private static void runExample(string title, string mlConfigPath, CreateCustomModel model = null)
{
var mlConfigFile2 = mlConfigPath;
Console.WriteLine(Environment.NewLine);
Console.WriteLine($"****{title}****");
Console.WriteLine(Environment.NewLine);
var token2 = new CancellationToken();
MachineLearning.Train(mlConfigFile2, trainingProgress, token2, model);
}
PrepareNNData(Dictionary <string, string> dicMParameters, CreateCustomModel customModel, DeviceDescriptor device)
{
try
{
//create factory object
MLFactory f = CreateMLFactory(dicMParameters);
//create learning params
var strLearning = dicMParameters["learning"];
LearningParameters lrData = MLFactory.CreateLearningParameters(strLearning);
//create training param
var strTraining = dicMParameters["training"];
TrainingParameters trData = MLFactory.CreateTrainingParameters(strTraining);
//set model component locations
var dicPath = MLFactory.GetMLConfigComponentPaths(dicMParameters["paths"]);
//
trData.ModelTempLocation = $"{dicMParameters["root"]}\\{dicPath["TempModels"]}";
trData.ModelFinalLocation = $"{dicMParameters["root"]}\\{dicPath["Models"]}";
var strTrainPath = $"{dicMParameters["root"]}\\{dicPath["Training"]}";
var strValidPath = (string.IsNullOrEmpty(dicPath["Validation"]) || dicPath["Validation"] == " ") ? "":
$"{dicMParameters["root"]}\\{dicPath["Validation"]}";
//data normalization in case the option is enabled
//check if network contains Normalization layer and assign value to normalization parameter
if (dicMParameters["network"].Contains("Normalization"))
{
trData.Normalization = new string[] { MLFactory.m_NumFeaturesGroupName }
}
;
//perform data normalization according to the normalization parameter
List <Variable> networkInput = NormalizeInputLayer(trData, f, strTrainPath, strValidPath, device);
//create network parameters
Function nnModel = CreateNetworkModel(dicMParameters["network"], networkInput, f.OutputVariables, customModel, device);
//create minibatch spurce
var mbs = new MinibatchSourceEx(trData.Type, f.StreamConfigurations.ToArray(), strTrainPath, strValidPath, MinibatchSource.InfinitelyRepeat, trData.RandomizeBatch);
//return ml parameters
return(f, lrData, trData, nnModel, mbs);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Creates network models based on ml configuration string or to create custom model in case
/// custom model creation delegate function is defined
/// </summary>
/// <param name="strNetwork"></param>
/// <param name="inputLayer"></param>
/// <param name="outputVars"></param>
/// <param name="customModel"></param>
/// <param name="device"></param>
/// <returns></returns>
private static Function CreateNetworkModel(string strNetwork, List <Variable> inputLayer, List <Variable> outputVars, CreateCustomModel customModel, DeviceDescriptor device)
{
Function nnModel = null;
//for custom implementation should use this string format
if (strNetwork.StartsWith("|Custom") || strNetwork.StartsWith("|Layer:Custom"))
{
//Todo: Implementation of reflection needs to be implemented.
//Two ways of calling customModels
//by reflection when delegate is null mostly from Desktop application
if (customModel == null)
{
throw new Exception("Custom Model is not implemented!");
}
else//when using Console tool when the delegate is not null
{
nnModel = customModel(inputLayer.Union(outputVars).ToList(), device);
}
}
else
{
var Layers = MLFactory.CreateNetworkParameters(strNetwork);
nnModel = MLFactory.CreateNetwrok(Layers, inputLayer, outputVars.First(), device);
}
return(nnModel);
}
/// <summary>
/// Main method to perform training process
/// </summary>
/// <param name="strFilePath">ML configuration file</param>
/// <param name="device">Device of computation (GPU/CPU)</param>
/// <param name="token">Cancellation token for interrupting training process on user request.</param>
/// <param name="trainingProgress">training progress object</param>
/// <param name="customModel">custom neural network model if available</param>
public static TrainResult Train(string mlconfigPath, TrainingProgress trainingProgress, CancellationToken token, CreateCustomModel customModel = null)
{
//LOad ML configuration file
var dicMParameters = MLFactory.LoadMLConfiguration(mlconfigPath);
var fi = new FileInfo(mlconfigPath);
var folderPath = MLFactory.GetMLConfigFolder(fi.FullName);
//add path of model folder
dicMParameters.Add("root", folderPath);
var retVal = MLFactory.PrepareNNData(dicMParameters, customModel, Device);
//create trainer
var tr = new MLTrainer(retVal.f.StreamConfigurations, retVal.f.InputVariables, retVal.f.OutputVariables);
//setup model checkpoint
string modelCheckPoint = null;
if (dicMParameters.ContainsKey("configid"))
{
modelCheckPoint = MLFactory.GetModelCheckPointPath(mlconfigPath, dicMParameters["configid"].Trim(' '));
}
//setup model checkpoint
string historyPath = null;
if (dicMParameters.ContainsKey("configid"))
{
historyPath = MLFactory.GetTrainingHistoryPath(mlconfigPath, dicMParameters["configid"].Trim(' '));
}
//create trainer
var trainer = tr.CreateTrainer(retVal.nnModel, retVal.lrData, retVal.trData, modelCheckPoint, historyPath);
//perform training
var result = tr.Train(trainer, retVal.nnModel, retVal.trData, retVal.mbs, Device, token, trainingProgress, modelCheckPoint, historyPath);
//delete previous best model before change variable values
retVal.trData.LastBestModel = MLFactory.ReplaceBestModel(retVal.trData, mlconfigPath, result.BestModelFile);
//save best model to mlconifg file
var trStrData = retVal.trData.ToString();
var d = new Dictionary <string, string>();
d.Add("training", trStrData);
//save to file
MLFactory.SaveMLConfiguration(mlconfigPath, d);
return(result);
}
