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(); }