[IE][VPU]: Decompose Swish to Sigmoid + Prod (#2107)

* Workaround to decompose Swish to Sigmoid + Multiply

inference-engine/src/vpu/graph_transformer/include/vpu/middleend/pass_manager.hpp

@@ -93,6 +93,7 @@ public:
     // Model common adaptation
     //
 
+    Pass::Ptr decomposeSwish();
     Pass::Ptr eliminateConstConcat();
     Pass::Ptr splitGroupedConv();
     Pass::Ptr splitConv3DInto2D();

inference-engine/src/vpu/graph_transformer/include/vpu/stage_builder.hpp

@@ -297,6 +297,21 @@ public:
         const std::string& name,
         const DataVector& inputs,
         const DataVector& outputs);
+
+    Stage addSigmoidStage(
+            const Model& model,
+            const std::string& name,
+            const ie::CNNLayerPtr& layer,
+            const DataVector& inputs,
+            const DataVector& outputs);
+
+    Stage addProdStage(
+            const Model& model,
+            const std::string& name,
+            const ie::CNNLayerPtr& layer,
+            const Data& input0,
+            const Data& input1,
+            const Data& output);
 };
 
 }  // namespace vpu

inference-engine/src/vpu/graph_transformer/src/middleend/pass_manager.cpp

@@ -87,6 +87,12 @@ PassSet::Ptr PassManager::buildMiddleEnd() {
     // initial dump pass must be the first dump
     ADD_DUMP_PASS("initial");
 
+    //
+    // Decompose swish layer to Sigmoid + Multiply
+    //
+    ADD_PASS(decomposeSwish);
+    ADD_DUMP_PASS("decomposeSwish");
+
     //
     // Convert shape notation
     //

inference-engine/src/vpu/graph_transformer/src/middleend/passes/decompose_swish.cpp

@@ -0,0 +1,61 @@
+// Copyright (C) 2018-2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <vpu/middleend/pass_manager.hpp>
+
+namespace vpu {
+
+namespace {
+
+class PassImpl final : public Pass {
+public:
+    explicit PassImpl(const StageBuilder::Ptr& stageBuilder) :
+            _stageBuilder(stageBuilder) {
+    }
+
+    void run(const Model& model) override;
+
+private:
+    StageBuilder::Ptr _stageBuilder;
+};
+
+void PassImpl::run(const Model& model) {
+    VPU_PROFILE(decomposeSwish);
+
+    for (const auto& swish : model->getStages()) {
+        if (swish->type() != StageType::Swish) {
+            continue;
+        }
+        const auto inputData = swish->input(0);
+        const auto outputData = swish->output(0);
+        const auto name = swish->name();
+        const auto& layer = swish->origLayer();
+
+        model->removeStage(swish);
+
+        const auto sigmoidOutput = model->addNewData(inputData->name() + "@sigmoid", inputData->desc());
+
+        _stageBuilder->addSigmoidStage(
+                model,
+                name + "@sigmoid",
+                layer,
+                {inputData},
+                {sigmoidOutput});
+        _stageBuilder->addProdStage(
+                model,
+                name + "@prod",
+                layer,
+                inputData,
+                sigmoidOutput,
+                outputData);
+    }
+}
+
+}  // namespace
+
+Pass::Ptr PassManager::decomposeSwish() {
+    return std::make_shared<PassImpl>(_stageBuilder);
+}
+
+}  // namespace vpu

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

@@ -350,6 +350,22 @@ Stage StageBuilder::addSumStage(
         {output});
 }
 
+Stage StageBuilder::addProdStage(
+        const Model& model,
+        const std::string& name,
+        const ie::CNNLayerPtr& layer,
+        const Data& input0,
+        const Data& input1,
+        const Data& output) {
+    const Data& fakeInput2 = model->addFakeData();
+    return model->addNewStage<EltwiseStage>(
+            name,
+            StageType::Prod,
+            layer,
+            {input0, input1, fakeInput2},
+            {output});
+}
+
 Stage StageBuilder::addMaxStage(
         const Model& model,
         const std::string& name,

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

@@ -33,7 +33,16 @@ void FrontEnd::parseSigmoid(const Model& model, const ie::CNNLayerPtr& layer, co
     IE_ASSERT(inputs.size() == 1);
     IE_ASSERT(outputs.size() == 1);
 
-    model->addNewStage<SigmoidStage>(layer->name, StageType::Sigmoid, layer, inputs, outputs);
+    _stageBuilder->addSigmoidStage(model, layer->name, layer, inputs, outputs);
+}
+
+Stage StageBuilder::addSigmoidStage(
+        const Model& model,
+        const std::string& name,
+        const ie::CNNLayerPtr& layer,
+        const DataVector& inputs,
+        const DataVector& outputs) {
+    return model->addNewStage<SigmoidStage>(name, StageType::Sigmoid, layer, inputs, outputs);
 }
 
 }  // namespace vpu