Autor: Hamwon
Zusammenfassung
„Playing Atari with Deep Reinforcement Learning“ ist das erste klassische Deep-Reinforcement-Learning-Papier, das Reinforcement-Learning mit Deep-Learning kombiniert. Der Algorithmus wurde in der Atari 2600-Spielumgebung und seiner Testleistung getestet Einige Spiele waren besser als menschliche Spieler.
Papier-URL: https://paperswithcode.com/paper/playing-atari-with-deep-reinforcement
01
Erstellen Sie mit Pycharm ein virtuelles Umgebungsprojekt
Der Projektcode und die Trainingsergebnisse wurden auf Baidu Netdisk hochgeladen. Da die virtuelle Umgebung jedoch zu groß ist, müssen Sie sie selbst herunterladen und installieren. Weitere Informationen finden Sie in der Einführung unten.
Link: https://pan.baidu.com/s/1zoh0glqH4xcNSbOUuR2r7g?pwd=00wdExtraktionscode
: 00wd
Erstellen Sie zunächst ein neues Projekt mit Pycharm und fügen Sie dann die virtuelle Umgebung in den Einstellungen hinzu, wie unten gezeigt:
Der Zweck der Erstellung eines virtuellen Umgebungsprojekts besteht darin, die laufende Umgebung des aktuellen Projekts von Ihrer eigenen Python-Umgebung zu trennen. Anschließend installieren Sie die erforderlichen Pakete in der virtuellen Umgebung, um eine Beeinträchtigung Ihrer vorherigen Python-Umgebung zu vermeiden. Die von mir verwendete Pycharm-Version ist die 2019-Version. Die Einstellungen der neuen Version von Pycharm sollten entsprechend Ihrer eigenen Situation ähnlich sein. Der Anaconda-Pfad ist bei jedem anders und Sie müssen den Basisinterpreter entsprechend Ihrem Installationsort auswählen.
Informationen zur Konfiguration der virtuellen Umgebung finden Sie im CSDN-Artikel: Pycharm erstellt und verwaltet eine virtuelle Umgebung.
Nachdem die virtuelle Umgebung erstellt wurde, müssen Sie noch das Terminalprogramm in den Einstellungen einrichten:
Öffnen Sie zu diesem Zeitpunkt die Registerkarte „Terminal“ unter Pycharm. Sie können die Eingabeaufforderung (venv) vor dem Terminal sehen, die angibt, dass sich das aktuelle Terminal in einer virtuellen Umgebung befindet:
Derzeit können alle benötigten Pakete über pip in diesem Terminal installiert werden.
Denken Sie daran, die drei von Baidu Cloud heruntergeladenen Ordner Code, Imgs und Model in den aktuellen Projektordner zu kopieren. Die für das Projekt erforderlichen Python-Pakete sind bereits in der Datei „requirements.tx“ im Codeordner enthalten . Öffnen Sie die Terminal-Registerkarte von Pycharm und geben Sie den Codeordner über den Befehl „cd“ ein:
cd code
Dann installiert pip die erforderlichen Pakete:
pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
Normalerweise sollte der Code im Codeordner nach der Konfiguration der oben genannten Umgebung normal ausgeführt werden können. Wenn es nicht normal läuft, liegt möglicherweise ein Problem mit der Spielumgebung von Atari vor. Weitere Informationen finden Sie in diesem CSDN-Artikel: [gym] Neue Versionsinstallation (0.21 oder höher) und Konfiguration der Atari-Umgebung, super einfach (Windows).
02
Erklärung des Papiermodells
Vereinfacht ausgedrückt entwirft das Papier ein DQN-Netzwerk, das 4 aufeinanderfolgende Frames von Spielbildern, die auf 84 x 84 zugeschnitten sind, in 4 x 84 x 84-Eingaben stapelt und dann Faltung + ReLU, Faltung + ReLU, Flatten, vollständige Verbindung + ReLU und vollständige Verbindung Get verwendet Die Ausgabe entspricht der Aktionsdimension. Hier trainieren und testen wir hauptsächlich das Spiel BreakOut (Flipper und Block). Es gibt 4 Arten von Aktionen, die diesem Spiel entsprechen, daher ist die Ausgabedimension hier 4.
Das ausgegebene 4-dimensionale Array stellt die Q(s,a)-Werte dar, die jeweils den vier Aktionen entsprechen. Die Zahl, die dem größten Q-Wert entspricht, wird als vom Netzwerk ausgegebener Aktionscode ausgewählt:
0: bedeutet keine Bewegung
1: Zeigt den Beginn des Spiels an (wenn das Spiel bereits begonnen hat, bewegt sich 1 immer noch nicht)
2: Zeigt eine Rechtsverschiebung an
3: Zeigt eine Linksverschiebung an
Berechnung der Faltungsgröße:
Ausgabegröße = (Eingabegröße – Faltungskerngröße + 2 x Polsterung) / Schrittweite + 1
Mit dem oben genannten DQN-Netzwerk als Agent kann die Interaktion zwischen dem Agenten und der Spielumgebung realisiert werden. Das Netzwerk generiert Aktionen basierend auf den aktuellen Beobachtungen
, steuert den Schieberegler unten und generiert bei Änderungen in der Umgebung neue
Beobachtungen Der Schieberegler bewegt den Ball erfolgreich. Bounce und trifft auf die Blöcke oben. Für jeden Block, den Sie treffen, erhalten Sie eine Belohnung = 1, andernfalls gibt es keine Belohnung = 0.
Als nächstes muss gelöst werden, wie der Reinforcement-Learning-Algorithmus die Parameter des DQN-Netzwerks des Agenten durch die Interaktion zwischen dem Agenten und der Umgebung kontinuierlich aktualisiert, sodass der Agent lernt, das Spiel zu spielen.
Der Verstärkungslernalgorithmus speichert die Interaktionserfahrung zwischen dem Agenten und der Umgebung und kann eine Reihe von Erfahrungstupeln erhalten, nämlich (aktuelle Beobachtung, Aktion, nächste Beobachtung, Belohnung, Endmarkierung). kann ausgedrückt werden als:
Wir geben die aktuelle Beobachtung im Erfahrungstupel in das Netzwerk ein, und die Ausgabe des Netzwerks ist ein 4-dimensionales Array, das den Werten von 4 Aktionen entspricht, die unter der aktuellen Beobachtung durchgeführt wurden. Entsprechend der tatsächlichen Aktion der aktuellen Beobachtung im Erfahrungstupel können wir den Wert erhalten, der der Aktion
der aktuellen Beobachtung aus diesem Array entspricht . Dieser Wert hängt offensichtlich mit dem aktuellen Parameter θ des Netzwerks zusammen.
Tatsächlich können wir gemäß der Bellman-Gleichung, auf der das Verstärkungslernen basiert, auch den aktuellen Wert anhand der nach der Durchführung der Aktion erhaltenen Belohnung
und des erwarteten Werts der entsprechenden nächsten Beobachtung schätzen. Dieser geschätzte Wert ist:
Für die Situation am Ende des Spiels gibt es nur die Belohnung, die nach Durchführung der Aktion erhalten wird, es gibt keine nächste Beobachtung, sodass die aktuelle Wertschätzung die Belohnung ist.
Für den Fall, dass das Spiel noch nicht vorbei ist, umfasst die aktuelle Wertschätzung die erhaltene Belohnung plus den größten geschätzten Wert unter den 4 in der nächsten Beobachtung durchgeführten Aktionen, multipliziert mit dem Abzinsungsfaktor γ. Dieser Abzinsungsfaktor stellt den aktuellen Wert dar Folgewert Sind die Verbindungen zwischen ihnen eng? Wenn 0, bedeutet dies, dass der aktuelle Wert nur von der aktuellen Belohnung abhängt. Je größer das γ, desto enger ist die Verbindung.
Jetzt haben wir:
Der geschätzte Wert, der der durch die aktuelle Beobachtung durchgeführten Aktion
entspricht und mithilfe des DQN-Netzwerks ermittelt wurde
.
Der aktuelle Wert wird aus der Belohnung und dem maximalen Schätzwert der nächsten Beobachtung multipliziert mit dem Abzinsungsfaktor geschätzt . Gemäß der Bellman-Gleichung sollten die beiden Schätzungen gleich sein. Da die Schätzung des Werts durch das Netzwerk jedoch ungenau ist, besteht ein Unterschied zwischen den beiden Schätzungen:
Das Ziel des Deep Reinforcement Learning-Algorithmus für das Netzwerktraining besteht darin, die Differenz zwischen den beiden Schätzungen zu verringern, sodass die DQN-Netzwerkstrategie die Bellman-Gleichung erfüllt, sodass das DQN-Netzwerk die optimale Strategie für dieses Spiel lernen kann. Im Prozess der Interaktion des Agenten-DQN-Netzwerks mit der Umgebung kann der oben genannte Zweck erreicht werden, indem die gespeicherten Erfahrungstupel verwendet werden, um den oben genannten Verlust zu berechnen, und dann die Parameter des DQN-Netzwerks mit Gradientenabstieg aktualisiert werden.
Im Folgenden wird die spezifische Code-Implementierung unter Verwendung des MindSpore-Frameworks in der Python-Umgebung beschrieben und entsprechende Erläuterungen gegeben.
03
Implementierung des Shengsi MindSpore-Codes
Öffnen Sie die Datei playing_atari.py im Codeordner. Die spezifische Bedeutung des Codes ist wie folgt:
3.1 Erstellung einer Spielumgebung
Erstellen Sie nach dem Import der entsprechenden Bibliotheken zunächst die Spielumgebung env:
env = gym.make("BreakoutNoFrameskip-v4") # 游戏环境
env = gym.wrappers.RecordEpisodeStatistics(env)
env = gym.wrappers.ResizeObservation(env, (84, 84)) # 设置图片放缩
env = gym.wrappers.GrayScaleObservation(env) # 设置图片为灰度图
env = gym.wrappers.FrameStack(env, 4) # 4帧图片堆叠在一起作为一个观测
env = MaxAndSkipEnv(env, skip=4) # 跳帧，一个动作维持4帧
Die Umgebung wurde hier gekapselt
envund ihre Ausgabebilder wurden vorverarbeitet. Jede Beobachtungsausgabe ist ein gestapeltes 4X84X84-Graustufenbild.
3.2 DQN-Netzwerkdefinition
Verwenden Sie Sengsi MindSpore, um das DQN-Netzwerk zu definieren, verwenden Sie nn.SequentialCell() direkt und definieren Sie es entsprechend dem entworfenen Netzwerk:
class DQN(nn.Cell):
def __init__(self, nb_actions):
super().__init__()
self.network = nn.SequentialCell(
nn.Conv2d(in_channels=4, out_channels=16, kernel_size=8, stride=4, pad_mode='valid'),
nn.ReLU(),
nn.Conv2d(in_channels=16, out_channels=32, kernel_size=4, stride=2, pad_mode='valid'),
nn.ReLU(),
nn.Flatten(),
nn.Dense(in_channels=2592, out_channels=256),
nn.ReLU(),
nn.Dense(in_channels=256, out_channels=nb_actions),
)
def construct(self, x):
return self.network(x / 255.)
„construct()“ stellt die Ausgabe des Netzwerks dar, ähnlich wie „forward()“ im Pytorch-Framework
3.3 Design-Erfahrungsspeicherpool
class ReplayBuffer():
def __init__(self, replay_memory_size):
def add(self, obs, next_obs, action, reward, done):
def sample(self, sample_num):
...
return Tensor(temp_obs, ms.float32), Tensor(temp_next_obs, ms.float32), Tensor(temp_action, ms.int32), Tensor(temp_reward, ms.float32), Tensor(temp_done, ms.float32)
Der spezifische Code wird hier nicht veröffentlicht. Einfach ausgedrückt, realisiert er die Speicherung von Erfahrungstupeln und Batch-Sampling, um das anschließende Training des neuronalen Netzwerks zu erleichtern.
3.4 Definition von Verlustfunktion, Optimierer und Trainingsfunktion
Instanziieren Sie zunächst ein Netzwerk für die definierte DQN-Klasse
q_networkund definieren Sie dann den Optimierer alsnn.Adamund die Verlustfunktion alsnn.HuberLOss()
q_network = DQN(nb_actions=env.action_space.n) # 网络实例化
optimizer = nn.Adam(params=q_network.trainable_params(), learning_rate=1.25e-4) # 优化器
loss_fn = nn.HuberLoss() # 损失函数
Im Folgenden sind die für MindSpore einzigartigen Schritte zur Definition des Netzwerktrainings aufgeführt, die als funktionale automatische Differenzierung bezeichnet werden. Sie können sich das Tutorial zur funktionalen automatischen Differenzierung auf der offiziellen Website ansehen . Definieren Sie insbesondere zunächst eine Verlustberechnungsfunktion forward_fn, generieren Sie dann eine Gradientenberechnungsfunktion basierend auf der Verlustberechnungsfunktion grad_fnund definieren Sie dann mithilfe der Gradientenberechnungsfunktion eine Funktion für einen Schritt des Netzwerktrainings train_step. Auf diese Weise train_stepmüssen Sie mit der Funktion nur die erforderlichen Daten eingeben, können die Netzwerkparameter einmal aktualisieren und ein einstufiges Training abschließen.
# 损失值计算函数
def forward_fn(observations, actions, y):
current_q_value = q_network(observations).gather_elements(dim=1, index=actions).squeeze() # 把经验对中这个动作对应的q_value给提取出来
loss = loss_fn(current_q_value, y)
return loss
In
forward_fnder Funktion wird die Berechnung der Wertschätzung abgeschlossen. Im Code
current_q_valuemuss das DQN-Netzwerk den Q-Wert in dieser Funktion berechnen. Der anschließende Verlustgradient wird in diesem Berechnungsprozess auf die DQN-Netzwerkparameter übertragen . Updates für neuronale Netze.
Beachten Sie
y, dass die Eingabe der Funktionnach der Berechnung außerhalb der Funktion eingegeben wird, da
forward_fn.
# 损失梯度函数
grad_fn = ms.ops.value_and_grad(forward_fn, None, optimizer.parameters)
# 参考:https://www.mindspore.cn/tutorials/zh-CN/r2.1/beginner/autograd.html
# 训练一步的函数
def train_step(observations, actions, y):
loss, grads = grad_fn(observations, actions, y)
optimizer(grads)
return loss
ms.ops.value_and_gradMithilfe der definierten Verlustberechnungsfunktionforward_fnkann eine Gradientenberechnungsfunktion grad_fn zurückgegeben werden.
train_stepDann können wir in der Trainingsfunktiongrad_fnden Gradienten berechnen und dann mit dem Optimiereroptimizereine Gradienten-Backpropagation durchführen, die Netzwerkparameter aktualisieren und ein einstufiges Training abschließen.
3.4 Netzwerkschulung
Als nächstes können Sie das Netzwerk trainieren. Hier sind einige Erklärungen zu den wichtigsten Schlüsselcodes:
def Deep_Q_Learning(env, replay_memory_size=100_000, nb_epochs=40000_000, update_frequency=4, batch_size=32,
discount_factor=0.99, replay_start_size=5000, initial_exploration=1, final_exploration=0.01,
exploration_steps=100_000):
Definieren Sie zunächst die relevanten Parameter, die für das Training erforderlich sind, einschließlich der Kapazitätsgröße des Erfahrungspools 100_000, der gesamten Trainingsepochen = 40000_000, der Netzwerkparameter werden alle 4 Epochen aktualisiert, der Abzinsungsfaktor beträgt 0,99 und das Training beginnt, wenn der Erfahrungspool mit 5000 voll ist und die anfängliche Explorationswahrscheinlichkeit beträgt 1. Die Gesamtzahl der Explorationsepochen beträgt 100_000
Erkundung bedeutet hier, dass DQN vor dem Training zufällig Aktionen für die Erkundung generiert und sich dann vollständig auf DQN verlässt, um Aktionen zu generieren Strategie.
Versetzen Sie das Netzwerk vor dem Training in den Trainingsmodus:
q_network.set_train() # 设置网络为训练模式
Lassen Sie DQN dann mit dem Spiel interagieren, und der entsprechende Code zum Generieren von Aktionen lautet (zufällige Erkundung oder von DQN generierte Aktionen):
if random.random() < epsilon: # With probability ε select a random action a
action = np.array(env.action_space.sample())
else: # Otherwise select a = max_a Q∗(φ(st), a; θ)
temp_input = Tensor(obs, ms.float32).unsqueeze(0)
q_values = q_network(temp_input)
action = q_values.argmax(axis=1).item().asnumpy()
Speichern Sie jedes Erfahrungstupel im Erfahrungspool:
rb.add(obs, real_next_obs, action, reward, done)
Wählen Sie einen Stapel Erfahrungstupel aus dem Erfahrungspool aus, berechnen Sie die Werte und verwenden Sie
train_stepdie Funktion, um die Netzwerkparameter zu aktualisieren:
data_obs, data_next_obs, data_action, data_reward, data_done = rb.sample(batch_size)
# 这一部分不用求梯度，所以写在forward_fn和train_step函数之外
max_q_value = q_network(data_next_obs).max(1)
y = data_reward.flatten() + discount_factor * max_q_value * (1 - data_done.flatten())
loss = train_step(data_obs, data_action, y)
Beachten Sie
train_stepFunktion eingegeben, um eine Trainingssitzung abzuschließen.
Als nächstes folgt der lange Schulungsprozess, der mit meinem eigenen Laptop etwa 10 Tage dauerte. Ich habe die Trainingsgeschwindigkeit auf meinem Laptop getestet und sie ist ungefähr die gleiche wie Pytorch. Ascend MindSpore kann Huawei Ascend 910 (von Huawei entwickelter KI-Chip) verwenden, um das Training zu beschleunigen, aber als schlechter Schüler denke ich darüber nach und würde es daher gerne mit vivo50 (｀・ω・´) versuchen.
Die Trainingskurve ist wie folgt. Das Ergebnis des Trainings durch den Chef auf Github mit Pytorch beträgt etwa 200. Begrenzt durch den Notebook-Speicher von 16 g beträgt das beste Ergebnis, das unter der aktuellen Erfahrungspoolkapazität trainiert werden kann, etwa 150.
04
Experimentelle Ergebnisse
Es ist ersichtlich, dass DQN nach dem Training gelernt hat, dieses Spiel zu spielen. Mit etwas Glück kann man so 300 Punkte erreichen.
Ein in den 1990er Jahren geborener Programmierer hat eine Videoportierungssoftware entwickelt und in weniger als einem Jahr über 7 Millionen verdient. Das Ende war sehr bestrafend! Google bestätigte Entlassungen, die den „35-jährigen Fluch“ chinesischer Programmierer in den Flutter-, Dart- und Teams- Python mit sich brachten stark und wird von GPT-4.5 vermutet; Tongyi Qianwen Open Source 8 Modelle Arc Browser für Windows 1.0 in 3 Monaten offiziell GA Windows 10 Marktanteil erreicht 70 %, Windows 11 GitHub veröffentlicht weiterhin KI-natives Entwicklungstool GitHub Copilot Workspace JAVA ist die einzige starke Abfrage, die OLTP+OLAP verarbeiten kann. Dies ist das beste ORM. Wir treffen uns zu spät.