Die ChainaerRL-Kurzanleitung ist eine Schande für Windows, daher handelt es sich um eine Windows-Version ohne die Zustimmung des Originals. Anaconda hat Erklärungen an verschiedenen Stellen, bitte beziehen Sie sich auf sie. Gehen Sie mit anaconda3 von python3.7 aus.
Dieses Notizbuch ist eine Kurzanleitung für Benutzer, die ChainerRL zum ersten Mal ausprobieren möchten. Führen Sie den folgenden Befehl aus, um ChainerRL zu installieren.
# Install Chainer, ChainerRL and CuPy!
!conda install cupy chainer
!pip -q install chainerrl
!pip -q install gym
!pip -q install pyglet
!pip -q install pyopengl
!pip -q install pyvirtualdisplay
!pip -q install JSAnimation
!pip -q install matplotlib
!pip -q install jupyter
!conda install -c conda-forge ffmpeg
Zunächst müssen Sie die erforderlichen Module importieren. Der Modulname für ChainerRL lautet chainerrl. Importieren wir auch Fitnessstudio und Numpy für die spätere Verwendung.
import chainer
import chainer.functions as F
import chainer.links as L
import chainerrl
import gym
import numpy as np
ChainerRL kann für jedes Problem verwendet werden, wenn die "Umgebung" modelliert ist. OpenAI Gym bietet verschiedene Arten von Benchmarking-Umgebungen und definiert eine gemeinsame Schnittstelle zwischen ihnen. ChainerRL verwendet eine Teilmenge dieser Schnittstelle. Insbesondere muss die Umgebung ihren Beobachtungs- und Aktionsraum definieren und über mindestens zwei Methoden verfügen: Zurücksetzen und Schritt.
env.reset setzt die Umgebung auf ihren Ausgangszustand zurück und gibt den Ausgangszustand zurück (Beobachtung). env.step führt die angegebene Aktion aus, wechselt zum nächsten Status und gibt vier Werte zurück: --observation --scalar belohnung - Ein Boolescher Wert, der angibt, ob der aktuelle Status der fertige Status ist Wert-Zusätzliche Informationen env.render rendert den aktuellen Status. Probieren wir jetzt CartPole-v0 aus, ein klassisches Steuerungsproblem. Unten sehen Sie, dass der Zustandsraum aus vier reellen Zahlen und sein Arbeitsraum aus zwei diskreten Aktionen besteht.
env = gym.make('CartPole-v0')
print('observation space:', env.observation_space)
print('action space:', env.action_space)
obs = env.reset()
#env.render()
print('initial observation:', obs)
action = env.action_space.sample()
obs, r, done, info = env.step(action)
print('next observation:', obs)
print('reward:', r)
print('done:', done)
print('info:', info)
WARN: gym.spaces.Box autodetected dtype as <class 'numpy.float32'>. Please provide explicit dtype.
observation space: Box(4,)
action space: Discrete(2)
initial observation: [-0.04055678 -0.00197163 0.02364212 0.03487198]
next observation: [-0.04059621 -0.1974245 0.02433956 0.33491948]
reward: 1.0
done: False
info: {}
Sie haben jetzt Ihre Umgebung definiert. Als nächstes müssen wir einen Agenten definieren, der durch Interaktion mit der Umgebung lernt.
ChainerRL bietet eine Vielzahl von Agenten, die jeweils einen Lernalgorithmus für die Tiefenverstärkung implementieren.
Um DQN (Deep Q-Network) verwenden zu können, müssen Sie eine Q-Funktion definieren, die einen Status annimmt und die erwartete zukünftige Rückgabe zurückgibt, die jede Aktion des Agenten ausführen kann. In ChainerRL kann die Q-Funktion wie folgt als chainer.Link definiert werden. Beachten Sie, dass die Ausgabe von chainerrl.action_value.DiscreteActionValue umbrochen wird, wodurch chainerrl.action_value.ActionValue implementiert wird. ChainerRL kann solche diskreten Aktions-Q-Funktionen und NAF (Normalized Advantage Functions) auf die gleiche Weise verarbeiten, indem die Ausgabe der Q-Funktion umbrochen wird.
class QFunction(chainer.Chain):
def __init__(self, obs_size, n_actions, n_hidden_channels=50):
super().__init__()
with self.init_scope():
self.l0 = L.Linear(obs_size, n_hidden_channels)
self.l1 = L.Linear(n_hidden_channels, n_hidden_channels)
self.l2 = L.Linear(n_hidden_channels, n_actions)
def __call__(self, x, test=False):
"""
Args:
x (ndarray or chainer.Variable): An observation
test (bool): a flag indicating whether it is in test mode
"""
h = F.tanh(self.l0(x))
h = F.tanh(self.l1(h))
return chainerrl.action_value.DiscreteActionValue(self.l2(h))
obs_size = env.observation_space.shape[0]
n_actions = env.action_space.n
q_func = QFunction(obs_size, n_actions)
Wenn Sie CUDA für Berechnungen wie Chainer verwenden möchten, rufen Sie to_gpu auf.
Wenn Sie Colaboratory verwenden möchten, müssen Sie den Laufzeittyp in GPU ändern. ..
q_func.to_gpu(0)
<__main__.QFunction at 0x7f0bc217beb8>
Sie können auch die vordefinierten Q-Funktionen von ChainerRL verwenden.
_q_func = chainerrl.q_functions.FCStateQFunctionWithDiscreteAction(
obs_size, n_actions,
n_hidden_layers=2, n_hidden_channels=50)
# Use Adam to optimize q_func. eps=1e-2 is for stability.
optimizer = chainer.optimizers.Adam(eps=1e-2)
optimizer.setup(q_func)
# Set the discount factor that discounts future rewards.
gamma = 0.95
# Use epsilon-greedy for exploration
explorer = chainerrl.explorers.ConstantEpsilonGreedy(
epsilon=0.3, random_action_func=env.action_space.sample)
# DQN uses Experience Replay.
# Specify a replay buffer and its capacity.
replay_buffer = chainerrl.replay_buffer.ReplayBuffer(capacity=10 ** 6)
# Since observations from CartPole-v0 is numpy.float64 while
# Chainer only accepts numpy.float32 by default, specify
# a converter as a feature extractor function phi.
phi = lambda x: x.astype(np.float32, copy=False)
# Now create an agent that will interact with the environment.
agent = chainerrl.agents.DoubleDQN(
q_func, optimizer, replay_buffer, gamma, explorer,
replay_start_size=500, update_interval=1,
target_update_interval=100, phi=phi)
n_episodes = 200
max_episode_len = 200
for i in range(1, n_episodes + 1):
obs = env.reset()
reward = 0
done = False
R = 0 # return (sum of rewards)
t = 0 # time step
while not done and t < max_episode_len:
# Uncomment to watch the behaviour
# env.render()
action = agent.act_and_train(obs, reward)
obs, reward, done, _ = env.step(action)
R += reward
t += 1
if i % 10 == 0:
print('episode:', i,
'R:', R,
'statistics:', agent.get_statistics())
agent.stop_episode_and_train(obs, reward, done)
print('Finished.')
episode: 10 R: 37.0 statistics: [('average_q', 1.2150215711003933), ('average_loss', 0.05015367301912823)]
episode: 20 R: 44.0 statistics: [('average_q', 3.7857904640201947), ('average_loss', 0.09890545599011519)]
episode: 30 R: 97.0 statistics: [('average_q', 7.7720408907953145), ('average_loss', 0.12504807923600555)]
episode: 40 R: 56.0 statistics: [('average_q', 10.963194695758215), ('average_loss', 0.15639676991049656)]
episode: 50 R: 177.0 statistics: [('average_q', 14.237965547239822), ('average_loss', 0.23526638038745168)]
episode: 60 R: 145.0 statistics: [('average_q', 17.240442032833762), ('average_loss', 0.16206694621384216)]
episode: 70 R: 175.0 statistics: [('average_q', 18.511116289009692), ('average_loss', 0.18787805607905012)]
episode: 80 R: 57.0 statistics: [('average_q', 18.951395985384725), ('average_loss', 0.149411012387425)]
episode: 90 R: 200.0 statistics: [('average_q', 19.599694542558165), ('average_loss', 0.16107124308010012)]
episode: 100 R: 200.0 statistics: [('average_q', 19.927458098228968), ('average_loss', 0.1474102671167888)]
episode: 110 R: 200.0 statistics: [('average_q', 19.943080568511867), ('average_loss', 0.12303519377444547)]
episode: 120 R: 152.0 statistics: [('average_q', 19.81996694327306), ('average_loss', 0.12570420169091834)]
episode: 130 R: 196.0 statistics: [('average_q', 19.961466224568177), ('average_loss', 0.17747677703107395)]
episode: 140 R: 194.0 statistics: [('average_q', 20.05166109574271), ('average_loss', 0.1334155925948816)]
episode: 150 R: 200.0 statistics: [('average_q', 19.982061292121358), ('average_loss', 0.12589899261907)]
episode: 160 R: 175.0 statistics: [('average_q', 20.060457421033803), ('average_loss', 0.13909796300744334)]
episode: 170 R: 200.0 statistics: [('average_q', 20.03359962493644), ('average_loss', 0.12457978502375021)]
episode: 180 R: 200.0 statistics: [('average_q', 20.023962037264738), ('average_loss', 0.10855797175237188)]
episode: 190 R: 200.0 statistics: [('average_q', 20.023348743333067), ('average_loss', 0.11714457311489457)]
episode: 200 R: 200.0 statistics: [('average_q', 19.924879051722634), ('average_loss', 0.08032495725586702)]
Finished.
from JSAnimation.IPython_display import display_animation
from matplotlib import animation
import matplotlib.pyplot as plt
%matplotlib inline
frames = []
for i in range(3):
obs = env.reset()
done = False
R = 0
t = 0
while not done and t < 200:
frames.append(env.render(mode = 'rgb_array'))
action = agent.act(obs)
obs, r, done, _ = env.step(action)
R += r
t += 1
print('test episode:', i, 'R:', R)
agent.stop_episode()
env.render()
from IPython.display import HTML
plt.figure(figsize=(frames[0].shape[1]/72.0, frames[0].shape[0]/72.0),dpi=72)
patch = plt.imshow(frames[0])
plt.axis('off')
def animate(i):
patch.set_data(frames[i])
anim = animation.FuncAnimation(plt.gcf(), animate, frames=len(frames),interval=50)
anim.save('movie_cartpole.mp4')
HTML(anim.to_jshtml())
test episode: 0 R: 200.0
test episode: 1 R: 200.0
test episode: 2 R: 200.0
Die Q-Funktion und ihre Optimierungsfunktion werden von den Agenten von DQN verwendet. Sie müssen weitere Parameter und Einstellungen angeben, um einen Agenten für DQN zu erstellen. Jetzt sind der Agent und die Umgebung bereit. Fangen wir an, das Lernen zu stärken! Verwenden Sie beim Lernen agent.act_and_train, um Erkundungsaktionen auszuwählen. Sie müssen agent.stop_episode_and_train nach dem Ende der Episode aufrufen. Mit agent.get_statistics können Sie Trainingsstatistiken für Agenten abrufen. Damit ist die Agentenschulung abgeschlossen. Wie gut lernt dieser Agent? Es kann mit agent.act und agent.stop_episode getestet werden. Erkundungen wie epsilon-gierig werden hier nicht verwendet. Um das Ausführungsergebnis auf Notebook zu überprüfen, wird es mit der Animationsfunktion von matplotlib angezeigt. Wenn die oben genannten Testergebnisse und Ergebnisse ausreichen, besteht der Rest der Arbeit darin, den Agenten zur Wiederverwendung aufzubewahren. Sie müssen lediglich agent.save aufrufen, um den Agenten zu speichern, und dann agent.load aufrufen, um den gespeicherten Agenten zu laden.
# Save an agent to the 'agent' directory
agent.save('agent')
# Uncomment to load an agent from the 'agent' directory
# agent.load('agent')
Mit dem oben Gesagten wurde die Stärkung des Lernens gelernt und getestet.
Das Schreiben von Code wie diesem jedes Mal, wenn Sie erweitertes Lernen implementieren, kann jedoch mühsam sein. Daher verfügt ChainerRL über Dienstprogrammfunktionen, die diese Aufgaben ausführen.
# Set up the logger to print info messages for understandability.
import logging
import sys
gym.undo_logger_setup() # Turn off gym's default logger settings
logging.basicConfig(level=logging.INFO, stream=sys.stdout, format='')
chainerrl.experiments.train_agent_with_evaluation(
agent, env,
steps=20000, # Train the agent for 2000 steps
eval_n_steps=None, # 10 episodes are sampled for each evaluation
eval_n_episodes=10, # 10 episodes are sampled for each evaluation
eval_max_episode_len=200, # Maximum length of each episodes
eval_interval=1000, # Evaluate the agent after every 1000 steps
outdir='result') # Save everything to 'result' directory
Das ist alles für die ChainerRL-Kurzanleitung. Um mehr über ChainerRL zu erfahren, schauen Sie sich das Beispielverzeichnis an und lesen Sie die Beispiele und führen Sie sie aus. Vielen Dank!
Die zu umgestaltende Chainerrl-Datei ist userfolder.conda\envs\chainer\Lib\site-packages\chainerrl\experiments\train_agent.py war. chainerui hat gut funktioniert.
Ich habe hier darauf hingewiesen. (Fast eine vollständige Kopie.) https://book.mynavi.jp/manatee/detail/id=88961
Ich hoffe, dass Windows-Benutzer auch chainerRL verwenden können.
Recommended Posts