// 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;
}
