def algorithm(self):
m = len(particles.particles())
lp = particles.particles()
data = self.data
tmp = []
for _ in particles.particles():
tmp.append(universe.getOrigin())
# create the table of info
printHeader('Iteration', 'Fitness', 'Elapsed')
dimension = universe.dimension()
for iteration in range(data.iterations):
selection = self._rouletteSelection(particles.particles())
for p in range(0, math.floor(m/2), 2):
crossover_index = math.floor(np.random.uniform(high=dimension))
for k in range(dimension):
if k < crossover_index:
tmp[p][k] = lp[selection[p]][k]
tmp[p+1][k] = lp[selection[p+1]][k]
else:
tmp[p][k] = lp[selection[p+1]][k]
tmp[p+1][k] = lp[selection[p]][k]
if m % 2 == 0:
cross_index = math.floor(np.random.uniform(high=dimension))
for k in range(dimension):
if k < cross_index:
tmp[m-1][k]= lp[selection[m-1]][k]
else:
tmp[m-1][k]= lp[selection[0]][k]
# It performs the mutation
for coord in tmp:
if np.random.uniform(0, 1) <= data.mutation_probability:
index = math.floor(np.random.uniform(high=dimension))
coord.uniformRandom(index)
# changes the generation
for j in range(m):
lp[j].position(tmp[j])
start_time = time.time()
yield iteration
elapsed_time = time.time() - start_time
# information output
printInfo(iteration,
self.data.iterations,
particles.getBestFitness(),
datetime.timedelta(seconds=elapsed_time))
def _mutationAndRecombination(self, particle, index, psize):
a = index
b = index
c = index
k = index
self.prev_features.append(particle.copyCoord())
newc = universe.getOrigin()
while a == index:
a = np.random.uniform(0, 1) * (psize - 1)
while b == index or b == a:
b = np.random.uniform(0, 1) * (psize - 1)
while c == index or b == c or c == a:
c = np.random.uniform(0, 1) * (psize - 1)
lp = particles.particles()
for i in range(universe.dimension()):
if np.random.uniform(0, 1) < self.data.mutation_factor:
newc[i] = particle[i]
else:
newc[i] = lp[math.floor(a)][i] + self.data.mutation_factor * \
(lp[math.floor(b)][i] + lp[math.floor(c)][i])
# ensure values are inbound
newc.inbounds()
particle.position(newc)
def initialize(self):
r = ('c1', 'c2', 'w')
self.data.hasrequired(r)
for p in particles.particles():
p.v = universe.getOrigin()
p.coordinate.uniformRandom()
yield 'initial'
def _innerGlobalEvaluation(self, gfit, gcoord):
if gcoord is None:
gcoord = universe.getOrigin()
particle = min(particles.particles(), key=lambda x: x.fitness)
if particle.fitness < gfit:
return (particle.fitness, particle.copyCoord())
return (gfit, gcoord)
def _innerGlobalEvaluation(self, gfit, gcoord):
particle = min(particles.particles(), key=lambda x: x.fitness)
if particle.fitness < gfit:
new = (particle.fitness, copy.deepcopy(particle.coordinate))
particle.fitness = gfit
particle.position(gcoord)
return new
return (gfit, gcoord)
return None
def initialize(self):
r = ('mutation_factor', 'crossover_probability')
self.data.hasrequired(r)
if particles.total() < 3:
logger.error('insufficient particles (must be at least 3)')
sys.exit(1)
for particle in particles.particles():
particle.coordinate.uniformRandom()
yield 'initial'
def evaluation(self):
for p in particles.particles():
prob = np.random.uniform(0, 1)
if p.intermediate < p.fitness and prob < p.loudness:
p.fitness = p.intermediate
p.pulse_rate = self.data.pulse_rate * \
(1 - math.exp(-_alpha*self.iteration))
p.loudness = self.data.loudness * _alpha
p.last_coordinate = copy.deepcopy(p.coordinate)
else:
p.position(p.last_coordinate)
def algorithm(self):
m = len(particles.particles())
lp = particles.particles()
data = self.data
# create the table of info
printHeader('Iteration', 'Fitness', 'Elapsed')
dimension = universe.dimension()
for iteration in range(data.iterations):
summ = 0
best = particles.getBestCoordinate()
for p in particles.particles():
rand = np.random.uniform(0, 1)
part = p
p.coordinate = rand * (best - p.coordinate)
p.coordinate.inbounds()
start_time = time.time()
yield iteration
elapsed_time = time.time() - start_time
for particle in particles.particles():
summ += particle.fitness
bestc = particles.getBestCoordinate()
radius = particles.getBestFitness() / summ
for p in particles.particles():
dist = p.coordinate.euclideanDistance(bestc)
if dist < radius:
p.coordinate.uniformRandom()
p.fitness = sys.maxsize
# information output
printInfo(iteration, self.data.iterations,
particles.getBestFitness(),
datetime.timedelta(seconds=elapsed_time))
def optimize(self):
if os.path.exists(self.config.env) and os.path.isdir(self.config.env):
shutil.rmtree(self.config.env, ignore_errors=True)
for iteration in self.strategy.iterations():
with Executor.Context(iteration, self.config) as handler:
self._coreExecution(handler, particles.particles())
particles.evaluate(handler.iterationpath, self.strategy)
# self.strategy.fitnessEvaluation()
# set cleanUp to clean executors garbage left
self.strategy.cleanUp()
self._cleanUp()
def algorithm(self):
m = particles.total()
lp = particles.particles()
data = self.data
# create the table of info
printHeader('Iteration', 'Fitness', 'Elapsed')
dimension = universe.dimension()
for iteration in range(data.iterations):
self.prev_features = []
for i, p in enumerate(particles.particles()):
self._mutationAndRecombination(p, i, particles.total())
start_time = time.time()
yield iteration
elapsed_time = time.time() - start_time
# information output
printInfo(iteration, self.data.iterations,
particles.getBestFitness(),
datetime.timedelta(seconds=elapsed_time))
def initialize(self):
r = ('min_frequency', 'max_frequency', 'pulse_rate', 'loudness')
self.data.hasrequired(r)
data = self.data
for p in particles.particles():
p.v = universe.getOrigin()
p.coordinate.uniformRandom()
p.last_coordinate = copy.deepcopy(p.coordinate)
p.pulse_rate = np.random.uniform(high=data.pulse_rate)
p.loudness = np.random.uniform(high=data.loudness)
p.frequency = np.random.uniform(data.min_frequency,
data.max_frequency)
yield 'initial'
def expand():
"""
Expand function will expand the universe with all variables and groups
given.
The function will expand the universe to reach all variables and to
prohibit every coordinate that is outside the users scope a.k.a
define the group of coordinates that are valid for this optimization.
"""
_universe.build()
Coordinate.setUniverse(_universe)
global _origin
_origin = Coordinate()
for particle in particles.particles():
particle.position(_origin)
def algorithm(self):
printHeader('Iteration', 'fitness', 'elapsed')
dimension = universe.dimension()
for iteration in range(self.data.iterations):
self.iteration = iteration
for p in particles.particles():
self._setBatFrequency(p)
self._updateBatVelocity(p, dimension)
p.coordinate.inbounds()
prob = np.random.uniform(0, 1)
if prob > p.pulse_rate:
best = particles.getBestCoordinate()
p.last_coordinate = copy.deepcopy(p.coordinate)
p.position(best)
start_time = time.time()
yield iteration
elapsed_time = time.time() - start_time
printInfo(iteration, self.data.iterations,
particles.getBestFitness(),
datetime.timedelta(seconds=elapsed_time))
def algorithm(self):
# extract darwin parametrs from dict
data = self.data
# create the table of info
printHeader('Iteration', 'fitness', 'elapsed')
dimension = universe.dimension()
for iteration in range(self.data.iterations):
for p in particles.particles():
self._updateParticleVelocity(p, dimension)
self._updateParticlePosition(p, dimension)
p.coordinate.inbounds()
start_time = time.time()
yield iteration
elapsed_time = time.time() - start_time
# information output
printInfo(iteration, self.data.iterations,
particles.getBestFitness(),
datetime.timedelta(seconds=elapsed_time))
def __enter__(self):
for p in particles.particles():
copyas(self.optdir, self.particlepath(p.name))
return self
def evaluation(self):
for p in particles.particles():
if p.intermediate < p.fitness:
p.fitness = p.intermediate
p.xl = copy.deepcopy(p.coordinate)
def initialize(self):
for particle in particles.particles():
particle.coordinate.uniformRandom()
yield 'initial'
def evaluation(self):
for p, prev in zip(particles.particles(), self.prev_features):
if p.intermediate < p.fitness:
p.fitness = p.intermediate
else:
p.position(prev)
def evaluation(self):
for p in particles.particles():
if p.intermediate < p.fitness:
p.fitness = p.intermediate
def initialize(self):
r = ('mutation_probability',)
self.data.hasrequired(r)
for particle in particles.particles():
particle.coordinate.uniformRandom()
yield 'initial'
