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.

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.

Recommended Posts

Apprentissage par renforcement 10 Essayez d'utiliser un réseau neuronal formé.
Renforcer l'apprentissage 8 Essayez d'utiliser l'interface utilisateur de Chainer
Essayez de créer un réseau de neurones / d'apprentissage en profondeur avec scratch
Essayez de créer un réseau de neurones en Python sans utiliser de bibliothèque
Essayez d'utiliser TensorFlow-Part 2-Convolution Neural Network (MNIST)
Apprendre un réseau neuronal à l'aide de Chainer
Implémentation d'un réseau de neurones convolutifs utilisant uniquement Numpy
Implémenter un réseau neuronal à 3 couches
Apprentissage par renforcement 5 Essayez de programmer CartPole?
Apprentissage des classements à l'aide d'un réseau neuronal (implémentation RankNet par Chainer)
Renforcer l'apprentissage 13 Essayez Mountain_car avec ChainerRL.
Implémentation d'un réseau de neurones à deux couches 2
Qu'est-ce que le réseau neuronal convolutif?
J'ai essayé de mettre en œuvre un réseau de neurones à deux couches
J'ai essayé l'apprentissage par renforcement avec PyBrain
Créer un modèle d'apprentissage à l'aide de MNIST
Essayez de modifier une nouvelle image à l'aide du modèle StyleGAN2 entraîné
Essayez de faire une stratégie de blackjack en renforçant l'apprentissage ((1) Implémentation du blackjack)
Prédiction des survivants à l'aide du réseau neuronal titanesque de Kaggle [80,8%]
Composez avec un réseau neuronal! Run Magenta
Implémentation d'un réseau neuronal à 3 couches (pas d'apprentissage)
Essayez d'utiliser un langage de programmation probabiliste (Pyro)
Implémentation de réseaux neuronaux "flous" avec Chainer
Implémentation de réseau neuronal simple à l'aide de la préparation Chainer-Data-
Mémo d'étude Python & Machine Learning ③: Réseau neuronal
Essayons la traduction automatique neuronale avec Transformer
Essayez d'utiliser Platypus, une bibliothèque d'optimisation polyvalente
Implémentation de réseau neuronal simple à l'aide de la description du modèle Chainer-
Essayez l'algorithme d'apprentissage amélioré standard d'OpenAI PPO
Création d'un modèle de discrimination d'image (cifar10) à l'aide d'un réseau neuronal convolutif
Renforcer l'apprentissage 11 Essayez OpenAI acrobot avec ChainerRL.
[Deep Learning from scratch] Valeur initiale du poids du réseau neuronal utilisant la fonction sigmoïde
[Python / Machine Learning] Pourquoi le Deep Learning # 1 Perceptron Neural Network
Une histoire sur l'apprentissage automatique simple avec TensorFlow
Expérimentez avec divers algorithmes d'optimisation sur le réseau neuronal
Une autre méthode de conversion de style utilisant le réseau neuronal convolutif
Visualisez la couche interne du réseau neuronal
Essayez d'utiliser le code QR avec Raspberry Pi
Essayez d'utiliser Sourcetrail, un outil de visualisation de code source
Essayez d'utiliser le bloc-notes Jupyter à partir d'Azure Machine Learning
Essayez d'utiliser Tkinter
[Introduction] Renforcer l'apprentissage
Essayez d'utiliser docker-py
Essayez d'utiliser Cookiecutter
Essayez d'utiliser PDFMiner
Essayez de faire une stratégie de blackjack en renforçant l'apprentissage (② Enregistrer l'environnement dans le gymnase)
Essayez d'utiliser des géopandas
Essayez d'utiliser Selenium
Essayez d'utiliser scipy
Apprentissage par renforcement futur_2
Apprentissage par renforcement futur_1
Essayez d'utiliser pandas.DataFrame
Essayez d'utiliser django-swiftbrowser
Essayez d'utiliser matplotlib
Essayez d'utiliser tf.metrics
Essayez d'utiliser PyODE
[Deep Learning from scratch] Poids initial du réseau neuronal lors de l'utilisation de la fonction Relu
Réseau neuronal paramétrique
Entraînez les données MNIST avec PyTorch en utilisant un réseau neuronal
Essayez de créer un fichier compressé en utilisant Python et zlib