Merge pull request #12 from interesaaat/LibTorchSharpFirstTest

Lib torch sharp first test

Author: interesaaat

Examples/MNIST.cs

@@ -45,7 +45,7 @@ private class Model : NN.Module
             private NN.Module fc1 = Linear(320, 50);
             private NN.Module fc2 = Linear(50, 10);
 
-            public Model() : base(IntPtr.Zero)
+            public Model() : base()
             {
                 RegisterModule(conv1);
                 RegisterModule(conv2);
@@ -68,7 +68,7 @@ public override ITorchTensor<float> Forward<T>(params ITorchTensor<T>[] tensors)
 
                 using (var l31 = fc1.Forward(x))
                 using (var l32 = Relu(l31))
-                using (var l33 = Dropout(l32, 0.5, _isTraining))
+                using (var l33 = Dropout(l32, 0.5, IsTraining()))
 
                 using (var l41 = fc2.Forward(l33))
 

Test/TorchSharp/TorchSharp.cs

@@ -1,5 +1,6 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
+using System.Linq;
 using TorchSharp.JIT;
 using TorchSharp.Tensor;
 
@@ -302,6 +303,88 @@ public void TestSetGetBiasInLinear()
             Assert.AreEqual(lin.Bias.NumberOfElements, bias.NumberOfElements);
         }
 
+        [TestMethod]
+        public void TestWeightAndBiasShapeInLinear()
+        {
+            var lin = NN.Module.Linear(1000, 100, true);
+
+            Assert.AreEqual(lin.Weight.Shape.Length, 2);
+            Assert.AreEqual(lin.Weight.Shape[0], 100);
+            Assert.AreEqual(lin.Weight.Shape[1], 1000);
+            Assert.AreEqual(lin.Bias.Shape.Length, 1);
+            Assert.AreEqual(lin.Bias.Shape[0], 100);
+        }
+
+        [TestMethod]
+        public void TestWeightAndBiasParametersInLinear()
+        {
+            var lin = NN.Module.Linear(1000, 100, true);
+            var names = lin.NamedParameters().Select(p => p.name);
+            Assert.IsTrue(names.Contains("weight"));
+            Assert.IsTrue(names.Contains("bias"));
+        }
+
+        [TestMethod]
+        public void TestWeightParameterInLinear()
+        {
+            var lin = NN.Module.Linear(1000, 100, false);
+            var names = lin.NamedParameters().Select(p => p.name);
+            Assert.IsTrue(names.Contains("weight"));
+            Assert.IsFalse(names.Contains("bias"));
+        }
+
+        [TestMethod]
+        public void TestWeightAndBiasShapeInLinear3()
+        {
+            var lin = NN.Module.Linear(1000, 100, true);
+            var weight = lin.GetParameter("weight");
+            var bias = lin.GetParameter("bias");
+            Assert.AreEqual(weight.Shape.Length, 2);
+            Assert.AreEqual(weight.Shape[0], 100);
+            Assert.AreEqual(weight.Shape[1], 1000);
+            Assert.AreEqual(bias.Shape.Length, 1);
+            Assert.AreEqual(bias.Shape[0], 100);
+        }
+
+        [TestMethod]
+        public void TestLinearWithBias()
+        {
+            var lin = NN.Module.Linear(1000, 100, true);
+            var bias = lin.Bias;
+            var weight = lin.Weight.T();
+            var input = FloatTensor.RandomN(new long[] { 1, 1000 });
+            var forward = lin.Forward(input);
+            var matmul = input.MatMul(weight).Add(bias);
+
+            Assert.AreEqual(forward.Shape.Length, matmul.Shape.Length);
+            Assert.AreEqual(forward.Shape[0], matmul.Shape[0]);
+            Assert.AreEqual(forward.Shape[1], matmul.Shape[1]);
+
+            for (int i = 0; i < 100; i++)
+            {
+                Assert.AreEqual(forward.Data[i], matmul.Data[i]);
+            }
+        }
+
+        [TestMethod]
+        public void TestLinearNoBias()
+        {
+            var lin = NN.Module.Linear(1000, 100, false);
+            var weight = lin.Weight.Transpose(0, 1);
+            var input = FloatTensor.RandomN(new long[] { 1, 1000 });
+            var forward = lin.Forward(input);
+            var matmul = input.MatMul(weight);
+
+            Assert.AreEqual(forward.Shape.Length, matmul.Shape.Length);
+            Assert.AreEqual(forward.Shape[0], matmul.Shape[0]);
+            Assert.AreEqual(forward.Shape[1], matmul.Shape[1]);
+
+            for (int i = 0; i < 100; i++)
+            {
+                Assert.AreEqual(forward.Data[i], matmul.Data[i]);
+            }
+        }
+
         [TestMethod]
         public void CreateRelu()
         {
@@ -317,6 +400,7 @@ public void CreateSequence()
             var lin2 = NN.Module.Linear(100, 10);
             var seq = NN.Module.Sequential(lin1, NN.Module.Relu(), lin2);
             var modules = seq.GetModules();
+            Assert.AreEqual(modules.Count(), 3);
         }
 
         [TestMethod]
@@ -501,6 +585,48 @@ public void TestMul()
             }
         }
 
+        [TestMethod]
+        public void TestCustomModule()
+        {
+            var module = new TestModule("test", FloatTensor.RandomN(new long[] { 2, 2 }), true);
+            var name = module.GetName();
+            Assert.IsNotNull(name);
+            Assert.IsTrue(module.HasParameter("test"));
+        }
+
+        [TestMethod]
+        public void TestCustomModuleWithInPlaceModification()
+        {
+            var param = FloatTensor.RandomN(new long[] { 1000, 100 });
+            var module = new TestModule("test", param, true);
+
+            Assert.AreEqual(module.GetParameter("test").Shape[0], 1000);
+            Assert.AreEqual(module.GetParameter("test").Shape[1], 100);
+
+            using (var grad = new AutoGradMode(false))
+            {
+                param.TransposeInPlace(0, 1);
+            }
+            Assert.AreEqual(module.GetParameter("test").Shape[0], 100);
+            Assert.AreEqual(module.GetParameter("test").Shape[1], 1000);
+            Assert.AreEqual(param.Shape[0], 100);
+            Assert.AreEqual(param.Shape[1], 1000);
+        }
+
+        private class TestModule : NN.Module
+        {
+            public TestModule(string name, ITorchTensor<float> tensor, bool withGrad) 
+                : base((name, tensor, withGrad))
+            {
+            }
+
+            public override ITorchTensor<float> Forward<T>(params ITorchTensor<T>[] tensors)
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+
         /// <summary>
         /// Fully connected Relu net with one hidden layer trained using gradient descent.
         /// Taken from <see cref="https://pytorch.org/tutorials/beginner/examples_nn/two_layer_net_nn.html"/>.

TorchSharp/NN/Dropout.cs

@@ -10,6 +10,7 @@ namespace TorchSharp.NN
     public class Dropout : FunctionalModule<Dropout>
     {
         private double _probability;
+        private bool _isTraining;
 
         internal Dropout(double probability, bool isTraining) : base()
         {

TorchSharp/NN/FunctionalModule.cs

@@ -21,6 +21,11 @@ public override void ZeroGrad()
         {
         }
 
+        public override IEnumerable<(string name, ITorchTensor<float> parameter)> NamedParameters()
+        {
+            return new List<(string, ITorchTensor<float>)>();
+        }
+
         public override IEnumerable<ITorchTensor<float>> Parameters()
         {
             return new List<ITorchTensor<float>>();

TorchSharp/NN/Linear.cs

@@ -11,11 +11,11 @@ public Linear(IntPtr handle) : base(handle)
         }
 
         [DllImport("libTorchSharp")]
-        extern static IntPtr THSNN_linearModule(int input, int output, bool hasBias);
+        extern static IntPtr THSNN_linearModule(long input_size, long output_size, bool with_bias);
 
-        public Linear(int input, int output, bool hasBias = false) : base()
+        public Linear(long inputSize, long outputSize, bool hasBias = false) : base()
         {
-            handle = new HType(THSNN_linearModule(input, output, hasBias), true);
+            handle = new HType(THSNN_linearModule(inputSize, outputSize, hasBias), true);
         }
 
         [DllImport("libTorchSharp")]