protected override void SwapPattern(int src, int dest, double[][] data, double[][] target)
{
// Save the selected classes
if (src < numberOfClusters)
{
int targetClass = (int)transform.TransformToValue(target[dest]);
selectedClasses[src] = targetClass;
}
base.SwapPattern(src, dest, data, target);
}
public void Test()
{
testData = new DataSetReader(Parameter.TestingFile, Parameter.InputSize,
Parameter.TargetSize);
outputData = new DataSetWriter(Parameter.OutputFile, false,
Parameter.InputSize, Parameter.TargetSize);
double[] data1 = new double[Parameter.InputSize]; // Original data from dataset file.
double[] data2 = new double[Parameter.InputSize]; // Temporaly transformed data (from data1).
double[] target = new double[Parameter.TargetSize];
double[] output = new double[1];
while (testData.Read(data1, target))
{
// transform input level 1
for (int i = 0; i < Parameter.InputSize; i++)
{
data2[i] = inputTransformers1[i].TransformToValue(data1[i]);
}
// transform input level 2
double[] dataInput = inputTransformers2.TransformToDimension(data2);
if (Parameter.Mode == ProcessModifiedHybridFuzzyARTMapMode.EXTERNAL)
{
fartmap.Run(dataInput);
output[0] = outputTransformers.TransformToValue(fartmap.Output);
}
else
{
mfartmap.Run(dataInput);
output[0] = outputTransformers.TransformToValue(mfartmap.Output);
}
outputData.Write(data1, output, target);
if (((int)output[0]) != 0)
{
if (((int)output[0]) == ((int)target[0]))
{
performanceCounter.RightIncrement();
}
else
{
performanceCounter.WrongIncrement();
}
}
else
{
performanceCounter.NonPredictIncrement();
}
}
outputData.Close();
}
public void Test()
{
Performance.Reset();
testData = new DataSetReader(Parameter.TestingFile, Parameter.InputSize,
Parameter.TargetSize);
outputData = new DataSetWriter(Parameter.OutputFile, false,
Parameter.InputSize, Parameter.TargetSize);
double[] data1 = new double[Parameter.InputSize]; // Original data from dataset file.
double[] data2 = new double[Parameter.InputSize]; // Temporaly transformed data (from data1).
double[] target = new double[Parameter.TargetSize];
double[] output = new double[1];
while (testData.Read(data1, target))
{
// transform input level 1
for (int i = 0; i < Parameter.InputSize; i++)
{
data2[i] = inputTransformers1[i].TransformToValue(data1[i]);
}
// transform input level 2
double[] dataInput = inputTransformers2.TransformToDimension(data2);
network.Run(dataInput);
output[0] = outputTransformers.TransformToValue(network.Output);
outputData.Write(data1, output, target);
if (Math.Round(output[0], 1) == Math.Round(target[0], 1))
{
performanceCounter.RightIncrement();
}
else
{
performanceCounter.WrongIncrement();
}
}
outputData.Close();
}
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;
}
}
}