def find_best_match():
"""Find the best matching word from the dictionary."""
i = input().split()
time_limit = int(i[0])
letter_multiset_size = int(i[1])
initial_size = int(i[2])
multiset = {}
initial_words = []
start_time = time.time()
for _ in range(letter_multiset_size):
e = input().split()
if e[0] in multiset.keys():
multiset[e[0]]['count'] += 1
else:
multiset[e[0]] = {'count': 1, 'value': int(e[1])}
for _ in range(initial_size):
initial_words.append(input().replace('\r', ''))
trie = read_dict(multiset)
matcher = WordMatcher(trie)
genetic = GeneticAlgorithm(matcher)
preprocessing_time = time.time() - start_time
result = genetic.search(time_limit - preprocessing_time, initial_words)
print(result, file=sys.stderr)
print(matcher.fitness(result))
def escape():
"""Perform genetic algorithm on a maze from the input data."""
i = list(map(int, input().split()))
time_limit = i[0]
n = i[1]
m = i[2]
initial_size = i[3]
population_size = i[4]
grid = []
start_field = -1
exit_field = -1
for i in range(n):
row = list(map(lambda u: Field(int(u)), input().replace('\r', '')))
if Field.AGENT in row:
start_field = (i, row.index(Field.AGENT))
if Field.EXIT in row:
exit_field = (i, row.index(Field.EXIT))
grid.append(row)
maze = Maze(grid, start_field, exit_field)
initial_paths = []
for i in range(initial_size):
initial_paths.append(path_from_string(input().replace('\r', '')))
genetic = GeneticAlgorithm(maze, population_size)
unchanged_iterations = 10 * (n * m)
result = genetic.search(time_limit, initial_paths, unchanged_iterations)
print(result[1])
print_path(result[0])
def main():
# Define objective class
objective_class = Objective_function(func1, 2, lo_bounds1, up_bounds1)
#set PSO optimizer
ga = GeneticAlgorithm(nb_generations=20,
nb_populations=10,
objective_class=objective_class)
ga.evolve()
for i in ga.populations:
print(i.fitness)
def optimize_route(objects, generations, crossover_chance, mutation_chance,
population):
"""
Return list of points ordered by genetic algorithm.
"""
generator = RouteGenerator(objects)
ga = GeneticAlgorithm(generator, crossover_chance, mutation_chance,
population)
print '\nINITIAL ROUTES'
print ', '.join(
[str(int(route.get_length())) for route in ga.get_solutions()])
# initial = [route.get_length() for route in ga.get_solutions()]
# best_initial = min(initial)
# while ga.get_best_solution().get_length() > best_initial * 0.5:
# # step condition instead of generations number
# # print ga.get_best_solution().get_length(), best_initial
# ga.evolve()
for _ in range(generations):
ga.evolve()
print '\nLAST GENERATION'
print ', '.join(
[str(int(route.get_length())) for route in ga.get_solutions()])
best = ga.get_best_solution()
print '\nLENGTH OF ROUTE AFTER OPTIMIZATION'
print int(best.get_length())
return best.objects
def optimize_route(objects, generations, crossover_chance, mutation_chance,
population):
"""
Return list of points ordered by genetic algorithm.
"""
generator = RouteGenerator(objects)
ga = GeneticAlgorithm(
generator, crossover_chance, mutation_chance, population
)
print '\nINITIAL ROUTES'
print ', '.join([
str(int(route.get_length())) for route in ga.get_solutions()
])
# initial = [route.get_length() for route in ga.get_solutions()]
# best_initial = min(initial)
# while ga.get_best_solution().get_length() > best_initial * 0.5:
# # step condition instead of generations number
# # print ga.get_best_solution().get_length(), best_initial
# ga.evolve()
for _ in range(generations):
ga.evolve()
print '\nLAST GENERATION'
print ', '.join([
str(int(route.get_length())) for route in ga.get_solutions()
])
best = ga.get_best_solution()
print '\nLENGTH OF ROUTE AFTER OPTIMIZATION'
print int(best.get_length())
return best.objects
def main(arguments):
trainer = Trainer(arguments.path, arguments.log)
ga = GeneticAlgorithm({
'model_arch': ['conv->lstm', 'lstm->conv', 'conv', 'lstm'],
'optimizer': ['adam', 'sgd', 'RMSprop'],
'conv_filters': [4, 8, 16, 32, 64, 128],
'conv_layers': [1, 2, 3, 5],
'conv_filter_size': [3, 5],
'use_max_pooling': [False, True],
'activation': ['relu', 'tanh', 'sigmoid'],
'lstm_cells': [4, 8, 16, 32, 64, 128],
'lstm_layers': [1, 2],
'loss': ['mse', huber_loss_mean],
'epochs': [10, 20, 30, 40, 50],
'batch_size': [32, 64, 128, 256],
'window_size': [5, 10, 20, 30, 40, 50],
'num_derivatives': [0, 1, 2, 3, 4, 5],
'scaler_class': [utils.StandardScaler, utils.MinMaxScaler, utils.NoScaler],
'num_points_to_predict': [1, 2, 3]
}, trainer.fitness, hall_of_fame=100)
kwargs = ga.get_kwargs(ga.sample())
kwargs['scaler_class'] = utils.StandardScaler
kwargs['epochs'] = 10
kwargs['model_arch'] = 'conv'
kwargs['num_derivatives'] = 3
kwargs['window_size'] = 30
kwargs['epochs'] = 40
kwargs['loss'] = huber_loss_mean
kwargs['use_max_pooling'] = False
kwargs['conv_filters'] = 64
kwargs['conv_layers'] = 2
kwargs['optimizer'] = 'adam'
kwargs['batch_size'] = 128
kwargs['num_points_to_predict'] = 1
kwargs['activation'] = 'relu'
kwargs['conv_filter_size'] = 5
#trainer.fitness(**kwargs)
ga.run(100, 100)
""" """ from genetic import GeneticAlgorithm image = [[False for __ in xrange(50)] for _ in xrange(80)] g = GeneticAlgorithm(100, 10, 5, 30, 80, 50, image) g.init_population() # g.crossover() # g.mutation() g.selection()
'neurons_per_hidden_layer': [17, 17, 17],
'input_layer_size': 17,
'output_layer_size': 4,
'input_af': Log2(),
'hidden_af': [TanH(), ReLU(), Sigmoid()],
'output_af': TanH()
}
game_parameters = {
'manual_input': True,
'random': False,
'steps': 0,
'sleep': 0
}
ga = GeneticAlgorithm(generation_size=GENERATION_SIZE, **nn_parameters)
ga.add_new_generation(weights_method=WEIGHTS_METHOD)
ga.populate_new_generation(ga[0], ga[0], weights_method=WEIGHTS_METHOD)
for k in range(GENRATION_COUNT):
print ' --- Generation: %5i ---' % k
for individual in ga[-1]:
game = run2048(**game_parameters)
runner = Runner(game, individual, print_steps=PRINT_STEPS)
while runner.step():
pass
game.gamegrid.destroy()
individual.set_fitness(runner.calculate_fitness())
# print individual.get_all_weights()
print ' === Individual: %5i ===' % individual.get_fitness()
genomes = []
for i in range(20):
genomes.append(Genome())
listofGenome = genomes.copy()
ga = GA()
generation = 10
while generation > 0:
parents = run(genomes, 20, generation)
if __name__ == '__main__':
generation = 10
genomes = []
ga = GA()
for i in range(20):
genomes.append(Genome())
ls = genomes.copy()
while generation > 0:
print("length of genomes", len(genomes))
parents = run(genomes, 20, generation)
print("next generation", generation)
best_gene = parents[0]
ref_weights = best_gene.model.get_weights()
fp = [g.flatten_weights(m1.model.get_weights()) for m1 in parents]
nw = ga.applyGenetic(fp, fp[-1], 20)
print(len(parents), len(ls))
for i in range(20):
"rail_length": 1.0, # m
"timestep": 0.001,
}
def fitness(params):
traces = rocket_architectures.sim1(**params)
time, position, velocity, acceleration = traces
speed = sqrt(np.sum(velocity * velocity, axis=1))
accel = sqrt(np.sum(acceleration * acceleration, axis=1)) / 9.81 # in Gs
max_speed = max(speed)
max_acceleration = max(sqrt(np.sum(acceleration * acceleration, axis=1)))
max_distance = np.max(position[:,0])
max_height = np.max(position[:,1])
# print(f"Distance and speed: max height:{np.max(position[:,1]):0.1f}m, distance:{max_distance:0.0f}m, "
# + f"max speed:{max_speed:0.0f}m/s, {ms2kmh(max_speed):0.0f}km/h), acceleration:{max_acceleration/9.81:0.0f}g")
return max_distance
ga = GeneticAlgorithm(params, fitness)
ga.run()
print(f"Rocket length:{length:0.01f}m, volume:{volume:0.01f}l")
best_params = ga.get_best_params()
traces = rocket_architectures.sim1(**best_params)
rocket_architectures.plot_basic(traces)
return params
if __name__ == '__main__':
if len(sys.argv) > 1:
params = load_configuration(sys.argv[1])
else:
params = get_user_input()
structure = parse_raw_structure(params["raw_structure"])
gen_alg = GeneticAlgorithm(
structure,
mfold_command=params["mfold_command"],
population_size=int(params["population_size"]),
iterations=int(params["iterations"]),
mutation_rate=int(params["mutation_rate"]),
boltzmann_factor=float(params["boltzmann_factor"]),
initial_sequences=[
Sequence(definition, structure)
for definition in params["input_sequence_definitions"]
],
fixed_regions=params['fixed_regions'])
try:
gen_alg.run()
finally:
print(len(gen_alg.diversity_history) - 1, " iterations completed")
print("Diversity history: ", gen_alg.diversity_history)
print("Fitness history: ", gen_alg.fitness_history)
with open("diversity.dat", "w") as outfile:
for diversity in gen_alg.diversity_history:
outfile.write(str(diversity) + '\n')
with open("fitness.dat", "w") as outfile:
print('Std Dev = ' + str(np.std(values)))
print('Normalise Std Dev = ' + str(np.std(values) / parameter_ranges[i]))
print('--------------------------------------')
#-----------------------------------------------------------------------------------
courses = []
course = Course()
for i in range(100):
courses.append(course.popcornCourse(i))
threshold = 0.
generation_limit = 30
population_size = 48 # Divisible by 4
mutation_variance = 1.5
algorithm = GeneticAlgorithm(threshold, generation_limit, population_size,
mutation_variance, [courses[0]])
def testOneGenome(genome, courses, algorithm):
drone, environment, stabiliser, preset_copy = algorithm.decodeGenome(
genome)
# For each obstacle course
counter = 0
energy = 0
for c in range(len(courses)):
# Reset all object parameters for new run (if not first run)
environment.resetEnv(courses[c])
drone.resetParams(preset_copy.drone_dict)
environment.update(drone, False)
drone.recieveLaserDistances(environment.laser_distances)
from genetic import GeneticAlgorithm
from output import Output
if __name__ == "__main__":
print("Genetic Algorithms ..........")
population_size = 150
mutation_rate = 0.02
perfect_score = 1
target = "Fc Barcelona"
output_object = Output(target, mutation_rate)
genetic = GeneticAlgorithm(population_size, target, mutation_rate,
perfect_score, output_object)
while True:
finished = genetic.natural_selection()
if finished:
break
output_object.print_pretty_output()
print(
" ----------------------- ------------------------------------------"
)
print(
" ----------------------- SUCCESS ------------------------------------------"
)
print(
" ----------------------- ------------------------------------------"
)
from product import Product
from genetic import GeneticAlgorithm
if __name__ == '__main__':
list_products = []
list_products.append(Product('Geladeira Dako', 0.751, 999.90))
list_products.append(Product('Iphone 6', 0.0000899, 2911.12))
list_products.append(Product('TV 55', 0.400, 4346.99))
list_products.append(Product('TV 50', 0.290, 3999.90))
list_products.append(Product('TV 42', 0.200, 2999.00))
list_products.append(Product('Notebook Dell', 0.00350, 2499.90))
list_products.append(Product('Ventilador Panasonic', 0.496, 199.90))
list_products.append(Product('Microondas Eletrolux', 0.0424, 308.66))
list_products.append(Product('Microondas LG', 0.0544, 429.90))
list_products.append(Product('Microondas Panasonic', 0.0319, 299.29))
list_products.append(Product('Geladeira Brastemp', 0.635, 849.00))
list_products.append(Product('Geladeira Consul', 0.870, 1199.89))
list_products.append(Product('Notebook Lenovo', 0.498, 1999.90))
list_products.append(Product('Notebook Asus', 0.527, 3999.00))
limit = 3
size_population = 200
prob_mutation = 0.01
num_generations = 100
ga = GeneticAlgorithm(size_population)
ga.solve(list_products, limit, num_generations, prob_mutation)
pyplot.plot(ga.get_result())
pyplot.title('Improvment through generations')
pyplot.show()
def main():
print('Started')
GeneticAlgorithm(GuessText("Hello World!")).run()
#%%
import numpy as np
from genetic import GeneticAlgorithm
import time
#%%
def fitnessFunction(individual):
x, y = individual.copy()
z = np.sin(x) * np.cos(y) + np.sin(y ** 2) * x
return z
#%%
startTime = time.time()
GA = GeneticAlgorithm(fitnessFunction)
bestCombo = GA.evolution()
print("Execution time: %.3f" % (time.time() - startTime))
print(bestCombo)
# %%
def fitness(params):
try:
traces = rocket_architectures.sim_3_boosters(**params)
except Exception as ex:
print(ex)
return 0.0
time, position, velocity, acceleration = traces
speed = sqrt(np.sum(velocity * velocity, axis=1))
accel = sqrt(np.sum(acceleration * acceleration, axis=1)) / 9.81 # in Gs
max_speed = max(speed)
max_acceleration = max(sqrt(np.sum(acceleration * acceleration, axis=1)))
max_distance = np.max(position[:, 0])
# print(f"Distance and speed: max height:{np.max(position[:,1]):0.1f}m, distance:{max_distance:0.0f}m, "
# + f"max speed:{max_speed:0.0f}m/s, {ms2kmh(max_speed):0.0f}km/h), acceleration:{max_acceleration/9.81:0.0f}g")
return max_distance
ga = GeneticAlgorithm(params,
fitness,
population_size=40,
generations=30,
temperature_factor=0.91)
ga.run()
best_params = ga.get_best_params()
traces = rocket_architectures.sim_3_boosters(**best_params)
rocket_architectures.plot_basic(traces)
import numpy as np
import time
import os
import pickle
import random
from genetic import GeneticAlgorithm
from environment import Course
import neat
# Generate obstacles
course = Course()
course_1 = course.popcornCourse(1.5)
course_2 = course.popcornCourse(11.5)
course_3 = course.avoidCourse()
courses = [course_1, course_2, course_3]
random.seed(1)
# Algorithm Paramaters
threshold = 0. # Fitness Threshold
generation_limit = 30
population_size = 48 # Divisible by 4
mutation_variance = 1.5
# Load Algorithm Object
algorithm = GeneticAlgorithm(threshold, generation_limit, population_size,
mutation_variance, courses)
# Run Genetic Algorithm
algorithm.run()
individual.crossover_tag = None
individual.mutation_tag = None
genealogy_logger = logging.getLogger('genealogy')
genealogy_logger.info(' '.join(tags))
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
pass
if __name__ == "__main__":
import sys
import structopt
import random
import numpy as np
from genetic import GeneticAlgorithm
parameters = structopt.setup(sys.argv[1])
random.seed(parameters.seed)
np.random.seed(parameters.seed)
population = Population(parameters=parameters)
with GeneticAlgorithm(population=population,
convergence=parameters.convergence,
post_processing=parameters.post_processing,
adaptation=parameters.adaptation) as optimizer:
optimizer.run()
def draw(self, sizes):
self.sizes = [(s[0] + 2 * self.space, s[1] + 2 * self.space) for s in sizes]
maxvals = [self.width() - s[0] - 2 * self.space for s in sizes]
maxvals.extend([self.height() - s[1] - 2 * self.space for s in sizes])
ga = GeneticAlgorithm()
ga.population = 150
ga.n_iters = 1000
ga.mutation_prob = 0.4
ga.dim = 2 * self.count()
ga.mutation_factor = int(round(min(self.width(), self.height()) / 2))
ga.set_minvals(self.space)
ga.set_maxvals(maxvals)
_, minx = ga.minimize(self.fitness)
return minx + self.space
