pairwise distance

Author: yueyinqiu

src/Native/LibTorchSharp/THSNN.cpp

@@ -538,22 +538,9 @@ Tensor THSNN_cosine_similarity(const Tensor input1, const Tensor input2, int64_t
     CATCH_TENSOR(torch::nn::functional::cosine_similarity(*input1, *input2, torch::nn::functional::CosineSimilarityFuncOptions().dim(dim).eps(eps)));
 }
 
-NNModule THSNN_PairwiseDistance_ctor(double p, double eps, bool keep_dim, NNAnyModule* outAsAnyModule)
+Tensor THSNN_pairwise_distance(const Tensor input1, const Tensor input2, double p, double eps, bool keepdim)
 {
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::PairwiseDistanceOptions()
-        .p(p)
-        .eps(eps)
-        .keepdim(keep_dim);
-
-        res = create_module<torch::nn::PairwiseDistanceImpl>(opts, outAsAnyModule);
-    );
-
-}
-
-Tensor  THSNN_PairwiseDistance_forward(const NNModule module, const Tensor input1, const Tensor input2)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::PairwiseDistance>()->forward(*input1, *input2));
+    CATCH_TENSOR(torch::nn::functional::pairwise_distance(*input1, *input2, torch::nn::functional::PairwiseDistanceFuncOptions().p(p).eps(eps).keepdim(keepdim)));
 }
 
 NNModule THSNN_RNN_ctor(const int64_t input_size, const int64_t hidden_size, const int64_t num_layers, const int64_t nonlinearity, const bool bias, const bool batchFirst, const double dropout, const bool bidirectional, NNAnyModule* outAsAnyModule)

src/Native/LibTorchSharp/THSNN.h

@@ -267,8 +267,7 @@ EXPORT_API(Tensor) THSNN_one_hot(const Tensor self, const int64_t num_classes);
 
 EXPORT_API(Tensor)   THSNN_cosine_similarity(const Tensor input1, const Tensor input2, int64_t dim, double eps);
 
-EXPORT_API(NNModule) THSNN_PairwiseDistance_ctor(double p, double eps, bool keep_dim, NNAnyModule* outAsAnyModule);
-EXPORT_API(Tensor)   THSNN_PairwiseDistance_forward(const NNModule module, const Tensor input1, const Tensor input2);
+EXPORT_API(Tensor) THSNN_pairwise_distance(const Tensor input1, const Tensor input2, double p, double eps, bool keepdim);
 
 EXPORT_API(Tensor) THSNN_scaled_dot_product_attention(const Tensor query, const Tensor key, const Tensor value, const Tensor attention_mask, double p, bool casual);
 

src/TorchSharp/NN/PairwiseDistance.cs

@@ -12,36 +12,36 @@ namespace Modules
         /// <summary>
         /// Computes the pairwise distance between vectors using the p-norm.
         /// </summary>
-        public sealed class PairwiseDistance : torch.nn.Module<Tensor, Tensor, Tensor>
+        public sealed class PairwiseDistance : ParamLessModule<Tensor, Tensor, Tensor>
         {
-            internal PairwiseDistance(IntPtr handle, IntPtr boxedHandle) : base(handle, boxedHandle)
+            public double norm { get; set; }
+            public double eps { get; set; }
+            public bool keepdim { get; set; }
+
+            internal PairwiseDistance(
+                double p = 2.0, double eps = 1e-6, bool keepdim = false)
+                : base(nameof(PairwiseDistance))
             {
+                this.norm = p;
+                this.eps = eps;
+                this.keepdim = keepdim;
             }
 
             public override Tensor forward(Tensor input1, Tensor input2)
             {
-                var res = THSNN_PairwiseDistance_forward(handle, input1.Handle, input2.Handle);
-                if (res == IntPtr.Zero) { torch.CheckForErrors(); }
-                return new Tensor(res);
+                return nn.functional.pairwise_distance(
+                    input1, input2, norm, eps, keepdim);
             }
-
-            // Rather than spending cycles only to discover that this module has neither
-            // parameters nor buffers, just shortcut the move completely.
-            protected internal override nn.Module _to(Device device, ScalarType dtype) => this;
-            protected internal override nn.Module _to(DeviceType deviceType, int deviceIndex = -1) => this;
-            protected internal override nn.Module _to(ScalarType dtype) => this;
         }
     }
 
     public static partial class torch
     {
         public static partial class nn
         {
-            public static PairwiseDistance PairwiseDistance(double p = 2.0, double eps = 1e-6, bool keep_dim = false)
+            public static PairwiseDistance PairwiseDistance(double p = 2.0, double eps = 1e-6, bool keepdim = false)
             {
-                var handle = THSNN_PairwiseDistance_ctor(p, eps, keep_dim, out var boxedHandle);
-                if (handle == IntPtr.Zero) { torch.CheckForErrors(); }
-                return new PairwiseDistance(handle, boxedHandle);
+                return new PairwiseDistance(p, eps, keepdim);
             }
 
             public static partial class functional
@@ -53,13 +53,13 @@ public static partial class functional
                 /// <param name="input2">(N, D) or (D), same shape as the Input1</param>
                 /// <param name="p">The norm degree. Default: 2</param>
                 /// <param name="eps">Small value to avoid division by zero.</param>
-                /// <param name="keep_dim">Determines whether or not to keep the vector dimension.</param>
+                /// <param name="keepdim">Determines whether or not to keep the vector dimension.</param>
                 /// <returns></returns>
-                public static Tensor pairwise_distance(Tensor input1, Tensor input2, double p = 2.0, double eps = 1e-6, bool keep_dim = false)
+                public static Tensor pairwise_distance(Tensor input1, Tensor input2, double p = 2.0, double eps = 1e-6, bool keepdim = false)
                 {
-                    using (var f = nn.PairwiseDistance(p, eps, keep_dim)) {
-                        return f.call(input1, input2);
-                    }
+                    var res = THSNN_pairwise_distance(input1.Handle, input2.Handle, p, eps, keepdim);
+                    if (res == IntPtr.Zero) { torch.CheckForErrors(); }
+                    return new Tensor(res);
                 }
             }
         }

src/TorchSharp/PInvoke/LibTorchSharp.THSNN.cs

@@ -402,10 +402,7 @@ internal static extern IntPtr THSNN_custom_module(
         internal static extern IntPtr THSNN_one_hot(IntPtr self, long num_classes);
 
         [DllImport("LibTorchSharp")]
-        internal static extern IntPtr THSNN_PairwiseDistance_forward(torch.nn.Module.HType module, IntPtr input1, IntPtr input2);
-
-        [DllImport("LibTorchSharp")]
-        internal static extern IntPtr THSNN_PairwiseDistance_ctor(double p, double eps, [MarshalAs(UnmanagedType.U1)] bool keep_dim, out IntPtr pBoxedModule);
+        internal static extern IntPtr THSNN_pairwise_distance(IntPtr input1, IntPtr input2, double p, double eps, [MarshalAs(UnmanagedType.U1)] bool keepdim);
 
         [DllImport("LibTorchSharp")]
         internal static extern IntPtr THSNN_pixel_unshuffle(IntPtr tensor, long downscale_factor);

test/TorchSharpTest/NN.cs

@@ -5567,7 +5567,7 @@ public void TestPairwiseDistance()
                 using (Tensor input1 = torch.rand(new long[] { 5, 12 }, device: device))
                 using (Tensor input2 = torch.randint(12, new long[] { 5, 12 }, torch.int64, device: device))
 
-                using (var module = PairwiseDistance(keep_dim: true)) {
+                using (var module = PairwiseDistance(keepdim: true)) {
                     var output = module.call(input1, input2);
                     Assert.Equal(device.type, output.device_type);
                     Assert.Equal(input1.shape[0], output.shape[0]);