public static void Update(string epoch, Accuracy acc)
{
string[] l = acc.Get();
try
{
Console.SetCursorPosition(0, 0);
Console.Write(new string(' ', Console.BufferWidth));
Console.SetCursorPosition(0, 0);
var time = DateTime.UtcNow - Process.GetCurrentProcess().StartTime.ToUniversalTime();
epoch += " : " + time + " elapsed";
Console.Write(epoch);
}
catch
{
Console.WriteLine(epoch);
}
for (int i = 0; i < l.Count(); i++)
{
try
{
Console.SetCursorPosition(0, i + 1);
Console.Write(new String(' ', Console.BufferWidth));
Console.SetCursorPosition(0, i + 1);
Console.Write(l[i]);
}
catch
{
Console.WriteLine(l[i]);
}
}
}
public static void RunSimple()
{
var mnist = TestUtils.GetMNIST(); //Get the MNIST dataset, it will download if not found
var batch_size = 100; //Set training batch size
var train_data = new NDArrayIter(mnist["train_data"], mnist["train_label"], batch_size);
var val_data = new NDArrayIter(mnist["test_data"], mnist["test_label"], batch_size);
// Define simple network with dense layers
var net = new Sequential();
net.Add(new Dense(128, ActivationType.Relu));
net.Add(new Dense(64, ActivationType.Relu));
net.Add(new Dense(10));
//Set context, multi-gpu supported
var gpus = TestUtils.ListGpus();
var ctx = gpus.Count > 0 ? gpus.Select(x => Context.Gpu(x)).ToArray() : new[] { Context.Cpu(0) };
//Initialize the weights
net.Initialize(new Xavier(magnitude: 2.24f), ctx);
//Create the trainer with all the network parameters and set the optimizer
var trainer = new Trainer(net.CollectParams(), new Adam());
var epoch = 10;
var metric = new Accuracy(); //Use Accuracy as the evaluation metric.
var softmax_cross_entropy_loss = new SoftmaxCrossEntropyLoss();
float lossVal = 0; //For loss calculation
for (var iter = 0; iter < epoch; iter++)
{
var tic = DateTime.Now;
// Reset the train data iterator.
train_data.Reset();
lossVal = 0;
// Loop over the train data iterator.
while (!train_data.End())
{
var batch = train_data.Next();
// Splits train data into multiple slices along batch_axis
// and copy each slice into a context.
var data = Utils.SplitAndLoad(batch.Data[0], ctx, batch_axis: 0);
// Splits train labels into multiple slices along batch_axis
// and copy each slice into a context.
var label = Utils.SplitAndLoad(batch.Label[0], ctx, batch_axis: 0);
var outputs = new NDArrayList();
// Inside training scope
NDArray loss = null;
for (int i = 0; i < data.Length; i++)
{
using (var ag = Autograd.Record())
{
var x = data[i];
var y = label[i];
var z = net.Call(x);
// Computes softmax cross entropy loss.
loss = softmax_cross_entropy_loss.Call(z, y);
outputs.Add(z);
}
// Backpropagate the error for one iteration.
loss.Backward();
lossVal += loss.Mean();
}
// Updates internal evaluation
metric.Update(label, outputs.ToArray());
// Make one step of parameter update. Trainer needs to know the
// batch size of data to normalize the gradient by 1/batch_size.
trainer.Step(batch.Data[0].Shape[0]);
}
var toc = DateTime.Now;
// Gets the evaluation result.
var(name, acc) = metric.Get();
// Reset evaluation result to initial state.
metric.Reset();
Console.Write($"Loss: {lossVal} ");
Console.WriteLine($"Training acc at epoch {iter}: {name}={(acc * 100).ToString("0.##")}%, Duration: {(toc - tic).TotalSeconds.ToString("0.#")}s");
}
}
public static void RunConv()
{
var mnist = TestUtils.GetMNIST();
var batch_size = 128;
var train_data = new NDArrayIter(mnist["train_data"], mnist["train_label"], batch_size, true);
var val_data = new NDArrayIter(mnist["test_data"], mnist["test_label"], batch_size);
var net = new Sequential();
net.Add(new Conv2D(20, kernel_size: (5, 5), activation: ActivationType.Tanh));
net.Add(new MaxPool2D(pool_size: (2, 2), strides: (2, 2)));
net.Add(new Conv2D(50, kernel_size: (5, 5), activation: ActivationType.Tanh));
net.Add(new MaxPool2D(pool_size: (2, 2), strides: (2, 2)));
net.Add(new Flatten());
net.Add(new Dense(500, ActivationType.Tanh));
net.Add(new Dense(10));
var gpus = TestUtils.ListGpus();
var ctx = gpus.Count > 0 ? gpus.Select(x => Context.Gpu(x)).ToArray() : new[] { Context.Cpu(0) };
net.Initialize(new Xavier(magnitude: 2.24f), ctx);
var trainer = new Trainer(net.CollectParams(), new SGD(learning_rate: 0.02f));
var epoch = 10;
var metric = new Accuracy();
var softmax_cross_entropy_loss = new SoftmaxCELoss();
float lossVal = 0;
for (var iter = 0; iter < epoch; iter++)
{
var tic = DateTime.Now;
train_data.Reset();
lossVal = 0;
while (!train_data.End())
{
var batch = train_data.Next();
var data = Utils.SplitAndLoad(batch.Data[0], ctx, batch_axis: 0);
var label = Utils.SplitAndLoad(batch.Label[0], ctx, batch_axis: 0);
var outputs = new NDArrayList();
using (var ag = Autograd.Record())
{
for (var i = 0; i < data.Length; i++)
{
var x = data[i];
var y = label[i];
var z = net.Call(x);
NDArray loss = softmax_cross_entropy_loss.Call(z, y);
loss.Backward();
lossVal += loss.Mean();
outputs.Add(z);
}
//outputs = Enumerable.Zip(data, label, (x, y) =>
//{
// var z = net.Call(x);
// NDArray loss = softmax_cross_entropy_loss.Call(z, y);
// loss.Backward();
// lossVal += loss.Mean();
// return z;
//}).ToList();
}
metric.Update(label, outputs.ToArray());
trainer.Step(batch.Data[0].Shape[0]);
}
var toc = DateTime.Now;
var(name, acc) = metric.Get();
metric.Reset();
Console.Write($"Loss: {lossVal} ");
Console.WriteLine($"Training acc at epoch {iter}: {name}={(acc * 100).ToString("0.##")}%, Duration: {(toc - tic).TotalSeconds.ToString("0.#")}s");
}
}
private static void Main()
{
const int imageSize = 28;
int[] layers = { 128, 64, 10 };
const int batchSize = 100;
const int maxEpoch = 10;
const float learningRate = 0.1f;
const float weightDecay = 1e-2f;
var trainIter = new MXDataIter("MNISTIter")
.SetParam("image", "./mnist_data/train-images-idx3-ubyte")
.SetParam("label", "./mnist_data/train-labels-idx1-ubyte")
.SetParam("batch_size", batchSize)
.SetParam("flat", 1)
.CreateDataIter();
var valIter = new MXDataIter("MNISTIter")
.SetParam("image", "./mnist_data/t10k-images-idx3-ubyte")
.SetParam("label", "./mnist_data/t10k-labels-idx1-ubyte")
.SetParam("batch_size", batchSize)
.SetParam("flat", 1)
.CreateDataIter();
var net = Mlp(layers);
Context ctx = Context.Cpu(); // Use CPU for training
var args = new SortedDictionary <string, NDArray>();
args["X"] = new NDArray(new Shape(batchSize, imageSize * imageSize), ctx);
args["label"] = new NDArray(new Shape(batchSize), ctx);
// Let MXNet infer shapes other parameters such as weights
net.InferArgsMap(ctx, args, args);
// Initialize all parameters with uniform distribution U(-0.01, 0.01)
var initializer = new Uniform(0.01f);
foreach (var arg in args)
{
// arg.first is parameter name, and arg.second is the value
initializer.Operator(arg.Key, arg.Value);
}
// Create sgd optimizer
var opt = OptimizerRegistry.Find("sgd");
opt.SetParam("rescale_grad", 1.0 / batchSize)
.SetParam("lr", learningRate)
.SetParam("wd", weightDecay);
// Create executor by binding parameters to the model
using (var exec = net.SimpleBind(ctx, args))
{
var argNames = net.ListArguments();
// Start training
var sw = new Stopwatch();
for (var iter = 0; iter < maxEpoch; ++iter)
{
var samples = 0;
trainIter.Reset();
sw.Restart();
while (trainIter.Next())
{
samples += batchSize;
var dataBatch = trainIter.GetDataBatch();
// Set data and label
dataBatch.Data.CopyTo(args["X"]);
dataBatch.Label.CopyTo(args["label"]);
// Compute gradients
exec.Forward(true);
exec.Backward();
// Update parameters
for (var i = 0; i < argNames.Count; ++i)
{
if (argNames[i] == "X" || argNames[i] == "label")
{
continue;
}
opt.Update(i, exec.ArgmentArrays[i], exec.GradientArrays[i]);
}
}
sw.Stop();
var accuracy = new Accuracy();
valIter.Reset();
while (valIter.Next())
{
var dataBatch = valIter.GetDataBatch();
dataBatch.Data.CopyTo(args["X"]);
dataBatch.Label.CopyTo(args["label"]);
// Forward pass is enough as no gradient is needed when evaluating
exec.Forward(false);
accuracy.Update(dataBatch.Label, exec.Outputs[0]);
}
var duration = sw.ElapsedMilliseconds / 1000.0;
Logging.LG($"Epoch: {iter} {samples / duration} samples/sec Accuracy: {accuracy.Get()}");
}
}
MXNet.MXNotifyShutdown();
}
public static void Run()
{
//Logistic Regression is one of the first models newcomers to Deep Learning are implementing.
//The focus of this tutorial is to show how to do logistic regression using Gluon API.
var ctx = mx.Cpu();
int train_data_size = 1000;
int val_data_size = 100;
var(train_x, train_ground_truth_class) = GetRandomState(train_data_size, ctx);
var train_dataset = new ArrayDataset((train_x, train_ground_truth_class));
train_dataloader = new DataLoader(train_dataset, batch_size: batch_size, shuffle: true);
var(val_x, val_ground_truth_class) = GetRandomState(val_data_size, ctx);
var val_dataset = new ArrayDataset((val_x, val_ground_truth_class));
val_dataloader = new DataLoader(val_dataset, batch_size: batch_size, shuffle: true);
net = new HybridSequential();
net.Add(new Dense(units: 10, activation: ActivationType.Relu));
net.Add(new Dense(units: 10, activation: ActivationType.Relu));
net.Add(new Dense(units: 10, activation: ActivationType.Relu));
net.Add(new Dense(units: 1));
net.Initialize(new Xavier());
loss = new SigmoidBinaryCrossEntropyLoss();
trainer = new Trainer(net.CollectParams(), new SGD(learning_rate: 0.1f));
accuracy = new Accuracy();
f1 = new F1();
int epochs = 10;
float threshold = 0.5f;
foreach (var e in Enumerable.Range(0, epochs))
{
var avg_train_loss = TrainModel() / train_data_size;
var avg_val_loss = ValidateModel(threshold) / val_data_size;
Console.WriteLine($"Epoch: {e}, Training loss: {avg_train_loss}, Validation loss: {avg_val_loss}, Validation accuracy: {accuracy.Get().Item2}, F1 score: {f1.Get().Item2}");
}
}
private static void Main()
{
/*basic config*/
const int batchSize = 256;
const int maxEpo = 100;
const float learningRate = 1e-4f;
const float weightDecay = 1e-4f;
/*context and net symbol*/
var ctx = Context.Gpu();
var net = AlexnetSymbol(2);
/*args_map and aux_map is used for parameters' saving*/
var argsMap = new Dictionary <string, NDArray>();
var auxMap = new Dictionary <string, NDArray>();
/*we should tell mxnet the shape of data and label*/
argsMap["data"] = new NDArray(new Shape(batchSize, 3, 256, 256), ctx);
argsMap["label"] = new NDArray(new Shape(batchSize), ctx);
/*with data and label, executor can be generated varmatically*/
using (var exec = net.SimpleBind(ctx, argsMap))
{
var argNames = net.ListArguments();
var auxiliaryDictionary = exec.AuxiliaryDictionary();
var argmentDictionary = exec.ArgmentDictionary();
/*if fine tune from some pre-trained model, we should load the parameters*/
// NDArray.Load("./model/alex_params_3", nullptr, &args_map);
/*else, we should use initializer Xavier to init the params*/
var xavier = new Xavier(RandType.Gaussian, FactorType.In, 2.34f);
foreach (var arg in argmentDictionary)
{
/*be careful here, the arg's name must has some specific ends or starts for
* initializer to call*/
xavier.Operator(arg.Key, arg.Value);
}
/*print out to check the shape of the net*/
foreach (var s in net.ListArguments())
{
Logging.LG(s);
var sb = new StringBuilder();
var k = argmentDictionary[s].GetShape();
foreach (var i in k)
{
sb.Append($"{i} ");
}
Logging.LG(sb.ToString());
}
/*these binary files should be generated using im2rc tools, which can be found
* in mxnet/bin*/
var trainIter = new MXDataIter("ImageRecordIter")
.SetParam("path_imglist", "./data/train.lst")
.SetParam("path_imgrec", "./data/train.rec")
.SetParam("data_shape", new Shape(3, 256, 256))
.SetParam("batch_size", batchSize)
.SetParam("shuffle", 1)
.CreateDataIter();
var valIter = new MXDataIter("ImageRecordIter")
.SetParam("path_imglist", "./data/val.lst")
.SetParam("path_imgrec", "./data/val.rec")
.SetParam("data_shape", new Shape(3, 256, 256))
.SetParam("batch_size", batchSize)
.CreateDataIter();
var opt = OptimizerRegistry.Find("ccsgd");
opt.SetParam("momentum", 0.9)
.SetParam("rescale_grad", 1.0 / batchSize)
.SetParam("clip_gradient", 10)
.SetParam("lr", learningRate)
.SetParam("wd", weightDecay);
var accuracyTrain = new Accuracy();
var accuracyVal = new Accuracy();
var loglossVal = new LogLoss();
for (var iter = 0; iter < maxEpo; ++iter)
{
Logging.LG($"Train Epoch: {iter}");
/*reset the metric every epoch*/
accuracyTrain.Reset();
/*reset the data iter every epoch*/
trainIter.Reset();
while (trainIter.Next())
{
var batch = trainIter.GetDataBatch();
Logging.LG($"{trainIter.GetDataBatch().Index.Length}");
/*use copyto to feed new data and label to the executor*/
batch.Data.CopyTo(argmentDictionary["data"]);
batch.Label.CopyTo(argmentDictionary["label"]);
exec.Forward(true);
exec.Backward();
for (var i = 0; i < argNames.Count; ++i)
{
if (argNames[i] == "data" || argNames[i] == "label")
{
continue;
}
opt.Update(i, exec.ArgmentArrays[i], exec.GradientArrays[i]);
}
NDArray.WaitAll();
accuracyTrain.Update(batch.Label, exec.Outputs[0]);
}
Logging.LG($"ITER: {iter} Train Accuracy: {accuracyTrain.Get()}");
Logging.LG($"Val Epoch: {iter}");
accuracyVal.Reset();
valIter.Reset();
loglossVal.Reset();
while (valIter.Next())
{
var batch = valIter.GetDataBatch();
Logging.LG($"{valIter.GetDataBatch().Index.Length}");
batch.Data.CopyTo(argmentDictionary["data"]);
batch.Label.CopyTo(argmentDictionary["label"]);
exec.Forward(false);
NDArray.WaitAll();
accuracyVal.Update(batch.Label, exec.Outputs[0]);
loglossVal.Update(batch.Label, exec.Outputs[0]);
}
Logging.LG($"ITER: {iter} Val Accuracy: {accuracyVal.Get()}");
Logging.LG($"ITER: {iter} Val LogLoss: {loglossVal.Get()}");
/*save the parameters*/
var savePathParam = $"./model/alex_param_{iter}";
var saveArgs = argmentDictionary;
/*we do not want to save the data and label*/
if (saveArgs.ContainsKey("data"))
{
saveArgs.Remove("data");
}
if (saveArgs.ContainsKey("label"))
{
saveArgs.Remove("label");
}
/*the alexnet does not get any aux array, so we do not need to save
* aux_map*/
Logging.LG($"ITER: {iter} Saving to...{savePathParam}");
NDArray.Save(savePathParam, saveArgs);
}
/*don't foget to release the executor*/
}
MXNet.MXNotifyShutdown();
}
private static void Main()
{
/*setup basic configs*/
const int W = 28;
const int H = 28;
const int batchSize = 128;
const int maxEpoch = 100;
const float learningRate = 1e-4f;
const float weightDecay = 1e-4f;
var contest = Context.Gpu();
var lenet = LenetSymbol();
var argsMap = new SortedDictionary <string, NDArray>();
argsMap["data"] = new NDArray(new Shape(batchSize, 1, W, H), contest);
argsMap["data_label"] = new NDArray(new Shape(batchSize), contest);
lenet.InferArgsMap(contest, argsMap, argsMap);
argsMap["fc1_w"] = new NDArray(new Shape(500, 4 * 4 * 50), contest);
NDArray.SampleGaussian(0, 1, argsMap["fc1_w"]);
argsMap["fc2_b"] = new NDArray(new Shape(10), contest);
argsMap["fc2_b"].Set(0);
var trainIter = new MXDataIter("MNISTIter")
.SetParam("image", "./mnist_data/train-images-idx3-ubyte")
.SetParam("label", "./mnist_data/train-labels-idx1-ubyte")
.SetParam("batch_size", batchSize)
.SetParam("shuffle", 1)
.SetParam("flat", 0)
.CreateDataIter();
var valIter = new MXDataIter("MNISTIter")
.SetParam("image", "./mnist_data/t10k-images-idx3-ubyte")
.SetParam("label", "./mnist_data/t10k-labels-idx1-ubyte")
.CreateDataIter();
var opt = OptimizerRegistry.Find("ccsgd");
opt.SetParam("momentum", 0.9)
.SetParam("rescale_grad", 1.0)
.SetParam("clip_gradient", 10)
.SetParam("lr", learningRate)
.SetParam("wd", weightDecay);
using (var exec = lenet.SimpleBind(contest, argsMap))
{
var argNames = lenet.ListArguments();
// Create metrics
var trainAccuracy = new Accuracy();
var valAccuracy = new Accuracy();
var sw = new Stopwatch();
for (var iter = 0; iter < maxEpoch; ++iter)
{
var samples = 0;
trainIter.Reset();
trainAccuracy.Reset();
sw.Restart();
while (trainIter.Next())
{
samples += batchSize;
var dataBatch = trainIter.GetDataBatch();
dataBatch.Data.CopyTo(argsMap["data"]);
dataBatch.Label.CopyTo(argsMap["data_label"]);
NDArray.WaitAll();
// Compute gradients
exec.Forward(true);
exec.Backward();
// Update parameters
for (var i = 0; i < argNames.Count; ++i)
{
if (argNames[i] == "data" || argNames[i] == "data_label")
{
continue;
}
opt.Update(i, exec.ArgmentArrays[i], exec.GradientArrays[i]);
}
// Update metric
trainAccuracy.Update(dataBatch.Label, exec.Outputs[0]);
}
// one epoch of training is finished
sw.Stop();
var duration = sw.ElapsedMilliseconds / 1000.0;
Logging.LG($"Epoch[{iter}] {samples / duration} samples/sec Train-Accuracy={trainAccuracy.Get()}");
valIter.Reset();
valAccuracy.Reset();
var accuracy = new Accuracy();
valIter.Reset();
while (valIter.Next())
{
var dataBatch = valIter.GetDataBatch();
dataBatch.Data.CopyTo(argsMap["data"]);
dataBatch.Label.CopyTo(argsMap["data_label"]);
NDArray.WaitAll();
// Only forward pass is enough as no gradient is needed when evaluating
exec.Forward(false);
NDArray.WaitAll();
accuracy.Update(dataBatch.Label, exec.Outputs[0]);
valAccuracy.Update(dataBatch.Label, exec.Outputs[0]);
}
Logging.LG($"Epoch[{iter}] Val-Accuracy={valAccuracy.Get()}");
}
}
MXNet.MXNotifyShutdown();
}
private static void Main(string[] args)
{
//var minScore = float.Parse(args[0], NumberStyles.Float, null);
var minScore = 0.9f;
const int imageSize = 28;
var layers = new[] { 128, 64, 10 };
const int batchSize = 100;
const int maxEpoch = 10;
const float learningRate = 0.1f;
const float weightDecay = 1e-2f;
var trainIter = new MXDataIter("MNISTIter")
.SetParam("image", "./mnist_data/train-images-idx3-ubyte")
.SetParam("label", "./mnist_data/train-labels-idx1-ubyte")
.SetParam("batch_size", batchSize)
.SetParam("flat", 1)
.CreateDataIter();
var valIter = new MXDataIter("MNISTIter")
.SetParam("image", "./mnist_data/t10k-images-idx3-ubyte")
.SetParam("label", "./mnist_data/t10k-labels-idx1-ubyte")
.SetParam("batch_size", batchSize)
.SetParam("flat", 1)
.CreateDataIter();
var net = Mlp(layers);
var ctx = Context.Cpu(); // Use GPU for training
var dictionary = new Dictionary <string, NDArray>();
dictionary["X"] = new NDArray(new Shape(batchSize, imageSize * imageSize), ctx);
dictionary["label"] = new NDArray(new Shape(batchSize), ctx);
// Let MXNet infer shapes of other parameters such as weights
net.InferArgsMap(ctx, dictionary, dictionary);
// Initialize all parameters with uniform distribution U(-0.01, 0.01)
var initializer = new Uniform(0.01f);
foreach (var arg in dictionary)
{
// arg.first is parameter name, and arg.second is the value
initializer.Operator(arg.Key, arg.Value);
}
// Create sgd optimizer
var opt = OptimizerRegistry.Find("sgd");
opt.SetParam("rescale_grad", 1.0 / batchSize)
.SetParam("lr", learningRate)
.SetParam("wd", weightDecay);
var lrSch = new UniquePtr <LRScheduler>(new FactorScheduler(5000, 0.1f));
opt.SetLearningRateScheduler(lrSch);
// Create executor by binding parameters to the model
using (var exec = net.SimpleBind(ctx, dictionary))
{
var argNames = net.ListArguments();
float score = 0;
// Start training
var sw = new Stopwatch();
for (var iter = 0; iter < maxEpoch; ++iter)
{
var samples = 0;
trainIter.Reset();
sw.Restart();
while (trainIter.Next())
{
samples += batchSize;
var dataBatch = trainIter.GetDataBatch();
// Data provided by DataIter are stored in memory, should be copied to GPU first.
dataBatch.Data.CopyTo(dictionary["X"]);
dataBatch.Label.CopyTo(dictionary["label"]);
// CopyTo is imperative, need to wait for it to complete.
NDArray.WaitAll();
// Compute gradients
exec.Forward(true);
exec.Backward();
// Update parameters
for (var i = 0; i < argNames.Count; ++i)
{
if (argNames[i] == "X" || argNames[i] == "label")
{
continue;
}
var weight = exec.ArgmentArrays[i];
var grad = exec.GradientArrays[i];
opt.Update(i, weight, grad);
}
}
sw.Stop();
var acc = new Accuracy();
valIter.Reset();
while (valIter.Next())
{
var dataBatch = valIter.GetDataBatch();
dataBatch.Data.CopyTo(dictionary["X"]);
dataBatch.Label.CopyTo(dictionary["label"]);
NDArray.WaitAll();
// Only forward pass is enough as no gradient is needed when evaluating
exec.Forward(false);
acc.Update(dataBatch.Label, exec.Outputs[0]);
}
var duration = sw.ElapsedMilliseconds / 1000.0;
var message = $"Epoch: {iter} {samples / duration} samples/sec Accuracy: {acc.Get()}";
Logging.LG(message);
score = acc.Get();
}
MXNet.MXNotifyShutdown();
var ret = score >= minScore ? 0 : 1;
Console.WriteLine($"{ret}");
}
}
private static void Main()
{
const uint batchSize = 50;
const uint maxEpoch = 100;
const float learningRate = 1e-4f;
const float weightDecay = 1e-4f;
var googlenet = GoogleNetSymbol(101 + 1); // +1 is BACKGROUND_Google
var argsMap = new Dictionary <string, NDArray>();
var auxMap = new Dictionary <string, NDArray>();
// change device type if you want to use GPU
var context = Context.Cpu();
argsMap["data"] = new NDArray(new Shape(batchSize, 3, 256, 256), context);
argsMap["data_label"] = new NDArray(new Shape(batchSize), context);
googlenet.InferArgsMap(Context.Cpu(), argsMap, argsMap);
var trainIter = new MXDataIter("ImageRecordIter")
.SetParam("path_imglist", "train.lst")
.SetParam("path_imgrec", "train.rec")
.SetParam("data_shape", new Shape(3, 256, 256))
.SetParam("batch_size", batchSize)
.SetParam("shuffle", 1)
.CreateDataIter();
var valIter = new MXDataIter("ImageRecordIter")
.SetParam("path_imglist", "val.lst")
.SetParam("path_imgrec", "val.rec")
.SetParam("data_shape", new Shape(3, 256, 256))
.SetParam("batch_size", batchSize)
.CreateDataIter();
var opt = OptimizerRegistry.Find("ccsgd");
opt.SetParam("momentum", 0.9)
.SetParam("rescale_grad", 1.0 / batchSize)
.SetParam("clip_gradient", 10)
.SetParam("lr", learningRate)
.SetParam("wd", weightDecay);
using (var exec = googlenet.SimpleBind(Context.Cpu(), argsMap))
{
var argNames = googlenet.ListArguments();
for (var iter = 0; iter < maxEpoch; ++iter)
{
Logging.LG($"Epoch: {iter}");
trainIter.Reset();
while (trainIter.Next())
{
var dataBatch = trainIter.GetDataBatch();
dataBatch.Data.CopyTo(argsMap["data"]);
dataBatch.Label.CopyTo(argsMap["data_label"]);
NDArray.WaitAll();
exec.Forward(true);
exec.Backward();
for (var i = 0; i < argNames.Count; ++i)
{
if (argNames[i] == "data" || argNames[i] == "data_label")
{
continue;
}
var weight = exec.ArgmentArrays[i];
var grad = exec.GradientArrays[i];
opt.Update(i, weight, grad);
}
}
var acu = new Accuracy();
valIter.Reset();
while (valIter.Next())
{
var dataBatch = valIter.GetDataBatch();
dataBatch.Data.CopyTo(argsMap["data"]);
dataBatch.Label.CopyTo(argsMap["data_label"]);
NDArray.WaitAll();
exec.Forward(false);
NDArray.WaitAll();
acu.Update(dataBatch.Label, exec.Outputs[0]);
}
Logging.LG($"Accuracy: {acu.Get()}");
}
}
MXNet.MXNotifyShutdown();
}
