inference-engine/tests/unit/cnn_network/shapes.h

   1 /*
   2 * INTEL CONFIDENTIAL
   3 * Copyright (C) 2018-2019 Intel Corporation.
   4 *
   5 * The source code contained or described herein and all documents
   6 * related to the source code ("Material") are owned by Intel Corporation
   7 * or its suppliers or licensors. Title to the Material remains with
   8 * Intel Corporation or its suppliers and licensors. The Material may
   9 * contain trade secrets and proprietary and confidential information
  10 * of Intel Corporation and its suppliers and licensors, and is protected
  11 * by worldwide copyright and trade secret laws and treaty provisions.
  12 * No part of the Material may be used, copied, reproduced, modified,
  13 * published, uploaded, posted, transmitted, distributed, or disclosed
  14 * in any way without Intel's prior express written permission.
  15 *
  16 * No license under any patent, copyright, trade secret or other
  17 * intellectual property right is granted to or conferred upon you by
  18 * disclosure or delivery of the Materials, either expressly, by implication,
  19 * inducement, estoppel or otherwise. Any license under such intellectual
  20 * property rights must be express and approved by Intel in writing.
  21 *
  22 * Include any supplier copyright notices as supplier requires Intel to use.
  23 *
  24 * Include supplier trademarks or logos as supplier requires Intel to use,
  25 * preceded by an asterisk. An asterisked footnote can be added as follows:
  26 * *Third Party trademarks are the property of their respective owners.
  27 *
  28 * Unless otherwise agreed by Intel in writing, you may not remove or alter
  29 * this notice or any other notice embedded in Materials by Intel or Intel's
  30 * suppliers or licensors in any way.
  31 */
  32
  33 #ifndef SHAPES_H
  34 #define SHAPES_H
  35
  36 #include <iostream>
  37 #include <map>
  38 #include <string>
  39 #include <vector>
  40 #include <xml_net_builder.hpp>
  41 #include <random>
  42 #include <chrono>
  43
  44 using namespace testing;
  45
  46 struct Maps{
  47     std::map<std::string, int> mapOfEqualShapes {
  48             // Layer name, Correct num of input, Correct num of output
  49             { "Convolution", 1},
  50             { "Deconvolution", 1},
  51             { "Crop", 1},
  52             { "Interp", 1}
  53     };
  54
  55     std::map<std::string, std::pair<int, int>> mapOfUnequalShapes {
  56             // Layer name, Correct num of input, Correct num of output
  57             { "Crop", {2, 1}},
  58             { "DetectionOutput", {3, 1}},
  59             { "Interp", {2, 1}}
  60     };
  61
  62     std::map<std::string, std::pair<std::string, std::string>> mapOfContinuousShapes {
  63             // Layer name, Correct num of input, Correct num of output
  64             { "Slice", {"1", "N"}},
  65             { "Eltwise", {"N", "1"}}
  66     };
  67 } maps;
  68
  69 class ShapesHelper {
  70 protected:
  71     std::string type;
  72 public:
  73     ShapesHelper() = default;
  74
  75     explicit ShapesHelper(std::string& type) {
  76         this->type = type;
  77     }
  78
  79     std::string getType() {return type;}
  80
  81     virtual testing::InOutShapes getValidShapes() = 0;
  82     virtual testing::InOutShapes getInvalidInputShapes() = 0;
  83
  84     std::vector<std::vector<size_t>> generateShapes(const int& numOfShapes) {
  85         std::mt19937 gen(static_cast<unsigned long>(std::chrono::high_resolution_clock::now().time_since_epoch().count()));
  86         std::uniform_int_distribution<unsigned long> dist(1, 256);
  87
  88         std::vector<std::vector<size_t>> shape;
  89         shape.reserve(static_cast<unsigned long>(numOfShapes));
  90         for (int i = 0; i < numOfShapes; ++i) {
  91             shape.push_back({dist(gen), dist(gen), dist(gen), 7});
  92         }
  93         return shape;
  94     }
  95     virtual ~ShapesHelper() = default;
  96 };
  97
  98 class EqualIOShapesHelper : public ShapesHelper {
  99 public:
 100     explicit EqualIOShapesHelper(std::string& type) : ShapesHelper(type) {};
 101
 102     testing::InOutShapes getValidShapes() override {
 103         int numOfInput = {maps.mapOfEqualShapes[type]};
 104         int numOfOutput = {maps.mapOfEqualShapes[type]};
 105         std::vector<std::vector<size_t>> inputs = generateShapes(numOfInput);
 106         std::vector<std::vector<size_t>> outputs = generateShapes(numOfOutput);
 107         return {inputs, outputs};
 108     }
 109
 110     testing::InOutShapes getInvalidInputShapes()  override {
 111         int numOfOutput = maps.mapOfEqualShapes[type];
 112         int numOfInput = maps.mapOfEqualShapes[type]  + numOfOutput;
 113         std::vector<std::vector<size_t>> inputs = generateShapes(numOfInput);
 114         std::vector<std::vector<size_t>> outputs = generateShapes(numOfOutput);
 115         return {inputs, outputs};
 116     }
 117     ~EqualIOShapesHelper() override = default;
 118 };
 119
 120 class NotEqualConcreteIOShapesHelper : public ShapesHelper {
 121 public:
 122     explicit NotEqualConcreteIOShapesHelper(std::string& type) : ShapesHelper(type) {};
 123
 124     testing::InOutShapes getValidShapes() override {
 125         int numOfInput = maps.mapOfUnequalShapes[type].first;
 126         int numOfOutput = maps.mapOfUnequalShapes[type].second;
 127         std::vector<std::vector<size_t>> inputs = generateShapes(numOfInput);
 128         std::vector<std::vector<size_t>> outputs = generateShapes(numOfOutput);
 129         return {inputs, outputs};
 130     }
 131
 132     testing::InOutShapes getInvalidInputShapes()  override {
 133         int numOfOutput = maps.mapOfUnequalShapes[type].second;
 134         int numOfInput = maps. mapOfUnequalShapes[type].first + numOfOutput;
 135
 136         std::vector<std::vector<size_t>> inputs = generateShapes(numOfInput);
 137         std::vector<std::vector<size_t>> outputs = generateShapes(numOfOutput);
 138         return {inputs, outputs};
 139     }
 140     ~NotEqualConcreteIOShapesHelper() override = default;
 141 };
 142
 143 class NotEqualIOShapesHelper : public ShapesHelper {
 144 private:
 145     bool is_number(const std::string& s)
 146     {
 147         return !s.empty() && std::find_if(s.begin(),
 148                                           s.end(), [](char c) { return !std::isdigit(c); }) == s.end();
 149     }
 150
 151 public:
 152
 153     explicit NotEqualIOShapesHelper(std::string& type) : ShapesHelper(type) {};
 154
 155     testing::InOutShapes getValidShapes() override {
 156         int numOfInput;
 157         int numOfOutput;
 158         std::vector<std::vector<size_t>> inputs;
 159         std::vector<std::vector<size_t>> outputs;
 160         if (is_number(maps.mapOfContinuousShapes[type].first)) {
 161             numOfInput = std::stoi(maps.mapOfContinuousShapes[type].first);
 162             inputs = generateShapes(numOfInput);
 163             outputs = generateShapes(100);
 164         } else {
 165             numOfOutput = std::stoi(maps.mapOfContinuousShapes[type].second);
 166             outputs = generateShapes(numOfOutput);
 167             inputs = generateShapes(100);
 168         }
 169
 170         return {inputs, outputs};
 171     }
 172
 173     testing::InOutShapes getInvalidInputShapes()  override {
 174         int numOfInput;
 175         int numOfOutput;
 176         std::vector<std::vector<size_t>> inputs;
 177         std::vector<std::vector<size_t>> outputs;
 178         if (is_number(maps.mapOfContinuousShapes[type].first)) {
 179             numOfInput = std::stoi(maps.mapOfContinuousShapes[type].first) * 2;
 180             inputs = generateShapes(numOfInput);
 181             outputs = generateShapes(100);
 182         } else {
 183             numOfOutput = std::stoi(maps.mapOfContinuousShapes[type].second);
 184             outputs = generateShapes(numOfOutput);
 185             inputs = generateShapes(100);
 186         }
 187         return {inputs, outputs};
 188     }
 189
 190     ~NotEqualIOShapesHelper() override = default;
 191 };
 192
 193 class Layers {
 194 public:
 195     virtual bool containLayer(std::string concrete_layer) = 0;
 196     virtual ShapesHelper* factoryShape() = 0;
 197     virtual ~Layers() = default;
 198 };
 199
 200 class LayersWithEqualIO : public Layers {
 201 private:
 202     std::string layer = "";
 203 public:
 204     bool containLayer(std::string concrete_layer) override {
 205         for (const auto& layer : maps.mapOfEqualShapes) {
 206             if (concrete_layer == layer.first) {
 207                 this->layer = concrete_layer;
 208                 return true;
 209             }
 210         }
 211         return false;
 212     }
 213     ShapesHelper* factoryShape() override {
 214         return new EqualIOShapesHelper(this->layer);
 215     }
 216     ~LayersWithEqualIO() override = default;
 217 };
 218
 219 class LayersWithNotEqualIO : public Layers{
 220 private:
 221     std::string layer = "";
 222 public:
 223     bool containLayer(std::string concrete_layer) override {
 224         for (const auto& layer : maps.mapOfUnequalShapes) {
 225             if (concrete_layer == layer.first) {
 226                 this->layer = concrete_layer;
 227                 return true;
 228             }
 229         }
 230         return false;
 231     }
 232     ShapesHelper* factoryShape() override {
 233         return new NotEqualConcreteIOShapesHelper(this->layer);
 234     }
 235     ~LayersWithNotEqualIO() override = default;
 236 };
 237
 238 class LayersWithNIO : public Layers{
 239 private:
 240     std::string layer = "";
 241 public:
 242     bool containLayer(std::string concrete_layer) override {
 243         for (const auto& layer : maps.mapOfContinuousShapes) {
 244             if (concrete_layer == layer.first) {
 245                 this->layer = concrete_layer;
 246                 return true;
 247             }
 248         }
 249         return false;
 250     }
 251     ShapesHelper* factoryShape() override {
 252         return new NotEqualIOShapesHelper(this->layer);
 253     }
 254     ~LayersWithNIO() override = default;
 255 };
 256
 257 #endif // SHAPES_H