public void Train()
{
// Read all training data and transforming them.
trainingData = new DataSetReader(Parameter.TrainingFile,
Parameter.InputSize, Parameter.TargetSize);
double[][] data, target;
trainingData.ReadAll(out data, out target);
for (int i = 0; i < trainingData.Count; ++i)
{
// transform input level 1
for (int j = 0; j < Parameter.InputSize; ++j)
{
data[i][j] = inputTransformers1[j].TransformToValue(data[i][j]);
}
// transform input level 2
data[i] = inputTransformers2.TransformToDimension(data[i]);
// transform target
target[i] = targetTransform.TransformToDimension(target[i]);
}
oldArtAWeights = new List <double[]>();
bool isWeightsChanged = true, completedLimited = false;
// Order input and target pattern before.
if (param.Mode == ProcessModifiedHybridFuzzyARTMapMode.EXTERNAL ||
param.Mode == ProcessModifiedHybridFuzzyARTMapMode.DUAL)
{
mcoa.OrderSequence(data, target);
}
do
{
SaveOldWeights();
// Training ordered fuzzy art map
if (param.Mode == ProcessModifiedHybridFuzzyARTMapMode.EXTERNAL)
{
fartmap.Run(data, target);
}
else
{
mfartmap.Run(data, target);
}
double mseValue = CalculateMse();
if (mseValue < Parameter.LimitedMseValue)
{
isWeightsChanged = false;
}
performanceCounter.Increment();
if (param.LimitedEpochs != 0 &&
param.LimitedEpochs <= performanceCounter.Count)
{
completedLimited = true;
}
}while (!completedLimited && isWeightsChanged);
}
public void Train()
{
// Read all training data and transforming them.
trainingData = new DataSetReader(Parameter.TrainingFile,
Parameter.InputSize, Parameter.TargetSize);
double[][] data, target;
trainingData.ReadAll(out data, out target);
for (int i = 0; i < trainingData.Count; ++i)
{
// transform input level 1
for (int j = 0; j < Parameter.InputSize; ++j)
{
data[i][j] = inputTransformers1[j].TransformToValue(data[i][j]);
}
// transform input level 2
data[i] = inputTransformers2.TransformToDimension(data[i]);
// transform target
target[i] = targetTransform.TransformToDimension(target[i]);
}
oldArtAWeights = new List <double[]>();
bool isWeightsChanged = true, completedLimited = false;
do
{
SaveOldWeights();
// Training ordered fuzzy art map
network.Run(data, target);
double mseValue = CalculateMse();
if (mseValue < Parameter.LimitedMseValue)
{
isWeightsChanged = false;
}
performanceCounter.Increment();
if (parameter.LimitedEpochs != 0 &&
parameter.LimitedEpochs <= performanceCounter.Count)
{
completedLimited = true;
}
}while (!completedLimited && isWeightsChanged);
}
public void Train()
{
oldArtAWeights = new List <double[]>();
bool isWeightsChanged = true, completedLimited = false;
do
{
SaveOldWeights();
trainingData = new DataSetReader(Parameter.TrainingFile,
Parameter.InputSize, Parameter.TargetSize);
double[] data = new double[Parameter.InputSize];
double[] target = new double[Parameter.TargetSize];
while (trainingData.Read(data, target))
{
// transform input level 1
for (int i = 0; i < Parameter.InputSize; i++)
{
data[i] = inputTransformers1[i].TransformToValue(data[i]);
}
// transform input level 2
double[] dataInput = inputTransformers2.TransformToDimension(data);
// transform target
double[] targetInput = targetTransform.TransformToDimension(target);
network.Run(dataInput, targetInput);
}
double mseValue = CalculateMse();
if (mseValue < Parameter.LimitedMseValue)
{
isWeightsChanged = false;
}
performanceCounter.Increment();
if (parameter.LimitedEpochs != 0 &&
parameter.LimitedEpochs <= performanceCounter.Count)
{
completedLimited = true;
}
}while (!completedLimited && isWeightsChanged);
}
private void Process()
{
double[] choicingValues = ComputeChoicingValues(input,
categories, numberOfCategories, choicingParam);;
int targetClass = 0;
if (mode == "TRAIN")
{
targetClass = (int)rtf.TransformToValue(target);
}
int category = 0;
bool nonprediction = false;
bool uncommited = false;
bool testVigilance = false;
while (!testVigilance)
{
category = MaxChoicingValues(choicingValues);
if (mode == "TRAIN")
{
if (category != -1)
{
double vigilance = ComputeVigilance(input, categories[category]);
if (vigilance >= vigilances[category])
{
mm.Increment(category, targetClass);
double entropy = esa.Compute(category);
if (entropy > maximumEntropy)
{
mm.Decrement(category, targetClass);
choicingValues[category] = 0;
}
else
{
testVigilance = true;
}
}
else
{
choicingValues[category] = 0;
}
}
else
{
category = NewCategory();
mm.Increment(category, targetClass);
uncommited = true;
testVigilance = true;
}
}
if (mode == "TEST")
{
if (category != -1)
{
double vigilance = ComputeVigilance(input, categories[category]);
if (vigilance < vigilances[category])
{
choicingValues[category] = 0;
}
}
else
{
nonprediction = true;
}
testVigilance = true;
}
}
if (mode == "TRAIN")
{
AdjustWeight(input, category, weightAdjustRate, uncommited);
}
if (mode == "TEST")
{
if (!nonprediction)
{
bool success = false;
if (categoryTargetClasses != null)
{
if (category >= 0 && category < numberOfCategories)
{
output = tf.TransformToDimension(new double[] { categoryTargetClasses[category] });
success = true;
}
}
if (!success)
{
output = null;
}
}
else
{
output = NONPREDICT_OUTPUT;
}
}
}
