Apprentissage par renforcement 10 Essayez d'utiliser un réseau neuronal formé.

On suppose que vous avez terminé jusqu'au renforcement de l'apprentissage 9. Le développement utilise le notebook jupyter. Puisque VSCode n'est pas utilisé, il est facile de changer.

Démarrage rapide de Chainer RL tel quel. Tout d'abord, installez matplotlib.

• Ceci n'est pas écrit dans l'installation rapide.

pip install matplotlib

Ce qui suit est une copie du bloc-notes Jupyter.

import chainer
import chainer.functions as F
import chainer.links as L
import chainerrl
import gym
import numpy as np

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)

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)

# 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)

# Start virtual display
from pyvirtualdisplay import Display
display = Display(visible=0, size=(1024, 768))
display.start()
import os
os.environ["DISPLAY"] = ":" + str(display.display) + "." + str(display.screen)

agent.load('agent')
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()

import matplotlib.pyplot as plt
import matplotlib.animation
import numpy as np
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')
animate = lambda i: patch.set_data(frames[i])
ani = matplotlib.animation.FuncAnimation(plt.gcf(), animate, frames=len(frames), interval = 50)
HTML(ani.to_jshtml())

Les fenêtres étant assez différentes, je les écrirai ensemble dans Enhanced Learning 12.

Un petit résumé de jusqu'à 10. Le démarrage rapide du chainerrl était généralement bon, avec un peu le mien. Chainerrl est-il un wrapper pour chainer? C'est facile à remodeler et je pense que c'est excellent. J'utiliserai tensorflow à l'avenir, mais pour le moment, je pense que j'utiliserai chainerrl. Jusqu'à environ 30, je vais faire de la gym OpenAI.

La raison du chainer est que j'ai des attentes élevées pour les réseaux préférés. Il existe un système aux États-Unis qui donne des sommes importantes à des chercheurs comme Google, mais il y en a peu au Japon. Un projet inexploré qui paie des fonds de recherche en tant qu'incubateur a également un salaire horaire de 1600 yens. Le stage préféré est de 2500 yens. De plus, il existe diverses indemnités. Voici leur sérieux. Et la référence est toujours élevée. J'attends ça avec impatience à l'avenir.