void TensorFlowRepresentation::update(const ProjectionPtr projection, const Vector &delta) { VectorProjection *vp = dynamic_cast<VectorProjection*>(projection.get()); if (vp) { Vector v; read(projection, &v, NULL); batch_.push_back({vp->vector, v+delta}); } else throw Exception("representation/tensorflow requires a projector returning a VectorProjection"); }
double ANNRepresentation::read(const ProjectionPtr &projection, Vector *result, Vector *stddev) const { VectorProjection *vp = dynamic_cast<VectorProjection*>(projection.get()); if (vp) { double hidden[MAX_NODES], output[MAX_NODES]; size_t hidden_params = inputs_+bias_+recurrent_; // Calculate hidden activation for (size_t hh=0; hh < hiddens_; ++hh) { const double *w = &weights_[hidden_params*hh]; double act = 0; if (bias_) act += w[inputs_]; // Bias if (recurrent_) act += state_[hh]*w[inputs_+bias_]; // Recurrence for (size_t ii=0; ii < inputs_; ++ii) act += w[ii]*vp->vector[ii]; hidden[hh] = activate(act); } // TODO: Remember state // memcpy(state_.data(), hidden, hiddens_*sizeof(double)); // Calculate output activation for (size_t oo=0; oo < outputs_; ++oo) { const double *w = &weights_[hidden_params*hiddens_+(hiddens_+bias_)*oo]; double act = 0; if (bias_) act += w[hiddens_]; // Bias for (size_t hh=0; hh < hiddens_; ++hh) act += w[hh]*hidden[hh]; output[oo] = activate(act); } // Normalize outputs from 0..1 to output_min_..output_max_ result->resize(outputs_); for (size_t oo=0; oo < outputs_; ++oo) (*result)[oo] = output_min_[oo]+output[oo]*(output_max_[oo]-output_min_[oo]); } else throw Exception("representation/parameterized/ann requires a projector returning a VectorProjection"); if (stddev) stddev->clear(); return (*result)[0]; }
void TensorFlowRepresentation::enqueue(const ProjectionPtr &projection) { VectorProjection *vp = dynamic_cast<VectorProjection*>(projection.get()); if (vp) { auto input_map = input_.tensor<float, 2>(); for (size_t jj=0; jj < input_map.dimension(1); ++jj) input_map(counter_, jj) = vp->vector[jj]; counter_++; } else throw Exception("representation/tensorflow requires a projector returning a VectorProjection"); }
void TensorFlowRepresentation::enqueue(const ProjectionPtr &projection, const Vector &target) { VectorProjection *vp = dynamic_cast<VectorProjection*>(projection.get()); if (vp) { auto input_map = input_.tensor<float, 2>(); for (size_t ii=0; ii < input_map.dimension(1); ++ii) input_map(counter_, ii) = vp->vector[ii]; auto target_map = target_.tensor<float, 2>(); for (size_t ii=0; ii < target_map.dimension(1); ++ii) target_map(counter_, ii) = target[ii]; counter_++; } else throw Exception("representation/tensorflow requires a projector returning a VectorProjection"); }
void TensorFlowRepresentation::write(const ProjectionPtr projection, const Vector &target, const Vector &alpha) { VectorProjection *vp = dynamic_cast<VectorProjection*>(projection.get()); if (vp) { if (prod(alpha) == 1) { batch_.push_back({vp->vector, target}); } else { Vector v; read(projection, &v, NULL); batch_.push_back({vp->vector, (1-alpha)*v + alpha*target}); } } else throw Exception("representation/tensorflow requires a projector returning a VectorProjection"); }
double TensorFlowRepresentation::read(const ProjectionPtr &projection, Vector *result, Vector *stddev) const { VectorProjection *vp = dynamic_cast<VectorProjection*>(projection.get()); if (vp) { Tensor input(tensorflow::DT_FLOAT, TensorShape({1, (int)vp->vector.size()})); auto input_map = input.tensor<float, 2>(); for (size_t ii=0; ii < vp->vector.size(); ++ii) input_map(0, ii) = vp->vector[ii]; Tensor learning(tensorflow::DT_BOOL, TensorShape()); learning.scalar<bool>()() = false; std::vector<std::pair<std::string, tensorflow::Tensor>> inputs = {{input_layer_, input}}; if (!learning_phase_.empty()) inputs.push_back({learning_phase_, learning}); std::vector<Tensor> outputs; Status run_status = session_->Run(inputs, {output_layer_}, {}, &outputs); if (!run_status.ok()) { ERROR(run_status.ToString()); throw Exception("Could not run prediction graph"); } auto output_map = outputs[0].tensor<float, 2>(); result->resize(output_map.dimension(1)); for (size_t ii=0; ii < result->size(); ++ii) (*result)[ii] = output_map(0, ii); } else throw Exception("representation/tensorflow requires a projector returning a VectorProjection"); if (stddev) *stddev = Vector(); return (*result)[0]; }