Merge pull request #11 from interesaaat/LibTorchSharpFirstTest

interesaaat · web-flow · commit c7a23e55e4f0 · 2019-04-16T22:20:43.000-07:00
* Renamed Item into DataItem (for some reason it was compiling otherw…
diff --git a/Examples/MNIST.cs b/Examples/MNIST.cs
@@ -101,7 +101,7 @@ private static void Train(
 
                     if (batchId % _logInterval == 0)
                     {
-                        Console.WriteLine($"\rTrain: epoch {epoch} [{batchId * batchSize} / {size}] Loss: {loss.Item}");
+                        Console.WriteLine($"\rTrain: epoch {epoch} [{batchId * batchSize} / {size}] Loss: {loss.DataItem}");
                     }
 
                     batchId++;
@@ -127,11 +127,11 @@ private static void Test(
                 using (var output = model.Forward(data))
                 using (var loss = NN.LossFunction.NLL(output, target, reduction: NN.Reduction.Sum))
                 {
-                    testLoss += loss.Item;
+                    testLoss += loss.DataItem;
 
                     var pred = output.Argmax(1);
 
-                    correct += pred.Eq(target).Sum().Item; // Memory leak here
+                    correct += pred.Eq(target).Sum().DataItem; // Memory leak here
 
                     data.Dispose();
                     target.Dispose();
diff --git a/Test/TorchSharp/TorchSharp.cs b/Test/TorchSharp/TorchSharp.cs
@@ -124,7 +124,7 @@ public void CreateFloatTensorFromScalar()
 
             using (var tensor = FloatTensor.From(scalar))
             {
-                Assert.AreEqual(tensor.Item, 333);
+                Assert.AreEqual(tensor.DataItem, 333);
             }
         }
 
@@ -135,7 +135,7 @@ public void CreateFloatTensorFromScalar2()
 
             using (var tensor = scalar.ToTorchTensor())
             {
-                Assert.AreEqual(tensor.Item, 333);
+                Assert.AreEqual(tensor.DataItem, 333);
             }
         }
 
@@ -144,7 +144,7 @@ public void InitUniform()
         {
             using (var tensor = FloatTensor.Zeros(new long[] { 2, 2 }))
             {
-                tensor.InitUniform();
+                NN.Init.Uniform(tensor);
 
                 Assert.IsNotNull(tensor);
             } 
@@ -281,6 +281,27 @@ public void CreateLinear()
             var modules = lin.GetName();
         }
 
+        [TestMethod]
+        public void TestGetBiasInLinear()
+        {
+            var lin = NN.Module.Linear(1000, 100);
+            Assert.IsFalse(lin.WithBias);
+            Assert.ThrowsException<ArgumentNullException>(() => lin.Bias);
+        }
+
+        [TestMethod]
+        public void TestSetGetBiasInLinear()
+        {
+            var lin = NN.Module.Linear(1000, 100, true);
+            Assert.IsNotNull(lin.Bias);
+
+            var bias = FloatTensor.Ones(new long[] { 1000 });
+
+            lin.Bias = bias;
+
+            Assert.AreEqual(lin.Bias.NumberOfElements, bias.NumberOfElements);
+        }
+
         [TestMethod]
         public void CreateRelu()
         {
@@ -323,7 +344,7 @@ public void EvalLossSequence()
             var eval = seq.Forward(x);
             var loss = NN.LossFunction.MSE(eval, y, NN.Reduction.Sum);
 
-            var result = loss.Item;
+            var result = loss.DataItem;
             Assert.IsNotNull(result);
         }
 
@@ -501,7 +522,7 @@ public void TestTraining()
             {
                 var eval = seq.Forward(x);
                 var loss = NN.LossFunction.MSE(eval, y, NN.Reduction.Sum);
-                var lossVal = loss.Item;
+                var lossVal = loss.DataItem;
 
                 Assert.IsTrue(lossVal < prevLoss);
                 prevLoss = lossVal;
@@ -558,7 +579,7 @@ public void TestTrainingAdam()
             {
                 var eval = seq.Forward(x);
                 var loss = NN.LossFunction.MSE(eval, y, NN.Reduction.Sum);
-                var lossVal = loss.Item;
+                var lossVal = loss.DataItem;
 
                 Assert.IsTrue(lossVal < prevLoss);
                 prevLoss = lossVal;
diff --git a/TorchSharp/NN/Linear.cs b/TorchSharp/NN/Linear.cs
@@ -6,10 +6,61 @@ namespace TorchSharp.NN
 {
     public class Linear : ProvidedModule
     {
-        internal Linear(IntPtr handle) : base(handle)
+        public Linear(IntPtr handle) : base(handle)
         {
         }
 
+        [DllImport("libTorchSharp")]
+        extern static IntPtr THSNN_linearModule(int input, int output, bool hasBias);
+
+        public Linear(int input, int output, bool hasBias = false) : base()
+        {
+            handle = new HType(THSNN_linearModule(input, output, hasBias), true);
+        }
+
+        [DllImport("libTorchSharp")]
+        extern static bool THSNN_linear_with_bias(Module.HType module);
+
+        public bool WithBias
+        {
+            get { return THSNN_linear_with_bias(handle); }
+        }
+
+        [DllImport("libTorchSharp")]
+        extern static IntPtr THSNN_linear_get_bias(Module.HType module);
+
+        [DllImport("libTorchSharp")]
+        extern static void THSNN_linear_set_bias(Module.HType module, IntPtr tensor);
+
+        public ITorchTensor<float> Bias
+        {
+            get
+            {
+                var bias = THSNN_linear_get_bias(handle);
+                if (bias == IntPtr.Zero)
+                {
+                    throw new ArgumentNullException("Linear module without bias term.");
+                }
+                return new FloatTensor(bias);
+            }
+            set { THSNN_linear_set_bias(handle, value.Handle); }
+        }
+
+        [DllImport("libTorchSharp")]
+        extern static IntPtr THSNN_linear_get_weight(Module.HType module);
+
+        [DllImport("libTorchSharp")]
+        extern static void THSNN_linear_set_weight(Module.HType module, IntPtr tensor);
+
+        public ITorchTensor<float> Weight
+        {
+            get
+            {
+                return new FloatTensor(THSNN_linear_get_weight(handle));
+            }
+            set { THSNN_linear_set_weight(handle, value.Handle); }
+        }
+
         [DllImport("libTorchSharp")]
         extern static IntPtr THSNN_linearModuleApply(Module.HType module, IntPtr tensor);
 
diff --git a/TorchSharp/NN/Module.cs b/TorchSharp/NN/Module.cs
@@ -11,7 +11,7 @@ public partial class Module
         /// <summary>
         ///    Class wrapping PyTorch's module object reference.
         /// </summary>
-        internal sealed class HType : SafeHandle
+        protected sealed class HType : SafeHandle
         {
             public HType(IntPtr preexistingHandle, bool ownsHandle) : base(IntPtr.Zero, ownsHandle)
             {
@@ -43,7 +43,7 @@ protected override void Dispose(bool disposing)
             }
         }
 
-        internal HType handle;
+        protected HType handle;
 
         protected bool _isTraining = true;
 
@@ -96,7 +96,7 @@ static public Sequential Sequential(params Module[] modules)
         [DllImport("libTorchSharp")]
         extern static IntPtr THSNN_linearModule(int input, int output, bool hasBias);
 
-        static public Module Linear(int input, int output, bool hasBias = false)
+        static public Linear Linear(int input, int output, bool hasBias = false)
         {
             return new Linear(THSNN_linearModule(input, output, hasBias));
         }

Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ private static void Train(`
`101`	`101`
`102`	`102`	`if (batchId % _logInterval == 0)`
`103`	`103`	`{`
`104`		`- Console.WriteLine($"\rTrain: epoch {epoch} [{batchId * batchSize} / {size}] Loss: {loss.Item}");`
	`104`	`+ Console.WriteLine($"\rTrain: epoch {epoch} [{batchId * batchSize} / {size}] Loss: {loss.DataItem}");`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`batchId++;`
`@@ -127,11 +127,11 @@ private static void Test(`
`127`	`127`	`using (var output = model.Forward(data))`
`128`	`128`	`using (var loss = NN.LossFunction.NLL(output, target, reduction: NN.Reduction.Sum))`
`129`	`129`	`{`
`130`		`- testLoss += loss.Item;`
	`130`	`+ testLoss += loss.DataItem;`
`131`	`131`
`132`	`132`	`var pred = output.Argmax(1);`
`133`	`133`
`134`		`- correct += pred.Eq(target).Sum().Item; // Memory leak here`
	`134`	`+ correct += pred.Eq(target).Sum().DataItem; // Memory leak here`
`135`	`135`
`136`	`136`	`data.Dispose();`
`137`	`137`	`target.Dispose();`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ public void CreateFloatTensorFromScalar()`
`124`	`124`
`125`	`125`	`using (var tensor = FloatTensor.From(scalar))`
`126`	`126`	`{`
`127`		`- Assert.AreEqual(tensor.Item, 333);`
	`127`	`+ Assert.AreEqual(tensor.DataItem, 333);`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`
`@@ -135,7 +135,7 @@ public void CreateFloatTensorFromScalar2()`
`135`	`135`
`136`	`136`	`using (var tensor = scalar.ToTorchTensor())`
`137`	`137`	`{`
`138`		`- Assert.AreEqual(tensor.Item, 333);`
	`138`	`+ Assert.AreEqual(tensor.DataItem, 333);`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`
`@@ -144,7 +144,7 @@ public void InitUniform()`
`144`	`144`	`{`
`145`	`145`	`using (var tensor = FloatTensor.Zeros(new long[] { 2, 2 }))`
`146`	`146`	`{`
`147`		`- tensor.InitUniform();`
	`147`	`+ NN.Init.Uniform(tensor);`
`148`	`148`
`149`	`149`	`Assert.IsNotNull(tensor);`
`150`	`150`	`}`
`@@ -281,6 +281,27 @@ public void CreateLinear()`
`281`	`281`	`var modules = lin.GetName();`
`282`	`282`	`}`
`283`	`283`
	`284`	`+ [TestMethod]`
	`285`	`+ public void TestGetBiasInLinear()`
	`286`	`+ {`
	`287`	`+ var lin = NN.Module.Linear(1000, 100);`
	`288`	`+ Assert.IsFalse(lin.WithBias);`
	`289`	`+ Assert.ThrowsException<ArgumentNullException>(() => lin.Bias);`
	`290`	`+ }`
	`291`	`+`
	`292`	`+ [TestMethod]`
	`293`	`+ public void TestSetGetBiasInLinear()`
	`294`	`+ {`
	`295`	`+ var lin = NN.Module.Linear(1000, 100, true);`
	`296`	`+ Assert.IsNotNull(lin.Bias);`
	`297`	`+`
	`298`	`+ var bias = FloatTensor.Ones(new long[] { 1000 });`
	`299`	`+`
	`300`	`+ lin.Bias = bias;`
	`301`	`+`
	`302`	`+ Assert.AreEqual(lin.Bias.NumberOfElements, bias.NumberOfElements);`
	`303`	`+ }`
	`304`	`+`
`284`	`305`	`[TestMethod]`
`285`	`306`	`public void CreateRelu()`
`286`	`307`	`{`
`@@ -323,7 +344,7 @@ public void EvalLossSequence()`
`323`	`344`	`var eval = seq.Forward(x);`
`324`	`345`	`var loss = NN.LossFunction.MSE(eval, y, NN.Reduction.Sum);`
`325`	`346`
`326`		`- var result = loss.Item;`
	`347`	`+ var result = loss.DataItem;`
`327`	`348`	`Assert.IsNotNull(result);`
`328`	`349`	`}`
`329`	`350`
`@@ -501,7 +522,7 @@ public void TestTraining()`
`501`	`522`	`{`
`502`	`523`	`var eval = seq.Forward(x);`
`503`	`524`	`var loss = NN.LossFunction.MSE(eval, y, NN.Reduction.Sum);`
`504`		`- var lossVal = loss.Item;`
	`525`	`+ var lossVal = loss.DataItem;`
`505`	`526`
`506`	`527`	`Assert.IsTrue(lossVal < prevLoss);`
`507`	`528`	`prevLoss = lossVal;`
`@@ -558,7 +579,7 @@ public void TestTrainingAdam()`
`558`	`579`	`{`
`559`	`580`	`var eval = seq.Forward(x);`
`560`	`581`	`var loss = NN.LossFunction.MSE(eval, y, NN.Reduction.Sum);`
`561`		`- var lossVal = loss.Item;`
	`582`	`+ var lossVal = loss.DataItem;`
`562`	`583`
`563`	`584`	`Assert.IsTrue(lossVal < prevLoss);`
`564`	`585`	`prevLoss = lossVal;`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ public partial class Module`
`11`	`11`	`/// <summary>`
`12`	`12`	`/// Class wrapping PyTorch's module object reference.`
`13`	`13`	`/// </summary>`
`14`		`- internal sealed class HType : SafeHandle`
	`14`	`+ protected sealed class HType : SafeHandle`
`15`	`15`	`{`
`16`	`16`	`public HType(IntPtr preexistingHandle, bool ownsHandle) : base(IntPtr.Zero, ownsHandle)`
`17`	`17`	`{`
`@@ -43,7 +43,7 @@ protected override void Dispose(bool disposing)`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`46`		`- internal HType handle;`
	`46`	`+ protected HType handle;`
`47`	`47`
`48`	`48`	`protected bool _isTraining = true;`
`49`	`49`
`@@ -96,7 +96,7 @@ static public Sequential Sequential(params Module[] modules)`
`96`	`96`	`[DllImport("libTorchSharp")]`
`97`	`97`	`extern static IntPtr THSNN_linearModule(int input, int output, bool hasBias);`
`98`	`98`
`99`		`- static public Module Linear(int input, int output, bool hasBias = false)`
	`99`	`+ static public Linear Linear(int input, int output, bool hasBias = false)`
`100`	`100`	`{`
`101`	`101`	`return new Linear(THSNN_linearModule(input, output, hasBias));`
`102`	`102`	`}`