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,
  52             StageDataInfo<float>& scaleInfo) override {
  53         auto power = attrs().get<float>("power");
  54         auto& scale = attrs().get<float>("scale");
  55         auto& bias = attrs().get<float>("bias");
  56
  57         if (power != 1.0f) {
  58             scaleInfo.setInput(inputEdge(0), 1.0f);
  59             scaleInfo.setOutput(outputEdge(0), 1.0f);
  60         } else {
  61             auto inputScale = inputScales[0];
  62
  63             scaleInfo.setOutput(outputEdge(0), inputScale);
  64
  65             if (step == ScalePropagationStep::ScaleInput) {
  66                 scale *= inputScale;
  67             }
  68             if (step != ScalePropagationStep::Check) {
  69                 bias *= inputScale;
  70             }
  71         }
  72     }
  73
  74     void serializeParamsImpl(BlobSerializer& serializer) const override {
  75         auto scale = attrs().get<float>("scale");
  76         auto power = attrs().get<float>("power");
  77         auto bias = attrs().get<float>("bias");
  78
  79         serializer.append(static_cast<float>(bias));
  80         serializer.append(static_cast<float>(scale));
  81         serializer.append(static_cast<float>(power));
  82     }
  83 };
  84
  85 }  // namespace
  86
  87 Stage StageBuilder::addPowerStage(
  88         const Model::Ptr& model,
  89         const std::string& name,
  90         const ie::CNNLayerPtr& layer,
  91         float scale,
  92         float power,
  93         float bias,
  94         const Data& input,
  95         const Data& output) {
  96     auto stage = model->addNewStage<PowerStage>(
  97         name,
  98         StageType::Power,
  99         layer,
 100         {input},
 101         {output});
 102
 103     stage->attrs().set<float>("scale", scale);
 104     stage->attrs().set<float>("power", power);
 105     stage->attrs().set<float>("bias", bias);
 106
 107     return stage;
 108 }
 109
 110 }  // namespace vpu