The ByteTensor mask for memory keys per batch (optional).\n /// \n /// Take in and process masked source/target sequences.\n /// \n /// The sequence to the encoder (required).\n /// The sequence to the decoder (required).\n public override Tensor forward(Tensor src, Tensor tgt)\n {\n var res = THSNN_Transformer_forward(handle,\n src.Handle,\n tgt.Handle,\n IntPtr.Zero,\n IntPtr.Zero,\n IntPtr.Zero,\n IntPtr.Zero,\n IntPtr.Zero,\n IntPtr.Zero);\n if (res == IntPtr.Zero) { torch.CheckForErrors(); }\n return new Tensor(res);\n }\n }\n }\n\n public static partial class torch\n {\n public static partial class nn\n {\n public enum Activations\n {\n ReLU = 0,\n GELU = 1\n }\n\n /// \n /// A transformer model. User is able to modify the attributes as needed. The architecture is based on the paper “Attention Is All You Need”.\n /// \n /// The number of expected features in the encoder/decoder inputs (default=512).\n /// The number of heads in the multiheadattention models (default=8).\n /// The number of sub-encoder-layers in the encoder (default=6).\n /// The number of sub-decoder-layers in the decoder (default=6).\n /// The dimension of the feedforward network model (default=2048).\n /// The dropout value (default=0.1).\n /// The activation function of encoder/decoder intermediate layer, relu or gelu (default=relu).\n /// \n /// Computes scaled dot product attention on query, key and value tensors, using an optional attention mask if passed, and applying dropout if a probability greater than 0.0 is specified.\n /// \n /// Query tensor, shaped (N, ..., L, E)\n /// Key tensor, shaped (N, ..., S, E)\n /// Value tensor, shaped (N, ..., S, Ev)\n /// \n /// Attention mask, shaped (N, ..., L, S).\n /// Two types of masks are supported:\n /// A boolean mask where a value of True indicates that the element should take part in attention.\n /// A float mask of the same type as query, key, value that is added to the attention score.\n /// \n /// Dropout probability\n /// If true, assumes causal attention masking and errors if both attn_mask and is_causal are set.\n /// \n /// Solarize the image by inverting all pixel values above a threshold.\n /// \n /// All pixels equal or above this value are inverted.\n static public ITransform Solarize(double threshold)\n {\n return new Solarize(threshold);\n }\n }\n }\n}"},{"alpha_fraction":0.6311787366867065,"alphanum_fraction":0.6425855755805969,"avg_line_length":25.399999618530273,"blob_id":"f9759eeff22e157cef190ed3566126bfd3dffbd0","content_id":"c6707d8f83b6dd3cd0631cdc02af30edd3da3e32","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":265,"license_type":"permissive","max_line_length":131,"num_lines":10,"path":"/src/TorchSharp/Tensor/Enums/PrintOptionsProfile.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\nnamespace TorchSharp\n{\n public enum PrintOptionsProfile\n {\n @default = 0,\n @short = 1,\n full = 2\n }\n}"},{"alpha_fraction":0.4884297549724579,"alphanum_fraction":0.5034238696098328,"avg_line_length":41.349998474121094,"blob_id":"db0f258d5c48f7757d3c0a06eff29cbc5f20e171","content_id":"a01824120b72a56d733887ca19434e6b6d29031d","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":8470,"license_type":"permissive","max_line_length":134,"num_lines":200,"path":"/src/TorchVision/Ops/Losses.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\nusing System;\nusing System.Drawing;\nusing System.Text;\nusing System.Threading.Tasks;\nusing static TorchSharp.torch;\nusing static TorchSharp.torch.nn.functional;\nusing static TorchSharp.torchvision;\n\nnamespace TorchSharp\n{\n public static partial class torchvision\n {\n public static partial class ops\n {\n // Ported from https://github.com/pytorch/vision/blob/main/torchvision/ops/focal_loss.py\n\n /// \n /// Loss used in RetinaNet for dense detection: https://arxiv.org/abs/1708.02002.\n /// \n /// A float tensor of arbitrary shape. The predictions for each example. \n /// A float tensor with the same shape as inputs.\n /// Stores the binary classification label for each element in inputs\n /// (0 for the negative class and 1 for the positive class).\n /// \n /// Weighting factor in range (0,1) to balance positive vs negative examples or -1 for ignore.\n /// Exponent of the modulating factor (1 - p_t) to balance easy vs hard examples.\n /// The kind of reduction to apply to the result.\n /// \n /// Gradient-friendly IoU loss with an additional penalty that is non-zero when the\n /// boxes do not overlap.This loss function considers important geometrical\n /// factors such as overlap area, normalized central point distance and aspect ratio.\n /// This loss is symmetric, so the boxes1 and boxes2 arguments are interchangeable.\n /// \n /// (Tensor[N, 4] or Tensor[4]) first set of boxes\n /// (Tensor[N, 4] or Tensor[4]) second set of boxes\n /// The kind of reduction to apply to the result.\n /// Small number to prevent division by zero.\n public static Tensor complete_box_iou_loss(\n Tensor boxes1,\n Tensor boxes2,\n nn.Reduction reduction = nn.Reduction.None,\n double eps = 1e-7)\n {\n boxes1 = _upcast_non_float(boxes1);\n boxes2 = _upcast_non_float(boxes2);\n\n var (diou_loss, iou) = _diou_iou_loss(boxes1, boxes2);\n\n var xy = boxes1.unbind(dimension: -1);\n var xyg = boxes2.unbind(dimension: -1);\n\n // width and height of boxes\n var w_pred = xy[2] - xy[0];\n var h_pred = xy[3] - xy[1];\n var w_gt = xyg[2] - xyg[0];\n var h_gt = xyg[3] - xyg[1];\n\n var v = (4 / Math.Pow(Math.PI, 2)) * torch.pow((torch.atan(w_gt / h_gt) - torch.atan(w_pred / h_pred)), 2);\n\n Tensor alpha = null;\n\n using (var _ = torch.no_grad()) {\n alpha = v / (1 - iou + v + eps);\n }\n\n var loss = diou_loss + alpha * v;\n\n switch (reduction) {\n case nn.Reduction.None:\n break;\n case nn.Reduction.Mean:\n loss = loss.mean();\n break;\n case nn.Reduction.Sum:\n loss = loss.sum();\n break;\n }\n\n return loss;\n }\n\n /// \n /// Gradient-friendly IoU loss with an additional penalty that is non-zero when the\n /// distance between boxes' centers isn't zero.Indeed, for two exactly overlapping\n /// boxes, the distance IoU is the same as the IoU loss.\n /// This loss is symmetric, so the boxes1 and boxes2 arguments are interchangeable.\n /// \n /// (Tensor[N, 4] or Tensor[4]) first set of boxes\n /// (Tensor[N, 4] or Tensor[4]) second set of boxes\n /// The kind of reduction to apply to the result.\n /// Small number to prevent division by zero.\n public static Tensor distance_box_iou_loss(\n Tensor boxes1,\n Tensor boxes2,\n nn.Reduction reduction = nn.Reduction.None,\n double eps = 1e-7)\n {\n boxes1 = _upcast_non_float(boxes1);\n boxes2 = _upcast_non_float(boxes2);\n\n var (loss, _) = _diou_iou_loss(boxes1, boxes2);\n\n switch (reduction) {\n case nn.Reduction.None:\n break;\n case nn.Reduction.Mean:\n loss = loss.mean();\n break;\n case nn.Reduction.Sum:\n loss = loss.sum();\n break;\n }\n\n return loss;\n }\n\n /// \n /// Gradient-friendly IoU loss with an additional penalty that is non-zero when the\n /// boxes do not overlap and scales with the size of their smallest enclosing box.\n /// This loss is symmetric, so the boxes1 and boxes2 arguments are interchangeable.\n /// \n /// (Tensor[N, 4] or Tensor[4]) first set of boxes\n /// (Tensor[N, 4] or Tensor[4]) second set of boxes\n /// The kind of reduction to apply to the result.\n /// Small number to prevent division by zero.\n public static Tensor generalized_box_iou_loss(\n Tensor boxes1,\n Tensor boxes2,\n nn.Reduction reduction = nn.Reduction.None,\n double eps = 1e-7)\n {\n boxes1 = _upcast_non_float(boxes1);\n boxes2 = _upcast_non_float(boxes2);\n\n var (intsctk, unionk) = _loss_inter_union(boxes1, boxes2);\n var iouk = intsctk / (unionk + eps);\n\n var (x1, y1, x2, y2) = unwrap4(boxes1.unbind(dimension: -1));\n var (x1g, y1g, x2g, y2g) = unwrap4(boxes2.unbind(dimension: -1));\n\n // smallest enclosing box\n\n var xc1 = torch.min(x1, x1g);\n var yc1 = torch.min(y1, y1g);\n var xc2 = torch.max(x2, x2g);\n var yc2 = torch.max(y2, y2g);\n\n var area_c = (xc2 - xc1) * (yc2 - yc1);\n var miouk = iouk - ((area_c - unionk) / (area_c + eps));\n\n var loss = 1 - miouk;\n\n switch (reduction) {\n case nn.Reduction.None:\n break;\n case nn.Reduction.Mean:\n loss = loss.mean();\n break;\n case nn.Reduction.Sum:\n loss = loss.sum();\n break;\n }\n\n return loss;\n }\n }\n }\n}\n"},{"alpha_fraction":0.5421236753463745,"alphanum_fraction":0.543523907661438,"avg_line_length":43.404144287109375,"blob_id":"f5300b88f4ee7c621bea8996b591f75d2d1d0420","content_id":"e607e9069d624100dc6a46ec7c0d0db872aa6376","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":8570,"license_type":"permissive","max_line_length":149,"num_lines":193,"path":"/src/TorchSharp/Distributions/OneHotCategorical.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\nusing System;\nusing static TorchSharp.torch;\n\nnamespace TorchSharp\n{\n using Modules;\n\n namespace Modules\n {\n /// \n /// A Bernoulli distribution parameterized by `probs` or `logits` (but not both).\n /// \n public class OneHotCategorical : torch.distributions.Distribution\n {\n /// \n /// The mean of the distribution.\n /// \n public override Tensor mean => _categorical._probs;\n\n /// \n /// The mode of the distribution.\n /// \n public override Tensor mode {\n get {\n var probs = _categorical.probs;\n var mode = probs.argmax(-1);\n return torch.nn.functional.one_hot(mode, num_classes: probs.shape[probs.ndim - 1]).to(probs);\n }\n }\n\n /// \n /// The variance of the distribution\n /// \n public override Tensor variance => probs * (1 - _categorical.probs);\n\n /// \n /// Constructor\n /// \n /// \n /// \n /// \n public OneHotCategorical(Tensor p = null, Tensor l = null, torch.Generator generator = null) : base(generator)\n {\n _categorical = new Categorical(p, l, generator);\n\n if ((p is null && logits is null) || (p is not null && l is not null))\n throw new ArgumentException(\"One and only one of 'probs' and logits should be provided.\");\n\n this.batch_shape = p is null ? l.size() : p.size();\n this._probs = p?.alias().DetachFromDisposeScope();\n this._logits = l?.alias().DetachFromDisposeScope();\n }\n\n /// \n /// The probability of sampling 1\n /// \n public Tensor probs {\n get {\n return _probs ?? LogitsToProbs(_logits, true);\n }\n }\n\n /// \n /// The log-odds of sampling 1\n /// \n public Tensor logits {\n get {\n return _logits ?? ProbsToLogits(_probs);\n }\n }\n\n private Categorical _categorical;\n private Tensor _probs;\n private Tensor _logits;\n\n /// \n /// Generates a sample_shape shaped reparameterized sample or sample_shape shaped batch of reparameterized samples\n /// if the distribution parameters are batched.\n /// \n /// The sample shape.\n /// \n /// Returns the log of the probability density/mass function evaluated at `value`.\n /// \n /// \n /// \n /// Returns entropy of distribution, batched over batch_shape.\n /// \n public override Tensor entropy()\n {\n return _categorical.entropy();\n }\n\n /// \n /// Returns a new distribution instance (or populates an existing instance provided by a derived class) with batch dimensions expanded to\n /// `batch_shape`. This method calls `torch.Tensor.expand()` on the distribution's parameters. As such, this does not allocate new\n /// memory for the expanded distribution instance.\n /// \n /// Tthe desired expanded size.\n /// new instance provided by subclasses that need to override `.expand`.\n /// \n /// Creates a Bernoulli distribution parameterized by `probs` or `logits` (but not both).\n /// \n /// The probability of sampling '1'\n /// The log-odds of sampling '1'\n /// An optional random number generator object.\n /// \n /// Creates a Bernoulli distribution parameterized by `probs` or `logits` (but not both).\n /// \n /// The probability of sampling '1'\n /// The log-odds of sampling '1'\n /// An optional random number generator object.\n /// \n /// Creates a Bernoulli distribution parameterized by `probs` or `logits` (but not both).\n /// \n /// The probability of sampling '1'\n /// The log-odds of sampling '1'\n /// An optional random number generator object.\n /// \n /// Convert image to grayscale. \n /// \n /// The number of channels in the output image tensor.\n /// kernelSize, float min, float max)\n {\n if (kernelSize == null || kernelSize.Count != 2 || kernelSize.Any(x => x <= 0)) {\n throw new ArgumentException(\"Invalid kernel size argument.\");\n }\n if (min < 0 || max < 0 || min >= max) {\n throw new ArgumentException(\"Invalid GaussianBlur arguments.\");\n }\n this.sigma = (min == max) ?\n min :\n (float)(new Random().NextDouble() * (max - min) + min);\n this.kernelSize = kernelSize.ToArray();\n }\n\n public Tensor call(Tensor input)\n {\n return transforms.functional.gaussian_blur(input, kernelSize, new float[] { sigma });\n }\n\n protected long[] kernelSize;\n protected float sigma;\n }\n\n public static partial class transforms\n {\n /// \n /// Apply a Gaussian blur effect to the image.\n /// \n /// Gaussian kernel size\n /// Gaussian kernel standard deviation\n /// kernelSize, float sigma)\n {\n return new GaussianBlur(kernelSize, sigma, sigma);\n }\n\n /// \n /// Apply a Gaussian blur effect to the image.\n /// \n /// Gaussian kernel size\n /// Minimum value of the range for the uniform distribution from which the Gaussian kernel standard deviation will sampled\n /// Maximum value of the range for the uniform distribution from which the Gaussian kernel standard deviation will sampled\n static public ITransform GaussianBlur(IList kernelSize, float min = 0.1f, float max = 2.0f)\n {\n return new GaussianBlur(kernelSize, min, max);\n }\n\n /// \n /// Apply a Gaussian blur effect to the image.\n /// \n /// Gaussian kernel size\n /// Gaussian kernel standard deviation\n static public ITransform GaussianBlur(long kernelSize, float sigma)\n {\n return new GaussianBlur(new long[] { kernelSize, kernelSize }, sigma, sigma);\n }\n\n /// \n /// Apply a Gaussian blur effect to the image.\n /// \n /// Gaussian kernel size\n /// Minimum value of the range for the uniform distribution from which the Gaussian kernel standard deviation will sampled\n /// Maximum value of the range for the uniform distribution from which the Gaussian kernel standard deviation will sampled\n static public ITransform GaussianBlur(long kernelSize, float min = 0.1f, float max = 2.0f)\n {\n return new GaussianBlur(new long[] { kernelSize, kernelSize }, min, max);\n }\n\n /// \n /// Apply a Gaussian blur effect to the image.\n /// \n /// Gaussian kernel height\n /// Gaussian kernel width\n /// Gaussian kernel standard deviation\n static public ITransform GaussianBlur(long kernelHeight, long kernelWidth, float sigma)\n {\n return new GaussianBlur(new long[] { kernelHeight, kernelWidth }, sigma, sigma);\n }\n\n /// \n /// Apply a Gaussian blur effect to the image.\n /// \n /// Gaussian kernel height\n /// Gaussian kernel width\n /// Minimum value of the range for the uniform distribution from which the Gaussian kernel standard deviation will sampled\n /// Minimum value of the range for the uniform distribution from which the Gaussian kernel standard deviation will sampled\n static public ITransform GaussianBlur(long kernelHeight, long kernelWidth, float min = 0.1f, float max = 2.0f)\n {\n return new GaussianBlur(new long[] { kernelHeight, kernelWidth }, min, max);\n }\n }\n }\n}"},{"alpha_fraction":0.45181626081466675,"alphanum_fraction":0.4575202763080597,"avg_line_length":33.340206146240234,"blob_id":"e4947a432e287f760d67e84bf80de2c4a0e373d6","content_id":"132721ee72a404b6bf8a59cbe62c86c78b83388d","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":9993,"license_type":"permissive","max_line_length":130,"num_lines":291,"path":"/src/TorchSharp/Tensor/Size.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\n\nusing System.Linq;\nusing System.Collections.Generic;\nusing System.Collections;\n\n#nullable enable\nnamespace TorchSharp\n{\n public static partial class torch\n {\n /// \n /// Represents the dimensions of a tensor, that is, its shape.\n /// \n /// \n /// The primary purpose of this type, at the moment, is to avoid having to declare\n /// too many overloads on tensor factories that take input sizes.\n /// The name was chosen to coincide with 'torch.Size' in PyTorch. It may later be\n /// used as the return value of 'Tensor.shape' and 'Tensor.size()'\n /// \n public struct Size : IEnumerable\n {\n /// \n /// Represents an empty size.\n /// \n public static Size Empty = new Size(System.Array.Empty());\n\n /// \n /// Constructor\n /// \n /// An array of longs, the size of an N-D tensor.\n public Size(long[] shape)\n {\n _shape = (long[])shape.Clone();\n }\n\n /// \n /// Constructor\n /// \n /// An enumerable of longs, the size of an N-D tensor.\n public Size(IEnumerable shape)\n {\n _shape = shape.ToArray();\n }\n\n /// \n /// Constructor\n /// \n /// An array of longs, the size of an N-D tensor.\n public Size(int[] shape)\n {\n _shape = shape.Select(i => (long)i).ToArray();\n }\n\n /// \n /// Constructor\n /// \n /// The size of a 1D tensor.\n public Size(long size)\n {\n _shape = new long[] { size };\n }\n\n /// \n /// Constructor\n /// \n /// The size of a 2D tensor.\n public Size((long, long) size)\n {\n _shape = new long[] { size.Item1, size.Item2 };\n }\n\n /// \n /// Constructor\n /// \n /// The size of a 3D tensor.\n public Size((long, long, long) size)\n {\n _shape = new long[] { size.Item1, size.Item2, size.Item3 };\n }\n\n /// \n /// Constructor\n /// \n /// The size of a 4D tensor.\n public Size((long, long, long, long) size)\n {\n _shape = new long[] { size.Item1, size.Item2, size.Item3, size.Item4 };\n }\n\n /// \n /// Constructor\n /// \n /// The size of a 5D tensor.\n public Size((long, long, long, long, long) size)\n {\n _shape = new long[] { size.Item1, size.Item2, size.Item3, size.Item4, size.Item5 };\n }\n\n /// \n /// Constructor\n /// \n /// The size of a 6D tensor.\n public Size((long, long, long, long, long, long) size)\n {\n _shape = new long[] { size.Item1, size.Item2, size.Item3, size.Item4, size.Item5, size.Item6 };\n }\n\n\n /// \n /// Constructor\n /// \n /// The size of a 1D tensor.\n public Size(int size)\n {\n _shape = new long[] { size };\n }\n\n /// \n /// Constructor\n /// \n /// The size of a 2D tensor.\n public Size((int, int) size)\n {\n _shape = new long[] { size.Item1, size.Item2 };\n }\n\n /// \n /// Constructor\n /// \n /// The size of a 3D tensor.\n public Size((int, int, int) size)\n {\n _shape = new long[] { size.Item1, size.Item2, size.Item3 };\n }\n /// \n /// Constructor\n /// \n /// The size of a 4D tensor.\n public Size((int, int, int, int) size)\n {\n _shape = new long[] { size.Item1, size.Item2, size.Item3, size.Item4 };\n }\n\n /// \n /// Constructor\n /// \n /// The size of a 5D tensor.\n public Size((int, int, int, int, int) size)\n {\n _shape = new long[] { size.Item1, size.Item2, size.Item3, size.Item4, size.Item5 };\n }\n\n /// \n /// Constructor\n /// \n /// The size of a 6D tensor.\n public Size((int, int, int, int, int, int) size)\n {\n _shape = new long[] { size.Item1, size.Item2, size.Item3, size.Item4, size.Item5, size.Item6 };\n }\n\n /// \n /// Implicit conversion operators. Useful to avoid overloads everywhere.\n /// \n public static implicit operator Size(long size) => new Size(size);\n public static implicit operator Size((long, long) size) => new Size(size);\n public static implicit operator Size((long, long, long) size) => new Size(size);\n public static implicit operator Size((long, long, long, long) size) => new Size(size);\n public static implicit operator Size((long, long, long, long, long) size) => new Size(size);\n public static implicit operator Size((long, long, long, long, long, long) size) => new Size(size);\n\n public static implicit operator Size(long[] size) => new Size(size);\n\n public static Size operator +(Size left, Size right)\n {\n return new Size(left._shape.AsEnumerable().Concat(right._shape).ToArray());\n }\n\n public static Size operator +(Size left, IEnumerable right)\n {\n return new Size(left._shape.AsEnumerable().Concat(right).ToArray());\n }\n\n //public static implicit operator Size(long[] size) => new Size(size);\n //public static implicit operator long[](Size size) => size._shape;\n\n public static bool operator ==(Size left, Size right) => left._shape == right._shape;\n\n public static bool operator !=(Size left, Size right) => left._shape != right._shape;\n\n public override bool Equals(object? obj)\n {\n if (obj is null || !(obj is Size)) return false;\n\n return _shape.Equals(((Size)obj)._shape);\n }\n\n public Size Slice(int first, int next)\n {\n if (next < 0) {\n next = _shape.Length + next;\n }\n\n if (first < 0) {\n first = _shape.Length + first;\n }\n\n if (next <= first) {\n return Size.Empty;\n }\n\n if (first == 0) {\n if (next == _shape.Length) {\n return this;\n }\n else {\n return new Size(_shape.Take(next));\n }\n }\n else {\n if (next == _shape.Length) {\n return new Size(_shape.Skip(first));\n } else {\n return new Size(_shape.Skip(first).Take(next-first));\n }\n }\n }\n\n public override int GetHashCode()\n {\n return _shape.GetHashCode();\n }\n\n /// \n /// The number of elements in a tensor, the product of its shape elements.\n /// \n /// Take(int i) => _shape.Take(i);\n\n public IEnumerator GetEnumerator()\n {\n return _shape.AsEnumerable().GetEnumerator();\n }\n\n IEnumerator IEnumerable.GetEnumerator()\n {\n return this.GetEnumerator();\n }\n\n /// \n /// Element accessor\n /// \n /// The element index\n /// \n /// Element accessor\n /// \n /// The element index\n /// \n /// This class is used to represent a dropout module.\n /// \n public sealed class PixelShuffle : torch.nn.Module\n {\n internal PixelShuffle(IntPtr handle, IntPtr boxedHandle) : base(handle, boxedHandle) { }\n\n /// \n /// Forward pass.\n /// \n /// Input tensor\n /// \n /// Rearranges 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 upscale factor.\n /// This is useful for implementing efficient sub-pixel convolution with a stride of 1/r.\n /// \n /// Factor to increase spatial resolution by\n /// \n /// Rearranges 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 upscale factor.\n /// This is useful for implementing efficient sub-pixel convolution with a stride of 1/r.\n /// \n /// Input tensor\n /// Factor to increase spatial resolution by\n /// \n\n\n\nNNModule THSNN_AvgPool1d_ctor(const int64_t* kernelSize, const int64_t* stride, const int64_t* padding,\n bool ceil_mode, bool count_include_pad, int64_t divisor_override,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::AvgPool1dOptions(at::ArrayRef(kernelSize, 1)).ceil_mode(ceil_mode).count_include_pad(count_include_pad);\n if (stride)\n opts = opts.stride(at::ArrayRef(stride, 1));\n if (padding)\n opts = opts.padding(at::ArrayRef(padding, 1));\n if (divisor_override > 0)\n opts = opts.divisor_override(divisor_override);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_AvgPool1d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_AvgPool2d_ctor(const int64_t* kernelSize, const int kernelSizeLength, const int64_t* stride, const int strideLength, const int64_t* padding, const int paddingLength,\n bool ceil_mode, bool count_include_pad, int64_t divisor_override,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::AvgPool2dOptions(at::ArrayRef(kernelSize, kernelSizeLength)).ceil_mode(ceil_mode).count_include_pad(count_include_pad);\n if (stride)\n opts = opts.stride(at::ArrayRef(stride, strideLength));\n if (padding)\n opts = opts.padding(at::ArrayRef(padding, paddingLength));\n if (divisor_override > 0)\n opts = opts.divisor_override(divisor_override);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_AvgPool2d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_AvgPool3d_ctor(const int64_t* kernelSize, const int kernelSizeLength, const int64_t* stride, const int strideLength, const int64_t* padding, const int paddingLength,\n bool ceil_mode, bool count_include_pad, int64_t divisor_override,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::AvgPool3dOptions(at::ArrayRef(kernelSize, kernelSizeLength)).ceil_mode(ceil_mode).count_include_pad(count_include_pad);\n if (stride)\n opts = opts.stride(at::ArrayRef(stride, strideLength));\n if (padding)\n opts = opts.padding(at::ArrayRef(padding, paddingLength));\n if (divisor_override > 0)\n opts = opts.divisor_override(divisor_override);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_AvgPool3d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_AdaptiveAvgPool1d_ctor(const int64_t* kernelSize, const int kernelSizeLength,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::AdaptiveAvgPool1dOptions(at::ArrayRef(kernelSize, kernelSizeLength));\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_AdaptiveAvgPool1d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_AdaptiveAvgPool2d_ctor(const int64_t* kernelSize, const int kernelSizeLength,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::AdaptiveAvgPool2dOptions(at::ArrayRef(kernelSize, kernelSizeLength));\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_AdaptiveAvgPool2d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_AdaptiveAvgPool3d_ctor(const int64_t* kernelSize, const int kernelSizeLength,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::AdaptiveAvgPool3dOptions(at::ArrayRef(kernelSize, kernelSizeLength));\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_AdaptiveAvgPool3d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_AdaptiveMaxPool1d_ctor(const int64_t* kernelSize, const int kernelSizeLength,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::AdaptiveMaxPool1dOptions(at::ArrayRef(kernelSize, kernelSizeLength));\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_AdaptiveMaxPool1d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_AdaptiveMaxPool2d_ctor(const int64_t* kernelSize, const int kernelSizeLength,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::AdaptiveMaxPool2dOptions(at::ArrayRef(kernelSize, kernelSizeLength));\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_AdaptiveMaxPool2d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_AdaptiveMaxPool3d_ctor(const int64_t* kernelSize, const int kernelSizeLength,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::AdaptiveMaxPool3dOptions(at::ArrayRef(kernelSize, kernelSizeLength));\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_AdaptiveMaxPool3d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_LPPool1d_ctor(double norm_type, const int64_t* kernelSize, const int64_t* stride, const bool ceil_mode,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::LPPool1dOptions(norm_type, at::ArrayRef(kernelSize, 1)).ceil_mode(ceil_mode);\n if (stride)\n opts = opts.stride(at::ArrayRef(stride, 1));\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_LPPool1d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_LPPool2d_ctor(double norm_type, const int64_t* kernelSize, const int kernelSizeLength, const int64_t* stride, const int strideLength, const bool ceil_mode,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::LPPool2dOptions(norm_type, at::ArrayRef(kernelSize, kernelSizeLength)).ceil_mode(ceil_mode);\n if (stride)\n opts = opts.stride(at::ArrayRef(stride, strideLength));\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_LPPool2d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_MaxPool1d_ctor(const int64_t* kernelSize, const int64_t* stride, const int64_t* padding, const int64_t* dilation, bool ceil_mode,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::MaxPool1dOptions(at::ArrayRef(kernelSize, 1)).ceil_mode(ceil_mode);\n if (stride)\n opts = opts.stride(at::ArrayRef(stride, 1));\n if (padding)\n opts = opts.padding(at::ArrayRef(padding, 1));\n if (dilation)\n opts = opts.dilation(at::ArrayRef(dilation, 1));\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_MaxPool1d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nTensor THSNN_MaxPool1d_forward_with_indices(const NNModule module, const Tensor tensor, Tensor* indices)\n{\n std::tuple res;\n CATCH(res = (*module)->as()->forward_with_indices(*tensor););\n *indices = ResultTensor(std::get<1>(res));\n return ResultTensor(std::get<0>(res));\n}\n\nNNModule THSNN_MaxPool2d_ctor(const int64_t* kernelSize, const int kernelSizeLength, const int64_t* stride, const int strideLength,\n const int64_t* padding, const int paddingLength, const int64_t* dilation, const int dilationLength, bool ceil_mode,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::MaxPool2dOptions(at::ArrayRef(kernelSize, kernelSizeLength)).ceil_mode(ceil_mode);\n if (stride)\n opts = opts.stride(at::ArrayRef(stride, strideLength));\n if (padding)\n opts = opts.padding(at::ArrayRef(padding, paddingLength));\n if (dilation)\n opts = opts.dilation(at::ArrayRef(dilation, dilationLength));\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_MaxPool2d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nTensor THSNN_MaxPool2d_forward_with_indices(const NNModule module, const Tensor tensor, Tensor* indices)\n{\n std::tuple res;\n CATCH(res = (*module)->as()->forward_with_indices(*tensor););\n *indices = ResultTensor(std::get<1>(res));\n return ResultTensor(std::get<0>(res));\n}\n\nNNModule THSNN_MaxPool3d_ctor(const int64_t* kernelSize, const int kernelSizeLength, const int64_t* stride, const int strideLength,\n const int64_t* padding, const int paddingLength, const int64_t* dilation, const int dilationLength, bool ceil_mode,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::MaxPool3dOptions(at::ArrayRef(kernelSize, kernelSizeLength)).ceil_mode(ceil_mode);\n if (stride)\n opts = opts.stride(at::ArrayRef(stride, strideLength));\n if (padding)\n opts = opts.padding(at::ArrayRef(padding, paddingLength));\n if (dilation)\n opts = opts.dilation(at::ArrayRef(dilation, dilationLength));\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_MaxPool3d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nTensor THSNN_MaxPool3d_forward_with_indices(const NNModule module, const Tensor tensor, Tensor* indices)\n{\n std::tuple res;\n CATCH(res = (*module)->as()->forward_with_indices(*tensor););\n *indices = ResultTensor(std::get<1>(res));\n return ResultTensor(std::get<0>(res));\n}\n\nNNModule THSNN_MaxUnpool1d_ctor(const int64_t* kernelSize, const int64_t* stride, const int64_t* padding, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::MaxUnpool1dOptions(at::ArrayRef(kernelSize, 1));\n if (stride)\n opts = opts.stride(at::ArrayRef(stride, 1));\n if (padding)\n opts = opts.padding(at::ArrayRef(padding, 1));\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_MaxUnpool1d_forward(const NNModule module, const Tensor tensor, const Tensor indices, const int64_t* outputSize)\n{\n if (outputSize != nullptr) {\n std::vector outSize;\n outSize.push_back(*outputSize);\n\n CATCH_TENSOR((*module)->as()->forward(*tensor, *indices, outSize));\n }\n else {\n CATCH_TENSOR((*module)->as()->forward(*tensor, *indices));\n }\n}\n\nNNModule THSNN_MaxUnpool2d_ctor(const int64_t* kernelSize, const int kernelSizeLength, const int64_t* stride, const int strideLength, const int64_t* padding, const int paddingLength, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::MaxUnpool2dOptions(at::ArrayRef(kernelSize, kernelSizeLength));\n if (stride)\n opts = opts.stride(at::ArrayRef(stride, strideLength));\n if (padding)\n opts = opts.padding(at::ArrayRef(padding, paddingLength));\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_MaxUnpool2d_forward(const NNModule module, const Tensor tensor, const Tensor indices, const int64_t* outputSize, const int outputSizeLength)\n{\n if (outputSize != nullptr) {\n std::vector outSize;\n for (auto i = 0L; i < outputSizeLength; i++) {\n outSize.push_back(outputSize[i]);\n }\n\n CATCH_TENSOR((*module)->as()->forward(*tensor, *indices, outSize));\n }\n else {\n CATCH_TENSOR((*module)->as()->forward(*tensor, *indices));\n }\n}\n\nNNModule THSNN_MaxUnpool3d_ctor(const int64_t* kernelSize, const int kernelSizeLength, const int64_t* stride, const int strideLength, const int64_t* padding, const int paddingLength, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::MaxUnpool3dOptions(at::ArrayRef(kernelSize, kernelSizeLength));\n if (stride)\n opts = opts.stride(at::ArrayRef(stride, strideLength));\n if (padding)\n opts = opts.padding(at::ArrayRef(padding, paddingLength));\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_MaxUnpool3d_forward(const NNModule module, const Tensor tensor, const Tensor indices, const int64_t* outputSize, const int outputSizeLength)\n{\n if (outputSize != nullptr) {\n std::vector outSize;\n for (auto i = 0L; i < outputSizeLength; i++) {\n outSize.push_back(outputSize[i]);\n }\n\n CATCH_TENSOR((*module)->as()->forward(*tensor, *indices, outSize));\n }\n else {\n CATCH_TENSOR((*module)->as()->forward(*tensor, *indices));\n }\n}\n\n\nNNModule THSNN_FractionalMaxPool2d_ctor(const int64_t* kernelSize, const int kernelSizeLength, const int64_t* outputSize, const int outputSizeLength, const double* outputRatio, const int outputRatioLength, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::FractionalMaxPool2dOptions(at::ArrayRef(kernelSize, kernelSizeLength));\n if (outputSize)\n opts = opts.output_size(at::ArrayRef(outputSize, outputSizeLength));\n if (outputRatio)\n opts = opts.output_ratio(at::ArrayRef(outputRatio, outputRatioLength));\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_FractionalMaxPool2d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nTensor THSNN_FractionalMaxPool2d_forward_with_indices(const NNModule module, const Tensor tensor, Tensor* indices)\n{\n std::tuple res;\n CATCH(res = (*module)->as()->forward_with_indices(*tensor););\n *indices = ResultTensor(std::get<1>(res));\n return ResultTensor(std::get<0>(res));\n}\n\nNNModule THSNN_FractionalMaxPool3d_ctor(const int64_t* kernelSize, const int kernelSizeLength, const int64_t* outputSize, const int outputSizeLength, const double* outputRatio, const int outputRatioLength, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::FractionalMaxPool3dOptions(at::ArrayRef(kernelSize, kernelSizeLength));\n if (outputSize)\n opts = opts.output_size(at::ArrayRef(outputSize, outputSizeLength));\n if (outputRatio)\n opts = opts.output_ratio(at::ArrayRef(outputRatio, outputRatioLength));\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_FractionalMaxPool3d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nTensor THSNN_FractionalMaxPool3d_forward_with_indices(const NNModule module, const Tensor tensor, Tensor* indices)\n{\n std::tuple res;\n CATCH(res = (*module)->as()->forward_with_indices(*tensor););\n *indices = ResultTensor(std::get<1>(res));\n return ResultTensor(std::get<0>(res));\n}\n\nNNModule THSNN_ZeroPad2d_ctor(const int64_t padding, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ZeroPad2dOptions(padding);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nNNModule THSNN_ZeroPad2d_ctor_tuple(const int64_t padding_left, const int64_t padding_right, const int64_t padding_top, const int64_t padding_bottom, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ZeroPad2dOptions({ padding_left, padding_right, padding_top, padding_bottom });\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_ZeroPad2d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_ConstantPad1d_ctor(const double value, const int64_t padding, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ConstantPad1dOptions(padding, value);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_ConstantPad1d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_ConstantPad2d_ctor(const double value, const int64_t padding, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ConstantPad2dOptions(padding, value);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_ConstantPad2d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_ConstantPad3d_ctor(const double value, const int64_t padding, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ConstantPad3dOptions(padding, value);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_ConstantPad3d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_ConstantPad1d_ctor_tuple(const double value, const int64_t padding_left, const int64_t padding_right, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ConstantPad1dOptions({ padding_left, padding_right }, value);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nNNModule THSNN_ConstantPad2d_ctor_tuple(const double value, const int64_t padding_left, const int64_t padding_right, const int64_t padding_top, const int64_t padding_bottom, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ConstantPad2dOptions({ padding_left, padding_right, padding_top, padding_bottom }, value);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nNNModule THSNN_ConstantPad3d_ctor_tuple(const double value, const int64_t padding_left, const int64_t padding_right, const int64_t padding_top, const int64_t padding_bottom, const int64_t padding_front, const int64_t padding_back, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ConstantPad3dOptions({ padding_left, padding_right, padding_top, padding_bottom, padding_front, padding_back }, value);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nNNModule THSNN_ReplicationPad1d_ctor(const int64_t padding, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ReplicationPad1dOptions(padding);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_ReplicationPad1d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_ReplicationPad2d_ctor(const int64_t padding, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ReplicationPad2dOptions(padding);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_ReplicationPad2d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_ReplicationPad3d_ctor(const int64_t padding, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ReplicationPad3dOptions(padding);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\n\nTensor THSNN_ReplicationPad3d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_ReplicationPad1d_ctor_tuple(const int64_t padding_left, const int64_t padding_right, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ReplicationPad1dOptions({ padding_left, padding_right });\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nNNModule THSNN_ReplicationPad2d_ctor_tuple(const int64_t padding_left, const int64_t padding_right, const int64_t padding_top, const int64_t padding_bottom, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ReplicationPad2dOptions({ padding_left, padding_right, padding_top, padding_bottom });\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nNNModule THSNN_ReplicationPad3d_ctor_tuple(const int64_t padding_left, const int64_t padding_right, const int64_t padding_top, const int64_t padding_bottom, const int64_t padding_front, const int64_t padding_back, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ReplicationPad3dOptions({ padding_left, padding_right, padding_top, padding_bottom, padding_front, padding_back });\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nNNModule THSNN_ReflectionPad1d_ctor(const int64_t padding, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ReflectionPad1dOptions(padding);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_ReflectionPad1d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_ReflectionPad2d_ctor(const int64_t padding, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ReflectionPad2dOptions(padding);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_ReflectionPad2d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_ReflectionPad3d_ctor(const int64_t padding, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ReflectionPad3dOptions(padding);\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_ReflectionPad3d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nNNModule THSNN_ReflectionPad1d_ctor_tuple(const int64_t padding_left, const int64_t padding_right, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ReflectionPad1dOptions({ padding_left, padding_right });\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nNNModule THSNN_ReflectionPad2d_ctor_tuple(const int64_t padding_left, const int64_t padding_right, const int64_t padding_top, const int64_t padding_bottom, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ReflectionPad2dOptions({ padding_left, padding_right, padding_top, padding_bottom });\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nNNModule THSNN_ReflectionPad3d_ctor_tuple(const int64_t padding_left, const int64_t padding_right, const int64_t padding_top, const int64_t padding_bottom, const int64_t padding_front, const int64_t padding_back, NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ReflectionPad3dOptions({ padding_left, padding_right, padding_top, padding_bottom, padding_front, padding_back });\n res = create_module(opts, outAsAnyModule);\n );\n}\n\n\ntemplate\nvoid ApplyPaddingMode(T& opts, const int64_t padding)\n{\n if (padding == 0)\n opts = opts.padding_mode(torch::kZeros);\n if (padding == 1)\n opts = opts.padding_mode(torch::kReflect);\n if (padding == 2)\n opts = opts.padding_mode(torch::kReplicate);\n if (padding == 3)\n opts = opts.padding_mode(torch::kCircular);\n}\n\nNNModule THSNN_Conv1d_ctor(const int64_t inputChannel, const int64_t outputChannel,\n const int64_t kernelSize, const int64_t stride, const int64_t padding,\n const int64_t dilation, const int64_t paddingMode, const int64_t groups, const bool bias,\n NNAnyModule* outAsAnyModule)\n{\n torch::nn::Conv1dOptions::padding_t padd(padding);\n if (padding == -1)\n {\n padd = torch::kSame;\n }\n\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::Conv1dOptions(inputChannel, outputChannel, kernelSize)\n .stride(stride)\n .padding(padd)\n .dilation(dilation)\n .groups(groups)\n .bias(bias);\n\n ApplyPaddingMode(opts, paddingMode);\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_Conv1d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nTensor THSNN_Conv1d_bias(const NNModule module)\n{\n return get_bias(module);\n}\n\nvoid THSNN_Conv1d_set_bias(const NNModule module, const Tensor bias)\n{\n set_bias(module, bias);\n}\n\nTensor THSNN_Conv1d_weight(const NNModule module)\n{\n return get_weight(module);\n}\n\nvoid THSNN_Conv1d_set_weight(const NNModule module, const Tensor weight)\n{\n set_weight(module, weight);\n}\n\nNNModule THSNN_Conv2d_ctor(const int64_t inputChannel, const int64_t outputChannel,\n const int64_t kernelSize, const int64_t stride, const int64_t padding,\n const int64_t dilation, const int64_t paddingMode, const int64_t groups, const bool bias,\n NNAnyModule* outAsAnyModule)\n{\n torch::nn::Conv2dOptions::padding_t padd =\n (padding == -1) ? torch::kSame :\n (padding == 0) ? torch::kValid :\n torch::nn::Conv2dOptions::padding_t(padding);\n\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::Conv2dOptions(inputChannel, outputChannel, kernelSize)\n .stride(stride)\n .padding(padd)\n .dilation(dilation)\n .groups(groups)\n .bias(bias);\n ApplyPaddingMode(opts, paddingMode);\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nNNModule THSNN_Conv2d_ctor_1(const int64_t inputChannel, const int64_t outputChannel,\n const int64_t kernelX, const int64_t kernelY,\n const int64_t strideX, const int64_t strideY,\n const int64_t paddingX, const int64_t paddingY,\n const int64_t dilationX, const int64_t dilationY,\n const int64_t paddingMode, const int64_t groups, const bool bias,\n NNAnyModule* outAsAnyModule)\n{\n torch::nn::Conv2dOptions::padding_t padd =\n (paddingX == -1) && (paddingY == 0) ? torch::kSame :\n (paddingX == 0) && (paddingY == 0) ? torch::kValid :\n (torch::nn::Conv2dOptions::padding_t)torch::ExpandingArray<2>({ paddingX, paddingY });\n\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::Conv2dOptions(inputChannel, outputChannel, { kernelX, kernelY })\n .stride({ strideX, strideY })\n .padding(padd)\n .dilation({ dilationX, dilationY })\n .groups(groups)\n .bias(bias);\n ApplyPaddingMode(opts, paddingMode);\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_Conv2d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nTensor THSNN_Conv2d_bias(const NNModule module)\n{\n return get_bias(module);\n}\n\nvoid THSNN_Conv2d_set_bias(const NNModule module, const Tensor bias)\n{\n set_bias(module, bias);\n}\n\nTensor THSNN_Conv2d_weight(const NNModule module)\n{\n return get_weight(module);\n}\n\nvoid THSNN_Conv2d_set_weight(const NNModule module, const Tensor weight)\n{\n set_weight(module, weight);\n}\n\nNNModule THSNN_Conv3d_ctor(const int64_t inputChannel, const int64_t outputChannel,\n const int64_t kernelSize, const int64_t stride, const int64_t padding,\n const int64_t dilation, const int64_t paddingMode, const int64_t groups, const bool bias,\n NNAnyModule* outAsAnyModule)\n{\n torch::nn::Conv3dOptions::padding_t padd =\n (padding == -1) ? torch::kSame :\n (padding == 0) ? torch::kValid :\n torch::nn::Conv3dOptions::padding_t(padding);\n\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::Conv3dOptions(inputChannel, outputChannel, kernelSize)\n .stride(stride)\n .padding(padd)\n .dilation(dilation)\n .groups(groups)\n .bias(bias);\n ApplyPaddingMode(opts, paddingMode);\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nNNModule THSNN_Conv3d_ctor_1(const int64_t inputChannel, const int64_t outputChannel,\n const int64_t kernelX, const int64_t kernelY, const int64_t kernelZ,\n const int64_t strideX, const int64_t strideY, const int64_t strideZ,\n const int64_t paddingX, const int64_t paddingY, const int64_t paddingZ,\n const int64_t dilationX, const int64_t dilationY, const int64_t dilationZ,\n const int64_t paddingMode, const int64_t groups, const bool bias,\n NNAnyModule* outAsAnyModule)\n{\n torch::nn::Conv3dOptions::padding_t padd =\n (paddingX == -1) && (paddingY == 0) && (paddingZ == 0) ? torch::kSame :\n (paddingX == 0) && (paddingY == 0) && (paddingZ == 0) ? torch::kValid :\n (torch::nn::Conv3dOptions::padding_t)torch::ExpandingArray<3>({ paddingX, paddingY, paddingZ });\n\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::Conv3dOptions(inputChannel, outputChannel, { kernelX, kernelY, kernelZ })\n .stride({ strideX, strideY, strideZ })\n .padding(padd)\n .dilation({ dilationX, dilationY, dilationZ })\n .groups(groups)\n .bias(bias);\n ApplyPaddingMode(opts, paddingMode);\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_Conv3d_bias(const NNModule module)\n{\n return get_bias(module);\n}\n\nvoid THSNN_Conv3d_set_bias(const NNModule module, const Tensor bias)\n{\n set_bias(module, bias);\n}\n\nTensor THSNN_Conv3d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nTensor THSNN_Conv3d_weight(const NNModule module)\n{\n return get_weight(module);\n}\n\nvoid THSNN_Conv3d_set_weight(const NNModule module, const Tensor weight)\n{\n set_weight(module, weight);\n}\n\n\nNNModule THSNN_ConvTranspose1d_ctor(const int64_t inputChannel, const int64_t outputChannel,\n const int64_t kernelSize, const int64_t stride, const int64_t padding, const int64_t output_padding,\n const int64_t dilation, const int64_t paddingMode, const int64_t groups, const bool bias,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ConvTranspose1dOptions(inputChannel, outputChannel, kernelSize)\n .stride(stride)\n .padding(padding)\n .dilation(dilation)\n .groups(groups)\n .bias(bias)\n .output_padding(output_padding);\n ApplyPaddingMode(opts, paddingMode);\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_ConvTranspose1d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nTensor THSNN_ConvTranspose1d_bias(const NNModule module)\n{\n return get_bias(module);\n}\n\nvoid THSNN_ConvTranspose1d_set_bias(const NNModule module, const Tensor bias)\n{\n set_bias(module, bias);\n}\n\nTensor THSNN_ConvTranspose1d_weight(const NNModule module)\n{\n return get_weight(module);\n}\n\nvoid THSNN_ConvTranspose1d_set_weight(const NNModule module, const Tensor weight)\n{\n set_weight(module, weight);\n}\n\nNNModule THSNN_ConvTranspose2d_ctor(const int64_t inputChannel, const int64_t outputChannel,\n const int64_t kernelSize, const int64_t stride, const int64_t padding, const int64_t output_padding,\n const int64_t dilation, const int64_t paddingMode, const int64_t groups, const bool bias,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ConvTranspose2dOptions(inputChannel, outputChannel, kernelSize)\n .stride(stride)\n .padding(padding)\n .dilation(dilation)\n .groups(groups)\n .bias(bias)\n .output_padding(output_padding);\n ApplyPaddingMode(opts, paddingMode);\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_ConvTranspose2d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nTensor THSNN_ConvTranspose2d_bias(const NNModule module)\n{\n return get_bias(module);\n}\n\nvoid THSNN_ConvTranspose2d_set_bias(const NNModule module, const Tensor bias)\n{\n set_bias(module, bias);\n}\n\nTensor THSNN_ConvTranspose2d_weight(const NNModule module)\n{\n return get_weight(module);\n}\n\nvoid THSNN_ConvTranspose2d_set_weight(const NNModule module, const Tensor weight)\n{\n set_weight(module, weight);\n}\n\nNNModule THSNN_ConvTranspose3d_ctor(const int64_t inputChannel, const int64_t outputChannel,\n const int64_t kernelSize, const int64_t stride, const int64_t padding, const int64_t output_padding,\n const int64_t dilation, const int64_t paddingMode, const int64_t groups, const bool bias,\n NNAnyModule* outAsAnyModule)\n{\n CATCH_RETURN_NNModule(\n auto opts = torch::nn::ConvTranspose3dOptions(inputChannel, outputChannel, kernelSize)\n .stride(stride)\n .padding(padding)\n .dilation(dilation)\n .groups(groups)\n .bias(bias)\n .output_padding(output_padding);\n ApplyPaddingMode(opts, paddingMode);\n\n res = create_module(opts, outAsAnyModule);\n );\n}\n\nTensor THSNN_ConvTranspose3d_bias(const NNModule module)\n{\n return get_bias(module);\n}\n\nvoid THSNN_ConvTranspose3d_set_bias(const NNModule module, const Tensor bias)\n{\n set_bias(module, bias);\n}\n\nTensor THSNN_ConvTranspose3d_forward(const NNModule module, const Tensor tensor)\n{\n CATCH_TENSOR((*module)->as()->forward(*tensor));\n}\n\nTensor THSNN_ConvTranspose3d_weight(const NNModule module)\n{\n return get_weight(module);\n}\n\nvoid THSNN_ConvTranspose3d_set_weight(const NNModule module, const Tensor weight)\n{\n set_weight(module, weight);\n}\n"},{"alpha_fraction":0.7513944506645203,"alphanum_fraction":0.7641434073448181,"avg_line_length":43.29411697387695,"blob_id":"ad82228860773a71eb344eccd4a8592acc6c7816","content_id":"a2610eca553080496e1d69c83d4979668d55b100","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C","length_bytes":3765,"license_type":"permissive","max_line_length":241,"num_lines":85,"path":"/src/Native/LibTorchSharp/THSJIT.h","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\n#pragma once\n\n#include \"../Stdafx.h\"\n\n#include \"torch/script.h\"\n\n#include \"Utils.h\"\n\n// Copied from libtorch to share the type as an int8_t.\nenum TypeKind : int8_t {\n#define DEFINE_TYPE(T) T,\n C10_FORALL_TYPES(DEFINE_TYPE)\n#undef DEFINE_TYPE\n};\n\n// API.\n\nstruct TensorOrScalar\n{\n int64_t TypeCode;\n int64_t ArrayIndex;\n ptrdiff_t Handle;\n};\n\n\nEXPORT_API(JITModule) THSJIT_load(const char* filename, int64_t device, int64_t index);\nEXPORT_API(void) THSJIT_save(JITModule module, const char* filename);\nEXPORT_API(JITCompilationUnit) THSJIT_compile(const char* script);\n\nEXPORT_API(void) THSJIT_Module_dispose(const JITModule module);\nEXPORT_API(void) THSJIT_CompilationUnit_dispose(const JITCompilationUnit module);\n\nEXPORT_API(int) THSJIT_Module_num_inputs(const JITModule method);\nEXPORT_API(int) THSJIT_Module_num_outputs(const JITModule method);\n\nEXPORT_API(void) THSJIT_Module_forward(const JITModule module, const TensorOrScalar* tensorPtrs, const int length, TensorOrScalar* (*allocator)(int32_t idx, size_t length), int8_t* typeCode, int32_t idx);\nEXPORT_API(void) THSJIT_Module_invoke(const JITModule module, const char* name, const TensorOrScalar* tensorPtrs, const int length, TensorOrScalar* (*allocator)(int32_t idx, size_t length), int8_t* typeCode, int32_t idx);\n\nEXPORT_API(void) THSJIT_CompilationUnit_Invoke(const JITCompilationUnit module, const char* method, const TensorOrScalar* tensorPtrs, const int length, TensorOrScalar* (*allocator)(int32_t idx, size_t length), int8_t* typeCode, int32_t idx);\n\nEXPORT_API(int) THSJIT_Module_is_training(JITModule module);\nEXPORT_API(void) THSJIT_Module_train(JITModule module, bool on);\nEXPORT_API(void) THSJIT_Module_eval(JITModule module);\n\nEXPORT_API(void) THSJIT_Module_to_device_dtype(JITModule module, int8_t dtype, int64_t device, int64_t index);\nEXPORT_API(void) THSJIT_Module_to_device(JITModule module, int64_t device, int64_t index);\nEXPORT_API(void) THSJIT_Module_to_dtype(JITModule module, int8_t dtype);\n\nEXPORT_API(JITType) THSJIT_Module_getInputType(JITModule module, int8_t dtype);\n\nEXPORT_API(int8_t) THSJIT_Type_kind(JITType handle);\nEXPORT_API(void*) THSJIT_Type_cast(const JITType type);\n\nEXPORT_API(int8_t) THSJIT_TensorType_dtype(const JITTensorType type);\nEXPORT_API(void) THSJIT_TensorType_sizes(const JITTensorType type, int64_t* (*allocator)(int64_t length));\n\nEXPORT_API(void) THSJIT_Type_dispose(const JITType type);\nEXPORT_API(void) THSJIT_TensorType_dispose(const JITTensorType type);\n\nEXPORT_API(void) THSJIT_Module_modules(const JITModule module, JITModule* (*allocator)(size_t length));\nEXPORT_API(void) THSJIT_Module_named_modules(const JITModule module,\n JITModule* (*allocator)(size_t length),\n const char** (*allocator2)(size_t length));\n\nEXPORT_API(void) THSJIT_Module_named_children(const JITModule module,\n JITModule* (*allocator)(size_t length),\n const char** (*allocator2)(size_t length));\n\nEXPORT_API(JITMethod) THSJIT_Module_get_method(const JITModule module, const char* name);\n\nEXPORT_API(void) THSJIT_Module_parameters(const JITModule module, Tensor* (*allocator)(size_t length));\nEXPORT_API(void) THSJIT_Module_named_parameters(const JITModule module,\n Tensor* (*allocator)(size_t length),\n const char** (*allocator2)(size_t length));\n\nEXPORT_API(void) THSJIT_Module_named_buffers(const JITModule module,\n Tensor* (*allocator)(size_t length),\n const char** (*allocator2)(size_t length));\n\nEXPORT_API(int) THSJIT_Method_num_inputs(const JITMethod method);\n\nEXPORT_API(void) THSJIT_Method_dispose(const JITMethod method);\n\nEXPORT_API(const char*) THSJIT_Method_name(const JITMethod method);\n"},{"alpha_fraction":0.6331987977027893,"alphanum_fraction":0.6352169513702393,"avg_line_length":40.3125,"blob_id":"07afdd45ed80d06eac1a840ebb05273477fcea3b","content_id":"4a2b244a97522255f43d3f133d199bd10dbcce53","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":1982,"license_type":"permissive","max_line_length":117,"num_lines":48,"path":"/src/TorchSharp/ThreadDisposeScopeStatistics.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"#nullable enable\nnamespace TorchSharp\n{\n /// \n /// Keeps track of statistics for a dispose scope. Can be queried to figure out performance/memory issues.\n /// \n public class ThreadDisposeScopeStatistics\n {\n /// \n /// The number of disposables that were created on this thread, but weren't captured by a DisposeScope.\n /// \n public long CreatedOutsideScopeCount { get; internal set; }\n\n /// \n /// The number of disposables that were created on this thread and were captured by a DisposeScope.\n /// \n public long CreatedInScopeCount { get; internal set; }\n\n /// \n /// The number of disposables that were disposed on this thread and were disposed while in a DisposeScope.\n /// \n public long DisposedInScopeCount { get; internal set; }\n\n /// \n /// Number of disposables that were once included in the scope, but were subsequently detached.\n /// \n public long DetachedFromScopeCount { get; internal set; }\n\n /// \n /// The number of disposables that are currently live on the current thread. If a It's aproximate, see\n /// Tensor.TotalCount. Disposables that weren't created within a DisposeScope, or detached from the dispose\n /// scope, will not be counted as alive.\n /// \n public long ThreadTotalLiveCount => CreatedInScopeCount - DisposedInScopeCount - DetachedFromScopeCount;\n\n /// \n /// Resets the counts for the current thread. See ThreadTotalLiveCount etc. Mainly used in tests to make sure\n /// we get a clean slate on the thread.\n /// \n public void Reset()\n {\n CreatedOutsideScopeCount = 0;\n CreatedInScopeCount = 0;\n DisposedInScopeCount = 0;\n DetachedFromScopeCount = 0;\n }\n }\n}"},{"alpha_fraction":0.5151354074478149,"alphanum_fraction":0.5264205932617188,"avg_line_length":42.2931022644043,"blob_id":"be2b0ba50ddf365ffbcc0593ba07837aef4ce7b5","content_id":"53cccf5fa827536eea4ebdcc9b6fcb196152bee0","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":7532,"license_type":"permissive","max_line_length":140,"num_lines":174,"path":"/src/TorchAudio/Transforms/InverseMelScale.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\n\n// A number of implementation details in this file have been translated from the Python version of torchaudio,\n// largely located in the files found in this folder:\n//\n// https://github.com/pytorch/audio/blob/bb77cbebb620a46fdc0dc7e6dae2253eef3f37e2/torchaudio/transforms/_transforms.py\n//\n// The origin has the following copyright notice and license:\n//\n// https://github.com/pytorch/audio/blob/main/LICENSE\n//\n\nusing System;\nusing System.Collections.Generic;\nusing static TorchSharp.torch;\nusing static TorchSharp.torch.nn;\nusing static TorchSharp.torchaudio;\nusing F = TorchSharp.torchaudio.functional;\n\nnamespace TorchSharp\n{\n namespace Transforms\n {\n public sealed class InverseMelScale : Module, ITransform\n {\n public readonly double f_max;\n public readonly double f_min;\n public readonly long max_iter;\n public readonly long n_mels;\n public readonly long sample_rate;\n public readonly double tolerance_change;\n public readonly double tolerance_loss;\n public readonly Tensor fb;\n\n protected override void Dispose(bool disposing)\n {\n if (disposing) {\n fb.Dispose();\n }\n base.Dispose(disposing);\n }\n\n internal InverseMelScale(\n string name,\n long n_stft,\n long n_mels = 128,\n long sample_rate = 16000,\n double f_min = 0.0,\n double? f_max = null,\n long max_iter = 100000,\n double tolerance_loss = 1e-05,\n double tolerance_change = 1e-08,\n MelNorm norm = MelNorm.none,\n torchaudio.MelScale mel_scale = torchaudio.MelScale.htk) : base(name)\n {\n this.n_mels = n_mels;\n this.sample_rate = sample_rate;\n this.f_max = f_max ?? (sample_rate / 2);\n this.f_min = f_min;\n this.max_iter = max_iter;\n this.tolerance_loss = tolerance_loss;\n this.tolerance_change = tolerance_change;\n\n if (f_min > this.f_max) {\n throw new ArgumentException($\"Require f_min: {this.f_min} <= f_max: {this.f_max}\");\n }\n\n this.fb = F.melscale_fbanks(n_stft, this.f_min, this.f_max, this.n_mels, this.sample_rate, norm, mel_scale);\n this.register_buffer(\"fb\", this.fb);\n }\n\n /// A Mel frequency spectrogram of dimension (..., ``n_mels``, time)\n /// Linear scale spectrogram of size (..., freq, time) \n /// { specgram },\n learningRate: 0.1, momentum: 0.9);\n\n var loss = float.PositiveInfinity;\n for (long i = 0; i < this.max_iter; i++) {\n optim.zero_grad();\n var diff = melspec - specgram.matmul(this.fb);\n var new_loss = diff.pow(2).sum(dim: -1).mean();\n // take sum over mel-frequency then average over other dimensions\n // so that loss threshold is applied par unit timeframe\n new_loss.backward();\n optim.step();\n using (torch.no_grad())\n specgram.set_(specgram.clamp(min: 0));\n\n var new_loss_value = new_loss.item();\n if (new_loss_value < this.tolerance_loss || Math.Abs(loss - new_loss_value) < this.tolerance_change) {\n break;\n }\n loss = new_loss_value;\n }\n\n specgram.requires_grad_(false);\n var specgram_tensor = specgram.clamp(min: 0).transpose(-1, -2);\n\n // unpack batch\n shape[shape.Length - 2] = freq;\n shape[shape.Length - 1] = time;\n specgram_tensor = specgram_tensor.view(shape);\n return specgram_tensor;\n }\n }\n }\n\n public partial class torchaudio\n {\n public partial class transforms\n {\n /// \n /// Estimate a STFT in normal frequency domain from mel frequency domain.\n /// It minimizes the euclidian norm between the input mel-spectrogram and the product between\n /// the estimated spectrogram and the filter banks using SGD.\n /// \n /// Number of bins in STFT. See ``n_fft`` in :class:`Spectrogram`.\n /// Number of mel filterbanks.\n /// Sample rate of audio signal.\n /// Minimum frequency.\n /// Maximum frequency.\n /// Maximum number of optimization iterations.\n /// Value of loss to stop optimization at.\n /// Difference in losses to stop optimization at.\n /// If 'slaney', divide the triangular mel weights by the width of the mel band (area normalization).\n /// Scale to use: ``htk`` or ``slaney``.\n /// \n /// Converts boxes from given in_fmt to out_fmt.\n /// Supported in_fmt and out_fmt are:\n ///\n /// 'xyxy': boxes are represented via corners, x1, y1 being top left and x2, y2 being bottom right. This is the format that torchvision utilities expect.\n /// 'xywh' : boxes are represented via corner, width and height, x1, y2 being top left, w, h being width and height.\n /// 'cxcywh' : boxes are represented via centre, width and height, cx, cy being center of box, w, h being width and height.\n /// \n /// Boxes which will be converted\n /// Input format of given boxes.\n /// Output format of given boxes.\n /// \n /// Computes the area of a set of bounding boxes, which are specified by their (x1, y1, x2, y2) coordinates.\n /// \n /// Boxes for which the area will be computed. They are expected to be in (x1, y1, x2, y2) format.\n /// \n /// Return intersection-over-union (Jaccard index) between two sets of boxes.\n /// \n /// First set of boxes\n /// Second set of boxes\n /// The NxM matrix containing the pairwise IoU values for every element in boxes1 and boxes2 \n public static Tensor box_iou(Tensor boxes1, Tensor boxes2)\n {\n var inter = _box_inter_union(boxes1, boxes2, out var union);\n return inter / union;\n }\n\n /// \n /// Return generalized intersection-over-union (Jaccard index) between two sets of boxes.\n /// \n /// First set of boxes\n /// Second set of boxes\n /// The NxM matrix containing the pairwise generalized IoU values for every element in boxes1 and boxes2 \n public static Tensor generalized_box_iou(Tensor boxes1, Tensor boxes2)\n {\n using var _ = NewDisposeScope();\n var inter = _box_inter_union(boxes1, boxes2, out var union);\n var iou = inter / union;\n\n var lti = torch.min(boxes1[colon, None, (null, 2)], boxes2[colon, (null, 2)]);\n var rbi = torch.max(boxes1[colon, None, (2, null)], boxes2[colon, (2, null)]);\n\n var whi = _upcast(rbi - lti).clamp(min: 0); // [N,M,2]\n var areai = whi[colon, colon, 0] * whi[colon, colon, 1];\n\n return (iou - (areai - union) / areai).MoveToOuterDisposeScope();\n }\n\n /// \n /// Return complete intersection-over-union (Jaccard index) between two sets of boxes.\n /// \n /// First set of boxes\n /// Second set of boxes\n /// Small number to prevent division by zero\n /// The NxM matrix containing the complete distance IoU values for every element in boxes1 and boxes2 \n public static Tensor complete_box_iou(Tensor boxes1, Tensor boxes2, double eps = 1e-7)\n {\n using var _ = NewDisposeScope();\n boxes1 = _upcast(boxes1);\n boxes2 = _upcast(boxes2);\n\n var diou = _box_diou_iou(boxes1, boxes2, out Tensor iou, eps);\n\n var w_pred = boxes1[colon, None, 2] - boxes1[colon, None, 0];\n var h_pred = boxes1[colon, None, 3] - boxes1[colon, None, 1];\n\n var w_gt = boxes2[colon, 2] - boxes2[colon, 0];\n var h_gt = boxes2[colon, 3] - boxes2[colon, 1];\n\n var v = (4 / (Math.Pow(Math.PI, 2))) * torch.pow(torch.atan(w_pred / h_pred) - torch.atan(w_gt / h_gt), 2);\n\n Tensor alpha;\n\n using (var ng = torch.no_grad()) {\n alpha = v / (1 - iou + v + eps);\n }\n return (diou - alpha * v).MoveToOuterDisposeScope();\n }\n\n\n /// \n /// Return generalized intersection-over-union (Jaccard index) between two sets of boxes.\n /// \n /// First set of boxes\n /// Second set of boxes\n /// Small number to prevent division by zero\n /// The NxM matrix containing the pairwise distance IoU values for every element in boxes1 and boxes2 \n public static Tensor distance_box_iou(Tensor boxes1, Tensor boxes2, double eps = 1e-7)\n {\n using var _ = NewDisposeScope();\n boxes1 = _upcast(boxes1);\n boxes2 = _upcast(boxes2);\n var diou = _box_diou_iou(boxes1, boxes2, out var _, eps: eps);\n return diou.MoveToOuterDisposeScope();\n }\n\n /// \n /// Compute the bounding boxes around the provided masks.\n /// \n /// masks to transform where N is the number of masks and (H, W) are the spatial dimensions.\n /// A [N, 4] tensor containing bounding boxes. The boxes are in the (x1, y1, x2, y2) format \n /// Raised if the input is not a three-dimensional tensor. \n public static Tensor masks_to_boxes(Tensor masks)\n {\n if (masks.ndim != 3) throw new ArgumentException(\"'masks' should have three dimensions: NxHxW\");\n if (masks.numel() == 0) {\n return torch.zeros(0, 4, device: masks.device, dtype: torch.float32);\n }\n\n var n = masks.shape[0];\n var bounding_boxes = torch.zeros(n, 4, device: masks.device, dtype: torch.float32);\n\n for (int i = 0;i < n; i++) {\n var yx = torch.where(masks[i] != 0);\n bounding_boxes[i, 0] = torch.min(yx[1]);\n bounding_boxes[i, 1] = torch.min(yx[0]);\n bounding_boxes[i, 2] = torch.max(yx[1]);\n bounding_boxes[i, 3] = torch.max(yx[0]);\n }\n return bounding_boxes;\n }\n\n private static Tensor _box_inter_union(Tensor boxes1, Tensor boxes2, out Tensor union)\n {\n var area1 = box_area(boxes1);\n var area2 = box_area(boxes2);\n\n var lt = torch.max(boxes1[colon, None, (null, 2)], boxes2[colon, (null, 2)]); // [N,M,2];\n var rb = torch.min(boxes1[colon, None, (2, null)], boxes2[colon, (2, null)]); // [N,M,2];\n\n var wh = _upcast(rb - lt).clamp(min: 0); // [N,M,2];\n var inter = wh[colon, colon, 0] * wh[colon, colon, 1]; // [N,M];\n\n union = area1[colon, None] + area2 - inter;\n return inter;\n }\n\n private static Tensor _box_diou_iou(Tensor boxes1, Tensor boxes2, out Tensor iou, double eps = 1e-7)\n {\n iou = box_iou(boxes1, boxes2);\n var lti = torch.min(boxes1[colon, None, (null, 2)], boxes2[colon, (null, 2)]);\n var rbi = torch.max(boxes1[colon, None, (2, null)], boxes2[colon, (2, null)]);\n var whi = _upcast(rbi - lti).clamp(min: 0); // [N,M,2];\n var diagonal_distance_squared = whi[colon, colon, 0].pow(2) + whi[colon, colon, 1].pow(2) + eps;\n // centers of boxes\n var x_p = (boxes1[colon, 0] + boxes1[colon, 2]) / 2;\n var y_p = (boxes1[colon, 1] + boxes1[colon, 3]) / 2;\n var x_g = (boxes2[colon, 0] + boxes2[colon, 2]) / 2;\n var y_g = (boxes2[colon, 1] + boxes2[colon, 3]) / 2;\n // The distance between boxes' centers squared.\n var centers_distance_squared = _upcast((x_p[colon, None] - x_g[None, colon])).pow(2) + _upcast((y_p[colon, None] - y_g[None, colon])).pow(2);\n // The distance IoU is the IoU penalized by a normalized\n // distance between boxes' centers squared.\n return iou - (centers_distance_squared / diagonal_distance_squared);\n }\n\n public enum BoxFormats\n {\n xyxy, xywh, cxcywh\n }\n\n private static TensorIndex colon = TensorIndex.Colon;\n private static TensorIndex None = TensorIndex.None;\n }\n }\n}\n"},{"alpha_fraction":0.5940752625465393,"alphanum_fraction":0.6172938346862793,"avg_line_length":32.53020095825195,"blob_id":"2c92de7a2557dbdcc81b9be1ca2150af183fbbe4","content_id":"1bf14cab930ead617b095000c7e8e12984aee989","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":4996,"license_type":"permissive","max_line_length":99,"num_lines":149,"path":"/test/TorchSharpTest/pyimporttest.py","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"from collections import OrderedDict\n\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\n\nimport importsd\n\n\nNUM_WORDS = 100\nEMBEDDING_VEC_LEN = 100\nHIDDEN_SIZE = 128\n\n\nclass LSTMModel(nn.Module):\n # The names of properties should be the same in C# and Python\n # otherwise, you have to manually change the key name in the state_dict\n def __init__(self):\n super(LSTMModel, self).__init__()\n self.embedding = nn.Embedding(NUM_WORDS, EMBEDDING_VEC_LEN)\n self.lstm = nn.LSTM(EMBEDDING_VEC_LEN, HIDDEN_SIZE, batch_first=True)\n self.dropout = nn.Dropout(0.5)\n self.dense = nn.Linear(HIDDEN_SIZE, 1)\n self.sigmoid = nn.Sigmoid()\n\n def forward(self, x):\n x_embed = self.embedding(x)\n x_lstm, _ = self.lstm(x_embed)\n x_lstm_last_seq = x_lstm[:, -1, :]\n x_lstm_last_seq = self.dropout(x_lstm_last_seq)\n logits = self.dense(x_lstm_last_seq)\n out = self.sigmoid(logits)\n return out\n\n\nclass LeNet1Model(nn.Module):\n # The names of properties should be the same in C# and Python\n # in this case, we both name the Sequential as layers\n def __init__(self):\n super(LeNet1Model, self).__init__()\n # the names of each layer should also be the same in C# and Python\n modules = OrderedDict([\n (\"conv-1\", nn.Conv2d(1, 4, 5, padding=2)),\n (\"bnrm2d-1\", nn.BatchNorm2d(4)),\n (\"relu-1\", nn.ReLU()),\n (\"maxpool-1\", nn.MaxPool2d(2, stride=2)),\n (\"conv-2\", nn.Conv2d(4, 12, 5)),\n (\"bnrm2d-2\", nn.BatchNorm2d(12)),\n (\"relu-2\", nn.ReLU()),\n (\"maxpool-2\", nn.MaxPool2d(2, stride=2)),\n (\"flatten\", nn.Flatten()),\n (\"linear\", nn.Linear(300, 10)),\n ])\n self.layers = nn.Sequential(modules)\n\n def forward(self, x):\n return self.layers.forward(x)\n\n\ndef testLSTM():\n print(\"testing LSTM\")\n mylstm = LSTMModel()\n with open(\"lstm.dat\", \"rb\") as f:\n sd = importsd.load_state_dict(f)\n # you can change the loaded key names here, for example:\n # sd = {k + \"py\": v for k, v in sd}\n # you can check the key names of state_dict in python by:\n # print(mylstm.state_dict())\n mylstm.load_state_dict(sd)\n\n # init values & functions\n torch.manual_seed(0)\n np.random.seed(0)\n labels = torch.tensor(np.random.randint(0, 1, [100, 1]), dtype=torch.float)\n inputs = torch.tensor(np.random.randint(0, 100, [100, 100]))\n opt = optim.Adam(mylstm.parameters(), lr=8e-5)\n loss_func = nn.BCELoss()\n\n # evaluation before training\n mylstm.eval()\n preds = mylstm.forward(inputs)\n preds = torch.round(preds)\n correct_num = torch.sum(preds == labels).item()\n print(f\"before training: {correct_num} corrected\")\n\n # training for 50 steps\n mylstm.train()\n for i in range(50):\n opt.zero_grad() # Reset the gradient in every iteration\n outputs = mylstm(inputs)\n loss = loss_func(outputs, labels) # Loss forward pass\n loss.backward() # Loss backaed pass\n opt.step() # Update all the parameters by the given learnig rule\n\n # evaluation after training\n mylstm.eval()\n preds = mylstm.forward(inputs)\n preds = torch.round(preds)\n correct_num = torch.sum(preds == labels).item()\n print(f\"after training: {correct_num} corrected\")\n\n\ndef testLeNet1():\n print(\"testing LeNet1\")\n mylenet = LeNet1Model()\n with open(\"lenet1.dat\", \"rb\") as f:\n sd = importsd.load_state_dict(f)\n # you can change the loaded key names here, for example:\n # sd = {k + \"py\": v for k, v in sd}\n # you can check the key names of state_dict in python by:\n # print(mylenet.state_dict())\n mylenet.load_state_dict(sd)\n\n # init values & functions\n torch.manual_seed(0)\n np.random.seed(0)\n labels = torch.tensor(np.random.randint(0, 10, [100]))\n inputs = torch.tensor(np.random.randint(0, 255, [100, 1, 28, 28]) / 255.0, dtype=torch.float32)\n opt = optim.Adam(mylenet.parameters(), lr=8e-5)\n loss_func = nn.CrossEntropyLoss()\n\n # evaluation before training\n mylenet.eval()\n output = mylenet.forward(inputs)\n _, preds = torch.max(output.data, dim=1)\n correct_num = torch.sum(preds == labels).item()\n print(f\"before training: {correct_num} corrected\")\n\n # training for 200 steps\n mylenet.train()\n for i in range(200):\n opt.zero_grad() # Reset the gradient in every iteration\n outputs = mylenet(inputs)\n loss = loss_func(outputs, labels) # Loss forward pass\n loss.backward() # Loss backaed pass\n opt.step() # Update all the parameters by the given learnig rule\n\n # evaluation after training\n mylenet.eval()\n output = mylenet.forward(inputs)\n _, preds = torch.max(output.data, dim=1)\n correct_num = torch.sum(preds == labels).item()\n print(f\"after training: {correct_num} corrected\")\n\n\nif __name__ == '__main__':\n testLSTM()\n testLeNet1()\n"},{"alpha_fraction":0.5116005539894104,"alphanum_fraction":0.5163080096244812,"avg_line_length":37.6298713684082,"blob_id":"4e6bfd60bf576dcac142404bfac714616492790b","content_id":"0e153f7e037a2eff04c00cb6e5aeed9c23bae806","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":5948,"license_type":"permissive","max_line_length":130,"num_lines":154,"path":"/src/TorchVision/Randomizer.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\n\nusing static TorchSharp.torch;\n\n\nnamespace TorchSharp\n{\n public static partial class torchvision\n {\n internal class Randomizer : ITransform\n {\n internal Randomizer(ITransform transform, double p = 0.1)\n {\n this.p = p;\n this.transform = transform;\n }\n\n public Tensor call(Tensor input)\n {\n using (var chance = torch.rand(1))\n\n if (chance.item() < p) {\n return transform.call(input);\n } else {\n return input;\n }\n }\n\n private ITransform transform;\n private double p;\n }\n\n public static partial class transforms\n {\n /// \n /// Randomly apply a transform given a probability.\n /// \n /// The transform that will be applied randomly.\n /// The probablity of applying the transform\n /// This uses the default TorchSharp RNG. \n static public ITransform Randomize(ITransform transform, double p = 0.1)\n {\n return new Randomizer(transform, p);\n }\n\n /// \n /// Posterize the image randomly with a given probability by reducing the number of bits for each color channel. \n /// \n /// Number of bits to keep for each channel (0-8)\n /// Probability of the transform being applied.\n /// The tensor must be an integer tensor \n static public ITransform RandomPosterize(int bits, double p = 0.5)\n {\n return new Randomizer(Posterize(bits), p);\n }\n\n /// \n /// Equalize the image randomly with a given probability. \n /// \n /// Probability of the transform being applied.\n /// The tensor must be an integer tensor \n static public ITransform Equalize(double p = 0.5)\n {\n return new Randomizer(Equalize(), p);\n }\n\n /// \n /// Solarize the image randomly with a given probability by inverting all pixel values above a threshold.\n /// \n /// All pixels equal or above this value are inverted.\n /// Probability of the transform being applied.\n /// \n /// \n /// \n /// Probability of the transform being applied.\n /// \n /// \n /// \n /// Probability of the transform being applied.\n /// \n /// \n /// \n /// Probability of the transform being applied.\n /// \n /// Adjust the sharpness of the image randomly with a given probability. \n /// \n /// The sharpness factor\n /// Probability of the transform being applied.\n /// \n /// \n /// \n /// Probability of the transform being applied.\n /// \n /// \n /// \n /// Probability of the transform being applied.\n /// \n /// Apply randomly a list of transformations with a given probability.\n /// \n /// A list of transforms to compose serially.\n /// Probability of the transforms being applied.\n /// \n /// Scale type of mel filterbanks\n /// \n public enum MelScale\n {\n slaney,\n htk\n }\n }\n}"},{"alpha_fraction":0.7017045617103577,"alphanum_fraction":0.7017045617103577,"avg_line_length":24.214284896850586,"blob_id":"7f197adec0be9a871b7c046cbf103f45f993681c","content_id":"4505451f652ccebecc58ce450c5a3ba2a18ebbf9","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":352,"license_type":"permissive","max_line_length":130,"num_lines":14,"path":"/src/TorchAudio/Transforms/ITransform.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\n\nusing static TorchSharp.torch;\nusing static TorchSharp.torch.nn;\n\nnamespace TorchSharp\n{\n public partial class torchaudio\n {\n public interface ITransform : IModule\n {\n }\n }\n}"},{"alpha_fraction":0.6907563209533691,"alphanum_fraction":0.6941176652908325,"avg_line_length":26.045454025268555,"blob_id":"f9e25e86405b9b91a2f7adf77f3d9cfca4e24108","content_id":"740fc71d2a1e639d4cf824d1eee1675c13950f4b","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":595,"license_type":"permissive","max_line_length":130,"num_lines":22,"path":"/src/Native/LibTorchSharp/Utils.cpp","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\n#include \"Utils.h\"\n\n#include \n#include \n#if _WINDOWS\n#include \n#define TP_CoTaskMemAlloc(t) CoTaskMemAlloc(t)\n#else\n#define TP_CoTaskMemAlloc(t) malloc(t)\n#endif\n\nthread_local char * torch_last_err = nullptr;\n\nconst char * make_sharable_string(const std::string str)\n{\n size_t n = str.length();\n char* result = (char *)TP_CoTaskMemAlloc(n + 1); \n strncpy(result, str.c_str(), n);\n result[n] = '\\0';\n return result;\n}\n"},{"alpha_fraction":0.5925925970077515,"alphanum_fraction":0.595678985118866,"avg_line_length":31.399999618530273,"blob_id":"3b28b40671e0eaca3666fefca066870f738848b6","content_id":"8d93f7de1dccb3b78515b0f6d06b3ca4b64b9d17","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":648,"license_type":"permissive","max_line_length":130,"num_lines":20,"path":"/src/Examples/Program.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\n\nnamespace TorchSharp.Examples\n{\n public static class Program\n {\n public static void Main(string[] args)\n {\n //MNIST.Main(args);\n //AdversarialExampleGeneration.Main(args);\n CIFAR10.Main(args);\n //SequenceToSequence.Main(args);\n //TextClassification.Main(args);\n //ImageTransforms.Main(args);\n //SpeechCommands.Main(args);\n IOReadWrite.Main(args);\n Tensorboard.Main(args).Wait();\n }\n }\n}\n"},{"alpha_fraction":0.6174419522285461,"alphanum_fraction":0.621430516242981,"avg_line_length":52.49214553833008,"blob_id":"9fdcf0e95ca2bb4c20b3e73902726533fce1d061","content_id":"fb4568b5c73292578f63e34c7406b7e4ec92ddd0","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":40897,"license_type":"permissive","max_line_length":254,"num_lines":764,"path":"/src/TorchSharp/Tensor/torch.OtherOperations.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\n#nullable enable\nusing System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing TorchSharp.PInvoke;\nusing static TorchSharp.PInvoke.NativeMethods;\n\nnamespace TorchSharp\n{\n // https://pytorch.org/docs/stable/torch#other-operations\n public static partial class torch\n {\n // https://pytorch.org/docs/stable/generated/torch.atleast_1d\n /// \n /// Returns a 1-dimensional view of each input tensor with zero dimensions. Input tensors with one or more dimensions are returned as-is.\n /// \n public static IEnumerable atleast_1d(params Tensor[] input) => input.Select(t => t.atleast_1d());\n\n // https://pytorch.org/docs/stable/generated/torch.atleast_2d\n /// \n /// Returns a 2-dimensional view of each input tensor with zero or one dimensions. Input tensors with two or more dimensions are returned as-is.\n /// \n public static IEnumerable atleast_2d(params Tensor[] input) => input.Select(t => t.atleast_2d());\n\n // https://pytorch.org/docs/stable/generated/torch.atleast_3d\n /// \n /// Returns a 1-dimensional view of each input tensor with fewer than three dimensions. Input tensors with three or more dimensions are returned as-is.\n /// \n public static IEnumerable atleast_3d(params Tensor[] input) => input.Select(t => t.atleast_3d());\n\n // https://pytorch.org/docs/stable/generated/torch.bincount\n /// \n /// Count the frequency of each value in an array of non-negative ints.\n /// \n public static Tensor bincount(Tensor input, Tensor? weights = null, long minlength = 0) => input.bincount(weights, minlength);\n\n // https://pytorch.org/docs/stable/generated/torch.block_diag\n /// \n /// Create a block diagonal matrix from provided tensors.\n /// \n /// One or more tensors with 0, 1, or 2 dimensions.\n /// ();\n IntPtr tensorsRef = parray.CreateArray(tensors.Select(p => p.Handle).ToArray());\n\n var res = THSTensor_block_diag(tensorsRef, parray.Array.Length);\n if (res == IntPtr.Zero) { CheckForErrors(); }\n return new Tensor(res);\n }\n\n // https://pytorch.org/docs/stable/generated/torch.broadcast_tensors\n /// \n /// Broadcasts the given tensors according to Torch broadcasting semantics.\n /// \n /// Any number of tensors of the same type\n public static IList broadcast_tensors(params Tensor[] tensors)\n {\n if (tensors.Length == 0) {\n throw new ArgumentException(nameof(tensors));\n }\n if (tensors.Length == 1) {\n return tensors;\n }\n\n IntPtr[] ptrArray;\n\n using (var pa = new PinnedArray())\n using (var parray = new PinnedArray()) {\n\n IntPtr tensorsRef = parray.CreateArray(tensors.Select(p => p.Handle).ToArray());\n\n THSTensor_broadcast_tensors(tensorsRef, tensors.Length, pa.CreateArray);\n CheckForErrors();\n ptrArray = pa.Array;\n }\n\n return ptrArray.Select(x => new Tensor(x)).ToList();\n }\n\n // https://pytorch.org/docs/stable/generated/torch.broadcast_to\n public static Tensor broadcast_to(Tensor input, params long[] shape) => input.broadcast_to(shape);\n\n // https://pytorch.org/docs/stable/generated/torch.broadcast_shapes\n /// \n /// This is equivalent to \n /// Shapes of tensors\n /// A shape compatible with all input shapes \n /// If shapes are incompatible. \n public static Size broadcast_shapes(params long[][] shapes)\n {\n var max_len = 0;\n foreach (var shape in shapes) {\n var s = shape.Length;\n if (s > max_len) max_len = s;\n }\n\n var result = Enumerable.Repeat(1, max_len).ToArray();\n\n foreach (var shape in shapes) {\n for (var i = shape.Length - 1; i >= 0; i--) {\n if (shape.Length == 0 || shape[i] == 1 || shape[i] == result[i])\n continue;\n if (result[i] != 1)\n throw new ArgumentException(\"Shape mismatch: objects cannot be broadcast to a single shape\");\n result[i] = shape[i];\n }\n }\n return result;\n }\n\n // https://pytorch.org/docs/stable/generated/torch.bucketize\n public static Tensor bucketize(Tensor input, Tensor boundaries, bool outInt32 = false, bool right = false)\n => input.bucketize(boundaries, outInt32, right);\n\n // https://pytorch.org/docs/stable/generated/torch.cartesian_prod\n /// \n /// Do cartesian product of the given sequence of tensors.\n /// \n /// \n public static Tensor cartesian_prod(IList tensors)\n {\n using var parray = new PinnedArray();\n IntPtr tensorsRef = parray.CreateArray(tensors.Select(p => p.Handle).ToArray());\n\n var res = THSTensor_cartesian_prod(tensorsRef, parray.Array.Length);\n if (res == IntPtr.Zero) { torch.CheckForErrors(); }\n return new Tensor(res);\n }\n\n // https://pytorch.org/docs/stable/generated/torch.cartesian_prod\n /// \n /// Do cartesian product of the given sequence of tensors.\n /// \n /// \n public static Tensor cartesian_prod(params Tensor[] tensors) => cartesian_prod((IList)tensors);\n\n // https://pytorch.org/docs/stable/generated/torch.cdist\n /// \n /// Computes batched the p-norm distance between each pair of the two collections of row vectors.\n /// \n /// Input tensor of shape BxPxM\n /// Input tensor of shape BxRxM\n /// p value for the p-norm distance to calculate between each vector (p > 0)\n /// \n /// use_mm_for_euclid_dist_if_necessary - will use matrix multiplication approach to calculate euclidean distance (p = 2) if P > 25 or R > 25\n /// use_mm_for_euclid_dist - will always use matrix multiplication approach to calculate euclidean distance (p = 2)\n /// donot_use_mm_for_euclid_dist - will never use matrix multiplication approach to calculate euclidean distance (p = 2)\n /// \n /// \n /// Compute combinations of length r of the given tensor\n /// \n /// 1D vector.\n /// Number of elements to combine\n /// Whether to allow duplication in combination\n /// \n /// Estimates the covariance matrix of the variables given by the input matrix, where rows are the variables and columns are the observations.\n /// \n /// The input tensor\n /// \n /// Difference between the sample size and sample degrees of freedom.\n /// Defaults to Bessel’s correction, correction = 1 which returns the unbiased estimate,\n /// even if both fweights and aweights are specified.\n /// Correction = 0 will return the simple average.\n /// \n /// \n /// A Scalar or 1D tensor of observation vector frequencies representing the number of times each observation should be repeated.\n /// Its numel must equal the number of columns of input.\n /// Must have integral dtype.\n /// A Scalar or 1D array of observation vector weights.\n /// These relative weights are typically large for observations considered “important” and smaller for\n /// observations considered less “important”.\n /// Its numel must equal the number of columns of input.\n /// Must have floating point dtype.\n public static Tensor cov(Tensor input, long correction = 1, Tensor? fweights = null, Tensor? aweights = null)\n => input.cov(correction, fweights, aweights);\n\n // https://pytorch.org/docs/stable/generated/torch.cross\n /// \n /// Returns the cross product of vectors in dimension dim of input and other.\n /// input and other must have the same size, and the size of their dim dimension should be 3.\n /// \n public static Tensor cross(Tensor input, Scalar other, long dim = 0L) => input.cross(other, dim);\n\n // https://pytorch.org/docs/stable/generated/torch.cummax\n public static (Tensor values, Tensor indices) cummax(Tensor input, long dim) => input.cummax(dim);\n\n // https://pytorch.org/docs/stable/generated/torch.cummin\n public static (Tensor values, Tensor indices) cummin(Tensor input, long dim) => input.cummin(dim);\n\n // https://pytorch.org/docs/stable/generated/torch.cumprod\n public static Tensor cumprod(Tensor input, long dim, ScalarType? dtype = null) => input.cumprod(dim, dtype);\n\n // https://pytorch.org/docs/stable/generated/torch.cumsum\n /// \n /// Returns the cumulative sum of elements of input in the dimension dim.\n /// \n /// The input tensor.\n /// The dimension to do the operation over\n /// The desired data type of returned tensor. If specified, the input tensor is casted to dtype before the operation is performed.\n /// This is useful for preventing data type overflows.\n public static Tensor cumsum(Tensor input, long dim, ScalarType? type = null) => input.cumsum(dim, type);\n\n // https://pytorch.org/docs/stable/generated/torch.diag\n /// \n /// If input is a vector (1-D tensor), then returns a 2-D square tensor with the elements of input as the diagonal.\n /// If input is a matrix (2-D tensor), then returns a 1-D tensor with the diagonal elements of input.\n /// \n /// The input tensor.\n /// \n /// The argument diagonal controls which diagonal to consider:\n /// If diagonal is 0, it is the main diagonal.\n /// If diagonal is greater than 0, it is above the main diagonal.\n /// If diagonal is less than 0, it is below the main diagonal.\n /// \n public static Tensor diag(Tensor input, long diagonal = 0) => input.diag(diagonal);\n\n // https://pytorch.org/docs/stable/generated/torch.diag_embed\n /// \n /// Creates a tensor whose diagonals of certain 2D planes (specified by dim1 and dim2) are filled by input.\n /// To facilitate creating batched diagonal matrices, the 2D planes formed by the last two dimensions of the returned tensor are chosen by default.\n ///\n /// The argument offset controls which diagonal to consider:\n /// If offset is equal to 0, it is the main diagonal.\n /// If offset is greater than 0, it is above the main diagonal.\n /// If offset is less than 0, it is below the main diagonal.\n ///\n /// The size of the new matrix will be calculated to make the specified diagonal of the size of the last input dimension.Note that for offset other than 0,\n ///\n /// the order of dim1 and dim2 matters.Exchanging them is equivalent to changing the sign of offset.\n /// \n /// The input tensor.\n /// Which diagonal to consider.\n /// First dimension with respect to which to take diagonal. \n /// Second dimension with respect to which to take diagonal\n public static Tensor diag_embed(Tensor input, long offset = 0L, long dim1 = -2L, long dim2 = -1L)\n => input.diag_embed(offset, dim1, dim2);\n\n // https://pytorch.org/docs/stable/generated/torch.diagflat\n /// \n /// If input is a vector (1-D tensor), then returns a 2-D square tensor with the elements of input as the diagonal.\n /// If input is a matrix (2-D tensor), then returns a 2-D tensor with diagonal elements equal to a flattened input.\n /// \n /// The input tensor.\n /// \n /// The argument diagonal controls which diagonal to consider:\n /// If diagonal is 0, it is the main diagonal.\n /// If diagonal is greater than 0, it is above the main diagonal.\n /// If diagonal is less than 0, it is below the main diagonal.\n /// \n public static Tensor diagflat(Tensor input, long offset = 0) => input.diagflat(offset);\n\n // https://pytorch.org/docs/stable/generated/torch.diagonal\n /// \n /// Returns a partial view of input with the its diagonal elements with respect to dim1 and dim2 appended as a dimension at the end of the shape.\n /// The argument offset controls which diagonal to consider:\n ///\n /// If offset == 0, it is the main diagonal.\n /// If offset > 0, it is above the main diagonal.\n /// If offset < 0, it is below the main diagonal.\n /// \n /// The input tensor\n /// Which diagonal to consider. Default: 0 (main diagonal).\n /// First dimension with respect to which to take diagonal. Default: 0.\n /// Second dimension with respect to which to take diagonal. Default: 1.\n /// \n /// Applying torch.diag_embed() to the output of this function with the same arguments yields a diagonal matrix with the diagonal entries of the input.\n /// However, torch.diag_embed() has different default dimensions, so those need to be explicitly specified.\n /// \n public static Tensor diagonal(Tensor input, long offset = 0, long dim1 = 0, long dim2 = 0) => input.diagonal(offset, dim1, dim2);\n\n // https://pytorch.org/docs/stable/generated/torch.diff\n /// \n /// Computes the n-th forward difference along the given dimension.\n /// \n /// The input tensor.\n /// The number of times to recursively compute the difference\n /// The dimension to compute the difference along. Default is the last dimension.\n /// \n /// Values to prepend or append to input along dim before computing the difference.\n /// Their dimensions must be equivalent to that of input, and their shapes must match input’s shape except on dim.\n /// \n /// \n /// Values to prepend or append to input along dim before computing the difference.\n /// Their dimensions must be equivalent to that of input, and their shapes must match input’s shape except on dim.\n /// \n public static Tensor diff(Tensor input, long n = 1, long dim = -1, Tensor? prepend = null, Tensor? append = null) => input.diff(n, dim, prepend, append);\n\n // https://pytorch.org/docs/stable/generated/torch.einsum\n /// \n /// Sums the product of the elements of the input operands along dimensions specified using a notation based on the Einstein summation convention.\n /// \n /// The subscripts for the Einstein summation.\n /// The operands to compute the Einstein sum of.\n /// \n /// Einsum allows computing many common multi-dimensional linear algebraic array operations by representing them in a short-hand format based on the\n /// Einstein summation convention, given by equation.The details of this format are described below, but the general idea is to label every dimension\n /// of the input operands with some subscript and define which subscripts are part of the output. The output is then computed by summing the product\n /// of the elements of the operands along the dimensions whose subscripts are not part of the output.For example, matrix multiplication can be computed\n /// using einsum as torch.einsum(“ij,jk->ik”, A, B). Here, j is the summation subscript and i and k the output subscripts(see section below for more details on why).\n /// \n /// ();\n IntPtr tensorsRef = parray.CreateArray(tensors.Select(p => p.Handle).ToArray());\n\n var res = THSTensor_einsum(equation, tensorsRef, parray.Array.Length);\n if (res == IntPtr.Zero) { CheckForErrors(); }\n return new Tensor(res);\n }\n\n // https://pytorch.org/docs/stable/generated/torch.flatten\n /// \n /// Flattens input by reshaping it into a one-dimensional tensor.\n /// \n /// The input tensor\n /// The first dim to flatten\n /// The last dim to flatten.\n /// Flattening a zero-dimensional tensor will return a one-dimensional view. \n public static Tensor flatten(Tensor input, long start_dim = 0, long end_dim = -1) => input.flatten(start_dim, end_dim);\n\n // https://pytorch.org/docs/stable/generated/torch.flip\n public static Tensor flip(Tensor input, params long[] dims) => input.flip(dims);\n\n // https://pytorch.org/docs/stable/generated/torch.fliplr\n public static Tensor fliplr(Tensor input) => input.fliplr();\n\n // https://pytorch.org/docs/stable/generated/torch.flipud\n public static Tensor flipud(Tensor input) => input.flipud();\n\n // https://pytorch.org/docs/stable/generated/torch.kron\n /// \n /// Computes the Kronecker product of input and other.\n /// \n /// The input tensor.\n /// The second tensor\n public static Tensor kron(Tensor input, Tensor other) => input.kron(other);\n\n // https://pytorch.org/docs/stable/generated/torch.rot90\n /// \n /// Rotate a n-D tensor by 90 degrees in the plane specified by dims axis.\n /// Rotation direction is from the first towards the second axis if k is greater than 0,\n /// and from the second towards the first for k less than 0.\n /// \n /// The input tensor\n /// The number of times to rotate.\n /// Axes to rotate\n public static Tensor rot90(Tensor input, long k = 1, (long, long)? dims = null) => input.rot90(k, dims);\n\n // https://pytorch.org/docs/stable/generated/torch.gcd\n /// \n /// Computes the element-wise greatest common divisor (GCD) of input and other.\n /// \n /// The left-hand operand.\n /// The right-hand operand.\n public static Tensor gcd(Tensor left, Tensor right) => left.gcd(right);\n\n // https://pytorch.org/docs/stable/generated/torch.gcd\n /// \n /// Computes the element-wise greatest common divisor (GCD) of input and other.\n /// \n /// The left-hand operand.\n /// The right-hand operand.\n public static Tensor gcd_(Tensor left, Tensor right) => left.gcd_(right);\n\n // https://pytorch.org/docs/stable/generated/torch.histc\n /// \n /// Computes the histogram of a tensor.\n /// The elements are sorted into equal width bins between min and max.If min and max are both zero, the minimum and maximum values of the data are used.\n /// Elements lower than min and higher than max are ignored.\n /// \n /// The input tensor.\n /// Number of histogram bins\n /// Lower end of the range (inclusive)\n /// Upper end of the range (inclusive)\n public static Tensor histc(Tensor input, long bins = 100, long min = 0, long max = 0) => input.histc(bins, min, max);\n\n // https://pytorch.org/docs/stable/generated/torch.histogram\n [Obsolete(\"not implemented\", true)]\n static Tensor histogram(\n Tensor input,\n long bins,\n (float min, float max)? range = null,\n Tensor? weight = null,\n bool density = false)\n => throw new NotImplementedException();\n\n // https://pytorch.org/docs/stable/generated/torch.histogram\n [Obsolete(\"not implemented\", true)]\n static Tensor histogram(\n Tensor input,\n long[] bins,\n (float min, float max)? range = null,\n Tensor? weight = null,\n bool density = false)\n => throw new NotImplementedException();\n\n // https://pytorch.org/docs/stable/generated/torch.histogram\n [Obsolete(\"not implemented\", true)]\n static Tensor histogram(\n Tensor input,\n Tensor[] bins,\n (float min, float max)? range = null,\n Tensor? weight = null,\n bool density = false)\n => throw new NotImplementedException();\n\n // https://pytorch.org/docs/stable/generated/torch.histogramdd\n [Obsolete(\"not implemented\", true)]\n static (Tensor hist_values, Tensor[] edges) histogramdd(\n Tensor input,\n long bins,\n (float min, float max)? range = null,\n Tensor? weight = null,\n bool density = false)\n => throw new NotImplementedException();\n\n // https://pytorch.org/docs/stable/generated/torch.histogramdd\n [Obsolete(\"not implemented\", true)]\n static (Tensor hist_values, Tensor[] edges) histogramdd(\n Tensor input,\n long[] bins,\n (float min, float max)? range = null,\n Tensor? weight = null,\n bool density = false)\n => throw new NotImplementedException();\n\n // https://pytorch.org/docs/stable/generated/torch.histogramdd\n [Obsolete(\"not implemented\", true)]\n static (Tensor hist_values, Tensor[] edges) histogramdd(\n Tensor input,\n Tensor[] bins,\n (float min, float max)? range = null,\n Tensor? weight = null,\n bool density = false)\n => throw new NotImplementedException();\n\n // https://pytorch.org/docs/stable/generated/torch.meshgrid\n /// \n /// Creates grids of coordinates specified by the 1D inputs in tensors.\n /// This is helpful when you want to visualize data over some range of inputs.\n /// \n /// All tensors need to be of the same size. \n static IEnumerable meshgrid(IEnumerable tensors, indexing indexing = indexing.ij)\n {\n var idx = indexing switch {\n indexing.ij => \"ij\",\n indexing.xy => \"xy\",\n _ => throw new ArgumentOutOfRangeException()\n };\n return meshgrid(tensors, idx);\n }\n\n // https://pytorch.org/docs/stable/generated/torch.meshgrid\n /// \n /// Creates grids of coordinates specified by the 1D inputs in tensors.\n /// This is helpful when you want to visualize data over some range of inputs.\n /// \n /// All tensors need to be of the same size. \n public static Tensor[] meshgrid(IEnumerable tensors, string indexing = \"ij\")\n {\n IntPtr[] ptrArray;\n\n using (var parray = new PinnedArray()) {\n IntPtr tensorsRef = parray.CreateArray(tensors.Select(p => p.Handle).ToArray());\n _ = THSTensor_meshgrid(tensorsRef, parray.Array.Length, indexing, parray.CreateArray);\n CheckForErrors();\n ptrArray = parray.Array;\n }\n return ptrArray.Select(x => new Tensor(x)).ToArray();\n }\n\n // https://pytorch.org/docs/stable/generated/torch.lcm\n /// \n /// Computes the element-wise least common multiple (LCM) of input and other.\n /// \n /// The first input tensor.\n /// The second input tensor.\n /// Both input and other must have integer types. \n public static Tensor lcm(Tensor input, Tensor other) => input.lcm(other);\n\n // https://pytorch.org/docs/stable/generated/torch.lcm\n /// \n /// Computes the element-wise least common multiple (LCM) of input and other in place.\n /// \n /// The first input tensor.\n /// The second input tensor.\n /// Both input and other must have integer types. \n public static Tensor lcm_(Tensor input, Tensor other) => input.lcm_(other);\n\n // https://pytorch.org/docs/stable/generated/torch.logcumsumexp\n /// \n /// Returns the logarithm of the cumulative summation of the exponentiation of elements of input in the dimension dim.\n /// \n /// The input tensor.\n /// The dimension to do the operation over\n public static Tensor logcumsumexp(Tensor input, long dim) => input.logcumsumexp(dim);\n\n // https://pytorch.org/docs/stable/generated/torch.ravel\n public static Tensor ravel(Tensor input) => input.ravel();\n\n // https://pytorch.org/docs/stable/generated/torch.renorm\n /// \n /// Returns a tensor where each sub-tensor of input along dimension dim is normalized such that the p-norm of the sub-tensor is lower than the value maxnorm\n /// \n /// The input tensor.\n /// The power for the norm computation\n /// The dimension to slice over to get the sub-tensors\n /// The maximum norm to keep each sub-tensor under\n public static Tensor renorm(Tensor input, float p, long dim, float maxnorm) => input.renorm(p, dim, maxnorm);\n\n // https://pytorch.org/docs/stable/generated/torch.repeat_interleave\n /// \n /// Repeat elements of a tensor.\n /// \n /// The input tensor\n /// The number of repeats\n /// The dimension to repeat\n /// The size of output\n /// \n /// Repeat elements of a tensor.\n /// \n /// The input tensor\n /// The number of repeats\n /// The dimension to repeat\n /// The size of output\n /// \n /// Roll the tensor along the given dimension(s).\n /// Elements that are shifted beyond the last position are re-introduced at the first position.\n /// If a dimension is not specified, the tensor will be flattened before rolling and then restored to the original shape.\n /// \n public static Tensor roll(Tensor input, long shifts, long? dims = null) => input.roll(shifts, dims);\n\n // https://pytorch.org/docs/stable/generated/torch.roll\n /// \n /// Roll the tensor along the given dimension(s).\n /// Elements that are shifted beyond the last position are re-introduced at the first position.\n /// If a dimension is not specified, the tensor will be flattened before rolling and then restored to the original shape.\n /// \n public static Tensor roll(Tensor input, (long, long) shifts, (long, long) dims) => input.roll(shifts, dims);\n\n // https://pytorch.org/docs/stable/generated/torch.roll\n /// \n /// Roll the tensor along the given dimension(s).\n /// Elements that are shifted beyond the last position are re-introduced at the first position.\n /// If a dimension is not specified, the tensor will be flattened before rolling and then restored to the original shape.\n /// \n public static Tensor roll(Tensor input, (long, long, long) shifts, (long, long, long) dims) => input.roll(shifts, dims);\n\n // https://pytorch.org/docs/stable/generated/torch.roll\n /// \n /// Roll the tensor along the given dimension(s).\n /// Elements that are shifted beyond the last position are re-introduced at the first position.\n /// If a dimension is not specified, the tensor will be flattened before rolling and then restored to the original shape.\n /// \n public static Tensor roll(Tensor input, long[] shifts, long[] dims) => input.roll(shifts, dims);\n\n // https://pytorch.org/docs/stable/generated/torch.roll\n /// \n /// Roll the tensor along the given dimension(s).\n /// Elements that are shifted beyond the last position are re-introduced at the first position.\n /// If a dimension is not specified, the tensor will be flattened before rolling and then restored to the original shape.\n /// \n public static Tensor roll(Tensor input, long[] shifts) => input.roll(shifts);\n\n // https://pytorch.org/docs/stable/generated/torch.roll\n /// \n /// Roll the tensor along the given dimension(s).\n /// Elements that are shifted beyond the last position are re-introduced at the first position.\n /// If a dimension is not specified, the tensor will be flattened before rolling and then restored to the original shape.\n /// \n public static Tensor roll(Tensor input, ReadOnlySpan shifts, ReadOnlySpan dims = default) => input.roll(shifts, dims);\n\n // https://pytorch.org/docs/stable/generated/torch.tensordot\n /// \n /// Returns a contraction of and over multiple dimensions.\n /// tensordot implements a generalized matrix product.\n /// \n /// Left tensor to contract\n /// Right tensor to contract\n /// number of dimensions to contract for and \n /// contraction \n public static Tensor tensordot(Tensor a, Tensor b, long dims = 2) => a.tensordot(b, dims);\n\n // https://pytorch.org/docs/stable/generated/torch.tensordot\n /// \n /// Returns a contraction of and over multiple dimensions.\n /// tensordot implements a generalized matrix product.\n /// \n /// Left tensor to contract\n /// Right tensor to contract\n /// dimensions to contract for \n /// dimensions to contract for \n /// contraction \n public static Tensor tensordot(Tensor a, Tensor b, long[] dims1, long[] dims2) => a.tensordot(b, dims1, dims2);\n\n // https://pytorch.org/docs/stable/generated/torch.tensordot\n /// \n /// Returns a contraction of and over multiple dimensions.\n /// tensordot implements a generalized matrix product.\n /// \n /// Left tensor to contract\n /// Right tensor to contract\n /// dimensions to contract for and respectively\n /// contraction \n public static Tensor tensordot(Tensor a, Tensor b, (long, long)[] dims) => a.tensordot(b, dims);\n\n // https://pytorch.org/docs/stable/generated/torch.trace\n /// \n /// Returns the sum of the elements of the diagonal of the input 2-D matrix.\n /// \n /// The input tensor\n /// \n /// Returns a view of input as a real tensor.\n /// For an input complex tensor of size m1, m2, …, mi, this function returns a new real tensor of size m1, m2, …, mi, 2, where the last dimension of size 2 represents the real and imaginary components of complex numbers.\n /// \n /// The input tensor\n public static Tensor view_as_real(Tensor input) => input.view_as_real();\n\n // https://pytorch.org/docs/stable/generated/torch.view_as_complex\n /// \n /// Returns a view of input as a complex tensor.\n /// For an input complex tensor of size m1, m2, …, mi, 2, this function returns a new complex tensor of size m1, m2, …, mi where the last dimension of the input tensor is expected to represent the real and imaginary components of complex numbers.\n /// \n /// The input tensor\n public static Tensor view_as_complex(Tensor input) => input.view_as_complex();\n\n // https://pytorch.org/docs/stable/generated/torch.resolve_conj\n /// \n /// Returns a new tensor with materialized conjugation if input’s conjugate bit is set to True, else returns input.\n /// The output tensor will always have its conjugate bit set to False.\n /// \n /// The input tensor.\n public static Tensor resolve_conj(Tensor input) => input.resolve_conj();\n\n // https://pytorch.org/docs/stable/generated/torch.resolve_neg\n /// \n /// Returns a new tensor with materialized negation if input’s negative bit is set to True, else returns input.\n /// The output tensor will always have its negative bit set to False.\n /// \n public static Tensor resolve_neg(Tensor input) => input.resolve_neg();\n\n /// \n /// Returns true if the input's negative bit is set to True.\n /// \n public static Tensor is_neg(Tensor input) => input.is_neg();\n }\n}"},{"alpha_fraction":0.668683648109436,"alphanum_fraction":0.6760084629058838,"avg_line_length":37.448978424072266,"blob_id":"756fb9fdb47cc2aa7f658aed5896b784fbdc41e1","content_id":"5bb6d76619f601b1f67ab57fb823fbe53563bd27","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":9420,"license_type":"permissive","max_line_length":224,"num_lines":245,"path":"/src/Native/LibTorchSharp/THSLoss.cpp","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\n#include \"THSNN.h\"\n\n#include \n\n\ntemplate\nvoid ApplyReduction(T& opts, const int64_t reduction)\n{\n if (reduction == 0)\n opts = opts.reduction(torch::kNone);\n if (reduction == 1)\n opts = opts.reduction(torch::kMean);\n if (reduction == 2)\n opts = opts.reduction(torch::kSum);\n}\n\nTensor THSNN_binary_cross_entropy(const Tensor input, const Tensor target, const Tensor weight, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::BinaryCrossEntropyFuncOptions();\n ApplyReduction(opts, reduction);\n if (weight != nullptr)\n opts = opts.weight(*weight);\n res = ResultTensor(torch::nn::functional::binary_cross_entropy(*input, *target, opts));\n )\n}\n\nTensor THSNN_binary_cross_entropy_with_logits(const Tensor input, const Tensor target, const Tensor weight, const int64_t reduction, const Tensor pos_weights_wrapper)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::BCEWithLogitsLossOptions();\n ApplyReduction(opts, reduction);\n if (pos_weights_wrapper != nullptr)\n opts = opts.pos_weight(*pos_weights_wrapper);\n if (weight != nullptr)\n opts = opts.weight(*weight);\n res = ResultTensor(torch::nn::functional::binary_cross_entropy_with_logits(*input, *target, opts));\n )\n}\n\nTensor THSNN_cosine_embedding_loss(const Tensor input1, const Tensor input2, const Tensor target, const double margin, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::CosineEmbeddingLossFuncOptions().margin(margin);\n ApplyReduction(opts, reduction);\n res = ResultTensor(torch::nn::functional::cosine_embedding_loss(*input1, *input2, *target, opts));\n )\n}\n\nTensor THSNN_cross_entropy(const Tensor input, const Tensor target, const Tensor weight, const int64_t ignore_index, const bool has_ii, const int64_t reduction, const double smoothing)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::CrossEntropyFuncOptions();\n ApplyReduction(opts, reduction);\n opts.label_smoothing(smoothing);\n if (has_ii)\n opts = opts.ignore_index(ignore_index);\n if (weight != nullptr)\n opts = opts.weight(*weight);\n res = ResultTensor(torch::nn::functional::cross_entropy(*input, *target, opts));\n )\n}\n\nTensor THSNN_hinge_embedding_loss(const Tensor input, const Tensor target, const double margin, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::HingeEmbeddingLossFuncOptions().margin(margin);\n ApplyReduction(opts, reduction);\n res = ResultTensor(torch::nn::functional::hinge_embedding_loss(*input, *target, opts));\n )\n}\n\nTensor THSNN_huber_loss(const Tensor input, const Tensor target, const double delta, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::HuberLossFuncOptions().delta(delta);\n ApplyReduction(opts, reduction);\n res = ResultTensor(torch::nn::functional::huber_loss(*input, *target, opts));\n )\n}\n\n\nTensor THSNN_kl_div_loss(const Tensor input, const Tensor target, const int64_t reduction, const bool log_target)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::KLDivFuncOptions().log_target(log_target);\n ApplyReduction(opts, reduction);\n\n res = ResultTensor(torch::nn::functional::kl_div(*input, *target, opts));\n )\n}\n\nTensor THSNN_l1_loss(const Tensor input, const Tensor target, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::MSELossFuncOptions();\n ApplyReduction(opts, reduction);\n\n res = ResultTensor(torch::nn::functional::mse_loss(*input, *target, opts));\n )\n}\n\nTensor THSNN_margin_ranking_loss(const Tensor input1, const Tensor input2, const Tensor target, const double margin, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::MarginRankingLossFuncOptions().margin(margin);\n ApplyReduction(opts, reduction);\n res = ResultTensor(torch::nn::functional::margin_ranking_loss(*input1, *input2, *target, opts));\n )\n}\n\nTensor THSNN_mse_loss(const Tensor input, const Tensor target, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::MSELossFuncOptions();\n ApplyReduction(opts, reduction);\n\n res = ResultTensor(torch::nn::functional::mse_loss(*input, *target, opts));\n )\n}\n\nTensor THSNN_nll_loss(const Tensor input, const Tensor target, const Tensor weight, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::NLLLossFuncOptions();\n ApplyReduction(opts, reduction);\n if (weight != nullptr)\n opts = opts.weight(*weight);\n\n res = ResultTensor(torch::nn::functional::nll_loss(*input, *target, opts));\n )\n}\n\nTensor THSNN_poisson_loss(const Tensor input, const Tensor target, const bool logInput, const bool full, const double eps, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::PoissonNLLLossFuncOptions().log_input(logInput).full(full).eps(eps);\n ApplyReduction(opts, reduction);\n\n res = ResultTensor(torch::nn::functional::poisson_nll_loss(*input, *target, opts));\n )\n}\n\nTensor THSNN_smooth_l1_loss(const Tensor input, const Tensor target, const int64_t reduction, const double beta)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::SmoothL1LossFuncOptions();\n ApplyReduction(opts, reduction);\n\n res = ResultTensor(torch::nn::functional::smooth_l1_loss(*input, *target, opts, beta));\n )\n}\n\nTensor THSNN_soft_margin_loss(const Tensor input, const Tensor target, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::SoftMarginLossFuncOptions();\n ApplyReduction(opts, reduction);\n\n res = ResultTensor(torch::nn::functional::soft_margin_loss(*input, *target, opts));\n )\n}\n\nTensor THSNN_ctc_loss(const Tensor log_probs, const Tensor targets, const Tensor input_lengths, const Tensor target_lengths, int64_t blank, bool zero_infinity, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::CTCLossFuncOptions().blank(blank).zero_infinity(zero_infinity);\n ApplyReduction(opts, reduction);\n\n res = ResultTensor(torch::nn::functional::ctc_loss(*log_probs, *targets, *input_lengths, *target_lengths, opts));\n )\n}\n\nTensor THSNN_multilabel_margin_loss(const Tensor input, const Tensor target, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::MultilabelMarginLossFuncOptions();\n ApplyReduction(opts, reduction);\n\n res = ResultTensor(torch::nn::functional::multilabel_margin_loss(*input, *target, opts));\n )\n}\n\nTensor THSNN_multilabel_soft_margin_loss(const Tensor input, const Tensor target, const Tensor weight, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::MultilabelSoftMarginLossFuncOptions();\n ApplyReduction(opts, reduction);\n if (weight != nullptr)\n opts = opts.weight(*weight);\n\n res = ResultTensor(torch::nn::functional::multilabel_soft_margin_loss(*input, *target, opts));\n )\n}\n\nTensor THSNN_multi_margin_loss(const Tensor input, const Tensor target, const int64_t p, const double margin, const Tensor weight, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::MultiMarginLossFuncOptions()\n .p(p)\n .margin(margin);\n ApplyReduction(opts, reduction);\n if (weight != nullptr)\n opts = opts.weight(*weight);\n\n res = ResultTensor(torch::nn::functional::multi_margin_loss(*input, *target, opts));\n )\n}\n\nTensor THSNN_triplet_margin_loss(const Tensor anchor, const Tensor positive, const Tensor negative, double margin, int64_t p, double eps, bool swap, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::TripletMarginLossFuncOptions()\n .p(p)\n .eps(eps)\n .margin(margin)\n .swap(swap);\n ApplyReduction(opts, reduction);\n\n res = ResultTensor(torch::nn::functional::triplet_margin_loss(*anchor, *positive, *negative, opts));\n )\n}\n\nTensor THSNN_triplet_margin_with_distance_loss(const Tensor anchor, const Tensor positive, const Tensor negative, Tensor(*distance_function)(const Tensor x, const Tensor y), double margin, bool swap, const int64_t reduction)\n{\n CATCH_RETURN_Tensor(\n auto opts = torch::nn::functional::TripletMarginWithDistanceLossFuncOptions()\n .margin(margin)\n .swap(swap);\n\n ApplyReduction(opts, reduction);\n\n if (distance_function != nullptr) {\n opts = opts.distance_function(\n [=](const at::Tensor& x, const at::Tensor& y) -> const at::Tensor& {\n auto x1 = ResultTensor(x);\n auto y1 = ResultTensor(y);\n return *distance_function(x1, y1);\n });\n }\n\n res = ResultTensor(torch::nn::functional::triplet_margin_with_distance_loss(*anchor, *positive, *negative, opts));\n )\n}\n"},{"alpha_fraction":0.6013590097427368,"alphanum_fraction":0.601925253868103,"avg_line_length":35.79166793823242,"blob_id":"c930e90ec5bec98691f0c32da6c8193f72f3a84c","content_id":"7296a52a14c582cf2428d250f63f3215fede9115","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":1766,"license_type":"permissive","max_line_length":130,"num_lines":48,"path":"/src/TorchSharp/NN/Identity.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\nusing System;\nusing static TorchSharp.torch;\nusing static TorchSharp.PInvoke.NativeMethods;\n\n#nullable enable\nnamespace TorchSharp\n{\n using Modules;\n\n namespace Modules\n {\n public sealed class Identity : torch.nn.Module\n {\n internal Identity(IntPtr handle, IntPtr boxedHandle) : base(handle, boxedHandle) { }\n\n public override Tensor forward(Tensor tensor)\n {\n var res = THSNN_Identity_forward(handle, tensor.Handle);\n if (res == IntPtr.Zero) { torch.CheckForErrors(); }\n return new Tensor(res);\n }\n\n // Rather than spending cycles only to discover that this module has neither\n // parameters nor buffers, just shortcut the move completely.\n protected internal override nn.Module _to(Device device, ScalarType dtype) => this;\n protected internal override nn.Module _to(DeviceType deviceType, int deviceIndex = -1) => this;\n protected internal override nn.Module _to(ScalarType dtype) => this;\n }\n }\n\n public static partial class torch\n {\n public static partial class nn\n {\n /// \n /// A placeholder identity operator.\n /// \n /// The same tensor as is input. \n public static Identity Identity()\n {\n var res = THSNN_Identity_ctor(out var boxedHandle);\n if (res == IntPtr.Zero) { torch.CheckForErrors(); }\n return new Identity(res, boxedHandle);\n }\n }\n }\n}\n"},{"alpha_fraction":0.5044258832931519,"alphanum_fraction":0.5215146541595459,"avg_line_length":36.311927795410156,"blob_id":"9b952b0b986168d478b2a5b4a70fac663b9c9120","content_id":"215e4f74d52b55e633c8ae1d8847ff95cedcd414","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":8134,"license_type":"permissive","max_line_length":197,"num_lines":218,"path":"/src/Examples/CIFAR10.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\nusing System;\nusing System.Diagnostics;\nusing static TorchSharp.torch.nn;\nusing static TorchSharp.torch.nn.functional;\nusing static TorchSharp.torch.utils.data;\n\nnamespace TorchSharp.Examples\n{\n /// \n /// Driver for various models trained and evaluated on the CIFAR10 small (32x32) color image data set.\n /// \n /// \n /// The dataset for this example can be found at: https://www.cs.toronto.edu/~kriz/cifar.html\n /// Download the binary file, and place it in a dedicated folder, e.g. 'CIFAR10,' then edit\n /// the '_dataLocation' definition below to point at the right folder.\n ///\n /// Note: so far, CIFAR10 is supported, but not CIFAR100.\n /// \n class CIFAR10\n {\n private static int _epochs = 8;\n private static int _trainBatchSize = 64;\n private static int _testBatchSize = 128;\n\n private readonly static int _logInterval = 25;\n private readonly static int _numClasses = 100;\n\n private readonly static int _timeout = 3600; // One hour by default.\n\n internal static void Main(string[] args)\n {\n var datasetPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);\n\n torch.random.manual_seed(1);\n\n var device =\n // This worked on a GeForce RTX 2080 SUPER with 8GB, for all the available network architectures.\n // It may not fit with less memory than that, but it's worth modifying the batch size to fit in memory.\n torch.cuda.is_available() ? torch.CUDA :\n torch.CPU;\n\n if (device.type == DeviceType.CUDA) {\n _trainBatchSize *= 8;\n _testBatchSize *= 8;\n _epochs *= 16;\n }\n\n var modelName = args.Length > 0 ? args[0] : \"AlexNet\";\n var epochs = args.Length > 1 ? int.Parse(args[1]) : _epochs;\n var timeout = args.Length > 2 ? int.Parse(args[2]) : _timeout;\n\n Console.WriteLine();\n Console.WriteLine($\"\\tRunning {modelName} with CIFAR100 on {device.type.ToString()} for {epochs} epochs, terminating after {TimeSpan.FromSeconds(timeout)}.\");\n Console.WriteLine();\n\n Console.WriteLine($\"\\tCreating the model...\");\n\n Module model = null;\n\n switch (modelName.ToLower()) {\n case \"alexnet\":\n model = new AlexNet(modelName, _numClasses, device);\n break;\n case \"mobilenet\":\n model = new MobileNet(modelName, _numClasses, device);\n break;\n case \"vgg11\":\n case \"vgg13\":\n case \"vgg16\":\n case \"vgg19\":\n model = new VGG(modelName, _numClasses, device);\n break;\n case \"resnet18\":\n model = ResNet.ResNet18(_numClasses, device);\n break;\n case \"resnet34\":\n _testBatchSize /= 4;\n model = ResNet.ResNet34(_numClasses, device);\n break;\n case \"resnet50\":\n _trainBatchSize /= 6;\n _testBatchSize /= 8;\n model = ResNet.ResNet50(_numClasses, device);\n break;\n#if false\n // The following is disabled, because they require big CUDA processors in order to run.\n case \"resnet101\":\n _trainBatchSize /= 6;\n _testBatchSize /= 8;\n model = ResNet.ResNet101(_numClasses, device);\n break;\n case \"resnet152\":\n _testBatchSize /= 4;\n model = ResNet.ResNet152(_numClasses, device);\n break;\n#endif\n }\n\n Console.WriteLine($\"\\tPreparing training and test data...\");\n Console.WriteLine();\n\n using (Dataset train_data = torchvision.datasets.CIFAR100(datasetPath, true, download: true),\n test_data = torchvision.datasets.CIFAR100(datasetPath, false, download: true))\n {\n using var train = new DataLoader(train_data, _trainBatchSize, device: device, shuffle: true);\n using var test = new DataLoader(test_data, _testBatchSize, device: device, shuffle: false);\n\n using (var optimizer = torch.optim.Adam(model.parameters(), 0.001)) {\n\n Stopwatch totalSW = new Stopwatch();\n totalSW.Start();\n\n for (var epoch = 1; epoch <= epochs; epoch++) {\n\n Stopwatch epchSW = new Stopwatch();\n epchSW.Start();\n\n Train(model, optimizer, torch.nn.NLLLoss(), train, epoch, _trainBatchSize, train_data.Count);\n Test(model, torch.nn.NLLLoss(), test, test_data.Count);\n\n epchSW.Stop();\n Console.WriteLine($\"Elapsed time for this epoch: {epchSW.Elapsed.TotalSeconds} s.\");\n\n if (totalSW.Elapsed.TotalSeconds > timeout) break;\n }\n\n totalSW.Stop();\n Console.WriteLine($\"Elapsed training time: {totalSW.Elapsed} s.\");\n }\n }\n\n model.Dispose();\n }\n\n private static void Train(\n Module model,\n torch.optim.Optimizer optimizer,\n Loss loss,\n DataLoader dataLoader,\n int epoch,\n long batchSize,\n long size)\n {\n model.train();\n\n int batchId = 1;\n long total = 0;\n long correct = 0;\n\n Console.WriteLine($\"Epoch: {epoch}...\");\n\n using (var d = torch.NewDisposeScope()) {\n\n foreach (var data in dataLoader) {\n\n optimizer.zero_grad();\n\n var target = data[\"label\"];\n var prediction = model.call(data[\"data\"]);\n var lsm = log_softmax(prediction, 1);\n var output = loss.call(lsm, target);\n\n output.backward();\n\n optimizer.step();\n\n total += target.shape[0];\n\n var predicted = prediction.argmax(1);\n correct += predicted.eq(target).sum().ToInt64();\n\n if (batchId % _logInterval == 0 || total == size) {\n Console.WriteLine($\"\\rTrain: epoch {epoch} [{total} / {size}] Loss: {output.ToSingle().ToString(\"0.000000\")} | Accuracy: { ((float)correct / total).ToString(\"0.000000\") }\");\n }\n\n batchId++;\n\n d.DisposeEverything();\n }\n }\n }\n\n private static void Test(\n Module model,\n Loss loss,\n DataLoader dataLoader,\n long size)\n {\n model.eval();\n\n double testLoss = 0;\n long correct = 0;\n int batchCount = 0;\n\n using (var d = torch.NewDisposeScope()) {\n\n foreach (var data in dataLoader) {\n\n var target = data[\"label\"];\n var prediction = model.call(data[\"data\"]);\n var lsm = log_softmax(prediction, 1);\n var output = loss.call(lsm, target);\n\n testLoss += output.ToSingle();\n batchCount += 1;\n\n var predicted = prediction.argmax(1);\n correct += predicted.eq(target).sum().ToInt64();\n\n d.DisposeEverything();\n }\n }\n\n Console.WriteLine($\"\\rTest set: Average loss {(testLoss / batchCount).ToString(\"0.0000\")} | Accuracy {((float)correct / size).ToString(\"0.0000\")}\");\n }\n }\n}\n"},{"alpha_fraction":0.40059059858322144,"alphanum_fraction":0.4575561583042145,"avg_line_length":32.95050811767578,"blob_id":"865a8c99e3cd4d61d62338f84b027274b2942e00","content_id":"a27582bbba6821bbbb2b559ed8bd9604fed713fe","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":26753,"license_type":"permissive","max_line_length":240,"num_lines":788,"path":"/test/TorchSharpTest/LinearAlgebra.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\nusing System;\nusing System.Linq;\nusing System.Runtime.InteropServices;\nusing Xunit;\nusing static TorchSharp.torch;\n\n#nullable enable\n\nnamespace TorchSharp\n{\n [Collection(\"Sequential\")]\n public class LinearAlgebra\n {\n [Fact]\n [TestOf(nameof(tensordot))]\n public void TestTensorDot()\n {\n var a = arange(60).reshape(3, 4, 5);\n var b = arange(24).reshape(4, 3, 2);\n var res = tensordot(a, b, new []{ 1L, 0L }, new []{ 0L, 1L });\n\n var expected = from_array(new long[,]\n {\n {4400, 4730},\n {4532, 4874},\n {4664, 5018},\n {4796, 5162},\n {4928, 5306}\n });\n\n Assert.True(allclose(res, expected));\n }\n\n [Fact]\n [TestOf(nameof(lu))]\n public void TestLUSolve()\n {\n var A = randn(2, 3, 3);\n var b = randn(2, 3, 1);\n\n {\n var (A_LU, pivots, infos) = lu(A);\n\n Assert.NotNull(A_LU);\n Assert.NotNull(pivots);\n Assert.Null(infos);\n\n Assert.Equal(new long[] { 2, 3, 3 }, A_LU.shape);\n Assert.Equal(new long[] { 2, 3 }, pivots.shape);\n\n var x = lu_solve(b, A_LU, pivots);\n Assert.Equal(new long[] { 2, 3, 1 }, x.shape);\n\n var y = norm(bmm(A, x) - b);\n Assert.Empty(y.shape);\n }\n\n {\n var (A_LU, pivots, infos) = lu(A, get_infos: true);\n\n Assert.NotNull(A_LU);\n Assert.NotNull(pivots);\n Assert.NotNull(infos);\n\n Assert.Equal(new long[] { 2, 3, 3 }, A_LU.shape);\n Assert.Equal(new long[] { 2, 3 }, pivots.shape);\n Assert.Equal(new long[] { 2 }, infos.shape);\n\n var x = lu_solve(b, A_LU, pivots);\n Assert.Equal(new long[] { 2, 3, 1 }, x.shape);\n\n var y = norm(bmm(A, x) - b);\n Assert.Empty(y.shape);\n }\n }\n\n [Fact]\n [TestOf(nameof(lu_unpack))]\n public void TestLUUnpack()\n {\n var A = randn(2, 3, 3);\n\n {\n var (A_LU, pivots, infos) = lu(A);\n\n Assert.NotNull(A_LU);\n Assert.NotNull(pivots);\n Assert.Null(infos);\n\n var (P, A_L, A_U) = lu_unpack(A_LU, pivots);\n\n Assert.NotNull(P);\n Assert.NotNull(A_L);\n Assert.NotNull(A_U);\n\n Assert.Equal(new long[] { 2, 3, 3 }, P.shape);\n Assert.Equal(new long[] { 2, 3, 3 }, A_L!.shape);\n Assert.Equal(new long[] { 2, 3, 3 }, A_U!.shape);\n }\n }\n\n [Fact]\n [TestOf(nameof(Tensor.mul))]\n public void TestMul()\n {\n var x = ones(new long[] { 100, 100 });\n\n var y = x.mul(0.5f.ToScalar());\n\n var ydata = y.data();\n var xdata = x.data();\n\n for (int i = 0; i < 100; i++) {\n for (int j = 0; j < 100; j++) {\n Assert.Equal(ydata[i + j], xdata[i + j] * 0.5f);\n }\n }\n }\n\n void TestMmGen(Device device)\n {\n {\n var x1 = ones(new long[] { 1, 2 }, device: device);\n var x2 = ones(new long[] { 2, 1 }, device: device);\n\n var y = x1.mm(x2).to(DeviceType.CPU);\n\n var ydata = y.data();\n\n Assert.Equal(2.0f, ydata[0]);\n }\n //System.Runtime.InteropServices.ExternalException : addmm for CUDA tensors only supports floating - point types.Try converting the tensors with.float() at C:\\w\\b\\windows\\pytorch\\aten\\src\\THC / generic / THCTensorMathBlas.cu:453\n if (device.type == DeviceType.CPU) {\n var x1 = ones(new long[] { 1, 2 }, int64, device: device);\n var x2 = ones(new long[] { 2, 1 }, int64, device: device);\n\n var y = x1.mm(x2).to(DeviceType.CPU);\n\n var ydata = y.data();\n\n Assert.Equal(2L, ydata[0]);\n }\n }\n\n [Fact]\n [TestOf(nameof(CPU))]\n public void TestMmCpu()\n {\n TestMmGen(CPU);\n }\n\n [Fact]\n [TestOf(nameof(CUDA))]\n public void TestMmCuda()\n {\n if (cuda.is_available()) {\n TestMmGen(CUDA);\n }\n }\n\n void TestMVGen(Device device)\n {\n {\n var mat1 = ones(new long[] { 4, 3 }, device: device);\n var vec1 = ones(new long[] { 3 }, device: device);\n\n var y = mat1.mv(vec1).to(DeviceType.CPU);\n\n Assert.Equal(4, y.shape[0]);\n }\n }\n\n void TestAddMVGen(Device device)\n {\n {\n var x1 = ones(new long[] { 4 }, device: device);\n var mat1 = ones(new long[] { 4, 3 }, device: device);\n var vec1 = ones(new long[] { 3 }, device: device);\n\n var y = x1.addmv(mat1, vec1).to(DeviceType.CPU);\n\n Assert.Equal(4, y.shape[0]);\n }\n }\n\n [Fact]\n [TestOf(nameof(CPU))]\n public void TestMVCpu()\n {\n TestMVGen(CPU);\n }\n\n [Fact]\n [TestOf(nameof(CUDA))]\n public void TestMVCuda()\n {\n if (cuda.is_available()) {\n TestMVGen(CUDA);\n }\n }\n\n [Fact]\n public void TestAddMVCpu()\n {\n TestAddMVGen(CPU);\n }\n\n [Fact]\n [TestOf(nameof(CUDA))]\n public void TestAddMVCuda()\n {\n if (cuda.is_available()) {\n TestAddMVGen(CUDA);\n }\n }\n\n void TestAddRGen(Device device)\n {\n {\n var x1 = ones(new long[] { 4, 3 }, device: device);\n var vec1 = ones(new long[] { 4 }, device: device);\n var vec2 = ones(new long[] { 3 }, device: device);\n\n var y = x1.addr(vec1, vec2).to(DeviceType.CPU);\n\n Assert.Equal(new long[] { 4, 3 }, y.shape);\n }\n }\n\n [Fact]\n [TestOf(nameof(CPU))]\n public void TestAddRCpu()\n {\n TestAddRGen(CPU);\n }\n\n [Fact]\n [TestOf(nameof(CUDA))]\n public void TestAddRCuda()\n {\n if (cuda.is_available()) {\n TestAddRGen(CUDA);\n }\n }\n\n [Fact]\n [TestOf(nameof(Tensor.vdot))]\n public void VdotTest()\n {\n var a = new float[] { 1.0f, 2.0f, 3.0f };\n var b = new float[] { 1.0f, 2.0f, 3.0f };\n var expected = tensor(a.Zip(b).Select(x => x.First * x.Second).Sum());\n var res = tensor(a).vdot(tensor(b));\n Assert.True(res.allclose(expected));\n }\n\n [Fact]\n [TestOf(nameof(Tensor.vander))]\n public void VanderTest()\n {\n var x = tensor(new int[] { 1, 2, 3, 5 });\n {\n var res = x.vander();\n var expected = tensor(new long[] { 1, 1, 1, 1, 8, 4, 2, 1, 27, 9, 3, 1, 125, 25, 5, 1 }, 4, 4);\n Assert.Equal(expected, res);\n }\n {\n var res = x.vander(3);\n var expected = tensor(new long[] { 1, 1, 1, 4, 2, 1, 9, 3, 1, 25, 5, 1 }, 4, 3);\n Assert.Equal(expected, res);\n }\n {\n var res = x.vander(3, true);\n var expected = tensor(new long[] { 1, 1, 1, 1, 2, 4, 1, 3, 9, 1, 5, 25 }, 4, 3);\n Assert.Equal(expected, res);\n }\n }\n\n [Fact]\n [TestOf(nameof(linalg.vander))]\n public void LinalgVanderTest()\n {\n var x = tensor(new int[] { 1, 2, 3, 5 });\n {\n var res = linalg.vander(x);\n var expected = tensor(new long[] { 1, 1, 1, 1, 1, 2, 4, 8, 1, 3, 9, 27, 1, 5, 25, 125 }, 4, 4);\n Assert.Equal(expected, res);\n }\n {\n var res = linalg.vander(x, 3);\n var expected = tensor(new long[] { 1, 1, 1, 1, 2, 4, 1, 3, 9, 1, 5, 25 }, 4, 3);\n Assert.Equal(expected, res);\n }\n }\n\n [Fact]\n [TestOf(nameof(linalg.cholesky))]\n public void CholeskyTest()\n {\n var a = randn(new long[] { 3, 2, 2 }, float64);\n a = a.matmul(a.swapdims(-2, -1)); // Worked this in to get it tested. Alias for 'transpose'\n var l = linalg.cholesky(a);\n\n Assert.True(a.allclose(l.matmul(l.swapaxes(-2, -1)))); // Worked this in to get it tested. Alias for 'transpose'\n }\n\n [Fact]\n [TestOf(nameof(linalg.cholesky_ex))]\n public void CholeskyExTest()\n {\n var a = randn(new long[] { 3, 2, 2 }, float64);\n a = a.matmul(a.swapdims(-2, -1)); // Worked this in to get it tested. Alias for 'transpose'\n var (l, info) = linalg.cholesky_ex(a);\n\n Assert.True(a.allclose(l.matmul(l.swapaxes(-2, -1))));\n }\n\n [Fact]\n [TestOf(nameof(linalg.inv))]\n public void InvTest()\n {\n var a = randn(new long[] { 3, 2, 2 }, float64);\n var l = linalg.inv(a);\n\n Assert.Equal(a.shape, l.shape);\n }\n\n [Fact]\n [TestOf(nameof(linalg.inv_ex))]\n public void InvExTest()\n {\n var a = randn(new long[] { 3, 2, 2 }, float64);\n var (l, info) = linalg.inv_ex(a);\n\n Assert.Equal(a.shape, l.shape);\n }\n\n [Fact]\n [TestOf(nameof(linalg.cond))]\n public void CondTestF64()\n {\n {\n var a = randn(new long[] { 3, 3, 3 }, float64);\n // The following mostly checks that the runtime interop doesn't blow up.\n _ = linalg.cond(a);\n _ = linalg.cond(a, \"fro\");\n _ = linalg.cond(a, \"nuc\");\n _ = linalg.cond(a, 1);\n _ = linalg.cond(a, -1);\n _ = linalg.cond(a, 2);\n _ = linalg.cond(a, -2);\n _ = linalg.cond(a, Double.PositiveInfinity);\n _ = linalg.cond(a, Double.NegativeInfinity);\n }\n }\n\n [Fact]\n [TestOf(nameof(linalg.cond))]\n public void CondTestCF64()\n {\n {\n var a = randn(new long[] { 3, 3, 3 }, complex128);\n // The following mostly checks that the runtime interop doesn't blow up.\n _ = linalg.cond(a);\n _ = linalg.cond(a, \"fro\");\n _ = linalg.cond(a, \"nuc\");\n _ = linalg.cond(a, 1);\n _ = linalg.cond(a, -1);\n _ = linalg.cond(a, 2);\n _ = linalg.cond(a, -2);\n _ = linalg.cond(a, Double.PositiveInfinity);\n _ = linalg.cond(a, Double.NegativeInfinity);\n }\n }\n\n [Fact]\n [TestOf(nameof(linalg.qr))]\n public void QRTest()\n {\n var a = randn(new long[] { 4, 25, 25 });\n\n var l = linalg.qr(a);\n\n Assert.Equal(a.shape, l.Q.shape);\n Assert.Equal(a.shape, l.R.shape);\n }\n\n [Fact]\n [TestOf(nameof(linalg.solve))]\n public void SolveTest()\n {\n var A = randn(3, 3);\n var b = randn(3);\n var x = linalg.solve(A, b);\n Assert.True(A.matmul(x).allclose(b, rtol: 1e-03, atol: 1e-06));\n }\n\n [Fact]\n [TestOf(nameof(linalg.solve_triangular))]\n public void SolveTriangularTest()\n {\n {\n var A = randn(3, 3).triu_();\n var b = randn(3, 4);\n var x = linalg.solve_triangular(A, b, upper: true);\n Assert.True(A.matmul(x).allclose(b, rtol: 1e-03, atol: 1e-06));\n }\n {\n var A = randn(2, 3, 3).tril_();\n var b = randn(2, 3, 4);\n var x = linalg.solve_triangular(A, b, upper: false);\n Assert.True(A.matmul(x).allclose(b, rtol: 1e-03, atol: 1e-06));\n }\n {\n var A = randn(2, 4, 4).tril_();\n var b = randn(2, 3, 4);\n var x = linalg.solve_triangular(A, b, upper: false, left: false);\n Assert.True(x.matmul(A).allclose(b, rtol: 1e-03, atol: 1e-06));\n }\n }\n\n [Fact]\n [TestOf(nameof(linalg.svd))]\n public void SVDTest()\n {\n var a = randn(new long[] { 4, 25, 15 });\n\n var l = linalg.svd(a);\n\n Assert.Equal(new long[] { 4, 25, 25 }, l.U.shape);\n Assert.Equal(new long[] { 4, 15 }, l.S.shape);\n Assert.Equal(new long[] { 4, 15, 15 }, l.Vh.shape);\n\n l = linalg.svd(a, fullMatrices: false);\n\n Assert.Equal(a.shape, l.U.shape);\n Assert.Equal(new long[] { 4, 15 }, l.S.shape);\n Assert.Equal(new long[] { 4, 15, 15 }, l.Vh.shape);\n }\n\n\n [Fact]\n [TestOf(nameof(linalg.svdvals))]\n public void SVDValsTest()\n {\n var a = tensor(new double[] { -1.3490, -0.1723, 0.7730,\n -1.6118, -0.3385, -0.6490,\n 0.0908, 2.0704, 0.5647,\n -0.6451, 0.1911, 0.7353,\n 0.5247, 0.5160, 0.5110}, 5, 3);\n\n var l = linalg.svdvals(a);\n Assert.True(l.allclose(tensor(new double[] { 2.5138929972840613, 2.1086555338402455, 1.1064930672223237 }), rtol: 1e-04, atol: 1e-07));\n }\n\n [Fact]\n [TestOf(nameof(linalg.lstsq))]\n public void LSTSQTest()\n {\n var a = randn(new long[] { 4, 25, 15 });\n var b = randn(new long[] { 4, 25, 10 });\n\n var l = linalg.lstsq(a, b);\n\n Assert.Equal(new long[] { 4, 15, 10 }, l.Solution.shape);\n Assert.Equal(0, l.Residuals.shape[0]);\n Assert.Equal(new long[] { 4 }, l.Rank.shape);\n Assert.Equal(new long[] { 4, 15, 10 }, l.Solution.shape);\n Assert.Equal(0, l.SingularValues.shape[0]);\n }\n\n [Fact]\n [TestOf(nameof(linalg.lu))]\n public void LUTest()\n {\n var A = randn(2, 3, 3);\n var A_factor = linalg.lu(A);\n // For right now, pretty much just checking that it's not blowing up.\n Assert.Multiple(\n () => Assert.NotNull(A_factor.P),\n () => Assert.NotNull(A_factor.L),\n () => Assert.NotNull(A_factor.U)\n );\n }\n\n [Fact]\n [TestOf(nameof(linalg.lu_factor))]\n public void LUFactorTest()\n {\n var A = randn(2, 3, 3);\n var A_factor = linalg.lu_factor(A);\n // For right now, pretty much just checking that it's not blowing up.\n Assert.Multiple(\n () => Assert.NotNull(A_factor.LU),\n () => Assert.NotNull(A_factor.Pivots)\n );\n }\n\n [Fact]\n [TestOf(nameof(linalg.ldl_factor))]\n public void LDLFactorTest()\n {\n var A = randn(2, 3, 3);\n var A_factor = linalg.ldl_factor(A);\n // For right now, pretty much just checking that it's not blowing up.\n Assert.Multiple(\n () => Assert.NotNull(A_factor.LU),\n () => Assert.NotNull(A_factor.Pivots)\n );\n }\n\n [Fact]\n [TestOf(nameof(linalg.ldl_factor))]\n public void LDLFactorExTest()\n {\n var A = randn(2, 3, 3);\n var A_factor = linalg.ldl_factor_ex(A);\n // For right now, pretty much just checking that it's not blowing up.\n Assert.Multiple(\n () => Assert.NotNull(A_factor.LU),\n () => Assert.NotNull(A_factor.Pivots),\n () => Assert.NotNull(A_factor.Info)\n );\n }\n\n [Fact]\n [TestOf(nameof(Tensor.matrix_power))]\n public void MatrixPowerTest()\n {\n var a = randn(new long[] { 25, 25 });\n var b = a.matrix_power(3);\n Assert.Equal(new long[] { 25, 25 }, b.shape);\n }\n\n [Fact]\n [TestOf(nameof(Tensor.matrix_exp))]\n public void MatrixExpTest1()\n {\n var a = randn(new long[] { 25, 25 });\n var b = a.matrix_exp();\n Assert.Equal(new long[] { 25, 25 }, b.shape);\n\n var c = matrix_exp(a);\n Assert.Equal(new long[] { 25, 25 }, c.shape);\n }\n\n [Fact]\n [TestOf(nameof(matrix_exp))]\n public void MatrixExpTest2()\n {\n var a = randn(new long[] { 16, 25, 25 });\n var b = a.matrix_exp();\n Assert.Equal(new long[] { 16, 25, 25 }, b.shape);\n var c = matrix_exp(a);\n Assert.Equal(new long[] { 16, 25, 25 }, c.shape);\n }\n\n [Fact]\n [TestOf(nameof(linalg.matrix_rank))]\n public void MatrixRankTest()\n {\n var mr1 = linalg.matrix_rank(randn(4, 3, 2));\n Assert.Equal(new long[] { 4 }, mr1.shape);\n\n var mr2 = linalg.matrix_rank(randn(2, 4, 3, 2));\n Assert.Equal(new long[] { 2, 4 }, mr2.shape);\n\n // Really just testing that it doesn't blow up in interop for the following lines:\n\n mr2 = linalg.matrix_rank(randn(2, 4, 3, 2), atol: 1.0);\n Assert.Equal(new long[] { 2, 4 }, mr2.shape);\n\n mr2 = linalg.matrix_rank(randn(2, 4, 3, 2), atol: 1.0, rtol: 0.0);\n Assert.Equal(new long[] { 2, 4 }, mr2.shape);\n\n mr2 = linalg.matrix_rank(randn(2, 4, 3, 2), atol: tensor(1.0));\n Assert.Equal(new long[] { 2, 4 }, mr2.shape);\n\n mr2 = linalg.matrix_rank(randn(2, 4, 3, 2), atol: tensor(1.0), rtol: tensor(0.0));\n Assert.Equal(new long[] { 2, 4 }, mr2.shape);\n }\n\n [Fact]\n [TestOf(nameof(linalg.multi_dot))]\n public void MultiDotTest()\n {\n var a = randn(new long[] { 25, 25 });\n var b = randn(new long[] { 25, 25 });\n var c = randn(new long[] { 25, 25 });\n var d = linalg.multi_dot(new Tensor[] { a, b, c });\n Assert.Equal(new long[] { 25, 25 }, d.shape);\n }\n\n [Fact]\n [TestOf(nameof(linalg.det))]\n public void DeterminantTest()\n {\n {\n var a = tensor(\n new float[] { 0.9478f, 0.9158f, -1.1295f,\n 0.9701f, 0.7346f, -1.8044f,\n -0.2337f, 0.0557f, 0.6929f }, 3, 3);\n var l = linalg.det(a);\n Assert.True(l.allclose(tensor(0.09335048f)));\n }\n {\n var a = tensor(\n new float[] { 0.9254f, -0.6213f, -0.5787f, 1.6843f, 0.3242f, -0.9665f,\n 0.4539f, -0.0887f, 1.1336f, -0.4025f, -0.7089f, 0.9032f }, 3, 2, 2);\n var l = linalg.det(a);\n Assert.True(l.allclose(tensor(new float[] { 1.19910491f, 0.4099378f, 0.7385352f })));\n }\n }\n\n [Fact]\n [TestOf(nameof(linalg.matrix_norm))]\n public void MatrixNormTest()\n {\n {\n var a = arange(9, float32).view(3, 3);\n\n var b = linalg.matrix_norm(a);\n var c = linalg.matrix_norm(a, ord: -1);\n\n Assert.Equal(14.282857f, b.item());\n Assert.Equal(9.0f, c.item());\n }\n }\n\n [Fact]\n [TestOf(nameof(linalg.vector_norm))]\n public void VectorNormTest()\n {\n {\n var a = tensor(\n new float[] { -4.0f, -3.0f, -2.0f, -1.0f, 0, 1.0f, 2.0f, 3.0f, 4.0f });\n\n var b = linalg.vector_norm(a, ord: 3.5);\n var c = linalg.vector_norm(a.view(3, 3), ord: 3.5);\n\n Assert.Equal(5.4344883f, b.item());\n Assert.Equal(5.4344883f, c.item());\n }\n }\n\n [Fact]\n [TestOf(nameof(linalg.pinv))]\n public void PinvTest()\n {\n var mr1 = linalg.pinv(randn(4, 3, 5));\n Assert.Equal(new long[] { 4, 5, 3 }, mr1.shape);\n\n // Really just testing that it doesn't blow up in interop for the following lines:\n\n mr1 = linalg.pinv(randn(4, 3, 5), atol: 1.0);\n Assert.Equal(new long[] { 4, 5, 3 }, mr1.shape);\n\n mr1 = linalg.pinv(randn(4, 3, 5), atol: 1.0, rtol: 0.0);\n Assert.Equal(new long[] { 4, 5, 3 }, mr1.shape);\n\n mr1 = linalg.pinv(randn(4, 3, 5), atol: tensor(1.0));\n Assert.Equal(new long[] { 4, 5, 3 }, mr1.shape);\n\n mr1 = linalg.pinv(randn(4, 3, 5), atol: tensor(1.0), rtol: tensor(0.0));\n Assert.Equal(new long[] { 4, 5, 3 }, mr1.shape);\n }\n\n [Fact]\n [TestOf(nameof(linalg.eig))]\n public void EigTest32()\n {\n {\n var a = tensor(\n new float[] { 2.8050f, -0.3850f, -0.3850f, 3.2376f, -1.0307f, -2.7457f, -2.7457f, -1.7517f, 1.7166f }, 3, 3);\n\n var expected = tensor(\n new (float, float)[] { (3.44288778f, 0.0f), (2.17609453f, 0.0f), (-2.128083f, 0.0f) });\n\n {\n var (values, vectors) = linalg.eig(a);\n Assert.NotNull(vectors);\n Assert.True(values.allclose(expected));\n }\n }\n }\n\n [Fact]\n [TestOf(nameof(linalg.eigvals))]\n public void EighvalsTest32()\n {\n var a = tensor(\n new float[] { 2.8050f, -0.3850f, -0.3850f, 3.2376f, -1.0307f, -2.7457f, -2.7457f, -1.7517f, 1.7166f }, 3, 3);\n var expected = tensor(\n new (float, float)[] { (3.44288778f, 0.0f), (2.17609453f, 0.0f), (-2.128083f, 0.0f) });\n var l = linalg.eigvals(a);\n Assert.True(l.allclose(expected));\n }\n\n // TODO: (Skip = \"Intermittently failing on MacOS or Linux (note: may now be working, we need to recheck)\")\n [FactIgnoreOnPlatform(\"Intermittently fails\", \"OSX\", \"Linux\")]\n [TestOf(nameof(linalg.eigvals))]\n public void EighvalsTest64()\n {\n var a = tensor(\n new double[] { 2.8050f, -0.3850f, -0.3850f, 3.2376f, -1.0307f, -2.7457f, -2.7457f, -1.7517f, 1.7166f }, 3, 3);\n var expected = tensor(\n new System.Numerics.Complex[] { new System.Numerics.Complex(3.44288778f, 0.0f), new System.Numerics.Complex(2.17609453f, 0.0f), new System.Numerics.Complex(-2.128083f, 0.0f) });\n var l = linalg.eigvals(a);\n Assert.True(l.allclose(expected));\n }\n\n // TODO: (Skip = \"Intermittently failing on MacOS or Linux (note: may now be working, we need to recheck)\")\n [FactIgnoreOnPlatform(\"Intermittently fails\", \"OSX\", \"Linux\")]\n [TestOf(nameof(linalg.eigvalsh))]\n public void EighvalshTest32()\n {\n var a = tensor(\n new float[] { 2.8050f, -0.3850f, -0.3850f, 3.2376f, -1.0307f, -2.7457f,\n -2.7457f, -1.7517f, 1.7166f, 2.2207f, 2.2207f, -2.0898f }, 3, 2, 2);\n var expected = tensor(\n new float[] { 2.5797f, 3.46290016f, -4.16046524f, 1.37806475f, -3.11126733f, 2.73806715f }, 3, 2);\n var l = linalg.eigvalsh(a);\n Assert.True(l.allclose(expected));\n }\n\n // TODO: (Skip = \"Intermittently failing on MacOS or Linux (note: may now be working, we need to recheck)\")\n [FactIgnoreOnPlatform(\"Intermittently fails\", \"OSX\", \"Linux\")]\n [TestOf(nameof(linalg.eigvalsh))]\n public void EighvalshTest64()\n {\n var a = tensor(\n new double[] { 2.8050, -0.3850, -0.3850, 3.2376, -1.0307, -2.7457,\n -2.7457, -1.7517, 1.7166, 2.2207, 2.2207, -2.0898 }, 3, 2, 2);\n var expected = tensor(\n new double[] { 2.5797, 3.46290016, -4.16046524, 1.37806475, -3.11126733, 2.73806715 }, 3, 2);\n var l = linalg.eigvalsh(a);\n Assert.True(l.allclose(expected));\n }\n\n [Fact]\n [TestOf(nameof(linalg.norm))]\n public void LinalgNormTest()\n {\n {\n var a = tensor(\n new float[] { -4.0f, -3.0f, -2.0f, -1.0f, 0.0f, 1.0f, 2.0f, 3.0f, 4.0f });\n var b = a.reshape(3, 3);\n\n Assert.True(linalg.norm(a).allclose(tensor(7.7460f)));\n Assert.True(linalg.norm(b).allclose(tensor(7.7460f)));\n Assert.True(linalg.norm(b, \"fro\").allclose(tensor(7.7460f)));\n\n Assert.True(linalg.norm(a, float.PositiveInfinity).allclose(tensor(4.0f)));\n Assert.True(linalg.norm(b, float.PositiveInfinity).allclose(tensor(9.0f)));\n Assert.True(linalg.norm(a, float.NegativeInfinity).allclose(tensor(0.0f)));\n Assert.True(linalg.norm(b, float.NegativeInfinity).allclose(tensor(2.0f)));\n\n Assert.True(linalg.norm(a, 1).allclose(tensor(20.0f)));\n Assert.True(linalg.norm(b, 1).allclose(tensor(7.0f)));\n Assert.True(linalg.norm(a, -1).allclose(tensor(0.0f)));\n Assert.True(linalg.norm(b, -1).allclose(tensor(6.0f)));\n\n Assert.True(linalg.norm(a, 2).allclose(tensor(7.7460f)));\n Assert.True(linalg.norm(b, 2).allclose(tensor(7.3485f)));\n Assert.True(linalg.norm(a, 3).allclose(tensor(5.8480f)));\n Assert.True(linalg.norm(a, -2).allclose(tensor(0.0f)));\n Assert.True(linalg.norm(a, -3).allclose(tensor(0.0f)));\n }\n }\n\n [Fact]\n public void TestTrilIndex()\n {\n var a = tril_indices(3, 3);\n var expected = new long[] { 0, 1, 1, 2, 2, 2, 0, 0, 1, 0, 1, 2 };\n Assert.Equal(expected, a.data().ToArray());\n }\n\n [Fact]\n public void TestTriuIndex()\n {\n var a = triu_indices(3, 3);\n var expected = new long[] { 0, 0, 0, 1, 1, 2, 0, 1, 2, 1, 2, 2 };\n Assert.Equal(expected, a.data().ToArray());\n }\n }\n}\n"},{"alpha_fraction":0.6116677522659302,"alphanum_fraction":0.6152304410934448,"avg_line_length":58.092105865478516,"blob_id":"2193a8c2faa8681546edda60ec36f27244284a7a","content_id":"0473ddb98051c9ff5a8cf567bcdaa941706cee72","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":4499,"license_type":"permissive","max_line_length":360,"num_lines":76,"path":"/src/TorchSharp/NN/MultiheadAttention.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See License.txt in the project root for license information.\nusing System;\nusing static TorchSharp.PInvoke.NativeMethods;\nusing static TorchSharp.torch;\n\n#nullable enable\nnamespace TorchSharp\n{\n using Modules;\n\n namespace Modules\n {\n public sealed class MultiheadAttention : torch.nn.Module>\n {\n internal MultiheadAttention(IntPtr handle, IntPtr boxedHandle) : base(handle, boxedHandle) { }\n\n /// \n /// Applies the MultiheadAttention function element-wise.\n /// \n /// map a query and a set of key-value pairs to an output. See “Attention Is All You Need” for more details\n /// \n /// \n /// if provided, specified padding elements in the key will be ignored by the attention. When given a binary mask and a value is True, the corresponding value on the attention layer will be ignored. When given a byte mask and a value is non-zero, the corresponding value on the attention layer will be ignored\n /// output attn_output_weights\n /// 2D or 3D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all the batches while a 3D mask allows to specify a different mask for the entries of each batch\n /// attn_output, attn_ouput_weights \n\n public override Tuple forward(Tensor query, Tensor key, Tensor value, Tensor? key_padding_mask, bool need_weights, Tensor? attn_mask)\n {\n THSNN_MultiheadAttention_forward(handle,\n query.Handle,\n key.Handle,\n value.Handle,\n key_padding_mask?.Handle ?? IntPtr.Zero,\n need_weights,\n attn_mask?.Handle ?? IntPtr.Zero,\n out var res1,\n out var res2);\n if (res1 == IntPtr.Zero || (need_weights && res2 == IntPtr.Zero)) { torch.CheckForErrors(); }\n return Tuple.Create(new Tensor(res1), new Tensor(res2));\n }\n\n public new Tuple call(Tensor query, Tensor key, Tensor value, Tensor? key_padding_mask = null, bool need_weights = true, Tensor? attn_mask = null)\n {\n return base.call(query, key, value, key_padding_mask, need_weights, attn_mask);\n }\n }\n }\n\n public static partial class torch\n {\n public static partial class nn\n {\n /// \n /// Allows the model to jointly attend to information from different representation subspaces (based on the paper “Attention Is All You Need”).\n /// \n /// total dimension of the model\n /// parallel attention heads\n /// a Dropout layer on attn_output_weights. Default: 0.0\n /// add bias as module parameter. Default: true\n /// add bias to the key and value sequences at dim=0\n /// add a new batch of zeros to the key and value sequences at dim=1\n /// total number of features in key\n /// total number of features in value\n /// ? fill)\n {\n switch(op_name) {\n case opType.ShearX:\n return F.affine(\n img,\n angle: 0.0f,\n translate: new[] { 0, 0 },\n scale: 1.0f,\n shear: new[] { (float)((180.0 / Math.PI) * Math.Atan(magnitude)), 0.0f },\n interpolation: interpolation,\n fill: fill?.FirstOrDefault());\n case opType.ShearY:\n return F.affine(\n img,\n angle: 0.0f,\n translate: new[] { 0, 0 },\n scale: 1.0f,\n shear: new[] { 0.0f, (float)((180.0 / Math.PI) * Math.Atan(magnitude)) },\n interpolation: interpolation,\n fill: fill?.FirstOrDefault());\n case opType.TranslateX:\n return F.affine(\n img,\n angle: 0.0f,\n translate: new[] { (int)(magnitude), 0 },\n scale: 1.0f,\n interpolation: interpolation,\n shear: new[] { 0.0f, 0.0f },\n fill: fill?.FirstOrDefault());\n case opType.TranslateY:\n return F.affine(\n img,\n angle: 0.0f,\n translate: new[] { 0, (int)(magnitude) },\n scale: 1.0f,\n interpolation: interpolation,\n shear: new[] { 0.0f, 0.0f },\n fill: fill?.FirstOrDefault());\n case opType.Rotate:\n return F.rotate(img, (float)magnitude, interpolation, fill: fill);\n case opType.Brightness:\n return F.adjust_brightness(img, 1.0 + magnitude);\n case opType.Color:\n return F.adjust_saturation(img, 1.0 + magnitude);\n case opType.Contrast:\n return F.adjust_contrast(img, 1.0 + magnitude);\n case opType.Sharpness:\n return F.adjust_sharpness(img, 1.0 + magnitude);\n case opType.Posterize:\n return F.posterize(img, (int)magnitude);\n case opType.Solarize:\n return F.solarize(img, magnitude);\n case opType.AutoContrast:\n return F.autocontrast(img);\n case opType.Equalize:\n return F.equalize(img);\n case opType.Invert:\n return F.invert(img);\n case opType.Identity:\n return img; // Pass\n default:\n throw new ArgumentException($\"The provided operator {op_name} is not recognized.\");\n }\n }\n }\n\n /* Original implementation from:\n * https://pytorch.org/vision/main/_modules/torchvision/transforms/autoaugment.html#RandAugment */\n internal class RandAugment : AutoAugmentBase, ITransform\n {\n public RandAugment(\n int num_ops = 2,\n int magnitude = 9,\n int num_magnitude_bins = 31,\n InterpolationMode interpolation = InterpolationMode.Nearest,\n IList? fill = null)\n {\n this.num_ops = num_ops;\n this.magnitude = magnitude;\n this.num_magnitude_bins = num_magnitude_bins;\n this.interpolation = interpolation;\n this.fill = fill;\n }\n\n public Tensor call(Tensor img)\n {\n using var _ = torch.NewDisposeScope();\n var cDim = img.Dimensions - 3;\n var height = img.shape[cDim + 1];\n var width = img.shape[cDim + 2];\n var op_meta = augmentation_space(num_magnitude_bins, (height, width));\n for (int i = 0; i < num_ops; ++i) {\n var op_index = torch.randint(0, op_meta.Count, 1).ToInt32();\n var op_name = op_meta.Keys.ToList()[op_index];\n var (magnitudes, signed) = op_meta[op_name];\n var magnitude = magnitudes.Dimensions > 0 ? magnitudes[this.magnitude].ToDouble() : 0.0;\n\n if (signed && torch.randint(0, 2, 1).ToBoolean())\n magnitude *= -1.0;\n\n img = apply_op(img, op_name, magnitude, interpolation, this.fill);\n }\n return img.MoveToOuterDisposeScope();\n }\n\n private Dictionary augmentation_space(int num_bins, (long height, long width) image_size)\n {\n return new Dictionary {\n { opType.Identity, (torch.tensor(0.0), false) },\n { opType.ShearX, (torch.linspace(0.0, 0.3, num_bins), true) },\n { opType.ShearY, (torch.linspace(0.0, 0.3, num_bins), true) },\n { opType.TranslateX, (torch.linspace(0.0, 150.0 / 331.0 * image_size.height, num_bins), true) },\n { opType.TranslateY, (torch.linspace(0.0, 150.0 / 331.0 * image_size.width, num_bins), true) },\n { opType.Rotate, (torch.linspace(0.0, 30.0, num_bins), true) },\n { opType.Brightness, (torch.linspace(0.0, 0.9, num_bins), true) },\n { opType.Color, (torch.linspace(0.0, 0.9, num_bins), true) },\n { opType.Contrast, (torch.linspace(0.0, 0.9, num_bins), true) },\n { opType.Sharpness, (torch.linspace(0.0, 0.9, num_bins), true) },\n { opType.Posterize, (8 - (torch.arange(num_bins) / ((num_bins - 1) / 4)).round().@int(), false)},\n { opType.Solarize, (torch.linspace(255.0, 0.0, num_bins), false) },\n { opType.AutoContrast, (torch.tensor(0.0), false) },\n { opType.Equalize, (torch.tensor(0.0), false) }\n };\n }\n\n private readonly int num_ops;\n private readonly int magnitude;\n private readonly int num_magnitude_bins;\n private readonly InterpolationMode interpolation;\n private readonly IList? fill;\n }\n\n public static partial class transforms\n {\n /// \n /// RandAugment data augmentation method based on\n /// \"RandAugment: Practical automated data augmentation with a reduced search space\"\n /// https://arxiv.org/abs/1909.13719\n /// The image is expected to be a torch Tensor, it should be of type torch.uint8, and it is expected\n /// to have [..., 1 or 3, H, W] shape, where ... means an arbitrary number of leading dimensions.\n /// \n /// Number of augmentation transformations to apply sequentially. Default: 2\n /// Magnitude for all the transformations. Default: 9\n /// The number of different magnitude values. Default: 31\n /// Desired interpolation enum defined by\n /// torchvision.transforms.InterpolationMode. Default: InterpolationMode.NEAREST.\n /// Pixel fill value for the area outside the transformed\n /// image. If given a number, the value is used for all bands respectively. Default: null\n static public ITransform RandAugment(\n int num_ops = 2,\n int magnitude = 9,\n int num_magnitude_bins = 31,\n InterpolationMode interpolation = InterpolationMode.Nearest,\n IList? fill = null)\n {\n return new RandAugment(num_ops, magnitude, num_magnitude_bins, interpolation, fill);\n }\n }\n }\n}\n"},{"alpha_fraction":0.5736501812934875,"alphanum_fraction":0.5752227902412415,"avg_line_length":42.35606002807617,"blob_id":"0f4ed65c2fb91ee2821da415f1600f77afa9d99e","content_id":"4fbb086a3cb0d8e783ebdbf8b4ffb6cc6f417e50","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":5725,"license_type":"permissive","max_line_length":149,"num_lines":132,"path":"/src/TorchSharp/Distributions/Exponential.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\nusing System;\nusing System.Collections.Generic;\nusing static TorchSharp.torch;\n\nnamespace TorchSharp\n{\n using Modules;\n\n namespace Modules\n {\n /// \n /// An Exponential distribution parameterized by `rate`.\n /// \n public class Exponential : torch.distributions.ExponentialFamily\n {\n /// \n /// The mean of the distribution.\n /// \n public override Tensor mean => rate.reciprocal();\n\n public override Tensor mode => torch.zeros_like(rate);\n\n /// \n /// The variance of the distribution\n /// \n public override Tensor variance => rate.pow(2);\n\n /// \n /// The standard deviation of the distribution\n /// \n public override Tensor stddev => rate.reciprocal();\n\n\n /// \n /// Constructor\n /// \n /// rate = 1 / scale of the distribution (often referred to as 'β')\n /// An optional random number generator object.\n public Exponential(Tensor rate, torch.Generator generator = null) : base(generator)\n {\n var locScale = torch.broadcast_tensors(rate);\n this.batch_shape = rate.size();\n this.rate = locScale[0].DetachFromDisposeScope();\n }\n\n private Tensor rate;\n\n /// \n /// Generates a sample_shape shaped reparameterized sample or sample_shape shaped batch of reparameterized samples\n /// if the distribution parameters are batched.\n /// \n /// The sample shape.\n public override Tensor rsample(params long[] sample_shape)\n {\n var shape = ExtendedShape(sample_shape);\n return rate.new_empty(shape).exponential_(generator: generator) / rate;\n }\n\n /// \n /// Returns the log of the probability density/mass function evaluated at `value`.\n /// \n /// \n public override Tensor log_prob(Tensor value) => WrappedTensorDisposeScope(() => rate.log() - rate * value);\n\n /// \n /// Returns entropy of distribution, batched over batch_shape.\n /// \n /// \n /// Returns the cumulative density/mass function evaluated at `value`.\n /// \n /// \n public override Tensor cdf(Tensor value) => WrappedTensorDisposeScope(() => 1 - torch.exp(-rate * value));\n\n /// \n /// Returns the inverse cumulative density/mass function evaluated at `value`.\n /// \n /// \n public override Tensor icdf(Tensor value) => WrappedTensorDisposeScope(() => -torch.log(1 - value) / rate);\n\n /// \n /// Returns a new distribution instance (or populates an existing instance provided by a derived class) with batch dimensions expanded to\n /// `batch_shape`. This method calls `torch.Tensor.expand()` on the distribution's parameters. As such, this does not allocate new\n /// memory for the expanded distribution instance.\n /// \n /// Tthe desired expanded size.\n /// new instance provided by subclasses that need to override `.expand`.\n public override distributions.Distribution expand(Size batch_shape, distributions.Distribution instance = null)\n {\n if (instance != null && !(instance is Exponential))\n throw new ArgumentException(\"expand(): 'instance' must be a Exponential distribution\");\n\n var r = rate.expand(batch_shape);\n\n var newDistribution = ((instance == null) ? new Exponential(r, generator) : instance) as Exponential;\n\n newDistribution.batch_shape = batch_shape;\n if (newDistribution == instance) {\n newDistribution.rate = r;\n }\n return newDistribution;\n }\n\n protected override IList NaturalParams => new Tensor[] { -rate };\n\n protected override Tensor MeanCarrierMeasure => torch.tensor(0, dtype:rate.dtype, device: rate.device);\n\n protected override Tensor LogNormalizer(params Tensor[] parameters) => -torch.log(-parameters[0]);\n }\n\n }\n\n public static partial class torch\n {\n public static partial class distributions\n {\n /// \n /// Creates a Exponential distribution parameterized by `rate`.\n /// \n /// rate = 1 / scale of the distribution (often referred to as 'β')\n /// An optional random number generator object.\n /// \n /// Abstract class for invertable transformations with computable log det jacobians.\n ///\n /// They are primarily used in torch.distributions.TransformedDistribution.\n /// \n /// \n /// Derived classes should implement one or both of 'forward()' or 'inverse()'.\n /// Derived classes that set `bijective=true` should also implement 'log_abs_det_jacobian()'\n /// \n public abstract class Transform\n {\n protected bool _bijective = false;\n\n protected constraints.Constraint _domain;\n\n protected constraints.Constraint _codomain;\n\n protected Transform _inv = null;\n\n public virtual int event_dim {\n get {\n if (_domain.event_dim == codomain.event_dim)\n return _domain.event_dim;\n throw new InvalidOperationException(\"Please use either .domain.event_dim or .codomain.event_dim\");\n }\n }\n\n public virtual Transform inv {\n get {\n Transform result = null;\n if (this._inv != null)\n result = _inv;\n if (result == null) {\n result = new _InverseTransform(this);\n _inv = result;\n }\n return result;\n }\n }\n\n public virtual constraints.Constraint domain {\n get {\n return _domain;\n }\n }\n\n public virtual constraints.Constraint codomain {\n get {\n return _codomain;\n }\n }\n\n public virtual bool bijective {\n get {\n return _bijective;\n }\n }\n\n public Tensor sign {\n get {\n return _sign();\n }\n }\n\n protected internal virtual Tensor _sign()\n {\n throw new NotImplementedException();\n }\n\n protected internal abstract Tensor _call(Tensor x);\n\n protected internal abstract Tensor _inverse(Tensor y);\n\n protected internal virtual Tensor log_abs_det_jacobian(Tensor x, Tensor y)\n {\n throw new NotImplementedException();\n }\n\n public Tensor forward(Tensor x) => this._call(x);\n\n public virtual long[] forward_shape(long[] shape) => shape;\n\n public virtual long[] inverse_shape(long[] shape) => shape;\n\n protected internal static Tensor _sum_rightmost(Tensor value, int dim)\n {\n if (dim == 0) return value;\n var required_shape = new long[value.shape.Length - dim + 1];\n var i = 0;\n for (; i < value.shape.Length - dim; i++) required_shape[i] = value.shape[i];\n required_shape[i] = -1;\n return value.reshape(required_shape).sum(-1);\n }\n }\n\n\n internal class _InverseTransform : Transform\n {\n public _InverseTransform(torch.distributions.transforms.Transform transform)\n {\n this._inv = transform;\n }\n\n public override constraints.Constraint domain {\n get {\n return _inv.domain;\n }\n }\n\n public override constraints.Constraint codomain {\n get {\n return _inv.codomain;\n }\n }\n\n public override bool bijective {\n get {\n return _inv.bijective;\n }\n }\n\n public override int event_dim => base.event_dim;\n\n public override Transform inv => base.inv;\n\n protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)\n {\n return -_inv.log_abs_det_jacobian(y, x);\n }\n\n protected internal override Tensor _call(Tensor x)\n {\n return _inv._inverse(x);\n }\n\n protected internal override Tensor _inverse(Tensor y)\n {\n return _inv._call(y);\n }\n\n protected internal override Tensor _sign()\n {\n return _inv.sign;\n }\n\n public override long[] forward_shape(long[] shape)\n {\n return _inv.forward_shape(shape);\n }\n\n public override long[] inverse_shape(long[] shape)\n {\n return _inv.inverse_shape(shape);\n }\n }\n\n public class ComposeTransform : Transform\n {\n public ComposeTransform(IEnumerable parts, int cache_size = 0)\n {\n if (parts == null) throw new ArgumentNullException(\"parts cannot be null\");\n\n _parts = parts.ToArray();\n _reverse_parts = parts.Reverse().ToArray();\n }\n\n private Transform[] _parts;\n private Transform[] _reverse_parts;\n\n public override int event_dim => base.event_dim;\n\n public override Transform inv {\n get {\n Transform i = _inv;\n\n if (i == null) {\n i = new ComposeTransform(_reverse_parts.Select(p => p.inv));\n _inv = i;\n }\n return _inv;\n }\n }\n\n public override constraints.Constraint domain {\n get {\n if (_parts == null) return constraints.real;\n\n var cnt = _parts.Length;\n var d = _parts[0].domain;\n\n var ed = _parts[cnt - 1].codomain.event_dim;\n foreach (var part in _reverse_parts) {\n ed += part.domain.event_dim - part.codomain.event_dim;\n ed = ed < part.domain.event_dim ? part.domain.event_dim : ed;\n }\n if (ed > d.event_dim) {\n d = constraints.independent(domain, ed - domain.event_dim);\n }\n return d;\n }\n }\n\n public override constraints.Constraint codomain {\n get {\n if (_parts == null) return constraints.real;\n\n var cnt = _parts.Length;\n var cod = _parts[cnt - 1].domain;\n\n var ed = _parts[0].domain.event_dim;\n foreach (var part in _parts) {\n ed += part.codomain.event_dim - part.domain.event_dim;\n ed = ed < part.codomain.event_dim ? part.codomain.event_dim : ed;\n }\n if (ed > cod.event_dim) {\n cod = constraints.independent(codomain, ed - codomain.event_dim);\n }\n return cod;\n }\n }\n\n public override bool bijective => _parts.All(p => p.bijective);\n\n protected internal override Tensor _sign()\n {\n Tensor s = 1;\n foreach (var p in _parts) s *= p.sign;\n return s;\n }\n\n protected internal override Tensor _call(Tensor x)\n {\n using var _ = torch.NewDisposeScope();\n foreach (var p in _parts) {\n x = p._call(x);\n }\n return x.MoveToOuterDisposeScope();\n }\n\n protected internal override Tensor _inverse(Tensor y)\n {\n throw new NotImplementedException();\n }\n\n protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)\n {\n if (_parts == null) {\n return torch.zeros_like(x);\n }\n\n using var _ = torch.NewDisposeScope();\n\n var xs = new List();\n xs.Add(x);\n for (int i = 0; i < _parts.Length-1; i++) {\n var part = _parts[i];\n xs.Add(part._call(xs[i]));\n }\n xs.Add(y);\n\n var terms = new List();\n var event_dim = domain.event_dim;\n\n for (int i = 0; i < _parts.Length - 1; i++) {\n var part = _parts[i];\n var x1 = xs[i];\n var y1 = xs[i + 1];\n\n terms.Add(_sum_rightmost(part.log_abs_det_jacobian(x1, y), event_dim - part.domain.event_dim));\n event_dim += part.codomain.event_dim - part.domain.event_dim;\n }\n\n Tensor result = terms[0];\n for (var i = 1; i < terms.Count; i++) {\n result = result + terms[i];\n }\n return result.MoveToOuterDisposeScope();\n }\n\n public override long[] forward_shape(long[] shape)\n {\n foreach (var p in _parts) {\n shape = p.forward_shape(shape);\n }\n return shape;\n }\n\n public override long[] inverse_shape(long[] shape)\n {\n foreach (var p in _reverse_parts) {\n shape = p.forward_shape(shape);\n }\n return shape;\n }\n }\n\n public class IndepdenentTransform : Transform\n {\n private Transform base_transform;\n private int reinterpreted_batch_dims;\n\n public IndepdenentTransform(Transform base_transform, int reinterpreted_batch_dims)\n {\n this.base_transform = base_transform;\n this.reinterpreted_batch_dims = reinterpreted_batch_dims;\n }\n\n public override int event_dim => base.event_dim;\n\n public override Transform inv => base.inv;\n\n public override constraints.Constraint domain => constraints.independent(base_transform.domain, reinterpreted_batch_dims);\n\n public override constraints.Constraint codomain => constraints.independent(base_transform.codomain, reinterpreted_batch_dims);\n\n public override bool bijective => base_transform.bijective;\n\n public override long[] forward_shape(long[] shape)\n {\n return base_transform.forward_shape(shape);\n }\n\n public override long[] inverse_shape(long[] shape)\n {\n return base_transform.inverse_shape(shape);\n }\n\n protected internal override Tensor _sign() => base_transform._sign();\n\n protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)\n {\n using var _ = torch.NewDisposeScope();\n var result = base_transform.log_abs_det_jacobian(x, y);\n result = _sum_rightmost(result, reinterpreted_batch_dims);\n return result.MoveToOuterDisposeScope();\n }\n\n protected internal override Tensor _call(Tensor x)\n {\n if (x.dim() < domain.event_dim)\n throw new ArgumentException(\"Too few dimensions on input\");\n return base_transform._call(x);\n }\n\n protected internal override Tensor _inverse(Tensor y)\n {\n if (y.dim() < codomain.event_dim)\n throw new ArgumentException(\"Too few dimensions on input\");\n return base_transform._inverse(y);\n }\n }\n\n public class ReshapeTransform : Transform\n {\n private Size in_shape;\n private Size out_shape;\n\n public ReshapeTransform(long[] in_shape, long[] out_shape)\n {\n this.in_shape = in_shape;\n this.out_shape = out_shape;\n if (this.in_shape.numel() != this.out_shape.numel())\n throw new ArgumentException(\"in_shape, out_shape have different numbers of elements\");\n\n }\n public override bool bijective => true;\n\n public override constraints.Constraint domain => constraints.independent(constraints.real, in_shape.Length);\n\n public override constraints.Constraint codomain => constraints.independent(constraints.real, out_shape.Length);\n\n public override long[] forward_shape(long[] shape)\n {\n return base.forward_shape(shape);\n }\n\n public override long[] inverse_shape(long[] shape)\n {\n return base.inverse_shape(shape);\n }\n\n protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)\n {\n long inLen = x.shape.Length - (x.dim() - in_shape.Length);\n var batch_shape = new long[inLen];\n for (var i = 0; i < inLen; i++) {\n batch_shape[i] = x.shape[i];\n }\n return x.new_zeros(batch_shape);\n }\n\n protected internal override Tensor _call(Tensor x)\n {\n long inLen = x.shape.Length - (x.dim() - in_shape.Length);\n long otLen = out_shape.Length;\n var batch_shape = new long[inLen+otLen];\n for (var i = 0; i < inLen; i++) {\n batch_shape[i] = x.shape[i];\n }\n for (var i = 0; i < otLen; i++) {\n batch_shape[i+inLen] = out_shape[i];\n }\n return x.reshape(batch_shape);\n }\n\n protected internal override Tensor _inverse(Tensor y)\n {\n long otLen = y.shape.Length - (y.dim() - out_shape.Length);\n long inLen = in_shape.Length;\n var batch_shape = new long[inLen + otLen];\n for (var i = 0; i < otLen; i++) {\n batch_shape[i] = y.shape[i];\n }\n for (var i = 0; i < inLen; i++) {\n batch_shape[i + otLen] = in_shape[i];\n }\n return y.reshape(batch_shape);\n }\n }\n\n public class ExpTransform : Transform\n {\n public override constraints.Constraint domain => constraints.real;\n\n public override constraints.Constraint codomain => constraints.positive;\n\n public override bool bijective => true;\n\n protected internal override Tensor _sign() => 1;\n\n protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y) => x;\n protected internal override Tensor _call(Tensor x) => x.exp();\n\n protected internal override Tensor _inverse(Tensor y) => y.log();\n }\n\n public class LogTransform : Transform\n {\n public override constraints.Constraint domain => constraints.positive;\n\n public override constraints.Constraint codomain => constraints.real;\n\n public override bool bijective => true;\n\n protected internal override Tensor _sign() => 1;\n\n protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y) => -x;\n\n protected internal override Tensor _call(Tensor x) => x.log();\n\n protected internal override Tensor _inverse(Tensor y) => y.exp();\n }\n\n public class PowerTransform : Transform\n {\n private Tensor exponent;\n\n public PowerTransform(Tensor exponent)\n {\n this.exponent = exponent;\n }\n\n public override constraints.Constraint domain => constraints.positive;\n\n public override constraints.Constraint codomain => constraints.positive;\n\n public override bool bijective => true;\n\n protected internal override Tensor _sign() => 1;\n\n public override long[] forward_shape(long[] shape)\n {\n return torch.broadcast_shapes(shape, exponent.shape).Shape;\n }\n\n public override long[] inverse_shape(long[] shape)\n {\n return torch.broadcast_shapes(shape, exponent.shape).Shape;\n }\n\n protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)\n {\n return torch.WrappedTensorDisposeScope(() => (exponent * y / x).abs().log());\n }\n\n protected internal override Tensor _call(Tensor x)\n {\n return x.pow(exponent);\n }\n\n protected internal override Tensor _inverse(Tensor y)\n {\n return y.pow(1 / exponent);\n }\n }\n\n public class SigmoidTransform : Transform\n {\n public override constraints.Constraint domain => constraints.real;\n\n public override constraints.Constraint codomain => constraints.unit_interval;\n\n public override bool bijective => true;\n\n protected internal override Tensor _sign() => 1;\n\n protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y) => -nn.functional.softplus(-x) - nn.functional.softplus(x);\n\n protected internal override Tensor _call(Tensor x)\n {\n var finfo = torch.finfo(x.dtype);\n return torch.WrappedTensorDisposeScope(() => torch.clamp(torch.sigmoid(x), min: finfo.tiny, max: 1 - finfo.eps));\n }\n\n protected internal override Tensor _inverse(Tensor y)\n {\n using var _ = torch.NewDisposeScope();\n var finfo = torch.finfo(y.dtype);\n y = y.clamp(min: finfo.tiny, max: 1 - finfo.eps);\n return (y.log() - (-y).log1p()).MoveToOuterDisposeScope();\n }\n }\n\n public class SoftplusTransform : Transform\n {\n public override constraints.Constraint domain => constraints.real;\n\n public override constraints.Constraint codomain => constraints.positive;\n\n public override bool bijective => true;\n\n protected internal override Tensor _sign() => 1;\n\n protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y) => -nn.functional.softplus(-x);\n\n protected internal override Tensor _call(Tensor x) => nn.functional.softplus(-x);\n\n protected internal override Tensor _inverse(Tensor y) => (-y).expm1().neg().log() + y;\n }\n\n public class SoftmaxTransform : Transform\n {\n public override constraints.Constraint domain => constraints.real_vector;\n\n public override constraints.Constraint codomain => constraints.simplex;\n\n public override bool bijective => true;\n\n protected internal override Tensor _call(Tensor x)\n {\n var logprobs = x;\n var probs = (logprobs - logprobs.max(-1, true).values).exp();\n return probs / probs.sum(-1, true);\n }\n\n protected internal override Tensor _inverse(Tensor y)\n {\n return y.log();\n }\n }\n\n\n public class TanhTransform : Transform\n {\n public override constraints.Constraint domain => constraints.real;\n\n public override constraints.Constraint codomain => constraints.interval(-1.0, 1.0);\n\n public override bool bijective => true;\n\n protected internal override Tensor _sign() => 1;\n\n protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y) => torch.WrappedTensorDisposeScope(() => 2.0 * (Math.Log(2.0) - x - -nn.functional.softplus(-2.0 * x)));\n\n protected internal override Tensor _call(Tensor x) => x.tanh();\n\n protected internal override Tensor _inverse(Tensor y) => y.atanh();\n }\n\n public class AbsTransform : Transform\n {\n public override constraints.Constraint domain => constraints.real;\n\n public override constraints.Constraint codomain => constraints.positive;\n\n protected internal override Tensor _call(Tensor x) => x.abs();\n\n protected internal override Tensor _inverse(Tensor y) => y;\n }\n\n public class AffineTransform : Transform\n {\n private Tensor loc;\n private Tensor scale;\n private int _event_dim;\n\n public AffineTransform(double loc, double scale, int event_dim = 0)\n {\n this._event_dim = event_dim;\n this.loc = loc;\n this.scale = scale;\n }\n\n public AffineTransform (Tensor loc, Tensor scale, int event_dim = 0)\n {\n this._event_dim = event_dim;\n this.loc = loc;\n this.scale = scale;\n }\n\n public override int event_dim => _event_dim;\n\n public override bool bijective => true;\n\n public override constraints.Constraint domain =>\n _event_dim == 0 ? constraints.real : constraints.independent(constraints.real, event_dim);\n\n public override constraints.Constraint codomain =>\n _event_dim == 0 ? constraints.real : constraints.independent(constraints.real, event_dim);\n\n public override long[] forward_shape(long[] shape)\n {\n return torch.broadcast_shapes(shape, loc.shape, scale.shape).Shape;\n }\n\n public override long[] inverse_shape(long[] shape)\n {\n return torch.broadcast_shapes(shape, loc.shape, scale.shape).Shape;\n }\n\n protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)\n {\n using var _ = torch.NewDisposeScope();\n var shape = x.shape;\n var scale = this.scale;\n var result = torch.abs(scale).log();\n\n if (_event_dim > 0) {\n var result_size = new long[result.shape.Length - _event_dim + 1];\n int i = 0;\n for (; i < result.shape.Length - _event_dim; i++) result_size[i] = result.shape[i];\n result_size[i] = -1;\n result = result.view(result_size).sum(-1);\n var nshape = new long[shape.Length];\n for (; i < shape.Length - _event_dim; i++) nshape[i] = shape[i];\n shape = nshape;\n }\n return result.expand(shape).MoveToOuterDisposeScope();\n }\n\n protected internal override Tensor _call(Tensor x) => torch.WrappedTensorDisposeScope(() => loc + scale * x);\n\n protected internal override Tensor _inverse(Tensor y) => torch.WrappedTensorDisposeScope(() => (y - loc) / scale);\n\n protected internal override Tensor _sign()\n {\n return scale.sign();\n }\n }\n }\n }\n }\n}\n"},{"alpha_fraction":0.6935985088348389,"alphanum_fraction":0.7016780376434326,"avg_line_length":39.224998474121094,"blob_id":"f788fa7e0caaf70a7fa0398e2ae4b69a1eb8b438","content_id":"bc54870cd554a8893b69066c4bcce17356955df5","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":1609,"license_type":"permissive","max_line_length":130,"num_lines":40,"path":"/src/TorchSharp/PInvoke/LibTorchSharp.THSData.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\n#nullable enable\nusing System;\nusing System.Runtime.InteropServices;\n\nnamespace TorchSharp.PInvoke\n{\n internal static partial class NativeMethods\n {\n#pragma warning disable CA2101\n [DllImport(\"LibTorchSharp\", CharSet = CharSet.Ansi, BestFitMapping = false, ThrowOnUnmappableChar = true)]\n internal static extern IntPtr THSData_loaderMNIST(\n [MarshalAs(UnmanagedType.LPStr)] string filename,\n long batchSize,\n [MarshalAs(UnmanagedType.U1)] bool isTrain);\n\n [DllImport(\"LibTorchSharp\", CharSet = CharSet.Ansi, BestFitMapping = false, ThrowOnUnmappableChar = true)]\n internal static extern IntPtr THSData_loaderCIFAR10(\n [MarshalAs(UnmanagedType.LPStr)] string path,\n long batchSize,\n [MarshalAs(UnmanagedType.U1)] bool isTrain);\n\n [DllImport(\"LibTorchSharp\")]\n internal static extern IntPtr THSData_current(IntPtr iterator, IntPtr data, IntPtr target);\n\n [DllImport(\"LibTorchSharp\")]\n [return: MarshalAs(UnmanagedType.U1)]\n internal static extern bool THSData_moveNext(IntPtr iterator);\n\n [DllImport(\"LibTorchSharp\")]\n internal static extern long THSData_size(IntPtr iterator);\n\n [DllImport(\"LibTorchSharp\")]\n internal static extern void THSData_reset(IntPtr iterator);\n\n [DllImport(\"LibTorchSharp\")]\n internal static extern void THSData_dispose(IntPtr iterator);\n }\n#pragma warning restore CA2101\n}\n"},{"alpha_fraction":0.5785619020462036,"alphanum_fraction":0.5825566053390503,"avg_line_length":34.78571319580078,"blob_id":"edbc10770974a49626d6a0d4677e3d08ee68af0b","content_id":"a9ee0ebe6bf3317ca1e3e115f971a3e9b27841df","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"C#","length_bytes":1502,"license_type":"permissive","max_line_length":130,"num_lines":42,"path":"/src/TorchVision/AdjustSaturation.cs","repo_name":"NiklasGustafsson/TorchSharp","src_encoding":"UTF-8","text":"// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. See LICENSE in the project root for license information.\nusing System;\nusing static TorchSharp.torch;\n\nnamespace TorchSharp\n{\n public static partial class torchvision\n {\n internal class AdjustSaturation : ITransform\n {\n internal AdjustSaturation(double saturation_factor)\n {\n if (saturation_factor < 0.0)\n throw new ArgumentException($\"The saturation factor ({saturation_factor}) must be non-negative.\");\n this.saturation_factor = saturation_factor;\n }\n\n public Tensor call(Tensor img)\n {\n return transforms.functional.adjust_saturation(img, saturation_factor);\n }\n\n private double saturation_factor;\n }\n\n public static partial class transforms\n {\n /// \n /// Adjust the color saturation of an image.\n /// \n /// \n /// How much to adjust the saturation. 0 will give a black and white image, 1 will give the original image\n /// while 2 will enhance the saturation by a factor of 2.\n /// \n /// \n /// This class is used to represent a WaveRNN module.\n /// \n public class WaveRNN : nn.Module\n {\n private readonly int _pad;\n public readonly nn.Module fc;\n public readonly nn.Module
torch.broadcast_tensors(*map(torch.empty, shapes))[0].shape\n /// but avoids the need create to intermediate tensors.\n /// This is useful for broadcasting tensors of common batch shape but different rightmost shape,\n /// e.g. to broadcast mean vectors with covariance matrices.\n ///