/// <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());
var result = buffer.LoadToMemory();
buffer.Close();
return(result);
}
/// <summary>
/// Evaluate disk.
/// </summary>
private void EvalBinary()
{
FileInfo file = FileUtil.CombinePath(new FileInfo(Path.GetTempPath()), "temp.egb");
BasicMLDataSet training = RandomTrainingFactory.Generate(
1000, 10000, 10, 10, -1, 1);
// create the binary file
if (file.Exists)
{
file.Delete();
}
var training2 = new BufferedMLDataSet(file.ToString());
training2.Load(training);
const long stop = (10 * Evaluate.Milis);
int record = 0;
IMLDataPair pair;
var watch = new Stopwatch();
watch.Start();
int iterations = 0;
while (true)
{
iterations++;
pair = training[record++];
if (record >= training.Count)
{
record = 0;
}
if ((iterations & 0xff) == 0 && watch.ElapsedMilliseconds >= stop)
{
break;
}
}
training2.Close();
iterations /= 100000;
_report.Report(Steps, Step3,
"Disk(binary) dataset, result: "
+ Format.FormatInteger(iterations));
if (file.Exists)
{
file.Delete();
}
_binaryScore = iterations;
}
/// <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));
}
}