C++ API Reference for Intel® Data Analytics Acceleration Library 2019 Update 5

spatial_maximum_pooling2d_layer_backward.h
1 /* file: spatial_maximum_pooling2d_layer_backward.h */
2 /*******************************************************************************
3 * Copyright 2014-2019 Intel Corporation.
4 *
5 * This software and the related documents are Intel copyrighted materials, and
6 * your use of them is governed by the express license under which they were
7 * provided to you (License). Unless the License provides otherwise, you may not
8 * use, modify, copy, publish, distribute, disclose or transmit this software or
9 * the related documents without Intel's prior written permission.
10 *
11 * This software and the related documents are provided as is, with no express
12 * or implied warranties, other than those that are expressly stated in the
13 * License.
14 *******************************************************************************/
15 
16 /*
17 //++
18 // Implementation of the interface for the backward spatial pyramid maximum two-dimensional (2D) pooling layer
19 // in the batch processing mode
20 //--
21 */
22 
23 #ifndef __SPATIAL_MAXIMUM_POOLING2D_LAYER_BACKWARD_H__
24 #define __SPATIAL_MAXIMUM_POOLING2D_LAYER_BACKWARD_H__
25 
26 #include "algorithms/algorithm.h"
27 #include "data_management/data/tensor.h"
28 #include "services/daal_defines.h"
29 #include "algorithms/neural_networks/layers/layer.h"
30 #include "algorithms/neural_networks/layers/spatial_pooling2d/spatial_maximum_pooling2d_layer_types.h"
31 #include "algorithms/neural_networks/layers/spatial_pooling2d/spatial_maximum_pooling2d_layer_backward_types.h"
32 
33 namespace daal
34 {
35 namespace algorithms
36 {
37 namespace neural_networks
38 {
39 namespace layers
40 {
41 namespace spatial_maximum_pooling2d
42 {
43 namespace backward
44 {
48 namespace interface1
49 {
55 template<typename algorithmFPType, Method method, CpuType cpu>
56 class DAAL_EXPORT BatchContainer : public AnalysisContainerIface<batch>
57 {};
68 template<typename algorithmFPType, CpuType cpu>
69 class DAAL_EXPORT BatchContainer<algorithmFPType, defaultDense, cpu> : public AnalysisContainerIface<batch>
70 {
71 public:
77  BatchContainer(daal::services::Environment::env *daalEnv);
79  ~BatchContainer();
85  services::Status compute() DAAL_C11_OVERRIDE;
86 };
87 
106 template<typename algorithmFPType = DAAL_ALGORITHM_FP_TYPE, Method method = defaultDense>
107 class Batch : public layers::backward::LayerIfaceImpl
108 {
109 public:
110  typedef layers::backward::LayerIfaceImpl super;
111 
112  typedef algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::Input InputType;
113  typedef algorithms::neural_networks::layers::spatial_maximum_pooling2d::Parameter ParameterType;
114  typedef algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::Result ResultType;
115 
116  ParameterType &parameter;
117  InputType input;
124  Batch(size_t pyramidHeight, size_t nDimensions) : _defaultParameter(pyramidHeight, nDimensions - 2, nDimensions - 1), parameter(_defaultParameter)
125  {
126  initialize();
127  }
128 
134  Batch(ParameterType& parameter) : parameter(parameter), _defaultParameter(parameter)
135  {
136  initialize();
137  }
138 
145  Batch(const Batch<algorithmFPType, method> &other) : super(other),
146  _defaultParameter(other.parameter), parameter(_defaultParameter), input(other.input)
147  {
148  initialize();
149  }
150 
155  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
156 
161  virtual InputType *getLayerInput() DAAL_C11_OVERRIDE { return &input; }
162 
167  virtual ParameterType *getLayerParameter() DAAL_C11_OVERRIDE { return &parameter; };
168 
173  layers::backward::ResultPtr getLayerResult() DAAL_C11_OVERRIDE
174  {
175  return _result;
176  }
177 
182  ResultPtr getResult()
183  {
184  return _result;
185  }
186 
193  services::Status setResult(const ResultPtr& result)
194  {
195  DAAL_CHECK(result, services::ErrorNullResult)
196  _result = result;
197  _res = _result.get();
198  return services::Status();
199  }
200 
207  services::SharedPtr<Batch<algorithmFPType, method> > clone() const
208  {
209  return services::SharedPtr<Batch<algorithmFPType, method> >(cloneImpl());
210  }
211 
217  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
218  {
219  services::Status s = this->_result->template allocate<algorithmFPType>(&(this->input), &parameter, (int) method);
220  this->_res = this->_result.get();
221  return s;
222  }
223 
224 protected:
225  virtual Batch<algorithmFPType, method> *cloneImpl() const DAAL_C11_OVERRIDE
226  {
227  return new Batch<algorithmFPType, method>(*this);
228  }
229 
230  void initialize()
231  {
232  Analysis<batch>::_ac = new __DAAL_ALGORITHM_CONTAINER(batch, BatchContainer, algorithmFPType, method)(&_env);
233  _in = &input;
234  _par = &parameter;
235  _result.reset(new ResultType());
236  }
237 
238 private:
239  ResultPtr _result;
240  ParameterType _defaultParameter;
241 };
243 } // namespace interface1
244 using interface1::BatchContainer;
245 using interface1::Batch;
246 } // namespace backward
247 } // namespace spatial_maximum_pooling2d
248 } // namespace layers
249 } // namespace neural_networks
250 } // namespace algorithms
251 } // namespace daal
252 
253 #endif
daal
Definition: algorithm_base_common.h:31
daal::algorithms::AnalysisContainerIface
Abstract interface class that provides virtual methods to access and run implementations of the analy...
Definition: analysis.h:53
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::input
InputType input
Definition: spatial_maximum_pooling2d_layer_backward.h:117
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::getLayerInput
virtual InputType * getLayerInput() DAAL_C11_OVERRIDE
Definition: spatial_maximum_pooling2d_layer_backward.h:161
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::allocateResult
virtual services::Status allocateResult() DAAL_C11_OVERRIDE
Definition: spatial_maximum_pooling2d_layer_backward.h:217
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::parameter
ParameterType & parameter
Definition: spatial_maximum_pooling2d_layer_backward.h:116
daal_defines.h
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::setResult
services::Status setResult(const ResultPtr &result)
Definition: spatial_maximum_pooling2d_layer_backward.h:193
daal::batch
Definition: daal_defines.h:110
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::getLayerResult
layers::backward::ResultPtr getLayerResult() DAAL_C11_OVERRIDE
Definition: spatial_maximum_pooling2d_layer_backward.h:173
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch
Provides methods for the backward spatial pyramid maximum 2D pooling layer in the batch processing mo...
Definition: spatial_maximum_pooling2d_layer_backward.h:107
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::Batch
Batch(ParameterType &parameter)
Definition: spatial_maximum_pooling2d_layer_backward.h:134
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::Batch
Batch(const Batch< algorithmFPType, method > &other)
Definition: spatial_maximum_pooling2d_layer_backward.h:145
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::clone
services::SharedPtr< Batch< algorithmFPType, method > > clone() const
Definition: spatial_maximum_pooling2d_layer_backward.h:207
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::getResult
ResultPtr getResult()
Definition: spatial_maximum_pooling2d_layer_backward.h:182
daal::algorithms::Analysis
Provides methods for execution of operations over data, such as computation of Summary Statistics est...
Definition: analysis.h:68
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::getLayerParameter
virtual ParameterType * getLayerParameter() DAAL_C11_OVERRIDE
Definition: spatial_maximum_pooling2d_layer_backward.h:167
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: spatial_maximum_pooling2d_layer_backward.h:155
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::BatchContainer
Definition: spatial_maximum_pooling2d_layer_backward.h:56
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::backward::interface1::Batch::Batch
Batch(size_t pyramidHeight, size_t nDimensions)
Definition: spatial_maximum_pooling2d_layer_backward.h:124
daal::services::ErrorNullResult
Definition: error_indexes.h:96
daal::algorithms::neural_networks::layers::spatial_maximum_pooling2d::defaultDense
Definition: spatial_maximum_pooling2d_layer_types.h:53

For more complete information about compiler optimizations, see our Optimization Notice.