/// <summary>
/// Evaluate one network.
/// </summary>
/// <param name="context">The job context.</param>
public override void PerformJobUnit(JobUnitContext context)
{
BasicNetwork network = (BasicNetwork)context.JobUnit;
// train the neural network
ITrain train = new ResilientPropagation(network, this.training);
for (int i = 0; i < this.iterations; i++)
{
train.Iteration();
}
double error = train.Error;
if ((error < this.bestResult) || (this.bestNetwork == null))
{
#if logging
if (this.logger.IsDebugEnabled)
{
this.logger.Debug("Prune found new best network: error="
+ error + ", network=" + network);
}
#endif
this.bestNetwork = network;
this.bestResult = error;
}
this.currentTry++;
this.ReportStatus(context,
"Current: " + PruneIncremental.NetworkToString(network)
+ ", Best: "
+ PruneIncremental.NetworkToString(this.bestNetwork));
}
/// <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>
/// Construct a job unit worker to execute the specified job.
/// </summary>
/// <param name="context">The context of the job to execute.</param>
public JobUnitWorker(JobUnitContext context)
{
_context = context;
}
/// <summary>
/// Construct a job unit worker to execute the specified job.
/// </summary>
/// <param name="context">The context of the job to execute.</param>
public JobUnitWorker(JobUnitContext context)
{
_context = context;
}
