LostTech.TensorFlow : API Documentation

Type tf.nn

Namespace tensorflow

Methods

Properties

Public static methods

object all_candidate_sampler(IGraphNodeBase true_classes, int num_true, int num_sampled, bool unique, object seed, string name)

Generate the set of all classes.

Deterministically generates and returns the set of all possible classes. For testing purposes. There is no need to use this, since you might as well use full softmax or full logistic regression.
Parameters
IGraphNodeBase true_classes
A `Tensor` of type `int64` and shape `[batch_size, num_true]`. The target classes.
int num_true
An `int`. The number of target classes per training example.
int num_sampled
An `int`. The number of possible classes.
bool unique
A `bool`. Ignored. unique.
object seed
An `int`. An operation-specific seed. Default is 0.
string name
A name for the operation (optional).
Returns
object

object all_candidate_sampler_dyn(object true_classes, object num_true, object num_sampled, object unique, object seed, object name)

Generate the set of all classes.

Deterministically generates and returns the set of all possible classes. For testing purposes. There is no need to use this, since you might as well use full softmax or full logistic regression.
Parameters
object true_classes
A `Tensor` of type `int64` and shape `[batch_size, num_true]`. The target classes.
object num_true
An `int`. The number of target classes per training example.
object num_sampled
An `int`. The number of possible classes.
object unique
A `bool`. Ignored. unique.
object seed
An `int`. An operation-specific seed. Default is 0.
object name
A name for the operation (optional).
Returns
object

Tensor atrous_conv2d(IGraphNodeBase value, IGraphNodeBase filters, int rate, string padding, string name)

Atrous convolution (a.k.a. convolution with holes or dilated convolution).

This function is a simpler wrapper around the more general tf.nn.convolution, and exists only for backwards compatibility. You can use tf.nn.convolution to perform 1-D, 2-D, or 3-D atrous convolution.

Computes a 2-D atrous convolution, also known as convolution with holes or dilated convolution, given 4-D `value` and `filters` tensors. If the `rate` parameter is equal to one, it performs regular 2-D convolution. If the `rate` parameter is greater than one, it performs convolution with holes, sampling the input values every `rate` pixels in the `height` and `width` dimensions. This is equivalent to convolving the input with a set of upsampled filters, produced by inserting `rate - 1` zeros between two consecutive values of the filters along the `height` and `width` dimensions, hence the name atrous convolution or convolution with holes (the French word trous means holes in English).

More specifically:

``` output[batch, height, width, out_channel] = sum_{dheight, dwidth, in_channel} ( filters[dheight, dwidth, in_channel, out_channel] * value[batch, height + rate*dheight, width + rate*dwidth, in_channel] ) ```

Atrous convolution allows us to explicitly control how densely to compute feature responses in fully convolutional networks. Used in conjunction with bilinear interpolation, it offers an alternative to `conv2d_transpose` in dense prediction tasks such as semantic image segmentation, optical flow computation, or depth estimation. It also allows us to effectively enlarge the field of view of filters without increasing the number of parameters or the amount of computation.

For a description of atrous convolution and how it can be used for dense feature extraction, please see: [Semantic Image Segmentation with Deep Convolutional Nets and Fully Connected CRFs](http://arxiv.org/abs/1412.7062). The same operation is investigated further in [Multi-Scale Context Aggregation by Dilated Convolutions](http://arxiv.org/abs/1511.07122). Previous works that effectively use atrous convolution in different ways are, among others, [OverFeat: Integrated Recognition, Localization and Detection using Convolutional Networks](http://arxiv.org/abs/1312.6229) and [Fast Image Scanning with Deep Max-Pooling Convolutional Neural Networks](http://arxiv.org/abs/1302.1700). Atrous convolution is also closely related to the so-called noble identities in multi-rate signal processing.

There are many different ways to implement atrous convolution (see the refs above). The implementation here reduces to the following three operations: Advanced usage. Note the following optimization: A sequence of `atrous_conv2d` operations with identical `rate` parameters, 'SAME' `padding`, and filters with odd heights/ widths: can be equivalently performed cheaper in terms of computation and memory as: because a pair of consecutive `space_to_batch` and `batch_to_space` ops with the same `block_size` cancel out when their respective `paddings` and `crops` inputs are identical.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float`. It needs to be in the default "NHWC" format. Its shape is `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filters
A 4-D `Tensor` with the same type as `value` and shape `[filter_height, filter_width, in_channels, out_channels]`. `filters`' `in_channels` dimension must match that of `value`. Atrous convolution is equivalent to standard convolution with upsampled filters with effective height `filter_height + (filter_height - 1) * (rate - 1)` and effective width `filter_width + (filter_width - 1) * (rate - 1)`, produced by inserting `rate - 1` zeros along consecutive elements across the `filters`' spatial dimensions.
int rate
A positive int32. The stride with which we sample input values across the `height` and `width` dimensions. Equivalently, the rate by which we upsample the filter values by inserting zeros across the `height` and `width` dimensions. In the literature, the same parameter is sometimes called `input stride` or `dilation`.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`. Output shape with `'VALID'` padding is:

[batch, height - 2 * (filter_width - 1), width - 2 * (filter_height - 1), out_channels].

Output shape with `'SAME'` padding is:

[batch, height, width, out_channels].
Show Example
atrous_conv2d(value, filters, rate, padding=padding) 

object atrous_conv2d_dyn(object value, object filters, object rate, object padding, object name)

Atrous convolution (a.k.a. convolution with holes or dilated convolution).

This function is a simpler wrapper around the more general tf.nn.convolution, and exists only for backwards compatibility. You can use tf.nn.convolution to perform 1-D, 2-D, or 3-D atrous convolution.

Computes a 2-D atrous convolution, also known as convolution with holes or dilated convolution, given 4-D `value` and `filters` tensors. If the `rate` parameter is equal to one, it performs regular 2-D convolution. If the `rate` parameter is greater than one, it performs convolution with holes, sampling the input values every `rate` pixels in the `height` and `width` dimensions. This is equivalent to convolving the input with a set of upsampled filters, produced by inserting `rate - 1` zeros between two consecutive values of the filters along the `height` and `width` dimensions, hence the name atrous convolution or convolution with holes (the French word trous means holes in English).

More specifically:

``` output[batch, height, width, out_channel] = sum_{dheight, dwidth, in_channel} ( filters[dheight, dwidth, in_channel, out_channel] * value[batch, height + rate*dheight, width + rate*dwidth, in_channel] ) ```

Atrous convolution allows us to explicitly control how densely to compute feature responses in fully convolutional networks. Used in conjunction with bilinear interpolation, it offers an alternative to `conv2d_transpose` in dense prediction tasks such as semantic image segmentation, optical flow computation, or depth estimation. It also allows us to effectively enlarge the field of view of filters without increasing the number of parameters or the amount of computation.

For a description of atrous convolution and how it can be used for dense feature extraction, please see: [Semantic Image Segmentation with Deep Convolutional Nets and Fully Connected CRFs](http://arxiv.org/abs/1412.7062). The same operation is investigated further in [Multi-Scale Context Aggregation by Dilated Convolutions](http://arxiv.org/abs/1511.07122). Previous works that effectively use atrous convolution in different ways are, among others, [OverFeat: Integrated Recognition, Localization and Detection using Convolutional Networks](http://arxiv.org/abs/1312.6229) and [Fast Image Scanning with Deep Max-Pooling Convolutional Neural Networks](http://arxiv.org/abs/1302.1700). Atrous convolution is also closely related to the so-called noble identities in multi-rate signal processing.

There are many different ways to implement atrous convolution (see the refs above). The implementation here reduces to the following three operations: Advanced usage. Note the following optimization: A sequence of `atrous_conv2d` operations with identical `rate` parameters, 'SAME' `padding`, and filters with odd heights/ widths: can be equivalently performed cheaper in terms of computation and memory as: because a pair of consecutive `space_to_batch` and `batch_to_space` ops with the same `block_size` cancel out when their respective `paddings` and `crops` inputs are identical.
Parameters
object value
A 4-D `Tensor` of type `float`. It needs to be in the default "NHWC" format. Its shape is `[batch, in_height, in_width, in_channels]`.
object filters
A 4-D `Tensor` with the same type as `value` and shape `[filter_height, filter_width, in_channels, out_channels]`. `filters`' `in_channels` dimension must match that of `value`. Atrous convolution is equivalent to standard convolution with upsampled filters with effective height `filter_height + (filter_height - 1) * (rate - 1)` and effective width `filter_width + (filter_width - 1) * (rate - 1)`, produced by inserting `rate - 1` zeros along consecutive elements across the `filters`' spatial dimensions.
object rate
A positive int32. The stride with which we sample input values across the `height` and `width` dimensions. Equivalently, the rate by which we upsample the filter values by inserting zeros across the `height` and `width` dimensions. In the literature, the same parameter is sometimes called `input stride` or `dilation`.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm.
object name
Optional name for the returned tensor.
Returns
object
A `Tensor` with the same type as `value`. Output shape with `'VALID'` padding is:

[batch, height - 2 * (filter_width - 1), width - 2 * (filter_height - 1), out_channels].

Output shape with `'SAME'` padding is:

[batch, height, width, out_channels].
Show Example
atrous_conv2d(value, filters, rate, padding=padding) 

Tensor atrous_conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filters, IEnumerable<int> output_shape, int rate, ValueTuple<IEnumerable<object>, object> padding, string name)

The transpose of `atrous_conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `atrous_conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float`. It needs to be in the default `NHWC` format. Its shape is `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filters
A 4-D `Tensor` with the same type as `value` and shape `[filter_height, filter_width, out_channels, in_channels]`. `filters`' `in_channels` dimension must match that of `value`. Atrous convolution is equivalent to standard convolution with upsampled filters with effective height `filter_height + (filter_height - 1) * (rate - 1)` and effective width `filter_width + (filter_width - 1) * (rate - 1)`, produced by inserting `rate - 1` zeros along consecutive elements across the `filters`' spatial dimensions.
IEnumerable<int> output_shape
A 1-D `Tensor` of shape representing the output shape of the deconvolution op.
int rate
A positive int32. The stride with which we sample input values across the `height` and `width` dimensions. Equivalently, the rate by which we upsample the filter values by inserting zeros across the `height` and `width` dimensions. In the literature, the same parameter is sometimes called `input stride` or `dilation`.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor atrous_conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filters, IEnumerable<int> output_shape, int rate, string padding, string name)

The transpose of `atrous_conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `atrous_conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float`. It needs to be in the default `NHWC` format. Its shape is `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filters
A 4-D `Tensor` with the same type as `value` and shape `[filter_height, filter_width, out_channels, in_channels]`. `filters`' `in_channels` dimension must match that of `value`. Atrous convolution is equivalent to standard convolution with upsampled filters with effective height `filter_height + (filter_height - 1) * (rate - 1)` and effective width `filter_width + (filter_width - 1) * (rate - 1)`, produced by inserting `rate - 1` zeros along consecutive elements across the `filters`' spatial dimensions.
IEnumerable<int> output_shape
A 1-D `Tensor` of shape representing the output shape of the deconvolution op.
int rate
A positive int32. The stride with which we sample input values across the `height` and `width` dimensions. Equivalently, the rate by which we upsample the filter values by inserting zeros across the `height` and `width` dimensions. In the literature, the same parameter is sometimes called `input stride` or `dilation`.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor atrous_conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filters, ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape, int rate, ValueTuple<IEnumerable<object>, object> padding, string name)

The transpose of `atrous_conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `atrous_conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float`. It needs to be in the default `NHWC` format. Its shape is `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filters
A 4-D `Tensor` with the same type as `value` and shape `[filter_height, filter_width, out_channels, in_channels]`. `filters`' `in_channels` dimension must match that of `value`. Atrous convolution is equivalent to standard convolution with upsampled filters with effective height `filter_height + (filter_height - 1) * (rate - 1)` and effective width `filter_width + (filter_width - 1) * (rate - 1)`, produced by inserting `rate - 1` zeros along consecutive elements across the `filters`' spatial dimensions.
ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape
A 1-D `Tensor` of shape representing the output shape of the deconvolution op.
int rate
A positive int32. The stride with which we sample input values across the `height` and `width` dimensions. Equivalently, the rate by which we upsample the filter values by inserting zeros across the `height` and `width` dimensions. In the literature, the same parameter is sometimes called `input stride` or `dilation`.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor atrous_conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filters, IGraphNodeBase output_shape, int rate, ValueTuple<IEnumerable<object>, object> padding, string name)

The transpose of `atrous_conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `atrous_conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float`. It needs to be in the default `NHWC` format. Its shape is `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filters
A 4-D `Tensor` with the same type as `value` and shape `[filter_height, filter_width, out_channels, in_channels]`. `filters`' `in_channels` dimension must match that of `value`. Atrous convolution is equivalent to standard convolution with upsampled filters with effective height `filter_height + (filter_height - 1) * (rate - 1)` and effective width `filter_width + (filter_width - 1) * (rate - 1)`, produced by inserting `rate - 1` zeros along consecutive elements across the `filters`' spatial dimensions.
IGraphNodeBase output_shape
A 1-D `Tensor` of shape representing the output shape of the deconvolution op.
int rate
A positive int32. The stride with which we sample input values across the `height` and `width` dimensions. Equivalently, the rate by which we upsample the filter values by inserting zeros across the `height` and `width` dimensions. In the literature, the same parameter is sometimes called `input stride` or `dilation`.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor atrous_conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filters, ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape, int rate, string padding, string name)

The transpose of `atrous_conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `atrous_conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float`. It needs to be in the default `NHWC` format. Its shape is `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filters
A 4-D `Tensor` with the same type as `value` and shape `[filter_height, filter_width, out_channels, in_channels]`. `filters`' `in_channels` dimension must match that of `value`. Atrous convolution is equivalent to standard convolution with upsampled filters with effective height `filter_height + (filter_height - 1) * (rate - 1)` and effective width `filter_width + (filter_width - 1) * (rate - 1)`, produced by inserting `rate - 1` zeros along consecutive elements across the `filters`' spatial dimensions.
ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape
A 1-D `Tensor` of shape representing the output shape of the deconvolution op.
int rate
A positive int32. The stride with which we sample input values across the `height` and `width` dimensions. Equivalently, the rate by which we upsample the filter values by inserting zeros across the `height` and `width` dimensions. In the literature, the same parameter is sometimes called `input stride` or `dilation`.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor atrous_conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filters, object output_shape, int rate, ValueTuple<IEnumerable<object>, object> padding, string name)

The transpose of `atrous_conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `atrous_conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float`. It needs to be in the default `NHWC` format. Its shape is `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filters
A 4-D `Tensor` with the same type as `value` and shape `[filter_height, filter_width, out_channels, in_channels]`. `filters`' `in_channels` dimension must match that of `value`. Atrous convolution is equivalent to standard convolution with upsampled filters with effective height `filter_height + (filter_height - 1) * (rate - 1)` and effective width `filter_width + (filter_width - 1) * (rate - 1)`, produced by inserting `rate - 1` zeros along consecutive elements across the `filters`' spatial dimensions.
object output_shape
A 1-D `Tensor` of shape representing the output shape of the deconvolution op.
int rate
A positive int32. The stride with which we sample input values across the `height` and `width` dimensions. Equivalently, the rate by which we upsample the filter values by inserting zeros across the `height` and `width` dimensions. In the literature, the same parameter is sometimes called `input stride` or `dilation`.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor atrous_conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filters, object output_shape, int rate, string padding, string name)

The transpose of `atrous_conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `atrous_conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float`. It needs to be in the default `NHWC` format. Its shape is `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filters
A 4-D `Tensor` with the same type as `value` and shape `[filter_height, filter_width, out_channels, in_channels]`. `filters`' `in_channels` dimension must match that of `value`. Atrous convolution is equivalent to standard convolution with upsampled filters with effective height `filter_height + (filter_height - 1) * (rate - 1)` and effective width `filter_width + (filter_width - 1) * (rate - 1)`, produced by inserting `rate - 1` zeros along consecutive elements across the `filters`' spatial dimensions.
object output_shape
A 1-D `Tensor` of shape representing the output shape of the deconvolution op.
int rate
A positive int32. The stride with which we sample input values across the `height` and `width` dimensions. Equivalently, the rate by which we upsample the filter values by inserting zeros across the `height` and `width` dimensions. In the literature, the same parameter is sometimes called `input stride` or `dilation`.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor atrous_conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filters, IGraphNodeBase output_shape, int rate, string padding, string name)

The transpose of `atrous_conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `atrous_conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float`. It needs to be in the default `NHWC` format. Its shape is `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filters
A 4-D `Tensor` with the same type as `value` and shape `[filter_height, filter_width, out_channels, in_channels]`. `filters`' `in_channels` dimension must match that of `value`. Atrous convolution is equivalent to standard convolution with upsampled filters with effective height `filter_height + (filter_height - 1) * (rate - 1)` and effective width `filter_width + (filter_width - 1) * (rate - 1)`, produced by inserting `rate - 1` zeros along consecutive elements across the `filters`' spatial dimensions.
IGraphNodeBase output_shape
A 1-D `Tensor` of shape representing the output shape of the deconvolution op.
int rate
A positive int32. The stride with which we sample input values across the `height` and `width` dimensions. Equivalently, the rate by which we upsample the filter values by inserting zeros across the `height` and `width` dimensions. In the literature, the same parameter is sometimes called `input stride` or `dilation`.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

object atrous_conv2d_transpose_dyn(object value, object filters, object output_shape, object rate, object padding, object name)

The transpose of `atrous_conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `atrous_conv2d` rather than an actual deconvolution.
Parameters
object value
A 4-D `Tensor` of type `float`. It needs to be in the default `NHWC` format. Its shape is `[batch, in_height, in_width, in_channels]`.
object filters
A 4-D `Tensor` with the same type as `value` and shape `[filter_height, filter_width, out_channels, in_channels]`. `filters`' `in_channels` dimension must match that of `value`. Atrous convolution is equivalent to standard convolution with upsampled filters with effective height `filter_height + (filter_height - 1) * (rate - 1)` and effective width `filter_width + (filter_width - 1) * (rate - 1)`, produced by inserting `rate - 1` zeros along consecutive elements across the `filters`' spatial dimensions.
object output_shape
A 1-D `Tensor` of shape representing the output shape of the deconvolution op.
object rate
A positive int32. The stride with which we sample input values across the `height` and `width` dimensions. Equivalently, the rate by which we upsample the filter values by inserting zeros across the `height` and `width` dimensions. In the literature, the same parameter is sometimes called `input stride` or `dilation`.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm.
object name
Optional name for the returned tensor.
Returns
object
A `Tensor` with the same type as `value`.

Tensor avg_pool(IEnumerable<object> value, int ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IEnumerable<object> value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(object value, int ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
object value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(object value, int ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
object value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(object value, ValueTuple<int, object> ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
object value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(ndarray value, IEnumerable<int> ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(object value, ValueTuple<int, object> ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
object value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(IEnumerable<object> value, int ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IEnumerable<object> value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(IGraphNodeBase value, IEnumerable<int> ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(IGraphNodeBase value, int ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(IGraphNodeBase value, ValueTuple<int, object> ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(IGraphNodeBase value, ValueTuple<int, object> ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(IGraphNodeBase value, int ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(PythonClassContainer value, IEnumerable<int> ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
PythonClassContainer value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(PythonClassContainer value, IEnumerable<int> ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
PythonClassContainer value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(PythonClassContainer value, ValueTuple<int, object> ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
PythonClassContainer value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(PythonClassContainer value, ValueTuple<int, object> ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
PythonClassContainer value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(PythonClassContainer value, int ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
PythonClassContainer value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(PythonClassContainer value, int ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
PythonClassContainer value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(IGraphNodeBase value, IEnumerable<int> ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(IEnumerable<object> value, ValueTuple<int, object> ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IEnumerable<object> value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(object value, IEnumerable<int> ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
object value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(object value, IEnumerable<int> ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
object value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(IEnumerable<object> value, IEnumerable<int> ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IEnumerable<object> value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(IEnumerable<object> value, IEnumerable<int> ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IEnumerable<object> value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(ndarray value, int ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(IEnumerable<object> value, ValueTuple<int, object> ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IEnumerable<object> value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(ndarray value, ValueTuple<int, object> ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(ndarray value, ValueTuple<int, object> ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(ndarray value, IEnumerable<int> ksize, object strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool(ndarray value, int ksize, PythonClassContainer strides, object padding, string data_format, string name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
PythonClassContainer strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the operation.
object input
Alias for value.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

object avg_pool_dyn(object value, object ksize, object strides, object padding, ImplicitContainer<T> data_format, object name, object input)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
object value
A 4-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
object ksize
An int or list of `ints` that has length `1`, `2` or `4`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
ImplicitContainer<T> data_format
A string. 'NHWC' and 'NCHW' are supported.
object name
Optional name for the operation.
object input
Alias for value.
Returns
object
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool_v2(ndarray input, int ksize, int strides, string padding, object data_format, string name)

Performs the avg pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray input
Tensor of rank N+2, of shape `[batch_size] + input_spatial_shape + [num_channels]` if `data_format` does not start with "NC" (default), or `[batch_size, num_channels] + input_spatial_shape` if data_format starts with "NC". Pooling happens over the spatial dimensions only.
int ksize
An int or list of `ints` that has length `1`, `N` or `N+2`. The size of the window for each dimension of the input tensor.
int strides
An int or list of `ints` that has length `1`, `N` or `N+2`. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
object data_format
A string. Specifies the channel dimension. For N=1 it can be either "NWC" (default) or "NCW", for N=2 it can be either "NHWC" (default) or "NCHW" and for N=3 either "NDHWC" (default) or "NCDHW".
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` of format specified by `data_format`. The average pooled output tensor.

Tensor avg_pool_v2(IGraphNodeBase input, int ksize, int strides, string padding, object data_format, string name)

Performs the avg pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase input
Tensor of rank N+2, of shape `[batch_size] + input_spatial_shape + [num_channels]` if `data_format` does not start with "NC" (default), or `[batch_size, num_channels] + input_spatial_shape` if data_format starts with "NC". Pooling happens over the spatial dimensions only.
int ksize
An int or list of `ints` that has length `1`, `N` or `N+2`. The size of the window for each dimension of the input tensor.
int strides
An int or list of `ints` that has length `1`, `N` or `N+2`. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
object data_format
A string. Specifies the channel dimension. For N=1 it can be either "NWC" (default) or "NCW", for N=2 it can be either "NHWC" (default) or "NCHW" and for N=3 either "NDHWC" (default) or "NCDHW".
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` of format specified by `data_format`. The average pooled output tensor.

object avg_pool_v2_dyn(object input, object ksize, object strides, object padding, object data_format, object name)

Performs the avg pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
object input
Tensor of rank N+2, of shape `[batch_size] + input_spatial_shape + [num_channels]` if `data_format` does not start with "NC" (default), or `[batch_size, num_channels] + input_spatial_shape` if data_format starts with "NC". Pooling happens over the spatial dimensions only.
object ksize
An int or list of `ints` that has length `1`, `N` or `N+2`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1`, `N` or `N+2`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
object data_format
A string. Specifies the channel dimension. For N=1 it can be either "NWC" (default) or "NCW", for N=2 it can be either "NHWC" (default) or "NCHW" and for N=3 either "NDHWC" (default) or "NCDHW".
object name
Optional name for the operation.
Returns
object
A `Tensor` of format specified by `data_format`. The average pooled output tensor.

Tensor avg_pool1d(IGraphNodeBase input, int ksize, int strides, string padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.

Note internally this op reshapes and uses the underlying 2d operation.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of the format specified by `data_format`.
int ksize
An int or list of `ints` that has length `1` or `3`. The size of the window for each dimension of the input tensor.
int strides
An int or list of `ints` that has length `1` or `3`. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
An optional string from: "NWC", "NCW". Defaults to "NWC".
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor` of format specified by `data_format`. The max pooled output tensor.

Tensor avg_pool1d(ndarray input, int ksize, int strides, string padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.

Note internally this op reshapes and uses the underlying 2d operation.
Parameters
ndarray input
A 3-D `Tensor` of the format specified by `data_format`.
int ksize
An int or list of `ints` that has length `1` or `3`. The size of the window for each dimension of the input tensor.
int strides
An int or list of `ints` that has length `1` or `3`. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
An optional string from: "NWC", "NCW". Defaults to "NWC".
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor` of format specified by `data_format`. The max pooled output tensor.

object avg_pool1d_dyn(object input, object ksize, object strides, object padding, ImplicitContainer<T> data_format, object name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.

Note internally this op reshapes and uses the underlying 2d operation.
Parameters
object input
A 3-D `Tensor` of the format specified by `data_format`.
object ksize
An int or list of `ints` that has length `1` or `3`. The size of the window for each dimension of the input tensor.
object strides
An int or list of `ints` that has length `1` or `3`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
ImplicitContainer<T> data_format
An optional string from: "NWC", "NCW". Defaults to "NWC".
object name
A name for the operation (optional).
Returns
object
A `Tensor` of format specified by `data_format`. The max pooled output tensor.

Tensor avg_pool3d(ndarray input, int ksize, IEnumerable<int> strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(IGraphNodeBase input, int ksize, ValueTuple<int, object, object> strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
ValueTuple<int, object, object> strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(IGraphNodeBase input, int ksize, IEnumerable<int> strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(IGraphNodeBase input, int ksize, int strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
int strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(IGraphNodeBase input, ValueTuple<int, object, object> ksize, int strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object, object> ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
int strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(IGraphNodeBase input, ValueTuple<int, object, object> ksize, ValueTuple<int, object, object> strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object, object> ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
ValueTuple<int, object, object> strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(IGraphNodeBase input, IEnumerable<int> ksize, int strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
int strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(IGraphNodeBase input, IEnumerable<int> ksize, ValueTuple<int, object, object> strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
ValueTuple<int, object, object> strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(IGraphNodeBase input, IEnumerable<int> ksize, IEnumerable<int> strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(ndarray input, int ksize, int strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
int strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(ndarray input, IEnumerable<int> ksize, IEnumerable<int> strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(ndarray input, IEnumerable<int> ksize, ValueTuple<int, object, object> strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
ValueTuple<int, object, object> strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(ndarray input, IEnumerable<int> ksize, int strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
IEnumerable<int> ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
int strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(ndarray input, ValueTuple<int, object, object> ksize, IEnumerable<int> strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object, object> ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(ndarray input, int ksize, ValueTuple<int, object, object> strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
int ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
ValueTuple<int, object, object> strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(ndarray input, ValueTuple<int, object, object> ksize, ValueTuple<int, object, object> strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object, object> ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
ValueTuple<int, object, object> strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(IGraphNodeBase input, ValueTuple<int, object, object> ksize, IEnumerable<int> strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
IGraphNodeBase input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object, object> ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

Tensor avg_pool3d(ndarray input, ValueTuple<int, object, object> ksize, int strides, object padding, string data_format, string name)

Performs the average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.
Parameters
ndarray input
A 5-D `Tensor` of shape `[batch, height, width, channels]` and type `float32`, `float64`, `qint8`, `quint8`, or `qint32`.
ValueTuple<int, object, object> ksize
An int or list of `ints` that has length `1`, `3` or `5`. The size of the window for each dimension of the input tensor.
int strides
An int or list of `ints` that has length `1`, `3` or `5`. The stride of the sliding window for each dimension of the input tensor.
object padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NDHWC' and 'NCDHW' are supported.
string name
Optional name for the operation.
Returns
Tensor
A `Tensor` with the same type as `value`. The average pooled output tensor.

object batch_norm_with_global_normalization(object t, object m, object v, object beta, object gamma, Nullable<double> variance_epsilon, Nullable<bool> scale_after_normalization, string name, object input, object mean, object variance)

Batch normalization.

This op is deprecated. See tf.nn.batch_normalization.
Parameters
object t
A 4D input Tensor.
object m
A 1D mean Tensor with size matching the last dimension of t. This is the first output from tf.nn.moments, or a saved moving average thereof.
object v
A 1D variance Tensor with size matching the last dimension of t. This is the second output from tf.nn.moments, or a saved moving average thereof.
object beta
A 1D beta Tensor with size matching the last dimension of t. An offset to be added to the normalized tensor.
object gamma
A 1D gamma Tensor with size matching the last dimension of t. If "scale_after_normalization" is true, this tensor will be multiplied with the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
Nullable<bool> scale_after_normalization
A bool indicating whether the resulted tensor needs to be multiplied with gamma.
string name
A name for this operation (optional).
object input
Alias for t.
object mean
Alias for m.
object variance
Alias for v.
Returns
object
A batch-normalized `t`.

object batch_norm_with_global_normalization_dyn(object t, object m, object v, object beta, object gamma, object variance_epsilon, object scale_after_normalization, object name, object input, object mean, object variance)

Batch normalization.

This op is deprecated. See tf.nn.batch_normalization.
Parameters
object t
A 4D input Tensor.
object m
A 1D mean Tensor with size matching the last dimension of t. This is the first output from tf.nn.moments, or a saved moving average thereof.
object v
A 1D variance Tensor with size matching the last dimension of t. This is the second output from tf.nn.moments, or a saved moving average thereof.
object beta
A 1D beta Tensor with size matching the last dimension of t. An offset to be added to the normalized tensor.
object gamma
A 1D gamma Tensor with size matching the last dimension of t. If "scale_after_normalization" is true, this tensor will be multiplied with the normalized tensor.
object variance_epsilon
A small float number to avoid dividing by 0.
object scale_after_normalization
A bool indicating whether the resulted tensor needs to be multiplied with gamma.
object name
A name for this operation (optional).
object input
Alias for t.
object mean
Alias for m.
object variance
Alias for v.
Returns
object
A batch-normalized `t`.

object batch_normalization(IEnumerable<IGraphNodeBase> x, object mean, object variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
IEnumerable<IGraphNodeBase> x
Input `Tensor` of arbitrary dimensionality.
object mean
A mean `Tensor`.
object variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(ValueTuple<PythonClassContainer, PythonClassContainer> x, object mean, IEnumerable<object> variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
ValueTuple<PythonClassContainer, PythonClassContainer> x
Input `Tensor` of arbitrary dimensionality.
object mean
A mean `Tensor`.
IEnumerable<object> variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(IndexedSlices x, IEnumerable<object> mean, IEnumerable<object> variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
IndexedSlices x
Input `Tensor` of arbitrary dimensionality.
IEnumerable<object> mean
A mean `Tensor`.
IEnumerable<object> variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(IndexedSlices x, IEnumerable<object> mean, object variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
IndexedSlices x
Input `Tensor` of arbitrary dimensionality.
IEnumerable<object> mean
A mean `Tensor`.
object variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(IndexedSlices x, object mean, IEnumerable<object> variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
IndexedSlices x
Input `Tensor` of arbitrary dimensionality.
object mean
A mean `Tensor`.
IEnumerable<object> variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(IndexedSlices x, object mean, object variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
IndexedSlices x
Input `Tensor` of arbitrary dimensionality.
object mean
A mean `Tensor`.
object variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(IGraphNodeBase x, IEnumerable<object> mean, IEnumerable<object> variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
IGraphNodeBase x
Input `Tensor` of arbitrary dimensionality.
IEnumerable<object> mean
A mean `Tensor`.
IEnumerable<object> variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(IGraphNodeBase x, IEnumerable<object> mean, object variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
IGraphNodeBase x
Input `Tensor` of arbitrary dimensionality.
IEnumerable<object> mean
A mean `Tensor`.
object variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(IGraphNodeBase x, object mean, IEnumerable<object> variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
IGraphNodeBase x
Input `Tensor` of arbitrary dimensionality.
object mean
A mean `Tensor`.
IEnumerable<object> variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(IGraphNodeBase x, object mean, object variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
IGraphNodeBase x
Input `Tensor` of arbitrary dimensionality.
object mean
A mean `Tensor`.
object variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(IEnumerable<IGraphNodeBase> x, IEnumerable<object> mean, IEnumerable<object> variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
IEnumerable<IGraphNodeBase> x
Input `Tensor` of arbitrary dimensionality.
IEnumerable<object> mean
A mean `Tensor`.
IEnumerable<object> variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(IEnumerable<IGraphNodeBase> x, IEnumerable<object> mean, object variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
IEnumerable<IGraphNodeBase> x
Input `Tensor` of arbitrary dimensionality.
IEnumerable<object> mean
A mean `Tensor`.
object variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(IEnumerable<IGraphNodeBase> x, object mean, IEnumerable<object> variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
IEnumerable<IGraphNodeBase> x
Input `Tensor` of arbitrary dimensionality.
object mean
A mean `Tensor`.
IEnumerable<object> variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(ValueTuple<PythonClassContainer, PythonClassContainer> x, object mean, object variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
ValueTuple<PythonClassContainer, PythonClassContainer> x
Input `Tensor` of arbitrary dimensionality.
object mean
A mean `Tensor`.
object variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(ValueTuple<PythonClassContainer, PythonClassContainer> x, IEnumerable<object> mean, IEnumerable<object> variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
ValueTuple<PythonClassContainer, PythonClassContainer> x
Input `Tensor` of arbitrary dimensionality.
IEnumerable<object> mean
A mean `Tensor`.
IEnumerable<object> variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization(ValueTuple<PythonClassContainer, PythonClassContainer> x, IEnumerable<object> mean, object variance, object offset, object scale, Nullable<double> variance_epsilon, string name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
ValueTuple<PythonClassContainer, PythonClassContainer> x
Input `Tensor` of arbitrary dimensionality.
IEnumerable<object> mean
A mean `Tensor`.
object variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
Nullable<double> variance_epsilon
A small float number to avoid dividing by 0.
string name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

object batch_normalization_dyn(object x, object mean, object variance, object offset, object scale, object variance_epsilon, object name)

Batch normalization.

Normalizes a tensor by `mean` and `variance`, and applies (optionally) a `scale` \\(\gamma\\) to it, as well as an `offset` \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

`mean`, `variance`, `offset` and `scale` are all expected to be of one of two shapes:

* In all generality, they can have the same number of dimensions as the input `x`, with identical sizes as `x` for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=True)` during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor `x`, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common `[batch, depth]` layout of fully-connected layers, and `[batch, height, width, depth]` for convolutions. `mean` and `variance` in this case would typically be the outputs of `tf.nn.moments(..., keep_dims=False)` during training, or running averages thereof during inference.

See Source: [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift; S. Ioffe, C. Szegedy] (http://arxiv.org/abs/1502.03167).
Parameters
object x
Input `Tensor` of arbitrary dimensionality.
object mean
A mean `Tensor`.
object variance
A variance `Tensor`.
object offset
An offset `Tensor`, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor.
object scale
A scale `Tensor`, often denoted \\(\gamma\\) in equations, or `None`. If present, the scale is applied to the normalized tensor.
object variance_epsilon
A small float number to avoid dividing by 0.
object name
A name for this operation (optional).
Returns
object
the normalized, scaled, offset tensor.

Tensor bias_add(IEnumerable<int> value, IGraphNodeBase bias, string data_format, string name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IEnumerable<int> value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
IGraphNodeBase bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IGraphNodeBase value, IndexedSlices bias, string data_format, PythonFunctionContainer name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IGraphNodeBase value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
IndexedSlices bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
PythonFunctionContainer name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IGraphNodeBase value, IndexedSlices bias, string data_format, string name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IGraphNodeBase value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
IndexedSlices bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IGraphNodeBase value, ValueTuple<PythonClassContainer, PythonClassContainer> bias, string data_format, string name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IGraphNodeBase value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
ValueTuple<PythonClassContainer, PythonClassContainer> bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IGraphNodeBase value, ValueTuple<PythonClassContainer, PythonClassContainer> bias, string data_format, PythonFunctionContainer name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IGraphNodeBase value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
ValueTuple<PythonClassContainer, PythonClassContainer> bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
PythonFunctionContainer name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IGraphNodeBase value, IEnumerable<int> bias, string data_format, string name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IGraphNodeBase value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
IEnumerable<int> bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IGraphNodeBase value, IEnumerable<int> bias, string data_format, PythonFunctionContainer name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IGraphNodeBase value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
IEnumerable<int> bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
PythonFunctionContainer name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IEnumerable<int> value, IEnumerable<int> bias, string data_format, string name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IEnumerable<int> value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
IEnumerable<int> bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IEnumerable<int> value, IEnumerable<int> bias, string data_format, PythonFunctionContainer name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IEnumerable<int> value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
IEnumerable<int> bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
PythonFunctionContainer name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IEnumerable<int> value, ValueTuple<PythonClassContainer, PythonClassContainer> bias, string data_format, PythonFunctionContainer name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IEnumerable<int> value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
ValueTuple<PythonClassContainer, PythonClassContainer> bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
PythonFunctionContainer name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IEnumerable<int> value, ValueTuple<PythonClassContainer, PythonClassContainer> bias, string data_format, string name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IEnumerable<int> value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
ValueTuple<PythonClassContainer, PythonClassContainer> bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IEnumerable<int> value, IndexedSlices bias, string data_format, PythonFunctionContainer name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IEnumerable<int> value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
IndexedSlices bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
PythonFunctionContainer name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IEnumerable<int> value, IndexedSlices bias, string data_format, string name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IEnumerable<int> value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
IndexedSlices bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor bias_add(IEnumerable<int> value, IGraphNodeBase bias, string data_format, PythonFunctionContainer name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
IEnumerable<int> value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
IGraphNodeBase bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
string data_format
A string. 'N...C' and 'NC...' are supported.
PythonFunctionContainer name
A name for the operation (optional).
Returns
Tensor
A `Tensor` with the same type as `value`.

object bias_add_dyn(object value, object bias, object data_format, object name)

Adds `bias` to `value`.

This is (mostly) a special case of tf.add where `bias` is restricted to 1-D. Broadcasting is supported, so `value` may have any number of dimensions. Unlike tf.add, the type of `bias` is allowed to differ from `value` in the case where both types are quantized.
Parameters
object value
A `Tensor` with type `float`, `double`, `int64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, or `complex128`.
object bias
A 1-D `Tensor` with size matching the channel dimension of `value`. Must be the same type as `value` unless `value` is a quantized type, in which case a different quantized type may be used.
object data_format
A string. 'N...C' and 'NC...' are supported.
object name
A name for the operation (optional).
Returns
object
A `Tensor` with the same type as `value`.

ValueTuple<object, object> bidirectional_dynamic_rnn(LSTMCell cell_fw, LSTMCell cell_bw, IGraphNodeBase inputs, IGraphNodeBase sequence_length, IGraphNodeBase initial_state_fw, IGraphNodeBase initial_state_bw, DType dtype, object parallel_iterations, bool swap_memory, Nullable<bool> time_major, object scope)

Creates a dynamic version of bidirectional recurrent neural network. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Please use `keras.layers.Bidirectional(keras.layers.RNN(cell))`, which is equivalent to this API

Takes input and builds independent forward and backward RNNs. The input_size of forward and backward cell must match. The initial state for both directions is zero by default (but can be set optionally) and no intermediate states are ever returned -- the network is fully unrolled for the given (passed in) length(s) of the sequence(s) or completely unrolled if length(s) is not given.
Parameters
LSTMCell cell_fw
An instance of RNNCell, to be used for forward direction.
LSTMCell cell_bw
An instance of RNNCell, to be used for backward direction.
IGraphNodeBase inputs
The RNN inputs. If time_major == False (default), this must be a tensor of shape: `[batch_size, max_time,...]`, or a nested tuple of such elements. If time_major == True, this must be a tensor of shape: `[max_time, batch_size,...]`, or a nested tuple of such elements.
IGraphNodeBase sequence_length
(optional) An int32/int64 vector, size `[batch_size]`, containing the actual lengths for each of the sequences in the batch. If not provided, all batch entries are assumed to be full sequences; and time reversal is applied from time `0` to `max_time` for each sequence.
IGraphNodeBase initial_state_fw
(optional) An initial state for the forward RNN. This must be a tensor of appropriate type and shape `[batch_size, cell_fw.state_size]`. If `cell_fw.state_size` is a tuple, this should be a tuple of tensors having shapes `[batch_size, s] for s in cell_fw.state_size`.
IGraphNodeBase initial_state_bw
(optional) Same as for `initial_state_fw`, but using the corresponding properties of `cell_bw`.
DType dtype
(optional) The data type for the initial states and expected output. Required if initial_states are not provided or RNN states have a heterogeneous dtype.
object parallel_iterations
(Default: 32). The number of iterations to run in parallel. Those operations which do not have any temporal dependency and can be run in parallel, will be. This parameter trades off time for space. Values >> 1 use more memory but take less time, while smaller values use less memory but computations take longer.
bool swap_memory
Transparently swap the tensors produced in forward inference but needed for back prop from GPU to CPU. This allows training RNNs which would typically not fit on a single GPU, with very minimal (or no) performance penalty.
Nullable<bool> time_major
The shape format of the `inputs` and `outputs` Tensors. If true, these `Tensors` must be shaped `[max_time, batch_size, depth]`. If false, these `Tensors` must be shaped `[batch_size, max_time, depth]`. Using `time_major = True` is a bit more efficient because it avoids transposes at the beginning and end of the RNN calculation. However, most TensorFlow data is batch-major, so by default this function accepts input and emits output in batch-major form.
object scope
VariableScope for the created subgraph; defaults to "bidirectional_rnn"
Returns
ValueTuple<object, object>
A tuple (outputs, output_states) where:

ValueTuple<Tensor, object> collapse_repeated(IGraphNodeBase labels, IEnumerable<int> seq_length, string name)

Merge repeated labels into single labels.
Parameters
IGraphNodeBase labels
Tensor of shape [batch, max value in seq_length]
IEnumerable<int> seq_length
Tensor of shape [batch], sequence length of each batch element.
string name
A name for this `Op`. Defaults to "collapse_repeated_labels".
Returns
ValueTuple<Tensor, object>
A tuple `(collapsed_labels, new_seq_length)` where

ValueTuple<Tensor, object> collapse_repeated(IEnumerable<object> labels, IEnumerable<int> seq_length, string name)

Merge repeated labels into single labels.
Parameters
IEnumerable<object> labels
Tensor of shape [batch, max value in seq_length]
IEnumerable<int> seq_length
Tensor of shape [batch], sequence length of each batch element.
string name
A name for this `Op`. Defaults to "collapse_repeated_labels".
Returns
ValueTuple<Tensor, object>
A tuple `(collapsed_labels, new_seq_length)` where

ValueTuple<Tensor, object> collapse_repeated(IGraphNodeBase labels, IGraphNodeBase seq_length, string name)

Merge repeated labels into single labels.
Parameters
IGraphNodeBase labels
Tensor of shape [batch, max value in seq_length]
IGraphNodeBase seq_length
Tensor of shape [batch], sequence length of each batch element.
string name
A name for this `Op`. Defaults to "collapse_repeated_labels".
Returns
ValueTuple<Tensor, object>
A tuple `(collapsed_labels, new_seq_length)` where

ValueTuple<Tensor, object> collapse_repeated(IEnumerable<object> labels, IGraphNodeBase seq_length, string name)

Merge repeated labels into single labels.
Parameters
IEnumerable<object> labels
Tensor of shape [batch, max value in seq_length]
IGraphNodeBase seq_length
Tensor of shape [batch], sequence length of each batch element.
string name
A name for this `Op`. Defaults to "collapse_repeated_labels".
Returns
ValueTuple<Tensor, object>
A tuple `(collapsed_labels, new_seq_length)` where

object collapse_repeated_dyn(object labels, object seq_length, object name)

Merge repeated labels into single labels.
Parameters
object labels
Tensor of shape [batch, max value in seq_length]
object seq_length
Tensor of shape [batch], sequence length of each batch element.
object name
A name for this `Op`. Defaults to "collapse_repeated_labels".
Returns
object
A tuple `(collapsed_labels, new_seq_length)` where

object compute_accidental_hits(IGraphNodeBase true_classes, IndexedSlices sampled_candidates, int num_true, object seed, string name)

Compute the position ids in `sampled_candidates` matching `true_classes`.

In Candidate Sampling, this operation facilitates virtually removing sampled classes which happen to match target classes. This is done in Sampled Softmax and Sampled Logistic.

See our [Candidate Sampling Algorithms Reference](http://www.tensorflow.org/extras/candidate_sampling.pdf).

We presuppose that the `sampled_candidates` are unique.

We call it an 'accidental hit' when one of the target classes matches one of the sampled classes. This operation reports accidental hits as triples `(index, id, weight)`, where `index` represents the row number in `true_classes`, `id` represents the position in `sampled_candidates`, and weight is `-FLOAT_MAX`.

The result of this op should be passed through a `sparse_to_dense` operation, then added to the logits of the sampled classes. This removes the contradictory effect of accidentally sampling the true target classes as noise classes for the same example.
Parameters
IGraphNodeBase true_classes
A `Tensor` of type `int64` and shape `[batch_size, num_true]`. The target classes.
IndexedSlices sampled_candidates
A tensor of type `int64` and shape `[num_sampled]`. The sampled_candidates output of CandidateSampler.
int num_true
An `int`. The number of target classes per training example.
object seed
An `int`. An operation-specific seed. Default is 0.
string name
A name for the operation (optional).
Returns
object

object compute_accidental_hits(IGraphNodeBase true_classes, IGraphNodeBase sampled_candidates, int num_true, object seed, string name)

Compute the position ids in `sampled_candidates` matching `true_classes`.

In Candidate Sampling, this operation facilitates virtually removing sampled classes which happen to match target classes. This is done in Sampled Softmax and Sampled Logistic.

See our [Candidate Sampling Algorithms Reference](http://www.tensorflow.org/extras/candidate_sampling.pdf).

We presuppose that the `sampled_candidates` are unique.

We call it an 'accidental hit' when one of the target classes matches one of the sampled classes. This operation reports accidental hits as triples `(index, id, weight)`, where `index` represents the row number in `true_classes`, `id` represents the position in `sampled_candidates`, and weight is `-FLOAT_MAX`.

The result of this op should be passed through a `sparse_to_dense` operation, then added to the logits of the sampled classes. This removes the contradictory effect of accidentally sampling the true target classes as noise classes for the same example.
Parameters
IGraphNodeBase true_classes
A `Tensor` of type `int64` and shape `[batch_size, num_true]`. The target classes.
IGraphNodeBase sampled_candidates
A tensor of type `int64` and shape `[num_sampled]`. The sampled_candidates output of CandidateSampler.
int num_true
An `int`. The number of target classes per training example.
object seed
An `int`. An operation-specific seed. Default is 0.
string name
A name for the operation (optional).
Returns
object

object compute_accidental_hits(IGraphNodeBase true_classes, ValueTuple<PythonClassContainer, PythonClassContainer> sampled_candidates, int num_true, object seed, string name)

Compute the position ids in `sampled_candidates` matching `true_classes`.

In Candidate Sampling, this operation facilitates virtually removing sampled classes which happen to match target classes. This is done in Sampled Softmax and Sampled Logistic.

See our [Candidate Sampling Algorithms Reference](http://www.tensorflow.org/extras/candidate_sampling.pdf).

We presuppose that the `sampled_candidates` are unique.

We call it an 'accidental hit' when one of the target classes matches one of the sampled classes. This operation reports accidental hits as triples `(index, id, weight)`, where `index` represents the row number in `true_classes`, `id` represents the position in `sampled_candidates`, and weight is `-FLOAT_MAX`.

The result of this op should be passed through a `sparse_to_dense` operation, then added to the logits of the sampled classes. This removes the contradictory effect of accidentally sampling the true target classes as noise classes for the same example.
Parameters
IGraphNodeBase true_classes
A `Tensor` of type `int64` and shape `[batch_size, num_true]`. The target classes.
ValueTuple<PythonClassContainer, PythonClassContainer> sampled_candidates
A tensor of type `int64` and shape `[num_sampled]`. The sampled_candidates output of CandidateSampler.
int num_true
An `int`. The number of target classes per training example.
object seed
An `int`. An operation-specific seed. Default is 0.
string name
A name for the operation (optional).
Returns
object

object compute_accidental_hits_dyn(object true_classes, object sampled_candidates, object num_true, object seed, object name)

Compute the position ids in `sampled_candidates` matching `true_classes`.

In Candidate Sampling, this operation facilitates virtually removing sampled classes which happen to match target classes. This is done in Sampled Softmax and Sampled Logistic.

See our [Candidate Sampling Algorithms Reference](http://www.tensorflow.org/extras/candidate_sampling.pdf).

We presuppose that the `sampled_candidates` are unique.

We call it an 'accidental hit' when one of the target classes matches one of the sampled classes. This operation reports accidental hits as triples `(index, id, weight)`, where `index` represents the row number in `true_classes`, `id` represents the position in `sampled_candidates`, and weight is `-FLOAT_MAX`.

The result of this op should be passed through a `sparse_to_dense` operation, then added to the logits of the sampled classes. This removes the contradictory effect of accidentally sampling the true target classes as noise classes for the same example.
Parameters
object true_classes
A `Tensor` of type `int64` and shape `[batch_size, num_true]`. The target classes.
object sampled_candidates
A tensor of type `int64` and shape `[num_sampled]`. The sampled_candidates output of CandidateSampler.
object num_true
An `int`. The number of target classes per training example.
object seed
An `int`. An operation-specific seed. Default is 0.
object name
A name for the operation (optional).
Returns
object

object compute_average_loss(IGraphNodeBase per_example_loss, IEnumerable<double> sample_weight, Nullable<int> global_batch_size)

Scales per-example losses with sample_weights and computes their average.

Usage with distribution strategy and custom training loop:
Parameters
IGraphNodeBase per_example_loss
Per-example loss.
IEnumerable<double> sample_weight
Optional weighting for each example.
Nullable<int> global_batch_size
Optional global batch size value. Defaults to (size of first dimension of `losses`) * (number of replicas).
Returns
object
Scalar loss value.
Show Example
with strategy.scope():
              def compute_loss(labels, predictions, sample_weight=None): 

# If you are using a `Loss` class instead, set reduction to `NONE` so that # we can do the reduction afterwards and divide by global batch size. per_example_loss = tf.keras.losses.sparse_categorical_crossentropy( labels, predictions)

# Compute loss that is scaled by sample_weight and by global batch size. return tf.compute_average_loss( per_example_loss, sample_weight=sample_weight, global_batch_size=GLOBAL_BATCH_SIZE)

object compute_average_loss(IEnumerable<int> per_example_loss, IEnumerable<double> sample_weight, Nullable<int> global_batch_size)

Scales per-example losses with sample_weights and computes their average.

Usage with distribution strategy and custom training loop:
Parameters
IEnumerable<int> per_example_loss
Per-example loss.
IEnumerable<double> sample_weight
Optional weighting for each example.
Nullable<int> global_batch_size
Optional global batch size value. Defaults to (size of first dimension of `losses`) * (number of replicas).
Returns
object
Scalar loss value.
Show Example
with strategy.scope():
              def compute_loss(labels, predictions, sample_weight=None): 

# If you are using a `Loss` class instead, set reduction to `NONE` so that # we can do the reduction afterwards and divide by global batch size. per_example_loss = tf.keras.losses.sparse_categorical_crossentropy( labels, predictions)

# Compute loss that is scaled by sample_weight and by global batch size. return tf.compute_average_loss( per_example_loss, sample_weight=sample_weight, global_batch_size=GLOBAL_BATCH_SIZE)

object compute_average_loss_dyn(object per_example_loss, object sample_weight, object global_batch_size)

Scales per-example losses with sample_weights and computes their average.

Usage with distribution strategy and custom training loop:
Parameters
object per_example_loss
Per-example loss.
object sample_weight
Optional weighting for each example.
object global_batch_size
Optional global batch size value. Defaults to (size of first dimension of `losses`) * (number of replicas).
Returns
object
Scalar loss value.
Show Example
with strategy.scope():
              def compute_loss(labels, predictions, sample_weight=None): 

# If you are using a `Loss` class instead, set reduction to `NONE` so that # we can do the reduction afterwards and divide by global batch size. per_example_loss = tf.keras.losses.sparse_categorical_crossentropy( labels, predictions)

# Compute loss that is scaled by sample_weight and by global batch size. return tf.compute_average_loss( per_example_loss, sample_weight=sample_weight, global_batch_size=GLOBAL_BATCH_SIZE)

Tensor conv_transpose(IGraphNodeBase input, IGraphNodeBase filters, IGraphNodeBase output_shape, string strides, string padding, object data_format, object dilations, string name)

The transpose of `convolution`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf), but is actually the transpose (gradient) of `convolution` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
An N+2 dimensional `Tensor` of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC". It must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
IGraphNodeBase filters
An N+2 dimensional `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
string strides
An int or list of `ints` that has length `1`, `N` or `N+2`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
object data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object dilations
An int or list of `ints` that has length `1`, `N` or `N+2`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details.
string name
A name for the operation (optional). If not specified "conv_transpose" is used.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv_transpose(IGraphNodeBase input, int filters, IEnumerable<int> output_shape, int strides, string padding, object data_format, object dilations, string name)

The transpose of `convolution`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf), but is actually the transpose (gradient) of `convolution` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
An N+2 dimensional `Tensor` of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC". It must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
int filters
An N+2 dimensional `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
int strides
An int or list of `ints` that has length `1`, `N` or `N+2`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
object data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object dilations
An int or list of `ints` that has length `1`, `N` or `N+2`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details.
string name
A name for the operation (optional). If not specified "conv_transpose" is used.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv_transpose(IGraphNodeBase input, int filters, IEnumerable<int> output_shape, string strides, string padding, object data_format, object dilations, string name)

The transpose of `convolution`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf), but is actually the transpose (gradient) of `convolution` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
An N+2 dimensional `Tensor` of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC". It must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
int filters
An N+2 dimensional `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
string strides
An int or list of `ints` that has length `1`, `N` or `N+2`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
object data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object dilations
An int or list of `ints` that has length `1`, `N` or `N+2`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details.
string name
A name for the operation (optional). If not specified "conv_transpose" is used.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv_transpose(IGraphNodeBase input, int filters, IGraphNodeBase output_shape, int strides, string padding, object data_format, object dilations, string name)

The transpose of `convolution`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf), but is actually the transpose (gradient) of `convolution` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
An N+2 dimensional `Tensor` of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC". It must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
int filters
An N+2 dimensional `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
int strides
An int or list of `ints` that has length `1`, `N` or `N+2`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
object data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object dilations
An int or list of `ints` that has length `1`, `N` or `N+2`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details.
string name
A name for the operation (optional). If not specified "conv_transpose" is used.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv_transpose(IGraphNodeBase input, IGraphNodeBase filters, IGraphNodeBase output_shape, int strides, string padding, object data_format, object dilations, string name)

The transpose of `convolution`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf), but is actually the transpose (gradient) of `convolution` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
An N+2 dimensional `Tensor` of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC". It must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
IGraphNodeBase filters
An N+2 dimensional `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
int strides
An int or list of `ints` that has length `1`, `N` or `N+2`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
object data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object dilations
An int or list of `ints` that has length `1`, `N` or `N+2`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details.
string name
A name for the operation (optional). If not specified "conv_transpose" is used.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv_transpose(IGraphNodeBase input, int filters, IGraphNodeBase output_shape, string strides, string padding, object data_format, object dilations, string name)

The transpose of `convolution`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf), but is actually the transpose (gradient) of `convolution` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
An N+2 dimensional `Tensor` of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC". It must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
int filters
An N+2 dimensional `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
string strides
An int or list of `ints` that has length `1`, `N` or `N+2`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
object data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object dilations
An int or list of `ints` that has length `1`, `N` or `N+2`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details.
string name
A name for the operation (optional). If not specified "conv_transpose" is used.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv_transpose(IGraphNodeBase input, IGraphNodeBase filters, IEnumerable<int> output_shape, int strides, string padding, object data_format, object dilations, string name)

The transpose of `convolution`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf), but is actually the transpose (gradient) of `convolution` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
An N+2 dimensional `Tensor` of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC". It must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
IGraphNodeBase filters
An N+2 dimensional `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
int strides
An int or list of `ints` that has length `1`, `N` or `N+2`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
object data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object dilations
An int or list of `ints` that has length `1`, `N` or `N+2`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details.
string name
A name for the operation (optional). If not specified "conv_transpose" is used.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv_transpose(IGraphNodeBase input, IGraphNodeBase filters, IEnumerable<int> output_shape, string strides, string padding, object data_format, object dilations, string name)

The transpose of `convolution`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf), but is actually the transpose (gradient) of `convolution` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
An N+2 dimensional `Tensor` of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC". It must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
IGraphNodeBase filters
An N+2 dimensional `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
string strides
An int or list of `ints` that has length `1`, `N` or `N+2`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
object data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object dilations
An int or list of `ints` that has length `1`, `N` or `N+2`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details.
string name
A name for the operation (optional). If not specified "conv_transpose" is used.
Returns
Tensor
A `Tensor` with the same type as `value`.

object conv_transpose_dyn(object input, object filters, object output_shape, object strides, ImplicitContainer<T> padding, object data_format, object dilations, object name)

The transpose of `convolution`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf), but is actually the transpose (gradient) of `convolution` rather than an actual deconvolution.
Parameters
object input
An N+2 dimensional `Tensor` of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC". It must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
object filters
An N+2 dimensional `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
object output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
object strides
An int or list of `ints` that has length `1`, `N` or `N+2`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ImplicitContainer<T> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
object data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object dilations
An int or list of `ints` that has length `1`, `N` or `N+2`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the spatial dimensions. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details.
object name
A name for the operation (optional). If not specified "conv_transpose" is used.
Returns
object
A `Tensor` with the same type as `value`.

Tensor conv1d(IEnumerable<IGraphNodeBase> value, IGraphNodeBase filters, IEnumerable<int> stride, string padding, Nullable<bool> use_cudnn_on_gpu, string data_format, string name, IGraphNodeBase input, object dilations)

Computes a 1-D convolution given 3-D input and filter tensors. (deprecated argument values) (deprecated argument values)

Warning: SOME ARGUMENT VALUES ARE DEPRECATED: `(data_format='NCHW')`. They will be removed in a future version. Instructions for updating: `NCHW` for data_format is deprecated, use `NCW` instead

Warning: SOME ARGUMENT VALUES ARE DEPRECATED: `(data_format='NHWC')`. They will be removed in a future version. Instructions for updating: `NHWC` for data_format is deprecated, use `NWC` instead

Given an input tensor of shape [batch, in_width, in_channels] if data_format is "NWC", or [batch, in_channels, in_width] if data_format is "NCW", and a filter / kernel tensor of shape [filter_width, in_channels, out_channels], this op reshapes the arguments to pass them to conv2d to perform the equivalent convolution operation.

Internally, this op reshapes the input tensors and invokes tf.nn.conv2d. For example, if `data_format` does not start with "NC", a tensor of shape [batch, in_width, in_channels] is reshaped to [batch, 1, in_width, in_channels], and the filter is reshaped to [1, filter_width, in_channels, out_channels]. The result is then reshaped back to [batch, out_width, out_channels] \(where out_width is a function of the stride and padding as in conv2d\) and returned to the caller.
Parameters
IEnumerable<IGraphNodeBase> value
A 3D `Tensor`. Must be of type `float16`, `float32`, or `float64`.
IGraphNodeBase filters
A 3D `Tensor`. Must have the same type as `value`.
IEnumerable<int> stride
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
'SAME' or 'VALID'
Nullable<bool> use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from `"NWC", "NCW"`. Defaults to `"NWC"`, the data is stored in the order of [batch, in_width, in_channels]. The `"NCW"` format stores data as [batch, in_channels, in_width].
string name
A name for the operation (optional).
IGraphNodeBase input
Alias for value.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
Returns
Tensor
A `Tensor`. Has the same type as input.

Tensor conv1d(IGraphNodeBase value, IGraphNodeBase filters, IEnumerable<int> stride, string padding, Nullable<bool> use_cudnn_on_gpu, string data_format, string name, IGraphNodeBase input, object dilations)

Computes a 1-D convolution given 3-D input and filter tensors. (deprecated argument values) (deprecated argument values)

Warning: SOME ARGUMENT VALUES ARE DEPRECATED: `(data_format='NCHW')`. They will be removed in a future version. Instructions for updating: `NCHW` for data_format is deprecated, use `NCW` instead

Warning: SOME ARGUMENT VALUES ARE DEPRECATED: `(data_format='NHWC')`. They will be removed in a future version. Instructions for updating: `NHWC` for data_format is deprecated, use `NWC` instead

Given an input tensor of shape [batch, in_width, in_channels] if data_format is "NWC", or [batch, in_channels, in_width] if data_format is "NCW", and a filter / kernel tensor of shape [filter_width, in_channels, out_channels], this op reshapes the arguments to pass them to conv2d to perform the equivalent convolution operation.

Internally, this op reshapes the input tensors and invokes tf.nn.conv2d. For example, if `data_format` does not start with "NC", a tensor of shape [batch, in_width, in_channels] is reshaped to [batch, 1, in_width, in_channels], and the filter is reshaped to [1, filter_width, in_channels, out_channels]. The result is then reshaped back to [batch, out_width, out_channels] \(where out_width is a function of the stride and padding as in conv2d\) and returned to the caller.
Parameters
IGraphNodeBase value
A 3D `Tensor`. Must be of type `float16`, `float32`, or `float64`.
IGraphNodeBase filters
A 3D `Tensor`. Must have the same type as `value`.
IEnumerable<int> stride
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
'SAME' or 'VALID'
Nullable<bool> use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from `"NWC", "NCW"`. Defaults to `"NWC"`, the data is stored in the order of [batch, in_width, in_channels]. The `"NCW"` format stores data as [batch, in_channels, in_width].
string name
A name for the operation (optional).
IGraphNodeBase input
Alias for value.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
Returns
Tensor
A `Tensor`. Has the same type as input.

Tensor conv1d(IGraphNodeBase value, IGraphNodeBase filters, int stride, string padding, Nullable<bool> use_cudnn_on_gpu, string data_format, string name, IGraphNodeBase input, object dilations)

Computes a 1-D convolution given 3-D input and filter tensors. (deprecated argument values) (deprecated argument values)

Warning: SOME ARGUMENT VALUES ARE DEPRECATED: `(data_format='NCHW')`. They will be removed in a future version. Instructions for updating: `NCHW` for data_format is deprecated, use `NCW` instead

Warning: SOME ARGUMENT VALUES ARE DEPRECATED: `(data_format='NHWC')`. They will be removed in a future version. Instructions for updating: `NHWC` for data_format is deprecated, use `NWC` instead

Given an input tensor of shape [batch, in_width, in_channels] if data_format is "NWC", or [batch, in_channels, in_width] if data_format is "NCW", and a filter / kernel tensor of shape [filter_width, in_channels, out_channels], this op reshapes the arguments to pass them to conv2d to perform the equivalent convolution operation.

Internally, this op reshapes the input tensors and invokes tf.nn.conv2d. For example, if `data_format` does not start with "NC", a tensor of shape [batch, in_width, in_channels] is reshaped to [batch, 1, in_width, in_channels], and the filter is reshaped to [1, filter_width, in_channels, out_channels]. The result is then reshaped back to [batch, out_width, out_channels] \(where out_width is a function of the stride and padding as in conv2d\) and returned to the caller.
Parameters
IGraphNodeBase value
A 3D `Tensor`. Must be of type `float16`, `float32`, or `float64`.
IGraphNodeBase filters
A 3D `Tensor`. Must have the same type as `value`.
int stride
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
'SAME' or 'VALID'
Nullable<bool> use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from `"NWC", "NCW"`. Defaults to `"NWC"`, the data is stored in the order of [batch, in_width, in_channels]. The `"NCW"` format stores data as [batch, in_channels, in_width].
string name
A name for the operation (optional).
IGraphNodeBase input
Alias for value.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
Returns
Tensor
A `Tensor`. Has the same type as input.

Tensor conv1d(IEnumerable<IGraphNodeBase> value, IGraphNodeBase filters, int stride, string padding, Nullable<bool> use_cudnn_on_gpu, string data_format, string name, IGraphNodeBase input, object dilations)

Computes a 1-D convolution given 3-D input and filter tensors. (deprecated argument values) (deprecated argument values)

Warning: SOME ARGUMENT VALUES ARE DEPRECATED: `(data_format='NCHW')`. They will be removed in a future version. Instructions for updating: `NCHW` for data_format is deprecated, use `NCW` instead

Warning: SOME ARGUMENT VALUES ARE DEPRECATED: `(data_format='NHWC')`. They will be removed in a future version. Instructions for updating: `NHWC` for data_format is deprecated, use `NWC` instead

Given an input tensor of shape [batch, in_width, in_channels] if data_format is "NWC", or [batch, in_channels, in_width] if data_format is "NCW", and a filter / kernel tensor of shape [filter_width, in_channels, out_channels], this op reshapes the arguments to pass them to conv2d to perform the equivalent convolution operation.

Internally, this op reshapes the input tensors and invokes tf.nn.conv2d. For example, if `data_format` does not start with "NC", a tensor of shape [batch, in_width, in_channels] is reshaped to [batch, 1, in_width, in_channels], and the filter is reshaped to [1, filter_width, in_channels, out_channels]. The result is then reshaped back to [batch, out_width, out_channels] \(where out_width is a function of the stride and padding as in conv2d\) and returned to the caller.
Parameters
IEnumerable<IGraphNodeBase> value
A 3D `Tensor`. Must be of type `float16`, `float32`, or `float64`.
IGraphNodeBase filters
A 3D `Tensor`. Must have the same type as `value`.
int stride
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
'SAME' or 'VALID'
Nullable<bool> use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from `"NWC", "NCW"`. Defaults to `"NWC"`, the data is stored in the order of [batch, in_width, in_channels]. The `"NCW"` format stores data as [batch, in_channels, in_width].
string name
A name for the operation (optional).
IGraphNodeBase input
Alias for value.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
Returns
Tensor
A `Tensor`. Has the same type as input.

object conv1d_dyn(object value, object filters, object stride, object padding, object use_cudnn_on_gpu, object data_format, object name, object input, object dilations)

Computes a 1-D convolution given 3-D input and filter tensors. (deprecated argument values) (deprecated argument values)

Warning: SOME ARGUMENT VALUES ARE DEPRECATED: `(data_format='NCHW')`. They will be removed in a future version. Instructions for updating: `NCHW` for data_format is deprecated, use `NCW` instead

Warning: SOME ARGUMENT VALUES ARE DEPRECATED: `(data_format='NHWC')`. They will be removed in a future version. Instructions for updating: `NHWC` for data_format is deprecated, use `NWC` instead

Given an input tensor of shape [batch, in_width, in_channels] if data_format is "NWC", or [batch, in_channels, in_width] if data_format is "NCW", and a filter / kernel tensor of shape [filter_width, in_channels, out_channels], this op reshapes the arguments to pass them to conv2d to perform the equivalent convolution operation.

Internally, this op reshapes the input tensors and invokes tf.nn.conv2d. For example, if `data_format` does not start with "NC", a tensor of shape [batch, in_width, in_channels] is reshaped to [batch, 1, in_width, in_channels], and the filter is reshaped to [1, filter_width, in_channels, out_channels]. The result is then reshaped back to [batch, out_width, out_channels] \(where out_width is a function of the stride and padding as in conv2d\) and returned to the caller.
Parameters
object value
A 3D `Tensor`. Must be of type `float16`, `float32`, or `float64`.
object filters
A 3D `Tensor`. Must have the same type as `value`.
object stride
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
object padding
'SAME' or 'VALID'
object use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
object data_format
An optional `string` from `"NWC", "NCW"`. Defaults to `"NWC"`, the data is stored in the order of [batch, in_width, in_channels]. The `"NCW"` format stores data as [batch, in_channels, in_width].
object name
A name for the operation (optional).
object input
Alias for value.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
Returns
object
A `Tensor`. Has the same type as input.

Tensor conv1d_transpose(IGraphNodeBase input, int filters, IEnumerable<int> output_shape, string strides, string padding, string data_format, object dilations, PythonFunctionContainer name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
int filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
string strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
PythonFunctionContainer name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, IGraphNodeBase filters, IGraphNodeBase output_shape, string strides, string padding, string data_format, object dilations, PythonFunctionContainer name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
IGraphNodeBase filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
string strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
PythonFunctionContainer name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, IGraphNodeBase filters, IGraphNodeBase output_shape, int strides, string padding, string data_format, object dilations, string name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
IGraphNodeBase filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
int strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, IGraphNodeBase filters, IEnumerable<int> output_shape, IEnumerable<int> strides, string padding, string data_format, object dilations, PythonFunctionContainer name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
IGraphNodeBase filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
PythonFunctionContainer name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, int filters, IEnumerable<int> output_shape, string strides, string padding, string data_format, object dilations, string name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
int filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
string strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, int filters, IGraphNodeBase output_shape, IEnumerable<int> strides, string padding, string data_format, object dilations, string name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
int filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, int filters, IGraphNodeBase output_shape, string strides, string padding, string data_format, object dilations, string name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
int filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
string strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, int filters, IGraphNodeBase output_shape, IEnumerable<int> strides, string padding, string data_format, object dilations, PythonFunctionContainer name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
int filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
PythonFunctionContainer name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, IGraphNodeBase filters, IGraphNodeBase output_shape, int strides, string padding, string data_format, object dilations, PythonFunctionContainer name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
IGraphNodeBase filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
int strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
PythonFunctionContainer name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, IGraphNodeBase filters, IEnumerable<int> output_shape, int strides, string padding, string data_format, object dilations, string name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
IGraphNodeBase filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
int strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, int filters, IEnumerable<int> output_shape, int strides, string padding, string data_format, object dilations, PythonFunctionContainer name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
int filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
int strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
PythonFunctionContainer name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, IGraphNodeBase filters, IGraphNodeBase output_shape, IEnumerable<int> strides, string padding, string data_format, object dilations, string name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
IGraphNodeBase filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, int filters, IEnumerable<int> output_shape, IEnumerable<int> strides, string padding, string data_format, object dilations, string name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
int filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, IGraphNodeBase filters, IGraphNodeBase output_shape, IEnumerable<int> strides, string padding, string data_format, object dilations, PythonFunctionContainer name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
IGraphNodeBase filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
PythonFunctionContainer name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, int filters, IGraphNodeBase output_shape, int strides, string padding, string data_format, object dilations, PythonFunctionContainer name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
int filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
int strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
PythonFunctionContainer name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, IGraphNodeBase filters, IEnumerable<int> output_shape, string strides, string padding, string data_format, object dilations, string name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
IGraphNodeBase filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
string strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, IGraphNodeBase filters, IEnumerable<int> output_shape, IEnumerable<int> strides, string padding, string data_format, object dilations, string name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
IGraphNodeBase filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, IGraphNodeBase filters, IEnumerable<int> output_shape, string strides, string padding, string data_format, object dilations, PythonFunctionContainer name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
IGraphNodeBase filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
string strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
PythonFunctionContainer name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, IGraphNodeBase filters, IEnumerable<int> output_shape, int strides, string padding, string data_format, object dilations, PythonFunctionContainer name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
IGraphNodeBase filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
int strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
PythonFunctionContainer name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, int filters, IEnumerable<int> output_shape, int strides, string padding, string data_format, object dilations, string name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
int filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
int strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, IGraphNodeBase filters, IGraphNodeBase output_shape, string strides, string padding, string data_format, object dilations, string name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
IGraphNodeBase filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
string strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, int filters, IGraphNodeBase output_shape, int strides, string padding, string data_format, object dilations, string name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
int filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
int strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
string name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, int filters, IEnumerable<int> output_shape, IEnumerable<int> strides, string padding, string data_format, object dilations, PythonFunctionContainer name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
int filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
PythonFunctionContainer name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv1d_transpose(IGraphNodeBase input, int filters, IGraphNodeBase output_shape, string strides, string padding, string data_format, object dilations, PythonFunctionContainer name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
IGraphNodeBase input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
int filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
string strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
PythonFunctionContainer name
Optional name for the returned tensor.
Returns
Tensor
A `Tensor` with the same type as `value`.

object conv1d_transpose_dyn(object input, object filters, object output_shape, object strides, ImplicitContainer<T> padding, ImplicitContainer<T> data_format, object dilations, object name)

The transpose of `conv1d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv1d` rather than an actual deconvolution.
Parameters
object input
A 3-D `Tensor` of type `float` and shape `[batch, in_width, in_channels]` for `NWC` data format or `[batch, in_channels, in_width]` for `NCW` data format.
object filters
A 3-D `Tensor` with the same type as `value` and shape `[filter_width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
object output_shape
A 1-D `Tensor`, containing three elements, representing the output shape of the deconvolution op.
object strides
An int or list of `ints` that has length `1` or `3`. The number of entries by which the filter is moved right at each step.
ImplicitContainer<T> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
ImplicitContainer<T> data_format
A string. `'NWC'` and `'NCW'` are supported.
object dilations
An int or list of `ints` that has length `1` or `3` which defaults to 1. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. Dilations in the batch and depth dimensions must be 1.
object name
Optional name for the returned tensor.
Returns
object
A `Tensor` with the same type as `value`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, int strides, ValueTuple<IEnumerable<object>, object> padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
int strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, int strides, IEnumerable<object> padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
int strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
IEnumerable<object> padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, ValueTuple<int, object, object, object> strides, IEnumerable<object> padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
ValueTuple<int, object, object, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
IEnumerable<object> padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, ValueTuple<int, object, object, object> strides, IEnumerable<object> padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
ValueTuple<int, object, object, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
IEnumerable<object> padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, int strides, string padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
int strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
string padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, ValueTuple<int, object, object, object> strides, ValueTuple<IEnumerable<object>, object> padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
ValueTuple<int, object, object, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, ValueTuple<int, object, object, object> strides, ValueTuple<IEnumerable<object>, object> padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
ValueTuple<int, object, object, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, ValueTuple<int, object, object, object> strides, int padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
ValueTuple<int, object, object, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
int padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, ValueTuple<int, object, object, object> strides, double padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
ValueTuple<int, object, object, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
double padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, ValueTuple<int, object, object, object> strides, string padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
ValueTuple<int, object, object, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
string padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, ValueTuple<int, object, object, object> strides, string padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
ValueTuple<int, object, object, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
string padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, int strides, double padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
int strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
double padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, int strides, double padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
int strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
double padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, int strides, IEnumerable<object> padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
int strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
IEnumerable<object> padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, ValueTuple<int, object, object, object> strides, int padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
ValueTuple<int, object, object, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
int padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, int strides, string padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
int strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
string padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, ValueTuple<int, object, object, object> strides, double padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
ValueTuple<int, object, object, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
double padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, IEnumerable<int> strides, int padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
int padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, int strides, ValueTuple<IEnumerable<object>, object> padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
int strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, int strides, int padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
int strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
int padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, int strides, int padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
int strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
int padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, IEnumerable<int> strides, double padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
double padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, IEnumerable<int> strides, string padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
string padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, IEnumerable<int> strides, double padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
double padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, IEnumerable<int> strides, IEnumerable<object> padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
IEnumerable<object> padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, IEnumerable<int> strides, IEnumerable<object> padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
IEnumerable<object> padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, IEnumerable<int> strides, string padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
string padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, IEnumerable<int> strides, ValueTuple<IEnumerable<object>, object> padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, IEnumerable<int> strides, ValueTuple<IEnumerable<object>, object> padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d(IGraphNodeBase input, IGraphNodeBase filter, IEnumerable<int> strides, int padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
IGraphNodeBase filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
int padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ValueTuple<int, object> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d_backprop_filter(IGraphNodeBase input, IGraphNodeBase filter_sizes, IGraphNodeBase out_backprop, IEnumerable<int> strides, string padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name)

Computes the gradients of convolution with respect to the filter.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filter_sizes
A `Tensor` of type `int32`. An integer vector representing the tensor shape of `filter`, where `filter` is a 4-D `[filter_height, filter_width, in_channels, out_channels]` tensor.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `input`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
string padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d_backprop_filter(IGraphNodeBase input, IGraphNodeBase filter_sizes, IGraphNodeBase out_backprop, IEnumerable<int> strides, ValueTuple<IEnumerable<object>, object> padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name)

Computes the gradients of convolution with respect to the filter.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filter_sizes
A `Tensor` of type `int32`. An integer vector representing the tensor shape of `filter`, where `filter` is a 4-D `[filter_height, filter_width, in_channels, out_channels]` tensor.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `input`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
ValueTuple<IEnumerable<object>, object> padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d_backprop_filter(IGraphNodeBase input, IGraphNodeBase filter_sizes, IGraphNodeBase out_backprop, IEnumerable<int> strides, object padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name)

Computes the gradients of convolution with respect to the filter.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filter_sizes
A `Tensor` of type `int32`. An integer vector representing the tensor shape of `filter`, where `filter` is a 4-D `[filter_height, filter_width, in_channels, out_channels]` tensor.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `input`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
object padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv2d_backprop_filter(IGraphNodeBase input, IGraphNodeBase filter_sizes, IGraphNodeBase out_backprop, IEnumerable<int> strides, IEnumerable<object> padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name)

Computes the gradients of convolution with respect to the filter.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[batch, in_height, in_width, in_channels]`.
IGraphNodeBase filter_sizes
A `Tensor` of type `int32`. An integer vector representing the tensor shape of `filter`, where `filter` is a 4-D `[filter_height, filter_width, in_channels, out_channels]` tensor.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `input`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
IEnumerable<object> padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor`. Has the same type as `input`.

object conv2d_backprop_filter_dyn(object input, object filter_sizes, object out_backprop, object strides, object padding, ImplicitContainer<T> use_cudnn_on_gpu, ImplicitContainer<T> data_format, ImplicitContainer<T> dilations, object name)

Computes the gradients of convolution with respect to the filter.
Parameters
object input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[batch, in_height, in_width, in_channels]`.
object filter_sizes
A `Tensor` of type `int32`. An integer vector representing the tensor shape of `filter`, where `filter` is a 4-D `[filter_height, filter_width, in_channels, out_channels]` tensor.
object out_backprop
A `Tensor`. Must have the same type as `input`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
object strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
object padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
ImplicitContainer<T> use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
ImplicitContainer<T> data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
object name
A name for the operation (optional).
Returns
object
A `Tensor`. Has the same type as `input`.

Tensor conv2d_backprop_input(IGraphNodeBase input_sizes, IGraphNodeBase filter, IGraphNodeBase out_backprop, IEnumerable<int> strides, ValueTuple<IEnumerable<object>, object> padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes the gradients of convolution with respect to the input.
Parameters
IGraphNodeBase input_sizes
A `Tensor` of type `int32`. An integer vector representing the shape of `input`, where `input` is a 4-D `[batch, height, width, channels]` tensor.
IGraphNodeBase filter
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[filter_height, filter_width, in_channels, out_channels]`.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `filter`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
ValueTuple<IEnumerable<object>, object> padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
ValueTuple<int, object> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `filter`.

Tensor conv2d_backprop_input(IGraphNodeBase input_sizes, IGraphNodeBase filter, IGraphNodeBase out_backprop, IEnumerable<int> strides, string padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes the gradients of convolution with respect to the input.
Parameters
IGraphNodeBase input_sizes
A `Tensor` of type `int32`. An integer vector representing the shape of `input`, where `input` is a 4-D `[batch, height, width, channels]` tensor.
IGraphNodeBase filter
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[filter_height, filter_width, in_channels, out_channels]`.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `filter`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
string padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
ValueTuple<int, object> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `filter`.

Tensor conv2d_backprop_input(IGraphNodeBase input_sizes, IGraphNodeBase filter, IGraphNodeBase out_backprop, IEnumerable<int> strides, ValueTuple<IEnumerable<object>, object> padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes the gradients of convolution with respect to the input.
Parameters
IGraphNodeBase input_sizes
A `Tensor` of type `int32`. An integer vector representing the shape of `input`, where `input` is a 4-D `[batch, height, width, channels]` tensor.
IGraphNodeBase filter
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[filter_height, filter_width, in_channels, out_channels]`.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `filter`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
ValueTuple<IEnumerable<object>, object> padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `filter`.

Tensor conv2d_backprop_input(IGraphNodeBase input_sizes, IGraphNodeBase filter, IGraphNodeBase out_backprop, IEnumerable<int> strides, string padding, bool use_cudnn_on_gpu, string data_format, IEnumerable<object> dilations, string name, object filters)

Computes the gradients of convolution with respect to the input.
Parameters
IGraphNodeBase input_sizes
A `Tensor` of type `int32`. An integer vector representing the shape of `input`, where `input` is a 4-D `[batch, height, width, channels]` tensor.
IGraphNodeBase filter
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[filter_height, filter_width, in_channels, out_channels]`.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `filter`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
string padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
IEnumerable<object> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `filter`.

Tensor conv2d_backprop_input(IGraphNodeBase input_sizes, IGraphNodeBase filter, IGraphNodeBase out_backprop, IEnumerable<int> strides, IEnumerable<object> padding, bool use_cudnn_on_gpu, string data_format, IEnumerable<object> dilations, string name, object filters)

Computes the gradients of convolution with respect to the input.
Parameters
IGraphNodeBase input_sizes
A `Tensor` of type `int32`. An integer vector representing the shape of `input`, where `input` is a 4-D `[batch, height, width, channels]` tensor.
IGraphNodeBase filter
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[filter_height, filter_width, in_channels, out_channels]`.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `filter`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
IEnumerable<object> padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
IEnumerable<object> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `filter`.

Tensor conv2d_backprop_input(IGraphNodeBase input_sizes, IGraphNodeBase filter, IGraphNodeBase out_backprop, IEnumerable<int> strides, IEnumerable<object> padding, bool use_cudnn_on_gpu, string data_format, ValueTuple<int, object> dilations, string name, object filters)

Computes the gradients of convolution with respect to the input.
Parameters
IGraphNodeBase input_sizes
A `Tensor` of type `int32`. An integer vector representing the shape of `input`, where `input` is a 4-D `[batch, height, width, channels]` tensor.
IGraphNodeBase filter
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[filter_height, filter_width, in_channels, out_channels]`.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `filter`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
IEnumerable<object> padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
ValueTuple<int, object> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `filter`.

Tensor conv2d_backprop_input(IGraphNodeBase input_sizes, IGraphNodeBase filter, IGraphNodeBase out_backprop, IEnumerable<int> strides, IEnumerable<object> padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes the gradients of convolution with respect to the input.
Parameters
IGraphNodeBase input_sizes
A `Tensor` of type `int32`. An integer vector representing the shape of `input`, where `input` is a 4-D `[batch, height, width, channels]` tensor.
IGraphNodeBase filter
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[filter_height, filter_width, in_channels, out_channels]`.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `filter`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
IEnumerable<object> padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `filter`.

Tensor conv2d_backprop_input(IGraphNodeBase input_sizes, IGraphNodeBase filter, IGraphNodeBase out_backprop, IEnumerable<int> strides, ValueTuple<IEnumerable<object>, object> padding, bool use_cudnn_on_gpu, string data_format, IEnumerable<object> dilations, string name, object filters)

Computes the gradients of convolution with respect to the input.
Parameters
IGraphNodeBase input_sizes
A `Tensor` of type `int32`. An integer vector representing the shape of `input`, where `input` is a 4-D `[batch, height, width, channels]` tensor.
IGraphNodeBase filter
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[filter_height, filter_width, in_channels, out_channels]`.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `filter`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
ValueTuple<IEnumerable<object>, object> padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
IEnumerable<object> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `filter`.

Tensor conv2d_backprop_input(IGraphNodeBase input_sizes, IGraphNodeBase filter, IGraphNodeBase out_backprop, IEnumerable<int> strides, string padding, bool use_cudnn_on_gpu, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes the gradients of convolution with respect to the input.
Parameters
IGraphNodeBase input_sizes
A `Tensor` of type `int32`. An integer vector representing the shape of `input`, where `input` is a 4-D `[batch, height, width, channels]` tensor.
IGraphNodeBase filter
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[filter_height, filter_width, in_channels, out_channels]`.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `filter`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
IEnumerable<int> strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
string padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
bool use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
string data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
object filters
Alias for filter.
Returns
Tensor
A `Tensor`. Has the same type as `filter`.

object conv2d_backprop_input_dyn(object input_sizes, object filter, object out_backprop, object strides, object padding, ImplicitContainer<T> use_cudnn_on_gpu, ImplicitContainer<T> data_format, ImplicitContainer<T> dilations, object name, object filters)

Computes the gradients of convolution with respect to the input.
Parameters
object input_sizes
A `Tensor` of type `int32`. An integer vector representing the shape of `input`, where `input` is a 4-D `[batch, height, width, channels]` tensor.
object filter
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4-D with shape `[filter_height, filter_width, in_channels, out_channels]`.
object out_backprop
A `Tensor`. Must have the same type as `filter`. 4-D with shape `[batch, out_height, out_width, out_channels]`. Gradients w.r.t. the output of the convolution.
object strides
A list of `ints`. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format.
object padding
Either the `string `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
ImplicitContainer<T> use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
ImplicitContainer<T> data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, in_channels, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
object name
A name for the operation (optional).
object filters
Alias for filter.
Returns
object
A `Tensor`. Has the same type as `filter`.

object conv2d_dyn(object input, object filter, object strides, object padding, ImplicitContainer<T> use_cudnn_on_gpu, ImplicitContainer<T> data_format, ImplicitContainer<T> dilations, object name, object filters)

Computes a 2-D convolution given 4-D `input` and `filter` tensors.

Given an input tensor of shape `[batch, in_height, in_width, in_channels]` and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`, this op performs the following:

1. Flattens the filter to a 2-D matrix with shape `[filter_height * filter_width * in_channels, output_channels]`. 2. Extracts image patches from the input tensor to form a *virtual* tensor of shape `[batch, out_height, out_width, filter_height * filter_width * in_channels]`. 3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]

Must have `strides[0] = strides[3] = 1`. For the most common case of the same horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
Parameters
object input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. A 4-D tensor. The dimension order is interpreted according to the value of `data_format`, see below for details.
object filter
A `Tensor`. Must have the same type as `input`. A 4-D tensor of shape `[filter_height, filter_width, in_channels, out_channels]`
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. The dimension order is determined by the value of `data_format`, see below for details.
object padding
Either the `string` `"SAME"` or `"VALID"` indicating the type of padding algorithm to use, or a list indicating the explicit paddings at the start and end of each dimension. When explicit padding is used and data_format is `"NHWC"`, this should be in the form `[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]]`. When explicit padding used and data_format is `"NCHW"`, this should be in the form `[[0, 0], [0, 0], [pad_top, pad_bottom], [pad_left, pad_right]]`.
ImplicitContainer<T> use_cudnn_on_gpu
An optional `bool`. Defaults to `True`.
ImplicitContainer<T> data_format
An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
ImplicitContainer<T> dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
object name
A name for the operation (optional).
object filters
Alias for filter.
Returns
object
A `Tensor`. Has the same type as `input`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, object output_shape, IEnumerable<int> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
object output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IGraphNodeBase output_shape, ValueTuple<int, object> strides, ValueTuple<IEnumerable<object>, object> padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IGraphNodeBase output_shape, ValueTuple<int, object> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, object output_shape, ValueTuple<int, object> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
object output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, object output_shape, object strides, ValueTuple<IEnumerable<object>, object> padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
object output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, object output_shape, object strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
object output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IGraphNodeBase output_shape, object strides, ValueTuple<IEnumerable<object>, object> padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IGraphNodeBase output_shape, object strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, object output_shape, IEnumerable<int> strides, ValueTuple<IEnumerable<object>, object> padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
object output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, object output_shape, ValueTuple<int, object> strides, ValueTuple<IEnumerable<object>, object> padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
object output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IEnumerable<int> output_shape, IEnumerable<int> strides, ValueTuple<IEnumerable<object>, object> padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IEnumerable<int> output_shape, IEnumerable<int> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IEnumerable<int> output_shape, ValueTuple<int, object> strides, ValueTuple<IEnumerable<object>, object> padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IGraphNodeBase output_shape, IEnumerable<int> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IEnumerable<int> output_shape, ValueTuple<int, object> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IEnumerable<int> output_shape, object strides, ValueTuple<IEnumerable<object>, object> padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IEnumerable<int> output_shape, object strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape, IEnumerable<int> strides, ValueTuple<IEnumerable<object>, object> padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape, IEnumerable<int> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IGraphNodeBase output_shape, IEnumerable<int> strides, ValueTuple<IEnumerable<object>, object> padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape, ValueTuple<int, object> strides, ValueTuple<IEnumerable<object>, object> padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape, object strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape, ValueTuple<int, object> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object> strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv2d_transpose(IGraphNodeBase value, IGraphNodeBase filter, ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape, object strides, ValueTuple<IEnumerable<object>, object> padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
IGraphNodeBase filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<IEnumerable<object>, PythonClassContainer> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ValueTuple<IEnumerable<object>, object> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string. 'NHWC' and 'NCHW' are supported.
string name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

object conv2d_transpose_dyn(object value, object filter, object output_shape, object strides, ImplicitContainer<T> padding, ImplicitContainer<T> data_format, object name, object input, object filters, object dilations)

The transpose of `conv2d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv2d` rather than an actual deconvolution.
Parameters
object value
A 4-D `Tensor` of type `float` and shape `[batch, height, width, in_channels]` for `NHWC` data format or `[batch, in_channels, height, width]` for `NCHW` data format.
object filter
A 4-D `Tensor` with the same type as `value` and shape `[height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
object output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
object strides
An int or list of `ints` that has length `1`, `2` or `4`. The stride of the sliding window for each dimension of `input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 0. The dimension order is determined by the value of `data_format`, see below for details.
ImplicitContainer<T> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
ImplicitContainer<T> data_format
A string. 'NHWC' and 'NCHW' are supported.
object name
Optional name for the returned tensor.
object input
Alias for value.
object filters
Alias for filter.
object dilations
An int or list of `ints` that has length `1`, `2` or `4`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 4-d tensor must be 1.
Returns
object
A `Tensor` with the same type as `value`.

Tensor conv3d(object input, object filter, object strides, object padding, string data_format, ImplicitContainer<T> dilations, string name, object filters)

Computes a 3-D convolution given 5-D `input` and `filter` tensors.

In signal processing, cross-correlation is a measure of similarity of two waveforms as a function of a time-lag applied to one of them. This is also known as a sliding dot product or sliding inner-product.

Our Conv3D implements a form of cross-correlation.
Parameters
object input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. Shape `[batch, in_depth, in_height, in_width, in_channels]`.
object filter
A `Tensor`. Must have the same type as `input`. Shape `[filter_depth, filter_height, filter_width, in_channels, out_channels]`. `in_channels` must match between `input` and `filter`.
object strides
A list of `ints` that has length `>= 5`. 1-D tensor of length 5. The stride of the sliding window for each dimension of `input`. Must have `strides[0] = strides[4] = 1`.
object padding
A `string` from: `"SAME", "VALID"`. The type of padding algorithm to use.
string data_format
An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`. The data format of the input and output data. With the default format "NDHWC", the data is stored in the order of: [batch, in_depth, in_height, in_width, in_channels]. Alternatively, the format could be "NCDHW", the data storage order is: [batch, in_channels, in_depth, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1, 1]`. 1-D tensor of length 5. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
object filters
Returns
Tensor
A `Tensor`. Has the same type as `input`.

Tensor conv3d_backprop_filter(IGraphNodeBase input, IGraphNodeBase filter_sizes, IGraphNodeBase out_backprop, IEnumerable<int> strides, string padding, string data_format, ImplicitContainer<T> dilations, string name)

Computes the gradients of 3-D convolution with respect to the filter.
Parameters
IGraphNodeBase input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. Shape `[batch, depth, rows, cols, in_channels]`.
IGraphNodeBase filter_sizes
A `Tensor` of type `int32`. An integer vector representing the tensor shape of `filter`, where `filter` is a 5-D `[filter_depth, filter_height, filter_width, in_channels, out_channels]` tensor.
IGraphNodeBase out_backprop
A `Tensor`. Must have the same type as `input`. Backprop signal of shape `[batch, out_depth, out_rows, out_cols, out_channels]`.
IEnumerable<int> strides
A list of `ints` that has length `>= 5`. 1-D tensor of length 5. The stride of the sliding window for each dimension of `input`. Must have `strides[0] = strides[4] = 1`.
string padding
A `string` from: `"SAME", "VALID"`. The type of padding algorithm to use.
string data_format
An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`. The data format of the input and output data. With the default format "NDHWC", the data is stored in the order of: [batch, in_depth, in_height, in_width, in_channels]. Alternatively, the format could be "NCDHW", the data storage order is: [batch, in_channels, in_depth, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1, 1]`. 1-D tensor of length 5. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor`. Has the same type as `input`.

object conv3d_backprop_filter_dyn(object input, object filter_sizes, object out_backprop, object strides, object padding, ImplicitContainer<T> data_format, ImplicitContainer<T> dilations, object name)

Computes the gradients of 3-D convolution with respect to the filter.
Parameters
object input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. Shape `[batch, depth, rows, cols, in_channels]`.
object filter_sizes
A `Tensor` of type `int32`. An integer vector representing the tensor shape of `filter`, where `filter` is a 5-D `[filter_depth, filter_height, filter_width, in_channels, out_channels]` tensor.
object out_backprop
A `Tensor`. Must have the same type as `input`. Backprop signal of shape `[batch, out_depth, out_rows, out_cols, out_channels]`.
object strides
A list of `ints` that has length `>= 5`. 1-D tensor of length 5. The stride of the sliding window for each dimension of `input`. Must have `strides[0] = strides[4] = 1`.
object padding
A `string` from: `"SAME", "VALID"`. The type of padding algorithm to use.
ImplicitContainer<T> data_format
An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`. The data format of the input and output data. With the default format "NDHWC", the data is stored in the order of: [batch, in_depth, in_height, in_width, in_channels]. Alternatively, the format could be "NCDHW", the data storage order is: [batch, in_channels, in_depth, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1, 1]`. 1-D tensor of length 5. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
object name
A name for the operation (optional).
Returns
object
A `Tensor`. Has the same type as `input`.

object conv3d_dyn(object input, object filter, object strides, object padding, ImplicitContainer<T> data_format, ImplicitContainer<T> dilations, object name, object filters)

Computes a 3-D convolution given 5-D `input` and `filter` tensors.

In signal processing, cross-correlation is a measure of similarity of two waveforms as a function of a time-lag applied to one of them. This is also known as a sliding dot product or sliding inner-product.

Our Conv3D implements a form of cross-correlation.
Parameters
object input
A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. Shape `[batch, in_depth, in_height, in_width, in_channels]`.
object filter
A `Tensor`. Must have the same type as `input`. Shape `[filter_depth, filter_height, filter_width, in_channels, out_channels]`. `in_channels` must match between `input` and `filter`.
object strides
A list of `ints` that has length `>= 5`. 1-D tensor of length 5. The stride of the sliding window for each dimension of `input`. Must have `strides[0] = strides[4] = 1`.
object padding
A `string` from: `"SAME", "VALID"`. The type of padding algorithm to use.
ImplicitContainer<T> data_format
An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`. The data format of the input and output data. With the default format "NDHWC", the data is stored in the order of: [batch, in_depth, in_height, in_width, in_channels]. Alternatively, the format could be "NCDHW", the data storage order is: [batch, in_channels, in_depth, in_height, in_width].
ImplicitContainer<T> dilations
An optional list of `ints`. Defaults to `[1, 1, 1, 1, 1]`. 1-D tensor of length 5. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1.
object name
A name for the operation (optional).
object filters
Returns
object
A `Tensor`. Has the same type as `input`.

Tensor conv3d_transpose(IEnumerable<IGraphNodeBase> value, IGraphNodeBase filter, IEnumerable<int> output_shape, ValueTuple<int, object, object> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IEnumerable<IGraphNodeBase> value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object, object> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IGraphNodeBase output_shape, ValueTuple<int, object, object> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object, object> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IEnumerable<IGraphNodeBase> value, IGraphNodeBase filter, IEnumerable<int> output_shape, IEnumerable<int> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IEnumerable<IGraphNodeBase> value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IEnumerable<IGraphNodeBase> value, IGraphNodeBase filter, ValueTuple<object, IEnumerable<object>> output_shape, IEnumerable<int> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IEnumerable<IGraphNodeBase> value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<object, IEnumerable<object>> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IEnumerable<IGraphNodeBase> value, IGraphNodeBase filter, ValueTuple<object, IEnumerable<object>> output_shape, ValueTuple<int, object, object> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IEnumerable<IGraphNodeBase> value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<object, IEnumerable<object>> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object, object> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IEnumerable<IGraphNodeBase> value, IGraphNodeBase filter, ValueTuple<object> output_shape, IEnumerable<int> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IEnumerable<IGraphNodeBase> value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<object> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IGraphNodeBase output_shape, IEnumerable<int> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IGraphNodeBase value, IGraphNodeBase filter, ValueTuple<object> output_shape, ValueTuple<int, object, object> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<object> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object, object> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IGraphNodeBase value, IGraphNodeBase filter, ValueTuple<object> output_shape, IEnumerable<int> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<object> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IGraphNodeBase value, IGraphNodeBase filter, ValueTuple<object, IEnumerable<object>> output_shape, ValueTuple<int, object, object> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<object, IEnumerable<object>> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object, object> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IEnumerable<int> output_shape, ValueTuple<int, object, object> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object, object> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IGraphNodeBase value, IGraphNodeBase filter, ValueTuple<object, IEnumerable<object>> output_shape, IEnumerable<int> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<object, IEnumerable<object>> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IEnumerable<IGraphNodeBase> value, IGraphNodeBase filter, IGraphNodeBase output_shape, ValueTuple<int, object, object> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IEnumerable<IGraphNodeBase> value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object, object> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IEnumerable<IGraphNodeBase> value, IGraphNodeBase filter, IGraphNodeBase output_shape, IEnumerable<int> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IEnumerable<IGraphNodeBase> value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IGraphNodeBase output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IEnumerable<IGraphNodeBase> value, IGraphNodeBase filter, ValueTuple<object> output_shape, ValueTuple<int, object, object> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IEnumerable<IGraphNodeBase> value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
ValueTuple<object> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
ValueTuple<int, object, object> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

Tensor conv3d_transpose(IGraphNodeBase value, IGraphNodeBase filter, IEnumerable<int> output_shape, IEnumerable<int> strides, string padding, string data_format, string name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
IGraphNodeBase value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
IGraphNodeBase filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
IEnumerable<int> output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
IEnumerable<int> strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
string padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
string data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
string name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
Tensor
A `Tensor` with the same type as `value`.

object conv3d_transpose_dyn(object value, object filter, object output_shape, object strides, ImplicitContainer<T> padding, ImplicitContainer<T> data_format, object name, object input, object filters, object dilations)

The transpose of `conv3d`.

This operation is sometimes called "deconvolution" after [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf), but is really the transpose (gradient) of `conv3d` rather than an actual deconvolution.
Parameters
object value
A 5-D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.
object filter
A 5-D `Tensor` with the same type as `value` and shape `[depth, height, width, output_channels, in_channels]`. `filter`'s `in_channels` dimension must match that of `value`.
object output_shape
A 1-D `Tensor` representing the output shape of the deconvolution op.
object strides
A list of ints. The stride of the sliding window for each dimension of the input tensor.
ImplicitContainer<T> padding
A string, either `'VALID'` or `'SAME'`. The padding algorithm. See the "returns" section of tf.nn.convolution for details.
ImplicitContainer<T> data_format
A string, either `'NDHWC'` or `'NCDHW`' specifying the layout of the input and output tensors. Defaults to `'NDHWC'`.
object name
Optional name for the returned tensor.
object input
Alias of value.
object filters
Alias of filter.
object dilations
An int or list of `ints` that has length `1`, `3` or `5`, defaults to 1. The dilation factor for each dimension of`input`. If a single value is given it is replicated in the `D`, `H` and `W` dimension. By default the `N` and `C` dimensions are set to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions if a 5-d tensor must be 1.
Returns
object
A `Tensor` with the same type as `value`.

object convolution(IEnumerable<IGraphNodeBase> input, IGraphNodeBase filter, string padding, IEnumerable<int> strides, IEnumerable<int> dilation_rate, string name, string data_format, object filters, object dilations)

Computes sums of N-D convolutions (actually cross-correlation).

This also supports either output striding via the optional `strides` parameter or atrous convolution (also known as convolution with holes or dilated convolution, based on the French word "trous" meaning holes in English) via the optional `dilation_rate` parameter. Currently, however, output striding is not supported for atrous convolutions.

Specifically, in the case that `data_format` does not start with "NC", given a rank (N+2) `input` Tensor of shape

[num_batches, input_spatial_shape[0], ..., input_spatial_shape[N-1], num_input_channels],

a rank (N+2) `filter` Tensor of shape

[spatial_filter_shape[0], ..., spatial_filter_shape[N-1], num_input_channels, num_output_channels],

an optional `dilation_rate` tensor of shape [N] (defaulting to [1]*N) specifying the filter upsampling/input downsampling rate, and an optional list of N `strides` (defaulting [1]*N), this computes for each N-D spatial output position (x[0],..., x[N-1]):

``` output[b, x[0],..., x[N-1], k] = sum_{z[0],..., z[N-1], q} filter[z[0],..., z[N-1], q, k] * padded_input[b, x[0]*strides[0] + dilation_rate[0]*z[0], ..., x[N-1]*strides[N-1] + dilation_rate[N-1]*z[N-1], q] ``` where b is the index into the batch, k is the output channel number, q is the input channel number, and z is the N-D spatial offset within the filter. Here, `padded_input` is obtained by zero padding the input using an effective spatial filter shape of `(spatial_filter_shape-1) * dilation_rate + 1` and output striding `strides` as described in the [comment here](https://tensorflow.org/api_guides/python/nn#Convolution).

In the case that `data_format` does start with `"NC"`, the `input` and output (but not the `filter`) are simply transposed as follows:

convolution(input, data_format, **kwargs) = tf.transpose(convolution(tf.transpose(input, [0] + range(2,N+2) + [1]), **kwargs), [0, N+1] + range(1, N+1))

It is required that 1 <= N <= 3.
Parameters
IEnumerable<IGraphNodeBase> input
An (N+2)-D `Tensor` of type `T`, of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC".
IGraphNodeBase filter
An (N+2)-D `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
string padding
A string, either `"VALID"` or `"SAME"`. The padding algorithm.
IEnumerable<int> strides
Optional. Sequence of N ints >= 1. Specifies the output stride. Defaults to [1]*N. If any value of strides is > 1, then all values of dilation_rate must be 1.
IEnumerable<int> dilation_rate
Optional. Sequence of N ints >= 1. Specifies the filter upsampling/input downsampling rate. In the literature, the same parameter is sometimes called `input stride` or `dilation`. The effective filter size used for the convolution will be `spatial_filter_shape + (spatial_filter_shape - 1) * (rate - 1)`, obtained by inserting (dilation_rate[i]-1) zeros between consecutive elements of the original filter in each spatial dimension i. If any value of dilation_rate is > 1, then all values of strides must be 1.
string name
Optional name for the returned tensor.
string data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object filters
Alias of filter.
object dilations
Alias of dilation_rate.
Returns
object
A `Tensor` with the same type as `input` of shape

`[batch_size] + output_spatial_shape + [out_channels]`

if data_format is None or does not start with "NC", or

`[batch_size, out_channels] + output_spatial_shape`

if data_format starts with "NC", where `output_spatial_shape` depends on the value of `padding`.

If padding == "SAME": output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides[i])

If padding == "VALID": output_spatial_shape[i] = ceil((input_spatial_shape[i] - (spatial_filter_shape[i]-1) * dilation_rate[i]) / strides[i]).

object convolution(IEnumerable<IGraphNodeBase> input, IGraphNodeBase filter, string padding, IEnumerable<int> strides, int dilation_rate, string name, string data_format, object filters, object dilations)

Computes sums of N-D convolutions (actually cross-correlation).

This also supports either output striding via the optional `strides` parameter or atrous convolution (also known as convolution with holes or dilated convolution, based on the French word "trous" meaning holes in English) via the optional `dilation_rate` parameter. Currently, however, output striding is not supported for atrous convolutions.

Specifically, in the case that `data_format` does not start with "NC", given a rank (N+2) `input` Tensor of shape

[num_batches, input_spatial_shape[0], ..., input_spatial_shape[N-1], num_input_channels],

a rank (N+2) `filter` Tensor of shape

[spatial_filter_shape[0], ..., spatial_filter_shape[N-1], num_input_channels, num_output_channels],

an optional `dilation_rate` tensor of shape [N] (defaulting to [1]*N) specifying the filter upsampling/input downsampling rate, and an optional list of N `strides` (defaulting [1]*N), this computes for each N-D spatial output position (x[0],..., x[N-1]):

``` output[b, x[0],..., x[N-1], k] = sum_{z[0],..., z[N-1], q} filter[z[0],..., z[N-1], q, k] * padded_input[b, x[0]*strides[0] + dilation_rate[0]*z[0], ..., x[N-1]*strides[N-1] + dilation_rate[N-1]*z[N-1], q] ``` where b is the index into the batch, k is the output channel number, q is the input channel number, and z is the N-D spatial offset within the filter. Here, `padded_input` is obtained by zero padding the input using an effective spatial filter shape of `(spatial_filter_shape-1) * dilation_rate + 1` and output striding `strides` as described in the [comment here](https://tensorflow.org/api_guides/python/nn#Convolution).

In the case that `data_format` does start with `"NC"`, the `input` and output (but not the `filter`) are simply transposed as follows:

convolution(input, data_format, **kwargs) = tf.transpose(convolution(tf.transpose(input, [0] + range(2,N+2) + [1]), **kwargs), [0, N+1] + range(1, N+1))

It is required that 1 <= N <= 3.
Parameters
IEnumerable<IGraphNodeBase> input
An (N+2)-D `Tensor` of type `T`, of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC".
IGraphNodeBase filter
An (N+2)-D `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
string padding
A string, either `"VALID"` or `"SAME"`. The padding algorithm.
IEnumerable<int> strides
Optional. Sequence of N ints >= 1. Specifies the output stride. Defaults to [1]*N. If any value of strides is > 1, then all values of dilation_rate must be 1.
int dilation_rate
Optional. Sequence of N ints >= 1. Specifies the filter upsampling/input downsampling rate. In the literature, the same parameter is sometimes called `input stride` or `dilation`. The effective filter size used for the convolution will be `spatial_filter_shape + (spatial_filter_shape - 1) * (rate - 1)`, obtained by inserting (dilation_rate[i]-1) zeros between consecutive elements of the original filter in each spatial dimension i. If any value of dilation_rate is > 1, then all values of strides must be 1.
string name
Optional name for the returned tensor.
string data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object filters
Alias of filter.
object dilations
Alias of dilation_rate.
Returns
object
A `Tensor` with the same type as `input` of shape

`[batch_size] + output_spatial_shape + [out_channels]`

if data_format is None or does not start with "NC", or

`[batch_size, out_channels] + output_spatial_shape`

if data_format starts with "NC", where `output_spatial_shape` depends on the value of `padding`.

If padding == "SAME": output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides[i])

If padding == "VALID": output_spatial_shape[i] = ceil((input_spatial_shape[i] - (spatial_filter_shape[i]-1) * dilation_rate[i]) / strides[i]).

object convolution(IEnumerable<IGraphNodeBase> input, IGraphNodeBase filter, string padding, int strides, IEnumerable<int> dilation_rate, string name, string data_format, object filters, object dilations)

Computes sums of N-D convolutions (actually cross-correlation).

This also supports either output striding via the optional `strides` parameter or atrous convolution (also known as convolution with holes or dilated convolution, based on the French word "trous" meaning holes in English) via the optional `dilation_rate` parameter. Currently, however, output striding is not supported for atrous convolutions.

Specifically, in the case that `data_format` does not start with "NC", given a rank (N+2) `input` Tensor of shape

[num_batches, input_spatial_shape[0], ..., input_spatial_shape[N-1], num_input_channels],

a rank (N+2) `filter` Tensor of shape

[spatial_filter_shape[0], ..., spatial_filter_shape[N-1], num_input_channels, num_output_channels],

an optional `dilation_rate` tensor of shape [N] (defaulting to [1]*N) specifying the filter upsampling/input downsampling rate, and an optional list of N `strides` (defaulting [1]*N), this computes for each N-D spatial output position (x[0],..., x[N-1]):

``` output[b, x[0],..., x[N-1], k] = sum_{z[0],..., z[N-1], q} filter[z[0],..., z[N-1], q, k] * padded_input[b, x[0]*strides[0] + dilation_rate[0]*z[0], ..., x[N-1]*strides[N-1] + dilation_rate[N-1]*z[N-1], q] ``` where b is the index into the batch, k is the output channel number, q is the input channel number, and z is the N-D spatial offset within the filter. Here, `padded_input` is obtained by zero padding the input using an effective spatial filter shape of `(spatial_filter_shape-1) * dilation_rate + 1` and output striding `strides` as described in the [comment here](https://tensorflow.org/api_guides/python/nn#Convolution).

In the case that `data_format` does start with `"NC"`, the `input` and output (but not the `filter`) are simply transposed as follows:

convolution(input, data_format, **kwargs) = tf.transpose(convolution(tf.transpose(input, [0] + range(2,N+2) + [1]), **kwargs), [0, N+1] + range(1, N+1))

It is required that 1 <= N <= 3.
Parameters
IEnumerable<IGraphNodeBase> input
An (N+2)-D `Tensor` of type `T`, of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC".
IGraphNodeBase filter
An (N+2)-D `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
string padding
A string, either `"VALID"` or `"SAME"`. The padding algorithm.
int strides
Optional. Sequence of N ints >= 1. Specifies the output stride. Defaults to [1]*N. If any value of strides is > 1, then all values of dilation_rate must be 1.
IEnumerable<int> dilation_rate
Optional. Sequence of N ints >= 1. Specifies the filter upsampling/input downsampling rate. In the literature, the same parameter is sometimes called `input stride` or `dilation`. The effective filter size used for the convolution will be `spatial_filter_shape + (spatial_filter_shape - 1) * (rate - 1)`, obtained by inserting (dilation_rate[i]-1) zeros between consecutive elements of the original filter in each spatial dimension i. If any value of dilation_rate is > 1, then all values of strides must be 1.
string name
Optional name for the returned tensor.
string data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object filters
Alias of filter.
object dilations
Alias of dilation_rate.
Returns
object
A `Tensor` with the same type as `input` of shape

`[batch_size] + output_spatial_shape + [out_channels]`

if data_format is None or does not start with "NC", or

`[batch_size, out_channels] + output_spatial_shape`

if data_format starts with "NC", where `output_spatial_shape` depends on the value of `padding`.

If padding == "SAME": output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides[i])

If padding == "VALID": output_spatial_shape[i] = ceil((input_spatial_shape[i] - (spatial_filter_shape[i]-1) * dilation_rate[i]) / strides[i]).

object convolution(IEnumerable<IGraphNodeBase> input, IGraphNodeBase filter, string padding, IEnumerable<int> strides, ValueTuple<int, object> dilation_rate, string name, string data_format, object filters, object dilations)

Computes sums of N-D convolutions (actually cross-correlation).

This also supports either output striding via the optional `strides` parameter or atrous convolution (also known as convolution with holes or dilated convolution, based on the French word "trous" meaning holes in English) via the optional `dilation_rate` parameter. Currently, however, output striding is not supported for atrous convolutions.

Specifically, in the case that `data_format` does not start with "NC", given a rank (N+2) `input` Tensor of shape

[num_batches, input_spatial_shape[0], ..., input_spatial_shape[N-1], num_input_channels],

a rank (N+2) `filter` Tensor of shape

[spatial_filter_shape[0], ..., spatial_filter_shape[N-1], num_input_channels, num_output_channels],

an optional `dilation_rate` tensor of shape [N] (defaulting to [1]*N) specifying the filter upsampling/input downsampling rate, and an optional list of N `strides` (defaulting [1]*N), this computes for each N-D spatial output position (x[0],..., x[N-1]):

``` output[b, x[0],..., x[N-1], k] = sum_{z[0],..., z[N-1], q} filter[z[0],..., z[N-1], q, k] * padded_input[b, x[0]*strides[0] + dilation_rate[0]*z[0], ..., x[N-1]*strides[N-1] + dilation_rate[N-1]*z[N-1], q] ``` where b is the index into the batch, k is the output channel number, q is the input channel number, and z is the N-D spatial offset within the filter. Here, `padded_input` is obtained by zero padding the input using an effective spatial filter shape of `(spatial_filter_shape-1) * dilation_rate + 1` and output striding `strides` as described in the [comment here](https://tensorflow.org/api_guides/python/nn#Convolution).

In the case that `data_format` does start with `"NC"`, the `input` and output (but not the `filter`) are simply transposed as follows:

convolution(input, data_format, **kwargs) = tf.transpose(convolution(tf.transpose(input, [0] + range(2,N+2) + [1]), **kwargs), [0, N+1] + range(1, N+1))

It is required that 1 <= N <= 3.
Parameters
IEnumerable<IGraphNodeBase> input
An (N+2)-D `Tensor` of type `T`, of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC".
IGraphNodeBase filter
An (N+2)-D `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
string padding
A string, either `"VALID"` or `"SAME"`. The padding algorithm.
IEnumerable<int> strides
Optional. Sequence of N ints >= 1. Specifies the output stride. Defaults to [1]*N. If any value of strides is > 1, then all values of dilation_rate must be 1.
ValueTuple<int, object> dilation_rate
Optional. Sequence of N ints >= 1. Specifies the filter upsampling/input downsampling rate. In the literature, the same parameter is sometimes called `input stride` or `dilation`. The effective filter size used for the convolution will be `spatial_filter_shape + (spatial_filter_shape - 1) * (rate - 1)`, obtained by inserting (dilation_rate[i]-1) zeros between consecutive elements of the original filter in each spatial dimension i. If any value of dilation_rate is > 1, then all values of strides must be 1.
string name
Optional name for the returned tensor.
string data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object filters
Alias of filter.
object dilations
Alias of dilation_rate.
Returns
object
A `Tensor` with the same type as `input` of shape

`[batch_size] + output_spatial_shape + [out_channels]`

if data_format is None or does not start with "NC", or

`[batch_size, out_channels] + output_spatial_shape`

if data_format starts with "NC", where `output_spatial_shape` depends on the value of `padding`.

If padding == "SAME": output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides[i])

If padding == "VALID": output_spatial_shape[i] = ceil((input_spatial_shape[i] - (spatial_filter_shape[i]-1) * dilation_rate[i]) / strides[i]).

object convolution(IEnumerable<IGraphNodeBase> input, IGraphNodeBase filter, string padding, IEnumerable<int> strides, ValueTuple<object> dilation_rate, string name, string data_format, object filters, object dilations)

Computes sums of N-D convolutions (actually cross-correlation).

This also supports either output striding via the optional `strides` parameter or atrous convolution (also known as convolution with holes or dilated convolution, based on the French word "trous" meaning holes in English) via the optional `dilation_rate` parameter. Currently, however, output striding is not supported for atrous convolutions.

Specifically, in the case that `data_format` does not start with "NC", given a rank (N+2) `input` Tensor of shape

[num_batches, input_spatial_shape[0], ..., input_spatial_shape[N-1], num_input_channels],

a rank (N+2) `filter` Tensor of shape

[spatial_filter_shape[0], ..., spatial_filter_shape[N-1], num_input_channels, num_output_channels],

an optional `dilation_rate` tensor of shape [N] (defaulting to [1]*N) specifying the filter upsampling/input downsampling rate, and an optional list of N `strides` (defaulting [1]*N), this computes for each N-D spatial output position (x[0],..., x[N-1]):

``` output[b, x[0],..., x[N-1], k] = sum_{z[0],..., z[N-1], q} filter[z[0],..., z[N-1], q, k] * padded_input[b, x[0]*strides[0] + dilation_rate[0]*z[0], ..., x[N-1]*strides[N-1] + dilation_rate[N-1]*z[N-1], q] ``` where b is the index into the batch, k is the output channel number, q is the input channel number, and z is the N-D spatial offset within the filter. Here, `padded_input` is obtained by zero padding the input using an effective spatial filter shape of `(spatial_filter_shape-1) * dilation_rate + 1` and output striding `strides` as described in the [comment here](https://tensorflow.org/api_guides/python/nn#Convolution).

In the case that `data_format` does start with `"NC"`, the `input` and output (but not the `filter`) are simply transposed as follows:

convolution(input, data_format, **kwargs) = tf.transpose(convolution(tf.transpose(input, [0] + range(2,N+2) + [1]), **kwargs), [0, N+1] + range(1, N+1))

It is required that 1 <= N <= 3.
Parameters
IEnumerable<IGraphNodeBase> input
An (N+2)-D `Tensor` of type `T`, of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC".
IGraphNodeBase filter
An (N+2)-D `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
string padding
A string, either `"VALID"` or `"SAME"`. The padding algorithm.
IEnumerable<int> strides
Optional. Sequence of N ints >= 1. Specifies the output stride. Defaults to [1]*N. If any value of strides is > 1, then all values of dilation_rate must be 1.
ValueTuple<object> dilation_rate
Optional. Sequence of N ints >= 1. Specifies the filter upsampling/input downsampling rate. In the literature, the same parameter is sometimes called `input stride` or `dilation`. The effective filter size used for the convolution will be `spatial_filter_shape + (spatial_filter_shape - 1) * (rate - 1)`, obtained by inserting (dilation_rate[i]-1) zeros between consecutive elements of the original filter in each spatial dimension i. If any value of dilation_rate is > 1, then all values of strides must be 1.
string name
Optional name for the returned tensor.
string data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object filters
Alias of filter.
object dilations
Alias of dilation_rate.
Returns
object
A `Tensor` with the same type as `input` of shape

`[batch_size] + output_spatial_shape + [out_channels]`

if data_format is None or does not start with "NC", or

`[batch_size, out_channels] + output_spatial_shape`

if data_format starts with "NC", where `output_spatial_shape` depends on the value of `padding`.

If padding == "SAME": output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides[i])

If padding == "VALID": output_spatial_shape[i] = ceil((input_spatial_shape[i] - (spatial_filter_shape[i]-1) * dilation_rate[i]) / strides[i]).

object convolution(IEnumerable<IGraphNodeBase> input, ndarray filter, string padding, int strides, ValueTuple<int, object> dilation_rate, string name, string data_format, object filters, object dilations)

Computes sums of N-D convolutions (actually cross-correlation).

This also supports either output striding via the optional `strides` parameter or atrous convolution (also known as convolution with holes or dilated convolution, based on the French word "trous" meaning holes in English) via the optional `dilation_rate` parameter. Currently, however, output striding is not supported for atrous convolutions.

Specifically, in the case that `data_format` does not start with "NC", given a rank (N+2) `input` Tensor of shape

[num_batches, input_spatial_shape[0], ..., input_spatial_shape[N-1], num_input_channels],

a rank (N+2) `filter` Tensor of shape

[spatial_filter_shape[0], ..., spatial_filter_shape[N-1], num_input_channels, num_output_channels],

an optional `dilation_rate` tensor of shape [N] (defaulting to [1]*N) specifying the filter upsampling/input downsampling rate, and an optional list of N `strides` (defaulting [1]*N), this computes for each N-D spatial output position (x[0],..., x[N-1]):

``` output[b, x[0],..., x[N-1], k] = sum_{z[0],..., z[N-1], q} filter[z[0],..., z[N-1], q, k] * padded_input[b, x[0]*strides[0] + dilation_rate[0]*z[0], ..., x[N-1]*strides[N-1] + dilation_rate[N-1]*z[N-1], q] ``` where b is the index into the batch, k is the output channel number, q is the input channel number, and z is the N-D spatial offset within the filter. Here, `padded_input` is obtained by zero padding the input using an effective spatial filter shape of `(spatial_filter_shape-1) * dilation_rate + 1` and output striding `strides` as described in the [comment here](https://tensorflow.org/api_guides/python/nn#Convolution).

In the case that `data_format` does start with `"NC"`, the `input` and output (but not the `filter`) are simply transposed as follows:

convolution(input, data_format, **kwargs) = tf.transpose(convolution(tf.transpose(input, [0] + range(2,N+2) + [1]), **kwargs), [0, N+1] + range(1, N+1))

It is required that 1 <= N <= 3.
Parameters
IEnumerable<IGraphNodeBase> input
An (N+2)-D `Tensor` of type `T`, of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC".
ndarray filter
An (N+2)-D `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
string padding
A string, either `"VALID"` or `"SAME"`. The padding algorithm.
int strides
Optional. Sequence of N ints >= 1. Specifies the output stride. Defaults to [1]*N. If any value of strides is > 1, then all values of dilation_rate must be 1.
ValueTuple<int, object> dilation_rate
Optional. Sequence of N ints >= 1. Specifies the filter upsampling/input downsampling rate. In the literature, the same parameter is sometimes called `input stride` or `dilation`. The effective filter size used for the convolution will be `spatial_filter_shape + (spatial_filter_shape - 1) * (rate - 1)`, obtained by inserting (dilation_rate[i]-1) zeros between consecutive elements of the original filter in each spatial dimension i. If any value of dilation_rate is > 1, then all values of strides must be 1.
string name
Optional name for the returned tensor.
string data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object filters
Alias of filter.
object dilations
Alias of dilation_rate.
Returns
object
A `Tensor` with the same type as `input` of shape

`[batch_size] + output_spatial_shape + [out_channels]`

if data_format is None or does not start with "NC", or

`[batch_size, out_channels] + output_spatial_shape`

if data_format starts with "NC", where `output_spatial_shape` depends on the value of `padding`.

If padding == "SAME": output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides[i])

If padding == "VALID": output_spatial_shape[i] = ceil((input_spatial_shape[i] - (spatial_filter_shape[i]-1) * dilation_rate[i]) / strides[i]).

object convolution(IEnumerable<IGraphNodeBase> input, ndarray filter, string padding, int strides, int dilation_rate, string name, string data_format, object filters, object dilations)

Computes sums of N-D convolutions (actually cross-correlation).

This also supports either output striding via the optional `strides` parameter or atrous convolution (also known as convolution with holes or dilated convolution, based on the French word "trous" meaning holes in English) via the optional `dilation_rate` parameter. Currently, however, output striding is not supported for atrous convolutions.

Specifically, in the case that `data_format` does not start with "NC", given a rank (N+2) `input` Tensor of shape

[num_batches, input_spatial_shape[0], ..., input_spatial_shape[N-1], num_input_channels],

a rank (N+2) `filter` Tensor of shape

[spatial_filter_shape[0], ..., spatial_filter_shape[N-1], num_input_channels, num_output_channels],

an optional `dilation_rate` tensor of shape [N] (defaulting to [1]*N) specifying the filter upsampling/input downsampling rate, and an optional list of N `strides` (defaulting [1]*N), this computes for each N-D spatial output position (x[0],..., x[N-1]):

``` output[b, x[0],..., x[N-1], k] = sum_{z[0],..., z[N-1], q} filter[z[0],..., z[N-1], q, k] * padded_input[b, x[0]*strides[0] + dilation_rate[0]*z[0], ..., x[N-1]*strides[N-1] + dilation_rate[N-1]*z[N-1], q] ``` where b is the index into the batch, k is the output channel number, q is the input channel number, and z is the N-D spatial offset within the filter. Here, `padded_input` is obtained by zero padding the input using an effective spatial filter shape of `(spatial_filter_shape-1) * dilation_rate + 1` and output striding `strides` as described in the [comment here](https://tensorflow.org/api_guides/python/nn#Convolution).

In the case that `data_format` does start with `"NC"`, the `input` and output (but not the `filter`) are simply transposed as follows:

convolution(input, data_format, **kwargs) = tf.transpose(convolution(tf.transpose(input, [0] + range(2,N+2) + [1]), **kwargs), [0, N+1] + range(1, N+1))

It is required that 1 <= N <= 3.
Parameters
IEnumerable<IGraphNodeBase> input
An (N+2)-D `Tensor` of type `T`, of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC".
ndarray filter
An (N+2)-D `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
string padding
A string, either `"VALID"` or `"SAME"`. The padding algorithm.
int strides
Optional. Sequence of N ints >= 1. Specifies the output stride. Defaults to [1]*N. If any value of strides is > 1, then all values of dilation_rate must be 1.
int dilation_rate
Optional. Sequence of N ints >= 1. Specifies the filter upsampling/input downsampling rate. In the literature, the same parameter is sometimes called `input stride` or `dilation`. The effective filter size used for the convolution will be `spatial_filter_shape + (spatial_filter_shape - 1) * (rate - 1)`, obtained by inserting (dilation_rate[i]-1) zeros between consecutive elements of the original filter in each spatial dimension i. If any value of dilation_rate is > 1, then all values of strides must be 1.
string name
Optional name for the returned tensor.
string data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object filters
Alias of filter.
object dilations
Alias of dilation_rate.
Returns
object
A `Tensor` with the same type as `input` of shape

`[batch_size] + output_spatial_shape + [out_channels]`

if data_format is None or does not start with "NC", or

`[batch_size, out_channels] + output_spatial_shape`

if data_format starts with "NC", where `output_spatial_shape` depends on the value of `padding`.

If padding == "SAME": output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides[i])

If padding == "VALID": output_spatial_shape[i] = ceil((input_spatial_shape[i] - (spatial_filter_shape[i]-1) * dilation_rate[i]) / strides[i]).

object convolution(IGraphNodeBase input, IGraphNodeBase filter, string padding, int strides, int dilation_rate, string name, string data_format, object filters, object dilations)

Computes sums of N-D convolutions (actually cross-correlation).

This also supports either output striding via the optional `strides` parameter or atrous convolution (also known as convolution with holes or dilated convolution, based on the French word "trous" meaning holes in English) via the optional `dilation_rate` parameter. Currently, however, output striding is not supported for atrous convolutions.

Specifically, in the case that `data_format` does not start with "NC", given a rank (N+2) `input` Tensor of shape

[num_batches, input_spatial_shape[0], ..., input_spatial_shape[N-1], num_input_channels],

a rank (N+2) `filter` Tensor of shape

[spatial_filter_shape[0], ..., spatial_filter_shape[N-1], num_input_channels, num_output_channels],

an optional `dilation_rate` tensor of shape [N] (defaulting to [1]*N) specifying the filter upsampling/input downsampling rate, and an optional list of N `strides` (defaulting [1]*N), this computes for each N-D spatial output position (x[0],..., x[N-1]):

``` output[b, x[0],..., x[N-1], k] = sum_{z[0],..., z[N-1], q} filter[z[0],..., z[N-1], q, k] * padded_input[b, x[0]*strides[0] + dilation_rate[0]*z[0], ..., x[N-1]*strides[N-1] + dilation_rate[N-1]*z[N-1], q] ``` where b is the index into the batch, k is the output channel number, q is the input channel number, and z is the N-D spatial offset within the filter. Here, `padded_input` is obtained by zero padding the input using an effective spatial filter shape of `(spatial_filter_shape-1) * dilation_rate + 1` and output striding `strides` as described in the [comment here](https://tensorflow.org/api_guides/python/nn#Convolution).

In the case that `data_format` does start with `"NC"`, the `input` and output (but not the `filter`) are simply transposed as follows:

convolution(input, data_format, **kwargs) = tf.transpose(convolution(tf.transpose(input, [0] + range(2,N+2) + [1]), **kwargs), [0, N+1] + range(1, N+1))

It is required that 1 <= N <= 3.
Parameters
IGraphNodeBase input
An (N+2)-D `Tensor` of type `T`, of shape `[batch_size] + input_spatial_shape + [in_channels]` if data_format does not start with "NC" (default), or `[batch_size, in_channels] + input_spatial_shape` if data_format starts with "NC".
IGraphNodeBase filter
An (N+2)-D `Tensor` with the same type as `input` and shape `spatial_filter_shape + [in_channels, out_channels]`.
string padding
A string, either `"VALID"` or `"SAME"`. The padding algorithm.
int strides
Optional. Sequence of N ints >= 1. Specifies the output stride. Defaults to [1]*N. If any value of strides is > 1, then all values of dilation_rate must be 1.
int dilation_rate
Optional. Sequence of N ints >= 1. Specifies the filter upsampling/input downsampling rate. In the literature, the same parameter is sometimes called `input stride` or `dilation`. The effective filter size used for the convolution will be `spatial_filter_shape + (spatial_filter_shape - 1) * (rate - 1)`, obtained by inserting (dilation_rate[i]-1) zeros between consecutive elements of the original filter in each spatial dimension i. If any value of dilation_rate is > 1, then all values of strides must be 1.
string name
Optional name for the returned tensor.
string data_format
A string or None. Specifies whether the channel dimension of the `input` and output is the last dimension (default, or if `data_format` does not start with "NC"), or the second dimension (if `data_format` starts with "NC"). For N=1, the valid values are "NWC" (default) and "NCW". For N=2, the valid values are "NHWC" (default) and "NCHW". For N=3, the valid values are "NDHWC" (default) and "NCDHW".
object filters
Alias of filter.
object dilations
Alias of dilation_rate.
Returns
object
A `Tensor` with the same type as `input` of shape

`[batch_size] + output_spatial_shape + [out_channels]`

if data_format is None or does not start with "NC", or

`[batch_size, out_channels] + output_spatial_shape`

if data_format starts with "NC", where `output_spatial_shape` depends on the value of `padding`.

If padding == "SAME": output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides[i])

If padding == "VALID": output_spatial_shape[i] = ceil((input_spatial_shape[i] - (spatial_filter_shape[i]-1) * dilation_rate[i]) / strides[i]).

object convolution(IGraphNodeBase input, IGraphNodeBase filter, string padding, int strides, ValueTuple<object> dilation_rate, string name, string data_format, object filters, object dilations)

Computes sums of N-D convolutions (actually cross-correlation).

This also supports either output striding via the optional `strides` parameter or atrous convolution (also known as convolution with holes or dilated convolution, based on the French word "trous" meaning holes in English) via the optional `dilation_rate` parameter. Currently, however, output striding is not supported for atrous convolutions.

Specifically, in the case that `data_format` does not start with "NC", given a rank (N+2) `input` Tensor of shape

[num_batches, input_spatial_shape[0], ..., input_spatial_shape[N-1], num_input_channels],

a rank (N+2) `filter` Tensor of shape

[spatial_filter_shape[0], ..., spatial_filter_shape[N-1], num_input_channels, num_output_channels],

an optional `dilation_rate` tensor of shape [N] (defaulting to [1]*N) specifying the filter upsampling/input downsampling rate, and an optional list of N `strides` (defaulting [1]*N), this computes for each N-D spatial output position (x[0],..., x[N-1]):

``` output[b, x[0],..., x[N-1], k] = sum_{z[0],..., z[N-1], q} filter[z[0],..., z[N-1], q, k] * padded_input[b, x[0]*strides[0] + dilation_rate[