<jupyter_start><jupyter_text>OpenAIGymで強化学習入門したい  とりあえずgymを触ってみる<jupyter_code>import gym

#マウンテンカーの環境を作成
env = gym.make("MountainCar-v0")
#上の他にも色んな環境があるよ
from gym import envs
envids = [spec.id for spec in envs.registry.all()]
envids
#環境の初期化
observation = env.reset()
#環境の描画
#jupyter上だとそのまま実行しても動かない
#env.render()
#[車の位置,車の速度]が返ってくる
observation
#状態数
print(env.observation_space)
#行動数
print(env.action_space)
#観測データの最大値
print(env.observation_space.high)
#観測データの最小値
print(env.observation_space.low)
#エージェントを動かす
#0:左へ押す 1:何もしない 2:右へ押す
action = 0
observation, reward, done, info = env.step(action)
print(observation, reward, done, info)<jupyter_output>[-0.52531032 -0.00099462] -1.0 False {}<jupyter_text>machinaを使ってみる<jupyter_code>import torch
import torch.nn.functional as F
import gym
env_name = 'MountainCar-v0'
env = gym.make(env_name)
obs = env.reset()

ob_space = env.observation_space
ac_space = env.action_space
print('obs:', ob_space)
print('act:', ac_space)
#状態->行動の関数近似
class PolicyNet(torch.nn.Module):
    def __init__(self, ob_space, ac_space, deterministic=False):
        super(PolicyNet, self).__init__()
        
        self.deterministic = deterministic
        
        if isinstance(ac_space, gym.spaces.Box):
            self.discrete = False
        else:
            self.discrete = True
            if isinstance(ac_space, gym.spaces.MultiDiscrete):
                self.multi = True
            else:
                self.multi = False
                
        self.fc1 = torch.nn.Linear(ob_space.shape[0], 200)
        self.fc2 = torch.nn.Linear(200, 100)
        self.fc_out = torch.nn.Linear(100, ac_space.n)
        
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        return torch.softmax(self.fc_out(x), dim=-1)
    
#状態->価値の関数近似
class ValueNet(torch.nn.Module):
    def __init__(self, ob_space):
        super(ValueNet, self).__init__()
        self.fc1 = torch.nn.Linear(ob_space.shape[0], 200)
        self.fc2 = torch.nn.Linear(200, 100)
        self.fc_out = torch.nn.Linear(100, 1)
        
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        return self.fc_out(x)
#エージェント作成
from machina.pols import CategoricalPol
from machina.vfuncs import DeterministicSVfunc

vf_net = ValueNet(ob_space)
vf = DeterministicSVfunc(ob_space, vf_net)

pol_net = PolicyNet(ob_space, ac_space)
pol = CategoricalPol(ob_space, ac_space, pol_net)
#環境とエージェントをsamplerに登録
from machina.samplers import EpiSampler
sampler = EpiSampler(env, pol, num_parallel=2, seed=42)
from machina.traj import epi_functional as ef
from machina.utils import measure
from machina.traj import Traj
from machina.algos import ppo_clip

##最適化法を定義
pol_lr = 1e-4
optim_pol = torch.optim.Adam(pol_net.parameters(), pol_lr)
vf_lr = 3e-4
optim_vf = torch.optim.Adam(vf_net.parameters(), vf_lr)

##学習とPPOのパラメータ
gamma = 0.995
lam = 1 
clip_param = 0.2
epoch_per_iter = 50
batch_size = 64
max_grad_norm = 10

##実行用のパラメータ
total_epi = 0             # 現在の実行回数
max_steps_per_iter = 150  # 実行するステップ数（ステップ数が150回になるまで何回もエピソードを繰り返すことに注意）
max_episodes = 100        # 実行するエピソード数
while max_episodes > total_epi:

   #エピソードを実行
    with measure('sample'):
        epis = sampler.sample(pol, max_steps=max_steps_per_iter) # obs:状態,acs:?,rews:報酬,pi:行動   max_steps数になるまで何回もエピソードを繰り返す
   #エピソード実行終了

    #学習(実行したエピソードepisをもとに学習する)
    with measure('train'):
        traj= Traj()         # trajectoryクラスを作成
        traj.add_epis(epis)   # 実行したエピソードを代入

        ### 6.2.1 episを使って，報酬や価値などを計算していく
        traj = ef.compute_vs(traj, vf)             # 価値を計算
        traj = ef.compute_rets(traj, gamma)        # 割引報酬を計算
        traj = ef.compute_advs(traj, gamma, lam)   # アドバンテージを計算(遅延報酬を抑制)
        traj = ef.centerize_advs(traj)
        traj = ef.compute_h_masks(traj)
        traj.register_epis()

        ###実際ここで学習
        result_dict = ppo_clip.train(traj=traj, pol=pol, vf=vf, clip_param=clip_param,
                                   optim_pol=optim_pol, optim_vf=optim_vf, 
                                   epoch=epoch_per_iter, batch_size=batch_size,
                                   max_grad_norm=max_grad_norm)
    del traj

    #エピソードでの報酬の計算
    rewards = [np.sum(epi['rews']) for epi in epis]
    print("epi: {}, reward: {}".format(total_epi, rewards))

    total_epi += 1

del sampler<jupyter_output>2020-03-14 23:36:29.408895 JST | sample: 0.1822sec
2020-03-14 23:36:29.419334 JST | Optimizing...
{'fraction_non_alphanumeric': 0.11332586786114222, 'fraction_numerical': 0.031578947368421054, 'mean_word_length': 3.104779411764706, 'pattern_counts': {'":': 0, '<': 7, '<?xml version=': 0, '>': 10, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '2', 'dir': 'jupyter-structured-clean-dedup', 'id': '37255', 'license': 'MIT', 'n_tokens_mistral': 2087, 'n_tokens_neox': 1978, 'n_words': 306, 'path': 'Question_howto/OpenAIGym.ipynb', 'repo_name': 'dsaito3110/DeepLearningMugenKnock', 'size': '4465'}