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);
}
}
/** Test for Vincent Function */
@Test
public void testEvaluate() {
Vector x = Vector.of(5, 5);
assertEquals(-0.246258053, function.apply(x), 0.000000009);
x.setReal(0, 10.0);
x.setReal(1, 10.0);
assertEquals(0.719420726, function.apply(x), 0.000000009);
x.setReal(0, 8.0);
x.setReal(1, 8.0);
assertEquals(-2.861700698, function.apply(x), 0.000000009);
}
/**
* Calculate the {@linkplain Vector} that is the resultant of several difference vectors.
*
* @param participants The {@linkplain Entity} list to create the difference vectors from. It is
* very important to note that the {@linkplain Entity} objects within this list should not
* contain duplicates. If duplicates are contained, this will severely reduce the diversity of
* the population as not all entities will be considered.
* @return A {@linkplain Vector} representing the resultant of all calculated difference vectors.
*/
protected Vector determineDistanceVector(List<Entity> participants) {
RandomProvider random = new MersenneTwister();
Vector distanceVector = Vector.fill(0.0, participants.get(0).getCandidateSolution().size());
Iterator<Entity> iterator;
int number = Double.valueOf(this.numberOfDifferenceVectors.getParameter()).intValue();
List<Entity> currentParticipants;
Vector first, second;
double difference;
for (int d = 0; d < distanceVector.size(); d++) {
// get random participants for this dimension
currentParticipants =
(List<Entity>)
Selection.copyOf(participants)
.orderBy(new RandomArrangement(random))
.select(Samples.first(number));
iterator = currentParticipants.iterator();
while (iterator.hasNext()) {
first = (Vector) iterator.next().getCandidateSolution();
second = (Vector) iterator.next().getCandidateSolution();
difference = first.doubleValueOf(d) - second.doubleValueOf(d);
distanceVector.setReal(d, distanceVector.get(d).doubleValue() + difference);
}
}
return distanceVector;
}
/** {@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);
}
/** {@inheritDoc} */
@Override
public Double apply(Vector input) {
Vector tmp = input.getClone();
for (int i = 0; i < input.size(); i++) {
tmp.setReal(i, (horizontalScale * input.doubleValueOf(i)));
}
return (verticalScale * function.apply(tmp));
}
/** Test of evaluate method, of class {@link Neumaier3}. */
@Test
public void testApply() {
Vector x = Vector.of(0.0, 2.0);
assertEquals(2.0, function.f(x), Maths.EPSILON);
x.setReal(0, 2.0);
x.setReal(1, 2.0);
assertEquals(-2.0, function.f(x), Maths.EPSILON);
}
/** {@inheritDoc} */
@Override
public void algorithmIteration() {
// TO-DO: Make sure that all fitnesses are evaluated initially, and
// that FE is incremented only once per iteration
// calculate a new harmony
Harmony newHarmony = new Harmony();
newHarmony.initialise(getOptimisationProblem());
Vector newHarmonyVector = (Vector) newHarmony.getCandidateSolution();
OptimisationProblem problem = getOptimisationProblem();
// Real newHarmonyValue;
for (int i = 0; i < problem.getDomain().getDimension(); ++i) {
if (uniform1.getRandomNumber() < harmonyMemoryConsideringRate.getParameter()) {
Harmony selectedHarmony =
this.harmonyMemory.get((int) uniform2.getRandomNumber(0, harmonyMemory.size() - 1));
Vector selectedHarmonyContents = (Vector) selectedHarmony.getCandidateSolution();
double newHarmonyValue = selectedHarmonyContents.doubleValueOf(i);
Bounds bounds = selectedHarmonyContents.boundsOf(i);
if (uniform1.getRandomNumber() < pitchAdjustingRate.getParameter()) {
double pitchedValue =
newHarmonyValue + uniform3.getRandomNumber(-1, 1) * distanceBandwidth.getParameter();
if ((pitchedValue > bounds.getLowerBound()) && (pitchedValue < bounds.getUpperBound())) {
newHarmonyValue = pitchedValue;
}
}
newHarmonyVector.setReal(i, newHarmonyValue);
} else {
double upper =
((Vector) problem.getDomain().getBuiltRepresenation()).boundsOf(i).getUpperBound();
double lower =
((Vector) problem.getDomain().getBuiltRepresenation()).boundsOf(i).getLowerBound();
newHarmonyVector.setReal(i, uniform3.getRandomNumber(lower, upper));
}
}
newHarmony.calculateFitness();
harmonyMemory.add(newHarmony);
harmonyMemory.remove(
harmonyMemory.get(0) /*getFirst()*/); // Remove the worst harmony in the memory
}
@Override
public void initialize(Enum<?> key, E entity) {
Type type = entity.getProperties().get(key);
Vector velocity = (Vector) type;
for (int i = 0; i < velocity.size(); i++) {
changeBoundsForNextDimension(i);
velocity.setReal(
i, random.getRandomNumber(lowerBound.getParameter(), upperBound.getParameter()));
}
}
/** {@inheritDoc} */
@Override
public Double apply(Vector input) {
Vector tmp = input.getClone();
if (horizontalReflection) {
for (int i = 0; i < input.size(); i++) {
tmp.setReal(i, -input.doubleValueOf(i));
}
}
if (verticalReflection) {
return -function.apply(tmp);
}
return function.apply(tmp);
}
/**
* Reinitialises all the output weights of a cascade network within a PSO.
*
* <p>{@inheritDoc}
*/
@Override
public void performReaction(E algorithm) {
NNDataTrainingProblem problem = (NNDataTrainingProblem) algorithm.getOptimisationProblem();
NeuralNetwork network = problem.getNeuralNetwork();
int precedingLayersSize =
network.getArchitecture().getArchitectureBuilder().getLayerConfigurations().get(0).getSize()
+ network
.getArchitecture()
.getArchitectureBuilder()
.getLayerConfigurations()
.get(1)
.getSize();
if (network.getArchitecture().getArchitectureBuilder().getLayerConfigurations().get(0).isBias())
precedingLayersSize++;
int outputLayerSize =
network
.getArchitecture()
.getArchitectureBuilder()
.getLayerConfigurations()
.get(2)
.getSize();
int nrOfweightsToDo = precedingLayersSize * outputLayerSize;
Topology<? extends Entity> entities = algorithm.getTopology();
for (Entity entity : entities) {
DynamicParticle particle = (DynamicParticle) entity;
Vector position = (Vector) particle.getPosition();
Vector velocity = (Vector) particle.getVelocity();
for (int curElement = position.size() - nrOfweightsToDo;
curElement < position.size();
++curElement) {
((Real) position.get(curElement)).randomize(randomGenerator);
velocity.setReal(curElement, 0.0);
}
}
}
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));//;
}
}
}
