From 6f92c8e9f8bb38dcf5dccf8deeff5112ecd8e37c Mon Sep 17 00:00:00 2001 From: Nikhil Raj Date: Wed, 22 Nov 2023 11:41:15 +0000 Subject: Update Doxygen for 23.11 Signed-off-by: Nikhil Raj Change-Id: I47cd933f5002cb94a73aa97689d7b3d9c93cb849 --- ...ssarmnn_serializer_1_1_serializer_strategy.html | 1001 ++++++++++++++++++++ 1 file changed, 1001 insertions(+) create mode 100644 23.11/classarmnn_serializer_1_1_serializer_strategy.html (limited to '23.11/classarmnn_serializer_1_1_serializer_strategy.html') diff --git a/23.11/classarmnn_serializer_1_1_serializer_strategy.html b/23.11/classarmnn_serializer_1_1_serializer_strategy.html new file mode 100644 index 0000000000..5b2ab900d4 --- /dev/null +++ b/23.11/classarmnn_serializer_1_1_serializer_strategy.html @@ -0,0 +1,1001 @@ + + + + + + + + +Arm NN: SerializerStrategy Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + ArmNN + + + +
+
+  23.11 +
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Public Member Functions | +List of all members
+
+
SerializerStrategy Class Reference
+
+
+ +

#include <Serializer.hpp>

+
+Inheritance diagram for SerializerStrategy:
+
+
+
+
[legend]
+
+Collaboration diagram for SerializerStrategy:
+
+
+
+
[legend]
+ + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

void ExecuteStrategy (const armnn::IConnectableLayer *layer, const armnn::BaseDescriptor &descriptor, const std::vector< armnn::ConstTensor > &constants, const char *name, const armnn::LayerBindingId id) override
 
 SerializerStrategy ()
 
 ~SerializerStrategy ()
 
flatbuffers::FlatBufferBuilder & GetFlatBufferBuilder ()
 
std::vector< int > & GetInputIds ()
 
std::vector< int > & GetOutputIds ()
 
std::vector< flatbuffers::Offset< armnnSerializer::AnyLayer > > & GetSerializedLayers ()
 
flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > GetVersionTable ()
 
- Public Member Functions inherited from IStrategy
virtual void ExecuteStrategy (const IConnectableLayer *layer, const armnn::BaseDescriptor &descriptor, const std::vector< armnn::ConstTensor > &constants, const char *name, const armnn::LayerBindingId id=0)=0
 
virtual void FinishStrategy ()
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from IStrategy
 IStrategy ()
 
virtual ~IStrategy ()
 
+

Detailed Description

+
+

Definition at line 22 of file Serializer.hpp.

+

Constructor & Destructor Documentation

+ +

◆ SerializerStrategy()

+ +
+
+ + + + + +
+ + + + + + + +
SerializerStrategy ()
+ 		+inline
+
+ +

Definition at line 31 of file Serializer.hpp.

+
31 : m_layerId(0) {}
+
+
+
+ +

◆ ~SerializerStrategy()

+ +
+
+ + + + + +
+ + + + + + + +
~SerializerStrategy ()
+ 		+inline
+
+ +

Definition at line 32 of file Serializer.hpp.

+
32 {}
+
+
+
+

Member Function Documentation

+ +

◆ ExecuteStrategy()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void ExecuteStrategy (const armnn::IConnectableLayer * layer,
const armnn::BaseDescriptor & descriptor,
const std::vector< armnn::ConstTensor > & constants,
const char * name,
const armnn::LayerBindingId id 
)
+ 		+override
+
+ +

Definition at line 2029 of file Serializer.cpp.

+
2034 {
+
2035  IgnoreUnused(constants);
+
2036 
+
2037  switch (layer->GetType())
+
2038  {
+
2039  case armnn::LayerType::Activation :
+
2040  {
+
2041  const armnn::ActivationDescriptor& layerDescriptor =
+
2042  static_cast<const armnn::ActivationDescriptor&>(descriptor);
+
2043  SerializeActivationLayer(layer, layerDescriptor, name);
+
2044  break;
+
2045  }
+
2046  case armnn::LayerType::Addition :
+
2047  {
+
2048  SerializeAdditionLayer(layer, name);
+
2049  break;
+
2050  }
+
2051  case armnn::LayerType::ArgMinMax :
+
2052  {
+
2053  const armnn::ArgMinMaxDescriptor& layerDescriptor =
+
2054  static_cast<const armnn::ArgMinMaxDescriptor&>(descriptor);
+
2055  SerializeArgMinMaxLayer(layer, layerDescriptor, name);
+
2056  break;
+
2057  }
+
2058  case armnn::LayerType::BatchMatMul:
+
2059  {
+
2060  const armnn::BatchMatMulDescriptor& layerDescriptor =
+
2061  static_cast<const armnn::BatchMatMulDescriptor&>(descriptor);
+
2062  SerializeBatchMatMulLayer(layer,
+
2063  layerDescriptor,
+
2064  name);
+
2065  break;
+
2066  }
+
2067  case armnn::LayerType::BatchNormalization :
+
2068  {
+
2069  const armnn::BatchNormalizationDescriptor& layerDescriptor =
+
2070  static_cast<const armnn::BatchNormalizationDescriptor&>(descriptor);
+
2071  SerializeBatchNormalizationLayer(layer,
+
2072  layerDescriptor,
+
2073  constants,
+
2074  name);
+
2075  break;
+
2076  }
+
2077  case armnn::LayerType::BatchToSpaceNd :
+
2078  {
+
2079  const armnn::BatchToSpaceNdDescriptor& layerDescriptor =
+
2080  static_cast<const armnn::BatchToSpaceNdDescriptor&>(descriptor);
+
2081  SerializeBatchToSpaceNdLayer(layer,
+
2082  layerDescriptor,
+
2083  name);
+
2084  break;
+
2085  }
+
2086  case armnn::LayerType::Cast :
+
2087  {
+
2088  SerializeCastLayer(layer, name);
+
2089  break;
+
2090  }
+
2091  case armnn::LayerType::ChannelShuffle :
+
2092  {
+
2093  const armnn::ChannelShuffleDescriptor& layerDescriptor =
+
2094  static_cast<const armnn::ChannelShuffleDescriptor&>(descriptor);
+
2095  SerializeChannelShuffleLayer(layer,
+
2096  layerDescriptor,
+
2097  name);
+
2098  break;
+
2099  }
+
2100  case armnn::LayerType::Comparison :
+
2101  {
+
2102  const armnn::ComparisonDescriptor& layerDescriptor =
+
2103  static_cast<const armnn::ComparisonDescriptor&>(descriptor);
+
2104  SerializeComparisonLayer(layer,
+
2105  layerDescriptor,
+
2106  name);
+
2107  break;
+
2108  }
+
2109  case armnn::LayerType::Concat :
+
2110  {
+
2111  const armnn::ConcatDescriptor& layerDescriptor =
+
2112  static_cast<const armnn::ConcatDescriptor&>(descriptor);
+
2113  SerializeConcatLayer(layer,
+
2114  layerDescriptor,
+
2115  name);
+
2116  break;
+
2117  }
+
2118  case armnn::LayerType::Constant :
+
2119  {
+
2120  SerializeConstantLayer(layer,
+
2121  constants,
+
2122  name);
+
2123  break;
+
2124  }
+
2125  case armnn::LayerType::Convolution2d :
+
2126  {
+
2127  const armnn::Convolution2dDescriptor& layerDescriptor =
+
2128  static_cast<const armnn::Convolution2dDescriptor&>(descriptor);
+
2129  SerializeConvolution2dLayer(layer,
+
2130  layerDescriptor,
+
2131  name);
+
2132  break;
+
2133  }
+
2134  case armnn::LayerType::Convolution3d :
+
2135  {
+
2136  const armnn::Convolution3dDescriptor& layerDescriptor =
+
2137  static_cast<const armnn::Convolution3dDescriptor&>(descriptor);
+
2138  SerializeConvolution3dLayer(layer,
+
2139  layerDescriptor,
+
2140  name);
+
2141  break;
+
2142  }
+
2143  case armnn::LayerType::DepthToSpace :
+
2144  {
+
2145  const armnn::DepthToSpaceDescriptor& layerDescriptor =
+
2146  static_cast<const armnn::DepthToSpaceDescriptor&>(descriptor);
+
2147  SerializeDepthToSpaceLayer(layer,
+
2148  layerDescriptor,
+
2149  name);
+
2150  break;
+
2151  }
+
2152  case armnn::LayerType::DepthwiseConvolution2d :
+
2153  {
+
2154  const armnn::DepthwiseConvolution2dDescriptor& layerDescriptor =
+
2155  static_cast<const armnn::DepthwiseConvolution2dDescriptor&>(descriptor);
+
2156  SerializeDepthwiseConvolution2dLayer(layer,
+
2157  layerDescriptor,
+
2158  name);
+
2159  break;
+
2160  }
+
2161  case armnn::LayerType::Dequantize :
+
2162  {
+
2163  SerializeDequantizeLayer(layer,
+
2164  name);
+
2165  break;
+
2166  }
+
2167  case armnn::LayerType::DetectionPostProcess :
+
2168  {
+
2169  const armnn::DetectionPostProcessDescriptor& layerDescriptor =
+
2170  static_cast<const armnn::DetectionPostProcessDescriptor&>(descriptor);
+
2171  SerializeDetectionPostProcessLayer(layer, layerDescriptor, constants, name);
+
2172  break;
+
2173  }
+
2174  case armnn::LayerType::Division :
+
2175  {
+
2176  SerializeDivisionLayer(layer, name);
+
2177  break;
+
2178  }
+
2179  case armnn::LayerType::ElementwiseBinary :
+
2180  {
+
2181  const armnn::ElementwiseBinaryDescriptor& layerDescriptor =
+
2182  static_cast<const armnn::ElementwiseBinaryDescriptor&>(descriptor);
+
2183  SerializeElementwiseBinaryLayer(layer, layerDescriptor, name);
+
2184  break;
+
2185  }
+
2186  case armnn::LayerType::ElementwiseUnary :
+
2187  {
+
2188  const armnn::ElementwiseUnaryDescriptor& layerDescriptor =
+
2189  static_cast<const armnn::ElementwiseUnaryDescriptor&>(descriptor);
+
2190  SerializeElementwiseUnaryLayer(layer, layerDescriptor, name);
+
2191  break;
+
2192  }
+
2193  case armnn::LayerType::Fill :
+
2194  {
+
2195  const armnn::FillDescriptor& layerDescriptor =
+
2196  static_cast<const armnn::FillDescriptor&>(descriptor);
+
2197  SerializeFillLayer(layer, layerDescriptor, name);
+
2198  break;
+
2199  }
+
2200  case armnn::LayerType::Floor :
+
2201  {
+
2202  SerializeFloorLayer(layer, name);
+
2203  break;
+
2204  }
+
2205  case armnn::LayerType::FullyConnected :
+
2206  {
+
2207  const armnn::FullyConnectedDescriptor& layerDescriptor =
+
2208  static_cast<const armnn::FullyConnectedDescriptor&>(descriptor);
+
2209  SerializeFullyConnectedLayer(layer, layerDescriptor, name);
+
2210  break;
+
2211  }
+
2212  case armnn::LayerType::Gather :
+
2213  {
+
2214  const armnn::GatherDescriptor& layerDescriptor =
+
2215  static_cast<const armnn::GatherDescriptor&>(descriptor);
+
2216  SerializeGatherLayer(layer, layerDescriptor, name);
+
2217  break;
+
2218  }
+
2219  case armnn::LayerType::GatherNd :
+
2220  {
+
2221  SerializeGatherNdLayer(layer, name);
+
2222  break;
+
2223  }
+
2224  case armnn::LayerType::Input:
+
2225  {
+
2226  SerializeInputLayer(layer, id, name);
+
2227  break;
+
2228  }
+
2229  case armnn::LayerType::InstanceNormalization :
+
2230  {
+
2231  const armnn::InstanceNormalizationDescriptor& layerDescriptor =
+
2232  static_cast<const armnn::InstanceNormalizationDescriptor&>(descriptor);
+
2233  SerializeInstanceNormalizationLayer(layer, layerDescriptor, name);
+
2234  break;
+
2235  }
+
2236  case armnn::LayerType::L2Normalization :
+
2237  {
+
2238  const armnn::L2NormalizationDescriptor& layerDescriptor =
+
2239  static_cast<const armnn::L2NormalizationDescriptor&>(descriptor);
+
2240  SerializeL2NormalizationLayer(layer, layerDescriptor, name);
+
2241  break;
+
2242  }
+
2243  case armnn::LayerType::LogicalBinary :
+
2244  {
+
2245  const armnn::LogicalBinaryDescriptor& layerDescriptor =
+
2246  static_cast<const armnn::LogicalBinaryDescriptor&>(descriptor);
+
2247  SerializeLogicalBinaryLayer(layer, layerDescriptor, name);
+
2248  break;
+
2249  }
+
2250  case armnn::LayerType::LogSoftmax :
+
2251  {
+
2252  const armnn::LogSoftmaxDescriptor& layerDescriptor =
+
2253  static_cast<const armnn::LogSoftmaxDescriptor&>(descriptor);
+
2254  SerializeLogSoftmaxLayer(layer, layerDescriptor, name);
+
2255  break;
+
2256  }
+
2257  case armnn::LayerType::Lstm :
+
2258  {
+
2259  const armnn::LstmDescriptor& layerDescriptor =
+
2260  static_cast<const armnn::LstmDescriptor&>(descriptor);
+
2261  SerializeLstmLayer(layer, layerDescriptor, constants, name);
+
2262  break;
+
2263  }
+
2264  case armnn::LayerType::QLstm :
+
2265  {
+
2266  const armnn::QLstmDescriptor& layerDescriptor =
+
2267  static_cast<const armnn::QLstmDescriptor&>(descriptor);
+
2268  SerializeQLstmLayer(layer, layerDescriptor, constants, name);
+
2269  break;
+
2270  }
+
2271  case armnn::LayerType::Maximum :
+
2272  {
+
2273  SerializeMaximumLayer(layer, name);
+
2274  break;
+
2275  }
+
2276  case armnn::LayerType::Mean :
+
2277  {
+
2278  const armnn::MeanDescriptor& layerDescriptor =
+
2279  static_cast<const armnn::MeanDescriptor&>(descriptor);
+
2280  SerializeMeanLayer(layer, layerDescriptor, name);
+
2281  break;
+
2282  }
+
2283  case armnn::LayerType::Merge :
+
2284  {
+
2285  SerializeMergeLayer(layer, name);
+
2286  break;
+
2287  }
+
2288  case armnn::LayerType::Minimum :
+
2289  {
+
2290  SerializeMinimumLayer(layer, name);
+
2291  break;
+
2292  }
+
2293  case armnn::LayerType::Multiplication :
+
2294  {
+
2295  SerializeMultiplicationLayer(layer, name);
+
2296  break;
+
2297  }
+
2298  case armnn::LayerType::Normalization :
+
2299  {
+
2300  const armnn::NormalizationDescriptor& layerDescriptor =
+
2301  static_cast<const armnn::NormalizationDescriptor&>(descriptor);
+
2302  SerializeNormalizationLayer(layer, layerDescriptor, name);
+
2303  break;
+
2304  }
+
2305  case armnn::LayerType::Output:
+
2306  {
+
2307  SerializeOutputLayer(layer, id, name);
+
2308  break;
+
2309  }
+
2310  case armnn::LayerType::Pad :
+
2311  {
+
2312  const armnn::PadDescriptor& layerDescriptor =
+
2313  static_cast<const armnn::PadDescriptor&>(descriptor);
+
2314  SerializePadLayer(layer, layerDescriptor, name);
+
2315  break;
+
2316  }
+
2317  case armnn::LayerType::Permute :
+
2318  {
+
2319  const armnn::PermuteDescriptor& layerDescriptor =
+
2320  static_cast<const armnn::PermuteDescriptor&>(descriptor);
+
2321  SerializePermuteLayer(layer, layerDescriptor, name);
+
2322  break;
+
2323  }
+
2324  case armnn::LayerType::Pooling2d :
+
2325  {
+
2326  const armnn::Pooling2dDescriptor& layerDescriptor =
+
2327  static_cast<const armnn::Pooling2dDescriptor&>(descriptor);
+
2328  SerializePooling2dLayer(layer, layerDescriptor, name);
+
2329  break;
+
2330  }
+
2331  case armnn::LayerType::Pooling3d :
+
2332  {
+
2333  const armnn::Pooling3dDescriptor& layerDescriptor =
+
2334  static_cast<const armnn::Pooling3dDescriptor&>(descriptor);
+
2335  SerializePooling3dLayer(layer, layerDescriptor, name);
+
2336  break;
+
2337  }
+
2338  case armnn::LayerType::Prelu :
+
2339  {
+
2340  SerializePreluLayer(layer, name);
+
2341  break;
+
2342  }
+
2343  case armnn::LayerType::Quantize :
+
2344  {
+
2345  SerializeQuantizeLayer(layer, name);
+
2346  break;
+
2347  }
+
2348  case armnn::LayerType::QuantizedLstm:
+
2349  SerializeQuantizedLstmLayer(layer, constants, name);
+
2350  break;
+
2351  case armnn::LayerType::Reshape:
+
2352  {
+
2353  const armnn::ReshapeDescriptor &layerDescriptor =
+
2354  static_cast<const armnn::ReshapeDescriptor &>(descriptor);
+
2355  SerializeReshapeLayer(layer, layerDescriptor, name);
+
2356  break;
+
2357  }
+
2358  case armnn::LayerType::Rank:
+
2359  {
+
2360  SerializeRankLayer(layer, name);
+
2361  break;
+
2362  }
+
2363  case armnn::LayerType::Reduce:
+
2364  {
+
2365  const armnn::ReduceDescriptor& layerDescriptor =
+
2366  static_cast<const armnn::ReduceDescriptor&>(descriptor);
+
2367  SerializeReduceLayer(layer, layerDescriptor, name);
+
2368  break;
+
2369  }
+
2370  case armnn::LayerType::Resize:
+
2371  {
+
2372  const armnn::ResizeDescriptor& layerDescriptor =
+
2373  static_cast<const armnn::ResizeDescriptor&>(descriptor);
+
2374  SerializeResizeLayer(layer, layerDescriptor, name);
+
2375  break;
+
2376  }
+
2377  case armnn::LayerType::ReverseV2:
+
2378  {
+
2379  SerializeReverseV2Layer(layer, name);
+
2380  break;
+
2381  }
+
2382  case armnn::LayerType::Shape:
+
2383  {
+
2384  SerializeShapeLayer(layer, name);
+
2385  break;
+
2386  }
+
2387  case armnn::LayerType::Slice:
+
2388  {
+
2389  const armnn::SliceDescriptor& layerDescriptor =
+
2390  static_cast<const armnn::SliceDescriptor&>(descriptor);
+
2391  SerializeSliceLayer(layer, layerDescriptor, name);
+
2392  break;
+
2393  }
+
2394  case armnn::LayerType::Softmax:
+
2395  {
+
2396  const armnn::SoftmaxDescriptor& layerDescriptor =
+
2397  static_cast<const armnn::SoftmaxDescriptor&>(descriptor);
+
2398  SerializeSoftmaxLayer(layer, layerDescriptor, name);
+
2399  break;
+
2400  }
+
2401  case armnn::LayerType::SpaceToBatchNd:
+
2402  {
+
2403  const armnn::SpaceToBatchNdDescriptor& layerDescriptor =
+
2404  static_cast<const armnn::SpaceToBatchNdDescriptor&>(descriptor);
+
2405  SerializeSpaceToBatchNdLayer(layer, layerDescriptor, name);
+
2406  break;
+
2407  }
+
2408  case armnn::LayerType::SpaceToDepth:
+
2409  {
+
2410  const armnn::SpaceToDepthDescriptor& layerDescriptor =
+
2411  static_cast<const armnn::SpaceToDepthDescriptor&>(descriptor);
+
2412  SerializeSpaceToDepthLayer(layer, layerDescriptor, name);
+
2413  break;
+
2414  }
+
2415  case armnn::LayerType::Splitter:
+
2416  {
+
2417  const armnn::SplitterDescriptor& layerDescriptor =
+
2418  static_cast<const armnn::SplitterDescriptor&>(descriptor);
+
2419  SerializeSplitterLayer(layer, layerDescriptor, name);
+
2420  break;
+
2421  }
+
2422  case armnn::LayerType::Stack:
+
2423  {
+
2424  const armnn::StackDescriptor& layerDescriptor =
+
2425  static_cast<const armnn::StackDescriptor&>(descriptor);
+
2426  SerializeStackLayer(layer, layerDescriptor, name);
+
2427  break;
+
2428  }
+
2429  case armnn::LayerType::StandIn:
+
2430  {
+
2431  const armnn::StandInDescriptor& layerDescriptor =
+
2432  static_cast<const armnn::StandInDescriptor&>(descriptor);
+
2433  SerializeStandInLayer(layer, layerDescriptor, name);
+
2434  break;
+
2435  }
+
2436  case armnn::LayerType::StridedSlice:
+
2437  {
+
2438  const armnn::StridedSliceDescriptor& layerDescriptor =
+
2439  static_cast<const armnn::StridedSliceDescriptor&>(descriptor);
+
2440  SerializeStridedSliceLayer(layer, layerDescriptor, name);
+
2441  break;
+
2442  }
+
2443  case armnn::LayerType::Subtraction:
+
2444  {
+
2445  SerializeSubtractionLayer(layer, name);
+
2446  break;
+
2447  }
+
2448  case armnn::LayerType::Switch:
+
2449  {
+
2450  SerializeSwitchLayer(layer, name);
+
2451  break;
+
2452  }
+
2453  case armnn::LayerType::Tile:
+
2454  {
+
2455  const armnn::TileDescriptor& layerDescriptor =
+
2456  static_cast<const armnn::TileDescriptor&>(descriptor);
+
2457  SerializeTileLayer(layer, layerDescriptor, name);
+
2458  break;
+
2459  }
+
2460  case armnn::LayerType::Transpose:
+
2461  {
+
2462  const armnn::TransposeDescriptor& layerDescriptor =
+
2463  static_cast<const armnn::TransposeDescriptor&>(descriptor);
+
2464  SerializeTransposeLayer(layer, layerDescriptor, name);
+
2465  break;
+
2466  }
+
2467  case armnn::LayerType::TransposeConvolution2d:
+
2468  {
+
2469  const armnn::TransposeConvolution2dDescriptor& layerDescriptor =
+
2470  static_cast<const armnn::TransposeConvolution2dDescriptor&>(descriptor);
+
2471  SerializeTransposeConvolution2dLayer(layer, layerDescriptor, constants, name);
+
2472  break;
+
2473  }
+
2474  case armnn::LayerType::UnidirectionalSequenceLstm :
+
2475  {
+
2476  const armnn::UnidirectionalSequenceLstmDescriptor& layerDescriptor =
+
2477  static_cast<const armnn::UnidirectionalSequenceLstmDescriptor&>(descriptor);
+
2478  SerializeUnidirectionalSequenceLstmLayer(layer, layerDescriptor, constants, name);
+
2479  break;
+
2480  }
+
2481  default:
+
2482  {
+
2483  throw InvalidArgumentException(
+
2484  fmt::format("A layer of unknown type was given to the serializer. Layer name: {}; Layer Id: {}",
+
2485  layer->GetName(),
+
2486  id));
+
2487  }
+
2488  }
+
2489 }
+
+

References armnn::Activation, armnn::Addition, armnn::ArgMinMax, armnn::BatchMatMul, armnn::BatchNormalization, armnn::BatchToSpaceNd, armnn::Cast, armnn::ChannelShuffle, armnn::Comparison, armnn::Concat, armnn::Constant, armnn::Convolution2d, armnn::Convolution3d, armnn::DepthToSpace, armnn::DepthwiseConvolution2d, armnn::Dequantize, armnn::DetectionPostProcess, armnn::Division, armnn::ElementwiseBinary, armnn::ElementwiseUnary, armnn::Fill, armnn::Floor, armnn::FullyConnected, armnn::Gather, armnn::GatherNd, IConnectableLayer::GetName(), IConnectableLayer::GetType(), armnn::IgnoreUnused(), armnn::Input, armnn::InstanceNormalization, armnn::L2Normalization, armnn::LogicalBinary, armnn::LogSoftmax, armnn::Lstm, armnn::Maximum, armnn::Mean, armnn::Merge, armnn::Minimum, armnn::Multiplication, armnn::Normalization, armnn::Output, armnn::Pad, armnn::Permute, armnn::Pooling2d, armnn::Pooling3d, armnn::Prelu, armnn::QLstm, armnn::Quantize, armnn::QuantizedLstm, armnn::Rank, armnn::Reduce, armnn::Reshape, armnn::Resize, armnn::ReverseV2, armnn::Shape, armnn::Slice, armnn::Softmax, armnn::SpaceToBatchNd, armnn::SpaceToDepth, armnn::Splitter, armnn::Stack, armnn::StandIn, armnn::StridedSlice, armnn::Subtraction, armnn::Switch, armnn::Tile, armnn::Transpose, armnn::TransposeConvolution2d, and armnn::UnidirectionalSequenceLstm.

+ +
+
+ +

◆ GetFlatBufferBuilder()

+ +
+
+ + + + + +
+ + + + + + + +
flatbuffers::FlatBufferBuilder& GetFlatBufferBuilder ()
+ 		+inline
+
+ +

Definition at line 34 of file Serializer.hpp.

+
35  {
+
36  return m_flatBufferBuilder;
+
37  }
+
+
+
+ +

◆ GetInputIds()

+ +
+
+ + + + + +
+ + + + + + + +
std::vector<int>& GetInputIds ()
+ 		+inline
+
+ +

Definition at line 39 of file Serializer.hpp.

+
40  {
+
41  return m_inputIds;
+
42  }
+
+
+
+ +

◆ GetOutputIds()

+ +
+
+ + + + + +
+ + + + + + + +
std::vector<int>& GetOutputIds ()
+ 		+inline
+
+ +

Definition at line 44 of file Serializer.hpp.

+
45  {
+
46  return m_outputIds;
+
47  }
+
+
+
+ +

◆ GetSerializedLayers()

+ +
+
+ + + + + +
+ + + + + + + +
std::vector<flatbuffers::Offset<armnnSerializer::AnyLayer> >& GetSerializedLayers ()
+ 		+inline
+
+ +

Definition at line 49 of file Serializer.hpp.

+
50  {
+
51  return m_serializedLayers;
+
52  }
+
+
+
+ +

◆ GetVersionTable()

+ +
+
+ + + + + + + +
flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > GetVersionTable ()
+
+ +

Definition at line 1972 of file Serializer.cpp.

+
1973 {
+
1974  flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> versionsTable =
+
1975  serializer::CreateFeatureCompatibilityVersions(
+
1976  m_flatBufferBuilder,
+
1977  1, // Binding ids scheme version
+
1978  1, // Weights layout scheme version
+
1979  1 // Constant tensors as inputs version
+
1980  );
+
1981  return versionsTable;
+
1982 }
+
+
+
+
The documentation for this class was generated from the following files: +
+
+
armnn::BatchNormalizationDescriptor
A BatchNormalizationDescriptor for the BatchNormalizationLayer.
Definition: Descriptors.hpp:828
+ +
armnn::ViewsDescriptor
A ViewsDescriptor for the SplitterLayer.
Definition: Descriptors.hpp:244
+ +
armnn::ActivationDescriptor
An ActivationDescriptor for the ActivationLayer.
Definition: Descriptors.hpp:36
+
armnn::FullyConnectedDescriptor
A FullyConnectedDescriptor for the FullyConnectedLayer.
Definition: Descriptors.hpp:507
+ + +
armnn::QLstmDescriptor
A QLstmDescriptor for the QLstmLayer.
Definition: Descriptors.hpp:1380
+
armnn::Pooling3dDescriptor
A Pooling3dDescriptor for the Pooling3dLayer.
Definition: Descriptors.hpp:431
+
armnn::ResizeDescriptor
A ResizeDescriptor for the ResizeLayer.
Definition: Descriptors.hpp:985
+
armnn::ArgMinMaxDescriptor
An ArgMinMaxDescriptor for ArgMinMaxLayer.
Definition: Descriptors.hpp:67
+
armnn::IConnectableLayer::GetName
virtual const char * GetName() const =0
Returns the name of the layer.
+
armnn::InstanceNormalizationDescriptor
An InstanceNormalizationDescriptor for InstanceNormalizationLayer.
Definition: Descriptors.hpp:847
+
armnn::GatherDescriptor
A GatherDescriptor for the GatherLayer.
Definition: Descriptors.hpp:965
+ + +
armnn::L2NormalizationDescriptor
A L2NormalizationDescriptor for the L2NormalizationLayer.
Definition: Descriptors.hpp:809
+ +
armnn::NormalizationDescriptor
A NormalizationDescriptor for the NormalizationLayer.
Definition: Descriptors.hpp:769
+ + +
armnn::ChannelShuffleDescriptor
A ChannelShuffleDescriptor for the ChannelShuffle operator.
Definition: Descriptors.hpp:1562
+ + +
armnn::StackDescriptor
A StackDescriptor for the StackLayer.
Definition: Descriptors.hpp:1251
+ + + + + + +
armnn::ElementwiseBinaryDescriptor
A ElementwiseBinaryDescriptor for the ElementwiseBinaryLayer.
Definition: Descriptors.hpp:109
+ + + + + + +
armnn::PadDescriptor
A PadDescriptor for the PadLayer.
Definition: Descriptors.hpp:1196
+
armnn::TransposeDescriptor
A TransposeDescriptor for the TransposeLayer.
Definition: Descriptors.hpp:1490
+ + +
armnn::SliceDescriptor
A SliceDescriptor for the SliceLayer.
Definition: Descriptors.hpp:1228
+ + +
armnn::ReshapeDescriptor
A ReshapeDescriptor for the ReshapeLayer.
Definition: Descriptors.hpp:1023
+ + + +
armnn::PermuteDescriptor
A PermuteDescriptor for the PermuteLayer.
Definition: Descriptors.hpp:149
+
armnn::BatchMatMulDescriptor
A BatchMatMulDescriptor for the BatchMatMul operator.
Definition: Descriptors.hpp:1584
+
armnn::IConnectableLayer::GetType
virtual LayerType GetType() const =0
Returns the armnn::LayerType of this layer.
+ +
armnn::SpaceToBatchNdDescriptor
A SpaceToBatchNdDescriptor for the SpaceToBatchNdLayer.
Definition: Descriptors.hpp:1043
+
armnn::Convolution3dDescriptor
A Convolution3dDescriptor for the Convolution3dLayer.
Definition: Descriptors.hpp:588
+ + + + + +
armnn::BatchToSpaceNdDescriptor
A BatchToSpaceNdDescriptor for the BatchToSpaceNdLayer.
Definition: Descriptors.hpp:875
+
armnn::Convolution2dDescriptor
A Convolution2dDescriptor for the Convolution2dLayer.
Definition: Descriptors.hpp:534
+
armnn::ComparisonDescriptor
A ComparisonDescriptor for the ComparisonLayer.
Definition: Descriptors.hpp:89
+
armnn::FillDescriptor
A FillDescriptor for the FillLayer.
Definition: Descriptors.hpp:925
+ + +
armnn::StandInDescriptor
A StandInDescriptor for the StandIn layer.
Definition: Descriptors.hpp:1281
+ + + + + + +
armnn::LstmDescriptor
An LstmDescriptor for the LstmLayer.
Definition: Descriptors.hpp:1102
+
armnn::StridedSliceDescriptor
A StridedSliceDescriptor for the StridedSliceLayer.
Definition: Descriptors.hpp:1303
+ +
armnn::LogicalBinaryDescriptor
A LogicalBinaryDescriptor for the LogicalBinaryLayer.
Definition: Descriptors.hpp:1518
+ + + + +
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
+ + + +
armnn::OriginsDescriptor
An OriginsDescriptor for the ConcatLayer.
Definition: Descriptors.hpp:201
+
armnn::ElementwiseUnaryDescriptor
A ElementwiseUnaryDescriptor for the ElementwiseUnaryLayer.
Definition: Descriptors.hpp:129
+
armnn::TransposeConvolution2dDescriptor
A TransposeConvolution2dDescriptor for the TransposeConvolution2dLayer.
Definition: Descriptors.hpp:1440
+ + + + + + +
armnn::DetectionPostProcessDescriptor
Definition: Descriptors.hpp:713
+ +
armnn::Pooling2dDescriptor
A Pooling2dDescriptor for the Pooling2dLayer.
Definition: Descriptors.hpp:371
+ + +
armnn::DepthwiseConvolution2dDescriptor
A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer.
Definition: Descriptors.hpp:659
+ + + +
armnn::ReduceDescriptor
A ReduceDescriptor for the REDUCE operators.
Definition: Descriptors.hpp:1538
+
armnn::MeanDescriptor
A MeanDescriptor for the MeanLayer.
Definition: Descriptors.hpp:1172
+ + +
armnn::SoftmaxDescriptor
A SoftmaxDescriptor for the SoftmaxLayer.
Definition: Descriptors.hpp:177
+
armnn::SpaceToDepthDescriptor
A SpaceToDepthDescriptor for the SpaceToDepthLayer.
Definition: Descriptors.hpp:1075
+ + + + + + -- cgit v1.2.1