カスタムGym環境作成(27) - 広げたマップを強化学習で攻略(学習率を深ぼり2回目)

今回も、学習率を調整して結果がどう変わるか見ていきたいと思います。

[広くしたマップイメージ]

学習率の微調整2回目

前回の結果より、学習率1.5付近の結果も比較良かったので、さらに学習率1.6から2.5の結果も確認してみます。

ソースの修正箇所は、26-35行目となります。

[ソース]

train7.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
# 警告を非表示
import os
import warnings
warnings.simplefilter('ignore')
import tensorflow as tf
tf.get_logger().setLevel("ERROR")

import gym
from env7 import MyEnv

from stable_baselines.common.vec_env import DummyVecEnv
#from stable_baselines import PPO2
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor

# ログフォルダの作成
log_dir = './logs/'
os.makedirs(log_dir, exist_ok=True)

# 環境の生成
env = MyEnv()
env = Monitor(env, log_dir, allow_early_resets=True)
env = DummyVecEnv([lambda: env])

# モデルの生成
model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1.6)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1.7)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1.8)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1.9)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=2.0)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=2.1)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=2.2)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=2.3)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=2.4)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=2.5)

# モデルの学習
model.learn(total_timesteps=128000)

# モデルの保存
model.save('model7')

# モデルのテスト
state = env.reset()
total_reward = 0
while True:
# 環境の描画
env.render()

# モデルの推論
action, _ = model.predict(state)

# 1ステップの実行
state, reward, done, info = env.step(action)
total_reward += reward
print('reward:', reward, 'total_reward', total_reward)
print('-----------')

print('')
# エピソード完了
if done:
# 環境の描画
print('total_reward:', total_reward)
break

学習率を変更しながら実行し、それぞれの最終結果と平均報酬遷移(グラフ)を確認します。

[結果]

学習率 最終位置・最終報酬 平均報酬遷移
1.6
1.7
1.8
1.9
2.0
2.1
2.2
2.3
2.4
2.5

学習率1.9と2.0は全エピソードの半分くらいゴールしているんですが、完全攻略はできていません。

もう一歩のような気もするんですが・・・😔

カスタムGym環境作成(26) - 広げたマップを強化学習で攻略(学習率を深ぼり)

今回は、学習率を微調整して結果がどう変わるか見ていきたいと思います。

[広くしたマップイメージ]

学習率の微調整

前回の結果より、学習率0.1~1.0付近でのゴール回数が多いように感じられました。

今回は学習率を0.5から1.5まで0.1ずつ増やしてその結果を確認していきたいと思います。

ソースの修正箇所は、26-36行目となります。

[ソース]

train7.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
# 警告を非表示
import os
import warnings
warnings.simplefilter('ignore')
import tensorflow as tf
tf.get_logger().setLevel("ERROR")

import gym
from env7 import MyEnv

from stable_baselines.common.vec_env import DummyVecEnv
#from stable_baselines import PPO2
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor

# ログフォルダの作成
log_dir = './logs/'
os.makedirs(log_dir, exist_ok=True)

# 環境の生成
env = MyEnv()
env = Monitor(env, log_dir, allow_early_resets=True)
env = DummyVecEnv([lambda: env])

# モデルの生成
model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.5)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.6)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.7)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.8)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.9)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1.0)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1.1)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1.2)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1.3)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1.4)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1.5)

# モデルの学習
model.learn(total_timesteps=128000)

# モデルの保存
model.save('model7')

# モデルのテスト
state = env.reset()
total_reward = 0
while True:
# 環境の描画
env.render()

# モデルの推論
action, _ = model.predict(state)

# 1ステップの実行
state, reward, done, info = env.step(action)
total_reward += reward
print('reward:', reward, 'total_reward', total_reward)
print('-----------')

print('')
# エピソード完了
if done:
# 環境の描画
print('total_reward:', total_reward)
break

学習率を変更しながら実行し、それぞれの最終結果と平均報酬遷移(グラフ)を確認します。

[結果]

学習率 最終位置・最終報酬 平均報酬遷移
0.5
0.6
0.7
0.8
0.9
1.0
1.1
1.2
1.3
1.4
1.5

ゴール回数は増えているように見えますが、今回も攻略するまでには至りませんでした。

次回ももう少し学習率を調整を行ってみたいと思います。

カスタムGym環境作成(25) - 広げたマップを強化学習で攻略(報酬の簡易化)

前回は、学習アルゴリズムを変更(PPO2アルゴリズム使用)しましたがぜんぜんゴールできない結果となってしまいました。

学習アルゴリズムはACKTRに戻します。

[広くしたマップイメージ]

いろいろ対策を行いまして、こんがらがってきてしまったので今回は一旦報酬をシンプルにしてみたいと思います。

報酬の簡易化

具体的には、ゴール時の報酬を500にし、それ以外の報酬を-1とします。

報酬をシンプルにし、とにかくゴールできるように学習をしてほしいという狙いです。

修正箇所は、カスタムGym環境の99-120行目となります。

[ソース]

env7.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
import sys

import gym
import numpy as np
import gym.spaces

class MyEnv(gym.Env):
FIELD_TYPES = [
'S', # 0: スタート
'G', # 1: ゴール
' ', # 2: 平地
'山', # 3: 山(歩けない)
'☆', # 4: プレイヤー
'三', # 5: 橋
'川', # 6: 川
'林', # 7: 林
]
MAP = np.array([
[0, 3, 3, 3, 2, 3, 7, 7, 3, 2, 2, 3],
[2, 2, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2],
[3, 2, 3, 2, 3, 7, 7, 2, 2, 2, 2, 3],
[3, 2, 2, 2, 7, 7, 6, 6, 3, 3, 2, 2],
[7, 7, 3, 2, 6, 6, 6, 3, 7, 7, 3, 3],
[3, 2, 3, 2, 3, 7, 3, 1, 2, 7, 2, 2],
[3, 7, 2, 2, 3, 2, 3, 3, 3, 3, 2, 7],
[2, 2, 3, 2, 2, 3, 2, 3, 2, 3, 3, 2],
[7, 3, 2, 7, 7, 2, 2, 2, 7, 6, 6, 7],
[2, 3, 2, 6, 6, 6, 2, 3, 2, 7, 2, 2],
[3, 3, 2, 3, 2, 3, 6, 2, 3, 2, 2, 3],
[7, 2, 2, 2, 3, 3, 6, 2, 7, 3, 2, 2],
])
#MAX_STEPS = 2000
MAX_STEPS = 5000

def __init__(self):
super().__init__()
# action_space, observation_space, reward_range を設定する
self.action_space = gym.spaces.Discrete(4) # 上下左右
self.observation_space = gym.spaces.Box(
low=0,
high=len(self.FIELD_TYPES),
shape=self.MAP.shape
)
self.reset()

def reset(self):
# 諸々の変数を初期化する
self.pos = self._find_pos('S')[0]
self.goal = self._find_pos('G')[0]
self.river = self._find_pos('川')
self.trees = self._find_pos('林')
self.start = self._find_pos('S')[0]
self.done = False
self.steps = 0
return self._observe()

def step(self, action):
# 1ステップ進める処理を記述。戻り値は observation, reward, done(ゲーム終了したか), info(追加の情報の辞書)
# 左上の座標を(0, 0)とする
if action == 0: # 右移動
next_pos = self.pos + [0, 1]
elif action == 1: # 左移動
next_pos = self.pos + [0, -1]
elif action == 2: # 下移動
next_pos = self.pos + [1, 0]
elif action == 3: # 上移動
next_pos = self.pos + [-1, 0]

if self._is_movable(next_pos):
self.pos = next_pos
moved = True
else:
moved = False

self.steps += 1
observation = self._observe()
reward = self._get_reward(self.pos, moved)
self.done = self._is_done()
return observation, reward, self.done, {}

def render(self, mode='console', close=False):
for row in self._observe():
for elem in row:
print(self.FIELD_TYPES[elem], end='')
print()

def _close(self):
pass

def _seed(self, seed=None):
pass

def _get_reward(self, pos, moved):
# 報酬を返す。
# - ゴールにたどり着くと 3000 ポイント
# - 川に入ったら -10 ポイント
# - 林に入ったら -3 ポイント
# - 1ステップごとに-1ポイント(できるだけ短いステップでゴールにたどり着きたい)
'''
if (self.start == pos).all(): # スタート位置に戻ってきたときのマイナス報酬
return -10
if moved:
if (self.goal == pos).all():
#return 3000
return 15000
for x in self.river:
if (x == pos).all():
return -10
for x in self.trees:
if (x == pos).all():
return -3
return -1
#return -3
else: # エージェントが動かなかった場合
return -10
'''
if (self.goal == pos).all():
return 500
else:
return -1

def _is_movable(self, pos):
# マップの中にいるか、歩けない場所にいないか
return (
0 <= pos[0] < self.MAP.shape[0]
and 0 <= pos[1] < self.MAP.shape[1]
and self.FIELD_TYPES[self.MAP[tuple(pos)]] != '山'
)

def _observe(self):
# マップにプレイヤーの位置を重ねて返す
observation = self.MAP.copy()
observation[tuple(self.pos)] = self.FIELD_TYPES.index('☆')
return observation

def _is_done(self):
# 最大で self.MAX_STEPS まで
if (self.pos == self.goal).all():
return True
elif self.steps > self.MAX_STEPS:
return True
else:
return False

def _find_pos(self, field_type):
return np.array(list(zip(*np.where(self.MAP == self.FIELD_TYPES.index(field_type)))))

学習率を変更しながら実行し、それぞれの最終結果と平均報酬遷移(グラフ)を確認します。

[結果]

学習率 最終位置・最終報酬 平均報酬遷移
0.01
0.05
0.1
0.5
1.0

学習完了(マップ攻略)とはいきませんでしたが、学習率0.1~1.0付近でのゴール回数が多いようです。

次回は、この学習率付近をもう少し深ぼりして調査したいと思います。

カスタムGym環境作成(22) - 広げたマップを強化学習で攻略(改善点まとめ)

これまで広げたマップに対していろいろ改善を行ってきましたが、まだ完全攻略するに至っていません。

[広くしたマップイメージ]

今後の戦略を練るために、一旦これまでの改善内容をまとめたいと思います。

改善点まとめ

  1. エージェントが動かない場合のマイナス報酬を増やす。
    エージェントが動かないステップが多かったので、エージェントが動かない場合のマイナス報酬を増やしてみました。(-1 ⇒ -10)
  1. スタート地点に戻ったときの報酬を設定。
    エージェントがスタート地点に戻った時の報酬を設定していなかったので、-10というマイナス報酬を設定しました。
  1. ゴール時の報酬をアップ。
    最終報酬がプラスになることがほとんどなかったので、ゴール時の報酬をアップさせました。(3000 ⇒ 15000)
  1. 学習回数を増やす。
    回数は少なめですがゴールすることあったので、もう少し頑張れば攻略できるのではないかと思い学習回数を5倍に増やしてみました。(128000 ⇒ 128000×5)

次回は別の改善を行い完全攻略を目指します。

カスタムGym環境作成(21) - 広げたマップを強化学習で攻略(学習回数を増やす)

前回、広げたマップに対してゴールしたときの報酬を増やみましたが、ほとんどゴールにたどり着くことができませんでした。

[広くしたマップイメージ]

今回は単純に学習回数を増やして、攻略を目指します。

学習回数を増やす

これまでの改善で、(たまたまかもしれませんが)何回かはゴールすることもあるようなのでもう少し学習回数を増やせば攻略できるのではないか・・・と考えました。

そこで今回は単純に学習回数をこれまでの5倍に増やしてみます。

修正箇所は32行目となります。

[ソース]

train7.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
# 警告を非表示
import os
import warnings
warnings.simplefilter('ignore')
import tensorflow as tf
tf.get_logger().setLevel("ERROR")

import gym
from env7 import MyEnv

from stable_baselines.common.vec_env import DummyVecEnv
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor

# ログフォルダの作成
log_dir = './logs/'
os.makedirs(log_dir, exist_ok=True)

# 環境の生成
env = MyEnv()
env = Monitor(env, log_dir, allow_early_resets=True)
env = DummyVecEnv([lambda: env])

# モデルの生成
model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.01)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.05)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.1)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.5)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1.0)

# モデルの学習
model.learn(total_timesteps=128000*5)

# モデルの保存
model.save('model7')

# モデルのテスト
state = env.reset()
total_reward = 0
while True:
# 環境の描画
env.render()

# モデルの推論
action, _ = model.predict(state)

# 1ステップの実行
state, reward, done, info = env.step(action)
total_reward += reward
print('reward:', reward, 'total_reward', total_reward)
print('-----------')

print('')
# エピソード完了
if done:
# 環境の描画
print('total_reward:', total_reward)
break

前回と同じように学習率を変更しながら実行し、それぞれの最終結果と平均報酬遷移(グラフ)を確認します。

[結果]

学習率 最終位置・最終報酬 平均報酬遷移
0.01
0.05
0.1
0.5
1.0

どの学習率でも同じような結果となりました。

ゴールまでたどり着く(最終報酬がプラスになる)ことは何度もあるのですが、その状態が続くことはありません。

つまりきちんと学習できていません。

行動報酬や学習回数を調整してきましたが、もしかしたら別の対策(切り口)が必要なのかもしれません。

次回は一旦これまでの改善点をまとめたいと思います。

カスタムGym環境作成(20) - 広げたマップを強化学習で攻略(報酬を改善3)

前回、広げたマップに対してエージェントがスタート位置に移動したときのマイナス報酬を増やしてみましたが、ゴールにたどり着くことができませんでした。

[広くしたマップイメージ]

今回は再度報酬を見直して、攻略を目指します。

最終報酬がプラスにならない問題の対策

これまでの結果を見るとプラス報酬になることがほとんどありませんでした。

そこで今回はゴール時の報酬を見直してみました。

具体的にはゴール時の報酬を3000から15000に変更してみました。

理由は、最終報酬が-20000となるケースが一番悪い結果のようなので、それ以前にゴールにたどり着けば最終報酬がプラスになるのではないかと考えたからです。

修正箇所は103~104行目となります。

[ソース]

env7.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
# activate openai_gym
import sys

import gym
import numpy as np
import gym.spaces

class MyEnv(gym.Env):
FIELD_TYPES = [
'S', # 0: スタート
'G', # 1: ゴール
' ', # 2: 平地
'山', # 3: 山(歩けない)
'☆', # 4: プレイヤー
'三', # 5: 橋
'川', # 6: 川
'林', # 7: 林
]
MAP = np.array([
[0, 3, 3, 3, 2, 3, 7, 7, 3, 2, 2, 3],
[2, 2, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2],
[3, 2, 3, 2, 3, 7, 7, 2, 2, 2, 2, 3],
[3, 2, 2, 2, 7, 7, 6, 6, 3, 3, 2, 2],
[7, 7, 3, 2, 6, 6, 6, 3, 7, 7, 3, 3],
[3, 2, 3, 2, 3, 7, 3, 1, 2, 7, 2, 2],
[3, 7, 2, 2, 3, 2, 3, 3, 3, 3, 2, 7],
[2, 2, 3, 2, 2, 3, 2, 3, 2, 3, 3, 2],
[7, 3, 2, 7, 7, 2, 2, 2, 7, 6, 6, 7],
[2, 3, 2, 6, 6, 6, 2, 3, 2, 7, 2, 2],
[3, 3, 2, 3, 2, 3, 6, 2, 3, 2, 2, 3],
[7, 2, 2, 2, 3, 3, 6, 2, 7, 3, 2, 2],
])
MAX_STEPS = 2000

def __init__(self):
super().__init__()
# action_space, observation_space, reward_range を設定する
self.action_space = gym.spaces.Discrete(4) # 上下左右
self.observation_space = gym.spaces.Box(
low=0,
high=len(self.FIELD_TYPES),
shape=self.MAP.shape
)
self.reset()

def reset(self):
# 諸々の変数を初期化する
self.pos = self._find_pos('S')[0]
self.goal = self._find_pos('G')[0]
self.river = self._find_pos('川')
self.trees = self._find_pos('林')
self.start = self._find_pos('S')[0]
self.done = False
self.steps = 0
return self._observe()

def step(self, action):
# 1ステップ進める処理を記述。戻り値は observation, reward, done(ゲーム終了したか), info(追加の情報の辞書)
# 左上の座標を(0, 0)とする
if action == 0: # 右移動
next_pos = self.pos + [0, 1]
elif action == 1: # 左移動
next_pos = self.pos + [0, -1]
elif action == 2: # 下移動
next_pos = self.pos + [1, 0]
elif action == 3: # 上移動
next_pos = self.pos + [-1, 0]

if self._is_movable(next_pos):
self.pos = next_pos
moved = True
else:
moved = False

self.steps += 1
observation = self._observe()
reward = self._get_reward(self.pos, moved)
self.done = self._is_done()
return observation, reward, self.done, {}

def render(self, mode='console', close=False):
for row in self._observe():
for elem in row:
print(self.FIELD_TYPES[elem], end='')
print()

def _close(self):
pass

def _seed(self, seed=None):
pass

def _get_reward(self, pos, moved):
# 報酬を返す。
# - ゴールにたどり着くと 3000 ポイント
# - 川に入ったら -10 ポイント
# - 林に入ったら -3 ポイント
# - 1ステップごとに-1ポイント(できるだけ短いステップでゴールにたどり着きたい)
if (self.start == pos).all(): # スタート位置に戻ってきたときのマイナス報酬
return -10
if moved:
if (self.goal == pos).all():
#return 3000
return 15000
for x in self.river:
if (x == pos).all():
return -10
for x in self.trees:
if (x == pos).all():
return -3
return -1
else: # エージェントが動かなかった場合
return -10

def _is_movable(self, pos):
# マップの中にいるか、歩けない場所にいないか
return (
0 <= pos[0] < self.MAP.shape[0]
and 0 <= pos[1] < self.MAP.shape[1]
and self.FIELD_TYPES[self.MAP[tuple(pos)]] != '山'
)

def _observe(self):
# マップにプレイヤーの位置を重ねて返す
observation = self.MAP.copy()
observation[tuple(self.pos)] = self.FIELD_TYPES.index('☆')
return observation

def _is_done(self):
# 最大で self.MAX_STEPS まで
if (self.pos == self.goal).all():
return True
elif self.steps > self.MAX_STEPS:
return True
else:
return False

def _find_pos(self, field_type):
return np.array(list(zip(*np.where(self.MAP == self.FIELD_TYPES.index(field_type)))))

報酬を修正したこのカスタム環境に対して、前回と同じように学習率を変更しながら実行し、それぞれの最終結果と平均報酬遷移(グラフ)を確認します。

各実行結果をまとめると下記のようになりました。

[結果]

学習率 最終位置・最終報酬 平均報酬遷移
0.01
0.05
0.1
0.5
1.0

ゴールしたときの報酬を増やしたおかげで、ゴールしたときのエピソードがどこかは分かりやすくなったのですが、どの学習率でもたまにラッキーゴールをした感じで、マップを攻略した状態にはなっていません。

マップを攻略したモデルであれば、つねにプラス報酬であり続けるはずですので。。。

次回は、学習ステップ数を増やしてマップを攻略できるかどうか試したいと思います。

カスタムGym環境作成(19) - 広げたマップを強化学習で攻略(報酬を改善2)

前回、広げたマップに対してエージェントが移動しない場合のマイナス報酬を修正して攻略を試みましたが、ゴールにたどり着くことができませんでした。

[広くしたマップイメージ]

今回は再度報酬を見直して、攻略を目指します。

ゴール近くから動かないことの対策

前回の結果を見ていてまたまた問題だと思ったのが、スタート地点付近からエージェントが全く動かないことが多いということです。

そのため前回、移動しない場合のマイナス報酬をよりマイナスにしたのですが、それでもスタート位置付近にいるケースが多々ありました。

という訳で今回はスタート地点に移動したときの報酬を-10としてみました。

修正箇所は52行目、99~100行目となります。

[ソース]

env7.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
# activate openai_gym
import sys

import gym
import numpy as np
import gym.spaces

class MyEnv(gym.Env):
FIELD_TYPES = [
'S', # 0: スタート
'G', # 1: ゴール
' ', # 2: 平地
'山', # 3: 山(歩けない)
'☆', # 4: プレイヤー
'三', # 5: 橋
'川', # 6: 川
'林', # 7: 林
]
MAP = np.array([
[0, 3, 3, 3, 2, 3, 7, 7, 3, 2, 2, 3],
[2, 2, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2],
[3, 2, 3, 2, 3, 7, 7, 2, 2, 2, 2, 3],
[3, 2, 2, 2, 7, 7, 6, 6, 3, 3, 2, 2],
[7, 7, 3, 2, 6, 6, 6, 3, 7, 7, 3, 3],
[3, 2, 3, 2, 3, 7, 3, 1, 2, 7, 2, 2],
[3, 7, 2, 2, 3, 2, 3, 3, 3, 3, 2, 7],
[2, 2, 3, 2, 2, 3, 2, 3, 2, 3, 3, 2],
[7, 3, 2, 7, 7, 2, 2, 2, 7, 6, 6, 7],
[2, 3, 2, 6, 6, 6, 2, 3, 2, 7, 2, 2],
[3, 3, 2, 3, 2, 3, 6, 2, 3, 2, 2, 3],
[7, 2, 2, 2, 3, 3, 6, 2, 7, 3, 2, 2],
])
MAX_STEPS = 2000

def __init__(self):
super().__init__()
# action_space, observation_space, reward_range を設定する
self.action_space = gym.spaces.Discrete(4) # 上下左右
self.observation_space = gym.spaces.Box(
low=0,
high=len(self.FIELD_TYPES),
shape=self.MAP.shape
)
self.reset()

def reset(self):
# 諸々の変数を初期化する
self.pos = self._find_pos('S')[0]
self.goal = self._find_pos('G')[0]
self.river = self._find_pos('川')
self.trees = self._find_pos('林')
self.start = self._find_pos('S')[0]
self.done = False
self.steps = 0
return self._observe()

def step(self, action):
# 1ステップ進める処理を記述。戻り値は observation, reward, done(ゲーム終了したか), info(追加の情報の辞書)
# 左上の座標を(0, 0)とする
if action == 0: # 右移動
next_pos = self.pos + [0, 1]
elif action == 1: # 左移動
next_pos = self.pos + [0, -1]
elif action == 2: # 下移動
next_pos = self.pos + [1, 0]
elif action == 3: # 上移動
next_pos = self.pos + [-1, 0]

if self._is_movable(next_pos):
self.pos = next_pos
moved = True
else:
moved = False

self.steps += 1
observation = self._observe()
reward = self._get_reward(self.pos, moved)
self.done = self._is_done()
return observation, reward, self.done, {}

def render(self, mode='console', close=False):
for row in self._observe():
for elem in row:
print(self.FIELD_TYPES[elem], end='')
print()

def _close(self):
pass

def _seed(self, seed=None):
pass

def _get_reward(self, pos, moved):
# 報酬を返す。
# - ゴールにたどり着くと 3000 ポイント
# - 川に入ったら -10 ポイント
# - 林に入ったら -3 ポイント
# - 1ステップごとに-1ポイント(できるだけ短いステップでゴールにたどり着きたい)
if (self.start == pos).all(): # スタート位置に戻ってきたときのマイナス報酬
return -10
if moved:
if (self.goal == pos).all():
return 3000
for x in self.river:
if (x == pos).all():
return -10
for x in self.trees:
if (x == pos).all():
return -3
return -1
else: # エージェントが動かなかった場合
return -10

def _is_movable(self, pos):
# マップの中にいるか、歩けない場所にいないか
return (
0 <= pos[0] < self.MAP.shape[0]
and 0 <= pos[1] < self.MAP.shape[1]
and self.FIELD_TYPES[self.MAP[tuple(pos)]] != '山'
)

def _observe(self):
# マップにプレイヤーの位置を重ねて返す
observation = self.MAP.copy()
observation[tuple(self.pos)] = self.FIELD_TYPES.index('☆')
return observation

def _is_done(self):
# 最大で self.MAX_STEPS まで
if (self.pos == self.goal).all():
return True
elif self.steps > self.MAX_STEPS:
return True
else:
return False

def _find_pos(self, field_type):
return np.array(list(zip(*np.where(self.MAP == self.FIELD_TYPES.index(field_type)))))

報酬を修正したこのカスタム環境に対して、前回と同じように学習率を変更しながら実行し、それぞれの最終結果と平均報酬遷移(グラフ)を確認します。

各実行結果をまとめると下記のようになりました。

[結果]

学習率 最終位置・最終報酬 平均報酬遷移
0.01
0.05
0.1
0.5
1.0
5.0
10.0
50.0

学習率が1.0以下の場合は、スタート地点から移動したまにゴールすることもありますが、学習が完了することはありませんでした。

学習率が5.0以上の場合は、移動をあきらめたのかスタート地点付近にとどまり続けてしまっています。

次回はまた報酬を見直しゴールを目指します。

(また学習率を5.0以上に設定した場合ですが、結果があまりにも悪いのでもう検証しないことにします)

カスタムGym環境作成(18) - 広げたマップを強化学習で攻略(報酬を改善1)

前回、広げたマップに対していろいろな学習率で攻略を試みましたが、ゴールにたどり着くことができませんでした。

[広くしたマップイメージ]

今回はカスタム環境の報酬を改善して、攻略を目指します。

報酬を改善

前回の結果を見ていて一番問題だと思ったのが、スタート地点付近からエージェントが全く動かないことでした。

これを改善するために、エージェントが動かない場合のマイナス報酬を増やして(-1 ⇒ -10)みたいと思います。

修正箇所は108~109行目となります。

[ソース]

env7.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
# activate openai_gym
import sys

import gym
import numpy as np
import gym.spaces

class MyEnv(gym.Env):
FIELD_TYPES = [
'S', # 0: スタート
'G', # 1: ゴール
' ', # 2: 平地
'山', # 3: 山(歩けない)
'☆', # 4: プレイヤー
'三', # 5: 橋
'川', # 6: 川
'林', # 7: 林
]
MAP = np.array([
[0, 3, 3, 3, 2, 3, 7, 7, 3, 2, 2, 3],
[2, 2, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2],
[3, 2, 3, 2, 3, 7, 7, 2, 2, 2, 2, 3],
[3, 2, 2, 2, 7, 7, 6, 6, 3, 3, 2, 2],
[7, 7, 3, 2, 6, 6, 6, 3, 7, 7, 3, 3],
[3, 2, 3, 2, 3, 7, 3, 1, 2, 7, 2, 2],
[3, 7, 2, 2, 3, 2, 3, 3, 3, 3, 2, 7],
[2, 2, 3, 2, 2, 3, 2, 3, 2, 3, 3, 2],
[7, 3, 2, 7, 7, 2, 2, 2, 7, 6, 6, 7],
[2, 3, 2, 6, 6, 6, 2, 3, 2, 7, 2, 2],
[3, 3, 2, 3, 2, 3, 6, 2, 3, 2, 2, 3],
[7, 2, 2, 2, 3, 3, 6, 2, 7, 3, 2, 2],
])
MAX_STEPS = 2000

def __init__(self):
super().__init__()
# action_space, observation_space, reward_range を設定する
self.action_space = gym.spaces.Discrete(4) # 上下左右
self.observation_space = gym.spaces.Box(
low=0,
high=len(self.FIELD_TYPES),
shape=self.MAP.shape
)
self.reset()

def reset(self):
# 諸々の変数を初期化する
self.pos = self._find_pos('S')[0]
self.goal = self._find_pos('G')[0]
self.river = self._find_pos('川')
self.trees = self._find_pos('林')
self.done = False
self.steps = 0
return self._observe()

def step(self, action):
# 1ステップ進める処理を記述。戻り値は observation, reward, done(ゲーム終了したか), info(追加の情報の辞書)
# 左上の座標を(0, 0)とする
if action == 0: # 右移動
next_pos = self.pos + [0, 1]
elif action == 1: # 左移動
next_pos = self.pos + [0, -1]
elif action == 2: # 下移動
next_pos = self.pos + [1, 0]
elif action == 3: # 上移動
next_pos = self.pos + [-1, 0]

if self._is_movable(next_pos):
self.pos = next_pos
moved = True
else:
moved = False

self.steps += 1
observation = self._observe()
reward = self._get_reward(self.pos, moved)
self.done = self._is_done()
return observation, reward, self.done, {}

def render(self, mode='console', close=False):
for row in self._observe():
for elem in row:
print(self.FIELD_TYPES[elem], end='')
print()

def _close(self):
pass

def _seed(self, seed=None):
pass

def _get_reward(self, pos, moved):
# 報酬を返す。
# - ゴールにたどり着くと 3000 ポイント
# - 川に入ったら -10 ポイント
# - 林に入ったら -3 ポイント
# - 1ステップごとに-1ポイント(できるだけ短いステップでゴールにたどり着きたい)
if moved:
if (self.goal == pos).all():
return 3000
for x in self.river:
if (x == pos).all():
return -10
for x in self.trees:
if (x == pos).all():
return -3
return -1
else: # エージェントが動かなかった場合
return -10

def _is_movable(self, pos):
# マップの中にいるか、歩けない場所にいないか
return (
0 <= pos[0] < self.MAP.shape[0]
and 0 <= pos[1] < self.MAP.shape[1]
and self.FIELD_TYPES[self.MAP[tuple(pos)]] != '山'
)

def _observe(self):
# マップにプレイヤーの位置を重ねて返す
observation = self.MAP.copy()
observation[tuple(self.pos)] = self.FIELD_TYPES.index('☆')
return observation

def _is_done(self):
# 最大で self.MAX_STEPS まで
if (self.pos == self.goal).all():
return True
elif self.steps > self.MAX_STEPS:
return True
else:
return False

def _find_pos(self, field_type):
return np.array(list(zip(*np.where(self.MAP == self.FIELD_TYPES.index(field_type)))))

報酬を修正したこのカスタム環境に対して、前回と同じように学習率を変更しながら実行し、それぞれの最終結果と平均報酬遷移(グラフ)を確認します。

各実行結果をまとめると下記のようになりました。

[結果]

学習率 最終位置・最終報酬 平均報酬遷移
0.01
0.05
0.1
0.5
1.0
5.0
10.0
50.0

学習率0.05の最終結果をみるとたまたまゴールしているようです。

その他の学習率の平均報酬遷移グラフをみるとたまにゴールすることはあるようですが、きちんと学習して常にゴールをするという段階には達していません。

次回はまた別の報酬を変更して、広げたマップの攻略を目指します。

カスタムGym環境作成(17) - 広げたマップを強化学習で攻略

今回は、広げたマップを強化学習で攻略していきます。

[広くしたマップイメージ]

広げたマップマップを強化学習

前々回に実装したカスタムGym環境(env7.py)を9行目で読み込み、強化学習を行います。

学習アルゴリズムはACKTR(25~32行目)で、学習率は0.01から50.0に段階的に変更して結果がどのように変わるか確認していきます。

学習ステップ数は128000(35行目)としています。

[ソース]

train7.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
# 警告を非表示
import os
import warnings
warnings.simplefilter('ignore')
import tensorflow as tf
tf.get_logger().setLevel("ERROR")

import gym
from env7 import MyEnv

from stable_baselines.common.vec_env import DummyVecEnv
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor

# ログフォルダの作成
log_dir = './logs/'
os.makedirs(log_dir, exist_ok=True)

# 環境の生成
env = MyEnv()
env = Monitor(env, log_dir, allow_early_resets=True)
env = DummyVecEnv([lambda: env])

# モデルの生成
model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.01)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.05)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.1)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=0.5)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1.0)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=5.0)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=10.0)
#model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=50.0)

# モデルの学習
model.learn(total_timesteps=128000)

# モデルの保存
model.save('model7')

# モデルのテスト
state = env.reset()
total_reward = 0
while True:
# 環境の描画
env.render()

# モデルの推論
action, _ = model.predict(state)

# 1ステップの実行
state, reward, done, info = env.step(action)
total_reward += reward
print('reward:', reward, 'total_reward', total_reward)
print('-----------')

print('')
# エピソード完了
if done:
# 環境の描画
print('total_reward:', total_reward)
break

各実行結果をまとめると下記のようになりました。

[結果]

学習率 最終位置・最終報酬 平均報酬遷移
0.01
0.05
0.1
0.5
1.0
5.0
10.0
50.0

全然ゴールできていません。

ランダムで実行していたときは、半分ほどゴールまでたどり着いていたのでランダム実行よりはるかに劣る結果ということになります😥

スタート地点付近からほとんど動かないことが多く、学習率の調整以前の問題だと考えられます。

ということで次回はカスタム環境の報酬設定を見直していきたいと思います。

カスタムGym環境作成(14) - 学習率と報酬の調整

前回記事で山超えのコースを学習・攻略しようとしましたが、うまく学習できませんでした。

[橋を渡るコースを山でふさいだマップイメージ]

今回は、学習率と報酬を調整してマップ攻略を目指します。

学習率と報酬の調整

学習率と報酬をいろいろと変更してみて、最終的には下記のように設定し攻略することができました。

  • 学習率を1に設定(train6.py 25行目のlearning_rateオプションで設定)
  • ゴール時の報酬を2000に変更(env6.py 92行目を修正)

[ソース]

train6.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# 警告を非表示
import os
import warnings
warnings.simplefilter('ignore')
import tensorflow as tf
tf.get_logger().setLevel("ERROR")

import gym
from env6 import MyEnv

from stable_baselines.common.vec_env import DummyVecEnv
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor

# ログフォルダの作成
log_dir = './logs/'
os.makedirs(log_dir, exist_ok=True)

# 環境の生成
env = MyEnv()
env = Monitor(env, log_dir, allow_early_resets=True)
env = DummyVecEnv([lambda: env])

# モデルの生成
model = ACKTR('MlpPolicy', env, verbose=1, learning_rate=1)

# モデルの学習
model.learn(total_timesteps=128000)

# モデルの保存
model.save('model6')

# モデルのテスト
state = env.reset()
total_reward = 0
while True:
# 環境の描画
env.render()

# モデルの推論
action, _ = model.predict(state)

# 1ステップの実行
state, reward, done, info = env.step(action)
total_reward += reward
print('reward:', reward, 'total_reward', total_reward)
print('-----------')

print('')
# エピソード完了
if done:
# 環境の描画
print('total_reward:', total_reward)
break

実行結果(ログ)は以下のようになります。

[実行結果]

---------------------------------
| explained_variance | 2.03e-06 |
| fps                | 31       |
| nupdates           | 1        |
| policy_entropy     | 1.39     |
| policy_loss        | -406     |
| total_timesteps    | 20       |
| value_loss         | 1.37e+05 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -322     |
| explained_variance | 0        |
| fps                | 948      |
| nupdates           | 100      |
| policy_entropy     | 0.0541   |
| policy_loss        | -0.00449 |
| total_timesteps    | 2000     |
| value_loss         | 0.218    |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -258     |
| explained_variance | 0.00392  |
| fps                | 1099     |
| nupdates           | 200      |
| policy_entropy     | 0.388    |
| policy_loss        | -0.0641  |
| total_timesteps    | 4000     |
| value_loss         | 0.0191   |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -269     |
| explained_variance | -0.0365  |
| fps                | 1158     |
| nupdates           | 300      |
| policy_entropy     | 1.35     |
| policy_loss        | -0.052   |
| total_timesteps    | 6000     |
| value_loss         | 0.002    |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -409     |
| explained_variance | -4.18    |
| fps                | 1188     |
| nupdates           | 400      |
| policy_entropy     | 1.35     |
| policy_loss        | -0.00553 |
| total_timesteps    | 8000     |
| value_loss         | 5.43e-05 |
---------------------------------
----------------------------------
| ep_len_mean        | 201       |
| ep_reward_mean     | -466      |
| explained_variance | -0.000672 |
| fps                | 1207      |
| nupdates           | 500       |
| policy_entropy     | 1.32      |
| policy_loss        | -55.1     |
| total_timesteps    | 10000     |
| value_loss         | 3.66e+03  |
----------------------------------
----------------------------------
| ep_len_mean        | 201       |
| ep_reward_mean     | -498      |
| explained_variance | -3.39e+04 |
| fps                | 1219      |
| nupdates           | 600       |
| policy_entropy     | 1.31      |
| policy_loss        | -0.00111  |
| total_timesteps    | 12000     |
| value_loss         | 0.00047   |
----------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -512     |
| explained_variance | -37      |
| fps                | 1228     |
| nupdates           | 700      |
| policy_entropy     | 1.29     |
| policy_loss        | -0.0169  |
| total_timesteps    | 14000    |
| value_loss         | 3.5e-05  |
---------------------------------
----------------------------------
| ep_len_mean        | 201       |
| ep_reward_mean     | -512      |
| explained_variance | -1.11e-05 |
| fps                | 1235      |
| nupdates           | 800       |
| policy_entropy     | 1.28      |
| policy_loss        | -57.6     |
| total_timesteps    | 16000     |
| value_loss         | 3.66e+03  |
----------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -482     |
| explained_variance | -7       |
| fps                | 1240     |
| nupdates           | 900      |
| policy_entropy     | 1.36     |
| policy_loss        | -0.0157  |
| total_timesteps    | 18000    |
| value_loss         | 5.22e-06 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -476     |
| explained_variance | -4.79    |
| fps                | 1244     |
| nupdates           | 1000     |
| policy_entropy     | 1.32     |
| policy_loss        | -0.0135  |
| total_timesteps    | 20000    |
| value_loss         | 1.72e-06 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -490     |
| explained_variance | -461     |
| fps                | 1246     |
| nupdates           | 1100     |
| policy_entropy     | 1.38     |
| policy_loss        | -0.0131  |
| total_timesteps    | 22000    |
| value_loss         | 1.42e-06 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -518     |
| explained_variance | -20.4    |
| fps                | 1248     |
| nupdates           | 1200     |
| policy_entropy     | 1.38     |
| policy_loss        | -0.0222  |
| total_timesteps    | 24000    |
| value_loss         | 6.51e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -531     |
| explained_variance | -22.4    |
| fps                | 1250     |
| nupdates           | 1300     |
| policy_entropy     | 1.37     |
| policy_loss        | -0.015   |
| total_timesteps    | 26000    |
| value_loss         | 2.2e-06  |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -480     |
| explained_variance | -0.00395 |
| fps                | 1251     |
| nupdates           | 1400     |
| policy_entropy     | 1.34     |
| policy_loss        | -79.9    |
| total_timesteps    | 28000    |
| value_loss         | 5.28e+03 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -450     |
| explained_variance | -3.2     |
| fps                | 1252     |
| nupdates           | 1500     |
| policy_entropy     | 1.3      |
| policy_loss        | -0.0117  |
| total_timesteps    | 30000    |
| value_loss         | 3.33e-06 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -426     |
| explained_variance | 0.413    |
| fps                | 1253     |
| nupdates           | 1600     |
| policy_entropy     | 1.35     |
| policy_loss        | -0.0134  |
| total_timesteps    | 32000    |
| value_loss         | 1.12e-06 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -392     |
| explained_variance | -0.00011 |
| fps                | 1254     |
| nupdates           | 1700     |
| policy_entropy     | 1.27     |
| policy_loss        | -22      |
| total_timesteps    | 34000    |
| value_loss         | 970      |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -377     |
| explained_variance | 1.26e-05 |
| fps                | 1255     |
| nupdates           | 1800     |
| policy_entropy     | 1.27     |
| policy_loss        | -124     |
| total_timesteps    | 36000    |
| value_loss         | 7.82e+03 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -377     |
| explained_variance | 0.000336 |
| fps                | 1256     |
| nupdates           | 1900     |
| policy_entropy     | 1.32     |
| policy_loss        | 59.4     |
| total_timesteps    | 38000    |
| value_loss         | 4.07e+03 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -364     |
| explained_variance | 0.000371 |
| fps                | 1257     |
| nupdates           | 2000     |
| policy_entropy     | 1.35     |
| policy_loss        | 116      |
| total_timesteps    | 40000    |
| value_loss         | 7.81e+03 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -359     |
| explained_variance | -1.94    |
| fps                | 1257     |
| nupdates           | 2100     |
| policy_entropy     | 1.38     |
| policy_loss        | -0.0157  |
| total_timesteps    | 42000    |
| value_loss         | 4.23e-06 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -336     |
| explained_variance | 0.494    |
| fps                | 1258     |
| nupdates           | 2200     |
| policy_entropy     | 1.38     |
| policy_loss        | -0.0175  |
| total_timesteps    | 44000    |
| value_loss         | 8.93e-06 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -313     |
| explained_variance | 0.071    |
| fps                | 1259     |
| nupdates           | 2300     |
| policy_entropy     | 1.38     |
| policy_loss        | -0.0205  |
| total_timesteps    | 46000    |
| value_loss         | 2.63e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -318     |
| explained_variance | -3.05    |
| fps                | 1259     |
| nupdates           | 2400     |
| policy_entropy     | 1.38     |
| policy_loss        | -0.0126  |
| total_timesteps    | 48000    |
| value_loss         | 1.01e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -308     |
| explained_variance | -0.223   |
| fps                | 1260     |
| nupdates           | 2500     |
| policy_entropy     | 1.37     |
| policy_loss        | -0.0161  |
| total_timesteps    | 50000    |
| value_loss         | 4.16e-06 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -304     |
| explained_variance | -0.795   |
| fps                | 1260     |
| nupdates           | 2600     |
| policy_entropy     | 1.37     |
| policy_loss        | -0.0182  |
| total_timesteps    | 52000    |
| value_loss         | 1.62e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 201      |
| ep_reward_mean     | -300     |
| explained_variance | -0.311   |
| fps                | 1261     |
| nupdates           | 2700     |
| policy_entropy     | 1.38     |
| policy_loss        | -0.0186  |
| total_timesteps    | 54000    |
| value_loss         | 1.6e-05  |
---------------------------------
---------------------------------
| ep_len_mean        | 199      |
| ep_reward_mean     | -264     |
| explained_variance | 0.0573   |
| fps                | 1261     |
| nupdates           | 2800     |
| policy_entropy     | 1.38     |
| policy_loss        | -0.0212  |
| total_timesteps    | 56000    |
| value_loss         | 3.45e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 199      |
| ep_reward_mean     | -226     |
| explained_variance | -3.36    |
| fps                | 1262     |
| nupdates           | 2900     |
| policy_entropy     | 1.36     |
| policy_loss        | -0.0107  |
| total_timesteps    | 58000    |
| value_loss         | 1.11e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 199      |
| ep_reward_mean     | -221     |
| explained_variance | -0.187   |
| fps                | 1262     |
| nupdates           | 3000     |
| policy_entropy     | 1.38     |
| policy_loss        | -0.0219  |
| total_timesteps    | 60000    |
| value_loss         | 4.85e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 199      |
| ep_reward_mean     | -215     |
| explained_variance | -5.68    |
| fps                | 1262     |
| nupdates           | 3100     |
| policy_entropy     | 1.36     |
| policy_loss        | -0.0262  |
| total_timesteps    | 62000    |
| value_loss         | 0.000103 |
---------------------------------
---------------------------------
| ep_len_mean        | 198      |
| ep_reward_mean     | -170     |
| explained_variance | 0.000507 |
| fps                | 1263     |
| nupdates           | 3200     |
| policy_entropy     | 1.38     |
| policy_loss        | 119      |
| total_timesteps    | 64000    |
| value_loss         | 7.81e+03 |
---------------------------------
---------------------------------
| ep_len_mean        | 198      |
| ep_reward_mean     | -175     |
| explained_variance | -0.506   |
| fps                | 1263     |
| nupdates           | 3300     |
| policy_entropy     | 1.38     |
| policy_loss        | -0.0174  |
| total_timesteps    | 66000    |
| value_loss         | 1.03e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 197      |
| ep_reward_mean     | -145     |
| explained_variance | 3.67e-05 |
| fps                | 1263     |
| nupdates           | 3400     |
| policy_entropy     | 1.38     |
| policy_loss        | 20.5     |
| total_timesteps    | 68000    |
| value_loss         | 1.44e+03 |
---------------------------------
---------------------------------
| ep_len_mean        | 196      |
| ep_reward_mean     | -114     |
| explained_variance | -1.71    |
| fps                | 1263     |
| nupdates           | 3500     |
| policy_entropy     | 1.37     |
| policy_loss        | -0.0166  |
| total_timesteps    | 70000    |
| value_loss         | 1.17e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 196      |
| ep_reward_mean     | -66.8    |
| explained_variance | -1.37    |
| fps                | 1263     |
| nupdates           | 3600     |
| policy_entropy     | 1.38     |
| policy_loss        | -0.0194  |
| total_timesteps    | 72000    |
| value_loss         | 2.63e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 195      |
| ep_reward_mean     | -11.9    |
| explained_variance | -3.93    |
| fps                | 1264     |
| nupdates           | 3700     |
| policy_entropy     | 1.37     |
| policy_loss        | -0.0467  |
| total_timesteps    | 74000    |
| value_loss         | 0.000802 |
---------------------------------
---------------------------------
| ep_len_mean        | 196      |
| ep_reward_mean     | 5.91     |
| explained_variance | -1.15    |
| fps                | 1264     |
| nupdates           | 3800     |
| policy_entropy     | 1.38     |
| policy_loss        | -0.0054  |
| total_timesteps    | 76000    |
| value_loss         | 6.35e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 193      |
| ep_reward_mean     | 73       |
| explained_variance | -1.33    |
| fps                | 1264     |
| nupdates           | 3900     |
| policy_entropy     | 1.36     |
| policy_loss        | -0.0216  |
| total_timesteps    | 78000    |
| value_loss         | 5.23e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 189      |
| ep_reward_mean     | 255      |
| explained_variance | -2.78    |
| fps                | 1264     |
| nupdates           | 4000     |
| policy_entropy     | 1.29     |
| policy_loss        | -0.0768  |
| total_timesteps    | 80000    |
| value_loss         | 0.00266  |
---------------------------------
---------------------------------
| ep_len_mean        | 189      |
| ep_reward_mean     | 278      |
| explained_variance | 0.157    |
| fps                | 1264     |
| nupdates           | 4100     |
| policy_entropy     | 1.37     |
| policy_loss        | -0.0131  |
| total_timesteps    | 82000    |
| value_loss         | 1.75e-05 |
---------------------------------
---------------------------------
| ep_len_mean        | 170      |
| ep_reward_mean     | 707      |
| explained_variance | 0.000953 |
| fps                | 1264     |
| nupdates           | 4200     |
| policy_entropy     | 0.94     |
| policy_loss        | 1.01e+03 |
| total_timesteps    | 84000    |
| value_loss         | 2.01e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 137      |
| ep_reward_mean     | 1.21e+03 |
| explained_variance | 0.471    |
| fps                | 1263     |
| nupdates           | 4300     |
| policy_entropy     | 0.83     |
| policy_loss        | -0.0847  |
| total_timesteps    | 86000    |
| value_loss         | 0.114    |
---------------------------------
---------------------------------
| ep_len_mean        | 68.7     |
| ep_reward_mean     | 1.86e+03 |
| explained_variance | 0.00681  |
| fps                | 1263     |
| nupdates           | 4400     |
| policy_entropy     | 0.517    |
| policy_loss        | 74.5     |
| total_timesteps    | 88000    |
| value_loss         | 1.03e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 23.5     |
| ep_reward_mean     | 1.97e+03 |
| explained_variance | 0.00852  |
| fps                | 1262     |
| nupdates           | 4500     |
| policy_entropy     | 0.211    |
| policy_loss        | 59.4     |
| total_timesteps    | 90000    |
| value_loss         | 3.15e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 21.2     |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.0106   |
| fps                | 1261     |
| nupdates           | 4600     |
| policy_entropy     | 0.149    |
| policy_loss        | 20.5     |
| total_timesteps    | 92000    |
| value_loss         | 2.26e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 22.6     |
| ep_reward_mean     | 1.96e+03 |
| explained_variance | 0.0142   |
| fps                | 1260     |
| nupdates           | 4700     |
| policy_entropy     | 0.141    |
| policy_loss        | 399      |
| total_timesteps    | 94000    |
| value_loss         | 2.72e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 20.8     |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.011    |
| fps                | 1260     |
| nupdates           | 4800     |
| policy_entropy     | 0.104    |
| policy_loss        | 7.25     |
| total_timesteps    | 96000    |
| value_loss         | 1.78e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 20.4     |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.0091   |
| fps                | 1260     |
| nupdates           | 4900     |
| policy_entropy     | 0.0783   |
| policy_loss        | 5.12     |
| total_timesteps    | 98000    |
| value_loss         | 1.99e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 20.4     |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.00713  |
| fps                | 1260     |
| nupdates           | 5000     |
| policy_entropy     | 0.115    |
| policy_loss        | -0.78    |
| total_timesteps    | 100000   |
| value_loss         | 1.28e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 20.4     |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.0218   |
| fps                | 1259     |
| nupdates           | 5100     |
| policy_entropy     | 0.0424   |
| policy_loss        | 0.498    |
| total_timesteps    | 102000   |
| value_loss         | 1.57e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 20.1     |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.00849  |
| fps                | 1259     |
| nupdates           | 5200     |
| policy_entropy     | 0.0179   |
| policy_loss        | -0.0378  |
| total_timesteps    | 104000   |
| value_loss         | 1.72e+05 |
---------------------------------
---------------------------------
| ep_len_mean        | 20.1     |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.0211   |
| fps                | 1259     |
| nupdates           | 5300     |
| policy_entropy     | 0.024    |
| policy_loss        | 0.205    |
| total_timesteps    | 106000   |
| value_loss         | 1.26e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 20.1     |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.039    |
| fps                | 1259     |
| nupdates           | 5400     |
| policy_entropy     | 0.0104   |
| policy_loss        | 0.972    |
| total_timesteps    | 108000   |
| value_loss         | 2.55e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 20       |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.0334   |
| fps                | 1259     |
| nupdates           | 5500     |
| policy_entropy     | 0.00561  |
| policy_loss        | 0.349    |
| total_timesteps    | 110000   |
| value_loss         | 2.52e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 20       |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.0375   |
| fps                | 1259     |
| nupdates           | 5600     |
| policy_entropy     | 0.0026   |
| policy_loss        | 0.306    |
| total_timesteps    | 112000   |
| value_loss         | 2.62e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 20       |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.0361   |
| fps                | 1258     |
| nupdates           | 5700     |
| policy_entropy     | 0.00159  |
| policy_loss        | 0.145    |
| total_timesteps    | 114000   |
| value_loss         | 2.61e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 20       |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.0308   |
| fps                | 1258     |
| nupdates           | 5800     |
| policy_entropy     | 0.00105  |
| policy_loss        | 0.089    |
| total_timesteps    | 116000   |
| value_loss         | 2.6e+06  |
---------------------------------
---------------------------------
| ep_len_mean        | 20       |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.0279   |
| fps                | 1258     |
| nupdates           | 5900     |
| policy_entropy     | 0.000787 |
| policy_loss        | 0.0623   |
| total_timesteps    | 118000   |
| value_loss         | 2.59e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 21.8     |
| ep_reward_mean     | 1.96e+03 |
| explained_variance | -0.983   |
| fps                | 1258     |
| nupdates           | 6000     |
| policy_entropy     | 0.135    |
| policy_loss        | -8.94    |
| total_timesteps    | 120000   |
| value_loss         | 919      |
---------------------------------
---------------------------------
| ep_len_mean        | 36.1     |
| ep_reward_mean     | 1.8e+03  |
| explained_variance | 0.0285   |
| fps                | 1258     |
| nupdates           | 6100     |
| policy_entropy     | 0.202    |
| policy_loss        | 2.62     |
| total_timesteps    | 122000   |
| value_loss         | 8.08e+05 |
---------------------------------
---------------------------------
| ep_len_mean        | 21.1     |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.0263   |
| fps                | 1258     |
| nupdates           | 6200     |
| policy_entropy     | 0.0413   |
| policy_loss        | 0.446    |
| total_timesteps    | 124000   |
| value_loss         | 9.49e+05 |
---------------------------------
---------------------------------
| ep_len_mean        | 20.3     |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.0725   |
| fps                | 1257     |
| nupdates           | 6300     |
| policy_entropy     | 0.0795   |
| policy_loss        | 1.3      |
| total_timesteps    | 126000   |
| value_loss         | 2.49e+06 |
---------------------------------
---------------------------------
| ep_len_mean        | 20.6     |
| ep_reward_mean     | 1.98e+03 |
| explained_variance | 0.0398   |
| fps                | 1256     |
| nupdates           | 6400     |
| policy_entropy     | 0.0273   |
| policy_loss        | 1.16     |
| total_timesteps    | 128000   |
| value_loss         | 2.37e+06 |
---------------------------------
☆山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-1.]
-----------

S山山山   山
☆ 川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-2.]
-----------

☆山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-3.]
-----------

S山山山   山
☆ 川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-4.]
-----------

S山山山   山
 ☆川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-5.]
-----------

S山山山   山
  川川山山 G
山☆三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-6.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山☆川川山   
  山  山山 
山 山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-7.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
 ☆山  山山 
山 山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-8.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山☆山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-9.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山☆      
  山 山山 山
reward: [-1.] total_reward [-10.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山 ☆     
  山 山山 山
reward: [-1.] total_reward [-11.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山  ☆    
  山 山山 山
reward: [-1.] total_reward [-12.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山   ☆   
  山 山山 山
reward: [-1.] total_reward [-13.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山    ☆  
  山 山山 山
reward: [-1.] total_reward [-14.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山     ☆ 
  山 山山 山
reward: [-1.] total_reward [-15.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山      ☆
  山 山山 山
reward: [-1.] total_reward [-16.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山☆
山       
  山 山山 山
reward: [-1.] total_reward [-17.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山   
  山  山山☆
山 山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-18.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山  ☆
  山  山山 
山 山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-19.]
-----------

S山山山   山
  川川山山 G
山 三三 山 山
山 川川山 ☆ 
  山  山山 
山 山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-20.]
-----------

S山山山   山
  川川山山 G
山 三三 山☆山
山 川川山   
  山  山山 
山 山 山 山 
山       
  山 山山 山
reward: [-1.] total_reward [-21.]
-----------

S山山山   山
  川川山山☆G
山 三三 山 山
山 川川山   
  山  山山 
山 山 山 山 
山       
  山 山山 山
reward: [2000.] total_reward [1979.]
-----------

total_reward: [1979.]

スタート時に一度出戻りしますが、その後はまっすぐゴールに向かっています。

平均報酬をグラフ化

確認のために学習中の平均報酬推移をグラフにします。

400エピソードを超えたあたりからゴール報酬の2000を取得できるようになっていることが分かります。

調整内容のまとめ

報酬に関しては、ゴールまでの距離が遠くなるほど大きめの報酬にしないといけないと感じました。

ゴールの報酬が、ゴール地点から波紋のように広がっていくイメージです。


また学習率はエージェントの大胆さを調整しているイメージでした。

学習率が低い場合は、臆病な感じで近くに障害(今回の場合は川)があるとそこに近づこうとはせずにスタート位置付近から移動しようとしません。

逆に学習率を高く設定した場合は、大胆にいろいろ行動するようになり、(川に飛び込んでしまうこともありますが)最終的にゴールにたどり着くことができるようになりました。

カスタムGym環境に合わせ報酬も学習率も適切に設定する必要性を強く感じました。


Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×