inference-engine/src/vpu/graph_transformer/src/stages/power.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 void FrontEnd::parsePower(
  17         const Model::Ptr& model,
  18         const ie::CNNLayerPtr& _layer,
  19         const DataVector& inputs,
  20         const DataVector& outputs) {
  21     IE_ASSERT(inputs.size() == 1);
  22     IE_ASSERT(outputs.size() == 1);
  23
  24     auto input = inputs[0];
  25     auto output = outputs[0];
  26
  27     auto layer = std::dynamic_pointer_cast<ie::PowerLayer>(_layer);
  28     IE_ASSERT(layer != nullptr);
  29
  30     _stageBuilder->addPowerStage(
  31         model,
  32         layer->name,
  33         layer,
  34         layer->scale,
  35         layer->power,
  36         layer->offset,
  37         inputs[0],
  38         outputs[0]);
  39 }
  40
  41 namespace {
  42
  43 class PowerStage final : public PostOpStage {
  44 private:
  45     StagePtr cloneImpl() const override {
  46         return std::make_shared<PowerStage>(*this);
  47     }
  48
  49     void propagateScaleFactorsImpl(
  50             const SmallVector<float>& inputScales,
  51             ScalePropagationStep step) override {
  52         IE_ASSERT(_inputEdges.size() == 1);
  53         IE_ASSERT(_outputEdges.size() == 1);
  54
  55         auto power = attrs().get<float>("power");
  56         auto& scale = attrs().get<float>("scale");
  57         auto& bias = attrs().get<float>("bias");
  58
  59         if (power != 1.0f) {
  60             _scaleInfo.setInput(_inputEdges[0], 1.0f);
  61             _scaleInfo.setOutput(_outputEdges[0], 1.0f);
  62         } else {
  63             auto inputScale = inputScales[0];
  64
  65             _scaleInfo.setOutput(_outputEdges[0], inputScale);
  66
  67             if (step == ScalePropagationStep::ScaleInput) {
  68                 scale *= inputScale;
  69             }
  70             if (step != ScalePropagationStep::Check) {
  71                 bias *= inputScale;
  72             }
  73         }
  74     }
  75
  76     void serializeParamsImpl(BlobSerializer& serializer) const override {
  77         auto scale = attrs().get<float>("scale");
  78         auto power = attrs().get<float>("power");
  79         auto bias = attrs().get<float>("bias");
  80
  81         serializer.append(static_cast<float>(bias));
  82         serializer.append(static_cast<float>(scale));
  83         serializer.append(static_cast<float>(power));
  84     }
  85 };
  86
  87 }  // namespace
  88
  89 Stage StageBuilder::addPowerStage(
  90         const Model::Ptr& model,
  91         const std::string& name,
  92         const ie::CNNLayerPtr& layer,
  93         float scale,
  94         float power,
  95         float bias,
  96         const Data& input,
  97         const Data& output) {
  98     auto stage = model->addNewStage<PowerStage>(
  99         name,
 100         StageType::Power,
 101         layer,
 102         {input},
 103         {output});
 104
 105     stage->attrs().set<float>("scale", scale);
 106     stage->attrs().set<float>("power", power);
 107     stage->attrs().set<float>("bias", bias);
 108
 109     return stage;
 110 }
 111
 112 }  // namespace vpu