LpPool#
LpPool  18#
Version
name: LpPool (GitHub)
domain: main
since_version: 18
function: False
support_level: SupportType.COMMON
shape inference: True
This version of the operator has been available since version 18.
Summary
LpPool consumes an input tensor X and applies Lp pooling across the tensor according to kernel sizes, stride sizes, and pad lengths. Lp pooling consisting of computing the Lp norm on all values of a subset of the input tensor according to the kernel size and downsampling the data into the output tensor Y for further processing. The output spatial shape will be following:
output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i]  {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
or#
output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i]  {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
if ceil_mode is enabled
* pad_shape[i] is sum of pads along axis i
auto_pad is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i]  {kernelSpatialShape} + 1) / strides_spatial_shape[i])
SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
And pad shape will be following if SAME_UPPER or SAME_LOWER:
pad_shape[i] = (output_spatial_shape[i]  1) * strides_spatial_shape[i] + {kernelSpatialShape}  input_spatial_shape[i]
Attributes
auto_pad: auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that output_shape[i] = ceil(input_shape[i] / strides[i]) for each axis i. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER. Default value is
'NOTSET'
.ceil_mode: Whether to use ceil or floor (default) to compute the output shape. Default value is
0
.dilations: dilation value along each spatial axis of the filter. If not present, the dilation defaults is 1 along each spatial axis.
kernel_shape (required): The size of the kernel along each axis.
p: p value of the Lp norm used to pool over the input data. Default value is
2
.pads: Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. pads format should be as follow [x1_begin, x2_begin…x1_end, x2_end,…], where xi_begin the number of pixels added at the beginning of axis i and xi_end, the number of pixels added at the end of axis i. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.
strides: Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.
Inputs
X (heterogeneous)  T: Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 … Dn), where N is the batch size.
Outputs
Y (heterogeneous)  T: Output data tensor from Lp pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes.
Type Constraints
T in ( tensor(double), tensor(float), tensor(float16) ): Constrain input and output types to float tensors.
Examples
Differences
0  0  LpPool consumes an input tensor X and applies Lp pooling across  LpPool consumes an input tensor X and applies Lp pooling across 
1  1  the tensor according to kernel sizes, stride sizes, and pad lengths.  the tensor according to kernel sizes, stride sizes, and pad lengths. 
2  2  Lp pooling consisting of computing the Lp norm on all values of a subset  Lp pooling consisting of computing the Lp norm on all values of a subset 
3  3  of the input tensor according to the kernel size and downsampling the  of the input tensor according to the kernel size and downsampling the 
4  data into the output tensor Y for further processing. The output spatial shape will be following:  
5  ::  
6 
 
7  output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i]  {kernelSpatialShape}) / strides_spatial_shape[i] + 1)  
8 
 
9  or  
10  ::  
11 
 
12  output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i]  {kernelSpatialShape}) / strides_spatial_shape[i] + 1)  
13 
 
14  if ceil_mode is enabled  
15 
 
16  ::  
17 
 
18  * pad_shape[i] is sum of pads along axis i  
19 
 
4  20  data into the output tensor Y for further processing. 

21  ::  
5  22 


23  VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i]  {kernelSpatialShape} + 1) / strides_spatial_shape[i])  
24  SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])  
25 
 
26  And pad shape will be following if SAME_UPPER or SAME_LOWER:  
27  ::  
28 
 
29  pad_shape[i] = (output_spatial_shape[i]  1) * strides_spatial_shape[i] + {kernelSpatialShape}  input_spatial_shape[i]  
30 
 
6  31  **Attributes**  **Attributes** 
7  32 


8  33  * **auto_pad**:  * **auto_pad**: 
9  34  auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID.  auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. 
10  35  Where default value is NOTSET, which means explicit padding is used.  Where default value is NOTSET, which means explicit padding is used. 
11  36  SAME_UPPER or SAME_LOWER mean pad the input so that output_shape[i]  SAME_UPPER or SAME_LOWER mean pad the input so that output_shape[i] 
12  37  = ceil(input_shape[i] / strides[i]) for each axis i. The padding  = ceil(input_shape[i] / strides[i]) for each axis i. The padding 
13  38  is split between the two sides equally or almost equally (depending  is split between the two sides equally or almost equally (depending 
14  39  on whether it is even or odd). In case the padding is an odd number,  on whether it is even or odd). In case the padding is an odd number, 
15  40  the extra padding is added at the end for SAME_UPPER and at the  the extra padding is added at the end for SAME_UPPER and at the 
16  41  beginning for SAME_LOWER. Default value is 'NOTSET'.  beginning for SAME_LOWER. Default value is 'NOTSET'. 
42  * **ceil_mode**:  
43  Whether to use ceil or floor (default) to compute the output shape. Default value is 0.  
44  * **dilations**:  
45  dilation value along each spatial axis of the filter. If not  
46  present, the dilation defaults is 1 along each spatial axis.  
17  47  * **kernel_shape** (required):  * **kernel_shape** (required): 
18  48  The size of the kernel along each axis.  The size of the kernel along each axis. 
19  49  * **p**:  * **p**: 
20  50  p value of the Lp norm used to pool over the input data. Default value is 2.  p value of the Lp norm used to pool over the input data. Default value is 2. 
21  51  * **pads**:  * **pads**: 
22  52  Padding for the beginning and ending along each spatial axis, it can  Padding for the beginning and ending along each spatial axis, it can 
23  53  take any value greater than or equal to 0. The value represent the  take any value greater than or equal to 0. The value represent the 
24  54  number of pixels added to the beginning and end part of the  number of pixels added to the beginning and end part of the 
25  55  corresponding axis. pads format should be as follow [x1_begin,  corresponding axis. pads format should be as follow [x1_begin, 
26  56  x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels  x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels 
27  57  added at the beginning of axis i and xi_end, the number of pixels  added at the beginning of axis i and xi_end, the number of pixels 
28  58  added at the end of axis i. This attribute cannot be used  added at the end of axis i. This attribute cannot be used 
29  59  simultaneously with auto_pad attribute. If not present, the padding  simultaneously with auto_pad attribute. If not present, the padding 
30  60  defaults to 0 along start and end of each spatial axis.  defaults to 0 along start and end of each spatial axis. 
31  61  * **strides**:  * **strides**: 
32  62  Stride along each spatial axis. If not present, the stride defaults  Stride along each spatial axis. If not present, the stride defaults 
33  63  to 1 along each spatial axis.  to 1 along each spatial axis. 
34  64 


35  65  **Inputs**  **Inputs** 
36  66 


37  67  * **X** (heterogeneous)  **T**:  * **X** (heterogeneous)  **T**: 
38  68  Input data tensor from the previous operator; dimensions for image  Input data tensor from the previous operator; dimensions for image 
39  69  case are (N x C x H x W), where N is the batch size, C is the number  case are (N x C x H x W), where N is the batch size, C is the number 
40  70  of channels, and H and W are the height and the width of the data.  of channels, and H and W are the height and the width of the data. 
41  71  For non image case, the dimensions are in the form of (N x C x D1 x  For non image case, the dimensions are in the form of (N x C x D1 x 
42  72  D2 ... Dn), where N is the batch size.  D2 ... Dn), where N is the batch size. 
43  73 


44  74  **Outputs**  **Outputs** 
45  75 


46  76  * **Y** (heterogeneous)  **T**:  * **Y** (heterogeneous)  **T**: 
47  77  Output data tensor from Lp pooling across the input tensor.  Output data tensor from Lp pooling across the input tensor. 
48  78  Dimensions will vary based on various kernel, stride, and pad sizes.  Dimensions will vary based on various kernel, stride, and pad sizes. 
49  79 


50  80  **Type Constraints**  **Type Constraints** 
51  81 


52  82  * **T** in (  * **T** in ( 
53  83  tensor(double),  tensor(double), 
54  84  tensor(float),  tensor(float), 
55  85  tensor(float16)  tensor(float16) 
56  86  ):  ): 
57  87  Constrain input and output types to float tensors.  Constrain input and output types to float tensors. 
LpPool  11#
Version
name: LpPool (GitHub)
domain: main
since_version: 11
function: False
support_level: SupportType.COMMON
shape inference: True
This version of the operator has been available since version 11.
Summary
LpPool consumes an input tensor X and applies Lp pooling across the tensor according to kernel sizes, stride sizes, and pad lengths. Lp pooling consisting of computing the Lp norm on all values of a subset of the input tensor according to the kernel size and downsampling the data into the output tensor Y for further processing.
Attributes
auto_pad: auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that output_shape[i] = ceil(input_shape[i] / strides[i]) for each axis i. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER. Default value is
'NOTSET'
.kernel_shape (required): The size of the kernel along each axis.
p: p value of the Lp norm used to pool over the input data. Default value is
2
.pads: Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. pads format should be as follow [x1_begin, x2_begin…x1_end, x2_end,…], where xi_begin the number of pixels added at the beginning of axis i and xi_end, the number of pixels added at the end of axis i. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.
strides: Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.
Inputs
X (heterogeneous)  T: Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 … Dn), where N is the batch size.
Outputs
Y (heterogeneous)  T: Output data tensor from Lp pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes.
Type Constraints
T in ( tensor(double), tensor(float), tensor(float16) ): Constrain input and output types to float tensors.
Differences
0  0  LpPool consumes an input tensor X and applies Lp pooling across  LpPool consumes an input tensor X and applies Lp pooling across 
1  1  the tensor according to kernel sizes, stride sizes, and pad lengths.  the tensor according to kernel sizes, stride sizes, and pad lengths. 
2  2  Lp pooling consisting of computing the Lp norm on all values of a subset  Lp pooling consisting of computing the Lp norm on all values of a subset 
3  3  of the input tensor according to the kernel size and downsampling the  of the input tensor according to the kernel size and downsampling the 
4  4  data into the output tensor Y for further processing.  data into the output tensor Y for further processing. 
5  5 


6  6  **Attributes**  **Attributes** 
7  7 


8  8  * **auto_pad**:  * **auto_pad**: 
9  9  auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID.  auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. 
10  10  Where default value is NOTSET, which means explicit padding is used.  Where default value is NOTSET, which means explicit padding is used. 
11  11  SAME_UPPER or SAME_LOWER mean pad the input so that the output 

12  spatial size match the input.In case of odd number add the extra  
12  = ceil(input_shape[i] / strides[i]) for each axis i. The padding  
13  is split between the two sides equally or almost equally (depending  
14  on whether it is even or odd). In case the padding is an odd number,  
13  15  padding at the end for SAME_UPPER and at the beginning for 

14  16  SAME_LOWER. VALID mean no padding. Default value is 'NOTSET'. 

15  17  * **kernel_shape** (required):  * **kernel_shape** (required): 
16  18  The size of the kernel along each axis.  The size of the kernel along each axis. 
17  19  * **p**:  * **p**: 
18  20  p value of the Lp norm used to pool over the input data. Default value is 2.  p value of the Lp norm used to pool over the input data. Default value is 2. 
19  21  * **pads**:  * **pads**: 
20  22  Padding for the beginning and ending along each spatial axis, it can  Padding for the beginning and ending along each spatial axis, it can 
21  23  take any value greater than or equal to 0. The value represent the  take any value greater than or equal to 0. The value represent the 
22  24  number of pixels added to the beginning and end part of the  number of pixels added to the beginning and end part of the 
23  25  corresponding axis. pads format should be as follow [x1_begin,  corresponding axis. pads format should be as follow [x1_begin, 
24  26  x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels  x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels 
25  27  added at the beginning of axis i and xi_end, the number of pixels  added at the beginning of axis i and xi_end, the number of pixels 
26  28  added at the end of axis i. This attribute cannot be used  added at the end of axis i. This attribute cannot be used 
27  29  simultaneously with auto_pad attribute. If not present, the padding  simultaneously with auto_pad attribute. If not present, the padding 
28  30  defaults to 0 along start and end of each spatial axis.  defaults to 0 along start and end of each spatial axis. 
29  31  * **strides**:  * **strides**: 
30  32  Stride along each spatial axis. 

33  to 1 along each spatial axis.  
31  34 


32  35  **Inputs**  **Inputs** 
33  36 


34  37  * **X** (heterogeneous)  **T**:  * **X** (heterogeneous)  **T**: 
35  38  Input data tensor from the previous operator; dimensions for image  Input data tensor from the previous operator; dimensions for image 
36  39  case are (N x C x H x W), where N is the batch size, C is the number  case are (N x C x H x W), where N is the batch size, C is the number 
37  40  of channels, and H and W are the height and the width of the data.  of channels, and H and W are the height and the width of the data. 
38  41  For non image case, the dimensions are in the form of (N x C x D1 x  For non image case, the dimensions are in the form of (N x C x D1 x 
39  42  D2 ... Dn), where N is the batch size.  D2 ... Dn), where N is the batch size. 
40  43 


41  44  **Outputs**  **Outputs** 
42  45 


43  46  * **Y** (heterogeneous)  **T**:  * **Y** (heterogeneous)  **T**: 
44  47  Output data tensor from Lp pooling across the input tensor.  Output data tensor from Lp pooling across the input tensor. 
45  48  Dimensions will vary based on various kernel, stride, and pad sizes.  Dimensions will vary based on various kernel, stride, and pad sizes. 
46  49 


47  50  **Type Constraints**  **Type Constraints** 
48  51 


49  52  * **T** in (  * **T** in ( 
50  53  tensor(double),  tensor(double), 
51  54  tensor(float),  tensor(float), 
52  55  tensor(float16)  tensor(float16) 
53  56  ):  ): 
54  57  Constrain input and output types to float tensors.  Constrain input and output types to float tensors. 
LpPool  2#
Version
name: LpPool (GitHub)
domain: main
since_version: 2
function: False
support_level: SupportType.COMMON
shape inference: True
This version of the operator has been available since version 2.
Summary
LpPool consumes an input tensor X and applies Lp pooling across the tensor according to kernel sizes, stride sizes, and pad lengths. Lp pooling consisting of computing the Lp norm on all values of a subset of the input tensor according to the kernel size and downsampling the data into the output tensor Y for further processing.
Attributes
auto_pad: auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding. Default value is
'NOTSET'
.kernel_shape (required): The size of the kernel along each axis.
p: p value of the Lp norm used to pool over the input data. Default value is
2
.pads: Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. pads format should be as follow [x1_begin, x2_begin…x1_end, x2_end,…], where xi_begin the number of pixels added at the beginning of axis i and xi_end, the number of pixels added at the end of axis i. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.
strides: Stride along each spatial axis.
Inputs
X (heterogeneous)  T: Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 … Dn), where N is the batch size.
Outputs
Y (heterogeneous)  T: Output data tensor from Lp pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes.
Type Constraints
T in ( tensor(double), tensor(float), tensor(float16) ): Constrain input and output types to float tensors.
Differences
0  0  LpPool consumes an input tensor X and applies Lp pooling across the 

1  1  the tensor according to kernel sizes, stride sizes, and pad lengths.  the tensor according to kernel sizes, stride sizes, and pad lengths. 
2  2  Lp pooling consisting of computing the Lp norm on all values of a subset  Lp pooling consisting of computing the Lp norm on all values of a subset 
3  3  of the input tensor according to the kernel size and downsampling the  of the input tensor according to the kernel size and downsampling the 
4  4  data into the output tensor Y for further processing.  data into the output tensor Y for further processing. 
5  5 


6  6  **Attributes**  **Attributes** 
7  7 


8  8  * **auto_pad**:  * **auto_pad**: 
9  9  auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID.  auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. 
10  10  Where default value is NOTSET, which means explicit padding is used.  Where default value is NOTSET, which means explicit padding is used. 
11  11  SAME_UPPER or SAME_LOWER mean pad the input so that the output size 

12  12  match the input.In case of odd number add the extra padding at the 

13  13  end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean 

14  SAME_LOWER. VALID mean no padding. Default value is 'NOTSET'.  
14  15  no padding. DEPRECATION NOTE: auto_pad is only intended to support 

15  legacy uses, and for framework authors, one is explicitly encouraged  
16  to use explicit padding specified in the pads attribute. Default value is 'NOTSET'.  
17  * **kernel_shape**:  
18  16  The size of the kernel along each axis.  The size of the kernel along each axis. 
19  17  * **p**:  * **p**: 
20  18  p value of the Lp norm used to pool over the input data, default is 

21  2.0. Default value is 2.0.  
22  19  * **pads**:  * **pads**: 
23  20  Padding for the beginning and ending along each axis, it can take 

24  21  any value greater than or equal to 0. The value represent the number 

25  22  of pixels added to the beginning and end part of the corresponding 

26  23  axis. pads format should be as follow [x1_begin, 

27  24  x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels  x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels 
28  25  added at the beginning of axis i and xi_end, the number of pixels  added at the beginning of axis i and xi_end, the number of pixels 
29  26  added at the end of axis i. This attribute cannot be used  added at the end of axis i. This attribute cannot be used 
30  27  simultaneously with auto_pad attribute. 

28  defaults to 0 along start and end of each spatial axis.  
31  29  * **strides**:  * **strides**: 
32  30  Stride along each axis. 

33  31 


34  32  **Inputs**  **Inputs** 
35  33 


36  34  * **X** (heterogeneous)  **T**:  * **X** (heterogeneous)  **T**: 
37  35  Input data tensor from the previous operator; dimensions for image  Input data tensor from the previous operator; dimensions for image 
38  36  case are (N x C x H x W), where N is the batch size, C is the number  case are (N x C x H x W), where N is the batch size, C is the number 
39  37  of channels, and H and W are the height and the width of the data.  of channels, and H and W are the height and the width of the data. 
40  38  For non image case, the dimension are in the form of (N x C x D1 x 

41  39  D2 ... Dn), where N is the batch size.  D2 ... Dn), where N is the batch size. 
42  40 


43  41  **Outputs**  **Outputs** 
44  42 


45  43  * **Y** (heterogeneous)  **T**:  * **Y** (heterogeneous)  **T**: 
46  44  Output data tensor from Lp pooling across the input tensor.  Output data tensor from Lp pooling across the input tensor. 
47  45  Dimensions will vary based on various kernel, stride, and pad sizes.  Dimensions will vary based on various kernel, stride, and pad sizes. 
48  46 


49  47  **Type Constraints**  **Type Constraints** 
50  48 


51  49  * **T** in (  * **T** in ( 
52  50  tensor(double),  tensor(double), 
53  51  tensor(float),  tensor(float), 
54  52  tensor(float16)  tensor(float16) 
55  53  ):  ): 
56  54  Constrain input and output types to float tensors.  Constrain input and output types to float tensors. 
LpPool  1#
Version
name: LpPool (GitHub)
domain: main
since_version: 1
function: False
support_level: SupportType.COMMON
shape inference: False
This version of the operator has been available since version 1.
Summary
LpPool consumes an input tensor X and applies Lp pooling across the the tensor according to kernel sizes, stride sizes, and pad lengths. Lp pooling consisting of computing the Lp norm on all values of a subset of the input tensor according to the kernel size and downsampling the data into the output tensor Y for further processing.
Attributes
auto_pad: auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding. DEPRECATION NOTE: auto_pad is only intended to support legacy uses, and for framework authors, one is explicitly encouraged to use explicit padding specified in the pads attribute. Default value is
'NOTSET'
.kernel_shape: The size of the kernel along each axis.
p: p value of the Lp norm used to pool over the input data, default is 2.0. Default value is
2.0
.pads: Padding for the beginning and ending along each axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. pads format should be as follow [x1_begin, x2_begin…x1_end, x2_end,…], where xi_begin the number of pixels added at the beginning of axis i and xi_end, the number of pixels added at the end of axis i. This attribute cannot be used simultaneously with auto_pad attribute.
strides: Stride along each axis.
Inputs
X (heterogeneous)  T: Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimension are in the form of (N x C x D1 x D2 … Dn), where N is the batch size.
Outputs
Y (heterogeneous)  T: Output data tensor from Lp pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes.
Type Constraints
T in ( tensor(double), tensor(float), tensor(float16) ): Constrain input and output types to float tensors.