inference-engine/src/vpu/graph_transformer/src/stages/scale.cpp

   1 // Copyright (C) 2018-2019 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 #include <vpu/frontend/frontend.hpp>
   6
   7 #include <vector>
   8 #include <memory>
   9 #include <set>
  10 #include <string>
  11
  12 #include <vpu/sw/post_op_stage.hpp>
  13
  14 namespace vpu {
  15
  16 namespace {
  17
  18 class ScaleStage final : public PostOpStage {
  19 private:
  20     StagePtr cloneImpl() const override {
  21         return std::make_shared<ScaleStage>(*this);
  22     }
  23
  24     void propagateScaleFactorsImpl(
  25             const SmallVector<float>& inputScales,
  26             ScalePropagationStep step) override {
  27         IE_ASSERT(_inputEdges.size() == 2 || _inputEdges.size() == 3);
  28         IE_ASSERT(_outputEdges.size() == 1);
  29
  30         auto inputScale = inputScales[0];
  31
  32         _scaleInfo.setInput(_inputEdges[1], step == ScalePropagationStep::Propagate ? 1.0f : inputScale);
  33         if (_inputEdges.size() == 3) {
  34             _scaleInfo.setInput(_inputEdges[2], inputScale);
  35         }
  36         _scaleInfo.setOutput(_outputEdges[0], inputScale);
  37     }
  38
  39     void serializeParamsImpl(BlobSerializer&) const override {
  40     }
  41 };
  42
  43 }  // namespace
  44
  45 Stage StageBuilder::addScaleStage(
  46         const Model::Ptr& model,
  47         const std::string& name,
  48         const ie::CNNLayerPtr& layer,
  49         const Data& input,
  50         const Data& scales,
  51         const Data& output) {
  52     return model->addNewStage<ScaleStage>(
  53         name,
  54         StageType::Scale,
  55         layer,
  56         {input, scales},
  57         {output});
  58 }
  59
  60 void FrontEnd::parseScale(
  61         const Model::Ptr& model,
  62         const ie::CNNLayerPtr& _layer,
  63         const DataVector& inputs,
  64         const DataVector& outputs) {
  65     IE_ASSERT(inputs.size() == 1);
  66     IE_ASSERT(outputs.size() == 1);
  67
  68     auto layer = std::dynamic_pointer_cast<ie::ScaleShiftLayer>(_layer);
  69     IE_ASSERT(layer != nullptr);
  70
  71     if (layer->_broadcast != 0) {
  72         VPU_THROW_EXCEPTION <<
  73             "Layer " << layer->name << " doesn't support broadcast param";
  74     }
  75
  76     auto input = inputs[0];
  77     auto output = outputs[0];
  78
  79     Data scales, biases;
  80     std::tie(scales, biases) = getWeightsAndBiases(model, layer);
  81
  82     if (biases->usage() == DataUsage::Fake) {
  83         model->addNewStage<ScaleStage>(
  84             layer->name,
  85             StageType::Scale,
  86             layer,
  87             {input, scales},
  88             {output});
  89     } else {
  90         model->addNewStage<ScaleStage>(
  91             layer->name,
  92             StageType::ScaleShift,
  93             layer,
  94             {input, scales, biases},
  95             {output});
  96     }
  97 }
  98
  99 }  // namespace vpu