Kaggle(2) - 統計量の算出とヒストグラム（度数分布表）の表示

統計量の算出とヒストグラム（度数分布表）の表示を試してみます。

実行環境としてGoogleさんのColaboratoryを使用します。

データの読み込み

まずは前回と同じようにタイタニックのデータセットを読み込みます。

1
2
3
4
5
6
7
8
9
import pandas as pd
import seaborn as sns
pd.options.display.max_colwidth = 2

# データ読み込み
url = 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/raw/titanic.csv'
titanic = pd.read_csv(url)

titanic.head()

統計量の算出

統計量の算出を行います。describe関数を使用します。

1
2
# 統計量の算出
titanic.describe()

データの意味は次の通りです。

名称意味
count要素の個数
mean平均
std標準偏差
min最小値
25%1/4分位数
50%中央値
75%3/4分位数
max最大値

ヒストグラム（度数分布表）の表示

年齢データ(age)のヒストグラム（度数分布表）を表示します。distplot関数を使用します。

1
2
# ヒストグラム表示
sns.distplot(titanic.age)

次回は、外れ値の判定を行います。

Kaggle(1) - 欠損値のカウントと欠損値が多い列をまるごと削除

「Kaggle」とは10万人以上のデータサイエンティストが参加するデータ分析コンペです。

コンペに参加するのに必要な分析手法を勉強していこう・・・とふと思いました。

実行環境としてGoogleさんのColaboratoryを使用します。

データの読み込み

まずはタイタニックのデータセットを読み込みます。

1
2
3
4
5
6
7
8
9
import pandas as pd
import seaborn as sns
pd.options.display.max_colwidth = 2

# データ読み込み
url = 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/raw/titanic.csv'
titanic = pd.read_csv(url)

titanic.head()

欠損値のカウント

欠損値をカウントしてパーセンテージを出力する関数を定義して、「cabin」列の欠損値の割合を求めます。

1
2
3
4
5
6
7
8
# 欠損値をカウントして、パーセンテージを出力する
def calc_missing_rate(df, v):
    total = df[v].isnull().sum()
    percent = round(total/ len(df[v]) * 100, 2)
    return pd.DataFrame([[total, percent]], columns=['total', 'percent'], index=[v])

# Cabinの欠損値の割合を確認
calc_missing_rate(titanic, 'cabin')

列をまるごとごと削除

欠損値の割合が77.1%と多かったので、「cabin」列を丸ごと削除します。

1
2
3
# Cabinを列ごと削除
titanic = titanic.drop('cabin', axis=1)   # axis=0が行データ,axis=1が列データを指定
titanic.head()

次回は、統計量の算出とヒストグラム（度数分布表）の表示を行います。

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日移動0日移動 50日移動50日移動 100日移動100日移動
150日移動150日移動 200日移動200日移動 250日移動250日移動
300日移動300日移動 350日移動350日移動 400日移動400日移動
450日移動450日移動 500日移動500日移動 550日移動550日移動
600日移動600日移動 650日移動650日移動 700日移動700日移動
750日移動750日移動 800日移動800日移動 850日移動850日移動
900日移動900日移動 950日移動950日移動 1000日移動1000日移動
1050日移動1050日移動 1100日移動1100日移動 1150日移動1150日移動
1200日移動1200日移動 1250日移動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日移動0日移動 50日移動50日移動 100日移動100日移動
150日移動150日移動 200日移動200日移動 250日移動250日移動
300日移動300日移動 350日移動350日移動 400日移動400日移動
450日移動450日移動 500日移動500日移動 550日移動550日移動
600日移動600日移動 650日移動650日移動 700日移動700日移動
750日移動750日移動 800日移動800日移動 850日移動850日移動
900日移動900日移動 950日移動950日移動 1000日移動1000日移動
1050日移動1050日移動 1100日移動1100日移動 1150日移動1150日移動
1200日移動1200日移動 1250日移動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日移動0日移動 50日移動50日移動 100日移動100日移動
150日移動150日移動 200日移動200日移動 250日移動250日移動
300日移動300日移動 350日移動350日移動 400日移動400日移動
450日移動450日移動 500日移動500日移動 550日移動550日移動
600日移動600日移動 650日移動650日移動 700日移動700日移動
750日移動750日移動 800日移動800日移動 850日移動850日移動
900日移動900日移動 950日移動950日移動 1000日移動1000日移動
1050日移動1050日移動 1100日移動1100日移動 1150日移動1150日移動
1200日移動1200日移動 1250日移動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日移動0日移動 50日移動50日移動 100日移動100日移動
150日移動150日移動 200日移動200日移動 250日移動250日移動
300日移動300日移動 350日移動350日移動 400日移動400日移動
450日移動450日移動 500日移動500日移動 550日移動550日移動
600日移動600日移動 650日移動650日移動 700日移動700日移動
750日移動750日移動 800日移動800日移動 850日移動850日移動
900日移動900日移動 950日移動950日移動 1000日移動1000日移動
1050日移動1050日移動 1100日移動1100日移動 1150日移動1150日移動
1200日移動1200日移動 1250日移動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日移動0日移動 50日移動50日移動 100日移動100日移動
150日移動150日移動 200日移動200日移動 250日移動250日移動
300日移動300日移動 350日移動350日移動 400日移動400日移動
450日移動450日移動 500日移動500日移動 550日移動550日移動
600日移動600日移動 650日移動650日移動 700日移動700日移動
750日移動750日移動 800日移動800日移動 850日移動850日移動
900日移動900日移動 950日移動950日移動 1000日移動1000日移動
1050日移動1050日移動 1100日移動1100日移動 1150日移動1150日移動
1200日移動1200日移動 1250日移動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日移動0日移動 50日移動50日移動 100日移動100日移動
150日移動150日移動 200日移動200日移動 250日移動250日移動
300日移動300日移動 350日移動350日移動 400日移動400日移動
450日移動450日移動 500日移動500日移動 550日移動550日移動
600日移動600日移動 650日移動650日移動 700日移動700日移動
750日移動750日移動 800日移動800日移動 850日移動850日移動
900日移動900日移動 950日移動950日移動 1000日移動1000日移動
1050日移動1050日移動 1100日移動1100日移動 1150日移動1150日移動
1200日移動1200日移動 1250日移動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日移動0日移動 20日移動20日移動 40日移動40日移動
60日移動60日移動 80日移動80日移動 100日移動100日移動
120日移動120日移動 140日移動140日移動 160日移動160日移動
180日移動180日移動 200日移動200日移動 220日移動220日移動
240日移動240日移動 260日移動260日移動 280日移動280日移動
300日移動300日移動 320日移動320日移動 340日移動340日移動
300日移動300日移動 320日移動320日移動 340日移動340日移動
360日移動360日移動 380日移動380日移動 400日移動400日移動
420日移動420日移動 440日移動440日移動 460日移動460日移動
480日移動480日移動 500日移動500日移動 520日移動520日移動
540日移動540日移動 560日移動560日移動 580日移動580日移動
600日移動600日移動 620日移動620日移動 640日移動640日移動
660日移動660日移動 680日移動680日移動 700日移動700日移動
720日移動720日移動 740日移動740日移動 760日移動760日移動
780日移動780日移動 800日移動800日移動 820日移動820日移動
840日移動840日移動 860日移動860日移動 880日移動880日移動
900日移動900日移動 920日移動920日移動 940日移動940日移動
960日移動960日移動 980日移動980日移動 1000日移動1000日移動

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

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

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