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, 50):
    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(9, 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日移動

勝敗を集計すると0勝20敗となりました。

今回は全１０学習済みモデルのうち最後のモデルに関する検証となりますが、全敗してしまいました。

しかし、今回の１０モデルは全勝あり、全敗あり、勝ち越し多めの結果ありとなかなか興味深い検証となりました。

次回はこれまで行った検証結果１０回分を総括したいと思います。

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, 50):
    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(8, 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日移動

勝敗を集計すると0勝19敗1分となりました。

ほぼ全敗ですね。グラフを見るとマイナス収益の赤グラフがほとんどで残念な結果です。

ここ４回の検証結果では、交互に全敗と全勝の結果となっていてなかなか興味深いです。

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

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, 50):
    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日移動 50日移動 100日移動
150日移動 200日移動 250日移動
300日移動 350日移動 400日移動
450日移動 500日移動 550日移動
600日移動 650日移動 700日移動
750日移動 800日移動 850日移動
900日移動 950日移動

勝敗を集計すると20勝0敗となりました。

２度目の全勝です。しかも各期間の成績が前回の全勝よりも格段にいいです。

この学習済みモデルものちほど再検証しようと思います。

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

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, 50):
    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(6, 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日移動

勝敗を集計すると１７勝３敗となりました。

なかなかの勝率ですが、各期間ごとのグラフをみると勝ったり負けたりといった感じです。

ただプラス収益になる割合はおおいので学習済みモデルとしては優秀かと思います。

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

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, 50):
    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(5, 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日移動

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

前回の全勝から一転全敗となりました。

各期間ごとのグラフも真っ赤になってます。

全勝したり全敗したり同じ学習パラメータを設定してもこんなに結果が変わってしまうものなんですね、勉強になります。

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

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, 50):
    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日移動 50日移動 100日移動
150日移動 200日移動 250日移動
300日移動 350日移動 400日移動
450日移動 500日移動 550日移動
600日移動 650日移動 700日移動
750日移動 800日移動 850日移動
900日移動 950日移動

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

ここまでずっと１１勝９敗だったので、いきなりの全勝で驚いています。

各期間ごとにみると常にプラス収益というわけではないのですが、十分な投資パフォーマンスを維持しているように思えます。

この学習済みモデルはのちほど再検証する予定です。

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

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, 50):
    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(3, 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日移動

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

勝敗数はいつもと同じになりましたが、勝つときの収益率がとびぬけているような気がします。

発生率は低いのですが、この飛びぬけた投資パフォーマンスの再現性を高められれば・・・とちょっと夢がありますね。

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

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, 50):
    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(2, 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日移動

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

勝敗数は前２回の検証結果とまったく同じですが、たまに大きく収益を上げたり、大きな損失が出ることがあるモデルのようです。

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

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, 50):
    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(1, 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日移動

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

前回の検証結果と同じ勝率ですが、各検証グラフはまばらに見えます。

どうやらたまに大勝することがあるため、他の結果がまばらに見えるようです。

ギャンブルのような投資モデルですね。

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

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, 50):
    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(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日移動

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

少々勝ち越していますが、トータルイーブンといったところでしょうか。

もっと投資パフォーマンスのよいモデルが今後でてくるとよいのですが・・・

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