Add the ability to create a loss function as a delegate. This allows to match the python api.

Author: interesaaat

Test/TorchSharp/TorchSharp.cs

@@ -733,6 +733,38 @@ public void TestTrainingAdam()
             }
         }
 
+        [TestMethod]
+        public void TestTrainingAdam2()
+        {
+            var lin1 = NN.Module.Linear(1000, 100);
+            var lin2 = NN.Module.Linear(100, 10);
+            var seq = NN.Module.Sequential(lin1, NN.Module.Relu(), lin2);
+
+            var x = FloatTensor.RandomN(new long[] { 64, 1000 }, device: "cpu:0");
+            var y = FloatTensor.RandomN(new long[] { 64, 10 }, device: "cpu:0");
+
+            double learning_rate = 0.00004f;
+            float prevLoss = float.MaxValue;
+            var optimizer = NN.Optimizer.Adam(seq.Parameters(), learning_rate);
+            var loss = NN.LossFunction.MSE(NN.Reduction.Sum);
+
+            for (int i = 0; i < 10; i++)
+            {
+                var eval = seq.Forward(x);
+                var output = loss(eval, y);
+                var lossVal = output.DataItem<float>();
+
+                Assert.IsTrue(lossVal < prevLoss);
+                prevLoss = lossVal;
+
+                optimizer.ZeroGrad();
+
+                output.Backward();
+
+                optimizer.Step();
+            }
+        }
+
         [TestMethod]
         public void TestMNISTLoader()
         {

TorchSharp/NN/LossFunction.cs

@@ -9,14 +9,21 @@ namespace TorchSharp.NN
     /// </summary>
     public class LossFunction
     {
+        public delegate TorchTensor Loss(TorchTensor source, TorchTensor target);
+
         [DllImport("libTorchSharp")]
         extern static IntPtr THSNN_lossBCE(IntPtr srct, IntPtr trgt, IntPtr wgt, long reduction);
 
-        public static TorchTensor BCE<T, U>(TorchTensor src, TorchTensor target, TorchTensor? weigths = null, Reduction reduction = Reduction.Mean)
+        public static TorchTensor BCE(TorchTensor src, TorchTensor target, TorchTensor? weigths = null, Reduction reduction = Reduction.Mean)
         {
             return new TorchTensor(THSNN_lossBCE(src.Handle, target.Handle, weigths?.Handle ?? IntPtr.Zero, (long)reduction));
         }
 
+        public static Loss BCE(TorchTensor? weigths = null, Reduction reduction = Reduction.Mean)
+        {
+            return (TorchTensor src, TorchTensor target) => new TorchTensor(THSNN_lossBCE(src.Handle, target.Handle, weigths?.Handle ?? IntPtr.Zero, (long)reduction));
+        }
+
         [DllImport("libTorchSharp")]
         extern static IntPtr THSNN_lossMSE(IntPtr srct, IntPtr trgt, long reduction);
 
@@ -25,6 +32,11 @@ public static TorchTensor MSE(TorchTensor src, TorchTensor target, Reduction red
             return new TorchTensor(THSNN_lossMSE(src.Handle, target.Handle, (long)reduction));
         }
 
+        public static Loss MSE(Reduction reduction = Reduction.Mean)
+        {
+            return (TorchTensor src, TorchTensor target) => new TorchTensor(THSNN_lossMSE(src.Handle, target.Handle, (long)reduction));
+        }
+
         [DllImport("libTorchSharp")]
         extern static IntPtr THSNN_lossNLL(IntPtr srct, IntPtr trgt, IntPtr wgt, long reduction);
 
@@ -33,13 +45,23 @@ public static TorchTensor NLL(TorchTensor src, TorchTensor target, TorchTensor?
             return new TorchTensor(THSNN_lossNLL(src.Handle, target.Handle, weigths?.Handle ?? IntPtr.Zero, (long)reduction));
         }
 
+        public static Loss NLL(TorchTensor? weigths = null, Reduction reduction = Reduction.Mean)
+        {
+            return (TorchTensor src, TorchTensor target) => new TorchTensor(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, float eps, long reduction);
 
         public static TorchTensor PoissonNLL(TorchTensor src, TorchTensor target, bool logInput = true, bool full = false, float eps = 1e-8f, Reduction reduction = Reduction.Mean)
         {
             return new TorchTensor(THSNN_lossPoissonNLL(src.Handle, target.Handle, logInput, full, 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));
+        }
     }
 
     public enum Reduction : long