static public TorchTensor AdaptiveAvgPool2D(TorchTensor x, long[] kernelSize) { using (var d = Modules.AdaptiveAvgPool2D(kernelSize)) { return(d.Forward(x)); } }
/// <summary> /// Reverses the PixelShuffle operation by rearranging elements in a tensor of shape (*, C * r^2, H, W) to a tensor of shape(*, C, H * r, W * r), where r is an downscale factor. /// This is useful for implementing efficient sub-pixel convolution with a stride of 1/r. /// </summary> /// <param name="x">Input tensor</param> /// <param name="downscaleFactor">Factor to increase spatial resolution by</param> /// <returns></returns> /// <returns></returns> static public TorchTensor PixelUnshuffle(TorchTensor x, long downscaleFactor) { using (var d = Modules.PixelUnshuffle(downscaleFactor)) { return(d.forward(x)); } }
/// <summary> /// A simple lookup table that stores embeddings of a fixed dictionary and size. /// This module is often used to store word embeddings and retrieve them using indices. The input to the module is a list of indices, and the output is the corresponding word embeddings. /// </summary> /// <param name="x">An input tensor of arbitrary shape.</param> /// <param name="num_embeddings">Size of the dictionary of embeddings, the vocabulary size.</param> /// <param name="embedding_dims">The size of each embedding vector</param> /// <param name="padding_idx">If given, pads the output with the embedding vector at padding_idx (initialized to zeros) whenever it encounters the index.</param> /// <param name="max_norm">If given, each embedding vector with norm larger than max_norm is renormalized to have norm max_norm.</param> /// <param name="norm_type">The p of the p-norm to compute for the max_norm option. Default 2.</param> /// <param name="scale_grad_by_freq">If given, this will scale gradients by the inverse of frequency of the words in the mini-batch. Default: false.</param> /// <param name="sparse">If true, gradient w.r.t. weight matrix will be a sparse tensor. Default: false</param> /// <returns></returns> /// <remarks>Keep in mind that only a limited number of optimizers support sparse gradients: currently it’s optim.SGD (CUDA and CPU), optim.SparseAdam (CUDA and CPU) and optim.Adagrad (CPU)</remarks> static public TorchTensor Embedding(TorchTensor x, long num_embeddings, long embedding_dims, long?padding_idx = null, double?max_norm = null, double norm_type = 2.0, bool scale_grad_by_freq = false, bool sparse = false) { using (var d = Modules.Embedding(num_embeddings, embedding_dims, padding_idx, max_norm, norm_type, scale_grad_by_freq, sparse)) { return(d.forward(x)); } }
static public TorchTensor AvgPool2D(TorchTensor x, long[] kernelSize, long[] strides = null) { using (var d = Modules.AvgPool2D(kernelSize, strides)) { return(d.Forward(x)); } }
/// <summary> /// Applies Batch Normalization over a 4D input (a mini-batch of 2D inputs with additional channel dimension) as described in the paper Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. /// </summary> /// <param name="x"></param> /// <param name="features">C from an expected input of size (N,C,H,W)</param> /// <param name="eps">A value added to the denominator for numerical stability. Default: 1e-5</param> /// <param name="momentum">The value used for the running_mean and running_var computation. Can be set to None for cumulative moving average (i.e. simple average). Default: 0.1</param> /// <param name="affine">A boolean value that when set to True, this module has learnable affine parameters. Default: true</param> /// <param name="track_running_stats">A boolean value that when set to True, this module tracks the running mean and variance, and when set to False, /// this module does not track such statistics, and initializes statistics buffers running_mean and running_var as None. /// When these buffers are None, this module always uses batch statistics. in both training and eval modes. Default: true</param> /// <returns></returns> static public TorchTensor BatchNorm2d(TorchTensor x, long features, double eps = 1e-05, double momentum = 0.1, bool affine = true, bool track_running_stats = true) { using (var d = Modules.BatchNorm2d(features, eps, momentum, affine, track_running_stats)) { return(d.forward(x)); } }
static public TorchTensor Linear(TorchTensor x, long inputSize, long outputSize, bool hasBias = true) { using (var d = Modules.Linear(inputSize, outputSize, hasBias)) { return(d.Forward(x)); } }
static public TorchTensor FeatureAlphaDropout(TorchTensor x, double probability = 0.5) { using (var f = Modules.FeatureAlphaDropout(probability)) { return(f.forward(x)); } }
/// <summary> /// Pads the input tensor using replication of the input boundary. /// </summary> /// <param name="x">Input tensor</param> /// <param name="padding">The size of the padding: (padding_left , padding_right)</param> /// <param name="value"></param> /// <returns></returns> static public TorchTensor ConstantPad1d(TorchTensor x, long padding, double value) { using (var d = Modules.ConstantPad1d(padding, value)) { return(d.forward(x)); } }
/// <summary> /// Rectified Linear Unit /// </summary> /// <param name="x">The input tensor</param> /// <param name="inPlace">Do the operation in-place. Default: False</param> /// <returns></returns> static public TorchTensor ReLU(TorchTensor x, bool inPlace = false) { using (var m = Modules.ReLU(inPlace)) { return(m.forward(x)); } }
/// <summary> /// Sigmoid activation /// </summary> /// <param name="x">The input tensor</param> /// <returns></returns> static public TorchTensor Sigmoid(TorchTensor x) { using (var m = Modules.Sigmoid()) { return(m.forward(x)); } }
/// <summary> /// Continuously Differentiable Exponential Linear Unit /// </summary> /// <param name="x">The input tensor</param> /// <param name="alpha">The α value for the CELU formulation. Default: 1.0</param> /// <param name="inPlace">Do the operation in-place. Default: False</param> /// <returns></returns> static public TorchTensor CELU(TorchTensor x, double alpha, bool inPlace = false) { using (var m = Modules.CELU(alpha, inPlace)) { return(m.forward(x)); } }
/// <summary> /// Applies a 3D max pooling over an input signal composed of several input planes. /// </summary> /// <param name="x">The input signal tensor</param> /// <param name="kernelSize">The size of the sliding window, must be > 0.</param> /// <param name="strides">The stride of the sliding window, must be > 0. Default value is kernel_size.</param> /// <returns></returns> static public TorchTensor MaxPool3d(TorchTensor x, long[] kernelSize, long[] strides = null) { using (var d = Modules.MaxPool3d(kernelSize, strides)) { return(d.forward(x)); } }
static public TorchTensor Identity(TorchTensor x) { using (var d = Modules.Identity()) { return(d.forward(x)); } }
static public TorchTensor PairwiseDistance(TorchTensor input1, TorchTensor input2, double p = 2.0, double eps = 1e-6, bool keep_dim = false) { using (var f = Modules.PairwiseDistance(p, eps, keep_dim)) { return(f.forward(input1, input2)); } }
static public TorchTensor Conv3d(TorchTensor x, long inputChannel, long outputChannel, long kernelSize, long stride = 1, long padding = 0, long dilation = 1, PaddingModes paddingMode = PaddingModes.Zeros, long groups = 1, bool bias = true) { using (var d = Modules.Conv3d(inputChannel, outputChannel, kernelSize, stride, padding, dilation, paddingMode, groups, bias)) { return(d.forward(x)); } }
/// <summary> /// Pads the input tensor using the reflection of the input boundary. /// </summary> /// <param name="x">Input tensor</param> /// <param name="padding">The size of the padding: (padding_left , padding_right)</param> /// <returns></returns> static public TorchTensor ReflectionPad1d(TorchTensor x, long padding) { using (var d = Modules.ReflectionPad1d(padding)) { return(d.forward(x)); } }
static public TorchTensor LogSoftMax(TorchTensor x, long dimension) { using (var l = Modules.LogSoftMax(dimension)) { return(l.Forward(x)); } }