Merge pull request #23 from interesaaat/LibTorchSharpFirstTest

Add basic error handling logic

Author: interesaaat

Test/TorchSharp/TorchSharp.cs

@@ -1,6 +1,8 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
+using System.Diagnostics;
 using System.Linq;
+using System.Runtime.InteropServices;
 using TorchSharp.JIT;
 using TorchSharp.NN;
 using TorchSharp.Tensor;
@@ -164,7 +166,7 @@ public void TestSparse()
                 Assert.IsTrue(sparse.IsSparse);
                 Assert.IsFalse(i.IsSparse);
                 Assert.IsFalse(v.IsSparse);
-                CollectionAssert.AreEqual(sparse.Indeces.Data<long>().ToArray(), new long[] { 0, 1, 1, 2, 0, 2 });
+                CollectionAssert.AreEqual(sparse.Indices.Data<long>().ToArray(), new long[] { 0, 1, 1, 2, 0, 2 });
                 CollectionAssert.AreEqual(sparse.Values.Data<float>().ToArray(), new float[] { 3, 4, 5 });
             }
         }
@@ -461,13 +463,24 @@ public void TestPoissonNLLLoss2()
             }
         }
 
+        # if DEBUG
+        [TestMethod]
+        public void TestErrorHandling()
+        {
+            using (TorchTensor input = FloatTensor.From(new float[] { 0.5f, 1.5f}))
+            using (TorchTensor target = FloatTensor.From(new float[] { 1f, 2f, 3f }))
+            {
+                Assert.ThrowsException<ExternalException>(() => NN.LossFunction.PoissonNLL()(input, target));
+            }
+        }
+        #endif
+
         [TestMethod]
         public void TestZeroGrad()
         {
             var lin1 = NN.Module.Linear(1000, 100);
             var lin2 = NN.Module.Linear(100, 10);
             var seq = NN.Module.Sequential(lin1, NN.Module.Relu(), lin2);
-
             seq.ZeroGrad();
         }
 

TorchSharp/NN/LossFunction.cs

@@ -36,11 +36,16 @@ public static Loss NLL(TorchTensor? weigths = null, Reduction reduction = Reduct
         }
 
         [DllImport("libTorchSharp")]
-        extern static IntPtr THSNN_lossPoissonNLL(IntPtr srct, IntPtr trgt, bool logInput, bool full, float eps, long reduction);
+        extern static IntPtr THSNN_loss_poisson_nll(IntPtr srct, IntPtr trgt, bool logInput, bool full, float eps, long reduction);
 
         public static Loss PoissonNLL(bool logInput = true, bool full = false, float eps = 1e-8f, Reduction reduction = Reduction.Mean)
         {
-            return (TorchTensor src, TorchTensor target) => new TorchTensor(THSNN_lossPoissonNLL(src.Handle, target.Handle, logInput, full, eps, (long)reduction));
+            return (TorchTensor src, TorchTensor target) =>
+            {
+                var tptr = THSNN_loss_poisson_nll(src.Handle, target.Handle, logInput, full, eps, (long)reduction);
+                Torch.AssertNoErrors();
+                return new TorchTensor(tptr);
+            };
         }
     }
 

TorchSharp/Tensor/TorchTensorTyped.generated.cs

@@ -876,7 +876,9 @@ static public TorchTensor Random(long[] size, string device = "cpu", bool requir
             {
                 fixed (long* psizes = size)
                 {
-                    return new TorchTensor (THSTensor_rand ((IntPtr)psizes, size.Length, (sbyte)ATenScalarMapping.Float, device, requiresGrad));
+                    var tptr = THSTensor_rand((IntPtr)psizes, size.Length, (sbyte)ATenScalarMapping.Float, device, requiresGrad);
+                    Torch.AssertNoErrors();
+                    return new TorchTensor (tptr);
                 }
             }
         }

TorchSharp/Torch.cs

@@ -1,7 +1,11 @@
-using System.Runtime.InteropServices;
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
 
 namespace TorchSharp
 {
+    using Debug = System.Diagnostics.Debug;
+
     public static class Torch
     {
         [DllImport("libTorchSharp")]
@@ -19,5 +23,19 @@ public static bool IsCudaAvailable()
         {
             return THSTorch_isCudaAvailable();
         }
+
+        [DllImport("libTorchSharp")]
+        extern static IntPtr THSTorch_get_and_reset_last_err();
+
+        [Conditional("DEBUG")]
+        internal static void AssertNoErrors()
+        {
+            var error = THSTorch_get_and_reset_last_err();
+
+            if (error != IntPtr.Zero)
+            {
+                throw new ExternalException(Marshal.PtrToStringAnsi(error));
+            }
+        }
     }
 }