1 Einführung in A3C
Der vollständige Name von A3C lautet Asynchronous Advantage Actor-Critic. Wie der Name schon sagt, nimmt es die Form von Actor-Critic an (Sie müssen Actor-Critic überprüfen, Sie können hier klicken [Reinforcement Learning] Actor-Critic (Schauspieler-Kritiker ) Algorithmus detaillierte Erklärung ). Um ein Paar aus Schauspieler und Kritiker auszubilden, erstellen wir mehrere Kopien von ihm in Rot und platzieren sie dann gleichzeitig in verschiedenen parallelen Räumen, damit sie ihre eigenen Spiele spielen können. Dann erzählte jedes rote Exemplar dem schwarzen Schauspieler-Kritiker in aller Stille, wie er dort in der Welt spielte und welche Erfahrungen es wert waren, geteilt zu werden. Dann können Sie sich die Zollabfertigungs-Cheats holen, nachdem Sie alle Kopiererfahrungen des schwarzen Schauspieler-Kritikers umfassend berücksichtigt haben. Auf diese Weise entsteht eine effiziente Reinforcement-Learning-Methode.
Die meisten aktuellen Computer sind Dual-Core-, 4-Core- oder sogar 6-Core-8-Core-Computer. Die allgemeine Lernmethode kann den Roboter nur auf einem Kern spielen lassen. Wenn wir jedoch die A3C-Methode verwenden, können wir sie verschiedenen Kernen zuweisen und parallele Vorgänge ausführen. Das experimentelle Ergebnis ist, dass eine solche Berechnungsmethode oft um ein Vielfaches schneller ist als die herkömmliche Methode.
2 Asynchronous Advantage Actor-Critic (A3C) Detaillierte Erläuterung
2.1 Hauptpunkte
Ein Satz fasst A3C zusammen: ein von Google DeepMind vorgeschlagener Algorithmus zur Lösung des Problems der Nichtkonvergenz zwischen Akteur und Kritik. Dadurch werden mehrere parallele Umgebungen erstellt, sodass mehrere Agenten mit sekundären Strukturen die Parameter in der Hauptstruktur dieser parallelen Umgebungen gleichzeitig aktualisieren können. Die parallelen Agenten stören sich nicht gegenseitig, und die Parameteraktualisierung der Hauptstruktur wird durch die von der Sekundärstruktur übermittelte diskontinuierliche Aktualisierung gestört, sodass die Korrelation der Aktualisierung verringert und die Konvergenz verbessert wird.
2.2 Algorithmus
Der Algorithmus von A3C fügt Actor-Critic für synchrones Training tatsächlich in mehrere Threads ein. Man kann sich vorstellen, dass mehrere Personen gleichzeitig dasselbe Spiel spielen und ihre Erfahrungen beim Spielen des Spiels synchron in ein zentrales Gehirn hochgeladen werden. Dann bekommen sie vom Zentralhirn die neueste Art, das Spiel zu spielen.
Auf diese Weise haben diese wenigen Menschen folgende Vorteile: Das zentrale Gehirn bündelt die Erfahrungen aller Menschen und ist dasjenige, das am besten Spiele spielt. Von Zeit zu Zeit können sie den ultimativen Zug des zentralen Gehirns erhalten Gehirn und nutzen es in ihren eigenen Szenen.
Der Vorteil für das Zentralhirn besteht darin, dass das Zentralhirn die kontinuierliche Aktualisierung einer Person am meisten fürchtet und diese Methode zum Pushen von Aktualisierungen basierend auf einer Person diese Kontinuität aufheben kann. Das zentrale Gehirn kann gut aktualisiert werden, ohne dass Speicherbänke wie DQN und DDPG verwendet werden müssen.
Um dieses Ziel zu erreichen, benötigen wir zwei Systeme, die als zentrales Gehirn mit dem globalen Netz und seinen Parametern betrachtet werden können. Jeder Spieler verfügt über eine Kopie des globalen Netzes, das lokale Netz, das regelmäßig Aktualisierungen in das globale Netz übertragen kann net, und aktualisieren Sie dann regelmäßig über das Glabal-Netz. Holen Sie sich dann die umfassende Version des Updates.
Wenn Sie sich das System ansehen, das wir in Tensorboard aufbauen möchten:
w_0 ist der 0. Worker, und jeder Worker kann das global_net teilen.
Wenn die Pull-In-Synchronisierung aufgerufen wird, erhält der Worker die neuesten Parameter von global_net.
Wenn wir push in sync aufrufen, überträgt der Worker seine persönlichen Aktualisierungen an global_net.
2.3 Hauptstruktur
Wir verwenden Tensorflow, um ein neuronales Netzwerk aufzubauen. Für unseren Akteur können wir deutlich sehen, wie wir es im Tensorboard erstellt haben:
Wir verwenden die Normalverteilung, um Aktionen auszuwählen. Beim Aufbau eines neuronalen Netzwerks muss die Akteurseite also Aktionen ausgeben. Mittelwert und Varianz . Fügen Sie es dann in die Normalverteilung ein, um die Aktion auszuwählen. Bei der Berechnung des Akteurverlusts müssen wir auch den vom Kritiker bereitgestellten TD-Fehler als Leitfaden für den Gradientenanstieg verwenden.
Der Kritiker ist sehr einfach, Sie müssen nur seinen Wert für den Zustand erhalten, der zur Berechnung des TD-Fehlers verwendet wird.
2.4 Akteur-Kritiker-Netzwerk
Wir verschmelzen Schauspieler und Kritiker zu einem kompletten System, das einfach zu bedienen ist.
# 这个 class 可以被调用生成一个 global net.
# 也能被调用生成一个 worker 的 net, 因为他们的结构是一样的,
# 所以这个 class 可以被重复利用.
class ACNet(object):
def __init__(self, globalAC=None):
# 当创建 worker 网络的时候, 我们传入之前创建的 globalAC 给这个 worker
if 这是 global: # 判断当下建立的网络是 local 还是 global
with tf.variable_scope('Global_Net'):
self._build_net()
else:
with tf.variable_scope('worker'):
self._build_net()
# 接着计算 critic loss 和 actor loss
# 用这两个 loss 计算要推送的 gradients
with tf.name_scope('sync'): # 同步
with tf.name_scope('pull'):
# 更新去 global
with tf.name_scope('push'):
# 获取 global 参数
def _build_net(self):
# 在这里搭建 Actor 和 Critic 的网络
return 均值, 方差, state_value
def update_global(self, feed_dict):
# 进行 push 操作
def pull_global(self):
# 进行 pull 操作
def choose_action(self, s):
# 根据 s 选动作
Dabei handelt es sich um die Erstellung von Netzwerken, Workern und einer eigenen Klasse, die für die Ausführung der Arbeit in jedem Thread verwendet werden.
2.5 Arbeiter
Jeder Woeker hat eine eigene Klasse, die seine Arbeitsinhalte enthält
class Worker(object):
def __init__(self, name, globalAC):
self.env = gym.make(GAME).unwrapped # 创建自己的环境
self.name = name # 自己的名字
self.AC = ACNet(name, globalAC) # 自己的 local net, 并绑定上 globalAC
def work(self):
# s, a, r 的缓存, 用于 n_steps 更新
buffer_s, buffer_a, buffer_r = [], [], []
while not COORD.should_stop() and GLOBAL_EP < MAX_GLOBAL_EP:
s = self.env.reset()
for ep_t in range(MAX_EP_STEP):
a = self.AC.choose_action(s)
s_, r, done, info = self.env.step(a)
buffer_s.append(s) # 添加各种缓存
buffer_a.append(a)
buffer_r.append(r)
# 每 UPDATE_GLOBAL_ITER 步 或者回合完了, 进行 sync 操作
if total_step % UPDATE_GLOBAL_ITER == 0 or done:
# 获得用于计算 TD error 的 下一 state 的 value
if done:
v_s_ = 0 # terminal
else:
v_s_ = SESS.run(self.AC.v, {
self.AC.s: s_[np.newaxis, :]})[0, 0]
buffer_v_target = [] # 下 state value 的缓存, 用于算 TD
for r in buffer_r[::-1]: # 进行 n_steps forward view
v_s_ = r + GAMMA * v_s_
buffer_v_target.append(v_s_)
buffer_v_target.reverse()
buffer_s, buffer_a, buffer_v_target = np.vstack(buffer_s), np.vstack(buffer_a), np.vstack(buffer_v_target)
feed_dict = {
self.AC.s: buffer_s,
self.AC.a_his: buffer_a,
self.AC.v_target: buffer_v_target,
}
self.AC.update_global(feed_dict) # 推送更新去 globalAC
buffer_s, buffer_a, buffer_r = [], [], [] # 清空缓存
self.AC.pull_global() # 获取 globalAC 的最新参数
s = s_
if done:
GLOBAL_EP += 1 # 加一回合
break # 结束这回合
2.6 Parallelarbeit der Arbeitnehmer
Hier liegt der eigentliche Schwerpunkt, das parallele Rechnen von Worker.
with tf.device("/cpu:0"):
GLOBAL_AC = ACNet(GLOBAL_NET_SCOPE) # 建立 Global AC
workers = []
for i in range(N_WORKERS): # 创建 worker, 之后在并行
workers.append(Worker(GLOBAL_AC)) # 每个 worker 都有共享这个 global AC
COORD = tf.train.Coordinator() # Tensorflow 用于并行的工具
worker_threads = []
for worker in workers:
job = lambda: worker.work()
t = threading.Thread(target=job) # 添加一个工作线程
t.start()
worker_threads.append(t)
COORD.join(worker_threads) # tf 的线程调度
Artikelquelle: Mofan Reinforcement Learning https://mofanpy.com/tutorials/machine-learning/reinforcement-learning/