C++ LayerPtr::getParameters方法代码示例

// 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, &parameters, &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, &parameters, &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, &parameters2, &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 &param) {
                                                                  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 &param) {
                                                                  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;
}