AnyTrading - イーサリアム投資を強化学習で実行　学習アルゴリズムACKTR（６番目）

12月31日の記事にて学習アルゴリズムACKTRでイーサリアムの学習済みモデルを１０種類作成しました。

そのうちの６番目の学習済みモデルに対して、３０回連続で投資検証を行います。

ソース

ソースは下記の通りです。

[ソース]

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
import os, gym
import datetime
import gym_anytrading
import matplotlib.pyplot as plt
from gym_anytrading.envs import TradingEnv, ForexEnv, StocksEnv, Actions, Positions
from gym_anytrading.datasets import FOREX_EURUSD_1H_ASK, STOCKS_GOOGL
from stable_baselines.common.vec_env import DummyVecEnv
from stable_baselines import PPO2
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor
from stable_baselines.common import set_global_seeds

import numpy as np
import matplotlib.pyplot as plt

# 勝敗をカウントする
def count(lst):
    cnt_win = 0
    cnt_lose = 0
    cnt_draw = 0
    for x in lst:
        if x == 0:
            cnt_draw += 1
        elif x > 0:
            cnt_win += 1
        else:
            cnt_lose += 1

    return cnt_win, cnt_lose, cnt_draw

def simulation(i, prm):
    global means
    # ログフォルダの生成
    log_dir = './logs/'
    os.makedirs(log_dir, exist_ok=True)
    # 環境の生成
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'],
                                            prm['end_idx']),
                                            window_size = prm['window_size'])
    env = Monitor(env, log_dir, allow_early_resets=True)
    # シードの指定
    env.seed(0)
    set_global_seeds(0)
    # ベクトル化環境の生成
    env = DummyVecEnv([lambda: env])
    # モデルの読み込み
    # model = PPO2.load('model{}'.format(i))
    model = ACKTR.load('model{}'.format(i))
    # モデルのテスト
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'] + prm['move_idx'],
                                            prm['end_idx']   + prm['move_idx']),
                                            window_size = prm['window_size'])
    env.seed(0)
    state = env.reset()
    while True:
        # 行動の取得
        action, _ = model.predict(state)    # 0 or 1
        # 1ステップ実行
        state, reward, done, info = env.step(action)
        # エピソード完了
        if done:
            print('info:', info, info['total_reward'])  # info: {'total_reward': 8610370000.0, 'total_profit': 1.7844206334206751, 'position': 1} 8610370000.0
            means.append(info['total_reward'])
            break
    # グラフのプロット
    plt.cla()
    env.render_all()

cnt_win = 0
cnt_lose = 0
cnt_draw = 0
#for move_idx in range(0, 801, 50):
#for move_idx in range(0, 2701, 100):
for move_idx in range(0, 1001, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   510,      #end_idx 学習データの終了位置
           'move_idx'   :   move_idx} #学習データからの移動分。移動したものを検証データとする。
    for i in range(30):
        labels.append('{}'.format(i))
        simulation(6, prm)

    x = np.arange(len(labels))
    width = 0.35

    fig, ax = plt.subplots()

    # 色の設定
    colorlist = ['r' if m < 0 else 'c' for m in means]

    rect = ax.bar(x, means, width, color=colorlist)
    ax.set_xticks(x)
    ax.set_xticklabels(labels)

    #print(means, np.average(means), count(means))
    cnt = count(means)
    plt.title('[Average]{:,.0f}  [Win]{} [Lose]{} [Draw]{}'.format(np.average(means), cnt[0], cnt[1], cnt[2]))

    plt.savefig('trading{:03d}.png'.format(move_idx))

    if cnt[0] == cnt[1]:
        cnt_draw += 1
    elif cnt[0] > cnt[1]:
        cnt_win += 1
    else:
        cnt_lose += 1

print('{}勝 {}敗 {}分'.format(cnt_win, cnt_lose, cnt_draw))

実行結果

実行結果は次のようになりました。

0日移動 50日移動 100日移動
150日移動 200日移動 250日移動
300日移動 350日移動 400日移動
450日移動 500日移動 550日移動
600日移動 650日移動 700日移動
750日移動 800日移動 850日移動
900日移動 950日移動 1000日移動

勝敗を集計するとまたまた１２勝９敗となりました。

・・・検証７回のうち６回同じ勝率となっています。

結果が変わり映えしないと、１０種類も学習済みモデルを検証している意味が薄れます。

ただ、同じパラメータで学習したモデルが比較的均一にできるのは安定感を感じます。
（別の言い方をしますと「個性がない」という表現になるかもしれません。）

次回はまた別の学習済みモデルを検証していきます。

AnyTrading - イーサリアム投資を強化学習で実行　学習アルゴリズムACKTR（５番目）

12月31日の記事にて学習アルゴリズムACKTRでイーサリアムの学習済みモデルを１０種類作成しました。

そのうちの５番目の学習済みモデルに対して、３０回連続で投資検証を行います。

ソース

ソースは下記の通りです。

[ソース]

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
import os, gym
import datetime
import gym_anytrading
import matplotlib.pyplot as plt
from gym_anytrading.envs import TradingEnv, ForexEnv, StocksEnv, Actions, Positions
from gym_anytrading.datasets import FOREX_EURUSD_1H_ASK, STOCKS_GOOGL
from stable_baselines.common.vec_env import DummyVecEnv
from stable_baselines import PPO2
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor
from stable_baselines.common import set_global_seeds

import numpy as np
import matplotlib.pyplot as plt

# 勝敗をカウントする
def count(lst):
    cnt_win = 0
    cnt_lose = 0
    cnt_draw = 0
    for x in lst:
        if x == 0:
            cnt_draw += 1
        elif x > 0:
            cnt_win += 1
        else:
            cnt_lose += 1

    return cnt_win, cnt_lose, cnt_draw

def simulation(i, prm):
    global means
    # ログフォルダの生成
    log_dir = './logs/'
    os.makedirs(log_dir, exist_ok=True)
    # 環境の生成
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'],
                                            prm['end_idx']),
                                            window_size = prm['window_size'])
    env = Monitor(env, log_dir, allow_early_resets=True)
    # シードの指定
    env.seed(0)
    set_global_seeds(0)
    # ベクトル化環境の生成
    env = DummyVecEnv([lambda: env])
    # モデルの読み込み
    # model = PPO2.load('model{}'.format(i))
    model = ACKTR.load('model{}'.format(i))
    # モデルのテスト
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'] + prm['move_idx'],
                                            prm['end_idx']   + prm['move_idx']),
                                            window_size = prm['window_size'])
    env.seed(0)
    state = env.reset()
    while True:
        # 行動の取得
        action, _ = model.predict(state)    # 0 or 1
        # 1ステップ実行
        state, reward, done, info = env.step(action)
        # エピソード完了
        if done:
            print('info:', info, info['total_reward'])  # info: {'total_reward': 8610370000.0, 'total_profit': 1.7844206334206751, 'position': 1} 8610370000.0
            means.append(info['total_reward'])
            break
    # グラフのプロット
    plt.cla()
    env.render_all()

cnt_win = 0
cnt_lose = 0
cnt_draw = 0
#for move_idx in range(0, 801, 50):
#for move_idx in range(0, 2701, 100):
for move_idx in range(0, 1001, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   510,      #end_idx 学習データの終了位置
           'move_idx'   :   move_idx} #学習データからの移動分。移動したものを検証データとする。
    for i in range(30):
        labels.append('{}'.format(i))
        simulation(5, prm)

    x = np.arange(len(labels))
    width = 0.35

    fig, ax = plt.subplots()

    # 色の設定
    colorlist = ['r' if m < 0 else 'c' for m in means]

    rect = ax.bar(x, means, width, color=colorlist)
    ax.set_xticks(x)
    ax.set_xticklabels(labels)

    #print(means, np.average(means), count(means))
    cnt = count(means)
    plt.title('[Average]{:,.0f}  [Win]{} [Lose]{} [Draw]{}'.format(np.average(means), cnt[0], cnt[1], cnt[2]))

    plt.savefig('trading{:03d}.png'.format(move_idx))

    if cnt[0] == cnt[1]:
        cnt_draw += 1
    elif cnt[0] > cnt[1]:
        cnt_win += 1
    else:
        cnt_lose += 1

print('{}勝 {}敗 {}分'.format(cnt_win, cnt_lose, cnt_draw))

実行結果

実行結果は次のようになりました。

0日移動 50日移動 100日移動
150日移動 200日移動 250日移動
300日移動 350日移動 400日移動
450日移動 500日移動 550日移動
600日移動 650日移動 700日移動
750日移動 800日移動 850日移動
900日移動 950日移動 1000日移動

勝敗を集計すると１２勝９敗となりました。

・・・検証６回のうち５回同じ勝率となっています。

やっぱり今回作成した学習済みモデルは、この「１２勝９敗」というモデルになりやすいようです。

次回はまた別の学習済みモデルを検証していきます。

AnyTrading - イーサリアム投資を強化学習で実行　学習アルゴリズムACKTR（４番目）

12月31日の記事にて学習アルゴリズムACKTRでイーサリアムの学習済みモデルを１０種類作成しました。

そのうちの４番目の学習済みモデルに対して、３０回連続で投資検証を行います。

ソース

ソースは下記の通りです。

[ソース]

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
import os, gym
import datetime
import gym_anytrading
import matplotlib.pyplot as plt
from gym_anytrading.envs import TradingEnv, ForexEnv, StocksEnv, Actions, Positions
from gym_anytrading.datasets import FOREX_EURUSD_1H_ASK, STOCKS_GOOGL
from stable_baselines.common.vec_env import DummyVecEnv
from stable_baselines import PPO2
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor
from stable_baselines.common import set_global_seeds

import numpy as np
import matplotlib.pyplot as plt

# 勝敗をカウントする
def count(lst):
    cnt_win = 0
    cnt_lose = 0
    cnt_draw = 0
    for x in lst:
        if x == 0:
            cnt_draw += 1
        elif x > 0:
            cnt_win += 1
        else:
            cnt_lose += 1

    return cnt_win, cnt_lose, cnt_draw

def simulation(i, prm):
    global means
    # ログフォルダの生成
    log_dir = './logs/'
    os.makedirs(log_dir, exist_ok=True)
    # 環境の生成
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'],
                                            prm['end_idx']),
                                            window_size = prm['window_size'])
    env = Monitor(env, log_dir, allow_early_resets=True)
    # シードの指定
    env.seed(0)
    set_global_seeds(0)
    # ベクトル化環境の生成
    env = DummyVecEnv([lambda: env])
    # モデルの読み込み
    # model = PPO2.load('model{}'.format(i))
    model = ACKTR.load('model{}'.format(i))
    # モデルのテスト
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'] + prm['move_idx'],
                                            prm['end_idx']   + prm['move_idx']),
                                            window_size = prm['window_size'])
    env.seed(0)
    state = env.reset()
    while True:
        # 行動の取得
        action, _ = model.predict(state)    # 0 or 1
        # 1ステップ実行
        state, reward, done, info = env.step(action)
        # エピソード完了
        if done:
            print('info:', info, info['total_reward'])  # info: {'total_reward': 8610370000.0, 'total_profit': 1.7844206334206751, 'position': 1} 8610370000.0
            means.append(info['total_reward'])
            break
    # グラフのプロット
    plt.cla()
    env.render_all()

cnt_win = 0
cnt_lose = 0
cnt_draw = 0
#for move_idx in range(0, 801, 50):
#for move_idx in range(0, 2701, 100):
for move_idx in range(0, 1001, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   510,      #end_idx 学習データの終了位置
           'move_idx'   :   move_idx} #学習データからの移動分。移動したものを検証データとする。
    for i in range(30):
        labels.append('{}'.format(i))
        simulation(4, prm)

    x = np.arange(len(labels))
    width = 0.35

    fig, ax = plt.subplots()

    # 色の設定
    colorlist = ['r' if m < 0 else 'c' for m in means]

    rect = ax.bar(x, means, width, color=colorlist)
    ax.set_xticks(x)
    ax.set_xticklabels(labels)

    #print(means, np.average(means), count(means))
    cnt = count(means)
    plt.title('[Average]{:,.0f}  [Win]{} [Lose]{} [Draw]{}'.format(np.average(means), cnt[0], cnt[1], cnt[2]))

    plt.savefig('trading{:03d}.png'.format(move_idx))

    if cnt[0] == cnt[1]:
        cnt_draw += 1
    elif cnt[0] > cnt[1]:
        cnt_win += 1
    else:
        cnt_lose += 1

print('{}勝 {}敗 {}分'.format(cnt_win, cnt_lose, cnt_draw))

実行結果

実行結果は次のようになりました。

0日移動 50日移動 100日移動
150日移動 200日移動 250日移動
300日移動 350日移動 400日移動
450日移動 500日移動 550日移動
600日移動 650日移動 700日移動
750日移動 800日移動 850日移動
900日移動 950日移動 1000日移動

勝敗を集計すると４勝１６敗１分となりました。

これまでと違う勝率がでましたが、負け越し過ぎで少しショックです。

各グラフの赤表示の割合が多く一目で負け越していることが分かり、グラフ表示を改善してよかったです(´;ω;｀)

次回はまた別の学習済みモデルを検証していきます。

AnyTrading - イーサリアム投資を強化学習で実行　学習アルゴリズムACKTR（３番目）

12月31日の記事にて学習アルゴリズムACKTRでイーサリアムの学習済みモデルを１０種類作成しました。

そのうちの３番目の学習済みモデルに対して、３０回連続で投資検証を行います。

ソース

ソースは下記の通りです。

[ソース]

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
import os, gym
import datetime
import gym_anytrading
import matplotlib.pyplot as plt
from gym_anytrading.envs import TradingEnv, ForexEnv, StocksEnv, Actions, Positions
from gym_anytrading.datasets import FOREX_EURUSD_1H_ASK, STOCKS_GOOGL
from stable_baselines.common.vec_env import DummyVecEnv
from stable_baselines import PPO2
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor
from stable_baselines.common import set_global_seeds

import numpy as np
import matplotlib.pyplot as plt

# 勝敗をカウントする
def count(lst):
    cnt_win = 0
    cnt_lose = 0
    cnt_draw = 0
    for x in lst:
        if x == 0:
            cnt_draw += 1
        elif x > 0:
            cnt_win += 1
        else:
            cnt_lose += 1

    return cnt_win, cnt_lose, cnt_draw

def simulation(i, prm):
    global means
    # ログフォルダの生成
    log_dir = './logs/'
    os.makedirs(log_dir, exist_ok=True)
    # 環境の生成
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'],
                                            prm['end_idx']),
                                            window_size = prm['window_size'])
    env = Monitor(env, log_dir, allow_early_resets=True)
    # シードの指定
    env.seed(0)
    set_global_seeds(0)
    # ベクトル化環境の生成
    env = DummyVecEnv([lambda: env])
    # モデルの読み込み
    # model = PPO2.load('model{}'.format(i))
    model = ACKTR.load('model{}'.format(i))
    # モデルのテスト
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'] + prm['move_idx'],
                                            prm['end_idx']   + prm['move_idx']),
                                            window_size = prm['window_size'])
    env.seed(0)
    state = env.reset()
    while True:
        # 行動の取得
        action, _ = model.predict(state)    # 0 or 1
        # 1ステップ実行
        state, reward, done, info = env.step(action)
        # エピソード完了
        if done:
            print('info:', info, info['total_reward'])  # info: {'total_reward': 8610370000.0, 'total_profit': 1.7844206334206751, 'position': 1} 8610370000.0
            means.append(info['total_reward'])
            break
    # グラフのプロット
    plt.cla()
    env.render_all()

cnt_win = 0
cnt_lose = 0
cnt_draw = 0
#for move_idx in range(0, 801, 50):
#for move_idx in range(0, 2701, 100):
for move_idx in range(0, 1001, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   510,      #end_idx 学習データの終了位置
           'move_idx'   :   move_idx} #学習データからの移動分。移動したものを検証データとする。
    for i in range(30):
        labels.append('{}'.format(i))
        simulation(3, prm)

    x = np.arange(len(labels))
    width = 0.35

    fig, ax = plt.subplots()

    # 色の設定
    colorlist = ['r' if m < 0 else 'c' for m in means]

    rect = ax.bar(x, means, width, color=colorlist)
    ax.set_xticks(x)
    ax.set_xticklabels(labels)

    #print(means, np.average(means), count(means))
    cnt = count(means)
    plt.title('[Average]{:,.0f}  [Win]{} [Lose]{} [Draw]{}'.format(np.average(means), cnt[0], cnt[1], cnt[2]))

    plt.savefig('trading{:03d}.png'.format(move_idx))

    if cnt[0] == cnt[1]:
        cnt_draw += 1
    elif cnt[0] > cnt[1]:
        cnt_win += 1
    else:
        cnt_lose += 1

print('{}勝 {}敗 {}分'.format(cnt_win, cnt_lose, cnt_draw))

実行結果

実行結果は次のようになりました。

0日移動 50日移動 100日移動
150日移動 200日移動 250日移動
300日移動 350日移動 400日移動
450日移動 500日移動 550日移動
600日移動 650日移動 700日移動
750日移動 800日移動 850日移動
900日移動 950日移動 1000日移動

勝敗を集計すると１２勝９敗となりました。

４連続で同じ勝率となってしまいました。

もしかして今回作成した学習済みモデルは、それぞれ相違がないモデルなのかもしれません。

次回はまた別の学習済みモデルを検証していきます。

AnyTrading - イーサリアム投資を強化学習で実行　学習アルゴリズムACKTR（２番目）

12月31日の記事にて学習アルゴリズムACKTRでイーサリアムの学習済みモデルを１０種類作成しました。

そのうちの２番目の学習済みモデルに対して、３０回連続で投資検証を行います。

ソース

ソースは下記の通りです。

[ソース]

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
import os, gym
import datetime
import gym_anytrading
import matplotlib.pyplot as plt
from gym_anytrading.envs import TradingEnv, ForexEnv, StocksEnv, Actions, Positions
from gym_anytrading.datasets import FOREX_EURUSD_1H_ASK, STOCKS_GOOGL
from stable_baselines.common.vec_env import DummyVecEnv
from stable_baselines import PPO2
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor
from stable_baselines.common import set_global_seeds

import numpy as np
import matplotlib.pyplot as plt

# 勝敗をカウントする
def count(lst):
    cnt_win = 0
    cnt_lose = 0
    cnt_draw = 0
    for x in lst:
        if x == 0:
            cnt_draw += 1
        elif x > 0:
            cnt_win += 1
        else:
            cnt_lose += 1

    return cnt_win, cnt_lose, cnt_draw

def simulation(i, prm):
    global means
    # ログフォルダの生成
    log_dir = './logs/'
    os.makedirs(log_dir, exist_ok=True)
    # 環境の生成
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'],
                                            prm['end_idx']),
                                            window_size = prm['window_size'])
    env = Monitor(env, log_dir, allow_early_resets=True)
    # シードの指定
    env.seed(0)
    set_global_seeds(0)
    # ベクトル化環境の生成
    env = DummyVecEnv([lambda: env])
    # モデルの読み込み
    # model = PPO2.load('model{}'.format(i))
    model = ACKTR.load('model{}'.format(i))
    # モデルのテスト
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'] + prm['move_idx'],
                                            prm['end_idx']   + prm['move_idx']),
                                            window_size = prm['window_size'])
    env.seed(0)
    state = env.reset()
    while True:
        # 行動の取得
        action, _ = model.predict(state)    # 0 or 1
        # 1ステップ実行
        state, reward, done, info = env.step(action)
        # エピソード完了
        if done:
            print('info:', info, info['total_reward'])  # info: {'total_reward': 8610370000.0, 'total_profit': 1.7844206334206751, 'position': 1} 8610370000.0
            means.append(info['total_reward'])
            break
    # グラフのプロット
    plt.cla()
    env.render_all()

cnt_win = 0
cnt_lose = 0
cnt_draw = 0
#for move_idx in range(0, 801, 50):
#for move_idx in range(0, 2701, 100):
for move_idx in range(0, 1001, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   510,      #end_idx 学習データの終了位置
           'move_idx'   :   move_idx} #学習データからの移動分。移動したものを検証データとする。
    for i in range(30):
        labels.append('{}'.format(i))
        simulation(2, prm)

    x = np.arange(len(labels))
    width = 0.35

    fig, ax = plt.subplots()

    # 色の設定
    colorlist = ['r' if m < 0 else 'c' for m in means]

    rect = ax.bar(x, means, width, color=colorlist)
    ax.set_xticks(x)
    ax.set_xticklabels(labels)

    #print(means, np.average(means), count(means))
    cnt = count(means)
    plt.title('[Average]{:,.0f}  [Win]{} [Lose]{} [Draw]{}'.format(np.average(means), cnt[0], cnt[1], cnt[2]))

    plt.savefig('trading{:03d}.png'.format(move_idx))

    if cnt[0] == cnt[1]:
        cnt_draw += 1
    elif cnt[0] > cnt[1]:
        cnt_win += 1
    else:
        cnt_lose += 1

print('{}勝 {}敗 {}分'.format(cnt_win, cnt_lose, cnt_draw))

実行結果

実行結果は次のようになりました。

0日移動 50日移動 100日移動
150日移動 200日移動 250日移動
300日移動 350日移動 400日移動
450日移動 500日移動 550日移動
600日移動 650日移動 700日移動
750日移動 800日移動 850日移動
900日移動 950日移動 1000日移動

勝敗を集計すると１２勝９敗となりました。

前回、前々回モデルと同じ勝率です。

そろそろ他の勝率となる結果がほしいところです。

次回はまた別の学習済みモデルを検証していきます。

AnyTrading - イーサリアム投資を強化学習で実行　学習アルゴリズムACKTR（１番目）※グラフ表示改善

12月31日の記事にて学習アルゴリズムACKTRでイーサリアムの学習済みモデルを１０種類作成しました。

そのうちの１番目の学習済みモデルに対して、３０回連続で投資検証を行います。

ソース

勝ち負けが見分けやすくなるように、勝った場合のグラフをシアンで負けた場合のグラフを赤で表示するように改善しました。

ソースは下記の通りです。

[ソース]

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
import os, gym
import datetime
import gym_anytrading
import matplotlib.pyplot as plt
from gym_anytrading.envs import TradingEnv, ForexEnv, StocksEnv, Actions, Positions
from gym_anytrading.datasets import FOREX_EURUSD_1H_ASK, STOCKS_GOOGL
from stable_baselines.common.vec_env import DummyVecEnv
from stable_baselines import PPO2
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor
from stable_baselines.common import set_global_seeds

import numpy as np
import matplotlib.pyplot as plt

# 勝敗をカウントする
def count(lst):
    cnt_win = 0
    cnt_lose = 0
    cnt_draw = 0
    for x in lst:
        if x == 0:
            cnt_draw += 1
        elif x > 0:
            cnt_win += 1
        else:
            cnt_lose += 1

    return cnt_win, cnt_lose, cnt_draw

def simulation(i, prm):
    global means
    # ログフォルダの生成
    log_dir = './logs/'
    os.makedirs(log_dir, exist_ok=True)
    # 環境の生成
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'],
                                            prm['end_idx']),
                                            window_size = prm['window_size'])
    env = Monitor(env, log_dir, allow_early_resets=True)
    # シードの指定
    env.seed(0)
    set_global_seeds(0)
    # ベクトル化環境の生成
    env = DummyVecEnv([lambda: env])
    # モデルの読み込み
    # model = PPO2.load('model{}'.format(i))
    model = ACKTR.load('model{}'.format(i))
    # モデルのテスト
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'] + prm['move_idx'],
                                            prm['end_idx']   + prm['move_idx']),
                                            window_size = prm['window_size'])
    env.seed(0)
    state = env.reset()
    while True:
        # 行動の取得
        action, _ = model.predict(state)    # 0 or 1
        # 1ステップ実行
        state, reward, done, info = env.step(action)
        # エピソード完了
        if done:
            print('info:', info, info['total_reward'])  # info: {'total_reward': 8610370000.0, 'total_profit': 1.7844206334206751, 'position': 1} 8610370000.0
            means.append(info['total_reward'])
            break
    # グラフのプロット
    plt.cla()
    env.render_all()

cnt_win = 0
cnt_lose = 0
cnt_draw = 0
#for move_idx in range(0, 801, 50):
#for move_idx in range(0, 2701, 100):
for move_idx in range(0, 1001, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   510,      #end_idx 学習データの終了位置
           'move_idx'   :   move_idx} #学習データからの移動分。移動したものを検証データとする。
    for i in range(30):
        labels.append('{}'.format(i))
        simulation(1, prm)

    x = np.arange(len(labels))
    width = 0.35

    fig, ax = plt.subplots()

    # 色の設定
    colorlist = ['r' if m < 0 else 'c' for m in means]

    rect = ax.bar(x, means, width, color=colorlist)
    ax.set_xticks(x)
    ax.set_xticklabels(labels)

    #print(means, np.average(means), count(means))
    cnt = count(means)
    plt.title('[Average]{:,.0f}  [Win]{} [Lose]{} [Draw]{}'.format(np.average(means), cnt[0], cnt[1], cnt[2]))

    plt.savefig('trading{:03d}.png'.format(move_idx))

    if cnt[0] == cnt[1]:
        cnt_draw += 1
    elif cnt[0] > cnt[1]:
        cnt_win += 1
    else:
        cnt_lose += 1

print('{}勝 {}敗 {}分'.format(cnt_win, cnt_lose, cnt_draw))

実行結果

実行結果は次のようになりました。

0日移動 50日移動 100日移動
150日移動 200日移動 250日移動
300日移動 350日移動 400日移動
450日移動 500日移動 550日移動
600日移動 650日移動 700日移動
750日移動 800日移動 850日移動
900日移動 950日移動 1000日移動

勝敗を集計すると１２勝９敗となりました。

前回モデルと同じ勝率です。

もしかして今回はこの辺りの勝率に収束する学習パラメータということになるのかもしれません。

次回はまた別の学習済みモデルを検証していきます。

AnyTrading - イーサリアム投資を強化学習で実行　学習アルゴリズムACKTR（０番目）

12月31日の記事にて学習アルゴリズムACKTRでイーサリアムの学習済みモデルを１０種類作成しました。

そのうちの０番目の学習済みモデルに対して、３０回連続で投資検証を行います。

ソース

ソースは下記の通りです。

[ソース]

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
import os, gym
import datetime
import gym_anytrading
import matplotlib.pyplot as plt
from gym_anytrading.envs import TradingEnv, ForexEnv, StocksEnv, Actions, Positions
from gym_anytrading.datasets import FOREX_EURUSD_1H_ASK, STOCKS_GOOGL
from stable_baselines.common.vec_env import DummyVecEnv
from stable_baselines import PPO2
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor
from stable_baselines.common import set_global_seeds

import numpy as np
import matplotlib.pyplot as plt

# 勝敗をカウントする
def count(lst):
    cnt_win = 0
    cnt_lose = 0
    cnt_draw = 0
    for x in lst:
        if x == 0:
            cnt_draw += 1
        elif x > 0:
            cnt_win += 1
        else:
            cnt_lose += 1

    return cnt_win, cnt_lose, cnt_draw

def simulation(i, prm):
    global means
    # ログフォルダの生成
    log_dir = './logs/'
    os.makedirs(log_dir, exist_ok=True)
    # 環境の生成
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'],
                                            prm['end_idx']),
                                            window_size = prm['window_size'])
    env = Monitor(env, log_dir, allow_early_resets=True)
    # シードの指定
    env.seed(0)
    set_global_seeds(0)
    # ベクトル化環境の生成
    env = DummyVecEnv([lambda: env])
    # モデルの読み込み
    # model = PPO2.load('model{}'.format(i))
    model = ACKTR.load('model{}'.format(i))
    # モデルのテスト
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'] + prm['move_idx'],
                                            prm['end_idx']   + prm['move_idx']),
                                            window_size = prm['window_size'])
    env.seed(0)
    state = env.reset()
    while True:
        # 行動の取得
        action, _ = model.predict(state)    # 0 or 1
        # 1ステップ実行
        state, reward, done, info = env.step(action)
        # エピソード完了
        if done:
            print('info:', info, info['total_reward'])  # info: {'total_reward': 8610370000.0, 'total_profit': 1.7844206334206751, 'position': 1} 8610370000.0
            means.append(info['total_reward'])
            break
    # グラフのプロット
    plt.cla()
    env.render_all()

cnt_win = 0
cnt_lose = 0
cnt_draw = 0
for move_idx in range(0, 1001, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   510,      #end_idx 学習データの終了位置
           'move_idx'   :   move_idx} #学習データからの移動分。移動したものを検証データとする。
    for i in range(30):
        labels.append('{}'.format(i))
        simulation(0, prm)

    x = np.arange(len(labels))
    width = 0.35

    fig, ax = plt.subplots()

    rect = ax.bar(x, means, width)
    ax.set_xticks(x)
    ax.set_xticklabels(labels)

    cnt = count(means)
    plt.title('[Average]{:,.0f}  [Win]{} [Lose]{} [Draw]{}'.format(np.average(means), cnt[0], cnt[1], cnt[2]))

    plt.savefig('trading{:03d}.png'.format(move_idx))

    if cnt[0] == cnt[1]:
        cnt_draw += 1
    elif cnt[0] > cnt[1]:
        cnt_win += 1
    else:
        cnt_lose += 1

print('{}勝 {}敗 {}分'.format(cnt_win, cnt_lose, cnt_draw))

実行結果

実行結果は次のようになりました。

0日移動 50日移動 100日移動
150日移動 200日移動 250日移動
300日移動 350日移動 400日移動
450日移動 500日移動 550日移動
600日移動 650日移動 700日移動
750日移動 800日移動 850日移動
900日移動 950日移動 1000日移動

勝敗を集計すると１２勝９敗となりました。

３勝ほど勝ち越してはいますが、それぞれの結果をみると完敗している期間が多く投資パフォーマンスはよくないと感じます。

次回はまた別の学習済みモデルを検証していきます。

AnyTrading - イーサリアムの投資シミュレーション（学習編）

前回イーサリアムのデータを準備したので、今回はそのデータを学習データとして参照し、学習済みモデルを１０種類作成していきます。

学習済みアルゴリズムはACKTRで、パラメータは次の一覧の通りです。

パラメータ設定値
参照すべき直前のデータ数(window_size)10
学習データの開始位置(start_idx)10
学習データの終了位置(end_idx)510
訓練ステップ数(timesteps)128000
学習アルゴリズムACKTR

ビットコインでの投資シミュレーションで、好成績を叩き出したモデルを作成したときのパラメータと同じです。

学習済みモデルの作成

学習済みモデルを作成するコードは下記の通りになります。

パラメータの内容は、コメント(41～44行目)していますのでご参照下さい。

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
import os, gym
import datetime
import gym_anytrading
import matplotlib.pyplot as plt
from gym_anytrading.envs import TradingEnv, ForexEnv, StocksEnv, Actions, Positions
from gym_anytrading.datasets import FOREX_EURUSD_1H_ASK, STOCKS_GOOGL
from stable_baselines.common.vec_env import DummyVecEnv
from stable_baselines import PPO2
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor
from stable_baselines.common import set_global_seeds

def simulation(i, prm):
    # ログフォルダの生成
    log_dir = './logs/'
    os.makedirs(log_dir, exist_ok=True)

    idx1 = prm['start_idx']
    idx2 = prm['end_idx']

    # 環境の生成
    env = gym.make('forex-v0', frame_bound=(idx1, idx2), window_size=prm['window_size'])
    env = Monitor(env, log_dir, allow_early_resets=True)

    # シードの指定
    env.seed(0)
    set_global_seeds(0)

    # ベクトル化環境の生成
    env = DummyVecEnv([lambda: env])

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

    # モデルの学習
    model.learn(total_timesteps=prm['timesteps'])

    # モデルの保存
    model.save('model{}'.format(i))

prm = {'window_size':    10,      # window_size 参照すべき直前のデータ数
       'start_idx'  :    10,      # start_idx 学習データの開始位置
       'end_idx'    :   510,      # end_idx 学習データの終了位置
       'timesteps'  :128000  }    # timesteps 訓練ステップ数
for i in range(10):
    simulation(i, prm)

上記コードを実行すると、model0.zipからmodel9.zipの１０種類の学習済みモデルが作成されます。

次回からはこのモデルでどのような投資成績を出すことができるのかを検証していきます。

AnyTrading - イーサリアムの投資シミュレーション（前準備）

今まではビットコインのデータを使って、投資シミュレーションを行ってきましたがこれからはイーサリアムのデータを使ってシミュレーションを行っていきます。

イーサリアムの時価総額は、仮想通貨の中ではビットコインに次いで第二位となっています。

ビットコインにはないスマートコントラクトという機能もあり今後ますます注目される仮想通貨だと思います。

イーサリアムデータのダウンロード

イーサリアムのcsvデータは下記のサイトからダウンロードできます。

インベスティング・ドットコム　ETH/JPY - イーサリアム 日本円

今回は、2018年02月15日から2020年12月29日までの日足データを取得しました。

イーサリアムデータの変換

イーサリアムデータをAnyTrading用に変換するソースは下記の通りです。

[ソース]

1
2
3
4
5
6
7
8
9
10
with open('(ダウンロードしたcsvファイル名)', 'r', encoding='utf-8') as f:
    lines = f.readlines()

with open('(AnyTradingインストールフォルダ)/datasets/data/FOREX_EURUSD_1H_ASK.csv', 'w') as f:
    f.write('Time,Open,High,Low,Close,Volume\n')
    for line in lines[1:]:
        ss = [s.strip('"') for s in line.split('","')]
        f.write('{}.{}.{} 00:00:00.000,{},{},{},{},0\n'.format(
                ss[0][5:7], ss[0][8:10], ss[0][0:4],
                ss[2], ss[3], ss[4], ss[1]))

次回はこのデータを使って学習済みモデルを１０種類作成します。

AnyTrading - ビットコイン投資を強化学習で実行　ACKTR編（４番目をUSDJPYで検証）

12月15日の記事にてアルゴリズムACKTRで新たにビットコインの学習済みモデルを１０種類作成しました。

そのうちの４番目の学習済みモデルが１６勝１敗ととびぬけた好成績だったので再検証してみます。

ソース

まず検証データとしては、前回の記事で準備したUSDJPYのデータを使います。

2010年1月1日の日足データから検証を開始して３０回検証を行い、次に1000日移動してまた３０回検証を行うといった処理を繰り返します。

ソースは下記の通りです。

[ソース]

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
import os, gym
import datetime
import gym_anytrading
import matplotlib.pyplot as plt
from gym_anytrading.envs import TradingEnv, ForexEnv, StocksEnv, Actions, Positions
from gym_anytrading.datasets import FOREX_EURUSD_1H_ASK, STOCKS_GOOGL
from stable_baselines.common.vec_env import DummyVecEnv
from stable_baselines import PPO2
from stable_baselines import ACKTR
from stable_baselines.bench import Monitor
from stable_baselines.common import set_global_seeds

import numpy as np
import matplotlib.pyplot as plt

# 勝敗をカウントする
def count(lst):
    cnt_win = 0
    cnt_lose = 0
    cnt_draw = 0
    for x in lst:
        if x == 0:
            cnt_draw += 1
        elif x > 0:
            cnt_win += 1
        else:
            cnt_lose += 1

    return cnt_win, cnt_lose, cnt_draw

def simulation(i, prm):
    global means
    # ログフォルダの生成
    log_dir = './logs/'
    os.makedirs(log_dir, exist_ok=True)
    # 環境の生成
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'],
                                            prm['end_idx']),
                                            window_size = prm['window_size'])
    env = Monitor(env, log_dir, allow_early_resets=True)
    # シードの指定
    env.seed(0)
    set_global_seeds(0)
    # ベクトル化環境の生成
    env = DummyVecEnv([lambda: env])
    # モデルの読み込み
    # model = PPO2.load('model{}'.format(i))
    model = ACKTR.load('model{}'.format(i))
    # モデルのテスト
    env = gym.make('forex-v0', frame_bound=(prm['start_idx'] + prm['move_idx'],
                                            prm['end_idx']   + prm['move_idx']),
                                            window_size = prm['window_size'])
    env.seed(0)
    state = env.reset()
    while True:
        # 行動の取得
        action, _ = model.predict(state)    # 0 or 1
        # 1ステップ実行
        state, reward, done, info = env.step(action)
        # エピソード完了
        if done:
            print('info:', info, info['total_reward'])  # info: {'total_reward': 8610370000.0, 'total_profit': 1.7844206334206751, 'position': 1} 8610370000.0
            means.append(info['total_reward'])
            break
    # グラフのプロット
    plt.cla()
    env.render_all()

cnt_win = 0
cnt_lose = 0
cnt_draw = 0
#for move_idx in range(0, 801, 50):
for move_idx in range(0, 2701, 100):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   510,      #end_idx 学習データの終了位置
           'move_idx'   :   move_idx} #学習データからの移動分。移動したものを検証データとする。
    for i in range(30):
        labels.append('{}'.format(i))
        simulation(4, prm)

    x = np.arange(len(labels))
    width = 0.35

    fig, ax = plt.subplots()

    rect = ax.bar(x, means, width)
    ax.set_xticks(x)
    ax.set_xticklabels(labels)

    #print(means, np.average(means), count(means))
    cnt = count(means)
    plt.title('[Average]{:,.0f}  [Win]{} [Lose]{} [Draw]{}'.format(np.average(means), cnt[0], cnt[1], cnt[2]))

    plt.savefig('trading{:03d}.png'.format(move_idx))

    if cnt[0] == cnt[1]:
        cnt_draw += 1
    elif cnt[0] > cnt[1]:
        cnt_win += 1
    else:
        cnt_lose += 1

print('{}勝 {}敗 {}分'.format(cnt_win, cnt_lose, cnt_draw))

実行結果

実行結果は次の通りです。

0日移動 100日移動 200日移動
300日移動 400日移動 500日移動
600日移動 700日移動 800日移動
900日移動 1000日移動 1100日移動
1200日移動 1300日移動 1400日移動
1500日移動 1600日移動 1700日移動
1800日移動 1900日移動 2000日移動
2100日移動 2200日移動 2300日移動
2400日移動 2500日移動 2600日移動
2700日移動

勝敗を集計すると１６勝１１敗１分となりました。

勝ち越してはいますがイマイチな結果です。。

投資成績がプラスマイナス・ゼロのデータが多いのも気になります。

やはりビットコインで学習したデータを、USDJPYのデータで検証するのは無理があるのでしょうか。

次回はイーサリアムのデータを使って検証を行ってみます。