neulab/docprompting-conala huggingface dataset:
tf.keras.layers.ReLU     View source on GitHub    Rectified Linear Unit activation function. Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.ReLU  
tf.keras.layers.ReLU(
    max_value=None, negative_slope=0, threshold=0, **kwargs
)
 With default values, it returns element-wise max(x, 0). Otherwise, it follows: f(x) = max_value if x >= max_value
f(x) = x if threshold <= x < max_value
f(x) = negative_slope * (x - threshold) otherwise
 Usage: 
layer = tf.keras.layers.ReLU()
output = layer([-3.0, -1.0, 0.0, 2.0])
list(output.numpy())
[0.0, 0.0, 0.0, 2.0]
layer = tf.keras.layers.ReLU(max_value=1.0)
output = layer([-3.0, -1.0, 0.0, 2.0])
list(output.numpy())
[0.0, 0.0, 0.0, 1.0]
layer = tf.keras.layers.ReLU(negative_slope=1.0)
output = layer([-3.0, -1.0, 0.0, 2.0])
list(output.numpy())
[-3.0, -1.0, 0.0, 2.0]
layer = tf.keras.layers.ReLU(threshold=1.5)
output = layer([-3.0, -1.0, 1.0, 2.0])
list(output.numpy())
[0.0, 0.0, 0.0, 2.0]
 Input shape: Arbitrary. Use the keyword argument input_shape (tuple of integers, does not include the batch axis) when using this layer as the first layer in a model. Output shape: Same shape as the input.
 


 Arguments
  max_value   Float >= 0. Maximum activation value. Default to None, which means unlimited.  
  negative_slope   Float >= 0. Negative slope coefficient. Default to 0.  
  threshold   Float. Threshold value for thresholded activation. Default to 0.
tf.keras.layers.RepeatVector     View source on GitHub    Repeats the input n times. Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.RepeatVector  
tf.keras.layers.RepeatVector(
    n, **kwargs
)
 Example: model = Sequential()
model.add(Dense(32, input_dim=32))
# now: model.output_shape == (None, 32)
# note: `None` is the batch dimension

model.add(RepeatVector(3))
# now: model.output_shape == (None, 3, 32)

 


 Arguments
  n   Integer, repetition factor.    Input shape: 2D tensor of shape (num_samples, features). Output shape: 3D tensor of shape (num_samples, n, features).
tf.keras.layers.Reshape     View source on GitHub    Layer that reshapes inputs into the given shape. Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.Reshape  
tf.keras.layers.Reshape(
    target_shape, **kwargs
)
 Input shape: Arbitrary, although all dimensions in the input shape must be known/fixed. Use the keyword argument input_shape (tuple of integers, does not include the samples/batch size axis) when using this layer as the first layer in a model. Output shape: (batch_size,) + target_shape Example: 
# as first layer in a Sequential model
model = tf.keras.Sequential()
model.add(tf.keras.layers.Reshape((3, 4), input_shape=(12,)))
# model.output_shape == (None, 3, 4), `None` is the batch size.
model.output_shape
(None, 3, 4)
 
# as intermediate layer in a Sequential model
model.add(tf.keras.layers.Reshape((6, 2)))
model.output_shape
(None, 6, 2)
 
# also supports shape inference using `-1` as dimension
model.add(tf.keras.layers.Reshape((-1, 2, 2)))
model.output_shape
(None, 3, 2, 2)

 


 Args
  target_shape   Target shape. Tuple of integers, does not include the samples dimension (batch size).  
  **kwargs   Any additional layer keyword arguments.
tf.keras.layers.serialize     View source on GitHub     View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.serialize  
tf.keras.layers.serialize(
    layer
)
tf.keras.layers.Softmax     View source on GitHub    Softmax activation function. Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.Softmax  
tf.keras.layers.Softmax(
    axis=-1, **kwargs
)
 Example without mask: 
inp = np.asarray([1., 2., 1.])
layer = tf.keras.layers.Softmax()
layer(inp).numpy()
array([0.21194157, 0.5761169 , 0.21194157], dtype=float32)
mask = np.asarray([True, False, True], dtype=bool)
layer(inp, mask).numpy()
array([0.5, 0. , 0.5], dtype=float32)
 Input shape: Arbitrary. Use the keyword argument input_shape (tuple of integers, does not include the samples axis) when using this layer as the first layer in a model. Output shape: Same shape as the input.
 


 Arguments
  axis   Integer, or list of Integers, axis along which the softmax normalization is applied.    Call arguments:  
inputs: The inputs, or logits to the softmax layer. 
mask: A boolean mask of the same shape as inputs. Defaults to None. 
 


 Returns   softmaxed output with the same shape as inputs.
tf.keras.layers.SpatialDropout1D     View source on GitHub    Spatial 1D version of Dropout. Inherits From: Dropout, Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.SpatialDropout1D  
tf.keras.layers.SpatialDropout1D(
    rate, **kwargs
)
 This version performs the same function as Dropout, however, it drops entire 1D feature maps instead of individual elements. If adjacent frames within feature maps are strongly correlated (as is normally the case in early convolution layers) then regular dropout will not regularize the activations and will otherwise just result in an effective learning rate decrease. In this case, SpatialDropout1D will help promote independence between feature maps and should be used instead.
 


 Arguments
  rate   Float between 0 and 1. Fraction of the input units to drop.    Call arguments:  
inputs: A 3D tensor. 
training: Python boolean indicating whether the layer should behave in training mode (adding dropout) or in inference mode (doing nothing).  Input shape: 3D tensor with shape: (samples, timesteps, channels) Output shape: Same as input. References:  Efficient Object Localization Using Convolutional Networks
tf.keras.layers.SpatialDropout2D     View source on GitHub    Spatial 2D version of Dropout. Inherits From: Dropout, Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.SpatialDropout2D  
tf.keras.layers.SpatialDropout2D(
    rate, data_format=None, **kwargs
)
 This version performs the same function as Dropout, however, it drops entire 2D feature maps instead of individual elements. If adjacent pixels within feature maps are strongly correlated (as is normally the case in early convolution layers) then regular dropout will not regularize the activations and will otherwise just result in an effective learning rate decrease. In this case, SpatialDropout2D will help promote independence between feature maps and should be used instead.
 


 Arguments
  rate   Float between 0 and 1. Fraction of the input units to drop.  
  data_format   'channels_first' or 'channels_last'. In 'channels_first' mode, the channels dimension (the depth) is at index 1, in 'channels_last' mode is it at index 3. It defaults to the image_data_format value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "channels_last".    Call arguments:  
inputs: A 4D tensor. 
training: Python boolean indicating whether the layer should behave in training mode (adding dropout) or in inference mode (doing nothing).  Input shape: 4D tensor with shape: (samples, channels, rows, cols) if data_format='channels_first' or 4D tensor with shape: (samples, rows, cols, channels) if data_format='channels_last'. Output shape: Same as input. References:  Efficient Object Localization Using Convolutional Networks
tf.keras.layers.SpatialDropout3D     View source on GitHub    Spatial 3D version of Dropout. Inherits From: Dropout, Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.SpatialDropout3D  
tf.keras.layers.SpatialDropout3D(
    rate, data_format=None, **kwargs
)
 This version performs the same function as Dropout, however, it drops entire 3D feature maps instead of individual elements. If adjacent voxels within feature maps are strongly correlated (as is normally the case in early convolution layers) then regular dropout will not regularize the activations and will otherwise just result in an effective learning rate decrease. In this case, SpatialDropout3D will help promote independence between feature maps and should be used instead.
 


 Arguments
  rate   Float between 0 and 1. Fraction of the input units to drop.  
  data_format   'channels_first' or 'channels_last'. In 'channels_first' mode, the channels dimension (the depth) is at index 1, in 'channels_last' mode is it at index 4. It defaults to the image_data_format value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "channels_last".    Call arguments:  
inputs: A 5D tensor. 
training: Python boolean indicating whether the layer should behave in training mode (adding dropout) or in inference mode (doing nothing).  Input shape: 5D tensor with shape: (samples, channels, dim1, dim2, dim3) if data_format='channels_first' or 5D tensor with shape: (samples, dim1, dim2, dim3, channels) if data_format='channels_last'. Output shape: Same as input. References:  Efficient Object Localization Using Convolutional Networks
tf.keras.layers.StackedRNNCells     View source on GitHub    Wrapper allowing a stack of RNN cells to behave as a single cell. Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.StackedRNNCells  
tf.keras.layers.StackedRNNCells(
    cells, **kwargs
)
 Used to implement efficient stacked RNNs.
 


 Arguments
  cells   List of RNN cell instances.    Examples: batch_size = 3
sentence_max_length = 5
n_features = 2
new_shape = (batch_size, sentence_max_length, n_features)
x = tf.constant(np.reshape(np.arange(30), new_shape), dtype = tf.float32)

rnn_cells = [tf.keras.layers.LSTMCell(128) for _ in range(2)]
stacked_lstm = tf.keras.layers.StackedRNNCells(rnn_cells)
lstm_layer = tf.keras.layers.RNN(stacked_lstm)

result = lstm_layer(x)

 


 Attributes
  output_size  
 
  state_size  
   Methods get_initial_state View source 
get_initial_state(
    inputs=None, batch_size=None, dtype=None
)
tf.keras.layers.Subtract     View source on GitHub    Layer that subtracts two inputs. Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.Subtract  
tf.keras.layers.Subtract(
    **kwargs
)
 It takes as input a list of tensors of size 2, both of the same shape, and returns a single tensor, (inputs[0] - inputs[1]), also of the same shape. Examples: import keras

input1 = keras.layers.Input(shape=(16,))
x1 = keras.layers.Dense(8, activation='relu')(input1)
input2 = keras.layers.Input(shape=(32,))
x2 = keras.layers.Dense(8, activation='relu')(input2)
# Equivalent to subtracted = keras.layers.subtract([x1, x2])
subtracted = keras.layers.Subtract()([x1, x2])

out = keras.layers.Dense(4)(subtracted)
model = keras.models.Model(inputs=[input1, input2], outputs=out)

 


 Arguments
  **kwargs   standard layer keyword arguments.
tf.keras.layers.ThresholdedReLU     View source on GitHub    Thresholded Rectified Linear Unit. Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.ThresholdedReLU  
tf.keras.layers.ThresholdedReLU(
    theta=1.0, **kwargs
)
 It follows: f(x) = x for x > theta
f(x) = 0 otherwise`
 Input shape: Arbitrary. Use the keyword argument input_shape (tuple of integers, does not include the samples axis) when using this layer as the first layer in a model. Output shape: Same shape as the input.
 


 Arguments
  theta   Float >= 0. Threshold location of activation.
tf.keras.layers.TimeDistributed     View source on GitHub    This wrapper allows to apply a layer to every temporal slice of an input. Inherits From: Wrapper, Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.TimeDistributed  
tf.keras.layers.TimeDistributed(
    layer, **kwargs
)
 The input should be at least 3D, and the dimension of index one will be considered to be the temporal dimension. Consider a batch of 32 video samples, where each sample is a 128x128 RGB image with channels_last data format, across 10 timesteps. The batch input shape is (32, 10, 128, 128, 3). You can then use TimeDistributed to apply the same Conv2D layer to each of the 10 timesteps, independently: 
inputs = tf.keras.Input(shape=(10, 128, 128, 3))
conv_2d_layer = tf.keras.layers.Conv2D(64, (3, 3))
outputs = tf.keras.layers.TimeDistributed(conv_2d_layer)(inputs)
outputs.shape
TensorShape([None, 10, 126, 126, 64])
 Because TimeDistributed applies the same instance of Conv2D to each of the timestamps, the same set of weights are used at each timestamp.
 


 Arguments
  layer   a tf.keras.layers.Layer instance.    Call arguments:  
inputs: Input tensor. 
training: Python boolean indicating whether the layer should behave in training mode or in inference mode. This argument is passed to the wrapped layer (only if the layer supports this argument). 
mask: Binary tensor of shape (samples, timesteps) indicating whether a given timestep should be masked. This argument is passed to the wrapped layer (only if the layer supports this argument). 
 


 Raises
  ValueError   If not initialized with a tf.keras.layers.Layer instance.
tf.keras.layers.UpSampling1D     View source on GitHub    Upsampling layer for 1D inputs. Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.UpSampling1D  
tf.keras.layers.UpSampling1D(
    size=2, **kwargs
)
 Repeats each temporal step size times along the time axis. Examples: 
input_shape = (2, 2, 3)
x = np.arange(np.prod(input_shape)).reshape(input_shape)
print(x)
[[[ 0  1  2]
  [ 3  4  5]]
 [[ 6  7  8]
  [ 9 10 11]]]
y = tf.keras.layers.UpSampling1D(size=2)(x)
print(y)
tf.Tensor(
  [[[ 0  1  2]
    [ 0  1  2]
    [ 3  4  5]
    [ 3  4  5]]
   [[ 6  7  8]
    [ 6  7  8]
    [ 9 10 11]
    [ 9 10 11]]], shape=(2, 4, 3), dtype=int64)

 


 Arguments
  size   Integer. Upsampling factor.    Input shape: 3D tensor with shape: (batch_size, steps, features). Output shape: 3D tensor with shape: (batch_size, upsampled_steps, features).
tf.keras.layers.UpSampling2D     View source on GitHub    Upsampling layer for 2D inputs. Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.UpSampling2D  
tf.keras.layers.UpSampling2D(
    size=(2, 2), data_format=None, interpolation='nearest', **kwargs
)
 Repeats the rows and columns of the data by size[0] and size[1] respectively. Examples: 
input_shape = (2, 2, 1, 3)
x = np.arange(np.prod(input_shape)).reshape(input_shape)
print(x)
[[[[ 0  1  2]]
  [[ 3  4  5]]]
 [[[ 6  7  8]]
  [[ 9 10 11]]]]
y = tf.keras.layers.UpSampling2D(size=(1, 2))(x)
print(y)
tf.Tensor(
  [[[[ 0  1  2]
     [ 0  1  2]]
    [[ 3  4  5]
     [ 3  4  5]]]
   [[[ 6  7  8]
     [ 6  7  8]]
    [[ 9 10 11]
     [ 9 10 11]]]], shape=(2, 2, 2, 3), dtype=int64)

 


 Arguments
  size   Int, or tuple of 2 integers. The upsampling factors for rows and columns.  
  data_format   A string, one of channels_last (default) or channels_first. The ordering of the dimensions in the inputs. channels_last corresponds to inputs with shape (batch_size, height, width, channels) while channels_first corresponds to inputs with shape (batch_size, channels, height, width). It defaults to the image_data_format value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "channels_last".  
  interpolation   A string, one of nearest or bilinear.    Input shape: 4D tensor with shape:  If data_format is "channels_last": (batch_size, rows, cols, channels)
 If data_format is "channels_first": (batch_size, channels, rows, cols)
  Output shape: 4D tensor with shape:  If data_format is "channels_last": (batch_size, upsampled_rows, upsampled_cols, channels)
 If data_format is "channels_first": (batch_size, channels, upsampled_rows, upsampled_cols)
tf.keras.layers.UpSampling3D     View source on GitHub    Upsampling layer for 3D inputs. Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.UpSampling3D  
tf.keras.layers.UpSampling3D(
    size=(2, 2, 2), data_format=None, **kwargs
)
 Repeats the 1st, 2nd and 3rd dimensions of the data by size[0], size[1] and size[2] respectively. Examples: 
input_shape = (2, 1, 2, 1, 3)
x = tf.constant(1, shape=input_shape)
y = tf.keras.layers.UpSampling3D(size=2)(x)
print(y.shape)
(2, 2, 4, 2, 3)

 


 Arguments
  size   Int, or tuple of 3 integers. The upsampling factors for dim1, dim2 and dim3.  
  data_format   A string, one of channels_last (default) or channels_first. The ordering of the dimensions in the inputs. channels_last corresponds to inputs with shape (batch_size, spatial_dim1, spatial_dim2, spatial_dim3, channels) while channels_first corresponds to inputs with shape (batch_size, channels, spatial_dim1, spatial_dim2, spatial_dim3). It defaults to the image_data_format value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "channels_last".    Input shape: 5D tensor with shape:  If data_format is "channels_last": (batch_size, dim1, dim2, dim3, channels)
 If data_format is "channels_first": (batch_size, channels, dim1, dim2, dim3)
  Output shape: 5D tensor with shape:  If data_format is "channels_last": (batch_size, upsampled_dim1, upsampled_dim2, upsampled_dim3, channels)
 If data_format is "channels_first": (batch_size, channels, upsampled_dim1, upsampled_dim2, upsampled_dim3)
tf.keras.layers.Wrapper     View source on GitHub    Abstract wrapper base class. Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.Wrapper  
tf.keras.layers.Wrapper(
    layer, **kwargs
)
 Wrappers take another layer and augment it in various ways. Do not use this class as a layer, it is only an abstract base class. Two usable wrappers are the TimeDistributed and Bidirectional wrappers.
 


 Arguments
  layer   The layer to be wrapped.
tf.keras.layers.ZeroPadding1D     View source on GitHub    Zero-padding layer for 1D input (e.g. temporal sequence). Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.ZeroPadding1D  
tf.keras.layers.ZeroPadding1D(
    padding=1, **kwargs
)
 Examples: 
input_shape = (2, 2, 3)
x = np.arange(np.prod(input_shape)).reshape(input_shape)
print(x)
[[[ 0  1  2]
  [ 3  4  5]]
 [[ 6  7  8]
  [ 9 10 11]]]
y = tf.keras.layers.ZeroPadding1D(padding=2)(x)
print(y)
tf.Tensor(
  [[[ 0  0  0]
    [ 0  0  0]
    [ 0  1  2]
    [ 3  4  5]
    [ 0  0  0]
    [ 0  0  0]]
   [[ 0  0  0]
    [ 0  0  0]
    [ 6  7  8]
    [ 9 10 11]
    [ 0  0  0]
    [ 0  0  0]]], shape=(2, 6, 3), dtype=int64)

 


 Arguments
  padding   Int, or tuple of int (length 2), or dictionary.  If int: How many zeros to add at the beginning and end of the padding dimension (axis 1). If tuple of int (length 2): How many zeros to add at the beginning and the end of the padding dimension ((left_pad, right_pad)). 

   Input shape: 3D tensor with shape (batch_size, axis_to_pad, features) Output shape: 3D tensor with shape (batch_size, padded_axis, features)
tf.keras.layers.ZeroPadding2D     View source on GitHub    Zero-padding layer for 2D input (e.g. picture). Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.ZeroPadding2D  
tf.keras.layers.ZeroPadding2D(
    padding=(1, 1), data_format=None, **kwargs
)
 This layer can add rows and columns of zeros at the top, bottom, left and right side of an image tensor. Examples: 
input_shape = (1, 1, 2, 2)
x = np.arange(np.prod(input_shape)).reshape(input_shape)
print(x)
[[[[0 1]
   [2 3]]]]
y = tf.keras.layers.ZeroPadding2D(padding=1)(x)
print(y)
tf.Tensor(
  [[[[0 0]
     [0 0]
     [0 0]
     [0 0]]
    [[0 0]
     [0 1]
     [2 3]
     [0 0]]
    [[0 0]
     [0 0]
     [0 0]
     [0 0]]]], shape=(1, 3, 4, 2), dtype=int64)

 


 Arguments
  padding   Int, or tuple of 2 ints, or tuple of 2 tuples of 2 ints.  If int: the same symmetric padding is applied to height and width. If tuple of 2 ints: interpreted as two different symmetric padding values for height and width: (symmetric_height_pad, symmetric_width_pad). If tuple of 2 tuples of 2 ints: interpreted as ((top_pad, bottom_pad), (left_pad, right_pad)) 

 
  data_format   A string, one of channels_last (default) or channels_first. The ordering of the dimensions in the inputs. channels_last corresponds to inputs with shape (batch_size, height, width, channels) while channels_first corresponds to inputs with shape (batch_size, channels, height, width). It defaults to the image_data_format value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "channels_last".    Input shape: 4D tensor with shape:  If data_format is "channels_last": (batch_size, rows, cols, channels)
 If data_format is "channels_first": (batch_size, channels, rows, cols)
  Output shape: 4D tensor with shape:  If data_format is "channels_last": (batch_size, padded_rows, padded_cols, channels)
 If data_format is "channels_first": (batch_size, channels, padded_rows, padded_cols)
tf.keras.layers.ZeroPadding3D     View source on GitHub    Zero-padding layer for 3D data (spatial or spatio-temporal). Inherits From: Layer, Module  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.keras.layers.ZeroPadding3D  
tf.keras.layers.ZeroPadding3D(
    padding=(1, 1, 1), data_format=None, **kwargs
)
 Examples: 
input_shape = (1, 1, 2, 2, 3)
x = np.arange(np.prod(input_shape)).reshape(input_shape)
y = tf.keras.layers.ZeroPadding3D(padding=2)(x)
print(y.shape)
(1, 5, 6, 6, 3)

 


 Arguments
  padding   Int, or tuple of 3 ints, or tuple of 3 tuples of 2 ints.  If int: the same symmetric padding is applied to height and width. If tuple of 3 ints: interpreted as two different symmetric padding values for height and width: (symmetric_dim1_pad, symmetric_dim2_pad, symmetric_dim3_pad). If tuple of 3 tuples of 2 ints: interpreted as ((left_dim1_pad, right_dim1_pad), (left_dim2_pad, right_dim2_pad), (left_dim3_pad, right_dim3_pad)) 

 
  data_format   A string, one of channels_last (default) or channels_first. The ordering of the dimensions in the inputs. channels_last corresponds to inputs with shape (batch_size, spatial_dim1, spatial_dim2, spatial_dim3, channels) while channels_first corresponds to inputs with shape (batch_size, channels, spatial_dim1, spatial_dim2, spatial_dim3). It defaults to the image_data_format value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "channels_last".    Input shape: 5D tensor with shape:  If data_format is "channels_last": (batch_size, first_axis_to_pad, second_axis_to_pad, third_axis_to_pad, depth)
 If data_format is "channels_first": (batch_size, depth, first_axis_to_pad, second_axis_to_pad, third_axis_to_pad)
  Output shape: 5D tensor with shape:  If data_format is "channels_last": (batch_size, first_padded_axis, second_padded_axis, third_axis_to_pad, depth)
 If data_format is "channels_first": (batch_size, depth, first_padded_axis, second_padded_axis, third_axis_to_pad)