[1113] | 1 | import argparse |
---|
| 2 | import os |
---|
[1128] | 3 | import pickle |
---|
[1113] | 4 | import sys |
---|
| 5 | from enum import Enum |
---|
| 6 | |
---|
| 7 | import numpy as np |
---|
| 8 | |
---|
| 9 | from FramsticksLib import FramsticksLib |
---|
| 10 | from evolalg.base.lambda_step import LambdaStep |
---|
[1128] | 11 | from evolalg.base.step import Step |
---|
[1113] | 12 | from evolalg.dissimilarity.frams_dissimilarity import FramsDissimilarity |
---|
| 13 | from evolalg.dissimilarity.levenshtein import LevenshteinDissimilarity |
---|
| 14 | from evolalg.experiment import Experiment |
---|
| 15 | from evolalg.fitness.fitness_step import FitnessStep |
---|
| 16 | from evolalg.mutation_cross.frams_cross_and_mutate import FramsCrossAndMutate |
---|
| 17 | from evolalg.population.frams_population import FramsPopulation |
---|
| 18 | from evolalg.repair.remove.field import FieldRemove |
---|
| 19 | from evolalg.repair.remove.remove import Remove |
---|
| 20 | from evolalg.selection.tournament import TournamentSelection |
---|
| 21 | from evolalg.statistics.halloffame_stats import HallOfFameStatistics |
---|
| 22 | from evolalg.statistics.statistics_deap import StatisticsDeap |
---|
| 23 | from evolalg.base.union_step import UnionStep |
---|
| 24 | from evolalg.utils.population_save import PopulationSave |
---|
[1128] | 25 | import time |
---|
[1113] | 26 | |
---|
| 27 | |
---|
| 28 | def ensureDir(string): |
---|
| 29 | if os.path.isdir(string): |
---|
| 30 | return string |
---|
| 31 | else: |
---|
| 32 | raise NotADirectoryError(string) |
---|
| 33 | |
---|
| 34 | |
---|
| 35 | class Dissim(Enum): |
---|
| 36 | levenshtein = "levenshtein" |
---|
| 37 | frams = "frams" |
---|
| 38 | |
---|
| 39 | def __str__(self): |
---|
| 40 | return self.name |
---|
| 41 | |
---|
| 42 | |
---|
| 43 | class Fitness(Enum): |
---|
| 44 | raw = "raw" |
---|
| 45 | niching = "niching" |
---|
| 46 | novelty = "novelty" |
---|
| 47 | |
---|
| 48 | def __str__(self): |
---|
| 49 | return self.name |
---|
| 50 | |
---|
| 51 | |
---|
| 52 | def parseArguments(): |
---|
| 53 | parser = argparse.ArgumentParser( |
---|
| 54 | description='Run this program with "python -u %s" if you want to disable buffering of its output.' % sys.argv[ |
---|
| 55 | 0]) |
---|
[1128] | 56 | parser.add_argument('-path', type=ensureDir, required=True, help='Path to the Framsticks library without trailing slash.') |
---|
[1113] | 57 | parser.add_argument('-opt', required=True, |
---|
[1132] | 58 | help='optimization criteria : vertpos, velocity, distance, vertvel, lifespan, numjoints, numparts, numneurons, numconnections (or other as long as it is provided by the .sim file and its .expdef). Single or multiple criteria.') |
---|
| 59 | parser.add_argument('-lib', required=False, help="Filename of .so or .dll with the Framsticks library") |
---|
[1113] | 60 | parser.add_argument('-genformat', required=False, default="1", |
---|
| 61 | help='Genetic format for the demo run, for example 4, 9, or B. If not given, f1 is assumed.') |
---|
[1132] | 62 | parser.add_argument('-sim', required=False, default="eval-allcriteria.sim", help="Name of the .sim file with all parameter values") |
---|
[1113] | 63 | parser.add_argument('-dissim', required=False, type=Dissim, default=Dissim.frams, |
---|
[1132] | 64 | help='Dissimilarity measure, default = frams', choices=list(Dissim)) |
---|
[1113] | 65 | parser.add_argument('-fit', required=False, default=Fitness.raw, type=Fitness, |
---|
[1138] | 66 | help=' Fitness criteria, default = raw', choices=list(Fitness)) |
---|
[1129] | 67 | parser.add_argument('-popsize', type=int, default=50, help="Population size, default 50.") |
---|
[1128] | 68 | parser.add_argument('-generations', type=int, default=5, help="Number of generations, default 5.") |
---|
[1129] | 69 | parser.add_argument('-tournament', type=int, default=5, help="Tournament size, default 5.") |
---|
[1138] | 70 | |
---|
| 71 | parser.add_argument('-max_numparts', type=int, default=None, help="Maximum number of Parts. Default: no limit") |
---|
| 72 | parser.add_argument('-max_numjoints', type=int, default=None, help="Maximum number of Joints. Default: no limit") |
---|
| 73 | parser.add_argument('-max_numneurons', type=int, default=None, help="Maximum number of Neurons. Default: no limit") |
---|
| 74 | parser.add_argument('-max_numconnections', type=int, default=None, help="Maximum number of Neural connections. Default: no limit") |
---|
| 75 | |
---|
[1128] | 76 | parser.add_argument('-checkpoint_path', required=False, default=None, help="Path to the checkpoint file") |
---|
[1113] | 77 | parser.add_argument('-checkpoint_interval', required=False, type=int, default=100, help="Checkpoint interval") |
---|
| 78 | return parser.parse_args() |
---|
| 79 | |
---|
| 80 | |
---|
| 81 | def extract_fitness(ind): |
---|
| 82 | return ind.fitness_raw |
---|
| 83 | |
---|
| 84 | |
---|
| 85 | def print_population_count(pop): |
---|
[1136] | 86 | print("Current popsize:", len(pop)) |
---|
[1113] | 87 | return pop # Each step must return a population |
---|
| 88 | |
---|
| 89 | |
---|
[1138] | 90 | class NumPartsHigher(Remove): |
---|
| 91 | def __init__(self, max_number): |
---|
| 92 | super(NumPartsHigher, self).__init__() |
---|
| 93 | self.max_number = max_number |
---|
[1113] | 94 | |
---|
| 95 | def remove(self, individual): |
---|
[1138] | 96 | return individual.numparts > self.max_number |
---|
[1113] | 97 | |
---|
| 98 | |
---|
[1138] | 99 | class NumJointsHigher(Remove): |
---|
| 100 | def __init__(self, max_number): |
---|
| 101 | super(NumJointsHigher, self).__init__() |
---|
| 102 | self.max_number = max_number |
---|
| 103 | |
---|
| 104 | def remove(self, individual): |
---|
| 105 | return individual.numjoints > self.max_number |
---|
| 106 | |
---|
| 107 | |
---|
| 108 | class NumNeuronsHigher(Remove): |
---|
| 109 | def __init__(self, max_number): |
---|
| 110 | super(NumNeuronsHigher, self).__init__() |
---|
| 111 | self.max_number = max_number |
---|
| 112 | |
---|
| 113 | def remove(self, individual): |
---|
| 114 | return individual.numneurons > self.max_number |
---|
| 115 | |
---|
| 116 | |
---|
| 117 | class NumConnectionsHigher(Remove): |
---|
| 118 | def __init__(self, max_number): |
---|
| 119 | super(NumConnectionsHigher, self).__init__() |
---|
| 120 | self.max_number = max_number |
---|
| 121 | |
---|
| 122 | def remove(self, individual): |
---|
| 123 | return individual.numconnections > self.max_number |
---|
| 124 | |
---|
| 125 | |
---|
[1113] | 126 | def func_niching(ind): setattr(ind, "fitness", ind.fitness_raw * (1 + ind.dissim)) |
---|
| 127 | |
---|
| 128 | |
---|
| 129 | def func_raw(ind): setattr(ind, "fitness", ind.fitness_raw) |
---|
| 130 | |
---|
| 131 | |
---|
| 132 | def func_novelty(ind): setattr(ind, "fitness", ind.dissim) |
---|
| 133 | |
---|
| 134 | |
---|
[1128] | 135 | def load_experiment(path): |
---|
| 136 | with open(path, "rb") as file: |
---|
| 137 | experiment = pickle.load(file) |
---|
| 138 | print("Loaded experiment. Generation:", experiment.generation) |
---|
| 139 | return experiment |
---|
| 140 | |
---|
| 141 | |
---|
| 142 | def create_experiment(): |
---|
[1113] | 143 | parsed_args = parseArguments() |
---|
[1138] | 144 | frams_lib = FramsticksLib(parsed_args.path, parsed_args.lib, |
---|
[1113] | 145 | parsed_args.sim) |
---|
| 146 | # Steps for generating first population |
---|
[1128] | 147 | init_stages = [ |
---|
[1138] | 148 | FramsPopulation(frams_lib, parsed_args.genformat, parsed_args.popsize) |
---|
[1128] | 149 | ] |
---|
[1113] | 150 | |
---|
| 151 | # Selection procedure |
---|
[1129] | 152 | selection = TournamentSelection(parsed_args.tournament, |
---|
[1128] | 153 | copy=True) # 'fitness' by default, the targeted attribute can be changed, e.g. fit_attr="fitness_raw" |
---|
[1113] | 154 | |
---|
| 155 | # Procedure for generating new population. This steps will be run as long there is less than |
---|
| 156 | # popsize individuals in the new population |
---|
[1138] | 157 | new_generation_stages = [FramsCrossAndMutate(frams_lib, cross_prob=0.2, mutate_prob=0.9)] |
---|
[1113] | 158 | |
---|
| 159 | # Steps after new population is created. Executed exacly once per generation. |
---|
| 160 | generation_modifications = [] |
---|
| 161 | |
---|
| 162 | # ------------------------------------------------- |
---|
| 163 | # Fitness |
---|
| 164 | |
---|
[1138] | 165 | fitness_raw = FitnessStep(frams_lib, fields={parsed_args.opt: "fitness_raw", |
---|
| 166 | "numparts": "numparts", |
---|
| 167 | "numjoints": "numjoints", |
---|
| 168 | "numneurons": "numneurons", |
---|
| 169 | "numconnections": "numconnections"}, |
---|
| 170 | fields_defaults={parsed_args.opt: None, "numparts": float("inf"), |
---|
| 171 | "numjoints": float("inf"), "numneurons": float("inf"), |
---|
| 172 | "numconnections": float("inf")}, |
---|
[1113] | 173 | evaluation_count=1) |
---|
| 174 | |
---|
[1138] | 175 | fitness_end = FitnessStep(frams_lib, fields={parsed_args.opt: "fitness_raw"}, |
---|
[1113] | 176 | fields_defaults={parsed_args.opt: None}, |
---|
| 177 | evaluation_count=100) # evaluate the contents of the last population 100 times (TODO replace this approach and evaluate HOF instead of the last population) |
---|
| 178 | # Remove |
---|
| 179 | remove = [] |
---|
| 180 | remove.append(FieldRemove("fitness_raw", None)) # Remove individuals if they have default value for fitness |
---|
[1138] | 181 | if parsed_args.max_numparts is not None: |
---|
| 182 | # This could be also implemented by "LambdaRemove(lambda x: x.numparts > parsed_args.num_parts)" |
---|
| 183 | # But this would not serialize in checkpoint. |
---|
| 184 | remove.append(NumPartsHigher(parsed_args.max_numparts)) |
---|
| 185 | if parsed_args.max_numjoints is not None: |
---|
| 186 | remove.append(NumJointsHigher(parsed_args.max_numjoints)) |
---|
| 187 | if parsed_args.max_numneurons is not None: |
---|
| 188 | remove.append(NumNeuronsHigher(parsed_args.max_numneurons)) |
---|
| 189 | if parsed_args.max_numconnections is not None: |
---|
| 190 | remove.append(NumConnectionsHigher(parsed_args.max_numconnections)) |
---|
| 191 | |
---|
[1113] | 192 | remove_step = UnionStep(remove) |
---|
| 193 | |
---|
| 194 | fitness_remove = UnionStep([fitness_raw, remove_step]) |
---|
| 195 | |
---|
| 196 | init_stages.append(fitness_remove) |
---|
| 197 | new_generation_stages.append(fitness_remove) |
---|
| 198 | |
---|
| 199 | # ------------------------------------------------- |
---|
| 200 | # Novelty or niching |
---|
| 201 | dissim = None |
---|
| 202 | if parsed_args.dissim == Dissim.levenshtein: |
---|
| 203 | dissim = LevenshteinDissimilarity(reduction="mean", output_field="dissim") |
---|
| 204 | elif parsed_args.dissim == Dissim.frams: |
---|
[1138] | 205 | dissim = FramsDissimilarity(frams_lib, reduction="mean", output_field="dissim") |
---|
[1113] | 206 | |
---|
| 207 | if parsed_args.fit == Fitness.raw: |
---|
| 208 | # Fitness is equal to finess raw |
---|
| 209 | raw = LambdaStep(func_raw) |
---|
| 210 | init_stages.append(raw) |
---|
| 211 | generation_modifications.append(raw) |
---|
| 212 | |
---|
| 213 | if parsed_args.fit == Fitness.niching: |
---|
| 214 | niching = UnionStep([ |
---|
| 215 | dissim, |
---|
| 216 | LambdaStep(func_niching) |
---|
| 217 | ]) |
---|
| 218 | init_stages.append(niching) |
---|
| 219 | generation_modifications.append(niching) |
---|
| 220 | |
---|
| 221 | if parsed_args.fit == Fitness.novelty: |
---|
| 222 | novelty = UnionStep([ |
---|
| 223 | dissim, |
---|
| 224 | LambdaStep(func_novelty) |
---|
| 225 | ]) |
---|
| 226 | init_stages.append(novelty) |
---|
| 227 | generation_modifications.append(novelty) |
---|
| 228 | |
---|
| 229 | # ------------------------------------------------- |
---|
| 230 | # Statistics |
---|
| 231 | hall_of_fame = HallOfFameStatistics(100, "fitness_raw") # Wrapper for halloffamae |
---|
| 232 | statistics_deap = StatisticsDeap([ |
---|
| 233 | ("avg", np.mean), |
---|
| 234 | ("stddev", np.std), |
---|
| 235 | ("min", np.min), |
---|
| 236 | ("max", np.max) |
---|
| 237 | ], extract_fitness) # Wrapper for deap statistics |
---|
| 238 | |
---|
| 239 | statistics_union = UnionStep([ |
---|
| 240 | hall_of_fame, |
---|
| 241 | statistics_deap |
---|
| 242 | ]) # Union of two statistics steps. |
---|
| 243 | |
---|
| 244 | init_stages.append(statistics_union) |
---|
| 245 | generation_modifications.append(statistics_union) |
---|
| 246 | |
---|
| 247 | # ------------------------------------------------- |
---|
| 248 | # End stages: this will execute exacly once after all generations. |
---|
| 249 | end_stages = [ |
---|
| 250 | fitness_end, |
---|
[1128] | 251 | PopulationSave("halloffame.gen", provider=hall_of_fame.halloffame, fields={"genotype": "genotype", |
---|
| 252 | "fitness": "fitness_raw"})] |
---|
[1113] | 253 | # ...but custom fields can be added, e.g. "custom": "recording" |
---|
| 254 | |
---|
| 255 | # ------------------------------------------------- |
---|
| 256 | # Experiment creation |
---|
| 257 | |
---|
| 258 | experiment = Experiment(init_population=init_stages, |
---|
| 259 | selection=selection, |
---|
| 260 | new_generation_steps=new_generation_stages, |
---|
| 261 | generation_modification=generation_modifications, |
---|
| 262 | end_steps=end_stages, |
---|
| 263 | population_size=parsed_args.popsize, |
---|
| 264 | checkpoint_path=parsed_args.checkpoint_path, |
---|
| 265 | checkpoint_interval=parsed_args.checkpoint_interval |
---|
| 266 | ) |
---|
[1128] | 267 | return experiment |
---|
| 268 | |
---|
| 269 | |
---|
| 270 | def main(): |
---|
| 271 | print("Running experiment with", sys.argv) |
---|
| 272 | parsed_args = parseArguments() |
---|
| 273 | |
---|
[1136] | 274 | if parsed_args.checkpoint_path is not None and os.path.exists(parsed_args.checkpoint_path): |
---|
[1128] | 275 | experiment = load_experiment(parsed_args.checkpoint_path) |
---|
| 276 | FramsticksLib(parsed_args.path, parsed_args.lib, |
---|
| 277 | parsed_args.sim) |
---|
| 278 | else: |
---|
| 279 | experiment = create_experiment() |
---|
| 280 | experiment.init() # init is mandatory |
---|
| 281 | |
---|
| 282 | |
---|
| 283 | experiment.run(parsed_args.generations) |
---|
| 284 | |
---|
[1113] | 285 | # Next call for experiment.run(10) will do nothing. Parameter 10 specifies how many generations should be |
---|
| 286 | # in one experiment. Previous call generated 10 generations. |
---|
| 287 | # Example 1: |
---|
| 288 | # experiment.init() |
---|
| 289 | # experiment.run(10) |
---|
| 290 | # experiment.run(12) |
---|
| 291 | # #This will run for total of 12 generations |
---|
| 292 | # |
---|
| 293 | # Example 2 |
---|
| 294 | # experiment.init() |
---|
| 295 | # experiment.run(10) |
---|
| 296 | # experiment.init() |
---|
| 297 | # experiment.run(10) |
---|
| 298 | # # All work produced by first run will be "destroyed" by second init(). |
---|
| 299 | |
---|
| 300 | |
---|
| 301 | |
---|
| 302 | if __name__ == '__main__': |
---|
| 303 | main() |
---|