public void Train(bool useGui)
{
// load, or create the neural network
BasicNetwork network;
if (!_config.TrainedNetworkFile.Exists)
{
throw new EncogError(@"Can't find neural network file, please generate data");
}
network = (BasicNetwork)EncogDirectoryPersistence.LoadObject(_config.TrainedNetworkFile);
// convert training data
Console.WriteLine(@"Converting training file to binary");
EncogUtility.ConvertCSV2Binary(
_config.NormalizedDataFile.ToString(),
CSVFormat.English,
_config.BinaryFile.ToString(),
network.InputCount,
network.OutputCount,
false, false);
var trainingSet = new BufferedMLDataSet(
_config.BinaryFile.ToString());
if (useGui)
{
EncogUtility.TrainDialog(network, trainingSet);
}
else
{
EncogUtility.TrainConsole(network, trainingSet,
_config.TrainingMinutes);
}
Console.WriteLine(@"Training complete, saving network...");
EncogDirectoryPersistence.SaveObject(_config.TrainedNetworkFile, network);
}
/// <summary>
/// Called to generate the training file.
/// </summary>
public void Generate()
{
string[] list = Directory.GetFiles(_path);
_trainingFile.Delete();
var output = new BufferedMLDataSet(_trainingFile.ToString());
output.BeginLoad(Config.InputWindow, 1);
foreach (string file in list)
{
var fn = new FileInfo(file);
if (fn.Name.StartsWith("collected") && fn.Name.EndsWith(".csv"))
{
ProcessFile(file, output);
}
}
output.EndLoad();
output.Close();
}
/// <summary>
/// Perform an individual job unit, which is a single network to train and
/// evaluate.
/// </summary>
///
/// <param name="context">Contains information about the job unit.</param>
public override sealed void PerformJobUnit(JobUnitContext context)
{
var network = (BasicNetwork)context.JobUnit;
BufferedMLDataSet buffer = null;
IMLDataSet useTraining = _training;
if (_training is BufferedMLDataSet)
{
buffer = (BufferedMLDataSet)_training;
useTraining = (buffer.OpenAdditional());
}
// train the neural network
double error = Double.PositiveInfinity;
for (int z = 0; z < _weightTries; z++)
{
network.Reset();
Propagation train = new ResilientPropagation(network,
useTraining);
var strat = new StopTrainingStrategy(0.001d,
5);
train.AddStrategy(strat);
train.ThreadCount = 1; // force single thread mode
for (int i = 0;
(i < _iterations) && !ShouldStop &&
!strat.ShouldStop();
i++)
{
train.Iteration();
}
error = Math.Min(error, train.Error);
}
if (buffer != null)
{
buffer.Close();
}
if (!ShouldStop)
{
// update min and max
_high = Math.Max(_high, error);
_low = Math.Min(_low, error);
if (_hidden1Size > 0)
{
int networkHidden1Count;
int networkHidden2Count;
if (network.LayerCount > 3)
{
networkHidden2Count = network.GetLayerNeuronCount(2);
networkHidden1Count = network.GetLayerNeuronCount(1);
}
else
{
networkHidden2Count = 0;
networkHidden1Count = network.GetLayerNeuronCount(1);
}
int row, col;
if (_hidden2Size == 0)
{
row = networkHidden1Count - _hidden[0].Min;
col = 0;
}
else
{
row = networkHidden1Count - _hidden[0].Min;
col = networkHidden2Count - _hidden[1].Min;
}
if ((row < 0) || (col < 0))
{
Console.Out.WriteLine("STOP");
}
_results[row][col] = error;
}
// report status
_currentTry++;
UpdateBest(network, error);
ReportStatus(
context,
"Current: "
+ NetworkToString(network)
+ "; Best: "
+ NetworkToString(_bestNetwork));
}
}
/// <summary>
/// Load an EGB file to memory.
/// </summary>
/// <param name="filename">The file to load.</param>
/// <returns>A memory data set.</returns>
public static IMLDataSet LoadEGB2Memory(FileInfo filename)
{
var buffer = new BufferedMLDataSet(filename.ToString());
return(buffer.LoadToMemory());
}
/// <summary>
/// Save the training set to an EGB file.
/// </summary>
/// <param name="egbFile">The EGB file to save to.</param>
/// <param name="data">The training data to save.</param>
public static void SaveEGB(FileInfo egbFile, IMLDataSet data)
{
var binary = new BufferedMLDataSet(egbFile.ToString());
binary.Load(data);
data.Close();
}
