Added Poisson NLL loss and related methods to make it work.

Author: interesaaat

Examples/MNIST.cs

@@ -125,7 +125,7 @@ private static void Test(
             foreach (var (data, target) in dataLoader)
             {
                 using (var output = model.Forward(data))
-                using (var loss = NN.LossFunction.NLL(output, target, NN.Reduction.Sum))
+                using (var loss = NN.LossFunction.NLL(output, target, reduction: NN.Reduction.Sum))
                 {
                     testLoss += loss.Item;
 

Test/TorchSharp/TorchSharp.cs

@@ -327,6 +327,19 @@ public void EvalLossSequence()
             Assert.IsNotNull(result);
         }
 
+        [TestMethod]
+        public void TestPoissonNLLLoss()
+        {
+            using (FloatTensor input = FloatTensor.From(new float[] { 0.5f, 1.5f, 2.5f }))
+            using (FloatTensor target = FloatTensor.From(new float[] { 1f, 2f, 3f }))
+            {
+                var componentWiseLoss = ((FloatTensor)input.Exp()) - target * input;
+                Assert.IsTrue(componentWiseLoss.Equal(NN.LossFunction.PoissonNLL(input, target, reduction: NN.Reduction.None)));
+                Assert.IsTrue(componentWiseLoss.Sum().Equal(NN.LossFunction.PoissonNLL(input, target, reduction: NN.Reduction.Sum)));
+                Assert.IsTrue(componentWiseLoss.Mean().Equal(NN.LossFunction.PoissonNLL(input, target, reduction: NN.Reduction.Mean)));
+            }
+        }
+
         [TestMethod]
         public void TestZeroGrad()
         {
@@ -563,13 +576,13 @@ public void TestMNISTLoader()
         {
             using (var train = Data.Loader.MNIST(@"E:/Source/Repos/LibTorchSharp/MNIST", 32))
             {
-                var size = train.Size();
-
                 Assert.IsNotNull(train);
-                Assert.IsNotNull(size);
 
+                var size = train.Size();
                 int i = 0;
 
+                Assert.IsNotNull(size);
+
                 foreach (var (data, target) in train)
                 {
                     i++;

TorchSharp/NN/LossFunction.cs

@@ -32,6 +32,14 @@ public static ITorchTensor<float> NLL<T, U>(ITorchTensor<T> src, ITorchTensor<U>
         {
             return new FloatTensor(THSNN_lossNLL(src.Handle, target.Handle, weigths?.Handle ?? IntPtr.Zero, (long)reduction));
         }
+
+        [DllImport("libTorchSharp")]
+        extern static IntPtr THSNN_lossPoissonNLL(IntPtr srct, IntPtr trgt, bool logInput, bool full, double eps, long reduction);
+
+        public static ITorchTensor<float> PoissonNLL<T, U>(ITorchTensor<T> src, ITorchTensor<U> target, bool logInput = true, bool full = false, double eps = 1e-8, Reduction reduction = Reduction.Mean)
+        {
+            return new FloatTensor(THSNN_lossPoissonNLL(src.Handle, target.Handle, logInput, full, eps, (long)reduction));
+        }
     }
 
     public enum Reduction : long

TorchSharp/Tensor/ITorchTensor.cs

@@ -40,6 +40,8 @@ public interface ITorchTensor<T> : IDisposable
 
         ITorchTensor<U> Eq<U>(ITorchTensor<U> target);
 
+        bool Equal<U>(ITorchTensor<U> target);
+
         ITorchTensor<T> Add(ITorchTensor<T> target, int scalar);
 
         void AddInPlace(ITorchTensor<T> target, int scalar);
@@ -50,10 +52,16 @@ public interface ITorchTensor<T> : IDisposable
 
         ITorchTensor<T> Baddbmm(ITorchTensor<T> batch2, ITorchTensor<T> mat, float beta, float alpha);
 
+        ITorchTensor<T> Bmm(ITorchTensor<T> batch2);
+
         ITorchTensor<T> Exp();
 
         ITorchTensor<T> MatMul(ITorchTensor<T> target);
 
+        ITorchTensor<T> Mean();
+
+        ITorchTensor<T> Mm(ITorchTensor<T> target);
+
         ITorchTensor<T> Mul(ITorchTensor<T> target);
 
         ITorchTensor<T> Mul(T scalar);