class GeneticAlgorithm (threading.Thread):
dim = 10
parents = [[None]] * dim
parents_fit = [None] * dim
best_parent = [None] * heuristic_data_dim
best_parent_fitnes = None
db = None
stop = False
def __init__(self, DIM):
threading.Thread.__init__(self)
self.dim = DIM
self.parents = [[0 for x in range(heuristic_data_dim)] for x in range(10)]
self.parents_fit = [None] * DIM
self.best_parent = [None] * heuristic_data_dim
self.best_parent_fitnes = None
def crossover(self):
childs = [None]* self.dim
for i in range(self.dim):
parent1 = random.randint(0, self.dim-1)
parent2 = random.randint(0, self.dim-1)
while parent1 == parent2:
parent2 = random.randint(0, self.dim-1)
parent3 = random.randint(0, self.dim-1)
while (parent1 == parent3) or (parent2 == parent3):
parent3 = random.randint(0, self.dim-1)
if self.parents_fit[parent1] > self.parents_fit[parent2] and self.parents_fit[parent1] > self.parents_fit[parent3]:
parent_new = parent1
elif self.parents_fit[parent2] > self.parents_fit[parent3]:
parent_new = parent2
else:
parent_new = parent3
childs[i] = self.onePointCrossover(self.parents[i], self.parents[parent_new])
return childs
def onePointCrossover(self, p1, p2):
dim = len(p1)
child = [None]*dim
cut = random.randint(1, dim-2)
brother = random.getrandbits(1)
hasCrossover = random.random()
if hasCrossover < 0.8:
if (brother):
for i in range(dim):
if (i <= cut):
child[i] = p1[i]
else:
child[i] = p2[i]
else:
for i in range(dim):
if (i <= cut):
child[i] = p2[i]
else:
child[i] = p1[i]
else:
if(brother):
child = p1
else:
child = p2
return child
def mutation(self, childs):
global heuristic_data_domain
for i in range(len(childs)):
for j in range(heuristic_data_dim):
pr = random.random()
if pr < 0.01:
childs[i][j] = random.uniform(heuristic_data_domain[j][0], heuristic_data_domain[j][1])
def initialization(self):
global heuristic_data_domain
for i in range(self.dim):
data = self.db.getRow(i)
if (data):
for j in range(heuristic_data_dim):
self.parents[i][j] = data[j+1]
else:
for j in range(heuristic_data_dim):
self.parents[i][j] = random.uniform(heuristic_data_domain[j][0], heuristic_data_domain[j][1])
self.db.insert([i, self.parents[i], None])
def replacement(self, childs, childs_fit):
better_fitness = self.parents_fit[0]
posP = 0
for i in range(1, self.dim):
if (self.parents_fit[i] < better_fitness):
better_fitness = self.parents_fit[i]
posP = i
worst_fitness = 0
posC = 0
for i in range(self.dim):
if(childs_fit[i] > worst_fitness ):
worst_fitness = childs_fit[i]
posC = i
childs[posC] = self.parents[posP]
self.parents = childs
self.parents_fit = childs_fit
def fitness(self, p):
queueGA.put([True, p])
fitness = queueBMO.get()
if fitness == None:
self.stop = True
return None
else:
return fitness
def mainLoop(self):
childs_fit = [None] * self.dim
while not self.stop:
childs = self.crossover()
self.mutation(childs)
self.db.deleteAll()
for i in range(self.dim):
self.db.insert([i, childs[i], None])
for i in range(self.dim):
childs_fit[i] = self.fitness(childs[i])
if stop:
return
self.db.updateFitness(i, childs_fit[i])
self.replacement(childs, childs_fit)
def run(self):
self.db = DataBase()
self.db.start()
self.initialization()
for i in range(self.dim):
if(self.db.getFitness(i) == None):
self.parents_fit[i] = self.fitness(self.parents[i])
if not self.stop:
self.db.updateFitness(i, self.parents_fit[i])
else:
break
else:
self.parents_fit[i] = self.db.getFitness(i)
self.mainLoop()
print ("Stoping GA")
