Compute Library
 22.02
ShapeCalculator.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017-2021 Arm Limited.
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to
8  * deal in the Software without restriction, including without limitation the
9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10  * sell copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in all
14  * copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
24 #ifndef ARM_COMPUTE_MISC_SHAPE_CALCULATOR_H
25 #define ARM_COMPUTE_MISC_SHAPE_CALCULATOR_H
26 
30 #include "arm_compute/core/Utils.h"
32 
34 
35 #include <cmath>
36 
37 namespace arm_compute
38 {
39 namespace misc
40 {
41 namespace shape_calculator
42 {
43 /** Calculate the output tensor shape for the reduce mean operation
44  *
45  * @param[in] input Input tensor shape
46  * @param[in] reduction_axis Reduction axis
47  * @param[in] keep_dims Flag to indicate if dimensions are kept
48  *
49  * @return the calculated shape
50  */
51 inline TensorShape calculate_reduce_mean_shape(ITensorInfo *input, const Coordinates &reduction_axis, bool keep_dims)
52 {
53  const int reduction_ops = reduction_axis.num_dimensions();
54  Coordinates axis_local = reduction_axis;
55  const int input_dims = input->num_dimensions();
56  convert_negative_axis(axis_local, input_dims);
57  TensorShape out_shape = input->tensor_shape();
58  // Configure reshape layer if we want to drop the dimensions
59  if(!keep_dims)
60  {
61  // We have to sort the reduction axis vectors in order for remove_dimension
62  // to work properly
63  std::sort(axis_local.begin(), axis_local.begin() + reduction_ops);
64  for(int i = 0; i < reduction_ops; ++i)
65  {
66  out_shape.remove_dimension(axis_local[i] - i);
67  }
68  return out_shape;
69  }
70  else
71  {
72  for(int i = 0; i < reduction_ops; ++i)
73  {
74  out_shape.set(axis_local[i], 1);
75  }
76  return out_shape;
77  }
78 }
79 /** Calculate the output tensor shape of a vector input given the convolution dimensions
80  *
81  * @param[in] input Input tensor shape
82  * @param[in] conv_w Convolution width
83  * @param[in] conv_h Convolution height
84  * @param[in] data_layout Data layout
85  *
86  * @return the calculated shape
87  */
88 inline TensorShape compute_vector_to_tensor_output_shape(const TensorShape &input, size_t conv_w, size_t conv_h, const DataLayout &data_layout)
89 {
90  const size_t idx_w = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
91  const size_t idx_h = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
92  const size_t idx_c = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
93 
95  output_shape.set(idx_w, conv_w);
96  output_shape.set(idx_h, conv_h);
97  output_shape.set(idx_c, input.x() / (conv_w * conv_h));
98 
99  return output_shape;
100 }
101 
102 /** Calculate the permuted shape of an input given a permutation vector
103  *
104  * @param[in] input Input tensor info
105  * @param[in] perm Permutation vector
106  *
107  * @return the calculated shape
108  */
110 {
112  permute(output_shape, perm);
113  return output_shape;
114 }
115 
116 /** Calculate the output shape of the reorg layer given a stride
117  *
118  * @param[in] input Input tensor info
119  * @param[in] stride Stride
120  *
121  * @return the calculated shape
122  */
124 {
127  const size_t idx_channel = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::CHANNEL);
128 
129  ARM_COMPUTE_ERROR_ON(stride <= 0);
130  ARM_COMPUTE_ERROR_ON_MSG((input.tensor_shape()[idx_width] % stride != 0), "The width of the input tensor must be a multiple of stride");
131  ARM_COMPUTE_ERROR_ON_MSG((input.tensor_shape()[idx_height] % stride != 0), "The height of the input tensor must be a multiple of stride");
132 
134 
135  output_shape.set(idx_width, output_shape[idx_width] / stride);
136  output_shape.set(idx_height, output_shape[idx_height] / stride);
137  output_shape.set(idx_channel, output_shape[idx_channel] * stride * stride);
138 
139  return output_shape;
140 }
141 
142 /** Calculate the reshaped shape of the weights
143  *
144  * @param[in] weights Weights tensor info
145  * @param[in] has_bias (Optional) Set to true if there is bias
146  * @param[in] num_groups (Optional) Number of groups
147  *
148  * @return the calculated shape of the reshaped weights
149  */
150 inline TensorShape compute_weights_reshaped_shape(const ITensorInfo &weights, bool has_bias = false, unsigned int num_groups = 1)
151 {
152  // Number of groups greater than one are only supported for NCHW data layout, and the number of weights must be a multiple of it.
155  ARM_COMPUTE_ERROR_ON((weights.dimension(3) % num_groups) != 0);
156 
157  // Calculate output shape
158  TensorShape weights_reshaped{ weights.tensor_shape() };
159  weights_reshaped.set(3, weights_reshaped[3] / num_groups);
160 
161  weights_reshaped.collapse(3);
162  const size_t tmp_dim = weights_reshaped[0];
163  weights_reshaped.set(0, weights_reshaped[1]);
164  weights_reshaped.set(1, tmp_dim + (has_bias ? 1 : 0));
165  if(weights.num_dimensions() < 5)
166  {
167  weights_reshaped.set(2, num_groups);
168  }
169 
170  return weights_reshaped;
171 }
172 
173 /** Calculate the Left Hand Side matrix reshaped shape
174  *
175  * @param[in] a Input tensor info
176  * @param[in] lhs_info Left Hand Side matrix information
177  * @param[in] reinterpret_input_as_3d (Optional) Set to true if the input need to be interpreted as 3d
178  *
179  * @return the calculated shape
180  */
181 inline TensorShape compute_lhs_reshaped_shape(const ITensorInfo &a, const GEMMLHSMatrixInfo &lhs_info, bool reinterpret_input_as_3d = false)
182 {
183  ARM_COMPUTE_ERROR_ON(lhs_info.m0 == 0);
184  ARM_COMPUTE_ERROR_ON(lhs_info.k0 == 0);
185  ARM_COMPUTE_ERROR_ON(lhs_info.v0 == 0);
186 
187  // Input width/height
188  const unsigned int input_width = a.dimension(0);
189  const unsigned int input_height = reinterpret_input_as_3d ? a.dimension(1) * a.dimension(2) : a.dimension(1);
190 
191  // Number of horizontal/vertical blocks in the input tensor
192  const unsigned int num_horiz_blocks = std::ceil(input_width / static_cast<float>(lhs_info.k0));
193  const unsigned int num_vert_blocks = std::ceil(input_height / static_cast<float>(lhs_info.m0));
194 
195  // Block size
196  const unsigned int block_size = lhs_info.m0 * lhs_info.k0;
197 
198  // Output width/height
199  const unsigned int output_width = block_size * num_horiz_blocks * lhs_info.v0;
200  const unsigned int output_height = std::ceil(num_vert_blocks / static_cast<float>(lhs_info.v0));
201 
202  TensorShape lhs_shape{ a.tensor_shape() };
203  lhs_shape.set(0, output_width);
204  lhs_shape.set(1, output_height);
205 
206  if((reinterpret_input_as_3d) && (lhs_shape.num_dimensions() > 2))
207  {
208  // When the data format is NHWC and the shapes are Nx1x1
209  // the tensor shape num_dimensions is automatically set to 1 instead of 3.
210  // To avoid failures by removing a dimension that doesn't exist
211  // check if the number of dimensions is greater than 2.
212  lhs_shape.remove_dimension(2);
213  }
214 
215  return lhs_shape;
216 }
217 
218 /** Calculate the Right Hand Side matrix reshaped shape
219  *
220  * @param[in] a Input tensor info
221  * @param[in] rhs_info Right Hand Side matrix information
222  *
223  * @return the calculated shape
224  */
226 {
227  ARM_COMPUTE_ERROR_ON(rhs_info.n0 == 0);
228  ARM_COMPUTE_ERROR_ON(rhs_info.k0 == 0);
229  ARM_COMPUTE_ERROR_ON(rhs_info.h0 == 0);
230 
231  // Input width/height
232  const unsigned int input_width = a.dimension(0);
233  const unsigned int input_height = a.dimension(1);
234 
235  // Number of horizontal/vertical blocks in the input tensor
236  const unsigned int num_horiz_blocks = std::ceil(input_width / static_cast<float>(rhs_info.n0));
237  const unsigned int num_vert_blocks = std::ceil(input_height / static_cast<float>(rhs_info.k0));
238 
239  // Block size
240  const unsigned int block_size = rhs_info.n0 * rhs_info.k0;
241 
242  // Output width/height
243  const unsigned int output_width = block_size * num_vert_blocks * rhs_info.h0;
244  const unsigned int output_height = std::ceil(num_horiz_blocks / static_cast<float>(rhs_info.h0));
245 
246  TensorShape rhs_shape{ a.tensor_shape() };
247  rhs_shape.set(0, output_width);
248  rhs_shape.set(1, output_height);
249 
250  return rhs_shape;
251 }
252 
253 /** Calculate the interleaved shape of an input tensor
254  *
255  * @param[in] a Input tensor info
256  * @param[in] mult_interleave4x4_height (Optional) Interleave4x4 height
257  * @param[in] reinterpret_input_as_3d (Optional) Set to true if the input need to be interpreted as 3d
258  *
259  * @return the calculated shape
260  */
261 inline TensorShape compute_interleaved_shape(const ITensorInfo &a, int mult_interleave4x4_height = 1, bool reinterpret_input_as_3d = false)
262 {
263  // The interleaved output matrix will have the following shape: [ a_height * W, ceil(a_width / W) ] where W = 4 * mult_interleave4x4_height
264  ARM_COMPUTE_ERROR_ON(mult_interleave4x4_height < 1);
265  const int interleave_width = 4 * mult_interleave4x4_height;
266  TensorShape shape_interleaved_a{ a.tensor_shape() };
267  shape_interleaved_a.set(0, a.dimension(0) * interleave_width);
268  if(reinterpret_input_as_3d)
269  {
270  const int M = a.dimension(1) * a.dimension(2);
271  const int height = std::ceil(M / static_cast<float>(interleave_width));
272  shape_interleaved_a.set(1, height);
273 
274  // When the data format is NHWC and the shapes are Nx1x1
275  // the tensor shape num_dimensions is automatically set to 1 instead of 3.
276  // To avoid failures by removing a dimension that doesn't exist
277  // check if the number of dimensions is greater than 2.
278  if(shape_interleaved_a.num_dimensions() > 2)
279  {
280  shape_interleaved_a.remove_dimension(2);
281  }
282  }
283  else
284  {
285  shape_interleaved_a.set(1, std::ceil(a.dimension(1) / static_cast<float>(interleave_width)));
286  }
287 
288  return shape_interleaved_a;
289 }
290 
291 /** Calculate the transposed 1xW shape
292  *
293  * @param[in] b Input tensor info
294  *
295  * @return the calculated shape
296  */
298 {
299  // The transpose1xW output matrix will have the following shape: [ b_height * 16, ceil(b_width / 16.0f) ]
300  TensorShape shape_transposed1xW_b{ b.tensor_shape() };
301  shape_transposed1xW_b.set(0, b.dimension(1) * 16);
302  shape_transposed1xW_b.set(1, std::ceil(b.dimension(0) / 16.f));
303 
304  return shape_transposed1xW_b;
305 }
306 
307 /** Calculate the transposed 1xW width element shape
308  *
309  * @param[in] b Input tensor info
310  * @param[in] mult_transpose1xW_width (Optional) Transpose1xW width
311  *
312  * @return the calculated shape
313  */
314 inline TensorShape compute_transpose1xW_with_element_size_shape(const ITensorInfo &b, int mult_transpose1xW_width = 1)
315 {
316  // Note: mult_transpose1xW_width expresses the number of chunks with size 1x(W) we want to store on the same row
317  // The transpose1xW output matrix will have the following shape:
318  // [ b_height * W, ceil(b_width / W) ] where W = (16 / element size of the tensor) * mult_transpose1xW_width
319  ARM_COMPUTE_ERROR_ON(mult_transpose1xW_width < 1);
320  TensorShape shape_transposed1xW_b{ b.tensor_shape() };
321  const size_t transpose_width = (16 / b.element_size()) * mult_transpose1xW_width;
322  shape_transposed1xW_b.set(0, b.dimension(1) * transpose_width);
323  shape_transposed1xW_b.set(1, static_cast<size_t>(std::ceil(b.dimension(0) / static_cast<float>(transpose_width))));
324 
325  return shape_transposed1xW_b;
326 }
327 
328 /** Calculate the reductionA shape used in GEMMLowp
329  *
330  * @param[in] b Input tensor info
331  *
332  * @return the calculated shape
333  */
335 {
336  TensorShape shape_vector_sum_col{ b.tensor_shape() };
337  if(shape_vector_sum_col.num_dimensions() > 1)
338  {
339  shape_vector_sum_col.remove_dimension(1);
340  }
341 
342  return shape_vector_sum_col;
343 }
344 
345 /** Calculate the reductionB shape used in GEMMLowp
346  *
347  * @param[in] a Input tensor info
348  *
349  * @return the calculated shape
350  */
352 {
353  TensorShape shape_vector_sum_row{ a.tensor_shape() };
354  shape_vector_sum_row.set(Window::DimX, a.dimension(1));
355  if(shape_vector_sum_row.num_dimensions() > 1)
356  {
357  shape_vector_sum_row.remove_dimension(1);
358  }
359 
360  return shape_vector_sum_row;
361 }
362 
363 /** Calculate the Col2Im shape
364  *
365  * @param[in] input Input tensor info
366  * @param[in] convolved_dims Convolved dimensions
367  * @param[in] batch_size_on_z True if batch size is on z axis
368  * @param[in] num_groups (Optional) Number of groups when performing a grouped convolution
369  *
370  * @return the calculated shape
371  */
372 inline TensorShape compute_col2im_shape(const ITensorInfo &input, const Size2D &convolved_dims, bool batch_size_on_z, unsigned int num_groups = 1)
373 {
375  ARM_COMPUTE_ERROR_ON(input.tensor_shape()[1] != (convolved_dims.area()));
376  ARM_COMPUTE_ERROR_ON((num_groups > 1) && input.tensor_shape()[2] != num_groups);
377 
378  const DataLayout data_layout = input.data_layout();
379  const int width_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
380  const int height_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
381  const int channel_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
382 
383  TensorShape col2im_shape{ input.tensor_shape() };
384  // If batches start on 3rd dimension shift dimensions right by 1 to retain upper tensor shape,
385  // as first three will be override by H,W,C data
386  if(batch_size_on_z && num_groups == 1)
387  {
388  col2im_shape.shift_right(1);
389  }
390  col2im_shape.set(width_idx, convolved_dims.width);
391  col2im_shape.set(height_idx, convolved_dims.height);
392  col2im_shape.set(channel_idx, input.tensor_shape()[0] * num_groups);
393 
394  return col2im_shape;
395 }
396 
397 /** Calculate the transposed shape of a tensor
398  *
399  * @param[in] input Input tensor info
400  *
401  * @return the calculated shape
402  */
404 {
405  TensorShape shape_transposed{ input.tensor_shape() };
406 
407  shape_transposed.set(0, input.dimension(1));
408  shape_transposed.set(1, input.dimension(0));
409 
410  return shape_transposed;
411 }
412 
413 /** Calculate the depthwise convolution output shape of a tensor
414  *
415  * @param[in] input Input tensor info
416  * @param[in] weights Weights tensor info
417  * @param[in] info Convolution info
418  *
419  * @return the calculated shape
420  */
422 {
423  const TensorShape input_shape{ input.tensor_shape() };
424  const TensorShape weights_shape{ weights.tensor_shape() };
425 
426  const DataLayout data_layout = input.data_layout();
427  const int width_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
428  const int height_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
429  const int channel_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
430 
431  const DataLayout weights_data_layout = weights.data_layout();
432  const int weights_width_idx = get_data_layout_dimension_index(weights_data_layout, DataLayoutDimension::WIDTH);
433  const int weights_height_idx = get_data_layout_dimension_index(weights_data_layout, DataLayoutDimension::HEIGHT);
434 
435  unsigned int output_width = 0;
436  unsigned int output_height = 0;
437  std::tie(output_width, output_height) = scaled_dimensions(input_shape[width_idx], input_shape[height_idx],
438  weights_shape[weights_width_idx], weights_shape[weights_height_idx],
439  info.pad_stride_info, info.dilation);
440 
442  output_shape.set(width_idx, output_width);
443  output_shape.set(height_idx, output_height);
444  output_shape.set(channel_idx, input_shape[channel_idx] * info.depth_multiplier);
445 
446  return output_shape;
447 }
448 
449 /** Calculate the upsampled output shape used for deconvolution
450  *
451  * @param[in] input Input tensor info
452  * @param[in] weights Weights tensor shape
453  * @param[in] sx Stride on x axis
454  * @param[in] sy Stride on y axis
455  * @param[in] out_dims Output shape dimensions
456  * @param[in] padx Padding on x axis
457  * @param[in] pady Padding on y axis
458  *
459  * @return the calculated shape
460  */
461 inline TensorShape compute_deconvolution_upsampled_shape(const ITensorInfo &input, const ITensorInfo &weights, unsigned int sx, unsigned int sy,
462  std::pair<unsigned int, unsigned int> &out_dims, uint32_t &padx, uint32_t &pady)
463 {
464  const DataLayout data_layout = input.data_layout();
465  const size_t idx_w = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
466  const size_t idx_h = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
467 
468  // Find the upsampled dimensions
469  unsigned int out_x = (input.dimension(idx_w) - 1) * sx + 1;
470  unsigned int out_y = (input.dimension(idx_h) - 1) * sy + 1;
471 
472  // Find the padding needed for the convolution with stride 1 in order to match output shape
473  padx = out_dims.first - (out_x - weights.dimension(idx_w) + 1);
474  pady = out_dims.second - (out_y - weights.dimension(idx_h) + 1);
475  out_x += padx;
476  out_y += pady;
477 
478  TensorShape scale_out_shape(input.tensor_shape());
479  scale_out_shape.set(idx_w, out_x);
480  scale_out_shape.set(idx_h, out_y);
481 
482  return scale_out_shape;
483 }
484 
485 /** Calculate the output shape of the deconvolution layer
486  *
487  * @param[in] out_dims Output x and y shape dimensions
488  * @param[in] input Input tensor info
489  * @param[in] weights Weights tensor shape
490  *
491  * @return the calculated shape
492  */
493 inline TensorShape compute_deconvolution_output_shape(const std::pair<unsigned int, unsigned int> &out_dims, const ITensorInfo &input, const ITensorInfo &weights)
494 {
495  const TensorShape input_shape{ input.tensor_shape() };
496  const TensorShape weights_shape{ weights.tensor_shape() };
497 
498  const DataLayout data_layout = input.data_layout();
499  const int width_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
500  const int height_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
501  const int channel_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
502  const int batch_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::BATCHES);
503 
504  TensorShape out_shape{ input_shape };
505  out_shape.set(width_idx, out_dims.first);
506  out_shape.set(height_idx, out_dims.second);
507  out_shape.set(channel_idx, weights_shape[batch_idx]);
508  return out_shape;
509 }
510 
511 /** Calculate the im2col output shape of a tensor
512  *
513  * @param[in] input Input tensor info
514  * @param[in] kernel_dims The kernel dimensions (width and height).
515  * @param[in] conv_info Contains padding and stride information
516  * @param[in] has_bias In case biases are provided expands the matrix with 1
517  * @param[in] dilation Dilation, in elements, across x and y
518  * @param[in] batch_size_on_z True if batch size is on z axis
519  * @param[in] num_groups (Optional) Number of groups when performing a grouped convolution
520  *
521  * @return the calculated shape
522  */
523 inline TensorShape compute_im2col_conv_shape(const ITensorInfo *input, const Size2D &kernel_dims, const PadStrideInfo &conv_info, bool has_bias, const Size2D &dilation, bool batch_size_on_z,
524  unsigned int num_groups = 1)
525 {
526  // The output shape will be the 3D shape [ out_channels * kernel_area, num_elems_per_out_channel, batches ] if batch_size_on_z == true
527  // or the 4D shape [ out_channels * kernel_area / num_groups, num_elems_per_out_channel, num_groups, batches ] if batch_size_on_z == false
528 
531  ARM_COMPUTE_ERROR_ON(num_groups > 1 && batch_size_on_z);
532 
534 
535  const DataLayout data_layout = input->data_layout();
536  const int width_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
537  const int height_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
538  const int channel_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
539 
540  std::pair<unsigned int, unsigned int> out_dims = scaled_dimensions(output_shape[width_idx], output_shape[height_idx], kernel_dims.width, kernel_dims.height, conv_info, dilation);
541  output_shape.set(0, (output_shape[channel_idx] / num_groups * kernel_dims.area() + (has_bias ? 1 : 0))); // NOLINT
542  output_shape.set(1, (out_dims.first * out_dims.second));
543  if(batch_size_on_z && output_shape.num_dimensions() >= 3)
544  {
545  output_shape.remove_dimension(2);
546  }
547  else
548  {
549  output_shape.set(2, num_groups);
550  }
551 
552  return output_shape;
553 }
554 
555 /** Calculate the flattened output shape of a tensor
556  *
557  * @param[in] input Input tensor info
558  *
559  * @return the calculated shape
560  */
562 {
563  // The output shape will be the flatten version of the input (i.e. [ width * height * channels, num_batches, ... ] ). Used for FlattenLayer and FullyConnectedLayer.
564 
566 
567  output_shape.collapse(3);
568 
569  return output_shape;
570 }
571 
572 /** Calculate the softmax output shape of a tensor
573  *
574  * @param[in] input Input tensor info
575  * @param[in] axis (Optional) Softmax axis
576  *
577  * @return the calculated shape
578  */
579 inline TensorShape compute_softmax_shape(const ITensorInfo *input, size_t axis = 1)
580 {
581  // The output shape will be a 2D version of the input. For instance:
582  // - [x,y,z] and axis 1 will return [x, y*z]
583  // - [x,y,z,w] and axis 2 will return [x*y, w*z]
584  // - [x,y,z,w] and axis 3 will return [x*y*z, w]
585  TensorShape shape2D = input->tensor_shape();
586 
587  if(axis < input->num_dimensions())
588  {
589  // Collapse from axis onward (this changes the shape)
590  shape2D.collapse_from(axis);
591 
592  // Collapse the rest (collapse is inclusive)
593  shape2D.collapse(shape2D.num_dimensions() - 1);
594  }
595  else
596  {
597  // Collapse everything
598  shape2D.collapse(shape2D.num_dimensions());
599  }
600 
601  if(axis == 0)
602  {
603  // If axis is zero the first dim should be one. Since
604  // collapse is an inclusive operation we need to shift
605  shape2D.shift_right(1);
606  }
607 
608  return shape2D;
609 }
610 
611 /** Calculate the winograd filter transform shape
612  *
613  * @param[in] input Input tensor info
614  * @param[in] winograd_info Winograd information
615  *
616  * @return the calculated shape
617  */
619 {
620  TensorShape tensor_shape{ input.tensor_shape() };
621 
622  const Size2D kernel_size = winograd_info.kernel_size;
623  const Size2D output_tile_size = winograd_info.output_tile_size;
624  const Size2D input_tile_size = Size2D(output_tile_size.width + kernel_size.width - 1, output_tile_size.height + kernel_size.height - 1);
625 
626  tensor_shape.remove_dimension(get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::WIDTH));
627  tensor_shape.set(Window::DimX, input.dimension(3));
629  tensor_shape.set(Window::DimZ, input_tile_size.area());
630 
631  return tensor_shape;
632 }
633 
634 /** Calculate the winograd input transform shape
635  *
636  * @param[in] input Input tensor info
637  * @param[in] winograd_info Winograd information
638  *
639  * @return the calculated shape
640  */
642 {
643  const PadStrideInfo conv_info = winograd_info.convolution_info;
644  const Size2D kernel_size = winograd_info.kernel_size;
645  const Size2D output_tile_size = winograd_info.output_tile_size;
646  const Size2D input_tile_size = Size2D(output_tile_size.width + kernel_size.width - 1, output_tile_size.height + kernel_size.height - 1);
647 
651 
652  // Compute the number of output tiles along the x and y direction of size "output_tile_size"
653  const Size2D num_tiles = compute_winograd_convolution_tiles(Size2D(input.tensor_shape()[idx_w], input.tensor_shape()[idx_h]),
654  kernel_size,
655  output_tile_size,
656  conv_info);
657 
658  const unsigned int width = input.tensor_shape()[idx_c];
659  const unsigned int height = num_tiles.area();
660  const unsigned int depth = input_tile_size.area();
661 
663  output_shape.set(0, width);
664  output_shape.set(1, height);
665  output_shape.set(2, depth);
666 
667  return output_shape;
668 }
669 
670 /** Calculate the winograd output transform shape
671  *
672  * @param[in] input Input tensor info
673  * @param[in] winograd_info Winograd information
674  *
675  * @return the calculated shape
676  */
678 {
679  const PadStrideInfo conv_info = winograd_info.convolution_info;
680  const Size2D kernel_size = winograd_info.kernel_size;
681  const Size2D input_dimensions = winograd_info.input_dimensions;
682  const DataLayout data_layout = winograd_info.output_data_layout;
683 
684  // Compute output shape
685  unsigned int output_width = 0;
686  unsigned int output_height = 0;
687  std::tie(output_width, output_height) = scaled_dimensions(input_dimensions.width, input_dimensions.height,
688  kernel_size.width, kernel_size.height, conv_info);
689 
690  TensorShape tensor_shape{ input.tensor_shape() };
691 
692  // Output dimension
693  const unsigned int out_w = output_width;
694  const unsigned int out_h = output_height;
695  const unsigned int out_c = input.dimension(0);
696 
697  tensor_shape.set(get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH), out_w);
698  tensor_shape.set(get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT), out_h);
699  tensor_shape.set(get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL), out_c);
700 
701  return tensor_shape;
702 }
703 
704 /** Calculate the deep convolution shape output shape of a tensor
705  *
706  * @param[in] input_shape Input tensor shape
707  * @param[in] input_data_layout Input data layout
708  * @param[in] weights_shape Weights tensor shape
709  * @param[in] conv_info Contains padding and stride information
710  *
711  * @return the calculated shape
712  */
714 {
715  const size_t idx_width = get_data_layout_dimension_index(input_data_layout, DataLayoutDimension::WIDTH);
717  const size_t idx_channel = get_data_layout_dimension_index(input_data_layout, DataLayoutDimension::CHANNEL);
718 
719  const unsigned int input_width = input_shape[idx_width];
720  const unsigned int input_height = input_shape[idx_height];
721  const unsigned int weights_width = weights_shape[idx_width];
722  const unsigned int weights_height = weights_shape[idx_height];
723  const unsigned int weights_out_channel = weights_shape[3];
724  unsigned int output_width = 0;
725  unsigned int output_height = 0;
726  std::tie(output_width, output_height) = scaled_dimensions(input_width, input_height, weights_width, weights_height, conv_info);
727 
728  TensorShape output_shape{ input_shape };
729  output_shape.set(idx_width, output_width);
730  output_shape.set(idx_height, output_height);
731  output_shape.set(idx_channel, weights_out_channel);
732 
733  return output_shape;
734 }
735 
736 /** Calculate the deep convolution shape output shape of a tensor
737  *
738  * @param[in] input Input tensor info
739  * @param[in] weights Weights tensor info
740  * @param[in] conv_info Contains padding and stride information
741  *
742  * @return the calculated shape
743  */
745 {
747 }
748 
749 /** Calculate the min/max shape output shape of a tensor
750  *
751  * @param[in] input Input tensor info
752  *
753  * @return the calculated shape
754  */
756 {
758  output_shape.set(Window::DimX, 2);
759  output_shape.remove_dimension(1);
760  output_shape.remove_dimension(1);
761 
762  return output_shape;
763 }
764 
765 /** Calculate the output pool shape of a tensor
766  *
767  * @param[in] input Input tensor info
768  * @param[in] pool_info Pooling layer info
769  *
770  * @return the calculated shape
771  */
773 {
774  int pooled_w = 0;
775  int pooled_h = 0;
776 
778 
779  const bool is_global_pooling = pool_info.is_global_pooling;
782  const int input_width = input.tensor_shape()[idx_width];
783  const int input_height = input.tensor_shape()[idx_height];
784  const int pool_size_x = is_global_pooling ? output_shape[idx_width] : pool_info.pool_size.width;
785  const int pool_size_y = is_global_pooling ? output_shape[idx_height] : pool_info.pool_size.height;
786 
787  std::tie(pooled_w, pooled_h) = scaled_dimensions_signed(input_width, input_height,
788  pool_size_x, pool_size_y,
789  pool_info.pad_stride_info);
790 
791  ARM_COMPUTE_ERROR_ON_MSG((pooled_w < 1 || pooled_h < 1), "Calculated output dimension size is invalid");
792 
793  output_shape.set(idx_width, static_cast<size_t>(pooled_w));
794  output_shape.set(idx_height, static_cast<size_t>(pooled_h));
795 
796  return output_shape;
797 }
798 
799 /** Calculate the output unpool shape of a tensor
800  *
801  * @param[in] input Input tensor info
802  * @param[in] pool_info Pooling layer info
803  *
804  * @return the calculated shape
805  */
807 {
810  const TensorShape input_shape = input.tensor_shape();
811  ARM_COMPUTE_ERROR_ON(input_shape[idx_height] <= 1 || input_shape[idx_width] <= 1);
812  const PadStrideInfo pad_stride_info = pool_info.pad_stride_info;
813  const unsigned int stride_x = pad_stride_info.stride().first;
814  const unsigned int stride_y = pad_stride_info.stride().second;
815 
816  const int pad_left = pad_stride_info.pad_left();
817  const int pad_top = pad_stride_info.pad_top();
818  const int pad_right = pad_stride_info.pad_right();
819  const int pad_bottom = pad_stride_info.pad_bottom();
820 
822  const unsigned int out_width = (input_shape[idx_width] - 1) * stride_x - pad_left - pad_right + pool_info.pool_size.width;
823  const unsigned int out_height = (input_shape[idx_height] - 1) * stride_y - pad_top - pad_bottom + pool_info.pool_size.height;
824 
825  output_shape.set(idx_width, out_width);
826  output_shape.set(idx_height, out_height);
827  return output_shape;
828 }
829 
830 /** Calculate the output roi align shape of a tensor
831  *
832  * @param[in] input Input tensor info
833  * @param[in] rois Rois tensor info
834  * @param[in] pool_info Pooling layer info
835  *
836  * @return the calculated shape
837  */
839 {
841 
844 
845  output_shape.set(idx_width, pool_info.pooled_width());
846  output_shape.set(idx_height, pool_info.pooled_height());
847  output_shape.set(3, rois.dimension(1));
848 
849  return output_shape;
850 }
851 
852 /** Calculate the RNN shape of a tensor
853  *
854  * @param[in] input Input tensor info
855  * @param[in] batch_size Batch size
856  *
857  * @return the calculated shape
858  */
859 inline TensorShape compute_rnn_shape(const ITensorInfo *input, const unsigned int batch_size)
860 {
862  output_shape.set(1, batch_size);
863 
864  return output_shape;
865 }
866 
867 /** Calculate the matrix multiplication output shape of two tensors
868  *
869  * @param[in] input0 First input tensor info
870  * @param[in] input1 Second input tensor info
871  * @param[in] is_interleaved_transposed True if the input is interleaved transposed
872  * @param[in] reshape_info GEMM reshape info
873  *
874  * @return the calculated shape
875  */
876 inline TensorShape compute_mm_shape(const ITensorInfo &input0, const ITensorInfo &input1, bool is_interleaved_transposed, const GEMMReshapeInfo &reshape_info)
877 {
878  ARM_COMPUTE_ERROR_ON_MSG(input0.num_dimensions() > 4, "The number of dimensions for the matrix A must be <= 4");
879  ARM_COMPUTE_ERROR_ON_MSG(is_interleaved_transposed && reshape_info.reinterpret_input_as_3d(), "The first input tensor cannot be reinterpreted as 3D if is_interleaved_transposed is true");
880 
881  const bool reinterpret_input_as_3d = reshape_info.reinterpret_input_as_3d();
882  const bool reinterpret_output_as_3d = reshape_info.depth_output_gemm3d() != 0;
883  const int depth_output_gemm3d = reinterpret_output_as_3d ? reshape_info.depth_output_gemm3d() : 1;
884  const int m = reshape_info.reinterpret_input_as_3d() ? input0.dimension(1) * input0.dimension(2) : input0.dimension(1);
885 
886  // If the output of GEMM has to be reinterpreted as 3D, the number of input0 rows (M) is obtained collapsing the second and third
887  // dimension of the output tensor
888  const int dim0 = is_interleaved_transposed ? reshape_info.n() : input1.dimension(0);
889  const int dim1 = is_interleaved_transposed ? reshape_info.m() / depth_output_gemm3d : m / depth_output_gemm3d;
890  const int dim2 = reinterpret_input_as_3d ? input0.tensor_shape()[3] : input0.tensor_shape()[2];
891  const int dim3 = reinterpret_input_as_3d ? 1 : input0.tensor_shape()[3];
892 
894 
895  output_shape.set(0, dim0);
896  output_shape.set(1, dim1);
897  output_shape.set(2, reinterpret_output_as_3d ? depth_output_gemm3d : dim2);
898  output_shape.set(3, reinterpret_output_as_3d ? dim2 : dim3);
899  output_shape.set(4, reinterpret_output_as_3d ? dim3 : 1);
900 
901  return output_shape;
902 }
903 
904 /** Calculate the matrix multiplication output shape of two tensors
905  *
906  * @param[in] input0 First input tensor info
907  * @param[in] input1 Second input tensor info
908  * @param[in] gemm_info GEMM reshape info
909  *
910  * @return the calculated shape
911  */
912 inline TensorShape compute_mm_shape(const ITensorInfo &input0, const ITensorInfo &input1, const GEMMReshapeInfo &gemm_info)
913 {
914  ARM_COMPUTE_UNUSED(input1);
915  ARM_COMPUTE_ERROR_ON_MSG(input0.num_dimensions() > 4, "The number of dimensions for the matrix A must be <= 4");
916 
917  const bool reinterpret_input_as_3d = gemm_info.reinterpret_input_as_3d();
918  const bool reinterpret_output_as_3d = gemm_info.depth_output_gemm3d() != 0;
919  const int depth_output_gemm3d = reinterpret_output_as_3d ? gemm_info.depth_output_gemm3d() : 1;
920 
922 
923  if(!reinterpret_input_as_3d && !reinterpret_output_as_3d)
924  {
925  output_shape.set(0, gemm_info.n());
926  output_shape.set(1, gemm_info.m());
927  }
928  else
929  {
930  // If the output of GEMM has to be reinterpreted as 3D, the number of input0 rows (M) is obtained collapsing the second and third
931  // dimension of the output tensor
932  const int batch_size = reinterpret_input_as_3d ? input0.tensor_shape()[3] : input0.tensor_shape()[2];
933  output_shape.set(0, gemm_info.n());
934  output_shape.set(1, gemm_info.m() / depth_output_gemm3d);
935  output_shape.set(2, reinterpret_output_as_3d ? depth_output_gemm3d : batch_size);
936  output_shape.set(3, reinterpret_output_as_3d ? batch_size : 1);
937  }
938 
939  return output_shape;
940 }
941 
942 /** Calculate the matrix multiplication output shape of two tensors
943  *
944  * @param[in] input0 First input tensor info
945  * @param[in] input1 Second input tensor info
946  * @param[in] gemm_info GEMM kernel info used to retrieve the original dimensions of the input matrices
947  *
948  * @return the calculated shape
949  */
950 inline TensorShape compute_mm_shape(const ITensorInfo &input0, const ITensorInfo &input1, const GEMMKernelInfo &gemm_info)
951 {
952  ARM_COMPUTE_UNUSED(input1);
953  ARM_COMPUTE_ERROR_ON_MSG(input0.num_dimensions() > 4, "The number of dimensions for the matrix A must be <= 4");
954 
955  const bool reinterpret_input_as_3d = gemm_info.reinterpret_input_as_3d;
956  const bool reinterpret_output_as_3d = gemm_info.depth_output_gemm3d != 0;
957  const unsigned int depth_output_gemm3d = reinterpret_output_as_3d ? gemm_info.depth_output_gemm3d : 1;
958 
960 
961  if(!reinterpret_input_as_3d && !reinterpret_output_as_3d)
962  {
963  output_shape.set(0, gemm_info.n);
964  output_shape.set(1, gemm_info.m);
965  }
966  else
967  {
968  // If the output of GEMM has to be reinterpreted as 3D, the number of input0 rows (M) is obtained collapsing the second and third
969  // dimension of the output tensor
970  const unsigned int batch_size = reinterpret_input_as_3d ? input0.tensor_shape()[3] : input0.tensor_shape()[2];
971  output_shape.set(0, gemm_info.n);
972  output_shape.set(1, gemm_info.m / depth_output_gemm3d);
973  output_shape.set(2, reinterpret_output_as_3d ? depth_output_gemm3d : batch_size);
974  output_shape.set(3, reinterpret_output_as_3d ? batch_size : 1);
975  }
976 
977  return output_shape;
978 }
979 
980 /** Calculate the matrix multiplication output shape of two tensors
981  *
982  * @param[in] input Input tensor info
983  * @param[in] gemm_3d_depth (Optional) GEMM 3d depth
984  * @param[in] batch_size_on_z (Optional) True if batch size is on z axis
985  *
986  * @return the calculated shape
987  */
988 inline TensorShape compute_output_stage_shape(const ITensorInfo &input, unsigned int gemm_3d_depth = 1, bool batch_size_on_z = false)
989 {
990  ARM_COMPUTE_ERROR_ON(input.data_layout() != DataLayout::NHWC && gemm_3d_depth > 1);
991 
993  if(gemm_3d_depth > 1)
994  {
995  if(batch_size_on_z)
996  {
997  output_shape.shift_right(1);
998  }
999  output_shape.set(0, input.tensor_shape().x());
1000  output_shape.set(1, input.tensor_shape().y() / gemm_3d_depth);
1001  output_shape.set(2, gemm_3d_depth);
1002  }
1003 
1004  return output_shape;
1005 }
1006 
1007 /** Calculate the strided slice output shape of a tensor
1008  *
1009  * @param[in] input Input tensor info
1010  * @param[in] starts The starts of the dimensions of the input tensor to be sliced
1011  * @param[in] ends The ends of the dimensions of the input tensor to be sliced
1012  * @param[in] strides The strides of the dimensions of the input tensor to be sliced
1013  * @param[in] begin_mask If the ith bit of begin_mask is set, starts[i] is ignored and the fullest possible range in that dimension is used instead.
1014  * @param[in] end_mask If the ith bit of end_mask is set, ends[i] is ignored and the fullest possible range in that dimension is used instead.
1015  * @param[in] shrink_axis_mask If the ith bit of shrink_axis_mask is set, it implies that the ith specification shrinks the dimensionality by 1
1016  *
1017  * @return the calculated shape
1018  */
1020  const Coordinates &starts, const Coordinates &ends, const Coordinates &strides,
1021  int32_t begin_mask, int32_t end_mask, int32_t shrink_axis_mask)
1022 {
1024  return compute_strided_slice_output_shape(input.tensor_shape(), starts, ends, strides, begin_mask, end_mask, shrink_axis_mask);
1025 }
1026 
1027 /** Calculate the slice output shape of a tensor
1028  *
1029  * @param[in] input_shape Input tensor info
1030  * @param[in] starts The starts of the dimensions of the input tensor to be sliced
1031  * @param[in] ends The ends of the dimensions of the input tensor to be sliced
1032  *
1033  * @return the calculated shape
1034  */
1036 {
1038 
1039  return compute_strided_slice_output_shape(input_shape,
1040  starts, ends, BiStrides(),
1041  0, construct_slice_end_mask(ends), 0);
1042 }
1043 
1044 /** Calculate the batch to space output shape of a tensor
1045  *
1046  * @param[in] input Input tensor info
1047  * @param[in] block_x Block shape x value
1048  * @param[in] block_y Block shape y value
1049  *
1050  * @return the calculated shape
1051  */
1052 inline TensorShape compute_batch_to_space_shape(const ITensorInfo *input, const int block_x, const int block_y)
1053 {
1054  ARM_COMPUTE_ERROR_ON(block_x <= 0 || block_y <= 0);
1055 
1056  const DataLayout data_layout = input->data_layout();
1059  const int idx_batch = get_data_layout_dimension_index(data_layout, DataLayoutDimension::BATCHES);
1060 
1062  output_shape.set(idx_width, input->tensor_shape()[idx_width] * block_x);
1063  output_shape.set(idx_height, input->tensor_shape()[idx_height] * block_y);
1064  output_shape.set(idx_batch, input->tensor_shape()[idx_batch] / (block_x * block_y));
1065 
1066  return output_shape;
1067 }
1068 
1069 /** Calculate the depth to space output shape of a tensor
1070  *
1071  * @param[in] input_shape Input tensor shape
1072  * @param[in] data_layout Operation data layout
1073  * @param[in] block Block shape value
1074  *
1075  * @return the calculated shape
1076  */
1078 {
1079  ARM_COMPUTE_ERROR_ON(block < 2);
1080 
1083  const int idx_channel = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
1084 
1085  TensorShape output_shape{ input_shape };
1086  output_shape.set(idx_width, input_shape[idx_width] * block);
1087  output_shape.set(idx_height, input_shape[idx_height] * block);
1088  output_shape.set(idx_channel, input_shape[idx_channel] / (block * block));
1089 
1090  return output_shape;
1091 }
1092 
1093 /** Calculate the split output shape of a tensor
1094  *
1095  * @param[in] input Input tensor info
1096  * @param[in] axis Axis on which to split the input
1097  * @param[in] num_splits Number of splits
1098  *
1099  * @return the calculated shape
1100  */
1101 inline TensorShape compute_split_shape(const ITensorInfo *input, unsigned int axis, unsigned int num_splits)
1102 {
1103  TensorShape empty_shape;
1104  empty_shape.set(0, 0);
1105 
1106  TensorShape out_shape{ input->tensor_shape() };
1107 
1108  // Return empty shape if axis is invalid
1109  if(axis > input->tensor_shape().num_dimensions())
1110  {
1111  return empty_shape;
1112  }
1113 
1114  size_t axis_size = out_shape[axis];
1115 
1116  // Return empty shape if num_split is not valid
1117  if(axis_size % num_splits)
1118  {
1119  return empty_shape;
1120  }
1121 
1122  out_shape[axis] = axis_size / num_splits;
1123  return out_shape;
1124 }
1125 
1126 /** Calculate the space to batch output shape of a tensor
1127  *
1128  * @param[in] input Input tensor info
1129  * @param[in] block_x Block shape x value
1130  * @param[in] block_y Block shape y value
1131  * @param[in] padding_left Left padding values
1132  * @param[in] padding_right Right padding values
1133  *
1134  * @return the calculated shape
1135  */
1136 inline TensorShape compute_space_to_batch_shape(const ITensorInfo *input, const int block_x, const int block_y, const Size2D &padding_left, const Size2D &padding_right)
1137 {
1139 
1140  const DataLayout data_layout = input->data_layout();
1143  const int idx_batch = get_data_layout_dimension_index(data_layout, DataLayoutDimension::BATCHES);
1144 
1145  ARM_COMPUTE_ERROR_ON((input->tensor_shape()[idx_width] + padding_left.x() + padding_right.x()) % block_x != 0);
1146  ARM_COMPUTE_ERROR_ON((input->tensor_shape()[idx_height] + padding_left.y() + padding_right.y()) % block_y != 0);
1147 
1148  output_shape.set(idx_width, (input->tensor_shape()[idx_width] + padding_left.x() + padding_right.x()) / block_x);
1149  output_shape.set(idx_height, (input->tensor_shape()[idx_height] + padding_left.y() + padding_right.y()) / block_y);
1150  output_shape.set(idx_batch, input->tensor_shape()[idx_batch] * block_x * block_y);
1151 
1152  return output_shape;
1153 }
1154 
1155 /** Calculate the space to batch output shape of a tensor
1156  *
1157  * @param[in] input Input tensor info
1158  * @param[in] block_shape Block shape value
1159  *
1160  * @return the calculated shape
1161  */
1162 inline TensorShape compute_space_to_depth_shape(const ITensorInfo *input, int32_t block_shape)
1163 {
1165 
1166  const DataLayout data_layout = input->data_layout();
1169  const int idx_depth = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
1170 
1171  output_shape.set(idx_width, input->tensor_shape()[idx_width] * block_shape);
1172  output_shape.set(idx_height, input->tensor_shape()[idx_height] * block_shape);
1173  output_shape.set(idx_depth, input->tensor_shape()[idx_depth] / (block_shape * block_shape));
1174 
1175  return output_shape;
1176 }
1177 
1178 /** Calculate the prior box output shape of a tensor
1179  *
1180  * @param[in] input Input tensor info
1181  * @param[in] info PriorBoxLayer info
1182  *
1183  * @return the calculated shape
1184  */
1186 {
1188  const size_t idx_w = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
1189  const size_t idx_h = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
1190  const int num_priors = info.aspect_ratios().size() * info.min_sizes().size() + info.max_sizes().size();
1191 
1193  output_shape.set(0, input.dimension(idx_w) * input.dimension(idx_h) * num_priors * 4);
1194  output_shape.set(1, 2);
1195 
1196  return output_shape;
1197 }
1198 
1199 /** Calculate the padded shape of a tensor
1200  *
1201  * @param[in] input_shape Input tensor shape
1202  * @param[in] padding Paddings list
1203  *
1204  * @return the calculated shape
1205  */
1207 {
1208  TensorShape padded_shape = input_shape;
1209  for(size_t dim = 0; dim < padding.size(); ++dim)
1210  {
1211  const auto &padding_pair = padding[dim];
1212  const uint32_t shape_on_index = (padded_shape.num_dimensions() <= dim) ? 1 : input_shape[dim];
1213  padded_shape.set(dim, padding_pair.first + shape_on_index + padding_pair.second);
1214  }
1215  return padded_shape;
1216 }
1217 
1218 /** Calculate the tiled shape of a tensor
1219  *
1220  * @param[in] input_shape Input tensor shape
1221  * @param[in] multiples Paddings list
1222  *
1223  * @return the calculated shape
1224  */
1226 {
1227  TensorShape tiled_shape = input_shape;
1228  for(size_t dim = 0; dim < multiples.size(); ++dim)
1229  {
1230  tiled_shape.set(dim, input_shape[dim] * multiples[dim]);
1231  }
1232  return tiled_shape;
1233 }
1234 
1235 /** Calculate the reduced shape of a tensor given an axis
1236  *
1237  * @param[in] input Input tensor info
1238  * @param[in] axis Axis on which to perform reduction
1239  * @param[in] keep_dims (Optional) Whether to keep the dimension after reduction operation. Defaults to true.
1240  *
1241  * @return the calculated shape
1242  */
1243 inline TensorShape compute_reduced_shape(const TensorShape &input, unsigned int axis, bool keep_dims = true)
1244 {
1245  TensorShape output_shape{ input };
1246 
1247  if(!keep_dims)
1248  {
1249  output_shape.remove_dimension(axis);
1250  }
1251  else
1252  {
1253  output_shape.set(axis, 1);
1254  }
1255 
1256  return output_shape;
1257 }
1258 
1259 /** Calculate the upsampled shape of a tensor
1260  *
1261  * @param[in] input Input tensor info
1262  * @param[in] info Contains stride information (x and y)
1263  *
1264  * @return the calculated shape
1265  */
1267 {
1268  const DataLayout data_layout = input.data_layout();
1271 
1272  TensorShape scale_out_shape(input.tensor_shape());
1273  const unsigned int out_x = input.dimension(idx_width) * info.x();
1274  const unsigned int out_y = input.dimension(idx_height) * info.y();
1275  scale_out_shape.set(idx_width, out_x);
1276  scale_out_shape.set(idx_height, out_y);
1277 
1278  return scale_out_shape;
1279 }
1280 
1281 /** Get the tensor shape
1282  *
1283  * @param[in] data Input data
1284  *
1285  * @return the extracted tensor shape
1286  */
1287 template <typename T>
1289 {
1290  return data->info()->tensor_shape();
1291 }
1292 
1294 {
1295  return data->tensor_shape();
1296 }
1298 {
1299  return data->tensor_shape();
1300 }
1301 
1303 {
1304  return *data;
1305 }
1306 
1308 {
1309  return *data;
1310 }
1311 
1312 /** Calculate the unstack shape of a tensor
1313  *
1314  * @param[in] input_shape Input tensor shape
1315  * @param[in] axis Axis on which to perform the unstack operation
1316  *
1317  * @return the calculated shape
1318  */
1320 {
1321  ARM_COMPUTE_ERROR_ON(axis > input_shape.num_dimensions());
1322  input_shape.remove_dimension(axis);
1323  return input_shape;
1324 }
1325 
1326 /** Calculate the concatenate output shape of the concatenate operation along a single axis
1327  *
1328  * @param[in] input Vector containing the shapes of the inputs
1329  * @param[in] axis Axis along which to concatenate the input tensors
1330  *
1331  * @return the calculated shape
1332  */
1333 template <typename T>
1334 inline TensorShape calculate_concatenate_shape(const std::vector<T *> &input, size_t axis)
1335 {
1336  TensorShape out_shape = extract_shape(input[0]);
1337 
1338 #if defined(ARM_COMPUTE_ASSERTS_ENABLED)
1339  // All dimensions must match except the axis one
1340  for(unsigned int i = 0; i < MAX_DIMS; ++i)
1341  {
1342  if(i == axis)
1343  {
1344  continue;
1345  }
1346 
1347  for(const auto &tensor : input)
1348  {
1349  ARM_COMPUTE_ERROR_ON(tensor == nullptr);
1350  const TensorShape shape = extract_shape(tensor);
1351  ARM_COMPUTE_ERROR_ON(out_shape[i] != shape[i]);
1352  }
1353  }
1354 #endif // defined(ARM_COMPUTE_ASSERTS_ENABLED)
1355 
1356  // Calculate output shape
1357  size_t new_size = 0;
1358  for(const auto &tensor : input)
1359  {
1360  const TensorShape shape = extract_shape(tensor);
1361  new_size += shape[axis];
1362  }
1363 
1364  out_shape.set(axis, new_size);
1365 
1366  return out_shape;
1367 }
1368 /** Calculate the stack output shape of a tensor
1369  *
1370  * @param[in] a Input tensor info
1371  * @param[in] axis Axis on which to perform the stack operation
1372  * @param[in] num_tensors Number of tensors to stack
1373  *
1374  * @return the calculated shape
1375  */
1376 inline TensorShape compute_stack_shape(const ITensorInfo &a, unsigned int axis, unsigned int num_tensors)
1377 {
1380 
1381  TensorShape shape_out{ a.tensor_shape() };
1382  shape_out.set(axis, num_tensors);
1383 
1384  unsigned int i_shift = 0;
1385 
1386  for(unsigned int i = 0; i < a.num_dimensions(); ++i)
1387  {
1388  if(i == axis)
1389  {
1390  i_shift++;
1391  }
1392 
1393  shape_out.set(i + i_shift, a.tensor_shape()[i]);
1394  }
1395  return shape_out;
1396 }
1397 
1398 /** Calculate the output shape of 3d Convolution
1399  *
1400  * @param[in] src Input tensor shape
1401  * @param[in] weights Weights tensor shape
1402  * @param[in] conv3d_info 3d Convolution Parameters object
1403  *
1404  * @return the calculated shape
1405  */
1406 inline TensorShape compute_conv3d_shape(const TensorShape &src, const TensorShape &weights, const Conv3dInfo &conv3d_info)
1407 {
1408  // Weight tensor shape indices (D H W Cin Cout)
1409  constexpr unsigned int weights_depth_dim = 4u;
1410  constexpr unsigned int weights_height_dim = 3u;
1411  constexpr unsigned int weights_width_dim = 2u;
1412  constexpr unsigned int weights_CHout_dim = 0u;
1413 
1414  // Source/Destination Tensor shape indices (N D H W C)
1415  constexpr unsigned int batch_dim = 4u;
1416  constexpr unsigned int depth_dim = 3u;
1417  constexpr unsigned int height_dim = 2u;
1418  constexpr unsigned int width_dim = 1u;
1419  constexpr unsigned int channel_dim = 0u;
1420 
1421  TensorShape output_shape{ src };
1422  const size_t pad_left = conv3d_info.padding.left;
1423  const size_t pad_right = conv3d_info.padding.right;
1424  const size_t pad_top = conv3d_info.padding.top;
1425  const size_t pad_bottom = conv3d_info.padding.bottom;
1426  const size_t pad_front = conv3d_info.padding.front;
1427  const size_t pad_back = conv3d_info.padding.back;
1428  const size_t dilation_x = conv3d_info.dilation.width;
1429  const size_t dilation_y = conv3d_info.dilation.height;
1430  const size_t dilation_z = conv3d_info.dilation.depth;
1431  const size_t stride_x = conv3d_info.stride.x();
1432  const size_t stride_y = conv3d_info.stride.y();
1433  const size_t stride_z = conv3d_info.stride.z();
1434 
1435  int output_width_size = 0;
1436  int output_height_size = 0;
1437  int output_depth_size = 0;
1438 
1439  switch(conv3d_info.round_type)
1440  {
1442  output_width_size = static_cast<int>(std::floor((static_cast<float>(src[width_dim] + pad_left + pad_right - (dilation_x * (weights[weights_width_dim] - 1) + 1)) / stride_x) + 1));
1443  output_height_size = static_cast<int>(std::floor((static_cast<float>(src[height_dim] + pad_top + pad_bottom - (dilation_y * (weights[weights_height_dim] - 1) + 1)) / stride_y) + 1));
1444  output_depth_size = static_cast<int>(std::floor((static_cast<float>(src[depth_dim] + pad_front + pad_back - (dilation_z * (weights[weights_depth_dim] - 1) + 1)) / stride_z) + 1));
1445  break;
1447  output_width_size = static_cast<int>(std::ceil((static_cast<float>(src[width_dim] + pad_left + pad_right - (dilation_x * (weights[weights_width_dim] - 1) + 1)) / stride_x) + 1));
1448  output_height_size = static_cast<int>(std::ceil((static_cast<float>(src[height_dim] + pad_top + pad_bottom - (dilation_y * (weights[weights_height_dim] - 1) + 1)) / stride_y) + 1));
1449  output_depth_size = static_cast<int>(std::ceil((static_cast<float>(src[depth_dim] + pad_front + pad_back - (dilation_z * (weights[weights_depth_dim] - 1) + 1)) / stride_z) + 1));
1450  break;
1451  default:
1452  ARM_COMPUTE_ERROR("Unsupported rounding type");
1453  }
1454 
1455  output_shape.set(batch_dim, src[batch_dim]);
1456  output_shape.set(width_dim, output_width_size);
1457  output_shape.set(height_dim, output_height_size);
1458  output_shape.set(depth_dim, output_depth_size);
1459  output_shape.set(channel_dim, weights[weights_CHout_dim]);
1460  return output_shape;
1461 }
1462 
1463 inline TensorShape compute_gather_shape(const TensorShape &input_shape, const TensorShape &indices_shape, uint32_t actual_axis)
1464 {
1465  ARM_COMPUTE_ERROR_ON(indices_shape.num_dimensions() > 1);
1466  ARM_COMPUTE_ERROR_ON(input_shape.num_dimensions() > 4);
1467  ARM_COMPUTE_ERROR_ON(actual_axis >= input_shape.num_dimensions());
1468 
1470  output_shape[actual_axis] = indices_shape[0];
1471 
1472  return output_shape;
1473 }
1474 } // namespace shape_calculator
1475 } // namespace misc
1476 } // namespace arm_compute
1477 #endif /* ARM_COMPUTE_MISC_SHAPE_CALCULATOR_H */
virtual size_t num_dimensions() const =0
The number of dimensions of the tensor (rank)
void shift_right(size_t step)
Shifts right the tensor shape increasing its dimensions.
Definition: TensorShape.h:144
TensorShape compute_slice_shape(const TensorShape &input_shape, const Coordinates &starts, const Coordinates &ends)
Calculate the slice output shape of a tensor.
Shape of a tensor.
Definition: TensorShape.h:39
TensorShape compute_permutation_output_shape(const ITensorInfo &input, const PermutationVector &perm)
Calculate the permuted shape of an input given a permutation vector.
TensorShape compute_depth_to_space_shape(const TensorShape &input_shape, DataLayout data_layout, int block)
Calculate the depth to space output shape of a tensor.
TensorShape compute_depthwise_convolution_shape(const ITensorInfo &input, const ITensorInfo &weights, const ConvolutionInfo &info)
Calculate the depthwise convolution output shape of a tensor.
constexpr unsigned int channel_dim
Definition: Conv3D.cpp:36
void remove_dimension(size_t n)
Accessor to remove the dimension n from the tensor shape.
Definition: TensorShape.h:111
Descriptor used by the 3d Convolution function.
TensorShape compute_winograd_input_transform_shape(const ITensorInfo &input, const WinogradInfo &winograd_info)
Calculate the winograd input transform shape.
DataLayout output_data_layout
Data layout to use for the output tensor once the convolution has been applied (NCHW or NHWC) ...
Definition: Types.h:2212
TensorShape calculate_unstack_shape(TensorShape input_shape, unsigned int axis)
Calculate the unstack shape of a tensor.
TensorShape compute_transpose1xW_with_element_size_shape(const ITensorInfo &b, int mult_transpose1xW_width=1)
Calculate the transposed 1xW width element shape.
const size_t weights_height
Descriptor used by the GEMM kernels.
TensorShape compute_stack_shape(const ITensorInfo &a, unsigned int axis, unsigned int num_tensors)
Calculate the stack output shape of a tensor.
virtual size_t dimension(size_t index) const =0
Return the size of the requested dimension.
std::vector< PaddingInfo > PaddingList
List of padding information.
Definition: Types.h:440
TensorShape compute_roi_align_shape(const ITensorInfo &input, const ITensorInfo &rois, ROIPoolingLayerInfo pool_info)
Calculate the output roi align shape of a tensor.
SimpleTensor< float > b
Definition: DFT.cpp:157
unsigned int v0
Number of vertical blocks of size (m0xk0) stored on the same output row.
Definition: Types.h:1947
#define ARM_COMPUTE_ERROR(msg)
Print the given message then throw an std::runtime_error.
Definition: Error.h:352
unsigned int depth_output_gemm3d
Depth of the output tensor in case is reinterpreted as 3D.
constexpr unsigned int weights_height_dim
Definition: Conv3D.cpp:40
Winograd information.
Definition: Types.h:2193
GEMM reshape information class.
Definition: Types.h:1794
PadStrideInfo convolution_info
Convolution info (Pads, strides,...)
Definition: Types.h:2211
std::vector< float > aspect_ratios() const
Get aspect ratios.
Definition: Types.h:903
TensorShape compute_mm_shape(const ITensorInfo &input0, const ITensorInfo &input1, bool is_interleaved_transposed, const GEMMReshapeInfo &reshape_info)
Calculate the matrix multiplication output shape of two tensors.
TensorShape compute_reductionA_shape(const ITensorInfo &b)
Calculate the reductionA shape used in GEMMLowp.
constexpr unsigned int weights_depth_dim
Definition: Conv3D.cpp:39
TensorShape compute_softmax_shape(const ITensorInfo *input, size_t axis=1)
Calculate the softmax output shape of a tensor.
Coordinates BiStrides
Bidirectional strides.
Definition: Types.h:53
TensorShape compute_space_to_batch_shape(const ITensorInfo *input, const int block_x, const int block_y, const Size2D &padding_left, const Size2D &padding_right)
Calculate the space to batch output shape of a tensor.
unsigned int h0
Number of horizontal blocks of size (k0xn0) stored on the same output row.
Definition: Types.h:1962
#define ARM_COMPUTE_ERROR_ON(cond)
If the condition is true then an error message is printed and an exception thrown.
Definition: Error.h:466
TensorShape compute_rnn_shape(const ITensorInfo *input, const unsigned int batch_size)
Calculate the RNN shape of a tensor.
GEMM LHS (Left Hand Side) matrix information.
Definition: Types.h:1938
Store the tensor&#39;s metadata.
Definition: ITensorInfo.h:40
Size2D compute_winograd_convolution_tiles(const Size2D &in_dims, const Size2D &kernel_size, const Size2D &output_tile_size, const PadStrideInfo &conv_info)
Calculate the number of output tiles required by Winograd Convolution layer.
Definition: Helpers.h:227
unsigned int M
TensorShape compute_reorg_output_shape(const ITensorInfo &input, int32_t stride)
Calculate the output shape of the reorg layer given a stride.
size_t x() const
Semantic accessor for width as x.
Definition: Size2D.h:75
unsigned int pooled_width() const
Get the pooled width of the layer.
Definition: Types.h:1283
unsigned int pad_top() const
Get the top padding.
Definition: Types.h:740
TensorShape compute_interleaved_shape(const ITensorInfo &a, int mult_interleave4x4_height=1, bool reinterpret_input_as_3d=false)
Calculate the interleaved shape of an input tensor.
TensorShape compute_output_stage_shape(const ITensorInfo &input, unsigned int gemm_3d_depth=1, bool batch_size_on_z=false)
Calculate the matrix multiplication output shape of two tensors.
SimpleTensor< float > src
Definition: DFT.cpp:155
Copyright (c) 2017-2021 Arm Limited.
size_t height
Height of the image region or rectangle.
Definition: Size2D.h:91
TensorShape compute_min_max_shape(const ITensorInfo *input)
Calculate the min/max shape output shape of a tensor.
int32_t construct_slice_end_mask(Coordinates ends)
Constructs end mask in case we want to perform a slice operation using the strided slice interface...
TensorShape compute_strided_slice_shape(const ITensorInfo &input, const Coordinates &starts, const Coordinates &ends, const Coordinates &strides, int32_t begin_mask, int32_t end_mask, int32_t shrink_axis_mask)
Calculate the strided slice output shape of a tensor.
std::pair< unsigned int, unsigned int > scaled_dimensions(int width, int height, int kernel_width, int kernel_height, const PadStrideInfo &pad_stride_info, const Size2D &dilation=Size2D(1U, 1U))
Returns expected width and height of output scaled tensor depending on dimensions rounding mode...
Definition: Utils.cpp:414
constexpr size_t MAX_DIMS
Constant value used to indicate maximum dimensions of a Window, TensorShape and Coordinates.
Definition: Dimensions.h:38
TensorShape compute_transposed_shape(const ITensorInfo &input)
Calculate the transposed shape of a tensor.
void permute(Dimensions< T > &dimensions, const PermutationVector &perm)
Permutes given Dimensions according to a permutation vector.
Definition: Helpers.h:125
TensorShape compute_deconvolution_output_shape(const std::pair< unsigned int, unsigned int > &out_dims, const ITensorInfo &input, const ITensorInfo &weights)
Calculate the output shape of the deconvolution layer.
std::pair< int, int > scaled_dimensions_signed(int width, int height, int kernel_width, int kernel_height, const PadStrideInfo &pad_stride_info)
Returns calculated width and height of output scaled tensor depending on dimensions rounding mode...
Definition: Utils.cpp:448
TensorShape compute_pool_shape(const ITensorInfo &input, PoolingLayerInfo pool_info)
Calculate the output pool shape of a tensor.
T x() const
Alias to access the size of the first dimension.
Definition: Dimensions.h:87
int n() const
Number of matrix B columns.
Definition: Types.h:1832
unsigned int depth_multiplier
Multiplier to apply to input&#39;s depth to retrieve the output depth.
Definition: Types.h:1907
TensorShape compute_flatten_shape(const ITensorInfo *input)
Calculate the flattened output shape of a tensor.
unsigned int k0
Number of partial accumulations performed by the matrix multiplication.
Definition: Types.h:1961
TensorShape compute_prior_box_shape(const ITensorInfo &input, const PriorBoxLayerInfo &info)
Calculate the prior box output shape of a tensor.
TensorShape compute_vector_to_tensor_output_shape(const TensorShape &input, size_t conv_w, size_t conv_h, const DataLayout &data_layout)
Calculate the output tensor shape of a vector input given the convolution dimensions.
unsigned int m
Number of LHS rows.
unsigned int n
Number of RHS columns.
const size_t input_width
const auto input_shape
Validate test suite is to test ARM_COMPUTE_RETURN_ON_* macros we use to check the validity of given a...
DimensionRoundingType round_type
static constexpr size_t DimX
Alias for dimension 0 also known as X dimension.
Definition: Window.h:43
#define ARM_COMPUTE_UNUSED(...)
To avoid unused variables warnings.
Definition: Error.h:152
size_t front
Padding across the depth dimenstion on the front, in elements.
Definition: Types.h:793
void collapse_from(size_t start)
Collapse dimensions starting from a given point.
Definition: Dimensions.h:183
TensorShape compute_lhs_reshaped_shape(const ITensorInfo &a, const GEMMLHSMatrixInfo &lhs_info, bool reinterpret_input_as_3d=false)
Calculate the Left Hand Side matrix reshaped shape.
TensorShape calculate_reduce_mean_shape(ITensorInfo *input, const Coordinates &reduction_axis, bool keep_dims)
Calculate the output tensor shape for the reduce mean operation.
GEMM RHS (Right Hand Side) matrix information.
Definition: Types.h:1953
virtual const TensorShape & tensor_shape() const =0
Size for each dimension of the tensor.
TensorShape compute_unpool_shape(const ITensorInfo &input, PoolingLayerInfo pool_info)
Calculate the output unpool shape of a tensor.
Size2D output_tile_size
Width and height of the output tile.
Definition: Types.h:2208
PadStrideInfo pad_stride_info
Convolution info (Pads, strides,...)
Definition: Types.h:1906
unsigned int n0
Number of columns processed by the matrix multiplication.
Definition: Types.h:1960
size_t height
Height of the 3D shape or object.
Definition: Size3D.h:93
#define ARM_COMPUTE_ERROR_ON_MSG(cond, msg)
Definition: Error.h:456
const unsigned int num_groups
Definition: Im2Col.cpp:153
TensorShape compute_tiled_shape(const TensorShape &input_shape, const Multiples &multiples)
Calculate the tiled shape of a tensor.
Coordinates of an item.
Definition: Coordinates.h:37
constexpr unsigned int depth_dim
Definition: Conv3D.cpp:33
std::pair< unsigned int, unsigned int > stride() const
Get the stride.
Definition: Types.h:704
TensorShape compute_reduced_shape(const TensorShape &input, unsigned int axis, bool keep_dims=true)
Calculate the reduced shape of a tensor given an axis.
Pooling Layer Information struct.
Definition: Types.h:1173
Size2D dilation
Dilation, in elements, across x and y.
Definition: Types.h:1909
TensorShape compute_rhs_reshaped_shape(const ITensorInfo &a, const GEMMRHSMatrixInfo &rhs_info)
Calculate the Right Hand Side matrix reshaped shape.
bool reinterpret_input_as_3d
Flag used to reinterpret the input as 3D.
PriorBox layer info.
Definition: Types.h:798
TensorShape compute_deconvolution_upsampled_shape(const ITensorInfo &input, const ITensorInfo &weights, unsigned int sx, unsigned int sy, std::pair< unsigned int, unsigned int > &out_dims, uint32_t &padx, uint32_t &pady)
Calculate the upsampled output shape used for deconvolution.
unsigned int pad_right() const
Get the right padding.
Definition: Types.h:735
size_t top
Padding across the height dimenstion on the top, in elements.
Definition: Types.h:791
size_t left
Padding across the width dimenstion on the left, in elements.
Definition: Types.h:789
size_t width
Width of the 3D shape or object.
Definition: Size3D.h:92
Padding and stride information class.
Definition: Types.h:656
virtual size_t element_size() const =0
Element size in bytes calculated as data_size() * num_channels()
std::array< T, num_max_dimensions >::iterator begin()
Returns a read/write iterator that points to the first element in the dimension array.
Definition: Dimensions.h:215
TensorShape compute_winograd_filter_transform_shape(const ITensorInfo &input, const WinogradInfo &winograd_info)
Calculate the winograd filter transform shape.
const size_t weights_width
TensorShape compute_padded_shape(const TensorShape &input_shape, const PaddingList &padding)
Calculate the padded shape of a tensor.
size_t back
Padding across the depth dimenstion on the back, in elements.
Definition: Types.h:794
Num samples, channels, height, width.
size_t y() const
Semantic accessor for height as y.
Definition: Size2D.h:84
constexpr unsigned int weights_width_dim
Definition: Conv3D.cpp:41
Strides of an item in bytes.
Definition: Strides.h:37
TensorShape compute_reductionB_shape(const ITensorInfo &a)
Calculate the reductionB shape used in GEMMLowp.
constexpr unsigned int batch_dim
Definition: Conv3D.cpp:32
static constexpr size_t DimY
Alias for dimension 1 also known as Y dimension.
Definition: Window.h:45
TensorShape extract_shape(T *data)
Get the tensor shape.
size_t right
Padding across the width dimenstion on the right, in elements.
Definition: Types.h:790
ScaleKernelInfo info(interpolation_policy, default_border_mode, PixelValue(), sampling_policy, false)
size_t depth
Depth of the 3D shape or object.
Definition: Size3D.h:94
PadStrideInfo pad_stride_info
Definition: Types.h:1261
TensorShape compute_upsample_shape(const ITensorInfo &input, const Size2D &info)
Calculate the upsampled shape of a tensor.
TensorShape compute_winograd_output_transform_shape(const ITensorInfo &input, const WinogradInfo &winograd_info)
Calculate the winograd output transform shape.
TensorShape compute_conv3d_shape(const TensorShape &src, const TensorShape &weights, const Conv3dInfo &conv3d_info)
Calculate the output shape of 3d Convolution.
size_t width
Width of the image region or rectangle.
Definition: Size2D.h:90
constexpr unsigned int weights_CHout_dim
Definition: Conv3D.cpp:43
static constexpr size_t DimZ
Alias for dimension 2 also known as Z dimension.
Definition: Window.h:47
unsigned int pooled_height() const
Get the pooled height of the layer.
Definition: Types.h:1288
TensorShape compute_weights_reshaped_shape(const ITensorInfo &weights, bool has_bias=false, unsigned int num_groups=1)
Calculate the reshaped shape of the weights.
int m() const
Number of matrix A rows.
Definition: Types.h:1824
ROI Pooling Layer Information class.
Definition: Types.h:1268
size_t get_data_layout_dimension_index(const DataLayout &data_layout, const DataLayoutDimension &data_layout_dimension)
Get the index of the given dimension.
Definition: Helpers.inl:193
Class for specifying the size of an image or rectangle.
Definition: Size2D.h:34
unsigned int num_dimensions() const
Returns the effective dimensionality of the tensor.
Definition: Dimensions.h:143
std::vector< float > max_sizes() const
Get max sizes.
Definition: Types.h:898
Num samples, height, width, channels.
const size_t input_height
TensorShape compute_batch_to_space_shape(const ITensorInfo *input, const int block_x, const int block_y)
Calculate the batch to space output shape of a tensor.
TensorShape compute_transpose1xW_shape(const ITensorInfo &b)
Calculate the transposed 1xW shape.
int depth_output_gemm3d() const
Depth (third dimension) of the output tensor to be used with the GEMM3D kernel.
Definition: Types.h:1867
Size2D kernel_size
Width and height of the kernel.
Definition: Types.h:2209
unsigned int k0
Number of partial accumulations performed by the matrix multiplication.
Definition: Types.h:1946
unsigned int m0
Number of rows processed by the matrix multiplication.
Definition: Types.h:1945
size_t z() const
Semantic accessor for depth as z.
Definition: Size3D.h:76
T y() const
Alias to access the size of the second dimension.
Definition: Dimensions.h:92
Coordinates & convert_negative_axis(Coordinates &coords, int max_value)
Convert negative coordinates to positive in the range [0, num_dims_input].
Definition: Helpers.h:257
constexpr unsigned int height_dim
Definition: Conv3D.cpp:34
TensorShape compute_col2im_shape(const ITensorInfo &input, const Size2D &convolved_dims, bool batch_size_on_z, unsigned int num_groups=1)
Calculate the Col2Im shape.
unsigned int pad_bottom() const
Get the bottom padding.
Definition: Types.h:745
Size2D input_dimensions
Width and height of the input tensor before the convolution is applied.
Definition: Types.h:2210
TensorShape calculate_concatenate_shape(const std::vector< T *> &input, size_t axis)
Calculate the concatenate output shape of the concatenate operation along a single axis...
bool reinterpret_input_as_3d() const
Flag which specifies if the input tensor has to be reinterpreted as 3D.
Definition: Types.h:1875
size_t x() const
Semantic accessor for width as x.
Definition: Size3D.h:58
TensorShape compute_split_shape(const ITensorInfo *input, unsigned int axis, unsigned int num_splits)
Calculate the split output shape of a tensor.
unsigned int pad_left() const
Get the left padding.
Definition: Types.h:730
DataLayout
[DataLayout enum definition]
Definition: Types.h:113
std::vector< uint32_t > Multiples
Information to produce a tiled version of a Tensor.
Definition: Types.h:443
TensorShape compute_im2col_conv_shape(const ITensorInfo *input, const Size2D &kernel_dims, const PadStrideInfo &conv_info, bool has_bias, const Size2D &dilation, bool batch_size_on_z, unsigned int num_groups=1)
Calculate the im2col output shape of a tensor.
void collapse(size_t n, size_t first=0)
Collapse the first n dimensions.
Definition: TensorShape.h:133
TensorShape & set(size_t dimension, size_t value, bool apply_dim_correction=true, bool increase_dim_unit=true)
Accessor to set the value of one of the dimensions.
Definition: TensorShape.h:79
TensorShape compute_deep_convolution_shape(const TensorShape &input_shape, DataLayout input_data_layout, const TensorShape &weights_shape, const PadStrideInfo &conv_info)
Calculate the deep convolution shape output shape of a tensor.
size_t area() const
The area of the image or rectangle calculated as (width * height)
Definition: Size2D.h:54
size_t bottom
Padding across the height dimenstion on the bottom, in elements.
Definition: Types.h:792
virtual DataLayout data_layout() const =0
Get the data layout of the tensor.
TensorShape compute_space_to_depth_shape(const ITensorInfo *input, int32_t block_shape)
Calculate the space to batch output shape of a tensor.
constexpr unsigned int width_dim
Definition: Conv3D.cpp:35
std::vector< float > min_sizes() const
Get min sizes.
Definition: Types.h:863
TensorShape compute_strided_slice_output_shape(TensorShape input_shape, Coordinates starts, Coordinates ends, Coordinates strides, int32_t begin_mask=0, int32_t end_mask=0, int32_t shrink_axis_mask=0, bool return_unshrinked=false)
Computes output shape of strided slice.
size_t y() const
Semantic accessor for height as y.
Definition: Size3D.h:67
TensorShape compute_gather_shape(const TensorShape &input_shape, const TensorShape &indices_shape, uint32_t actual_axis)