IVGCVSW-4268 Print all Descriptors on dot graph

Change-Id: I82a7dcffc3771efa8350e2e1e22cfb20969551f9
Signed-off-by: Jim Flynn <jim.flynn@arm.com>
Signed-off-by: Teresa Charlin <teresa.charlinreyes@arm.com>

diff --git a/include/armnn/TypesUtils.hpp b/include/armnn/TypesUtils.hpp
index 065b683..8157d4f 100644 (file)
--- a/include/armnn/TypesUtils.hpp
+++ b/include/armnn/TypesUtils.hpp
@@ -77,16 +77,6 @@ constexpr char const* GetPoolingAlgorithmAsCString(PoolingAlgorithm pooling)
     }
 }
 
-constexpr char const* GetResizeMethodAsCString(ResizeMethod resizeMethod)
-{
-    switch (resizeMethod)
-    {
-        case ResizeMethod::Bilinear:        return "Bilinear";
-        case ResizeMethod::NearestNeighbor: return "NearestNeighbor";
-        default:                            return "Unknown";
-    }
-}
-
 constexpr char const* GetOutputShapeRoundingAsCString(OutputShapeRounding rounding)
 {
     switch (rounding)
@@ -97,7 +87,6 @@ constexpr char const* GetOutputShapeRoundingAsCString(OutputShapeRounding roundi
     }
 }
 
-
 constexpr char const* GetPaddingMethodAsCString(PaddingMethod method)
 {
     switch (method)
@@ -185,6 +174,35 @@ constexpr const char* GetDataLayoutName(DataLayout dataLayout)
     }
 }
 
+constexpr const char* GetNormalizationAlgorithmChannelAsCString(NormalizationAlgorithmChannel channel)
+{
+    switch (channel)
+    {
+        case NormalizationAlgorithmChannel::Across: return "Across";
+        case NormalizationAlgorithmChannel::Within: return "Within";
+        default:                                    return "Unknown";
+    }
+}
+
+constexpr const char* GetNormalizationAlgorithmMethodAsCString(NormalizationAlgorithmMethod method)
+{
+    switch (method)
+    {
+        case NormalizationAlgorithmMethod::LocalBrightness: return "LocalBrightness";
+        case NormalizationAlgorithmMethod::LocalContrast:   return "LocalContrast";
+        default:                                            return "Unknown";
+    }
+}
+
+constexpr const char* GetResizeMethodAsCString(ResizeMethod method)
+{
+    switch (method)
+    {
+        case ResizeMethod::Bilinear:        return "Bilinear";
+        case ResizeMethod::NearestNeighbor: return "NearestNeighbour";
+        default:                            return "Unknown";
+    }
+}
 
 template<typename T>
 struct IsHalfType

diff --git a/src/armnn/SerializeLayerParameters.cpp b/src/armnn/SerializeLayerParameters.cpp
index 1b0ec02..544e389 100644 (file)
--- a/src/armnn/SerializeLayerParameters.cpp
+++ b/src/armnn/SerializeLayerParameters.cpp
@@ -11,20 +11,19 @@
 namespace armnn
 {
 
-void
-StringifyLayerParameters<PermuteDescriptor>::Serialize(ParameterStringifyFunction & fn,
-                                                       const PermuteDescriptor & desc)
+void StringifyLayerParameters<PermuteDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                            const PermuteDescriptor& desc)
 {
     std::stringstream ss;
     ss <<  "[";
     bool addComma = false;
-    for (auto it=desc.m_DimMappings.begin(); it!= desc.m_DimMappings.end(); ++it)
+    for (auto it : desc.m_DimMappings)
     {
         if (addComma)
         {
             ss << ",";
         }
-        ss << *it;
+        ss << it;
         addComma = true;
     }
     ss << "]";
@@ -32,27 +31,24 @@ StringifyLayerParameters<PermuteDescriptor>::Serialize(ParameterStringifyFunctio
     fn("DimMappings",ss.str());
 }
 
-void
-StringifyLayerParameters<ReshapeDescriptor>::Serialize(ParameterStringifyFunction & fn,
-                                                       const ReshapeDescriptor & desc)
+void StringifyLayerParameters<ReshapeDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                            const ReshapeDescriptor& desc)
 {
     std::stringstream ss;
     ss << desc.m_TargetShape;
     fn("TargetShape",ss.str());
 }
 
-void
-StringifyLayerParameters<ActivationDescriptor>::Serialize(ParameterStringifyFunction & fn,
-                                                          const ActivationDescriptor & desc)
+void StringifyLayerParameters<ActivationDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                               const ActivationDescriptor& desc)
 {
-    fn("Function",GetActivationFunctionAsCString(desc.m_Function));
-    fn("A",std::to_string(desc.m_A));
-    fn("B",std::to_string(desc.m_B));
+    fn("Function", GetActivationFunctionAsCString(desc.m_Function));
+    fn("A", std::to_string(desc.m_A));
+    fn("B", std::to_string(desc.m_B));
 }
 
-void
-StringifyLayerParameters<Convolution2dDescriptor>::Serialize(ParameterStringifyFunction & fn,
-                                                             const Convolution2dDescriptor & desc)
+void StringifyLayerParameters<Convolution2dDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                  const Convolution2dDescriptor& desc)
 {
     {
         std::stringstream ss;
@@ -67,20 +63,26 @@ StringifyLayerParameters<Convolution2dDescriptor>::Serialize(ParameterStringifyF
         fn("Stride(X,Y)", ss.str());
     }
 
-    fn("BiasEnabled",(desc.m_BiasEnabled?"true":"false"));
-    fn("DataLayout",GetDataLayoutName(desc.m_DataLayout));
+    {
+        std::stringstream ss;
+        ss << "(" << desc.m_DilationX << "," << desc.m_DilationY << ")";
+        fn("Dilation(X,Y)", ss.str());
+    }
+
+    fn("BiasEnabled",(desc.m_BiasEnabled ? "true" : "false"));
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
 }
 
-void
-StringifyLayerParameters<BatchNormalizationDescriptor>::Serialize(ParameterStringifyFunction & fn,
-                                                                  const BatchNormalizationDescriptor & desc)
+void StringifyLayerParameters<BatchNormalizationDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                       const BatchNormalizationDescriptor& desc)
 {
-    fn("Eps",std::to_string(desc.m_Eps));
+    fn("Eps", std::to_string(desc.m_Eps));
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
 }
 
-void
-StringifyLayerParameters<DepthwiseConvolution2dDescriptor>::Serialize(ParameterStringifyFunction & fn,
-                                                                      const DepthwiseConvolution2dDescriptor & desc)
+void StringifyLayerParameters<DepthwiseConvolution2dDescriptor>::Serialize(
+    ParameterStringifyFunction& fn,
+    const DepthwiseConvolution2dDescriptor& desc)
 {
     {
         std::stringstream ss;
@@ -95,26 +97,31 @@ StringifyLayerParameters<DepthwiseConvolution2dDescriptor>::Serialize(ParameterS
         fn("Stride(X,Y)", ss.str());
     }
 
-    fn("BiasEnabled",(desc.m_BiasEnabled?"true":"false"));
-    fn("DataLayout",std::to_string(int(desc.m_DataLayout)));
+    {
+        std::stringstream ss;
+        ss << "(" << desc.m_DilationX << "," << desc.m_DilationY << ")";
+        fn("Dilation(X,Y)", ss.str());
+    }
+
+    fn("BiasEnabled",(desc.m_BiasEnabled ? "true" : "false"));
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
 }
 
-void
-StringifyLayerParameters<Pooling2dDescriptor>::Serialize(ParameterStringifyFunction & fn,
-                                                         const Pooling2dDescriptor & desc)
+void StringifyLayerParameters<Pooling2dDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                              const Pooling2dDescriptor& desc)
 {
     fn("Type", GetPoolingAlgorithmAsCString(desc.m_PoolType));
     {
         std::stringstream ss;
         ss << "(" << desc.m_PadTop    << "," << desc.m_PadLeft
            << "," << desc.m_PadBottom << "," << desc.m_PadRight << ")";
-        fn("Padding(T,L,B,R)",ss.str());
+        fn("Padding(T,L,B,R)", ss.str());
     }
 
     {
         std::stringstream ss;
         ss << "(" << desc.m_PoolWidth    << "," << desc.m_PoolHeight << ")";
-        fn("(Width,Height)",ss.str());
+        fn("(Width,Height)", ss.str());
     }
 
     {
@@ -125,31 +132,32 @@ StringifyLayerParameters<Pooling2dDescriptor>::Serialize(ParameterStringifyFunct
 
     fn("OutputShapeRounding", GetOutputShapeRoundingAsCString(desc.m_OutputShapeRounding));
     fn("PaddingMethod", GetPaddingMethodAsCString(desc.m_PaddingMethod));
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
 }
 
-void
-StringifyLayerParameters<SoftmaxDescriptor>::Serialize(ParameterStringifyFunction & fn,
-                                                       const SoftmaxDescriptor & desc)
+void StringifyLayerParameters<SoftmaxDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                            const SoftmaxDescriptor& desc)
 {
     fn("Beta", std::to_string(desc.m_Beta));
+    fn("Axis", std::to_string(desc.m_Axis));
 }
 
-void
-StringifyLayerParameters<FullyConnectedDescriptor>::Serialize(ParameterStringifyFunction & fn,
-                                                              const FullyConnectedDescriptor & desc)
+void StringifyLayerParameters<FullyConnectedDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                   const FullyConnectedDescriptor& desc)
 {
-    fn("BiasEnabled", (desc.m_BiasEnabled?"true":"false"));
-    fn("TransposeWeightMatrix", (desc.m_TransposeWeightMatrix?"true":"false"));
+    fn("BiasEnabled", (desc.m_BiasEnabled ? "true" : "false"));
+    fn("TransposeWeightMatrix", (desc.m_TransposeWeightMatrix ? "true" : "false"));
 }
 
-void
-StringifyLayerParameters<OriginsDescriptor>::Serialize(ParameterStringifyFunction & fn,
-                                                       const OriginsDescriptor & desc)
+void StringifyLayerParameters<OriginsDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                            const OriginsDescriptor& desc)
 {
+    fn("ConcatAxis", std::to_string(desc.GetConcatAxis()));
+
     uint32_t numViews = desc.GetNumViews();
     uint32_t numDims  = desc.GetNumDimensions();
 
-    for (uint32_t view=0; view<numViews; ++view)
+    for (uint32_t view = 0; view < numViews; ++view)
     {
         std::stringstream key;
         key << "MergeTo#" << view;
@@ -157,9 +165,32 @@ StringifyLayerParameters<OriginsDescriptor>::Serialize(ParameterStringifyFunctio
         value << "[";
         auto viewData = desc.GetViewOrigin(view);
 
-        for (uint32_t dim=0; dim<numDims; ++dim)
+        for (uint32_t dim = 0; dim < numDims; ++dim)
+        {
+            if (dim > 0)
+            {
+                value << ",";
+            }
+            value << viewData[dim];
+        }
+        value << "]";
+        fn(key.str(), value.str());
+    }
+}
+
+void StringifyLayerParameters<ViewsDescriptor>::Serialize(ParameterStringifyFunction& fn, const ViewsDescriptor& desc)
+{
+    uint32_t numViews = desc.GetNumViews();
+    uint32_t numDims  = desc.GetNumDimensions();
+    for (uint32_t view = 0; view < numViews; ++view) {
+        std::stringstream key;
+        key << "ViewSizes#" << view;
+        std::stringstream value;
+        value << "[";
+        auto viewData = desc.GetViewSizes(view);
+        for (uint32_t dim = 0; dim < numDims; ++dim)
         {
-            if(dim > 0)
+            if (dim > 0)
             {
                 value << ",";
             }
@@ -168,6 +199,296 @@ StringifyLayerParameters<OriginsDescriptor>::Serialize(ParameterStringifyFunctio
         value << "]";
         fn(key.str(), value.str());
     }
+    StringifyLayerParameters<OriginsDescriptor>::Serialize(fn, desc.GetOrigins());
+}
+
+void StringifyLayerParameters<DetectionPostProcessDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                         const DetectionPostProcessDescriptor& desc)
+{
+    fn("MaxDetections", std::to_string(desc.m_MaxDetections));
+    fn("MaxClassesPerDetection", std::to_string(desc.m_MaxClassesPerDetection));
+    fn("DetectionsPerClass", std::to_string(desc.m_DetectionsPerClass));
+    fn("NmsScoreThreshold", std::to_string(desc.m_NmsScoreThreshold));
+    fn("NmsIouThreshold", std::to_string(desc.m_NmsIouThreshold));
+    fn("NumClasses", std::to_string(desc.m_NumClasses));
+    fn("UseRegularNms", (desc.m_UseRegularNms ? "true" : "false"));
+    {
+        std::stringstream ss;
+        ss << "(" << desc.m_ScaleX <<  "," << desc.m_ScaleY << ")";
+        fn("Scale(X,Y)", ss.str());
+    }
+
+    {
+        std::stringstream ss;
+        ss << "(" << desc.m_ScaleW <<  "," << desc.m_ScaleH << ")";
+        fn("Scale(W,H)", ss.str());
+    }
+}
+
+void StringifyLayerParameters<NormalizationDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                  const NormalizationDescriptor& desc)
+{
+    fn("NormChannelType", GetNormalizationAlgorithmChannelAsCString(desc.m_NormChannelType));
+    fn("NormMethodType", GetNormalizationAlgorithmMethodAsCString(desc.m_NormMethodType));
+    fn("NormSize", std::to_string(desc.m_NormSize));
+    fn("Alpha", std::to_string(desc.m_Alpha));
+    fn("Beta", std::to_string(desc.m_Beta));
+    fn("K", std::to_string(desc.m_K));
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
+}
+
+void StringifyLayerParameters<L2NormalizationDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                    const L2NormalizationDescriptor& desc)
+{
+    fn("Eps", std::to_string(desc.m_Eps));
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
+}
+
+void StringifyLayerParameters<BatchToSpaceNdDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                   const BatchToSpaceNdDescriptor& desc)
+{
+    {
+        std::stringstream ss;
+        int count = 0;
+        for (auto&& var : desc.m_BlockShape)
+        {
+            if (count > 0)
+            {
+                ss << ",";
+            }
+            ss << var;
+            ++count;
+        }
+        fn("BlockShape", ss.str());
+    }
+
+    {
+        std::stringstream ss;
+        int count = 0;
+        for (auto&& var : desc.m_Crops)
+        {
+            if (count > 0)
+            {
+                ss << ",";
+            }
+            ss << "[" << var.first << "," << var.second << "]";
+            ++count;
+        }
+        fn("Crops", ss.str());
+    }
+
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
+}
+
+void StringifyLayerParameters<FakeQuantizationDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                     const FakeQuantizationDescriptor& desc)
+{
+    fn("Min", std::to_string(desc.m_Min));
+    fn("Max", std::to_string(desc.m_Max));
+}
+
+void StringifyLayerParameters<ResizeBilinearDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                   const ResizeBilinearDescriptor& desc)
+{
+    fn("TargetWidth", std::to_string(desc.m_TargetWidth));
+    fn("TargetHeight", std::to_string(desc.m_TargetHeight));
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
+}
+
+void StringifyLayerParameters<ResizeDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                           const ResizeDescriptor& desc)
+{
+    fn("TargetWidth", std::to_string(desc.m_TargetWidth));
+    fn("TargetHeight", std::to_string(desc.m_TargetHeight));
+    fn("ResizeMethod", GetResizeMethodAsCString(desc.m_Method));
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
+}
+
+void StringifyLayerParameters<SpaceToBatchNdDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                   const SpaceToBatchNdDescriptor& desc)
+{
+    {
+        std::stringstream ss;
+        int count = 0;
+        for (auto&& var : desc.m_BlockShape)
+        {
+            if (count > 0)
+            {
+                ss << ",";
+            }
+            ss << var;
+            ++count;
+        }
+        fn("BlockShape", ss.str());
+    }
+
+    {
+        std::stringstream ss;
+        int count = 0;
+        for (auto&& var : desc.m_PadList)
+        {
+            if (count > 0)
+            {
+                ss << ",";
+            }
+            ss << "[" << var.first << "," << var.second << "]";
+            ++count;
+        }
+        fn("PadList", ss.str());
+    }
+
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
+}
+
+void StringifyLayerParameters<SpaceToDepthDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                 const SpaceToDepthDescriptor& desc)
+{
+    fn("BlockSize", std::to_string(desc.m_BlockSize));
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
+}
+
+void StringifyLayerParameters<LstmDescriptor>::Serialize(ParameterStringifyFunction& fn, const LstmDescriptor& desc)
+{
+    fn("ActivationFunc", std::to_string(desc.m_ActivationFunc));
+    fn("ClippingThresCell", std::to_string(desc.m_ClippingThresCell));
+    fn("ClippingThresProj", std::to_string(desc.m_ClippingThresProj));
+    fn("CifgEnabled", (desc.m_CifgEnabled ? "true" : "false"))   ;
+    fn("PeepholeEnabled", (desc.m_PeepholeEnabled ? "true" : "false"))   ;
+    fn("ProjectionEnabled", (desc.m_ProjectionEnabled ? "true" : "false"))   ;
+    fn("LayerNormEnabled", (desc.m_LayerNormEnabled ? "true" : "false"));
+}
+
+void StringifyLayerParameters<MeanDescriptor>::Serialize(ParameterStringifyFunction& fn, const MeanDescriptor& desc)
+{
+    {
+        std::stringstream ss;
+        int count = 0;
+        for (auto&& var : desc.m_Axis)
+        {
+            if (count > 0)
+            {
+                ss << ",";
+            }
+            ss << var;
+            ++count;
+        }
+        fn("Axis", ss.str());
+    }
+    fn("KeepDims", (desc.m_KeepDims ? "true" : "false"));
+}
+
+void StringifyLayerParameters<PadDescriptor>::Serialize(ParameterStringifyFunction& fn, const PadDescriptor& desc)
+{
+    {
+        std::stringstream ss;
+        int count = 0;
+        for (auto&& var : desc.m_PadList)
+        {
+            if (count > 0)
+            {
+                ss << ",";
+            }
+            ss << "[" << var.first << "," << var.second << "]";
+            ++count;
+        }
+        fn("PadList", ss.str());
+    }
+    fn("PadValue", std::to_string(desc.m_PadValue));
+}
+
+void StringifyLayerParameters<StackDescriptor>::Serialize(ParameterStringifyFunction& fn, const StackDescriptor& desc)
+{
+    fn("Axis", std::to_string(desc.m_Axis));
+    fn("NumInputs", std::to_string(desc.m_NumInputs));
+    {
+        std::stringstream ss;
+        ss << desc.m_InputShape;
+        fn("InputShape",ss.str());
+    }
+}
+
+void StringifyLayerParameters<StridedSliceDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                 const StridedSliceDescriptor& desc)
+{
+    {
+        std::stringstream ss;
+        int count = 0;
+        for (auto&& var : desc.m_Begin)
+        {
+            if (count > 0)
+            {
+                ss << ",";
+            }
+            ss << var;
+            ++count;
+        }
+        fn("Begin", ss.str());
+    }
+
+    {
+        std::stringstream ss;
+        int count = 0;
+        for (auto&& var : desc.m_End)
+        {
+            if (count > 0)
+            {
+                ss << ",";
+            }
+            ss << var;
+            ++count;
+        }
+        fn("End", ss.str());
+    }
+
+    {
+        std::stringstream ss;
+        int count = 0;
+        for (auto&& var : desc.m_Stride)
+        {
+            if (count > 0)
+            {
+                ss << ",";
+            }
+            ss << var;
+            ++count;
+        }
+        fn("Stride", ss.str());
+    }
+
+    fn("BeginMask", std::to_string(desc.m_BeginMask));
+    fn("EndMask", std::to_string(desc.m_EndMask));
+    fn("ShrinkAxisMask", std::to_string(desc.m_ShrinkAxisMask));
+    fn("EllipsisMask", std::to_string(desc.m_EllipsisMask));
+    fn("NewAxisMask", std::to_string(desc.m_NewAxisMask));
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
 }
 
+void StringifyLayerParameters<PreCompiledDescriptor>::Serialize(ParameterStringifyFunction& fn,
+                                                                const PreCompiledDescriptor& desc)
+{
+    fn("NumInputSlots", std::to_string(desc.m_NumInputSlots));
+    fn("NumOutputSlots", std::to_string(desc.m_NumOutputSlots));
 }
+
+void StringifyLayerParameters<TransposeConvolution2dDescriptor>::Serialize(
+    ParameterStringifyFunction& fn,
+    const TransposeConvolution2dDescriptor& desc)
+{
+    {
+        std::stringstream ss;
+        ss << "(" << desc.m_PadTop    << "," << desc.m_PadLeft
+           << "," << desc.m_PadBottom << "," << desc.m_PadRight << ")";
+        fn("Padding(T,L,B,R)",ss.str());
+    }
+
+    {
+        std::stringstream ss;
+        ss << "(" << desc.m_StrideX <<  "," << desc.m_StrideY << ")";
+        fn("Stride(X,Y)", ss.str());
+    }
+
+    fn("BiasEnabled", (desc.m_BiasEnabled ? "true" : "false"));
+    fn("DataLayout", GetDataLayoutName(desc.m_DataLayout));
+}
+
+} // namespace armnn
\ No newline at end of file

diff --git a/src/armnn/SerializeLayerParameters.hpp b/src/armnn/SerializeLayerParameters.hpp
index a47ce5a..76ca0a5 100644 (file)
--- a/src/armnn/SerializeLayerParameters.hpp
+++ b/src/armnn/SerializeLayerParameters.hpp
@@ -11,7 +11,7 @@
 namespace armnn
 {
 
-using ParameterStringifyFunction = std::function<void(const std::string & name, const std::string & value)>;
+using ParameterStringifyFunction = std::function<void(const std::string& name, const std::string& value)>;
 
 ///
 /// StringifyLayerParameters allows serializing layer parameters to string.
@@ -22,57 +22,142 @@ using ParameterStringifyFunction = std::function<void(const std::string & name,
 template <typename LayerParameter>
 struct StringifyLayerParameters
 {
-    static void Serialize(ParameterStringifyFunction &, const LayerParameter &) {}
+    static void Serialize(ParameterStringifyFunction&, const LayerParameter&) {}
 };
 
 template <> struct StringifyLayerParameters<PermuteDescriptor>
 {
-    static void Serialize(ParameterStringifyFunction & fn, const PermuteDescriptor & desc);
+    static void Serialize(ParameterStringifyFunction& fn, const PermuteDescriptor& desc);
 };
 
 template <> struct StringifyLayerParameters<ReshapeDescriptor>
 {
-    static void Serialize(ParameterStringifyFunction & fn, const ReshapeDescriptor & desc);
+    static void Serialize(ParameterStringifyFunction& fn, const ReshapeDescriptor& desc);
 };
 
 template <> struct StringifyLayerParameters<ActivationDescriptor>
 {
-    static void Serialize(ParameterStringifyFunction & fn, const ActivationDescriptor & desc);
+    static void Serialize(ParameterStringifyFunction& fn, const ActivationDescriptor& desc);
 };
 
 template <> struct StringifyLayerParameters<Convolution2dDescriptor>
 {
-    static void Serialize(ParameterStringifyFunction & fn, const Convolution2dDescriptor & desc);
+    static void Serialize(ParameterStringifyFunction& fn, const Convolution2dDescriptor& desc);
 };
 
 template <> struct StringifyLayerParameters<BatchNormalizationDescriptor>
 {
-    static void Serialize(ParameterStringifyFunction & fn, const BatchNormalizationDescriptor & desc);
+    static void Serialize(ParameterStringifyFunction& fn, const BatchNormalizationDescriptor& desc);
 };
 
 template <> struct StringifyLayerParameters<DepthwiseConvolution2dDescriptor>
 {
-    static void Serialize(ParameterStringifyFunction & fn, const DepthwiseConvolution2dDescriptor & desc);
+    static void Serialize(ParameterStringifyFunction& fn, const DepthwiseConvolution2dDescriptor& desc);
 };
 
 template <> struct StringifyLayerParameters<Pooling2dDescriptor>
 {
-    static void Serialize(ParameterStringifyFunction & fn, const Pooling2dDescriptor & desc);
+    static void Serialize(ParameterStringifyFunction& fn, const Pooling2dDescriptor& desc);
 };
 
 template <> struct StringifyLayerParameters<SoftmaxDescriptor>
 {
-    static void Serialize(ParameterStringifyFunction & fn, const SoftmaxDescriptor & desc);
+    static void Serialize(ParameterStringifyFunction& fn, const SoftmaxDescriptor& desc);
 };
 
 template <> struct StringifyLayerParameters<FullyConnectedDescriptor>
 {
-    static void Serialize(ParameterStringifyFunction & fn, const FullyConnectedDescriptor & desc);
+    static void Serialize(ParameterStringifyFunction& fn, const FullyConnectedDescriptor& desc);
 };
 
 template <> struct StringifyLayerParameters<OriginsDescriptor>
 {
-    static void Serialize(ParameterStringifyFunction & fn, const OriginsDescriptor & desc);
+    static void Serialize(ParameterStringifyFunction& fn, const OriginsDescriptor& desc);
 };
 
-}
\ No newline at end of file
+template <> struct StringifyLayerParameters<ViewsDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const ViewsDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<DetectionPostProcessDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const DetectionPostProcessDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<NormalizationDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const NormalizationDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<L2NormalizationDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const L2NormalizationDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<BatchToSpaceNdDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const BatchToSpaceNdDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<FakeQuantizationDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const FakeQuantizationDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<ResizeBilinearDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const ResizeBilinearDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<ResizeDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const ResizeDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<SpaceToBatchNdDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const SpaceToBatchNdDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<SpaceToDepthDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const SpaceToDepthDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<LstmDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const LstmDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<MeanDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const MeanDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<PadDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const PadDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<StackDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const StackDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<StridedSliceDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const StridedSliceDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<PreCompiledDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const PreCompiledDescriptor& desc);
+};
+
+template <> struct StringifyLayerParameters<TransposeConvolution2dDescriptor>
+{
+    static void Serialize(ParameterStringifyFunction& fn, const TransposeConvolution2dDescriptor& desc);
+};
+
+} // namespace armnn
\ No newline at end of file