private void calculateANOVA() throws SignificanceCalculationException {
double alpha = -1;
String alphaString = alphaField.getText();
try {
alpha = Double.parseDouble(alphaString);
} catch (NumberFormatException e) {
SwingTools.showVerySimpleErrorMessage("Significance level must be a number between 0 and 1.");
}
if ((alpha < 0) || (alpha > 1)) {
SwingTools.showVerySimpleErrorMessage("Significance level must be a number between 0 and 1.");
} else {
this.calculator.clearGroups();
this.calculator.setAlpha(alpha);
for (int i = 0; i < tableModel.getRowCount(); i++) {
int number = ((Integer) tableModel.getValueAt(i, 2)).intValue();
double mean = ((Double) tableModel.getValueAt(i, 0)).doubleValue();
double variance = ((Double) tableModel.getValueAt(i, 1)).doubleValue();
calculator.addGroup(number, mean, variance);
}
if (tableModel.getRowCount() < 2) {
SwingTools.showVerySimpleErrorMessage(
"You need to add at least two rows in order to calculate an ANOVA test.");
return;
}
SignificanceTestResult result = calculator.performSignificanceTest();
JOptionPane.showMessageDialog(
this, result.getVisualizationComponent(null), "ANOVA result", JOptionPane.PLAIN_MESSAGE);
}
}
@Override
public void doWork() throws OperatorException {
ExampleSet exampleSetOriginal = exampleSetInput.getData(ExampleSet.class);
ExampleSet exampleSet = (ExampleSet) exampleSetOriginal.clone();
int numberOfAttributes = exampleSet.getAttributes().size();
Attributes attributes = exampleSet.getAttributes();
int maxNumberOfAttributes =
Math.min(getParameterAsInt(PARAMETER_MAX_ATTRIBUTES), numberOfAttributes - 1);
int maxNumberOfFails = getParameterAsInt(PARAMETER_ALLOWED_CONSECUTIVE_FAILS);
int behavior = getParameterAsInt(PARAMETER_STOPPING_BEHAVIOR);
boolean useRelativeIncrease =
(behavior == WITH_DECREASE_EXCEEDS)
? getParameterAsBoolean(PARAMETER_USE_RELATIVE_DECREASE)
: false;
double maximalDecrease = 0;
if (useRelativeIncrease)
maximalDecrease =
useRelativeIncrease
? getParameterAsDouble(PARAMETER_MAX_RELATIVE_DECREASE)
: getParameterAsDouble(PARAMETER_MAX_ABSOLUT_DECREASE);
double alpha =
(behavior == WITH_DECREASE_SIGNIFICANT) ? getParameterAsDouble(PARAMETER_ALPHA) : 0d;
// remembering attributes and removing all from example set
Attribute[] attributeArray = new Attribute[numberOfAttributes];
int i = 0;
Iterator<Attribute> iterator = attributes.iterator();
while (iterator.hasNext()) {
Attribute attribute = iterator.next();
attributeArray[i] = attribute;
i++;
}
boolean[] selected = new boolean[numberOfAttributes];
Arrays.fill(selected, true);
boolean earlyAbort = false;
List<Integer> speculativeList = new ArrayList<Integer>(maxNumberOfFails);
int numberOfFails = maxNumberOfFails;
currentNumberOfFeatures = numberOfAttributes;
currentAttributes = attributes;
PerformanceVector lastPerformance = getPerformance(exampleSet);
PerformanceVector bestPerformanceEver = lastPerformance;
for (i = 0; i < maxNumberOfAttributes && !earlyAbort; i++) {
// setting values for logging
currentNumberOfFeatures = numberOfAttributes - i - 1;
// performing a round
int bestIndex = 0;
PerformanceVector currentBestPerformance = null;
for (int current = 0; current < numberOfAttributes; current++) {
if (selected[current]) {
// switching off
attributes.remove(attributeArray[current]);
currentAttributes = attributes;
// evaluate performance
PerformanceVector performance = getPerformance(exampleSet);
if (currentBestPerformance == null || performance.compareTo(currentBestPerformance) > 0) {
bestIndex = current;
currentBestPerformance = performance;
}
// switching on
attributes.addRegular(attributeArray[current]);
currentAttributes = null; // removing reference
}
}
double currentFitness = currentBestPerformance.getMainCriterion().getFitness();
if (i != 0) {
double lastFitness = lastPerformance.getMainCriterion().getFitness();
// switch stopping behavior
switch (behavior) {
case WITH_DECREASE:
if (lastFitness >= currentFitness) earlyAbort = true;
break;
case WITH_DECREASE_EXCEEDS:
if (useRelativeIncrease) {
// relative increase testing
if (currentFitness < lastFitness - Math.abs(lastFitness * maximalDecrease))
earlyAbort = true;
} else {
// absolute increase testing
if (currentFitness < lastFitness - maximalDecrease) earlyAbort = true;
}
break;
case WITH_DECREASE_SIGNIFICANT:
AnovaCalculator calculator = new AnovaCalculator();
calculator.setAlpha(alpha);
PerformanceCriterion pc = currentBestPerformance.getMainCriterion();
calculator.addGroup(pc.getAverageCount(), pc.getAverage(), pc.getVariance());
pc = lastPerformance.getMainCriterion();
calculator.addGroup(pc.getAverageCount(), pc.getAverage(), pc.getVariance());
SignificanceTestResult result;
try {
result = calculator.performSignificanceTest();
} catch (SignificanceCalculationException e) {
throw new UserError(this, 920, e.getMessage());
}
if (lastFitness > currentFitness && result.getProbability() < alpha) earlyAbort = true;
}
}
if (earlyAbort) {
// check if there are some free tries left
if (numberOfFails == 0) {
break;
}
numberOfFails--;
speculativeList.add(bestIndex);
earlyAbort = false;
// needs performance increase compared to better performance of current and last!
if (currentBestPerformance.compareTo(lastPerformance) > 0)
lastPerformance = currentBestPerformance;
} else {
// resetting maximal number of fails.
numberOfFails = maxNumberOfFails;
speculativeList.clear();
lastPerformance = currentBestPerformance;
bestPerformanceEver = currentBestPerformance;
}
// switching best index off
attributes.remove(attributeArray[bestIndex]);
selected[bestIndex] = false;
}
// add predictively removed attributes: speculative execution did not yield good result
for (Integer removeIndex : speculativeList) {
selected[removeIndex] = true;
attributes.addRegular(attributeArray[removeIndex]);
}
AttributeWeights weights = new AttributeWeights();
i = 0;
for (Attribute attribute : attributeArray) {
if (selected[i]) weights.setWeight(attribute.getName(), 1d);
else weights.setWeight(attribute.getName(), 0d);
i++;
}
exampleSetOutput.deliver(exampleSet);
performanceOutput.deliver(bestPerformanceEver);
weightsOutput.deliver(weights);
}
