remove anakin from code, test=release/1.7 (#22421)

CMakeLists.txt

@@ -149,7 +149,6 @@ if(NOT WIN32)
     include(cupti)
 endif()
 
-include(anakin_subgraph)
 include(flags)              # set paddle compile flags
 include(cudnn)              # set cudnn libraries, must before configure
 

cmake/anakin_subgraph.cmake

-set(ANAKIN_ROOT "/usr" CACHE PATH "ANAKIN ROOT")
-find_path(ANAKIN_INCLUDE_DIR anakin_config.h
-    PATHS ${ANAKIN_ROOT} ${ANAKIN_ROOT}/include
-    $ENV{ANAKIN_ROOT} $ENV{ANAKIN_ROOT}/include
-    NO_DEFAULT_PATH
-)
-
-find_library(ANAKIN_LIBRARY NAMES libanakin_saber_common.so libanakin.so
-    PATHS ${ANAKIN_ROOT}
-    $ENV{ANAKIN_ROOT} $ENV{ANAKIN_ROOT}/lib
-    NO_DEFAULT_PATH
-    DOC "Path to ANAKIN library.")
-
-if(ANAKIN_INCLUDE_DIR AND ANAKIN_LIBRARY)
-    set(ANAKIN_FOUND ON)
-else()
-    set(ANAKIN_FOUND OFF)
-endif()
-
-if(ANAKIN_FOUND)
-    message(STATUS "Current ANAKIN header is ${ANAKIN_INCLUDE_DIR}/anakin_config.h. ")
-    include_directories(${ANAKIN_ROOT})
-    include_directories(${ANAKIN_ROOT}/include)
-    include_directories(${ANAKIN_ROOT}/saber)
-    link_directories(${ANAKIN_ROOT})
-    add_definitions(-DPADDLE_WITH_ANAKIN)
-endif()
-
-if(ANAKIN_FOUND)
-  if (ANAKIN_MLU AND NOT WITH_GPU AND NOT ANAKIN_X86)
-    message(STATUS "Compile with anakin mlu place.")
-    add_definitions(-DANAKIN_MLU_PLACE)
-  elseif(ANAKIN_BM AND NOT WITH_GPU AND NOT ANAKIN_X86)
-    message(STATUS "Compile with anakin bm place.")
-    add_definitions(-DANAKIN_BM_PLACE)
-  elseif(ANAKIN_X86)
-    message(STATUS "Compile with anakin x86 place.")
-    add_definitions(-DANAKIN_X86_PLACE)
-  endif()
-endif()
-
-if(ANAKIN_FOUND AND WITH_GPU AND WITH_DSO)
-    message(STATUS "Compile with anakin subgraph.")
-    set(ANAKIN_SUBGRAPH ON)
-endif()

cmake/configure.cmake

@@ -105,16 +105,6 @@ if(WITH_GPU)
         endif()
         include_directories(${TENSORRT_INCLUDE_DIR})
     endif()
-    if(ANAKIN_FOUND)
-        if(${CUDA_VERSION_MAJOR} VERSION_LESS 8)
-            message(WARNING "Anakin needs CUDA >= 8.0 to compile. Force ANAKIN_FOUND = OFF")
-            set(ANAKIN_FOUND OFF CACHE STRING "Anakin is valid only when CUDA >= 8.0." FORCE)
-        endif()
-        if(${CUDNN_MAJOR_VERSION} VERSION_LESS 7)
-            message(WARNING "Anakin needs CUDNN >= 7.0 to compile. Force ANAKIN_FOUND = OFF")
-            set(ANAKIN_FOUND OFF CACHE STRING "Anakin is valid only when CUDNN >= 7.0." FORCE)
-        endif()
-    endif()
 elseif(WITH_AMD_GPU)
     add_definitions(-DPADDLE_WITH_HIP)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D__HIP_PLATFORM_HCC__")

cmake/inference_lib.cmake

@@ -126,12 +126,12 @@ function(copy_part_of_thrid_party TARGET DST)
                 DSTS ${dst_dir}/include ${dst_dir}/lib)
     endif ()
 
-    if (ANAKIN_FOUND)
-        set(dst_dir "${DST}/third_party/install/anakin")
+    if (LITE_BINARY_DIR)
+        set(dst_dir "${DST}/third_party/install/lite")
         copy(${TARGET}
-                SRCS ${ANAKIN_ROOT}/*
+                SRCS ${LITE_BINARY_DIR}/inference_lite_lib/*
                 DSTS ${dst_dir})
-    endif ()
+    endif()
 endfunction()
 
 # inference library for only inference

paddle/fluid/framework/ir/CMakeLists.txt

@@ -71,7 +71,6 @@ pass_library(identity_scale_op_clean_pass base)
 pass_library(sync_batch_norm_pass base)
 pass_library(runtime_context_cache_pass base)
 pass_library(quant_conv2d_dequant_fuse_pass inference)
-pass_library(fillconstant_elementwisemul_fuse inference)
 pass_library(shuffle_channel_detect_pass inference)
 pass_library(delete_quant_dequant_op_pass inference)
 pass_library(simplify_with_basic_ops_pass base)
@@ -81,10 +80,6 @@ if(WITH_GPU)
     pass_library(cudnn_placement_pass base DEPS placement_pass_base)
 endif()
 
-if(ANAKIN_SUBGRAPH)
-pass_library(simplify_anakin_priorbox_detection_out_pass inference)
-endif()
-
 if(WITH_MKLDNN)
     pass_library(mkldnn_placement_pass base DEPS placement_pass_base DIR mkldnn)
     pass_library(depthwise_conv_mkldnn_pass base DIR mkldnn)

paddle/fluid/framework/ir/fillconstant_elementwisemul_fuse.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <memory>
-#include <string>
-
-#include "paddle/fluid/framework/ir/fillconstant_elementwisemul_fuse.h"
-#include "paddle/fluid/framework/ir/graph_viz_pass.h"
-
-namespace paddle {
-namespace framework {
-namespace ir {
-
-#define GET_IR_NODE(node__) GET_IR_NODE_FROM_SUBGRAPH(node__, node__, pattern);
-#define GET_NODES                 \
-  GET_IR_NODE(fill_constant);     \
-  GET_IR_NODE(fill_constant_out); \
-  GET_IR_NODE(elementwise_mul);   \
-  GET_IR_NODE(elementwise_mul_out);
-
-void FillconstantElementwisemulFuse::ApplyImpl(ir::Graph* graph) const {
-  const std::string pattern_name = "fillconstant_elementwisemul_fuse";
-  FusePassBase::Init(pattern_name, graph);
-
-  GraphPatternDetector gpd;
-  auto* x = gpd.mutable_pattern()
-                ->NewNode("x")
-                ->assert_is_op_input("elementwise_mul", "X")
-                ->AsInput();
-
-  patterns::FillConstantElementWiseMulFuse pattern(gpd.mutable_pattern(),
-                                                   pattern_name);
-  pattern(x);
-
-  auto handler = [&](const GraphPatternDetector::subgraph_t& subgraph,
-                     Graph* g) {
-    GET_NODES;
-
-    PADDLE_ENFORCE(subgraph.count(x));
-    auto* elementwise_in = subgraph.at(x);
-    float constant_value =
-        boost::get<float>(fill_constant->Op()->GetAttr("value"));
-
-    framework::OpDesc new_op_desc;
-    new_op_desc.SetType("scale");
-    new_op_desc.SetInput("X", {elementwise_in->Name()});
-    new_op_desc.SetAttr("scale", constant_value);
-    new_op_desc.SetAttr("bias", static_cast<float>(0.0));
-    new_op_desc.SetAttr("bias_after_scale", true);
-    new_op_desc.SetOutput("Out", {elementwise_mul_out->Name()});
-    new_op_desc.Flush();
-
-    // Create a new node for the fused op.
-    auto* scale_op = graph->CreateOpNode(&new_op_desc);
-
-    IR_NODE_LINK_TO(elementwise_in, scale_op);       // Input
-    IR_NODE_LINK_TO(scale_op, elementwise_mul_out);  // Output
-
-    // Delete the unneeded nodes.
-    GraphSafeRemoveNodes(graph,
-                         {fill_constant, fill_constant_out, elementwise_mul});
-  };
-
-  gpd(graph, handler);
-}
-
-}  // namespace ir
-}  // namespace framework
-}  // namespace paddle
-
-REGISTER_PASS(fillconstant_elementwisemul_fuse,
-              paddle::framework::ir::FillconstantElementwisemulFuse);

paddle/fluid/framework/ir/graph_pattern_detector.cc

@@ -1878,173 +1878,6 @@ PDNode *patterns::TransposeFlattenConcat::operator()(
   return concat_out;
 }
 
-PDNode *patterns::AnakinDetectionPattern::operator()(
-    std::vector<PDNode *> conv_in, int times, std::string priorbox_type,
-    bool is_reshape) {
-  // The times represents the repeat times of the
-  // {prior_box, prior_box_loc_out, flatten, prior_box_var_out, reshape}
-  const int kNumFields = 7;
-  const int kPriorBoxLocOffset = 1;
-  const int kReshape1Offset = 2;
-  const int kReshape1OutOffset = 3;
-  const int kPriorBoxVarOffset = 4;
-  const int kReshape2Offset = 5;
-  const int kReshape2OutOffset = 6;
-
-  const int kBoxCoderThirdInputOffset = times;
-  const int kMultiClassSecondInputNmsOffset = times + 1;
-
-  std::vector<PDNode *> nodes;
-  std::string op_after_priorbox = is_reshape ? "reshape2" : "flatten2";
-
-  for (int i = 0; i < times; i++) {
-    nodes.push_back(
-        pattern->NewNode(GetNodeName("prior_box" + std::to_string(i)))
-            ->assert_is_op(priorbox_type));
-    nodes.push_back(pattern->NewNode(GetNodeName("box_out" + std::to_string(i)))
-                        ->assert_is_op_output(priorbox_type, "Boxes")
-                        ->assert_is_op_input(op_after_priorbox, "X")
-                        ->AsIntermediate());
-    nodes.push_back(
-        pattern->NewNode(GetNodeName("reshape1" + std::to_string(i)))
-            ->assert_is_op(op_after_priorbox));
-
-    nodes.push_back(
-        pattern->NewNode(GetNodeName("reshape1_out" + std::to_string(i)))
-            ->assert_is_op_output(op_after_priorbox)
-            ->assert_is_op_nth_input("concat", "X", i)
-            ->AsIntermediate());
-
-    nodes.push_back(
-        pattern->NewNode(GetNodeName("box_var_out" + std::to_string(i)))
-            ->assert_is_op_output(priorbox_type, "Variances")
-            ->assert_is_op_input(op_after_priorbox, "X")
-            ->AsIntermediate());
-    nodes.push_back(
-        pattern->NewNode(GetNodeName("reshape2" + std::to_string(i)))
-            ->assert_is_op(op_after_priorbox));
-
-    nodes.push_back(
-        pattern->NewNode(GetNodeName("reshape2_out" + std::to_string(i)))
-            ->assert_is_op_output(op_after_priorbox)
-            ->assert_is_op_nth_input("concat", "X", i)
-            ->AsIntermediate());
-  }
-
-  auto concat_op1 = pattern->NewNode(GetNodeName("concat1"))
-                        ->assert_is_op("concat")
-                        ->assert_op_has_n_inputs("concat", times);
-  auto concat_out1 = pattern->NewNode(GetNodeName("concat1_out"))
-                         ->assert_is_op_output("concat")
-                         ->AsIntermediate();
-
-  auto concat_op2 = pattern->NewNode(GetNodeName("concat2"))
-                        ->assert_is_op("concat")
-                        ->assert_op_has_n_inputs("concat", times);
-  auto concat_out2 = pattern->NewNode(GetNodeName("concat2_out"))
-                         ->assert_is_op_output("concat")
-                         ->AsIntermediate();
-
-  auto box_coder_op = pattern->NewNode(GetNodeName("box_coder"))
-                          ->assert_is_op("box_coder")
-                          ->assert_op_has_n_inputs("box_coder", 3);
-
-  auto box_coder_out = pattern->NewNode(GetNodeName("box_coder_out"))
-                           ->assert_is_op_output("box_coder")
-                           ->AsIntermediate();
-
-  auto transpose_before_nms =
-      pattern->NewNode(GetNodeName("transpose_before_nms"))
-          ->assert_is_op("transpose2");
-
-  auto transpose_before_nms_out =
-      pattern->NewNode(GetNodeName("transpose_before_nms_out"))
-          ->assert_is_op_output("transpose2")
-          ->assert_is_op_input("multiclass_nms", "Scores")
-          ->AsIntermediate();
-
-  auto multiclass_nms_op = pattern->NewNode(GetNodeName("multiclass_nms"))
-                               ->assert_is_op("multiclass_nms")
-                               ->assert_op_has_n_inputs("multiclass_nms", 2);
-
-  auto multiclass_nms_out = pattern->NewNode(GetNodeName("multiclass_nms_out"))
-                                ->assert_is_op_output("multiclass_nms")
-                                ->AsOutput();
-
-  std::vector<PDNode *> reshape1_outs;
-  std::vector<PDNode *> reshape2_outs;
-
-  for (int i = 0; i < times; i++) {
-    conv_in[i]->AsInput();
-    // prior_box
-    nodes[i * kNumFields]->LinksFrom({conv_in[i]});
-    // prior_box box out
-    nodes[i * kNumFields + kPriorBoxLocOffset]->LinksFrom(
-        {nodes[i * kNumFields]});
-    // reshape
-    nodes[i * kNumFields + kReshape1Offset]->LinksFrom(
-        {nodes[i * kNumFields + kPriorBoxLocOffset]});
-    // reshape_out
-    nodes[i * kNumFields + kReshape1OutOffset]->LinksFrom(
-        {nodes[i * kNumFields + kReshape1Offset]});
-
-    nodes[i * kNumFields + kPriorBoxVarOffset]->LinksFrom(
-        {nodes[i * kNumFields]});
-    // reshape
-    nodes[i * kNumFields + kReshape2Offset]->LinksFrom(
-        {nodes[i * kNumFields + kPriorBoxVarOffset]});
-    // reshape_out
-    nodes[i * kNumFields + kReshape2OutOffset]->LinksFrom(
-        {nodes[i * kNumFields + kReshape2Offset]});
-
-    reshape1_outs.push_back(nodes[i * kNumFields + kReshape1OutOffset]);
-    reshape2_outs.push_back(nodes[i * kNumFields + kReshape2OutOffset]);
-  }
-
-  concat_op1->LinksFrom(reshape1_outs);
-  concat_op2->LinksFrom(reshape2_outs);
-  concat_out1->LinksFrom({concat_op1});
-  concat_out2->LinksFrom({concat_op2});
-
-  conv_in[kBoxCoderThirdInputOffset]->AsInput();
-  conv_in[kMultiClassSecondInputNmsOffset]->AsInput();
-
-  box_coder_op->LinksFrom(
-      {concat_out1, concat_out2, conv_in[kBoxCoderThirdInputOffset]});
-  box_coder_out->LinksFrom({box_coder_op});
-
-  transpose_before_nms->LinksFrom({conv_in[kMultiClassSecondInputNmsOffset]});
-  transpose_before_nms_out->LinksFrom({transpose_before_nms});
-
-  multiclass_nms_op->LinksFrom({box_coder_out, transpose_before_nms_out})
-      .LinksTo({multiclass_nms_out});
-
-  return multiclass_nms_out;
-}
-
-PDNode *patterns::FillConstantElementWiseMulFuse::operator()(
-    PDNode *elementwise_op_input) {
-  auto fill_constant =
-      pattern->NewNode(fill_constant_repr())->assert_is_op("fill_constant");
-
-  auto fill_constant_out = pattern->NewNode(fill_constant_out_repr())
-                               ->assert_is_op_output("fill_constant")
-                               ->assert_is_op_input("elementwise_mul", "Y")
-                               ->AsIntermediate();
-
-  auto elementwise_mul_op =
-      pattern->NewNode(elementwise_mul_repr())->assert_is_op("elementwise_mul");
-
-  auto elementwise_mul_out = pattern->NewNode(elementwise_mul_out_repr())
-                                 ->assert_is_op_output("elementwise_mul")
-                                 ->AsOutput();
-
-  fill_constant_out->LinksFrom({fill_constant});
-  elementwise_mul_op->LinksFrom({elementwise_op_input, fill_constant_out});
-  elementwise_mul_out->LinksFrom({elementwise_mul_op});
-  return elementwise_mul_out;
-}
-
 void patterns::QuantDequantOpFuse::operator()(PDNode *quant_op_input,
                                               const std::string &op_type,
                                               const std::string &weight_name,

paddle/fluid/framework/ir/graph_pattern_detector.h

@@ -1093,37 +1093,6 @@ struct TransposeFlattenConcat : public PatternBase {
   }
 };
 
-struct AnakinDetectionPattern : public PatternBase {
-  AnakinDetectionPattern(PDPattern* pattern, const std::string& name_scope)
-      : PatternBase(pattern, name_scope, "anakin_detect_pattern") {}
-
-  PDNode* operator()(std::vector<PDNode*> conv_inputs, int times,
-                     std::string priorbox_type, bool is_reshape);
-
-  std::string GetNodeName(const std::string& op_type) {
-    return PDNodeName(name_scope_, repr_, id_, op_type);
-  }
-
-  PDNode* GetPDNode(const std::string& op_type) {
-    return pattern->RetrieveNode(GetNodeName(op_type));
-  }
-};
-
-struct FillConstantElementWiseMulFuse : public PatternBase {
-  FillConstantElementWiseMulFuse(PDPattern* pattern,
-                                 const std::string& name_scope)
-      : PatternBase(pattern, name_scope,
-                    "anakin_fillconstant_elementwisemul_fuse") {}
-
-  PDNode* operator()(PDNode* elementwise_op_input);
-
-  // declare operator node's name
-  PATTERN_DECL_NODE(fill_constant);
-  PATTERN_DECL_NODE(fill_constant_out);
-  PATTERN_DECL_NODE(elementwise_mul);
-  PATTERN_DECL_NODE(elementwise_mul_out);
-};
-
 struct QuantDequantOpFuse : public PatternBase {
   QuantDequantOpFuse(PDPattern* pattern, const std::string& name_scope)
       : PatternBase(pattern, name_scope, "quant_dequant_fuse") {}

paddle/fluid/framework/ir/simplify_anakin_priorbox_detection_out_pass.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <string>
-#include <vector>
-
-#include "paddle/fluid/framework/ir/graph_viz_pass.h"
-#include "paddle/fluid/framework/ir/node.h"
-#include "paddle/fluid/framework/ir/simplify_anakin_priorbox_detection_out_pass.h"
-
-namespace paddle {
-namespace framework {
-namespace ir {
-
-void RunSimplifyAnakinDetection(ir::Graph *graph, int times, bool is_density,
-                                bool is_reshape) {
-  const std::string pattern_name =
-      "simplify_anakin_detection_pattern_pass" + std::to_string(times);
-  std::string priorbox_type = is_density ? "density_prior_box" : "prior_box";
-
-  GraphPatternDetector gpd;
-  std::vector<PDNode *> input_nodes;
-  for (int i = 0; i < times; i++) {
-    input_nodes.push_back(gpd.mutable_pattern()
-                              ->NewNode("x" + std::to_string(i))
-                              ->assert_is_op_input(priorbox_type, "Input")
-                              ->AsInput());
-  }
-  input_nodes.push_back(gpd.mutable_pattern()
-                            ->NewNode("x" + std::to_string(times))
-                            ->assert_is_op_input("box_coder", "TargetBox")
-                            ->AsInput());
-
-  input_nodes.push_back(gpd.mutable_pattern()
-                            ->NewNode("x" + std::to_string(times + 1))
-                            ->assert_is_op_input("transpose2")
-                            ->AsInput());
-
-  patterns::AnakinDetectionPattern pattern(gpd.mutable_pattern(), pattern_name);
-  pattern(input_nodes, times, priorbox_type, is_reshape);
-
-  auto handler = [&](const GraphPatternDetector::subgraph_t &subgraph,
-                     Graph *g) {
-    const int kNumFields = 7;
-    const int kPriorBoxLocOffset = 1;
-    const int kReshape1Offset = 2;
-    const int kReshape1OutOffset = 3;
-    const int kPriorBoxVarOffset = 4;
-    const int kReshape2Offset = 5;
-    const int kReshape2OutOffset = 6;
-    std::vector<Node *> nodes;
-
-    for (int i = 0; i < times; i++) {
-      PADDLE_ENFORCE(
-          subgraph.at(pattern.GetPDNode("prior_box" + std::to_string(i))));
-      PADDLE_ENFORCE(
-          subgraph.at(pattern.GetPDNode("box_out" + std::to_string(i))));
-      PADDLE_ENFORCE(
-          subgraph.at(pattern.GetPDNode("reshape1" + std::to_string(i))));
-      PADDLE_ENFORCE(
-          subgraph.at(pattern.GetPDNode("reshape1_out" + std::to_string(i))));
-      PADDLE_ENFORCE(
-          subgraph.at(pattern.GetPDNode("reshape2" + std::to_string(i))));
-      PADDLE_ENFORCE(
-          subgraph.at(pattern.GetPDNode("reshape2_out" + std::to_string(i))));
-
-      PADDLE_ENFORCE(
-          subgraph.at(pattern.GetPDNode("box_var_out" + std::to_string(i))));
-
-      nodes.push_back(
-          subgraph.at(pattern.GetPDNode("prior_box" + std::to_string(i))));
-      nodes.push_back(
-          subgraph.at(pattern.GetPDNode("box_out" + std::to_string(i))));
-      nodes.push_back(
-          subgraph.at(pattern.GetPDNode("reshape1" + std::to_string(i))));
-      nodes.push_back(
-          subgraph.at(pattern.GetPDNode("reshape1_out" + std::to_string(i))));
-      nodes.push_back(
-          subgraph.at(pattern.GetPDNode("box_var_out" + std::to_string(i))));
-      nodes.push_back(
-          subgraph.at(pattern.GetPDNode("reshape2" + std::to_string(i))));
-      nodes.push_back(
-          subgraph.at(pattern.GetPDNode("reshape2_out" + std::to_string(i))));
-    }
-
-    Node *concat_op1 = subgraph.at(pattern.GetPDNode("concat1"));
-    Node *concat_out1 = subgraph.at(pattern.GetPDNode("concat1_out"));
-
-    Node *concat_op2 = subgraph.at(pattern.GetPDNode("concat2"));
-    Node *concat_out2 = subgraph.at(pattern.GetPDNode("concat2_out"));
-
-    Node *box_coder_third_input = subgraph.at(input_nodes[times]);
-    Node *box_coder_op = subgraph.at(pattern.GetPDNode("box_coder"));
-    Node *box_coder_out = subgraph.at(pattern.GetPDNode("box_coder_out"));
-
-    Node *multiclass_nms_second_input = subgraph.at(input_nodes[times + 1]);
-    Node *transpose_before_nms =
-        subgraph.at(pattern.GetPDNode("transpose_before_nms"));
-    Node *transpose_before_nms_out =
-        subgraph.at(pattern.GetPDNode("transpose_before_nms_out"));
-
-    Node *multiclass_nms = subgraph.at(pattern.GetPDNode("multiclass_nms"));
-    Node *multiclass_nms_out =
-        subgraph.at(pattern.GetPDNode("multiclass_nms_out"));
-
-    std::string code_type =
-        boost::get<std::string>(box_coder_op->Op()->GetAttr("code_type"));
-    bool box_normalized =
-        boost::get<bool>(box_coder_op->Op()->GetAttr("box_normalized"));
-
-    int background_label =
-        boost::get<int>(multiclass_nms->Op()->GetAttr("background_label"));
-    float score_threshold =
-        boost::get<float>(multiclass_nms->Op()->GetAttr("score_threshold"));
-    int nms_top_k = boost::get<int>(multiclass_nms->Op()->GetAttr("nms_top_k"));
-    float nms_threshold =
-        boost::get<float>(multiclass_nms->Op()->GetAttr("nms_threshold"));
-    float nms_eta = boost::get<float>(multiclass_nms->Op()->GetAttr("nms_eta"));
-    int keep_top_k =
-        boost::get<int>(multiclass_nms->Op()->GetAttr("keep_top_k"));
-
-    std::vector<std::string> concat1_input_names;
-    for (int i = 0; i < times; i++) {
-      concat1_input_names.push_back(
-          nodes[i * kNumFields + kPriorBoxLocOffset]->Name());
-    }
-
-    framework::OpDesc concat1_desc;
-    concat1_desc.SetType("concat");
-    concat1_desc.SetInput("X", concat1_input_names);
-    concat1_desc.SetAttr("axis", 2);
-    concat1_desc.SetOutput("Out", {concat_out1->Name()});
-
-    auto *new_add_concat_op = graph->CreateOpNode(&concat1_desc);
-
-    for (int i = 0; i < times; i++) {
-      nodes[i * kNumFields + kPriorBoxLocOffset]->outputs.push_back(
-          new_add_concat_op);
-      new_add_concat_op->inputs.push_back(
-          nodes[i * kNumFields + kPriorBoxLocOffset]);
-    }
-
-    framework::OpDesc new_op_desc;
-    new_op_desc.SetType("detection_out");
-    new_op_desc.SetInput("PriorBox", {concat_out1->Name()});
-    new_op_desc.SetInput("TargetBox", {box_coder_third_input->Name()});
-    new_op_desc.SetInput("Scores", {multiclass_nms_second_input->Name()});
-    new_op_desc.SetAttr("code_type", code_type);
-    new_op_desc.SetAttr("box_normalized", box_normalized);
-    new_op_desc.SetAttr("background_label", background_label);
-    new_op_desc.SetAttr("score_threshold", score_threshold);
-    new_op_desc.SetAttr("nms_top_k", nms_top_k);
-    new_op_desc.SetAttr("nms_threshold", nms_threshold);
-    new_op_desc.SetAttr("nms_eta", nms_eta);
-    new_op_desc.SetAttr("keep_top_k", keep_top_k);
-    new_op_desc.SetOutput("Out", {multiclass_nms_out->Name()});
-    new_op_desc.Flush();
-
-    // Create a new node for the fused op.
-    auto *detection_out_op = graph->CreateOpNode(&new_op_desc);
-
-    std::unordered_set<const Node *> delete_nodes;
-
-    for (int i = 0; i < times; i++) {
-      nodes[i * kNumFields + kPriorBoxLocOffset]->outputs.push_back(concat_op1);
-      delete_nodes.insert(nodes[i * kNumFields + kReshape1Offset]);
-      delete_nodes.insert(nodes[i * kNumFields + kReshape1OutOffset]);
-      delete_nodes.insert(nodes[i * kNumFields + kPriorBoxVarOffset]);
-      delete_nodes.insert(nodes[i * kNumFields + kReshape2Offset]);
-      delete_nodes.insert(nodes[i * kNumFields + kReshape2OutOffset]);
-    }
-
-    delete_nodes.insert(concat_op1);
-    delete_nodes.insert(concat_op2);
-    delete_nodes.insert(concat_out2);
-    delete_nodes.insert(box_coder_op);
-    delete_nodes.insert(box_coder_out);
-    delete_nodes.insert(transpose_before_nms);
-    delete_nodes.insert(transpose_before_nms_out);
-    delete_nodes.insert(multiclass_nms);
-
-    new_add_concat_op->outputs.push_back(concat_out1);
-    concat_out1->inputs.push_back(new_add_concat_op);
-
-    detection_out_op->inputs.push_back(concat_out1);
-    detection_out_op->inputs.push_back(box_coder_third_input);
-    detection_out_op->inputs.push_back(multiclass_nms_second_input);
-    detection_out_op->outputs.push_back(multiclass_nms_out);
-
-    concat_out1->outputs.push_back(detection_out_op);
-    box_coder_third_input->outputs.push_back(detection_out_op);
-    multiclass_nms_second_input->outputs.push_back(detection_out_op);
-    multiclass_nms_out->inputs.push_back(detection_out_op);
-
-    // Delete the unneeded nodes.
-    GraphSafeRemoveNodes(graph, delete_nodes);
-  };
-
-  gpd(graph, handler);
-}
-
-void SimplifyAnakinDetectionPatternPass::ApplyImpl(ir::Graph *graph) const {
-  const int pattern_nums = 6;
-  const std::string pattern_name = "simplify_anakin_detection_pattern_pass";
-  FusePassBase::Init(pattern_name, graph);
-  std::vector<bool> options = {true, false};
-  for (const auto &is_density : options) {
-    for (const auto &is_reshape : options) {
-      for (int i = 1; i <= pattern_nums; i++) {
-        RunSimplifyAnakinDetection(graph, i, is_density, is_reshape);
-      }
-    }
-  }
-}
-
-}  // namespace ir
-}  // namespace framework
-}  // namespace paddle
-
-typedef paddle::framework::ir::SimplifyAnakinDetectionPatternPass
-    priorbox_pattern;
-REGISTER_PASS(simplify_anakin_priorbox_detection_out_pass, priorbox_pattern);

paddle/fluid/framework/ir/simplify_anakin_priorbox_detection_out_pass.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-#include <memory>
-#include <unordered_set>
-#include "paddle/fluid/framework/ir/fuse_pass_base.h"
-#include "paddle/fluid/framework/ir/graph_pattern_detector.h"
-
-namespace paddle {
-namespace framework {
-namespace ir {
-
-// There may be many transpose-flatten structures in a model, and the output of
-// these structures will be used as inputs to the concat Op. This pattern will
-// be detected by our pass. The times here represents the repeat times of this
-// structure.
-class SimplifyAnakinDetectionPatternPass : public FusePassBase {
- public:
-  virtual ~SimplifyAnakinDetectionPatternPass() {}
-
- protected:
-  void ApplyImpl(ir::Graph* graph) const override;
-};
-
-}  // namespace ir
-}  // namespace framework
-}  // namespace paddle

paddle/fluid/framework/ir/subgraph_detector.h

@@ -65,7 +65,7 @@ class SubGraphFuser {
   using NodeInsideSubgraphTeller = SubgraphDetector::NodeInsideSubgraphTeller;
 
   SubGraphFuser(Graph *graph, const NodeInsideSubgraphTeller &teller,
-                int min_subgraph_size, std::string name = "anakin_engine")
+                int min_subgraph_size, std::string name = "tensorrt_engine")
       : graph_(graph),
         node_inside_subgraph_teller_(teller),
         min_subgraph_size_{min_subgraph_size},

paddle/fluid/inference/CMakeLists.txt

@@ -30,10 +30,6 @@ if (TENSORRT_FOUND)
   add_subdirectory(tensorrt)
 endif()
 
-if (ANAKIN_SUBGRAPH)
-  add_subdirectory(anakin)
-endif()
-
 if (WITH_LITE)
   add_subdirectory(lite)
 endif()
@@ -68,9 +64,6 @@ if(NOT APPLE)
   set_target_properties(paddle_fluid PROPERTIES LINK_FLAGS "${LINK_FLAGS}")
 endif()
 
-if(ANAKIN_FOUND)
-    set(ANAKIN_SHARED_INFERENCE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/api/api_anakin_engine.cc)
-endif()
 set(SHARED_INFERENCE_SRCS
     io.cc
     ${CMAKE_CURRENT_SOURCE_DIR}/../framework/data_feed.cc
@@ -80,8 +73,7 @@ set(SHARED_INFERENCE_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/api/api_impl.cc
     ${CMAKE_CURRENT_SOURCE_DIR}/api/analysis_predictor.cc
     ${CMAKE_CURRENT_SOURCE_DIR}/api/details/zero_copy_tensor.cc
-    ${mkldnn_quantizer_src_file}
-    ${ANAKIN_SHARED_INFERENCE_SRCS})
+    ${mkldnn_quantizer_src_file})
 
 # Create shared inference library defaultly
 cc_library(paddle_fluid_shared SHARED SRCS ${SHARED_INFERENCE_SRCS}

paddle/fluid/inference/anakin/CMakeLists.txt

-cc_library(anakin_engine SRCS engine.cc DEPS framework_proto boost)
-cc_library(anakin_op_teller SRCS op_teller.cc DEPS framework_proto device_context boost)
-target_link_libraries(anakin_engine anakin anakin_saber_common)
-cc_test(test_anakin_engine SRCS test_anakin_engine.cc DEPS anakin_engine)
-add_subdirectory(convert)

paddle/fluid/inference/anakin/convert/CMakeLists.txt

-cc_library(anakin_op_converter SRCS fc.cc conv2d.cc conv2d_fusion.cc
-elementwise.cc activation.cc pool2d.cc concat.cc split.cc relu.cc softmax.cc
-batch_norm.cc reshape.cc flatten.cc transpose.cc density_prior_box.cc
-detection_out.cc scale.cc dropout.cc im2sequence.cc sum.cc affine_channel.cc
-roi_align.cc shuffle_channel.cc helper.cc DEPS anakin_engine framework_proto
-scope op_registry gtest gflags)
-
-cc_test(test_anakin_fc SRCS test_fc_op.cc DEPS anakin_op_converter mul_op)
-cc_test(test_anakin_conv2d SRCS test_conv2d_op.cc DEPS anakin_op_converter conv_op im2col vol2col depthwise_conv)
-cc_test(test_anakin_activation SRCS test_activation_op.cc DEPS activation_op anakin_op_converter)
-cc_test(test_anakin_pool2d SRCS test_pool2d_op.cc DEPS anakin_op_converter pool_op pooling)
-cc_test(test_anakin_concat SRCS test_concat_op.cc DEPS anakin_op_converter concat_op concat_and_split)
-cc_test(test_anakin_split SRCS test_split_op.cc DEPS anakin_op_converter split_op concat_and_split)
-cc_test(test_anakin_elementwise SRCS test_elementwise_op.cc DEPS anakin_op_converter elementwise_add_op elementwise_mul_op)
-cc_test(test_anakin_relu SRCS test_relu_op.cc DEPS activation_op anakin_op_converter)
-cc_test(test_anakin_softmax SRCS test_softmax_op.cc DEPS anakin_op_converter softmax_op softmax)
-cc_test(test_anakin_reshape SRCS test_reshape_op.cc DEPS anakin_op_converter reshape_op)
-cc_test(test_anakin_flatten SRCS test_flatten_op.cc DEPS anakin_op_converter flatten_op reshape_op)
-cc_test(test_anakin_transpose SRCS test_transpose_op.cc DEPS anakin_op_converter transpose_op)
-cc_test(test_anakin_batch_norm SRCS test_batch_norm_op.cc DEPS anakin_op_converter batch_norm_op)
-cc_test(test_anakin_dropout SRCS test_dropout_op.cc DEPS anakin_op_converter dropout_op)
-cc_test(test_anakin_sum SRCS test_sum_op.cc DEPS  anakin_op_converter sum_op selected_rows_functor)
-cc_test(test_anakin_affine_channel SRCS test_affine_channel_op.cc DEPS anakin_op_converter affine_channel_op)

paddle/fluid/inference/anakin/convert/activation.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/activation.h"
-#include <algorithm>
-#include <map>
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-ActivationOpConverter<TargetT, PrecisionT>::ActivationOpConverter(
-    const std::string &op_type)
-    : op_type_(op_type) {
-  auto it = anakin_op_types_.find(op_type_);
-  PADDLE_ENFORCE(it != anakin_op_types_.end(),
-                 "activation op type is not support");
-  anakin_op_type_ = it->second;
-}
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void ActivationOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-  auto input_name = op_desc.Input("X").front();
-  auto output_name = op_desc.Output("Out").front();
-  this->engine_->AddOp(op_name, "Activation", {input_name}, {output_name});
-  this->engine_->AddOpAttr(op_name, "type", anakin_op_type_);
-
-  if (op_type_ == "swish") {
-    float beta = boost::get<float>(op_desc.GetAttr("beta"));
-    this->engine_->AddOpAttr(op_name, "clip_relu_num", beta);
-  }
-  if (op_type_ == "relu6") {
-    float threshold = boost::get<float>(op_desc.GetAttr("threshold"));
-    this->engine_->AddOpAttr(op_name, "clip_relu_num", threshold);
-  }
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(sigmoid, SigmoidOpConverter);
-REGISTER_ANAKIN_OP_CONVERTER(tanh, TanhOpConverter);
-REGISTER_ANAKIN_OP_CONVERTER(swish, SwishOpConverter);
-REGISTER_ANAKIN_OP_CONVERTER(relu6, Relu6OpConverter);

paddle/fluid/inference/anakin/convert/activation.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <map>
-#include <string>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class ActivationOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  explicit ActivationOpConverter(const std::string &op_type);
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~ActivationOpConverter() {}
-
- private:
-  std::string op_type_;
-  std::string anakin_op_type_;
-  std::map<std::string, std::string> anakin_op_types_{{"tanh", "TanH"},
-                                                      {"sigmoid", "Sigmoid"},
-                                                      {"relu6", "ClippedRelu"},
-                                                      {"swish", "Swish"}};
-};
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class TanhOpConverter : public ActivationOpConverter<TargetT, PrecisionT> {
- public:
-  TanhOpConverter() : ActivationOpConverter<TargetT, PrecisionT>("tanh") {}
-};
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class SigmoidOpConverter : public ActivationOpConverter<TargetT, PrecisionT> {
- public:
-  SigmoidOpConverter()
-      : ActivationOpConverter<TargetT, PrecisionT>("sigmoid") {}
-};
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class Relu6OpConverter : public ActivationOpConverter<TargetT, PrecisionT> {
- public:
-  Relu6OpConverter() : ActivationOpConverter<TargetT, PrecisionT>("relu6") {}
-};
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class SwishOpConverter : public ActivationOpConverter<TargetT, PrecisionT> {
- public:
-  SwishOpConverter() : ActivationOpConverter<TargetT, PrecisionT>("swish") {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/affine_channel.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/affine_channel.h"
-#include <algorithm>
-#include <string>
-#include <vector>
-#include "paddle/fluid/inference/anakin/convert/helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void AffineChannelOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-  auto input_name = op_desc.Input("X").front();
-  auto output_name = op_desc.Output("Out").front();
-  this->engine_->AddOp(op_name, "AffineChannel", {input_name}, {output_name});
-
-  // Copy the Scale to CPUPlace and get the pointer.
-  auto *scale_v = scope.FindVar(op_desc.Input("Scale").front());
-  PADDLE_ENFORCE_NOT_NULL(scale_v);
-  auto weight1 = pblock_from_var<TargetT, PrecisionT>(*scale_v, this->engine_);
-  this->engine_->AddOpAttr(op_name, "weight_1", *weight1);
-
-  // Copy the Bias to CPUPlace and get the pointer.
-  auto *bias_v = scope.FindVar(op_desc.Input("Bias").front());
-  PADDLE_ENFORCE_NOT_NULL(bias_v);
-  auto weight2 = pblock_from_var<TargetT, PrecisionT>(*bias_v, this->engine_);
-  this->engine_->AddOpAttr(op_name, "weight_2", *weight2);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(affine_channel, AffineChannelOpConverter);

paddle/fluid/inference/anakin/convert/affine_channel.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <memory>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class AffineChannelOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  AffineChannelOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~AffineChannelOpConverter() {}
-
- private:
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/batch_norm.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/batch_norm.h"
-#include <math.h>
-#include <algorithm>
-#include <map>
-#include <string>
-#include <vector>
-#include "paddle/fluid/inference/anakin/convert/helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void BatchNormOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Y").size(), 1);
-  std::map<std::string, std::string> inputs;
-  for (auto k : {"X", "Scale", "Bias", "Mean", "Variance"}) {
-    PADDLE_ENFORCE_EQ(op_desc.Input(k).size(), 1UL);
-  }
-
-  auto input = op_desc.Input("X").front();
-  auto output = op_desc.Output("Y").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Y").front();
-  auto epsilon = boost::get<float>(op_desc.GetAttr("epsilon"));
-
-  auto bn_op_name = op_name + ":bn";
-  auto bn_output = bn_op_name + "_output";
-  this->engine_->AddOp(bn_op_name, "BatchNorm", {input}, {bn_output});
-  this->engine_->AddOpAttr(bn_op_name, "epsilon", epsilon);
-  this->engine_->AddOpAttr(bn_op_name, "momentum", static_cast<float>(1.0));
-
-  auto scale_op_name = op_name + ":scale";
-  this->engine_->AddOp(scale_op_name, "Scale", {bn_output}, {output});
-  this->engine_->AddOpAttr(scale_op_name, "axis", 1);
-  this->engine_->AddOpAttr(scale_op_name, "num_axes", 1);
-  this->engine_->AddOpAttr(scale_op_name, "bias_term", true);
-
-  auto *mean_v = scope.FindVar(op_desc.Input("Mean").front());
-  PADDLE_ENFORCE_NOT_NULL(mean_v);
-  auto weight1 = pblock_from_var<TargetT, PrecisionT>(*mean_v, this->engine_);
-  this->engine_->AddOpAttr(bn_op_name, "weight_1", *weight1);
-
-  auto *variance_v = scope.FindVar(op_desc.Input("Variance").front());
-  PADDLE_ENFORCE_NOT_NULL(variance_v);
-  auto weight2 =
-      pblock_from_var<TargetT, PrecisionT>(*variance_v, this->engine_);
-  this->engine_->AddOpAttr(bn_op_name, "weight_2", *weight2);
-
-  auto *weight3 = pblock_from_vector<TargetT, PrecisionT>(
-      std::vector<float>({1}), this->engine_);
-  this->engine_->AddOpAttr(bn_op_name, "weight_3", *weight3);
-
-  auto *scale_v = scope.FindVar(op_desc.Input("Scale").front());
-  PADDLE_ENFORCE_NOT_NULL(scale_v);
-  auto scale = pblock_from_var<TargetT, PrecisionT>(*scale_v, this->engine_);
-  this->engine_->AddOpAttr(scale_op_name, "weight_1", *scale);
-
-  auto *bias_v = scope.FindVar(op_desc.Input("Bias").front());
-  PADDLE_ENFORCE_NOT_NULL(bias_v);
-  auto bias = pblock_from_var<TargetT, PrecisionT>(*bias_v, this->engine_);
-  this->engine_->AddOpAttr(scale_op_name, "weight_2", *bias);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(batch_norm, BatchNormOpConverter);

paddle/fluid/inference/anakin/convert/batch_norm.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class BatchNormOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  BatchNormOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~BatchNormOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/concat.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/concat.h"
-#include <algorithm>
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void ConcatOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  int axis = boost::get<int>(op_desc.GetAttr("axis"));
-  auto input_names = op_desc.Input("X");
-
-  auto y_name = op_desc.Output("Out").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-
-  this->engine_->AddOp(op_name, "Concat", input_names, {y_name});
-  this->engine_->AddOpAttr(op_name, "axis", axis);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(concat, ConcatOpConverter);

paddle/fluid/inference/anakin/convert/concat.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class ConcatOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  ConcatOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~ConcatOpConverter() {}
-
- private:
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/conv2d.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/conv2d.h"
-#include <algorithm>
-#include <memory>
-#include <vector>
-#include "paddle/fluid/inference/anakin/convert/helper.h"
-
-using anakin::PTuple;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void Conv2dOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("Input").size(), 1UL);
-  PADDLE_ENFORCE_EQ(op_desc.Input("Filter").size(), 1UL);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Output").size(), 1UL);
-
-  auto input_name = op_desc.Input("Input").front();
-  auto output_name = op_desc.Output("Output").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Output").front();
-  this->engine_->AddOp(op_name, "Convolution", {input_name}, {output_name});
-
-  auto *filter_v = scope.FindVar(op_desc.Input("Filter").front());
-  PADDLE_ENFORCE_NOT_NULL(filter_v);
-  auto weight_tensor = tensor_from_var(*filter_v, platform::CPUPlace());
-  auto weight_shape = framework::vectorize<int>(weight_tensor->dims());
-
-  PADDLE_ENFORCE_EQ(weight_tensor->dims().size(), 4UL);
-
-  const int filter_h = weight_tensor->dims()[2];
-  const int filter_w = weight_tensor->dims()[3];
-
-  auto filter_num = weight_tensor->dims()[0];
-  this->engine_->template AddOpAttr<int>(op_name, "filter_num", filter_num);
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "kernel_size",
-                                                 {filter_h, filter_w});
-  auto strides = boost::get<std::vector<int>>(op_desc.GetAttr("strides"));
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "strides", strides);
-  auto paddings = boost::get<std::vector<int>>(op_desc.GetAttr("paddings"));
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "padding", paddings);
-  auto dilations = boost::get<std::vector<int>>(op_desc.GetAttr("dilations"));
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "dilation_rate",
-                                                 dilations);
-  const int groups = boost::get<int>(op_desc.GetAttr("groups"));
-  this->engine_->AddOpAttr(op_name, "group", groups);
-  this->engine_->AddOpAttr(op_name, "axis", 1);
-  this->engine_->AddOpAttr(op_name, "bias_term", false);
-
-  ::anakin::saber::Shape anakin_shape(weight_shape);
-  bool enable_int8 = boost::get<bool>(op_desc.HasAttr("enable_int8"));
-
-  if (enable_int8) {
-    const float int8_range = 127.;
-    float in_scale = boost::get<float>(op_desc.GetAttr("input_scale"));
-    auto weight_scale =
-        boost::get<std::vector<float>>(op_desc.GetAttr("weight_scale"));
-    PBlock<TargetT> *weight1 =
-        new PBlock<TargetT>(anakin_shape, ::anakin::AK_INT8);
-    this->engine_->RegistBlock(weight1);
-    float *weight_data = weight_tensor->data<float>();
-    std::vector<char> weight_int8;
-    int weight_num = weight_tensor->numel();
-    for (int i = 0; i < weight_tensor->numel(); i++) {
-      bool is_valid_int8 =
-          ((weight_data[i] >= -128) && (weight_data[i] <= 127));
-      PADDLE_ENFORCE(is_valid_int8,
-                     "We are in anakin subgraph int8 mode, the weight of conv "
-                     "should be in range [-128, 127]");
-      weight_int8.push_back(static_cast<char>(weight_data[i]));
-    }
-    memcpy(static_cast<void *>(weight1->h_tensor().mutable_data()),
-           static_cast<void *>(weight_int8.data()), sizeof(char) * weight_num);
-    weight1->d_tensor().set_shape(anakin_shape);
-    weight1->d_tensor().copy_from(weight1->h_tensor());
-    this->engine_->AddOpAttr(op_name, "weight_1", *weight1);
-    this->engine_->Graph()->SetOpPrec(op_name, ::anakin::AK_INT8);
-    this->engine_->Graph()->SetWeightsScale(
-        op_name, {weight_scale[0] / int8_range}, false);
-    this->engine_->AddTensorScale(input_name, in_scale / int8_range);
-  } else {
-    auto *weight1 = pblock_from_tensor<TargetT, PrecisionT>(
-        *weight_tensor, weight_shape, this->engine_);
-    this->engine_->AddOpAttr(op_name, "weight_1", *weight1);
-  }
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(conv2d, Conv2dOpConverter);

paddle/fluid/inference/anakin/convert/conv2d.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class Conv2dOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  Conv2dOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~Conv2dOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/conv2d_fusion.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/conv2d_fusion.h"
-#include <algorithm>
-#include <memory>
-#include <vector>
-#include "paddle/fluid/inference/anakin/convert/helper.h"
-
-using anakin::PTuple;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void Conv2dFusionOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("Input").size(), 1UL);
-  PADDLE_ENFORCE_EQ(op_desc.Input("Filter").size(), 1UL);
-  PADDLE_ENFORCE_EQ(op_desc.Input("Bias").size(), 1UL);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Output").size(), 1UL);
-
-  auto input_name = op_desc.Input("Input").front();
-  auto output_name = op_desc.Output("Output").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Output").front();
-  this->engine_->AddOp(op_name, "Convolution", {input_name}, {output_name});
-
-  auto *filter_v = scope.FindVar(op_desc.Input("Filter").front());
-  PADDLE_ENFORCE_NOT_NULL(filter_v);
-
-  auto weight_tensor = tensor_from_var(*filter_v, platform::CPUPlace());
-  auto weight_shape = framework::vectorize<int>(weight_tensor->dims());
-
-  auto *b_v = scope.FindVar(op_desc.Input("Bias").front());
-  PADDLE_ENFORCE_NOT_NULL(b_v);
-
-  PADDLE_ENFORCE_EQ(weight_tensor->dims().size(), 4UL);
-  const int filter_h = weight_tensor->dims()[2];
-  const int filter_w = weight_tensor->dims()[3];
-  auto filter_num = weight_tensor->dims()[0];
-  this->engine_->template AddOpAttr<int>(op_name, "filter_num", filter_num);
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "kernel_size",
-                                                 {filter_h, filter_w});
-  auto strides = boost::get<std::vector<int>>(op_desc.GetAttr("strides"));
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "strides", strides);
-  auto paddings = boost::get<std::vector<int>>(op_desc.GetAttr("paddings"));
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "padding", paddings);
-  auto dilations = boost::get<std::vector<int>>(op_desc.GetAttr("dilations"));
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "dilation_rate",
-                                                 dilations);
-  const int groups = boost::get<int>(op_desc.GetAttr("groups"));
-  this->engine_->AddOpAttr(op_name, "group", groups);
-  this->engine_->AddOpAttr(op_name, "axis", 1);
-  this->engine_->AddOpAttr(op_name, "bias_term", true);
-
-  ::anakin::saber::Shape anakin_shape(weight_shape);
-  bool enable_int8 = boost::get<bool>(op_desc.HasAttr("enable_int8"));
-  if (enable_int8) {
-    const float int8_range = 127.;
-    float in_scale = boost::get<float>(op_desc.GetAttr("input_scale"));
-    auto weight_scale =
-        boost::get<std::vector<float>>(op_desc.GetAttr("weight_scale"));
-    PBlock<TargetT> *weight1 =
-        new PBlock<TargetT>(anakin_shape, ::anakin::AK_INT8);
-    this->engine_->RegistBlock(weight1);
-    float *weight_data = weight_tensor->data<float>();
-    std::vector<char> weight_int8;
-    int weight_num = weight_tensor->numel();
-    for (int i = 0; i < weight_tensor->numel(); i++) {
-      bool is_valid_int8 =
-          ((weight_data[i] >= -128) && (weight_data[i] <= 127));
-      PADDLE_ENFORCE(is_valid_int8,
-                     "We are in anakin subgraph int8 mode, the weight of conv "
-                     "should be in range [-128, 127]");
-      weight_int8.push_back(static_cast<char>(weight_data[i]));
-    }
-    memcpy(static_cast<void *>(weight1->h_tensor().mutable_data()),
-           static_cast<void *>(weight_int8.data()), sizeof(char) * weight_num);
-    weight1->d_tensor().set_shape(anakin_shape);
-    weight1->d_tensor().copy_from(weight1->h_tensor());
-    this->engine_->AddOpAttr(op_name, "weight_1", *weight1);
-    this->engine_->Graph()->SetOpPrec(op_name, ::anakin::AK_INT8);
-    this->engine_->Graph()->SetWeightsScale(
-        op_name, {weight_scale[0] / int8_range}, false);
-    this->engine_->AddTensorScale(input_name, in_scale / int8_range);
-  } else {
-    auto weight_tensor = tensor_from_var(*filter_v, platform::CPUPlace());
-    auto weight_shape = framework::vectorize<int>(weight_tensor->dims());
-    auto *weight1 = pblock_from_tensor<TargetT, PrecisionT>(
-        *weight_tensor, weight_shape, this->engine_);
-    this->engine_->AddOpAttr(op_name, "weight_1", *weight1);
-    auto weight2 = pblock_from_var<TargetT, PrecisionT>(*b_v, this->engine_);
-    this->engine_->AddOpAttr(op_name, "weight_2", *weight2);
-  }
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(conv2d_fusion, Conv2dFusionOpConverter);

paddle/fluid/inference/anakin/convert/conv2d_fusion.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class Conv2dFusionOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  Conv2dFusionOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~Conv2dFusionOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/density_prior_box.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/density_prior_box.h"
-#include <algorithm>
-#include <map>
-#include <vector>
-
-using anakin::PTuple;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void DensityPriorBoxOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc& op, const framework::BlockDesc& block_desc,
-    const framework::Scope& scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  auto input_name = op_desc.Input("Input").front();
-  auto image_name = op_desc.Input("Image").front();
-  auto output_name = op_desc.Output("Boxes").front();
-  auto op_type = op_desc.Type();
-  auto op_name = op_type + ":" + op_desc.Output("Boxes").front();
-
-  // only for density_prior_box
-  std::vector<float> fixed_sizes = {};
-  std::vector<float> fixed_ratios = {};
-  std::vector<int> densities = {};
-
-  std::vector<float> min_sizes = {};
-  std::vector<float> max_sizes = {};
-  std::vector<float> aspect_ratios = {};
-  bool is_clip = false;
-  bool is_flip = false;
-
-  if (op_type == "density_prior_box") {
-    fixed_sizes =
-        boost::get<std::vector<float>>(op_desc.GetAttr("fixed_sizes"));
-    fixed_ratios =
-        boost::get<std::vector<float>>(op_desc.GetAttr("fixed_ratios"));
-    densities = boost::get<std::vector<int>>(op_desc.GetAttr("densities"));
-    is_clip = boost::get<bool>(op_desc.GetAttr("clip"));
-  } else if (op_type == "prior_box") {
-    min_sizes = boost::get<std::vector<float>>(op_desc.GetAttr("min_sizes"));
-    max_sizes = boost::get<std::vector<float>>(op_desc.GetAttr("max_sizes"));
-    aspect_ratios =
-        boost::get<std::vector<float>>(op_desc.GetAttr("aspect_ratios"));
-    is_clip = boost::get<bool>(op_desc.GetAttr("clip"));
-    is_flip = boost::get<bool>(op_desc.GetAttr("flip"));
-  }
-  std::vector<float> dens;
-  for (auto& ele : densities) {
-    dens.push_back(static_cast<float>(ele));
-  }
-
-  auto variances = boost::get<std::vector<float>>(op_desc.GetAttr("variances"));
-
-  // lack img_h, img_w
-  auto step_h = boost::get<float>(op_desc.GetAttr("step_h"));
-  auto step_w = boost::get<float>(op_desc.GetAttr("step_w"));
-  auto offset = boost::get<float>(op_desc.GetAttr("offset"));
-  PTuple<std::string> t_order;
-  t_order.push_back("MIN");
-  t_order.push_back("COM");
-  t_order.push_back("MAX");
-
-  std::vector<float> temp_v = {};
-
-  this->engine_->AddOp(op_name, "PriorBox", {input_name, image_name},
-                       {output_name});
-  this->engine_->template AddOpAttr<PTuple<float>>(op_name, "min_size",
-                                                   min_sizes);
-  this->engine_->template AddOpAttr<PTuple<float>>(op_name, "max_size",
-                                                   max_sizes);
-  this->engine_->template AddOpAttr<PTuple<float>>(op_name, "aspect_ratio",
-                                                   aspect_ratios);
-  this->engine_->template AddOpAttr<PTuple<float>>(op_name, "fixed_size",
-                                                   fixed_sizes);
-  this->engine_->template AddOpAttr<PTuple<float>>(op_name, "fixed_ratio",
-                                                   fixed_ratios);
-  this->engine_->template AddOpAttr<PTuple<float>>(op_name, "density", dens);
-  this->engine_->AddOpAttr(op_name, "is_flip", is_flip);
-  this->engine_->AddOpAttr(op_name, "is_clip", is_clip);
-  this->engine_->template AddOpAttr<PTuple<float>>(op_name, "variance",
-                                                   variances);
-  this->engine_->AddOpAttr(op_name, "img_h", static_cast<int>(0));
-  this->engine_->AddOpAttr(op_name, "img_w", static_cast<int>(0));
-  this->engine_->AddOpAttr(op_name, "step_h", step_h);
-  this->engine_->AddOpAttr(op_name, "step_w", step_w);
-  this->engine_->AddOpAttr(op_name, "offset", offset);
-  this->engine_->template AddOpAttr<PTuple<std::string>>(op_name, "order",
-                                                         t_order);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(density_prior_box, DensityPriorBoxOpConverter);
-REGISTER_ANAKIN_OP_CONVERTER(prior_box, DensityPriorBoxOpConverter);

paddle/fluid/inference/anakin/convert/density_prior_box.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <map>
-#include <string>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class DensityPriorBoxOpConverter
-    : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  DensityPriorBoxOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~DensityPriorBoxOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/detection_out.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/detection_out.h"
-#include <algorithm>
-#include <map>
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void DetectionOutOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  auto target_name = op_desc.Input("TargetBox").front();
-  auto prior_box_name = op_desc.Input("PriorBox").front();
-  auto scores_name = op_desc.Input("Scores").front();
-  auto output_name = op_desc.Output("Out").front();
-
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-
-  auto code_type = boost::get<std::string>(op_desc.GetAttr("code_type"));
-  auto background_label = boost::get<int>(op_desc.GetAttr("background_label"));
-  auto score_threshold = boost::get<float>(op_desc.GetAttr("score_threshold"));
-  auto nms_top_k = boost::get<int>(op_desc.GetAttr("nms_top_k"));
-  auto nms_threshold = boost::get<float>(op_desc.GetAttr("nms_threshold"));
-  auto nms_eta = boost::get<float>(op_desc.GetAttr("nms_eta"));
-  auto keep_top_k = boost::get<int>(op_desc.GetAttr("keep_top_k"));
-  std::string anakin_code_type;
-  if (code_type == "decode_center_size") {
-    anakin_code_type = "CENTER_SIZE";
-  } else if (code_type == "encode_center_size") {
-    PADDLE_THROW(
-        "Not support encode_center_size code_type in DetectionOut of anakin");
-  }
-
-  this->engine_->AddOp(op_name, "DetectionOutput",
-                       {target_name, scores_name, prior_box_name},
-                       {output_name});
-  this->engine_->AddOpAttr(op_name, "share_location", true);
-  this->engine_->AddOpAttr(op_name, "variance_encode_in_target", false);
-  this->engine_->AddOpAttr(op_name, "class_num", static_cast<int>(0));
-  this->engine_->AddOpAttr(op_name, "background_id", background_label);
-  this->engine_->AddOpAttr(op_name, "keep_top_k", keep_top_k);
-  this->engine_->AddOpAttr(op_name, "code_type", anakin_code_type);
-  this->engine_->AddOpAttr(op_name, "conf_thresh", score_threshold);
-  this->engine_->AddOpAttr(op_name, "nms_top_k", nms_top_k);
-  this->engine_->AddOpAttr(op_name, "nms_thresh", nms_threshold);
-  this->engine_->AddOpAttr(op_name, "nms_eta", nms_eta);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(detection_out, DetectionOutOpConverter);

paddle/fluid/inference/anakin/convert/detection_out.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <map>
-#include <string>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class DetectionOutOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  DetectionOutOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~DetectionOutOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/dropout.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/dropout.h"
-#include <algorithm>
-#include <string>
-#include <vector>
-#include "paddle/fluid/inference/anakin/convert/helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void DropoutOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Mask").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto x_name = op_desc.Input("X").front();
-  auto out_name = op_desc.Output("Out").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-
-  this->engine_->AddOp(op_name, "Scale", {x_name}, {out_name});
-
-  auto dropout_prob = boost::get<float>(op_desc.GetAttr("dropout_prob"));
-  auto factor = 1 - dropout_prob;
-  auto *weight1 = pblock_from_vector<TargetT, PrecisionT>(
-      std::vector<float>({factor}), this->engine_);
-
-  this->engine_->AddOpAttr(op_name, "weight_1", *weight1);
-  this->engine_->AddOpAttr(op_name, "axis", 0);
-  this->engine_->AddOpAttr(op_name, "num_axes", 0);
-  this->engine_->AddOpAttr(op_name, "bias_term", false);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(dropout, DropoutOpConverter);

paddle/fluid/inference/anakin/convert/dropout.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class DropoutOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  DropoutOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~DropoutOpConverter() {}
-
- private:
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/elementwise.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/elementwise.h"
-#include <algorithm>
-#include <string>
-#include <vector>
-
-using anakin::PTuple;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void ElementwiseAddOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Input("Y").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto x_name = op_desc.Input("X").front();
-  auto y_name = op_desc.Input("Y").front();
-  auto out_name = op_desc.Output("Out").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-
-  this->engine_->AddOp(op_name, "Eltwise", {x_name, y_name}, {out_name});
-  std::string elementwise_type = "Add";
-  this->engine_->template AddOpAttr<std::string>(op_name, "type",
-                                                 elementwise_type);
-  std::vector<float> coeff = {1.0, 1.0};
-  this->engine_->template AddOpAttr<PTuple<float>>(op_name, "coeff", coeff);
-}
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void ElementwiseMulOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Input("Y").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto x_name = op_desc.Input("X").front();
-  auto y_name = op_desc.Input("Y").front();
-  auto out_name = op_desc.Output("Out").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-
-  this->engine_->AddOp(op_name, "Eltwise", {x_name, y_name}, {out_name});
-  std::string elementwise_type = "Mul";
-  this->engine_->template AddOpAttr<std::string>(op_name, "type",
-                                                 elementwise_type);
-  std::vector<float> coeff = {1.0, 1.0};
-  this->engine_->template AddOpAttr<PTuple<float>>(op_name, "coeff", coeff);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(elementwise_add, ElementwiseAddOpConverter);
-REGISTER_ANAKIN_OP_CONVERTER(elementwise_mul, ElementwiseMulOpConverter);

paddle/fluid/inference/anakin/convert/elementwise.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class ElementwiseAddOpConverter
-    : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  ElementwiseAddOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~ElementwiseAddOpConverter() {}
-
- private:
-};
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class ElementwiseMulOpConverter
-    : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  ElementwiseMulOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~ElementwiseMulOpConverter() {}
-
- private:
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/fc.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/fc.h"
-#include <algorithm>
-#include <string>
-#include <vector>
-#include "paddle/fluid/inference/anakin/convert/helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void FcBaseOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  auto input_names = op_desc.InputNames();
-  bool with_bias = input_names.size() >= 3;
-
-  std::string w_name = "Y";
-  std::string i_name = "X";
-  if (with_bias) {
-    w_name = "W";
-    i_name = "Input";
-  }
-
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-
-  // get weights
-  auto *y_v = scope.FindVar(op_desc.Input(w_name).front());
-  PADDLE_ENFORCE_NOT_NULL(y_v);
-  auto weight_tensor = tensor_from_var(*y_v, platform::CPUPlace());
-  auto weight_shape = framework::vectorize<int>(weight_tensor->dims());
-
-  int out_dim = weight_shape[1];
-  const int w_m = weight_shape[0];
-  const int w_k = weight_shape[1];
-
-  auto input_name = op_desc.Input(i_name).front();
-  auto output_name = op_desc.Output("Out").front();
-
-  this->engine_->AddOp(op_name, "Dense", {input_name}, {output_name});
-  this->engine_->AddOpAttr(op_name, "bias_term", with_bias);
-  this->engine_->AddOpAttr(op_name, "axis", 1);
-  this->engine_->AddOpAttr(op_name, "out_dim", out_dim);
-
-  auto *weight_data = weight_tensor->data<float>();
-  PADDLE_ENFORCE(w_m * w_k == weight_tensor->numel());
-
-  std::vector<float> trans_weight_data(weight_tensor->numel());
-  for (int i = 0; i < w_m; i++) {
-    for (int j = 0; j < w_k; j++) {
-      trans_weight_data[i + j * w_m] = weight_data[i * w_k + j];
-    }
-  }
-
-  int weight_num = weight_tensor->numel();
-  bool enable_int8 = boost::get<bool>(op_desc.HasAttr("enable_int8"));
-  if (enable_int8) {
-    if (weight_shape.size() < 4UL) {
-      weight_shape.insert(weight_shape.begin(), 4UL - weight_shape.size(), 1);
-    }
-    ::anakin::saber::Shape anakin_shape(weight_shape);
-    const float int8_range = 127.;
-    float in_scale = boost::get<float>(op_desc.GetAttr("input_scale"));
-    auto weight_scale =
-        boost::get<std::vector<float>>(op_desc.GetAttr("weight_scale"));
-    PBlock<TargetT> *weight1 =
-        new PBlock<TargetT>(anakin_shape, ::anakin::AK_INT8);
-    this->engine_->RegistBlock(weight1);
-    std::vector<char> weight_int8;
-    for (int i = 0; i < weight_num; i++) {
-      bool is_valid_int8 =
-          ((trans_weight_data[i] >= -128) && (trans_weight_data[i] <= 127));
-      PADDLE_ENFORCE(is_valid_int8,
-                     "We are in anakin subgraph int8 mode, the weight of fc "
-                     "should be in range [-128, 127]");
-      weight_int8.push_back(static_cast<char>(trans_weight_data[i]));
-    }
-    memcpy(static_cast<void *>(weight1->h_tensor().mutable_data()),
-           static_cast<void *>(weight_int8.data()), sizeof(char) * weight_num);
-    weight1->d_tensor().set_shape(anakin_shape);
-    weight1->d_tensor().copy_from(weight1->h_tensor());
-    this->engine_->AddOpAttr(op_name, "weight_1", *weight1);
-    this->engine_->Graph()->SetOpPrec(op_name, ::anakin::AK_INT8);
-    this->engine_->Graph()->SetWeightsScale(
-        op_name, {weight_scale[0] / int8_range}, false);
-    this->engine_->AddTensorScale(input_name, in_scale / int8_range);
-  } else {
-    auto *weight1 = pblock_from_vector<TargetT, PrecisionT>(trans_weight_data,
-                                                            this->engine_);
-    this->engine_->AddOpAttr(op_name, "weight_1", *weight1);
-  }
-
-  // get bias
-  if (with_bias) {
-    auto *b_v = scope.FindVar(op_desc.Input("Bias").front());
-    PADDLE_ENFORCE_NOT_NULL(b_v);
-    auto weight2 = pblock_from_var<TargetT, PrecisionT>(*b_v, this->engine_);
-    this->engine_->AddOpAttr(op_name, "weight_2", *weight2);
-  }
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(mul, MulOpConverter);
-REGISTER_ANAKIN_OP_CONVERTER(fc, FcOpConverter);

paddle/fluid/inference/anakin/convert/fc.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class FcBaseOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  FcBaseOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~FcBaseOpConverter() {}
-};
-
-// with bias
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class FcOpConverter : public FcBaseOpConverter<TargetT, PrecisionT> {
- public:
-  FcOpConverter() = default;
-};
-
-// without bias
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class MulOpConverter : public FcBaseOpConverter<TargetT, PrecisionT> {
- public:
-  MulOpConverter() = default;
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/flatten.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/flatten.h"
-#include <vector>
-
-using anakin::PTuple;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void FlattenOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1UL);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1UL);
-
-  auto input = op_desc.Input("X").front();
-  auto output = op_desc.Output("Out").front();
-  int axis = boost::get<int>(op_desc.GetAttr("axis"));
-  PADDLE_ENFORCE(axis == 1,
-                 "the anakin flatten op converter now only support aixs == 1.");
-
-  std::vector<int> out_dims = {0, -1, 1, 1};
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-  this->engine_->AddOp(op_name, "Reshape", {input}, {output});
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "dims", out_dims);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(flatten, FlattenOpConverter);

paddle/fluid/inference/anakin/convert/flatten.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class FlattenOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  FlattenOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~FlattenOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/helper.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-std::unique_ptr<framework::LoDTensor> tensor_from_var(
-    const framework::Variable& var, const platform::Place& place) {
-  auto& src = var.Get<framework::LoDTensor>();
-  std::unique_ptr<framework::LoDTensor> dst(new framework::LoDTensor());
-  dst->Resize(src.dims());
-  TensorCopySync((src), place, dst.get());
-  return dst;
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/helper.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-#include <algorithm>
-#include <map>
-#include <memory>
-#include <vector>
-
-#include "paddle/fluid/framework/lod_tensor.h"
-#include "paddle/fluid/framework/variable.h"
-#include "paddle/fluid/inference/anakin/engine.h"
-
-#include "framework/core/net/net.h"
-#include "framework/core/types.h"
-#include "framework/graph/graph.h"
-#include "framework/graph/graph_global_mem.h"
-#include "saber/saber_types.h"
-
-using anakin::saber::Shape;
-using anakin::AK_FLOAT;
-using anakin::AK_INT8;
-using anakin::PBlock;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-std::unique_ptr<framework::LoDTensor> tensor_from_var(
-    const framework::Variable& var, const platform::Place& place);
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-PBlock<TargetT>* pblock_from_tensor(const framework::LoDTensor& tensor,
-                                    std::vector<int> shape_vec,
-                                    AnakinEngine<TargetT, PrecisionT>* engine) {
-  while (shape_vec.size() < 4) {
-    shape_vec.insert(shape_vec.begin(), 1);
-  }
-  Shape shape(shape_vec);
-  PBlock<TargetT>* weight = new PBlock<TargetT>(shape, AK_FLOAT);
-  engine->RegistBlock(weight);
-  float* cpu_data = static_cast<float*>(weight->h_tensor().mutable_data());
-  std::copy_n(tensor.data<float>(), tensor.numel(), cpu_data);
-  weight->d_tensor().set_shape(shape);
-  weight->d_tensor().copy_from(weight->h_tensor());
-  return weight;
-}
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-PBlock<TargetT>* pblock_from_vector(const std::vector<float>& vec,
-                                    std::vector<int> shape_vec,
-                                    AnakinEngine<TargetT, PrecisionT>* engine) {
-  while (shape_vec.size() < 4) {
-    shape_vec.insert(shape_vec.begin(), 1);
-  }
-  Shape shape(shape_vec);
-  PBlock<TargetT>* weight = new PBlock<TargetT>(shape, AK_FLOAT);
-  engine->RegistBlock(weight);
-  auto* weight_data = static_cast<float*>(weight->h_tensor().mutable_data());
-  std::copy(std::begin(vec), std::end(vec), weight_data);
-  weight->d_tensor().set_shape(shape);
-  weight->d_tensor().copy_from(weight->h_tensor());
-  return weight;
-}
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-PBlock<TargetT>* pblock_from_vector(const std::vector<float>& vec,
-                                    AnakinEngine<TargetT, PrecisionT>* engine) {
-  int size = vec.size();
-  return pblock_from_vector<TargetT, PrecisionT>(
-      vec, std::vector<int>({1, 1, 1, size}), engine);
-}
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-PBlock<TargetT>* pblock_from_var(const framework::Variable& var,
-                                 AnakinEngine<TargetT, PrecisionT>* engine) {
-  auto tensor = tensor_from_var(var, platform::CPUPlace());
-  auto shape = framework::vectorize<int>(tensor->dims());
-  return pblock_from_tensor<TargetT, PrecisionT>(*tensor, shape, engine);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/im2sequence.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/im2sequence.h"
-#include <algorithm>
-#include <string>
-#include <vector>
-
-using anakin::PTuple;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void Im2SequenceConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Y").size(), 0);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto x_name = op_desc.Input("X").front();
-  auto out_name = op_desc.Output("Out").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-
-  this->engine_->AddOp(op_name, "Im2Sequence", {x_name}, {out_name});
-
-  std::vector<int> dilations = {1, 1};
-  auto paddings = boost::get<std::vector<int>>(op_desc.GetAttr("paddings"));
-  auto strides = boost::get<std::vector<int>>(op_desc.GetAttr("strides"));
-  auto kernels = boost::get<std::vector<int>>(op_desc.GetAttr("kernels"));
-
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "paddings", paddings);
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "strides", strides);
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "window_size",
-                                                 kernels);
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "dilations",
-                                                 dilations);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(im2sequence, Im2SequenceConverter);

paddle/fluid/inference/anakin/convert/im2sequence.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class Im2SequenceConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  Im2SequenceConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~Im2SequenceConverter() {}
-
- private:
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/op_converter.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <map>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-#include "framework/core/types.h"
-#include "paddle/fluid/framework/block_desc.h"
-#include "paddle/fluid/framework/op_registry.h"
-#include "paddle/fluid/framework/scope.h"
-#include "paddle/fluid/inference/anakin/engine.h"
-#include "paddle/fluid/inference/utils/singleton.h"
-#include "saber/saber_types.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class AnakinOpConverter {
-  using AnakinEngineT = AnakinEngine<TargetT, PrecisionT>;
-
- public:
-  AnakinOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope, bool test_mode) {}
-  void ConvertOp(const framework::proto::OpDesc &op,
-                 const framework::BlockDesc &block_desc,
-                 const std::unordered_set<std::string> &parameters,
-                 const framework::Scope &scope, AnakinEngineT *engine,
-                 bool test_mode = false) {
-    framework::OpDesc op_desc(op, nullptr);
-    std::string op_type = op_desc.Type();
-    AnakinOpConverter *it = nullptr;
-    if (op_type == "depthwise_conv2d") op_type = "conv2d";
-    if (op_type == "reshape2") op_type = "reshape";
-    if (op_type == "transpose2") op_type = "transpose";
-    if (op_type == "flatten2") op_type = "flatten";
-
-    if (!it) {
-      it = Registry<AnakinOpConverter>::Global().Lookup(op_type);
-    }
-    PADDLE_ENFORCE_NOT_NULL(it, "no OpConverter for optype [%s]", op_type);
-    it->SetEngine(engine);
-    (*it)(op, block_desc, scope, test_mode);
-  }
-
-  void ConvertBlock(framework::BlockDesc *block_desc,
-                    const std::unordered_set<std::string> &parameters,
-                    const framework::Scope &scope, AnakinEngineT *engine) {
-    std::unique_lock<std::mutex> lock(mutex_);
-    framework::proto::BlockDesc *block = block_desc->Proto();
-    for (auto i = 0; i < block->ops_size(); i++) {
-      auto &op = block->ops(i);
-      ConvertOp(op, *block_desc, parameters, scope, engine);
-    }
-  }
-
-  // The scope  here should be inited with the parameter vars.
-  void ConvertBlockToAnakinEngine(
-      framework::BlockDesc *block_desc, framework::Scope *scope,
-      const std::vector<std::string> &inputs,
-      const std::unordered_set<std::string> &parameters,
-      const std::vector<std::string> &outputs, AnakinEngineT *engine) {
-    ConvertBlock(block_desc, parameters, *scope, engine);
-    // if the max_batch size
-    int max_batch_size = engine->GetMaxBatchSize();
-    PADDLE_ENFORCE(max_batch_size > 0,
-                   "the max_batch_size setted from config->EnableAnakinEngine "
-                   "must largger than 0");
-    // If the user does not specify this variable, we use the input shape from
-    // the block_desc.
-    auto max_input_shape = engine->GetMaxInputShape();
-    std::map<std::string, std::vector<int>> temp_max_input_shape;
-    // Register outputs with anakin using the RegistVar interface before Freeze.
-    // Note that RegistVar's parameters can only be outputs, not inputs.
-    for (auto &output : outputs) {
-      engine->Graph()->RegistVar(output);
-    }
-    engine->Freeze();
-    // Add scale for tensor in int8 mode.
-    auto tensor_scales = engine->GetTensorScales();
-
-    for (auto &item : tensor_scales) {
-      engine->Graph()->SetVarScale(item.first, item.second);
-    }
-
-    for (auto &input : inputs) {
-      if (parameters.count(input)) continue;
-      std::vector<int> input_shape;
-      input_shape.resize(4);
-      input_shape[0] = max_batch_size;
-      if (max_input_shape.count(input)) {
-        PADDLE_ENFORCE(max_input_shape[input].size() == 4,
-                       "the dimensions of max_input_shape setted from "
-                       "config->EnableAnakinEngine must be 4");
-        for (int i = 1; i < 4; i++) {
-          input_shape[i] = max_input_shape[input][i];
-        }
-      } else {
-        auto *var = block_desc->FindVar(input);
-        PADDLE_ENFORCE(var, "no variable called %s", input);
-
-        auto var_shape = var->GetShape();
-        std::cout << "input :" << input << std::endl;
-        PADDLE_ENFORCE(var_shape.size() == 4);
-
-        for (size_t i = 1; i < var_shape.size(); i++) {
-          input_shape[i] = var_shape[i];
-        }
-      }
-      temp_max_input_shape[input] = input_shape;
-      engine->SetInputShape(input, input_shape);
-    }
-    engine->SetMaxInputShape(temp_max_input_shape);
-    engine->Optimize();
-    engine->InitNet();
-  }
-
-  void SetEngine(AnakinEngineT *engine) { engine_ = engine; }
-  virtual ~AnakinOpConverter() {}
-
- protected:
-  bool test_mode_;
-  AnakinEngineT *engine_{nullptr};
-
- private:
-  std::unordered_map<std::string, AnakinOpConverter<TargetT, PrecisionT> *>
-      converters_;
-  framework::Scope *scope_{nullptr};
-  std::mutex mutex_;
-};
-
-template class AnakinOpConverter<::anakin::saber::NV,
-                                 ::anakin::Precision::FP32>;
-template class AnakinOpConverter<::anakin::saber::NV,
-                                 ::anakin::Precision::INT8>;
-#ifdef ANAKIN_X86_PLACE
-template class AnakinOpConverter<::anakin::saber::X86,
-                                 ::anakin::Precision::FP32>;
-template class AnakinOpConverter<::anakin::saber::X86,
-                                 ::anakin::Precision::INT8>;
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-#define REGISTER_ANAKIN_OP_CONVERTER_BASE(op_type__, Converter__,              \
-                                          place_type__, place_class__,         \
-                                          precision_type__, precision_class__) \
-  struct anakin_##op_type__##_##place_type__##_##precision_type__##_converter  \
-      : public ::paddle::framework::Registrar {                                \
-    anakin_##op_type__##_##place_type__##_##precision_type__##_converter() {   \
-      LOG(INFO) << "register convert " << #op_type__ << " ";                   \
-      ::paddle::inference::Registry<                                           \
-          ::paddle::inference::anakin::AnakinOpConverter<                      \
-              place_class__, precision_class__>>::Global()                     \
-          .Register<Converter__>(#op_type__);                                  \
-    }                                                                          \
-  };                                                                           \
-  anakin_##op_type__##_##place_type__##_##precision_type__##_converter         \
-      anakin_##op_type__##_##place_type__##_##precision_type__##_converter__;  \
-  int Touch_anakin_##op_type__##_##place_type__##_##precision_type__() {       \
-    anakin_##op_type__##_##place_type__##_##precision_type__##_converter__     \
-        .Touch();                                                              \
-    return 0;                                                                  \
-  }
-
-#define WRAP(...) __VA_ARGS__
-
-#define REGISTER_CUDA_ANAKIN_OP_CONVERTER(op_type__, Converter__,       \
-                                          precision_type__)             \
-  REGISTER_ANAKIN_OP_CONVERTER_BASE(                                    \
-      op_type__,                                                        \
-      ::paddle::inference::anakin::Converter__<WRAP(                    \
-          ::anakin::saber::NV, ::anakin::Precision::precision_type__)>, \
-      CUDA, ::anakin::saber::NV, precision_type__,                      \
-      ::anakin::Precision::precision_type__)
-
-#define REGISTER_CPU_ANAKIN_OP_CONVERTER(op_type__, Converter__,         \
-                                         precision_type__)               \
-  REGISTER_ANAKIN_OP_CONVERTER_BASE(                                     \
-      op_type__,                                                         \
-      ::paddle::inference::anakin::Converter__<WRAP(                     \
-          ::anakin::saber::X86, ::anakin::Precision::precision_type__)>, \
-      CPU, ::anakin::saber::X86, precision_type__,                       \
-      ::anakin::Precision::precision_type__)
-
-#if defined(PADDLE_WITH_CUDA) && defined(ANAKIN_X86_PLACE)
-#define REGISTER_ANAKIN_OP_CONVERTER(op_type__, Converter__)       \
-  REGISTER_CUDA_ANAKIN_OP_CONVERTER(op_type__, Converter__, FP32); \
-  REGISTER_CUDA_ANAKIN_OP_CONVERTER(op_type__, Converter__, INT8); \
-  REGISTER_CPU_ANAKIN_OP_CONVERTER(op_type__, Converter__, FP32);  \
-  REGISTER_CPU_ANAKIN_OP_CONVERTER(op_type__, Converter__, INT8)
-#elif defined(PADDLE_WITH_CUDA)
-#define REGISTER_ANAKIN_OP_CONVERTER(op_type__, Converter__)       \
-  REGISTER_CUDA_ANAKIN_OP_CONVERTER(op_type__, Converter__, FP32); \
-  REGISTER_CUDA_ANAKIN_OP_CONVERTER(op_type__, Converter__, INT8)
-#endif
-
-#define USE_ANAKIN_CONVERTER_BASE(op_type__, place_type__, precision_type__)   \
-  extern int Touch_anakin_##op_type__##_##place_type__##_##precision_type__(); \
-  int use_converter_anakin_##op_type__##_##place_type__##_##precision_type__   \
-      UNUSED =                                                                 \
-          Touch_anakin_##op_type__##_##place_type__##_##precision_type__();
-
-#if defined(PADDLE_WITH_CUDA) && defined(ANAKIN_X86_PLACE)
-#define USE_ANAKIN_CONVERTER(op_type__)            \
-  USE_ANAKIN_CONVERTER_BASE(op_type__, CUDA, FP32) \
-  USE_ANAKIN_CONVERTER_BASE(op_type__, CPU, FP32)
-#define USE_INT8_ANAKIN_CONVERTER(op_type__)       \
-  USE_ANAKIN_CONVERTER_BASE(op_type__, CUDA, INT8) \
-  USE_ANAKIN_CONVERTER_BASE(op_type__, CPU, INT8)
-#elif defined(PADDLE_WITH_CUDA)
-#define USE_ANAKIN_CONVERTER(op_type__) \
-  USE_ANAKIN_CONVERTER_BASE(op_type__, CUDA, FP32)
-#define USE_INT8_ANAKIN_CONVERTER(op_type__) \
-  USE_ANAKIN_CONVERTER_BASE(op_type__, CUDA, INT8)
-#endif

paddle/fluid/inference/anakin/convert/pool2d.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/pool2d.h"
-#include <algorithm>
-#include <string>
-#include <vector>
-
-using anakin::PTuple;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void Pool2dOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto x_name = op_desc.Input("X").front();
-  auto y_name = op_desc.Output("Out").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-
-  bool global_pooling = boost::get<bool>(op_desc.GetAttr("global_pooling"));
-  std::string pool_type =
-      boost::get<std::string>(op_desc.GetAttr("pooling_type"));
-  std::vector<int> ksize =
-      boost::get<std::vector<int>>(op_desc.GetAttr("ksize"));
-  std::vector<int> strides =
-      boost::get<std::vector<int>>(op_desc.GetAttr("strides"));
-  std::vector<int> paddings =
-      boost::get<std::vector<int>>(op_desc.GetAttr("paddings"));
-  bool ceil_mode = boost::get<bool>(op_desc.GetAttr("ceil_mode"));
-  std::string anakin_pool_type;
-  if (pool_type == "max") {
-    anakin_pool_type = "MAX";
-  } else if (pool_type == "avg") {
-    if (paddings[0] || paddings[1]) {
-      anakin_pool_type = "AVGEXC";
-    } else {
-      anakin_pool_type = "AVG";
-    }
-  } else {
-    PADDLE_THROW("TensorRT unsupported pooling type!");
-  }
-
-  this->engine_->AddOp(op_name, "Pooling", {x_name}, {y_name});
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "pool_size", ksize);
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "strides", strides);
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "padding", paddings);
-  this->engine_->AddOpAttr(op_name, "method", anakin_pool_type);
-  this->engine_->AddOpAttr(op_name, "global_pooling", global_pooling);
-  this->engine_->AddOpAttr(op_name, "cmp_out_shape_floor_as_conv", !ceil_mode);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(pool2d, Pool2dOpConverter);

paddle/fluid/inference/anakin/convert/pool2d.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class Pool2dOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  Pool2dOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~Pool2dOpConverter() {}
-
- private:
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/relu.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/relu.h"
-#include <algorithm>
-#include <map>
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void ReluOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-  auto input_name = op_desc.Input("X").front();
-  auto output_name = op_desc.Output("Out").front();
-
-  this->engine_->AddOp(op_name, "ReLU", {input_name}, {output_name});
-  this->engine_->AddOpAttr(op_name, "alpha", 0);
-}
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void LeakyReluOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-  auto input_name = op_desc.Input("X").front();
-  auto output_name = op_desc.Output("Out").front();
-
-  float alpha = boost::get<float>(op_desc.GetAttr("alpha"));
-  this->engine_->AddOp(op_name, "ReLU", {input_name}, {output_name});
-  this->engine_->AddOpAttr(op_name, "alpha", alpha);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(relu, ReluOpConverter);
-REGISTER_ANAKIN_OP_CONVERTER(leaky_relu, LeakyReluOpConverter);

paddle/fluid/inference/anakin/convert/relu.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <map>
-#include <string>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class ReluOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  ReluOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~ReluOpConverter() {}
-};
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class LeakyReluOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  LeakyReluOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~LeakyReluOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/reshape.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/reshape.h"
-#include <vector>
-
-using anakin::PTuple;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void ReshapeOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1UL);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1UL);
-
-  auto input = op_desc.Input("X").front();
-  auto output = op_desc.Output("Out").front();
-
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-  this->engine_->AddOp(op_name, "Reshape", {input}, {output});
-
-  auto shape = boost::get<std::vector<int>>(op_desc.GetAttr("shape"));
-  if (shape.size() < 4) {
-    shape.insert(shape.end(), 4 - shape.size(), 1);
-  }
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "dims", shape);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(reshape, ReshapeOpConverter);

paddle/fluid/inference/anakin/convert/reshape.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class ReshapeOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  ReshapeOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~ReshapeOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/roi_align.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/roi_align.h"
-#include <algorithm>
-#include <map>
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void RoiAlignOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Input("ROIs").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-  auto input_x_name = op_desc.Input("X").front();
-  auto input_rois_name = op_desc.Input("ROIs").front();
-  auto output_name = op_desc.Output("Out").front();
-
-  auto spatial_scale = boost::get<float>(op_desc.GetAttr("spatial_scale"));
-  auto pooled_height = boost::get<int>(op_desc.GetAttr("pooled_height"));
-  auto pooled_width = boost::get<int>(op_desc.GetAttr("pooled_width"));
-  auto sampling_ratio = boost::get<int>(op_desc.GetAttr("sampling_ratio"));
-
-  this->engine_->AddOp(op_name, "RoiAlign", {input_x_name, input_rois_name},
-                       {output_name});
-  this->engine_->AddOpAttr(op_name, "spatial_scale", spatial_scale);
-  this->engine_->AddOpAttr(op_name, "pooled_height", pooled_height);
-  this->engine_->AddOpAttr(op_name, "pooled_width", pooled_width);
-  this->engine_->AddOpAttr(op_name, "sampling_ratio", sampling_ratio);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(roi_align, RoiAlignOpConverter);

paddle/fluid/inference/anakin/convert/roi_align.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <map>
-#include <string>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class RoiAlignOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  RoiAlignOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~RoiAlignOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/scale.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/scale.h"
-#include <algorithm>
-#include <map>
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void ScaleOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-
-  auto input_name = op_desc.Input("X").front();
-  auto output_name = op_desc.Output("Out").front();
-  float scale = boost::get<float>(op_desc.GetAttr("scale"));
-  float bias = boost::get<float>(op_desc.GetAttr("bias"));
-  float bias_after_scale =
-      boost::get<bool>(op_desc.GetAttr("bias_after_scale"));
-  PADDLE_ENFORCE(bias_after_scale,
-                 "The anakin scale layer only support bias after scale now.");
-
-  this->engine_->AddOp(op_name, "Power", {input_name}, {output_name});
-  this->engine_->AddOpAttr(op_name, "shift", bias);
-  this->engine_->AddOpAttr(op_name, "scale", scale);
-  this->engine_->AddOpAttr(op_name, "power", static_cast<float>(1.0));
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(scale, ScaleOpConverter);

paddle/fluid/inference/anakin/convert/scale.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <map>
-#include <string>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class ScaleOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  ScaleOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~ScaleOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/shuffle_channel.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/shuffle_channel.h"
-#include <algorithm>
-#include <string>
-#include <vector>
-
-using anakin::PTuple;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void ShuffleChannelOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto input = op_desc.Input("X").front();
-  auto output = op_desc.Output("Out").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-  this->engine_->AddOp(op_name, "ShuffleChannel", {input}, {output});
-
-  auto group = boost::get<int>(op_desc.GetAttr("group"));
-  this->engine_->AddOpAttr(op_name, "group", group);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(shuffle_channel, ShuffleChannelOpConverter);

paddle/fluid/inference/anakin/convert/shuffle_channel.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class ShuffleChannelOpConverter
-    : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  ShuffleChannelOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~ShuffleChannelOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/softmax.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/softmax.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void SoftMaxOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1UL);
-
-  auto input = op_desc.Input("X").front();
-  auto output = op_desc.Output("Out").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-
-  auto input_var_desc = block_desc.FindVar(input);
-  PADDLE_ENFORCE(input_var_desc,
-                 "Cant find %s variable When runing Anakin Softmax converter.",
-                 input);
-  auto input_shape_in_fluid = input_var_desc->GetShape();
-  size_t input_dims = input_shape_in_fluid.size();
-
-  this->engine_->AddOp(op_name, "Softmax", {input}, {output});
-  this->engine_->AddOpAttr(op_name, "axis", static_cast<int>(input_dims - 1));
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(softmax, SoftMaxOpConverter);

paddle/fluid/inference/anakin/convert/softmax.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class SoftMaxOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  SoftMaxOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~SoftMaxOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/split.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/split.h"
-#include <algorithm>
-#include <vector>
-
-using anakin::PTuple;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void SplitOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  auto input_name = op_desc.Input("X").front();
-  auto y_names = op_desc.Output("Out");
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-  int axis = boost::get<int>(op_desc.GetAttr("axis"));
-
-  std::vector<int> output_lengths =
-      boost::get<std::vector<int>>(op_desc.GetAttr("sections"));
-
-  int split_num = output_lengths.size();
-  PADDLE_ENFORCE(split_num > 1,
-                 "anakin split op converter: the split num should > 1");
-  int num_sum = 0;
-  std::vector<int> slice_point;
-  for (int i = 0; i < split_num - 1; i++) {
-    num_sum += output_lengths[i];
-    slice_point.push_back(num_sum);
-  }
-  this->engine_->AddOp(op_name, "Slice", {input_name}, y_names);
-  this->engine_->AddOpAttr(op_name, "axis", axis);
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "slice_point",
-                                                 slice_point);
-  // slice_dim is useless in anakin
-  this->engine_->AddOpAttr(op_name, "slice_dim", 4);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(split, SplitOpConverter);

paddle/fluid/inference/anakin/convert/split.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class SplitOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  SplitOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~SplitOpConverter() {}
-
- private:
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/sum.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/sum.h"
-#include <algorithm>
-#include <string>
-#include <vector>
-
-using anakin::PTuple;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void SumOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 2);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto input_names = op_desc.Input("X");
-  auto out_name = op_desc.Output("Out").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-
-  std::vector<float> coeff = {1, 1};
-  std::string elementwise_type = "Add";
-  this->engine_->AddOp(op_name, "Eltwise", input_names, {out_name});
-  this->engine_->template AddOpAttr<PTuple<float>>(op_name, "coeff", coeff);
-  this->engine_->template AddOpAttr<std::string>(op_name, "type",
-                                                 elementwise_type);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(sum, SumOpConverter);

paddle/fluid/inference/anakin/convert/sum.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class SumOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  SumOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~SumOpConverter() {}
-
- private:
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/anakin/convert/test_activation_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/activation.h"
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-static void test_activation_op(const std::string& op_type,
-                               const platform::DeviceContext& context,
-                               bool use_gpu) {
-  std::unordered_set<std::string> parameters;
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  validator.DeclInputVar("act-X", {10, 6, 1, 1});
-  validator.DeclOutputVar("act-Out", {10, 6, 1, 1});
-  framework::OpDesc desc;
-  desc.SetType(op_type);
-  desc.SetInput("X", {"act-X"});
-  desc.SetOutput("Out", {"act-Out"});
-
-  if (op_type == "swish") {
-    desc.SetAttr("beta", 1.0f);
-  }
-
-  if (op_type == "relu6") {
-    desc.SetAttr("threshold", 6.0f);
-  }
-
-  LOG(INFO) << "set OP";
-  validator.SetOp(*desc.Proto());
-  LOG(INFO) << "execute";
-
-  validator.Execute(5);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(sigm_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_activation_op<::anakin::saber::NV>("sigmoid", ctx, true);
-}
-
-TEST(tanh_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_activation_op<::anakin::saber::NV>("tanh", ctx, true);
-}
-
-TEST(relu6_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_activation_op<::anakin::saber::NV>("relu6", ctx, true);
-}
-
-TEST(swish_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_activation_op<::anakin::saber::NV>("swish", ctx, true);
-}
-#endif
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(sigmoid);
-USE_OP(tanh);
-USE_OP(relu6);
-USE_OP(swish);
-
-USE_ANAKIN_CONVERTER(sigmoid);
-USE_ANAKIN_CONVERTER(tanh);
-USE_ANAKIN_CONVERTER(relu6);
-USE_ANAKIN_CONVERTER(swish);

paddle/fluid/inference/anakin/convert/test_affine_channel_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/affine_channel.h"
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-void test_affine_channel_op(const platform::DeviceContext& context,
-                            bool use_gpu) {
-  // Declare the difference between the inputs.
-  std::unordered_set<std::string> parameters({"scale", "bias"});
-
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  validator.DeclInputVar("x", {1, 3, 5, 2});
-  validator.DeclOutputVar("out", {1, 3, 5, 2});
-  validator.DeclParamVar("scale", {3});
-  validator.DeclParamVar("bias", {3});
-
-  // Prepare Op descriptions.
-  framework::OpDesc desc;
-  desc.SetType("affine_channel");
-  desc.SetInput("X", {"x"});
-  desc.SetInput("Bias", {"bias"});
-  desc.SetInput("Scale", {"scale"});
-  desc.SetOutput("Out", {"out"});
-
-  // Layout must be explicitly specified here as NCHW.
-  desc.SetAttr("data_layout", std::string("NCHW"));
-
-  validator.SetOp(*desc.Proto());
-  validator.Execute(1);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(affine_channel_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_affine_channel_op<::anakin::saber::NV>(ctx, true);
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(affine_channel_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_affine_channel_op<::anakin::saber::X86>(ctx, false);
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(affine_channel);
-USE_ANAKIN_CONVERTER(affine_channel);

paddle/fluid/inference/anakin/convert/test_batch_norm_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-void test_batchnorm_op(const platform::DeviceContext& context, bool use_gpu) {
-  std::unordered_set<std::string> parameters(
-      {"batch_norm_scale", "batch_norm_bias", "batch_norm_mean",
-       "batch_norm_variance"});
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  std::vector<int> param_shape{2};
-
-  validator.DeclInputVar("batch_norm_X", {1, 2, 5, 5});
-  validator.DeclParamVar("batch_norm_scale", param_shape);
-  validator.DeclParamVar("batch_norm_bias", param_shape);
-  validator.DeclParamVar("batch_norm_mean", param_shape);
-  validator.DeclParamVar("batch_norm_variance", param_shape);
-  validator.DeclOutputVar("batch_norm_Y", {1, 2, 5, 5});
-  validator.DeclOutputVar("batch_norm_save_mean", param_shape);
-  validator.DeclOutputVar("batch_norm_save_variance", param_shape);
-
-  // Prepare Op description
-  framework::OpDesc desc;
-
-  desc.SetType("batch_norm");
-  desc.SetInput("X", {"batch_norm_X"});
-  desc.SetInput("Scale", {"batch_norm_scale"});
-  desc.SetInput("Bias", {"batch_norm_bias"});
-  desc.SetInput("Mean", {"batch_norm_mean"});
-  desc.SetInput("Variance", {"batch_norm_variance"});
-  desc.SetOutput("Y", {"batch_norm_Y"});
-  desc.SetOutput("MeanOut", {"batch_norm_mean"});
-  desc.SetOutput("VarianceOut", {"batch_norm_variance"});
-  desc.SetOutput("SavedMean", {"batch_norm_save_mean"});
-  desc.SetOutput("SavedVariance", {"batch_norm_save_variance"});
-
-  float eps = 1e-5f;
-  bool is_test = true;
-  desc.SetAttr("epsilon", eps);
-  desc.SetAttr("is_test", is_test);
-
-  validator.SetOp(*desc.Proto());
-
-  std::unordered_set<std::string> neglected_output = {
-      "batch_norm_save_mean", "batch_norm_save_variance", "batch_norm_mean",
-      "batch_norm_variance"};
-  validator.Execute(1, neglected_output);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(batch_norm_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_batchnorm_op<::anakin::saber::NV>(ctx, true);
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(batch_norm_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_batchnorm_op<::anakin::saber::X86>(ctx, false);
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-USE_OP(batch_norm);
-USE_ANAKIN_CONVERTER(batch_norm);

paddle/fluid/inference/anakin/convert/test_concat_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/concat.h"
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-void test_concat_op(const platform::DeviceContext& context, bool use_gpu) {
-  std::unordered_set<std::string> parameters({""});
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  validator.DeclInputVar("concat_x1", {1, 2, 1, 1});
-  validator.DeclInputVar("concat_x2", {1, 3, 1, 1});
-  validator.DeclInputVar("concat_x3", {1, 1, 1, 1});
-  validator.DeclOutputVar("concat_out", {1, 6, 1, 1});
-
-  // Prepare Op description
-  framework::OpDesc desc;
-  desc.SetType("concat");
-  desc.SetInput("X", {"concat_x1", "concat_x2", "concat_x3"});
-  desc.SetOutput("Out", {"concat_out"});
-
-  int axis = 1;
-  desc.SetAttr("axis", axis);
-
-  validator.SetOp(*desc.Proto());
-
-  validator.Execute(1);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(concat_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_concat_op<::anakin::saber::NV>(ctx, true);
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(concat_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_concat_op<::anakin::saber::X86>(ctx, false);
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-USE_OP(concat);
-USE_ANAKIN_CONVERTER(concat);

paddle/fluid/inference/anakin/convert/test_conv2d_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/conv2d.h"
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-void test_conv2d_op(const platform::DeviceContext& context, bool use_gpu) {
-  std::unordered_set<std::string> parameters({"conv2d-Y"});
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  validator.DeclInputVar("conv2d-X", {1, 3, 3, 3});
-  validator.DeclParamVar("conv2d-Y", {4, 3, 1, 1});
-  validator.DeclOutputVar("conv2d-Out", {1, 4, 3, 3});
-
-  // Prepare Op description
-  framework::OpDesc desc;
-  desc.SetType("conv2d");
-  desc.SetInput("Input", {"conv2d-X"});
-  desc.SetInput("Filter", {"conv2d-Y"});
-  desc.SetOutput("Output", {"conv2d-Out"});
-
-  const std::vector<int> strides({1, 1});
-  const std::vector<int> paddings({0, 0});
-  const std::vector<int> dilations({1, 1});
-  const int groups = 1;
-
-  desc.SetAttr("strides", strides);
-  desc.SetAttr("paddings", paddings);
-  desc.SetAttr("dilations", dilations);
-  desc.SetAttr("groups", groups);
-
-  validator.SetOp(*desc.Proto());
-
-  validator.Execute(3);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(conv2d_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_conv2d_op<::anakin::saber::NV>(ctx, true);
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(conv2d_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_conv2d_op<::anakin::saber::X86>(ctx, false);
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(conv2d);
-USE_ANAKIN_CONVERTER(conv2d);

paddle/fluid/inference/anakin/convert/test_dropout_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/dropout.h"
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-void test_dropout_op(const platform::DeviceContext& context, bool use_gpu) {
-  std::unordered_set<std::string> parameters;
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  validator.DeclInputVar("x", {1, 1, 2, 2});
-  validator.DeclOutputVar("out", {1, 1, 2, 2});
-  validator.DeclOutputVar("mask", {1, 1, 2, 2});
-
-  // Prepare Op description
-  framework::OpDesc desc;
-  desc.SetType("dropout");
-  desc.SetInput("X", {"x"});
-  desc.SetOutput("Out", {"out"});
-  desc.SetOutput("Mask", {"mask"});
-
-  float dropout_prob = 0.5;
-  desc.SetAttr("dropout_prob", dropout_prob);
-  desc.SetAttr("is_test", true);
-
-  validator.SetOp(*desc.Proto());
-  std::unordered_set<std::string> neglected_output = {"mask"};
-  validator.Execute(1, neglected_output);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(dropout_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_dropout_op<::anakin::saber::NV>(ctx, true);
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(dropout_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_dropout_op<::anakin::saber::X86>(ctx, false);
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(dropout);
-USE_ANAKIN_CONVERTER(dropout);

paddle/fluid/inference/anakin/convert/test_elementwise_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/elementwise.h"
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-static void test_elementwise_op(const std::string& op_type,
-                                const platform::DeviceContext& context,
-                                bool use_gpu) {
-  std::unordered_set<std::string> parameters;
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  validator.DeclInputVar("x", {1, 1, 2, 2});
-  validator.DeclInputVar("y", {1, 1, 2, 2});
-  validator.DeclOutputVar("out", {1, 1, 2, 2});
-
-  // Prepare Op description
-  framework::OpDesc desc;
-  desc.SetType(op_type);
-  desc.SetInput("X", {"x"});
-  desc.SetInput("Y", {"y"});
-  desc.SetOutput("Out", {"out"});
-
-  int axis = -1;
-  desc.SetAttr("axis", axis);
-
-  validator.SetOp(*desc.Proto());
-  validator.Execute(1);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(elementwise_op, native_add_gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_elementwise_op<::anakin::saber::NV>("elementwise_add", ctx, true);
-}
-TEST(elementwise_op, native_mul_gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_elementwise_op<::anakin::saber::NV>("elementwise_mul", ctx, true);
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(elementwise_op, native_add_cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_elementwise_op<::anakin::saber::X86>("elementwise_add", ctx, false);
-}
-TEST(elementwise_op, native_mul_cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_elementwise_op<::anakin::saber::X86>("elementwise_mul", ctx, false);
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(elementwise_add);
-USE_OP(elementwise_mul);
-USE_ANAKIN_CONVERTER(elementwise_add);
-USE_ANAKIN_CONVERTER(elementwise_mul);

paddle/fluid/inference/anakin/convert/test_fc_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-void test_mul_op(const platform::DeviceContext& context, bool use_gpu) {
-  std::unordered_set<std::string> parameters({"mul_y"});
-  framework::Scope scope;
-
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  validator.DeclInputVar("mul_x", {1, 1, 2, 2});
-  validator.DeclParamVar("mul_y", {4, 2});
-  validator.DeclOutputVar("mul_out", {1, 2});
-
-  // Prepare Op description
-  framework::OpDesc desc;
-  desc.SetType("mul");
-  desc.SetInput("X", {"mul_x"});
-  desc.SetInput("Y", {"mul_y"});
-  desc.SetOutput("Out", {"mul_out"});
-  validator.SetOp(*desc.Proto());
-
-  validator.Execute(10);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(mul_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_mul_op<::anakin::saber::NV>(ctx, true);
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(mul_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_mul_op<::anakin::saber::X86>(ctx, false);
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(mul);
-USE_ANAKIN_CONVERTER(fc);

paddle/fluid/inference/anakin/convert/test_flatten_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-void test_flatten_op(const platform::DeviceContext& context, bool use_gpu) {
-  std::unordered_set<std::string> parameters;
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  validator.DeclInputVar("flatten-X", {3, 10, 10, 4});
-  validator.DeclOutputVar("flatten-Out", {3, 400, 1, 1});
-  framework::OpDesc desc;
-  desc.SetType("flatten");
-  desc.SetInput("X", {"flatten-X"});
-  desc.SetOutput("Out", {"flatten-Out"});
-  desc.SetAttr("axis", 1);
-
-  LOG(INFO) << "set OP";
-  validator.SetOp(*desc.Proto());
-  LOG(INFO) << "execute";
-
-  validator.Execute(5);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(flatten_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_flatten_op<::anakin::saber::NV>(ctx, true);
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(flatten_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_flatten_op<::anakin::saber::X86>(ctx, false);
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(reshape);
-USE_OP_ITSELF(flatten);
-USE_ANAKIN_CONVERTER(flatten);

paddle/fluid/inference/anakin/convert/test_im2sequence_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/im2sequence.h"
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-TEST(im2sequence_op, native) {
-  std::unordered_set<std::string> parameters;
-  framework::Scope scope;
-  AnakinConvertValidation validator(parameters, &scope);
-
-  std::vector<int> kernels = {6, 1};
-  std::vector<int> strides = {1, 1};
-  std::vector<int> paddings = {0, 0, 0, 0};
-
-  validator.DeclInputVar("x", {1, 1, 2, 2});
-  validator.DeclOutputVar("out", {1, 1 * kernels[0] * kernels[1]});
-
-  // Prepare Op description
-  framework::OpDesc desc;
-  desc.SetType("im2sequence");
-  desc.SetInput("X", {"x"});
-  desc.SetOutput("Out", {"out"});
-
-  desc.SetAttr("kernels", kernels);
-  desc.SetAttr("strides", strides);
-  desc.SetAttr("paddings", paddings);
-
-  validator.SetOp(*desc.Proto());
-  validator.Execute(1);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(im2sequence);
-USE_ANAKIN_CONVERTER(im2sequence);

paddle/fluid/inference/anakin/convert/test_pool2d_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-   http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License. */
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-void test_pool2d(const platform::DeviceContext& context, bool use_gpu,
-                 bool global_pooling, bool ceil_mode,
-                 std::string pool_type = "max") {
-  framework::Scope scope;
-  std::unordered_set<std::string> parameters;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-
-  // The ITensor's Dims should not contain the batch size.
-  // So, the ITensor's Dims of input and output should be C * H * W.
-  validator.DeclInputVar("pool2d_x", {1, 3, 6, 7});
-  if (global_pooling)
-    validator.DeclOutputVar("pool2d_out", {1, 3, 1, 1});
-  else if (ceil_mode)
-    validator.DeclOutputVar("pool2d_out", {1, 3, 3, 4});
-  else
-    validator.DeclOutputVar("pool2d_out", {1, 3, 3, 3});
-
-  // Prepare Op description
-  framework::OpDesc desc;
-  desc.SetType("pool2d");
-  desc.SetInput("X", {"pool2d_x"});
-  desc.SetOutput("Out", {"pool2d_out"});
-
-  std::vector<int> ksize({2, 2});
-  std::vector<int> strides({2, 2});
-  std::vector<int> paddings({0, 0});
-  std::string pooling_t = pool_type;
-
-  desc.SetAttr("pooling_type", pooling_t);
-  desc.SetAttr("ksize", ksize);
-  desc.SetAttr("strides", strides);
-  desc.SetAttr("paddings", paddings);
-  desc.SetAttr("global_pooling", global_pooling);
-  desc.SetAttr("ceil_mode", ceil_mode);
-
-  LOG(INFO) << "set OP";
-  validator.SetOp(*desc.Proto());
-  LOG(INFO) << "execute";
-
-  validator.Execute(1);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(Pool2dOpConverter, normal) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_pool2d<::anakin::saber::NV>(ctx, true, false, false);
-}
-TEST(Pool2dOpConverter, test_global_pooling) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_pool2d<::anakin::saber::NV>(ctx, true, true, false);
-}
-
-TEST(Pool2dOpConverter, max_ceil_test) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_pool2d<::anakin::saber::NV>(ctx, true, false, true);
-}
-
-TEST(Pool2dOpConverter, avg_ceil_test) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_pool2d<::anakin::saber::NV>(ctx, true, false, true, "avg");
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(Pool2dOpConverter, normal_cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_pool2d<::anakin::saber::X86>(ctx, false, false, false);
-}
-TEST(Pool2dOpConverter, test_global_pooling_cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_pool2d<::anakin::saber::X86>(ctx, false, true, false);
-}
-
-TEST(Pool2dOpConverter, max_ceil_test_cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_pool2d<::anakin::saber::X86>(ctx, false, false, true);
-}
-
-TEST(Pool2dOpConverter, avg_ceil_test_cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_pool2d<::anakin::saber::X86>(ctx, false, false, true, "avg");
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(pool2d);
-USE_ANAKIN_CONVERTER(pool2d);

paddle/fluid/inference/anakin/convert/test_relu_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/relu.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-static void test_activation_op(const std::string& op_type,
-                               const platform::DeviceContext& context,
-                               bool use_gpu) {
-  std::unordered_set<std::string> parameters;
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  validator.DeclInputVar("act-X", {10, 6, 1, 1});
-  validator.DeclOutputVar("act-Out", {10, 6, 1, 1});
-  framework::OpDesc desc;
-  desc.SetType(op_type);
-  desc.SetInput("X", {"act-X"});
-  desc.SetOutput("Out", {"act-Out"});
-  if (op_type == "leaky_relu") {
-    desc.SetAttr("alpha", 0.1f);
-  }
-
-  LOG(INFO) << "set OP";
-  validator.SetOp(*desc.Proto());
-  LOG(INFO) << "execute";
-
-  validator.Execute(5);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(relu_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_activation_op<::anakin::saber::NV>("relu", ctx, true);
-}
-
-TEST(leaky_relu_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_activation_op<::anakin::saber::NV>("leaky_relu", ctx, true);
-}
-#endif
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(relu);
-USE_OP(leaky_relu);
-USE_ANAKIN_CONVERTER(relu);
-USE_ANAKIN_CONVERTER(leaky_relu);

paddle/fluid/inference/anakin/convert/test_reshape_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-void test_reshape1_op(const platform::DeviceContext& context, bool use_gpu) {
-  framework::Scope scope;
-  std::unordered_set<std::string> parameters;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-
-  // validator.DeclInputVar("reshape-X", {2, 3, 3, 1});
-  // validator.DeclOutputVar("reshape-Out", {3, 2, 1, 3});
-  validator.DeclInputVar("reshape-X", {1, 2, 4, 1});
-  validator.DeclOutputVar("reshape-Out", {1, 8, 1, 1});
-
-  framework::OpDesc desc;
-  desc.SetType("reshape");
-  desc.SetInput("X", {"reshape-X"});
-  desc.SetOutput("Out", {"reshape-Out"});
-  // desc.SetAttr("shape", std::vector<int>({3, 2, 1, 3}));
-  desc.SetAttr("shape", std::vector<int>({1, 8, 1, 1}));
-
-  LOG(INFO) << "set OP";
-  validator.SetOp(*desc.Proto());
-  LOG(INFO) << "execute";
-  validator.Execute(1);
-}
-
-template <typename TargetT>
-void test_reshape2_op(const platform::DeviceContext& context, bool use_gpu) {
-  framework::Scope scope;
-  std::unordered_set<std::string> parameters;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-
-  validator.DeclInputVar("reshape-X", {1, 2, 4});
-  validator.DeclOutputVar("reshape-Out", {1, 4, 2});
-
-  framework::OpDesc desc;
-  desc.SetType("reshape");
-  desc.SetInput("X", {"reshape-X"});
-  desc.SetOutput("Out", {"reshape-Out"});
-  // desc.SetAttr("shape", std::vector<int>({3, 2, 1, 3}));
-  desc.SetAttr("shape", std::vector<int>({0, -1, 2}));
-
-  LOG(INFO) << "set OP";
-  validator.SetOp(*desc.Proto());
-  LOG(INFO) << "execute";
-  validator.Execute(1);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(reshape1_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_reshape1_op<::anakin::saber::NV>(ctx, true);
-}
-
-TEST(reshape2_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_reshape2_op<::anakin::saber::NV>(ctx, true);
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(reshape1_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_reshape2_op<::anakin::saber::X86>(ctx, false);
-}
-
-TEST(reshape2_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_reshape2_op<::anakin::saber::X86>(ctx, false);
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(reshape);
-USE_ANAKIN_CONVERTER(reshape);

paddle/fluid/inference/anakin/convert/test_softmax_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-void test_softmax_op(const platform::DeviceContext& context, bool use_gpu) {
-  framework::Scope scope;
-  std::unordered_set<std::string> parameters;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-
-  validator.DeclInputVar("softmax-X", {1, 10, 2});
-  validator.DeclOutputVar("softmax-Out", {1, 10, 2});
-
-  framework::OpDesc desc;
-  desc.SetType("softmax");
-  desc.SetInput("X", {"softmax-X"});
-  desc.SetOutput("Out", {"softmax-Out"});
-
-  LOG(INFO) << "set OP";
-  validator.SetOp(*desc.Proto());
-  LOG(INFO) << "execute";
-  validator.Execute(1);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(softmax_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_softmax_op<::anakin::saber::NV>(ctx, true);
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(relu_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_softmax_op<::anakin::saber::X86>(ctx, false);
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(softmax);
-USE_ANAKIN_CONVERTER(softmax);

paddle/fluid/inference/anakin/convert/test_split_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/split.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, int Axis>
-void AnakinSliceTest(const platform::DeviceContext &context, bool use_gpu,
-                     const std::vector<int> &in_shape,
-                     const std::vector<int> &sections) {
-  std::unordered_set<std::string> parameters({""});
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-
-  validator.DeclInputVar("split_input", in_shape);
-  std::vector<std::string> output_vars;
-  for (size_t i = 0; i < sections.size(); ++i) {
-    auto out_shape = in_shape;
-    out_shape[Axis] = sections[i];
-    std::string output_name = "split_out" + std::to_string(i);
-    validator.DeclOutputVar(output_name, out_shape);
-    output_vars.push_back(output_name);
-  }
-
-  // Prepare Op description
-  framework::OpDesc desc;
-  desc.SetType("split");
-  desc.SetInput("X", {"split_input"});
-  desc.SetOutput("Out", output_vars);
-
-  desc.SetAttr("axis", Axis);
-  desc.SetAttr("num", 0);
-  desc.SetAttr("sections", sections);
-
-  validator.SetOp(*desc.Proto());
-
-  validator.Execute(1);
-}
-
-// batch = 0, axis = 1, same shape
-TEST(split_op, test_same_shape_axis1_batch1) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  AnakinSliceTest<::anakin::saber::NV, 1>(ctx, true, {1, 4, 2, 2}, {2, 2});
-}
-// batch = 0, axis = 1, different shape
-TEST(split_op, test_different_shape_axis1_batch1) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  AnakinSliceTest<::anakin::saber::NV, 1>(ctx, true, {1, 3, 2, 2}, {2, 1});
-}
-// batch = 0, axis = 2, same shape
-TEST(split_op, test_same_shape_axis2_batch1) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  AnakinSliceTest<::anakin::saber::NV, 2>(ctx, true, {1, 3, 4, 2}, {2, 2});
-}
-// batch = 0, axis = 2, different shape
-TEST(split_op, test_different_shape_axis2_batch1) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  AnakinSliceTest<::anakin::saber::NV, 2>(ctx, true, {1, 3, 3, 2}, {2, 1});
-}
-
-// batch = 0, axis = 3, same shape
-TEST(split_op, test_same_shape_axis3_batch1) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  AnakinSliceTest<::anakin::saber::NV, 3>(ctx, true, {1, 3, 2, 4}, {2, 2});
-}
-// batch = 0, axis = 3, different shape
-TEST(split_op, test_different_shape_axis3_batch1) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  AnakinSliceTest<::anakin::saber::NV, 3>(ctx, true, {1, 3, 2, 3}, {2, 1});
-}
-#ifdef ANAKIN_X86_PLACE
-TEST(split_op, test_different_shape_axis1_batch1_cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  AnakinSliceTest<::anakin::saber::X86, 1>(ctx, false, {1, 3, 2, 3}, {2, 1});
-}
-
-TEST(split_op, test_different_shape_axis2_batch1_cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  AnakinSliceTest<::anakin::saber::X86, 2>(ctx, false, {1, 3, 4, 2}, {2, 2});
-}
-
-TEST(split_op, test_different_shape_axis3_batch1_cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  AnakinSliceTest<::anakin::saber::X86, 3>(ctx, false, {1, 3, 2, 4}, {2, 2});
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(split);
-USE_ANAKIN_CONVERTER(split);

paddle/fluid/inference/anakin/convert/test_sum_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/sum.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-#include "paddle/fluid/operators/sum_op.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-static void test_sum_op(const platform::DeviceContext& context, bool use_gpu) {
-  std::unordered_set<std::string> parameters;
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  validator.DeclInputVar("sum_x1", {1, 2, 1, 2});
-  validator.DeclInputVar("sum_x2", {1, 2, 1, 2});
-  validator.DeclOutputVar("sum_out", {1, 2, 1, 2});
-
-  // Prepare Op description
-  framework::OpDesc desc;
-  desc.SetType("sum");
-  desc.SetInput("X", {"sum_x1", "sum_x2"});
-  desc.SetOutput("Out", {"sum_out"});
-
-  validator.SetOp(*desc.Proto());
-  validator.Execute(1);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(sum_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_sum_op<::anakin::saber::NV>(ctx, true);
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(sum_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_sum_op<::anakin::saber::X86>(ctx, false);
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(sum);
-USE_ANAKIN_CONVERTER(sum);

paddle/fluid/inference/anakin/convert/test_transpose_op.cc

-/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-
-#include <gtest/gtest.h>
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-#include "paddle/fluid/inference/anakin/convert/ut_helper.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT>
-void test_transpose1_op(const platform::DeviceContext& context, bool use_gpu) {
-  std::unordered_set<std::string> parameters;
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  validator.DeclInputVar("transpose-X", {2, 3, 4, 5});
-  validator.DeclOutputVar("transpose-Out", {4, 2, 5, 3});
-
-  // Prepare Op description
-  framework::OpDesc desc;
-  desc.SetType("transpose");
-  desc.SetInput("X", {"transpose-X"});
-  desc.SetOutput("Out", {"transpose-Out"});
-  desc.SetAttr("axis", std::vector<int>({2, 0, 3, 1}));
-
-  LOG(INFO) << "set OP";
-  validator.SetOp(*desc.Proto());
-  LOG(INFO) << "execute";
-
-  validator.Execute(3);
-}
-
-template <typename TargetT>
-void test_transpose2_op(const platform::DeviceContext& context, bool use_gpu) {
-  std::unordered_set<std::string> parameters;
-  framework::Scope scope;
-  AnakinConvertValidation<TargetT, ::anakin::Precision::FP32> validator(
-      parameters, &scope, context, use_gpu);
-  validator.DeclInputVar("transpose-X", {3, 4, 5});
-  validator.DeclOutputVar("transpose-Out", {3, 5, 4});
-
-  // Prepare Op description
-  framework::OpDesc desc;
-  desc.SetType("transpose");
-  desc.SetInput("X", {"transpose-X"});
-  desc.SetOutput("Out", {"transpose-Out"});
-  desc.SetAttr("axis", std::vector<int>({0, 2, 1}));
-
-  LOG(INFO) << "set OP";
-  validator.SetOp(*desc.Proto());
-  LOG(INFO) << "execute";
-
-  validator.Execute(1);
-}
-
-#ifdef PADDLE_WITH_CUDA
-TEST(transpose1_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_transpose1_op<::anakin::saber::NV>(ctx, true);
-}
-
-TEST(transpose2_op, gpu) {
-  platform::CUDAPlace gpu_place(0);
-  platform::CUDADeviceContext ctx(gpu_place);
-  test_transpose2_op<::anakin::saber::NV>(ctx, true);
-}
-#endif
-#ifdef ANAKIN_X86_PLACE
-TEST(transpose1_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_transpose2_op<::anakin::saber::X86>(ctx, false);
-}
-
-TEST(transpose2_op, cpu) {
-  platform::CPUPlace cpu_place;
-  platform::CPUDeviceContext ctx(cpu_place);
-  test_transpose2_op<::anakin::saber::X86>(ctx, false);
-}
-#endif
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-USE_OP(transpose);
-USE_ANAKIN_CONVERTER(transpose);

paddle/fluid/inference/anakin/convert/transpose.cc

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/fluid/inference/anakin/convert/transpose.h"
-#include <algorithm>
-#include <string>
-#include <vector>
-
-using anakin::PTuple;
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-void TransposeOpConverter<TargetT, PrecisionT>::operator()(
-    const framework::proto::OpDesc &op, const framework::BlockDesc &block_desc,
-    const framework::Scope &scope, bool test_mode) {
-  framework::OpDesc op_desc(op, nullptr);
-  PADDLE_ENFORCE_EQ(op_desc.Input("X").size(), 1);
-  PADDLE_ENFORCE_EQ(op_desc.Output("Out").size(), 1);
-
-  auto input = op_desc.Input("X").front();
-  auto output = op_desc.Output("Out").front();
-  auto op_name = op_desc.Type() + ":" + op_desc.Output("Out").front();
-  this->engine_->AddOp(op_name, "Permute", {input}, {output});
-
-  auto axis = boost::get<std::vector<int>>(op_desc.GetAttr("axis"));
-  size_t axis_size = axis.size();
-  while (axis.size() < 4) {
-    axis.push_back(axis_size);
-    axis_size += 1;
-  }
-  this->engine_->template AddOpAttr<PTuple<int>>(op_name, "dims", axis);
-}
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle
-
-REGISTER_ANAKIN_OP_CONVERTER(transpose, TransposeOpConverter);

paddle/fluid/inference/anakin/convert/transpose.h

-// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/fluid/inference/anakin/convert/op_converter.h"
-
-namespace paddle {
-namespace inference {
-namespace anakin {
-
-template <typename TargetT, ::anakin::Precision PrecisionT>
-class TransposeOpConverter : public AnakinOpConverter<TargetT, PrecisionT> {
- public:
-  TransposeOpConverter() = default;
-
-  virtual void operator()(const framework::proto::OpDesc &op,
-                          const framework::BlockDesc &block_desc,
-                          const framework::Scope &scope,
-                          bool test_mode) override;
-  virtual ~TransposeOpConverter() {}
-};
-
-}  // namespace anakin
-}  // namespace inference
-}  // namespace paddle

paddle/fluid/inference/analysis/argument.h

@@ -59,7 +59,6 @@ struct Argument {
 
   using unique_ptr_t = std::unique_ptr<void, std::function<void(void*)>>;
   using fusion_statis_t = std::unordered_map<std::string, int>;
-  using anakin_max_shape_t = std::map<std::string, std::vector<int>>;
 
   bool Has(const std::string& key) const { return valid_fields_.count(key); }
   // If we set the model using config.SetModelBuffer,
@@ -184,19 +183,6 @@ struct Argument {
                       bool);
   DECL_ARGUMENT_FIELD(tensorrt_use_calib_mode, TensorRtUseCalibMode, bool);
 
-  DECL_ARGUMENT_FIELD(anakin_max_input_shape, AnakinMaxInputShape,
-                      anakin_max_shape_t);
-  DECL_ARGUMENT_FIELD(anakin_max_batch_size, AnakinMaxBatchSize, int);
-  DECL_ARGUMENT_FIELD(anakin_min_subgraph_size, AnakinMinSubgraphSize, int);
-  DECL_ARGUMENT_FIELD(anakin_precision_mode, AnakinPrecisionMode,
-                      AnalysisConfig::Precision);
-  DECL_ARGUMENT_FIELD(anakin_auto_config_layout, AnakinAutoConfigLayout, bool);
-  DECL_ARGUMENT_FIELD(use_anakin, UseAnakin, bool);
-  DECL_ARGUMENT_FIELD(anakin_passes_filter, AnakinPassesFilter,
-                      std::vector<std::string>);
-  DECL_ARGUMENT_FIELD(anakin_ops_filter, AnakinOpsFilter,
-                      std::vector<std::string>);
-
   DECL_ARGUMENT_FIELD(lite_passes_filter, LitePassesFilter,
                       std::vector<std::string>);
   DECL_ARGUMENT_FIELD(lite_ops_filter, LiteOpsFilter, std::vector<std::string>);