inference-engine/tests/unit/builders/convolution_layer_test.cpp

   1 // Copyright (C) 2018-2019 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 #include <gtest/gtest.h>
   6 #include <string.h>
   7 #include <ie_builders.hpp>
   8 #include <builders/ie_convolution_layer.hpp>
   9
  10 #include "builder_test.hpp"
  11
  12 using namespace testing;
  13 using namespace InferenceEngine;
  14
  15 class ConvolutionLayerBuilderTest : public BuilderTestCommon {};
  16
  17 TEST_F(ConvolutionLayerBuilderTest, cannotCreateConvolutionWithoutWeight) {
  18     Builder::Network network("Test");
  19
  20     Builder::ConvolutionLayer convBuilder("Convolution");
  21     convBuilder.setStrides({4, 4});
  22     convBuilder.setKernel({11, 11});
  23     convBuilder.setOutDepth(96);
  24     convBuilder.setInputPort(Port({1, 3, 225, 225}));
  25     convBuilder.setDilation({1, 1});
  26     size_t ind = network.addLayer(convBuilder);
  27     ASSERT_THROW(network.getLayer(ind)->validate(false), InferenceEngine::details::InferenceEngineException);
  28 }
  29
  30 TEST_F(ConvolutionLayerBuilderTest, getExistsLayerFromNetworkBuilderWithInputPort) {
  31     Builder::Network network("Test");
  32     Builder::ConvolutionLayer convBuilder("Convolution");
  33
  34     convBuilder.setStrides({4, 4});
  35     convBuilder.setKernel({11, 11});
  36     convBuilder.setOutDepth(96);
  37     convBuilder.setInputPort(Port({1, 3, 225, 225}));
  38     convBuilder.setDilation({1, 1});
  39
  40     idx_t convId = network.addLayer(convBuilder);
  41
  42     idx_t weightsId = network.addLayer(Builder::ConstLayer("weights").setData(generateBlob(Precision::FP32, {96, 3, 11, 11}, Layout::OIHW)));
  43     network.connect({weightsId}, {convId, 1});
  44
  45     idx_t biasesId = network.addLayer(Builder::ConstLayer("biases").setData(generateBlob(Precision::FP32, {96}, Layout::C)));
  46     network.connect({biasesId}, {convId, 2});
  47
  48     Builder::ConvolutionLayer convBuilderFromNetwork(network.getLayer(convId));
  49
  50     ASSERT_EQ(convBuilderFromNetwork.getStrides(), convBuilder.getStrides());
  51     ASSERT_EQ(convBuilderFromNetwork.getKernel(), convBuilder.getKernel());
  52     ASSERT_EQ(convBuilderFromNetwork.getPaddingsEnd(), convBuilder.getPaddingsEnd());
  53     ASSERT_EQ(convBuilderFromNetwork.getPaddingsBegin(), convBuilder.getPaddingsBegin());
  54     ASSERT_EQ(convBuilderFromNetwork.getOutDepth(), convBuilder.getOutDepth());
  55     ASSERT_EQ(convBuilderFromNetwork.getDilation(), convBuilder.getDilation());
  56 }
  57
  58 TEST_F(ConvolutionLayerBuilderTest, getExistsLayerFromNetworkBuilderWithoutInputPort) {
  59     Builder::Network network("Test");
  60     Builder::ConvolutionLayer convBuilder("Convolution");
  61
  62     convBuilder.setStrides({4, 4});
  63     convBuilder.setKernel({11, 11});
  64     convBuilder.setOutDepth(96);
  65     convBuilder.setDilation({1, 1});
  66
  67     idx_t convId = network.addLayer(convBuilder);
  68
  69     idx_t weightsId = network.addLayer(Builder::ConstLayer("weights").setData(generateBlob(Precision::FP32, {96, 3, 11, 11}, Layout::OIHW)));
  70     network.connect({weightsId}, {convId, 1});
  71
  72     idx_t biasesId = network.addLayer(Builder::ConstLayer("biases").setData(generateBlob(Precision::FP32, {96}, Layout::C)));
  73     network.connect({biasesId}, {convId, 2});
  74
  75     Builder::ConvolutionLayer convBuilderFromNetwork(network.getLayer(convId));
  76
  77     ASSERT_EQ(convBuilderFromNetwork.getStrides(), convBuilder.getStrides());
  78     ASSERT_EQ(convBuilderFromNetwork.getKernel(), convBuilder.getKernel());
  79     ASSERT_EQ(convBuilderFromNetwork.getPaddingsEnd(), convBuilder.getPaddingsEnd());
  80     ASSERT_EQ(convBuilderFromNetwork.getPaddingsBegin(), convBuilder.getPaddingsBegin());
  81     ASSERT_EQ(convBuilderFromNetwork.getOutDepth(), convBuilder.getOutDepth());
  82     ASSERT_EQ(convBuilderFromNetwork.getDilation(), convBuilder.getDilation());
  83 }
  84
  85 TEST_F(ConvolutionLayerBuilderTest, cannotCreateConvolutionWithWrongNumberOfInputChannels) {
  86     Builder::Network network("Test");
  87     Builder::ConvolutionLayer convBuilder("Convolution");
  88
  89     convBuilder.setStrides({4, 4});
  90     convBuilder.setKernel({11, 11});
  91     convBuilder.setOutDepth(96);
  92     convBuilder.setInputPort(Port({1, 64, 225, 225}));  // here
  93
  94     idx_t convId = network.addLayer(convBuilder);
  95
  96     idx_t weightsId = network.addLayer(Builder::ConstLayer("weights").setData(generateBlob(Precision::FP32, {96, 3, 11, 11}, Layout::OIHW)));
  97     network.connect({weightsId}, {convId, 1});
  98
  99     idx_t biasesId = network.addLayer(Builder::ConstLayer("biases").setData(generateBlob(Precision::FP32, {96}, Layout::C)));
 100     network.connect({biasesId}, {convId, 2});
 101
 102     ASSERT_THROW(network.getLayer(convId)->validate(false), InferenceEngine::details::InferenceEngineException);
 103 }
 104
 105 TEST_F(ConvolutionLayerBuilderTest, canCreateCorrcetConvolution) {
 106     Builder::Network network("Test");
 107     Builder::ConvolutionLayer convBuilder("Convolution");
 108
 109     convBuilder.setStrides({4, 4});
 110     convBuilder.setKernel({11, 11});
 111     convBuilder.setOutDepth(96);
 112     convBuilder.setInputPort(Port({1, 3, 225, 225}));  // here
 113
 114     idx_t convId = network.addLayer(convBuilder);
 115
 116     idx_t weightsId = network.addLayer(Builder::ConstLayer("weights").setData(generateBlob(Precision::FP32, {96, 3, 11, 11}, Layout::OIHW)));
 117     network.connect({weightsId}, {convId, 1});
 118
 119     idx_t biasesId = network.addLayer(Builder::ConstLayer("biases").setData(generateBlob(Precision::FP32, {96}, Layout::C)));
 120     network.connect({biasesId}, {convId, 2});
 121
 122     ASSERT_NO_THROW(network.getLayer(convId)->validate(false));
 123 }
 124
 125 TEST_F(ConvolutionLayerBuilderTest, cannotCreateConvolutionWithGroup) {
 126     Builder::Network network("Test");
 127     Builder::ConvolutionLayer convBuilder("Convolution");
 128
 129     convBuilder.setStrides({4, 4});
 130     convBuilder.setKernel({11, 11});
 131     convBuilder.setOutDepth(96);
 132     convBuilder.setGroup(2);
 133     convBuilder.setInputPort(Port({1, 6, 225, 225}));
 134
 135     idx_t convId = network.addLayer(convBuilder);
 136
 137     idx_t weightsId = network.addLayer(Builder::ConstLayer("weights").setData(generateBlob(Precision::FP32, {96, 6, 11, 11}, Layout::OIHW)));
 138     // should be {96, 6 / 2, 11, 11}
 139     network.connect({weightsId}, {convId, 1});
 140
 141     idx_t biasesId = network.addLayer(Builder::ConstLayer("biases").setData(generateBlob(Precision::FP32, {96}, Layout::C)));
 142     network.connect({biasesId}, {convId, 2});
 143
 144     ASSERT_THROW(network.getLayer(convId)->validate(false), InferenceEngine::details::InferenceEngineException);
 145 }
 146
 147 TEST_F(ConvolutionLayerBuilderTest, canCreateConvolution) {
 148     Builder::Network network("Test");
 149     Builder::ConvolutionLayer convBuilder("Convolution");
 150
 151     convBuilder.setStrides({4, 4});
 152     convBuilder.setKernel({11, 11});
 153     convBuilder.setOutDepth(96);
 154     convBuilder.setGroup(2);
 155     convBuilder.setInputPort(Port({1, 6, 225, 225}));  // here
 156
 157     idx_t convId = network.addLayer(convBuilder);
 158
 159     idx_t weightsId = network.addLayer(Builder::ConstLayer("weights").setData(generateBlob(Precision::FP32, {96, 3, 11, 11}, Layout::OIHW)));
 160     network.connect({weightsId}, {convId, 1});
 161
 162     idx_t biasesId = network.addLayer(Builder::ConstLayer("biases").setData(generateBlob(Precision::FP32, {96}, Layout::C)));
 163     network.connect({biasesId}, {convId, 2});
 164
 165     ASSERT_NO_THROW(network.getLayer(convId)->validate(false));
 166 }
 167
 168 TEST_F(ConvolutionLayerBuilderTest, cannotCreateConvolutionWithWrongOutDepth) {
 169     Builder::Network network("Test");
 170     Builder::ConvolutionLayer convBuilder("Convolution");
 171
 172     convBuilder.setStrides({4, 4});
 173     convBuilder.setKernel({11, 11});
 174     convBuilder.setOutDepth(4);  // here
 175     convBuilder.setInputPort(Port({1, 3, 225, 225}));
 176
 177     idx_t convId = network.addLayer(convBuilder);
 178
 179     idx_t weightsId = network.addLayer(Builder::ConstLayer("weights").setData(generateBlob(Precision::FP32, {96, 3, 11, 11}, Layout::OIHW)));
 180     network.connect({weightsId}, {convId, 1});
 181
 182     idx_t biasesId = network.addLayer(Builder::ConstLayer("biases").setData(generateBlob(Precision::FP32, {96}, Layout::C)));
 183     network.connect({biasesId}, {convId, 2});
 184
 185     ASSERT_THROW(network.getLayer(convId)->validate(false), InferenceEngine::details::InferenceEngineException);
 186 }
 187
 188 TEST_F(ConvolutionLayerBuilderTest, cannotCreateConvolutionWithWrongStrides) {
 189     Builder::Network network("Test");
 190     Builder::ConvolutionLayer convBuilder("Convolution");
 191
 192     convBuilder.setStrides({4, 0});  // here
 193     convBuilder.setKernel({11, 11});
 194     convBuilder.setOutDepth(96);
 195     convBuilder.setInputPort(Port({1, 3, 225, 225}));
 196     convBuilder.setPaddingsEnd({0, 0});
 197     convBuilder.setPaddingsBegin({0, 0});
 198     convBuilder.setDilation({0, 0});
 199     ASSERT_THROW(network.addLayer(convBuilder), InferenceEngine::details::InferenceEngineException);
 200 }
 201
 202 TEST_F(ConvolutionLayerBuilderTest, cannotCreateConvolutionWithWrongKernel1) {
 203     Builder::Network network("Test");
 204     Builder::ConvolutionLayer convBuilder("Convolution");
 205
 206     convBuilder.setStrides({4, 4});
 207     convBuilder.setKernel({11, 0});  // here
 208     convBuilder.setOutDepth(96);
 209     convBuilder.setInputPort(Port({1, 3, 225, 225}));
 210
 211     ASSERT_THROW(network.addLayer(convBuilder), InferenceEngine::details::InferenceEngineException);
 212 }
 213
 214 TEST_F(ConvolutionLayerBuilderTest, cannotCreateConvolutionWithWrongKernel2) {
 215     Builder::Network network("Test");
 216     Builder::ConvolutionLayer convBuilder("Convolution");
 217
 218     convBuilder.setStrides({4, 4});
 219     convBuilder.setKernel({11, 11, 11});  // here
 220     convBuilder.setOutDepth(96);
 221     convBuilder.setInputPort(Port({1, 3, 225, 225}));
 222
 223     ASSERT_THROW(network.addLayer(convBuilder), InferenceEngine::details::InferenceEngineException);
 224 }
 225
 226 TEST_F(ConvolutionLayerBuilderTest, cannotCreateConvolutionWithWrongDilation1) {
 227     Builder::Network network("Test");
 228     Builder::ConvolutionLayer convBuilder("Convolution");
 229
 230     convBuilder.setStrides({4, 4});
 231     convBuilder.setKernel({11, 11});
 232     convBuilder.setOutDepth(96);
 233     convBuilder.setInputPort(Port({1, 3, 225, 225}));
 234     convBuilder.setDilation({1, 0});  // here
 235
 236     ASSERT_THROW(network.addLayer(convBuilder), InferenceEngine::details::InferenceEngineException);
 237 }
 238
 239 TEST_F(ConvolutionLayerBuilderTest, cannotCreateConvolutionWithWrongDilation2) {
 240     Builder::Network network("Test");
 241     Builder::ConvolutionLayer convBuilder("Convolution");
 242
 243     convBuilder.setStrides({4, 4});
 244     convBuilder.setKernel({11, 11});
 245     convBuilder.setOutDepth(96);
 246     convBuilder.setInputPort(Port({1, 3, 225, 225}));
 247     convBuilder.setDilation({1, 1, 1});  // here
 248
 249     ASSERT_THROW(network.addLayer(convBuilder), InferenceEngine::details::InferenceEngineException);
 250 }
 251
 252 TEST_F(ConvolutionLayerBuilderTest, canCreateLayerWithNumberOfGroupDividingNumberOfInputChannels) {
 253     Builder::Network network("Test");
 254     Builder::ConvolutionLayer convLayer("Convolution");
 255
 256     size_t weightsId = network.addLayer(Builder::ConstLayer("weights").setData(generateBlob(Precision::FP32, {96, 2, 11, 11}, Layout::OIHW)));
 257     size_t biasesId = network.addLayer(Builder::ConstLayer("biases").setData(generateBlob(Precision::FP32, {96}, Layout::C)));
 258
 259     convLayer.setStrides({4, 4});
 260     convLayer.setKernel({11, 11});
 261     convLayer.setOutDepth(96);
 262     convLayer.setInputPort(Port({1, 6, 225, 225}));
 263     convLayer.setDilation({1, 1});
 264
 265     convLayer.setGroup(3);
 266     size_t convId = network.addLayer(convLayer);
 267     network.connect({weightsId}, {convId, 1});
 268     network.connect({biasesId}, {convId, 2});
 269     ASSERT_NO_THROW(network.getLayer(convId)->validate(false));
 270 }
 271
 272 TEST_F(ConvolutionLayerBuilderTest, canCreateLayerWithWeightsNotAvailableForGroup) {
 273     Builder::Network network("Test");
 274     Builder::ConvolutionLayer convLayer("Convolution");
 275
 276     size_t weightsId = network.addLayer(Builder::ConstLayer("weights").setData(generateBlob(Precision::FP32, {96, 5, 11, 11}, Layout::OIHW)));
 277     size_t biasesId = network.addLayer(Builder::ConstLayer("biases").setData(generateBlob(Precision::FP32, {96}, Layout::C)));
 278
 279     convLayer.setStrides({4, 4});
 280     convLayer.setKernel({11, 11});
 281     convLayer.setOutDepth(96);
 282     convLayer.setInputPort(Port({1, 6, 225, 225}));
 283     convLayer.setDilation({1, 1});
 284
 285     convLayer.setGroup(3);
 286     ASSERT_THROW(network.addLayer({{weightsId}, {biasesId}}, convLayer),
 287                  InferenceEngine::details::InferenceEngineException);  // 6 / 3 != 5
 288 }
 289
 290 TEST_F(ConvolutionLayerBuilderTest, cannotCreateLayerWithNumberOfGroupNotDividingNumberOfInputChannels) {
 291     Builder::Network network("Test");
 292     Builder::ConvolutionLayer convLayer("Convolution");
 293
 294     size_t weightsId = network.addLayer(Builder::ConstLayer("weights").setData(generateBlob(Precision::FP32, {96, 2, 11, 11}, Layout::OIHW)));
 295     size_t biasesId = network.addLayer(Builder::ConstLayer("biases").setData(generateBlob(Precision::FP32, {96}, Layout::C)));
 296
 297     convLayer.setStrides({4, 4});
 298     convLayer.setKernel({11, 11});
 299     convLayer.setOutDepth(96);
 300     convLayer.setInputPort(Port({1, 6, 225, 225}));
 301     convLayer.setDilation({1, 1});
 302
 303     convLayer.setGroup(4);
 304     ASSERT_THROW(network.addLayer({{weightsId}, {biasesId}}, convLayer),
 305                  InferenceEngine::details::InferenceEngineException);  // 6 % 4 == 2
 306 }
 307