From 087eaf67dc4be4234a7fcfc3b109c1e4f5e7dd5e Mon Sep 17 00:00:00 2001 From: Georgios Pinitas Date: Wed, 16 May 2018 15:52:35 +0100 Subject: COMPMID-1176: Adds nodes to the graph. Nodes added: -ChannelShuffle -Resize -Deconvolution -Dummy (used for performance analysis and debugging) Change-Id: Iad19960cbbce6e25532f77bfd34b2292c0ca9781 Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/131672 Tested-by: Jenkins Reviewed-by: Pablo Tello Reviewed-by: Anthony Barbier --- arm_compute/graph/GraphBuilder.h | 51 +++++++++ arm_compute/graph/TypePrinter.h | 27 +++++ arm_compute/graph/Types.h | 7 +- arm_compute/graph/backends/ValidateHelpers.h | 23 +++++ arm_compute/graph/frontend/Layers.h | 120 ++++++++++++++++++++++ arm_compute/graph/frontend/Types.h | 2 + arm_compute/graph/nodes/ChannelShuffleLayerNode.h | 59 +++++++++++ arm_compute/graph/nodes/DeconvolutionLayerNode.h | 79 ++++++++++++++ arm_compute/graph/nodes/DummyNode.h | 61 +++++++++++ arm_compute/graph/nodes/Nodes.h | 4 + arm_compute/graph/nodes/NodesFwd.h | 4 + arm_compute/graph/nodes/ResizeLayerNode.h | 63 ++++++++++++ 12 files changed, 499 insertions(+), 1 deletion(-) create mode 100644 arm_compute/graph/nodes/ChannelShuffleLayerNode.h create mode 100644 arm_compute/graph/nodes/DeconvolutionLayerNode.h create mode 100644 arm_compute/graph/nodes/DummyNode.h create mode 100644 arm_compute/graph/nodes/ResizeLayerNode.h (limited to 'arm_compute/graph') diff --git a/arm_compute/graph/GraphBuilder.h b/arm_compute/graph/GraphBuilder.h index 04edf673d1..6359e05a63 100644 --- a/arm_compute/graph/GraphBuilder.h +++ b/arm_compute/graph/GraphBuilder.h @@ -97,6 +97,16 @@ public: static NodeID add_batch_normalization_node(Graph &g, NodeParams params, NodeIdxPair input, float epsilon, ITensorAccessorUPtr mean_accessor = nullptr, ITensorAccessorUPtr var_accessor = nullptr, ITensorAccessorUPtr beta_accessor = nullptr, ITensorAccessorUPtr gamma_accessor = nullptr); + /** Adds an channel shuffle layer node to the graph + * + * @param[in] g Graph to add the node to + * @param[in] params Common node parameters + * @param[in] input Input to the activation layer node as a NodeID-Index pair + * @param[in] num_groups Number of groups + * + * @return Node ID of the created node, EmptyNodeID in case of error + */ + static NodeID add_channel_shuffle_node(Graph &g, NodeParams params, NodeIdxPair input, unsigned int num_groups); /** Adds a convolution layer node to the graph * * TODO (COMPMID-1113): Add a graph descriptor for convolution layer node @@ -123,6 +133,23 @@ public: ITensorAccessorUPtr weights_accessor = nullptr, ITensorAccessorUPtr bias_accessor = nullptr, const QuantizationInfo weights_quant_info = QuantizationInfo(), const QuantizationInfo out_quant_info = QuantizationInfo()); + /** Adds a deconvolution layer node to the graph + * + * @param[in] g Graph to add the node to + * @param[in] params Common node parameters + * @param[in] input Input to the convolution layer node as a NodeID-Index pair + * @param[in] kernel_spatial_extend Spatial extend of convolution kernels + * @param[in] depth Number of convolution kernels + * @param[in] deconv_info Convolution layer information + * @param[in] inner_border Inner border (right, top) + * @param[in] weights_accessor (Optional) Accessor of the weights node data + * @param[in] bias_accessor (Optional) Accessor of the bias node data + * + * @return Node ID of the created node, EmptyNodeID in case of error + */ + static NodeID add_deconvolution_node(Graph &g, NodeParams params, NodeIdxPair input, + Size2D kernel_spatial_extend, unsigned int depth, PadStrideInfo deconv_info, Size2D inner_border, + ITensorAccessorUPtr weights_accessor = nullptr, ITensorAccessorUPtr bias_accessor = nullptr); /** Adds a depth concatenate node to the graph * * @param[in] g Graph to add the node to @@ -161,6 +188,18 @@ public: * @return Node ID of the created node, EmptyNodeID in case of error */ static NodeID add_elementwise_node(Graph &g, NodeParams params, NodeIdxPair input0, NodeIdxPair input1, EltwiseOperation operation); + /** Adds a Dummy node to the graph + * + * @note this node if for debugging purposes. Just alters the shape of the graph pipeline as requested. + * + * @param[in] g Graph to add the node to + * @param[in] params Common node parameters + * @param[in] input Input to the dummy node as a NodeID-Index pair + * @param[in] shape Output shape + * + * @return Node ID of the created node, EmptyNodeID in case of error + */ + static NodeID add_dummy_node(Graph &g, NodeParams params, NodeIdxPair input, TensorShape shape); /** Adds a flatten layer node to the graph * * @param[in] g Graph to add the node to @@ -213,6 +252,18 @@ public: * @return Node ID of the created node, EmptyNodeID in case of error */ static NodeID add_reshape_node(Graph &g, NodeParams params, NodeIdxPair input, TensorShape shape); + /** Adds a resize layer node to the graph + * + * @param[in] g Graph to add the node to + * @param[in] params Common node parameters + * @param[in] input Input to the reshape layer node as a NodeID-Index pair + * @param[in] policy Interpolation policy + * @param[in] width_scale Width scaling factor + * @param[in] height_scale Height scaling factor + * + * @return Node ID of the created node, EmptyNodeID in case of error + */ + static NodeID add_resize_node(Graph &g, NodeParams params, NodeIdxPair input, InterpolationPolicy policy, float width_scale, float height_scale); /** Adds a scale layer node to the graph * This layer computes a product of the input with a scale (read from mul_accessor) and it applies an offset (read from add_accessor). * output = input * mul_w + add_w diff --git a/arm_compute/graph/TypePrinter.h b/arm_compute/graph/TypePrinter.h index 6babd3961d..edce77c4ad 100644 --- a/arm_compute/graph/TypePrinter.h +++ b/arm_compute/graph/TypePrinter.h @@ -352,6 +352,33 @@ inline ::std::ostream &operator<<(::std::ostream &os, const QuantizationInfo &qu << "Offset:" << quantization_info.offset; return os; } + +/** Formatted output of the Interpolation policy type. + * + * @param[out] os Output stream. + * @param[in] policy Interpolation policy to output. + * + * @return Modified output stream. + */ +inline ::std::ostream &operator<<(::std::ostream &os, const InterpolationPolicy &policy) +{ + switch(policy) + { + case InterpolationPolicy::NEAREST_NEIGHBOR: + os << "NEAREST NEIGHBOR"; + break; + case InterpolationPolicy::BILINEAR: + os << "BILINEAR"; + break; + case InterpolationPolicy::AREA: + os << "AREA"; + break; + default: + ARM_COMPUTE_ERROR("NOT_SUPPORTED!"); + } + + return os; +} } // namespace graph } // namespace arm_compute #endif /* __ARM_COMPUTE_GRAPH_TYPE_PRINTER_H__ */ diff --git a/arm_compute/graph/Types.h b/arm_compute/graph/Types.h index d4e4f99377..9cfede9cf3 100644 --- a/arm_compute/graph/Types.h +++ b/arm_compute/graph/Types.h @@ -52,6 +52,7 @@ using arm_compute::PadStrideInfo; using arm_compute::PoolingLayerInfo; using arm_compute::PoolingType; using arm_compute::DimensionRoundingType; +using arm_compute::InterpolationPolicy; /** TODO (geopin01): Make ids strongly typed */ using TensorID = unsigned int; @@ -128,7 +129,9 @@ enum class NodeType { ActivationLayer, BatchNormalizationLayer, + ChannelShuffleLayer, ConvolutionLayer, + DeconvolutionLayer, DepthConcatenateLayer, DepthwiseConvolutionLayer, EltwiseLayer, @@ -137,13 +140,15 @@ enum class NodeType NormalizationLayer, PoolingLayer, ReshapeLayer, - ScaleLayer, + ResizeLayer, SoftmaxLayer, SplitLayer, Input, Output, Const, + + Dummy }; /** Backend Memory Manager affinity **/ diff --git a/arm_compute/graph/backends/ValidateHelpers.h b/arm_compute/graph/backends/ValidateHelpers.h index db3f8ba4f9..189fbdc9c7 100644 --- a/arm_compute/graph/backends/ValidateHelpers.h +++ b/arm_compute/graph/backends/ValidateHelpers.h @@ -52,6 +52,29 @@ inline arm_compute::ITensorInfo *get_backing_tensor_info(arm_compute::graph::Ten return ((tensor == nullptr) || (tensor->handle() == nullptr)) ? nullptr : tensor->handle()->tensor().info(); } +/** Validates a Channel Shuffle layer node + * + * @tparam ChannelShuffleLayer Channel Shuffle layer function type + * + * @param[in] node Node to validate + * + * @return Status + */ +template +Status validate_channel_shuffle_layer(ChannelShuffleLayerNode &node) +{ + ARM_COMPUTE_LOG_GRAPH_VERBOSE("Validating ChannelShuffle node with ID : " << node.id() << " and Name: " << node.name() << std::endl); + ARM_COMPUTE_RETURN_ERROR_ON(node.num_inputs() != 1); + ARM_COMPUTE_RETURN_ERROR_ON(node.num_outputs() != 1); + + // Extract IO and info + arm_compute::ITensorInfo *input = get_backing_tensor_info(node.input(0)); + arm_compute::ITensorInfo *output = get_backing_tensor_info(node.output(0)); + const unsigned int num_groups = node.num_groups(); + + return ChannelShuffleLayer::validate(input, output, num_groups); +} + /** Validates a Convolution layer node * * @tparam ConvolutionLayer Default Convolution layer function type diff --git a/arm_compute/graph/frontend/Layers.h b/arm_compute/graph/frontend/Layers.h index a97684453c..197d2ea409 100644 --- a/arm_compute/graph/frontend/Layers.h +++ b/arm_compute/graph/frontend/Layers.h @@ -154,6 +154,30 @@ private: float _epsilon; }; +/** Channel Shuffle Layer */ +class ChannelShuffleLayer final : public ILayer +{ +public: + /** Construct a Channel Shuffle layer. + * + * @param[in] num_groups Number of groups + */ + ChannelShuffleLayer(unsigned int num_groups) + : _num_groups(num_groups) + { + } + + NodeID create_layer(IStream &s) override + { + NodeParams common_params = { name(), s.hints().target_hint }; + NodeIdxPair input = { s.tail_node(), 0 }; + return GraphBuilder::add_channel_shuffle_node(s.graph(), common_params, input, _num_groups); + } + +private: + unsigned int _num_groups; +}; + /** Convolution Layer */ class ConvolutionLayer final : public ILayer { @@ -213,6 +237,56 @@ private: const QuantizationInfo _out_quant_info; }; +/** Deconvolution Layer */ +class DeconvolutionLayer final : public ILayer +{ +public: + /** Construct a convolution layer. + * + * @param[in] conv_width Convolution width. + * @param[in] conv_height Convolution height. + * @param[in] ofm Output feature map. + * @param[in] weights Accessor to get kernel weights from. + * @param[in] bias Accessor to get kernel bias from. + * @param[in] deconv_info Padding and stride information. + * @param[in] inner_border Inner border padding (right, top) + */ + DeconvolutionLayer(unsigned int conv_width, + unsigned int conv_height, + unsigned int ofm, + ITensorAccessorUPtr weights, + ITensorAccessorUPtr bias, + PadStrideInfo deconv_info, + Size2D inner_border) + : _conv_width(conv_width), + _conv_height(conv_height), + _ofm(ofm), + _deconv_info(std::move(deconv_info)), + _inner_border(inner_border), + _weights(std::move(weights)), + _bias(std::move(bias)) + { + } + + NodeID create_layer(IStream &s) override + { + NodeIdxPair input = { s.tail_node(), 0 }; + NodeParams common_params = { name(), s.hints().target_hint }; + return GraphBuilder::add_deconvolution_node(s.graph(), common_params, input, + Size2D(_conv_width, _conv_height), _ofm, _deconv_info, _inner_border, + std::move(_weights), std::move(_bias)); + } + +private: + unsigned int _conv_width; + unsigned int _conv_height; + unsigned int _ofm; + const PadStrideInfo _deconv_info; + Size2D _inner_border; + ITensorAccessorUPtr _weights; + ITensorAccessorUPtr _bias; +}; + /** Depthwise Convolution Layer */ class DepthwiseConvolutionLayer final : public ILayer { @@ -260,6 +334,30 @@ private: const QuantizationInfo _quant_info; }; +/** Dummy Layer */ +class DummyLayer final : public ILayer +{ +public: + /** Construct an input layer. + * + * @param[in] shape Output shape + */ + DummyLayer(TensorShape shape) + : _shape(shape) + { + } + + NodeID create_layer(IStream &s) override + { + NodeParams common_params = { name(), s.hints().target_hint }; + NodeIdxPair input = { s.tail_node(), 0 }; + return GraphBuilder::add_dummy_node(s.graph(), common_params, input, _shape); + } + +private: + TensorShape _shape; +}; + /** Flatten Layer */ class FlattenLayer final : public ILayer { @@ -380,6 +478,28 @@ private: TensorShape _shape; }; +/** Resize Layer */ +class ResizeLayer final : public ILayer +{ +public: + ResizeLayer(InterpolationPolicy policy, float width_scale, float height_scale) + : _policy(policy), _width_scale(width_scale), _height_scale(height_scale) + { + } + + NodeID create_layer(IStream &s) override + { + NodeParams common_params = { name(), s.hints().target_hint }; + NodeIdxPair input = { s.tail_node(), 0 }; + return GraphBuilder::add_resize_node(s.graph(), common_params, input, _policy, _width_scale, _height_scale); + } + +private: + InterpolationPolicy _policy; + float _width_scale; + float _height_scale; +}; + /** Scale Layer */ class ScaleLayer final : public ILayer { diff --git a/arm_compute/graph/frontend/Types.h b/arm_compute/graph/frontend/Types.h index 47893613c7..cd579e2119 100644 --- a/arm_compute/graph/frontend/Types.h +++ b/arm_compute/graph/frontend/Types.h @@ -50,6 +50,8 @@ using graph::DepthwiseConvolutionMethod; using graph::TensorDescriptor; using graph::DimensionRoundingType; using graph::GraphConfig; +using graph::InterpolationPolicy; +using graph::Size2D; /** Branch layer merging method */ enum class BranchMergeMethod diff --git a/arm_compute/graph/nodes/ChannelShuffleLayerNode.h b/arm_compute/graph/nodes/ChannelShuffleLayerNode.h new file mode 100644 index 0000000000..696012a818 --- /dev/null +++ b/arm_compute/graph/nodes/ChannelShuffleLayerNode.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2018 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef __ARM_COMPUTE_GRAPH_CHANNEL_SHUFFLE_LAYER_NODE_H__ +#define __ARM_COMPUTE_GRAPH_CHANNEL_SHUFFLE_LAYER_NODE_H__ + +#include "arm_compute/graph/INode.h" + +namespace arm_compute +{ +namespace graph +{ +/** Channel Shuffle Layer node */ +class ChannelShuffleLayerNode final : public INode +{ +public: + /** Constructor + * + * @param[in] num_groups Number of groups + */ + ChannelShuffleLayerNode(unsigned int num_groups); + /** Number of groups accessor + * + * @return Number of groups + */ + unsigned int num_groups() const; + + // Inherited overridden methods: + NodeType type() const override; + bool forward_descriptors() override; + TensorDescriptor configure_output(size_t idx) const override; + void accept(INodeVisitor &v) override; + +private: + unsigned int _num_groups; +}; +} // namespace graph +} // namespace arm_compute +#endif /* __ARM_COMPUTE_GRAPH_CHANNEL_SHUFFLE_LAYER_NODE_H__ */ diff --git a/arm_compute/graph/nodes/DeconvolutionLayerNode.h b/arm_compute/graph/nodes/DeconvolutionLayerNode.h new file mode 100644 index 0000000000..73210a299e --- /dev/null +++ b/arm_compute/graph/nodes/DeconvolutionLayerNode.h @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2018 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef __ARM_COMPUTE_GRAPH_DECONVOLUTION_LAYER_NODE_H__ +#define __ARM_COMPUTE_GRAPH_DECONVOLUTION_LAYER_NODE_H__ + +#include "arm_compute/graph/INode.h" + +namespace arm_compute +{ +namespace graph +{ +/** Deconvolution Layer node */ +class DeconvolutionLayerNode final : public INode +{ +public: + /** Constructor + * + * @param[in] info DeConvolution layer attributes + * @param[in] inner_border Inner border (right, top) + */ + DeconvolutionLayerNode(PadStrideInfo info, Size2D inner_border); + /** Deconvolution metadata accessor + * + * @return Deconvolution information + */ + PadStrideInfo deconvolution_info() const; + /** Deconvolution inner border accessor + * + * @return Inner border(top, right) + */ + Size2D inner_border() const; + /** Computes deconvolution output descriptor + * + * @param[in] input_descriptor Input descriptor + * @param[in] weights_descriptor Weights descriptor + * @param[in] info Convolution operation attributes + * @param[in] inner_border Inner border (right, top) + * + * @return Output descriptor + */ + static TensorDescriptor compute_output_descriptor(const TensorDescriptor &input_descriptor, + const TensorDescriptor &weights_descriptor, + const PadStrideInfo &info, + const Size2D &inner_border); + + // Inherited overridden methods: + NodeType type() const override; + bool forward_descriptors() override; + TensorDescriptor configure_output(size_t idx) const override; + void accept(INodeVisitor &v) override; + +private: + PadStrideInfo _info; + Size2D _inner_border; +}; +} // namespace graph +} // namespace arm_compute +#endif /* __ARM_COMPUTE_GRAPH_DECONVOLUTION_LAYER_NODE_H__ */ diff --git a/arm_compute/graph/nodes/DummyNode.h b/arm_compute/graph/nodes/DummyNode.h new file mode 100644 index 0000000000..72d73ec825 --- /dev/null +++ b/arm_compute/graph/nodes/DummyNode.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2018 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef __ARM_COMPUTE_GRAPH_DUMMY_NODE_H__ +#define __ARM_COMPUTE_GRAPH_DUMMY_NODE_H__ + +#include "arm_compute/graph/INode.h" + +namespace arm_compute +{ +namespace graph +{ +/** Dummy Layer node + * + * Dummy layer transforms a given input to a specified output with a given shape. + * + * @note Used only for debugging/performance reasons. + * @note It does not perform any computation at all. + * @note Can be used to simulate graphs that they have nodes that are not yet supported. + */ +class DummyNode final : public INode +{ +public: + /** Constructor + * + * @param[in] shape Reshaped tensor shape + */ + DummyNode(TensorShape shape); + + // Inherited overridden methods: + NodeType type() const override; + bool forward_descriptors() override; + TensorDescriptor configure_output(size_t idx) const override; + void accept(INodeVisitor &v) override; + +private: + TensorShape _shape; +}; +} // namespace graph +} // namespace arm_compute +#endif /* __ARM_COMPUTE_GRAPH_DUMMY_NODE_H__ */ \ No newline at end of file diff --git a/arm_compute/graph/nodes/Nodes.h b/arm_compute/graph/nodes/Nodes.h index c39546c6bd..97aa191916 100644 --- a/arm_compute/graph/nodes/Nodes.h +++ b/arm_compute/graph/nodes/Nodes.h @@ -26,10 +26,13 @@ #include "arm_compute/graph/nodes/ActivationLayerNode.h" #include "arm_compute/graph/nodes/BatchNormalizationLayerNode.h" +#include "arm_compute/graph/nodes/ChannelShuffleLayerNode.h" #include "arm_compute/graph/nodes/ConstNode.h" #include "arm_compute/graph/nodes/ConvolutionLayerNode.h" +#include "arm_compute/graph/nodes/DeconvolutionLayerNode.h" #include "arm_compute/graph/nodes/DepthConcatenateLayerNode.h" #include "arm_compute/graph/nodes/DepthwiseConvolutionLayerNode.h" +#include "arm_compute/graph/nodes/DummyNode.h" #include "arm_compute/graph/nodes/EltwiseLayerNode.h" #include "arm_compute/graph/nodes/FlattenLayerNode.h" #include "arm_compute/graph/nodes/FullyConnectedLayerNode.h" @@ -38,6 +41,7 @@ #include "arm_compute/graph/nodes/OutputNode.h" #include "arm_compute/graph/nodes/PoolingLayerNode.h" #include "arm_compute/graph/nodes/ReshapeLayerNode.h" +#include "arm_compute/graph/nodes/ResizeLayerNode.h" #include "arm_compute/graph/nodes/SoftmaxLayerNode.h" #include "arm_compute/graph/nodes/SplitLayerNode.h" diff --git a/arm_compute/graph/nodes/NodesFwd.h b/arm_compute/graph/nodes/NodesFwd.h index b90cb5c308..05979d796c 100644 --- a/arm_compute/graph/nodes/NodesFwd.h +++ b/arm_compute/graph/nodes/NodesFwd.h @@ -32,10 +32,13 @@ namespace graph class INode; class ActivationLayerNode; class BatchNormalizationLayerNode; +class ChannelShuffleLayerNode; class ConstNode; class ConvolutionLayerNode; +class DeconvolutionLayerNode; class DepthConcatenateLayerNode; class DepthwiseConvolutionLayerNode; +class DummyNode; class EltwiseLayerNode; class FlattenLayerNode; class FullyConnectedLayerNode; @@ -44,6 +47,7 @@ class NormalizationLayerNode; class OutputNode; class PoolingLayerNode; class ReshapeLayerNode; +class ResizeLayerNode; class SoftmaxLayerNode; class SplitLayerNode; } // namespace graph diff --git a/arm_compute/graph/nodes/ResizeLayerNode.h b/arm_compute/graph/nodes/ResizeLayerNode.h new file mode 100644 index 0000000000..231e79e62e --- /dev/null +++ b/arm_compute/graph/nodes/ResizeLayerNode.h @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2018 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef __ARM_COMPUTE_GRAPH_RESIZE_LAYER_NODE_H__ +#define __ARM_COMPUTE_GRAPH_RESIZE_LAYER_NODE_H__ + +#include "arm_compute/graph/INode.h" + +namespace arm_compute +{ +namespace graph +{ +/** Resize Layer node */ +class ResizeLayerNode final : public INode +{ +public: + /** Default Constructor */ + ResizeLayerNode(InterpolationPolicy policy, float scale_width, float scale_height); + /** Interpolation policy accessor + * + * @return Interpolation policy + */ + InterpolationPolicy policy() const; + /** Scaling factor accessors + * + * @return Scaling factors (width, height) + */ + std::pair scaling_factor() const; + + // Inherited overridden methods: + NodeType type() const override; + bool forward_descriptors() override; + TensorDescriptor configure_output(size_t idx) const override; + void accept(INodeVisitor &v) override; + +private: + InterpolationPolicy _policy; + float _scale_width; + float _scale_height; +}; +} // namespace graph +} // namespace arm_compute +#endif /* __ARM_COMPUTE_GRAPH_RESIZE_LAYER_NODE_H__ */ -- cgit v1.2.1