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)
