MatrixPtr GenerateClusteredData::operator()() { auto matrix = std::make_shared<Matrix>(); matrix->reserve(nbrInds); Variables variables; for (size_t var = 0; var < nbrClusters * clustSize; ++var) { variables ^= Variable( boost::lexical_cast<std::string>(var), plIntegerType(0, cardinality-1) ); } Clustering clustering; clustering.reserve(nbrClusters); for ( size_t clust = 0; clust < nbrClusters; ++clust ) { Cluster cluster; for ( size_t item = 0; item < clustSize; ++item ) { cluster.push_back( clust*clustSize + item ); } clustering.push_back( cluster ); } plJointDistribution jointDist = createClusteringJointDist( variables, clustering); plValues values( variables ); // std::cout << jointDist << std::endl << jointDist.get_computable_object_list() << std::endl; for (size_t ind = 0; ind < nbrInds; ++ind) { jointDist.draw(values); std::vector<int> row(variables.size()); for (size_t var = 0; var < variables.size(); ++var) { row[var] = values[variables[var]]; } matrix->push_back(row); } //std::cout << jointDist << std::endl; return Transpose(*matrix); }
/** * Applies the required resizes to nodes in the specified axis, rerouting edges * around the resized nodes. * @param dim axis * @param targets the target rectangles (in both axes) * @param nodes to be moved and/or resized * @param edges to be rerouted around nodes * @param resizes ResizeInfo for specific nodes * @param vs canonical list of variables passed into solver. Note that * the first nodes.size() variables are used for each corresponding node. * Note also that new variables for the dummy nodes will be appended to this * list and will need to be cleaned up later. * @param cs canonical list of constraints over variables. Note that new * non-overlap constraints may be appended to the end of this list. */ static void resizeAxis(vpsc::Dim dim, const Rectangles& targets, Nodes& nodes, Edges& edges, RootCluster *clusters, ResizeMap& resizes, Variables& vs, Constraints& cs) { COLA_ASSERT(vs.size()>=nodes.size()); // - create copy tn of topologyNodes with resize rects replaced with // three nodes: one for the lhs of rect, one for centre and one for rhs. // lhs node goes at position of replaced node, the others are appended // to end of tn. // - set desired positions of each lhs node to be the left side // of resized rect and symmetric for rhs node, centre node's desired // pos it at the centre Nodes tn(nodes.size()); COLA_ASSERT(assertConvexBends(edges)); COLA_ASSERT(assertNoSegmentRectIntersection(nodes,edges)); transform(nodes.begin(),nodes.end(),tn.begin(), TransformNode(dim, targets,resizes,vs)); feach(resizes, CreateLeftRightDummyNodes(dim,targets,tn,vs)); COLA_ASSERT(tn.size()==nodes.size()+2*resizes.size()); COLA_ASSERT(vs.size()>=tn.size()); // update topologyRoutes with references to resized nodes replaced with // correct references to lhs/rhs nodes feach(edges,SubstituteNodes(dim,resizes,tn)); COLA_ASSERT(assertConvexBends(edges)); COLA_ASSERT(assertNoSegmentRectIntersection(tn,edges)); // move nodes and reroute topology::TopologyConstraints t(dim, tn, edges, clusters, vs, cs); COLA_ASSERT(checkDesired(dim,tn,targets,resizes)); #ifndef NDEBUG unsigned loopCtr=0; #endif while(t.solve()) { COLA_ASSERT(++loopCtr<1000); } //COLA_ASSERT(checkFinal(tn,targets,resizes)); // reposition and resize original nodes feach(nodes,CopyPositions(dim,tn,resizes)); // revert topologyRoutes back to original nodes feach(edges,RevertNodes(nodes)); COLA_ASSERT(assertConvexBends(edges)); COLA_ASSERT(assertNoSegmentRectIntersection(nodes,edges)); // clean up feach(tn,DeleteTempNode()); }
IncSolver::IncSolver(Variables const &vs, Constraints const &cs) : m(cs.size()), cs(cs), n(vs.size()), vs(vs), needsScaling(false) { for(unsigned i=0;i<n;++i) { vs[i]->in.clear(); vs[i]->out.clear(); // Set needsScaling if any variables have a scale other than 1. needsScaling |= (vs[i]->scale != 1); } for(unsigned i=0;i<m;++i) { Constraint *c=cs[i]; c->left->out.push_back(c); c->right->in.push_back(c); c->needsScaling = needsScaling; } bs=new Blocks(vs); #ifdef LIBVPSC_LOGGING printBlocks(); //COLA_ASSERT(!constraintGraphIsCyclic(n,vs)); #endif inactive=cs; for(Constraints::iterator i=inactive.begin();i!=inactive.end();++i) { (*i)->active=false; } }
EqualityConstraintSet(Variables vs) { for (size_t i = 0; i < vs.size(); ++i) { std::map<Variable *, double> varSet; varSet[vs[i]] = 0; variableGroups.push_back(varSet); } }
void Deconvolution<T>::forward_impl(const Variables &inputs, const Variables &outputs) { using namespace ::nbla::eigen; // Getting variable pointers const T *y = inputs[0]->get_data_pointer<T>(this->ctx_); const T *w = inputs[1]->get_data_pointer<T>(this->ctx_); T *col = col_.cast_data_and_get_pointer<T>(this->ctx_); T *x = outputs[0]->cast_data_and_get_pointer<T>(this->ctx_); const T *b; if (inputs.size() == 3) { b = inputs[2]->get_data_pointer<T>(this->ctx_); } // Sample loop for (int n = 0; n < outer_size_; ++n) { // matrix multiplication const T *y_n = y + n * inner_size_o_; for (int g = 0; g < group_; ++g) { ConstMatrixMap<T> mw(w + g * row_w_ * col_w_, row_w_, col_w_); ConstMatrixMap<T> my(y_n + g * row_y_ * col_y_, row_y_, col_y_); MatrixMap<T> mcol(col + g * row_col_ * col_col_, row_col_, col_col_); mcol = mw.transpose() * my; } // col2im for w * x T *x_n = x + n * inner_size_i_; memset(x_n, 0, sizeof(*x_n) * inner_size_i_); if (spatial_dims_ == 2) { col2im<T>(col, channels_i_, spatial_shape_i_.data(), kernel_.data(), pad_.data(), stride_.data(), dilation_.data(), x_n); } else { col2im_nd<T>(col, channels_i_, spatial_dims_, spatial_shape_i_.data(), kernel_.data(), pad_.data(), stride_.data(), dilation_.data(), x_n); } // adding bias if (inputs.size() == 3) { MatrixMap<T> mx(x_n, channels_i_, inner_size_i_ / channels_i_); mx.colwise() += ConstColVectorMap<T>(b, channels_i_); } } }
DistValueMat createNBProbTables( const Variables& variables, const Variable& latentVar) { DistValueMat probTableX; for (size_t var = 0; var < variables.size(); ++var) { DistValueVec X_Z; for (size_t i = 0; i < latentVar.cardinality(); ++i) { const DistValues X_Z_i = createNBUniVarProbTab( variables[var].cardinality() ); X_Z.push_back(X_Z_i); } probTableX.push_back(X_Z); } return probTableX; }
plComputableObjectList createNBCndTable(Variables& variables, Variable& latentVar) { plComputableObjectList dataCndTable; DistValueMat probTableXZ = createNBProbTables(variables, latentVar); for (size_t x = 0; x < variables.size(); ++x) { plDistributionTable distTab_Xi_Z(variables[x], latentVar); for (size_t h = 0; h < latentVar.cardinality(); ++h) { distTab_Xi_Z.push( plProbTable(variables[x], probTableXZ[x][h]), (int)h ); } dataCndTable *= distTab_Xi_Z; // adds the conditional table to result } return dataCndTable; }
Variables FunctionRef::call(const Variables ¶ms) const { StackGuard guard(*_luaState); const int savedTop = lua_gettop(_luaState); pushSelf(); Stack stack(*_luaState); stack.pushVariables(params); if (lua_pcall(&stack.getLuaState(), params.size(), LUA_MULTRET, 0) != 0) { throw Common::Exception("Failed to call Lua function:\n\t%s", lua_tostring(&stack.getLuaState(), -1)); } const int retsCount = stack.getSize() - savedTop; return stack.getVariablesFromTop(retsCount); }
void increaseStack() { if (SP == stack.size()) { stack.resize(SP * 2); } }
void Deconvolution<T>::setup_impl(const Variables &inputs, const Variables &outputs) { // Shape check Shape_t shape_out = inputs[0]->shape(); Shape_t shape_weights = inputs[1]->shape(); NBLA_CHECK(base_axis_ < shape_out.size() - 1, error_code::unclassified, "base_axis must be less than ndim - 1 of inputs[0]. " "base_axis: %d >= ndim of inputs[0] - 1: %d.", base_axis_, shape_out.size() - 1); spatial_dims_ = shape_out.size() - base_axis_ - 1; NBLA_CHECK(shape_weights.size() == 2 + spatial_dims_, error_code::value, "Weights must be a tensor more than 3D."); // Storing shape variables channels_i_ = shape_weights[1] * group_; channels_o_ = shape_weights[0]; channels_g_ = shape_weights[1]; inner_size_k_ = channels_g_; const int channels_i_mod_group = channels_i_ % group_; NBLA_CHECK(channels_i_mod_group == 0, error_code::value, "Number of input channel needs to be divisible by group. " "Input channel: %d, group: %d", channels_i_, group_); const int channels_o_mod_group = channels_o_ % group_; NBLA_CHECK(channels_o_mod_group == 0, error_code::value, "Number of output channel needs to be divisible by group. " "Output channel: %d, group: %d", channels_o_, group_); NBLA_CHECK(channels_i_ / group_ == channels_g_, error_code::value, "Number of grouped channel mismatch." "Input: %d != Weights[1]: %d", channels_i_ / group_, channels_g_); NBLA_CHECK(pad_.size() == spatial_dims_, error_code::value, "pad size mismatch. pad size: %d != spatial dims: %d.", pad_.size(), spatial_dims_); NBLA_CHECK(stride_.size() == spatial_dims_, error_code::value, "stride size mismatch. stride size: %d != spatial dims: %d.", stride_.size(), spatial_dims_); NBLA_CHECK(dilation_.size() == spatial_dims_, error_code::value, "dilation size mismatch. dilation size: %d != spatial dims: %d.", dilation_.size(), spatial_dims_); for (int i = 0; i < spatial_dims_; ++i) { kernel_.push_back(shape_weights[2 + i]); inner_size_k_ *= kernel_[i]; spatial_shape_o_.push_back(shape_out[base_axis_ + 1 + i]); const int k = dilation_[i] * (kernel_[i] - 1) + 1; const int size_i = stride_[i] * (spatial_shape_o_[i] - 1) + k - 2 * pad_[i]; NBLA_CHECK( size_i > 0, error_code::value, "Invalid configuration of deconvolution at %d-th spatial dimension. " "{input:%d, kernel:%d, pad:%d, stride:%d, dilation:%d}.", i, size_i, kernel_[i], pad_[i], stride_[i], dilation_[i]); spatial_shape_i_.push_back(size_i); } // Reshaping output Shape_t shape_data; outer_size_ = 1; for (int i = 0; i < base_axis_; ++i) { // Fill shapes up to base axis shape_data.push_back(shape_out[i]); outer_size_ *= shape_out[i]; } shape_data.push_back(channels_i_); // output channels inner_size_i_ = channels_i_; inner_size_o_ = channels_o_; for (int i = 0; i < spatial_dims_; ++i) { shape_data.push_back(spatial_shape_i_[i]); inner_size_i_ *= spatial_shape_i_[i]; inner_size_o_ *= spatial_shape_o_[i]; } outputs[0]->reshape(shape_data, true); // Reshaping col buffer // Actual memory is not allocated until it is used. col_.reshape(Shape_t{inner_size_k_ * group_, inner_size_o_ / channels_o_}, true); // Check for with bias if (inputs.size() == 3) { NBLA_CHECK(inputs[2]->shape().size() == 1, error_code::value, "Bias(inputs[2]) must be a 1d tensor."); NBLA_CHECK(inputs[2]->shape()[0] == channels_i_, error_code::value, "Shape of bias(inputs[2]) and weights(inputs[1]) mismatch. " "bias shape[0]: %d != weights shape[1] * group: %d.", inputs[2]->shape()[0], channels_i_); } // Check for with bias if (inputs.size() == 3) { NBLA_CHECK(inputs[2]->shape().size() == 1, error_code::value, ""); NBLA_CHECK(inputs[2]->shape()[0] == channels_i_, error_code::value, ""); } // Set variables for convolution by matrix multiplication // In 2D case: // K: in maps, H: in height, W: in width // K': out maps, H': out height, W': out height // M: kernel height, N: kernel width row_w_ = channels_o_ / group_; // K' col_w_ = inner_size_k_; // KMN row_col_ = col_w_; // KMN col_col_ = inner_size_o_ / channels_o_; // H'W' row_y_ = channels_o_ / group_; // K' col_y_ = col_col_; // H'W' }
void Deconvolution<T>::backward_impl(const Variables &inputs, const Variables &outputs, const vector<bool> &propagate_down, const vector<bool> &accum) { if (!(propagate_down[0] || propagate_down[1] || (inputs.size() == 3 && propagate_down[2]))) { return; } using namespace ::nbla::eigen; const T *dx = outputs[0]->get_grad_pointer<T>(this->ctx_); const T *y; const T *w; T *dy, *dw, *db, *col; std::unique_ptr<ColVectorMap<T>> mdb; if (propagate_down[0] || propagate_down[1]) { col = col_.cast_data_and_get_pointer<T>(this->ctx_); } if (propagate_down[0]) { w = inputs[1]->get_data_pointer<T>(this->ctx_); dy = inputs[0]->cast_grad_and_get_pointer<T>(this->ctx_); } if (propagate_down[1]) { if (!accum[1]) inputs[1]->grad()->zero(); y = inputs[0]->get_data_pointer<T>(this->ctx_); dw = inputs[1]->cast_grad_and_get_pointer<T>(this->ctx_); } if (inputs.size() == 3 && propagate_down[2]) { if (!accum[2]) inputs[2]->grad()->zero(); db = inputs[2]->cast_grad_and_get_pointer<T>(this->ctx_); mdb.reset(new ColVectorMap<T>(db, channels_i_)); } // Sample loop for (int n = 0; n < outer_size_; ++n) { const T *dx_n = dx + n * inner_size_i_; if (propagate_down[0] || propagate_down[1]) { // im2col if (spatial_dims_ == 2) { im2col<T>(dx_n, channels_i_, spatial_shape_i_.data(), kernel_.data(), pad_.data(), stride_.data(), dilation_.data(), col); } else { im2col_nd<T>(dx_n, channels_i_, spatial_dims_, spatial_shape_i_.data(), kernel_.data(), pad_.data(), stride_.data(), dilation_.data(), col); } } if (propagate_down[0]) { // Backprop to image T *dy_n = dy + n * inner_size_o_; for (int g = 0; g < group_; ++g) { ConstMatrixMap<T> mcol(col + g * row_col_ * col_col_, row_col_, col_col_); ConstMatrixMap<T> mw(w + g * row_w_ * col_w_, row_w_, col_w_); MatrixMap<T> mdy(dy_n + g * row_y_ * col_y_, row_y_, col_y_); if (accum[0]) mdy += mw * mcol; else mdy = mw * mcol; } } if (propagate_down[1]) { // Backprop to weights const T *y_n = y + n * inner_size_o_; for (int g = 0; g < group_; ++g) { ConstMatrixMap<T> mcol(col + g * row_col_ * col_col_, row_col_, col_col_); ConstMatrixMap<T> my(y_n + g * row_y_ * col_y_, row_y_, col_y_); MatrixMap<T> mdw(dw + g * row_w_ * col_w_, row_w_, col_w_); mdw += my * mcol.transpose(); } } if (inputs.size() == 3 && propagate_down[2]) { // Backprop to bias ConstMatrixMap<T> mdx(dx_n, channels_i_, inner_size_i_ / channels_i_); *mdb += mdx.rowwise().sum(); } } }