public async Task <PredictionResult> PredictNumberByRest([FromBody] PredictionRequest model)
{
try
{
var stopWatch = Stopwatch.StartNew();
var imageData = CreateImageDataFromModel(model.ImageData);
var request = new PredictionRestRequest();
request.SignatureName = "serving_default";
request.Instances = TensorBuilder.CreateTensorFromImage(imageData, 255.0f).FloatVal.ToList();
var result = await _httpClient.PostAsync(_configuration.GetSection("TfServer")["RestServerUrl"],
new StringContent(JsonConvert.SerializeObject(request, Formatting.Indented)));
//Process response
var content = await result.Content.ReadAsStringAsync();
var predictionRestResponse = JsonConvert.DeserializeObject <PredictionRestResponse>(content);
var maxValue = predictionRestResponse.Predictions[0][0].Max();
var predictedValue = Array.IndexOf(predictionRestResponse.Predictions[0][0], maxValue);
return(new PredictionResult()
{
Success = true,
Results = predictionRestResponse.Predictions[0][0].Select(x => x).ToList(),
PredictedValue = predictedValue.ToString(),
DebugText = $"Total time: {stopWatch.ElapsedMilliseconds} ms"
});
}
catch (Exception ex)
{
return(ErrorResult(ex));
}
}
public List <Tensor> GetLossList(ProcessData data)
{
Tensor[] lossList = new Tensor[this.Count];
List <Tensor> pushes = this.GetAllOutputs(data.Data);
Tensor loss;
//这里对softmax层进行了特别对待处理，应该如何统一化？
if (layers[layerCount - 1].Sign == LayerSign.SoftMaxLayer)
{
loss = data.Label - pushes[this.layerCount - 1];
}
else
{
loss = LossFunc.Loss(data.Label, pushes[this.layerCount - 1]);;
}
Tensor nextWeight = TensorBuilder.FromMatrix(Matrix <double> .Build.DenseIdentity(data.Label[0, 0].ColumnCount));
LayerSign nextType = LayerSign.Nothing;
for (int i = this.layerCount - 1; i >= 2; i--)
{
loss = layers[i].ComputeLoss(loss, pushes[i - 1], nextWeight, nextType);
lossList[i] = loss;
nextWeight = layers[i].Weight;
nextType = layers[i].Sign;
}
loss = layers[1].ComputeLoss(loss, pushes[0], nextWeight, nextType);
lossList[1] = loss;
nextWeight = layers[1].Weight;
nextType = layers[1].Sign;
loss = layers[0].ComputeLoss(loss, data.Data, nextWeight, nextType);
lossList[0] = loss;
return(lossList.ToList());
}
/// <summary>
/// 获取一个批量内的平均梯度列表，为了减少运算开销同时给出损失列表
/// </summary>
/// <param name="model"></param>
/// <param name="dataCollection"></param>
/// <returns>第一个为梯度列表，第二个为损失列表</returns>
public static Tuple <Tensor[], Tensor[]> GetAverageGradient(IModel model, ProcessData[] dataCollection)
{
Tensor[] gradientList = new Tensor[model.Count];
Tensor[] lossList = new Tensor[model.Count];
var temp = model.GetGradientList(dataCollection[0]);
for (int i = 0; i <= model.Count - 1; i++)
{
gradientList[i] = TensorBuilder.AllZeros(temp.Item1[i]);
lossList[i] = TensorBuilder.AllZeros(temp.Item2[i]);
}
//foreach(var data in dataCollection)
for (int j = 0; j <= dataCollection.Length - 1; j++)
//Parallel.For(0, dataCollection.Length - 1, j =>
{
//var tempList = model.GetGradientList(data);
var tempList = model.GetGradientList(dataCollection[j]);
for (int i = 0; i <= tempList.Item1.Length - 1; i++)
{
gradientList[i] = gradientList[i] + tempList.Item1[i];
lossList[i] = lossList[i] + tempList.Item2[i];
}
}
gradientList = gradientList.Select(r => r / dataCollection.Count()).ToArray();
lossList = lossList.Select(r => r / dataCollection.Count()).ToArray();
return(new Tuple <Tensor[], Tensor[]>(gradientList, lossList));
}
/// <summary>
/// 获取梯度列表，同时为了简化运算同时输出损失列表
/// </summary>
/// <param name="data"></param>
/// <returns>第一个为梯度列表，第二个为损失列表</returns>
public Tuple <Tensor[], Tensor[]> GetGradientList(ProcessData data)
{
Tensor[] gradientList = new Tensor[this.Count];
Tensor[] lossList = new Tensor[this.Count];
List <Tensor> pushes = this.GetAllOutputs(data.Data);
Tensor loss;
//这里对softmax层进行了特别对待处理，应该如何统一化？
if (layers[layerCount - 1].Sign == LayerSign.SoftMaxLayer)//反射是否开销太大了？
{
loss = data.Label - pushes[this.layerCount - 1];
}
else
{
loss = LossFunc.Loss(data.Label, pushes[this.layerCount - 1]);
}
Tensor nextWeight = TensorBuilder.FromMatrix(Matrix <double> .Build.DenseIdentity(data.Label[0, 0].RowCount));
LayerSign nextType = LayerSign.Nothing;
for (int i = this.layerCount - 1; i >= 2; i--)
{
(gradientList[i], loss) = layers[i].GetGradient(loss, pushes[i - 1], nextWeight, nextType);
lossList[i] = loss;
//loss = layers[i].ComputeLoss(loss, pushes[i - 1], nextWeight);
nextWeight = layers[i].Weight;
nextType = layers[i].Sign;
}
(gradientList[1], loss) = layers[1].GetGradient(loss, pushes[0], nextWeight, nextType);
lossList[1] = loss;
//loss = layers[1].ComputeLoss(loss, pushes[0], nextWeight);
nextWeight = layers[1].Weight;
nextType = layers[1].Sign;
(gradientList[0], lossList[0]) = layers[0].GetGradient(loss, data.Data, nextWeight, nextType);
return(new Tuple <Tensor[], Tensor[]>(gradientList, lossList));
}
public ProcessData ConvertInputToProcess(InputData <double[], string> inputData)
{
return(new ProcessData()
{
Data = TensorBuilder.FromMatrix(Matrix <double> .Build.DenseOfRowMajor(10, 1, inputData.OriginalData)),
Label = TensorBuilder.FromMatrix(Matrix <double> .Build.Dense(12, 1, labelEncodeDic[inputData.OriginalLabel]))
});
}
public ProcessData ConvertInputToProcess(InputData <double[], double> inputData)
{
return(new ProcessData()
{
//Data = TensorBuilder.FromMatrix(Matrix<double>.Build.DenseOfRowMajor(784, 1, inputData.OriginalData)),
Data = TensorBuilder.FromMatrix(Matrix <double> .Build.DenseOfRowMajor(28, 28, inputData.OriginalData)),
Label = TensorBuilder.FromMatrix(Matrix <double> .Build.Dense(10, 1, ConvertToOnehot(inputData.OriginalLabel, 9)))
});
}
static void Main(string[] args)
{
//Create gRPC Channel
var channel = new Channel(ConfigurationManager.AppSettings["ServerHost"], ChannelCredentials.Insecure);
var client = new PredictionService.PredictionServiceClient(channel);
//Check available MNIST model
var responce = client.GetModelMetadata(new GetModelMetadataRequest()
{
ModelSpec = new ModelSpec()
{
Name = "mnist"
},
MetadataField = { "signature_def" }
});
Console.WriteLine($"Model Available: {responce.ModelSpec.Name} Ver.{responce.ModelSpec.Version}");
var imagesFolder = ConfigurationManager.AppSettings["ImagesFolder"];
//Process images prediction from 0 to 9 fromexample folder
for (int number = 0; number < 10; number++)
{
//Create prediction request
var request = new PredictRequest()
{
ModelSpec = new ModelSpec()
{
Name = "mnist", SignatureName = ModelMethodClasses.PredictImages
}
};
//Add image tensor [1 - 784]
using (Stream stream = new FileStream($"{AppDomain.CurrentDomain.BaseDirectory}/{imagesFolder}/{number}.bmp", FileMode.Open))
{
request.Inputs.Add("images", TensorBuilder.CreateTensorFromImage(stream, 255.0f));
}
//Add keep_prob tensor [1 - 1]
request.Inputs.Add("keep_prob", TensorBuilder.CreateTensor(0.5f));
var predictResponse = client.Predict(request);
//Compute Max value from prediction array
var maxValue = predictResponse.Outputs["scores"].FloatVal.Max();
//Get index of predicted value
var predictedValue = predictResponse.Outputs["scores"].FloatVal.IndexOf(maxValue);
Console.WriteLine($"Predict: {number} {(number == predictedValue ? "Y" : "N")}");
Console.WriteLine($"Result value: {predictedValue}, probability: {maxValue}");
Console.WriteLine($"All values: {predictResponse.Outputs["scores"].FloatVal}");
Console.WriteLine("");
}
channel.ShutdownAsync().Wait();
}
protected BaseLayer(LayerInfo info)
{
InputShape = new Shape(info.InputShape.B, info.InputShape.C, info.InputShape.H, info.InputShape.W);
OutputShape = new Shape(info.OutputShape.B, info.OutputShape.C, info.OutputShape.H, info.OutputShape.W);
Builder = TensorBuilder.Create();
Output = Builder.Empty();
InputGradient = Builder.Empty();
IsInit = true;
}
public static Tensor GetFinalAbsoluteAverageLoss(IModel model, IEnumerable <ProcessData> dataCollection)
{
Tensor loss = TensorBuilder.AllZeros(model.GetFinalLoss(dataCollection.ElementAt(0)));
foreach (var data in dataCollection)
{
var tempList = model.GetFinalLoss(data);
loss = loss + model.GetFinalLoss(data).OuterMap(r => r.PointwiseAbs());
}
return(loss / dataCollection.Count());
}
public async Task <PredictionResult> PredictByRest([FromBody] PredictionRequest model)
{
try
{
var stopWatch = Stopwatch.StartNew();
var imageData = CreateImageDataFromModel(model.ImageData);
var tensors = TensorBuilder.CreateTensorFromImage(imageData, 1.0f, 0f).FloatVal.ToList();
var request = new PredictionRestCatsAndDogsRequest();
request.SignatureName = "serving_default";
request.Instances = new float[1][][][];
request.Instances[0] = new float[160][][];
for (int i = 0; i < 160; i++)
{
request.Instances[0][i] = new float[160][];
for (int j = 0; j < 160; j++)
{
request.Instances[0][i][j] = new float[3];
request.Instances[0][i][j][0] = tensors[(i * 160 + j) * 3];
request.Instances[0][i][j][1] = tensors[(i * 160 + j) * 3 + 1];
request.Instances[0][i][j][2] = tensors[(i * 160 + j) * 3 + 2];
}
}
var result = await _httpClient.PostAsync(_configuration.GetSection("TfServerCatsAndDogs")["RestServerUrl"],
new StringContent(JsonConvert.SerializeObject(request, Formatting.Indented)));
//Process response
var content = await result.Content.ReadAsStringAsync();
var predictionRestResponse = JsonConvert.DeserializeObject <PredictionRestCatsAndDogsResponse>(content);
//Process response
var predictedIndex = predictionRestResponse.Predictions[0].Max() > 0 ? 1 : 0;
var predictionResults = new float[2] {
0, 0
};
predictionResults[predictedIndex] = predictionRestResponse.Predictions[0].Max();
return(new PredictionResult()
{
Success = true,
Results = predictionResults.ToList(),
PredictedValue = predictedIndex > 0 ? "Dog" : "Cat",
DebugText = $"Total time: {stopWatch.ElapsedMilliseconds} ms"
});
}
catch (Exception ex)
{
return(ErrorResult(ex));
}
}
public static List <Tensor> GetAverageLoss(IModel model, IEnumerable <ProcessData> dataCollection)
{
List <Tensor> lossList = new List <Tensor>();
for (int i = 0; i <= model.Count - 1; i++)
{
lossList.Add(TensorBuilder.AllZeros(model.GetOutputAt(i, dataCollection.ElementAt(0).Data)));
}
foreach (var data in dataCollection)
{
var tempList = model.GetLossList(data);
for (int i = 0; i <= tempList.Count - 1; i++)
{
lossList[i] = lossList[i] + tempList[i] / dataCollection.Count();
}
}
return(lossList.Select(r => r / dataCollection.Count()).ToList());
}
public PredictionResult PredictByGrpc([FromBody] PredictionRequest model)
{
try
{
var stopWatch = Stopwatch.StartNew();
var imageData = CreateImageDataFromModel(model.ImageData);
//Init predict request
var request = new PredictRequest()
{
ModelSpec = new ModelSpec()
{
Name = "cats_and_dogs", SignatureName = "serving_default"
}
};
request.Inputs.Add("input_2", TensorBuilder.CreateTensorFromImage(imageData, 1.0f, 0f));
//Create grpc request
var channel = new Channel(_configuration.GetSection("TfServerCatsAndDogs")["GrpcServerUrl"], ChannelCredentials.Insecure);
var client = new PredictionService.PredictionServiceClient(channel);
var predictResponse = client.Predict(request);
//Process response
var predictedIndex = predictResponse.Outputs["dense"].FloatVal.Max() > 0 ? 1 : 0;
var predictionResults = new float[2] {
0, 0
};
predictionResults[predictedIndex] = predictResponse.Outputs["dense"].FloatVal.Max();
return(new PredictionResult()
{
Success = true,
Results = predictionResults.ToList(),
PredictedValue = predictedIndex > 0 ? "Dog" : "Cat",
DebugText = $"Total time: {stopWatch.ElapsedMilliseconds} ms"
});
}
catch (Exception ex)
{
return(ErrorResult(ex));
}
}
public PredictionResult PredictNumberByGrpc([FromBody] PredictionRequest model)
{
try
{
var stopWatch = Stopwatch.StartNew();
var imageData = CreateImageDataFromModel(model.ImageData);
//Init predict request
var request = new PredictRequest()
{
ModelSpec = new ModelSpec()
{
Name = "mnist_v1", SignatureName = "serving_default"
}
};
request.Inputs.Add("flatten_input", TensorBuilder.CreateTensorFromImage(imageData, 255.0f));
//Create grpc request
var channel = new Channel(_configuration.GetSection("TfServer")["GrpcServerUrl"], ChannelCredentials.Insecure);
var client = new PredictionService.PredictionServiceClient(channel);
var predictResponse = client.Predict(request);
//Process response
var maxValue = predictResponse.Outputs["dense_1"].FloatVal.Max();
var predictedValue = predictResponse.Outputs["dense_1"].FloatVal.IndexOf(maxValue);
return(new PredictionResult()
{
Success = true,
Results = predictResponse.Outputs["dense_1"].FloatVal.Select(x => x).ToList(),
PredictedValue = predictedValue.ToString(),
DebugText = $"Total time: {stopWatch.ElapsedMilliseconds} ms"
});
}
catch (Exception ex)
{
return(ErrorResult(ex));
}
}
private void Init(string datasetPath, Func <float, float> dataNormalizer, int batchSize)
{
FileInfo file = new FileInfo(datasetPath);
if (!file.Exists)
{
throw new ArgumentException($"File {datasetPath} is not exist");
}
if (file.Extension != ".dset")
{
throw new ArgumentException($"File {datasetPath} has wrong format");
}
_fileStream = new FileStream(datasetPath, FileMode.Open);
_binaryReader = new BinaryReader(_fileStream);
_dataNormalizer = dataNormalizer;
var c = _binaryReader.ReadInt32();
var h = _binaryReader.ReadInt32();
var w = _binaryReader.ReadInt32();
ExamplesCount = _binaryReader.ReadInt32();
_classesCount = _binaryReader.ReadInt32();
_shape = new Shape(1, c, h, w);
LoadingBatchSize = batchSize != -1 ? batchSize : ExamplesCount;
TotalBatches = (int)Math.Ceiling((float)ExamplesCount / LoadingBatchSize);
var tensorBuilder = TensorBuilder.OfType(typeof(TTensor));
for (int i = 0; i < LoadingBatchSize; i++)
{
_loadedExamples.Add(new Example
{
Input = (TTensor)tensorBuilder.OfShape(_shape),
Output = (TTensor)tensorBuilder.OfShape(new Shape(1, 1, 1, _classesCount))
});
}
}
public async Task recognize(uint[] rgb_image, int height, int width)
{
var request = new PredictRequest()
{
ModelSpec = new ModelSpec()
{
Name = "default"
}
};
request.Inputs.Add("inputs", TensorBuilder.CreateTensorFromImage(rgb_image, height, width, 3));
// Run the prediction
var predictResponse = await client.PredictAsync(request);
//float num_classes= TensorProtoDecoder.TensorProtoToFloat(predictResponse.Outputs["num_classes"]);
int num_detections = (int)TensorProtoDecoder.TensorProtoToFloat(predictResponse.Outputs["num_detections"]);
float[] classes = TensorProtoDecoder.TensorProtoToFloatArray(predictResponse.Outputs["detection_classes"]);
float[] bboxes = TensorProtoDecoder.TensorProtoToFloatArray(predictResponse.Outputs["detection_boxes"]);
float[] scores = TensorProtoDecoder.TensorProtoToFloatArray(predictResponse.Outputs["detection_scores"]);
for (var i = 0; i < num_detections; i++)
{
float[] bbox = new float[4];
Array.Copy(bboxes, i * 4, bbox, 0, 4);
detectedObjects.Add(new Detection
{
boundingBox = bbox,
objectClass = label_list[(int)classes[i]],
confidence = scores[i]
});
}
readyForNextFrame = true;
}
private void InitializeTraining()
{
TensorBuilder builder = TensorBuilder.Create();
Dy = builder.Empty();
Loss = builder.Empty();
if (!(Optimizer is IParametersProvider provider))
{
return;
}
foreach (var storage in Network.GetParameters())
{
var layerParams = new Dictionary <string, Tensor>();
foreach (var parameter in provider.GetParameters())
{
var tensor = TensorBuilder.Create()
.Filled(storage.Weights.Storage.Shape, parameter.Value);
layerParams.Add(parameter.Key, tensor);
}
storage.Parameters = layerParams;
}
}
public TestResult TestModel(INetwork network)
{
var result = new TestResult();
var max1 = TensorBuilder.Create().Empty();
var max2 = TensorBuilder.Create().Empty();
foreach (var example in _testExamples)
{
network.Forward(example.Input);
network.Output.Max(max1);
example.Output.Max(max2);
if (max1[1] == max2[1])
{
result.Successful++;
}
else
{
result.Failed++;
}
result.TotalTests++;
result.SuccessfulRatio = (float)result.Successful / result.TotalTests;
}
return(result);
}
public PredictionResult PredictNumber([FromBody] PredictionRequest model)
{
try
{
//Load Bitmap from input base64
Bitmap convertedImage = null;
using (var str = new MemoryStream(Convert.FromBase64String(model.ImageData)))
{
str.Position = 0;
using (var bmp = Image.FromStream(str))
{
//Resize image and convert to rgb24
convertedImage = ImageUtils.ResizeImage(bmp, 28, 28, 280, 280);
}
}
//Create channel
var channel = new Channel(_configuration.GetSection("TfServer")["ServerUrl"], ChannelCredentials.Insecure);
var client = new PredictionService.PredictionServiceClient(channel);
//Init predict request
var request = new PredictRequest()
{
ModelSpec = new ModelSpec()
{
Name = "mnist", SignatureName = ModelMethodClasses.PredictImages
}
};
//Convert image to 28x28 8bit per pixel image data array
var imageData = ImageUtils.ConvertImageStreamToDimArrays(convertedImage);
var textDebug = TextUtils.RenderImageData(imageData);
//add image tensor
request.Inputs.Add("images", TensorBuilder.CreateTensorFromImage(imageData, 255.0f));
//add keep_prob tensor
request.Inputs.Add("keep_prob", TensorBuilder.CreateTensor(1.0f));
var predictResponse = client.Predict(request);
var maxValue = predictResponse.Outputs["scores"].FloatVal.Max();
var predictedValue = predictResponse.Outputs["scores"].FloatVal.IndexOf(maxValue);
return(new PredictionResult()
{
Success = true,
Results = predictResponse.Outputs["scores"].FloatVal.Select(x => x).ToList(),
PredictedNumber = predictedValue,
DebugText = textDebug
});
}
catch (Exception ex)
{
return(new PredictionResult()
{
Success = false,
ErrorMessage = ex.ToString()
});
}
}
public NeuralNetworkComponent(int inputSize)
{
_inputBuilder = new CpuBuilder();
_network = CreateNetwork(inputSize);
}
public static void SendRequest(string inputPath, string outputPath)
{
IPHostEntry host;
string containerIP = "?";
string hostName = "mw-tf-server.uksouth.azurecontainer.io";
host = Dns.GetHostEntry(hostName); //; //Dns.GetHostEntry(Dns.GetHostName());
foreach (IPAddress ip in host.AddressList)
{
if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
containerIP = ip.ToString();
}
}
//Create gRPC Channel
var channel = new Channel(containerIP + ":8500", ChannelCredentials.Insecure);
var client = new PredictionService.PredictionServiceClient(channel);
//Check available models
//var responce = client.GetModelMetadata(new GetModelMetadataRequest()
//{
// ModelSpec = new ModelSpec() { Name = "model" },
// MetadataField = { "signature_def" }
//});
//Console.WriteLine($"Model Available: {responce.ModelSpec.Name} Ver.{responce.ModelSpec.Version}");
//string imagePath = "C:/WebcamSnapshots/picture.png";
var request = new PredictRequest()
{
ModelSpec = new ModelSpec()
{
Name = "model", SignatureName = "serving_default"
}
};
Stream stream = new FileStream(inputPath, FileMode.Open);
byte[] b;
using (BinaryReader br = new BinaryReader(stream))
{
b = br.ReadBytes((int)stream.Length);
}
string base64String = Convert.ToBase64String(b, 0, b.Length);
//Console.WriteLine(base64String.Substring(0, 50));
request.Inputs.Add("input_image", TensorBuilder.CreateTensorFromString(base64String));
try
{
var predictResponse = client.Predict(request);
var output = predictResponse.Outputs["output_image"];
var image_output0 = output.StringVal[0];
var stri = image_output0.ToString(Encoding.ASCII);
//Console.WriteLine(stri);
for (int i = 0; i < (stri.Length % 4); i++)
{
stri += "=";
}
//byte[] image_output1 = ASCIIEncoding.ASCII.GetBytes(stri);
stri = stri.Replace('_', '/').Replace('-', '+');
byte[] test = Convert.FromBase64String(stri);
//string savePath = "C:/WebcamSnapshots/csharp_prediction.png";
ImageConverter converter = new ImageConverter();
Image image = (Image)converter.ConvertFrom(test);
image.Save(outputPath, ImageFormat.Png);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
channel.ShutdownAsync().Wait();
}
static void Main(string[] args)
{
#region Reading Data
string[] fields = new string[ParametersCount];
float[][] parameters = new float[RowsCount][];
float[] output = new float[RowsCount];
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = new float[ParametersCount];
}
using (StreamReader streamReader = new StreamReader(DataFilePath))
{
using (CsvReader csvReader = new CsvReader(streamReader, new CultureInfo("en-US")))
{
csvReader.Configuration.Delimiter = ",";
csvReader.Read();
for (int i = 0; i < ParametersCount; i++)
{
fields[i] = csvReader.GetField <string>(i + 1);
}
var index = 0;
while (csvReader.Read())
{
for (int i = 0; i < ParametersCount; i++)
{
parameters[index][i] = csvReader.GetField <float>(i + 1);
}
output[index] = csvReader.GetField <float>(ParametersCount + 1);
index++;
}
}
}
#endregion
#region Data standartization
float[] mean = new float[ParametersCount];
float[] deviation = new float[ParametersCount];
for (int i = 0; i < ParametersCount; i++)
{
for (int j = 0; j < RowsCount; j++)
{
mean[i] += parameters[j][i];
deviation[i] += MathF.Pow(parameters[j][i] - mean[i], 2);
}
mean[i] /= RowsCount;
deviation[i] = MathF.Sqrt(deviation[i]) / RowsCount;
}
for (int i = 0; i < RowsCount; i++)
{
for (int j = 0; j < ParametersCount; j++)
{
parameters[i][j] = (parameters[i][j] - mean[j]) / deviation[j];
}
}
#endregion
#region Training
var examples = new List <Example>();
var builder = TensorBuilder.Create();
for (int i = 0; i < RowsCount; i++)
{
var inTensor = builder.OfShape(new Shape(1, 1, 1, ParametersCount));
var outTensor = builder.OfShape(Shape.ForScalar());
inTensor.Storage.Data = parameters[i];
outTensor[0] = output[i];
examples.Add(new Example
{
Input = inTensor,
Output = outTensor
});
}
var network = new NeuralLayeredNetwork(new Shape(1, 1, 1, ParametersCount));
network
.Fully(64)
.Relu()
.Fully(1);
var optimizerFactory = ComponentsFactories.OptimizerFactory;
var metricFactory = ComponentsFactories.MetricFactory;
var trainer = new MiniBatchTrainer(examples, new MiniBatchTrainerSettings
{
BatchSize = 32,
EpochsCount = 50,
LossFunction = new MeanSquaredError(),
Metric = metricFactory.CreateMAE(), //Warning: GPU metrics have not implemented yet
Optimizer = optimizerFactory.CreateAdam(0.001f)
});
trainer.AddEventHandler(new ConsoleLogger());
trainer.TrainModel(network);
#endregion
}
protected BaseLayer()
{
Builder = TensorBuilder.Create();
Output = Builder.Empty();
InputGradient = Builder.Empty();
}
private static List <Example> CreateDataset(string imagesFile, string labelsFile, int batch)
{
var examples = new List <Example>();
DownloadDataset();
using var fs = new FileStream(imagesFile, FileMode.Open);
using var fs2 = new FileStream(labelsFile, FileMode.Open);
using var zip1 = new GZipStream(fs, CompressionMode.Decompress);
using var zip2 = new GZipStream(fs2, CompressionMode.Decompress);
using var reader = new BinaryReader(zip1, Encoding.UTF8);
using var reader2 = new BinaryReader(zip2, Encoding.UTF8);
reader.ReadInt32();
reader.ReadInt32();
reader.ReadInt32();
reader.ReadInt32();
reader2.ReadInt32();
reader2.ReadInt32();
int count = 0;
var labels = new int[batch];
var data = new float[0];
var outTensor = TensorBuilder.Create().OfShape(new Shape(batch, 1, 1, 10));
var tensor = TensorBuilder.Create().OfShape(new Shape(batch, 1, 28, 28));
while (fs.Position != fs.Length)
{
float[] norm = new float[784];
byte[] b = reader.ReadBytes(784);
for (int i = 0; i < b.Length; i++)
{
norm[i] = (float)b[i] / 255;
}
data = data.Concat(norm).ToArray();
int label = reader2.ReadByte();
labels[count] = label;
if (count == batch - 1)
{
for (int i = 0; i < labels.Length; i++)
{
outTensor[i, 0, 0, labels[i]] = 1;
labels[i] = 0;
}
tensor.Storage.Data = data;
examples.Add(new Example
{
Input = tensor,
Output = outTensor
});
tensor = TensorBuilder.Create().OfShape(new Shape(batch, 1, 28, 28));
outTensor = TensorBuilder.Create().OfShape(new Shape(batch, 1, 1, 10));
data = new float[0];
count = 0;
continue;
}
count++;
}
return(examples);
}
