@Test public void testBiDistribution() { Algorithm algorithm = mock(Algorithm.class); MOFitness fitness01 = Fitnesses.create(new MinimisationFitness(3.0), new MinimisationFitness(0.0)); final Type type01 = mock(Type.class, "type2_01"); MOFitness fitness02 = Fitnesses.create(new MinimisationFitness(2.0), new MinimisationFitness(1.0)); final Type type02 = mock(Type.class, "type2_02"); // Cloning returns the mocked objects themselves. when(type01.getClone()).thenReturn(type01); when(type02.getClone()).thenReturn(type02); OptimisationSolution solution01 = new OptimisationSolution(type01, fitness01); OptimisationSolution solution02 = new OptimisationSolution(type02, fitness02); Archive archive = Archive.Provider.get(); archive.add(solution01); archive.add(solution02); Real distribution = new SolutionDistribution().getValue(algorithm); Assert.assertEquals(0.0, distribution.doubleValue(), 0.0000000000001); }
/** Test the get column method. */ @Test public void testGetColumn() { TypeList expected = new TypeList(); expected.add(Real.valueOf(0.2)); expected.add(Real.valueOf(1.2)); TypeList column = stringTargetPatterns.getColumn(1); Assert.assertEquals(expected, column); expected = new TypeList(); Vector target = Vector.of(1, 1, 0); expected.add(target); target = Vector.of(0, 0, 1); expected.add(target); column = vectorTargetPatterns.getColumn(5); Assert.assertEquals(expected, column); }
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); } }
/** * Given the datatype key, determines the datatype for a given column. Also sets up the HashTables * to map a nominal attribute to a corresponding integer number. * * @param columnn the column to map to a datatype. * @param datatype the datatype key. * @return a corresponding CIlib type. * @throws CIlibIOException {@inheritDoc} */ private Type getTypeData(int columnn, String datatype) throws CIlibIOException { if (datatype.equalsIgnoreCase("NUMERIC")) { return Real.valueOf(0.0); } if (datatype.equalsIgnoreCase("STRING")) { return new StringType(""); } if (datatype.equalsIgnoreCase("DATE")) { throw new UnsupportedOperationException("Date format currently not supported" + " in CIlib."); } // If none of the above, has to be a nominal attribute. if (columnToNominalAttributesMap == null) { columnToNominalAttributesMap = new HashMap<Integer, HashMap<String, Integer>>(); } HashMap<String, Integer> nominalMap = new HashMap<String, Integer>(); datatype = datatype.replaceAll("[{}]", ""); String[] nominalAttributes = datatype.split("\\,"); if (nominalAttributes.length == 0) { throw new CIlibIOException( "Nominal attributes must be comma separated:" + "{<nominal-name1>, <nominal-name2>, <nominal-name3>, ...} "); } for (int i = 0; i < nominalAttributes.length; i++) { String nominalAttribute = nominalAttributes[i]; nominalMap.put(nominalAttribute, i); } columnToNominalAttributesMap.put(columnn, nominalMap); return Int.valueOf(0); }
@Test public void testSetColumn() { TypeList newColumn = new TypeList(); List<Real> list = Arrays.asList(Real.valueOf(5.2), Real.valueOf(6.2)); for (Real real : list) { newColumn.add(real); } stringTargetPatterns.setColumn(0, newColumn); Assert.assertEquals(newColumn, stringTargetPatterns.getColumn(0)); newColumn = new TypeList(); Vector target = Vector.of(1, 1, 0); newColumn.add(target); target = Vector.of(0, 0, 1); newColumn.add(target); newColumn = vectorTargetPatterns.getColumn(5); Assert.assertEquals(newColumn, vectorTargetPatterns.getColumn(5)); }
@Override public List<Type> nextRow() { List<Type> row = Lists.newArrayList(); for (int i = 0; i < this.columnCount; ++i) { row.add(Real.valueOf(this.vector.get(this.index + i).doubleValue())); } this.index += this.columnCount; return row; }
@BeforeClass public static void setUpBeforeClass() throws Exception { Vector.Builder tmp = Vector.newBuilder(); set = new ArrayList<Pattern>(); for (int i = 1; i <= SIZE; i++) { tmp.add(Real.valueOf(i)); } set.add(new Pattern("class0", tmp.build())); tmp = Vector.newBuilder(); for (int i = SIZE; i > 0; i--) { tmp.add(Real.valueOf(i)); } set.add(new Pattern("class1", tmp.build())); set.add(new Pattern("class2", Vector.of(1.0, 1.0, 1.0))); set.add(new Pattern("class1", Vector.of(2.0, 2.0, 2.0))); set.add(new Pattern("class0", Vector.of(3.0, 3.0, 3.0))); }
@Test public void results() { Algorithm algorithm = this.mockery.mock(Algorithm.class); MOFitness fitness01 = Fitnesses.create(new MinimisationFitness(0.0), new MinimisationFitness(1.0)); final Type type01 = this.mockery.mock(Type.class, "type_01"); MOFitness fitness02 = Fitnesses.create(new MinimisationFitness(0.5), new MinimisationFitness(0.5)); final Type type02 = this.mockery.mock(Type.class, "type_02"); MOFitness fitness03 = Fitnesses.create(new MinimisationFitness(1.0), new MinimisationFitness(0.0)); final Type type03 = this.mockery.mock(Type.class, "type_03"); // Cloning returns the mocked objects themselves. this.mockery.checking( new Expectations() { { oneOf(type01).getClone(); will(returnValue(type01)); oneOf(type02).getClone(); will(returnValue(type02)); oneOf(type03).getClone(); will(returnValue(type03)); } }); OptimisationSolution solution01 = new OptimisationSolution(type01, fitness01); OptimisationSolution solution02 = new OptimisationSolution(type02, fitness02); OptimisationSolution solution03 = new OptimisationSolution(type03, fitness03); Archive archive = Archive.Provider.get(); archive.add(solution01); archive.add(solution02); archive.add(solution03); Real extent = new ParetoFrontExtent().getValue(algorithm); Assert.assertEquals(Math.sqrt(2.0), extent.doubleValue(), 0.00001); }
/** * 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; }
@Override public <E extends Entity> List<E> crossover(List<E> parentCollection) { Preconditions.checkArgument( parentCollection.size() == 2, "BlendCrossoverStrategy requires 2 parents."); // How do we handle variable sizes? Resizing the entities? E offspring1 = (E) parentCollection.get(0).getClone(); E offspring2 = (E) parentCollection.get(1).getClone(); Vector parentChromosome1 = (Vector) parentCollection.get(0).getCandidateSolution(); Vector parentChromosome2 = (Vector) parentCollection.get(1).getCandidateSolution(); Vector.Builder offspringChromosome1 = Vector.newBuilder(); Vector.Builder offspringChromosome2 = Vector.newBuilder(); int sizeParent1 = parentChromosome1.size(); int sizeParent2 = parentChromosome2.size(); int minDimension = Math.min(sizeParent1, sizeParent2); for (int i = 0; i < minDimension; i++) { double gamma = (1 + 2 * alpha.getParameter()) * random.getRandomNumber() - alpha.getParameter(); double value1 = (1 - gamma) * parentChromosome1.doubleValueOf(i) + gamma * parentChromosome2.doubleValueOf(i); double value2 = (1 - gamma) * parentChromosome2.doubleValueOf(i) + gamma * parentChromosome1.doubleValueOf(i); offspringChromosome1.add(Real.valueOf(value1, parentChromosome1.boundsOf(i))); offspringChromosome2.add(Real.valueOf(value2, parentChromosome1.boundsOf(i))); } offspring1.setCandidateSolution(offspringChromosome1.build()); offspring2.setCandidateSolution(offspringChromosome2.build()); return Arrays.asList(offspring1, offspring2); }
/** * Puts a token into a new object of the correct CIlib type. * * @param index the index of the token in the row (its column). * @param token the token to be typed. * @return a new CIlib object of the correct type. */ private Type mapTokenToType(int index, String token) { Type type = columnTypePrototypes.get(index); if (type instanceof Real) { return Real.valueOf(Double.parseDouble(token)); } if (type instanceof StringType) { return new StringType(token); } // If none of the above, has to be a nominal attribute. HashMap<String, Integer> nominalMap = this.columnToNominalAttributesMap.get(index); return Int.valueOf(nominalMap.get(token)); }
@Override public Vector get(Particle particle) { Vector newPos = (Vector) delegate.get(particle); Particle tmp = particle.getClone(); tmp.setPosition(newPos); Fitness newFitness = particle.getBehaviour().getFitnessCalculator().getFitness(tmp); final UniformDistribution uniform = new UniformDistribution(); Vector newPBest = newPos.plus( Vector.newBuilder() .repeat(newPos.size(), Real.valueOf(1.0)) .build() .multiply( new P1<Number>() { @Override public Number _1() { return uniform.getRandomNumber( -granularity.getParameter(), granularity.getParameter()); } })); tmp.setPosition(newPos); Fitness newPBestFitness = particle.getBehaviour().getFitnessCalculator().getFitness(tmp); if (newPBestFitness.compareTo(newFitness) < 0) { Vector tmpVector = Vector.copyOf(newPos); newPos = newPBest; newPBest = tmpVector; newPBestFitness = newFitness; } double dot = ((Vector) particle.getNeighbourhoodBest().getBestPosition()) .subtract(newPos) .dot(newPBest.subtract(newPos)); if (dot < 0) { return (Vector) particle.getPosition(); } particle.put(Property.BEST_POSITION, newPBest); particle.put(Property.BEST_FITNESS, newPBestFitness); return newPos; }
/** {@inheritDoc} */ public Real getValue(Algorithm algorithm) { PSO pso = (PSO) algorithm; int numberParticles = pso.getTopology().size(); Iterator<Particle> k = pso.getTopology().iterator(); Particle particle = k.next(); Vector averageParticlePosition = (Vector) particle.getPosition().getClone(); while (k.hasNext()) { particle = k.next(); Vector v = (Vector) particle.getPosition(); for (int j = 0; j < averageParticlePosition.size(); ++j) { averageParticlePosition.setReal( j, averageParticlePosition.doubleValueOf(j) + v.doubleValueOf(j)); } } for (int j = 0; j < averageParticlePosition.size(); ++j) { averageParticlePosition.setReal( j, averageParticlePosition.doubleValueOf(j) / numberParticles); } Iterator<Particle> i = pso.getTopology().iterator(); double particleSum = 0.0; while (i.hasNext()) { particle = i.next(); double dimensionSum = 0.0; Vector v = (Vector) particle.getPosition(); for (int j = 0; j < particle.getDimension(); ++j) { dimensionSum += (v.doubleValueOf(j) - averageParticlePosition.doubleValueOf(j)) * (v.doubleValueOf(j) - averageParticlePosition.doubleValueOf(j)); } particleSum += Math.sqrt(dimensionSum); } double diversity = particleSum / numberParticles; DiameterVisitor diameterVisitor = new DiameterVisitor(); pso.accept(diameterVisitor); double diameter = diameterVisitor.getResult(); return Real.valueOf(diversity / diameter); }
@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); }
@Test public void algorithmExecution() { NNDataTrainingProblem problem = new NNDataTrainingProblem(); problem.getDataTableBuilder().setDataReader(new ARFFFileReader()); problem.getDataTableBuilder().setSourceURL("library/src/test/resources/datasets/iris.arff"); problem.setTrainingSetPercentage(0.7); problem.setGeneralizationSetPercentage(0.3); problem .getNeuralNetwork() .getArchitecture() .setArchitectureBuilder(new CascadeArchitectureBuilder()); problem.getNeuralNetwork().setOperationVisitor(new CascadeVisitor()); problem .getNeuralNetwork() .getArchitecture() .getArchitectureBuilder() .addLayer(new LayerConfiguration(4)); problem .getNeuralNetwork() .getArchitecture() .getArchitectureBuilder() .addLayer(new LayerConfiguration(0)); problem .getNeuralNetwork() .getArchitecture() .getArchitectureBuilder() .addLayer(new LayerConfiguration(1)); problem .getNeuralNetwork() .getArchitecture() .getArchitectureBuilder() .getLayerBuilder() .setDomain("R(-3:3)"); problem.initialise(); PSO pso = new PSO(); pso.getInitialisationStrategy().setEntityType(new DynamicParticle()); pso.addStoppingCondition(new MeasuredStoppingCondition()); pso.setOptimisationProblem(problem); pso.performInitialisation(); CascadeNetworkExpansionReactionStrategy reaction = new CascadeNetworkExpansionReactionStrategy(); Assert.assertEquals(5, ((Vector) pso.getBestSolution().getPosition()).size()); Assert.assertEquals(5, problem.getNeuralNetwork().getWeights().size()); for (int i = 0; i < Topologies.getBestEntity(pso.getTopology()).getDimension(); ++i) { ((Vector) Topologies.getBestEntity(pso.getTopology()).getPosition()) .set(i, Real.valueOf(0.0)); ((Vector) Topologies.getBestEntity(pso.getTopology()).getVelocity()) .set(i, Real.valueOf(0.0)); ((Vector) Topologies.getBestEntity(pso.getTopology()).getBestPosition()) .set(i, Real.valueOf(0.0)); } reaction.performReaction(pso); Assert.assertEquals(11, ((Vector) pso.getBestSolution().getPosition()).size()); Assert.assertEquals(11, problem.getNeuralNetwork().getWeights().size()); Assert.assertEquals( Vector.of( Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN), (Vector) Topologies.getBestEntity(pso.getTopology()).getPosition()); Assert.assertEquals( Vector.of( Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN), (Vector) Topologies.getBestEntity(pso.getTopology()).getVelocity()); Assert.assertEquals( Vector.of( Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN), (Vector) Topologies.getBestEntity(pso.getTopology()).getBestPosition()); for (int i = 0; i < Topologies.getBestEntity(pso.getTopology()).getDimension(); ++i) { ((Vector) Topologies.getBestEntity(pso.getTopology()).getPosition()) .set(i, Real.valueOf(0.0)); ((Vector) Topologies.getBestEntity(pso.getTopology()).getVelocity()) .set(i, Real.valueOf(0.0)); ((Vector) Topologies.getBestEntity(pso.getTopology()).getBestPosition()) .set(i, Real.valueOf(0.0)); } reaction.performReaction(pso); Assert.assertEquals(18, ((Vector) pso.getBestSolution().getPosition()).size()); Assert.assertEquals(18, problem.getNeuralNetwork().getWeights().size()); Assert.assertEquals( Vector.of( 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN), (Vector) Topologies.getBestEntity(pso.getTopology()).getPosition()); Assert.assertEquals( Vector.of( 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN), (Vector) Topologies.getBestEntity(pso.getTopology()).getVelocity()); Assert.assertEquals( Vector.of( 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN), (Vector) Topologies.getBestEntity(pso.getTopology()).getBestPosition()); for (int i = 0; i < Topologies.getBestEntity(pso.getTopology()).getDimension(); ++i) { ((Vector) Topologies.getBestEntity(pso.getTopology()).getPosition()) .set(i, Real.valueOf(0.0)); ((Vector) Topologies.getBestEntity(pso.getTopology()).getVelocity()) .set(i, Real.valueOf(0.0)); ((Vector) Topologies.getBestEntity(pso.getTopology()).getBestPosition()) .set(i, Real.valueOf(0.0)); } reaction.performReaction(pso); Assert.assertEquals(26, ((Vector) pso.getBestSolution().getPosition()).size()); Assert.assertEquals(26, problem.getNeuralNetwork().getWeights().size()); Assert.assertEquals( Vector.of( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN), (Vector) Topologies.getBestEntity(pso.getTopology()).getPosition()); Assert.assertEquals( Vector.of( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN), (Vector) Topologies.getBestEntity(pso.getTopology()).getVelocity()); Assert.assertEquals( Vector.of( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.NaN), (Vector) Topologies.getBestEntity(pso.getTopology()).getBestPosition()); }
private void updateInertia(PSO pso) { int dimension = pso.getTopology().last().getDimension(); if (inertiaWeight.size() < dimension) { Vector.Builder builder = Vector.newBuilder(); builder.repeat(dimension, Real.valueOf(initialInertiaWeight.getParameter())); inertiaWeight = builder.build(); } Vector.Builder builder = Vector.newBuilder(); for (int i = 0; i < dimension; i++) { builder.add( Math.sqrt( Math.pow(absoluteAverageVelocityVector.doubleValueOf(i), 2) + Math.pow(averageSpeedVector.doubleValueOf(i), 2))); } Vector d = builder.build(); // get the degree of convergence vector double max_d = 0; for (Numeric component : d) { if (component.doubleValue() > max_d) { max_d = component.doubleValue(); } } if (max_d != 0) { Vector.Builder builder2 = Vector.newBuilder(); for (Numeric component : d) { builder2.add(max_d / (max_d + component.doubleValue())); } Vector w = builder2.build(); /*double sum_w = 0; for(Numeric component : w) { sum_w += component.doubleValue(); } /* Vector.Builder builder3 = Vector.newBuilder(); for(Numeric component : w) { builder3.add(Math.pow(dimension * component.doubleValue() / sum_w, pwr.getParameter())); } */ /* for(Numeric component : w) { //builder3.add(component.doubleValue() - w_mean / w_stdDiv); builder3.add(component.doubleValue() * initialInertiaWeight.getParameter()); } for(int i = 0; i < inertiaWeight.size(); i++) { builder3.add(w.doubleValueOf(i) * inertiaWeight.doubleValueOf(i)); } */ /* Vector m = builder3.build(); double sum_m = 0; for (Numeric num : m) { sum_m += num.doubleValue(); } double m_mean = sum_m / (double) dimension; double sum_diff_squared = 0; for(Numeric component : m) { sum_diff_squared += Math.pow(component.doubleValue() - m_mean, 2); } double m_stdDiv = Math.sqrt(sum_diff_squared / (double) dimension); */ // System.out.println("VEL: StdDiv of M: " + m_stdDiv + ", mean of M: " + m_mean); for (int i = 0; i < inertiaWeight.size(); i++) { inertiaWeight.setReal( i, (1 - filter.getParameter()) * w.doubleValueOf(i) + filter.getParameter() * inertiaWeight.doubleValueOf(i)); // w.doubleValueOf(i));//; } } }
/** * Calculates the AUC of one output. * * @param targets The expected outputs. Each value is discetised to the closest bound. * @param outputs The outputs of the NN. * @return The AUC in the range [0,1]. */ public double areaUnderCurve(ArrayList<Real> targets, ArrayList<Real> outputs) { double negatives = 0.0; double positives = 0.0; double centerBound = (upperBound + lowerBound) / 2.0; // determine total positives and negatives for (Real curTarget : targets) { if (curTarget.doubleValue() > centerBound) positives += 1; else negatives += 1; } // plot ROC curve coordinates double threshold = lowerBound; ArrayList<Real> tpCoords = new ArrayList<Real>(); ArrayList<Real> fpCoords = new ArrayList<Real>(); // when all outputs are seen as true tpCoords.add(Real.valueOf(1.0)); fpCoords.add(Real.valueOf(1.0)); double newThresholdL; double newThresholdU; do { // calculate next threshold newThresholdL = upperBound; newThresholdU = upperBound; for (Real curOutput : outputs) { if (curOutput.doubleValue() >= threshold && curOutput.doubleValue() < newThresholdL) { newThresholdL = curOutput.doubleValue(); } } for (Real curOutput : outputs) { if (curOutput.doubleValue() > newThresholdL && curOutput.doubleValue() < newThresholdU) { newThresholdU = curOutput.doubleValue(); } } threshold = (newThresholdL + newThresholdU) / 2.0; // calculate tp and fp for this threshold double tPositive = 0; double fPositive = 0; for (int curOutput = 0; curOutput < outputs.size(); ++curOutput) { if (targets.get(curOutput).doubleValue() > centerBound && outputs.get(curOutput).doubleValue() > threshold) { tPositive += 1; } else if (targets.get(curOutput).doubleValue() <= centerBound && outputs.get(curOutput).doubleValue() > threshold) { fPositive += 1; } } tpCoords.add(Real.valueOf(tPositive / positives)); fpCoords.add(Real.valueOf(fPositive / negatives)); } while (newThresholdU < upperBound); // when all outputs are seen as false tpCoords.add(Real.valueOf(0.0)); fpCoords.add(Real.valueOf(0.0)); // calculate area double area = 0.0; for (int curCoord = 1; curCoord < fpCoords.size(); ++curCoord) { area += ((tpCoords.get(curCoord - 1).doubleValue() + tpCoords.get(curCoord).doubleValue()) / 2) * (fpCoords.get(curCoord - 1).doubleValue() - fpCoords.get(curCoord).doubleValue()); // fpCoords sorted in decending order } return area; }