Type tf.nn
Namespace tensorflow
Methods
 all_candidate_sampler
 all_candidate_sampler_dyn
 atrous_conv2d
 atrous_conv2d_dyn
 atrous_conv2d_transpose
 atrous_conv2d_transpose
 atrous_conv2d_transpose
 atrous_conv2d_transpose
 atrous_conv2d_transpose
 atrous_conv2d_transpose
 atrous_conv2d_transpose
 atrous_conv2d_transpose
 atrous_conv2d_transpose_dyn
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool
 avg_pool_dyn
 avg_pool_v2
 avg_pool_v2
 avg_pool_v2_dyn
 avg_pool1d
 avg_pool1d
 avg_pool1d_dyn
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 avg_pool3d
 batch_norm_with_global_normalization
 batch_norm_with_global_normalization_dyn
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization
 batch_normalization_dyn
 bias_add
 bias_add
 bias_add
 bias_add
 bias_add
 bias_add
 bias_add
 bias_add
 bias_add
 bias_add
 bias_add
 bias_add
 bias_add
 bias_add
 bias_add_dyn
 bidirectional_dynamic_rnn
 collapse_repeated
 collapse_repeated
 collapse_repeated
 collapse_repeated
 collapse_repeated_dyn
 compute_accidental_hits
 compute_accidental_hits
 compute_accidental_hits
 compute_accidental_hits_dyn
 compute_average_loss
 compute_average_loss
 compute_average_loss_dyn
 conv_transpose
 conv_transpose
 conv_transpose
 conv_transpose
 conv_transpose
 conv_transpose
 conv_transpose
 conv_transpose
 conv_transpose_dyn
 conv1d
 conv1d
 conv1d
 conv1d
 conv1d_dyn
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose
 conv1d_transpose_dyn
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d
 conv2d_backprop_filter
 conv2d_backprop_filter
 conv2d_backprop_filter
 conv2d_backprop_filter
 conv2d_backprop_filter_dyn
 conv2d_backprop_input
 conv2d_backprop_input
 conv2d_backprop_input
 conv2d_backprop_input
 conv2d_backprop_input
 conv2d_backprop_input
 conv2d_backprop_input
 conv2d_backprop_input
 conv2d_backprop_input
 conv2d_backprop_input_dyn
 conv2d_dyn
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose
 conv2d_transpose_dyn
 conv3d
 conv3d_backprop_filter
 conv3d_backprop_filter_dyn
 conv3d_dyn
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose
 conv3d_transpose_dyn
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution
 convolution_dyn
 crelu
 crelu
 crelu_dyn
 ctc_beam_search_decoder
 ctc_beam_search_decoder
 ctc_beam_search_decoder
 ctc_beam_search_decoder
 ctc_beam_search_decoder
 ctc_beam_search_decoder
 ctc_beam_search_decoder
 ctc_beam_search_decoder
 ctc_beam_search_decoder_dyn
 ctc_beam_search_decoder_v2
 ctc_beam_search_decoder_v2_dyn
 ctc_greedy_decoder
 ctc_greedy_decoder
 ctc_greedy_decoder
 ctc_greedy_decoder
 ctc_greedy_decoder
 ctc_greedy_decoder
 ctc_greedy_decoder
 ctc_greedy_decoder
 ctc_greedy_decoder_dyn
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss
 ctc_loss_dyn
 ctc_loss_v2
 ctc_loss_v2
 ctc_loss_v2_dyn
 ctc_unique_labels
 ctc_unique_labels
 ctc_unique_labels_dyn
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d
 depthwise_conv2d_backprop_filter
 depthwise_conv2d_backprop_filter_dyn
 depthwise_conv2d_backprop_input
 depthwise_conv2d_backprop_input_dyn
 depthwise_conv2d_dyn
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native
 depthwise_conv2d_native_dyn
 dilation2d
 dilation2d_dyn
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout
 dropout_dyn
 dynamic_rnn
 dynamic_rnn
 dynamic_rnn
 dynamic_rnn
 dynamic_rnn
 dynamic_rnn
 dynamic_rnn
 dynamic_rnn
 elu
 elu_dyn
 embedding_lookup
 embedding_lookup
 embedding_lookup
 embedding_lookup
 embedding_lookup
 embedding_lookup
 embedding_lookup
 embedding_lookup
 embedding_lookup
 embedding_lookup
 embedding_lookup_dyn
 embedding_lookup_sparse
 embedding_lookup_sparse
 embedding_lookup_sparse
 embedding_lookup_sparse
 embedding_lookup_sparse
 embedding_lookup_sparse
 embedding_lookup_sparse
 embedding_lookup_sparse
 embedding_lookup_sparse_dyn
 erosion2d
 erosion2d_dyn
 fixed_unigram_candidate_sampler
 fixed_unigram_candidate_sampler_dyn
 fractional_avg_pool
 fractional_max_pool
 fused_batch_norm
 fused_batch_norm
 fused_batch_norm_dyn
 l2_loss
 l2_loss_dyn
 l2_normalize
 l2_normalize_dyn
 learned_unigram_candidate_sampler
 learned_unigram_candidate_sampler_dyn
 log_poisson_loss
 log_poisson_loss
 log_poisson_loss
 log_poisson_loss
 log_poisson_loss_dyn
 log_softmax
 log_softmax
 log_softmax
 log_softmax
 log_softmax
 log_softmax
 log_softmax
 log_softmax_dyn
 log_uniform_candidate_sampler
 log_uniform_candidate_sampler_dyn
 lrn
 lrn
 lrn
 lrn
 lrn_dyn
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool
 max_pool_dyn
 max_pool_v2
 max_pool_v2
 max_pool_v2_dyn
 max_pool_with_argmax
 max_pool_with_argmax_dyn
 max_pool1d
 max_pool1d
 max_pool1d_dyn
 max_pool2d
 max_pool2d_dyn
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 max_pool3d
 moments
 moments_dyn
 nce_loss
 nce_loss
 nce_loss_dyn
 normalize_moments
 normalize_moments_dyn
 pool
 pool
 pool
 pool
 pool
 pool
 pool
 pool
 pool
 pool_dyn
 raw_rnn
 raw_rnn
 raw_rnn_dyn
 relu
 relu
 relu_dyn
 relu_layer
 relu_layer_dyn
 relu6
 safe_embedding_lookup_sparse_dyn
 sampled_softmax_loss
 sampled_softmax_loss
 sampled_softmax_loss
 sampled_softmax_loss
 sampled_softmax_loss_dyn
 scale_regularization_loss
 scale_regularization_loss
 scale_regularization_loss_dyn
 selu
 selu_dyn
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d
 separable_conv2d_dyn
 sigmoid_cross_entropy_with_logits
 sigmoid_cross_entropy_with_logits
 sigmoid_cross_entropy_with_logits_dyn
 softmax
 softmax
 softmax
 softmax
 softmax
 softmax
 softmax_cross_entropy_with_logits
 softmax_cross_entropy_with_logits
 softmax_cross_entropy_with_logits
 softmax_cross_entropy_with_logits
 softmax_cross_entropy_with_logits
 softmax_cross_entropy_with_logits
 softmax_cross_entropy_with_logits
 softmax_cross_entropy_with_logits
 softmax_cross_entropy_with_logits
 softmax_cross_entropy_with_logits
 softmax_cross_entropy_with_logits_dyn
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2
 softmax_cross_entropy_with_logits_v2_dyn
 softmax_dyn
 softplus
 softplus_dyn
 softsign
 softsign_dyn
 sparse_softmax_cross_entropy_with_logits
 sparse_softmax_cross_entropy_with_logits
 sparse_softmax_cross_entropy_with_logits
 sparse_softmax_cross_entropy_with_logits
 sparse_softmax_cross_entropy_with_logits
 sparse_softmax_cross_entropy_with_logits
 sparse_softmax_cross_entropy_with_logits
 sparse_softmax_cross_entropy_with_logits
 sparse_softmax_cross_entropy_with_logits
 sparse_softmax_cross_entropy_with_logits
 sparse_softmax_cross_entropy_with_logits
 sparse_softmax_cross_entropy_with_logits
 sparse_softmax_cross_entropy_with_logits_dyn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn
 static_bidirectional_rnn_dyn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn
 static_rnn_dyn
 static_state_saving_rnn
 static_state_saving_rnn
 static_state_saving_rnn_dyn
 sufficient_statistics
 sufficient_statistics_dyn
 swish
 swish_dyn
 top_k
 top_k
 top_k_dyn
 uniform_candidate_sampler
 uniform_candidate_sampler_dyn
 weighted_cross_entropy_with_logits
 weighted_cross_entropy_with_logits_dyn
 weighted_moments
 weighted_moments
 weighted_moments
 weighted_moments
 weighted_moments_dyn
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch
 with_space_to_batch_dyn
 xw_plus_b
 xw_plus_b
 xw_plus_b
 xw_plus_b_dyn
 zero_fraction
 zero_fraction
 zero_fraction
 zero_fraction_dyn
Properties
 all_candidate_sampler_fn
 atrous_conv2d_fn
 atrous_conv2d_transpose_fn
 avg_pool_fn
 avg_pool_v2_fn
 avg_pool1d_fn
 avg_pool3d_fn
 batch_norm_with_global_normalization_fn
 batch_normalization_fn
 bias_add_fn
 bidirectional_dynamic_rnn_fn
 collapse_repeated_fn
 compute_accidental_hits_fn
 compute_average_loss_fn
 conv_transpose_fn
 conv1d_fn
 conv1d_transpose_fn
 conv2d_backprop_filter_fn
 conv2d_backprop_input_fn
 conv2d_fn
 conv2d_transpose_fn
 conv3d_backprop_filter_fn_
 conv3d_fn
 conv3d_transpose_fn
 convolution_fn
 crelu_fn
 ctc_beam_search_decoder_fn
 ctc_beam_search_decoder_v2_fn
 ctc_greedy_decoder_fn
 ctc_loss_fn
 ctc_loss_v2_fn
 ctc_unique_labels_fn
 depthwise_conv2d_backprop_filter_fn
 depthwise_conv2d_backprop_input_fn
 depthwise_conv2d_fn
 depthwise_conv2d_native_fn
 dilation2d_fn
 dropout_fn
 dynamic_rnn_fn
 elu_fn
 embedding_lookup_fn
 embedding_lookup_sparse_fn
 erosion2d_fn
 fixed_unigram_candidate_sampler_fn
 fractional_avg_pool_fn
 fractional_max_pool_fn
 fused_batch_norm_fn
 in_top_k_fn
 l2_loss_fn
 l2_normalize_fn
 leaky_relu_fn
 learned_unigram_candidate_sampler_fn
 log_poisson_loss_fn
 log_softmax_fn
 log_uniform_candidate_sampler_fn
 lrn_fn
 max_pool_fn
 max_pool_v2_fn
 max_pool_with_argmax_fn
 max_pool1d_fn
 max_pool2d_fn
 max_pool3d_fn
 moments_fn
 nce_loss_fn
 normalize_moments_fn
 pool_fn
 raw_rnn_fn
 relu_fn
 relu_layer_fn
 relu6_fn
 safe_embedding_lookup_sparse_fn
 sampled_softmax_loss_fn
 scale_regularization_loss_fn
 selu_fn
 separable_conv2d_fn
 sigmoid_cross_entropy_with_logits_fn
 softmax_cross_entropy_with_logits_fn
 softmax_cross_entropy_with_logits_v2_fn
 softmax_fn
 softplus_fn
 softsign_fn
 sparse_softmax_cross_entropy_with_logits_fn
 static_bidirectional_rnn_fn
 static_rnn_fn
 static_state_saving_rnn_fn
 sufficient_statistics_fn
 swish_fn
 top_k_fn
 uniform_candidate_sampler_fn
 weighted_cross_entropy_with_logits_fn
 weighted_moments_fn
 with_space_to_batch_fn
 xw_plus_b_fn
 zero_fraction_fn
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 operationspecific 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 operationspecific 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 1D, 2D, or 3D atrous convolution. Computes a 2D atrous convolution, also known as convolution with holes or
dilated convolution, given 4D `value` and `filters` tensors. If the `rate`
parameter is equal to one, it performs regular 2D 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 [MultiScale 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 MaxPooling Convolutional Neural
Networks](http://arxiv.org/abs/1302.1700).
Atrous convolution is also closely related to the socalled noble identities
in multirate 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 4D `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 4D `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 1D, 2D, or 3D atrous convolution. Computes a 2D atrous convolution, also known as convolution with holes or
dilated convolution, given 4D `value` and `filters` tensors. If the `rate`
parameter is equal to one, it performs regular 2D 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 [MultiScale 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 MaxPooling Convolutional Neural
Networks](http://arxiv.org/abs/1302.1700).
Atrous convolution is also closely related to the socalled noble identities
in multirate 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 4D `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 4D `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 4D `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 4D `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 1D `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 4D `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 4D `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 1D `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 4D `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 4D `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 1D `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 4D `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 4D `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 1D `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 4D `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 4D `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 1D `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 4D `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 4D `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 1D `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 4D `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 4D `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 1D `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 4D `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 4D `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 1D `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 4D `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 4D `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 1D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 4D `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 3D `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 3D `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 3D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 5D `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 batchnormalized `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 batchnormalized `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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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
fullyconnected 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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 1D.
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 1D `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 batchmajor, so by default this function accepts input and emits output in batchmajor 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 operationspecific 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 operationspecific 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 operationspecific 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 operationspecific 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 perexample losses with sample_weights and computes their average. Usage with distribution strategy and custom training loop:
Parameters

IGraphNodeBase
per_example_loss  Perexample 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 perexample losses with sample_weights and computes their average. Usage with distribution strategy and custom training loop:
Parameters

IEnumerable<int>
per_example_loss  Perexample 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 perexample losses with sample_weights and computes their average. Usage with distribution strategy and custom training loop:
Parameters

object
per_example_loss  Perexample 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 1D `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 k1 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 1D `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 k1 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 1D `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 k1 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 1D `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 k1 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 1D `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 k1 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 1D `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 k1 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 1D `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 k1 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 1D `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 k1 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 1D `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 k1 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 1D convolution given 3D 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 k1 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 1D convolution given 3D 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 k1 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 1D convolution given 3D 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 k1 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 1D convolution given 3D 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 k1 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 1D convolution given 3D 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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 3D `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 3D `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 1D `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 k1 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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`. 4D 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 4D `[filter_height, filter_width, in_channels, out_channels]` tensor.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `input`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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`. 4D 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 4D `[filter_height, filter_width, in_channels, out_channels]` tensor.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `input`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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`. 4D 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 4D `[filter_height, filter_width, in_channels, out_channels]` tensor.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `input`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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`. 4D 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 4D `[filter_height, filter_width, in_channels, out_channels]` tensor.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `input`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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`. 4D 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 4D `[filter_height, filter_width, in_channels, out_channels]` tensor.

object
out_backprop  A `Tensor`. Must have the same type as `input`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 4D `[batch, height, width, channels]` tensor.

IGraphNodeBase
filter  A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4D with shape `[filter_height, filter_width, in_channels, out_channels]`.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `filter`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 4D `[batch, height, width, channels]` tensor.

IGraphNodeBase
filter  A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4D with shape `[filter_height, filter_width, in_channels, out_channels]`.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `filter`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 4D `[batch, height, width, channels]` tensor.

IGraphNodeBase
filter  A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4D with shape `[filter_height, filter_width, in_channels, out_channels]`.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `filter`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 4D `[batch, height, width, channels]` tensor.

IGraphNodeBase
filter  A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4D with shape `[filter_height, filter_width, in_channels, out_channels]`.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `filter`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 4D `[batch, height, width, channels]` tensor.

IGraphNodeBase
filter  A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4D with shape `[filter_height, filter_width, in_channels, out_channels]`.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `filter`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 4D `[batch, height, width, channels]` tensor.

IGraphNodeBase
filter  A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4D with shape `[filter_height, filter_width, in_channels, out_channels]`.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `filter`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 4D `[batch, height, width, channels]` tensor.

IGraphNodeBase
filter  A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4D with shape `[filter_height, filter_width, in_channels, out_channels]`.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `filter`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 4D `[batch, height, width, channels]` tensor.

IGraphNodeBase
filter  A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4D with shape `[filter_height, filter_width, in_channels, out_channels]`.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `filter`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 4D `[batch, height, width, channels]` tensor.

IGraphNodeBase
filter  A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4D with shape `[filter_height, filter_width, in_channels, out_channels]`.

IGraphNodeBase
out_backprop  A `Tensor`. Must have the same type as `filter`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 4D `[batch, height, width, channels]` tensor.

object
filter  A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 4D with shape `[filter_height, filter_width, in_channels, out_channels]`.

object
out_backprop  A `Tensor`. Must have the same type as `filter`. 4D 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]`. 1D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 2D convolution given 4D `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 2D 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, rightmultiplies 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 4D 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 4D 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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 4D `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 4D `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 1D `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 k1 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 4d 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 3D convolution given 5D `input` and `filter` tensors. In signal processing, crosscorrelation is a measure of similarity of
two waveforms as a function of a timelag applied to one of them. This
is also known as a sliding dot product or sliding innerproduct. Our Conv3D implements a form of crosscorrelation.
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`. 1D 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]`. 1D tensor of length 5. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 3D 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 5D `[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`. 1D 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]`. 1D tensor of length 5. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 3D 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 5D `[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`. 1D 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]`. 1D tensor of length 5. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 3D convolution given 5D `input` and `filter` tensors. In signal processing, crosscorrelation is a measure of similarity of
two waveforms as a function of a timelag applied to one of them. This
is also known as a sliding dot product or sliding innerproduct. Our Conv3D implements a form of crosscorrelation.
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`. 1D 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]`. 1D tensor of length 5. The dilation factor for each dimension of `input`. If set to k > 1, there will be k1 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

IGraphNodeBase
filter  A 5D `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 1D `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 k1 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 5d 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 5D `Tensor` of type `float` and shape `[batch, depth, height, width, in_channels]`.

object
filter  A 5D `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 1D `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 k1 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 5d 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 ND convolutions (actually crosscorrelation). 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[N1],
num_input_channels], a rank (N+2) `filter` Tensor of shape [spatial_filter_shape[0],
...,
spatial_filter_shape[N1],
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 ND spatial output
position (x[0],..., x[N1]): ```
output[b, x[0],..., x[N1], k] =
sum_{z[0],..., z[N1], q}
filter[z[0],..., z[N1], q, k] *
padded_input[b,
x[0]*strides[0] + dilation_rate[0]*z[0],
...,
x[N1]*strides[N1] + dilation_rate[N1]*z[N1],
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 ND spatial offset within the filter. Here,
`padded_input` is obtained by zero padding the input using an effective
spatial filter shape of `(spatial_filter_shape1) * 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 ND convolutions (actually crosscorrelation). 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[N1],
num_input_channels], a rank (N+2) `filter` Tensor of shape [spatial_filter_shape[0],
...,
spatial_filter_shape[N1],
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 ND spatial output
position (x[0],..., x[N1]): ```
output[b, x[0],..., x[N1], k] =
sum_{z[0],..., z[N1], q}
filter[z[0],..., z[N1], q, k] *
padded_input[b,
x[0]*strides[0] + dilation_rate[0]*z[0],
...,
x[N1]*strides[N1] + dilation_rate[N1]*z[N1],
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 ND spatial offset within the filter. Here,
`padded_input` is obtained by zero padding the input using an effective
spatial filter shape of `(spatial_filter_shape1) * 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 ND convolutions (actually crosscorrelation). 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[N1],
num_input_channels], a rank (N+2) `filter` Tensor of shape [spatial_filter_shape[0],
...,
spatial_filter_shape[N1],
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 ND spatial output
position (x[0],..., x[N1]): ```
output[b, x[0],..., x[N1], k] =
sum_{z[0],..., z[N1], q}
filter[z[0],..., z[N1], q, k] *
padded_input[b,
x[0]*strides[0] + dilation_rate[0]*z[0],
...,
x[N1]*strides[N1] + dilation_rate[N1]*z[N1],
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 ND spatial offset within the filter. Here,
`padded_input` is obtained by zero padding the input using an effective
spatial filter shape of `(spatial_filter_shape1) * 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 ND convolutions (actually crosscorrelation). 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[N1],
num_input_channels], a rank (N+2) `filter` Tensor of shape [spatial_filter_shape[0],
...,
spatial_filter_shape[N1],
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 ND spatial output
position (x[0],..., x[N1]): ```
output[b, x[0],..., x[N1], k] =
sum_{z[0],..., z[N1], q}
filter[z[0],..., z[N1], q, k] *
padded_input[b,
x[0]*strides[0] + dilation_rate[0]*z[0],
...,
x[N1]*strides[N1] + dilation_rate[N1]*z[N1],
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 ND spatial offset within the filter. Here,
`padded_input` is obtained by zero padding the input using an effective
spatial filter shape of `(spatial_filter_shape1) * 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 ND convolutions (actually crosscorrelation). 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[N1],
num_input_channels], a rank (N+2) `filter` Tensor of shape [spatial_filter_shape[0],
...,
spatial_filter_shape[N1],
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 ND spatial output
position (x[0],..., x[N1]): ```
output[b, x[0],..., x[N1], k] =
sum_{z[0],..., z[N1], q}
filter[z[0],..., z[N1], q, k] *
padded_input[b,
x[0]*strides[0] + dilation_rate[0]*z[0],
...,
x[N1]*strides[N1] + dilation_rate[N1]*z[N1],
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 ND spatial offset within the filter. Here,
`padded_input` is obtained by zero padding the input using an effective
spatial filter shape of `(spatial_filter_shape1) * 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 ND convolutions (actually crosscorrelation). 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[N1],
num_input_channels], a rank (N+2) `filter` Tensor of shape [spatial_filter_shape[0],
...,
spatial_filter_shape[N1],
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 ND spatial output
position (x[0],..., x[N1]): ```
output[b, x[0],..., x[N1], k] =
sum_{z[0],..., z[N1], q}
filter[z[0],..., z[N1], q, k] *
padded_input[b,
x[0]*strides[0] + dilation_rate[0]*z[0],
...,
x[N1]*strides[N1] + dilation_rate[N1]*z[N1],
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 ND spatial offset within the filter. Here,
`padded_input` is obtained by zero padding the input using an effective
spatial filter shape of `(spatial_filter_shape1) * 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 ND convolutions (actually crosscorrelation). 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[N1],
num_input_channels], a rank (N+2) `filter` Tensor of shape [spatial_filter_shape[0],
...,
spatial_filter_shape[N1],
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 ND spatial output
position (x[0],..., x[N1]): ```
output[b, x[0],..., x[N1], k] =
sum_{z[0],..., z[N1], q}
filter[z[0],..., z[N1], q, k] *
padded_input[b,
x[0]*strides[0] + dilation_rate[0]*z[0],
...,
x[N1]*strides[N1] + dilation_rate[N1]*z[N1],
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 ND spatial offset within the filter. Here,
`padded_input` is obtained by zero padding the input using an effective
spatial filter shape of `(spatial_filter_shape1) * 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 ND convolutions (actually crosscorrelation). 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[N1],
num_input_channels], a rank (N+2) `filter` Tensor of shape [spatial_filter_shape[0],
...,
spatial_filter_shape[N1],
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 ND spatial output
position (x[0],..., x[N1]): ```
output[b, x[0],..., x[N1], k] =
sum_{z[0],..., z[N1], q}
filter[z[0],..., z[N1], q, k] *
padded_input[b,
x[0]*strides[0] + dilation_rate[0]*z[0],
...,
x[N1]*strides[N1] + dilation_rate[N1]*z[N1],
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 ND spatial offset within the filter. Here,
`padded_input` is obtained by zero padding the input using an effective
spatial filter shape of `(spatial_filter_shape1) * 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 ND convolutions (actually crosscorrelation). 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[N1],
num_input_channels], a rank (N+2) `filter` Tensor of shape [spatial_filter_shape[0],
...,
spatial_filter_shape[N1],
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 ND spatial output
position (x[0],..., x[N1]): ```
output[b, x[0],..., x[N1], k] =
sum_{z[0],..., z[N1], q}
filter[z[0],..., z[N1], q, k] *
padded_input[b,
x[0]*strides[0] + dilation_rate[