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

   1 // Copyright (C) 2018-2019 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 #ifndef SHAPES_H
   6 #define SHAPES_H
   7
   8 #include <iostream>
   9 #include <map>
  10 #include <string>
  11 #include <vector>
  12 #include <xml_net_builder.hpp>
  13 #include <random>
  14 #include <chrono>
  15
  16 using namespace testing;
  17
  18 struct Maps{
  19     std::map<std::string, int> mapOfEqualShapes {
  20             // Layer name, Correct num of input, Correct num of output
  21             { "Convolution", 1},
  22             { "Deconvolution", 1},
  23             { "Crop", 1},
  24             { "Interp", 1}
  25     };
  26
  27     std::map<std::string, std::pair<int, int>> mapOfUnequalShapes {
  28             // Layer name, Correct num of input, Correct num of output
  29             { "Crop", {2, 1}},
  30             { "DetectionOutput", {3, 1}},
  31             { "Interp", {2, 1}}
  32     };
  33
  34     std::map<std::string, std::pair<std::string, std::string>> mapOfContinuousShapes {
  35             // Layer name, Correct num of input, Correct num of output
  36             { "Slice", {"1", "N"}},
  37             { "Eltwise", {"N", "1"}}
  38     };
  39 } maps;
  40
  41 class ShapesHelper {
  42 protected:
  43     std::string type;
  44 public:
  45     ShapesHelper() = default;
  46
  47     explicit ShapesHelper(std::string& type) {
  48         this->type = type;
  49     }
  50
  51     std::string getType() {return type;}
  52
  53     virtual testing::InOutShapes getValidShapes() = 0;
  54     virtual testing::InOutShapes getInvalidInputShapes() = 0;
  55
  56     std::vector<std::vector<size_t>> generateShapes(const int& numOfShapes) {
  57         std::mt19937 gen(static_cast<unsigned long>(std::chrono::high_resolution_clock::now().time_since_epoch().count()));
  58         std::uniform_int_distribution<unsigned long> dist(1, 256);
  59
  60         std::vector<std::vector<size_t>> shape;
  61         shape.reserve(static_cast<unsigned long>(numOfShapes));
  62         for (int i = 0; i < numOfShapes; ++i) {
  63             shape.push_back({dist(gen), dist(gen), dist(gen), 7});
  64         }
  65         return shape;
  66     }
  67     virtual ~ShapesHelper() = default;
  68 };
  69
  70 class EqualIOShapesHelper : public ShapesHelper {
  71 public:
  72     explicit EqualIOShapesHelper(std::string& type) : ShapesHelper(type) {};
  73
  74     testing::InOutShapes getValidShapes() override {
  75         int numOfInput = {maps.mapOfEqualShapes[type]};
  76         int numOfOutput = {maps.mapOfEqualShapes[type]};
  77         std::vector<std::vector<size_t>> inputs = generateShapes(numOfInput);
  78         std::vector<std::vector<size_t>> outputs = generateShapes(numOfOutput);
  79         return {inputs, outputs};
  80     }
  81
  82     testing::InOutShapes getInvalidInputShapes()  override {
  83         int numOfOutput = maps.mapOfEqualShapes[type];
  84         int numOfInput = maps.mapOfEqualShapes[type]  + numOfOutput;
  85         std::vector<std::vector<size_t>> inputs = generateShapes(numOfInput);
  86         std::vector<std::vector<size_t>> outputs = generateShapes(numOfOutput);
  87         return {inputs, outputs};
  88     }
  89     ~EqualIOShapesHelper() override = default;
  90 };
  91
  92 class NotEqualConcreteIOShapesHelper : public ShapesHelper {
  93 public:
  94     explicit NotEqualConcreteIOShapesHelper(std::string& type) : ShapesHelper(type) {};
  95
  96     testing::InOutShapes getValidShapes() override {
  97         int numOfInput = maps.mapOfUnequalShapes[type].first;
  98         int numOfOutput = maps.mapOfUnequalShapes[type].second;
  99         std::vector<std::vector<size_t>> inputs = generateShapes(numOfInput);
 100         std::vector<std::vector<size_t>> outputs = generateShapes(numOfOutput);
 101         return {inputs, outputs};
 102     }
 103
 104     testing::InOutShapes getInvalidInputShapes()  override {
 105         int numOfOutput = maps.mapOfUnequalShapes[type].second;
 106         int numOfInput = maps. mapOfUnequalShapes[type].first + numOfOutput;
 107
 108         std::vector<std::vector<size_t>> inputs = generateShapes(numOfInput);
 109         std::vector<std::vector<size_t>> outputs = generateShapes(numOfOutput);
 110         return {inputs, outputs};
 111     }
 112     ~NotEqualConcreteIOShapesHelper() override = default;
 113 };
 114
 115 class NotEqualIOShapesHelper : public ShapesHelper {
 116 private:
 117     bool is_number(const std::string& s)
 118     {
 119         return !s.empty() && std::find_if(s.begin(),
 120                                           s.end(), [](char c) { return !std::isdigit(c); }) == s.end();
 121     }
 122
 123 public:
 124
 125     explicit NotEqualIOShapesHelper(std::string& type) : ShapesHelper(type) {};
 126
 127     testing::InOutShapes getValidShapes() override {
 128         int numOfInput;
 129         int numOfOutput;
 130         std::vector<std::vector<size_t>> inputs;
 131         std::vector<std::vector<size_t>> outputs;
 132         if (is_number(maps.mapOfContinuousShapes[type].first)) {
 133             numOfInput = std::stoi(maps.mapOfContinuousShapes[type].first);
 134             inputs = generateShapes(numOfInput);
 135             outputs = generateShapes(100);
 136         } else {
 137             numOfOutput = std::stoi(maps.mapOfContinuousShapes[type].second);
 138             outputs = generateShapes(numOfOutput);
 139             inputs = generateShapes(100);
 140         }
 141
 142         return {inputs, outputs};
 143     }
 144
 145     testing::InOutShapes getInvalidInputShapes()  override {
 146         int numOfInput;
 147         int numOfOutput;
 148         std::vector<std::vector<size_t>> inputs;
 149         std::vector<std::vector<size_t>> outputs;
 150         if (is_number(maps.mapOfContinuousShapes[type].first)) {
 151             numOfInput = std::stoi(maps.mapOfContinuousShapes[type].first) * 2;
 152             inputs = generateShapes(numOfInput);
 153             outputs = generateShapes(100);
 154         } else {
 155             numOfOutput = std::stoi(maps.mapOfContinuousShapes[type].second);
 156             outputs = generateShapes(numOfOutput);
 157             inputs = generateShapes(100);
 158         }
 159         return {inputs, outputs};
 160     }
 161
 162     ~NotEqualIOShapesHelper() override = default;
 163 };
 164
 165 class Layers {
 166 public:
 167     virtual bool containLayer(std::string concrete_layer) = 0;
 168     virtual ShapesHelper* factoryShape() = 0;
 169     virtual ~Layers() = default;
 170 };
 171
 172 class LayersWithEqualIO : public Layers {
 173 private:
 174     std::string layer = "";
 175 public:
 176     bool containLayer(std::string concrete_layer) override {
 177         for (const auto& layer : maps.mapOfEqualShapes) {
 178             if (concrete_layer == layer.first) {
 179                 this->layer = concrete_layer;
 180                 return true;
 181             }
 182         }
 183         return false;
 184     }
 185     ShapesHelper* factoryShape() override {
 186         return new EqualIOShapesHelper(this->layer);
 187     }
 188     ~LayersWithEqualIO() override = default;
 189 };
 190
 191 class LayersWithNotEqualIO : public Layers{
 192 private:
 193     std::string layer = "";
 194 public:
 195     bool containLayer(std::string concrete_layer) override {
 196         for (const auto& layer : maps.mapOfUnequalShapes) {
 197             if (concrete_layer == layer.first) {
 198                 this->layer = concrete_layer;
 199                 return true;
 200             }
 201         }
 202         return false;
 203     }
 204     ShapesHelper* factoryShape() override {
 205         return new NotEqualConcreteIOShapesHelper(this->layer);
 206     }
 207     ~LayersWithNotEqualIO() override = default;
 208 };
 209
 210 class LayersWithNIO : public Layers{
 211 private:
 212     std::string layer = "";
 213 public:
 214     bool containLayer(std::string concrete_layer) override {
 215         for (const auto& layer : maps.mapOfContinuousShapes) {
 216             if (concrete_layer == layer.first) {
 217                 this->layer = concrete_layer;
 218                 return true;
 219             }
 220         }
 221         return false;
 222     }
 223     ShapesHelper* factoryShape() override {
 224         return new NotEqualIOShapesHelper(this->layer);
 225     }
 226     ~LayersWithNIO() override = default;
 227 };
 228
 229 #endif // SHAPES_H