[PYTHON] Stärkung des Lernens der dritten Zeile
Während der Lernsitzung, an der ich teilnahm, gab es eine Geschichte über die Stärkung der dritten Zeile, also schrieb ich den Code.
Verweise
- Wie man ein stärkeres Roboterspiel macht - Stärkung des Lernens durch Lernen- B00CXEXQ7U & linkCode = as2 & tag = shimashimao06-22)
- Lernen stärken //ir-jp.amazon-adsystem.com/e/ir?t=shimashimao06-22&l=as2&o=9&a=4627826613 "width =" 1 "height =" 1 "border =" 0 "alt =" "style = "Grenze: keine! wichtig; Rand: 0px! wichtig;" />
Super Überblick über verbessertes Lernen nach der Monte-Carlo-Methode
Da ich diesmal die Monte-Carlo-Methode (Typrichtlinie) verwendet habe, werde ich nur um die Monte-Carlo-Methode herum schreiben. (Ich bin nicht zufrieden mit dem Inhalt, weil ich gerade ein kleines Buch gelesen habe, als ich die Geschichte während der Lernsitzung hörte.) Um in einem Wort über die Monte-Carlo-Methode zu schreiben, handelt es sich um eine Methode zum Lernen der Anzahl von Werten und optimalen Maßen aus der Erfahrung des Beispiel-Episodenformats, und es handelt sich (wahrscheinlich) um eine Methode zur Bewertung und Verbesserung von Richtlinien, während Richtlinien wiederholt werden. (Der Code kann auch grob in Blöcke für die Wiederholung von Richtlinien, die Bewertung von Richtlinien und die Verbesserung von Richtlinien unterteilt werden.) Die Vor- und Nachteile sind unten aufgeführt.
Vorteile der Monte-Carlo-Methode
- Erfordert keine Vorkenntnisse (Modell) der Umweltdynamik
- Trotzdem können Sie das optimale Verhalten erzielen
- Erfordert keine vollständige Wahrscheinlichkeitsverteilung aller Übergänge wie bei der dynamischen Planung (DP)
Probleme mit der Monte-Carlo-Methode
- Kann nicht in einem vollständig progressiven Verfahren implementiert werden, da die Einnahmen bis zum Ende der Episode unbekannt sind (Wenn es sich um die TD-Methode handelt, kann sie in einem vollständig progressiven Verfahren implementiert werden.)
- Auch wenn das Verhalten in der Mitte der Episode bewertet wird, ist ein Rabatt erforderlich
- Ausreichende Episoden zum Lernen und hohe Zeitkosten für die Probenahme (Das obige Nachschlagewerk besagt auch, dass die Konvergenz im Vergleich zur TD-Methode nicht gut ist.)
Angesichts der Gewinnrate der dreiäugigen Liste, die unter "Wie man einen stärkeren Roboterspieler macht" beschrieben ist, war die Monte-Carlo-Methode die höchste, daher schreibe ich den Code für die Monte-Carlo-Methode.
Referenzcode
Da es sich um eine Drei-Wege-Anordnung handelt, handelt es sich um einen Code beim Lernen in einem diskreten Raum, und der letzte Zeitschritt T existiert.
Der folgende Code ist fast der gleiche wie der in "Wie man einen starken Roboterspieler macht" Puck (ry </ del>) beschriebene Code.
Dann werde ich den folgenden Code schreiben.
python
# coding: utf-8
import numpy as np
from math import floor
import matplotlib.pyplot as plt
class MonteCarloPolycyIteration:
n_states = 3**9 #Anzahl der Staaten
n_actions = 9 #Anzahl der Aktionen
T = 5 #Maximale Anzahl von Schritten
visites = None
states = None
actions = None
rewards = None
drewards = None
results = None
rate = []
#Es wird der gleiche Zustand, wenn die Plattenoberfläche gedreht wird
#Führen Sie die Konvertierung durch und reduzieren Sie die Anzahl der Zustände
convert = [[0,1,2,3,4,5,6,7,8], #Originalzustand
[2,1,0,5,4,3,8,7,6], #Umwandlung(2)
[6,3,0,7,4,1,8,5,2], #Umwandlung(3)
[0,3,8,1,4,7,2,5,8], #Umwandlung(4)
[8,7,6,5,4,3,2,1,0], #Umwandlung(5)
[6,7,8,3,4,5,0,1,2], #Umwandlung(6)
[2,5,8,1,4,7,0,3,6], #Umwandlung(7)
[8,5,2,7,4,1,6,3,0] #Umwandlung(8)
]
#Vektor zur Umwandlung von ternär nach dezimal
power = np.array([ 3**i for i in xrange(8,-1,-1) ], dtype=np.float64)
def __init__(self,L,M,options):
self.L = L #Anzahl der Richtlinieniterationen
self.M = M #Anzahl der Folgen
self.options = options
self.Q = self.init_Q()
np.random.seed(555)
def init_Q(self):
"""Initialisierung der Q-Funktion(initialize look up table) """
return np.zeros((self.n_states,self.n_actions))
def train(self):
# policy iteration
for l in xrange(self.L):
self.visites = self.init_visites()
self.states = self.init_matrix()
self.actions = self.init_matrix()
self.rewards = self.init_matrix()
self.drewards = self.init_matrix()
self.results = self.init_results()
# episode
for m in xrange(self.M):
state3 = self.init_state3()
# step
for t in xrange(self.T):
state = self.encode(state3)
policy = self.generate_policy()
policy = self.policy_improvement(policy,state)
#Aktionsauswahl und -ausführung
action, reward, state3, fin = self.action_train(policy, t, state3)
self.update(m, t, state, action, reward)
if self.isfinished(fin):
#print 'fin_state',state3
self.results[m] = fin
#Berechnung der Rabattprämiensumme
self.calculate_discounted_rewards(m, t)
break
self.Q = self.calculate_state_action_value_function()
self.output_results(l)
self.rate.append( float(len(self.results[self.results==2]))/self.M )
def init_visites(self):
return np.ones((self.n_states, self.n_actions))
def init_matrix(self):
return np.ones((self.M, self.T))
def init_results(self):
return np.zeros(self.M)
def init_state3(self):
return np.zeros(self.n_actions)
def generate_policy(self):
return np.zeros(self.n_actions)
def policy_improvement(self,policy,state):
if self.options['pmode']==0:
q = self.Q[state] #Geben Sie den Wert in der aktuellen Richtlinie an
v = max(q) #Wert im optimalen Verhalten im aktuellen Zustand
a = np.where(q==v)[0][0] #Optimales Verhalten
policy[a] = 1
elif self.options['pmode']==1:
q = self.Q[state] #Geben Sie den Wert in der aktuellen Richtlinie an
v = max(q) #Wert im optimalen Verhalten im aktuellen Zustand
a = np.where(q==v)[0][0] #Optimales Verhalten
policy = np.ones(self.n_actions)*self.options['epsilon']/self.n_actions
policy[a] = 1-self.options['epsilon']+self.options['epsilon']/self.n_actions
elif self.options['pmode']==2:
policy = np.exp(self.Q[state]/self.options['tau'])/ \
sum(np.exp(self.Q[state]/self.options['tau']))
return policy
def action_train(self, policy, t, state3):
npc_action = self.select_npc_action(t, state3, policy)
state3[npc_action] = 2
fin = self.check_game(state3)
reward = self.calculate_reward(fin)
if reward is not None:
return npc_action, reward, state3, fin
enemy_action = self.select_enemy_action(t, state3)
state3[enemy_action] = 1
fin = self.check_game(state3)
reward = self.calculate_reward(fin)
return npc_action, reward, state3, fin
def select_npc_action(self, step, state3, policy):
a = None
if step==0:
a = 0
else:
while 1:
random = np.random.rand()
cprob = 0
for a in xrange(self.n_actions):
cprob += policy[a]
if random<cprob: break
#Überprüfen Sie, ob die Masse bereits gefüllt ist
if state3[a]==0:break
return a
def select_enemy_action(self, step, state3):
reach = 0
pos = [[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[1,5,8],[0,4,8],[2,4,6]]
a = None
for i in xrange(len(pos)):
state_i = state3[pos[i]]
val = sum(state_i)
num = len(state_i[state_i==0])
if val==2 and num==1:
idx = int( state_i[state_i==0][0] )
a = pos[i][idx]
reach = 1
break
if reach==0:
while 1:
a = floor(np.random.rand()*8)+1
if state3[a]==0: break
return a
def check_game(self, state3):
pos = [[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[1,5,8],[0,4,8],[2,4,6]]
for i in xrange(len(pos)):
state_i = state3[pos[i]]
val_npc = sum(state_i==1)
val_enemy = sum(state_i==2)
if val_npc==3:
return 1 #Sieg
elif val_enemy==3:
return 2 #Verlieren
if sum(state3==0)==0:
return 3 #zeichnen
return 0 #Weiterspielen
def calculate_reward(self, fin):
if fin==2:
return 10
elif fin==1:
return -10
elif fin==3:
return 0
elif fin==0:
return None
def update(self,m,t,state,action,reward):
"""Aktualisieren Sie Status, Aktionen, Belohnungen und Anzahl der Erscheinungsbilder"""
self.states[m,t] = state
self.actions[m,t] = action
self.rewards[m,t] = reward
self.visites[state, action] += 1
def isfinished(self,fin):
if fin>0: return True
else: return False
def calculate_discounted_rewards(self, m, t):
for pstep in xrange(t-1,-1,-1):
self.drewards[m,t] = self.rewards[m,t]
self.drewards[m,pstep] = \
self.options['gamma']*self.drewards[m,pstep+1]
def calculate_state_action_value_function(self):
Q = self.init_Q()
for m in xrange(self.M):
for t in xrange(self.T):
s = self.states[m,t]
if s==0: break #Wenn es bis zum 9. Zug beendet ist, ist der Vorgang beendet
a =self.actions[m,t]
Q[s,a] += self.drewards[m,t]
return Q/self.visites
def output_results(self,l):
print 'l=%d: Win=%d/%d, Draw=%d/%d, Lose=%d/%d\n' % (l, \
len(self.results[self.results==2]),self.M, \
len(self.results[self.results==3]),self.M, \
len(self.results[self.results==1]),self.M)
def encode(self, state3):
#zu erklären(2)～(8)Konvertieren Sie nach dem Hinzufügen von 8 Konvertierungsarten in eine Dezimalzahl
cands = [ sum(state3[self.convert[i]]*self.power) #Indizes austauschen und in Dezimalzahlen konvertieren
for i in xrange(len(self.convert))]
#Wählen Sie den kleinsten der 8 Kandidaten
return min(cands)+1
if __name__=='__main__':
options = {'pmode':1,'epsilon':0.05,'tau':2,'gamma':0.9}
mcpi= MonteCarloPolycyIteration(100,100,options)
mcpi.train()
plt.plot(range(len(mcpi.rate)), mcpi.rate)
plt.show()
Versuchsergebnis
Ich experimentierte mit der ε-gierigen Methode mit 100 Schritten als einem Satz.
Im Folgenden veröffentlichen wir die Gewinnrate für 100 Sätze während des Lernens.
Zusammenfassung
Lernen scheint zu funktionieren, aber es ist langsam zu berechnen. .. Es ist rücksichtslos, die Monte-Carlo-Methode in Python zu implementieren. .. Das gleiche Ergebnis wurde übrigens mit Softmax erzielt.
Wir entschuldigen uns für die Unannehmlichkeiten, aber wenn Sie einen Fehler machen, würden wir uns freuen, wenn Sie darauf hinweisen könnten.
Recommended Posts