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

1月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
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, 1251, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   310,      #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日移動
1050日移動 1100日移動 1150日移動
1200日移動 1250日移動

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

これまでの検証した６つの学習済みモデルのうち、５モデルが１４勝１２敗という結果となっています。

今回のモデルの特徴としては各期間の投資成績が全く同じになっていることです。

安定した結果が残せているということになりますが、この勝率ではあまり嬉しくありませんね。

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

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

1月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
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, 1251, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   310,      #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日移動
1050日移動 1100日移動 1150日移動
1200日移動 1250日移動

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

これまでの検証した５つの学習済みモデルのうち、４モデルが１４勝１２敗という結果となっています。

1月31日に作成した学習済みモデルの結果はこの勝率に収束しそうです。。。

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

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

1月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
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, 1251, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   310,      #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日移動
1050日移動 1100日移動 1150日移動
1200日移動 1250日移動

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

勝率はトータルイーブンとなっていてイマイチな学習済みモデルです。

期間ごとの結果としては、勝ち負けのはっきりした（差異のない）結果となっています。

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

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

1月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
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, 1251, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   310,      #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日移動
1050日移動 1100日移動 1150日移動
1200日移動 1250日移動

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

各期間それぞれマイナス収益が優勢な結果となってしまいました。

前２回はトータルイーブンで今回は負け優勢・・・学習パラメータの学習期間を短くしただけなんですが結果はだいぶ悪くなってしまいましたね。

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

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

1月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
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, 1251, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   310,      #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日移動
1050日移動 1100日移動 1150日移動
1200日移動 1250日移動

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

この勝率は前回結果と同じで、トータルイーブンといったところです。

グラフごとに縦軸の単位が自動調整されていて分かりにくいのですが、大勝することがたまにあるのが気になります。

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

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

1月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
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, 1251, 50):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :   310,      #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()

    # 色の設定
    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日移動
1050日移動 1100日移動 1150日移動
1200日移動 1250日移動

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

ぱっとしない投資成績ですね。

グラフからも勝ったり負けたり、そしてたまに大勝したり大負けしたりと安定していません。

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

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

前回までで一通り検証を終えたのですが、もう一度だけイーサリアムのデータで学習・検証を行います。

前回結果では、全勝結果が２モデルもありなかなかの好感触だったのですが、ちょっと学習スパンが長すぎたような気がしました。

学習データと検証データが被っていると成績がよくても少々ずるいのではないかと・・・・。

そんなわけで今回は学習データのスパンだけを短く(1000→300)にしてみたいと思います。

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

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

学習済みモデルの作成

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

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

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
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 = PPO2('MlpPolicy', env, verbose=1)
    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'    :   310,      #end_idx 学習データの終了位置
       'timesteps'  :128000  }    #timesteps 訓練ステップ数
for i in range(10):
    simulation(i, prm)

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

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

AnyTrading - イーサリアム投資を強化学習で実行　学習アルゴリズムACKTR（７番目） - 全勝モデルの再検証

1月17日の記事にて学習アルゴリズム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, 20):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :  1010,      #end_idx 学習データの終了位置
           'move_idx'   :   move_idx} #学習データからの移動分。移動したものを検証データとする。
    for i in range(30):
        labels.append('{}'.format(i))
        simulation(7, 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日移動 20日移動 40日移動
60日移動 80日移動 100日移動
120日移動 140日移動 160日移動
180日移動 200日移動 220日移動
240日移動 260日移動 280日移動
300日移動 320日移動 340日移動
300日移動 320日移動 340日移動
360日移動 380日移動 400日移動
420日移動 440日移動 460日移動
480日移動 500日移動 520日移動
540日移動 560日移動 580日移動
600日移動 620日移動 640日移動
660日移動 680日移動 700日移動
720日移動 740日移動 760日移動
780日移動 800日移動 820日移動
840日移動 860日移動 880日移動
900日移動 920日移動 940日移動
960日移動 980日移動 1000日移動

勝敗を集計すると５１勝０敗となりました。

完璧な勝率はもちろん、各グラフをみてもほぼマイナス収益（赤いデータ）のない理想的な投資パフォーマンスです。

この学習済みモデルで実運用をしたらどうなるのか・・・なんとか実運用の確立をめざしたいと思います。

AnyTrading - イーサリアム投資を強化学習で実行　学習アルゴリズムACKTR（４番目） - 全勝モデルの再検証

1月17日の記事にて学習アルゴリズム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, 20):
    labels = []
    means = []
    prm = {'window_size':    10,      #window_size 参照すべき直前のデータ数
           'start_idx'  :    10,      #start_idx 学習データの開始位置
           'end_idx'    :  1010,      #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)

    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日移動 20日移動 40日移動
60日移動 80日移動 100日移動
120日移動 140日移動 160日移動
180日移動 200日移動 220日移動
240日移動 260日移動 280日移動
300日移動 320日移動 340日移動
300日移動 320日移動 340日移動
360日移動 380日移動 400日移動
420日移動 440日移動 460日移動
480日移動 500日移動 520日移動
540日移動 560日移動 580日移動
600日移動 620日移動 640日移動
660日移動 680日移動 700日移動
720日移動 740日移動 760日移動
780日移動 800日移動 820日移動
840日移動 860日移動 880日移動
900日移動 920日移動 940日移動
960日移動 980日移動 1000日移動

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

（大分長い結果にもかかわらず最後までスクロールして頂きありがとうございます）

勝率だけをみますと十分な投資パフォーマンスですが、780日移動後の結果がほぼイーブンとあまり良くない成績のように見えます。

とはいえ全体的な結果としては、実運用も可能ではないかと期待ができる学習済みモデルといって問題ないと思います。

次回はもう一つの全勝モデル（７番目の学習済みモデルを）を同じように再検証してみます。

AnyTrading - イーサリアム投資を強化学習で実行　ACKTR編（総括）

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

そのすべてのモデルに対して、３０回連続で投資検証を行った結果をまとめてみます。

結果

学習済みモデル勝敗数
０番目１１勝９敗
１番目１１勝９敗
２番目１１勝９敗
３番目１１勝９敗
４番目２０勝０敗
５番目０勝２０敗
６番目１７勝３敗
７番目２０勝０敗
８番目０勝１９敗１分
９番目０勝２０敗

全勝したり、全敗したりと結果の差が激しい１０モデルとなりました。

４番目と７番目の全勝という結果は初めての最高パフォーマンスなので、次回から再検証を行っていきます。

全敗（またはほぼ全敗）となっている３モデルは気にはなるのですが、これらの再検証はやめておきます。楽しくなさそうなので・・・。