// Do one forward pass of convTrans layer and check to see if its output // matches the given result void doOneConvtTest(size_t imgSize, size_t output_x, size_t stride, size_t padding, size_t filter_size, MatrixPtr& result) { TestConfig configt; configt.biasSize = 1; configt.layerConfig.set_type("exconvt"); configt.layerConfig.set_num_filters(1); configt.layerConfig.set_partial_sum(1); configt.layerConfig.set_shared_biases(true); configt.inputDefs.push_back( {INPUT_DATA, "layer_0", output_x * output_x, filter_size * filter_size}); LayerInputConfig* input = configt.layerConfig.add_inputs(); ConvConfig* conv = input->mutable_conv_conf(); conv->set_filter_size(filter_size); conv->set_filter_size_y(filter_size); conv->set_channels(1); conv->set_padding(padding); conv->set_padding_y(padding); conv->set_stride(stride); conv->set_stride_y(stride); conv->set_groups(1); conv->set_filter_channels(1); conv->set_img_size(imgSize); conv->set_output_x(output_x); configt.layerConfig.set_size(conv->img_size() * conv->img_size() * configt.layerConfig.num_filters()); configt.layerConfig.set_name("convTrans"); std::vector<DataLayerPtr> dataLayers; LayerMap layerMap; vector<Argument> datas; initDataLayer( configt, &dataLayers, &datas, &layerMap, "convTrans", 1, false, false); dataLayers[0]->getOutputValue()->zeroMem(); dataLayers[0]->getOutputValue()->add(1.0); // test layer initialize std::vector<ParameterPtr> parameters; LayerPtr convtLayer; initTestLayer(configt, &layerMap, ¶meters, &convtLayer); convtLayer->getBiasParameter()->zeroMem(); convtLayer->getParameters()[0]->zeroMem(); convtLayer->getParameters()[0]->getBuf(PARAMETER_VALUE)->add(1.0); convtLayer->forward(PASS_GC); checkMatrixEqual(convtLayer->getOutputValue(), result); }
// Test that the convTrans forward is the same as conv backward TEST(Layer, convTransLayerFwd) { // Setting up conv-trans layer TestConfig configt; configt.biasSize = 3; configt.layerConfig.set_type("exconvt"); configt.layerConfig.set_num_filters(3); configt.layerConfig.set_partial_sum(1); configt.layerConfig.set_shared_biases(true); configt.inputDefs.push_back({INPUT_DATA, "layer_0", 1024, 384}); LayerInputConfig* input = configt.layerConfig.add_inputs(); ConvConfig* conv = input->mutable_conv_conf(); conv->set_filter_size(2); conv->set_filter_size_y(4); conv->set_channels(16); conv->set_padding(0); conv->set_padding_y(1); conv->set_stride(2); conv->set_stride_y(2); conv->set_groups(1); conv->set_filter_channels(3 / conv->groups()); conv->set_img_size(16); conv->set_output_x(outputSize(conv->img_size(), conv->filter_size(), conv->padding(), conv->stride(), /* caffeMode */ true)); configt.layerConfig.set_size(conv->img_size() * conv->img_size() * configt.layerConfig.num_filters()); configt.layerConfig.set_name("convTrans"); // data layer initialize std::vector<DataLayerPtr> dataLayers; LayerMap layerMap; vector<Argument> datas; initDataLayer(configt, &dataLayers, &datas, &layerMap, "convTrans", 100, false, false); // test layer initialize std::vector<ParameterPtr> parameters; LayerPtr convtLayer; initTestLayer(configt, &layerMap, ¶meters, &convtLayer); convtLayer->getBiasParameter()->zeroMem(); convtLayer->forward(PASS_GC); // Setting up conv-layer config TestConfig config; config.biasSize = 16; config.layerConfig.set_type("exconv"); config.layerConfig.set_num_filters(16); config.layerConfig.set_partial_sum(1); config.layerConfig.set_shared_biases(true); config.inputDefs.push_back({INPUT_DATA, "layer_1", 768, 384}); input = config.layerConfig.add_inputs(); conv = input->mutable_conv_conf(); conv->set_filter_size(2); conv->set_filter_size_y(4); conv->set_channels(3); conv->set_padding(0); conv->set_padding_y(1); conv->set_stride(2); conv->set_stride_y(2); conv->set_groups(1); conv->set_filter_channels(conv->channels() / conv->groups()); conv->set_img_size(16); conv->set_output_x(outputSize(conv->img_size(), conv->filter_size(), conv->padding(), conv->stride(), /* caffeMode */ true)); config.layerConfig.set_size(conv->output_x() * conv->output_x() * config.layerConfig.num_filters()); config.layerConfig.set_name("conv"); // data layer initialize std::vector<DataLayerPtr> dataLayers2; LayerMap layerMap2; vector<Argument> datas2; initDataLayer(config, &dataLayers2, &datas2, &layerMap2, "conv", 100, false, false); // test layer initialize std::vector<ParameterPtr> parameters2; LayerPtr convLayer; initTestLayer(config, &layerMap2, ¶meters2, &convLayer); // Sync convLayer and convtLayer parameter convLayer->getBiasParameter()->zeroMem(); convLayer->getParameters()[0]->getBuf(PARAMETER_VALUE)->copyFrom( *(convtLayer->getParameters()[0]->getBuf(PARAMETER_VALUE))); // Set convLayer outputGrad as convTransLayer input value convLayer->forward(PASS_GC); convLayer->getOutput().grad->copyFrom(*(dataLayers[0]->getOutputValue())); vector<int> callbackFlags(parameters2.size(), 0); auto callback = [&](Parameter* para) { ++callbackFlags[para->getID()]; }; convLayer->backward(callback); // Check that the convLayer backward is the same as convTransLayer forward checkMatrixEqual(convtLayer->getOutputValue(), dataLayers2[0]->getOutputGrad()); }
int console_param_selection(ContextPtr env, char *cmd) { if(!cmd) return 0; if(!strlen(cmd)) return 0; ViewPortPtr screen = getSelectedScreen(); if(!screen) { ::error("no screen currently selected"); return 0; } LayerPtr lay = getSelectedLayer(); if(!lay) { ::error("no layer currently selected"); return 0; } FilterInstancePtr filt = getSelectedFilter(); // find the values after the first blank space char *p; for(p = cmd; *p != '\0'; p++) if(*p == '=') { *p = '\0'; if(*(p - 1) == ' ') *(p - 1) = '\0'; p++; break; } while(*p == ' ') p++; // jump all spaces if(*p == '\0') return 0; // no value was given if(filt) { ///////////////////////// parameters for filter LinkList<ParameterInstance> &list = filt->getParameters(); LinkList<ParameterInstance>::iterator it = std::find_if(list.begin(), list.end(), [&] (ParameterInstancePtr ¶m) { return param->getName() == cmd; }); if(it == list.end()) { error("parameter %s not found in filter %s", cmd, filt->getName().c_str()); return 0; } else { ParameterInstancePtr param = *it; func("parameter %s found in filter %s", param->getName().c_str(), filt->getName().c_str()); // parse from the string to the value param->parse(p); } } else { /////// parameters for layer LinkList<ParameterInstance> &list = lay->getParameters(); LinkList<ParameterInstance>::iterator it = std::find_if(list.begin(), list.end(), [&] (ParameterInstancePtr ¶m) { return param->getName() == cmd; }); if(it == list.end()) { error("parameter %s not found in layers %s", cmd, lay->getName().c_str()); return 0; } else { ParameterInstancePtr param = *it; func("parameter %s found in layer %s at position %u", param->getName().c_str(), lay->getName().c_str()); // parse from the string to the value param->parse(p); } } return 1; }
int console_param_completion(ContextPtr env, char *cmd) { ViewPortPtr screen = getSelectedScreen(); if(!screen) { ::error("no screen currently selected"); return 0; } LayerPtr lay = getSelectedLayer(); if(!lay) { ::error("no layer currently selected"); return 0; } FilterInstancePtr filt = getSelectedFilter(); LinkList<ParameterInstance> *parameters; if(filt) parameters = &filt->getParameters(); else parameters = &lay->getParameters(); // Find completions ParameterInstancePtr exactParam = NULL; LinkList<ParameterInstance> retList; LinkList<ParameterInstance> &list = *parameters; std::string cmdString(cmd); std::transform(cmdString.begin(), cmdString.end(), cmdString.begin(), ::tolower); std::copy_if(list.begin(), list.end(), retList.begin(), [&] (ParameterInstancePtr param) { std::string name = param->getName(); std::transform(name.begin(), name.end(), name.begin(), ::tolower); if(name == cmdString) { exactParam = param; } return name.compare(cmdString) == 0; }); if(retList.empty()) return 0; if(exactParam != NULL) { snprintf(cmd, MAX_CMDLINE, "%s = ", exactParam->getName().c_str()); return 1; } if(cmdString.empty()) { notice("List available parameters"); } else { notice("List available parameters starting with \"%s\"", cmd); } int c = 0; std::for_each(retList.begin(), retList.end(), [&] (ParameterInstancePtr p) { switch(p->getType()) { case Parameter::BOOL: ::act("(bool) %s = %s :: %s", p->getName().c_str(), (*(bool*)p->get() == true) ? "true" : "false", p->getDescription().c_str()); break; case Parameter::NUMBER: ::act("(number) %s = %.2f :: %s", p->getName().c_str(), *(float*)p->get(), p->getDescription().c_str()); break; case Parameter::STRING: ::act("(string) %s = %s :: %s", p->getName().c_str(), (char*)p->get(), p->getDescription().c_str()); break; case Parameter::POSITION: { float *val = (float*)p->get(); ::act("(position) %s = %.2f x %.2f :: %s", p->getName().c_str(), val[0], val[1], p->getDescription().c_str()); } break; case Parameter::COLOR: ::act("%s (color) %s", p->getName().c_str(), p->getDescription().c_str()); break; default: ::error("%s (unknown) %s", p->getName().c_str(), p->getDescription().c_str()); break; } ++c; }); return c; }