def testProgressBar(self):
"""Tests single progress bar for genalg.
"""
user_spec_nodes = np.array([[]]).reshape(0, 3)
nodes = np.array([[1, 2, 3], [2, 3, 4]])
edges = np.array([[0, 1]])
properties = np.array([[0, 3]])
pop_size = 10
population = [
Truss(user_spec_nodes, nodes, edges, properties)
for i in range(pop_size)
]
for truss in population:
truss.fitness_score = np.random.random()
population.sort(key=lambda x: x.fitness_score)
GA = GenAlg(config)
GA.population = population
progress_truss = False
progress_fitness = False
# dumb GA run
num_generations = 20
progress = ProgMon(progress_fitness, progress_truss, num_generations)
# Loop over all generations:
for current_gen in tqdm(range(num_generations)):
progress.progress_monitor(current_gen, population)
time.sleep(0.05)
for truss in GA.population:
truss.fitness_score = truss.fitness_score + 5.0
return GA.population[0], GA.pop_progress
def main(args=sys.argv[1:]):
"""Runs the main GASTOp script, from the command line.
Reads and parses user input from command line, runs the code,
and prints and plots the resulting best truss.
"""
args = parse_args(args)
config = utilities.init_file_parser(args.config_path)
if args.display:
progress_fitness = True
progress_truss = True
elif args.quiet:
progress_fitness = False
progress_truss = False
else:
progress_fitness = config['monitor_params']['progress_fitness']
progress_truss = config['monitor_params']['progress_truss']
if args.num_threads:
num_threads = args.num_threads
else:
num_threads = config['ga_params']['num_threads']
if args.num_gens:
num_generations = args.num_gens
else:
num_generations = config['ga_params']['num_generations']
if args.pop_size:
pop_size = args.pop_size
else:
pop_size = config['ga_params']['pop_size']
# Create the Genetic Algorithm Object
ga = GenAlg(config)
ga.initialize_population(pop_size)
best, progress_history = ga.run(num_generations=num_generations,
progress_fitness=progress_fitness,
progress_truss=progress_truss,
num_threads=num_threads)
print(best)
if args.output:
utilities.save_progress_history(progress_history,
path_progress_history=args.output)
if progress_fitness or progress_truss:
best.plot(
domain=config['random_params']['domain'],
loads=config['evaluator_params']['boundary_conditions']['loads'],
fixtures=config['evaluator_params']['boundary_conditions']
['fixtures'],
deflection=True)
def test_rastrigin(self):
"""Test GA using rastrigin function,
highly non-convex optimization test function.
"""
config['fitness_params'] = {'equation': 'rastrigin', 'parameters': {}}
config['ga_params']['pop_size'] = 1000
ga = GenAlg(config)
ga.initialize_population()
best, progress_history = ga.run()
self.assertAlmostEqual(best.fitness_score, 0, places=2)
def test_sphere(self):
"""Tests GA using sphere function,
ie sum of squares. Simple convex test case.
"""
config['ga_params']['num_threads'] = 2
config['fitness_params'] = {'equation': 'sphere', 'parameters': {}}
ga = GenAlg(config)
ga.initialize_population(pop_size)
best, progress_history = ga.run(num_generations=100,
progress_fitness=True,
progress_truss=False)
self.assertAlmostEqual(best.fitness_score, 0, places=4)
def testInvalidCrossover(self):
"""Tests genalg when % crossover + % mutation >1"""
config = utilities.init_file_parser(init_file_path)
config['ga_params']['percent_crossover'] = .6
config['ga_params']['percent_mutation'] = .6
ga = GenAlg(config)
ga.initialize_population(100)
for t in ga.population:
t.fitness_score = np.random.random()
self.assertRaises(RuntimeError, ga.update_population)
bad_path = 'gastop-config/error_config.txt'
self.assertRaises(RuntimeError, utilities.init_file_parser, bad_path)
def test_nodes_in_domain(self):
"""Tests if the created nodes are in the desired range.
"""
# Create the Genetic Algorithm Object
ga = GenAlg(config)
ga.initialize_population(pop_size)
for truss in ga.population:
for node in truss.rand_nodes:
self.assertTrue(node[0] > ga.random_params['domain'][0, 0])
self.assertTrue(node[0] < ga.random_params['domain'][1, 0])
self.assertTrue(node[1] > ga.random_params['domain'][0, 1])
self.assertTrue(node[1] < ga.random_params['domain'][1, 1])
self.assertTrue(node[2] > ga.random_params['domain'][0, 2])
self.assertTrue(node[2] < ga.random_params['domain'][1, 2])
def testSaveLoadPopProgress(self):
'''Tests that the pop_progress dictionary is correctly saved to and
loaded from a JSON file.
'''
# Parse input paramters from init.txt file
init_file_path = 'gastop-config/struct_making_test_init.txt'
config = utilities.init_file_parser(init_file_path)
progress_fitness = False
progress_truss = False
num_threads = 1
num_generations = 3
pop_size = 5
# Create the Genetic Algorithm Object
ga = GenAlg(config)
ga.initialize_population(pop_size)
best, progress_history = ga.run(num_generations=num_generations,
progress_fitness=progress_fitness,
progress_truss=progress_truss,
num_threads=num_threads)
# Save and load pop_progress to/from JSON file
utilities.save_progress_history(progress_history)
loaded_progress_history = utilities.load_progress_history()
print(loaded_progress_history)
for gen in loaded_progress_history.keys():
self.assertTrue(
isinstance(loaded_progress_history[gen]['Generation'], int))
self.assertTrue(
isinstance(loaded_progress_history[gen]['Best Truss'], Truss))
self.assertTrue(
isinstance(loaded_progress_history[gen]['Best Fitness Score'],
float))
self.assertTrue(
isinstance(
loaded_progress_history[gen]
['Population Median Fitness Score'], float))
self.assertTrue(
isinstance(
loaded_progress_history[gen]
['Population Fitness Score Range'], float))
def testProgressPlotClass(self):
"""Tests fitness plot for progmon
"""
user_spec_nodes = np.array([[]]).reshape(0, 3)
nodes = np.array([[1, 2, 3], [2, 3, 4]])
edges = np.array([[0, 1]])
properties = np.array([[0, 3]])
pop_size = 10
population = [
Truss(user_spec_nodes, nodes, edges, properties)
for i in range(pop_size)
]
for truss in population:
truss.fitness_score = np.random.random()
population.sort(key=lambda x: x.fitness_score)
# print([x.fitness_score for x in population])
GA = GenAlg(config)
GA.population = population
progress_fitness = True
progress_truss = False
num_generations = 20
progress = ProgMon(progress_fitness, progress_truss, num_generations)
#
# Loop over all generations:
for current_gen in range(num_generations):
progress.progress_monitor(current_gen, population)
for truss in GA.population:
#truss.fos = np.random.random()
truss.fitness_score = truss.fitness_score + 5.0
# plt.show() # sfr, keep plot from closing right after this completes, terminal will hang until this is closed
return GA.population[0], GA.pop_progress
def testSaveLoadState(self):
'''Tests that config and population can be saved to and loaded from
JSON files.
'''
# Parse input parameters from init file
init_file_path = 'gastop-config/struct_making_test_init.txt'
config = utilities.init_file_parser(init_file_path)
# Create GenAlg object
pop_size = int(1e4)
ga = GenAlg(config)
ga.initialize_population(pop_size)
# Save and reload
ga.save_state()
ga_loaded = ga.load_state()
config = ga_loaded.config
population = ga_loaded.population
# Test config
self.assertTrue(isinstance(config['ga_params']['num_elite'], int))
self.assertTrue(
isinstance(config['ga_params']['percent_crossover'], float))
self.assertTrue(
type(config['mutator_params']['node_mutator_params']['boundaries'])
is type(np.array([1, 1])))
self.assertTrue(
isinstance(
config['mutator_params']['node_mutator_params']['int_flag'],
bool))
# Test population
for truss in population:
self.assertTrue(isinstance(truss, Truss))
self.assertTrue(isinstance(truss.user_spec_nodes, np.ndarray))
self.assertTrue(isinstance(truss.rand_nodes, np.ndarray))
self.assertTrue(isinstance(truss.edges, np.ndarray))
self.assertTrue(isinstance(truss.properties, np.ndarray))
def testUpdatePopulation(self):
'''Tests that the population correctly updates every generation.
'''
# Create GenAlg object and assign random fitness scores
pop_size = int(1e4)
ga = GenAlg(init_file_path)
ga.initialize_population(pop_size)
for truss in ga.population:
truss.fitness_score = np.random.random()
ga.population.sort(key=lambda x: x.fitness_score)
ga.update_population()
# Check that population is sorted by fitness_score
fitness = [truss.fitness_score for truss in ga.population
][:config['ga_params']['num_elite']]
self.assertTrue(sorted(fitness) == fitness)
for truss in ga.population:
self.assertTrue(isinstance(truss, Truss))
self.assertTrue(isinstance(truss.user_spec_nodes, np.ndarray))
self.assertTrue(isinstance(truss.rand_nodes, np.ndarray))
self.assertTrue(isinstance(truss.edges, np.ndarray))
self.assertTrue(isinstance(truss.properties, np.ndarray))
# Parse input paramters from init.txt file
init_file_path = 'gastop-config/struct_making_test_init.txt'
config = utilities.init_file_parser(init_file_path)
ga_params = config['ga_params']
random_params = config['random_params']
crossover_params = config['crossover_params']
mutator_params = config['mutator_params']
selector_params = config['selector_params']
evaluator_params = config['evaluator_params']
fitness_params = config['fitness_params']
# properties_df = 0
evaluator = 0
pop_size = int(1e6)
num_gens = int(1e2)
# boundaries = Boundaries(#Input here);
# Create the Evaluator Object
#evaluator = Eval(blah)
# Create a Fitness Function Object
fitness_function = FitnessFunction('rastrigin', 0)
pop_size = int(1e4)
ga = GenAlg(ga_params, mutator_params, random_params, crossover_params,
selector_params, evaluator, fitness_function)
#ga.initialize_population(pop_size)
cProfile.run('ga.initialize_population(pop_size)')
from gastop import GenAlg, utilities
# needs to be full path
animation_path = '/Users/susanredmond/Desktop/APC524_FinalProject/animation'
# Parse input paramters from init.txt file
init_file_path = 'gastop-config/struct_making_test_init2.txt'
config = utilities.init_file_parser(init_file_path)
pop_size = 1000
num_gens = 50
progress_fitness = True
progress_truss = True
# Create the Genetic Algorithm Object
ga = GenAlg(config)
ga.initialize_population(pop_size)
best, progress_history = ga.run(num_generations=num_gens,
progress_fitness=progress_fitness,
progress_truss=progress_truss,
num_threads=8)
print(best)
best.plot(
domain=config['random_params']['domain'],
loads=config['evaluator_params']['boundary_conditions']['loads'],
fixtures=config['evaluator_params']['boundary_conditions']['fixtures'],
deflection=True,
load_scale=.0002,
def_scale=50)
# Parse input paramters from init.txt file
init_file_path = 'gastop-config/struct_making_test_init2.txt'
config = utilities.init_file_parser(init_file_path)
pop_size = config['ga_params']['pop_size']
num_gens = config['ga_params']['num_generations']
conf = Config()
conf.trace_filter = GlobbingFilter(include=['__main__', 'gastop.*'])
graphviz = GraphvizOutput(output_file='filter_exclude4.png')
with PyCallGraph(output=graphviz, config=conf):
# Create the Genetic Algorithm Object
ga = GenAlg(config)
ga.initialize_population(200)
best, progress_history = ga.run(num_generations=10,
progress_display=1,
num_threads=1)
# con = best.edges.copy()
# matl = best.properties.copy()
# matl = matl[(con[:, 0]) >= 0]
# con = con[(con[:, 0]) >= 0]
# matl = matl[(con[:, 1]) >= 0]
# con = con[(con[:, 1]) >= 0]
# print(best.rand_nodes)
# print(con)
# print(matl)
def testOddNumCrossover(self):
"""Tests genalg when crossover number is odd
to make sure it still return the correct population size
"""
config = utilities.init_file_parser(init_file_path)
config['ga_params']['percent_crossover'] = 1
config['ga_params']['percent_mutation'] = 0
config['ga_params']['num_elite'] = 5
ga = GenAlg(config)
ga.initialize_population(100)
ga.run(num_generations=2)
self.assertAlmostEqual(len(ga.population), 100)
# test zero crossover
config['ga_params']['percent_crossover'] = 0
config['ga_params']['percent_mutation'] = 1
ga = GenAlg(config)
ga.initialize_population(100)
ga.run(num_generations=2)
self.assertAlmostEqual(len(ga.population), 100)
import timeit
import multiprocessing
import sys
sys.path.append('.')
from gastop import GenAlg, Truss, Evaluator, FitnessFunction, Crossover, Mutator, Selector, utilities
# Parse input paramters from init.txt file
init_file_path = 'gastop-config/struct_making_test_init.txt'
config = utilities.init_file_parser(init_file_path)
pop_size = int(1e2)
num_gens = int(1e1)
# Create GenAlg object and assign random fitness scores
ga = GenAlg(config)
ga.initialize_population(pop_size)
for truss in ga.population:
truss.fitness_score = np.random.random()
setup ='''
import numpy as np
import multiprocessing
from gastop import GenAlg, Truss, Evaluator, FitnessFunction, Crossover, Mutator, Selector, utilities
from __main__ import method1, method2
init_file_path = 'gastop-config/struct_making_test_init.txt'
config = utilities.init_file_parser(init_file_path)
pop_size = int(1e2)
num_gens = int(1e1)