Merge pull request #3358 from NervanaSystems/cyphers/expdesc

Convert op/experimental to type_name descriptions

src/ngraph/op/experimental/batch_mat_mul.cpp

@@ -24,8 +24,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::BatchMatMul::type_name{"BatchMatMul"};
+
 op::BatchMatMul::BatchMatMul(const shared_ptr<Node>& arg0, const shared_ptr<Node>& arg1)
-    : Op("BatchMatMul", check_single_output_args({arg0, arg1}))
+    : Op(check_single_output_args({arg0, arg1}))
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/experimental/batch_mat_mul.hpp

@@ -32,6 +32,9 @@ namespace ngraph
         class BatchMatMul : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a batch of matmul product operation.
             ///
             /// \param arg0 The node producing the first argument.

src/ngraph/op/experimental/compiled_kernel.cpp

@@ -23,6 +23,8 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::CompiledKernel::type_name{"CompiledKernel"};
+
 shared_ptr<Node> ngraph::op::CompiledKernel::copy_with_new_args(const NodeVector& new_args) const
 {
     auto args = inputs();
@@ -64,7 +66,7 @@ shared_ptr<Node> ngraph::op::CompiledKernel::copy_with_new_args(const NodeVector
 ngraph::op::CompiledKernel::CompiledKernel(const NodeVector& node_list,
                                            const NodeVector& outputs,
                                            const NodeVector& args)
-    : Op("CompiledKernel", check_single_output_args({args}))
+    : Op(check_single_output_args({args}))
     , m_node_list(node_list)
     , m_output_nodes(outputs)
 {

src/ngraph/op/experimental/compiled_kernel.hpp

@@ -32,6 +32,9 @@ namespace ngraph
         class CompiledKernel : public ngraph::op::Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             CompiledKernel(const NodeVector& node_list,
                            const NodeVector& outputs,
                            const NodeVector& args);

src/ngraph/op/experimental/dyn_broadcast.cpp

@@ -20,10 +20,12 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::DynBroadcast::type_name{"DynBroadcast"};
+
 op::DynBroadcast::DynBroadcast(const shared_ptr<Node>& arg,
                                const shared_ptr<Node>& shape,
                                const shared_ptr<Node>& broadcast_axes)
-    : Op("DynBroadcast", check_single_output_args({arg, shape, broadcast_axes}))
+    : Op(check_single_output_args({arg, shape, broadcast_axes}))
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/experimental/dyn_broadcast.hpp

@@ -28,6 +28,9 @@ namespace ngraph
         class DynBroadcast : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a dynamic broadcast operation.
             ///
             /// \param arg            Node that produces the input tensor to be broadcast.

src/ngraph/op/experimental/dyn_pad.cpp

@@ -19,12 +19,14 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::DynPad::type_name{"DynPad"};
+
 op::DynPad::DynPad(const std::shared_ptr<Node>& arg,
                    const std::shared_ptr<Node>& padding_below,
                    const std::shared_ptr<Node>& padding_above,
                    const std::shared_ptr<Node>& padding_value,
                    op::PadMode pad_mode)
-    : Op("DynPad", check_single_output_args({arg, padding_below, padding_above, padding_value}))
+    : Op(check_single_output_args({arg, padding_below, padding_above, padding_value}))
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/experimental/dyn_pad.hpp

@@ -27,6 +27,9 @@ namespace ngraph
         class DynPad : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Perform dynamic padding of a tensor
             ///
             /// \param arg The node producing input tensor to be padded.

src/ngraph/op/experimental/dyn_replace_slice.cpp

@@ -24,6 +24,8 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::DynReplaceSlice::type_name{"DynReplaceSlice"};
+
 op::DynReplaceSlice::DynReplaceSlice(const shared_ptr<Node>& arg,
                                      const shared_ptr<Node>& replacement,
                                      const shared_ptr<Node>& lower_bounds,
@@ -34,8 +36,7 @@ op::DynReplaceSlice::DynReplaceSlice(const shared_ptr<Node>& arg,
                                      const AxisSet& new_axis,
                                      const AxisSet& shrink_axis,
                                      const AxisSet& ellipsis_mask)
-    : Op("DynReplaceSlice",
-         check_single_output_args({arg, replacement, lower_bounds, upper_bounds, strides}))
+    : Op(check_single_output_args({arg, replacement, lower_bounds, upper_bounds, strides}))
     , m_lower_bounds_mask(lower_bounds_mask)
     , m_upper_bounds_mask(upper_bounds_mask)
     , m_new_axis(new_axis)

src/ngraph/op/experimental/dyn_replace_slice.hpp

@@ -27,6 +27,9 @@ namespace ngraph
         class DynReplaceSlice : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a dynamic tensor replace-slice operation.
             ///
             /// \param arg The tensor in which to replace the slice.

src/ngraph/op/experimental/dyn_reshape.cpp

@@ -24,10 +24,12 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::DynReshape::type_name{"DynReshape"};
+
 op::DynReshape::DynReshape(const shared_ptr<Node>& arg,
                            const shared_ptr<Node>& pattern,
                            bool zero_flag)
-    : Op("DynReshape", check_single_output_args({arg, pattern}))
+    : Op(check_single_output_args({arg, pattern}))
     , m_zero_flag(zero_flag)
 {
     constructor_validate_and_infer_types();

src/ngraph/op/experimental/dyn_reshape.hpp

@@ -31,6 +31,9 @@ namespace ngraph
         class DynReshape : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a dynamic reshape operation. This operation does not perform transpose.
             ///
             /// \param arg The tensor to be reshaped.

src/ngraph/op/experimental/dyn_slice.cpp

@@ -24,6 +24,8 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::DynSlice::type_name{"DynSlice"};
+
 op::DynSlice::DynSlice(const shared_ptr<Node>& arg,
                        const shared_ptr<Node>& lower_bounds,
                        const shared_ptr<Node>& upper_bounds,
@@ -33,7 +35,7 @@ op::DynSlice::DynSlice(const shared_ptr<Node>& arg,
                        const AxisSet& new_axis,
                        const AxisSet& shrink_axis,
                        const AxisSet& ellipsis_mask)
-    : Op("DynSlice", check_single_output_args({arg, lower_bounds, upper_bounds, strides}))
+    : Op(check_single_output_args({arg, lower_bounds, upper_bounds, strides}))
     , m_lower_bounds_mask(lower_bounds_mask)
     , m_upper_bounds_mask(upper_bounds_mask)
     , m_new_axis(new_axis)

src/ngraph/op/experimental/dyn_slice.hpp

@@ -27,6 +27,9 @@ namespace ngraph
         class DynSlice : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a dynamic tensor slice operation.
             ///
             /// \param arg The tensor to be sliced.

src/ngraph/op/experimental/layers/ctc_greedy_decoder.cpp

@@ -19,10 +19,12 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::CTCGreedyDecoder::type_name{"CTCGreedyDecoder"};
+
 op::CTCGreedyDecoder::CTCGreedyDecoder(const shared_ptr<Node>& input,
                                        const std::shared_ptr<Node>& seq_len,
                                        const bool ctc_merge_repeated)
-    : Op("CTCGreedyDecoder", check_single_output_args({input, seq_len}))
+    : Op(check_single_output_args({input, seq_len}))
     , m_ctc_merge_repeated(ctc_merge_repeated)
 {
     constructor_validate_and_infer_types();

src/ngraph/op/experimental/layers/ctc_greedy_decoder.hpp

@@ -25,6 +25,9 @@ namespace ngraph
         class CTCGreedyDecoder : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a CTCGreedyDecoder operation
             ///
             /// \param input              Logits on which greedy decoding is performed

src/ngraph/op/experimental/layers/detection_output.cpp

@@ -21,15 +21,16 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::DetectionOutput::type_name{"DetectionOutput"};
+
 op::DetectionOutput::DetectionOutput(const std::shared_ptr<Node>& box_logits,
                                      const std::shared_ptr<Node>& class_preds,
                                      const std::shared_ptr<Node>& proposals,
                                      const std::shared_ptr<Node>& aux_class_preds,
                                      const std::shared_ptr<Node>& aux_box_preds,
                                      const DetectionOutputAttrs& attrs)
-    : Op("DetectionOutput",
-         check_single_output_args(
-             {box_logits, class_preds, proposals, aux_class_preds, aux_box_preds}))
+    : Op(check_single_output_args(
+          {box_logits, class_preds, proposals, aux_class_preds, aux_box_preds}))
     , m_attrs(attrs)
 {
     constructor_validate_and_infer_types();

src/ngraph/op/experimental/layers/detection_output.hpp

@@ -47,6 +47,9 @@ namespace ngraph
         class DetectionOutput : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a DetectionOutput operation
             ///
             /// \param box_logits			Box logits

src/ngraph/op/experimental/layers/interpolate.cpp

@@ -21,10 +21,12 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Interpolate::type_name{"Interpolate"};
+
 op::Interpolate::Interpolate(const std::shared_ptr<Node>& image,
                              const std::shared_ptr<Node>& output_shape,
                              const InterpolateAttrs& attrs)
-    : Op("Interpolate", check_single_output_args({image, output_shape}))
+    : Op(check_single_output_args({image, output_shape}))
     , m_attrs(attrs)
 {
     constructor_validate_and_infer_types();

src/ngraph/op/experimental/layers/interpolate.hpp

@@ -36,6 +36,9 @@ namespace ngraph
         class Interpolate : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a Interpolate operation
             ///
             /// \param image	    Input image

src/ngraph/op/experimental/layers/prior_box.cpp

@@ -21,10 +21,12 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::PriorBox::type_name{"PriorBox"};
+
 op::PriorBox::PriorBox(const shared_ptr<Node>& layer_shape,
                        const shared_ptr<Node>& image_shape,
                        const PriorBoxAttrs& attrs)
-    : Op("PriorBox", check_single_output_args({layer_shape, image_shape}))
+    : Op(check_single_output_args({layer_shape, image_shape}))
     , m_attrs(attrs)
 {
     constructor_validate_and_infer_types();

src/ngraph/op/experimental/layers/prior_box.hpp

@@ -49,6 +49,9 @@ namespace ngraph
         class PriorBox : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a PriorBox operation
             ///
             /// \param layer_shape    Shape of layer for which prior boxes are computed

src/ngraph/op/experimental/layers/prior_box_clustered.cpp

@@ -21,10 +21,12 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::PriorBoxClustered::type_name{"PriorBoxClustered"};
+
 op::PriorBoxClustered::PriorBoxClustered(const shared_ptr<Node>& layer_shape,
                                          const shared_ptr<Node>& image_shape,
                                          const PriorBoxClusteredAttrs& attrs)
-    : Op("PriorBoxClustered", check_single_output_args({layer_shape, image_shape}))
+    : Op(check_single_output_args({layer_shape, image_shape}))
     , m_attrs(attrs)
 {
     constructor_validate_and_infer_types();

src/ngraph/op/experimental/layers/prior_box_clustered.hpp

@@ -47,6 +47,9 @@ namespace ngraph
         class PriorBoxClustered : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a PriorBoxClustered operation
             ///
             /// \param layer_shape    Shape of layer for which prior boxes are computed

src/ngraph/op/experimental/layers/proposal.cpp

@@ -21,11 +21,13 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Proposal::type_name{"Proposal"};
+
 op::Proposal::Proposal(const std::shared_ptr<Node>& class_probs,
                        const std::shared_ptr<Node>& class_logits,
                        const std::shared_ptr<Node>& image_shape,
                        const ProposalAttrs& attrs)
-    : Op("Proposal", check_single_output_args({class_probs, class_logits, image_shape}))
+    : Op(check_single_output_args({class_probs, class_logits, image_shape}))
     , m_attrs(attrs)
 {
     constructor_validate_and_infer_types();

src/ngraph/op/experimental/layers/proposal.hpp

@@ -57,6 +57,9 @@ namespace ngraph
         class Proposal : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a Proposal operation
             ///
             /// \param class_probs     Class probability scores

src/ngraph/op/experimental/layers/psroi_pooling.cpp

@@ -19,6 +19,8 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::PSROIPooling::type_name{"PSROIPooling"};
+
 op::PSROIPooling::PSROIPooling(const shared_ptr<Node>& input,
                                const std::shared_ptr<Node>& coords,
                                const size_t output_dim,
@@ -26,7 +28,7 @@ op::PSROIPooling::PSROIPooling(const shared_ptr<Node>& input,
                                const float spatial_scale,
                                const Shape& num_bins,
                                const std::string& kind)
-    : Op("PSROIPooling", check_single_output_args({input, coords}))
+    : Op(check_single_output_args({input, coords}))
     , m_output_dim(output_dim)
     , m_group_size(group_size)
     , m_spatial_scale(spatial_scale)

src/ngraph/op/experimental/layers/psroi_pooling.hpp

@@ -25,6 +25,9 @@ namespace ngraph
         class PSROIPooling : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a PSROIPooling operation
             ///
             /// \param input          Input feature map {N, C, ...}

src/ngraph/op/experimental/layers/region_yolo.cpp

@@ -19,6 +19,8 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::RegionYolo::type_name{"RegionYolo"};
+
 op::RegionYolo::RegionYolo(const shared_ptr<Node>& input,
                            const size_t num_coords,
                            const size_t num_classes,
@@ -27,7 +29,7 @@ op::RegionYolo::RegionYolo(const shared_ptr<Node>& input,
                            const vector<int64_t>& mask,
                            const int axis,
                            const int end_axis)
-    : Op("RegionYolo", check_single_output_args({input}))
+    : Op(check_single_output_args({input}))
     , m_num_coords(num_coords)
     , m_num_classes(num_classes)
     , m_num_regions(num_regions)

src/ngraph/op/experimental/layers/region_yolo.hpp

@@ -25,6 +25,9 @@ namespace ngraph
         class RegionYolo : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a RegionYolo operation
             ///
             /// \param input          Input

src/ngraph/op/experimental/layers/reorg_yolo.cpp

@@ -21,8 +21,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::ReorgYolo::type_name{"ReorgYolo"};
+
 op::ReorgYolo::ReorgYolo(const shared_ptr<Node>& input, const Strides& strides)
-    : Op("ReorgYolo", check_single_output_args({input}))
+    : Op(check_single_output_args({input}))
     , m_strides(strides)
 {
     constructor_validate_and_infer_types();

src/ngraph/op/experimental/layers/reorg_yolo.hpp

@@ -25,6 +25,9 @@ namespace ngraph
         class ReorgYolo : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a ReorgYolo operation
             ///
             /// \param input          Input

src/ngraph/op/experimental/layers/roi_pooling.cpp

@@ -19,12 +19,14 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::ROIPooling::type_name{"ROIPooling"};
+
 op::ROIPooling::ROIPooling(const shared_ptr<Node>& input,
                            const std::shared_ptr<Node>& coords,
                            const Shape& output_size,
                            const float spatial_scale,
                            const std::string& kind)
-    : Op("ROIPooling", check_single_output_args({input, coords}))
+    : Op(check_single_output_args({input, coords}))
     , m_output_size(output_size)
     , m_spatial_scale(spatial_scale)
     , m_kind(kind)

src/ngraph/op/experimental/layers/roi_pooling.hpp

@@ -25,6 +25,9 @@ namespace ngraph
         class ROIPooling : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a ROIPooling operation
             ///
             /// \param input          Input feature map {N, C, ...}

src/ngraph/op/experimental/quantized_concat.cpp

@@ -23,8 +23,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::QuantizedConcat::type_name{"QuantizedConcat"};
+
 op::QuantizedConcat::QuantizedConcat(const NodeVector& args, size_t concatenation_axis)
-    : Op("QuantizedConcat", check_single_output_args(args))
+    : Op(check_single_output_args(args))
     , m_concatenation_axis(concatenation_axis)
 {
     constructor_validate_and_infer_types();

src/ngraph/op/experimental/quantized_concat.hpp

@@ -28,6 +28,9 @@ namespace ngraph
         class QuantizedConcat : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a concatenation operation.
             ///
             /// \param args               The nodes producing the input tensors.

src/ngraph/op/experimental/shape_of.cpp

@@ -20,8 +20,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::ShapeOf::type_name{"ShapeOf"};
+
 op::ShapeOf::ShapeOf(const shared_ptr<Node>& arg)
-    : Op("ShapeOf", check_single_output_args({arg}))
+    : Op(check_single_output_args({arg}))
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/experimental/shape_of.hpp

@@ -26,6 +26,9 @@ namespace ngraph
         class ShapeOf : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a shape-of operation.
             ShapeOf(const std::shared_ptr<Node>& arg);
 

src/ngraph/op/experimental/tile.cpp

@@ -21,8 +21,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Tile::type_name{"Tile"};
+
 op::Tile::Tile(const std::shared_ptr<Node>& arg, const std::shared_ptr<Node>& repeats)
-    : Op("Tile", check_single_output_args({arg, repeats}))
+    : Op(check_single_output_args({arg, repeats}))
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/experimental/tile.hpp

@@ -27,6 +27,9 @@ namespace ngraph
         class Tile : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Perform dynamic padding of a tensor
             ///
             /// \param arg The node producing input tensor to be padded.

src/ngraph/op/experimental/transpose.cpp

@@ -22,8 +22,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Transpose::type_name{"Transpose"};
+
 op::Transpose::Transpose(const shared_ptr<Node>& arg, const shared_ptr<Node>& input_order)
-    : Op("Transpose", check_single_output_args({arg, input_order}))
+    : Op(check_single_output_args({arg, input_order}))
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/experimental/transpose.hpp

@@ -28,6 +28,9 @@ namespace ngraph
         class Transpose : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a transpose operation.
             ///
             /// \param arg Node producing the tensor to be transposed.