-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathiac.py
163 lines (138 loc) · 4.89 KB
/
iac.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
# Implementation algorithme IAC
# vrep api utilities
import vrep
# iac utilities
import kppv
import tree
import toy
import utilities
# math utilities
import random
from math import sqrt
import time
# Plotter
import matplotlib.pyplot as plt
t=0
delay = 150
nbExemple = 20
duree = 1000 #1500
c1 = 300
varKppv = 10
vitRobot = 1
# Start IAC
vrep.simxFinish(-1) # just in case, close all opened connections
clientID=vrep.simxStart('127.0.0.1',19999,True,True,5000,5)
err_epuck, epuckHandle = vrep.simxGetObjectHandle(clientID,"ePuck", vrep.simx_opmode_oneshot_wait)
err_toy, toyHandle = vrep.simxGetObjectHandle(clientID,"Sphere", vrep.simx_opmode_oneshot_wait)
err_left,leftHandle = vrep.simxGetObjectHandle(clientID,"ePuck_leftJoint",vrep.simx_opmode_oneshot_wait)
err_right,rightHandle = vrep.simxGetObjectHandle(clientID,"ePuck_rightJoint",vrep.simx_opmode_oneshot_wait)
# Prediction machine P (arbre d'experts) qui apprends a predire la
# distance au jouet
Pbdd = tree.node(-1,-1,[],None,None,[],[])
# Meta learning machine (apprends a predire l'erreure)
MPbdd = []
S_calculated = 0
# Debut de la simulation
while t < duree:
# Vecteur d'actions possibles
actions = []
if t==0:
err,epuck_position = vrep.simxGetObjectPosition(clientID, epuckHandle, -1, vrep.simx_opmode_streaming)
else:
err,epuck_position = vrep.simxGetObjectPosition(clientID, epuckHandle, -1, vrep.simx_opmode_buffer)
pass
# Creation des actions aleatoires
for i in range(0,nbExemple):
actions.append( [random.uniform(-vitRobot,vitRobot) , random.uniform(-vitRobot,vitRobot) , random.uniform(0,1), S_calculated] )
pass
if t<delay:
# Action random
actionChoisie = actions[0]
pass
else:
#Calcul du learning progress LPi pour chaque action
# Ep = erreur de prediction de la learning machine P
Ep = []
# Erreure moyenne de l'expert associe a l'action
Emtplusun = []
LP = []
# Calcul de LP pour chaque action aleatoire tiree
for x in range(0,nbExemple):
# Prediction de l'erreur de prediction de la meta learning-machine MP
Ep.append( kppv.kppv(actions[x], MPbdd,varKppv) ) #### probleme de taille entre actions[x] et la base de MPbdd
# Calcul de la moyenne Em(t+1)
Emtplusun.append(utilities.moyenneMobile(utilities.getTheGoodLE(Pbdd,actions[x]),Ep[x],delay) )
# Calcul de LP
LP.append( [-(Emtplusun[x] - utilities.getTheGoodLEM(Pbdd,delay,actions[x]) ) , x] )
pass
# Tri du tableau contenant les LPi
LP.sort()
# 10% de chances de realiser une action random
if random.randint(0,100)<10:
#Action random
actionChoisie = actions[0]
pass
else:
# Selection de l'action ayant le LP le plus eleve
actionChoisie = actions[LP[len(LP)-1][1]]
pass
pass
#On a choisi l'action
# Estimation de S(t+1) avec la learning machine P
# Choix de l'expert associe a l'action choisie
T= utilities.getTheGoodTree(Pbdd,actionChoisie)
if len(T.data) > varKppv:
S_predicted = kppv.kppv(actionChoisie,T.data,varKppv)
else:
S_predicted = 0
pass
# On realise l'action dans VREP
vrep.simxSetJointTargetVelocity(clientID,leftHandle,actionChoisie[0],vrep.simx_opmode_oneshot)
vrep.simxSetJointTargetVelocity(clientID,rightHandle,actionChoisie[1],vrep.simx_opmode_oneshot)
vec = toy.toy_controller(actionChoisie[2],epuck_position)
if isinstance(vec,type([])) and len(vec)!=0:
vrep.simxSetObjectPosition(clientID,toyHandle,-1,vec,vrep.simx_opmode_oneshot)
pass
# On calcule E(t)
if t ==0:
err_toy, toyPosition = vrep.simxGetObjectPosition(clientID,toyHandle, -1, vrep.simx_opmode_streaming)
else:
err_toy, toyPosition = vrep.simxGetObjectPosition(clientID,toyHandle, -1, vrep.simx_opmode_buffer)
# Calcul de l'erreur de prediction
S_calculated = sqrt((epuck_position[0] - toyPosition[0])**2 + (epuck_position[1] - toyPosition[1])**2)
E = abs(S_predicted - S_calculated)
# Ajout a la base de donnees de MP
# Retires S(t) du vecteur actionChoisie
actionChoisie.pop()
# Ajoutes l'erreur de prediction
actionChoisie.append(E)
MPbdd.append( actionChoisie )
#print 'f =',actionChoisie[2],'S_calculated =',S_calculated###################################
# On ajoute E(t) a LE (liste d'erreures de l'expert associe)
T.LE.append(E)
# On calcul Em(t) et ajout a LEM (liste des moyennes d'erreures)
if t>delay:
Em = utilities.moyenneMobile(T.LE,0,delay)
else:
Em = utilities.moyenneMobile(T.LE,0,t)
T.LEM.append(Em)
# Ajout dans la base de donnees de P
actionChoisie.pop()
actionChoisie.append(S_calculated)
T.data.append(actionChoisie)
# Separation pour creer deux experts
utilities.splitBDD(T,c1)
print 't =',t #
t+=1
#time.sleep(1)
pass
# Stops robot
vrep.simxSetJointTargetVelocity(clientID,leftHandle,0,vrep.simx_opmode_oneshot)
vrep.simxSetJointTargetVelocity(clientID,rightHandle,0,vrep.simx_opmode_oneshot)
# Affichage de l'arbre d'experts
tree.status(Pbdd,0) ###########
# Affichage de la moyenne d'erreur par expert
utilities.superPlot(Pbdd)
plt.show()
# Fin de la simulation
vrep.simxFinish(clientID)