/** {@inheritDoc} */
@Override
public Vector get(Particle particle) {
Vector localGuide = (Vector) particle.getLocalGuide();
Vector globalGuide = (Vector) particle.getGlobalGuide();
PSO pso = (PSO) AbstractAlgorithm.get();
List<Entity> positions = getRandomParentEntities(pso.getTopology());
// select three random individuals, all different and different from particle
ProbabilityDistributionFuction pdf = new UniformDistribution();
Vector position1 = (Vector) positions.get(0).getCandidateSolution();
Vector position2 = (Vector) positions.get(1).getCandidateSolution();
// Vector position3 = (Vector) positions.get(2).getContents();
Vector.Builder builder = Vector.newBuilder();
for (int i = 0; i < particle.getDimension(); ++i) {
double r = pdf.getRandomNumber(0, 1);
double attractor = r * localGuide.doubleValueOf(i) + (1 - r) * globalGuide.doubleValueOf(i);
double stepSize =
this.rand3.getRandomNumber(0, 1)
* (position1.doubleValueOf(i) - position2.doubleValueOf(i));
if (this.rand2.getRandomNumber(0, 1) > this.crossoverProbability.getParameter()) {
builder.add(attractor + stepSize);
} else {
builder.add(((Vector) particle.getPosition()).doubleValueOf(i)); // position3.getReal(i));
}
}
return builder.build();
}
@Override
public Vector get(Particle particle) {
Vector localGuide = (Vector) particle.getLocalGuide(); // personal best (yi)
Vector globalGuide = (Vector) particle.getGlobalGuide(); // global best (y^i)
Vector.Builder builder = Vector.newBuilder();
for (int i = 0; i < particle.getDimension(); ++i) {
// double tmp1 = cognitive.getParameter();
// double tmp2 = social.getParameter();
double sigma = Math.abs(localGuide.doubleValueOf(i) - globalGuide.doubleValueOf(i));
if (sigma == 0) {
sigma = 1;
}
// System.out.println("Sigma: "+sigma);
// according to Kennedy
double mean = (localGuide.doubleValueOf(i) + globalGuide.doubleValueOf(i)) / 2;
// andries proposal: double mean = (tmp1*personalBestPosition.getReal(i) +
// tmp2*nBestPosition.getReal(i)) / (tmp1+tmp2);
if (Rand.nextDouble() < p) {
builder.add(
localGuide.doubleValueOf(i) + this.cauchyDistribution.getRandomNumber(mean, sigma));
} else {
builder.add(
globalGuide.doubleValueOf(i) + this.gaussianDistribution.getRandomNumber(mean, sigma));
}
}
return builder.build();
}
@Override
public Vector get(Particle particle) {
Vector velocity = (Vector) particle.getVelocity();
Vector position = (Vector) particle.getPosition();
PSO algorithm = (PSO) AbstractAlgorithm.get();
int ns = (int) nSize.getParameter();
fj.data.List<Particle> neighbours =
algorithm
.getTopology()
.sort(
Ord.ord(
VectorBasedFunctions.sortByDistance(particle, new EuclideanDistanceMeasure())))
.take(ns);
Vector.Builder builder = Vector.newBuilder();
for (int i = 0; i < particle.getDimension(); ++i) {
double informationSum = 0.0;
double randomSum = 0;
for (Particle currentTarget : neighbours) {
Vector currentTargetPosition = (Vector) currentTarget.getBestPosition();
double randomComponent = Rand.nextDouble() * (4.1 / ns);
informationSum += randomComponent * currentTargetPosition.doubleValueOf(i);
randomSum += randomComponent;
}
double value =
inertiaWeight.getParameter()
* (velocity.doubleValueOf(i)
+ randomSum * ((informationSum / (ns * randomSum) - position.doubleValueOf(i))));
builder.add(value);
}
return builder.build();
}
/**
* Convert the provided {@code representation} into a {@code Vector}.
*
* @param representation The {@code StructuredType} to convert.
* @return The converted vector object.
*/
private static Vector toVector(List<Type> representation) {
Vector.Builder vector = Vector.newBuilder();
for (Type type : representation) {
vector.add((Numeric) type);
}
return vector.build();
}
public static Vector normalise_z(Vector z, Vector z_max) {
Vector.Builder result = Vector.newBuilder();
for (int i = 0; i < z.size(); i++) {
Preconditions.checkArgument(z.doubleValueOf(i) >= 0.0);
Preconditions.checkArgument(z.doubleValueOf(i) <= z_max.doubleValueOf(i));
Preconditions.checkArgument(z_max.doubleValueOf(i) > 0.0);
result.add(z.doubleValueOf(i) / z_max.doubleValueOf(i));
}
return result.build();
}
@Override
public void performIteration(PSO algorithm) {
delegate.performIteration(algorithm);
Topology<Particle> topology = algorithm.getTopology();
// calculate vAvg
Vector avgV =
Vectors.mean(
Lists.transform(
topology,
new Function<Particle, Vector>() {
@Override
public Vector apply(Particle f) {
return (Vector) f.getVelocity();
}
}));
Vector.Builder builder = Vector.newBuilder();
for (Numeric n : avgV) {
if (Math.abs(n.doubleValue()) > vMax.getParameter()) {
builder.add(vMax.getParameter());
} else {
builder.add(n);
}
}
avgV = builder.build();
// mutation
Particle gBest = Topologies.getBestEntity(topology, new SocialBestFitnessComparator());
Particle mutated = gBest.getClone();
Vector pos = (Vector) gBest.getBestPosition();
final Bounds bounds = pos.boundsOf(0);
pos =
pos.plus(
avgV.multiply(
new Supplier<Number>() {
@Override
public Number get() {
return distribution.getRandomNumber() * bounds.getRange()
+ bounds.getLowerBound();
}
}));
mutated.setCandidateSolution(pos);
mutated.calculateFitness();
if (gBest.getBestFitness().compareTo(mutated.getFitness()) < 0) {
gBest.getProperties().put(EntityType.Particle.BEST_FITNESS, mutated.getBestFitness());
gBest.getProperties().put(EntityType.Particle.BEST_POSITION, mutated.getBestPosition());
}
}
/**
* @param bits
* @param dimensionBits
* @return
*/
public Vector decodeBitString(String bits, int dimensionBits) {
Vector.Builder vector = Vector.newBuilder();
for (int i = 0; i < bits.length(); ) {
double tmp = valueOf(bits, i, i + dimensionBits);
tmp = transform(tmp);
vector.add(tmp);
i += dimensionBits;
}
return vector.build();
}
/** Before each test, make a new StandardPatternDataTable object and add in the test data. */
@Before
public void setRawData() {
stringTargetPatterns = new StandardPatternDataTable();
vectorTargetPatterns = new StandardPatternDataTable();
Vector.Builder feature;
Type classification;
for (int i = 0; i < typedData.size() / 2; i++) {
feature = Vector.newBuilder();
List<Type> row = typedData.getRow(i);
for (int j = 0; j < row.size() - 1; j++) {
feature.add((Numeric) row.get(j));
}
classification = row.get(row.size() - 1).getClone();
stringTargetPatterns.addRow(new StandardPattern(feature.build(), classification));
}
for (int i = typedData.size() / 2; i < typedData.size(); i++) {
feature = Vector.newBuilder();
Vector.Builder classificationB = Vector.newBuilder();
List<Type> row = typedData.getRow(i);
for (int j = 0; j < row.size() - 3; j++) {
feature.add((Numeric) row.get(j));
}
for (int j = row.size() - 3; j < row.size(); j++) {
classificationB.add((Numeric) row.get(j));
}
vectorTargetPatterns.addRow(new StandardPattern(feature.build(), classificationB.build()));
}
}
public static Vector calculate_f(double D, Vector x, Vector h, Vector S) {
Preconditions.checkArgument(D > 0.0);
Preconditions.checkArgument(Misc.vector_in_01(x));
Preconditions.checkArgument(Misc.vector_in_01(h));
Preconditions.checkArgument(x.size() == h.size());
Preconditions.checkArgument(h.size() == S.size());
Vector.Builder result = Vector.newBuilder();
for (int i = 0; i < h.size(); i++) {
Preconditions.checkArgument(S.doubleValueOf(i) > 0.0);
result.add(D * x.doubleValueOf(x.size() - 1) + S.doubleValueOf(i) * h.doubleValueOf(i));
}
return result.build();
}
public static Vector calculate_x(Vector t_p, Vector A) {
Preconditions.checkArgument(Misc.vector_in_01(t_p));
Preconditions.checkArgument(!t_p.isEmpty());
Preconditions.checkArgument(A.size() == t_p.size() - 1);
Vector.Builder result = Vector.newBuilder();
for (int i = 0; i < t_p.size() - 1; i++) {
Preconditions.checkArgument(A.doubleValueOf(i) == 0 || A.doubleValueOf(i) == 1);
double tmp1 = Math.max(t_p.doubleValueOf(t_p.size() - 1), A.doubleValueOf(i));
result.add(tmp1 * (t_p.doubleValueOf(i) - 0.5) + 0.5);
}
result.add(t_p.doubleValueOf(t_p.size() - 1));
return result.build();
}
@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)));
}
@Override
public Vector get(Particle particle) {
Vector localGuide = (Vector) particle.getLocalGuide();
Vector globalGuide = (Vector) particle.getGlobalGuide();
Vector.Builder builder = Vector.newBuilder();
for (int i = 0; i < particle.getDimension(); ++i) {
if (this.uniform.getRandomNumber(0, 1) < 0.5) {
builder.add(localGuide.doubleValueOf(i));
} else {
// double tmp1 = cognitive.getParameter();
// double tmp2 = social.getParameter();
double sigma = Math.abs(localGuide.doubleValueOf(i) - globalGuide.doubleValueOf(i));
// according to Kennedy
double mean = (localGuide.doubleValueOf(i) + globalGuide.doubleValueOf(i)) / 2;
// andries proposal: double mean = (tmp1*personalBestPosition.getReal(i) +
// tmp2*nBestPosition.getReal(i)) / (tmp1+tmp2);
builder.add(this.randomDistribution.getRandomNumber(mean, sigma));
}
}
return builder.build();
}
@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);
}
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));//;
}
}
}
/** {@inheritDoc} */
@Override
public Vector get(Particle particle) {
double averageParticleVelocity = 0.0;
Vector averageVelocity = null; // velocity.getClone();
// averageVelocity.reset();
PSO pso = (PSO) AbstractAlgorithm.get();
for (Particle p : pso.getTopology()) {
if (averageVelocity == null) {
averageVelocity = (Vector) p.getVelocity();
continue;
}
Vector particleVelocity = (Vector) p.getVelocity();
averageVelocity = averageVelocity.plus(particleVelocity);
averageParticleVelocity += particleVelocity.norm();
}
averageVelocity = averageVelocity.divide(particle.getDimension());
averageParticleVelocity /= particle.getDimension();
double swarmCenterVelocity = averageVelocity.norm();
double swarmCoherence = calculateSwarmCoherence(swarmCenterVelocity, averageParticleVelocity);
double sigmoidValue = this.sigmoid.apply(swarmCoherence);
Vector standardVelocity = this.delegate.get(particle);
Vector.Builder builder = Vector.newBuilder();
for (int i = 0; i < particle.getDimension(); ++i) {
double coherenceVelocity =
this.scalingFactor.getParameter()
* sigmoidValue
* averageVelocity.doubleValueOf(i)
* this.randomNumber.getRandomNumber();
builder.add(coherenceVelocity);
}
Vector coherence = builder.build();
return Vectors.sumOf(standardVelocity, coherence);
// float social = socialRandomGenerator.nextFloat();
// float cognitive = cognitiveRandomGenerator.nextFloat();
//
// //DistanceMeasure adm = new AbsoluteDistanceMeasure();
// //DistanceMeasure dm = new MetricDistanceMeasure();
//
// double avgv = 0.0;
// double swv = 0.0;
// Topology<Particle> topology = ((PSO)Algorithm.get()).getTopology();
// Iterator<? extends Particle> it = topology.neighbourhood(null);
// double[] al = new double[particle.getDimension()];
// while (it.hasNext()) {
// Particle pl = it.next();
// double tmpv = 0.0;
// //double tmpsv = 0.0;
// for(int dim = 0; dim < particle.getDimension(); dim++) {
// al[dim] = al[dim]+((Vector)pl.getVelocity()).getReal(dim);
// tmpv += Math.pow(((Vector)pl.getVelocity()).getReal(dim), 2);
// }
// tmpv = Math.sqrt(tmpv);
// avgv += tmpv;
// }
// for(int i = 0; i < particle.getDimension(); i++) {
// //al.set(i, ;
// swv += (al[i]/topology.size()) * (al[i]/topology.size());
// }
// swv = Math.sqrt(swv);
//
// for (int i = 0; i < particle.getDimension(); ++i) {
// double tmp = 0.0;
// tmp = inertiaWeight.getParameter()*velocity.getReal(i)
// + cognitive * (bestPosition.getReal(i) - position.getReal(i)) *
// cognitiveAcceleration.getParameter()
// + social * (nBestPosition.getReal(i) - position.getReal(i)) *
// socialAcceleration.getParameter();
//
// double avgdim = 0.0;
// it = topology.neighbourhood(null);
// while (it.hasNext()) {
// avgdim += ((Vector)(it.next().getVelocity())).getReal(i);
// }
// avgdim /= particle.getDimension();
//
// double cvelocity = MathUtil.sigmoid(swv/avgv)*avgdim*randomNumber.getCauchy();
//
// System.out.println(cvelocity);
// tmp += cvelocity;
//
// velocity.setReal(i, tmp);
//
// clamp(velocity, i);
// }
}
