[PYTHON] Versuchen Sie, CNN mit ChainerRL auszuführen

Einführung

Ich habe das Beispiel von QuickStart ein wenig geändert und CNN verschoben. Das Ziel des Lernens ist Ataris "Pong-v0". ChainerRL Quickstart Guide

Ich verweise auf diesen Artikel. Versuchen Sie es mit chainerRL

Ich kann nicht sagen, ob ich richtig lerne, weil ich keine Kenntnisse über Linux, Python und erweitertes Lernen habe, aber ich habe bestätigt, dass es funktioniert. Bitte geben Sie uns Fehler oder Ratschläge.

Umgebung

OS: ubuntu 16.04 python: 3.6.0 chainer: 1.21.0

Paketimport

Es gibt zwei Hauptänderungen unten. Ich habe es verwendet, um den Spielbildschirm in Graustufen zu skalieren und seine Größe zu ändern.

train.py

import chainer
import chainer.functions as F
import chainer.links as L
import chainerrl
import gym
import numpy as np
import datetime
from skimage.color import rgb2gray
from skimage.transform import resize

Spielauswahl etc.

Ich habe diesen Bereich nicht geändert.

train.py

env = gym.make('Pong-v0')
obs = env.reset()
env.render()

Agenteneinstellungen usw.

Ich weiß nicht, wie ich es einstellen soll, also verwende ich das alte Modell für CNN so wie es ist.

train.py

class QFunction(chainer.Chain):
    def __init__(self, n_history=1, n_action=6):
        super().__init__(
            l1=L.Convolution2D(n_history, 32, ksize=8, stride=4, nobias=False, wscale=np.sqrt(2)),
            l2=L.Convolution2D(32, 64, ksize=3, stride=2, nobias=False, wscale=np.sqrt(2)),
            l3=L.Convolution2D(64, 64, ksize=3, stride=1, nobias=False, wscale=np.sqrt(2)),
            l4=L.Linear(3136, 512, wscale=np.sqrt(2)),
            out=L.Linear(512, n_action, initialW=np.zeros((n_action, 512), dtype=np.float32))
        )

    def __call__(self, x, test=False):
        s = chainer.Variable(x)
        h1 = F.relu(self.l1(s))
        h2 = F.relu(self.l2(h1))
        h3 = F.relu(self.l3(h2))
        h4 = F.relu(self.l4(h3))
        h5 = self.out(h4)
        return chainerrl.action_value.DiscreteActionValue(h5)

Gleiches gilt dafür. Ich lerne nicht genug. Mit n_history wird ein Kanal bezeichnet. Dieses Mal habe ich es grau skaliert, also ist der Kanal 1.

train.py

n_action = env.action_space.n
n_history=1
q_func = QFunction(n_history, n_action)

Optimierungseinstellungen usw.

Geänderte Kapazität von 10 ** 6.

optimizer = chainer.optimizers.Adam(eps=1e-2)
optimizer.setup(q_func)

gamma = 0.95

explorer = chainerrl.explorers.ConstantEpsilonGreedy(
    epsilon=0.3, random_action_func=env.action_space.sample)

replay_buffer = chainerrl.replay_buffer.ReplayBuffer(capacity=10 ** 4)

phi = lambda x: x.astype(np.float32, copy=False)

Spielfortschritt etc.

train.py

agent = chainerrl.agents.DoubleDQN(
    q_func, optimizer, replay_buffer, gamma, explorer,
    minibatch_size=4, replay_start_size=500, update_frequency=1,
    target_update_frequency=100, phi=phi)

last_time = datetime.datetime.now()
n_episodes = 1000
for i in range(1, n_episodes + 1):
    obs = resize(rgb2gray(env.reset()),(80,80))
    obs = obs[np.newaxis, :, :]

    reward = 0
    done = False
    R = 0

    while not done:
        action = agent.act_and_train(obs, reward)
        obs, reward, done, _ = env.step(action)
        obs = resize(rgb2gray(obs), (80, 80))
        obs = obs[np.newaxis, :, :]

        if reward != 0:
            R += reward

    elapsed_time = datetime.datetime.now() - last_time
    print('episode:', i, '/', n_episodes,
          'reward:', R,
          'minutes:', elapsed_time.seconds/60)
    last_time = datetime.datetime.now()

    if i % 100 == 0:
        filename = 'agent_Breakout' + str(i)
        agent.save(filename)

    agent.stop_episode_and_train(obs, reward, done)
print('Finished.')

Die Hauptänderungen sind diese beiden Zeilen. Die erste Zeile ist Graustufen und Größenänderung. In der zweiten Zeile habe ich die Form geändert, um sie in Convolution2D einzufügen.

obs = resize(rgb2gray(env.reset()),(80,80))
obs = obs[np.newaxis, :, :]

Ich habe einen Laptop mit 8 GB Speicher verwendet, aber wenn ich die Kapazität auf 10 ** 6 einstelle und ihn nicht in Graustufen skaliere, wird er nach etwa 300 Folgen beendet. Ich weiß nicht, welches funktioniert, aber diese beiden Änderungen haben es behoben.

Wenn Sie ungefähr 200 Folgen studieren, erhalten Sie 21 Punkte hintereinander. Ich habe ungefähr 5 Punkte in 1000 Folgen bekommen. Das Erlernen von 1000 Folgen dauert einen ganzen Tag.

Ich werde es veröffentlichen, weil ich denke, dass es für Anfänger hilfreich sein kann. Wenn Sie Fehler oder Punkte haben, die verbessert werden müssen, geben Sie uns bitte einen Rat.