def guess_password(self, target): startTime = datetime.datetime.now() def fnGetFitness(genes): return get_fitness(genes, target) def fnDisplay(genes): display(genes, target, startTime) optimalFitness = len(target) best = genetic.get_best(fnGetFitness, len(target), optimalFitness, self.geneset, fnDisplay) self.assertEqual(best, target)
def run_with(self, geneSet, width, height, minGenes, maxGenes, expectedNumberOfInstructions, maxMutationRounds, fnCreateField, expectedNumberOfSteps): mowerStartLocation = lawnmower.Location(int(width / 2), int(height / 2)) mowerStartDirection = lawnmower.Directions.South.value startTime = datetime.datetime.now() optimalFitness = Fitness(width * height, expectedNumberOfInstructions, expectedNumberOfSteps) def fnMutate(child): mutate(child, geneSet, minGenes, maxGenes, fnGetFitness, maxMutationRounds) def fnCreate(): return create(geneSet, 1, height) def fnEvaluate(instructions): program = Program(instructions) mower = lawnmower.Mower(mowerStartLocation, mowerStartDirection) field = fnCreateField() try: program.evaluate(mower, field) except RecursionError: pass return field, mower, program def fnGetFitness(genes): return get_fitness(genes, fnEvaluate) def fnDisplay(candidate): display(candidate, startTime, fnEvaluate) best = genetic.get_best(fnGetFitness, None, optimalFitness, None, fnDisplay, fnMutate, fnCreate, poolSize=10, crossover=crossover) self.assertTrue(not best.Fitness > optimalFitness)
def sort_numbers(self, totalNumbers=10): geneset = [i for i in range(100)] startTime = datetime.datetime.now() def fnDisplay(candidate): display(candidate, startTime) def fnGetFitness(genes): return get_fitness(genes) optimalFitness = Fitness(totalNumbers, 0) best = genetic.get_best(fnGetFitness, totalNumbers, optimalFitness, geneset, fnDisplay) self.assertTrue(not optimalFitness > best.Fitness) def test_benchmark(self): genetic.Benchmark.run(lambda: self.sort_numbers(40))
def test_group(self, maxGeneCount=500, maxGeneGroupSize=7): #population creation geneset = [] for eachGene in range(maxGeneCount): workRole = random.randint(1, 6) peopleRole = random.randint(1, 6) gene = Resource(eachGene + 1, workRole, peopleRole) geneset.append(gene) #Groups geneGroupCount = math.ceil(maxGeneCount / maxGeneGroupSize) startTime = datetime.datetime.now() def fnDisplay(candidate): display(candidate, startTime) def fnGetFitness(genes, geneGroupCount, maxGeneGroupSize): return get_fitness(genes, geneGroupCount, maxGeneGroupSize) def fnMutate(genes, maxGeneGroupSize): return mutate(genes, maxGeneGroupSize) optimalFitness = Fitness([x+2*maxGeneGroupSize for x in range(geneGroupCount)], \ geneGroupCount ) print("Optimal:", optimalFitness) best = genetic.get_best(fnGetFitness, maxGeneCount, maxGeneGroupSize, optimalFitness, geneset, fnDisplay, custom_mutate=fnMutate, maxAge=100000) # print("Genes: ",best.Genes, "Group Count:", geneGroupCount) self.assertTrue(not optimalFitness < best.Fitness)
def find_regex(self, wanted, unwanted, expectedLength, customOperators=None): startTime = datetime.datetime.now() textGenes = wanted | set(c for w in wanted for c in w) fullGeneset = [i for i in allMetas | textGenes] def fnDisplay(candidate): display(candidate, startTime) def fnGetFitness(genes): return get_fitness(genes, wanted, unwanted) mutationRoundCounts = [1] mutationOperators = [ partial(mutate_add, geneset=fullGeneset), partial(mutate_replace, geneset=fullGeneset), mutate_remove, mutate_swap, mutate_move, ] if customOperators is not None: mutationOperators.extend(customOperators) def fnMutate(genes): mutate(genes, fnGetFitness, mutationOperators, mutationRoundCounts) optimalFitness = Fitness(len(wanted), len(wanted), 0, expectedLength) best = genetic.get_best(fnGetFitness, max(len(i) for i in textGenes), optimalFitness, fullGeneset, fnDisplay, fnMutate, poolSize=10) self.assertTrue(not optimalFitness > best.Fitness) for info in regexErrorsSeen.values(): print("") print(info[0]) print(info[1]) print(info[2])
def test(self, bitValues = [512, 256, 128, 64, 32, 16, 8, 4, 2, 1], maxSeconds = None): geneset = [i for i in range(2)] startTime = datetime.datetime.now() def fnDisplay(candidate): display(candidate, startTime, bitValues) def fnGetFitness(genes): return get_fitness(genes, bitValues) def fnMutate(genes): mutate(genes, len(bitValues)) optimalFitness = 3.14159 length = 2 * len(bitValues) best = genetic.get_best(fnGetFitness, length, optimalFitness, geneset, fnDisplay, fnMutate, maxAge = 250, maxSeconds = maxSeconds) return optimalFitness <= best.Fitness
def fill_knapsack(self, items, maxWeight, maxVolume, optimalFitness): startTime = dt.now() window = Window(1, max(1, int(len(items) / 3)), int(len(items) / 2)) sortedItems = sorted(items, key = lambda item: item.Value) def fnDisplay(candidate): display(candidate, startTime) def fnGetFitness(genes): return get_fitness(genes) def fnCreate(): return create(items, maxWeight, maxVolume) def fnMutate(genes): mutate(genes, items, maxWeight, maxVolume, window) best = genetic.get_best(fnGetFitness, None, optimalFitness, None, fnDisplay, fnMutate, fnCreate, maxAge = 100) self.assertTrue(not optimalFitness > best.Fitness)
def test(self): geneset = [i + 1 for i in range(10)] startTime = datetime.datetime.now() def fnDisplay(candidate): display(candidate, startTime) def fnGetFitness(genes): return get_fitness(genes) def fnMutate(genes): mutate(genes, geneset) optimalFitness = Fitness(36, 360, 0) best = genetic.get_best(fnGetFitness, 10, optimalFitness, geneset, fnDisplay, custom_mutate=fnMutate) self.assertTrue(not optimalFitness > best.Fitness)
def test(self): geneset=[i for i in range(1,9+1)] optimalValue=100 startTime=datetime.datetime.now() geneIndexes=[i for i in range(0,81)] validationRules=build_validation_rules() def fnDisplay(candidate): display(candidate,startTime) def fnGetFitness(genes): return get_fitness(genes,validationRules) def fnCreate(): return random.sample(geneset*9,81) def fnMutate(genes): mutate(genes,validationRules) best=genetic.get_best(fnGetFitness,None,optimalValue,None,fnDisplay,fnMutate,fnCreate,maxAge=50) self.assertEqual(best.Fitness,optimalValue)
def find_features(self, genes, X, y): geneset = [0, 1] startTime = dt.datetime.now() def fnDisplay(candidate): display(candidate, startTime) def fnGetFitness(genes): return get_fitness( genes, linearSVC, X, y, (CONST_C[genes[0] * 4 + genes[1] * 2 + genes[2] * 1], )) optimalFitness = ModelFitness(genes, 1) best = gn.get_best(fnGetFitness, len(genes), optimalFitness, geneset, fnDisplay, custom_mutate=None, maxAge=100) self.assertTrue(not optimalFitness > best.ModelFitness)
def color(self, file, colors): rules, nodes = load_data(file) colorLookup = {color[0]: color for color in colors} geneset = list(colorLookup.keys()) startTime = datetime.datetime.now() nodeIndexLookup = {key: index for index, key in enumerate(sorted(nodes))} def fnDisplay(candidate): display(candidate, startTime) def fnGetFitness(genes): return get_fitness(genes, rules, nodeIndexLookup) optimalValue = len(rules) best = genetic.get_best(fnGetFitness, len(nodes), optimalValue, geneset, fnDisplay) self.assertTrue(not optimalValue > best.Fitness) keys = sorted(nodes) for index in range(len(nodes)): print(keys[index] + " is " + colorLookup[best.Genes[index]])
def find_knight_positions(self, width, height, num): def fnDisplay(candidate): display(candidate, width, height) def fnGetFitness(genes): return get_fitness(genes, width, height) def fnGetRandomPositions(): return Position(random.randrange(0, width), random.randrange(0, height)) def fnMutate(genes): mutate(genes, fnGetRandomPositions) def fncreate(): return create(fnGetRandomPositions, num) optimalFitness = width * height best, mutations = genetic.get_best(fnGetFitness, None, optimalFitness, None, fnDisplay, fnMutate, fncreate) print(not optimalFitness < best.Fitness)
def test_solve(self): numberOfTask = 10 arrayOfDependencies = load_task_dependency("resource.ra") arrayOfDuration = load_task_duration("duration.ra") def fnGenerateGenes(length, geneSet): return generate_genes(numberOfTask, geneSet, arrayOfDependencies, arrayOfDuration) def fnCreate(): return random.sample(geneset, len(geneset)) def fnDisplay(candidate): display(candidate, startTime) def fnGetFitness(genes): return get_fitness_of_duration(genes, numberOfTask, arrayOfDependencies, arrayOfDuration) def fnMutate(genes, bestParent): return mutate(genes, fnGetFitness, arrayOfDependencies, arrayOfDuration, bestParent) def fnCrossover(genes, donor): return crossover(genes, donor, fnGetFitness) startTime = datetime.datetime.now() best = genetic.get_best(fnGenerateGenes, fnGetFitness, 10, None, self.geneSet, fnDisplay, fnMutate, fnCreate, maxAge=500, poolSize=70, crossover=fnCrossover)
def generate(self, diagonalSize, maxAge): nSquared = diagonalSize * diagonalSize geneset = [i for i in range(1, nSquared + 1)] expectedSum = diagonalSize * (nSquared + 1) / 2 # sum of all in range 1:nSquared geneIndexes = [i for i in range(0, len(geneset))] def fnCustomCreate(): return random.sample(geneset, len(geneset)) def fnMutate(genes): mutate(genes, geneIndexes) def fnGetFitness(genes): return get_fitness(genes, diagonalSize, expectedSum) def fnDisplay(candidate): display(candidate, diagonalSize, startTime) optimalValue = Fitness(0) startTime = datetime.datetime.now() best = genetic.get_best( fnGetFitness, nSquared, optimalValue, geneset, fnDisplay, fnMutate, fnCustomCreate, maxAge )
def solve_unknowns(self, numUnknowns, geneset, equations, fnGenesToInputs): startTime = datetime.datetime.now() maxAge = 50 window = Window(max(1, int(len(geneset) / (2 * maxAge))), max(1, int(len(geneset) / 3)), int(len(geneset) / 2)) geneIndexes = [i for i in range(numUnknowns)] sortedGeneset = sorted(geneset) def fnDisplay(candidate): display(candidate, startTime, fnGenesToInputs) def fnGetFitness(genes): return get_fitness(genes, equations) def fnMutate(genes): mutate(genes, sortedGeneset, window, geneIndexes) optimalFitness = Fitness(0) best = genetic.get_best(fnGetFitness, numUnknowns, optimalFitness, geneset, fnDisplay, fnMutate, maxAge=maxAge) self.assertTrue(not optimalFitness > best.Fitness)
def guess_password(self, target): startTime = datetime.datetime.now() def display(candidate, startTime): timeDiff = datetime.datetime.now() - startTime print("{}\t{}\t{}".format( ''.join(candidate.Genes), candidate.Fitness, timeDiff)) def get_fitness(genes, target): return sum(1 for expected, actual in zip(target, genes) if expected == actual) def fnGetFitness(genes): return get_fitness(genes, target) def fnDisplay(candidate): display(candidate, startTime) optimalFitness = len(target) best = genetic.get_best(fnGetFitness, len(target), optimalFitness, self.geneset, fnDisplay) self.assertEqual(''.join(best.Genes), target)
def color(self, file, colors): rules, nodes = load_data(file) optimalValue = len(rules) colorLookup = {color[0]: color for color in colors} geneset = list(colorLookup.keys()) startTime = datetime.datetime.now() nodeIndexLookup = { key: index for index, key in enumerate(sorted(nodes)) } def fnDisplay(candidate): display(candidate, startTime) def fnGetFitness(genes): return get_fitness(genes, rules, nodeIndexLookup) def fnMutate(genes): mutate(genes, geneset) def fnCrossover(parent, donor): return crossover2(parent, donor) best = genetic.get_best(fnGetFitness, len(nodes), optimalValue, geneset, fnDisplay, custom_mutate=fnMutate, maxAge=500, poolSize=25, crossover=fnCrossover) self.assertTrue(not optimalValue > best.Fitness) keys = sorted(nodes) for index in range(len(nodes)): print(keys[index] + " is " + colorLookup[best.Genes[index]])
def find_knight_positions(self, boardWidth, boardHeight, expectedKnights): startTime = datetime.datetime.now() def fnDisplay(candidate): display(candidate, startTime, boardWidth, boardHeight) def fnGetFitness(genes): return get_fitness(genes, boardWidth, boardHeight) allPositions = [ Position(x, y) for y in range(boardHeight) for x in range(boardWidth) ] if boardWidth < 6 or boardHeight < 6: nonEdgePositions = allPositions else: nonEdgePositions = [ i for i in allPositions if 0 < i.X < boardWidth - 1 and 0 < i.Y < boardHeight - 1 ] def fnGetRandomPosition(): return random.choice(nonEdgePositions) def fnMutate(genes): mutate(genes, boardWidth, boardHeight, allPositions, nonEdgePositions) def fnCreate(): return create(fnGetRandomPosition, expectedKnights) optimalFitness = boardWidth * boardHeight best = genetic.get_best(fnGetFitness, None, optimalFitness, None, fnDisplay, fnMutate, fnCreate) self.assertTrue(not optimalFitness > best.Fitness)
def test(self): geneset = [j for i in range(1, 10) for j in range(1, 10)] startTime = datetime.datetime.now() def fnDisplay(candidate): display(candidate, startTime) def fnGenFitness(genes): return get_fitness(genes) geneIndexes = [i for i in range(0, len(geneset))] def fnMutate(genes): mutate(genes, geneIndexes) optimalFitness = Fitness(0) best = genetic.get_best(fnGenFitness, 9 * 9, optimalFitness, geneset, fnDisplay, fnMutate, maxAge=1000) self.assertTrue(not optimalFitness > best.Fitness)
def generate(self, diagSize, maxAge): nSqr = diagSize * diagSize geneset = [i for i in range(1, nSqr + 1)] expectedSum = diagSize * (nSqr + 1) / 2 geneIndexes = [i for i in range(0, len(geneset))] def fnGetFitness(genes): return get_fitness(genes, diagSize, expectedSum) def fnCustomCreate(): return random.sample(geneset, len(geneset)) def fnDisplay(candidate): display(candidate, diagSize, startTime) def fnMutate(genes): mutate(genes, geneIndexes) optVal = Fitness(0) startTime = datetime.datetime.now() best = genetic.get_best(fnGetFitness, nSqr, optVal, geneset, fnDisplay, fnMutate, fnCustomCreate, maxAge) self.assertTrue(not optVal > best.fitness)
def solve(self, idToLocationLookup, optimalSequence): geneset = [i for i in idToLocationLookup.keys()] def fnCreate(): return random.sample(geneset, len(geneset)) def fnDisplay(candidate): display(candidate, startTime) def fnGetFitness(genes): return get_fitness(genes, idToLocationLookup) def fnMutate(genes): mutate(genes, fnGetFitness) def fnCrossover(parent, donor): return crossover(parent, donor, fnGetFitness) optimalFitness = fnGetFitness(optimalSequence) startTime = datetime.datetime.now() best = genetic.get_best(fnGetFitness, None, optimalFitness, None, fnDisplay, fnMutate, fnCreate, maxAge=500, poolSize=25, crossover=fnCrossover) self.assertTrue(not optimalFitness > best.Fitness)
def guess_password(lenght = 10, target=None): geneSet = [0,1] start_time = dt.datetime.now() genetic.get_best(get_fitness, lenght, geneSet, display, start_time=start_time)
def find_circuit(self, rules, expectedLength): startTime = datetime.datetime.now() def fnDisplay(candidate, length=None): if length is not None: print("-- distinct nodes in circuit:", len(nodes_to_circuit(candidate.Genes)[1])) display(candidate, startTime) def fnGetFitness(genes): return get_fitness(genes, rules, self.inputs) def fnCreateGene(index): return create_gene(index, self.geneSet) def fnMutate(genes): mutate(genes, fnCreateGene) maxLength = expectedLength def fnCreate(): return [fnCreateGene(i) for i in range(maxLength)] def fnOptimizationFunction(variableLength): nonlocal maxLength maxLength = variableLength return genetic.get_best(fnGetFitness, None, len(rules), None, fnDisplay, fnMutate, fnCreate, poolSize=3, maxSeconds=30) def fnIsImprovement(currentBest, child): return child.Fitness == len(rules) and \ len(nodes_to_circuit(child.Genes)[1]) < \ len(nodes_to_circuit(currentBest.Genes)[1]) def fnIsOptimal(child): return child.Fitness == len(rules) and \ len(nodes_to_circuit(child.Genes)[1]) <= expectedLength def fnGetNextFeatureValue(currentBest): return len(nodes_to_circuit(currentBest.Genes)[1]) best = genetic.get_best(fnGetFitness, None, len(rules), None, fnDisplay, fnMutate, fnCreate, poolSize=3) self.assertTrue(best.Fitness == len(rules)) self.assertFalse(len(nodes_to_circuit(best.Genes)[1]) > expectedLength)
def fnOptimizationFunction(variableLength): nonlocal maxLength maxLength = variableLength return genetic.get_best(fnGetFitness, None, len(rules), None, fnDisplay, fnMutate, fnCreate, poolSize=3, maxSeconds=30)
def guess_password(self, target): optimalFitness = len(target) best = genetic.get_best(geneSet, len(target), fnGetFitness, fnDisplay) self.assertEqual(best.Genes, target)