Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #16436 from YashasSamaga:feature-enetb0-yolo

Browse Source 
dnn(darknet-importer): add grouped convolutions, sigmoid, swish, scale_channels

* update darknet importer to support enetb0-yolo

* remove dropout (pr16438) and fix formatting

* add test for scale_channels

* disable batch testing for scale channels

* do not set LayerParams::name

* merge all activations into setActivation
pull/16770/head
Yashas Samaga B L 5 years ago committed by GitHub
parent 0bcdf7d03e
commit 490908f0ff
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 76 additions and 14 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 80
      modules/dnn/src/darknet/darknet_io.cpp
  2. 10
      modules/dnn/test/test_darknet_importer.cpp

80
modules/dnn/src/darknet/darknet_io.cpp
Unescape View File

@ -149,7 +149,7 @@ namespace cv {
void setConvolution(int kernel, int pad, int stride,
int filters_num, int channels_num, int use_batch_normalize)
int filters_num, int channels_num, int groups, int use_batch_normalize)
{
cv::dnn::LayerParams conv_param =
getParamConvolution(kernel, pad, stride, filters_num);
@ -162,6 +162,8 @@ namespace cv {
conv_param.set<bool>("bias_term", true);
}
conv_param.set<int>("group", groups);
lp.layer_name = layer_name;
lp.layer_type = conv_param.type;
lp.layerParams = conv_param;
@ -215,15 +217,30 @@ namespace cv {
fused_layer_names.push_back(last_layer);
}
void setReLU()
void setActivation(String type)
{
cv::dnn::LayerParams activation_param;
activation_param.set<float>("negative_slope", 0.1f);
activation_param.name = "ReLU-name";
activation_param.type = "ReLU";
if (type == "relu")
{
activation_param.set<float>("negative_slope", 0.1f);
activation_param.type = "ReLU";
}
else if (type == "swish")
{
activation_param.type = "Swish";
}
else if (type == "logistic")
{
activation_param.type = "Sigmoid";
}
else
{
CV_Error(cv::Error::StsParseError, "Unsupported activation: " + type);
}
std::string layer_name = cv::format("%s_%d", type.c_str(), layer_id);
darknet::LayerParameter lp;
std::string layer_name = cv::format("relu_%d", layer_id);
lp.layer_name = layer_name;
lp.layer_type = activation_param.type;
lp.layerParams = activation_param;
@ -487,6 +504,25 @@ namespace cv {
fused_layer_names.push_back(last_layer);
}
void setScaleChannels(int from)
{
cv::dnn::LayerParams shortcut_param;
shortcut_param.type = "Scale";
darknet::LayerParameter lp;
std::string layer_name = cv::format("scale_channels_%d", layer_id);
lp.layer_name = layer_name;
lp.layer_type = shortcut_param.type;
lp.layerParams = shortcut_param;
lp.bottom_indexes.push_back(fused_layer_names.at(from));
lp.bottom_indexes.push_back(last_layer);
last_layer = layer_name;
net->layers.push_back(lp);
layer_id++;
fused_layer_names.push_back(last_layer);
}
void setUpsample(int scaleFactor)
{
cv::dnn::LayerParams param;
@ -608,6 +644,7 @@ namespace cv {
int padding = getParam<int>(layer_params, "padding", 0);
int stride = getParam<int>(layer_params, "stride", 1);
int filters = getParam<int>(layer_params, "filters", -1);
int groups = getParam<int>(layer_params, "groups", 1);
bool batch_normalize = getParam<int>(layer_params, "batch_normalize", 0) == 1;
int flipped = getParam<int>(layer_params, "flipped", 0);
if (flipped == 1)
@ -618,9 +655,10 @@ namespace cv {
CV_Assert(kernel_size > 0 && filters > 0);
CV_Assert(tensor_shape[0] > 0);
CV_Assert(tensor_shape[0] % groups == 0);
setParams.setConvolution(kernel_size, padding, stride, filters, tensor_shape[0],
batch_normalize);
groups, batch_normalize);
tensor_shape[0] = filters;
tensor_shape[1] = (tensor_shape[1] - kernel_size + 2 * padding) / stride + 1;
@ -727,6 +765,14 @@ namespace cv {
from = from < 0 ? from + layers_counter : from;
setParams.setShortcut(from, alpha);
}
else if (layer_type == "scale_channels")
{
std::string bottom_layer = getParam<std::string>(layer_params, "from", "");
CV_Assert(!bottom_layer.empty());
int from = std::atoi(bottom_layer.c_str());
from = from < 0 ? from + layers_counter : from;
setParams.setScaleChannels(from);
}
else if (layer_type == "upsample")
{
int scaleFactor = getParam<int>(layer_params, "stride", 1);
@ -761,7 +807,15 @@ namespace cv {
std::string activation = getParam<std::string>(layer_params, "activation", "linear");
if (activation == "leaky")
{
setParams.setReLU();
setParams.setActivation("relu");
}
else if (activation == "swish")
{
setParams.setActivation("swish");
}
else if (activation == "logistic")
{
setParams.setActivation("logistic");
}
else if (activation != "linear")
CV_Error(cv::Error::StsParseError, "Unsupported activation: " + activation);
@ -818,13 +872,15 @@ namespace cv {
{
int kernel_size = getParam<int>(layer_params, "size", -1);
filters = getParam<int>(layer_params, "filters", -1);
int groups = getParam<int>(layer_params, "groups", 1);
use_batch_normalize = getParam<int>(layer_params, "batch_normalize", 0) == 1;
CV_Assert(kernel_size > 0 && filters > 0);
CV_Assert(tensor_shape[0] > 0);
CV_Assert(tensor_shape[0] % groups == 0);
weights_size = filters * tensor_shape[0] * kernel_size * kernel_size;
int sizes_weights[] = { filters, tensor_shape[0], kernel_size, kernel_size };
weights_size = filters * (tensor_shape[0] / groups) * kernel_size * kernel_size;
int sizes_weights[] = { filters, tensor_shape[0] / groups, kernel_size, kernel_size };
weightsBlob.create(4, sizes_weights, CV_32F);
}
else
@ -879,8 +935,8 @@ namespace cv {
}
std::string activation = getParam<std::string>(layer_params, "activation", "linear");
if(activation == "leaky")
++cv_layers_counter; // For ReLU
if(activation == "leaky" || activation == "swish" || activation == "logistic")
++cv_layers_counter; // For ReLU, Swish, Sigmoid
if(!darknet_layers_counter)
tensor_shape.resize(1);

10
modules/dnn/test/test_darknet_importer.cpp
Unescape View File

@ -97,7 +97,7 @@ TEST(Test_Darknet, read_yolo_voc_stream)
class Test_Darknet_layers : public DNNTestLayer
{
public:
void testDarknetLayer(const std::string& name, bool hasWeights = false)
void testDarknetLayer(const std::string& name, bool hasWeights = false, bool testBatchProcessing = true)
{
SCOPED_TRACE(name);
Mat inp = blobFromNPY(findDataFile("dnn/darknet/" + name + "_in.npy"));
@ -117,7 +117,7 @@ public:
Mat out = net.forward();
normAssert(out, ref, "", default_l1, default_lInf);
if (inp.size[0] == 1) // test handling of batch size
if (inp.size[0] == 1 && testBatchProcessing) // test handling of batch size
{
SCOPED_TRACE("batch size 2");
@ -552,6 +552,12 @@ TEST_P(Test_Darknet_layers, convolutional)
testDarknetLayer("convolutional", true);
}
TEST_P(Test_Darknet_layers, scale_channels)
{
// TODO: test fails for batches due to a bug/missing feature in ScaleLayer
testDarknetLayer("scale_channels", false, false);
}
TEST_P(Test_Darknet_layers, connected)
{
if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)

Write Preview
Loading…
Cancel
Save