Small sample addition

migueldeicaza · migueldeicaza · commit 8559b6b1452f · 2017-02-12T23:29:20.000-05:00
diff --git a/Learn/Datasets/MNIST.cs b/Learn/Datasets/MNIST.cs
@@ -7,28 +7,87 @@
 using System.IO.Compression;
 using Mono;
 using TensorFlow;
+using System.Linq;
 
 namespace Learn.Mnist
 {
+	// Stores the per-image MNIST information we loaded from disk 
+	//
+	// We store the data in two formats, byte array (as it came in from disk), and float array
+	// where each 0..255 value has been mapped to 0.0f..1.0f
 	public struct MnistImage
 	{
 		public int Cols, Rows;
 		public byte [] Data;
+		public float [] DataFloat;
 
 		public MnistImage (int cols, int rows, byte [] data)
 		{
 			Cols = cols;
 			Rows = rows;
 			Data = data;
+			DataFloat = new float [data.Length];
+			for (int i = 0; i < data.Length; i++) {
+				DataFloat [i] = Data [i] / 255f;
+			}
 		}
 	}
 
+	// Helper class used to load and work with the Mnist data set
 	public class Mnist 
 	{
+		// 
+		// The loaded results
+		//
 		public MnistImage [] TrainImages, TestImages, ValidationImages;
-		public byte [] TrainLabels, TestLabels, ValidationLabels;
+		public byte [] 	TrainLabels, TestLabels, ValidationLabels;
 		public byte [,] OneHotTrainLabels, OneHotTestLabels, OneHotValidationLabels;
 
+		// Simple batch reader to get pieces of data from the dataset
+		public BatchReader GetBatchReader (MnistImage [] source)
+		{
+			return new BatchReader (source);
+		}
+
+		public class BatchReader
+		{
+			int start = 0;
+			MnistImage [] source;
+
+			public BatchReader (MnistImage [] source)
+			{
+				this.source = source;
+			}
+
+			public MnistImage [] Read (int batchSize)
+			{
+				var result = new MnistImage [batchSize];
+				if (start + batchSize < source.Length) {
+					Array.Copy (source, start, result, 0, batchSize);
+					start += batchSize;
+				} else {
+					var firstLength = source.Length - start;
+					Array.Copy (source, start, result, 0, firstLength);
+					Array.Copy (source, 0, result, firstLength, batchSize-firstLength);
+					start = firstLength;
+				}
+				return result;
+			}
+
+			public TFTensor ReadAsTensor (int batchSize)
+			{
+				var result = new float [batchSize, 784];
+
+				var x = Read (batchSize);
+				int p = 0;
+				for (int i = 0; i < batchSize; i++) {
+					Buffer.BlockCopy (x [i].DataFloat, 0, result, p, 784);
+					p += 784;
+				}
+				return (TFTensor)result;
+			}
+		}
+
 		int Read32 (Stream s)
 		{
 			var x = new byte [4];
@@ -98,7 +157,7 @@ T [] Pick<T> (T [] source, int first, int last)
 		/// <param name="trainDir">Directory where the training data is downlaoded to.</param>
 		/// <param name="numClasses">Number classes to use for one-hot encoding, or zero if this is not desired</param>
 		/// <param name="validationSize">Validation size.</param>
-		public void ReadDataSets (string trainDir, int numClasses = 0, int validationSize = 5000)
+		public void ReadDataSets (string trainDir, int numClasses = 10, int validationSize = 5000)
 		{
 			const string SourceUrl = "http://yann.lecun.com/exdb/mnist/";
 			const string TrainImagesName = "train-images-idx3-ubyte.gz";
@@ -122,5 +181,12 @@ public void ReadDataSets (string trainDir, int numClasses = 0, int validationSiz
 				OneHotTestLabels = OneHot (TestLabels, numClasses);
 			}
 		}
+
+		public static Mnist Load ()
+		{
+			var x = new Mnist ();
+			x.ReadDataSets ("/tmp");
+			return x;
+		}
 	}
 }
diff --git a/SampleTest/SampleTest.cs b/SampleTest/SampleTest.cs
@@ -5,6 +5,7 @@
 using System.IO;
 using System.Collections.Generic;
 using Learn.Mnist;
+using System.Linq;
 
 namespace SampleTest
 {
@@ -441,6 +442,67 @@ void BasicMatrix ()
 
 			};
 		}
+
+		int ArgMax (byte [,] array, int idx)
+		{
+			int max = -1;
+			int maxIdx = -1;
+			var l = array.GetLength (1);
+			for (int i = 0; i < l; i++)
+				if (array [idx, i] > max)
+					maxIdx = i;
+			return maxIdx;
+		}	
+
+		void NearestNeighbor ()
+		{
+			// Get the Mnist data
+
+			var mnist = Mnist.Load ();
+
+			// 5000 for training
+			const int trainCount = 5000;
+			const int testCount = 200;
+			var Xtr = mnist.GetBatchReader (mnist.TrainImages).ReadAsTensor (trainCount);
+			var Ytr = mnist.OneHotTrainLabels;
+			var Xte = mnist.GetBatchReader (mnist.TestImages).Read (testCount);
+			var Yte = mnist.OneHotTestLabels;
+
+
+
+			Console.WriteLine ("Nearest neighbor on Mnist images");
+			using (var g = new TFGraph ()) {
+				var s = new TFSession (g);
+
+				var xtr = g.Placeholder (TFDataType.Float, new TFShape (-1, 784));
+				var xte = g.Placeholder (TFDataType.Float, new TFShape (784));
+
+				// Nearest Neighbor calculation using L1 Distance
+				// Calculate L1 Distance
+				var distance = g.ReduceSum (g.Abs (g.Add (xtr, g.Neg (xte))), axis: g.Const (1));
+
+				// Prediction: Get min distance index (Nearest neighbor)
+				var pred = g.ArgMin (distance, g.Const (0));
+
+				var accuracy = 0f;
+				// Loop over the test data
+				for (int i = 0; i < testCount; i++) {
+					var runner = s.GetRunner ();
+
+					// Get nearest neighbor
+
+					var result = runner.Fetch (pred).AddInput (xtr, Xtr).AddInput (xte, Xte [i].DataFloat).Run ();
+					var nn_index = (int)(long) result [0].GetValue ();
+
+					// Get nearest neighbor class label and compare it to its true label
+					Console.WriteLine ($"Test {i}: Prediction: {nn_index} {ArgMax (Ytr, nn_index)} True class: {ArgMax (Yte, i)}");
+					if (ArgMax (Ytr, nn_index) == ArgMax (Yte, i))
+						accuracy += 1f/ Xte.Length;
+				}
+				Console.WriteLine ("Accuracy: " + accuracy);
+			}
+		}
+
 #if true
 		void LinearRegression ()
 		{
@@ -514,6 +576,7 @@ public static void Main (string [] args)
 			t.BasicVariables ();
 			t.BasicMatrix ();
 
+			t.NearestNeighbor ();
 
 		}
 	}
diff --git a/TensorFlowSharp/OperationsExtras.cs b/TensorFlowSharp/OperationsExtras.cs
@@ -69,6 +69,10 @@ public TFOutput ReduceSum (TFOutput input, TFOutput? axis = null, bool? keep_dim
 		/// <param name="value">Returns the value of the variable.</param>
 		/// <param name="operName">Operation name, optional.</param>
 		/// <returns>The returning TFOutput returns the handle to the variable.</returns>
+		/// <remarks>
+		/// Variables need to be initialized before the main execution so you will typically want to
+		/// run the session on the variable
+		/// </remarks>
 		public TFOutput Variable (TFOutput initialValue, out TFOperation init, out TFOutput value, string operName = null)
 		{
 			var scopeName = MakeName ("Variable", operName);
diff --git a/TensorFlowSharp/Tensorflow.cs b/TensorFlowSharp/Tensorflow.cs
@@ -2038,6 +2038,15 @@ public TFOutput GetOutput (TFInput operIn)
 	/// <summary>
 	/// Represents a specific output of an operation on a tensor.
 	/// </summary>
+	/// <remarks>
+	/// TFOutput objects represent one of the outputs of an operation in the graph
+	/// (TFGraph).  Outputs have a data type, and eventually a shape that you can 
+	/// retrieve by calling the <see cref="M:TensorFlow.TFGraph.GetShape"/> method.
+	/// 
+	/// These can be passed as an input argument to a function for adding operations 
+	/// to a graph, or to the TFSession's Run and GetRunner method as values to be
+	/// fetched.
+	/// </remarks>
 	[StructLayout (LayoutKind.Sequential)]
 	public struct TFOutput
 	{
