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();
}
private static TrainingSessionResult TrainNetworkCore(
[NotNull] INeuralNetwork network,
[NotNull] ITrainingDataset dataset,
[NotNull] ITrainingAlgorithmInfo algorithm,
int epochs, float dropout,
[CanBeNull] IProgress <BatchProgress> batchProgress,
[CanBeNull] IProgress <TrainingProgressEventArgs> trainingProgress,
[CanBeNull] IValidationDataset validationDataset,
[CanBeNull] ITestDataset testDataset,
CancellationToken token)
{
// Preliminary checks
if (epochs < 1)
{
throw new ArgumentOutOfRangeException(nameof(epochs), "The number of epochs must at be at least equal to 1");
}
if (dropout < 0 || dropout >= 1)
{
throw new ArgumentOutOfRangeException(nameof(dropout), "The dropout probability is invalid");
}
// Start the training
return(NetworkTrainer.TrainNetwork(
network as SequentialNetwork ?? throw new ArgumentException("The input network instance isn't valid", nameof(network)),
dataset as BatchesCollection ?? throw new ArgumentException("The input dataset instance isn't valid", nameof(dataset)),
epochs, dropout, algorithm, batchProgress, trainingProgress,
validationDataset as ValidationDataset,
testDataset as TestDataset,
token));
}
public static TrainingSessionResult TrainNetwork(
[NotNull] INeuralNetwork network,
[NotNull] ITrainingDataset dataset,
[NotNull] ITrainingAlgorithmInfo algorithm,
int epochs, float dropout = 0,
[CanBeNull] Action <BatchProgress> batchCallback = null,
[CanBeNull] Action <TrainingProgressEventArgs> trainingCallback = null,
[CanBeNull] IValidationDataset validationDataset = null,
[CanBeNull] ITestDataset testDataset = null,
CancellationToken token = default)
{
return(TrainNetworkCore(network, dataset, algorithm, epochs, dropout, batchCallback.AsIProgress(), trainingCallback.AsIProgress(), validationDataset, testDataset, token));
}
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();
}
private static TrainingSessionResult TrainNetworkCore(
[NotNull] INeuralNetwork network,
[NotNull] ITrainingDataset dataset,
[NotNull] ITrainingAlgorithmInfo algorithm,
int epochs, float dropout,
[CanBeNull] IProgress <BatchProgress> batchProgress,
[CanBeNull] IProgress <TrainingProgressEventArgs> trainingProgress,
[CanBeNull] IValidationDataset validationDataset,
[CanBeNull] ITestDataset testDataset,
CancellationToken token)
{
// Preliminary checks
if (epochs < 1)
{
throw new ArgumentOutOfRangeException(nameof(epochs), "The number of epochs must at be at least equal to 1");
}
if (dropout < 0 || dropout >= 1)
{
throw new ArgumentOutOfRangeException(nameof(dropout), "The dropout probability is invalid");
}
if (validationDataset != null && (validationDataset.InputFeatures != dataset.InputFeatures || validationDataset.OutputFeatures != dataset.OutputFeatures))
{
throw new ArgumentException("The validation dataset doesn't match the training dataset", nameof(validationDataset));
}
if (testDataset != null && (testDataset.InputFeatures != dataset.InputFeatures || testDataset.OutputFeatures != dataset.OutputFeatures))
{
throw new ArgumentException("The test dataset doesn't match the training dataset", nameof(testDataset));
}
if (dataset.InputFeatures != network.InputInfo.Size || dataset.OutputFeatures != network.OutputInfo.Size)
{
throw new ArgumentException("The input dataset doesn't match the number of input and output features for the current network", nameof(dataset));
}
// Start the training
TrainingInProgress = TrainingInProgress
? throw new InvalidOperationException("Can't train two networks at the same time") // This would cause problems with cuDNN
: true;
TrainingSessionResult result = NetworkTrainer.TrainNetwork(
network as NeuralNetworkBase ?? throw new ArgumentException("The input network instance isn't valid", nameof(network)),
dataset as BatchesCollection ?? throw new ArgumentException("The input dataset instance isn't valid", nameof(dataset)),
epochs, dropout, algorithm, batchProgress, trainingProgress,
validationDataset as ValidationDataset,
testDataset as TestDataset,
token);
TrainingInProgress = false;
return(result);
}
public static Task <TrainingSessionResult> TrainNetworkAsync(
[NotNull] INeuralNetwork network,
[NotNull] ITrainingDataset dataset,
[NotNull] ITrainingAlgorithmInfo algorithm,
int epochs, float dropout = 0,
[CanBeNull] Action <BatchProgress> batchCallback = null,
[CanBeNull] Action <TrainingProgressEventArgs> trainingCallback = null,
[CanBeNull] IValidationDataset validationDataset = null,
[CanBeNull] ITestDataset testDataset = null,
CancellationToken token = default)
{
IProgress <BatchProgress> batchProgress = batchCallback.AsIProgress();
IProgress <TrainingProgressEventArgs> trainingProgress = trainingCallback.AsIProgress(); // Capture the synchronization contexts
return(Task.Run(() => TrainNetworkCore(network, dataset, algorithm, epochs, dropout, batchProgress, trainingProgress, validationDataset, testDataset, token), token));
}
public TrainingSessionResult Train(ITrainingDataset data, ITestDataset testData)
{
INeuralNetwork net = NetworkManager.NewSequential(TensorInfo.Linear(SubHistory.SubHistoryLength),
NetworkLayers.FullyConnected(SubHistory.SubHistoryLength, ActivationType.LeCunTanh),
NetworkLayers.Softmax(IMoveEngine.Payoffs));
TrainingSessionResult result = NetworkManager.TrainNetwork(net,
data,
TrainingAlgorithms.AdaDelta(),
100, 0.0f,
null,
testDataset: testData);
if (result.StopReason == TrainingStopReason.EpochsCompleted)
{
_storage.Save(net);
_network = net;
}
return(result);
}
public DatasetNeuralNetworkNet(ITrainingDataset training, ITestDataset test)
{
this.Training = training;
this.Test = test;
}
