private void calculateAbsoluteAverages(PSO pso) {
int dimension = pso.getTopology().last().getDimension();
absoluteAverageVelocityVector = Vector.of();
averageSpeedVector = Vector.of();
for (Entity e : pso.getTopology()) {
Vector velocity = (Vector) e.getProperties().get(EntityType.Particle.VELOCITY);
for (int i = 0; i < dimension; i++) {
if (absoluteAverageVelocityVector.size() < dimension) {
absoluteAverageVelocityVector.add(velocity.get(i));
averageSpeedVector.add(Real.valueOf(Math.abs(velocity.doubleValueOf(i))));
} else {
absoluteAverageVelocityVector.setReal(
i, absoluteAverageVelocityVector.doubleValueOf(i) + velocity.doubleValueOf(i));
averageSpeedVector.setReal(
i, averageSpeedVector.doubleValueOf(i) + Math.abs(velocity.doubleValueOf(i)));
}
}
}
for (int i = 0; i < dimension; i++) {
absoluteAverageVelocityVector.setReal(
i, Math.abs(absoluteAverageVelocityVector.doubleValueOf(i) / (double) dimension));
averageSpeedVector.setReal(i, averageSpeedVector.doubleValueOf(i) / (double) dimension);
}
}
/**
* Calculates the AUC measurment.
*
* @param algorithm The optimisation algorithm with a NNTrainingProblem.
* @return A Vector with the AUC for each NN output.
*/
@Override
public Vector getValue(Algorithm algorithm) {
Vector solution = (Vector) algorithm.getBestSolution().getPosition();
NNTrainingProblem problem = (NNTrainingProblem) algorithm.getOptimisationProblem();
StandardPatternDataTable generalisationSet = problem.getGeneralisationSet();
NeuralNetwork neuralNetwork = problem.getNeuralNetwork();
neuralNetwork.setWeights(solution);
// Arrange outputs and target values into ArrayLists.
ArrayList<ArrayList<Real>> targets = new ArrayList<ArrayList<Real>>();
ArrayList<ArrayList<Real>> outputs = new ArrayList<ArrayList<Real>>();
// case of multiple outputs
if (generalisationSet.getRow(0).getTarget() instanceof Vector) {
int size = ((Vector) generalisationSet.getRow(0).getTarget()).size();
for (int i = 0; i < size; ++i) {
targets.add(new ArrayList<Real>());
outputs.add(new ArrayList<Real>());
}
for (StandardPattern pattern : generalisationSet) {
Vector target = (Vector) pattern.getTarget();
Vector output = neuralNetwork.evaluatePattern(pattern);
for (int curOutput = 0; curOutput < target.size(); ++curOutput) {
targets.get(curOutput).add((Real) target.get(curOutput));
outputs.get(curOutput).add((Real) output.get(curOutput));
}
}
}
// case of single output
else {
targets.add(new ArrayList<Real>());
outputs.add(new ArrayList<Real>());
for (StandardPattern pattern : generalisationSet) {
Real target = (Real) pattern.getTarget();
Vector output = neuralNetwork.evaluatePattern(pattern);
targets.get(0).add(target);
outputs.get(0).add((Real) output.get(0));
}
}
// Calculate the Vector of AUC values
Vector results = Vector.of();
for (int curOutput = 0; curOutput < outputs.size(); ++curOutput) {
results.add(Real.valueOf(areaUnderCurve(targets.get(curOutput), outputs.get(curOutput))));
}
return results;
}
@Test(expected = IllegalArgumentException.class)
public void testVectorDistance() {
DistanceMeasure distanceMeasure = new CosineDistanceMeasure();
Vector v1 = new Vector();
Vector v2 = new Vector();
v1.add(Real.valueOf(4.0));
v1.add(Real.valueOf(3.0));
v1.add(Real.valueOf(2.0));
v2.add(Real.valueOf(2.0));
v2.add(Real.valueOf(3.0));
v2.add(Real.valueOf(4.0));
double distance = distanceMeasure.distance(v1, v2);
assertTrue(distance >= -1 && distance <= 1);
assertEquals(1 - (25.0 / 29.0), distance, 0.000000000000001);
v1.add(Real.valueOf(22.0));
distanceMeasure.distance(v1, v2);
}
