def sensorX(self, walls, angle):
wp = []
dist = 5
for w in walls:
mp = (int(self.center[0] -
dist * cos(radians(self.angle + angle))),
int(self.center[1] +
dist * sin(radians(self.angle + angle))))
a, b = w.begin, w.end
p = collide.intersect(w.begin, w.end, self.center, mp)
if p != None:
if p[0] >= a[0] and p[0] <= b[0] and p[1] <= b[1] and p[
1] >= a[1]:
wp.append(p)
# ms = (int(self.center[0] + dist * cos(radians(self.angle + angle + 90))),
# int(self.center[1] + dist * sin(radians(self.angle + angle + 90))))
#
# c, d = droite(self.center, ms)
# d = evalPointDroite(p, (c, d))
# ang = (self.angle + angle) % 360
# if ang <= 270 and ang >= 90:
# if c > 0:
# wp.append(p)
# else:
# if c < 0:
# wp.append(p)
# print(wp)
dp = [collide.distc(self.center, i) for i in wp]
if dp != []:
pos = dp.index(min(dp))
return wp[pos]
return a # TO DO: a ameliorer
def eval_genomes(population,generation,nb_run):
global solution;
global probMutation
taillePopulation =len(population);
visitedPositions = set();
for j in range(generation):
print(j,"-ieme generation")
pos = []
dis = []
delta = 0;
### evaluation des reseaux neurones
for genome in population:
#affichage de image
# positionFinale = robot.simulationNavigation(genome);
positionFinale = robot.simulationNavigationSansImage(genome);
if positionFinale not in visitedPositions:
visitedPositions.add(positionFinale);
delta += 1;
# evaluation
pos.append(positionFinale);
dis.append(10000-distc(positionFinale,robot.finish_position))
if butAtteint(positionFinale):
plotmaze(visitedPositions,"./rf/fitnessGuideMaze_{}_run_{}_generation_image_finale.png".format(nb_run,j))
return;
f = open("./rf/fitness_5_run.txt","a");
f.write(str(positionFinale)+"\n");
f.close();
### generer prochaine generation
nextPopulation = [];
distribution = rangementParQualite(p = 0.1,taille = taillePopulation);
for i in range(taillePopulation//2):
#selection
individu1,individu2 = selection(population,dis,distribution);
#croisement
individu3,individu4 = croissement(individu1,individu2);
#mutation
individu3 = mutation(individu3,probMutation);
individu4 = mutation(individu4,probMutation);
#ajouter dans la prochaine population
nextPopulation.append(individu3);
nextPopulation.append(individu4);
population = nextPopulation;
if delta <20:
probMutation += 0.01
### plot
#generation de graph
if j%50 == 0 and j!=0:
plotmaze(visitedPositions,"./rf/fitnessGuideMaze_{}_run_{}_generation_image.png".format(nb_run,j))
def perception(self, walls):
sensordata = self.sensor(walls)
assert None not in sensordata
return [collide.distc(self.center, i)
for i in sensordata] + self.radar(walls)
#test
#def radar(x0,y0,angle):
# r = 1
# x1,y1 = x0-r*cos(radians(angle-45)), y0+r*sin(radians(angle-45));
# print("x1,y1: ",x1," ",y1)
# x2,y2 = x0-r*cos(radians(angle+45)), y0+r*sin(radians(angle+45));
# print("x2,y2: ",x2," ",y2)
#
#radar(0,0,90)
def butAtteint(positionFinale):
if distc(positionFinale, robot.finish_position) < 10 :
return True;
else:
return False;
def eval_genomes(population, generation, nb_run):
global test_var1
global test_var2
global solution
global probMutation
global position
k = 20
#nombre de voisins les plus proches
visitedPosition = set()
R = set()
for j in range(1, generation + 1):
print(j, "-ieme generation")
delta = 0
pos = []
nouveaute = []
### evaluate population and add into archive of past behaviors
for genome in population:
#affichage de image
# positionFinale = robot.simulationNavigation(genome);
positionFinale = robot.simulationNavigationSansImage(genome)
# ajouter la positionFinale dans l'ensemble de positions visitees par la population
pos.append(positionFinale)
# ajouter la positionFinale dans la list R
R.add(positionFinale)
# MAJ de nouveaute
if (positionFinale) not in visitedPosition:
nouveaute.append(10000)
else:
nouveaute.append(0)
# ajouter la positionFinale dans l'ensemble de positions visitees
if positionFinale not in visitedPosition:
visitedPosition.add(positionFinale)
delta += 1
# verifier si le but est atteint
if butAtteint(positionFinale):
plotmaze(
visitedPosition,
"./rf/noveltyGuideMaze_{}_run_{}_generation.png".format(
nb_run, j))
# plotmaze(visitedPosition,"./test/result_pb5sur1000p01_250000evaluations/noveltyGuideMaze_{}_run_{}_generation_image_finale.png".format(nb_run,j))
return
f = open("./rf/novelty_5_run.txt", "a")
f.write(str(positionFinale) + "\n")
f.close()
### calculer le nouveaute par rapport a ses distances avec les voisins pour chaque genome dans la population
# print("visitedPosition: ",visitedPosition);
for i in range(len(population)):
#calculer les distances entre cette position et toutes les autres positions visitees
distances = []
heapq.heapify(distances)
for p in R:
heapq.heappush(distances, distc(pos[i], p))
nouveaute[i] += sum(
[heapq.heappop(distances) for d in range(k + 1)])
# print("len(distance) :",len(distances))
# print("len(visitedPOsition) :",len(visitedPosition));
# print("positionFi ", pos[i]);
# print("pos[i] nouveaute: ",nouveaute[i]);
# print("nouveaute: ",nouveaute)
# print("pos : ",pos);
### generer prochaine generation
nextPopulation = []
distribution = rangementParQualite(p=0.1, taille=len(population))
for i in range(len(population) // 2):
#selection
individu1, individu2 = selection(population, nouveaute,
distribution)
#croisement
individu3, individu4 = croissement(individu1, individu2)
#mutation
individu3 = mutation(individu3, probMutation)
individu4 = mutation(individu4, probMutation)
#ajouter dans la prochaine population
nextPopulation.append(individu3)
nextPopulation.append(individu4)
population = nextPopulation
# R ne retenir que les 1250 positions de nouveaute les plus haute
if len(R) > 1250: #250*5
l = []
for position in R:
nvt = sum(
les_k_plus_petits_elements(
20, [distc(position, i) for i in visitedPosition]))
l.append([position, nvt])
R = set([i[0] for i in sorted(l, key=lambda x: -x[1])[:1250]])
# adjuster la probabilite de mutatioin dynamiquement
if delta < 20:
probMutation += 0.005
print("prob mutation ", probMutation)
#generation de graph
print("j=", j)
if j % 50 == 0 and j != 0:
plotmaze(
visitedPosition,
"./rf/noveltyGuideMaze_{}_run_{}_generation.png".format(
nb_run, j))
def butAtteint(positionFinale):
if distc(positionFinale, robot.finish_position) < 10:
print("**************goal atteint************************")
return True
else:
return False
def eval_genomes(nb_run):
global probMutation
size_layers = (16, 12, 1)
X = [[None for i in range(200)] for j in range(400)]
visitedPosition = set()
R = set()
#generate and evaluate B random genomes initiales
B = [Mlp(size_layers) for i in range(1000)]
pos = [robot.simulationNavigationSansImage(genome) for genome in B]
for genome, position in zip(B, pos):
R.add(position)
X[position[0]][position[1]] = genome
visitedPosition.add(position)
nouveaute_position = []
for position in visitedPosition:
nouveaute_position.append(
(position,
sum(
les_k_plus_petits_elements(20,
[distc(position, i) for i in R]))))
for generation in range(1, 1001):
delta = 0
# choisir 250 genomes dans la population par rapport a sa nouveaute
positions = select_k_position(250, nouveaute_position)
B = [X[position[0]][position[1]] for position in positions]
# mutation pour generer leurs enfants
B = [mutation(genome, 1) for genome in B]
# evaluer les genomes
pos = [robot.simulationNavigationSansImage(genome) for genome in B]
# ajouter dans les grid et la list de positions visitees dans le passe
for genome, position in zip(B, pos):
R.add(position)
X[position[0]][position[1]] = genome
# ajouter la positionFinale dans l'ensemble de positions visitees
if position not in visitedPosition:
visitedPosition.add(position)
delta += 1
# si le goal est atteint
if butAtteint(position):
plotmaze(
visitedPosition,
"./result1905/result_NS_plus_mapelite/NS_mapElite_Maze_{}_run_{}_generation_image_finale.png"
.format(nb_run, generation))
return
nouveaute_position = []
# calculer nouveaute pour tout genome de la population
for position in visitedPosition:
nouveaute_position.append(
(position,
sum(
les_k_plus_petits_elements(
20, [distc(position, i) for i in R]))))
# calculer nouveaute pour tout genome dans le list R
if len(R) > 1250: #250*5
l = []
for position in R:
nvt = sum(
les_k_plus_petits_elements(
20, [distc(position, i) for i in visitedPosition]))
l.append([position, nvt])
R = set([i[0] for i in sorted(l, key=lambda x: -x[1])[:1250]])
print("len(visitedPosition) ", len(visitedPosition))
#generation de graph
print("generation = ", generation)
if generation % 50 == 0 and generation != 0:
# plotmaze(visitedPosition,"./result/noveltyGuideMaze_{}_run_{}_generation_image.png".format(nb_run,j))
plotmaze(
visitedPosition,
"./result1905/result_NS_plus_mapelite/NS_mapElite_Maze_{}_run_{}_generation_image.png"
.format(nb_run, generation))
if delta < 20:
probMutation += 0.005
print("prob mutation ", probMutation)
def eval_genomes(nb_run):
fn = "./2305/map_" + str(nb_run) + "_run_mutationfaible.txt"
f = open(fn, "a")
f.close()
global probMutation
size_layers = (16, 12, 1)
X = [[None for i in range(200)] for j in range(400)]
visitedPosition = set()
R = set()
#generate and evaluate B random genomes initiales
B = [Mlp(size_layers) for i in range(1000)]
pos = [robot.simulationNavigationSansImage(genome) for genome in B]
for genome, position in zip(B, pos):
if X[position[0]][position[1]] == None:
R.add(position)
X[position[0]][position[1]] = genome
visitedPosition.add(position)
f = open(fn, "a")
f.write(str(position) + "\n")
f.close()
nouveaute_position = []
for position in visitedPosition:
nouveaute_position.append(
(position,
sum(
les_k_plus_petits_elements(20,
[distc(position, i) for i in R]))))
for generation in range(1, 501):
delta = 0
# choisir 250 genomes dans la population par rapport a sa nouveaute
positions = select_k_position(200, nouveaute_position)
B = [X[position[0]][position[1]] for position in positions]
# mutation pour generer leurs enfants
B = varier(B)
# evaluer les genomes
pos = [robot.simulationNavigationSansImage(genome) for genome in B]
# ajouter dans les grid et la list de positions visitees dans le passe
for genome, position in zip(B, pos):
if X[position[0]][position[1]] == None:
R.add(position)
X[position[0]][position[1]] = genome
# ajouter la positionFinale dans l'ensemble de positions visitees
visitedPosition.add(position)
delta += 1
# si le goal est atteint
if butAtteint(position):
plotmaze(
visitedPosition,
"./2305/NS_mapElite_Maze_{}_run_{}_generation.png".
format(nb_run, generation))
return
f = open(fn, "a")
f.write(str(position) + "\n")
f.close()
nouveaute_position = []
# calculer nouveaute pour tout genome de la population
for position in visitedPosition:
nouveaute_position.append(
(position,
sum(
les_k_plus_petits_elements(
20, [distc(position, i) for i in R]))))
# calculer nouveaute pour tout genome dans le list R
if len(R) > 1250: #250*5
l = []
for position in R:
nvt = sum(
les_k_plus_petits_elements(
20, [distc(position, i) for i in visitedPosition]))
l.append([position, nvt])
R = set([i[0] for i in sorted(l, key=lambda x: -x[1])[:1250]])
print("len(visitedPosition) ", len(visitedPosition))
#generation de graph
print("generation = ", generation)
if generation % 5 == 0 and generation != 0:
plotmaze(
visitedPosition,
"./2305/NS_mapElite_Maze_{}_run_{}_generation.png".format(
nb_run, generation))
if delta < 20:
probMutation += 0.01
print("prob mutation ", probMutation)
