開発記録#116(2024/10/16)MLBot開発「DDPGとLSTM」

前回の記事に引き続き、今回も仮想通貨botの開発状況をまとめていきます。

今回は「DDPGとLSTMの組み合わせ」を実行するbotを組んでみました。

今回参考にしたのは@lawn_repさんのポストです。

DDPG に LSTM 組み込んでみたけどどうやろ？ pic.twitter.com/56j3JAmmyv

— しば（Lawn） (@lawn_rep) October 13, 2024

DDPGとは

DDPG（Deep Deterministic Policy Gradient）は、連続的なアクション空間を持つ問題に対して効果的な強化学習アルゴリズムです。これは、アクター・クリティック手法の一種で、ポリシーベースと価値ベースのアプローチを組み合わせた手法です。以下にDDPGの主要な特徴と動作原理を詳しく説明します。

主要な特徴

• 連続的なアクション空間: DDPGは、ロボット制御のような連続的なアクションを必要とする環境に適しています。たとえば、ロボットの関節をどの角度に動かすか、エンジンのスロットルの位置をどの程度に設定するかなど、具体的な値を出力します。
• 決定論的ポリシー: DDPGは確率的ではなく決定論的なポリシーを使用します。これにより、与えられた状態で常に同じ行動を選択し、ノイズなどの外部要因がない限り同じ結果が得られます。

動作原理

DDPGは以下の主要なコンポーネントから構成されます。

1. アクターネットワーク:
   • アクターモデルは、現在の環境の状態から行動を直接生成します。このモデルはニューラルネットワークであり、最適な行動を推定するために訓練されます。
2. クリティックネットワーク:
   • クリティックモデルは、取られた行動の価値を評価します。具体的には、ある状態で特定の行動をとった場合の期待されるリターンを出力します。このモデルもニューラルネットワークで構築されます。
3. ターゲットネットワーク:
   • 安定した学習のために、アクターとクリティックのそれぞれにターゲットネットワークが用意されます。これらのネットワークは本来のネットワークのコピーであり、定期的に元のネットワークから少しずつパラメータが更新されます（ソフトアップデート）。これにより、学習過程が安定し、収束しやすくなります。
4. リプレイバッファー:
   • 学習データのサンプリングのバイアスを減少させるために、経験リプレイバッファーを使用します。エージェントの経験（状態、行動、報酬、新しい状態）はバッファーに保存され、学習のたびにランダムにサンプリングされて使用されます。

学習プロセス

DDPGの学習プロセスでは、クリティックネットワークを用いて行動の価値を推定し、この情報を基にアクターネットワークを更新していきます。目的は、最終的な報酬を最大化する行動を選択できるようにすることです。

DDPGはその柔軟性と効率のよさから、多くの実用的なアプリケーションで使用されており、特に高次元のアクションスペースを持つ問題に対して有効です。

DDPGとLSTMの組み合わせ

DDPG（Deep Deterministic Policy Gradient）をLSTM（Long Short-Term Memory）と組み合わせることで、主に時間的な特徴を捉える能力が強化されます。これは特に、時間的なダイナミクスが重要な役割を果たす環境において有効です。以下に具体的なメリット、デメリット、および他の有効な手法の組み合わせを説明します。

メリット

• 時間的連続性の把握: LSTMは過去の情報を記憶する能力に優れているため、連続したデータポイント間の関連性やパターンを捉えることができます。これにより、DDPGが与えられた状態だけでなく、その状態に至るまでの経緯を理解するのに役立ちます。
• 非定常環境への適応: 金融市場のようにデータの分布が時間とともに変化する場合、LSTMは過去のトレンドを記憶し、その変動をモデル化するのに有効です。

デメリット

• 計算コスト: LSTM層を追加することで、モデルのパラメータ数が増加し、学習に必要な計算資源が増大します。
• 過学習のリスク: 過去のデータに過度に適合することで、新しい未知のデータや状況に対する汎化性能が低下する可能性があります。

最適な使用環境

• LSTMを組み込んだDDPGは、特に時間的な情報が重要な役割を果たす環境（例えば、株式や為替の取引、エネルギー管理システムなど）で有効です。

仮想通貨bot開発における優位性

仮想通貨の自動取引botを作る際にDDPG（Deep Deterministic Policy Gradient）とLSTM（Long Short-Term Memory）を組み合わせることにはいくつかの明確な優位性があります。仮想通貨市場は非常にボラティリティが高く、価格動向に影響を与える要因が多岐にわたるため、これらの技術を利用することでより精度の高い取引戦略が実現可能です。

優位性の詳細

1. 時間的特徴の把握:
   • LSTMの利点: LSTMは時系列データの長期的な依存関係を学習する能力に優れています。仮想通貨の価格データは時間と共に変化するため、過去の価格変動パターンから現在及び未来の価格変動を予測するのにLSTMは非常に有効です。
   • DDPGの役割: DDPGは決定論的なポリシーを提供し、与えられた状態で最適な行動を学習します。LSTMによって提供されたリッチな時系列特徴を活用して、より効果的な取引決定を行うことができます。
2. 非定常市場への適応性:
   • 仮想通貨市場はその性質上、急激なトレンドの変更や価格の急騰・急落が頻繁に起こります。LSTMはこれらの変動を過去のデータから学習し、DDPGのアクション選択においてこれを考慮することで、市場の急変に迅速かつ適切に反応する取引戦略を形成します。
3. リスク低減:
   • 自動取引botでは、潜在的な損失を最小化しつつ利益を最大化することが求められます。LSTMとDDPGの組み合わせは、市場の不確実性をモデル化し、高リスクの状況を避けながら利益を確保する戦略を学習するのに有効です。LSTMが過去のデータトレンドを通じてリスク要因を識別し、DDPGがそれを基に最適な取引アクションを選択します。

実装上の考慮事項

• データ前処理: LSTMを効果的に使用するためには、入力データの正規化が重要です。価格データを適切にスケーリングすることで、ネットワークの学習効率とパフォーマンスが向上します。
• ハイパーパラメータのチューニング: LSTMとDDPGの両方で使用されるハイパーパラメータ（例えば、隠れ層の数やユニット数、学習率など）の適切な設定が求められます。これらのパラメータは市場データの特性や学習の目的に応じて慎重に選択する必要があります。
• 計算資源: LSTMとDDPGの組み合わせは計算コストが高いため、十分な計算リソースが必要です。特にリアルタイム取引を目指す場合、高速な処理能力が求められることがあります。

以上のように、DDPGとLSTMを組み合わせることで、時間的ダイナミクスを重視する仮想通貨市場において、より洗練された取引戦略の実現が可能になります。これにより、市場の変動を利用した効率的な取引が期待できます。

ここまでのまとめ

DDPG（Deep Deterministic Policy Gradient）とLSTM（Long Short-Term Memory）を組み合わせて仮想通貨の自動取引botを構築すると、以下のような主要な利点があります：

1. 時間的特徴の把握:
   • LSTMは過去の価格変動のパターンを捉え、それを基に未来の価格動向を予測するのに有効です。
   • DDPGはこの情報を利用して、与えられた状態で最適な取引行動を学習します。
2. 非定常市場への適応:
   • LSTMによる過去データの学習を通じて、急激な市場の変動を予測し、DDPGがこれに基づいて適切な行動を決定します。
3. リスク低減:
   • 組み合わせにより、リスクを識別し避けつつ、利益を最大化する取引戦略を形成することが可能です。

これらの技術を活用することで、仮想通貨市場の複雑な動きを解析し、リアルタイムで効果的な取引判断を下す能力を高めることができます。ただし、適切なデータ前処理、ハイパーパラメータのチューニング、そして十分な計算リソースが必要です。

コードの雛形

#必要なライブラリのインポート
import numpy as np
import pandas as pd
from datetime import datetime
import gym
from gym import spaces
import tensorflow as tf
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Dense, LSTM, Input, concatenate
from tensorflow.keras.optimizers import Adam
import random
from collections import deque

#取引環境の定義
class TradingEnv(gym.Env):
    def __init__(self, df):
        super(TradingEnv, self).__init__()
        self.df = df
        self.n_features = df.shape[1]
        self.action_space = spaces.Box(low=np.array([0, 0]), high=np.array([1, 1]), dtype=np.float32)
        self.observation_space = spaces.Box(low=0, high=1, shape=(self.n_features,), dtype=np.float32)
        self.current_step = 0

    def step(self, action):
        self.current_step += 1
        done = self.current_step >= len(self.df) - 1
        current_price = self.df.iloc[self.current_step]['close']
        previous_price = self.df.iloc[self.current_step - 1]['close']
        reward = (current_price - previous_price) * (action[0] - action[1])
        next_state = self.df.iloc[self.current_step].values / self.df.max().values
        return next_state, reward, done, {}

    def reset(self):
        self.current_step = 0
        return self.df.iloc[self.current_step].values / self.df.max().values

    def render(self, mode='human', close=False):
        pass

#DDPGエージェントの定義
class DDPGAgent:
    def __init__(self, state_size, action_size):
        self.state_size = state_size
        self.action_size = action_size
        self.memory = deque(maxlen=10000)
        self.gamma = 0.95  # discount rate
        self.epsilon = 1.0  # exploration rate
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.actor_model = self.build_actor()
        self.critic_model = self.build_critic()
        self.actor_optimizer = Adam(learning_rate=0.001)
        self.critic_optimizer = Adam(learning_rate=0.002)

    def build_actor(self):
        inputs = Input(shape=(self.state_size,))
        out = Dense(64, activation='relu')(inputs)
        out = Dense(64, activation='relu')(out)
        outputs = Dense(self.action_size, activation='sigmoid')(out)
        model = Model(inputs, outputs)
        return model

    def build_critic(self):
        state_input = Input(shape=(self.state_size,))
        action_input = Input(shape=(self.action_size,))
        concatenated = concatenate([state_input, action_input])
        out = LSTM(64, return_sequences=True)(concatenated)
        out = LSTM(32)(out)
        outputs = Dense(1, activation='linear')(out)
        model = Model([state_input, action_input], outputs)
        return model

    def act(self, state):
        if np.random.rand() <= self.epsilon:
            return np.random.uniform(0, 1, 2)
        act_values = self.actor_model.predict(state[None])[0]
        return act_values

    def remember(self, state, action, reward, next_state, done):
        self.memory.append((state, action, reward, next_state, done))

    def replay(self, batch_size):
        minibatch = random.sample(self.memory, batch_size)
        for state, action, reward, next_state, done in minibatch:
            target = reward
            if not done:
                target = reward + self.gamma * np.amax(self.critic_model.predict([next_state[None], self.actor_model.predict(next_state[None])])[0])
            target_f = self.critic_model.predict([state[None], action[None]])[0]
            self.critic_model.fit([state[None], action[None]], target_f, epochs=1, verbose=0)
            a_for_grad = self.actor_model.predict(state[None])
            grads = np.array(self.critic_model.predict([state[None], a_for_grad])[0])  # Dummy gradient calculation
            self.actor_optimizer.apply_gradients(zip(grads, self.actor_model.trainable_variables))

        if self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay

#トレーニングループの実行
def train(agent, env, episodes=500, batch_size=32):
    for e in range(episodes):
        state = env.reset()
        total_reward = 0
        done = False
        while not done:
            action = agent.act(state)
            next_state, reward, done, _ = env.step(action)
            agent.remember(state, action, reward, next_state, done)
            agent.replay(batch_size)
            state = next_state
            total_reward += reward
        print(f'Episode: {e+1}, Total Reward: {total_reward}')

#データの準備とエージェントの初期化
data = pd.read_csv('your_cryptocurrency_data.csv')  # 'close'列が必要
env = TradingEnv(data)
agent = DDPGAgent(state_size=data.shape[1], action_size=2)
train(agent, env)

こちらのコードは、DDPG（Deep Deterministic Policy Gradient）とLSTM（Long Short-Term Memory）ネットワークを用いた仮想通貨の自動取引システムです。各コンポーネントの役割とその動作を以下に詳しく説明します。

1. 取引環境 (TradingEnv)

このクラスはOpenAI Gymの環境を継承しており、仮想通貨の取引シミュレーションのための基盤を提供します。以下のメソッドに分かれています：

• __init__(self, df): 環境を初期化します。ここでデータフレーム（df）を受け取り、取引に使用する市場データを設定します。
• step(self, action): エージェントが選択したアクションを受け取り、次の状態を返します。報酬は前の価格と現在の価格の差に基づいて計算され、取引が「売る」か「買う」かに依存します。
• reset(self): エピソードが終了した際に環境をリセットし、初期状態を返します。
• render(self, mode='human', close=False): 環境の現状を可視化するためのメソッドですが、この例では実装されていません。

2. DDPGエージェント (DDPGAgent)

このクラスはDDPGアルゴリズムを実装し、自動取引を行うための決定を行います：

• __init__(self, state_size, action_size): エージェントの初期設定を行います。ニューラルネットワーク（アクターとクリティック）の構築、学習率、探索率（epsilon）などが設定されます。
• build_actor(self): アクターネットワークを構築します。このネットワークは状態を受け取り、取引のアクション（連続値）を出力します。
• build_critic(self): クリティックネットワークを構築します。このネットワークは状態とアクションのペアを受け取り、そのアクションの価値（Q値）を評価します。
• act(self, state): 現在の状態に基づいてアクションを決定します。探索と利用のバランスを取るためにepsilon-greedy戦略を使用します。
• remember(self, state, action, reward, next_state, done): 経験をメモリに保存します。これらは後で学習に再利用されます。
• replay(self, batch_size): メモリからランダムにサンプルを取り出し、学習（経験再生）を行います。この中でアクターとクリティックのネットワークが更新されます。

3. トレーニングループ (train)

この関数はエージェントのトレーニングプロセスを制御します：

• train(agent, env, episodes=500, batch_size=32): 指定されたエピソード数でトレーニングを行います。各エピソードで環境をリセットし、エージェントがアクションを選択し、環境を更新し、報酬を受け取り、エージェントがその経験を記憶し、ニューラルネットワークを更新します。

関連する構造

• アクターとクリティックネットワーク：アクターは最適なアクションを推定し、クリティックはそのアクションの価値を評価します。これらの相互作用により、ポリシーと価値関数が同時に更新されます。
• 環境とエージェントのインタラクション：エージェントが環境から状態を受け取り、アクションを決定し、環境がそのアクションに基づいて次の状態と報酬をエージェントに提供します。このサイクルがトレーニングプロセスを通じて続きます。
• 経験再生：ランダムに選ばれた過去の経験を使って学習することで、サンプルの相関を減少させ、学習プロセスを安定させます。

このプログラムは、仮想通貨市場での自動取引を実現するための一つのアプローチであり、さまざまな調整とテストを必要とします。

ライブラリのインポート

numpy:NumPy は、Pythonで数値計算を行う基本的なライブラリです。多次元配列オブジェクトやこれを扱うための様々な派生オブジェクト（例えば、マスクされた配列や行列）を提供し、配列操作や数学関数の実行が可能です。このコードでは、配列操作や数学的計算にNumPyが使われています。

pandas:Pandas は、データ分析を支援する機能を提供するライブラリです。データ構造には、1次元のSeries、2次元のDataFrameがあります。これらは時系列データや表（スプレッドシート）データを扱うのに適しており、データの読み込み、加工、集約処理などを容易に行えます。

datetime:datetime モジュールは、日付や時刻を操作するためのクラスを提供します。datetime クラスを使用することで、プログラム内で日時情報を表現し、操作することができます。

gym:OpenAI Gym は強化学習アルゴリズムの開発と評価のためのツールキットです。gym ライブラリを使用することで、様々な種類の環境でエージェントを訓練するための標準的なインターフェースを提供します。spaces は、アクションや観測が取れる範囲（スペース）を定義するために使用されます。

tensorflow:TensorFlow は、ディープラーニングや機械学習モデルを構築、訓練、デプロイするためのオープンソースライブラリです。Keras はTensorFlowの上に構築された高レベルのAPIで、モデルの構築を簡単に行えます。Sequential と Model はモデルのアーキテクチャを定義するために使用され、Dense, LSTM, Input, concatenate はモデル内の異なる層を表します。Adam は最適化アルゴリズムの一つで、ニューラルネットワークの訓練に使用されます。

random:random モジュールは、乱数を生成するための関数を提供します。このコードでは、バッチ学習中に経験をランダムにサンプリングするために使用されている可能性があります。

collections:collections モジュールは、特殊なデータ構造を提供します。deque（デック）は、両端からデータの追加や削除が高速に行えるリスト型のデータ構造で、強化学習での経験再生バッファとして利用されます。これにより、効率的なデータ管理とランダムアクセスが可能になります。

取引環境の定義

TradingEnv クラスはOpenAI Gymフレームワークを使って設計された、仮想通貨取引戦略のシミュレーション環境を提供します。ここでは、このクラスが何を行っているかを一つずつ説明します。

コンストラクタ: __init__(self, df)

• df: このパラメータはpandasのDataFrameで、取引データ（例えば歴史的価格データ）を含みます。
• self.df: インスタンス内でDataFrameを保存し、将来的に使用します。
• self.n_features: DataFrameの特徴量の数を数え、観測空間の次元数を決定します。
• self.action_space: エージェントが取ることのできる行動の空間を定義します。ここではエージェントには2次元の連続値行動が可能で、それぞれの値は0から1の範囲です。これらの行動は、どれだけの量を買うか、売るかを表している可能性があります。
• self.observation_space: エージェントが受け取る可能性のある観測値の空間を定義します。これは0から1までの範囲で正規化されたDataFrameの行を基にしています。
• self.current_step: 現在のステップ数を追跡するカウンターです。これにより、データセットを通じてどこに位置しているかを管理します。

ステップ関数: step(self, action)

• action: エージェントによって取られた行動。このコンテキストでは2つの連続値が含まれ、それぞれの値が買いまたは売りの強度を表します。
• この関数は環境を一つのタイムステップ前進させます。
• self.current_step: 現在のステップ数を1増やします。
• done: シミュレーションが終了したかどうかを示すブール値。DataFrameの最後に達したかどうかで決定されます。
• current_price と previous_price: 現在と前のステップの価格を取得し、報酬の計算に使用します。
• reward: 報酬は現在価格と前価格の差によって計算され、行動の結果（買いアクションと売りアクションの差）に基づいて調整されます。
• next_state: 次の状態は、現在のステップのDataFrameの行を最大値で正規化して得られます。
• 返り値は次の状態、計算された報酬、終了フラグ、追加情報を含む辞書（ここでは空）です。

リセット関数: reset(self)

• この関数は新しいエピソードのために環境を初期状態にリセットします。
• self.current_step: ステップカウンターを0にリセットします。
• 初期状態を返します。これはDataFrameの最初の行を最大値で正規化したものです。

レンダー関数: render(self, mode='human', close=False)

• レンダリング関数は環境の現在の状態を可視化するためのものです。この実装では機能が実装されておらず、passとなっているため何も行われません。実際のアプリケーションでは、この関数を拡張して取引の状態や行動、その他の情報をグラフィカルに表示することが可能です。

DDPGエージェントの定義

DDPGAgent クラスは、Deep Deterministic Policy Gradient (DDPG) アルゴリズムを使用するエージェントを実装しています。DDPGは強化学習の一形態で、連続的な行動空間に適しています。このクラスの機能は以下の通りです：

コンストラクタ: __init__(self, state_size, action_size)

• パラメータ:
  • state_size: 状態のサイズ（特徴量の数）を指定します。
  • action_size: 行動のサイズ（エージェントが取ることができる行動の次元数）を指定します。
• 機能:
  • self.memory: エピソードから得られた経験を保存するためのデキュー（最大長10,000）を初期化します。
  • self.gamma: 割引率です。将来の報酬を現在の価値にどれだけ割り引くかを示します。
  • self.epsilon: 探索率です。ランダムに行動する確率を示し、学習初期は高く設定されています。
  • self.epsilon_min と self.epsilon_decay: epsilon の最小値と減衰率です。学習が進むにつれて epsilon はこの値まで減少します。
  • self.actor_model と self.critic_model: 行動を選択するためのアクターモデルと、行動の価値を評価するためのクリティックモデルを構築します。
  • オプティマイザ: アクターとクリティックの学習に使用されるオプティマイザを設定します。

アクターモデル構築: build_actor()

• 入力層に状態サイズを指定し、2つの隠れ層（それぞれ64ユニット）をReLU活性化関数で処理後、出力層では行動サイズに基づいてシグモイド活性化関数を使用しています。これにより、行動の値を [0, 1] の範囲で出力します。

クリティックモデル構築: build_critic()

• 状態と行動を入力として受け取り、それらを結合してLSTM層を通過させ、最終的に線形活性化関数を持つ出力層から行動の価値（Q値）を出力します。

行動選択: act(self, state)

• 現在の状態に基づいて、アクターモデルを使用して行動を選択します。epsilon の値に基づいて、時にはランダムに行動を選択することもあります（探索）。

経験記憶: remember(self, state, action, reward, next_state, done)

• 取得した状態、行動、報酬、次の状態、およびエピソードが終了したかどうかの情報をメモリに保存します。

経験再生: replay(self, batch_size)

• メモリからランダムにサンプルを取り出し、それらを使ってモデルを訓練します。訓練データは、現在の報酬と割引された未来の最大報酬を合わせて目標値を設定し、クリティックモデルを更新します。また、アクターモデルも更新され、ポリシーが改善されます。

トレーニングループの実行

train 関数は、DDPGエージェントを使って仮想通貨取引環境で学習を行うためのものです。以下、この関数が行っている処理について詳しく説明します。

train関数の定義

• パラメータ:
  • agent: 学習を行うエージェント（DDPGAgentクラスのインスタンス）。
  • env: エージェントが操作する環境（TradingEnvクラスのインスタンス）。
  • episodes: エージェントが学習を行うエピソードの総数。デフォルトは500。
  • batch_size: 経験再生の際に使用するバッチサイズ。デフォルトは32。

学習プロセス

• エピソードループ:
  • for e in range(episodes): 指定されたエピソード数だけ学習プロセスを繰り返します。
• エピソード開始時の初期化:
  • state = env.reset(): 各エピソードの開始時に環境をリセットし、初期状態を取得します。
  • total_reward = 0: そのエピソードで獲得した総報酬を追跡するための変数を0に初期化します。
  • done = False: エピソードが終了したかどうかを示すフラグ。まだ終了していないため、Falseに設定します。
• ステップループ:
  • while not done: エピソードが終了するまで（doneがTrueになるまで）以下のステップを繰り返します。
    • action = agent.act(state): 現在の状態に基づいて、エージェントが行動を選択します。
    • next_state, reward, done, _ = env.step(action): 選択した行動を環境に適用し、次の状態、その行動による報酬、エピソードが終了したかどうかの情報を取得します。
    • agent.remember(state, action, reward, next_state, done): 経験（状態、行動、報酬、次の状態、終了フラグ）をエージェントのメモリに保存します。
    • agent.replay(batch_size): メモリからランダムに選ばれた経験を用いて、ネットワーク（アクターとクリティック）を訓練します。
    • state = next_state: 状態を更新します。
    • total_reward += reward: 獲得した報酬を総報酬に加算します。
• エピソード終了後の処理:
  • print(f'Episode: {e+1}, Total Reward: {total_reward}'): エピソードが終了するたびに、そのエピソードの番号と獲得した総報酬を出力します。

データの準備とエージェントの初期化

このコードは、仮想通貨取引のための自動取引エージェント（DDPGエージェント）をトレーニングするためのプロセスをセットアップしています。以下、各行が何をしているのかを日本語で詳しく説明します。

データの読み込み

data = pd.read_csv('your_cryptocurrency_data.csv')  # 'close'列が必要

この行は、仮想通貨の価格データが格納されたCSVファイルを読み込みます。ここで重要なのは、DataFrameに「close」という名前の列が含まれている必要があります。これは通常、その日の取引終了時の価格を示しており、取引戦略の決定に用いられます。

環境の初期化

env = TradingEnv(data)

TradingEnv クラスのインスタンスを作成します。この環境は、上記で読み込んだデータを基にして仮想通貨の取引シミュレーションを行うためのものです。エージェントがこの環境内で行動を選択し、その結果として得られる状態の変化や報酬を通じて学習します。

エージェントの初期化

agent = DDPGAgent(state_size=data.shape[1], action_size=2)

DDPGAgent クラスのインスタンスを作成します。このエージェントは、環境から得られる情報（状態）を元に最適な行動を学びます。state_size はデータの特徴量の数を指定しており、action_size はエージェントが取ることのできる行動の種類（この場合は2つ、おそらく「買う」「売る」の行動）を意味します。

トレーニングの実行

train(agent, env)

train 関数を呼び出して、初期化したエージェントを使用し、設定した環境で学習を行います。このプロセスでは、エージェントが複数のエピソードを通じて取引戦略を試し、その結果を基に学習を進め、行動選択能力を向上させます。

まとめ

今回は「DDPGとLSTMの組み合わせ」を実行するbotを組んでみました。

ML系のbotはできることが多くてあれもこれもと手を出しがちになりそうです。

しかし、"基礎的なものから一つずつ取り組むことで発展的な技術を身につける"ことを意識して、確実に理解していきたいです。

また、発展的なことを実装させる過程で基礎的な概念や技術の理解を効率良く進めることができるということも実感しています。

今後もこの調子で、開発や研究の過程を発信していきます。

宿題