__input,
/,
*,
align=[],
axes=[],
axis_names='',
bytes_per_sample_hint=[0],
fill_value=0.0,
preserve=False,
seed=-1,
shape=[],
device=None,
name=None,
)#

Pads all samples with the `fill_value` in the specified axes to match the biggest extent in the batch for those axes or to match the minimum shape specified.

Here are a few examples:

• 1-D samples, fill_value = -1, axes = (0,)

The samples are padded in the first axis to match the extent of the largest sample.

```input  = [[3,   4,   2,   5,   4],
[2,   2],
[3, 199,   5]];
output = [[3,   4,   2,   5,   4],
[2,   2,  -1,  -1,  -1],
[3, 199,   5,  -1,  -1]]
```
• 1-D samples, fill_value = -1, axes = (0,), shape = (7,)

The samples are padded in the first axis to a minimum extent of 7.

```input  = [[3,   4,   2,   5,   4],
[2,   2],
[3, 199,   5],
[1,   2,   3,   4,   5,   6,   7,   8]];
output = [[3,   4,   2,   5,   4,  -1,  -1],
[2,   2,  -1,  -1,  -1,  -1,  -1],
[3, 199,   5,  -1,  -1,  -1,  -1],
[1,   2,   3,   4,   5,   6,   7,   8]]
```
• 1-D samples, fill_value = -1, axes = (0,), align = (4,)

The samples are padded in the first axis to match the extent of the largest sample and the alignment requirements. The output extent is 8, which is a result of rounding up the largest extent (5) to a multiple of alignment (4).

```input  = [[3,   4,   2,   5,   4],
[2,   2],
[3, 199,   5]];
output = [[3,   4,   2,   5,   4,  -1,  -1,  -1],
[2,   2,  -1,  -1,  -1,  -1,  -1,  -1],
[3, 199,   5,  -1,  -1,  -1,  -1,  -1]]
```
• 1-D samples, fill_value = -1, axes = (0,), shape = (1,), align = (2,)

The samples are padded in the first axis to match the alignments requirements only. The minimum extent (shape) is set to 1 to avoid any padding other than the necessary for alignment.

```input  = [[3,   4,   2,   5,   4],
[2,   2],
[3, 199,   5]];
output = [[3,   4,   2,   5,   4,  -1],
[2,   2],
[3, 199,   5,  -1]]
```
• 2-D samples, fill_value = 42, axes = (1,)

The samples are padded in the second axis to match the extent of the largest sample and uses a custom fill value 42 instead of the default 0.

```input  = [[[1,  2,  3,  4],
[5,  6,  7,  8]],
[[1,  2],
[4,  5]]]
output = [[[1,  2,  3,  4],
[5,  6,  7,  8]],
[[1,  2, 42, 42],
[4,  5, 42, 42]]]
```
• 2-D samples, fill_value = 0, axes = (0, 1), align = (4, 5)

The samples are padded in the first and second axes to match the alignment requirements of each axis.

```input  = [[[1,  2,  3,  4],
[5,  6,  7,  8],
[9, 10, 11, 12]],
[[1, 2],
[4, 5]]]
output = [[[1,  2,  3,  4,  0],
[5,  6,  7,  8,  0],
[9, 10, 11, 12,  0],
[0,  0,  0,  0,  0]],
[[1,  2,  0,  0,  0],
[4,  5,  0,  0,  0],
[0,  0,  0,  0,  0],
[0,  0,  0,  0,  0]]]
```
• 2-D samples, fill_value = 0, axes = (0, 1), align = (1, 2), shape = (4, -1)

The samples are padded in the first axis to match a minimum extent of 4, and in the second axis to match the largest sample in the batch and an alignment of 2.

```input  = [[[1,  2,  3],
[4,  5,  6]],
[[1, 2],
[4, 5],
[6, 7]]]
output = [[[1,  2,  3,  0],
[4,  5,  6,  0],
[0,  0,  0,  0],
[0,  0,  0,  0]],
[[1,  2,  0,  0],
[4,  5,  0,  0],
[6,  7,  0,  0],
[0,  0,  0,  0]]]
```
Supported backends
• ‘cpu’

• ‘gpu’

Parameters:

__input (TensorList) – Input to the operator.

Keyword Arguments:
• align (int or list of int or TensorList of int, optional, default = []) –

If specified, this argument determines the alignment on the dimensions specified by `axes` or `axis_names`.

The extent on `axis = axes[i]` will be adjusted to be a multiple of `align[i]`.

If an integer value is provided, the alignment restrictions are applied to all the padded axes.

To use alignment only, that is without any default or explicit padding behavior, set the minimum `shape` to 1 for the specified axis.

• axes (int or list of int or TensorList of int, optional, default = []) –

Indices of the axes on which the batch samples will be padded.

Negative values are interpreted as counting dimensions from the back. Valid range: `[-ndim, ndim-1]`, where ndim is the number of dimensions in the input data.

The `axis_names` and `axes` arguments are mutually exclusive. If `axes` and `axis_names` are empty, or have not been provided, the output will be padded on all of the axes.

:keyword axis_names : layout str, optional, default = ‘’: Names of the axes on which the batch samples will be padded.

The `axis_names` and `axes` arguments are mutually exclusive. If `axes` and `axis_names` are empty, or have not been provided, the output will be padded on all of the axes.

Keyword Arguments:
• bytes_per_sample_hint (int or list of int, optional, default = [0]) –

Output size hint, in bytes per sample.

If specified, the operator’s outputs residing in GPU or page-locked host memory will be preallocated to accommodate a batch of samples of this size.

• fill_value (float or TensorList of float, optional, default = 0.0) – The value to pad the batch with.

• preserve (bool, optional, default = False) – Prevents the operator from being removed from the graph even if its outputs are not used.

• seed (int, optional, default = -1) –

Random seed.

If not provided, it will be populated based on the global seed of the pipeline.

• shape (int or list of int or TensorList of int, optional, default = []) –

The extents of the output shape in the axes specified by the `axes` or `axis_names`.

Specifying -1 for an axis restores the default behavior of extending the axis to accommodate the aligned size of the largest sample in the batch.

If the provided extent is smaller than the one of the samples, padding will be applied only to match the required alignment. For example, to disable padding in an axis, except for the necessary for alignment, you can specify a value of 1.