public static async Task Main()
{
// Create the network
INeuralNetwork network = NetworkManager.NewSequential(TensorInfo.Image <Alpha8>(28, 28),
NetworkLayers.Convolutional((5, 5), 20, ActivationType.Identity),
NetworkLayers.Pooling(ActivationType.LeakyReLU),
NetworkLayers.FullyConnected(100, ActivationType.LeCunTanh),
NetworkLayers.Softmax(10));
// Prepare the dataset
ITrainingDataset trainingData = await Mnist.GetTrainingDatasetAsync(100); // Batches of 100 samples
ITestDataset testData = await Mnist.GetTestDatasetAsync(p => Printf($"Epoch {p.Iteration}, cost: {p.Result.Cost}, accuracy: {p.Result.Accuracy}"));
if (trainingData == null || testData == null)
{
Printf("Error downloading the datasets");
Console.ReadKey();
return;
}
// Train the network
TrainingSessionResult result = await NetworkManager.TrainNetworkAsync(network,
trainingData,
TrainingAlgorithms.AdaDelta(),
60, 0.5f,
TrackBatchProgress,
testDataset : testData);
Printf($"Stop reason: {result.StopReason}, elapsed time: {result.TrainingTime}");
Console.ReadKey();
}
public static void MNISTConvolutional(string dataFilesPath)
{
Console.Write("Loading training data...");
var trainingData = Mnist.Load(dataFilesPath + "train-labels.idx1-ubyte", dataFilesPath + "train-images.idx3-ubyte");
var testData = Mnist.Load(dataFilesPath + "t10k-labels.idx1-ubyte", dataFilesPath + "t10k-images.idx3-ubyte");
Console.WriteLine($"done - found {trainingData.Count} training samples and {testData.Count} test samples");
var convolutionDescriptor = new ConvolutionDescriptor(0.1f)
{
Stride = 1,
Padding = 1,
FilterDepth = 4,
FilterHeight = 3,
FilterWidth = 3,
WeightInitialisation = WeightInitialisationType.Xavier,
WeightUpdate = WeightUpdateType.RMSprop,
Activation = ActivationType.LeakyRelu
};
const int BATCH_SIZE = 128, NUM_EPOCHS = 2;
const float TRAINING_RATE = 0.03f;
var errorMetric = ErrorMetricType.OneHot.Create();
var layerTemplate = new LayerDescriptor(0.1f)
{
WeightUpdate = WeightUpdateType.RMSprop,
Activation = ActivationType.LeakyRelu
};
using (var lap = Provider.CreateLinearAlgebra(false)) {
var trainingSamples = trainingData.Shuffle(0).Take(1000).Select(d => d.AsVolume).Select(d => Tuple.Create(d.AsTensor(lap), d.ExpectedOutput)).ToList();
var testSamples = testData.Shuffle(0).Take(100).Select(d => d.AsVolume).Select(d => Tuple.Create(d.AsTensor(lap), d.ExpectedOutput)).ToList();
// create a network with two convolutional layers
// the first takes the input image of depth 1
// and the second expects of tensor with depth equal to the output of the first layer
var layer = new IConvolutionalLayer[] {
lap.NN.CreateConvolutionalLayer(convolutionDescriptor, 1, 28),
lap.NN.CreateConvolutionalLayer(convolutionDescriptor, convolutionDescriptor.FilterDepth, 28)
};
var trainingDataProvider = lap.NN.CreateConvolutionalTrainingProvider(convolutionDescriptor, trainingSamples, layer, true);
var testDataProvider = lap.NN.CreateConvolutionalTrainingProvider(convolutionDescriptor, testSamples, layer, false);
using (var trainer = lap.NN.CreateBatchTrainer(layerTemplate, trainingDataProvider.InputSize, 128, trainingDataProvider.OutputSize)) {
var trainingContext = lap.NN.CreateTrainingContext(errorMetric, TRAINING_RATE, BATCH_SIZE);
trainingContext.EpochComplete += c => {
var output = trainer.Execute(testDataProvider.TrainingDataProvider);
var testError = output.Select(d => errorMetric.Compute(d.Output, d.ExpectedOutput)).Average();
trainingContext.WriteScore(testError, errorMetric.DisplayAsPercentage);
};
trainingContext.ScheduleTrainingRateChange(50, TRAINING_RATE / 3f);
trainingContext.ScheduleTrainingRateChange(100, TRAINING_RATE / 9f);
trainingContext.ScheduleTrainingRateChange(150, TRAINING_RATE / 27f);
trainer.Train(trainingDataProvider.TrainingDataProvider, NUM_EPOCHS, trainingContext);
}
foreach (var item in layer)
{
item.Dispose();
}
}
}
/// <summary>
/// Trains a neural net on the MNIST database (digit recognition)
/// The data files can be downloaded from http://yann.lecun.com/exdb/mnist/
/// </summary>
/// <param name="dataFilesPath">The path to a directory with the four extracted data files</param>
public static void MNIST(string dataFilesPath, string outputModelPath)
{
// neural network hyper parameters
const int HIDDEN_SIZE = 1024, BATCH_SIZE = 128, NUM_EPOCHS = 40;
const float TRAINING_RATE = 0.03f;
var errorMetric = ErrorMetricType.OneHot.Create();
var layerTemplate = new LayerDescriptor(0f)
{
WeightUpdate = WeightUpdateType.RMSprop,
Activation = ActivationType.LeakyRelu
};
Console.Write("Loading training data...");
var trainingData = Mnist.Load(dataFilesPath + "train-labels.idx1-ubyte", dataFilesPath + "train-images.idx3-ubyte");
var testData = Mnist.Load(dataFilesPath + "t10k-labels.idx1-ubyte", dataFilesPath + "t10k-images.idx3-ubyte");
Console.WriteLine("done");
Console.WriteLine("Starting training...");
using (var lap = GPUProvider.CreateLinearAlgebra()) {
var trainingSet = lap.NN.CreateTrainingDataProvider(trainingData.Select(d => d.Sample).ToList());
var testSet = lap.NN.CreateTrainingDataProvider(testData.Select(d => d.Sample).ToList());
using (var trainer = lap.NN.CreateBatchTrainer(layerTemplate, Mnist.INPUT_SIZE, HIDDEN_SIZE, Mnist.OUTPUT_SIZE)) {
var trainingManager = lap.NN.CreateFeedForwardManager(trainer, outputModelPath, testSet);
var trainingContext = lap.NN.CreateTrainingContext(errorMetric, TRAINING_RATE, BATCH_SIZE);
trainingContext.ScheduleTrainingRateChange(NUM_EPOCHS / 2, TRAINING_RATE / 3);
trainingManager.Train(trainingSet, NUM_EPOCHS, trainingContext);
}
}
}
public void DevicePlacementTest()
{
using (var graph = new TFGraph())
using (var session = new TFSession(graph))
{
var X = graph.Placeholder(TFDataType.Float, new TFShape(-1, 784));
var Y = graph.Placeholder(TFDataType.Float, new TFShape(-1, 10));
int numGPUs = 4;
var Xs = graph.Split(graph.Const(0), X, numGPUs);
var Ys = graph.Split(graph.Const(0), Y, numGPUs);
var products = new TFOutput[numGPUs];
for (int i = 0; i < numGPUs; i++)
{
using (var device = graph.WithDevice("/device:GPU:" + i))
{
var W = graph.Constant(0.1f, new TFShape(784, 500), TFDataType.Float);
var b = graph.Constant(0.1f, new TFShape(500), TFDataType.Float);
products[i] = graph.Add(graph.MatMul(Xs[i], W), b);
}
}
var stacked = graph.Concat(graph.Const(0), products);
Mnist mnist = new Mnist();
mnist.ReadDataSets("/tmp");
int batchSize = 1000;
for (int i = 0; i < 100; i++)
{
var reader = mnist.GetTrainReader();
(var trainX, var trainY) = reader.NextBatch(batchSize);
var outputTensors = session.Run(new TFOutput[] { X }, new TFTensor[] { new TFTensor(trainX) }, new TFOutput[] { stacked });
Assert.Equal(1000, outputTensors[0].Shape[0]);
Assert.Equal(500, outputTensors[0].Shape[1]);
}
}
}
private Point startPoint; // coordinate of the start point of the line to be draw
// Initialize the window, setup all things
private void Form1_Load(object sender, EventArgs e)
{
model = new Mnist();
writeArea.Image = new Bitmap(writeArea.Width, writeArea.Height);
graphics = Graphics.FromImage(writeArea.Image);
graphics.Clear(Color.White);
}
public void ImageCut()
{
Mnist model = new Mnist();
List <int> x_coord = new List <int>();
List <int> y_coord = new List <int>();
int index = 0;
const int MnistImageSize = 28, corr = 25;
CutY(ref x_coord);
if (x_coord.Count > 1)
{
int x_start = x_coord[0];
int x_end = x_coord[x_coord.Count - 1];
int x_index = 0;
while (x_start != x_end)
{
int Region_Width = x_start;
while (x_coord.Contains(Region_Width) && x_index < x_coord.Count)
{
Region_Width++;
x_index++;
}
int x = x_start;
int y = 0;
int width = Region_Width - x_start;
int height = img.Height;
CutX(img.Clone(new Rectangle(x, y, width, height), img.PixelFormat), ref y_coord);
if (y_coord.Count > 1 && y_coord.Count != img.Height)
{
int y1 = y_coord[0];
int y2 = y_coord[y_coord.Count - 1];
if (y1 != 1)
{
y = y1 - 1;
}
height = y2 - y1 + 1;
}
Bitmap temp = img.Clone(new Rectangle(x - corr, y - corr, width + 2 * corr, height + 2 * corr),
img.PixelFormat);
TextInfer(temp, model, MnistImageSize);
temp.Dispose();
if (x_index < x_coord.Count)
{
x_start = x_coord[x_index];
}
else
{
x_start = x_end;
}
}
}
}
static void Main(string[] args)
{
// 加载手写数字资源
var mnist = Mnist.Load();
// 训练次数和测试次数
var trainCount = 5000;
var testCount = 200;
// 获取训练图片、训练图片标签、测试图片、测试图片标签
float[,] trainingImages, trainingLabels, testImages, testLabels;
mnist.GetTrainReader().NextBatch(trainCount, out trainingImages, out trainingLabels);
mnist.GetTestReader().NextBatch(testCount, out testImages, out testLabels);
// 创建图
var g = new TFGraph();
// 训练图片占位符和训练标签占位符
var trainingInput = g.Placeholder(TFDataType.Float, new TFShape(-1, 784)); // 不定数量的像素为24*24的图片
var xte = g.Placeholder(TFDataType.Float, new TFShape(784));
// 创建计算误差和预测的图
var distance = g.ReduceSum(g.Abs(g.Add(trainingInput, g.Neg(xte))), axis: g.Const(1));
var pred = g.ArgMin(distance, g.Const(0));
// 创建会话
var sess = new TFSession(g);
// 精度
var accuracy = 0.0f;
// 进行迭代训练，并且每次都输出预测值
for (int i = 0; i < testCount; i++)
{
var runner = sess.GetRunner();
// 计算并且获取误差和预测值
var result = runner.
Fetch(pred).
Fetch(distance).
AddInput(trainingInput, trainingImages).
AddInput(xte, Extract(testImages, i)).Run();
var r = result[0].GetValue();
var tr = result[1].GetValue();
var nn_index = (int)(long)result[0].GetValue();
Console.WriteLine($"训练次数 {i}： 预测： { ArgMax(trainingLabels, nn_index) } 真实值： { ArgMax(testLabels, i)} (nn_index= { nn_index })");
if (ArgMax(trainingLabels, nn_index) == ArgMax(testLabels, i))
{
accuracy += 1f / testImages.Length;
}
}
// 精确度
Console.WriteLine("精度：" + accuracy);
}
private const int MnistImageSize = 28; //Mnist模型所需的输入图片大小
private void Form1_Load(object sender, EventArgs e)
{
//当窗口加载时，绘制一个白色方框
model = new Mnist();
digitImage = new Bitmap(picturebox1.Width, picturebox1.Height);
Graphics g = Graphics.FromImage(digitImage);
g.Clear(Color.White);
picturebox1.Image = digitImage;
}
// This sample has a bug, I suspect the data loaded is incorrect, because the returned
// values in distance is wrong, and so is the prediction computed from it.
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);
TFOutput xtr = g.Placeholder(TFDataType.Float, new TFShape(-1, 784));
TFOutput xte = g.Placeholder(TFDataType.Float, new TFShape(784));
// Nearest Neighbor calculation using L1 Distance
// Calculate L1 Distance
TFOutput distance = g.ReduceSum(g.Abs(g.Add(xtr, g.Neg(xte))), axis: g.Const(1));
// Prediction: Get min distance index (Nearest neighbor)
TFOutput 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).Fetch(distance).AddInput(xtr, Xtr).AddInput(xte, Xte [i].DataFloat).Run();
var r = result [0].GetValue();
var tr = result [1].GetValue();
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: {ArgMax (Ytr, nn_index)} True class: {ArgMax (Yte, i)} (nn_index={nn_index})");
if (ArgMax(Ytr, nn_index) == ArgMax(Yte, i))
{
accuracy += 1f / Xte.Length;
}
}
Console.WriteLine("Accuracy: " + accuracy);
}
}
/// <summary>
/// 窗体的加载事件，在窗体显示时只执行一次。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Form1_Load(object sender, EventArgs e)
{
// 新建模型
model = new Mnist();
// 初始化手写区为其大小的位图，以便进行操作。
writeArea.Image = new Bitmap(writeArea.Width, writeArea.Height);
// 获取手写区位图的绘图类，以便以后重置图像。
graphics = Graphics.FromImage(writeArea.Image);
// 清除图像及文字。
clear();
}
public static async Task Main()
{
// Create the network
INeuralNetwork network = NetworkManager.NewSequential(TensorInfo.Image <Alpha8>(28, 28),
CuDnnNetworkLayers.Convolutional((5, 5), 20, ActivationType.Identity),
CuDnnNetworkLayers.Pooling(ActivationType.LeakyReLU),
CuDnnNetworkLayers.Convolutional((3, 3), 40, ActivationType.Identity),
CuDnnNetworkLayers.Pooling(ActivationType.LeakyReLU),
CuDnnNetworkLayers.FullyConnected(125, ActivationType.LeCunTanh),
CuDnnNetworkLayers.Softmax(10));
// Prepare the dataset
ITrainingDataset trainingData = await Mnist.GetTrainingDatasetAsync(400); // Batches of 400 samples
ITestDataset testData = await Mnist.GetTestDatasetAsync(p => Printf($"Epoch {p.Iteration}, cost: {p.Result.Cost}, accuracy: {p.Result.Accuracy}"));
if (trainingData == null || testData == null)
{
Printf("Error downloading the datasets");
Console.ReadKey();
return;
}
// Setup and network training
CancellationTokenSource cts = new CancellationTokenSource();
Console.CancelKeyPress += (s, e) => cts.Cancel();
TrainingSessionResult result = await NetworkManager.TrainNetworkAsync(network,
trainingData,
TrainingAlgorithms.AdaDelta(),
20, 0.5f,
TrackBatchProgress,
testDataset : testData, token : cts.Token);
// Save the training reports
string
timestamp = DateTime.Now.ToString("yy-MM-dd-hh-mm-ss"),
path = Path.GetDirectoryName(Path.GetFullPath(Assembly.GetExecutingAssembly().Location)),
dir = Path.Combine(path ?? throw new InvalidOperationException("The dll path can't be null"), "TrainingResults", timestamp);
Directory.CreateDirectory(dir);
File.WriteAllText(Path.Combine(dir, $"{timestamp}_cost.py"), result.TestReports.AsPythonMatplotlibChart(TrainingReportType.Cost));
File.WriteAllText(Path.Combine(dir, $"{timestamp}_accuracy.py"), result.TestReports.AsPythonMatplotlibChart(TrainingReportType.Accuracy));
network.Save(new FileInfo(Path.Combine(dir, $"{timestamp}{NetworkLoader.NetworkFileExtension}")));
File.WriteAllText(Path.Combine(dir, $"{timestamp}.json"), network.SerializeMetadataAsJson());
File.WriteAllText(Path.Combine(dir, $"{timestamp}_report.json"), result.SerializeAsJson());
Printf($"Stop reason: {result.StopReason}, elapsed time: {result.TrainingTime}");
Console.ReadKey();
}
static void MNISTConvolutional(string dataFilesPath)
{
using (var lap = BrightWireGpuProvider.CreateLinearAlgebra()) {
var graph = new GraphFactory(lap);
Console.Write("Loading training data...");
var trainingData = _BuildTensors(graph, null, Mnist.Load(dataFilesPath + "train-labels.idx1-ubyte", dataFilesPath + "train-images.idx3-ubyte"));
var testData = _BuildTensors(graph, trainingData, Mnist.Load(dataFilesPath + "t10k-labels.idx1-ubyte", dataFilesPath + "t10k-images.idx3-ubyte"));
Console.WriteLine($"done - {trainingData.RowCount} training images and {testData.RowCount} test images loaded");
var errorMetric = graph.ErrorMetric.OneHotEncoding;
var propertySet = graph.CurrentPropertySet
.Use(graph.GradientDescent.RmsProp)
.Use(graph.WeightInitialisation.Xavier)
;
// create the network
const int HIDDEN_LAYER_SIZE = 1024;
const float LEARNING_RATE = 0.05f;
var engine = graph.CreateTrainingEngine(trainingData, LEARNING_RATE, 32);
engine.LearningContext.ScheduleLearningRate(15, LEARNING_RATE / 3);
graph.Connect(engine)
.AddConvolutional(8, 2, 5, 5, 1, false)
.Add(graph.ReluActivation())
.AddDropOut(0.5f)
.AddMaxPooling(2, 2, 2)
.AddConvolutional(16, 2, 5, 5, 1)
.Add(graph.ReluActivation())
.AddMaxPooling(2, 2, 2)
.Transpose()
.AddFeedForward(HIDDEN_LAYER_SIZE)
.Add(graph.ReluActivation())
.AddDropOut(0.5f)
.AddFeedForward(trainingData.OutputSize)
.Add(graph.SoftMaxActivation())
.AddBackpropagation(errorMetric)
;
engine.Train(20, testData, errorMetric);
// export the graph and verify that the error is the same
var networkGraph = engine.Graph;
var executionEngine = graph.CreateEngine(networkGraph);
var output = executionEngine.Execute(testData);
Console.WriteLine(output.Average(o => o.CalculateError(errorMetric)));
}
}
public static DataSet CreateDataset(GraphFactory graph, string folderPath)
{
var trainLabelPath = Path.Combine(folderPath, "train-labels.idx1-ubyte");
var trainDataPath = Path.Combine(folderPath, "train-images.idx3-ubyte");
var testLabelPath = Path.Combine(folderPath, "t10k-labels.idx1-ubyte");
var testDataPath = Path.Combine(folderPath, "t10k-images.idx3-ubyte");
var trainingData = BuildTensors(graph, null, Mnist.Load(trainLabelPath, trainDataPath));
var testData = BuildTensors(graph, trainingData, Mnist.Load(testLabelPath, testDataPath));
return(new DataSet()
{
TestData = testData,
TrainData = trainingData,
TrainingRowCount = trainingData.RowCount,
TestRowCount = testData.RowCount
});
}
static void Main(string[] args)
{
var separator = DirectorySeparatorChar.ToString();
var mnistPath = $".{separator}mnist-fashion{separator}";
var mnist = new Mnist(mnistPath);
var xor = new XorDataSet();
//var imagePath = $"{mnistPath}png{separator}";
//mnist.OutputImages(imagePath);
//Trainer.DefaultOptimizer = new AdaDelta();
//Trainer.DefaultOptimizer = new RMSProp();
//Trainer.DefaultOptimizer = new NAG();
Trainer.DefaultOptimizer = new Adam();
Network.Factory.New();
Network.Factory.AddLayer(xor.InputDataSize, Identity);
Network.Factory.AddLayer(100, ReLU);
Network.Factory.AddConnection(He);
Network.Factory.AddLayer(xor.OutputDataSize, Identity, false);
Network.Factory.AddConnection(He);
Network.Factory.SetErrorFunction(MeanSquared);
Network.Factory.Create(out var network);
Trainer.Training(network, xor, limitError: 1e-10f, printLog: true);
Trainer.RegressionTest(network, xor);
Network.Factory.New();
Network.Factory.AddLayer(mnist.InputDataSize, Identity);
Network.Factory.AddLayer(400, ReLU);
Network.Factory.AddConnection(He);
Network.Factory.AddLayer(100, ReLU);
Network.Factory.AddConnection(He);
Network.Factory.AddLayer(50, ReLU);
Network.Factory.AddConnection(He);
Network.Factory.AddLayer(10, ReLU);
Network.Factory.AddConnection(He);
Network.Factory.AddLayer(mnist.OutputDataSize, Softmax, false);
Network.Factory.AddConnection(He);
Network.Factory.SetErrorFunction(CrossEntropy);
Network.Factory.Create(out network);
//Trainer.PreTraining(network, mnist, epoch: 4, batchSize: 30, printLog: true);
Trainer.Training(network, mnist, epoch: 5, batchSize: 50, printLog: true);
Trainer.ClusteringTest(network, mnist);
}
static int Main(string[] args)
{
// get the config in the following order:
// file specified by the first command line argument
// "default.json"
// defaults
Config conf;
if (args.Length > 0)
{
if (File.Exists(args[0]))
{
conf = Config.ReadFromJson(args[0]);
}
else
{
return(-1);
}
}
else if (File.Exists("default.json"))
{
conf = Config.ReadFromJson("default.json");
}
else
{
conf = new Config();
}
//conf.WriteToJson("default.json");
// init logger
Global.Logger = new Logger(true);
Global.Logger.SetAppName(conf.Name());
// print the config
Global.Logger.WriteLine($"{Config.Sep}{Config.Sep}");
Global.Logger.Write(conf.ToString());
Global.Logger.WriteLine($"{Config.Sep}{Config.Sep}");
// run the application
var mnist = new Mnist(conf);
mnist.Run();
return(0);
}
public void MNISTTwoHiddenLayerNetworkGPUTest()
{
// Parameters
var learningRate = 0.1f;
var epochs = 5;
var numGPUs = 4;
var mnist = new Mnist();
mnist.ReadDataSets("/tmp");
int batchSize = 400;
int numBatches = mnist.TrainImages.Length / batchSize;
using (var graph = new TFGraph())
{
var X = graph.Placeholder(TFDataType.Float, new TFShape(-1, 784));
var Y = graph.Placeholder(TFDataType.Float, new TFShape(-1, 10));
var Xs = graph.Split(graph.Const(0), X, numGPUs);
var Ys = graph.Split(graph.Const(0), Y, numGPUs);
var sgd = new SGD(graph, learningRate, 0.9f);
TFOutput[] costs = new TFOutput[numGPUs];
TFOutput[] accuracys = new TFOutput[numGPUs];
var variablesAndGradients = new Dictionary <Variable, List <TFOutput> >();
for (int i = 0; i < numGPUs; i++)
{
using (var device = graph.WithDevice("/GPU:" + i))
{
(costs[i], _, accuracys[i]) = CreateNetwork(graph, Xs[i], Ys[i], variablesAndGradients);
foreach (var gv in sgd.ComputeGradient(costs[i], colocateGradientsWithOps: true))
{
if (!variablesAndGradients.ContainsKey(gv.variable))
{
variablesAndGradients[gv.variable] = new List <TFOutput>();
}
variablesAndGradients[gv.variable].Add(gv.gradient);
}
}
}
var cost = graph.ReduceMean(graph.Stack(costs));
var accuracy = graph.ReduceMean(graph.Stack(accuracys));
var gradientsAndVariables = new (TFOutput gradient, Variable variable)[variablesAndGradients.Count];
/// <summary>
/// Trains a feed forward neural net on the MNIST data set (handwritten digit recognition)
/// The data files can be downloaded from http://yann.lecun.com/exdb/mnist/
/// </summary>
/// <param name="dataFilesPath">The path to a directory with the four extracted data files</param>
public static void MNIST(string dataFilesPath)
{
using (var lap = BrightWireGpuProvider.CreateLinearAlgebra()) {
var graph = new GraphFactory(lap);
Console.Write("Loading training data...");
var trainingData = _BuildVectors(null, graph, Mnist.Load(dataFilesPath + "train-labels.idx1-ubyte", dataFilesPath + "train-images.idx3-ubyte"));
var testData = _BuildVectors(trainingData, graph, Mnist.Load(dataFilesPath + "t10k-labels.idx1-ubyte", dataFilesPath + "t10k-images.idx3-ubyte"));
Console.WriteLine($"done - {trainingData.RowCount} training images and {testData.RowCount} test images loaded");
// one hot encoding uses the index of the output vector's maximum value as the classification label
var errorMetric = graph.ErrorMetric.OneHotEncoding;
// configure the network properties
graph.CurrentPropertySet
.Use(graph.GradientDescent.RmsProp)
.Use(graph.WeightInitialisation.Xavier)
;
// create the training engine and schedule a training rate change
const float TRAINING_RATE = 0.1f;
var engine = graph.CreateTrainingEngine(trainingData, TRAINING_RATE, 128);
engine.LearningContext.ScheduleLearningRate(15, TRAINING_RATE / 3);
// create the network
graph.Connect(engine)
.AddFeedForward(outputSize: 1024)
.Add(graph.LeakyReluActivation())
.AddDropOut(dropOutPercentage: 0.5f)
.AddFeedForward(outputSize: trainingData.OutputSize)
.Add(graph.SigmoidActivation())
.AddBackpropagation(errorMetric)
;
// train the network for twenty iterations, saving the model on each improvement
Models.ExecutionGraph bestGraph = null;
engine.Train(20, testData, errorMetric, model => bestGraph = model.Graph);
// export the final model and execute it on the training set
var executionEngine = graph.CreateEngine(bestGraph ?? engine.Graph);
var output = executionEngine.Execute(testData);
Console.WriteLine($"Final accuracy: {output.Average(o => o.CalculateError(errorMetric)):P2}");
}
}
/// <summary>
/// Trains a neural net on the MNIST database (digit recognition)
/// The data files can be downloaded from http://yann.lecun.com/exdb/mnist/
/// </summary>
/// <param name="dataFilesPath">The path to a directory with the four extracted data files</param>
public static void MNIST(string dataFilesPath)
{
using (var lap = BrightWireGpuProvider.CreateLinearAlgebra()) {
var graph = new GraphFactory(lap);
Console.Write("Loading training data...");
var trainingData = _BuildVectors(null, graph, Mnist.Load(dataFilesPath + "train-labels.idx1-ubyte", dataFilesPath + "train-images.idx3-ubyte"));
var testData = _BuildVectors(trainingData, graph, Mnist.Load(dataFilesPath + "t10k-labels.idx1-ubyte", dataFilesPath + "t10k-images.idx3-ubyte"));
Console.WriteLine($"done - {trainingData.RowCount} training images and {testData.RowCount} test images loaded");
// use a one hot encoding error metric, rmsprop gradient descent and xavier weight initialisation
var errorMetric = graph.ErrorMetric.OneHotEncoding;
var propertySet = graph.CurrentPropertySet
//.Use(graph.Regularisation.L2)
.Use(graph.GradientDescent.RmsProp)
.Use(graph.WeightInitialisation.Xavier)
;
// create the training engine and schedule a training rate change
const float TRAINING_RATE = 0.1f;
var engine = graph.CreateTrainingEngine(trainingData, TRAINING_RATE, 128);
engine.LearningContext.ScheduleLearningRate(15, TRAINING_RATE / 3);
// create the network
graph.Connect(engine)
.AddFeedForward(1024)
.Add(graph.LeakyReluActivation())
.AddDropOut(0.5f)
.AddFeedForward(trainingData.OutputSize)
.Add(graph.SigmoidActivation())
.AddBackpropagation(errorMetric)
;
// train the network
engine.Train(20, testData, errorMetric);
// export the graph and verify that the error is the same
var networkGraph = engine.Graph;
var executionEngine = graph.CreateEngine(networkGraph);
var output = executionEngine.Execute(testData);
Console.WriteLine(output.Average(o => o.CalculateError(errorMetric)));
}
}
private void TextInfer(Bitmap img, Mnist model, int MnistImageSize)
{
Graphics gNormalized = Graphics.FromImage(img);
gNormalized.DrawImage(img, 0, 0, MnistImageSize, MnistImageSize);
var image = new List <float>(MnistImageSize * MnistImageSize);
for (var x = 0; x < MnistImageSize; x++)
{
for (var y = 0; y < MnistImageSize; y++)
{
var color = img.GetPixel(y, x);
image.Add((float)(0.5 - (color.R + color.G + color.B) / (3.0 * 255)));
}
}
string str_temp = (model.Infer(new List <IEnumerable <float> > {
image
})).First().First().ToString();
if (str_temp == "43")
{
str_temp = "+";
}
else if (str_temp == "42")
{
str_temp = "*";
}
else if (str_temp == "45")
{
str_temp = "-";
}
else if (str_temp == "47")
{
str_temp = "/";
}
DispText.Add(str_temp);
}
static void MNIST()
{
Console.WriteLine("Parsing data -------------------");
List <Mnist> TrainingList = new List <Mnist>();
StreamReader sw = new StreamReader(@"E:\Music\training.txt");
List <string> charstr = new List <string>();
string build = "";
int index = -1;
int label = 0;
double[] data = new double[28 * 28];
while (!sw.EndOfStream)
{
int next = sw.Read() - 48;
if (next == -4)
{
if (index == -1)
{
label = Convert.ToInt32(build);
index++;
}
else
{
data[index] = Convert.ToInt32(build);
index++;
}
if (index == (28 * 28) - 1)
{
TrainingList.Add(new Mnist(data, label));
index = -1;
data = new double[28 * 28];
build = "";
sw.Read();
sw.Read();
}
build = "";
}
else
{
//check for line breaks & spaces
if (build.Contains(@"\"))
{
build = build.Remove(build.IndexOf(@"\"));
}
if (build.Contains(@"n"))
{
build = build.Remove(build.IndexOf(@"n"));
}
build += next;
}
}
sw.Close();
Random random = new Random();
//choose random object
for (int i = 0; i < 50; i++)
{
Mnist mn = TrainingList[random.Next(0, TrainingList.Count - 1)];
Bitmap bm = new Bitmap(28, 28);
index = 0;
for (int x = 0; x < 28; x++)
{
for (int y = 0; y < 28; y++)
{
int bright = Convert.ToInt32(mn.Data[index]);
bm.SetPixel(y, x, Color.FromArgb(255, bright, bright, bright));
index++;
}
}
string filename = @"E:\Music\Imagetest" + i + " " + mn.Label + ".png";
bm.Save(filename);
}
Console.WriteLine("Files output | press enter to continue");
Console.ReadLine();
var tempList = new List <Mnist>();
int count2 = 0;
foreach (Mnist nn in TrainingList)
{
tempList.Add(nn);
if (count2 > 15000)
{
break;
}
count2++;
}
TrainingList = tempList;
int isn = 0;
Console.WriteLine("Checking data -------------------");
foreach (Mnist mn in TrainingList)
{
int value = Convert.ToInt32(mn.Label);
if (value > 9 || value < 0)
{
Console.WriteLine("error at {0}", isn);
Console.ReadLine();
}
isn++;
}
var LMM = new LMMCNet(28 * 28, 1, new int[] { 10 }, 10, new Random());
Console.WriteLine("Training-------------------");
int count = 0;
int total = TrainingList.Count;
foreach (Mnist mn in TrainingList)
{
count++;
Console.WriteLine("Executing {0} of {1}", count, total);
var ExpectedOut = new double[10];
ExpectedOut[mn.Label] = 1;
for (int i = 0; i <= mn.Data.GetUpperBound(0); i++)
{
mn.Data[i] = mn.Data[i] / 255;
}
LMM.Train(mn.Data, ExpectedOut);
}
int totalSuccesses = 0;
int totalGuesses = 0;
int secondGuesses = 0;
Console.WriteLine("Guessing -----------------------");
foreach (Mnist mn in TrainingList)
{
totalGuesses++;
Console.WriteLine("On guess {0}", totalGuesses);
Console.WriteLine("{0} success from {1} guesses", totalSuccesses, totalGuesses);
Console.WriteLine("{0} first successes and {1} second guesses", totalSuccesses, secondGuesses);
var output = LMM.Predict(mn.Data);
Hessian(LMM.Net);
Console.WriteLine("-----------------");
int HighestIndex = 0;
double HighestValue = 0;
int secondIndex = 0;
double secondValue = 0;
for (int i = 0; i <= output.GetUpperBound(0); i++)
{
if (output[i] > HighestValue)
{
secondIndex = HighestIndex;
secondValue = HighestValue;
HighestIndex = i;
HighestValue = output[i];
}
}
Console.WriteLine("Array is");
int coun = 0;
foreach (double d in output)
{
Console.WriteLine("{0} = {1}", coun, d);
coun++;
}
Console.WriteLine("");
Console.WriteLine("Highest value is {0}", HighestValue);
Console.WriteLine("Index of highest is {0}", HighestIndex);
Console.WriteLine("Label is {0}", mn.Label);
if (mn.Label == HighestIndex)
{
Console.WriteLine("Is matching");
}
else if (mn.Label == secondIndex)
{
secondGuesses++;
}
else
{
Console.WriteLine("Is not matching");
}
if (HighestIndex == (mn.Label))
{
totalSuccesses++;
}
}
Console.WriteLine("{0} successes, {1} failures", totalSuccesses, totalGuesses - totalSuccesses);
Console.ReadLine();
}
public static void ReducedMNIST(string dataFilesPath)
{
Console.Write("Loading training data...");
var trainingData = Mnist.Load(dataFilesPath + "train-labels.idx1-ubyte", dataFilesPath + "train-images.idx3-ubyte");
var testData = Mnist.Load(dataFilesPath + "t10k-labels.idx1-ubyte", dataFilesPath + "t10k-images.idx3-ubyte");
Console.WriteLine("done");
var onesAndZeroesTraining = trainingData.Where(s => s.Label == 0 || s.Label == 1).Shuffle(0).Take(1000).ToList();
var onesAndZeroesTest = testData.Where(s => s.Label == 0 || s.Label == 1).Shuffle(0).Take(100).ToList();
using (var lap = GPUProvider.CreateLinearAlgebra(false)) {
var convolutionDescriptor = new ConvolutionDescriptor(0.1f)
{
Stride = 1,
Padding = 1,
FilterDepth = 4,
FilterHeight = 3,
FilterWidth = 3,
WeightInitialisation = WeightInitialisationType.Xavier,
WeightUpdate = WeightUpdateType.RMSprop,
Activation = ActivationType.LeakyRelu
};
const int BATCH_SIZE = 128, NUM_EPOCHS = 2, IMAGE_WIDTH = 28;
const float TRAINING_RATE = 0.03f;
var errorMetric = ErrorMetricType.OneHot.Create();
var layerTemplate = new LayerDescriptor(0.1f)
{
WeightUpdate = WeightUpdateType.RMSprop,
Activation = ActivationType.LeakyRelu
};
var trainingSamples = onesAndZeroesTraining.Select(d => d.AsVolume).Select(d => Tuple.Create(d.AsTensor(lap), d.ExpectedOutput)).ToList();
var testSamples = onesAndZeroesTest.Select(d => d.AsVolume).Select(d => Tuple.Create(d.AsTensor(lap), d.ExpectedOutput)).ToList();
// create a network with a single convolutional layer followed by a max pooling layer
var convolutionalLayer = new IConvolutionalLayer [] {
lap.NN.CreateConvolutionalLayer(convolutionDescriptor, 1, IMAGE_WIDTH, false),
lap.NN.CreateMaxPoolingLayer(2, 2, 2)
};
var trainingDataProvider = lap.NN.CreateConvolutionalTrainingProvider(convolutionDescriptor, trainingSamples, convolutionalLayer, true);
var testDataProvider = lap.NN.CreateConvolutionalTrainingProvider(convolutionDescriptor, testSamples, convolutionalLayer, false);
ConvolutionalNetwork network;
using (var trainer = lap.NN.CreateBatchTrainer(layerTemplate, 784, trainingDataProvider.OutputSize)) {
var trainingContext = lap.NN.CreateTrainingContext(errorMetric, TRAINING_RATE, BATCH_SIZE);
trainingContext.EpochComplete += c => {
var output = trainer.Execute(testDataProvider.TrainingDataProvider);
var testError = output.Select(d => errorMetric.Compute(d.Output, d.ExpectedOutput)).Average();
trainingContext.WriteScore(testError, errorMetric.DisplayAsPercentage);
};
trainer.Train(trainingDataProvider.TrainingDataProvider, NUM_EPOCHS, trainingContext);
network = trainingDataProvider.GetCurrentNetwork(trainer);
}
foreach (var layer in convolutionalLayer)
{
layer.Dispose();
}
foreach (var item in trainingSamples)
{
item.Item1.Dispose();
}
foreach (var item in testSamples)
{
item.Item1.Dispose();
}
int correct = 0, total = 0;
using (var execution = lap.NN.CreateConvolutional(network)) {
foreach (var item in onesAndZeroesTest)
{
using (var tensor = item.AsVolume.AsTensor(lap)) {
using (var output = execution.Execute(tensor)) {
var maxIndex = output.MaximumIndex();
if (maxIndex == item.Label)
{
++correct;
}
++total;
}
}
}
}
Console.WriteLine($"Execution results: {(double)correct / total:P0} correct");
}
}
public void MNISTTwoHiddenLayerNetworkTest()
{
// Parameters
var learningRate = 0.1f;
var epochs = 5;
var mnist = new Mnist();
mnist.ReadDataSets("/tmp");
int batchSize = 100;
int numBatches = mnist.TrainImages.Length / batchSize;
using (var graph = new TFGraph())
{
var X = graph.Placeholder(TFDataType.Float, new TFShape(-1, 784));
var Y = graph.Placeholder(TFDataType.Float, new TFShape(-1, 10));
graph.Seed = 1;
var initB = (float)(4 * Math.Sqrt(6) / Math.Sqrt(784 + 500));
var W1 = graph.Variable(graph.RandomUniform(new TFShape(784, 500), minval: -initB, maxval: initB), operName: "W1");
var b1 = graph.Variable(graph.Constant(0f, new TFShape(500), TFDataType.Float), operName: "b1");
var layer1 = graph.Sigmoid(graph.Add(graph.MatMul(X, W1.Read), b1.Read, operName: "layer1"));
initB = (float)(4 * Math.Sqrt(6) / Math.Sqrt(500 + 100));
var W2 = graph.Variable(graph.RandomUniform(new TFShape(500, 100), minval: -initB, maxval: initB), operName: "W2");
var b2 = graph.Variable(graph.Constant(0f, new TFShape(100), TFDataType.Float), operName: "b2");
var layer2 = graph.Sigmoid(graph.Add(graph.MatMul(layer1, W2.Read), b2.Read, operName: "layer2"));
initB = (float)(4 * Math.Sqrt(6) / Math.Sqrt(100 + 10));
var W3 = graph.Variable(graph.RandomUniform(new TFShape(100, 10), minval: -initB, maxval: initB), operName: "W3");
var b3 = graph.Variable(graph.Constant(0f, new TFShape(10), TFDataType.Float), operName: "b3");
var layer3 = graph.Add(graph.MatMul(layer2, W3.Read), b3.Read, operName: "layer3");
// No support for computing gradient for the SparseSoftmaxCrossEntropyWithLogits function
// instead using SoftmaxCrossEntropyWithLogits
var cost = graph.ReduceMean(graph.SoftmaxCrossEntropyWithLogits(layer3, Y, "cost").loss);
var prediction = graph.ArgMax(graph.Softmax(layer3), graph.Const(1));
var labels = graph.ArgMax(Y, graph.Const(1));
var areCorrect = graph.Equal(prediction, labels);
var accuracy = graph.ReduceMean(graph.Cast(areCorrect, TFDataType.Float));
var sgd = new SGD(graph, learningRate, 0.9f);
var updateOps = sgd.Minimize(cost);
using (var sesssion = new TFSession(graph))
{
sesssion.GetRunner().AddTarget(graph.GetGlobalVariablesInitializer()).Run();
var expectedLines = File.ReadAllLines(Path.Combine(_testDataPath, "SGDMnist", "expected.txt"));
for (int i = 0; i < epochs; i++)
{
var reader = mnist.GetTrainReader();
float avgLoss = 0;
float avgAccuracy = 0;
for (int j = 0; j < numBatches; j++)
{
var batch = reader.NextBatch(batchSize);
var tensors = sesssion.GetRunner()
.AddInput(X, batch.Item1)
.AddInput(Y, batch.Item2)
.AddTarget(updateOps).Fetch(cost, accuracy, prediction, labels).Run();
avgLoss += (float)tensors[0].GetValue();
avgAccuracy += (float)tensors[1].GetValue();
}
var output = $"Epoch: {i}, loss(Cross-Entropy): {avgLoss / numBatches:F4}, Accuracy:{avgAccuracy / numBatches:F4}";
Assert.Equal(expectedLines[i], output);
}
}
}
}
/// <summary>
/// Trains a feed forward neural net on the MNIST data set (handwritten digit recognition)
/// The data files can be downloaded from http://yann.lecun.com/exdb/mnist/
/// </summary>
/// <param name="dataFilesPath">The path to a directory with the four extracted data files</param>
/// <param name="outputModelPath">Optional path to save the best model to</param>
static void MNISTConvolutional(string dataFilesPath, string outputModelPath = null)
{
using var lap = BrightWireGpuProvider.CreateLinearAlgebra();
var graph = new GraphFactory(lap);
Console.Write("Loading training data...");
var mnistTraining = Mnist.Load(dataFilesPath + "train-labels.idx1-ubyte",
dataFilesPath + "train-images.idx3-ubyte");
var mnistTest = Mnist.Load(dataFilesPath + "t10k-labels.idx1-ubyte",
dataFilesPath + "t10k-images.idx3-ubyte");
var trainingData =
_BuildTensors(graph, null, mnistTraining /*.Where(d => d.Label < 2).ToList()*/);
var testData = _BuildTensors(graph, trainingData,
mnistTest /*.Where(d => d.Label < 2).ToList()*/);
Console.WriteLine(
$"done - {trainingData.RowCount} training images and {testData.RowCount} test images loaded");
// one hot encoding uses the index of the output vector's maximum value as the classification label
var errorMetric = graph.ErrorMetric.OneHotEncoding;
// configure the network properties
graph.CurrentPropertySet.Use(graph.GradientDescent.Adam).Use(
graph.GaussianWeightInitialisation(false, 0.1f, GaussianVarianceCalibration.SquareRoot2N));
// create the network
const int HIDDEN_LAYER_SIZE = 1024, TRAINING_ITERATIONS = 20;
const float LEARNING_RATE = 0.05f;
var engine = graph.CreateTrainingEngine(trainingData, LEARNING_RATE);
if (!string.IsNullOrWhiteSpace(outputModelPath) && File.Exists(outputModelPath))
{
Console.WriteLine("Loading existing model from: " + outputModelPath);
using var file = new FileStream(outputModelPath, FileMode.Open, FileAccess.Read);
var model = Serializer.Deserialize <GraphModel>(file);
engine = graph.CreateTrainingEngine(trainingData, model.Graph, LEARNING_RATE);
}
else
{
graph.Connect(engine).
AddConvolutional(filterCount: 16, padding: 2, filterWidth: 5, filterHeight: 5, xStride: 1,
yStride: 1, shouldBackpropagate: false).Add(graph.LeakyReluActivation()).
AddMaxPooling(filterWidth: 2, filterHeight: 2, xStride: 2, yStride: 2).
AddConvolutional(filterCount: 32, padding: 2, filterWidth: 5, filterHeight: 5, xStride: 1,
yStride: 1).Add(graph.LeakyReluActivation()).
AddMaxPooling(filterWidth: 2, filterHeight: 2, xStride: 2, yStride: 2).Transpose().
AddFeedForward(HIDDEN_LAYER_SIZE).Add(graph.LeakyReluActivation()).
AddDropOut(dropOutPercentage: 0.5f).AddFeedForward(trainingData.OutputSize).
Add(graph.SoftMaxActivation()).AddBackpropagation(errorMetric);
}
// lower the learning rate over time
engine.LearningContext.ScheduleLearningRate(15, LEARNING_RATE / 2);
// train the network for twenty iterations, saving the model on each improvement
Models.ExecutionGraph bestGraph = null;
engine.Train(TRAINING_ITERATIONS, testData, errorMetric, model =>
{
bestGraph = model.Graph;
if (!string.IsNullOrWhiteSpace(outputModelPath))
{
using var file = new FileStream(outputModelPath, FileMode.Create, FileAccess.Write);
Serializer.Serialize(file, model);
}
});
// export the final model and execute it on the training set
var executionEngine = graph.CreateEngine(bestGraph ?? engine.Graph);
var output = executionEngine.Execute(testData);
Console.WriteLine($"Final accuracy: {output.Average(o => o.CalculateError(errorMetric)):P2}");
// execute the model with a single image
var tensor = mnistTest.First().AsFloatTensor.Tensor;
var singleData = graph.CreateDataSource(new[] { tensor });
var result = executionEngine.Execute(singleData);
var prediction = result.Single().Output.Single().MaximumIndex();
}
static void MNISTBinaryNet()
{
Console.WriteLine("Parsing data -------------------");
List <Mnist> TrainingList = new List <Mnist>();
StreamReader sw = new StreamReader(@"E:\Music\training.txt");
List <string> charstr = new List <string>();
string build = "";
int index = -1;
int label = 0;
double[] data = new double[28 * 28];
while (!sw.EndOfStream)
{
int next = sw.Read() - 48;
if (next == -4)
{
if (index == -1)
{
label = Convert.ToInt32(build);
index++;
}
else
{
data[index] = Convert.ToInt32(build);
index++;
}
if (index == (28 * 28) - 1)
{
TrainingList.Add(new Mnist(data, label));
index = -1;
data = new double[28 * 28];
build = "";
sw.Read();
sw.Read();
}
build = "";
}
else
{
//check for line breaks & spaces
if (build.Contains(@"\"))
{
build = build.Remove(build.IndexOf(@"\"));
}
if (build.Contains(@"n"))
{
build = build.Remove(build.IndexOf(@"n"));
}
build += next;
}
}
sw.Close();
Random random = new Random();
//choose random object
for (int i = 0; i < 50; i++)
{
Mnist mn = TrainingList[random.Next(0, TrainingList.Count - 1)];
Bitmap bm1 = new Bitmap(28, 28);
index = 0;
for (int x = 0; x < 28; x++)
{
for (int y = 0; y < 28; y++)
{
int bright = Convert.ToInt32(mn.Data[index]);
bm1.SetPixel(y, x, Color.FromArgb(255, bright, bright, bright));
index++;
}
}
string filename = @"E:\Music\Imagetest" + i + " " + mn.Label + ".png";
bm1.Save(filename);
}
Console.WriteLine("Files output | press enter to continue");
//Console.ReadLine();
var tempList = new List <Mnist>();
int count2 = 0;
foreach (Mnist nn in TrainingList)
{
tempList.Add(nn);
if (count2 > 20000)
{
break;
}
count2++;
}
TrainingList = tempList;
int isn = 0;
Console.WriteLine("Checking data -------------------");
foreach (Mnist mn in TrainingList)
{
int value = Convert.ToInt32(mn.Label);
if (value > 9 || value < 0)
{
Console.WriteLine("error at {0}", isn);
Console.ReadLine();
}
isn++;
}
var fac = new BinaryNetFactory(new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 28 * 28, new int[] { 10 }, new Random());
Console.WriteLine("Training-------------------");
int count = 0;
int total = TrainingList.Count;
foreach (Mnist mn in TrainingList)
{
count++;
Console.WriteLine("Executing {0} of {1}", count, total);
var ExpectedOut = new double[10];
ExpectedOut[mn.Label] = 1;
for (int i = 0; i <= mn.Data.GetUpperBound(0); i++)
{
mn.Data[i] = mn.Data[i] / 255;
}
fac.Train(mn.Data, mn.Label);
}
//load chris' handwriting
Bitmap bm = new Bitmap(@"E:\music\ChrisWriting.png");
double[] dataArray = new double[28 * 28];
int dataIndex = 0;
for (int x = 0; x < 28; x++)
{
for (int y = 0; y < 28; y++)
{
dataArray[dataIndex] = bm.GetPixel(x, y).GetBrightness() != 0 ? bm.GetPixel(x, y).GetBrightness() : 0;
dataIndex++;
}
}
var result = fac.Predict(dataArray);
Console.WriteLine("Result of Chris' handwriting is {0}", result[0]);
Console.ReadLine();
int totalSuccesses = 0;
int totalGuesses = 0;
int secondGuesses = 0;
Console.WriteLine("Guessing -----------------------");
foreach (Mnist mn in TrainingList)
{
totalGuesses++;
Console.WriteLine("On guess {0}", totalGuesses);
Console.WriteLine("{0} success from {1} guesses", totalSuccesses, totalGuesses);
Console.WriteLine("{0} first successes and {1} second guesses", totalSuccesses, secondGuesses);
var output = fac.Predict(mn.Data);
Console.WriteLine("-----------------");
if (mn.Label == output[0])
{
Console.WriteLine("Is matching");
totalSuccesses++;
}
else
{
Console.WriteLine("Is not matching");
}
}
Console.WriteLine("{0} successes, {1} failures", totalSuccesses, totalGuesses - totalSuccesses);
Console.ReadLine();
}
