ChainerRLのε-Greedyをエピソード単位で減衰させたい

ランダム行動の確率をエピソードが進むごとに減衰させたいのですが…
挙動を見るに「同一エピソードの後半ステップになるほどランダム行動が減っている」ように見えています。

修正方法等ご教示頂けないでしょうか、よろしくお願いします。

chainer 6.3.0
chainerrl 0.7.0
cupy 6.3.0
cupy-cuda100 6.3.0
numpy 1.15.4

bitx_dqn.py
1import chainer
2import chainer.functions as F
3import chainer.links as L
4import chainerrl
5import gym
6import numpy as np
7import cupy as cp
8import setting_value
9import copy
10import bitmex_env
11
12# 環境の作成と中身の確認
13env = bitmex_env.BitmexEnv()
14print('observation space:', env.observation_space)
15print('action space:', env.action_space)
16
17# 環境の初期化
18# resetはループ内でも呼ばれているが、obs_sizeの確認に必要なのでここでも呼んでいる
19obs, close_price, pos_side, pos_avg, funds, reward, counter = env.reset()
20print('initial observation:', obs)
21
22class QFunction(chainer.Chain):
23    
24    def __init__(self, obs_size, n_actions, n_hidden_channels=50):
25        super(QFunction, self).__init__(
26            l0=L.Linear(obs_size, n_hidden_channels*16),
27            l1=L.Linear(n_hidden_channels*16, n_hidden_channels*16),
28            l2=L.Linear(n_hidden_channels*16, n_hidden_channels*16),
29            l3=L.Linear(n_hidden_channels*16, n_hidden_channels*16),
30            l4=L.Linear(n_hidden_channels*16, n_hidden_channels*8),
31            l5=L.Linear(n_hidden_channels*8, n_hidden_channels*8),
32            l6=L.Linear(n_hidden_channels*8, n_hidden_channels*8),
33            l7=L.Linear(n_hidden_channels*8, n_hidden_channels*8),
34            l8=L.Linear(n_hidden_channels*8, n_hidden_channels*4),
35            l9=L.Linear(n_hidden_channels*4, n_hidden_channels*4),
36            l10=L.Linear(n_hidden_channels*4, n_hidden_channels*4),
37            l11=L.Linear(n_hidden_channels*4, n_hidden_channels*4),
38            l12=L.Linear(n_hidden_channels*4, n_hidden_channels*2),
39            l13=L.Linear(n_hidden_channels*2, n_hidden_channels*2),
40            l14=L.Linear(n_hidden_channels*2, n_hidden_channels*2),
41            l15=L.Linear(n_hidden_channels*2, n_hidden_channels*2),
42            l16=L.Linear(n_hidden_channels*2, n_hidden_channels),
43            l17=L.Linear(n_hidden_channels, n_hidden_channels),
44            l18=L.Linear(n_hidden_channels, n_hidden_channels),
45            l19=L.Linear(n_hidden_channels, n_hidden_channels),
46            l20=L.Linear(n_hidden_channels, n_actions))
47
48    def __call__(self, x, test=False):
49        """
50        Args:
51            x (ndarray or chainer.Variable): An observation
52            test (bool): a flag indicating whether it is in test mode
53        """
54        h = F.tanh(self.l0(x))
55        h = F.relu(self.l1(h))
56        h = F.tanh(self.l2(h))
57        h = F.relu(self.l3(h))
58        h = F.tanh(self.l4(h))
59        h = F.relu(self.l5(h))
60        h = F.tanh(self.l6(h))
61        h = F.relu(self.l7(h))
62        h = F.tanh(self.l8(h))
63        h = F.relu(self.l9(h))
64        h = F.tanh(self.l10(h))
65        h = F.relu(self.l11(h))
66        h = F.tanh(self.l12(h))
67        h = F.relu(self.l13(h))
68        h = F.tanh(self.l14(h))
69        h = F.relu(self.l15(h))
70        h = F.tanh(self.l16(h))
71        h = F.relu(self.l17(h))
72        h = F.tanh(self.l18(h))
73        h = F.relu(self.l19(h))
74        
75        return chainerrl.action_value.DiscreteActionValue(self.l19(h))
76
77obs_size = env.observation_space
78n_actions = env.action_space.n
79q_func = QFunction(obs_size, n_actions, obs_size*2)
80chainer.cuda.get_device(0).use()
81q_func.to_gpu()
82
83optimizer = chainer.optimizers.Adam(eps=1e-2)
84optimizer.setup(q_func)
85
86# ループ1回の長さを確認
87if np.ndim(env.input_data) == 1:
88    loop_length = len(env.input_data)
89
90elif np.ndim(env.input_data) > 1:
91    loop_length = len(env.input_data[0])
92
93# ループカウンターを初期化
94loop_counter = 1
95
96# 報酬の割引率
97gamma = 0.95
98
99# 最初は100%ランダムに行動、10000ステップで1%までランダム率を下げる
100explorer = chainerrl.explorers.LinearDecayEpsilonGreedy(
101    start_epsilon=1.0, end_epsilon=0.01, decay_steps=10000, random_action_func=env.random_action_func)
102
103# 記憶用のバッファ
104replay_buffer = chainerrl.replay_buffer.ReplayBuffer(capacity=10 ** 6)
105
106# エージェントの作成
107agent = chainerrl.agents.DoubleDQN(
108    q_func, optimizer, replay_buffer, gamma, explorer,
109    replay_start_size=50, update_interval=1,
110    target_update_interval=10)
111
112# エピソードの繰り返し回数
113n_episodes = 10000
114
115
116# エピソード開始
117for i in range(1, n_episodes + 1):
118
119    # 環境の初期化
120    obs, last_close, pos_side, pos_avg, funds, reward, counter = env.reset()
121    reward = 0
122    done = False
123    last_state = None
124
125    for j in range(env.span + 1, loop_length):
126
127        # アクションの作成
128        action = agent.act_and_train(obs, reward)
129
130        # シグナルの作成
131        signal = env.make_signal(action)
132
133        # ステップの実行
134        obs, last_close, pos_side, pos_avg, funds, reward, counter = env.step(obs, last_close, pos_side, pos_avg, signal, funds, reward, counter)
135        if i == 1:
136            print("ep:{0:5g} |{1:5g} / {2} |random:{3:5g} |entry: {4:5g} |win: {5:5g} |draw: {6:5g} |lose: {7:5g} |F: {8:7g} |R: {9:>10}"\
137                .format(i, j+1, loop_length, env.random_count, env.entry_count, env.win_count, env.draw_count, env.lose_count, int(float(funds)), float(reward), ),end="\r")
138        else:
139            stat = agent.get_statistics()
140            # エピソードごとに結果を出力
141            print("ep:{0:5g} |{1:5g} / {2} |random:{3:5g} |entry: {4:5g} |win: {5:5g} |draw: {6:5g} |lose: {7:5g} |F: {8:7g} |R: {9:.10f} |avg_Q: {10:.10f} |avg_L: {11:.10f}"\
142                .format(i, j+1, loop_length, env.random_count, env.entry_count, env.win_count, env.draw_count, env.lose_count, int(float(funds)), float(reward), stat[0][1], stat[1][1]),end="\r"
143            )
144
145    if i % 1 == 0:
146        stat = agent.get_statistics()
147        # 10エピソードごとに結果を出力
148        print("ep:{0:5g} |{1:5g} / {2} |random:{3:5g} |entry: {4:5g} |win: {5:5g} |draw: {6:5g} |lose: {7:5g} |F: {8:7g} |R: {9:.10f} |avg_Q: {10:.10f} |avg_L: {11:.10f}"\
149            .format(i, j+1, loop_length, env.random_count, env.entry_count, env.win_count, env.draw_count, env.lose_count, int(float(funds)), float(reward), stat[0][1], stat[1][1])
150              )
151
152    if i % 100 == 0:
153        # 100エピソードごとにモデルを保存
154        agent.save("result_" + str(i))
155
156    done = True
157    agent.stop_episode_and_train(obs, reward, done)
158print('Finished.')

行動規範の内容に同意します

回答1件

ベストアンサー

chainerrl.explorers.LinearDecayEpsilonGreedy
をオーバーライドして

class MyGreedy(chainerrl.explorers.LinearDecayEpsilonGreedy):
def compute_epsilon(self, t):
if self.ep_counter > self.decay_steps:
return self.end_epsilon
else:
epsilon_diff = self.end_epsilon - self.start_epsilon
return self.start_epsilon + epsilon_diff * (self.ep_counter / self.decay_steps)

explorer.ep_counter = 1
を追加して

explorer.ep_counter = explorer.ep_counter + 1
1EPごとにインクリメントで実現できました。

投稿2019/09/13 10:28

退会済みユーザー

総合スコア0