/// <summary>
/// Training the network (Async call)
/// </summary>
/// <param name="inputPatterns">Input patterns set</param>
/// <param name="outputPatterns">Output patterns set</param>
/// <param name="errorTarget">Target error</param>
/// <param name="mode">Initialization mode</param>
/// <returns>Returns true if the training is successful, otherwise it returns false</returns>
public async Task <bool> TrainingAsync(
double[][] inputPatterns,
double[][] outputPatterns,
double errorTarget = 0.01,
SynInitMode mode = SynInitMode.NGUYEN_WINDROW
)
{
try
{
bool result = false;
await Task.Run(() =>
{
ThreadStart work = delegate
{
try
{
result = Training(inputPatterns, outputPatterns, errorTarget, mode);
} catch (Exception e) { throw e; }
};
Thread trainingThread = new Thread(work);
trainingThread.Start();
trainingThread.Join();
});
return(result);
} catch (Exception e) { throw e; }
}
/// <summary>
/// Training the network
/// </summary>
/// <param name="inputPatterns">Input patterns set</param>
/// <param name="outputPatterns">Output patterns set</param>
/// <param name="errorTarget">Target error</param>
/// <param name="maxEpochs">Maximum number of epochs</param>
/// <param name="mode">Weights initialization mode</param>
/// <param name="learningRate">Learning rate</param>
/// <returns>Returns true if the training is successful, otherwise it returns false</returns>
public bool Training(
double[][] inputPatterns,
double[][] outputPatterns,
double errorTarget = 0.01,
uint maxEpochs = 100000,
SynInitMode mode = SynInitMode.FAN_IN,
double learningRate = 0.25
)
{
IntPtr p_in;
IntPtr p_out;
// Conversion to unmanaged types
LibsannInvoke.MatrixConversion(inputPatterns, out p_in);
LibsannInvoke.MatrixConversion(outputPatterns, out p_out);
_currentError = LibsannInvoke.mAdelineTrainingWithWindrowHoff(
_network, p_in, p_out, (uint)inputPatterns.Count(), _inputSize, _outputSize, errorTarget, maxEpochs, learningRate, mode);
if (errorTarget < _currentError)
{
return(false);
}
else
{
return(true);
}
}
public extern static double MlpTrainingWithPropagation(
IntPtr net,
IntPtr inputPatterns,
IntPtr outputPatterns,
uint inputRows,
uint numberOfInputUnits,
uint numberOfUnitsForOutputLayer,
IntPtr trainAlg,
SynInitMode mode);
public extern static double mAdelineTrainingWithWindrowHoff(
IntPtr net,
IntPtr inputPatterns,
IntPtr outputPatterns,
uint inputRows,
uint numberOfInputNeurons,
uint numberOfOutputNeurons,
double errorTarget,
uint maxEpochs,
double learningRate,
SynInitMode mode);
/// <summary>
/// Training the network
/// </summary>
/// <param name="inputPatterns">Input patterns set</param>
/// <param name="outputPatterns">Output patterns set</param>
/// <param name="errorTarget">Target error</param>
/// <param name="mode">Initialization mode</param>
/// <returns>Returns true if the training is successful, otherwise it returns false</returns>
public bool Training(
double[][] inputPatterns,
double[][] outputPatterns,
double errorTarget,
SynInitMode mode = SynInitMode.NGUYEN_WINDROW
)
{
IntPtr p_in;
IntPtr p_out;
try
{
if (trainAlg == null)
{
throw new Exception("Training algorithm not initialized.");
}
if (stats != null)
{
LibsannInvoke.ResetPropStats(stats.Value);
}
// Conversion to unmanaged types
LibsannInvoke.MatrixConversion(inputPatterns, out p_in);
LibsannInvoke.MatrixConversion(outputPatterns, out p_out);
_currentError = LibsannInvoke.MlpTrainingWithPropagation(
_network, p_in, p_out, (uint)inputPatterns.Count(), _inputSize, _outputSize, trainAlg, mode);
if (errorTarget < _currentError)
{
return(false);
}
else
{
return(true);
}
} catch (Exception e) { throw e; }
}
public void Build(AnnBuild AnnBuilding)
{
if (network != null)
{
network.Destroy();
}
network = new Mlp(
AnnBuilding.InputUnits,
AnnBuilding.HiddenUnits,
AnnBuilding.HiddenLayers,
AnnBuilding.OutputUnits,
AnnBuilding.Bias,
AnnBuilding.ActivationNeuroMode
);
synInitMode = AnnBuilding.SynInitMode;
network.Instantiate();
status = NetworkStatus.UNTRAINED;
logger.InfoFormat("Building neural network classifier: {0}", this.ToString());
}
