Menu
▾
▴
[cilib-devel] [PATCH 12/14] Various changes and a rebase.
|
From: Theuns C. <the...@gm...> - 2009-06-10 06:42:38
|
1. Modified ClusteringUtils to work with SplitCooperativeAlgorithm.
CooperativeEntity was also refactored to make use of the "candidate
solution" property available in AbstractEntity. Previously, the
CooperativeEntity had its own Vector object to represent the context.
CooperativeOptimisationProblemAdapter needed the ability to return the
"higher level" problem - it was implemented.
2. Removed the AbsoluteDistanceMeasure that has been deprecated a very
long while ago. Implemented the HammingDistanceMeasure - like XOR.
3. Implemented a new dynamic environment response strategy that
reinitialises a user-specified percentage of the least fit entities in
the population.
4. Updated measurements used for clustering including a new class to
print GNUplot commands to plot high dimensional (> 2) clusters and
centroids.
5. Updated some JavaDoc comments.
6. Corrected MOO response strategy after rebase, because I renamed
some classes in earlier pathces that have not yet been applied to
master. Also corrected dynamic-vepso.xml file.
---
...gPotentialCentroidsInitialisationStrategy.java} | 17 ++-
.../cilib/cooperative/CooperativeEntity.java | 61 ++++++----
.../clustering/ClusteringFitnessFunction.java | 4 +-
.../clustering/PlotClustersAndCentroids.java | 4 +-
.../PlotHighDimensionalClustersAndCentroids.java | 130 ++++++++++++++++++++
.../CooperativeOptimisationProblemAdapter.java | 12 ++-
.../sourceforge/cilib/problem/dataset/Pattern.java | 11 +-
.../pso/dynamic/ChargedVelocityUpdateStrategy.java | 20 +++-
.../ArchiveReevaluationResponseStrategy.java | 5 +-
.../LeastFitReinitialisationResponseStrategy.java | 54 ++++++++
.../cilib/util/ChebyshevDistanceMeasure.java | 3 +-
.../sourceforge/cilib/util/ClusteringUtils.java | 12 ++-
.../cilib/util/CosineDistanceMeasure.java | 4 +-
...nceMeasure.java => HammingDistanceMeasure.java} | 54 +++++----
xml/kmeans.xml | 11 +-
15 files changed, 324 insertions(+), 78 deletions(-)
rename src/main/java/net/sourceforge/cilib/clustering/kmeans/{KMeansPlusPlusCentroidsInitialisationStrategy.java => ContributingPotentialCentroidsInitialisationStrategy.java} (85%)
create mode 100644 src/main/java/net/sourceforge/cilib/measurement/single/clustering/PlotHighDimensionalClustersAndCentroids.java
create mode 100644 src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/LeastFitReinitialisationResponseStrategy.java
rename src/main/java/net/sourceforge/cilib/util/{AbsoluteDistanceMeasure.java => HammingDistanceMeasure.java} (54%)
diff --git a/src/main/java/net/sourceforge/cilib/clustering/kmeans/KMeansPlusPlusCentroidsInitialisationStrategy.java b/src/main/java/net/sourceforge/cilib/clustering/kmeans/ContributingPotentialCentroidsInitialisationStrategy.java
similarity index 85%
rename from src/main/java/net/sourceforge/cilib/clustering/kmeans/KMeansPlusPlusCentroidsInitialisationStrategy.java
rename to src/main/java/net/sourceforge/cilib/clustering/kmeans/ContributingPotentialCentroidsInitialisationStrategy.java
index 5ad35f8..75132a8 100644
--- a/src/main/java/net/sourceforge/cilib/clustering/kmeans/KMeansPlusPlusCentroidsInitialisationStrategy.java
+++ b/src/main/java/net/sourceforge/cilib/clustering/kmeans/ContributingPotentialCentroidsInitialisationStrategy.java
@@ -29,6 +29,8 @@ import net.sourceforge.cilib.problem.dataset.Pattern;
import net.sourceforge.cilib.problem.dataset.StaticDataSetBuilder;
import net.sourceforge.cilib.type.types.container.Vector;
import net.sourceforge.cilib.util.DistanceMeasure;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Initialises each centroid with probability proportional to its contribution to the overall potential.
@@ -43,11 +45,13 @@ import net.sourceforge.cilib.util.DistanceMeasure;
*
* @author Theuns Cloete
*/
-public class KMeansPlusPlusCentroidsInitialisationStrategy implements CentroidsInitialisationStrategy {
+public class ContributingPotentialCentroidsInitialisationStrategy implements CentroidsInitialisationStrategy {
+ private static final Logger logger = LoggerFactory.getLogger(ContributingPotentialCentroidsInitialisationStrategy.class);
+
private ArrayList<Pattern> patterns;
private DistanceMeasure distanceMeasure;
- public KMeansPlusPlusCentroidsInitialisationStrategy() {
+ public ContributingPotentialCentroidsInitialisationStrategy() {
patterns = null;
distanceMeasure = null;
}
@@ -56,8 +60,8 @@ public class KMeansPlusPlusCentroidsInitialisationStrategy implements CentroidsI
* {@inheritDoc}
*/
@Override
- public KMeansPlusPlusCentroidsInitialisationStrategy getClone() {
- return new KMeansPlusPlusCentroidsInitialisationStrategy();
+ public ContributingPotentialCentroidsInitialisationStrategy getClone() {
+ return new ContributingPotentialCentroidsInitialisationStrategy();
}
/**
@@ -79,10 +83,12 @@ public class KMeansPlusPlusCentroidsInitialisationStrategy implements CentroidsI
if (i > 0) {
while (randomProbability.nextDouble() >= this.calculateProbability(chosenCentroids, candidateCentroid)) {
+ logger.debug("Trying another candidate centroid");
candidateCentroid = patterns.get(randomPattern.nextInt(patterns.size())).data.getClone();
}
}
chosenCentroids.add(candidateCentroid);
+ logger.debug("Adding candidate centroid " + i);
}
return chosenCentroids;
}
@@ -123,6 +129,9 @@ public class KMeansPlusPlusCentroidsInitialisationStrategy implements CentroidsI
}
probability += denominator;
}
+ logger.debug("numerator = " + numerator);
+ logger.debug("denominator = " + probability);
+ logger.debug("probability = " + numerator / probability);
return numerator / probability;
}
}
diff --git a/src/main/java/net/sourceforge/cilib/cooperative/CooperativeEntity.java b/src/main/java/net/sourceforge/cilib/cooperative/CooperativeEntity.java
index 38723b4..faefa8d 100644
--- a/src/main/java/net/sourceforge/cilib/cooperative/CooperativeEntity.java
+++ b/src/main/java/net/sourceforge/cilib/cooperative/CooperativeEntity.java
@@ -23,75 +23,81 @@ package net.sourceforge.cilib.cooperative;
import net.sourceforge.cilib.entity.AbstractEntity;
import net.sourceforge.cilib.entity.Entity;
+import net.sourceforge.cilib.problem.CooperativeOptimisationProblemAdapter;
import net.sourceforge.cilib.problem.Fitness;
import net.sourceforge.cilib.problem.InferiorFitness;
import net.sourceforge.cilib.problem.OptimisationProblem;
import net.sourceforge.cilib.type.types.Numeric;
import net.sourceforge.cilib.type.types.Type;
-import net.sourceforge.cilib.type.types.container.StructuredType;
-import net.sourceforge.cilib.type.types.container.TypeList;
import net.sourceforge.cilib.type.types.container.Vector;
/**
+ * The cooperative entity is used in cooperative multi-population based algorithms such as the
+ * {@link SplitCooperativeAlgorithm} in conjunction with the {@link CooperativeOptimisationProblemAdapter}. It
+ * represents the context, which is a possible solution to the problem being optimised, and is usually a combination of
+ * smaller entities which represent the solutions to sub-problems.
*
* @author Theuns Cloete
*/
public class CooperativeEntity extends AbstractEntity {
private static final long serialVersionUID = -8298684370426283216L;
- protected Vector context = null;
protected Fitness fitness = null;
public CooperativeEntity() {
- context = new Vector();
fitness = InferiorFitness.instance();
}
public CooperativeEntity(CooperativeEntity rhs) {
- context = rhs.context.getClone();
- fitness = rhs.fitness;
+ super(rhs);
+ fitness = rhs.fitness.getClone();
}
+ @Override
public CooperativeEntity getClone() {
return new CooperativeEntity(this);
}
@Override
public boolean equals(Object object) {
- if (this == object)
+ if (this == object) {
return true;
+ }
- if ((object == null) || (this.getClass() != object.getClass()))
+ if ((object == null) || (this.getClass() != object.getClass())) {
return false;
+ }
CooperativeEntity other = (CooperativeEntity) object;
- return super.equals(other) &&
- (this.context.equals(other.context)) &&
- (this.fitness.equals(other.fitness));
+ return super.equals(other) && this.fitness.equals(other.fitness);
}
@Override
public int hashCode() {
int hash = 7;
hash = 31 * hash + super.hashCode();
- hash = 31 * hash + (this.context == null ? 0 : this.context.hashCode());
hash = 31 * hash + (this.fitness == null ? 0 : this.fitness.hashCode());
return hash;
}
public void reset() {
- context.clear();
+ this.getCandidateSolution().clear();
}
+ @Override
public int compareTo(Entity o) {
return getFitness().compareTo(o.getFitness());
}
public void append(Type value) {
- if(value instanceof Vector)
+ Vector context = (Vector) this.getCandidateSolution();
+
+ if (value instanceof Vector) {
context.append((Vector) value);
- else
+ }
+ else {
context.append((Numeric) value);
+ }
}
public void append(Entity entity) {
@@ -99,28 +105,33 @@ public class CooperativeEntity extends AbstractEntity {
}
public void update(Entity src, int srcPos, int dstPos, int length) {
- for(int i = dstPos; i < dstPos + length; ++i) {
+ Vector context = (Vector) this.getCandidateSolution();
+
+ for (int i = dstPos; i < dstPos + length; ++i) {
context.setReal(i, ((Vector) src.getCandidateSolution()).getReal(srcPos + i - dstPos));
}
}
-
+ /*
public StructuredType getCandidateSolution() {
- return context;
+ return context;
}
public void setCandidateSolution(Type type) {
- context.clear();
- append(type);
+ context.clear();
+ append(type);
}
+ */
+ @Override
public int getDimension() {
- return context.getDimension();
+ return ((Vector) this.getCandidateSolution()).getDimension();
}
public void setDimension(int dim) {
throw new UnsupportedOperationException("The dimension of a CooperativeEntity is determined by its context");
}
+ @Override
public Fitness getFitness() {
return fitness;
}
@@ -129,18 +140,22 @@ public class CooperativeEntity extends AbstractEntity {
fitness = f;
}
+ @Override
public void initialise(OptimisationProblem problem) {
- context = (Vector) problem.getDomain().getBuiltRepresenation().getClone();
+ this.setCandidateSolution(problem.getDomain().getBuiltRepresenation().getClone());
}
+ @Override
public void reinitialise() {
- throw new UnsupportedOperationException("Methd not implemented");
+ ((Vector) this.getCandidateSolution()).randomize();
}
+ @Override
public void calculateFitness() {
calculateFitness(true);
}
+ @Override
public void calculateFitness(boolean count) {
fitness = getFitnessCalculator().getFitness(this, count);
}
diff --git a/src/main/java/net/sourceforge/cilib/functions/clustering/ClusteringFitnessFunction.java b/src/main/java/net/sourceforge/cilib/functions/clustering/ClusteringFitnessFunction.java
index a60d7d5..c3a1514 100644
--- a/src/main/java/net/sourceforge/cilib/functions/clustering/ClusteringFitnessFunction.java
+++ b/src/main/java/net/sourceforge/cilib/functions/clustering/ClusteringFitnessFunction.java
@@ -113,7 +113,8 @@ public abstract class ClusteringFitnessFunction extends ContinuousFunction {
return worstFitness();
}
- return validateFitness(calculateFitness());
+ return calculateFitness();
+// return validateFitness(calculateFitness());
}
public abstract double calculateFitness();
@@ -387,6 +388,7 @@ public abstract class ClusteringFitnessFunction extends ContinuousFunction {
*
* @param fitness the fitness value that will be validated.
* @return the fitness.
+ * @deprecated depending on the distance measure used, a negative fitness function may be allowed
*/
protected double validateFitness(double fitness) {
if (fitness < 0.0) {
diff --git a/src/main/java/net/sourceforge/cilib/measurement/single/clustering/PlotClustersAndCentroids.java b/src/main/java/net/sourceforge/cilib/measurement/single/clustering/PlotClustersAndCentroids.java
index 0f9a6cd..3cd6101 100644
--- a/src/main/java/net/sourceforge/cilib/measurement/single/clustering/PlotClustersAndCentroids.java
+++ b/src/main/java/net/sourceforge/cilib/measurement/single/clustering/PlotClustersAndCentroids.java
@@ -80,12 +80,12 @@ public class PlotClustersAndCentroids implements Measurement {
for (Pattern pattern : cluster.values()) {
System.out.println(pattern);
}
- System.out.println('e');
+ System.out.println("e");
}
for (Vector centroid : arrangedCentroids) {
System.out.println(centroid.toString('\0', '\0', '\t'));
- System.out.println('e');
+ System.out.println("e");
}
return new Int(0, 0);
}
diff --git a/src/main/java/net/sourceforge/cilib/measurement/single/clustering/PlotHighDimensionalClustersAndCentroids.java b/src/main/java/net/sourceforge/cilib/measurement/single/clustering/PlotHighDimensionalClustersAndCentroids.java
new file mode 100644
index 0000000..9db85cc
--- /dev/null
+++ b/src/main/java/net/sourceforge/cilib/measurement/single/clustering/PlotHighDimensionalClustersAndCentroids.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2003 - 2008
+ * Computational Intelligence Research Group (CIRG@UP)
+ * Department of Computer Science
+ * University of Pretoria
+ * South Africa
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package net.sourceforge.cilib.measurement.single.clustering;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Hashtable;
+import net.sourceforge.cilib.algorithm.Algorithm;
+import net.sourceforge.cilib.measurement.Measurement;
+import net.sourceforge.cilib.problem.dataset.Pattern;
+import net.sourceforge.cilib.type.types.Int;
+import net.sourceforge.cilib.type.types.Type;
+import net.sourceforge.cilib.type.types.container.Vector;
+import net.sourceforge.cilib.util.ClusteringUtils;
+
+/**
+ * This measurement is handy when debugging a clustering in R^n space using GNUplot. Logging should be disabled and no
+ * other output should be written to standard out. To try it, start GNUplot, execute:<br/>
+ * load "<./simulator.sh path/to/your/cilib.config.file.xml -noprogress"<br/>
+ * and enjoy.
+ *
+ * @author Theuns Cloete
+ */
+public class PlotHighDimensionalClustersAndCentroids implements Measurement {
+
+ @Override
+ public Measurement getClone() {
+ return this;
+ }
+
+ @Override
+ public String getDomain() {
+ return "Z";
+ }
+
+ @Override
+ public Type getValue(Algorithm algorithm) {
+ ClusteringUtils helper = ClusteringUtils.get();
+ Vector centroids = (Vector) algorithm.getBestSolution().getPosition();
+ helper.arrangeClustersAndCentroids(centroids);
+
+ System.out.println("reset");
+ System.out.println("set term jpeg medium");
+ System.out.println("set style data lines");
+ System.out.println("set key off");
+
+
+ ArrayList<Hashtable<Integer, Pattern>> arrangedClusters = helper.getArrangedClusters();
+ ArrayList<Vector> arrangedCentroids = helper.getArrangedCentroids();
+ int iteration = Algorithm.get().getIterations();
+
+ this.plotCentroids(iteration, arrangedCentroids);
+ this.plotClustersWithCentroids(iteration, arrangedClusters, arrangedCentroids);
+
+ return new Int(0, 0);
+ }
+
+ private void plotCentroids(int iteration, ArrayList<Vector> centroids) {
+ System.out.println("set output \"centroids.all.iteration." + String.format("%04d", iteration) + ".jpg\"");
+ System.out.println("set title 'Iteration " + iteration + ": Centroids (" + centroids.size() + ")'");
+ System.out.print("plot ");
+
+ for (int i = 0; i < centroids.size(); ++i) {
+ System.out.print("'-' title 'centroid " + i + "'");
+ if (i < centroids.size() - 1) {
+ System.out.print(", ");
+ }
+ }
+ System.out.println();
+
+ for (Vector centroid : centroids) {
+ for (int i = 0; i < centroid.size(); ++i) {
+ System.out.println(String.format("%d\t%f", i, centroid.getReal(i)));
+ }
+ System.out.println("e");
+ }
+ }
+
+ private void plotClustersWithCentroids(int iteration, ArrayList<Hashtable<Integer, Pattern>> clusters, ArrayList<Vector> centroids) {
+ for (int i = 0; i < clusters.size(); ++i) {
+ System.out.println("set output \"cluster." + String.format("%02d", i) + ".iteration."+ String.format("%04d", iteration) + ".jpg\"");
+
+ plotClusterWithCentroid(iteration, i, clusters.get(i).values(), centroids.get(i));
+ }
+ }
+
+ private void plotClusterWithCentroid(int iteration, int id, Collection<Pattern> cluster, Vector centroid) {
+ System.out.println("set title 'Iteration " + iteration + ": Cluster " + id + " (" + cluster.size() + " patterns)'");
+ System.out.print("plot ");
+
+ for (Pattern pattern : cluster) {
+ System.out.print("'-' title '" + pattern.clazz + "', ");
+ }
+
+ System.out.println("'-' title 'centroid' linetype 1 linewidth 5");
+
+ for (Pattern pattern : cluster) {
+ Vector vector = pattern.data;
+
+ for (int i = 0; i < vector.size(); ++i) {
+ System.out.println(String.format("%d\t%f", i, vector.getReal(i)));
+ }
+ System.out.println("e");
+ }
+
+ for (int i = 0; i < centroid.size(); ++i) {
+ System.out.println(String.format("%d\t%f", i, centroid.getReal(i)));
+ }
+ System.out.println("e");
+ }
+}
diff --git a/src/main/java/net/sourceforge/cilib/problem/CooperativeOptimisationProblemAdapter.java b/src/main/java/net/sourceforge/cilib/problem/CooperativeOptimisationProblemAdapter.java
index 8d45549..fd22cce 100644
--- a/src/main/java/net/sourceforge/cilib/problem/CooperativeOptimisationProblemAdapter.java
+++ b/src/main/java/net/sourceforge/cilib/problem/CooperativeOptimisationProblemAdapter.java
@@ -59,7 +59,7 @@ public class CooperativeOptimisationProblemAdapter extends OptimisationProblemAd
offset = o;
domainRegistry = new StringBasedDomainRegistry();
String expandedDomain = "";
- for (int i = offset; i < offset + dimension; i++) {
+ for (int i = offset; i < offset + dimension; ++i) {
String tmp = TypeUtil.getRepresentation(((Vector) context.getCandidateSolution()).get(i));
expandedDomain += tmp;//((Vector) context.getCandidateSolution()).get(i).getRepresentation();
if (i < offset + dimension - 1)
@@ -82,6 +82,7 @@ public class CooperativeOptimisationProblemAdapter extends OptimisationProblemAd
offset = copy.offset;
}
+ @Override
public CooperativeOptimisationProblemAdapter getClone() {
return new CooperativeOptimisationProblemAdapter(this);
}
@@ -107,13 +108,18 @@ public class CooperativeOptimisationProblemAdapter extends OptimisationProblemAd
return problem.getFitness(context.getCandidateSolution(), true);
}
+ public OptimisationProblem getWrappingProblem() {
+ return this.problem;
+ }
+
+ @Override
public DomainRegistry getDomain() {
return domainRegistry;
}
+ @Override
public DomainRegistry getBehaviouralDomain() {
- // QUESTION What exactly does the problem.getBehaviouralDomain() method return and what is
- // really needed?
+ // QUESTION What exactly does the problem.getBehaviouralDomain() method return and what is really needed?
return domainRegistry;
}
}
diff --git a/src/main/java/net/sourceforge/cilib/problem/dataset/Pattern.java b/src/main/java/net/sourceforge/cilib/problem/dataset/Pattern.java
index a6bfa0b..bcd8cec 100644
--- a/src/main/java/net/sourceforge/cilib/problem/dataset/Pattern.java
+++ b/src/main/java/net/sourceforge/cilib/problem/dataset/Pattern.java
@@ -1,4 +1,4 @@
-/**
+/*
* Copyright (C) 2003 - 2008
* Computational Intelligence Research Group (CIRG@UP)
* Department of Computer Science
@@ -27,16 +27,17 @@ import net.sourceforge.cilib.type.types.container.Vector;
public class Pattern implements Cloneable, Serializable {
private static final long serialVersionUID = 3018524182531891291L;
- private String clas = "<not set>";
+
+ public String clazz = "<not set>";
public Vector data = null;
public Pattern(String c, Vector d) {
- clas = c;
+ clazz = c;
data = d;
}
public Pattern(Pattern rhs) {
- clas = rhs.clas;
+ clazz = rhs.clazz;
data = rhs.data;
}
@@ -46,6 +47,6 @@ public class Pattern implements Cloneable, Serializable {
@Override
public String toString() {
- return data.toString('\0', '\0', '\t') + '\t' + clas;
+ return data.toString('\0', '\0', '\t') + '\t' + clazz;
}
}
diff --git a/src/main/java/net/sourceforge/cilib/pso/dynamic/ChargedVelocityUpdateStrategy.java b/src/main/java/net/sourceforge/cilib/pso/dynamic/ChargedVelocityUpdateStrategy.java
index 2f2346b..fd7b8c0 100644
--- a/src/main/java/net/sourceforge/cilib/pso/dynamic/ChargedVelocityUpdateStrategy.java
+++ b/src/main/java/net/sourceforge/cilib/pso/dynamic/ChargedVelocityUpdateStrategy.java
@@ -37,10 +37,13 @@ import net.sourceforge.cilib.util.EuclideanDistanceMeasure;
import net.sourceforge.cilib.util.VectorUtils;
/**
- * This is the velocity update mechanism that the Charged PSO makes use of. This is an
- * implementation of the original Charged PSO algorithm developed by Blackwell and Bentley
- * and then further improved by Blackwell and Branke. NOTE: A requirement for this velocity
- * update to produce good results is that coreRadius < perceptionLimit
+ * This is the velocity update mechanism that the ChargedPSO makes use of. This is an implementation of the original
+ * charged velocity update mechanism used for the ChargedPSO algorithm developed by Blackwell and Bentley and then
+ * further improved by Blackwell and Branke. NOTE: A requirement for this velocity update to produce good results is
+ * that <code>coreRadius < perceptionLimit</code>. A user-specified {@link VelocityUpdateStrategy} can also be given
+ * and this class will effectively adapt it into having <i>charged</i> behaviour. The default wrapped velocity update
+ * strategy is the {@link StandardVelocityUpdate} which causes this velocity update strategy to adhere to the original
+ * ChargedPSO implementation.
*
* @author Anna Rakitianskaia
* @author Theuns Cloete
@@ -67,11 +70,20 @@ public class ChargedVelocityUpdateStrategy implements VelocityUpdateStrategy {
this.distanceMeasure = rhs.distanceMeasure;
}
+ /**
+ * {@inheritDoc}
+ */
@Override
public ChargedVelocityUpdateStrategy getClone() {
return new ChargedVelocityUpdateStrategy(this);
}
+ /**
+ * First perform the velocity update as configured for the
+ * {@link #velocityUpdateStrategy wrapped velovity update strategy} and then add a charge if required.
+ *
+ * {@inheritDoc}
+ */
@Override
public void updateVelocity(Particle particle) {
// perform the standard (wrapped / decorated) velocity update
diff --git a/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/ArchiveReevaluationResponseStrategy.java b/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/ArchiveReevaluationResponseStrategy.java
index 2ae1f2b..a4dcd8e 100644
--- a/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/ArchiveReevaluationResponseStrategy.java
+++ b/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/ArchiveReevaluationResponseStrategy.java
@@ -1,4 +1,4 @@
-/**
+/*
* Copyright (C) 2003 - 2008
* Computational Intelligence Research Group (CIRG@UP)
* Department of Computer Science
@@ -19,7 +19,6 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-
package net.sourceforge.cilib.pso.dynamic.responsestrategies;
import java.util.LinkedList;
@@ -45,7 +44,7 @@ public class ArchiveReevaluationResponseStrategy extends EnvironmentChangeRespon
}
@Override
- protected void performReaction(PopulationBasedAlgorithm algorithm) {
+ protected void performResponse(PopulationBasedAlgorithm algorithm) {
for (Entity entity : algorithm.getTopology()) {
entity.getProperties().put(EntityType.Particle.BEST_FITNESS, entity.getFitnessCalculator().getFitness(entity, true));
//entity.getProperties().put(EntityType.Particle.BEST_POSITION, entity.getCandidateSolution());
diff --git a/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/LeastFitReinitialisationResponseStrategy.java b/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/LeastFitReinitialisationResponseStrategy.java
new file mode 100644
index 0000000..2f26cee
--- /dev/null
+++ b/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/LeastFitReinitialisationResponseStrategy.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2003 - 2008
+ * Computational Intelligence Research Group (CIRG@UP)
+ * Department of Computer Science
+ * University of Pretoria
+ * South Africa
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+package net.sourceforge.cilib.pso.dynamic.responsestrategies;
+
+import java.util.List;
+import net.sourceforge.cilib.algorithm.population.PopulationBasedAlgorithm;
+import net.sourceforge.cilib.container.SortedList;
+import net.sourceforge.cilib.entity.Entity;
+import net.sourceforge.cilib.type.types.TypeUtil;
+
+/**
+ * @author Theuns Cloete
+ */
+public class LeastFitReinitialisationResponseStrategy<E extends PopulationBasedAlgorithm> extends ReinitializationResponseStrategy<E> {
+
+ /**
+ * Reinitialise the least fit entities in the provided list.
+ *
+ * @param entities a {@link List} of entities that should be considered for reinitialization
+ * @param reinitializeCount the number of least fit entities that should be reinitialized
+ */
+ @Override
+ protected void reinitialize(List<? extends Entity> entities, int reinitializeCount) {
+ SortedList<Entity> sortedList = new SortedList<Entity>();
+ sortedList.addAll(entities);
+
+ for (int i = 0; i < reinitializeCount; ++i) {
+ Entity entity = sortedList.get(i);
+ TypeUtil.randomize(entity.getCandidateSolution());
+
+ entity.calculateFitness();
+ }
+ }
+}
diff --git a/src/main/java/net/sourceforge/cilib/util/ChebyshevDistanceMeasure.java b/src/main/java/net/sourceforge/cilib/util/ChebyshevDistanceMeasure.java
index c42edeb..ddab6d4 100644
--- a/src/main/java/net/sourceforge/cilib/util/ChebyshevDistanceMeasure.java
+++ b/src/main/java/net/sourceforge/cilib/util/ChebyshevDistanceMeasure.java
@@ -27,7 +27,6 @@ import java.util.Iterator;
import net.sourceforge.cilib.type.types.Numeric;
import net.sourceforge.cilib.type.types.Type;
import net.sourceforge.cilib.type.types.container.StructuredType;
-import net.sourceforge.cilib.type.types.container.Vector;
/**
* Chebyshev Distance is a special case of the
@@ -76,6 +75,7 @@ public class ChebyshevDistanceMeasure extends MinkowskiMetric {
/**
* {@inheritDoc}
*/
+ @Override
public <T extends Collection<? extends Number>> double distance(T x, T y) {
/*
* TODO: Consider re-implementing for different sized collections, especially as everything is
@@ -100,6 +100,7 @@ public class ChebyshevDistanceMeasure extends MinkowskiMetric {
/**
* {@inheritDoc}
*/
+ @Override
public void setAlpha(int a) {
throw new IllegalArgumentException("The 'alpha' parameter of the Chebyshev Distance Measure cannot be set directly");
}
diff --git a/src/main/java/net/sourceforge/cilib/util/ClusteringUtils.java b/src/main/java/net/sourceforge/cilib/util/ClusteringUtils.java
index d8c2972..5ddca83 100644
--- a/src/main/java/net/sourceforge/cilib/util/ClusteringUtils.java
+++ b/src/main/java/net/sourceforge/cilib/util/ClusteringUtils.java
@@ -28,6 +28,8 @@ import java.util.Hashtable;
import net.sourceforge.cilib.algorithm.Algorithm;
import net.sourceforge.cilib.functions.clustering.ClusteringFitnessFunction;
import net.sourceforge.cilib.problem.ClusteringProblem;
+import net.sourceforge.cilib.problem.CooperativeOptimisationProblemAdapter;
+import net.sourceforge.cilib.problem.OptimisationProblem;
import net.sourceforge.cilib.problem.dataset.DataSet;
import net.sourceforge.cilib.problem.dataset.DataSetBuilder;
import net.sourceforge.cilib.problem.dataset.DataSetManager;
@@ -87,7 +89,15 @@ public final class ClusteringUtils {
if (clusteringProblem == null || dataSetBuilder == null) {
try {
Algorithm algorithm = Algorithm.get();
- clusteringProblem = (ClusteringProblem) algorithm.getOptimisationProblem();
+ OptimisationProblem problem = algorithm.getOptimisationProblem();
+
+ if (problem instanceof ClusteringProblem) {
+ clusteringProblem = (ClusteringProblem) problem;
+ }
+ else if (problem instanceof CooperativeOptimisationProblemAdapter) {
+ clusteringProblem = (ClusteringProblem) (((CooperativeOptimisationProblemAdapter) problem).getWrappingProblem());
+ }
+
dataSetBuilder = (StaticDataSetBuilder) clusteringProblem.getDataSetBuilder();
logger.info("Initialised Algorithm found: " + ClusteringUtils.class.getSimpleName() + " is now configured");
diff --git a/src/main/java/net/sourceforge/cilib/util/CosineDistanceMeasure.java b/src/main/java/net/sourceforge/cilib/util/CosineDistanceMeasure.java
index 874abdc..ba399cf 100644
--- a/src/main/java/net/sourceforge/cilib/util/CosineDistanceMeasure.java
+++ b/src/main/java/net/sourceforge/cilib/util/CosineDistanceMeasure.java
@@ -83,7 +83,9 @@ public class CosineDistanceMeasure implements DistanceMeasure {
if(norm_x <= 0.0 || norm_y <= 0.0)
throw new ArithmeticException("Division by zero");
- // TODO: return x.dot(y) ???
+ // TODO: the following (single line) statement returns exactly the same value
+ // TODO: but x and y should then be Vectors
+ // return 1.0 - (x.dot(y) / (x.norm() * y.norm())); ???
//convert to distance by subtracting from 1
return 1.0 - (distance / (norm_x * norm_y));
diff --git a/src/main/java/net/sourceforge/cilib/util/AbsoluteDistanceMeasure.java b/src/main/java/net/sourceforge/cilib/util/HammingDistanceMeasure.java
similarity index 54%
rename from src/main/java/net/sourceforge/cilib/util/AbsoluteDistanceMeasure.java
rename to src/main/java/net/sourceforge/cilib/util/HammingDistanceMeasure.java
index 14f3485..f0fa78e 100644
--- a/src/main/java/net/sourceforge/cilib/util/AbsoluteDistanceMeasure.java
+++ b/src/main/java/net/sourceforge/cilib/util/HammingDistanceMeasure.java
@@ -23,61 +23,65 @@ package net.sourceforge.cilib.util;
import java.util.Collection;
import java.util.Iterator;
-
import net.sourceforge.cilib.type.types.Numeric;
import net.sourceforge.cilib.type.types.Type;
import net.sourceforge.cilib.type.types.container.StructuredType;
/**
- * @deprecated Make use of {@link net.sourceforge.cilib.util.ManhattanDistance Manhattan Distance}. It is the correct name.
- * @author Edwin Peer
+ * Calculates the Hamming distance between two points. As an example, the Hamming distance between the two vectors<br/>
+ * [1, 2, 3, 4, 5] and<br/>
+ * [1, 5, 3, 2, 4]<br/>
+ * is 3.<br/>
+ * In other words, it counts the number of elements that are different.
+ *
+ * @author Theuns Cloete
*/
-@Deprecated
-public class AbsoluteDistanceMeasure implements DistanceMeasure {
-
+public class HammingDistanceMeasure implements DistanceMeasure {
/**
* {@inheritDoc}
*/
+ @Override
public <T extends Type, U extends StructuredType<T>> double distance(U x, U y) {
if (x.size() != y.size()) {
- throw new IllegalArgumentException("Unmatched argument lengths");
+ throw new IllegalArgumentException("Cannot calculate Hamming Distance for vectors of different dimensions: " + x.size() + " != " + y.size());
}
Iterator<T> xIterator = x.iterator();
Iterator<T> yIterator = y.iterator();
+ int distance = 0;
- double distance = 0;
for (int i = 0; i < x.size(); ++i) {
- Numeric xNumeric = (Numeric) xIterator.next();
- Numeric yNumeric = (Numeric) yIterator.next();
+ Numeric xElement = (Numeric) xIterator.next();
+ Numeric yElement = (Numeric) yIterator.next();
- distance += Math.abs(xNumeric.getReal() - yNumeric.getReal());
+ if (xElement.getReal() != yElement.getReal()) {
+ ++distance;
+ }
}
-
return distance;
}
/**
* {@inheritDoc}
*/
+ @Override
public <T extends Collection<? extends Number>> double distance(T x, T y) {
- if (x.size() != y.size())
- throw new IllegalArgumentException("Unmatched argument lengths");
-
- double distance = 0;
- Iterator<? extends Number> i = x.iterator();
- Iterator<? extends Number> j = y.iterator();
+ if (x.size() != y.size()) {
+ throw new IllegalArgumentException("Cannot calculate Hamming Distance for vectors of different dimensions: " + x.size() + " != " + y.size());
+ }
- while (i.hasNext() && j.hasNext()) {
- Number n1 = i.next();
- Number n2 = j.next();
+ Iterator<? extends Number> xIterator = x.iterator();
+ Iterator<? extends Number> yIterator = y.iterator();
+ int distance = 0;
- double tmp = Math.abs(n1.doubleValue() - n2.doubleValue());
+ while (xIterator.hasNext() && yIterator.hasNext()) {
+ double xElement = xIterator.next().doubleValue();
+ double yElement = yIterator.next().doubleValue();
- distance += tmp;
+ if (xElement != yElement) {
+ ++distance;
+ }
}
-
return distance;
}
-
}
diff --git a/xml/kmeans.xml b/xml/kmeans.xml
index 7421622..f0bc119 100644
--- a/xml/kmeans.xml
+++ b/xml/kmeans.xml
@@ -17,9 +17,9 @@
<centroidsInitialisationStrategy class="clustering.kmeans.DataSetBasedCentroidsInitialisationStrategy"/>
</algorithm>
- <algorithm id="kmeans.plusplus" class="clustering.kmeans.KMeans">
+ <algorithm id="kmeans.potential" class="clustering.kmeans.KMeans">
<addStoppingCondition class="stoppingcondition.MaximumIterations" maximumIterations="100"/>
- <centroidsInitialisationStrategy class="clustering.kmeans.KMeansPlusPlusCentroidsInitialisationStrategy"/>
+ <centroidsInitialisationStrategy class="clustering.kmeans.ContributingPotentialCentroidsInitialisationStrategy"/>
<centroidsDiversificationStrategy class="clustering.kmeans.StandardCentroidsDiversificationStrategy" interval="1" diversifyRatio="0.1" />
</algorithm>
</algorithms>
@@ -37,7 +37,8 @@
<measurements id="measurements" class="simulator.MeasurementSuite" resolution="1" samples="1">
<addMeasurement class="measurement.single.Fitness" />
-<!-- <addMeasurement class="measurement.single.GenericFunctionMeasurement">
+<!--
+ <addMeasurement class="measurement.single.GenericFunctionMeasurement">
<function class="functions.clustering.InterClusterDistance" />
</addMeasurement>
<addMeasurement class="measurement.single.GenericFunctionMeasurement">
@@ -62,9 +63,9 @@
</simulation>
<simulation>
- <algorithm idref="kmeans.plusplus"/>
+ <algorithm idref="kmeans.potential"/>
<problem idref="artificial.combined" numberOfClusters="4" />
- <measurements idref="measurements" file="measurements/kmeans.plusplus.artificial.4.txt" />
+ <measurements idref="measurements" file="measurements/kmeans.potential.artificial.4.txt" />
</simulation>
</simulations>
</simulator>
--
1.6.0.6
|
