[DigitDetection] port ViewController

Author: Rustam Zaitov

ios10/DigitDetection/DigitDetection/DrawView.cs

@@ -9,7 +9,7 @@
 namespace DigitDetection
 {
 	// 2 points can give a line and this class is just for that purpose, it keeps a record of a lin
-	class Line
+	public class Line
 	{
 		public CGPoint Start { get; }
 		public CGPoint End { get; }
@@ -49,7 +49,7 @@ UIColor Color {
 		}
 
 		// we will keep touches made by user in view in these as a record so we can draw them
-		readonly List<Line> lines = new List<Line> ();
+		public List<Line> Lines { get; } = new List<Line> ();
 		CGPoint lastPoint;
 
 		public DrawView (IntPtr handle)
@@ -66,7 +66,7 @@ public override void TouchesMoved (NSSet touches, UIEvent evt)
 		{
 			var newPoint = ((UITouch)touches.First ()).LocationInView (this);
 			// keep all lines drawn by user as touch in record so we can draw them in view
-			lines.Add (new Line (lastPoint, newPoint));
+			Lines.Add (new Line (lastPoint, newPoint));
 
 			lastPoint = newPoint;
 
@@ -82,7 +82,7 @@ public override void Draw (CGRect rect)
 
 			drawPath.LineCapStyle = CGLineCap.Round;
 
-			foreach (var line in lines) {
+			foreach (var line in Lines) {
 				drawPath.MoveTo (line.Start);
 				drawPath.AddLineTo (line.End);
 			}
@@ -93,7 +93,7 @@ public override void Draw (CGRect rect)
 			Color.SetStroke ();
 		}
 
-		public CGContext GetViewContext ()
+		public CGBitmapContext GetViewContext ()
 		{
 			// our network takes in only grayscale images as input
 			var colorSpace = CGColorSpace.CreateDeviceGray ();

ios10/DigitDetection/DigitDetection/MNISTData.cs

@@ -5,8 +5,8 @@ namespace DigitDetection
 {
 	public class MNISTData : IDisposable
 	{
-		byte [] labels;
-		byte [] images;
+		public byte [] Labels { get; private set; }
+		public byte [] images { get; private set; } // tODO: rename
 
 		nuint sizeBias;
 		nuint sizeWeights;

ios10/DigitDetection/DigitDetection/NeuralNetworkLayers/MnistDeepConvNeuralNetwork.cs

@@ -92,7 +92,7 @@ public MnistDeepConvNeuralNetwork (IMTLCommandQueue commandQueueIn)
 		/// <param name="inputImage">Image coming in on which the network will run</param>
 		/// <param name="imageNum">If the test set is being used we will get a value between 0 and 9999 for which of the 10,000 images is being evaluated</param>
 		/// <param name="correctLabel">The correct label for the inputImage while testing</param>
-		public override uint Forward (MPSImage inputImage = null, int imageNum = 9999, uint correctLabel = 10)
+		public override uint Forward (MPSImage inputImage = null, int imageNum = 9999, int correctLabel = 10)
 		{
 			uint label = 99;
 

ios10/DigitDetection/DigitDetection/NeuralNetworkLayers/MnistFullLayerNeuralNetwork.cs

@@ -15,11 +15,11 @@ public class MnistFullLayerNeuralNetwork
 		// TODO: convert protected fields to props
 
 		// MPSImageDescriptors for different layers outputs to be put in
-		protected readonly MPSImageDescriptor sid = MPSImageDescriptor.GetImageDescriptor (MPSImageFeatureChannelFormat.Unorm8, 28, 28, 1);
+		public readonly MPSImageDescriptor sid = MPSImageDescriptor.GetImageDescriptor (MPSImageFeatureChannelFormat.Unorm8, 28, 28, 1);
 		protected readonly MPSImageDescriptor did = MPSImageDescriptor.GetImageDescriptor (MPSImageFeatureChannelFormat.Float16, 1, 1, 10);
 
 		// MPSImages and layers declared
-		protected MPSImage srcImage;
+		public MPSImage srcImage { get; protected set; } // TODO: rename
 		protected MPSImage dstImage;
 		MPSCnnFullyConnected layer;
 		protected MPSCnnSoftMax softmax;
@@ -54,7 +54,7 @@ public MnistFullLayerNeuralNetwork (IMTLCommandQueue commandQueueIn)
 		/// <param name="inputImage">Image coming in on which the network will run</param>
 		/// <param name="imageNum">If the test set is being used we will get a value between 0 and 9999 for which of the 10,000 images is being evaluated</param>
 		/// <param name="correctLabel">The correct label for the inputImage while testing</param>
-		public virtual uint Forward (MPSImage inputImage = null, int imageNum = 9999, uint correctLabel = 10)
+		public virtual uint Forward (MPSImage inputImage = null, int imageNum = 9999, int correctLabel = 10)
 		{
 			uint label = 99;
 

ios10/DigitDetection/DigitDetection/ViewController.cs

@@ -1,14 +1,169 @@
-using Foundation;
-using System;
-using UIKit;
-
-namespace DigitDetection
+using System;
+using System.Runtime.InteropServices;
+
+using UIKit;
+using Foundation;
+using Metal;
+using MetalPerformanceShaders;
+
+namespace DigitDetection
 {
 	public partial class ViewController : UIViewController
 	{
-		public ViewController (IntPtr handle)
+		// some properties used to control the app and store appropriate values
+		// we will start with the simple 1 layer
+		bool deep;
+
+		IMTLCommandQueue commandQueue;
+		IMTLDevice device;
+
+		// Networks we have
+		MnistFullLayerNeuralNetwork neuralNetwork;
+		MnistDeepConvNeuralNetwork neuralNetworkDeep;
+		MnistFullLayerNeuralNetwork runningNet;
+
+		// loading MNIST Test Set here
+		readonly MNISTData Mnistdata = new MNISTData ();
+
+		// MNIST dataset image parameters
+		nuint mnistInputWidth = 28;
+		int mnistInputHeight = 28;
+		int mnistInputNumPixels = 784;
+
+		public ViewController (IntPtr handle)
 			: base (handle)
 		{
 		}
-	}
+
+		public override void ViewDidLoad ()
+		{
+			base.ViewDidLoad ();
+
+			// Load default device.
+			device = MTLDevice.SystemDefault;
+
+			// Make sure the current device supports MetalPerformanceShaders.
+			if (!MPSKernel.Supports (device)) {
+				Console.WriteLine ("Metal Performance Shaders not Supported on current Device");
+				return;
+			}
+
+			// Create new command queue.
+			commandQueue = device.CreateCommandQueue ();
+
+			// initialize the networks we shall use to detect digits
+			neuralNetwork = new MnistFullLayerNeuralNetwork (commandQueue);
+			neuralNetworkDeep = new MnistDeepConvNeuralNetwork (commandQueue);
+
+			runningNet = neuralNetwork;
+		}
+
+		partial void TappedDeepButton (UIButton sender)
+		{
+			// switch network to be used between the deep and the single layered
+			if (deep) {
+				sender.SetTitle ("Use Deep Net", UIControlState.Normal);
+				runningNet = neuralNetwork;
+			} else {
+				sender.SetTitle ("Use Single Layer", UIControlState.Normal);
+				runningNet = neuralNetworkDeep;
+			}
+
+			deep = !deep;
+		}
+
+		partial void TappedClear (UIButton sender)
+		{
+			// clear the digitview
+			DigitView.Lines.Clear ();
+			DigitView.SetNeedsDisplay ();
+			PredictionLabel.Hidden = true;
+		}
+
+		partial void TappedTestSet (UIButton sender)
+		{
+			// placeholder to count number of correct detections on the test set
+			var correctDetections = 0;
+			var total = 10000f;
+			AccuracyLabel.Hidden = false;
+
+			Atomics.Reset ();
+
+			// validate NeuralNetwork was initialized properly
+			if (runningNet == null)
+				throw new InvalidProgramException ();
+
+			for (int i = 0; i < total; i++) {
+				Inference (i, Mnistdata.Labels.Length);
+
+				if (i % 100 == 0) {
+					AccuracyLabel.Text = $"{i / 100}% Done";
+					// this command helps update the UI in the loop regularly
+					NSRunLoop.Current.RunUntil (NSRunLoopMode.Default, NSDate.DistantPast);
+				}
+			}
+			// display accuracy of the network on the MNIST test set
+			correctDetections = Atomics.GetCount ();
+
+			AccuracyLabel.Hidden = false;
+			AccuracyLabel.Text = $"Accuracy = {(correctDetections * 100) / total}%";
+		}
+
+		partial void TappedDetectDigit (UIButton sender)
+		{
+			// get the digitView context so we can get the pixel values from it to intput to network
+			var context = DigitView.GetViewContext ();
+
+			// validate NeuralNetwork was initialized properly
+			if (runningNet == null)
+				throw new InvalidProgramException ();
+
+			// putting input into MTLTexture in the MPSImage
+			var region = new MTLRegion (new MTLOrigin (0, 0, 0), new MTLSize ((nint)mnistInputWidth, mnistInputHeight, 1));
+			runningNet.srcImage.Texture.ReplaceRegion (region,
+													   level: 0,
+													   slice: 0,
+													   pixelBytes: context.Data,
+													   bytesPerRow: mnistInputWidth,
+													   bytesPerImage: 0);
+			// run the network forward pass
+			var label = runningNet.Forward ();
+
+			// show the prediction
+			PredictionLabel.Text = $"{label}";
+			PredictionLabel.Hidden = false;
+		}
+
+		/// <summary>
+		/// This function runs the inference network on the test set
+		/// </summary>
+		/// <param name="imageNum">If the test set is being used we will get a value between 0 and 9999 for which of the 10,000 images is being evaluated</param>
+		/// <param name="correctLabel">The correct label for the inputImage while testing</param>
+		void Inference (int imageNum, int correctLabel)
+		{
+			// get the correct image pixels from the test set
+
+			int startIndex = imageNum * mnistInputNumPixels;
+			var mnist_input_image = new byte [784];
+			Array.Copy (Mnistdata.images, startIndex, mnist_input_image, 0, mnist_input_image.Length);
+			var imageHandle = GCHandle.Alloc (mnist_input_image, GCHandleType.Pinned);
+			var imagePtr = imageHandle.AddrOfPinnedObject ();
+
+
+			// create a source image for the network to forward
+			var inputImage = new MPSImage (device, runningNet.sid);
+
+			// put image in source texture (input layer)
+			inputImage.Texture.ReplaceRegion (region: new MTLRegion (new MTLOrigin (0, 0, 0), new MTLSize ((nint)mnistInputWidth, mnistInputHeight, 1)),
+											  level: 0,
+											  slice: 0,
+											  pixelBytes: imagePtr,
+											  bytesPerRow: mnistInputWidth,
+											  bytesPerImage: 0);
+			imageHandle.Free (); // TODO: request overload with managed array
+
+			// run the network forward pass
+			runningNet.Forward (inputImage, imageNum, correctLabel);
+		}
+	}
 }