Merge branch 'main' into main

AhmedZero · web-flow · commit e7e626575640 · 2025-04-11T20:52:10.000+02:00
diff --git a/RELEASENOTES.md b/RELEASENOTES.md
@@ -7,7 +7,13 @@ __Bug Fixes__:
 
 #1426 Sequential.eval() does not put model into eval mode<br/>
 `torch.optim.lr_scheduler.LinearLR` `end_factor` default has been corrected, is now 1.0.<br/>
+
+__API Changes__:
+
+#1374 Add accumulate to index_put_<br/>
 `torch.optim.lr_scheduler.PolynomialLR` `power` type has been corrected, is now double.<br/>
+Returning an input tensor has been corrected, is now `alias()`.<br/>
+Add `torchvision.transforms.Resize` `interpolation` and `antialias`.<br />
 
 # NuGet Version 0.105.0
 
diff --git a/build/BranchInfo.props b/build/BranchInfo.props
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <MajorVersion>0</MajorVersion>
     <MinorVersion>105</MinorVersion>
-    <PatchVersion>0</PatchVersion>
-    <PreviousPackageVersion>0.104.0</PreviousPackageVersion>
+    <PatchVersion>1</PatchVersion>
+    <PreviousPackageVersion>0.105.0</PreviousPackageVersion>
   </PropertyGroup>
 </Project>
diff --git a/src/Native/LibTorchSharp/THSNN.cpp b/src/Native/LibTorchSharp/THSNN.cpp
@@ -109,6 +109,8 @@ void ApplyInterpolateMode(T& opts, const int8_t mode)
         opts = opts.mode(torch::kTrilinear);
     if (mode == 5)
         opts = opts.mode(torch::kArea);
+    if (mode == 6)
+        opts = opts.mode(torch::kNearestExact);
 }
 
 template<typename T>
@@ -176,13 +178,14 @@ Tensor THSNN_affine_grid(const Tensor theta, const int64_t* size, const int size
 }
 
 
-EXPORT_API(Tensor) THSNN_interpolate(const Tensor input, const int64_t* size, const int size_len, const double* scale_factor, const int scale_factor_len, const int8_t mode, const int8_t align_corners, const bool recompute_scale_factor, NNAnyModule* outAsAnyModule)
+EXPORT_API(Tensor) THSNN_interpolate(const Tensor input, const int64_t* size, const int size_len, const double* scale_factor, const int scale_factor_len, const int8_t mode, const int8_t align_corners, const bool recompute_scale_factor, const bool antialias, NNAnyModule* outAsAnyModule)
 {
     auto opts = torch::nn::functional::InterpolateFuncOptions().recompute_scale_factor(recompute_scale_factor);
     // align_corners -- 0=None, 1=true, 2=false
     if (align_corners != 0)
         opts.align_corners(align_corners == 1);
     ApplyInterpolateMode(opts, mode);
+    opts.antialias(antialias);
 
     if (size_len > 0) {
         std::vector<int64_t> sizes;
diff --git a/src/Native/LibTorchSharp/THSNN.h b/src/Native/LibTorchSharp/THSNN.h
@@ -71,7 +71,7 @@ EXPORT_API(Tensor)   THSNN_pixel_unshuffle(const Tensor tensor, const int64_t do
 // Vision -- Functions
 
 EXPORT_API(Tensor) THSNN_pad(const Tensor input, const int64_t* pad, const int pad_length, const int8_t mode, const double value);
-EXPORT_API(Tensor) THSNN_interpolate(const Tensor input, const int64_t* size, const int size_len, const double* scale_factor, const int scale_factor_len, const int8_t mode, const int8_t align_corners, const bool recompute_scale_factor, NNAnyModule* outAsAnyModule);
+EXPORT_API(Tensor) THSNN_interpolate(const Tensor input, const int64_t* size, const int size_len, const double* scale_factor, const int scale_factor_len, const int8_t mode, const int8_t align_corners, const bool recompute_scale_factor, const bool antialias, NNAnyModule* outAsAnyModule);
 EXPORT_API(Tensor) THSNN_grid_sample(const Tensor input, const Tensor grid, const int8_t mode, const int8_t padding_mode, const int8_t align_corners);
 EXPORT_API(Tensor) THSNN_affine_grid(const Tensor theta, const int64_t* size, const int size_len, const bool align_corners);
 
diff --git a/src/Native/LibTorchSharp/THSTensor.cpp b/src/Native/LibTorchSharp/THSTensor.cpp
@@ -837,6 +837,31 @@ void THSTensor_index_put_(Tensor tensor,
     CATCH(tensor->index_put_(indices, *value););
 }
 
+void THSTensor_index_put_(Tensor tensor,
+    const int64_t* indexStarts,
+    const int64_t* indexEnds,
+    const int64_t* indexSteps,
+    const Tensor* indexTensors,
+    const int indicesLength,
+    const Tensor value,
+    const bool accumulate)
+{
+    at::indexing::TensorIndex* indicesArray = (at::indexing::TensorIndex*)alloca(indicesLength * sizeof(at::indexing::TensorIndex));
+    memset(indicesArray, 0, indicesLength * sizeof(at::indexing::TensorIndex));
+    completeTensorIndices(indexStarts, indexEnds, indexSteps, indexTensors, indicesArray, indicesLength);
+    auto indices = at::ArrayRef<at::indexing::TensorIndex>(indicesArray, indicesLength);
+    if (accumulate) {
+        c10::List<std::optional<at::Tensor>> indicesList = c10::List<std::optional<at::Tensor>>();
+        for (int i = 0; i < indicesLength; i++) {
+            indicesList.push_back(c10::optional<at::Tensor>(*indexTensors[i]));
+        }
+        CATCH(tensor->index_put_(indicesList, *value, accumulate););
+    }
+    else {
+        CATCH(tensor->index_put_(indices, *value););
+    }
+}
+
 void THSTensor_index_put_scalar_(Tensor tensor,
     const int64_t* indexStarts,
     const int64_t* indexEnds,
diff --git a/src/Native/LibTorchSharp/THSTensor.h b/src/Native/LibTorchSharp/THSTensor.h
@@ -683,7 +683,8 @@ EXPORT_API(void) THSTensor_index_put_(Tensor tensor,
     const int64_t* indexSteps,
     const Tensor* indexTensors,
     const int indicesLength,
-    const Tensor value);
+    const Tensor value,
+    const bool accumulate = false);
 
 EXPORT_API(Tensor) THSTensor_index_select(Tensor tensor, int64_t dim, Tensor index);
 
diff --git a/src/TorchSharp/LinearAlgebra.cs b/src/TorchSharp/LinearAlgebra.cs
@@ -440,7 +440,7 @@ public static Tensor multi_dot(IList<Tensor> tensors)
                     throw new ArgumentException(nameof(tensors));
                 }
                 if (tensors.Count == 1) {
-                    return tensors[0];
+                    return tensors[0].alias();
                 }
 
                 using (var parray = new PinnedArray<IntPtr>()) {
diff --git a/src/TorchSharp/NN/Vision.cs b/src/TorchSharp/NN/Vision.cs
@@ -23,7 +23,8 @@ public enum InterpolationMode
             Bilinear = 2,
             Bicubic = 3,
             Trilinear = 4,
-            Area = 5
+            Area = 5,
+            NearestExact = 6
         }
 
         public enum GridSampleMode
@@ -194,7 +195,7 @@ public static Tensor affine_grid(Tensor theta, long[]? size = null, bool align_c
                 /// <param name="x">The input tensor</param>
                 /// <param name="size">Output spatial size</param>
                 /// <param name="scale_factor">Multiplier for spatial size. Has to match input size if it is a tuple.</param>
-                /// <param name="mode">The algorithm used for upsampling: 'nearest' | 'linear' | 'bilinear' | 'bicubic' | 'trilinear' | 'area'</param>
+                /// <param name="mode">The algorithm used for upsampling: 'nearest' | 'linear' | 'bilinear' | 'bicubic' | 'trilinear' | 'area' | 'nearest-exact'</param>
                 /// <param name="align_corners">Geometrically, we consider the pixels of the input and output as squares rather than points.
                 /// If set to true, the input and output tensors are aligned by the center points of their corner pixels, preserving the values at the corner pixels.
                 /// If set to false, the input and output tensors are aligned by the corner points of their corner pixels, and the interpolation uses edge value padding for out-of-boundary values, making this operation independent of input size when scale_factor is kept the same.</param>
@@ -205,14 +206,19 @@ public static Tensor affine_grid(Tensor theta, long[]? size = null, bool align_c
                 /// Otherwise, a new scale_factor will be computed based on the output and input sizes for use in the interpolation computation
                 /// (i.e. the computation will be identical to if the computed output_size were passed-in explicitly).
                 /// </param>
+                /// <param name="antialias">
+                /// Flag to apply anti-aliasing. Using anti-alias
+                /// option together with align_corners = false, interpolation result would match Pillow
+                /// result for downsampling operation. Supported modes: 'bilinear', 'bicubic'.
+                /// </param>
                 /// <returns></returns>
-                public static Tensor interpolate(Tensor x, long[]? size = null, double[]? scale_factor = null, InterpolationMode mode = InterpolationMode.Nearest, bool? align_corners = null, bool recompute_scale_factor = false)
+                public static Tensor interpolate(Tensor x, long[]? size = null, double[]? scale_factor = null, InterpolationMode mode = InterpolationMode.Nearest, bool? align_corners = null, bool recompute_scale_factor = false, bool antialias = false)
                 {
                     unsafe {
                         fixed (long* psize = size) {
                             fixed (double* pSF = scale_factor) {
                                 byte ac = (byte)((align_corners.HasValue) ? (align_corners.Value ? 1 : 2) : 0);
-                                var res = THSNN_interpolate(x.Handle, (IntPtr)psize, size is null ? 0 : size.Length, (IntPtr)pSF, scale_factor is null ? 0 : scale_factor.Length, (byte)mode, ac, recompute_scale_factor);
+                                var res = THSNN_interpolate(x.Handle, (IntPtr)psize, size is null ? 0 : size.Length, (IntPtr)pSF, scale_factor is null ? 0 : scale_factor.Length, (byte)mode, ac, recompute_scale_factor, antialias);
                                 if (res == IntPtr.Zero) { torch.CheckForErrors(); }
                                 return new Tensor(res);
                             }
diff --git a/src/TorchSharp/PInvoke/LibTorchSharp.THSNN.cs b/src/TorchSharp/PInvoke/LibTorchSharp.THSNN.cs
@@ -44,7 +44,7 @@ internal static extern IntPtr THSNN_custom_module(
 
         [DllImport("LibTorchSharp")]
         // align_corners -- 0=None, 1=true, 2=false
-        internal static extern IntPtr THSNN_interpolate(IntPtr input, IntPtr size, int size_len, IntPtr scale_factor, int scale_factor_len, byte mode, byte align_corners, [MarshalAs(UnmanagedType.U1)] bool recompute_scale_factor);
+        internal static extern IntPtr THSNN_interpolate(IntPtr input, IntPtr size, int size_len, IntPtr scale_factor, int scale_factor_len, byte mode, byte align_corners, [MarshalAs(UnmanagedType.U1)] bool recompute_scale_factor, [MarshalAs(UnmanagedType.U1)] bool antialias);
 
         [DllImport("LibTorchSharp")]
         // align_corners -- 0=None, 1=true, 2=false
diff --git a/src/TorchSharp/PInvoke/LibTorchSharp.THSTensor.cs b/src/TorchSharp/PInvoke/LibTorchSharp.THSTensor.cs
@@ -410,7 +410,7 @@ internal static extern IntPtr THSTensor_upsample_nearest3d(IntPtr input,
         internal static extern void THSTensor_index_put_scalar_(IntPtr tensor, IntPtr indexStarts, IntPtr indexEnds, IntPtr indexSteps, IntPtr indexTensors, int indicesLength, IntPtr value);
 
         [DllImport("LibTorchSharp")]
-        internal static extern void THSTensor_index_put_(IntPtr tensor, IntPtr indexStarts, IntPtr indexEnds, IntPtr indexSteps, IntPtr indexTensors, int indicesLength, IntPtr value);
+        internal static extern void THSTensor_index_put_(IntPtr tensor, IntPtr indexStarts, IntPtr indexEnds, IntPtr indexSteps, IntPtr indexTensors, int indicesLength, IntPtr value, [MarshalAs(UnmanagedType.U1)] bool accumulate);
 
         [DllImport("LibTorchSharp")]
         internal static extern IntPtr THSTensor_get1(IntPtr handle, long i1);
diff --git a/src/TorchSharp/Tensor/Tensor.cs b/src/TorchSharp/Tensor/Tensor.cs
@@ -1604,7 +1604,25 @@ public Tensor index_put_(Tensor value, params TensorIndex[] indices)
                 unsafe {
                     fixed (long* ptrKindAndStarts = arrKindAndStarts, ptrStops = arrStops, ptrSteps = arrSteps) {
                         fixed (IntPtr* ptrTensors = arrTensors) {
-                            NativeMethods.THSTensor_index_put_(Handle, (IntPtr)ptrKindAndStarts, (IntPtr)ptrStops, (IntPtr)ptrSteps, (IntPtr)ptrTensors, indices.Length, value.Handle);
+                            NativeMethods.THSTensor_index_put_(Handle, (IntPtr)ptrKindAndStarts, (IntPtr)ptrStops, (IntPtr)ptrSteps, (IntPtr)ptrTensors, indices.Length, value.Handle, false);
+                            CheckForErrors();
+                            GC.KeepAlive(indices); // don't release or finalize Tensor indices whose handles have been put into ptrTensors
+                            GC.KeepAlive(value);
+                            return this;
+                        }
+                    }
+                }
+            }
+
+            public Tensor index_put_(Tensor value, TensorIndex[] indices, bool accumulate = false)
+            {
+                EncodeIndices(indices, out var arrKindAndStarts, out var arrStops, out var arrSteps, out var arrTensors);
+                if (accumulate && arrTensors == null)
+                    throw new Exception("Invalid 'indices' parameter. Must be an array of TensorIndex objects containing tensors with indices that match the shape of the tensor to update");
+                unsafe {
+                    fixed (long* ptrKindAndStarts = arrKindAndStarts, ptrStops = arrStops, ptrSteps = arrSteps) {
+                        fixed (IntPtr* ptrTensors = arrTensors) {
+                            NativeMethods.THSTensor_index_put_(Handle, (IntPtr)ptrKindAndStarts, (IntPtr)ptrStops, (IntPtr)ptrSteps, (IntPtr)ptrTensors, indices.Length, value.Handle, accumulate);
                             CheckForErrors();
                             GC.KeepAlive(indices); // don't release or finalize Tensor indices whose handles have been put into ptrTensors
                             GC.KeepAlive(value);
@@ -1622,6 +1640,11 @@ public Tensor index_put_(Tensor value, params Tensor[] indices)
                 return index_put_(value, indices.Select(t => TensorIndex.Tensor(t)).ToArray());
             }
 
+            public Tensor index_put_(Tensor value, Tensor[] indices, bool accumulate = false)
+            {
+                return index_put_(value, indices.Select(t => TensorIndex.Tensor(t)).ToArray(), accumulate);
+            }
+
 
             /// <summary>
             /// Index into the tensor using Python-like indexing expressions and place a scalar tensor at the index.
diff --git a/src/TorchSharp/Tensor/torch.IndexingSlicingJoiningMutatingOps.cs b/src/TorchSharp/Tensor/torch.IndexingSlicingJoiningMutatingOps.cs
@@ -40,7 +40,7 @@ public static Tensor cat(IList<Tensor> tensors, long dim = 0)
             switch (tensors.Count)
             {
                 case <=0: throw new ArgumentException(nameof(tensors));
-                case 1: return tensors[0];
+                case 1: return tensors[0].alias();
             }
 
             using var parray = new PinnedArray<IntPtr>();
diff --git a/src/TorchSharp/Tensor/torch.OtherOperations.cs b/src/TorchSharp/Tensor/torch.OtherOperations.cs
@@ -63,7 +63,7 @@ public static IList<Tensor> broadcast_tensors(params Tensor[] tensors)
                 throw new ArgumentException(nameof(tensors));
             }
             if (tensors.Length == 1) {
-                return tensors;
+                return new Tensor[] { tensors[0].alias() };
             }
 
             IntPtr[] ptrArray;
diff --git a/src/TorchVision/Functional.cs b/src/TorchVision/Functional.cs
@@ -732,13 +732,23 @@ public static Tensor posterize(Tensor input, int bits)
                 /// <param name="input">An image tensor.</param>
                 /// <param name="height">The height of the resized image. Must be > 0.</param>
                 /// <param name="width">The width of the resized image. Must be > 0.</param>
+                /// <param name="interpolation">
+                /// Desired interpolation enum defined by TorchSharp.torch.InterpolationMode.
+                /// Default is InterpolationMode.Nearest; not InterpolationMode.Bilinear (incompatible to Python's torchvision v0.17 or later for historical reasons).
+                /// Only InterpolationMode.Nearest, InterpolationMode.NearestExact, InterpolationMode.Bilinear and InterpolationMode.Bicubic are supported.
+                /// </param>
                 /// <param name="maxSize">The maximum allowed for the longer edge of the resized image.</param>
+                /// <param name="antialias">
+                /// Whether to apply antialiasing.
+                /// It only affects bilinear or bicubic modes and it is ignored otherwise.
+                /// Possible values are:
+                /// * true: will apply antialiasing for bilinear or bicubic modes. Other mode aren't affected. This is probably what you want to use.
+                /// * false (default, incompatible to Python's torchvision v0.17 or later for historical reasons): will not apply antialiasing on any mode.
+                /// antialias value will be automatically set to false silently in case interpolation is not InterpolationMode.Bilinear or InterpolationMode.Bicubic.
+                /// </param>
                 /// <returns></returns>
-                public static Tensor resize(Tensor input, int height, int width, int? maxSize = null)
+                public static Tensor resize(Tensor input, int height, int width, InterpolationMode interpolation = InterpolationMode.Nearest, int? maxSize = null, bool antialias = false)
                 {
-                    // For now, we don't allow any other modes.
-                    const InterpolationMode interpolation = InterpolationMode.Nearest;
-
                     var hoffset = input.Dimensions - 2;
                     var iHeight = input.shape[hoffset];
                     var iWidth = input.shape[hoffset + 1];
@@ -765,13 +775,46 @@ public static Tensor resize(Tensor input, int height, int width, int? maxSize =
                         }
                     }
 
+                    // See https://github.com/pytorch/vision/blob/v0.21.0/torchvision/transforms/_functional_tensor.py#L455
+                    // "We manually set it to False to avoid an error downstream in interpolate()
+                    //  This behaviour is documented: the parameter is irrelevant for modes
+                    //  that are not bilinear or bicubic. We used to raise an error here, but
+                    //  now we don't ..."
+                    if (antialias && interpolation != InterpolationMode.Bilinear && interpolation != InterpolationMode.Bicubic)
+                        antialias = false;
+
                     using var img0 = SqueezeIn(input, new ScalarType[] { ScalarType.Float32, ScalarType.Float64 }, out var needCast, out var needSqueeze, out var dtype);
 
-                    using var img1 = torch.nn.functional.interpolate(img0, new long[] { h, w }, mode: interpolation, align_corners: null);
+                    using var img1 = torch.nn.functional.interpolate(img0, new long[] { h, w }, mode: interpolation, align_corners: null, antialias: antialias);
 
                     return SqueezeOut(img1, needCast, needSqueeze, dtype);
                 }
 
+                /// <summary>
+                /// Resize the input image to the given size.
+                /// </summary>
+                /// <param name="input">An image tensor.</param>
+                /// <param name="height">The height of the resized image. Must be > 0.</param>
+                /// <param name="width">The width of the resized image. Must be > 0.</param>
+                /// <param name="maxSize">The maximum allowed for the longer edge of the resized image.</param>
+                /// <returns></returns>
+                public static Tensor resize(Tensor input, int height, int width, int? maxSize = null)
+                {
+                    return resize(input, height, width, InterpolationMode.Nearest, maxSize, false);
+                }
+
+                /// <summary>
+                /// Resize the input image to the given size.
+                /// </summary>
+                /// <param name="input">An image tensor.</param>
+                /// <param name="height">The height of the resized image. Must be > 0.</param>
+                /// <param name="width">The width of the resized image. Must be > 0.</param>
+                /// <returns></returns>
+                public static Tensor resize(Tensor input, int height, int width)
+                {
+                    return resize(input, height, width, InterpolationMode.Nearest, null, false);
+                }
+
                 /// <summary>
                 /// Crop the given image and resize it to desired size.
                 /// </summary>
diff --git a/src/TorchVision/Resize.cs b/src/TorchVision/Resize.cs
diff --git a/test/TorchSharpTest/NN.cs b/test/TorchSharpTest/NN.cs
diff --git a/test/TorchSharpTest/TestTorchTensor.cs b/test/TorchSharpTest/TestTorchTensor.cs

Original file line number	Diff line number	Diff line change
`@@ -440,7 +440,7 @@ public static Tensor multi_dot(IList<Tensor> tensors)`
`440`	`440`	`throw new ArgumentException(nameof(tensors));`
`441`	`441`	`}`
`442`	`442`	`if (tensors.Count == 1) {`
`443`		`- return tensors[0];`
	`443`	`+ return tensors[0].alias();`
`444`	`444`	`}`
`445`	`445`
`446`	`446`	`using (var parray = new PinnedArray<IntPtr>()) {`