Freenove ESP32-WROVER Board CAMを購入しました。

FreenoveのESP32-WROVERボードは、さまざまな電子プロジェクトや教育目的でよく使用されるマイクロコントローラーボードです。このボードはESP32チップセットを搭載しており、Wi-FiとBluetoothの機能を内蔵しています。Freenoveは通常、そのようなボードとともに詳細なチュートリアルやプロジェクトガイドを提供しているので、プログラミングや電子工学の初心者にも扱いやすいです。

アップロードされた画像

画像に写っているのはFreenoveのESP32-WROVERボードとUSBケーブル、そして小型のカメラモジュールです。ESP32-WROVERはWi-FiとBluetoothを内蔵した強力なマイクロコントローラで、さまざまなIoT（モノのインターネット）アプリケーションに適しています。このボードには、外部機器やGPIOピンを接続するための複数のインターフェースがあります。

同梱されているカメラモジュールが示しているように、このキットは画像の取得や処理に関わるアプリケーションに使用することができます。これには、自宅の監視カメラ、QRコードリーダー、AIを組み込んだ物体認識タスクなどの進んでいて興味深いプロジェクトが含まれます。

このボードを使用するには以下の手順を通常踏みます：

USBケーブルを使ってコンピュータに接続します。
Arduino IDEやEspressifのESP-IDFなど、必要なドライバと開発環境をコンピュータにインストールします。
開発環境を設定して、ESP32-WROVERボードを認識させます。
カメラや他の接続されたセンサーやデバイスを制御するためのファームウェアでボードをプログラミングし始めます。

FreenoveのESP32-WROVERボードとカメラモジュールの使用を開始するための手順を詳しく説明します。

1. ハードウェアの接続

ESP32ボードをコンピューターにUSBケーブルで接続します。
カメラモジュールをボードのカメラインターフェースに接続します。

2. 開発環境の準備

Arduino IDEをダウンロードしてインストールします。（Arduino公式サイトから入手できます。）
Arduino IDEを起動し、[ファイル] > [環境設定] で「追加のボードマネージャのURL」にESP32のボードマネージャのURLを追加します。
- 通常は https://dl.espressif.com/dl/package_esp32_index.json を使用します。
[ツール] > [ボード] > [ボードマネージャ]を開き、「ESP32」と検索して、出てきたリストからESP32 by Espressif Systemsをインストールします。

3. ボードとポートの選択

ツールメニューからボードを「ESP32 Wrover Module」に設定します。
正しいCOMポートを選択します（Windowsの場合は「COMx」と表示され、Macの場合は「/dev/cu.xxxxx」と表示されます）。どれがESP32ボードに割り当てられているかは、ボードを接続してArduino IDEの[ツール] > [ポート]を見ることで確認できます。

4. プログラムの書き込み

サンプルプログラムを開きます。[ファイル] > [サンプル] > [ESP32] > [Camera]などから、カメラを使用するサンプルプログラムを選ぶことができます。
サンプルプログラムをボードに合わせて必要に応じて修正します。例えば、Wi-Fi設定やカメラモジュールのピン設定などがあります。
プログラムをボードにアップロードします。[スケッチ] > [アップロード]を選択するか、ツールバーの右矢印のアイコンをクリックします。

5. シリアルモニタの使用

プログラムによっては、シリアルモニタを通じてボードからの出力を見る必要があるかもしれません。[ツール] > [シリアルモニタ]を開いて確認します。

6. カメラの動作確認

サンプルプログラムがカメラの映像をウェブサーバーにストリーミングするものであれば、ボードが提供するIPアドレスにウェブブラウザからアクセスして映像を確認します。

トラブルシューティング

もしプログラムのアップロードやボードの動作に問題がある場合は、エラーメッセージを確認してトラブルシューティングの手順を行います。ボードが認識されない、アップロードに失敗するなどの問題が起きた時は、ドライバの問題やUSBケーブルの問題など様々な原因が考えられます。

このメッセージは、ESP32へのスケッチのアップロードが成功したことを示しています。ここで表示されているのは、プログラム（スケッチ）がフラッシュメモリに書き込まれ、その後、書き込まれたデータが検証されたというプロセスのログです。

プロセスの要点をまとめると以下の通りです：

esptool.py：これはESP32ボードにスケッチをアップロードするために使われるPythonスクリプトです。
COMポートの確認：シリアルポートが認識され、COM6が使用されています。
ボードの情報の取得：ESP32-D0WD-V3 チップの詳細な情報が取得され、この情報にはクリスタルの周波数やMACアドレスも含まれています。
スタブのアップロード：アップロードプロセス中に使用される一時的なプログラムであるスタブがボードにアップロードされています。
ボーレートの変更：アップロードの速度を上げるために、ボーレートがデフォルトから921600に変更されています。
フラッシュサイズの設定：アップロードするプログラムのサイズに基づいてフラッシュメモリのどの部分を消去するかが設定されています。
データのアップロード：様々なセクションへのデータの書き込みが成功し、それぞれのセクションのハッシュが検証されています。
アップロード完了とリセット：全てのデータのアップロードが終了し、ボードはハードリセットを行っています。

このログによれば、アップロードは正常に完了しており、ESP32ボードはリセットされて通常通り動作する準備が整っています。これであなたのスケッチがESP32デバイス上で実行されるはずです。プログラムが意図したとおりに動作しているかを確認するためには、シリアルモニタを開いて出力を確認するか、その他のデバッグ手段を用いる必要があります。

/*
  フェード

  この例では、analogWrite()関数を使用してピン9に接続されたLEDをフェードさせる方法を示します。

  analogWrite()関数はPWMを使用しますので、使用するピンを変更する場合は、
  別のPWM対応ピンを使用してください。ほとんどのArduinoでは、PWMピンは"~"記号で
  識別されます。例えば ~3, ~5, ~6, ~9, ~10, ~11 などです。

  この例のコードはパブリックドメインです。

  https://www.arduino.cc/en/Tutorial/BuiltInExamples/Fade
*/

int led = 9;         // LEDが接続されているPWMピン
int brightness = 0;  // LEDの明るさ
int fadeAmount = 5;  // LEDをフェードさせるポイントの数

// setupルーチンは、リセットを押すと一度だけ実行されます：
void setup() {
  // ピン9を出力として宣言します：
  pinMode(led, OUTPUT);
}

// loopルーチンは永遠に何度も実行されます：
void loop() {
  // ピン9の明るさを設定します：
  analogWrite(led, brightness);

  // 次回のループでの明るさを変更します：
  brightness = brightness + fadeAmount;

  // フェードの端でフェードの方向を逆にします：
  if (brightness <= 0 || brightness >= 255) {
    fadeAmount = -fadeAmount;
  }
  // 調光効果を確認するために30ミリ秒待ちます
  delay(30);
}

フェード

この例では、analogWrite()関数を使用してピン9に接続されたLEDをフェードさせる方法を示します。

analogWrite()関数はPWMを使用しますので、使用するピンを変更する場合は、

別のPWM対応ピンを使用してください。ほとんどのArduinoでは、PWMピンは"~"記号で

識別されます。例えば ~3, ~5, ~6, ~9, ~10, ~11 などです。

この例のコードはパブリックドメインです。

https://www.arduino.cc/en/Tutorial/BuiltInExamples/Fade

int led = 9; // LEDが接続されているPWMピン

int brightness = 0; // LEDの明るさ

int fadeAmount = 5; // LEDをフェードさせるポイントの数

// setupルーチンは、リセットを押すと一度だけ実行されます：

void setup() {

// ピン9を出力として宣言します：

pinMode(led, OUTPUT);

}

// loopルーチンは永遠に何度も実行されます：

void loop() {

// ピン9の明るさを設定します：

analogWrite(led, brightness);

// 次回のループでの明るさを変更します：

brightness = brightness + fadeAmount;

// フェードの端でフェードの方向を逆にします：

if (brightness <= 0 || brightness >= 255) {

fadeAmount = -fadeAmount;

}

// 調光効果を確認するために30ミリ秒待ちます

delay(30);

}

LEDをArduinoに接続する基本的な方法は次のとおりです：

LEDの極性を確認する： LEDにはアノード（長い足、プラス側）とカソード（短い足、マイナス側）があります。
抵抗を使用する： LEDを直接Arduinoのピンに接続すると、過剰な電流でLEDが壊れる可能性があります。そのため、適切な抵抗（一般的には220Ωから1kΩ）をシリーズに接続して電流を制限します。
接続：
- アノード（長い足）をArduinoのデジタル出力ピンに接続します。サンプルコードではピン9を使用していますが、他のPWMが使えるピンでも構いません。
- カソード（短い足）を抵抗に接続し、抵抗のもう一端をArduinoのGNDピンに接続します。
コードをアップロードする： Arduino IDEから提供されたサンプルコードをアップロードします。
動作確認： Arduinoに電源を供給すると、LEDがフェードイン（明るくなる）とフェードアウト（暗くなる）を繰り返すはずです。

LEDの極性を間違えてしまうと、LEDは光りません。その場合は、LEDの足を逆にして再度試してみてください。また、使用する抵抗の値はLEDの仕様と使用する電源の電圧によって異なるため、LEDのデータシートを確認するか、オームの法則を使用して計算してください。

アップロードされた画像

画像には、Freenove ESP32-WROVER-CAM開発ボードのピンアウト図が示されています。この図は、各GPIOピンの機能を詳細に説明しており、アナログからデジタルへの変換機能（ADC）、デジタル入出力（GPIO）、シリアル通信（I2C, SPI）、PWM出力などの機能を持つピンを識別するのに役立ちます。

もしGPIO0（表記はIO0ともされます）が利用できない場合、このピンアウト図に基づいて他のピンを選択できます。アナログ入力が必要な場合は、ADC1_CH0からADC1_CH7またはADC2_CH0からADC2_CH9までのいずれかのピンを使用できます。ただし、ESP32ではADC2チャンネルがWi-Fi機能と共有されているため、Wi-Fiを使用しているときはADC2チャンネルをアナログ読み取りに使用することはできません。

もしGPIO0の代わりに別のデジタルピンが必要な場合は、ピンアウト図からGPIO1からGPIO39までの範囲のいずれかのピンを選ぶことができます（ただし、ピンの中には入力専用や特定の機能に予約されているものもあります）。

次回はカメラを試してみます。

ANOGAN 第一話

異常検知システムを作ってみたい

しばらく深層強化学習の分野に力を入れていましたが、次は生成系ニューラルネットワークを使って異常検知にチャレンジしてみます。

異常検知システム

異常検知の種類を分類すると

外れ値検知：正常データの分布から外れているデータを検知
変化点検知：時系列データの傾向が変化した点を検知
異常部位検知：時系列データに対して正常パターンから外れているパターンを検知。

に分けられます。

異常検知の難しい点

とあるアルゴリズムで異常を検知したが、それが本当に異常なのか判断するのは、ドメイン知識がなければできません。

AutoEncoder

ニューラルネットワークを使った異常検知として基本的なアルゴリズムにAutoEndocerがあります。

正常データを入力しエンコーダーで圧縮し、再びデコーダーで元データに戻します。その過程で特徴が抽出されます。

出力の教師データに入力と同じ正解データを使うことによって徐々に各ネットワークパラメータを学習していきます。

学習後、データを入力したときに出力がデータと大きな差があれば、それは学習できていない未知のデータであり正解データとは異なる、つまり異常データと判断できます。

GAN

生成系と言ったらGANが有名ですが、異常検知システムに使われるANO-GAN（Anomaly Generative Adversarial Networks）を使って設備の波形データ異常を検出できるかやってみましょう。

まず、anoganを使用するためには、PythonのディープラーニングフレームワークであるPytorch, TensorFlowやKerasが必要です。これらのライブラリをインストールしてセットアップする必要があります。また、適切なデータセットも必要です。

大まかな手順

ライブラリのインストール
データセットの準備
Generator（生成器）の定義
Discriminator（識別器）の定義
モデルのトレーニング
異常スコアの計算
異常の検出と評価
ハイパーパラメータのチューニング

ライブラリのインストール: Pytorch, TensorFlowやKerasをインストールします。私はPytorchを使ってます。
データセットの準備: 正常データだけあればモデルを作れるのがANOGANのメリットですが、異常が含まれるデータも検証で使いますので、結局は正常、異常の両方のデータを準備する必要があります。
Generator（生成器）とDiscriminator（識別器）の定義: anoganは、生成器と識別器の2つのネットワークで構成されます。生成器は、正常なデータを生成し、識別器は正常なデータと異常なデータを識別します。
モデルのトレーニング: 正常なデータセットを使用してモデルをトレーニングします。トレーニング中に生成器と識別器を交互に更新し、互いに競い合わせることで、正常なデータの特徴を学習します。
異常スコアの計算: モデルがトレーニングされたら、生成器を使用して異常スコアを計算します。異常スコアは、生成器が正常なデータをどれだけ正確に再現できるかを示す指標です。異常スコアが高いほど、異常と判断される可能性が高くなります。

異常の検出と評価: 異常スコアを閾値と比較し、異常と判断されるデータを検出します。また、モデルの性能を評価するために、テストデータセットを使用して評価指標（精度、再現率、F値など）を計算します。
ハイパーパラメータのチューニング: モデルのパフォーマンスを改善するために、ハイパーパラメータのチューニングを行います。モデルのアーキテクチャ、学習率、バッチサイズなどのパラメータを調整し、最適な結果を得るようにします。

以上が基本的な手順ですが、anoganを使用した異常検知システムの構築は一般的には複雑なタスクです。データセットの準備やモデルのトレーニングには時間と計算リソースが必要であり、さまざまな試行錯誤が必要となる場合もあります。

ではやっていこう。

DDPG by gymnasium １７日目

今回は、単純にノードを64から32に落としてみたらどうかと思います。

学習のステップ

100Steps x 1000Epsodes
200Steps x 1000Epsodes
300Steps x 1000Epsodes

非常にうまくいきました。文句なしです。

走りも安定しています。

これで、このDDPGシリーズはお終いにいたします。

続編はMalti Agent Deep Detarministic Policy Gradient:MADDPG　の予定です。ありがとうございました。

import gymnasium as gym
import time
import torch as T
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
import os
import csv

# 44.OUActionNOoiseクラスを作成する
class OUActionNoise(object):
    def __init__(self, mu, sigma=0.15, theta=0.2, dt=1e-2, x0=None):
        self.mu = mu
        self.sigma = sigma
        self.theta = theta
        self.dt = dt
        self.x0 = x0
        self.reset()

    def __call__(self):
        x = self.x_prev + self.theta * (self.mu - self.x_prev) * self.dt + \
        self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)
        self.x_prev = x
        return x

    def reset(self):
        self.x_prev = self.x0 if self.x0 is not None else np.zeros_like(self.mu)


# 10. ReplayBufferクラスを新規作成する
class ReplayBuffer:
    def __init__(self, max_memory_size, n_obs_space, n_action_space):
        self.max_memory_size = max_memory_size
        self.n_obs_space = n_obs_space
        self.n_action_space = n_action_space

        self.memory_count = 0

        self.state_memory = np.zeros((self.max_memory_size, self.n_obs_space))
        self.action_memory =  np.zeros((self.max_memory_size, self.n_action_space))
        self.reward_memory =  np.zeros(self.max_memory_size)
        self.next_state_memory =  np.zeros((self.max_memory_size, self.n_obs_space))
        self.terminal_memory =  np.zeros(self.max_memory_size)
        #self.terminal_memory = np.zeros(self.max_memory_size, dtype=np.bool)

    # 11.トランジション保存のためstore_transitionメソドを作成する
    def store_transition(self, obs, action, reward, next_state, done):
        #print('store_transition is working.')
        index = self.memory_count % self.max_memory_size # 最大メモリー数に到達したら、古いデータから上書きされていくギミック
        #print('obs.detach().numpy().flatten():',obs.detach().numpy().flatten())
        self.state_memory[index] = obs.detach().numpy().flatten()
        self.action_memory[index] = action.flatten()
        self.reward_memory[index] = reward.flatten()
        self.next_state_memory[index] = next_state.flatten()
        self.terminal_memory[index] = 1 - int(done) # ゴールならterminal = 0 となるように

        self.memory_count += 1
        #print('memory_count :', agent.memory.memory_count)

    # 16 バッファメモリーからランダムに抽出する
    def sample_buffer(self, batch_size):
        # indexが最大メモリに到達していない場合を想定する。
        max_index = min(self.max_memory_size, self.memory_count)
        choosed_index = np.random.choice(max_index, batch_size)
        
        observations = self.state_memory[choosed_index]
        actions = self.action_memory[choosed_index]
        rewards = self.reward_memory[choosed_index]
        next_states = self.next_state_memory[choosed_index]
        terminals = self.terminal_memory[choosed_index]

        return observations, actions, rewards, next_states, terminals


# 6.ActorNNクラスを新規作成する
class ActorNN(nn.Module):
    def __init__(self, device, alpha=0.001, n_obs_space=17, n_action_space=6,
                                    layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):
        #print('ActorNN.__init__ is working.')
        super(ActorNN, self).__init__()

        self.fc1 = nn.Linear(n_obs_space, layer1_size)
        f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値   　-fから+fの範囲で一様分布
        nn.init.uniform_(self.fc1.bias, -f1, +f1)   # バイアス初期値 -fから+fの範囲で一様分布

        self.bn1 =  nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

        self.fc2 = nn.Linear(layer1_size, layer2_size)
        f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc2.weight, -f2, +f2) # -fから+fの範囲で一様分布
        nn.init.uniform_(self.fc2.bias, -f2, +f2) # -fから+fの範囲で一様分布

        self.bn2 =  nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

        self.fc3 = nn.Linear(layer2_size, n_action_space) # 

        #26.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=alpha)
        #self.optimizer = optim.SGD(self.parameters(), lr=alpha)


    def forward(self, obs):
        #print('AgetDDPG.ActorNN.forward is working')
        #print('====ここまではOK1====')
        x = self.fc1(obs)
        x = self.bn1(x)
        x = F.relu(x)

        x = self.fc2(x)
        x = self.bn2(x)
        x = F.relu(x)

        x = self.fc3(x)
        action = F.tanh(x)

        return action

# 22.CriticNNクラスを新規作成する
class CriticNN(nn.Module):

    def __init__(self, device, beta=0.001, n_obs_space=17, n_action_space=6,
                 layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):
        #print('CriticNN.__init__ is working.')
        super(CriticNN, self).__init__()

        # クリティックNNは観察空間+行動空間の２つを入力とする構造
        input_dim = n_obs_space + n_action_space
        self.fc1 = nn.Linear(input_dim, layer1_size)

        f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値   　-fから+fの範囲で一様分布
        nn.init.uniform_(self.fc1.bias, -f1, +f1)   # バイアス初期値 -fから+fの範囲で一様分布

        self.bn1 =  nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

        self.fc2 = nn.Linear(layer1_size, layer2_size)
        f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc2.weight, -f1, +f1) # 重み初期値   　-fから+fの範囲で一様分布
        nn.init.uniform_(self.fc2.bias, -f1, +f1)   # バイアス初期値 -fから+fの範囲で一様分布

        self.bn2 =  nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

        self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

        #27.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=beta)
        #self.optimizer = optim.SGD(self.parameters(), lr=beta)

    def forward(self, obs, action):
        input_data = T.cat([obs, action], dim=1)
        x = self.fc1(input_data)
        x = self.bn1(x)
        x = F.relu(x)

        x = self.fc2(x)
        x = self.bn2(x)
        x = F.relu(x)

        x = self.fc3(x)

        return x #一つの状態価値を出力する。

# 3.エージェントクラスを定義する
class AgentDDPG:

    def __init__(self, device, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=64, layer2_size=64, layer3_size=64, batch_size=64, mode='train_mode'):
        #print('AgentDDPG.__init__ is working.')
        # 5.ActorNNクラスのインスタンスを生成する
        self.device = device

        self.alpha = alpha
        self.beta = beta
        self.gamma = gamma
        self.tau = tau
        
        self.n_obs_space = n_obs_space
        self.n_action_space = n_action_space

        self.n_state_action_value = n_state_action_value

        self.layer1_size = layer1_size
        self.layer2_size = layer2_size
        self.layer3_size = layer3_size

        # 13.バッチサイズを決めておく
        self.batch_size = batch_size 

        self.actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,
                            layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size) 
        
        if os.path.isfile('actor_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.actor.load_state_dict(T.load('actor_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'actor_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'actor_params.pt')

        # actorネットワークをGPUへ転送
        self.actor.to(device)
        
        # 9.memoryインスタンスを追加
        self.MAX_MEMORY_SIZE = 10000
        self.memory = ReplayBuffer(max_memory_size=self.MAX_MEMORY_SIZE,
                                   n_obs_space=self.n_obs_space,
                                   n_action_space=self.n_action_space)
        
        # 19.ターゲットアクターネットワークインスタンスtarget_actorを作成する
        # actorとtarget_actorのネットワークは同じActorNNで良い
        self.target_actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,
                                    layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

        if os.path.isfile('target_actor_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.target_actor.load_state_dict(T.load('target_actor_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'target_actor_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'target_actor_params.pt')


        # target_actorネットワークをGPUへ転送
        self.target_actor.to(device)

        # 21.ターゲットクリティックネットワークインスタンスtareget_criticを作成する
        self.target_critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,
                                    layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

        if os.path.isfile('target_critic_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.target_critic.load_state_dict(T.load('target_critic_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'target_critic_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'target_critic_params.pt')

         # target_criticネットワークをGPUへ転送
        self.target_critic.to(device)

        # 24.クリティックネットワークインスタンスcriticを作成する。

        self.critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,
                                    layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)


        if os.path.isfile('critic_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.critic.load_state_dict(T.load('critic_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'critic_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'critic_params.pt')
            
        # criticネットワークをGPUへ転送
        self.critic.to(device)
        
        # アクターロスとクリティックロス
        self.actor_loss = 0
        self.critic_loss = 0
        
        # 45.行動ノイズのインスタンス化
        self.mode = mode
        if self.mode == 'train_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space))
        elif self.mode == 'eval_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)
        else:
            print('mode error')
        

    def choose_action(self, obs): # GPU対応済み
        #print('AgentDDPG.choose_action is working.')
        # 4.方策（アクター）はニューラルネットワークで表現する。
        #   ActorNNクラスを新規作成し、インスタンスactorとして使用する。
        obs = obs.to(device)
        action = self.actor.forward(obs)
        action = action.cpu()

        # 46.行動ノイズを入れて探索性を向上させる。  
        action += T.tensor(self.noise(), dtype=T.float32)
        action = action.detach().numpy()

        return action
    
    # 8.remenberメソドを追加
    def remember(self, obs, action, reward, next_state, done):
        self.memory.store_transition(obs, action, reward, next_state, done)

    # 13.learnメソドを追加
    def learn(self):
        # 14.バッチサイズ分のトランジションが集まるまでは何も実行しない。
        if self.memory.memory_count < self.batch_size:
            return
        
        # 15.メモリバッファからデータを抜き出す sample_buffer()
        # バッチ化されているので変数名を複数形にする
        observations, actions, rewards, next_states, terminals = self.memory.sample_buffer(self.batch_size)


        # 17.抜き出したデータをpytorchで微分可能なようにtorch.tensor化する 
        observations = T.tensor(observations, dtype=T.float32).to(device)
        actions = T.tensor(actions, dtype=T.float32).to(device)
        rewards = T.tensor(rewards, dtype=T.float32).to(device)
        next_states = T.tensor(next_states, dtype=T.float32).to(device)
        terminals = T.tensor(terminals, dtype=T.float32).to(device)


        # 18.ターゲットアクターネットワークインスタンスtarget_actorに
        # 次の状態next_satesを入れて、ターゲットアクションtarget_actionsとして取り出す。
        # このターゲットネットワークはターゲットでないネットワークとNNパラメータを共有させる。
        #print('next_states :', next_states)
        target_actions = self.target_actor.forward(next_states)


        # 20.ターゲットクリティックネットワークインスタンスtarget_criticに
        # 次の状態next_statesと上記より算出したターゲットアクションの２つを入力して
        # 価値関数の推定値ターゲットバリューを出力する。
        # TDターゲット：r + γ*V(w)[s_t+1] の部分のこと。
        # ターゲットクリティックバリューはターゲットアクターネットワークを使う
        target_critic_values = self.target_critic.forward(next_states, target_actions)

        
        # 23.ベースラインとして機能するクリティックネットワーク（価値関数V(w)[s_t]ネットワーク）に
        # 現在の状態observationsと行動actionsを入力して
        # クリティックバリューを算出する
        critic_values = self.critic.forward(observations, actions)
        

        # 25.TDターゲットを算出する：r + γ*V(w)[s_t+1]
        td_targets = []
        for i in range(self.batch_size):
            td_target = rewards[i] + self.gamma * target_critic_values[i] * terminals[i]
            td_targets.append(td_target)

        # TDターゲットの形をバッチに整える
        td_targets = T.tensor(td_targets, dtype=T.float32).to(device)
        td_targets = td_targets.view(self.batch_size, 1) #viewはreshapeと同じ。64x1に見え方を変更した、という意味
        #print('td_targets :', td_targets)


        # ==== （１）クリティックの学習 ====

        # 28.クリティックの勾配をゼロに初期化する
        self.critic.optimizer.zero_grad()

        # 29. TDターゲットと状態価値の二乗誤差を算出して、クリティックの損失関数とする。バッチサイズは６４個
        critic_loss = F.mse_loss(td_targets, critic_values)
        self.critic_loss = critic_loss
        #print('critic_loss : ', critic_loss) # tensor(0.0485, grad_fn=<MseLossBackward0>)

        # 30. クリティックの損失関数を微分して、勾配を算出する
        self.critic_loss.backward()

        # 31. 勾配からオプティマイザーによってクリティックのパラメータ（重みとバイアス）を更新する
        self.critic.optimizer.step()


        # ==== （２）アクターの学習 ====

        # 32. アクターの勾配をゼロに初期化する
        self.actor.optimizer.zero_grad()

        # 33. アクターに観測情報を入力して行動を算出する。バッチサイズは６４個
        predicted_actions = self.actor.forward(observations)

        # 34.アクターの損失関数を算出する
        #    Actorの目的は、Criticネットワークの出力（行動価値）を最大化するような行動を選択すること。
        #    なので、actorNN→criticNNのDDPG構造全体の出力結果をactor_lossとして、actorNNとcriticNNの両方をbackwardし、
        #    actorだけをパラメータ更新することによりactorの学習をすることができる。

        actor_loss = -self.critic.forward(observations, predicted_actions)
        actor_loss = T.mean(actor_loss)
        self.actor_loss = actor_loss

        #print(f'actor_loss: {actor_loss}, critic_loss: {critic_loss}')

        # 35. DDPG構造全体の損失関数actor_lossを微分し、勾配を算出する
        self.actor_loss.backward()

        # 36. 勾配からオプティマイザーによってアクターのパラメータだけを（重みとバイアス）を更新する
        self.actor.optimizer.step()
    
        # 37. 全ニューラルネットワークのパラメータを更新する。
        self.update_network_parameters()

    # 37. パラメータ更新メソド。
    def update_network_parameters(self, tau=None):
        if tau is None:
            tau = self.tau
    
        # 38. actor, critic, target_actor, target_criticのネットワーク内の全てのパラメータ（重みとバイアス）とその名前を取得する
        # actorとcriticは先ほど更新されたばかりのパラメーター
        actor_params = self.actor.named_parameters()
        critic_params = self.critic.named_parameters()
        target_actor_params = self.target_actor.named_parameters()
        target_critic_params = self.target_critic.named_parameters()
        #print('actor_params : ', actor_params) # actor_params :  <generator object Module.named_parameters at 0x000001661B2D9D48>

        # 39. パラメータをディクショナリとして取り出す。
        actor_params_dict = dict(actor_params)
        critic_params_dict = dict(critic_params)
        target_actor_params_dict = dict(target_actor_params)
        target_critic_params_dict = dict(target_critic_params)
        #print('actor_params_dict : ', actor_params_dict)
        #print(actor_params_dict.keys())


        # 40. クリティックの各パラメーター毎に 更新重みtau=0.0001の分だけほんの少しcriticパラメータをtarget_criticパラメータに近づける。
        for name in critic_params_dict:
            critic_params_dict[name] = tau * critic_params_dict[name].clone() + \
                                       (1-tau) * target_critic_params_dict[name].clone()
            
        # 41. 更新したcriticパラメータをtarget_criticのパラメータとしてロードする。
        self.target_critic.load_state_dict(critic_params_dict)

        # 42.アクターの各パラメーター毎に 更新重みtau=0.0001の分だけほんの少しactorパラメータをtarget_actorパラメータに近づける。
        for name in actor_params_dict:
            actor_params_dict[name] = tau * actor_params_dict[name].clone() + \
                                      (1 - tau) * target_actor_params_dict[name].clone()
            
        # 43. 更新したactorパラメータをtarget_actorのパラメータとしてロードする。
        self.target_actor.load_state_dict(actor_params_dict)


# データをCSVファイルに追記保存する関数
def append_data_to_csv(episode, total_reward, actor_loss, critic_loss, file_path):
    with open(file_path, 'a', newline='') as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow([episode, total_reward, actor_loss, critic_loss])

#### =================== メインスクリプト ======================= ####

device = T.device('cuda' if T.cuda.is_available() else 'cpu') # cuda追加
device = 'cpu' # 強制的にcpuを使う

EVAL_TRAIN_MODE = 'eval_mode' # eval_mode 評価モードか train_mode 訓練モードかを選択
EPISODES = 1001 # episodes
STEPS = 300    # steps
DELAY_TIME = 0.00 # sec
print('Selected Mode : ', EVAL_TRAIN_MODE)

# 2.エージェントクラスのインスタンスを生成する

agent = AgentDDPG(device=device, alpha=0.0001, beta=0.0001, gamma=0.99, tau=0.01,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=32, layer2_size=32, layer3_size=32, batch_size=64, mode=EVAL_TRAIN_MODE) # cuda追加

if EVAL_TRAIN_MODE == 'train_mode':
    env = gym.make("HalfCheetah-v4", render_mode='depth_array')

elif EVAL_TRAIN_MODE == 'eval_mode':
    env = gym.make("HalfCheetah-v4", render_mode= 'human')


total_rewards = []
actor_losses = []
critic_losses = []
for episode in range(EPISODES):
    obs = env.reset()
    obs = T.tensor(obs[0], dtype=T.float)


    reward: float = 0
    total_reward: float = 0
    done: bool = False
    for j in range(STEPS):
        env.render()
        
        # ここをDDPGに置き換えていく
        action = agent.choose_action(obs) # 1.Agentクラスを定義していく # GPU対応済み


        next_state, reward, done, _, info = env.step(action)
        #print('next_state, reward, done, _, info :', next_state, reward, done, _, info)

        #7. トラジェクトを保存する。経験再生(ReplayBuffer)
        agent.remember(obs, action, reward, next_state, int(done))
       

        #12. ニューラルネットワークを学習する
        agent.learn()

        # 26.エピソード内での報酬を累積していく
        total_reward += reward
        
        # 27. next_stateをobsとして再出発する
        #print('next_state:', next_state)
        obs = next_state
        obs = T.tensor(obs, dtype=T.float)
        # 28. チーターの動きを見たいのでスリープを入れる
        time.sleep(DELAY_TIME)

    #print('total_reward : ', total_reward)
    total_rewards.append(total_reward)

    actor_losses.append(agent.actor_loss) 
    critic_losses.append(agent.critic_loss) 

    # print('epsisode', i, 'score %.2f' % score, '100 game sverage %.2f' % np.mean(score_history[-100:]))
 
    # 47. 各ニューラルネットワークのパラメータを１０エピソード毎に保存する
    print('episode, total_reward : ', episode , total_reward, float(agent.actor_loss), float(agent.critic_loss))
    

    if episode % 10 == 0:
        T.save(agent.actor.state_dict(), 'actor_params.pt')
        T.save(agent.critic.state_dict(), 'critic_params.pt')
        T.save(agent.target_actor.state_dict(), 'target_actor_params.pt')
        T.save(agent.target_critic.state_dict(), 'target_critic_params.pt')
        print('==== params were saved. ====')

    append_data_to_csv(episode, total_reward, float(agent.actor_loss), float(agent.critic_loss), 'total_reward.csv')

#print('total_rewards : ', total_rewards)
#plt.plot(total_rewards)

#plt.plot(actor_losses, label='actor_losses')
#plt.plot(critic_losses, label='critic_losses')
plt.plot(total_rewards, label='total_rewards')
plt.legend()
plt.grid(True)
plt.ioff()
plt.show()

env.close() # 空なんですけど・・・

print('script is done.')

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

import gymnasium as gym

import time

import torch as T

import torch.nn as nn

import torch.nn.functional as F

import torch.optim as optim

import numpy as np

import matplotlib.pyplot as plt

import os

import csv

# 44.OUActionNOoiseクラスを作成する

class OUActionNoise(object):

def __init__(self, mu, sigma=0.15, theta=0.2, dt=1e-2, x0=None):

self.mu = mu

self.sigma = sigma

self.theta = theta

self.dt = dt

self.x0 = x0

self.reset()

def __call__(self):

x = self.x_prev + self.theta * (self.mu - self.x_prev) * self.dt + \

self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)

self.x_prev = x

return x

def reset(self):

self.x_prev = self.x0 if self.x0 is not None else np.zeros_like(self.mu)

# 10. ReplayBufferクラスを新規作成する

class ReplayBuffer:

def __init__(self, max_memory_size, n_obs_space, n_action_space):

self.max_memory_size = max_memory_size

self.n_obs_space = n_obs_space

self.n_action_space = n_action_space

self.memory_count = 0

self.state_memory = np.zeros((self.max_memory_size, self.n_obs_space))

self.action_memory = np.zeros((self.max_memory_size, self.n_action_space))

self.reward_memory = np.zeros(self.max_memory_size)

self.next_state_memory = np.zeros((self.max_memory_size, self.n_obs_space))

self.terminal_memory = np.zeros(self.max_memory_size)

#self.terminal_memory = np.zeros(self.max_memory_size, dtype=np.bool)

# 11.トランジション保存のためstore_transitionメソドを作成する

def store_transition(self, obs, action, reward, next_state, done):

#print('store_transition is working.')

index = self.memory_count % self.max_memory_size # 最大メモリー数に到達したら、古いデータから上書きされていくギミック

#print('obs.detach().numpy().flatten():',obs.detach().numpy().flatten())

self.state_memory[index] = obs.detach().numpy().flatten()

self.action_memory[index] = action.flatten()

self.reward_memory[index] = reward.flatten()

self.next_state_memory[index] = next_state.flatten()

self.terminal_memory[index] = 1 - int(done) # ゴールならterminal = 0 となるように

self.memory_count += 1

#print('memory_count :', agent.memory.memory_count)

# 16 バッファメモリーからランダムに抽出する

def sample_buffer(self, batch_size):

# indexが最大メモリに到達していない場合を想定する。

max_index = min(self.max_memory_size, self.memory_count)

choosed_index = np.random.choice(max_index, batch_size)

observations = self.state_memory[choosed_index]

actions = self.action_memory[choosed_index]

rewards = self.reward_memory[choosed_index]

next_states = self.next_state_memory[choosed_index]

terminals = self.terminal_memory[choosed_index]

return observations, actions, rewards, next_states, terminals

# 6.ActorNNクラスを新規作成する

class ActorNN(nn.Module):

def __init__(self, device, alpha=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):

#print('ActorNN.__init__ is working.')

super(ActorNN, self).__init__()

self.fc1 = nn.Linear(n_obs_space, layer1_size)

f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値　-fから+fの範囲で一様分布

nn.init.uniform_(self.fc1.bias, -f1, +f1) # バイアス初期値 -fから+fの範囲で一様分布

self.bn1 = nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

self.fc2 = nn.Linear(layer1_size, layer2_size)

f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc2.weight, -f2, +f2) # -fから+fの範囲で一様分布

nn.init.uniform_(self.fc2.bias, -f2, +f2) # -fから+fの範囲で一様分布

self.bn2 = nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

self.fc3 = nn.Linear(layer2_size, n_action_space) #

#26.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=alpha)

#self.optimizer = optim.SGD(self.parameters(), lr=alpha)

def forward(self, obs):

#print('AgetDDPG.ActorNN.forward is working')

#print('====ここまではOK1====')

x = self.fc1(obs)

x = self.bn1(x)

x = F.relu(x)

x = self.fc2(x)

x = self.bn2(x)

x = F.relu(x)

x = self.fc3(x)

action = F.tanh(x)

return action

# 22.CriticNNクラスを新規作成する

class CriticNN(nn.Module):

def __init__(self, device, beta=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):

#print('CriticNN.__init__ is working.')

super(CriticNN, self).__init__()

# クリティックNNは観察空間+行動空間の２つを入力とする構造

input_dim = n_obs_space + n_action_space

self.fc1 = nn.Linear(input_dim, layer1_size)

f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値　-fから+fの範囲で一様分布

nn.init.uniform_(self.fc1.bias, -f1, +f1) # バイアス初期値 -fから+fの範囲で一様分布

self.bn1 = nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

self.fc2 = nn.Linear(layer1_size, layer2_size)

f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc2.weight, -f1, +f1) # 重み初期値　-fから+fの範囲で一様分布

nn.init.uniform_(self.fc2.bias, -f1, +f1) # バイアス初期値 -fから+fの範囲で一様分布

self.bn2 = nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

#27.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=beta)

#self.optimizer = optim.SGD(self.parameters(), lr=beta)

def forward(self, obs, action):

input_data = T.cat([obs, action], dim=1)

x = self.fc1(input_data)

x = self.bn1(x)

x = F.relu(x)

x = self.fc2(x)

x = self.bn2(x)

x = F.relu(x)

x = self.fc3(x)

return x #一つの状態価値を出力する。

# 3.エージェントクラスを定義する

class AgentDDPG:

def __init__(self, device, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=64, layer2_size=64, layer3_size=64, batch_size=64, mode='train_mode'):

#print('AgentDDPG.__init__ is working.')

# 5.ActorNNクラスのインスタンスを生成する

self.device = device

self.alpha = alpha

self.beta = beta

self.gamma = gamma

self.tau = tau

self.n_obs_space = n_obs_space

self.n_action_space = n_action_space

self.n_state_action_value = n_state_action_value

self.layer1_size = layer1_size

self.layer2_size = layer2_size

self.layer3_size = layer3_size

# 13.バッチサイズを決めておく

self.batch_size = batch_size

self.actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

if os.path.isfile('actor_params.pt'):

# パラメータファイルが存在する場合はロード

self.actor.load_state_dict(T.load('actor_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'actor_params.pt')

else:

print("パラメータファイルが見つかりません:", 'actor_params.pt')

# actorネットワークをGPUへ転送

self.actor.to(device)

# 9.memoryインスタンスを追加

self.MAX_MEMORY_SIZE = 10000

self.memory = ReplayBuffer(max_memory_size=self.MAX_MEMORY_SIZE,

n_obs_space=self.n_obs_space,

n_action_space=self.n_action_space)

# 19.ターゲットアクターネットワークインスタンスtarget_actorを作成する

# actorとtarget_actorのネットワークは同じActorNNで良い

self.target_actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

if os.path.isfile('target_actor_params.pt'):

# パラメータファイルが存在する場合はロード

self.target_actor.load_state_dict(T.load('target_actor_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'target_actor_params.pt')

else:

print("パラメータファイルが見つかりません:", 'target_actor_params.pt')

# target_actorネットワークをGPUへ転送

self.target_actor.to(device)

# 21.ターゲットクリティックネットワークインスタンスtareget_criticを作成する

self.target_critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

if os.path.isfile('target_critic_params.pt'):

# パラメータファイルが存在する場合はロード

self.target_critic.load_state_dict(T.load('target_critic_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'target_critic_params.pt')

else:

print("パラメータファイルが見つかりません:", 'target_critic_params.pt')

# target_criticネットワークをGPUへ転送

self.target_critic.to(device)

# 24.クリティックネットワークインスタンスcriticを作成する。

self.critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

if os.path.isfile('critic_params.pt'):

# パラメータファイルが存在する場合はロード

self.critic.load_state_dict(T.load('critic_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'critic_params.pt')

else:

print("パラメータファイルが見つかりません:", 'critic_params.pt')

# criticネットワークをGPUへ転送

self.critic.to(device)

# アクターロスとクリティックロス

self.actor_loss = 0

self.critic_loss = 0

# 45.行動ノイズのインスタンス化

self.mode = mode

if self.mode == 'train_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space))

elif self.mode == 'eval_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)

else:

print('mode error')

def choose_action(self, obs): # GPU対応済み

#print('AgentDDPG.choose_action is working.')

# 4.方策（アクター）はニューラルネットワークで表現する。

# ActorNNクラスを新規作成し、インスタンスactorとして使用する。

obs = obs.to(device)

action = self.actor.forward(obs)

action = action.cpu()

# 46.行動ノイズを入れて探索性を向上させる。

action += T.tensor(self.noise(), dtype=T.float32)

action = action.detach().numpy()

return action

# 8.remenberメソドを追加

def remember(self, obs, action, reward, next_state, done):

self.memory.store_transition(obs, action, reward, next_state, done)

# 13.learnメソドを追加

def learn(self):

# 14.バッチサイズ分のトランジションが集まるまでは何も実行しない。

if self.memory.memory_count < self.batch_size:

return

# 15.メモリバッファからデータを抜き出す sample_buffer()

# バッチ化されているので変数名を複数形にする

observations, actions, rewards, next_states, terminals = self.memory.sample_buffer(self.batch_size)

# 17.抜き出したデータをpytorchで微分可能なようにtorch.tensor化する

observations = T.tensor(observations, dtype=T.float32).to(device)

actions = T.tensor(actions, dtype=T.float32).to(device)

rewards = T.tensor(rewards, dtype=T.float32).to(device)

next_states = T.tensor(next_states, dtype=T.float32).to(device)

terminals = T.tensor(terminals, dtype=T.float32).to(device)

# 18.ターゲットアクターネットワークインスタンスtarget_actorに

# 次の状態next_satesを入れて、ターゲットアクションtarget_actionsとして取り出す。

# このターゲットネットワークはターゲットでないネットワークとNNパラメータを共有させる。

#print('next_states :', next_states)

target_actions = self.target_actor.forward(next_states)

# 20.ターゲットクリティックネットワークインスタンスtarget_criticに

# 次の状態next_statesと上記より算出したターゲットアクションの２つを入力して

# 価値関数の推定値ターゲットバリューを出力する。

# TDターゲット：r + γ*V(w)[s_t+1] の部分のこと。

# ターゲットクリティックバリューはターゲットアクターネットワークを使う

target_critic_values = self.target_critic.forward(next_states, target_actions)

# 23.ベースラインとして機能するクリティックネットワーク（価値関数V(w)[s_t]ネットワーク）に

# 現在の状態observationsと行動actionsを入力して

# クリティックバリューを算出する

critic_values = self.critic.forward(observations, actions)

# 25.TDターゲットを算出する：r + γ*V(w)[s_t+1]

td_targets = []

for i in range(self.batch_size):

td_target = rewards[i] + self.gamma * target_critic_values[i] * terminals[i]

td_targets.append(td_target)

# TDターゲットの形をバッチに整える

td_targets = T.tensor(td_targets, dtype=T.float32).to(device)

td_targets = td_targets.view(self.batch_size, 1) #viewはreshapeと同じ。64x1に見え方を変更した、という意味

#print('td_targets :', td_targets)

# ==== （１）クリティックの学習 ====

# 28.クリティックの勾配をゼロに初期化する

self.critic.optimizer.zero_grad()

# 29. TDターゲットと状態価値の二乗誤差を算出して、クリティックの損失関数とする。バッチサイズは６４個

critic_loss = F.mse_loss(td_targets, critic_values)

self.critic_loss = critic_loss

#print('critic_loss : ', critic_loss) # tensor(0.0485, grad_fn=<MseLossBackward0>)

# 30. クリティックの損失関数を微分して、勾配を算出する

self.critic_loss.backward()

# 31. 勾配からオプティマイザーによってクリティックのパラメータ（重みとバイアス）を更新する

self.critic.optimizer.step()

# ==== （２）アクターの学習 ====

# 32. アクターの勾配をゼロに初期化する

self.actor.optimizer.zero_grad()

# 33. アクターに観測情報を入力して行動を算出する。バッチサイズは６４個

predicted_actions = self.actor.forward(observations)

# 34.アクターの損失関数を算出する

# Actorの目的は、Criticネットワークの出力（行動価値）を最大化するような行動を選択すること。

# なので、actorNN→criticNNのDDPG構造全体の出力結果をactor_lossとして、actorNNとcriticNNの両方をbackwardし、

# actorだけをパラメータ更新することによりactorの学習をすることができる。

actor_loss = -self.critic.forward(observations, predicted_actions)

actor_loss = T.mean(actor_loss)

self.actor_loss = actor_loss

#print(f'actor_loss: {actor_loss}, critic_loss: {critic_loss}')

# 35. DDPG構造全体の損失関数actor_lossを微分し、勾配を算出する

self.actor_loss.backward()

# 36. 勾配からオプティマイザーによってアクターのパラメータだけを（重みとバイアス）を更新する

self.actor.optimizer.step()

# 37. 全ニューラルネットワークのパラメータを更新する。

self.update_network_parameters()

# 37. パラメータ更新メソド。

def update_network_parameters(self, tau=None):

if tau is None:

tau = self.tau

# 38. actor, critic, target_actor, target_criticのネットワーク内の全てのパラメータ（重みとバイアス）とその名前を取得する

# actorとcriticは先ほど更新されたばかりのパラメーター

actor_params = self.actor.named_parameters()

critic_params = self.critic.named_parameters()

target_actor_params = self.target_actor.named_parameters()

target_critic_params = self.target_critic.named_parameters()

#print('actor_params : ', actor_params) # actor_params : <generator object Module.named_parameters at 0x000001661B2D9D48>

# 39. パラメータをディクショナリとして取り出す。

actor_params_dict = dict(actor_params)

critic_params_dict = dict(critic_params)

target_actor_params_dict = dict(target_actor_params)

target_critic_params_dict = dict(target_critic_params)

#print('actor_params_dict : ', actor_params_dict)

#print(actor_params_dict.keys())

# 40. クリティックの各パラメーター毎に更新重みtau=0.0001の分だけほんの少しcriticパラメータをtarget_criticパラメータに近づける。

for name in critic_params_dict:

critic_params_dict[name] = tau * critic_params_dict[name].clone() + \

(1-tau) * target_critic_params_dict[name].clone()

# 41. 更新したcriticパラメータをtarget_criticのパラメータとしてロードする。

self.target_critic.load_state_dict(critic_params_dict)

# 42.アクターの各パラメーター毎に更新重みtau=0.0001の分だけほんの少しactorパラメータをtarget_actorパラメータに近づける。

for name in actor_params_dict:

actor_params_dict[name] = tau * actor_params_dict[name].clone() + \

(1 - tau) * target_actor_params_dict[name].clone()

# 43. 更新したactorパラメータをtarget_actorのパラメータとしてロードする。

self.target_actor.load_state_dict(actor_params_dict)

# データをCSVファイルに追記保存する関数

def append_data_to_csv(episode, total_reward, actor_loss, critic_loss, file_path):

with open(file_path, 'a', newline='') as csvfile:

writer = csv.writer(csvfile)

writer.writerow([episode, total_reward, actor_loss, critic_loss])

#### =================== メインスクリプト ======================= ####

device = T.device('cuda' if T.cuda.is_available() else 'cpu') # cuda追加

device = 'cpu' # 強制的にcpuを使う

EVAL_TRAIN_MODE = 'eval_mode' # eval_mode 評価モードか train_mode 訓練モードかを選択

EPISODES = 1001 # episodes

STEPS = 300 # steps

DELAY_TIME = 0.00 # sec

print('Selected Mode : ', EVAL_TRAIN_MODE)

# 2.エージェントクラスのインスタンスを生成する

agent = AgentDDPG(device=device, alpha=0.0001, beta=0.0001, gamma=0.99, tau=0.01,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=32, layer2_size=32, layer3_size=32, batch_size=64, mode=EVAL_TRAIN_MODE) # cuda追加

if EVAL_TRAIN_MODE == 'train_mode':

env = gym.make("HalfCheetah-v4", render_mode='depth_array')

elif EVAL_TRAIN_MODE == 'eval_mode':

env = gym.make("HalfCheetah-v4", render_mode= 'human')

total_rewards = []

actor_losses = []

critic_losses = []

for episode in range(EPISODES):

obs = env.reset()

obs = T.tensor(obs[0], dtype=T.float)

reward: float = 0

total_reward: float = 0

done: bool = False

for j in range(STEPS):

env.render()

# ここをDDPGに置き換えていく

action = agent.choose_action(obs) # 1.Agentクラスを定義していく # GPU対応済み

next_state, reward, done, _, info = env.step(action)

#print('next_state, reward, done, _, info :', next_state, reward, done, _, info)

#7. トラジェクトを保存する。経験再生(ReplayBuffer)

agent.remember(obs, action, reward, next_state, int(done))

#12. ニューラルネットワークを学習する

agent.learn()

# 26.エピソード内での報酬を累積していく

total_reward += reward

# 27. next_stateをobsとして再出発する

#print('next_state:', next_state)

obs = next_state

obs = T.tensor(obs, dtype=T.float)

# 28. チーターの動きを見たいのでスリープを入れる

time.sleep(DELAY_TIME)

#print('total_reward : ', total_reward)

total_rewards.append(total_reward)

actor_losses.append(agent.actor_loss)

critic_losses.append(agent.critic_loss)

# print('epsisode', i, 'score %.2f' % score, '100 game sverage %.2f' % np.mean(score_history[-100:]))

# 47. 各ニューラルネットワークのパラメータを１０エピソード毎に保存する

print('episode, total_reward : ', episode , total_reward, float(agent.actor_loss), float(agent.critic_loss))

if episode % 10 == 0:

T.save(agent.actor.state_dict(), 'actor_params.pt')

T.save(agent.critic.state_dict(), 'critic_params.pt')

T.save(agent.target_actor.state_dict(), 'target_actor_params.pt')

T.save(agent.target_critic.state_dict(), 'target_critic_params.pt')

print('==== params were saved. ====')

append_data_to_csv(episode, total_reward, float(agent.actor_loss), float(agent.critic_loss), 'total_reward.csv')

#print('total_rewards : ', total_rewards)

#plt.plot(total_rewards)

#plt.plot(actor_losses, label='actor_losses')

#plt.plot(critic_losses, label='critic_losses')

plt.plot(total_rewards, label='total_rewards')

plt.legend()

plt.grid(True)

plt.ioff()

plt.show()

env.close() # 空なんですけど・・・

print('script is done.')

DDPG by gymnasium １６日目

前回

学習が進まず、チーターの様子を見ると開始直後に静止してお終いです。ぐーたらになってしまいました。

考えうる原因

ノード数が多すぎる？256
学習率が大きすぎる？0.01
パラメータの初期値　Heがうまくいってない？/1√256は小さすぎる？
レイヤー正規化が上手くいってない？

→レイヤー正規化をキャンセルしてみます。

actor:

def forward(self, obs):

#print(‘AgetDDPG.ActorNN.forward is working’)

#print(‘====ここまではOK1====’)

x = self.fc1(obs)

#x = self.bn1(x)

x = F.relu(x)

x = self.fc2(x)

#x = self.bn2(x)

x = F.relu(x)

x = self.fc3(x)

action = F.tanh(x)

return action

critic:

def forward(self, obs, action):

input_data = T.cat([obs, action], dim=1)

x = self.fc1(input_data)

#x = self.bn1(x)

x = F.relu(x)

x = self.fc2(x)

#x = self.bn2(x)

x = F.relu(x)

x = self.fc3(x)

return x #一つの状態価値を出力する。

結果：ダメです！学習が進みません。

次はHeの初期値をキャンセルしてみます。

→結果：ダメです、収益が徐々に下がり気味で、Actor_lossもなぜか安定して増えていっています。

次はノードを256から64に落としてみます。また同時にバッチサイズも256から64に落としてみます。

→結果：Stepは200にして始めています。

３００回やったあと、続けて１０００回やってみました。頑張ってる？

ここでStepを300にしてみます。安定して前進している姿を経験再生バッファに溜め込むのが目的です。

悪化しました・・・。

ということは、残すところ学習率？0.01から0.001に細かくしました。

100Stepを1000Episode、200Stepを1000Episode実行しました。

上手くいきました。

ActorNN:He適用しない, alpha=0.0001, Adam, bn1,キャンセル bn2キャンセル

batch64,obs17→17 fc1 64→64 ReLU 64→64 fc2 64→64ReLU64→64fc3 6 →Tanh6→ action6

CriticNN:He適用, beta=0.001, Adam,bn1,キャンセル bn2キャンセル

batch64,obs17+act6→input23 fc1 64→64 ReLU 64→64 fc2 64→64fc3 1→活性化関数なし→Q_value 1

結果的に、

ノード数が多すぎる？256→64
学習率が大きすぎる？0.01→0.001
パラメータのHe初期値　→キャンセル
レイヤー正規化→キャンセル

でうまくいきましたが、学習率が大きすぎたのが原因ではないかと考えます。

またノード数が多すぎて過学習を起こしていた可能性もあります。

またレイヤー正規化が上手くいかないのも腑に落ちません。

He初期化は原因として考えにくいので、まずはここだけ戻してみます。

問題ありませんでした。次にレイヤー正規化を適用してみます。

600Epsodeを過ぎたあたりで悪化していますが、何とか持ち直しています。どうやら、スタートダッシュで前傾姿勢になりすぎて逆に速度が遅くなっているようです。ひっくり返っているのでしょう。１０００回超えたあたりでStepを伸ばしたので前のめりが修正されつつあると考えます。よってStep300にして1000回続けてみます。

ブレ幅が大きいですが、よさそうです。

いや、やっぱダメです（笑）ずっと逆立ちして頭と前足で前進しています。

６００回～９００回あたりで、変な癖を覚えてしまったようです。

ほんとAIってやつは突拍子もないことを考え付きます。

原因は何でしょうか、過学習と言っていいものかはさだかではありませんが、正則化のようにニューラルネットワークの最適化に対して何らかの拘束を与えるとよいかもしれません。正則化というとよく活性化関数からの出力のうち10%程度を0にして学習をさせる、ドロップアウトがでてきますが、単純にノードを64から32に落としてみたらどうかと思います。次回やってみます。

import gymnasium as gym
import time
import torch as T
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
import os
import csv

# 44.OUActionNOoiseクラスを作成する
class OUActionNoise(object):
    def __init__(self, mu, sigma=0.15, theta=0.2, dt=1e-2, x0=None):
        self.mu = mu
        self.sigma = sigma
        self.theta = theta
        self.dt = dt
        self.x0 = x0
        self.reset()

    def __call__(self):
        x = self.x_prev + self.theta * (self.mu - self.x_prev) * self.dt + \
        self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)
        self.x_prev = x
        return x

    def reset(self):
        self.x_prev = self.x0 if self.x0 is not None else np.zeros_like(self.mu)


# 10. ReplayBufferクラスを新規作成する
class ReplayBuffer:
    def __init__(self, max_memory_size, n_obs_space, n_action_space):
        self.max_memory_size = max_memory_size
        self.n_obs_space = n_obs_space
        self.n_action_space = n_action_space

        self.memory_count = 0

        self.state_memory = np.zeros((self.max_memory_size, self.n_obs_space))
        self.action_memory =  np.zeros((self.max_memory_size, self.n_action_space))
        self.reward_memory =  np.zeros(self.max_memory_size)
        self.next_state_memory =  np.zeros((self.max_memory_size, self.n_obs_space))
        self.terminal_memory =  np.zeros(self.max_memory_size)
        #self.terminal_memory = np.zeros(self.max_memory_size, dtype=np.bool)

    # 11.トランジション保存のためstore_transitionメソドを作成する
    def store_transition(self, obs, action, reward, next_state, done):
        #print('store_transition is working.')
        index = self.memory_count % self.max_memory_size # 最大メモリー数に到達したら、古いデータから上書きされていくギミック
        #print('obs.detach().numpy().flatten():',obs.detach().numpy().flatten())
        self.state_memory[index] = obs.detach().numpy().flatten()
        self.action_memory[index] = action.flatten()
        self.reward_memory[index] = reward.flatten()
        self.next_state_memory[index] = next_state.flatten()
        self.terminal_memory[index] = 1 - int(done) # ゴールならterminal = 0 となるように

        self.memory_count += 1
        #print('memory_count :', agent.memory.memory_count)

    # 16 バッファメモリーからランダムに抽出する
    def sample_buffer(self, batch_size):
        # indexが最大メモリに到達していない場合を想定する。
        max_index = min(self.max_memory_size, self.memory_count)
        choosed_index = np.random.choice(max_index, batch_size)
        
        observations = self.state_memory[choosed_index]
        actions = self.action_memory[choosed_index]
        rewards = self.reward_memory[choosed_index]
        next_states = self.next_state_memory[choosed_index]
        terminals = self.terminal_memory[choosed_index]

        return observations, actions, rewards, next_states, terminals


# 6.ActorNNクラスを新規作成する
class ActorNN(nn.Module):
    def __init__(self, device, alpha=0.001, n_obs_space=17, n_action_space=6,
                                    layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):
        #print('ActorNN.__init__ is working.')
        super(ActorNN, self).__init__()

        self.fc1 = nn.Linear(n_obs_space, layer1_size)
        f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値   　-fから+fの範囲で一様分布
        nn.init.uniform_(self.fc1.bias, -f1, +f1)   # バイアス初期値 -fから+fの範囲で一様分布

        self.bn1 =  nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

        self.fc2 = nn.Linear(layer1_size, layer2_size)
        f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc2.weight, -f2, +f2) # -fから+fの範囲で一様分布
        nn.init.uniform_(self.fc2.bias, -f2, +f2) # -fから+fの範囲で一様分布
        print(self.fc2.weight.data.size()[0])

        self.bn2 =  nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

        self.fc3 = nn.Linear(layer2_size, n_action_space) # 


        #26.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=alpha)
        #self.optimizer = optim.SGD(self.parameters(), lr=alpha)


    def forward(self, obs):
        #print('AgetDDPG.ActorNN.forward is working')
        #print('====ここまではOK1====')
        x = self.fc1(obs)
        x = self.bn1(x)
        x = F.relu(x)

        x = self.fc2(x)
        x = self.bn2(x)
        x = F.relu(x)

        x = self.fc3(x)
        action = F.tanh(x)

        return action

# 22.CriticNNクラスを新規作成する
class CriticNN(nn.Module):

    def __init__(self, device, beta=0.001, n_obs_space=17, n_action_space=6,
                 layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):
        #print('CriticNN.__init__ is working.')
        super(CriticNN, self).__init__()

        # クリティックNNは観察空間+行動空間の２つを入力とする構造
        input_dim = n_obs_space + n_action_space
        self.fc1 = nn.Linear(input_dim, layer1_size)

        f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値   　-fから+fの範囲で一様分布
        nn.init.uniform_(self.fc1.bias, -f1, +f1)   # バイアス初期値 -fから+fの範囲で一様分布

        self.bn1 =  nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

        self.fc2 = nn.Linear(layer1_size, layer2_size)
        f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc2.weight, -f1, +f1) # 重み初期値   　-fから+fの範囲で一様分布
        nn.init.uniform_(self.fc2.bias, -f1, +f1)   # バイアス初期値 -fから+fの範囲で一様分布

        self.bn2 =  nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

        self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

        #27.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=beta)
        #self.optimizer = optim.SGD(self.parameters(), lr=beta)

    def forward(self, obs, action):
        input_data = T.cat([obs, action], dim=1)
        x = self.fc1(input_data)
        x = self.bn1(x)
        x = F.relu(x)

        x = self.fc2(x)
        x = self.bn2(x)
        x = F.relu(x)

        x = self.fc3(x)

        return x #一つの状態価値を出力する。

# 3.エージェントクラスを定義する
class AgentDDPG:

    def __init__(self, device, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=64, layer2_size=64, layer3_size=64, batch_size=64, mode='train_mode'):
        #print('AgentDDPG.__init__ is working.')
        # 5.ActorNNクラスのインスタンスを生成する
        self.device = device

        self.alpha = alpha
        self.beta = beta
        self.gamma = gamma
        self.tau = tau
        
        self.n_obs_space = n_obs_space
        self.n_action_space = n_action_space

        self.n_state_action_value = n_state_action_value

        self.layer1_size = layer1_size
        self.layer2_size = layer2_size
        self.layer3_size = layer3_size

        # 13.バッチサイズを決めておく
        self.batch_size = batch_size 

        self.actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,
                            layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size) 
        
        if os.path.isfile('actor_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.actor.load_state_dict(T.load('actor_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'actor_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'actor_params.pt')

        # actorネットワークをGPUへ転送
        self.actor.to(device)
        
        # 9.memoryインスタンスを追加
        self.MAX_MEMORY_SIZE = 10000
        self.memory = ReplayBuffer(max_memory_size=self.MAX_MEMORY_SIZE,
                                   n_obs_space=self.n_obs_space,
                                   n_action_space=self.n_action_space)
        
        # 19.ターゲットアクターネットワークインスタンスtarget_actorを作成する
        # actorとtarget_actorのネットワークは同じActorNNで良い
        self.target_actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,
                                    layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

        if os.path.isfile('target_actor_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.target_actor.load_state_dict(T.load('target_actor_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'target_actor_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'target_actor_params.pt')


        # target_actorネットワークをGPUへ転送
        self.target_actor.to(device)

        # 21.ターゲットクリティックネットワークインスタンスtareget_criticを作成する
        self.target_critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,
                                    layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

        if os.path.isfile('target_critic_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.target_critic.load_state_dict(T.load('target_critic_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'target_critic_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'target_critic_params.pt')

         # target_criticネットワークをGPUへ転送
        self.target_critic.to(device)

        # 24.クリティックネットワークインスタンスcriticを作成する。

        self.critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,
                                    layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)


        if os.path.isfile('critic_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.critic.load_state_dict(T.load('critic_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'critic_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'critic_params.pt')
            
        # criticネットワークをGPUへ転送
        self.critic.to(device)
        
        # アクターロスとクリティックロス
        self.actor_loss = 0
        self.critic_loss = 0
        
        # 45.行動ノイズのインスタンス化
        self.mode = mode
        if self.mode == 'train_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space))
        elif self.mode == 'eval_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)
        else:
            print('mode error')
        

    def choose_action(self, obs): # GPU対応済み
        #print('AgentDDPG.choose_action is working.')
        # 4.方策（アクター）はニューラルネットワークで表現する。
        #   ActorNNクラスを新規作成し、インスタンスactorとして使用する。
        obs = obs.to(device)
        action = self.actor.forward(obs)
        action = action.cpu()

        # 46.行動ノイズを入れて探索性を向上させる。  
        action += T.tensor(self.noise(), dtype=T.float32)
        action = action.detach().numpy()

        return action
    
    # 8.remenberメソドを追加
    def remember(self, obs, action, reward, next_state, done):
        self.memory.store_transition(obs, action, reward, next_state, done)

    # 13.learnメソドを追加
    def learn(self):
        # 14.バッチサイズ分のトランジションが集まるまでは何も実行しない。
        if self.memory.memory_count < self.batch_size:
            return
        
        # 15.メモリバッファからデータを抜き出す sample_buffer()
        # バッチ化されているので変数名を複数形にする
        observations, actions, rewards, next_states, terminals = self.memory.sample_buffer(self.batch_size)


        # 17.抜き出したデータをpytorchで微分可能なようにtorch.tensor化する 
        observations = T.tensor(observations, dtype=T.float32).to(device)
        actions = T.tensor(actions, dtype=T.float32).to(device)
        rewards = T.tensor(rewards, dtype=T.float32).to(device)
        next_states = T.tensor(next_states, dtype=T.float32).to(device)
        terminals = T.tensor(terminals, dtype=T.float32).to(device)


        # 18.ターゲットアクターネットワークインスタンスtarget_actorに
        # 次の状態next_satesを入れて、ターゲットアクションtarget_actionsとして取り出す。
        # このターゲットネットワークはターゲットでないネットワークとNNパラメータを共有させる。
        #print('next_states :', next_states)
        target_actions = self.target_actor.forward(next_states)


        # 20.ターゲットクリティックネットワークインスタンスtarget_criticに
        # 次の状態next_statesと上記より算出したターゲットアクションの２つを入力して
        # 価値関数の推定値ターゲットバリューを出力する。
        # TDターゲット：r + γ*V(w)[s_t+1] の部分のこと。
        # ターゲットクリティックバリューはターゲットアクターネットワークを使う
        target_critic_values = self.target_critic.forward(next_states, target_actions)

        
        # 23.ベースラインとして機能するクリティックネットワーク（価値関数V(w)[s_t]ネットワーク）に
        # 現在の状態observationsと行動actionsを入力して
        # クリティックバリューを算出する
        critic_values = self.critic.forward(observations, actions)
        

        # 25.TDターゲットを算出する：r + γ*V(w)[s_t+1]
        td_targets = []
        for i in range(self.batch_size):
            td_target = rewards[i] + self.gamma * target_critic_values[i] * terminals[i]
            td_targets.append(td_target)

        # TDターゲットの形をバッチに整える
        td_targets = T.tensor(td_targets, dtype=T.float32).to(device)
        td_targets = td_targets.view(self.batch_size, 1) #viewはreshapeと同じ。64x1に見え方を変更した、という意味
        #print('td_targets :', td_targets)


        # ==== （１）クリティックの学習 ====

        # 28.クリティックの勾配をゼロに初期化する
        self.critic.optimizer.zero_grad()

        # 29. TDターゲットと状態価値の二乗誤差を算出して、クリティックの損失関数とする。バッチサイズは６４個
        critic_loss = F.mse_loss(td_targets, critic_values)
        self.critic_loss = critic_loss
        #print('critic_loss : ', critic_loss) # tensor(0.0485, grad_fn=<MseLossBackward0>)

        # 30. クリティックの損失関数を微分して、勾配を算出する
        self.critic_loss.backward()

        # 31. 勾配からオプティマイザーによってクリティックのパラメータ（重みとバイアス）を更新する
        self.critic.optimizer.step()


        # ==== （２）アクターの学習 ====

        # 32. アクターの勾配をゼロに初期化する
        self.actor.optimizer.zero_grad()

        # 33. アクターに観測情報を入力して行動を算出する。バッチサイズは６４個
        predicted_actions = self.actor.forward(observations)

        # 34.アクターの損失関数を算出する
        #    Actorの目的は、Criticネットワークの出力（行動価値）を最大化するような行動を選択すること。
        #    なので、actorNN→criticNNのDDPG構造全体の出力結果をactor_lossとして、actorNNとcriticNNの両方をbackwardし、
        #    actorだけをパラメータ更新することによりactorの学習をすることができる。

        actor_loss = -self.critic.forward(observations, predicted_actions)
        actor_loss = T.mean(actor_loss)
        self.actor_loss = actor_loss

        #print(f'actor_loss: {actor_loss}, critic_loss: {critic_loss}')

        # 35. DDPG構造全体の損失関数actor_lossを微分し、勾配を算出する
        self.actor_loss.backward()

        # 36. 勾配からオプティマイザーによってアクターのパラメータだけを（重みとバイアス）を更新する
        self.actor.optimizer.step()
    
        # 37. 全ニューラルネットワークのパラメータを更新する。
        self.update_network_parameters()

    # 37. パラメータ更新メソド。
    def update_network_parameters(self, tau=None):
        if tau is None:
            tau = self.tau
    
        # 38. actor, critic, target_actor, target_criticのネットワーク内の全てのパラメータ（重みとバイアス）とその名前を取得する
        # actorとcriticは先ほど更新されたばかりのパラメーター
        actor_params = self.actor.named_parameters()
        critic_params = self.critic.named_parameters()
        target_actor_params = self.target_actor.named_parameters()
        target_critic_params = self.target_critic.named_parameters()
        #print('actor_params : ', actor_params) # actor_params :  <generator object Module.named_parameters at 0x000001661B2D9D48>

        # 39. パラメータをディクショナリとして取り出す。
        actor_params_dict = dict(actor_params)
        critic_params_dict = dict(critic_params)
        target_actor_params_dict = dict(target_actor_params)
        target_critic_params_dict = dict(target_critic_params)
        #print('actor_params_dict : ', actor_params_dict)
        #print(actor_params_dict.keys())


        # 40. クリティックの各パラメーター毎に 更新重みtau=0.0001の分だけほんの少しcriticパラメータをtarget_criticパラメータに近づける。
        for name in critic_params_dict:
            critic_params_dict[name] = tau * critic_params_dict[name].clone() + \
                                       (1-tau) * target_critic_params_dict[name].clone()
            
        # 41. 更新したcriticパラメータをtarget_criticのパラメータとしてロードする。
        self.target_critic.load_state_dict(critic_params_dict)

        # 42.アクターの各パラメーター毎に 更新重みtau=0.0001の分だけほんの少しactorパラメータをtarget_actorパラメータに近づける。
        for name in actor_params_dict:
            actor_params_dict[name] = tau * actor_params_dict[name].clone() + \
                                      (1 - tau) * target_actor_params_dict[name].clone()
            
        # 43. 更新したactorパラメータをtarget_actorのパラメータとしてロードする。
        self.target_actor.load_state_dict(actor_params_dict)


# データをCSVファイルに追記保存する関数
def append_data_to_csv(episode, total_reward, actor_loss, critic_loss, file_path):
    with open(file_path, 'a', newline='') as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow([episode, total_reward, actor_loss, critic_loss])

#### =================== メインスクリプト ======================= ####

device = T.device('cuda' if T.cuda.is_available() else 'cpu') # cuda追加
device = 'cpu' # 強制的にcpuを使う

EVAL_TRAIN_MODE = 'eval_mode' # eval_mode 評価モードか train_mode 訓練モードかを選択
EPISODES = 1001 # episodes
STEPS = 300    # steps
DELAY_TIME = 0.00 # sec
print('Selected Mode : ', EVAL_TRAIN_MODE)

# 2.エージェントクラスのインスタンスを生成する
"""agent = AgentDDPG(device=device, alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=256, layer2_size=256, layer3_size=256, batch_size=256, mode=EVAL_TRAIN_MODE) # cuda追加
"""
agent = AgentDDPG(device=device, alpha=0.0001, beta=0.0001, gamma=0.99, tau=0.01,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=64, layer2_size=64, layer3_size=64, batch_size=64, mode=EVAL_TRAIN_MODE) # cuda追加

if EVAL_TRAIN_MODE == 'train_mode':
    env = gym.make("HalfCheetah-v4", render_mode='depth_array')

elif EVAL_TRAIN_MODE == 'eval_mode':
    env = gym.make("HalfCheetah-v4", render_mode= 'human')


total_rewards = []
actor_losses = []
critic_losses = []
for episode in range(EPISODES):
    obs = env.reset()
    obs = T.tensor(obs[0], dtype=T.float)


    reward: float = 0
    total_reward: float = 0
    done: bool = False
    for j in range(STEPS):
        env.render()
        
        # ここをDDPGに置き換えていく
        action = agent.choose_action(obs) # 1.Agentクラスを定義していく # GPU対応済み


        next_state, reward, done, _, info = env.step(action)
        #print('next_state, reward, done, _, info :', next_state, reward, done, _, info)

        #7. トラジェクトを保存する。経験再生(ReplayBuffer)
        agent.remember(obs, action, reward, next_state, int(done))
       

        #12. ニューラルネットワークを学習する
        agent.learn()

        # 26.エピソード内での報酬を累積していく
        total_reward += reward
        
        # 27. next_stateをobsとして再出発する
        #print('next_state:', next_state)
        obs = next_state
        obs = T.tensor(obs, dtype=T.float)
        # 28. チーターの動きを見たいのでスリープを入れる
        time.sleep(DELAY_TIME)

    #print('total_reward : ', total_reward)
    total_rewards.append(total_reward)

    actor_losses.append(agent.actor_loss) 
    critic_losses.append(agent.critic_loss) 

    # print('epsisode', i, 'score %.2f' % score, '100 game sverage %.2f' % np.mean(score_history[-100:]))
 
    # 47. 各ニューラルネットワークのパラメータを１０エピソード毎に保存する
    print('episode, total_reward : ', episode , total_reward, float(agent.actor_loss), float(agent.critic_loss))
    

    if episode % 10 == 0:
        T.save(agent.actor.state_dict(), 'actor_params.pt')
        T.save(agent.critic.state_dict(), 'critic_params.pt')
        T.save(agent.target_actor.state_dict(), 'target_actor_params.pt')
        T.save(agent.target_critic.state_dict(), 'target_critic_params.pt')
        print('==== params were saved. ====')

    append_data_to_csv(episode, total_reward, float(agent.actor_loss), float(agent.critic_loss), 'total_reward.csv')

#print('total_rewards : ', total_rewards)
#plt.plot(total_rewards)

#plt.plot(actor_losses, label='actor_losses')
#plt.plot(critic_losses, label='critic_losses')
plt.plot(total_rewards, label='total_rewards')
plt.legend()
plt.grid(True)
plt.ioff()
plt.show()

env.close() # 空なんですけど・・・

print('script is done.')

# https://gymnasium.farama.org/

"""
To start off with,
shall we have a look at the main points for today's discussion?

cambly:

I'd like to begin by outlining the main points on the agenda.

Thank you for taking time out of your busy schejule.

"""

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

import gymnasium as gym

import time

import torch as T

import torch.nn as nn

import torch.nn.functional as F

import torch.optim as optim

import numpy as np

import matplotlib.pyplot as plt

import os

import csv

# 44.OUActionNOoiseクラスを作成する

class OUActionNoise(object):

def __init__(self, mu, sigma=0.15, theta=0.2, dt=1e-2, x0=None):

self.mu = mu

self.sigma = sigma

self.theta = theta

self.dt = dt

self.x0 = x0

self.reset()

def __call__(self):

x = self.x_prev + self.theta * (self.mu - self.x_prev) * self.dt + \

self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)

self.x_prev = x

return x

def reset(self):

self.x_prev = self.x0 if self.x0 is not None else np.zeros_like(self.mu)

# 10. ReplayBufferクラスを新規作成する

class ReplayBuffer:

def __init__(self, max_memory_size, n_obs_space, n_action_space):

self.max_memory_size = max_memory_size

self.n_obs_space = n_obs_space

self.n_action_space = n_action_space

self.memory_count = 0

self.state_memory = np.zeros((self.max_memory_size, self.n_obs_space))

self.action_memory = np.zeros((self.max_memory_size, self.n_action_space))

self.reward_memory = np.zeros(self.max_memory_size)

self.next_state_memory = np.zeros((self.max_memory_size, self.n_obs_space))

self.terminal_memory = np.zeros(self.max_memory_size)

#self.terminal_memory = np.zeros(self.max_memory_size, dtype=np.bool)

# 11.トランジション保存のためstore_transitionメソドを作成する

def store_transition(self, obs, action, reward, next_state, done):

#print('store_transition is working.')

index = self.memory_count % self.max_memory_size # 最大メモリー数に到達したら、古いデータから上書きされていくギミック

#print('obs.detach().numpy().flatten():',obs.detach().numpy().flatten())

self.state_memory[index] = obs.detach().numpy().flatten()

self.action_memory[index] = action.flatten()

self.reward_memory[index] = reward.flatten()

self.next_state_memory[index] = next_state.flatten()

self.terminal_memory[index] = 1 - int(done) # ゴールならterminal = 0 となるように

self.memory_count += 1

#print('memory_count :', agent.memory.memory_count)

# 16 バッファメモリーからランダムに抽出する

def sample_buffer(self, batch_size):

# indexが最大メモリに到達していない場合を想定する。

max_index = min(self.max_memory_size, self.memory_count)

choosed_index = np.random.choice(max_index, batch_size)

observations = self.state_memory[choosed_index]

actions = self.action_memory[choosed_index]

rewards = self.reward_memory[choosed_index]

next_states = self.next_state_memory[choosed_index]

terminals = self.terminal_memory[choosed_index]

return observations, actions, rewards, next_states, terminals

# 6.ActorNNクラスを新規作成する

class ActorNN(nn.Module):

def __init__(self, device, alpha=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):

#print('ActorNN.__init__ is working.')

super(ActorNN, self).__init__()

self.fc1 = nn.Linear(n_obs_space, layer1_size)

f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値　-fから+fの範囲で一様分布

nn.init.uniform_(self.fc1.bias, -f1, +f1) # バイアス初期値 -fから+fの範囲で一様分布

self.bn1 = nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

self.fc2 = nn.Linear(layer1_size, layer2_size)

f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc2.weight, -f2, +f2) # -fから+fの範囲で一様分布

nn.init.uniform_(self.fc2.bias, -f2, +f2) # -fから+fの範囲で一様分布

print(self.fc2.weight.data.size()[0])

self.bn2 = nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

self.fc3 = nn.Linear(layer2_size, n_action_space) #

#26.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=alpha)

#self.optimizer = optim.SGD(self.parameters(), lr=alpha)

def forward(self, obs):

#print('AgetDDPG.ActorNN.forward is working')

#print('====ここまではOK1====')

x = self.fc1(obs)

x = self.bn1(x)

x = F.relu(x)

x = self.fc2(x)

x = self.bn2(x)

x = F.relu(x)

x = self.fc3(x)

action = F.tanh(x)

return action

# 22.CriticNNクラスを新規作成する

class CriticNN(nn.Module):

def __init__(self, device, beta=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):

#print('CriticNN.__init__ is working.')

super(CriticNN, self).__init__()

# クリティックNNは観察空間+行動空間の２つを入力とする構造

input_dim = n_obs_space + n_action_space

self.fc1 = nn.Linear(input_dim, layer1_size)

f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値　-fから+fの範囲で一様分布

nn.init.uniform_(self.fc1.bias, -f1, +f1) # バイアス初期値 -fから+fの範囲で一様分布

self.bn1 = nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

self.fc2 = nn.Linear(layer1_size, layer2_size)

f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc2.weight, -f1, +f1) # 重み初期値　-fから+fの範囲で一様分布

nn.init.uniform_(self.fc2.bias, -f1, +f1) # バイアス初期値 -fから+fの範囲で一様分布

self.bn2 = nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

#27.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=beta)

#self.optimizer = optim.SGD(self.parameters(), lr=beta)

def forward(self, obs, action):

input_data = T.cat([obs, action], dim=1)

x = self.fc1(input_data)

x = self.bn1(x)

x = F.relu(x)

x = self.fc2(x)

x = self.bn2(x)

x = F.relu(x)

x = self.fc3(x)

return x #一つの状態価値を出力する。

# 3.エージェントクラスを定義する

class AgentDDPG:

def __init__(self, device, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=64, layer2_size=64, layer3_size=64, batch_size=64, mode='train_mode'):

#print('AgentDDPG.__init__ is working.')

# 5.ActorNNクラスのインスタンスを生成する

self.device = device

self.alpha = alpha

self.beta = beta

self.gamma = gamma

self.tau = tau

self.n_obs_space = n_obs_space

self.n_action_space = n_action_space

self.n_state_action_value = n_state_action_value

self.layer1_size = layer1_size

self.layer2_size = layer2_size

self.layer3_size = layer3_size

# 13.バッチサイズを決めておく

self.batch_size = batch_size

self.actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

if os.path.isfile('actor_params.pt'):

# パラメータファイルが存在する場合はロード

self.actor.load_state_dict(T.load('actor_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'actor_params.pt')

else:

print("パラメータファイルが見つかりません:", 'actor_params.pt')

# actorネットワークをGPUへ転送

self.actor.to(device)

# 9.memoryインスタンスを追加

self.MAX_MEMORY_SIZE = 10000

self.memory = ReplayBuffer(max_memory_size=self.MAX_MEMORY_SIZE,

n_obs_space=self.n_obs_space,

n_action_space=self.n_action_space)

# 19.ターゲットアクターネットワークインスタンスtarget_actorを作成する

# actorとtarget_actorのネットワークは同じActorNNで良い

self.target_actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

if os.path.isfile('target_actor_params.pt'):

# パラメータファイルが存在する場合はロード

self.target_actor.load_state_dict(T.load('target_actor_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'target_actor_params.pt')

else:

print("パラメータファイルが見つかりません:", 'target_actor_params.pt')

# target_actorネットワークをGPUへ転送

self.target_actor.to(device)

# 21.ターゲットクリティックネットワークインスタンスtareget_criticを作成する

self.target_critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

if os.path.isfile('target_critic_params.pt'):

# パラメータファイルが存在する場合はロード

self.target_critic.load_state_dict(T.load('target_critic_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'target_critic_params.pt')

else:

print("パラメータファイルが見つかりません:", 'target_critic_params.pt')

# target_criticネットワークをGPUへ転送

self.target_critic.to(device)

# 24.クリティックネットワークインスタンスcriticを作成する。

self.critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

if os.path.isfile('critic_params.pt'):

# パラメータファイルが存在する場合はロード

self.critic.load_state_dict(T.load('critic_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'critic_params.pt')

else:

print("パラメータファイルが見つかりません:", 'critic_params.pt')

# criticネットワークをGPUへ転送

self.critic.to(device)

# アクターロスとクリティックロス

self.actor_loss = 0

self.critic_loss = 0

# 45.行動ノイズのインスタンス化

self.mode = mode

if self.mode == 'train_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space))

elif self.mode == 'eval_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)

else:

print('mode error')

def choose_action(self, obs): # GPU対応済み

#print('AgentDDPG.choose_action is working.')

# 4.方策（アクター）はニューラルネットワークで表現する。

# ActorNNクラスを新規作成し、インスタンスactorとして使用する。

obs = obs.to(device)

action = self.actor.forward(obs)

action = action.cpu()

# 46.行動ノイズを入れて探索性を向上させる。

action += T.tensor(self.noise(), dtype=T.float32)

action = action.detach().numpy()

return action

# 8.remenberメソドを追加

def remember(self, obs, action, reward, next_state, done):

self.memory.store_transition(obs, action, reward, next_state, done)

# 13.learnメソドを追加

def learn(self):

# 14.バッチサイズ分のトランジションが集まるまでは何も実行しない。

if self.memory.memory_count < self.batch_size:

return

# 15.メモリバッファからデータを抜き出す sample_buffer()

# バッチ化されているので変数名を複数形にする

observations, actions, rewards, next_states, terminals = self.memory.sample_buffer(self.batch_size)

# 17.抜き出したデータをpytorchで微分可能なようにtorch.tensor化する

observations = T.tensor(observations, dtype=T.float32).to(device)

actions = T.tensor(actions, dtype=T.float32).to(device)

rewards = T.tensor(rewards, dtype=T.float32).to(device)

next_states = T.tensor(next_states, dtype=T.float32).to(device)

terminals = T.tensor(terminals, dtype=T.float32).to(device)

# 18.ターゲットアクターネットワークインスタンスtarget_actorに

# 次の状態next_satesを入れて、ターゲットアクションtarget_actionsとして取り出す。

# このターゲットネットワークはターゲットでないネットワークとNNパラメータを共有させる。

#print('next_states :', next_states)

target_actions = self.target_actor.forward(next_states)

# 20.ターゲットクリティックネットワークインスタンスtarget_criticに

# 次の状態next_statesと上記より算出したターゲットアクションの２つを入力して

# 価値関数の推定値ターゲットバリューを出力する。

# TDターゲット：r + γ*V(w)[s_t+1] の部分のこと。

# ターゲットクリティックバリューはターゲットアクターネットワークを使う

target_critic_values = self.target_critic.forward(next_states, target_actions)

# 23.ベースラインとして機能するクリティックネットワーク（価値関数V(w)[s_t]ネットワーク）に

# 現在の状態observationsと行動actionsを入力して

# クリティックバリューを算出する

critic_values = self.critic.forward(observations, actions)

# 25.TDターゲットを算出する：r + γ*V(w)[s_t+1]

td_targets = []

for i in range(self.batch_size):

td_target = rewards[i] + self.gamma * target_critic_values[i] * terminals[i]

td_targets.append(td_target)

# TDターゲットの形をバッチに整える

td_targets = T.tensor(td_targets, dtype=T.float32).to(device)

td_targets = td_targets.view(self.batch_size, 1) #viewはreshapeと同じ。64x1に見え方を変更した、という意味

#print('td_targets :', td_targets)

# ==== （１）クリティックの学習 ====

# 28.クリティックの勾配をゼロに初期化する

self.critic.optimizer.zero_grad()

# 29. TDターゲットと状態価値の二乗誤差を算出して、クリティックの損失関数とする。バッチサイズは６４個

critic_loss = F.mse_loss(td_targets, critic_values)

self.critic_loss = critic_loss

#print('critic_loss : ', critic_loss) # tensor(0.0485, grad_fn=<MseLossBackward0>)

# 30. クリティックの損失関数を微分して、勾配を算出する

self.critic_loss.backward()

# 31. 勾配からオプティマイザーによってクリティックのパラメータ（重みとバイアス）を更新する

self.critic.optimizer.step()

# ==== （２）アクターの学習 ====

# 32. アクターの勾配をゼロに初期化する

self.actor.optimizer.zero_grad()

# 33. アクターに観測情報を入力して行動を算出する。バッチサイズは６４個

predicted_actions = self.actor.forward(observations)

# 34.アクターの損失関数を算出する

# Actorの目的は、Criticネットワークの出力（行動価値）を最大化するような行動を選択すること。

# なので、actorNN→criticNNのDDPG構造全体の出力結果をactor_lossとして、actorNNとcriticNNの両方をbackwardし、

# actorだけをパラメータ更新することによりactorの学習をすることができる。

actor_loss = -self.critic.forward(observations, predicted_actions)

actor_loss = T.mean(actor_loss)

self.actor_loss = actor_loss

#print(f'actor_loss: {actor_loss}, critic_loss: {critic_loss}')

# 35. DDPG構造全体の損失関数actor_lossを微分し、勾配を算出する

self.actor_loss.backward()

# 36. 勾配からオプティマイザーによってアクターのパラメータだけを（重みとバイアス）を更新する

self.actor.optimizer.step()

# 37. 全ニューラルネットワークのパラメータを更新する。

self.update_network_parameters()

# 37. パラメータ更新メソド。

def update_network_parameters(self, tau=None):

if tau is None:

tau = self.tau

# 38. actor, critic, target_actor, target_criticのネットワーク内の全てのパラメータ（重みとバイアス）とその名前を取得する

# actorとcriticは先ほど更新されたばかりのパラメーター

actor_params = self.actor.named_parameters()

critic_params = self.critic.named_parameters()

target_actor_params = self.target_actor.named_parameters()

target_critic_params = self.target_critic.named_parameters()

#print('actor_params : ', actor_params) # actor_params : <generator object Module.named_parameters at 0x000001661B2D9D48>

# 39. パラメータをディクショナリとして取り出す。

actor_params_dict = dict(actor_params)

critic_params_dict = dict(critic_params)

target_actor_params_dict = dict(target_actor_params)

target_critic_params_dict = dict(target_critic_params)

#print('actor_params_dict : ', actor_params_dict)

#print(actor_params_dict.keys())

# 40. クリティックの各パラメーター毎に更新重みtau=0.0001の分だけほんの少しcriticパラメータをtarget_criticパラメータに近づける。

for name in critic_params_dict:

critic_params_dict[name] = tau * critic_params_dict[name].clone() + \

(1-tau) * target_critic_params_dict[name].clone()

# 41. 更新したcriticパラメータをtarget_criticのパラメータとしてロードする。

self.target_critic.load_state_dict(critic_params_dict)

# 42.アクターの各パラメーター毎に更新重みtau=0.0001の分だけほんの少しactorパラメータをtarget_actorパラメータに近づける。

for name in actor_params_dict:

actor_params_dict[name] = tau * actor_params_dict[name].clone() + \

(1 - tau) * target_actor_params_dict[name].clone()

# 43. 更新したactorパラメータをtarget_actorのパラメータとしてロードする。

self.target_actor.load_state_dict(actor_params_dict)

# データをCSVファイルに追記保存する関数

def append_data_to_csv(episode, total_reward, actor_loss, critic_loss, file_path):

with open(file_path, 'a', newline='') as csvfile:

writer = csv.writer(csvfile)

writer.writerow([episode, total_reward, actor_loss, critic_loss])

#### =================== メインスクリプト ======================= ####

device = T.device('cuda' if T.cuda.is_available() else 'cpu') # cuda追加

device = 'cpu' # 強制的にcpuを使う

EVAL_TRAIN_MODE = 'eval_mode' # eval_mode 評価モードか train_mode 訓練モードかを選択

EPISODES = 1001 # episodes

STEPS = 300 # steps

DELAY_TIME = 0.00 # sec

print('Selected Mode : ', EVAL_TRAIN_MODE)

# 2.エージェントクラスのインスタンスを生成する

"""agent = AgentDDPG(device=device, alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=256, layer2_size=256, layer3_size=256, batch_size=256, mode=EVAL_TRAIN_MODE) # cuda追加

"""

agent = AgentDDPG(device=device, alpha=0.0001, beta=0.0001, gamma=0.99, tau=0.01,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=64, layer2_size=64, layer3_size=64, batch_size=64, mode=EVAL_TRAIN_MODE) # cuda追加

if EVAL_TRAIN_MODE == 'train_mode':

env = gym.make("HalfCheetah-v4", render_mode='depth_array')

elif EVAL_TRAIN_MODE == 'eval_mode':

env = gym.make("HalfCheetah-v4", render_mode= 'human')

total_rewards = []

actor_losses = []

critic_losses = []

for episode in range(EPISODES):

obs = env.reset()

obs = T.tensor(obs[0], dtype=T.float)

reward: float = 0

total_reward: float = 0

done: bool = False

for j in range(STEPS):

env.render()

# ここをDDPGに置き換えていく

action = agent.choose_action(obs) # 1.Agentクラスを定義していく # GPU対応済み

next_state, reward, done, _, info = env.step(action)

#print('next_state, reward, done, _, info :', next_state, reward, done, _, info)

#7. トラジェクトを保存する。経験再生(ReplayBuffer)

agent.remember(obs, action, reward, next_state, int(done))

#12. ニューラルネットワークを学習する

agent.learn()

# 26.エピソード内での報酬を累積していく

total_reward += reward

# 27. next_stateをobsとして再出発する

#print('next_state:', next_state)

obs = next_state

obs = T.tensor(obs, dtype=T.float)

# 28. チーターの動きを見たいのでスリープを入れる

time.sleep(DELAY_TIME)

#print('total_reward : ', total_reward)

total_rewards.append(total_reward)

actor_losses.append(agent.actor_loss)

critic_losses.append(agent.critic_loss)

# print('epsisode', i, 'score %.2f' % score, '100 game sverage %.2f' % np.mean(score_history[-100:]))

# 47. 各ニューラルネットワークのパラメータを１０エピソード毎に保存する

print('episode, total_reward : ', episode , total_reward, float(agent.actor_loss), float(agent.critic_loss))

if episode % 10 == 0:

T.save(agent.actor.state_dict(), 'actor_params.pt')

T.save(agent.critic.state_dict(), 'critic_params.pt')

T.save(agent.target_actor.state_dict(), 'target_actor_params.pt')

T.save(agent.target_critic.state_dict(), 'target_critic_params.pt')

print('==== params were saved. ====')

append_data_to_csv(episode, total_reward, float(agent.actor_loss), float(agent.critic_loss), 'total_reward.csv')

#print('total_rewards : ', total_rewards)

#plt.plot(total_rewards)

#plt.plot(actor_losses, label='actor_losses')

#plt.plot(critic_losses, label='critic_losses')

plt.plot(total_rewards, label='total_rewards')

plt.legend()

plt.grid(True)

plt.ioff()

plt.show()

env.close() # 空なんですけど・・・

print('script is done.')

# https://gymnasium.farama.org/

"""

To start off with,

shall we have a look at the main points for today's discussion?

cambly:

I'd like to begin by outlining the main points on the agenda.

Thank you for taking time out of your busy schejule.

"""

DDPG by gymnasium １５日目

さて最終章に近づいてまいりました。（ような気がする）

ニューラルネットワークの学習をより安定化させるために標準化Standarzation,正規化Normalizationをやっていきましょう。

まずは入力値について考えます

各特徴量ごとの学習の感度を同じくらいにそろえるために、入力値の値を相対的に加工します。

標準化

Z-scor normalization

手持ちデータを平均ゼロ、分散１の正規分布にする手法

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
x = scaler.fit_transform(x)

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

x = scaler.fit_transform(x)

正規化

Min-Max normalization

最小値～最大値を0~1にスケーリングする手法

使い分け

標準化：最大最小が決まっていない場合、外れ値が存在する場合

正規化：最大値および最小値が決まっている場合

戦闘力は標準化が良い

住宅価格も標準化が良い

弱点

弱点として、入力値はいいのですが、ネットワークを伝播していくうちに各ノードの入力値（活性化関数がかかる前）の分布は崩れていきます。

すると、勾配消失が起こりやすくなります。

重みパラメータの初期値を工夫する

そこで重みの初期値を工夫して一様分布や正規分布に従うランスを使うのですがディープラーニングではうまく動かないことがあります。

解決策として　乱数ｘネットワークの大きさに合わせた係数　を初期値とすると　分布が崩れにくくなるそうです。（ちょっとわかりません。）

活性化関数がシグモイド関数の場合はXavierの初期値、ReLU関数の場合はHeの初期値というものが良いそうです。

重みの要素数がnである場合、Heの初期値は1/√nとなります。

        self.fc1 = nn.Linear(self.input_dims, self.fc1_dims)
        f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0])
        T.nn.init.uniform_(self.fc1.weight.data, -f1, f1)
        T.nn.init.uniform_(self.fc1.bias.data, -f1, f1)

self.fc1 = nn.Linear(self.input_dims, self.fc1_dims)

f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0])

T.nn.init.uniform_(self.fc1.weight.data, -f1, f1)

T.nn.init.uniform_(self.fc1.bias.data, -f1, f1)

バッチ正規化

もっと直接的で良い方法があります。

各ノードに入力されたら、そこで正規化してしまえば良いのです。各層で毎回正規化を繰り返します。

因みになぜバッチ正規化というのかはわかりません。各レイヤーのノード群をバッチと呼んでいるのでしょうか。

とにかく各層のノードを正規化するのです。

学習の成功率を上げるとともに過学習もしにくくなるらしいです。

やりかた

標準化して線形変換するだけです。

標準化：

あるレイヤーのノード群の平均値μと分散sを求める

各ノードの値xから平均値μを引いて標準偏差σで割った値が標準化された値z

線形変換：

zにパラメータw,バイアスbを使って　y=wz+bへ線形変換する。

 self.bn1 =  nn.LayerNorm(self.fc1_dims)

1	self.bn1 = nn.LayerNorm(self.fc1_dims)

正確に言うとこれはバッチ正規化の発展系であるレイヤーノーマライゼーションを使っています。

ActorNNクラスの改造：

重みパラメータ、バイアスパラメータの初期値

今まではランダムに初期値を決めていたところをHeの初期値に変更しました。つまり、ネットワークの各層のノード数ActorNN.各fc.weight.data.size()[0]に応じて、初期値の上下限f1,f2を決定するようにしました。nn.init.uniform_()。

各層の入力値を正規化

今までは各層への入力値は特に加工せずに活性化関数へ入れていましたが、入力値は正規化nn.LayerNorm()を適用してから活性化関数に入れるように変更しました。入力値→正規化bn→活性化関数ReLU。

class ActorNN(nn.Module):
    def __init__(self, device, alpha=0.001, n_obs_space=17, n_action_space=6,
                                    layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):
        #print('ActorNN.__init__ is working.')
        super(ActorNN, self).__init__()

        self.fc1 = nn.Linear(n_obs_space, layer1_size)
        f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値   　-fから+fの範囲で一様分布
        nn.init.uniform_(self.fc1.bias, -f1, +f1)   # バイアス初期値 -fから+fの範囲で一様分布

        self.bn1 =  nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

        self.fc2 = nn.Linear(layer1_size, layer2_size)
        f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc2.weight, -f2, +f2) # -fから+fの範囲で一様分布
        nn.init.uniform_(self.fc2.bias, -f2, +f2) # -fから+fの範囲で一様分布

        self.bn2 =  nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

        self.fc3 = nn.Linear(layer2_size, n_action_space) # 


        #26.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=alpha)
        #self.optimizer = optim.SGD(self.parameters(), lr=alpha)


    def forward(self, obs):
        #print('AgetDDPG.ActorNN.forward is working')
        #print('====ここまではOK1====')
        x = self.fc1(obs)
        x = self.bn1(x)
        x = F.relu(x)

        x = self.fc2(x)
        x = self.bn2(x)
        x = F.relu(x)

        x = self.fc3(x)
        action = F.tanh(x)

        return action

class ActorNN(nn.Module):

def __init__(self, device, alpha=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):

#print('ActorNN.__init__ is working.')

super(ActorNN, self).__init__()

self.fc1 = nn.Linear(n_obs_space, layer1_size)

f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値　-fから+fの範囲で一様分布

nn.init.uniform_(self.fc1.bias, -f1, +f1) # バイアス初期値 -fから+fの範囲で一様分布

self.bn1 = nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

self.fc2 = nn.Linear(layer1_size, layer2_size)

f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc2.weight, -f2, +f2) # -fから+fの範囲で一様分布

nn.init.uniform_(self.fc2.bias, -f2, +f2) # -fから+fの範囲で一様分布

self.bn2 = nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

self.fc3 = nn.Linear(layer2_size, n_action_space) #

#26.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=alpha)

#self.optimizer = optim.SGD(self.parameters(), lr=alpha)

def forward(self, obs):

#print('AgetDDPG.ActorNN.forward is working')

#print('====ここまではOK1====')

x = self.fc1(obs)

x = self.bn1(x)

x = F.relu(x)

x = self.fc2(x)

x = self.bn2(x)

x = F.relu(x)

x = self.fc3(x)

action = F.tanh(x)

return action

CriticNNクラスの改造：

こちらも考え方は同じです。

class CriticNN(nn.Module):

    def __init__(self, device, beta=0.001, n_obs_space=17, n_action_space=6,
                 layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):
        #print('CriticNN.__init__ is working.')
        super(CriticNN, self).__init__()

        # クリティックNNは観察空間+行動空間の２つを入力とする構造
        input_dim = n_obs_space + n_action_space
        self.fc1 = nn.Linear(input_dim, layer1_size)

        f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値   　-fから+fの範囲で一様分布
        nn.init.uniform_(self.fc1.bias, -f1, +f1)   # バイアス初期値 -fから+fの範囲で一様分布

        self.bn1 =  nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

        self.fc2 = nn.Linear(layer1_size, layer2_size)
        f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc2.weight, -f1, +f1) # 重み初期値   　-fから+fの範囲で一様分布
        nn.init.uniform_(self.fc2.bias, -f1, +f1)   # バイアス初期値 -fから+fの範囲で一様分布

        self.bn2 =  nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

        self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

        #27.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=beta)
        #self.optimizer = optim.SGD(self.parameters(), lr=beta)

class CriticNN(nn.Module):

def __init__(self, device, beta=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):

#print('CriticNN.__init__ is working.')

super(CriticNN, self).__init__()

# クリティックNNは観察空間+行動空間の２つを入力とする構造

input_dim = n_obs_space + n_action_space

self.fc1 = nn.Linear(input_dim, layer1_size)

f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値　-fから+fの範囲で一様分布

nn.init.uniform_(self.fc1.bias, -f1, +f1) # バイアス初期値 -fから+fの範囲で一様分布

self.bn1 = nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

self.fc2 = nn.Linear(layer1_size, layer2_size)

f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc2.weight, -f1, +f1) # 重み初期値　-fから+fの範囲で一様分布

nn.init.uniform_(self.fc2.bias, -f1, +f1) # バイアス初期値 -fから+fの範囲で一様分布

self.bn2 = nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

#27.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=beta)

#self.optimizer = optim.SGD(self.parameters(), lr=beta)

学習結果

1000エピソード以上学習しましたが、どういうことでしょう調子いいのは３００エピソードくらいのところで、そこから一気に悪化しています。

横軸：エピソード、縦軸：収益

ハーフチーターは一体何をやっているのでしょうか？

開始直後に素早く美しく前転し、ひっくり返りながらバタバタしていました。どうやら３００回転超えたあたりから学習するべきデータが間違ったものしかない状況になり、回復しなかったと推測します。負のスパイラルに落ち込んでいったのでしょう。

反省

今回の条件を確認します。

agentインスタンス：

alpha=0.01,

beta=0.01,

gamma=0.99,

tau=0.01,

n_obs_space=17 ,

n_action_space=6,

n_state_action_value=1,

layer1_size=256,

layer2_size=256,

layer3_size=256,

batch_size=256,

AgentDDPGクラス__init__():

alpha=0.000025,

beta=0.00025,

amma=0.99,

tau=0.001,

n_obs_space=17 ,

n_action_space=6,

n_state_action_value=1,

layer1_size=64,

layer2_size=64,

layer3_size=64,

batch_size=64,

self.actorインスタンス:

alpha=0.000025,※ここ間違った。alpha=self.alphaにするべき

n_obs_space=17,※ここ間違った。同上

n_action_space=6,※ここ間違った。同上

layer1_size=64,※ここ間違った。同上

layer2_size=64,※ここ間違った。同上

layer3_size=64,※ここ間違った。同上

batch_size=64※ここ間違った。同上

なので actorとしては

ActorNN:He適用, alpha=0.000025, Adam

batch64,obs17→17 fc1 64→64 bn1 64→64 ReLU 64→64 fc2 64→64 bn2 64→64ReLU64→64fc3 6 →Tanh6→ action6

※layer3_sizeは不使用

という状況でした。一部間違っていました。直します。

修整後↓

self.actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

ちなみにActorNNの初期化メソドは

ActorNNクラス__init__():

alpha=0.001

n_obs_space=17,

n_action_space=6

layer1_size=256,

layer2_size=256,

layer3_size=256,

batch_size=64

です。

target_actorインスタンスも下記のように間違っているので

self.target_actor = ActorNN(device=self.device, alpha=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, layer3_size=64, batch_size=64)

直します。↓修整後

self.target_actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

次に、target_criticインスタンスを見ていきます。

beta=0.000025,※ここも間違い。self.betaにするべき

n_obs_space=17,※同上

n_action_space=6,※同上

layer1_size=64,※同上

layer2_size=64,※同上

layer3_size=64,※同上

batch_size=64)※同上

これも間違っているので修正。修整後はこちら↓

self.target_critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

同じくtarget_criticインスタンスもself.なんちゃらにしていないので修正が必要です。修整後↓

self.critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

なので target_criticとしては

CriticNN:He適用, beta=0.000025, Adam

batch64,obs17+act6→input23 fc1 64→64 bn1 64→64 ReLU 64→64 fc2 64→64 bn2 64→64fc3 1→活性化関数なし→Q_value 1

※layer3_sizeは不使用

ちなみに

CriticNNクラスの__init__()

beta=0.001,

n_obs_space=17,

n_action_space=6,

layer1_size=256,

layer2_size=256,

layer3_size=256,

batch_size=64):

です。

現在までのまとめ

学習率とノード数を間違って入れていましたが、これが悪いとは現時点では言えません。

可能性としてはバッファメモリが１００００で１エピソード2000ステップなので５回連続でダメな収益結果の場合、「ひっくり返ってお終い」、のようなダメな経験しか持ってない状態になります。

これが、二度とまともな状態に学習が継続できない要因ではないでしょうか。

（メモ：ステップを400とすると１エピソードがなぜか５倍の2000ステップまで実行されます。仕様ですかね。）

修正したコード

ひとまず、間違っていた部分を直したので張っておきます。

agent = AgentDDPG(device=device, alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=256, layer2_size=256, layer3_size=256, batch_size=256, mode=EVAL_TRAIN_MODE) # cuda追加

がネットワーク生成までこのパラメータが適用されるように修正しました。

import gymnasium as gym
import time
import torch as T
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
import os

# 44.OUActionNOoiseクラスを作成する
class OUActionNoise(object):
    def __init__(self, mu, sigma=0.15, theta=0.2, dt=1e-2, x0=None):
        self.mu = mu
        self.sigma = sigma
        self.theta = theta
        self.dt = dt
        self.x0 = x0
        self.reset()

    def __call__(self):
        x = self.x_prev + self.theta * (self.mu - self.x_prev) * self.dt + \
        self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)
        self.x_prev = x
        return x

    def reset(self):
        self.x_prev = self.x0 if self.x0 is not None else np.zeros_like(self.mu)


# 10. ReplayBufferクラスを新規作成する
class ReplayBuffer:
    def __init__(self, max_memory_size, n_obs_space, n_action_space):
        self.max_memory_size = max_memory_size
        self.n_obs_space = n_obs_space
        self.n_action_space = n_action_space

        self.memory_count = 0

        self.state_memory = np.zeros((self.max_memory_size, self.n_obs_space))
        self.action_memory =  np.zeros((self.max_memory_size, self.n_action_space))
        self.reward_memory =  np.zeros(self.max_memory_size)
        self.next_state_memory =  np.zeros((self.max_memory_size, self.n_obs_space))
        self.terminal_memory =  np.zeros(self.max_memory_size)
        #self.terminal_memory = np.zeros(self.max_memory_size, dtype=np.bool)

    # 11.トランジション保存のためstore_transitionメソドを作成する
    def store_transition(self, obs, action, reward, next_state, done):
        #print('store_transition is working.')
        index = self.memory_count % self.max_memory_size # 最大メモリー数に到達したら、古いデータから上書きされていくギミック
        #print('obs.detach().numpy().flatten():',obs.detach().numpy().flatten())
        self.state_memory[index] = obs.detach().numpy().flatten()
        self.action_memory[index] = action.flatten()
        self.reward_memory[index] = reward.flatten()
        self.next_state_memory[index] = next_state.flatten()
        self.terminal_memory[index] = 1 - int(done) # ゴールならterminal = 0 となるように

        self.memory_count += 1
        #print('memory_count :', agent.memory.memory_count)

    # 16 バッファメモリーからランダムに抽出する
    def sample_buffer(self, batch_size):
        # indexが最大メモリに到達していない場合を想定する。
        max_index = min(self.max_memory_size, self.memory_count)
        choosed_index = np.random.choice(max_index, batch_size)
        
        observations = self.state_memory[choosed_index]
        actions = self.action_memory[choosed_index]
        rewards = self.reward_memory[choosed_index]
        next_states = self.next_state_memory[choosed_index]
        terminals = self.terminal_memory[choosed_index]

        return observations, actions, rewards, next_states, terminals


# 6.ActorNNクラスを新規作成する
class ActorNN(nn.Module):
    def __init__(self, device, alpha=0.001, n_obs_space=17, n_action_space=6,
                                    layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):
        #print('ActorNN.__init__ is working.')
        super(ActorNN, self).__init__()

        self.fc1 = nn.Linear(n_obs_space, layer1_size)
        f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値   　-fから+fの範囲で一様分布
        nn.init.uniform_(self.fc1.bias, -f1, +f1)   # バイアス初期値 -fから+fの範囲で一様分布

        self.bn1 =  nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

        self.fc2 = nn.Linear(layer1_size, layer2_size)
        f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc2.weight, -f2, +f2) # -fから+fの範囲で一様分布
        nn.init.uniform_(self.fc2.bias, -f2, +f2) # -fから+fの範囲で一様分布
        print(self.fc2.weight.data.size()[0])

        self.bn2 =  nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

        self.fc3 = nn.Linear(layer2_size, n_action_space) # 


        #26.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=alpha)
        #self.optimizer = optim.SGD(self.parameters(), lr=alpha)


    def forward(self, obs):
        #print('AgetDDPG.ActorNN.forward is working')
        #print('====ここまではOK1====')
        x = self.fc1(obs)
        x = self.bn1(x)
        x = F.relu(x)

        x = self.fc2(x)
        x = self.bn2(x)
        x = F.relu(x)

        x = self.fc3(x)
        action = F.tanh(x)

        return action

# 22.CriticNNクラスを新規作成する
class CriticNN(nn.Module):

    def __init__(self, device, beta=0.001, n_obs_space=17, n_action_space=6,
                 layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):
        #print('CriticNN.__init__ is working.')
        super(CriticNN, self).__init__()

        # クリティックNNは観察空間+行動空間の２つを入力とする構造
        input_dim = n_obs_space + n_action_space
        self.fc1 = nn.Linear(input_dim, layer1_size)

        f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値   　-fから+fの範囲で一様分布
        nn.init.uniform_(self.fc1.bias, -f1, +f1)   # バイアス初期値 -fから+fの範囲で一様分布

        self.bn1 =  nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

        self.fc2 = nn.Linear(layer1_size, layer2_size)
        f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値
        nn.init.uniform_(self.fc2.weight, -f1, +f1) # 重み初期値   　-fから+fの範囲で一様分布
        nn.init.uniform_(self.fc2.bias, -f1, +f1)   # バイアス初期値 -fから+fの範囲で一様分布

        self.bn2 =  nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

        self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

        #27.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=beta)
        #self.optimizer = optim.SGD(self.parameters(), lr=beta)

    def forward(self, obs, action):
        input_data = T.cat([obs, action], dim=1)
        x = self.fc1(input_data)
        x = self.bn1(x)
        x = F.relu(x)

        x = self.fc2(x)
        x = self.bn2(x)
        x = F.relu(x)

        x = self.fc3(x)

        return x #一つの状態価値を出力する。

# 3.エージェントクラスを定義する
class AgentDDPG:

    def __init__(self, device, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=64, layer2_size=64, layer3_size=64, batch_size=64, mode='train_mode'):
        #print('AgentDDPG.__init__ is working.')
        # 5.ActorNNクラスのインスタンスを生成する
        self.device = device

        self.alpha = alpha
        self.beta = beta
        self.gamma = gamma
        self.tau = tau
        
        self.n_obs_space = n_obs_space
        self.n_action_space = n_action_space

        self.n_state_action_value = n_state_action_value

        self.layer1_size = layer1_size
        self.layer2_size = layer2_size
        self.layer3_size = layer3_size

        # 13.バッチサイズを決めておく
        self.batch_size = batch_size 

        self.actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,
                            layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size) 
        
        if os.path.isfile('actor_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.actor.load_state_dict(T.load('actor_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'actor_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'actor_params.pt')

        # actorネットワークをGPUへ転送
        self.actor.to(device)
        
        # 9.memoryインスタンスを追加
        self.MAX_MEMORY_SIZE = 10000
        self.memory = ReplayBuffer(max_memory_size=self.MAX_MEMORY_SIZE,
                                   n_obs_space=self.n_obs_space,
                                   n_action_space=self.n_action_space)
        
        # 19.ターゲットアクターネットワークインスタンスtarget_actorを作成する
        # actorとtarget_actorのネットワークは同じActorNNで良い
        self.target_actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,
                                    layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

        if os.path.isfile('target_actor_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.target_actor.load_state_dict(T.load('target_actor_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'target_actor_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'target_actor_params.pt')


        # target_actorネットワークをGPUへ転送
        self.target_actor.to(device)

        # 21.ターゲットクリティックネットワークインスタンスtareget_criticを作成する
        self.target_critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,
                                    layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

        if os.path.isfile('target_critic_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.target_critic.load_state_dict(T.load('target_critic_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'target_critic_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'target_critic_params.pt')

         # target_criticネットワークをGPUへ転送
        self.target_critic.to(device)

        # 24.クリティックネットワークインスタンスcriticを作成する。

        self.critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,
                                    layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)


        if os.path.isfile('critic_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.critic.load_state_dict(T.load('critic_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'critic_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'critic_params.pt')
            
        # criticネットワークをGPUへ転送
        self.critic.to(device)
        
        # アクターロスとクリティックロス
        self.actor_loss = 0
        self.critic_loss = 0
        
        # 45.行動ノイズのインスタンス化
        self.mode = mode
        if self.mode == 'train_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space))
        elif self.mode == 'eval_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)
        else:
            print('mode error')
        

    def choose_action(self, obs): # GPU対応済み
        #print('AgentDDPG.choose_action is working.')
        # 4.方策（アクター）はニューラルネットワークで表現する。
        #   ActorNNクラスを新規作成し、インスタンスactorとして使用する。
        obs = obs.to(device)
        action = self.actor.forward(obs)
        action = action.cpu()

        # 46.行動ノイズを入れて探索性を向上させる。  
        action += T.tensor(self.noise(), dtype=T.float32)
        action = action.detach().numpy()

        return action
    
    # 8.remenberメソドを追加
    def remember(self, obs, action, reward, next_state, done):
        self.memory.store_transition(obs, action, reward, next_state, done)

    # 13.learnメソドを追加
    def learn(self):
        # 14.バッチサイズ分のトランジションが集まるまでは何も実行しない。
        if self.memory.memory_count < self.batch_size:
            return
        
        # 15.メモリバッファからデータを抜き出す sample_buffer()
        # バッチ化されているので変数名を複数形にする
        observations, actions, rewards, next_states, terminals = self.memory.sample_buffer(self.batch_size)


        # 17.抜き出したデータをpytorchで微分可能なようにtorch.tensor化する 
        observations = T.tensor(observations, dtype=T.float32).to(device)
        actions = T.tensor(actions, dtype=T.float32).to(device)
        rewards = T.tensor(rewards, dtype=T.float32).to(device)
        next_states = T.tensor(next_states, dtype=T.float32).to(device)
        terminals = T.tensor(terminals, dtype=T.float32).to(device)


        # 18.ターゲットアクターネットワークインスタンスtarget_actorに
        # 次の状態next_satesを入れて、ターゲットアクションtarget_actionsとして取り出す。
        # このターゲットネットワークはターゲットでないネットワークとNNパラメータを共有させる。
        #print('next_states :', next_states)
        target_actions = self.target_actor.forward(next_states)


        # 20.ターゲットクリティックネットワークインスタンスtarget_criticに
        # 次の状態next_statesと上記より算出したターゲットアクションの２つを入力して
        # 価値関数の推定値ターゲットバリューを出力する。
        # TDターゲット：r + γ*V(w)[s_t+1] の部分のこと。
        # ターゲットクリティックバリューはターゲットアクターネットワークを使う
        target_critic_values = self.target_critic.forward(next_states, target_actions)

        
        # 23.ベースラインとして機能するクリティックネットワーク（価値関数V(w)[s_t]ネットワーク）に
        # 現在の状態observationsと行動actionsを入力して
        # クリティックバリューを算出する
        critic_values = self.critic.forward(observations, actions)
        

        # 25.TDターゲットを算出する：r + γ*V(w)[s_t+1]
        td_targets = []
        for i in range(self.batch_size):
            td_target = rewards[i] + self.gamma * target_critic_values[i] * terminals[i]
            td_targets.append(td_target)

        # TDターゲットの形をバッチに整える
        td_targets = T.tensor(td_targets, dtype=T.float32).to(device)
        td_targets = td_targets.view(self.batch_size, 1) #viewはreshapeと同じ。64x1に見え方を変更した、という意味
        #print('td_targets :', td_targets)


        # ==== （１）クリティックの学習 ====

        # 28.クリティックの勾配をゼロに初期化する
        self.critic.optimizer.zero_grad()

        # 29. TDターゲットと状態価値の二乗誤差を算出して、クリティックの損失関数とする。バッチサイズは６４個
        critic_loss = F.mse_loss(td_targets, critic_values)
        self.critic_loss = critic_loss
        #print('critic_loss : ', critic_loss) # tensor(0.0485, grad_fn=<MseLossBackward0>)

        # 30. クリティックの損失関数を微分して、勾配を算出する
        critic_loss.backward()

        # 31. 勾配からオプティマイザーによってクリティックのパラメータ（重みとバイアス）を更新する
        self.critic.optimizer.step()


        # ==== （２）アクターの学習 ====

        # 32. アクターの勾配をゼロに初期化する
        self.actor.optimizer.zero_grad()

        # 33. アクターに観測情報を入力して行動を算出する。バッチサイズは６４個
        predicted_actions = self.actor.forward(observations)

        # 34.アクターの損失関数を算出する
        #    Actorの目的は、Criticネットワークの出力（行動価値）を最大化するような行動を選択すること。
        #    なので、actorNN→criticNNのDDPG構造全体の出力結果をactor_lossとして、actorNNとcriticNNの両方をbackwardし、
        #    actorだけをパラメータ更新することによりactorの学習をすることができる。

        actor_loss = -self.critic.forward(observations, predicted_actions)
        actor_loss = T.mean(actor_loss)
        self.actor_loss = actor_loss

        #print(f'actor_loss: {actor_loss}, critic_loss: {critic_loss}')

        # 35. DDPG構造全体の損失関数actor_lossを微分し、勾配を算出する
        actor_loss.backward()

        # 36. 勾配からオプティマイザーによってアクターのパラメータだけを（重みとバイアス）を更新する
        self.actor.optimizer.step()
    
        # 37. 全ニューラルネットワークのパラメータを更新する。
        self.update_network_parameters()

    # 37. パラメータ更新メソド。
    def update_network_parameters(self, tau=None):
        if tau is None:
            tau = self.tau
    
        # 38. actor, critic, target_actor, target_criticのネットワーク内の全てのパラメータ（重みとバイアス）とその名前を取得する
        # actorとcriticは先ほど更新されたばかりのパラメーター
        actor_params = self.actor.named_parameters()
        critic_params = self.critic.named_parameters()
        target_actor_params = self.target_actor.named_parameters()
        target_critic_params = self.target_critic.named_parameters()
        #print('actor_params : ', actor_params) # actor_params :  <generator object Module.named_parameters at 0x000001661B2D9D48>

        # 39. パラメータをディクショナリとして取り出す。
        actor_params_dict = dict(actor_params)
        critic_params_dict = dict(critic_params)
        target_actor_params_dict = dict(target_actor_params)
        target_critic_params_dict = dict(target_critic_params)
        #print('actor_params_dict : ', actor_params_dict)
        #print(actor_params_dict.keys())


        # 40. クリティックの各パラメーター毎に 更新重みtau=0.0001の分だけほんの少しcriticパラメータをtarget_criticパラメータに近づける。
        for name in critic_params_dict:
            critic_params_dict[name] = tau * critic_params_dict[name].clone() + \
                                       (1-tau) * target_critic_params_dict[name].clone()
            
        # 41. 更新したcriticパラメータをtarget_criticのパラメータとしてロードする。
        self.target_critic.load_state_dict(critic_params_dict)

        # 42.アクターの各パラメーター毎に 更新重みtau=0.0001の分だけほんの少しactorパラメータをtarget_actorパラメータに近づける。
        for name in actor_params_dict:
            actor_params_dict[name] = tau * actor_params_dict[name].clone() + \
                                      (1 - tau) * target_actor_params_dict[name].clone()
            
        # 43. 更新したactorパラメータをtarget_actorのパラメータとしてロードする。
        self.target_actor.load_state_dict(actor_params_dict)


#### =================== メインスクリプト ======================= ####

device = T.device('cuda' if T.cuda.is_available() else 'cpu') # cuda追加
device = 'cpu' # 強制的にcpuを使う

EVAL_TRAIN_MODE = 'train_mode' # eval_mode 評価モードか train_mode 訓練モードかを選択
EPISODES = 10001 # episodes
STEPS = 400    # steps
DELAY_TIME = 0.00 # sec
print('Selected Mode : ', EVAL_TRAIN_MODE)

# 2.エージェントクラスのインスタンスを生成する
agent = AgentDDPG(device=device, alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=256, layer2_size=256, layer3_size=256, batch_size=256, mode=EVAL_TRAIN_MODE) # cuda追加

if EVAL_TRAIN_MODE == 'train_mode':
    env = gym.make("HalfCheetah-v4", render_mode='depth_array')

elif EVAL_TRAIN_MODE == 'eval_mode':
    env = gym.make("HalfCheetah-v4", render_mode= 'human')


total_rewards = []
actor_losses = []
critic_losses = []
for episode in range(EPISODES):
    obs = env.reset()
    obs = T.tensor(obs[0], dtype=T.float)


    reward: float = 0
    total_reward: float = 0
    done: bool = False
    for j in range(STEPS):
        env.render()
        
        # ここをDDPGに置き換えていく
        action = agent.choose_action(obs) # 1.Agentクラスを定義していく # GPU対応済み


        next_state, reward, done, _, info = env.step(action)
        #print('next_state, reward, done, _, info :', next_state, reward, done, _, info)

        #7. トラジェクトを保存する。経験再生(ReplayBuffer)
        agent.remember(obs, action, reward, next_state, int(done))
       

        #12. ニューラルネットワークを学習する
        agent.learn()

        # 26.エピソード内での報酬を累積していく
        total_reward += reward
        
        # 27. next_stateをobsとして再出発する
        #print('next_state:', next_state)
        obs = next_state
        obs = T.tensor(obs, dtype=T.float)
        # 28. チーターの動きを見たいのでスリープを入れる
        time.sleep(DELAY_TIME)

    #print('total_reward : ', total_reward)
    total_rewards.append(total_reward)

    actor_losses.append(float(agent.actor_loss)) 
    critic_losses.append(float(agent.critic_loss)) 

    # print('epsisode', i, 'score %.2f' % score, '100 game sverage %.2f' % np.mean(score_history[-100:]))
 
    # 47. 各ニューラルネットワークのパラメータを１０エピソード毎に保存する
    print('episode, total_reward : ', episode , total_reward)
    if episode % 10 == 0:
        T.save(agent.actor.state_dict(), 'actor_params.pt')
        T.save(agent.critic.state_dict(), 'critic_params.pt')
        T.save(agent.target_actor.state_dict(), 'target_actor_params.pt')
        T.save(agent.target_critic.state_dict(), 'target_critic_params.pt')
        print('==== params were saved. ====')

#print('total_rewards : ', total_rewards)
#plt.plot(total_rewards)

#plt.plot(actor_losses, label='actor_losses')
#plt.plot(critic_losses, label='critic_losses')
plt.plot(total_rewards, label='total_rewards')
plt.legend()
plt.grid(True)
plt.ioff()
plt.show()

env.close() # 空なんですけど・・・

print('script is done.')

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

import gymnasium as gym

import time

import torch as T

import torch.nn as nn

import torch.nn.functional as F

import torch.optim as optim

import numpy as np

import matplotlib.pyplot as plt

import os

# 44.OUActionNOoiseクラスを作成する

class OUActionNoise(object):

def __init__(self, mu, sigma=0.15, theta=0.2, dt=1e-2, x0=None):

self.mu = mu

self.sigma = sigma

self.theta = theta

self.dt = dt

self.x0 = x0

self.reset()

def __call__(self):

x = self.x_prev + self.theta * (self.mu - self.x_prev) * self.dt + \

self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)

self.x_prev = x

return x

def reset(self):

self.x_prev = self.x0 if self.x0 is not None else np.zeros_like(self.mu)

# 10. ReplayBufferクラスを新規作成する

class ReplayBuffer:

def __init__(self, max_memory_size, n_obs_space, n_action_space):

self.max_memory_size = max_memory_size

self.n_obs_space = n_obs_space

self.n_action_space = n_action_space

self.memory_count = 0

self.state_memory = np.zeros((self.max_memory_size, self.n_obs_space))

self.action_memory = np.zeros((self.max_memory_size, self.n_action_space))

self.reward_memory = np.zeros(self.max_memory_size)

self.next_state_memory = np.zeros((self.max_memory_size, self.n_obs_space))

self.terminal_memory = np.zeros(self.max_memory_size)

#self.terminal_memory = np.zeros(self.max_memory_size, dtype=np.bool)

# 11.トランジション保存のためstore_transitionメソドを作成する

def store_transition(self, obs, action, reward, next_state, done):

#print('store_transition is working.')

index = self.memory_count % self.max_memory_size # 最大メモリー数に到達したら、古いデータから上書きされていくギミック

#print('obs.detach().numpy().flatten():',obs.detach().numpy().flatten())

self.state_memory[index] = obs.detach().numpy().flatten()

self.action_memory[index] = action.flatten()

self.reward_memory[index] = reward.flatten()

self.next_state_memory[index] = next_state.flatten()

self.terminal_memory[index] = 1 - int(done) # ゴールならterminal = 0 となるように

self.memory_count += 1

#print('memory_count :', agent.memory.memory_count)

# 16 バッファメモリーからランダムに抽出する

def sample_buffer(self, batch_size):

# indexが最大メモリに到達していない場合を想定する。

max_index = min(self.max_memory_size, self.memory_count)

choosed_index = np.random.choice(max_index, batch_size)

observations = self.state_memory[choosed_index]

actions = self.action_memory[choosed_index]

rewards = self.reward_memory[choosed_index]

next_states = self.next_state_memory[choosed_index]

terminals = self.terminal_memory[choosed_index]

return observations, actions, rewards, next_states, terminals

# 6.ActorNNクラスを新規作成する

class ActorNN(nn.Module):

def __init__(self, device, alpha=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):

#print('ActorNN.__init__ is working.')

super(ActorNN, self).__init__()

self.fc1 = nn.Linear(n_obs_space, layer1_size)

f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値　-fから+fの範囲で一様分布

nn.init.uniform_(self.fc1.bias, -f1, +f1) # バイアス初期値 -fから+fの範囲で一様分布

self.bn1 = nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

self.fc2 = nn.Linear(layer1_size, layer2_size)

f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc2.weight, -f2, +f2) # -fから+fの範囲で一様分布

nn.init.uniform_(self.fc2.bias, -f2, +f2) # -fから+fの範囲で一様分布

print(self.fc2.weight.data.size()[0])

self.bn2 = nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

self.fc3 = nn.Linear(layer2_size, n_action_space) #

#26.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=alpha)

#self.optimizer = optim.SGD(self.parameters(), lr=alpha)

def forward(self, obs):

#print('AgetDDPG.ActorNN.forward is working')

#print('====ここまではOK1====')

x = self.fc1(obs)

x = self.bn1(x)

x = F.relu(x)

x = self.fc2(x)

x = self.bn2(x)

x = F.relu(x)

x = self.fc3(x)

action = F.tanh(x)

return action

# 22.CriticNNクラスを新規作成する

class CriticNN(nn.Module):

def __init__(self, device, beta=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, layer3_size=256, batch_size=64):

#print('CriticNN.__init__ is working.')

super(CriticNN, self).__init__()

# クリティックNNは観察空間+行動空間の２つを入力とする構造

input_dim = n_obs_space + n_action_space

self.fc1 = nn.Linear(input_dim, layer1_size)

f1 = 1 / np.sqrt(self.fc1.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc1.weight, -f1, +f1) # 重み初期値　-fから+fの範囲で一様分布

nn.init.uniform_(self.fc1.bias, -f1, +f1) # バイアス初期値 -fから+fの範囲で一様分布

self.bn1 = nn.LayerNorm(layer1_size) #レイヤーノーマライゼーション

self.fc2 = nn.Linear(layer1_size, layer2_size)

f2 = 1 / np.sqrt(self.fc2.weight.data.size()[0]) # Heの初期値

nn.init.uniform_(self.fc2.weight, -f1, +f1) # 重み初期値　-fから+fの範囲で一様分布

nn.init.uniform_(self.fc2.bias, -f1, +f1) # バイアス初期値 -fから+fの範囲で一様分布

self.bn2 = nn.LayerNorm(layer2_size) #レイヤーノーマライゼーション

self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

#27.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=beta)

#self.optimizer = optim.SGD(self.parameters(), lr=beta)

def forward(self, obs, action):

input_data = T.cat([obs, action], dim=1)

x = self.fc1(input_data)

x = self.bn1(x)

x = F.relu(x)

x = self.fc2(x)

x = self.bn2(x)

x = F.relu(x)

x = self.fc3(x)

return x #一つの状態価値を出力する。

# 3.エージェントクラスを定義する

class AgentDDPG:

def __init__(self, device, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=64, layer2_size=64, layer3_size=64, batch_size=64, mode='train_mode'):

#print('AgentDDPG.__init__ is working.')

# 5.ActorNNクラスのインスタンスを生成する

self.device = device

self.alpha = alpha

self.beta = beta

self.gamma = gamma

self.tau = tau

self.n_obs_space = n_obs_space

self.n_action_space = n_action_space

self.n_state_action_value = n_state_action_value

self.layer1_size = layer1_size

self.layer2_size = layer2_size

self.layer3_size = layer3_size

# 13.バッチサイズを決めておく

self.batch_size = batch_size

self.actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

if os.path.isfile('actor_params.pt'):

# パラメータファイルが存在する場合はロード

self.actor.load_state_dict(T.load('actor_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'actor_params.pt')

else:

print("パラメータファイルが見つかりません:", 'actor_params.pt')

# actorネットワークをGPUへ転送

self.actor.to(device)

# 9.memoryインスタンスを追加

self.MAX_MEMORY_SIZE = 10000

self.memory = ReplayBuffer(max_memory_size=self.MAX_MEMORY_SIZE,

n_obs_space=self.n_obs_space,

n_action_space=self.n_action_space)

# 19.ターゲットアクターネットワークインスタンスtarget_actorを作成する

# actorとtarget_actorのネットワークは同じActorNNで良い

self.target_actor = ActorNN(device=self.device, alpha=self.alpha, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

if os.path.isfile('target_actor_params.pt'):

# パラメータファイルが存在する場合はロード

self.target_actor.load_state_dict(T.load('target_actor_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'target_actor_params.pt')

else:

print("パラメータファイルが見つかりません:", 'target_actor_params.pt')

# target_actorネットワークをGPUへ転送

self.target_actor.to(device)

# 21.ターゲットクリティックネットワークインスタンスtareget_criticを作成する

self.target_critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

if os.path.isfile('target_critic_params.pt'):

# パラメータファイルが存在する場合はロード

self.target_critic.load_state_dict(T.load('target_critic_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'target_critic_params.pt')

else:

print("パラメータファイルが見つかりません:", 'target_critic_params.pt')

# target_criticネットワークをGPUへ転送

self.target_critic.to(device)

# 24.クリティックネットワークインスタンスcriticを作成する。

self.critic = CriticNN(device=self.device, beta=self.beta, n_obs_space=self.n_obs_space, n_action_space=self.n_action_space,

layer1_size=self.layer1_size, layer2_size=self.layer2_size, layer3_size=self.layer3_size, batch_size=self.batch_size)

if os.path.isfile('critic_params.pt'):

# パラメータファイルが存在する場合はロード

self.critic.load_state_dict(T.load('critic_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'critic_params.pt')

else:

print("パラメータファイルが見つかりません:", 'critic_params.pt')

# criticネットワークをGPUへ転送

self.critic.to(device)

# アクターロスとクリティックロス

self.actor_loss = 0

self.critic_loss = 0

# 45.行動ノイズのインスタンス化

self.mode = mode

if self.mode == 'train_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space))

elif self.mode == 'eval_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)

else:

print('mode error')

def choose_action(self, obs): # GPU対応済み

#print('AgentDDPG.choose_action is working.')

# 4.方策（アクター）はニューラルネットワークで表現する。

# ActorNNクラスを新規作成し、インスタンスactorとして使用する。

obs = obs.to(device)

action = self.actor.forward(obs)

action = action.cpu()

# 46.行動ノイズを入れて探索性を向上させる。

action += T.tensor(self.noise(), dtype=T.float32)

action = action.detach().numpy()

return action

# 8.remenberメソドを追加

def remember(self, obs, action, reward, next_state, done):

self.memory.store_transition(obs, action, reward, next_state, done)

# 13.learnメソドを追加

def learn(self):

# 14.バッチサイズ分のトランジションが集まるまでは何も実行しない。

if self.memory.memory_count < self.batch_size:

return

# 15.メモリバッファからデータを抜き出す sample_buffer()

# バッチ化されているので変数名を複数形にする

observations, actions, rewards, next_states, terminals = self.memory.sample_buffer(self.batch_size)

# 17.抜き出したデータをpytorchで微分可能なようにtorch.tensor化する

observations = T.tensor(observations, dtype=T.float32).to(device)

actions = T.tensor(actions, dtype=T.float32).to(device)

rewards = T.tensor(rewards, dtype=T.float32).to(device)

next_states = T.tensor(next_states, dtype=T.float32).to(device)

terminals = T.tensor(terminals, dtype=T.float32).to(device)

# 18.ターゲットアクターネットワークインスタンスtarget_actorに

# 次の状態next_satesを入れて、ターゲットアクションtarget_actionsとして取り出す。

# このターゲットネットワークはターゲットでないネットワークとNNパラメータを共有させる。

#print('next_states :', next_states)

target_actions = self.target_actor.forward(next_states)

# 20.ターゲットクリティックネットワークインスタンスtarget_criticに

# 次の状態next_statesと上記より算出したターゲットアクションの２つを入力して

# 価値関数の推定値ターゲットバリューを出力する。

# TDターゲット：r + γ*V(w)[s_t+1] の部分のこと。

# ターゲットクリティックバリューはターゲットアクターネットワークを使う

target_critic_values = self.target_critic.forward(next_states, target_actions)

# 23.ベースラインとして機能するクリティックネットワーク（価値関数V(w)[s_t]ネットワーク）に

# 現在の状態observationsと行動actionsを入力して

# クリティックバリューを算出する

critic_values = self.critic.forward(observations, actions)

# 25.TDターゲットを算出する：r + γ*V(w)[s_t+1]

td_targets = []

for i in range(self.batch_size):

td_target = rewards[i] + self.gamma * target_critic_values[i] * terminals[i]

td_targets.append(td_target)

# TDターゲットの形をバッチに整える

td_targets = T.tensor(td_targets, dtype=T.float32).to(device)

td_targets = td_targets.view(self.batch_size, 1) #viewはreshapeと同じ。64x1に見え方を変更した、という意味

#print('td_targets :', td_targets)

# ==== （１）クリティックの学習 ====

# 28.クリティックの勾配をゼロに初期化する

self.critic.optimizer.zero_grad()

# 29. TDターゲットと状態価値の二乗誤差を算出して、クリティックの損失関数とする。バッチサイズは６４個

critic_loss = F.mse_loss(td_targets, critic_values)

self.critic_loss = critic_loss

#print('critic_loss : ', critic_loss) # tensor(0.0485, grad_fn=<MseLossBackward0>)

# 30. クリティックの損失関数を微分して、勾配を算出する

critic_loss.backward()

# 31. 勾配からオプティマイザーによってクリティックのパラメータ（重みとバイアス）を更新する

self.critic.optimizer.step()

# ==== （２）アクターの学習 ====

# 32. アクターの勾配をゼロに初期化する

self.actor.optimizer.zero_grad()

# 33. アクターに観測情報を入力して行動を算出する。バッチサイズは６４個

predicted_actions = self.actor.forward(observations)

# 34.アクターの損失関数を算出する

# Actorの目的は、Criticネットワークの出力（行動価値）を最大化するような行動を選択すること。

# なので、actorNN→criticNNのDDPG構造全体の出力結果をactor_lossとして、actorNNとcriticNNの両方をbackwardし、

# actorだけをパラメータ更新することによりactorの学習をすることができる。

actor_loss = -self.critic.forward(observations, predicted_actions)

actor_loss = T.mean(actor_loss)

self.actor_loss = actor_loss

#print(f'actor_loss: {actor_loss}, critic_loss: {critic_loss}')

# 35. DDPG構造全体の損失関数actor_lossを微分し、勾配を算出する

actor_loss.backward()

# 36. 勾配からオプティマイザーによってアクターのパラメータだけを（重みとバイアス）を更新する

self.actor.optimizer.step()

# 37. 全ニューラルネットワークのパラメータを更新する。

self.update_network_parameters()

# 37. パラメータ更新メソド。

def update_network_parameters(self, tau=None):

if tau is None:

tau = self.tau

# 38. actor, critic, target_actor, target_criticのネットワーク内の全てのパラメータ（重みとバイアス）とその名前を取得する

# actorとcriticは先ほど更新されたばかりのパラメーター

actor_params = self.actor.named_parameters()

critic_params = self.critic.named_parameters()

target_actor_params = self.target_actor.named_parameters()

target_critic_params = self.target_critic.named_parameters()

#print('actor_params : ', actor_params) # actor_params : <generator object Module.named_parameters at 0x000001661B2D9D48>

# 39. パラメータをディクショナリとして取り出す。

actor_params_dict = dict(actor_params)

critic_params_dict = dict(critic_params)

target_actor_params_dict = dict(target_actor_params)

target_critic_params_dict = dict(target_critic_params)

#print('actor_params_dict : ', actor_params_dict)

#print(actor_params_dict.keys())

# 40. クリティックの各パラメーター毎に更新重みtau=0.0001の分だけほんの少しcriticパラメータをtarget_criticパラメータに近づける。

for name in critic_params_dict:

critic_params_dict[name] = tau * critic_params_dict[name].clone() + \

(1-tau) * target_critic_params_dict[name].clone()

# 41. 更新したcriticパラメータをtarget_criticのパラメータとしてロードする。

self.target_critic.load_state_dict(critic_params_dict)

# 42.アクターの各パラメーター毎に更新重みtau=0.0001の分だけほんの少しactorパラメータをtarget_actorパラメータに近づける。

for name in actor_params_dict:

actor_params_dict[name] = tau * actor_params_dict[name].clone() + \

(1 - tau) * target_actor_params_dict[name].clone()

# 43. 更新したactorパラメータをtarget_actorのパラメータとしてロードする。

self.target_actor.load_state_dict(actor_params_dict)

#### =================== メインスクリプト ======================= ####

device = T.device('cuda' if T.cuda.is_available() else 'cpu') # cuda追加

device = 'cpu' # 強制的にcpuを使う

EVAL_TRAIN_MODE = 'train_mode' # eval_mode 評価モードか train_mode 訓練モードかを選択

EPISODES = 10001 # episodes

STEPS = 400 # steps

DELAY_TIME = 0.00 # sec

print('Selected Mode : ', EVAL_TRAIN_MODE)

# 2.エージェントクラスのインスタンスを生成する

agent = AgentDDPG(device=device, alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=256, layer2_size=256, layer3_size=256, batch_size=256, mode=EVAL_TRAIN_MODE) # cuda追加

if EVAL_TRAIN_MODE == 'train_mode':

env = gym.make("HalfCheetah-v4", render_mode='depth_array')

elif EVAL_TRAIN_MODE == 'eval_mode':

env = gym.make("HalfCheetah-v4", render_mode= 'human')

total_rewards = []

actor_losses = []

critic_losses = []

for episode in range(EPISODES):

obs = env.reset()

obs = T.tensor(obs[0], dtype=T.float)

reward: float = 0

total_reward: float = 0

done: bool = False

for j in range(STEPS):

env.render()

# ここをDDPGに置き換えていく

action = agent.choose_action(obs) # 1.Agentクラスを定義していく # GPU対応済み

next_state, reward, done, _, info = env.step(action)

#print('next_state, reward, done, _, info :', next_state, reward, done, _, info)

#7. トラジェクトを保存する。経験再生(ReplayBuffer)

agent.remember(obs, action, reward, next_state, int(done))

#12. ニューラルネットワークを学習する

agent.learn()

# 26.エピソード内での報酬を累積していく

total_reward += reward

# 27. next_stateをobsとして再出発する

#print('next_state:', next_state)

obs = next_state

obs = T.tensor(obs, dtype=T.float)

# 28. チーターの動きを見たいのでスリープを入れる

time.sleep(DELAY_TIME)

#print('total_reward : ', total_reward)

total_rewards.append(total_reward)

actor_losses.append(float(agent.actor_loss))

critic_losses.append(float(agent.critic_loss))

# print('epsisode', i, 'score %.2f' % score, '100 game sverage %.2f' % np.mean(score_history[-100:]))

# 47. 各ニューラルネットワークのパラメータを１０エピソード毎に保存する

print('episode, total_reward : ', episode , total_reward)

if episode % 10 == 0:

T.save(agent.actor.state_dict(), 'actor_params.pt')

T.save(agent.critic.state_dict(), 'critic_params.pt')

T.save(agent.target_actor.state_dict(), 'target_actor_params.pt')

T.save(agent.target_critic.state_dict(), 'target_critic_params.pt')

print('==== params were saved. ====')

#print('total_rewards : ', total_rewards)

#plt.plot(total_rewards)

#plt.plot(actor_losses, label='actor_losses')

#plt.plot(critic_losses, label='critic_losses')

plt.plot(total_rewards, label='total_rewards')

plt.legend()

plt.grid(True)

plt.ioff()

plt.show()

env.close() # 空なんですけど・・・

print('script is done.')

これの結果：学習が進みません。チーターの様子を見ると開始直後に静止してお終いです。ぐーたらになってしまいました。

ノード数が多すぎる？256

学習率が小さすぎる？0.01

パラメータの初期値　Heがうまくいってない？/1√256は小さすぎる？

レイヤー正規化が上手くいってない？

次回へ続きます。

DDPG by gymnasium １４日目

本日のお題は

保存したパラメータを読み出すのはactorとtarget_actorまたcriticとtarget_criticで共通で良いのだろうか。

です。結果として共通で良いです。

つまりactorとtarget_actorはactor_params.ptを呼び出して、criticとtarget_criticはcritic_params.ptを呼び出せば成り立ちます。

ただ、実行開始直後が同じパラメータになってしまうので、リプレイバッファに経験が貯まりTDターゲットの再計算が始まるまではcriticとの差が小さいので、しばらくは学習の進み方が遅くなるのではないかと予想しております。

実際は問題になるほどではありませんでしたが、ここはセオリー通り共通ではなくてそれぞれのパラメータを読み込むように修正しました。

ActorNNクラスの__initi__()の中に

        if os.path.isfile('actor_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.load_state_dict(T.load('actor_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'actor_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'actor_params.pt')

if os.path.isfile('actor_params.pt'):

# パラメータファイルが存在する場合はロード

self.load_state_dict(T.load('actor_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'actor_params.pt')

else:

print("パラメータファイルが見つかりません:", 'actor_params.pt')

そしてCriticNNクラスの_init__()の中に

        if os.path.isfile('critic_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.load_state_dict(T.load('critic_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'critic_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'critic_params.pt')

if os.path.isfile('critic_params.pt'):

# パラメータファイルが存在する場合はロード

self.load_state_dict(T.load('critic_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'critic_params.pt')

else:

print("パラメータファイルが見つかりません:", 'critic_params.pt')

と書いていたのを削除して、代わりに

actor, ciritc, target_critic, target_actorそれぞれのインスタンス生成直後に入れています。

import gymnasium as gym
import time
import torch as T
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
import os

""" nvidia CUDA Toolkit 12.1
https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exe_local
Download cuda_12.1.1_531.14_windows.exe
"""
""" pip install
pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu121
pip install gymnasium
pip install gymnasium[mujoco]
pip install matplotlib
pip install mujoco
"""
# 44.OUActionNOoiseクラスを作成する
class OUActionNoise(object):
    def __init__(self, mu, sigma=0.15, theta=0.2, dt=1e-2, x0=None):
        self.mu = mu
        self.sigma = sigma
        self.theta = theta
        self.dt = dt
        self.x0 = x0
        self.reset()

    def __call__(self):
        x = self.x_prev + self.theta * (self.mu - self.x_prev) * self.dt + \
        self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)
        self.x_prev = x
        return x

    def reset(self):
        self.x_prev = self.x0 if self.x0 is not None else np.zeros_like(self.mu)


# 10. ReplayBufferクラスを新規作成する
class ReplayBuffer:
    def __init__(self, max_memory_size, n_obs_space, n_action_space):
        self.max_memory_size = max_memory_size
        self.n_obs_space = n_obs_space
        self.n_action_space = n_action_space

        self.memory_count = 0

        self.state_memory = np.zeros((self.max_memory_size, self.n_obs_space))
        self.action_memory =  np.zeros((self.max_memory_size, self.n_action_space))
        self.reward_memory =  np.zeros(self.max_memory_size)
        self.next_state_memory =  np.zeros((self.max_memory_size, self.n_obs_space))
        self.terminal_memory =  np.zeros(self.max_memory_size)
        #self.terminal_memory = np.zeros(self.max_memory_size, dtype=np.bool)

    # 11.トランジション保存のためstore_transitionメソドを作成する
    def store_transition(self, obs, action, reward, next_state, done):
        #print('store_transition is working.')
        index = self.memory_count % self.max_memory_size # 最大メモリー数に到達したら、古いデータから上書きされていくギミック
        #print('obs.detach().numpy().flatten():',obs.detach().numpy().flatten())
        self.state_memory[index] = obs.detach().numpy().flatten()
        self.action_memory[index] = action.flatten()
        self.reward_memory[index] = reward.flatten()
        self.next_state_memory[index] = next_state.flatten()
        self.terminal_memory[index] = 1 - int(done) # ゴールならterminal = 0 となるように
        #print('state_memory :', self.state_memory)
        #print('action_memory :', self.action_memory)
        #print('reward_memory :', self.reward_memory)
        #print('next_state_memory :', self.next_state_memory)
        #print('memory.state_memory :', self.terminal_memory)

        #print('type of state_memory :', type(self.state_memory[0][0]))
        #print('type of action_memory :', type(self.action_memory[0][0]))
        #print('type of reward_memory :', type(self.reward_memory[0]))
        #print('type of next_state_memory :', type(self.next_state_memory[0][0]))
        #print('type of memory.state_memory :', type(self.terminal_memory[0]))

        self.memory_count += 1
        #print('memory_count :', agent.memory.memory_count)

    # 16 バッファメモリーからランダムに抽出する
    def sample_buffer(self, batch_size):
        # indexが最大メモリに到達していない場合を想定する。
        max_index = min(self.max_memory_size, self.memory_count)
        choosed_index = np.random.choice(max_index, batch_size)
        
        observations = self.state_memory[choosed_index]
        actions = self.action_memory[choosed_index]
        rewards = self.reward_memory[choosed_index]
        next_states = self.next_state_memory[choosed_index]
        terminals = self.terminal_memory[choosed_index]

        return observations, actions, rewards, next_states, terminals


# 6.ActorNNクラスを新規作成する
class ActorNN(nn.Module):
    def __init__(self, device, alpha=0.001, n_obs_space=17, n_action_space=6,
                                    layer1_size=256, layer2_size=256, batch_size=64):
        #print('ActorNN.__init__ is working.')
        super(ActorNN, self).__init__()
        self.fc1 = nn.Linear(n_obs_space, layer1_size)
        self.fc2 = nn.Linear(layer1_size, layer2_size)
        self.fc3 = nn.Linear(layer2_size, n_action_space)

        #26.最適化処理としてアダムを設定する
        #self.optimizer = optim.Adam(self.parameters(), lr=alpha)
        self.optimizer = optim.SGD(self.parameters(), lr=alpha)

        # 48. actorパラメータの読み出し
        # もし、パラメータのデータが存在していたらそのパラメータで初期化する。
        # パラメータファイルの存在チェック
        """
        if os.path.isfile('actor_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.load_state_dict(T.load('actor_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'actor_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'actor_params.pt')
        """

    def forward(self, obs):
        #print('AgetDDPG.ActorNN.forward is working')
        #print('====ここまではOK1====')
        x = self.fc1(obs)
        x = F.relu(x)
        x = self.fc2(x)
        x = F.relu(x)
        x = self.fc3(x)
        action = F.tanh(x)

        return action

# 22.CriticNNクラスを新規作成する
class CriticNN(nn.Module):

    def __init__(self, device, beta=0.001, n_obs_space=17, n_action_space=6,
                 layer1_size=256, layer2_size=256, batch_size=64):
        #print('CriticNN.__init__ is working.')
        super(CriticNN, self).__init__()

        # クリティックNNは観察空間+行動空間の２つを入力とする構造
        input_dim = n_obs_space + n_action_space
        self.fc1 = nn.Linear(input_dim, layer1_size)
        self.fc2 = nn.Linear(layer1_size, layer2_size)
        self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

        #27.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=beta)
        self.optimizer = optim.SGD(self.parameters(), lr=beta)

        # 49. criticパラメータの読み出し
        # もし、パラメータのデータが存在していたらそのパラメータで初期化する。
        # パラメータファイルの存在チェック
        """
        if os.path.isfile('critic_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.load_state_dict(T.load('critic_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'critic_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'critic_params.pt')
        """

    def forward(self, obs, action):
        input_data = T.cat([obs, action], dim=1)
        x = self.fc1(input_data)
        x = F.relu(x)
        x =self.fc2(x)
        x = F.relu(x)
        x = self.fc3(x)

        return x #一つの状態価値を出力する。

# 3.エージェントクラスを定義する
class AgentDDPG:

    def __init__(self, device, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=64, layer2_size=64, batch_size=64, mode='train_mode'):
        #print('AgentDDPG.__init__ is working.')
        # 5.ActorNNクラスのインスタンスを生成する
        self.device = device

        self.alpha = alpha
        self.beta = beta
        self.gamma = gamma
        self.tau = tau
        
        self.n_obs_space = n_obs_space
        self.n_action_space = n_action_space

        self.n_state_action_value = n_state_action_value

        self.layer1_size = layer1_size
        self.layer2_size = layer2_size

        # 13.バッチサイズを決めておく
        self.batch_size = batch_size 

        self.actor = ActorNN(device=self.device, alpha=0.000025, n_obs_space=17, n_action_space=6,
                            layer1_size=64, layer2_size=64, batch_size=64) 
        
        if os.path.isfile('actor_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.actor.load_state_dict(T.load('actor_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'actor_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'actor_params.pt')

        # actorネットワークをGPUへ転送
        self.actor.to(device)
        
        # 9.memoryインスタンスを追加
        self.MAX_MEMORY_SIZE = 10000
        self.memory = ReplayBuffer(max_memory_size=self.MAX_MEMORY_SIZE,
                                   n_obs_space=self.n_obs_space,
                                   n_action_space=self.n_action_space)
        
        # 19.ターゲットアクターネットワークインスタンスtarget_actorを作成する
        # actorとtarget_actorのネットワークは同じActorNNで良い
        self.target_actor = ActorNN(device=self.device, alpha=0.000025, n_obs_space=17, n_action_space=6,
                                    layer1_size=64, layer2_size=64, batch_size=64)

        if os.path.isfile('target_actor_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.target_actor.load_state_dict(T.load('target_actor_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'target_actor_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'target_actor_params.pt')


        # target_actorネットワークをGPUへ転送
        self.target_actor.to(device)

        # 21.ターゲットクリティックネットワークインスタンスtareget_criticを作成する
        self.target_critic = CriticNN(device=self.device, beta=0.000025, n_obs_space=17, n_action_space=6,
                                    layer1_size=64, layer2_size=64, batch_size=64)

        if os.path.isfile('target_critic_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.target_critic.load_state_dict(T.load('target_critic_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'target_critic_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'target_critic_params.pt')

         # target_criticネットワークをGPUへ転送
        self.target_critic.to(device)

        # 24.クリティックネットワークインスタンスcriticを作成する。
        self.critic = CriticNN(device=self.device, beta=0.000025, n_obs_space=17, n_action_space=6,
                               layer1_size=64, layer2_size=64, batch_size=64)

        if os.path.isfile('critic_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.critic.load_state_dict(T.load('critic_params.pt', map_location=device))
            print("パラメータファイルをロードしました:", 'critic_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'critic_params.pt')
            
        # criticネットワークをGPUへ転送
        self.critic.to(device)
        
        # アクターロスとクリティックロス
        self.actor_loss = 0
        self.critic_loss = 0
        
        # 45.行動ノイズのインスタンス化
        self.mode = mode
        if self.mode == 'train_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space))
        elif self.mode == 'eval_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)
        else:
            print('mode error')
        

    def choose_action(self, obs): # GPU対応済み
        #print('AgentDDPG.choose_action is working.')
        # 4.方策（アクター）はニューラルネットワークで表現する。
        #   ActorNNクラスを新規作成し、インスタンスactorとして使用する。
        obs = obs.to(device)
        action = self.actor.forward(obs)
        action = action.cpu()

        # 46.行動ノイズを入れて探索性を向上させる。  
        action += T.tensor(self.noise(), dtype=T.float32)
        action = action.detach().numpy()

        return action
    
    # 8.remenberメソドを追加
    def remember(self, obs, action, reward, next_state, done):
        self.memory.store_transition(obs, action, reward, next_state, done)

    # 13.learnメソドを追加
    def learn(self):
        # 14.バッチサイズ分のトランジションが集まるまでは何も実行しない。
        if self.memory.memory_count < self.batch_size:
            return
        
        # 15.メモリバッファからデータを抜き出す sample_buffer()
        # バッチ化されているので変数名を複数形にする
        observations, actions, rewards, next_states, terminals = self.memory.sample_buffer(self.batch_size)
        #print('s:', observations)
        #print(observations.shape)
        #print('a :', actions)
        #print('r :', rewards)
        #print('s_ :', next_states)
        #print('terminal :', terminals)

        # 17.抜き出したデータをpytorchで微分可能なようにtorch.tensor化する 
        observations = T.tensor(observations, dtype=T.float32).to(device)
        actions = T.tensor(actions, dtype=T.float32).to(device)
        rewards = T.tensor(rewards, dtype=T.float32).to(device)
        next_states = T.tensor(next_states, dtype=T.float32).to(device)
        terminals = T.tensor(terminals, dtype=T.float32).to(device)


        # 18.ターゲットアクターネットワークインスタンスtarget_actorに
        # 次の状態next_satesを入れて、ターゲットアクションtarget_actionsとして取り出す。
        # このターゲットネットワークはターゲットでないネットワークとNNパラメータを共有させる。
        #print('next_states :', next_states)
        target_actions = self.target_actor.forward(next_states)


        # 20.ターゲットクリティックネットワークインスタンスtarget_criticに
        # 次の状態next_statesと上記より算出したターゲットアクションの２つを入力して
        # 価値関数の推定値ターゲットバリューを出力する。
        # TDターゲット：r + γ*V(w)[s_t+1] の部分のこと。
        # ターゲットクリティックバリューはターゲットアクターネットワークを使う
        target_critic_values = self.target_critic.forward(next_states, target_actions)

        
        # 23.ベースラインとして機能するクリティックネットワーク（価値関数V(w)[s_t]ネットワーク）に
        # 現在の状態observationsと行動actionsを入力して
        # クリティックバリューを算出する
        critic_values = self.critic.forward(observations, actions)
        

        # 25.TDターゲットを算出する：r + γ*V(w)[s_t+1]
        td_targets = []
        for i in range(self.batch_size):
            td_target = rewards[i] + self.gamma * target_critic_values[i] * terminals[i]
            td_targets.append(td_target)

        # TDターゲットの形をバッチに整える
        td_targets = T.tensor(td_targets, dtype=T.float32).to(device)
        td_targets = td_targets.view(self.batch_size, 1) #viewはreshapeと同じ。64x1に見え方を変更した、という意味
        #print('td_targets :', td_targets)


        # ==== （１）クリティックの学習 ====

        # 28.クリティックの勾配をゼロに初期化する
        self.critic.optimizer.zero_grad()

        # 29. TDターゲットと状態価値の二乗誤差を算出して、クリティックの損失関数とする。バッチサイズは６４個
        critic_loss = F.mse_loss(td_targets, critic_values)
        self.critic_loss = critic_loss
        #print('critic_loss : ', critic_loss) # tensor(0.0485, grad_fn=<MseLossBackward0>)

        # 30. クリティックの損失関数を微分して、勾配を算出する
        critic_loss.backward()

        # 31. 勾配からオプティマイザーによってクリティックのパラメータ（重みとバイアス）を更新する
        self.critic.optimizer.step()


        # ==== （２）アクターの学習 ====

        # 32. アクターの勾配をゼロに初期化する
        self.actor.optimizer.zero_grad()

        # 33. アクターに観測情報を入力して行動を算出する。バッチサイズは６４個
        predicted_actions = self.actor.forward(observations)

        # 34.アクターの損失関数を算出する
        #    Actorの目的は、Criticネットワークの出力（行動価値）を最大化するような行動を選択すること。
        #    なので、actorNN→criticNNのDDPG構造全体の出力結果をactor_lossとして、actorNNとcriticNNの両方をbackwardし、
        #    actorだけをパラメータ更新することによりactorの学習をすることができる。

        actor_loss = -self.critic.forward(observations, predicted_actions)
        actor_loss = T.mean(actor_loss)
        self.actor_loss = actor_loss

        #print(f'actor_loss: {actor_loss}, critic_loss: {critic_loss}')

        # 35. DDPG構造全体の損失関数actor_lossを微分し、勾配を算出する
        actor_loss.backward()

        # 36. 勾配からオプティマイザーによってアクターのパラメータだけを（重みとバイアス）を更新する
        self.actor.optimizer.step()
    
        # 37. 全ニューラルネットワークのパラメータを更新する。
        self.update_network_parameters()

    # 37. パラメータ更新メソド。
    def update_network_parameters(self, tau=None):
        if tau is None:
            tau = self.tau
    
        # 38. actor, critic, target_actor, target_criticのネットワーク内の全てのパラメータ（重みとバイアス）とその名前を取得する
        # actorとcriticは先ほど更新されたばかりのパラメーター
        actor_params = self.actor.named_parameters()
        critic_params = self.critic.named_parameters()
        target_actor_params = self.target_actor.named_parameters()
        target_critic_params = self.target_critic.named_parameters()
        #print('actor_params : ', actor_params) # actor_params :  <generator object Module.named_parameters at 0x000001661B2D9D48>

        # 39. パラメータをディクショナリとして取り出す。
        actor_params_dict = dict(actor_params)
        critic_params_dict = dict(critic_params)
        target_actor_params_dict = dict(target_actor_params)
        target_critic_params_dict = dict(target_critic_params)
        #print('actor_params_dict : ', actor_params_dict)
        #print(actor_params_dict.keys())
        """
        actor_params_dict :  {'fc1.weight': Parameter containing:
                                   tensor([[-0.1895, -0.0343,  0.1138,  ...,  0.2157,  0.0527, -0.1173],/

        dict_keys(['fc1.weight', 'fc1.bias', 'fc2.weight', 'fc2.bias', 'fc3.weight', 'fc3.bias'])
        """

        # 40. クリティックの各パラメーター毎に 更新重みtau=0.0001の分だけほんの少しcriticパラメータをtarget_criticパラメータに近づける。
        for name in critic_params_dict:
            critic_params_dict[name] = tau * critic_params_dict[name].clone() + \
                                       (1-tau) * target_critic_params_dict[name].clone()
            
        # 41. 更新したcriticパラメータをtarget_criticのパラメータとしてロードする。
        self.target_critic.load_state_dict(critic_params_dict)

        # 42.アクターの各パラメーター毎に 更新重みtau=0.0001の分だけほんの少しactorパラメータをtarget_actorパラメータに近づける。
        for name in actor_params_dict:
            actor_params_dict[name] = tau * actor_params_dict[name].clone() + \
                                      (1 - tau) * target_actor_params_dict[name].clone()
            
        # 43. 更新したactorパラメータをtarget_actorのパラメータとしてロードする。
        self.target_actor.load_state_dict(actor_params_dict)


#### =================== メインスクリプト ======================= ####

device = T.device('cuda' if T.cuda.is_available() else 'cpu') # cuda追加
device = 'cpu' # 強制的にcpuを使う

EVAL_TRAIN_MODE = 'eval_mode' # eval_mode 評価モードか train_mode 訓練モードかを選択
EPISODES = 501 # episodes
STEPS = 500    # steps
DELAY_TIME = 0.00 # sec
print('Selected Mode : ', EVAL_TRAIN_MODE)

# 2.エージェントクラスのインスタンスを生成する
agent = AgentDDPG(device=device, alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=64, layer2_size=64, batch_size=64, mode=EVAL_TRAIN_MODE) # cuda追加

if EVAL_TRAIN_MODE == 'train_mode':
    env = gym.make("HalfCheetah-v4", render_mode='depth_array')

elif EVAL_TRAIN_MODE == 'eval_mode':
    env = gym.make("HalfCheetah-v4", render_mode= 'human')


total_rewards = []
actor_losses = []
critic_losses = []
for episode in range(EPISODES):
    obs = env.reset()
    obs = T.tensor(obs[0], dtype=T.float)
    # tensor([ 0.0040,  0.0199, -0.0622,  0.0594, -0.0605,  0.0577, -0.0056,  0.0333,        -0.0072,  0.0532, -0.0512,  0.0173, -0.0529, -0.1104,  0.0946, -0.0559,         0.0824])
    #print(type(obs))
    # observation_space :  Box(-inf, inf, (17,), float64)
    #print('observation_space : ', env.observation_space)
    #print('obs :', obs)

    reward: float = 0
    total_reward: float = 0
    done: bool = False
    for j in range(STEPS):
        env.render()
        
        # ここをDDPGに置き換えていく
        action = agent.choose_action(obs) # 1.Agentクラスを定義していく # GPU対応済み
        #action :  [ 0.06660474 -0.11753064  0.02527559  0.06465236  0.1050786   0.05048539]
        #print('====ここまではOK4====')
        #print('action_space : ', env.action_space)
        #print('action : ', action)

        next_state, reward, done, _, info = env.step(action)
        #print('next_state, reward, done, _, info :', next_state, reward, done, _, info)
        """
        action :  [ 0.06660474 -0.11753064  0.02527559  0.06465236  0.1050786   0.05048539]

        next_state, reward, done, _, info : 
        [-0.00265179  0.0229547   0.00463243 -0.04729936 -0.00959038  0.04734605
        0.03672746  0.02857842  0.09980254 -0.32065693  0.04221647  1.58668951
        -2.31089174  1.30338924 -0.25465526  1.08250465 -0.14134398]
        0.07553858359316026
        False
        False
        {'x_position': -0.09233384215910741, 'x_velocity': 0.07920445513883267, 'reward_run': 0.07920445513883267, 'reward_ctrl': -0.0036658715456724168}
        """

        #7. トラジェクトを保存する。経験再生(ReplayBuffer)
        agent.remember(obs, action, reward, next_state, int(done))
       

        #12. ニューラルネットワークを学習する
        agent.learn()

        # 26.エピソード内での報酬を累積していく
        total_reward += reward
        
        # 27. next_stateをobsとして再出発する
        #print('next_state:', next_state)
        obs = next_state
        obs = T.tensor(obs, dtype=T.float)
        # 28. チーターの動きを見たいのでスリープを入れる
        time.sleep(DELAY_TIME)

    #print('total_reward : ', total_reward)
    total_rewards.append(total_reward)

    actor_losses.append(float(agent.actor_loss)) 
    critic_losses.append(float(agent.critic_loss)) 

    # print('epsisode', i, 'score %.2f' % score, '100 game sverage %.2f' % np.mean(score_history[-100:]))
 
    # 47. 各ニューラルネットワークのパラメータを１０エピソード毎に保存する
    print('episode, total_reward : ', episode , total_reward)
    if episode % 10 == 0:
        T.save(agent.actor.state_dict(), 'actor_params.pt')
        T.save(agent.critic.state_dict(), 'critic_params.pt')
        T.save(agent.target_actor.state_dict(), 'target_actor_params.pt')
        T.save(agent.target_critic.state_dict(), 'target_critic_params.pt')
        print('==== params were saved. ====')

#print('total_rewards : ', total_rewards)
#plt.plot(total_rewards)

#plt.plot(actor_losses, label='actor_losses')
#plt.plot(critic_losses, label='critic_losses')
plt.plot(total_rewards, label='total_rewards')
plt.legend()
plt.grid(True)
plt.ioff()
plt.show()

env.close() # 空なんですけど・・・

print('script is done.')

# https://gymnasium.farama.org/


"""
episods=11 step=500
    GPUで80秒 
    CPUで48秒

    episods=5 step=500
    GPUで40秒 
    CPUで25秒

結論 CPUのほうが速い!!
intel core i7-8700cpu 3.2GHz
"""

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

import gymnasium as gym

import time

import torch as T

import torch.nn as nn

import torch.nn.functional as F

import torch.optim as optim

import numpy as np

import matplotlib.pyplot as plt

import os

""" nvidia CUDA Toolkit 12.1

https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exe_local

Download cuda_12.1.1_531.14_windows.exe

"""

""" pip install

pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu121

pip install gymnasium

pip install gymnasium[mujoco]

pip install matplotlib

pip install mujoco

"""

# 44.OUActionNOoiseクラスを作成する

class OUActionNoise(object):

def __init__(self, mu, sigma=0.15, theta=0.2, dt=1e-2, x0=None):

self.mu = mu

self.sigma = sigma

self.theta = theta

self.dt = dt

self.x0 = x0

self.reset()

def __call__(self):

x = self.x_prev + self.theta * (self.mu - self.x_prev) * self.dt + \

self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)

self.x_prev = x

return x

def reset(self):

self.x_prev = self.x0 if self.x0 is not None else np.zeros_like(self.mu)

# 10. ReplayBufferクラスを新規作成する

class ReplayBuffer:

def __init__(self, max_memory_size, n_obs_space, n_action_space):

self.max_memory_size = max_memory_size

self.n_obs_space = n_obs_space

self.n_action_space = n_action_space

self.memory_count = 0

self.state_memory = np.zeros((self.max_memory_size, self.n_obs_space))

self.action_memory = np.zeros((self.max_memory_size, self.n_action_space))

self.reward_memory = np.zeros(self.max_memory_size)

self.next_state_memory = np.zeros((self.max_memory_size, self.n_obs_space))

self.terminal_memory = np.zeros(self.max_memory_size)

#self.terminal_memory = np.zeros(self.max_memory_size, dtype=np.bool)

# 11.トランジション保存のためstore_transitionメソドを作成する

def store_transition(self, obs, action, reward, next_state, done):

#print('store_transition is working.')

index = self.memory_count % self.max_memory_size # 最大メモリー数に到達したら、古いデータから上書きされていくギミック

#print('obs.detach().numpy().flatten():',obs.detach().numpy().flatten())

self.state_memory[index] = obs.detach().numpy().flatten()

self.action_memory[index] = action.flatten()

self.reward_memory[index] = reward.flatten()

self.next_state_memory[index] = next_state.flatten()

self.terminal_memory[index] = 1 - int(done) # ゴールならterminal = 0 となるように

#print('state_memory :', self.state_memory)

#print('action_memory :', self.action_memory)

#print('reward_memory :', self.reward_memory)

#print('next_state_memory :', self.next_state_memory)

#print('memory.state_memory :', self.terminal_memory)

#print('type of state_memory :', type(self.state_memory[0][0]))

#print('type of action_memory :', type(self.action_memory[0][0]))

#print('type of reward_memory :', type(self.reward_memory[0]))

#print('type of next_state_memory :', type(self.next_state_memory[0][0]))

#print('type of memory.state_memory :', type(self.terminal_memory[0]))

self.memory_count += 1

#print('memory_count :', agent.memory.memory_count)

# 16 バッファメモリーからランダムに抽出する

def sample_buffer(self, batch_size):

# indexが最大メモリに到達していない場合を想定する。

max_index = min(self.max_memory_size, self.memory_count)

choosed_index = np.random.choice(max_index, batch_size)

observations = self.state_memory[choosed_index]

actions = self.action_memory[choosed_index]

rewards = self.reward_memory[choosed_index]

next_states = self.next_state_memory[choosed_index]

terminals = self.terminal_memory[choosed_index]

return observations, actions, rewards, next_states, terminals

# 6.ActorNNクラスを新規作成する

class ActorNN(nn.Module):

def __init__(self, device, alpha=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, batch_size=64):

#print('ActorNN.__init__ is working.')

super(ActorNN, self).__init__()

self.fc1 = nn.Linear(n_obs_space, layer1_size)

self.fc2 = nn.Linear(layer1_size, layer2_size)

self.fc3 = nn.Linear(layer2_size, n_action_space)

#26.最適化処理としてアダムを設定する

#self.optimizer = optim.Adam(self.parameters(), lr=alpha)

self.optimizer = optim.SGD(self.parameters(), lr=alpha)

# 48. actorパラメータの読み出し

# もし、パラメータのデータが存在していたらそのパラメータで初期化する。

# パラメータファイルの存在チェック

"""

if os.path.isfile('actor_params.pt'):

# パラメータファイルが存在する場合はロード

self.load_state_dict(T.load('actor_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'actor_params.pt')

else:

print("パラメータファイルが見つかりません:", 'actor_params.pt')

"""

def forward(self, obs):

#print('AgetDDPG.ActorNN.forward is working')

#print('====ここまではOK1====')

x = self.fc1(obs)

x = F.relu(x)

x = self.fc2(x)

x = F.relu(x)

x = self.fc3(x)

action = F.tanh(x)

return action

# 22.CriticNNクラスを新規作成する

class CriticNN(nn.Module):

def __init__(self, device, beta=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, batch_size=64):

#print('CriticNN.__init__ is working.')

super(CriticNN, self).__init__()

# クリティックNNは観察空間+行動空間の２つを入力とする構造

input_dim = n_obs_space + n_action_space

self.fc1 = nn.Linear(input_dim, layer1_size)

self.fc2 = nn.Linear(layer1_size, layer2_size)

self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

#27.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=beta)

self.optimizer = optim.SGD(self.parameters(), lr=beta)

# 49. criticパラメータの読み出し

# もし、パラメータのデータが存在していたらそのパラメータで初期化する。

# パラメータファイルの存在チェック

"""

if os.path.isfile('critic_params.pt'):

# パラメータファイルが存在する場合はロード

self.load_state_dict(T.load('critic_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'critic_params.pt')

else:

print("パラメータファイルが見つかりません:", 'critic_params.pt')

"""

def forward(self, obs, action):

input_data = T.cat([obs, action], dim=1)

x = self.fc1(input_data)

x = F.relu(x)

x =self.fc2(x)

x = F.relu(x)

x = self.fc3(x)

return x #一つの状態価値を出力する。

# 3.エージェントクラスを定義する

class AgentDDPG:

def __init__(self, device, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=64, layer2_size=64, batch_size=64, mode='train_mode'):

#print('AgentDDPG.__init__ is working.')

# 5.ActorNNクラスのインスタンスを生成する

self.device = device

self.alpha = alpha

self.beta = beta

self.gamma = gamma

self.tau = tau

self.n_obs_space = n_obs_space

self.n_action_space = n_action_space

self.n_state_action_value = n_state_action_value

self.layer1_size = layer1_size

self.layer2_size = layer2_size

# 13.バッチサイズを決めておく

self.batch_size = batch_size

self.actor = ActorNN(device=self.device, alpha=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, batch_size=64)

if os.path.isfile('actor_params.pt'):

# パラメータファイルが存在する場合はロード

self.actor.load_state_dict(T.load('actor_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'actor_params.pt')

else:

print("パラメータファイルが見つかりません:", 'actor_params.pt')

# actorネットワークをGPUへ転送

self.actor.to(device)

# 9.memoryインスタンスを追加

self.MAX_MEMORY_SIZE = 10000

self.memory = ReplayBuffer(max_memory_size=self.MAX_MEMORY_SIZE,

n_obs_space=self.n_obs_space,

n_action_space=self.n_action_space)

# 19.ターゲットアクターネットワークインスタンスtarget_actorを作成する

# actorとtarget_actorのネットワークは同じActorNNで良い

self.target_actor = ActorNN(device=self.device, alpha=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, batch_size=64)

if os.path.isfile('target_actor_params.pt'):

# パラメータファイルが存在する場合はロード

self.target_actor.load_state_dict(T.load('target_actor_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'target_actor_params.pt')

else:

print("パラメータファイルが見つかりません:", 'target_actor_params.pt')

# target_actorネットワークをGPUへ転送

self.target_actor.to(device)

# 21.ターゲットクリティックネットワークインスタンスtareget_criticを作成する

self.target_critic = CriticNN(device=self.device, beta=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, batch_size=64)

if os.path.isfile('target_critic_params.pt'):

# パラメータファイルが存在する場合はロード

self.target_critic.load_state_dict(T.load('target_critic_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'target_critic_params.pt')

else:

print("パラメータファイルが見つかりません:", 'target_critic_params.pt')

# target_criticネットワークをGPUへ転送

self.target_critic.to(device)

# 24.クリティックネットワークインスタンスcriticを作成する。

self.critic = CriticNN(device=self.device, beta=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, batch_size=64)

if os.path.isfile('critic_params.pt'):

# パラメータファイルが存在する場合はロード

self.critic.load_state_dict(T.load('critic_params.pt', map_location=device))

print("パラメータファイルをロードしました:", 'critic_params.pt')

else:

print("パラメータファイルが見つかりません:", 'critic_params.pt')

# criticネットワークをGPUへ転送

self.critic.to(device)

# アクターロスとクリティックロス

self.actor_loss = 0

self.critic_loss = 0

# 45.行動ノイズのインスタンス化

self.mode = mode

if self.mode == 'train_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space))

elif self.mode == 'eval_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)

else:

print('mode error')

def choose_action(self, obs): # GPU対応済み

#print('AgentDDPG.choose_action is working.')

# 4.方策（アクター）はニューラルネットワークで表現する。

# ActorNNクラスを新規作成し、インスタンスactorとして使用する。

obs = obs.to(device)

action = self.actor.forward(obs)

action = action.cpu()

# 46.行動ノイズを入れて探索性を向上させる。

action += T.tensor(self.noise(), dtype=T.float32)

action = action.detach().numpy()

return action

# 8.remenberメソドを追加

def remember(self, obs, action, reward, next_state, done):

self.memory.store_transition(obs, action, reward, next_state, done)

# 13.learnメソドを追加

def learn(self):

# 14.バッチサイズ分のトランジションが集まるまでは何も実行しない。

if self.memory.memory_count < self.batch_size:

return

# 15.メモリバッファからデータを抜き出す sample_buffer()

# バッチ化されているので変数名を複数形にする

observations, actions, rewards, next_states, terminals = self.memory.sample_buffer(self.batch_size)

#print('s:', observations)

#print(observations.shape)

#print('a :', actions)

#print('r :', rewards)

#print('s_ :', next_states)

#print('terminal :', terminals)

# 17.抜き出したデータをpytorchで微分可能なようにtorch.tensor化する

observations = T.tensor(observations, dtype=T.float32).to(device)

actions = T.tensor(actions, dtype=T.float32).to(device)

rewards = T.tensor(rewards, dtype=T.float32).to(device)

next_states = T.tensor(next_states, dtype=T.float32).to(device)

terminals = T.tensor(terminals, dtype=T.float32).to(device)

# 18.ターゲットアクターネットワークインスタンスtarget_actorに

# 次の状態next_satesを入れて、ターゲットアクションtarget_actionsとして取り出す。

# このターゲットネットワークはターゲットでないネットワークとNNパラメータを共有させる。

#print('next_states :', next_states)

target_actions = self.target_actor.forward(next_states)

# 20.ターゲットクリティックネットワークインスタンスtarget_criticに

# 次の状態next_statesと上記より算出したターゲットアクションの２つを入力して

# 価値関数の推定値ターゲットバリューを出力する。

# TDターゲット：r + γ*V(w)[s_t+1] の部分のこと。

# ターゲットクリティックバリューはターゲットアクターネットワークを使う

target_critic_values = self.target_critic.forward(next_states, target_actions)

# 23.ベースラインとして機能するクリティックネットワーク（価値関数V(w)[s_t]ネットワーク）に

# 現在の状態observationsと行動actionsを入力して

# クリティックバリューを算出する

critic_values = self.critic.forward(observations, actions)

# 25.TDターゲットを算出する：r + γ*V(w)[s_t+1]

td_targets = []

for i in range(self.batch_size):

td_target = rewards[i] + self.gamma * target_critic_values[i] * terminals[i]

td_targets.append(td_target)

# TDターゲットの形をバッチに整える

td_targets = T.tensor(td_targets, dtype=T.float32).to(device)

td_targets = td_targets.view(self.batch_size, 1) #viewはreshapeと同じ。64x1に見え方を変更した、という意味

#print('td_targets :', td_targets)

# ==== （１）クリティックの学習 ====

# 28.クリティックの勾配をゼロに初期化する

self.critic.optimizer.zero_grad()

# 29. TDターゲットと状態価値の二乗誤差を算出して、クリティックの損失関数とする。バッチサイズは６４個

critic_loss = F.mse_loss(td_targets, critic_values)

self.critic_loss = critic_loss

#print('critic_loss : ', critic_loss) # tensor(0.0485, grad_fn=<MseLossBackward0>)

# 30. クリティックの損失関数を微分して、勾配を算出する

critic_loss.backward()

# 31. 勾配からオプティマイザーによってクリティックのパラメータ（重みとバイアス）を更新する

self.critic.optimizer.step()

# ==== （２）アクターの学習 ====

# 32. アクターの勾配をゼロに初期化する

self.actor.optimizer.zero_grad()

# 33. アクターに観測情報を入力して行動を算出する。バッチサイズは６４個

predicted_actions = self.actor.forward(observations)

# 34.アクターの損失関数を算出する

# Actorの目的は、Criticネットワークの出力（行動価値）を最大化するような行動を選択すること。

# なので、actorNN→criticNNのDDPG構造全体の出力結果をactor_lossとして、actorNNとcriticNNの両方をbackwardし、

# actorだけをパラメータ更新することによりactorの学習をすることができる。

actor_loss = -self.critic.forward(observations, predicted_actions)

actor_loss = T.mean(actor_loss)

self.actor_loss = actor_loss

#print(f'actor_loss: {actor_loss}, critic_loss: {critic_loss}')

# 35. DDPG構造全体の損失関数actor_lossを微分し、勾配を算出する

actor_loss.backward()

# 36. 勾配からオプティマイザーによってアクターのパラメータだけを（重みとバイアス）を更新する

self.actor.optimizer.step()

# 37. 全ニューラルネットワークのパラメータを更新する。

self.update_network_parameters()

# 37. パラメータ更新メソド。

def update_network_parameters(self, tau=None):

if tau is None:

tau = self.tau

# 38. actor, critic, target_actor, target_criticのネットワーク内の全てのパラメータ（重みとバイアス）とその名前を取得する

# actorとcriticは先ほど更新されたばかりのパラメーター

actor_params = self.actor.named_parameters()

critic_params = self.critic.named_parameters()

target_actor_params = self.target_actor.named_parameters()

target_critic_params = self.target_critic.named_parameters()

#print('actor_params : ', actor_params) # actor_params : <generator object Module.named_parameters at 0x000001661B2D9D48>

# 39. パラメータをディクショナリとして取り出す。

actor_params_dict = dict(actor_params)

critic_params_dict = dict(critic_params)

target_actor_params_dict = dict(target_actor_params)

target_critic_params_dict = dict(target_critic_params)

#print('actor_params_dict : ', actor_params_dict)

#print(actor_params_dict.keys())

"""

actor_params_dict : {'fc1.weight': Parameter containing:

tensor([[-0.1895, -0.0343, 0.1138, ..., 0.2157, 0.0527, -0.1173],/

dict_keys(['fc1.weight', 'fc1.bias', 'fc2.weight', 'fc2.bias', 'fc3.weight', 'fc3.bias'])

"""

# 40. クリティックの各パラメーター毎に更新重みtau=0.0001の分だけほんの少しcriticパラメータをtarget_criticパラメータに近づける。

for name in critic_params_dict:

critic_params_dict[name] = tau * critic_params_dict[name].clone() + \

(1-tau) * target_critic_params_dict[name].clone()

# 41. 更新したcriticパラメータをtarget_criticのパラメータとしてロードする。

self.target_critic.load_state_dict(critic_params_dict)

# 42.アクターの各パラメーター毎に更新重みtau=0.0001の分だけほんの少しactorパラメータをtarget_actorパラメータに近づける。

for name in actor_params_dict:

actor_params_dict[name] = tau * actor_params_dict[name].clone() + \

(1 - tau) * target_actor_params_dict[name].clone()

# 43. 更新したactorパラメータをtarget_actorのパラメータとしてロードする。

self.target_actor.load_state_dict(actor_params_dict)

#### =================== メインスクリプト ======================= ####

device = T.device('cuda' if T.cuda.is_available() else 'cpu') # cuda追加

device = 'cpu' # 強制的にcpuを使う

EVAL_TRAIN_MODE = 'eval_mode' # eval_mode 評価モードか train_mode 訓練モードかを選択

EPISODES = 501 # episodes

STEPS = 500 # steps

DELAY_TIME = 0.00 # sec

print('Selected Mode : ', EVAL_TRAIN_MODE)

# 2.エージェントクラスのインスタンスを生成する

agent = AgentDDPG(device=device, alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=64, layer2_size=64, batch_size=64, mode=EVAL_TRAIN_MODE) # cuda追加

if EVAL_TRAIN_MODE == 'train_mode':

env = gym.make("HalfCheetah-v4", render_mode='depth_array')

elif EVAL_TRAIN_MODE == 'eval_mode':

env = gym.make("HalfCheetah-v4", render_mode= 'human')

total_rewards = []

actor_losses = []

critic_losses = []

for episode in range(EPISODES):

obs = env.reset()

obs = T.tensor(obs[0], dtype=T.float)

# tensor([ 0.0040, 0.0199, -0.0622, 0.0594, -0.0605, 0.0577, -0.0056, 0.0333, -0.0072, 0.0532, -0.0512, 0.0173, -0.0529, -0.1104, 0.0946, -0.0559, 0.0824])

#print(type(obs))

# observation_space : Box(-inf, inf, (17,), float64)

#print('observation_space : ', env.observation_space)

#print('obs :', obs)

reward: float = 0

total_reward: float = 0

done: bool = False

for j in range(STEPS):

env.render()

# ここをDDPGに置き換えていく

action = agent.choose_action(obs) # 1.Agentクラスを定義していく # GPU対応済み

#action : [ 0.06660474 -0.11753064 0.02527559 0.06465236 0.1050786 0.05048539]

#print('====ここまではOK4====')

#print('action_space : ', env.action_space)

#print('action : ', action)

next_state, reward, done, _, info = env.step(action)

#print('next_state, reward, done, _, info :', next_state, reward, done, _, info)

"""

action : [ 0.06660474 -0.11753064 0.02527559 0.06465236 0.1050786 0.05048539]

next_state, reward, done, _, info :

[-0.00265179 0.0229547 0.00463243 -0.04729936 -0.00959038 0.04734605

0.03672746 0.02857842 0.09980254 -0.32065693 0.04221647 1.58668951

-2.31089174 1.30338924 -0.25465526 1.08250465 -0.14134398]

0.07553858359316026

False

{'x_position': -0.09233384215910741, 'x_velocity': 0.07920445513883267, 'reward_run': 0.07920445513883267, 'reward_ctrl': -0.0036658715456724168}

"""

#7. トラジェクトを保存する。経験再生(ReplayBuffer)

agent.remember(obs, action, reward, next_state, int(done))

#12. ニューラルネットワークを学習する

agent.learn()

# 26.エピソード内での報酬を累積していく

total_reward += reward

# 27. next_stateをobsとして再出発する

#print('next_state:', next_state)

obs = next_state

obs = T.tensor(obs, dtype=T.float)

# 28. チーターの動きを見たいのでスリープを入れる

time.sleep(DELAY_TIME)

#print('total_reward : ', total_reward)

total_rewards.append(total_reward)

actor_losses.append(float(agent.actor_loss))

critic_losses.append(float(agent.critic_loss))

# print('epsisode', i, 'score %.2f' % score, '100 game sverage %.2f' % np.mean(score_history[-100:]))

# 47. 各ニューラルネットワークのパラメータを１０エピソード毎に保存する

print('episode, total_reward : ', episode , total_reward)

if episode % 10 == 0:

T.save(agent.actor.state_dict(), 'actor_params.pt')

T.save(agent.critic.state_dict(), 'critic_params.pt')

T.save(agent.target_actor.state_dict(), 'target_actor_params.pt')

T.save(agent.target_critic.state_dict(), 'target_critic_params.pt')

print('==== params were saved. ====')

#print('total_rewards : ', total_rewards)

#plt.plot(total_rewards)

#plt.plot(actor_losses, label='actor_losses')

#plt.plot(critic_losses, label='critic_losses')

plt.plot(total_rewards, label='total_rewards')

plt.legend()

plt.grid(True)

plt.ioff()

plt.show()

env.close() # 空なんですけど・・・

print('script is done.')

# https://gymnasium.farama.org/

"""

episods=11 step=500

GPUで80秒

CPUで48秒

episods=5 step=500

GPUで40秒

CPUで25秒

結論 CPUのほうが速い!!

intel core i7-8700cpu 3.2GHz

"""

DDPG by gymnasium １３日目

GPUによる計算に成功しました。

GPUとCPUの速度比較

episods=11 step=500

GPUで80秒

CPUで48秒

episods=5 step=500

GPUで40秒

CPUで25秒

結論 CPUのほうが速い!!うそーん！

ショックすぎて、今日はもうやめます。CPU買ったほうがいいじゃん！

スクリプト

import gymnasium as gym
import time
import torch as T
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
import os

""" nvidia CUDA Toolkit 12.1
https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exe_local
Download cuda_12.1.1_531.14_windows.exe
"""
""" pip install
pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu121
pip install gymnasium
pip install gymnasium[mujoco]
pip install matplotlib
pip install mujoco
"""
# 44.OUActionNOoiseクラスを作成する
class OUActionNoise(object):
    def __init__(self, mu, sigma=0.15, theta=0.2, dt=1e-2, x0=None):
        self.mu = mu
        self.sigma = sigma
        self.theta = theta
        self.dt = dt
        self.x0 = x0
        self.reset()

    def __call__(self):
        x = self.x_prev + self.theta * (self.mu - self.x_prev) * self.dt + \
        self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)
        self.x_prev = x
        return x

    def reset(self):
        self.x_prev = self.x0 if self.x0 is not None else np.zeros_like(self.mu)


# 10. ReplayBufferクラスを新規作成する
class ReplayBuffer:
    def __init__(self, max_memory_size, n_obs_space, n_action_space):
        self.max_memory_size = max_memory_size
        self.n_obs_space = n_obs_space
        self.n_action_space = n_action_space

        self.memory_count = 0

        self.state_memory = np.zeros((self.max_memory_size, self.n_obs_space))
        self.action_memory =  np.zeros((self.max_memory_size, self.n_action_space))
        self.reward_memory =  np.zeros(self.max_memory_size)
        self.next_state_memory =  np.zeros((self.max_memory_size, self.n_obs_space))
        self.terminal_memory =  np.zeros(self.max_memory_size)
        #self.terminal_memory = np.zeros(self.max_memory_size, dtype=np.bool)

    # 11.トランジション保存のためstore_transitionメソドを作成する
    def store_transition(self, obs, action, reward, next_state, done):
        #print('store_transition is working.')
        index = self.memory_count % self.max_memory_size # 最大メモリー数に到達したら、古いデータから上書きされていくギミック
        #print('obs.detach().numpy().flatten():',obs.detach().numpy().flatten())
        self.state_memory[index] = obs.detach().numpy().flatten()
        self.action_memory[index] = action.flatten()
        self.reward_memory[index] = reward.flatten()
        self.next_state_memory[index] = next_state.flatten()
        self.terminal_memory[index] = 1 - int(done) # ゴールならterminal = 0 となるように
        #print('state_memory :', self.state_memory)
        #print('action_memory :', self.action_memory)
        #print('reward_memory :', self.reward_memory)
        #print('next_state_memory :', self.next_state_memory)
        #print('memory.state_memory :', self.terminal_memory)

        #print('type of state_memory :', type(self.state_memory[0][0]))
        #print('type of action_memory :', type(self.action_memory[0][0]))
        #print('type of reward_memory :', type(self.reward_memory[0]))
        #print('type of next_state_memory :', type(self.next_state_memory[0][0]))
        #print('type of memory.state_memory :', type(self.terminal_memory[0]))

        self.memory_count += 1
        #print('memory_count :', agent.memory.memory_count)

    # 16 バッファメモリーからランダムに抽出する
    def sample_buffer(self, batch_size):
        # indexが最大メモリに到達していない場合を想定する。
        max_index = min(self.max_memory_size, self.memory_count)
        choosed_index = np.random.choice(max_index, batch_size)
        
        observations = self.state_memory[choosed_index]
        actions = self.action_memory[choosed_index]
        rewards = self.reward_memory[choosed_index]
        next_states = self.next_state_memory[choosed_index]
        terminals = self.terminal_memory[choosed_index]

        return observations, actions, rewards, next_states, terminals


# 6.ActorNNクラスを新規作成する
class ActorNN(nn.Module):
    def __init__(self, device, alpha=0.001, n_obs_space=17, n_action_space=6,
                                    layer1_size=256, layer2_size=256, batch_size=64):
        #print('ActorNN.__init__ is working.')
        super(ActorNN, self).__init__()
        self.fc1 = nn.Linear(n_obs_space, layer1_size)
        self.fc2 = nn.Linear(layer1_size, layer2_size)
        self.fc3 = nn.Linear(layer2_size, n_action_space)

        #26.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=alpha)

        # 48. actorパラメータの読み出し
        # もし、パラメータのデータが存在していたらそのパラメータで初期化する。
        # パラメータファイルの存在チェック
        """
        # if T.cuda.is_available():
            map_location = 'cuda'
        else:
            map_location = 'cpu'
        """
        map_location = device
        if os.path.isfile('actor_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.load_state_dict(T.load('actor_params.pt', map_location=map_location))
            print("パラメータファイルをロードしました:", 'actor_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'actor_params.pt')

    def forward(self, obs):
        #print('AgetDDPG.ActorNN.forward is working')
        #print('====ここまではOK1====')
        x = self.fc1(obs)
        x = F.relu(x)
        x = self.fc2(x)
        x = F.relu(x)
        x = self.fc3(x)
        action = F.tanh(x)

        return action

# 22.CriticNNクラスを新規作成する
class CriticNN(nn.Module):

    def __init__(self, device, beta=0.001, n_obs_space=17, n_action_space=6,
                 layer1_size=256, layer2_size=256, batch_size=64):
        #print('CriticNN.__init__ is working.')
        super(CriticNN, self).__init__()

        # クリティックNNは観察空間+行動空間の２つを入力とする構造
        input_dim = n_obs_space + n_action_space
        self.fc1 = nn.Linear(input_dim, layer1_size)
        self.fc2 = nn.Linear(layer1_size, layer2_size)
        self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

        #27.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=beta)

        # 49. criticパラメータの読み出し
        # もし、パラメータのデータが存在していたらそのパラメータで初期化する。
        # パラメータファイルの存在チェック
        """
        # if T.cuda.is_available():
            map_location = 'cuda'
        else:
            map_location = 'cpu'
        """
        map_location = device
        if os.path.isfile('critic_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.load_state_dict(T.load('critic_params.pt', map_location=map_location))
            print("パラメータファイルをロードしました:", 'critic_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'critic_params.pt')

    def forward(self, obs, action):
        input_data = T.cat([obs, action], dim=1)
        x = self.fc1(input_data)
        x = F.relu(x)
        x =self.fc2(x)
        x = F.relu(x)
        x = self.fc3(x)

        return x #一つの状態価値を出力する。

# 3.エージェントクラスを定義する
class AgentDDPG:

    def __init__(self, device, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=64, layer2_size=64, batch_size=64, mode='train_mode'):
        #print('AgentDDPG.__init__ is working.')
        # 5.ActorNNクラスのインスタンスを生成する
        self.device = device

        self.alpha = alpha
        self.beta = beta
        self.gamma = gamma
        self.tau = tau
        
        self.n_obs_space = n_obs_space
        self.n_action_space = n_action_space

        self.n_state_action_value = n_state_action_value

        self.layer1_size = layer1_size
        self.layer2_size = layer2_size

        # 13.バッチサイズを決めておく
        self.batch_size = batch_size 

        self.actor = ActorNN(device=self.device, alpha=0.000025, n_obs_space=17, n_action_space=6,
                            layer1_size=64, layer2_size=64, batch_size=64) 
        
        # actorネットワークをGPUへ転送
        

        self.actor.to(device)
        
        # 9.memoryインスタンスを追加
        self.MAX_MEMORY_SIZE = 10000
        self.memory = ReplayBuffer(max_memory_size=self.MAX_MEMORY_SIZE,
                                   n_obs_space=self.n_obs_space,
                                   n_action_space=self.n_action_space)
        
        # 19.ターゲットアクターネットワークインスタンスtarget_actorを作成する
        # actorとtarget_actorのネットワークは同じActorNNで良い
        self.target_actor = ActorNN(device=self.device, alpha=0.000025, n_obs_space=17, n_action_space=6,
                                    layer1_size=64, layer2_size=64, batch_size=64)

        # target_actorネットワークをGPUへ転送
        self.target_actor.to(device)

        # 21.ターゲットクリティックネットワークインスタンスtareget_criticを作成する
        self.target_critic = CriticNN(device=self.device, beta=0.000025, n_obs_space=17, n_action_space=6,
                                    layer1_size=64, layer2_size=64, batch_size=64)

         # target_criticネットワークをGPUへ転送
        self.target_critic.to(device)

        # 24.クリティックネットワークインスタンスcriticを作成する。
        self.critic = CriticNN(device=self.device, beta=0.000025, n_obs_space=17, n_action_space=6,
                               layer1_size=64, layer2_size=64, batch_size=64)

        # criticネットワークをGPUへ転送
        self.critic.to(device)
        
        # アクターロスとクリティックロス
        self.actor_loss = 0
        self.critic_loss = 0
        
        # 45.行動ノイズのインスタンス化
        self.mode = mode
        if self.mode == 'train_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space))
        elif self.mode == 'eval_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)
        else:
            print('mode error')
        

    def choose_action(self, obs): # GPU対応済み
        #print('AgentDDPG.choose_action is working.')
        # 4.方策（アクター）はニューラルネットワークで表現する。
        #   ActorNNクラスを新規作成し、インスタンスactorとして使用する。
        obs = obs.to(device)
        action = self.actor.forward(obs)
        action = action.cpu()

        # 46.行動ノイズを入れて探索性を向上させる。  
        action += T.tensor(self.noise(), dtype=T.float32)
        action = action.detach().numpy()

        return action
    
    # 8.remenberメソドを追加
    def remember(self, obs, action, reward, next_state, done):
        self.memory.store_transition(obs, action, reward, next_state, done)

    # 13.learnメソドを追加
    def learn(self):
        # 14.バッチサイズ分のトランジションが集まるまでは何も実行しない。
        if self.memory.memory_count < self.batch_size:
            return
        
        # 15.メモリバッファからデータを抜き出す sample_buffer()
        # バッチ化されているので変数名を複数形にする
        observations, actions, rewards, next_states, terminals = self.memory.sample_buffer(self.batch_size)
        #print('s:', observations)
        #print(observations.shape)
        #print('a :', actions)
        #print('r :', rewards)
        #print('s_ :', next_states)
        #print('terminal :', terminals)

        # 17.抜き出したデータをpytorchで微分可能なようにtorch.tensor化する 
        observations = T.tensor(observations, dtype=T.float32).to(device)
        actions = T.tensor(actions, dtype=T.float32).to(device)
        rewards = T.tensor(rewards, dtype=T.float32).to(device)
        next_states = T.tensor(next_states, dtype=T.float32).to(device)
        terminals = T.tensor(terminals, dtype=T.float32).to(device)


        # 18.ターゲットアクターネットワークインスタンスtarget_actorに
        # 次の状態next_satesを入れて、ターゲットアクションtarget_actionsとして取り出す。
        # このターゲットネットワークはターゲットでないネットワークとNNパラメータを共有させる。
        #print('next_states :', next_states)
        target_actions = self.target_actor.forward(next_states)


        # 20.ターゲットクリティックネットワークインスタンスtarget_criticに
        # 次の状態next_statesと上記より算出したターゲットアクションの２つを入力して
        # 価値関数の推定値ターゲットバリューを出力する。
        # TDターゲット：r + γ*V(w)[s_t+1] の部分のこと。
        # ターゲットクリティックバリューはターゲットアクターネットワークを使う
        target_critic_values = self.target_critic.forward(next_states, target_actions)

        
        # 23.ベースラインとして機能するクリティックネットワーク（価値関数V(w)[s_t]ネットワーク）に
        # 現在の状態observationsと行動actionsを入力して
        # クリティックバリューを算出する
        critic_values = self.critic.forward(observations, actions)
        

        # 25.TDターゲットを算出する：r + γ*V(w)[s_t+1]
        td_targets = []
        for i in range(self.batch_size):
            td_target = rewards[i] + self.gamma * target_critic_values[i] * terminals[i]
            td_targets.append(td_target)

        # TDターゲットの形をバッチに整える
        td_targets = T.tensor(td_targets, dtype=T.float32).to(device)
        td_targets = td_targets.view(self.batch_size, 1) #viewはreshapeと同じ。64x1に見え方を変更した、という意味
        #print('td_targets :', td_targets)


        # ==== （１）クリティックの学習 ====

        # 28.クリティックの勾配をゼロに初期化する
        self.critic.optimizer.zero_grad()

        # 29. TDターゲットと状態価値の二乗誤差を算出して、クリティックの損失関数とする。バッチサイズは６４個
        critic_loss = F.mse_loss(td_targets, critic_values)
        self.critic_loss = critic_loss
        #print('critic_loss : ', critic_loss) # tensor(0.0485, grad_fn=<MseLossBackward0>)

        # 30. クリティックの損失関数を微分して、勾配を算出する
        critic_loss.backward()

        # 31. 勾配からオプティマイザーによってクリティックのパラメータ（重みとバイアス）を更新する
        self.critic.optimizer.step()


        # ==== （２）アクターの学習 ====

        # 32. アクターの勾配をゼロに初期化する
        self.actor.optimizer.zero_grad()

        # 33. アクターに観測情報を入力して行動を算出する。バッチサイズは６４個
        predicted_actions = self.actor.forward(observations)

        # 34.アクターの損失関数を算出する
        #    Actorの目的は、Criticネットワークの出力（行動価値）を最大化するような行動を選択すること。
        #    なので、actorNN→criticNNのDDPG構造全体の出力結果をactor_lossとして、actorNNとcriticNNの両方をbackwardし、
        #    actorだけをパラメータ更新することによりactorの学習をすることができる。

        actor_loss = -self.critic.forward(observations, predicted_actions)
        actor_loss = T.mean(actor_loss)
        self.actor_loss = actor_loss

        #print(f'actor_loss: {actor_loss}, critic_loss: {critic_loss}')

        # 35. DDPG構造全体の損失関数actor_lossを微分し、勾配を算出する
        actor_loss.backward()

        # 36. 勾配からオプティマイザーによってアクターのパラメータだけを（重みとバイアス）を更新する
        self.actor.optimizer.step()
    
        # 37. 全ニューラルネットワークのパラメータを更新する。
        self.update_network_parameters()

    # 37. パラメータ更新メソド。
    def update_network_parameters(self, tau=None):
        if tau is None:
            tau = self.tau
    
        # 38. actor, critic, target_actor, target_criticのネットワーク内の全てのパラメータ（重みとバイアス）とその名前を取得する
        # actorとcriticは先ほど更新されたばかりのパラメーター
        actor_params = self.actor.named_parameters()
        critic_params = self.critic.named_parameters()
        target_actor_params = self.target_actor.named_parameters()
        target_critic_params = self.target_critic.named_parameters()
        #print('actor_params : ', actor_params) # actor_params :  <generator object Module.named_parameters at 0x000001661B2D9D48>

        # 39. パラメータをディクショナリとして取り出す。
        actor_params_dict = dict(actor_params)
        critic_params_dict = dict(critic_params)
        target_actor_params_dict = dict(target_actor_params)
        target_critic_params_dict = dict(target_critic_params)
        #print('actor_params_dict : ', actor_params_dict)
        #print(actor_params_dict.keys())
        """
        actor_params_dict :  {'fc1.weight': Parameter containing:
                                   tensor([[-0.1895, -0.0343,  0.1138,  ...,  0.2157,  0.0527, -0.1173],/

        dict_keys(['fc1.weight', 'fc1.bias', 'fc2.weight', 'fc2.bias', 'fc3.weight', 'fc3.bias'])
        """

        # 40. クリティックの各パラメーター毎に 更新重みtau=0.0001の分だけほんの少しcriticパラメータをtarget_criticパラメータに近づける。
        for name in critic_params_dict:
            critic_params_dict[name] = tau * critic_params_dict[name].clone() + \
                                       (1-tau) * target_critic_params_dict[name].clone()
            
        # 41. 更新したcriticパラメータをtarget_criticのパラメータとしてロードする。
        self.target_critic.load_state_dict(critic_params_dict)

        # 42.アクターの各パラメーター毎に 更新重みtau=0.0001の分だけほんの少しactorパラメータをtarget_actorパラメータに近づける。
        for name in actor_params_dict:
            actor_params_dict[name] = tau * actor_params_dict[name].clone() + \
                                      (1 - tau) * target_actor_params_dict[name].clone()
            
        # 43. 更新したactorパラメータをtarget_actorのパラメータとしてロードする。
        self.target_actor.load_state_dict(actor_params_dict)


#### =================== メインスクリプト ======================= ####

device = T.device('cuda' if T.cuda.is_available() else 'cpu') # cuda追加
#device = 'cpu'
EVAL_TRAIN_MODE = 'train_mode' # 評価モードか訓練モードかを選択
EPISODES = 5 # episodes
STEPS = 500    # steps
DELAY_TIME = 0.00 # sec
print('Selected Mode : ', EVAL_TRAIN_MODE)

# 2.エージェントクラスのインスタンスを生成する
agent = AgentDDPG(device=device, alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=256, layer2_size=256, batch_size=64, mode=EVAL_TRAIN_MODE) # cuda追加

if EVAL_TRAIN_MODE == 'train_mode':
    env = gym.make("HalfCheetah-v4", render_mode='depth_array')

elif EVAL_TRAIN_MODE == 'eval_mode':
    env = gym.make("HalfCheetah-v4", render_mode= 'human')


total_rewards = []
actor_losses = []
critic_losses = []
for episode in range(EPISODES):
    obs = env.reset()
    obs = T.tensor(obs[0], dtype=T.float)
    # tensor([ 0.0040,  0.0199, -0.0622,  0.0594, -0.0605,  0.0577, -0.0056,  0.0333,        -0.0072,  0.0532, -0.0512,  0.0173, -0.0529, -0.1104,  0.0946, -0.0559,         0.0824])
    #print(type(obs))
    # observation_space :  Box(-inf, inf, (17,), float64)
    #print('observation_space : ', env.observation_space)
    #print('obs :', obs)

    reward: float = 0
    total_reward: float = 0
    done: bool = False
    for j in range(STEPS):
        env.render()
        
        # ここをDDPGに置き換えていく
        action = agent.choose_action(obs) # 1.Agentクラスを定義していく # GPU対応済み
        #action :  [ 0.06660474 -0.11753064  0.02527559  0.06465236  0.1050786   0.05048539]
        #print('====ここまではOK4====')
        #print('action_space : ', env.action_space)
        #print('action : ', action)

        next_state, reward, done, _, info = env.step(action)
        #print('next_state, reward, done, _, info :', next_state, reward, done, _, info)
        """
        action :  [ 0.06660474 -0.11753064  0.02527559  0.06465236  0.1050786   0.05048539]

        next_state, reward, done, _, info : 
        [-0.00265179  0.0229547   0.00463243 -0.04729936 -0.00959038  0.04734605
        0.03672746  0.02857842  0.09980254 -0.32065693  0.04221647  1.58668951
        -2.31089174  1.30338924 -0.25465526  1.08250465 -0.14134398]
        0.07553858359316026
        False
        False
        {'x_position': -0.09233384215910741, 'x_velocity': 0.07920445513883267, 'reward_run': 0.07920445513883267, 'reward_ctrl': -0.0036658715456724168}
        """

        #7. トラジェクトを保存する。経験再生(ReplayBuffer)
        agent.remember(obs, action, reward, next_state, int(done))
       

        #12. ニューラルネットワークを学習する
        agent.learn()

        # 26.エピソード内での報酬を累積していく
        total_reward += reward
        
        # 27. next_stateをobsとして再出発する
        #print('next_state:', next_state)
        obs = next_state
        obs = T.tensor(obs, dtype=T.float)
        # 28. チーターの動きを見たいのでスリープを入れる
        time.sleep(DELAY_TIME)

    #print('total_reward : ', total_reward)
    total_rewards.append(total_reward)

    actor_losses.append(float(agent.actor_loss)) 
    critic_losses.append(float(agent.critic_loss)) 

    # print('epsisode', i, 'score %.2f' % score, '100 game sverage %.2f' % np.mean(score_history[-100:]))
 
    # 47. 各ニューラルネットワークのパラメータを１０エピソード毎に保存する
    print('episode, total_reward : ', episode , total_reward)
    if episode % 10 == 0:
        T.save(agent.actor.state_dict(), 'actor_params.pt')
        T.save(agent.critic.state_dict(), 'critic_params.pt')
        T.save(agent.target_actor.state_dict(), 'target_actor_params.pt')
        T.save(agent.target_critic.state_dict(), 'target_critic_params.pt')
        print('==== params were saved. ====')

#print('total_rewards : ', total_rewards)
#plt.plot(total_rewards)

#plt.plot(actor_losses, label='actor_losses')
#plt.plot(critic_losses, label='critic_losses')
plt.plot(total_rewards, label='total_rewards')
plt.legend()
plt.grid(True)
plt.ioff()
plt.show()

env.close() # 空なんですけど・・・

print('script is done.')

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

import gymnasium as gym

import time

import torch as T

import torch.nn as nn

import torch.nn.functional as F

import torch.optim as optim

import numpy as np

import matplotlib.pyplot as plt

import os

""" nvidia CUDA Toolkit 12.1

https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exe_local

Download cuda_12.1.1_531.14_windows.exe

"""

""" pip install

pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu121

pip install gymnasium

pip install gymnasium[mujoco]

pip install matplotlib

pip install mujoco

"""

# 44.OUActionNOoiseクラスを作成する

class OUActionNoise(object):

def __init__(self, mu, sigma=0.15, theta=0.2, dt=1e-2, x0=None):

self.mu = mu

self.sigma = sigma

self.theta = theta

self.dt = dt

self.x0 = x0

self.reset()

def __call__(self):

x = self.x_prev + self.theta * (self.mu - self.x_prev) * self.dt + \

self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)

self.x_prev = x

return x

def reset(self):

self.x_prev = self.x0 if self.x0 is not None else np.zeros_like(self.mu)

# 10. ReplayBufferクラスを新規作成する

class ReplayBuffer:

def __init__(self, max_memory_size, n_obs_space, n_action_space):

self.max_memory_size = max_memory_size

self.n_obs_space = n_obs_space

self.n_action_space = n_action_space

self.memory_count = 0

self.state_memory = np.zeros((self.max_memory_size, self.n_obs_space))

self.action_memory = np.zeros((self.max_memory_size, self.n_action_space))

self.reward_memory = np.zeros(self.max_memory_size)

self.next_state_memory = np.zeros((self.max_memory_size, self.n_obs_space))

self.terminal_memory = np.zeros(self.max_memory_size)

#self.terminal_memory = np.zeros(self.max_memory_size, dtype=np.bool)

# 11.トランジション保存のためstore_transitionメソドを作成する

def store_transition(self, obs, action, reward, next_state, done):

#print('store_transition is working.')

index = self.memory_count % self.max_memory_size # 最大メモリー数に到達したら、古いデータから上書きされていくギミック

#print('obs.detach().numpy().flatten():',obs.detach().numpy().flatten())

self.state_memory[index] = obs.detach().numpy().flatten()

self.action_memory[index] = action.flatten()

self.reward_memory[index] = reward.flatten()

self.next_state_memory[index] = next_state.flatten()

self.terminal_memory[index] = 1 - int(done) # ゴールならterminal = 0 となるように

#print('state_memory :', self.state_memory)

#print('action_memory :', self.action_memory)

#print('reward_memory :', self.reward_memory)

#print('next_state_memory :', self.next_state_memory)

#print('memory.state_memory :', self.terminal_memory)

#print('type of state_memory :', type(self.state_memory[0][0]))

#print('type of action_memory :', type(self.action_memory[0][0]))

#print('type of reward_memory :', type(self.reward_memory[0]))

#print('type of next_state_memory :', type(self.next_state_memory[0][0]))

#print('type of memory.state_memory :', type(self.terminal_memory[0]))

self.memory_count += 1

#print('memory_count :', agent.memory.memory_count)

# 16 バッファメモリーからランダムに抽出する

def sample_buffer(self, batch_size):

# indexが最大メモリに到達していない場合を想定する。

max_index = min(self.max_memory_size, self.memory_count)

choosed_index = np.random.choice(max_index, batch_size)

observations = self.state_memory[choosed_index]

actions = self.action_memory[choosed_index]

rewards = self.reward_memory[choosed_index]

next_states = self.next_state_memory[choosed_index]

terminals = self.terminal_memory[choosed_index]

return observations, actions, rewards, next_states, terminals

# 6.ActorNNクラスを新規作成する

class ActorNN(nn.Module):

def __init__(self, device, alpha=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, batch_size=64):

#print('ActorNN.__init__ is working.')

super(ActorNN, self).__init__()

self.fc1 = nn.Linear(n_obs_space, layer1_size)

self.fc2 = nn.Linear(layer1_size, layer2_size)

self.fc3 = nn.Linear(layer2_size, n_action_space)

#26.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=alpha)

# 48. actorパラメータの読み出し

# もし、パラメータのデータが存在していたらそのパラメータで初期化する。

# パラメータファイルの存在チェック

"""

# if T.cuda.is_available():

map_location = 'cuda'

else:

map_location = 'cpu'

"""

map_location = device

if os.path.isfile('actor_params.pt'):

# パラメータファイルが存在する場合はロード

self.load_state_dict(T.load('actor_params.pt', map_location=map_location))

print("パラメータファイルをロードしました:", 'actor_params.pt')

else:

print("パラメータファイルが見つかりません:", 'actor_params.pt')

def forward(self, obs):

#print('AgetDDPG.ActorNN.forward is working')

#print('====ここまではOK1====')

x = self.fc1(obs)

x = F.relu(x)

x = self.fc2(x)

x = F.relu(x)

x = self.fc3(x)

action = F.tanh(x)

return action

# 22.CriticNNクラスを新規作成する

class CriticNN(nn.Module):

def __init__(self, device, beta=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, batch_size=64):

#print('CriticNN.__init__ is working.')

super(CriticNN, self).__init__()

# クリティックNNは観察空間+行動空間の２つを入力とする構造

input_dim = n_obs_space + n_action_space

self.fc1 = nn.Linear(input_dim, layer1_size)

self.fc2 = nn.Linear(layer1_size, layer2_size)

self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

#27.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=beta)

# 49. criticパラメータの読み出し

# もし、パラメータのデータが存在していたらそのパラメータで初期化する。

# パラメータファイルの存在チェック

"""

# if T.cuda.is_available():

map_location = 'cuda'

else:

map_location = 'cpu'

"""

map_location = device

if os.path.isfile('critic_params.pt'):

# パラメータファイルが存在する場合はロード

self.load_state_dict(T.load('critic_params.pt', map_location=map_location))

print("パラメータファイルをロードしました:", 'critic_params.pt')

else:

print("パラメータファイルが見つかりません:", 'critic_params.pt')

def forward(self, obs, action):

input_data = T.cat([obs, action], dim=1)

x = self.fc1(input_data)

x = F.relu(x)

x =self.fc2(x)

x = F.relu(x)

x = self.fc3(x)

return x #一つの状態価値を出力する。

# 3.エージェントクラスを定義する

class AgentDDPG:

def __init__(self, device, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=64, layer2_size=64, batch_size=64, mode='train_mode'):

#print('AgentDDPG.__init__ is working.')

# 5.ActorNNクラスのインスタンスを生成する

self.device = device

self.alpha = alpha

self.beta = beta

self.gamma = gamma

self.tau = tau

self.n_obs_space = n_obs_space

self.n_action_space = n_action_space

self.n_state_action_value = n_state_action_value

self.layer1_size = layer1_size

self.layer2_size = layer2_size

# 13.バッチサイズを決めておく

self.batch_size = batch_size

self.actor = ActorNN(device=self.device, alpha=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, batch_size=64)

# actorネットワークをGPUへ転送

self.actor.to(device)

# 9.memoryインスタンスを追加

self.MAX_MEMORY_SIZE = 10000

self.memory = ReplayBuffer(max_memory_size=self.MAX_MEMORY_SIZE,

n_obs_space=self.n_obs_space,

n_action_space=self.n_action_space)

# 19.ターゲットアクターネットワークインスタンスtarget_actorを作成する

# actorとtarget_actorのネットワークは同じActorNNで良い

self.target_actor = ActorNN(device=self.device, alpha=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, batch_size=64)

# target_actorネットワークをGPUへ転送

self.target_actor.to(device)

# 21.ターゲットクリティックネットワークインスタンスtareget_criticを作成する

self.target_critic = CriticNN(device=self.device, beta=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, batch_size=64)

# target_criticネットワークをGPUへ転送

self.target_critic.to(device)

# 24.クリティックネットワークインスタンスcriticを作成する。

self.critic = CriticNN(device=self.device, beta=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, batch_size=64)

# criticネットワークをGPUへ転送

self.critic.to(device)

# アクターロスとクリティックロス

self.actor_loss = 0

self.critic_loss = 0

# 45.行動ノイズのインスタンス化

self.mode = mode

if self.mode == 'train_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space))

elif self.mode == 'eval_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)

else:

print('mode error')

def choose_action(self, obs): # GPU対応済み

#print('AgentDDPG.choose_action is working.')

# 4.方策（アクター）はニューラルネットワークで表現する。

# ActorNNクラスを新規作成し、インスタンスactorとして使用する。

obs = obs.to(device)

action = self.actor.forward(obs)

action = action.cpu()

# 46.行動ノイズを入れて探索性を向上させる。

action += T.tensor(self.noise(), dtype=T.float32)

action = action.detach().numpy()

return action

# 8.remenberメソドを追加

def remember(self, obs, action, reward, next_state, done):

self.memory.store_transition(obs, action, reward, next_state, done)

# 13.learnメソドを追加

def learn(self):

# 14.バッチサイズ分のトランジションが集まるまでは何も実行しない。

if self.memory.memory_count < self.batch_size:

return

# 15.メモリバッファからデータを抜き出す sample_buffer()

# バッチ化されているので変数名を複数形にする

observations, actions, rewards, next_states, terminals = self.memory.sample_buffer(self.batch_size)

#print('s:', observations)

#print(observations.shape)

#print('a :', actions)

#print('r :', rewards)

#print('s_ :', next_states)

#print('terminal :', terminals)

# 17.抜き出したデータをpytorchで微分可能なようにtorch.tensor化する

observations = T.tensor(observations, dtype=T.float32).to(device)

actions = T.tensor(actions, dtype=T.float32).to(device)

rewards = T.tensor(rewards, dtype=T.float32).to(device)

next_states = T.tensor(next_states, dtype=T.float32).to(device)

terminals = T.tensor(terminals, dtype=T.float32).to(device)

# 18.ターゲットアクターネットワークインスタンスtarget_actorに

# 次の状態next_satesを入れて、ターゲットアクションtarget_actionsとして取り出す。

# このターゲットネットワークはターゲットでないネットワークとNNパラメータを共有させる。

#print('next_states :', next_states)

target_actions = self.target_actor.forward(next_states)

# 20.ターゲットクリティックネットワークインスタンスtarget_criticに

# 次の状態next_statesと上記より算出したターゲットアクションの２つを入力して

# 価値関数の推定値ターゲットバリューを出力する。

# TDターゲット：r + γ*V(w)[s_t+1] の部分のこと。

# ターゲットクリティックバリューはターゲットアクターネットワークを使う

target_critic_values = self.target_critic.forward(next_states, target_actions)

# 23.ベースラインとして機能するクリティックネットワーク（価値関数V(w)[s_t]ネットワーク）に

# 現在の状態observationsと行動actionsを入力して

# クリティックバリューを算出する

critic_values = self.critic.forward(observations, actions)

# 25.TDターゲットを算出する：r + γ*V(w)[s_t+1]

td_targets = []

for i in range(self.batch_size):

td_target = rewards[i] + self.gamma * target_critic_values[i] * terminals[i]

td_targets.append(td_target)

# TDターゲットの形をバッチに整える

td_targets = T.tensor(td_targets, dtype=T.float32).to(device)

td_targets = td_targets.view(self.batch_size, 1) #viewはreshapeと同じ。64x1に見え方を変更した、という意味

#print('td_targets :', td_targets)

# ==== （１）クリティックの学習 ====

# 28.クリティックの勾配をゼロに初期化する

self.critic.optimizer.zero_grad()

# 29. TDターゲットと状態価値の二乗誤差を算出して、クリティックの損失関数とする。バッチサイズは６４個

critic_loss = F.mse_loss(td_targets, critic_values)

self.critic_loss = critic_loss

#print('critic_loss : ', critic_loss) # tensor(0.0485, grad_fn=<MseLossBackward0>)

# 30. クリティックの損失関数を微分して、勾配を算出する

critic_loss.backward()

# 31. 勾配からオプティマイザーによってクリティックのパラメータ（重みとバイアス）を更新する

self.critic.optimizer.step()

# ==== （２）アクターの学習 ====

# 32. アクターの勾配をゼロに初期化する

self.actor.optimizer.zero_grad()

# 33. アクターに観測情報を入力して行動を算出する。バッチサイズは６４個

predicted_actions = self.actor.forward(observations)

# 34.アクターの損失関数を算出する

# Actorの目的は、Criticネットワークの出力（行動価値）を最大化するような行動を選択すること。

# なので、actorNN→criticNNのDDPG構造全体の出力結果をactor_lossとして、actorNNとcriticNNの両方をbackwardし、

# actorだけをパラメータ更新することによりactorの学習をすることができる。

actor_loss = -self.critic.forward(observations, predicted_actions)

actor_loss = T.mean(actor_loss)

self.actor_loss = actor_loss

#print(f'actor_loss: {actor_loss}, critic_loss: {critic_loss}')

# 35. DDPG構造全体の損失関数actor_lossを微分し、勾配を算出する

actor_loss.backward()

# 36. 勾配からオプティマイザーによってアクターのパラメータだけを（重みとバイアス）を更新する

self.actor.optimizer.step()

# 37. 全ニューラルネットワークのパラメータを更新する。

self.update_network_parameters()

# 37. パラメータ更新メソド。

def update_network_parameters(self, tau=None):

if tau is None:

tau = self.tau

# 38. actor, critic, target_actor, target_criticのネットワーク内の全てのパラメータ（重みとバイアス）とその名前を取得する

# actorとcriticは先ほど更新されたばかりのパラメーター

actor_params = self.actor.named_parameters()

critic_params = self.critic.named_parameters()

target_actor_params = self.target_actor.named_parameters()

target_critic_params = self.target_critic.named_parameters()

#print('actor_params : ', actor_params) # actor_params : <generator object Module.named_parameters at 0x000001661B2D9D48>

# 39. パラメータをディクショナリとして取り出す。

actor_params_dict = dict(actor_params)

critic_params_dict = dict(critic_params)

target_actor_params_dict = dict(target_actor_params)

target_critic_params_dict = dict(target_critic_params)

#print('actor_params_dict : ', actor_params_dict)

#print(actor_params_dict.keys())

"""

actor_params_dict : {'fc1.weight': Parameter containing:

tensor([[-0.1895, -0.0343, 0.1138, ..., 0.2157, 0.0527, -0.1173],/

dict_keys(['fc1.weight', 'fc1.bias', 'fc2.weight', 'fc2.bias', 'fc3.weight', 'fc3.bias'])

"""

# 40. クリティックの各パラメーター毎に更新重みtau=0.0001の分だけほんの少しcriticパラメータをtarget_criticパラメータに近づける。

for name in critic_params_dict:

critic_params_dict[name] = tau * critic_params_dict[name].clone() + \

(1-tau) * target_critic_params_dict[name].clone()

# 41. 更新したcriticパラメータをtarget_criticのパラメータとしてロードする。

self.target_critic.load_state_dict(critic_params_dict)

# 42.アクターの各パラメーター毎に更新重みtau=0.0001の分だけほんの少しactorパラメータをtarget_actorパラメータに近づける。

for name in actor_params_dict:

actor_params_dict[name] = tau * actor_params_dict[name].clone() + \

(1 - tau) * target_actor_params_dict[name].clone()

# 43. 更新したactorパラメータをtarget_actorのパラメータとしてロードする。

self.target_actor.load_state_dict(actor_params_dict)

#### =================== メインスクリプト ======================= ####

device = T.device('cuda' if T.cuda.is_available() else 'cpu') # cuda追加

#device = 'cpu'

EVAL_TRAIN_MODE = 'train_mode' # 評価モードか訓練モードかを選択

EPISODES = 5 # episodes

STEPS = 500 # steps

DELAY_TIME = 0.00 # sec

print('Selected Mode : ', EVAL_TRAIN_MODE)

# 2.エージェントクラスのインスタンスを生成する

agent = AgentDDPG(device=device, alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=256, layer2_size=256, batch_size=64, mode=EVAL_TRAIN_MODE) # cuda追加

if EVAL_TRAIN_MODE == 'train_mode':

env = gym.make("HalfCheetah-v4", render_mode='depth_array')

elif EVAL_TRAIN_MODE == 'eval_mode':

env = gym.make("HalfCheetah-v4", render_mode= 'human')

total_rewards = []

actor_losses = []

critic_losses = []

for episode in range(EPISODES):

obs = env.reset()

obs = T.tensor(obs[0], dtype=T.float)

# tensor([ 0.0040, 0.0199, -0.0622, 0.0594, -0.0605, 0.0577, -0.0056, 0.0333, -0.0072, 0.0532, -0.0512, 0.0173, -0.0529, -0.1104, 0.0946, -0.0559, 0.0824])

#print(type(obs))

# observation_space : Box(-inf, inf, (17,), float64)

#print('observation_space : ', env.observation_space)

#print('obs :', obs)

reward: float = 0

total_reward: float = 0

done: bool = False

for j in range(STEPS):

env.render()

# ここをDDPGに置き換えていく

action = agent.choose_action(obs) # 1.Agentクラスを定義していく # GPU対応済み

#action : [ 0.06660474 -0.11753064 0.02527559 0.06465236 0.1050786 0.05048539]

#print('====ここまではOK4====')

#print('action_space : ', env.action_space)

#print('action : ', action)

next_state, reward, done, _, info = env.step(action)

#print('next_state, reward, done, _, info :', next_state, reward, done, _, info)

"""

action : [ 0.06660474 -0.11753064 0.02527559 0.06465236 0.1050786 0.05048539]

next_state, reward, done, _, info :

[-0.00265179 0.0229547 0.00463243 -0.04729936 -0.00959038 0.04734605

0.03672746 0.02857842 0.09980254 -0.32065693 0.04221647 1.58668951

-2.31089174 1.30338924 -0.25465526 1.08250465 -0.14134398]

0.07553858359316026

False

{'x_position': -0.09233384215910741, 'x_velocity': 0.07920445513883267, 'reward_run': 0.07920445513883267, 'reward_ctrl': -0.0036658715456724168}

"""

#7. トラジェクトを保存する。経験再生(ReplayBuffer)

agent.remember(obs, action, reward, next_state, int(done))

#12. ニューラルネットワークを学習する

agent.learn()

# 26.エピソード内での報酬を累積していく

total_reward += reward

# 27. next_stateをobsとして再出発する

#print('next_state:', next_state)

obs = next_state

obs = T.tensor(obs, dtype=T.float)

# 28. チーターの動きを見たいのでスリープを入れる

time.sleep(DELAY_TIME)

#print('total_reward : ', total_reward)

total_rewards.append(total_reward)

actor_losses.append(float(agent.actor_loss))

critic_losses.append(float(agent.critic_loss))

# print('epsisode', i, 'score %.2f' % score, '100 game sverage %.2f' % np.mean(score_history[-100:]))

# 47. 各ニューラルネットワークのパラメータを１０エピソード毎に保存する

print('episode, total_reward : ', episode , total_reward)

if episode % 10 == 0:

T.save(agent.actor.state_dict(), 'actor_params.pt')

T.save(agent.critic.state_dict(), 'critic_params.pt')

T.save(agent.target_actor.state_dict(), 'target_actor_params.pt')

T.save(agent.target_critic.state_dict(), 'target_critic_params.pt')

print('==== params were saved. ====')

#print('total_rewards : ', total_rewards)

#plt.plot(total_rewards)

#plt.plot(actor_losses, label='actor_losses')

#plt.plot(critic_losses, label='critic_losses')

plt.plot(total_rewards, label='total_rewards')

plt.legend()

plt.grid(True)

plt.ioff()

plt.show()

env.close() # 空なんですけど・・・

print('script is done.')

DDPG by gymnasium １２日目

GPUをニューラルネットワークのテンソル演算に利用します。

GPUへの飛ばし方

#変数deviceを’cuda’にする

device = torch.device(“cuda” if torch.cuda.is_available() else “cpu”)

#ネットワークのインスタンスを.to(‘cuda’)する

net_gpu.to(device)

# ネットワークへの入力xを.to(‘cuda’)する

x = x.to(device)

# ネットワークへの正解ラベルyをy.to(‘cuda’)する

y = y.to(device)

これでGPU上のnetへxとyを入れることができるので演算可能になります。

    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

loss = criterion(outputs, y)

loss.backward()

optimizer.step()

速度比較

class SimpleNet(nn.Module):クラスとしてネットワークを作成します。

n_inputs:2

バッチ数:4

n_output:1

n_hidden:1024

hidden layer 4層をもつ全５層のネットワークです。

ネットワークのインスタンスを２つ作って

net_cpu = SimpleNet()

net_gpu = SimpleNet()

エポック数：1000でそれぞれ回してみましょう。

結果は

CPU training time: 9.972002267837524 seconds
GPU training time: 2.5578291416168213 seconds

ということで。GPUのほうが高速です。

しかし、n_hiddenを64にすると、

CPU training time: 0.5419738292694092 seconds
GPU training time: 2.506857395172119 seconds

となり、node数が少ない場合はcpuのほうが高速になります。

GPUならいつでも高速というわけではないことに注意しましょう。

スクリプト

import torch
import torch.nn as nn
import torch.optim as optim
import time

class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        hidden = 1024
        self.fc1 = nn.Linear(2, hidden)
        self.fc2 = nn.Linear(hidden, hidden)
        self.fc3 = nn.Linear(hidden, hidden)
        self.fc4 = nn.Linear(hidden, hidden)
        self.fc5 = nn.Linear(hidden, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = torch.relu(self.fc3(x))
        x = torch.relu(self.fc4(x))
        x = self.fc5(x)
        return x

# データの生成
x = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float32)
y = torch.tensor([[0], [1], [1], [0]], dtype=torch.float32)

# ネットワークの初期化
net_cpu = SimpleNet()
net_gpu = SimpleNet()

# 損失関数とオプティマイザの定義
criterion = nn.MSELoss()
optimizer = optim.SGD(net_cpu.parameters(), lr=0.1)

# ==== CPUでのトレーニング時間の測定
start_time = time.time()

for epoch in range(1000):
    optimizer.zero_grad()
    outputs = net_cpu(x)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

end_time = time.time()
cpu_training_time = end_time - start_time
print("CPU training time:", cpu_training_time, "seconds")


# GPUでのトレーニング時間の測定
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
net_gpu.to(device)
x = x.to(device)
y = y.to(device)

start_time = time.time()

for epoch in range(1000):
    optimizer.zero_grad()
    outputs = net_gpu(x)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

end_time = time.time()
gpu_training_time = end_time - start_time
print("GPU training time:", gpu_training_time, "seconds")

import torch

import torch.nn as nn

import torch.optim as optim

import time

class SimpleNet(nn.Module):

def __init__(self):

super(SimpleNet, self).__init__()

hidden = 1024

self.fc1 = nn.Linear(2, hidden)

self.fc2 = nn.Linear(hidden, hidden)

self.fc3 = nn.Linear(hidden, hidden)

self.fc4 = nn.Linear(hidden, hidden)

self.fc5 = nn.Linear(hidden, 1)

def forward(self, x):

x = torch.relu(self.fc1(x))

x = torch.relu(self.fc2(x))

x = torch.relu(self.fc3(x))

x = torch.relu(self.fc4(x))

x = self.fc5(x)

return x

# データの生成

x = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float32)

y = torch.tensor([[0], [1], [1], [0]], dtype=torch.float32)

# ネットワークの初期化

net_cpu = SimpleNet()

net_gpu = SimpleNet()

# 損失関数とオプティマイザの定義

criterion = nn.MSELoss()

optimizer = optim.SGD(net_cpu.parameters(), lr=0.1)

# ==== CPUでのトレーニング時間の測定

start_time = time.time()

for epoch in range(1000):

optimizer.zero_grad()

outputs = net_cpu(x)

loss = criterion(outputs, y)

loss.backward()

optimizer.step()

end_time = time.time()

cpu_training_time = end_time - start_time

print("CPU training time:", cpu_training_time, "seconds")

# GPUでのトレーニング時間の測定

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

net_gpu.to(device)

x = x.to(device)

y = y.to(device)

start_time = time.time()

for epoch in range(1000):

optimizer.zero_grad()

outputs = net_gpu(x)

loss = criterion(outputs, y)

loss.backward()

optimizer.step()

end_time = time.time()

gpu_training_time = end_time - start_time

print("GPU training time:", gpu_training_time, "seconds")

次回はDDPGコードをGPU対応していきます。

DDPG by gymnasium １１日目

計算の高速化（GPUの利用）
適切なエピソード数
適切なメモリバッファ数
ネットワークの入力値？パラメータ？の正規化。
保存したパラメータを読み出すのはactorとtarget_actorまたcriticとtarget_criticで共通で良いのだろうか。

計算の高速化：GPUを使ってみる。

今日は下準備をやっていきます。

GPUの準備ができているＰＣなら

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(device)

1 2	device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(device)

で’cuda’が出力されます。

‘cpu’が出力されたならGPUの準備から始める必要があります。

GPUの準備

PCIスロットに入っているGPUを調べる

$ nvidia-smi –query-gpu=name –format=csv

出力：NVIDIA GeForce RTX 3070 Ti

cudaバージョンを調べる

$ nvidia-smi

出力：

NVIDIA-SMI 528.49　Driver Version: 528.49　CUDA Version: 12.0

CUDA Toolkit のバージョンを調べる

$ nvcc -V

出力：

nvcc: NVIDIA (R) Cuda compiler driver

Built on Fri_Jan__6_19:04:39_Pacific_Standard_Time_2023

Cuda compilation tools, release 12.0, V12.0.140

Build cuda_12.0.r12.0/compiler.32267302_0

NVIDIAのGPUドライバを最新にする

https://www.nvidia.co.jp/Download/index.aspx?lang=jp

でNVIDIA GeForce RTX 3070 Tiのドライバをインストールします。Driver Version: 531.14 にアップデートしました。

再度 $ nvidia-smiで確認すると

CUDA Version: 12.1 にアップデートしていました。

CUDA ToolkitをGPUドライバに合わせてインストールする

https://developer.nvidia.com/cuda-toolkit-archive

GPUドライバをアップデートした結果CUDAバージョンは12.1になったので、それに合わせてCUDA Toolkit 12.1.0 (February 2023), Versioned Online Documentationを選択。

次にwindows10, exeファイルを選択して、ダウンロードしてインストール。

PytorchのGPU使用バージョンをインストールする

https://pytorch.org/get-started/locally/

Pytorchがインストールされているようであれば、アンインストールしておくのが良いです。

$ pip uninstall torch

下記のように自分に合ったOS, CUDAバージョンを指定すると、インストール用のコマンドが生成されるので、実行します。

pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu121

1	pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu121

確認する

今一度下記でdeviceが’cuda’と出力されれば完了です。

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(device)

1 2	device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(device)

Pythonからもいろいろ情報を取得できます。

print(torch.__version__)
print(torch.cuda.is_available(), torch.cuda.device_count())
if torch.cuda.is_available():
    print(torch.cuda.current_device())
    print(torch.cuda.get_device_name())
    print(torch.cuda.get_device_capability())

""" 出力
2.1.0.dev20230519+cu121
True 1
0
NVIDIA GeForce RTX 3070 Ti
(8, 6)
"""

print(torch.__version__)

print(torch.cuda.is_available(), torch.cuda.device_count())

if torch.cuda.is_available():

print(torch.cuda.current_device())

print(torch.cuda.get_device_name())

print(torch.cuda.get_device_capability())

""" 出力

2.1.0.dev20230519+cu121

True 1

NVIDIA GeForce RTX 3070 Ti

(8, 6)

"""

GPUでPytorchのテンソルを計算してみよう。

cpu_tensor = torch.rand(10)
gpu_tensor = cpu_tensor.to(device=device)
print('cpu_tensor : ', cpu_tensor)
print('gpu_tensor : ', gpu_tensor)
print('gpu culc : ', gpu_tensor * gpu_tensor)

cpu_tensor = torch.rand(10)

gpu_tensor = cpu_tensor.to(device=device)

print('cpu_tensor : ', cpu_tensor)

print('gpu_tensor : ', gpu_tensor)

print('gpu culc : ', gpu_tensor * gpu_tensor)

結果

GPU同士でないと計算できないので注意です。

cpu_tensor :  tensor([0.6008, 0.6893, 0.2151, 0.6096, 0.3254, 0.5945, 0.1834, 0.3007, 0.3145,
        0.7312])
gpu_tensor :  tensor([0.6008, 0.6893, 0.2151, 0.6096, 0.3254, 0.5945, 0.1834, 0.3007, 0.3145,
        0.7312], device='cuda:0')
gpu culc :  tensor([0.3609, 0.4752, 0.0463, 0.3716, 0.1059, 0.3535, 0.0337, 0.0904, 0.0989,
        0.5346], device='cuda:0')

cpu_tensor : tensor([0.6008, 0.6893, 0.2151, 0.6096, 0.3254, 0.5945, 0.1834, 0.3007, 0.3145,

0.7312])

gpu_tensor : tensor([0.6008, 0.6893, 0.2151, 0.6096, 0.3254, 0.5945, 0.1834, 0.3007, 0.3145,

0.7312], device='cuda:0')

gpu culc : tensor([0.3609, 0.4752, 0.0463, 0.3716, 0.1059, 0.3535, 0.0337, 0.0904, 0.0989,

0.5346], device='cuda:0')

演算後にCPU上の数値またはNumpy.arrayと演算するためにはGPU上からCPU上へ戻す必要があります。

# gpu上のテンソルをCPU上にコピーし、テンソルを計算グラフから切り離し、numpyのarrayに変換する一連の操作。
numpy_array = gpu_tensor.cpu().detach().numpy()

1 2	# gpu上のテンソルをCPU上にコピーし、テンソルを計算グラフから切り離し、numpyのarrayに変換する一連の操作。 numpy_array = gpu_tensor.cpu().detach().numpy()

また、GPU上にあるとmatplotlibでグラフが書けないので、GPU→CPUまたは、Numpy.arrayにしてからmatplotlibで描画します。

gpu上にある数値でグラフ描画を試みたときの警告

plt.plot(gpu_tensor)

#TypeError: can’t convert cuda:0 device type tensor to numpy. Use Tensor.cpu() to copy the tensor to host memory first.

次回

次回はニューラルネットワークに

device = torch.device(‘cuda’ if torch.cuda.is_available() else ‘cpu’)

と

tensor.to(device)

と

numpy_array = gpu_tensor.cpu().detach().numpy()

を入れ込んでみます。

DDPG by gymnasium １０日目

未解決の課題・疑問点

model.train()とmodel.eval()の使い方が分からない。
計算の高速化（GPUの利用）
適切なエピソード数
適切なメモリバッファ数
ネットワークの入力値？パラメータ？の正規化。
保存したパラメータを読み出すのはactorとtarget_actorまたcriticとtarget_criticで共通で良いのだろうか。

model.train()とmodel.eval()の使い方

ニューラルネットワークの訓練モードと評価モードを切り替えるメソドのようです。

例えばNNモデルがactorの場合

インスタンス生成：actor = ActorNN(引数)　してから

actor.train()で訓練モードに設定すると、バッチ正規化やドロップアウトなどの要素が有効になります。あくまで自分でバッチ正規化、ドロップアウトを設定していた場合です。

逆に、actor.eval()にするとバッチ正規化、ドロップアウトを設定していたとしても無効化されます。

ここで重要なのはactor.eval()であっても勾配は計算するし、パラメータ更新も行われるということです。評価モードということなので、推論だけするのかと勘違いしてしまいますが違います。

証拠としてスクリプトを置いておきますので実行してみてください。ちゃんと勾配計算して損失関数の値も減少していきます。

サンプルスクリプト

import torch as T
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import matplotlib.pyplot as plt

class ActorNN(nn.Module):
    def __init__(self, n_inputs, n_hidden, n_outputs):
        super(ActorNN, self).__init__()

        self.fc1 = nn.Linear(n_inputs, n_hidden)
        self.fc2 = nn.Linear(n_hidden, n_hidden)
        self.fc3 = nn.Linear(n_hidden, n_outputs)

        #self.optimizer = optim.SGD(self.parameters(), lr=0.01)
        self.optimizer = optim.SGD(self.parameters(), lr=0.01)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        y_pred = F.tanh(self.fc3(x))
        return y_pred

actor = ActorNN(n_inputs=4, n_hidden=256, n_outputs=4)
#actor.train()
actor.eval()

inputs = T.tensor([1,2,3,4], dtype=T.float32)
y_label = T.tensor([0,1,0,0], dtype=T.float32)

threshold = 1e-4
losses = []
N_EPOCHS = 10000
for epoch in range(N_EPOCHS):
    y_pred = actor.forward(inputs)
    loss = F.mse_loss(y_pred, y_label) 
    actor.optimizer.zero_grad()    
    loss.backward()
    actor.optimizer.step()

    print(epoch, loss.item(), y_pred.detach().numpy())
    losses.append(loss.detach().numpy())

    if loss.detach().numpy() < threshold:
        break

plt.plot(losses)
plt.show()そ

import torch as T

import torch.nn as nn

import torch.nn.functional as F

import torch.optim as optim

import matplotlib.pyplot as plt

class ActorNN(nn.Module):

def __init__(self, n_inputs, n_hidden, n_outputs):

super(ActorNN, self).__init__()

self.fc1 = nn.Linear(n_inputs, n_hidden)

self.fc2 = nn.Linear(n_hidden, n_hidden)

self.fc3 = nn.Linear(n_hidden, n_outputs)

#self.optimizer = optim.SGD(self.parameters(), lr=0.01)

self.optimizer = optim.SGD(self.parameters(), lr=0.01)

def forward(self, x):

x = F.relu(self.fc1(x))

x = F.relu(self.fc2(x))

y_pred = F.tanh(self.fc3(x))

return y_pred

actor = ActorNN(n_inputs=4, n_hidden=256, n_outputs=4)

#actor.train()

actor.eval()

inputs = T.tensor([1,2,3,4], dtype=T.float32)

y_label = T.tensor([0,1,0,0], dtype=T.float32)

threshold = 1e-4

losses = []

N_EPOCHS = 10000

for epoch in range(N_EPOCHS):

y_pred = actor.forward(inputs)

loss = F.mse_loss(y_pred, y_label)

actor.optimizer.zero_grad()

loss.backward()

actor.optimizer.step()

print(epoch, loss.item(), y_pred.detach().numpy())

losses.append(loss.detach().numpy())

if loss.detach().numpy() < threshold:

break

plt.plot(losses)

plt.show()そ

パラメータ更新による損失関数の減少グラフ

推論するときはOUActionNoise()を止めよう

バッチ正規化やドロップアウトで訓練した場合、actor.eval()で無効化が必要なのはわかりました。しかし行動ノイズは依然として有効なので、こちらも止めましょう。

ou_noise = OUActionNoise(mu=np.zeros(1), sigma=0)

のように sigmaを0に設定することで更新を停止するギミックが必要になります。

メインスクリプト

EVAL_TRAIN_MODE = 'eval_mode' # 評価モードか訓練モードかを選択

1	EVAL_TRAIN_MODE = 'eval_mode' # 評価モードか訓練モードかを選択

# 2.エージェントクラスのインスタンスを生成する
agent = AgentDDPG(alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=256, layer2_size=256, batch_size=64, mode=EVAL_TRAIN_MODE)

# 2.エージェントクラスのインスタンスを生成する

agent = AgentDDPG(alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=256, layer2_size=256, batch_size=64, mode=EVAL_TRAIN_MODE)

AgentDDPGクラス

class AgentDDPG:
    def __init__(self, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=64, layer2_size=64, batch_size=64, mode='train_mode'):

        # 45.行動ノイズのインスタンス化
        self.mode = mode
        if self.mode == 'train_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space))
        elif self.mode == 'eval_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)
        else:
            print('mode error')

class AgentDDPG:

def __init__(self, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=64, layer2_size=64, batch_size=64, mode='train_mode'):

# 45.行動ノイズのインスタンス化

self.mode = mode

if self.mode == 'train_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space))

elif self.mode == 'eval_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)

else:

print('mode error')

これでOUActionNoise()は無効化できました。

ハーフチーターがプルプルしなくなりました。

しかし、各ニューラルネットワークのパラメータ更新は止まっているわけではありません。

パラメータ更新を止める

書きかけです。おそらく、EVAL_TRAIN_MODE = ‘eval_mode’ でないときだけパラメータ更新メソドである、optim.step()を行うようにすればよいと思います。

if EVAL_TRAIN_MODE != ‘eval_mode’:

self.optimizer.step()

現在のスクリプト全体

import gymnasium as gym
import time
import torch as T
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
import os

""" nvidia CUDA Toolkit 12.1
https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exe_local
Download cuda_12.1.1_531.14_windows.exe
"""
""" pip install
pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu121
pip install gymnasium
pip install gymnasium[mujoco]
pip install matplotlib
pip install mujoco
"""
# 44.OUActionNOoiseクラスを作成する
class OUActionNoise(object):
    def __init__(self, mu, sigma=0.15, theta=0.2, dt=1e-2, x0=None):
        self.mu = mu
        self.sigma = sigma
        self.theta = theta
        self.dt = dt
        self.x0 = x0
        self.reset()

    def __call__(self):
        x = self.x_prev + self.theta * (self.mu - self.x_prev) * self.dt + \
        self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)
        self.x_prev = x
        return x

    def reset(self):
        self.x_prev = self.x0 if self.x0 is not None else np.zeros_like(self.mu)


# 10. ReplayBufferクラスを新規作成する
class ReplayBuffer:
    def __init__(self, max_memory_size, n_obs_space, n_action_space):
        self.max_memory_size = max_memory_size
        self.n_obs_space = n_obs_space
        self.n_action_space = n_action_space

        self.memory_count = 0

        self.state_memory = np.zeros((self.max_memory_size, self.n_obs_space))
        self.action_memory =  np.zeros((self.max_memory_size, self.n_action_space))
        self.reward_memory =  np.zeros(self.max_memory_size)
        self.next_state_memory =  np.zeros((self.max_memory_size, self.n_obs_space))
        self.terminal_memory =  np.zeros(self.max_memory_size)
        #self.terminal_memory = np.zeros(self.max_memory_size, dtype=np.bool)

    # 11.トランジション保存のためstore_transitionメソドを作成する
    def store_transition(self, obs, action, reward, next_state, done):
        #print('store_transition is working.')
        index = self.memory_count % self.max_memory_size # 最大メモリー数に到達したら、古いデータから上書きされていくギミック
        #print('obs.detach().numpy().flatten():',obs.detach().numpy().flatten())
        self.state_memory[index] = obs.detach().numpy().flatten()
        self.action_memory[index] = action.flatten()
        self.reward_memory[index] = reward.flatten()
        self.next_state_memory[index] = next_state.flatten()
        self.terminal_memory[index] = 1 - int(done) # ゴールならterminal = 0 となるように
        #print('state_memory :', self.state_memory)
        #print('action_memory :', self.action_memory)
        #print('reward_memory :', self.reward_memory)
        #print('next_state_memory :', self.next_state_memory)
        #print('memory.state_memory :', self.terminal_memory)

        #print('type of state_memory :', type(self.state_memory[0][0]))
        #print('type of action_memory :', type(self.action_memory[0][0]))
        #print('type of reward_memory :', type(self.reward_memory[0]))
        #print('type of next_state_memory :', type(self.next_state_memory[0][0]))
        #print('type of memory.state_memory :', type(self.terminal_memory[0]))

        self.memory_count += 1
        #print('memory_count :', agent.memory.memory_count)

    # 16 バッファメモリーからランダムに抽出する
    def sample_buffer(self, batch_size):
        # indexが最大メモリに到達していない場合を想定する。
        max_index = min(self.max_memory_size, self.memory_count)
        choosed_index = np.random.choice(max_index, batch_size)
        
        observations = self.state_memory[choosed_index]
        actions = self.action_memory[choosed_index]
        rewards = self.reward_memory[choosed_index]
        next_states = self.next_state_memory[choosed_index]
        terminals = self.terminal_memory[choosed_index]

        return observations, actions, rewards, next_states, terminals


# 6.ActorNNクラスを新規作成する
class ActorNN(nn.Module):
    def __init__(self, alpha=0.001, n_obs_space=17, n_action_space=6,
                                    layer1_size=256, layer2_size=256, batch_size=64):
        #print('ActorNN.__init__ is working.')
        super(ActorNN, self).__init__()
        self.fc1 = nn.Linear(n_obs_space, layer1_size)
        self.fc2 = nn.Linear(layer1_size, layer2_size)
        self.fc3 = nn.Linear(layer2_size, n_action_space)

        #26.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=alpha)

        # 48. actorパラメータの読み出し
        # もし、パラメータのデータが存在していたらそのパラメータで初期化する。
        # パラメータファイルの存在チェック
        if T.cuda.is_available():
            map_location = 'cuda'
        else:
            map_location = 'cpu'

        if os.path.isfile('actor_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.load_state_dict(T.load('actor_params.pt', map_location=map_location))
            print("パラメータファイルをロードしました:", 'actor_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'actor_params.pt')

    def forward(self, obs):
        #print('AgetDDPG.ActorNN.forward is working')
        #print('====ここまではOK1====')
        x = self.fc1(obs)
        x = F.relu(x)
        x = self.fc2(x)
        x = F.relu(x)
        x = self.fc3(x)
        action = F.tanh(x)

        return action

# 22.CriticNNクラスを新規作成する
class CriticNN(nn.Module):

    def __init__(self, beta=0.001, n_obs_space=17, n_action_space=6,
                 layer1_size=256, layer2_size=256, batch_size=64):
        #print('CriticNN.__init__ is working.')
        super(CriticNN, self).__init__()

        # クリティックNNは観察空間+行動空間の２つを入力とする構造
        input_dim = n_obs_space + n_action_space
        self.fc1 = nn.Linear(input_dim, layer1_size)
        self.fc2 = nn.Linear(layer1_size, layer2_size)
        self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

        #27.最適化処理としてアダムを設定する
        self.optimizer = optim.Adam(self.parameters(), lr=beta)

        # 49. criticパラメータの読み出し
        # もし、パラメータのデータが存在していたらそのパラメータで初期化する。
        # パラメータファイルの存在チェック
        if T.cuda.is_available():
            map_location = 'cuda'
        else:
            map_location = 'cpu'

        if os.path.isfile('critic_params.pt'):
            # パラメータファイルが存在する場合はロード
            self.load_state_dict(T.load('critic_params.pt', map_location=map_location))
            print("パラメータファイルをロードしました:", 'critic_params.pt')
        else:
            print("パラメータファイルが見つかりません:", 'critic_params.pt')

    def forward(self, obs, action):
        input_data = T.cat([obs, action], dim=1)
        x = self.fc1(input_data)
        x = F.relu(x)
        x =self.fc2(x)
        x = F.relu(x)
        x = self.fc3(x)
        return x #一つの状態価値を出力する。

# 3.エージェントクラスを定義する
class AgentDDPG:

    def __init__(self, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=64, layer2_size=64, batch_size=64, mode='train_mode'):
        #print('AgentDDPG.__init__ is working.')
        # 5.ActorNNクラスのインスタンスを生成する
        self.alpha = alpha
        self.beta = beta
        self.gamma = gamma
        self.tau = tau
        
        self.n_obs_space = n_obs_space
        self.n_action_space = n_action_space

        self.n_state_action_value = n_state_action_value

        self.layer1_size = layer1_size
        self.layer2_size = layer2_size

        # 13.バッチサイズを決めておく
        self.batch_size = batch_size 

        self.actor = ActorNN(alpha=0.000025, n_obs_space=17, n_action_space=6,
                            layer1_size=64, layer2_size=64, batch_size=64)        
        
        # 9.memoryインスタンスを追加
        self.MAX_MEMORY_SIZE = 10000
        self.memory = ReplayBuffer(max_memory_size=self.MAX_MEMORY_SIZE,
                                   n_obs_space=self.n_obs_space,
                                   n_action_space=self.n_action_space)
        
        # 19.ターゲットアクターネットワークインスタンスtarget_actorを作成する
        # actorとtarget_actorのネットワークは同じActorNNで良い
        self.target_actor = ActorNN(alpha=0.000025, n_obs_space=17, n_action_space=6,
                                    layer1_size=64, layer2_size=64, batch_size=64)

        
        # 21.ターゲットクリティックネットワークインスタンスtareget_criticを作成する
        self.target_critic = CriticNN(beta=0.000025, n_obs_space=17, n_action_space=6,
                                    layer1_size=64, layer2_size=64, batch_size=64)
        
        # 24.クリティックネットワークインスタンスcriticを作成する。
        self.critic = CriticNN(beta=0.000025, n_obs_space=17, n_action_space=6,
                               layer1_size=64, layer2_size=64, batch_size=64)
        
        # アクターロスとクリティックロス
        self.actor_loss = 0
        self.critic_loss = 0
        
        # 45.行動ノイズのインスタンス化
        self.mode = mode
        if self.mode == 'train_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space))
        elif self.mode == 'eval_mode':
            self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)
        else:
            print('mode error')
        

    def choose_action(self, obs):
        #print('AgentDDPG.choose_action is working.')
        # 4.方策（アクター）はニューラルネットワークで表現する。
        #   ActorNNクラスを新規作成し、インスタンスactorとして使用する。
        action = self.actor.forward(obs)
        

        # 46.行動ノイズを入れて探索性を向上させる。
        action += T.tensor(self.noise(), dtype=T.float32)
        action = action.detach().numpy()

        return action
    
    # 8.remenberメソドを追加
    def remember(self, obs, action, reward, next_state, done):
        self.memory.store_transition(obs, action, reward, next_state, done)

    # 13.learnメソドを追加
    def learn(self):
        # 14.バッチサイズ分のトランジションが集まるまでは何も実行しない。
        if self.memory.memory_count < self.batch_size:
            return
        
        # 15.メモリバッファからデータを抜き出す sample_buffer()
        # バッチ化されているので変数名を複数形にする
        observations, actions, rewards, next_states, terminals = self.memory.sample_buffer(self.batch_size)
        #print('s:', observations)
        #print(observations.shape)
        #print('a :', actions)
        #print('r :', rewards)
        #print('s_ :', next_states)
        #print('terminal :', terminals)

        # 17.抜き出したデータをpytorchで微分可能なようにtorch.tensor化する
        observations = T.tensor(observations, dtype=T.float32)
        actions = T.tensor(actions, dtype=T.float32)
        rewards = T.tensor(rewards, dtype=T.float32)
        next_states = T.tensor(next_states, dtype=T.float32)
        terminals = T.tensor(terminals, dtype=T.float32)
       
        # 18.ターゲットアクターネットワークインスタンスtarget_actorに
        # 次の状態next_satesを入れて、ターゲットアクションtarget_actionsとして取り出す。
        # このターゲットネットワークはターゲットでないネットワークとNNパラメータを共有させる。
        #print('next_states :', next_states)
        target_actions = self.target_actor.forward(next_states)

        # 20.ターゲットクリティックネットワークインスタンスtarget_criticに
        # 次の状態next_statesと上記より算出したターゲットアクションの２つを入力して
        # 価値関数の推定値ターゲットバリューを出力する。
        # TDターゲット：r + γ*V(w)[s_t+1] の部分のこと。
        # ターゲットクリティックバリューはターゲットアクターネットワークを使う
        target_critic_values = self.target_critic.forward(next_states, target_actions)

        
        # 23.ベースラインとして機能するクリティックネットワーク（価値関数V(w)[s_t]ネットワーク）に
        # 現在の状態observationsと行動actionsを入力して
        # クリティックバリューを算出する
        critic_values = self.critic.forward(observations, actions)

        # 25.TDターゲットを算出する：r + γ*V(w)[s_t+1]
        td_targets = []
        for i in range(self.batch_size):
            td_target = rewards[i] + self.gamma * target_critic_values[i] * terminals[i]
            td_targets.append(td_target)
        
        # TDターゲットの形をバッチに整える
        td_targets = T.tensor(td_targets, dtype=T.float32)
        td_targets = td_targets.view(self.batch_size, 1) #viewはreshapeと同じ。64x1に見え方を変更した、という意味
        #print('td_targets :', td_targets)


        # ==== （１）クリティックの学習 ====

        # 28.クリティックの勾配をゼロに初期化する
        self.critic.optimizer.zero_grad()

        # 29. TDターゲットと状態価値の二乗誤差を算出して、クリティックの損失関数とする。バッチサイズは６４個
        critic_loss = F.mse_loss(td_targets, critic_values)
        self.critic_loss = critic_loss
        #print('critic_loss : ', critic_loss) # tensor(0.0485, grad_fn=<MseLossBackward0>)

        # 30. クリティックの損失関数を微分して、勾配を算出する
        critic_loss.backward()

        # 31. 勾配からオプティマイザーによってクリティックのパラメータ（重みとバイアス）を更新する
        self.critic.optimizer.step()


        # ==== （２）アクターの学習 ====

        # 32. アクターの勾配をゼロに初期化する
        self.actor.optimizer.zero_grad()

        # 33. アクターに観測情報を入力して行動を算出する。バッチサイズは６４個
        predicted_actions = self.actor.forward(observations)

        # 34.アクターの損失関数を算出する
        #    Actorの目的は、Criticネットワークの出力（行動価値）を最大化するような行動を選択すること。
        #    なので、actorNN→criticNNのDDPG構造全体の出力結果をactor_lossとして、actorNNとcriticNNの両方をbackwardし、
        #    actorだけをパラメータ更新することによりactorの学習をすることができる。

        actor_loss = -self.critic.forward(observations, predicted_actions)
        actor_loss = T.mean(actor_loss)
        self.actor_loss = actor_loss

        #print(f'actor_loss: {actor_loss}, critic_loss: {critic_loss}')

        # 35. DDPG構造全体の損失関数actor_lossを微分し、勾配を算出する
        actor_loss.backward()

        # 36. 勾配からオプティマイザーによってアクターのパラメータだけを（重みとバイアス）を更新する
        self.actor.optimizer.step()
    
        # 37. 全ニューラルネットワークのパラメータを更新する。
        self.update_network_parameters()

    # 37. パラメータ更新メソド。
    def update_network_parameters(self, tau=None):
        if tau is None:
            tau = self.tau
    
        # 38. actor, critic, target_actor, target_criticのネットワーク内の全てのパラメータ（重みとバイアス）とその名前を取得する
        # actorとcriticは先ほど更新されたばかりのパラメーター
        actor_params = self.actor.named_parameters()
        critic_params = self.critic.named_parameters()
        target_actor_params = self.target_actor.named_parameters()
        target_critic_params = self.target_critic.named_parameters()
        #print('actor_params : ', actor_params) # actor_params :  <generator object Module.named_parameters at 0x000001661B2D9D48>

        # 39. パラメータをディクショナリとして取り出す。
        actor_params_dict = dict(actor_params)
        critic_params_dict = dict(critic_params)
        target_actor_params_dict = dict(target_actor_params)
        target_critic_params_dict = dict(target_critic_params)
        #print('actor_params_dict : ', actor_params_dict)
        #print(actor_params_dict.keys())
        """
        actor_params_dict :  {'fc1.weight': Parameter containing:
                                   tensor([[-0.1895, -0.0343,  0.1138,  ...,  0.2157,  0.0527, -0.1173],/

        dict_keys(['fc1.weight', 'fc1.bias', 'fc2.weight', 'fc2.bias', 'fc3.weight', 'fc3.bias'])
        """

        # 40. クリティックの各パラメーター毎に 更新重みtau=0.0001の分だけほんの少しcriticパラメータをtarget_criticパラメータに近づける。
        for name in critic_params_dict:
            critic_params_dict[name] = tau * critic_params_dict[name].clone() + \
                                       (1-tau) * target_critic_params_dict[name].clone()
            
        # 41. 更新したcriticパラメータをtarget_criticのパラメータとしてロードする。
        self.target_critic.load_state_dict(critic_params_dict)

        # 42.アクターの各パラメーター毎に 更新重みtau=0.0001の分だけほんの少しactorパラメータをtarget_actorパラメータに近づける。
        for name in actor_params_dict:
            actor_params_dict[name] = tau * actor_params_dict[name].clone() + \
                                      (1 - tau) * target_actor_params_dict[name].clone()
            
        # 43. 更新したactorパラメータをtarget_actorのパラメータとしてロードする。
        self.target_actor.load_state_dict(actor_params_dict)


#### =================== メインスクリプト ======================= ####



EVAL_TRAIN_MODE = 'train_mode' # 評価モードか訓練モードかを選択
EPISODES = 1001# episodes
STEPS = 500    # steps
DELAY_TIME = 0.00 # sec

# 2.エージェントクラスのインスタンスを生成する
agent = AgentDDPG(alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,
                  n_obs_space=17 , n_action_space=6, n_state_action_value=1,
                  layer1_size=256, layer2_size=256, batch_size=64, mode=EVAL_TRAIN_MODE)

if EVAL_TRAIN_MODE == 'train_mode':
    env = gym.make("HalfCheetah-v4", render_mode='depth_array')

elif EVAL_TRAIN_MODE == 'eval_mode':
    env = gym.make("HalfCheetah-v4", render_mode= 'human')


total_rewards = []
actor_losses = []
critic_losses = []
for episode in range(EPISODES):
    obs = env.reset()
    obs = T.tensor(obs[0], dtype=T.float)
    # tensor([ 0.0040,  0.0199, -0.0622,  0.0594, -0.0605,  0.0577, -0.0056,  0.0333,        -0.0072,  0.0532, -0.0512,  0.0173, -0.0529, -0.1104,  0.0946, -0.0559,         0.0824])
    #print(type(obs))
    # observation_space :  Box(-inf, inf, (17,), float64)
    #print('observation_space : ', env.observation_space)
    #print('obs :', obs)

    reward: float = 0
    total_reward: float = 0
    done: bool = False
    for j in range(STEPS):
        env.render()
        
        # ここをDDPGに置き換えていく
        action = agent.choose_action(obs) # 1.Agentクラスを定義していく
        #action :  [ 0.06660474 -0.11753064  0.02527559  0.06465236  0.1050786   0.05048539]
        #print('====ここまではOK4====')
        #print('action_space : ', env.action_space)
        #print('action : ', action)

        next_state, reward, done, _, info = env.step(action)
        #print('next_state, reward, done, _, info :', next_state, reward, done, _, info)
        """
        action :  [ 0.06660474 -0.11753064  0.02527559  0.06465236  0.1050786   0.05048539]

        next_state, reward, done, _, info : 
        [-0.00265179  0.0229547   0.00463243 -0.04729936 -0.00959038  0.04734605
        0.03672746  0.02857842  0.09980254 -0.32065693  0.04221647  1.58668951
        -2.31089174  1.30338924 -0.25465526  1.08250465 -0.14134398]
        0.07553858359316026
        False
        False
        {'x_position': -0.09233384215910741, 'x_velocity': 0.07920445513883267, 'reward_run': 0.07920445513883267, 'reward_ctrl': -0.0036658715456724168}
        """

        #7. トラジェクトを保存する。経験再生(ReplayBuffer)
        agent.remember(obs, action, reward, next_state, int(done))

        #12. ニューラルネットワークを学習する
        agent.learn()
        
        # 26.エピソード内での報酬を累積していく
        total_reward += reward
        
        # 27. next_stateをobsとして再出発する
        #print('next_state:', next_state)
        obs = next_state
        obs = T.tensor(obs, dtype=T.float)
        # 28. チーターの動きを見たいのでスリープを入れる
        time.sleep(DELAY_TIME)

    #print('total_reward : ', total_reward)
    total_rewards.append(total_reward)

    actor_losses.append(float(agent.actor_loss)) 
    critic_losses.append(float(agent.critic_loss)) 

    # print('epsisode', i, 'score %.2f' % score, '100 game sverage %.2f' % np.mean(score_history[-100:]))
 
    # 47. 各ニューラルネットワークのパラメータを１０エピソード毎に保存する
    print('episode, total_reward : ', episode , total_reward)
    if episode % 10 == 0:
        T.save(agent.actor.state_dict(), 'actor_params.pt')
        T.save(agent.critic.state_dict(), 'critic_params.pt')
        T.save(agent.target_actor.state_dict(), 'target_actor_params.pt')
        T.save(agent.target_critic.state_dict(), 'target_critic_params.pt')
        print('==== params were saved. ====')

#print('total_rewards : ', total_rewards)
#plt.plot(total_rewards)

#plt.plot(actor_losses, label='actor_losses')
#plt.plot(critic_losses, label='critic_losses')
plt.plot(total_rewards, label='total_rewards')
plt.legend()
plt.grid(True)
plt.ioff()
plt.show()

env.close() # 空なんですけど・・・

print('script is done.')

# https://gymnasium.farama.org/

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

import gymnasium as gym

import time

import torch as T

import torch.nn as nn

import torch.nn.functional as F

import torch.optim as optim

import numpy as np

import matplotlib.pyplot as plt

import os

""" nvidia CUDA Toolkit 12.1

https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exe_local

Download cuda_12.1.1_531.14_windows.exe

"""

""" pip install

pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu121

pip install gymnasium

pip install gymnasium[mujoco]

pip install matplotlib

pip install mujoco

"""

# 44.OUActionNOoiseクラスを作成する

class OUActionNoise(object):

def __init__(self, mu, sigma=0.15, theta=0.2, dt=1e-2, x0=None):

self.mu = mu

self.sigma = sigma

self.theta = theta

self.dt = dt

self.x0 = x0

self.reset()

def __call__(self):

x = self.x_prev + self.theta * (self.mu - self.x_prev) * self.dt + \

self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)

self.x_prev = x

return x

def reset(self):

self.x_prev = self.x0 if self.x0 is not None else np.zeros_like(self.mu)

# 10. ReplayBufferクラスを新規作成する

class ReplayBuffer:

def __init__(self, max_memory_size, n_obs_space, n_action_space):

self.max_memory_size = max_memory_size

self.n_obs_space = n_obs_space

self.n_action_space = n_action_space

self.memory_count = 0

self.state_memory = np.zeros((self.max_memory_size, self.n_obs_space))

self.action_memory = np.zeros((self.max_memory_size, self.n_action_space))

self.reward_memory = np.zeros(self.max_memory_size)

self.next_state_memory = np.zeros((self.max_memory_size, self.n_obs_space))

self.terminal_memory = np.zeros(self.max_memory_size)

#self.terminal_memory = np.zeros(self.max_memory_size, dtype=np.bool)

# 11.トランジション保存のためstore_transitionメソドを作成する

def store_transition(self, obs, action, reward, next_state, done):

#print('store_transition is working.')

index = self.memory_count % self.max_memory_size # 最大メモリー数に到達したら、古いデータから上書きされていくギミック

#print('obs.detach().numpy().flatten():',obs.detach().numpy().flatten())

self.state_memory[index] = obs.detach().numpy().flatten()

self.action_memory[index] = action.flatten()

self.reward_memory[index] = reward.flatten()

self.next_state_memory[index] = next_state.flatten()

self.terminal_memory[index] = 1 - int(done) # ゴールならterminal = 0 となるように

#print('state_memory :', self.state_memory)

#print('action_memory :', self.action_memory)

#print('reward_memory :', self.reward_memory)

#print('next_state_memory :', self.next_state_memory)

#print('memory.state_memory :', self.terminal_memory)

#print('type of state_memory :', type(self.state_memory[0][0]))

#print('type of action_memory :', type(self.action_memory[0][0]))

#print('type of reward_memory :', type(self.reward_memory[0]))

#print('type of next_state_memory :', type(self.next_state_memory[0][0]))

#print('type of memory.state_memory :', type(self.terminal_memory[0]))

self.memory_count += 1

#print('memory_count :', agent.memory.memory_count)

# 16 バッファメモリーからランダムに抽出する

def sample_buffer(self, batch_size):

# indexが最大メモリに到達していない場合を想定する。

max_index = min(self.max_memory_size, self.memory_count)

choosed_index = np.random.choice(max_index, batch_size)

observations = self.state_memory[choosed_index]

actions = self.action_memory[choosed_index]

rewards = self.reward_memory[choosed_index]

next_states = self.next_state_memory[choosed_index]

terminals = self.terminal_memory[choosed_index]

return observations, actions, rewards, next_states, terminals

# 6.ActorNNクラスを新規作成する

class ActorNN(nn.Module):

def __init__(self, alpha=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, batch_size=64):

#print('ActorNN.__init__ is working.')

super(ActorNN, self).__init__()

self.fc1 = nn.Linear(n_obs_space, layer1_size)

self.fc2 = nn.Linear(layer1_size, layer2_size)

self.fc3 = nn.Linear(layer2_size, n_action_space)

#26.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=alpha)

# 48. actorパラメータの読み出し

# もし、パラメータのデータが存在していたらそのパラメータで初期化する。

# パラメータファイルの存在チェック

if T.cuda.is_available():

map_location = 'cuda'

else:

map_location = 'cpu'

if os.path.isfile('actor_params.pt'):

# パラメータファイルが存在する場合はロード

self.load_state_dict(T.load('actor_params.pt', map_location=map_location))

print("パラメータファイルをロードしました:", 'actor_params.pt')

else:

print("パラメータファイルが見つかりません:", 'actor_params.pt')

def forward(self, obs):

#print('AgetDDPG.ActorNN.forward is working')

#print('====ここまではOK1====')

x = self.fc1(obs)

x = F.relu(x)

x = self.fc2(x)

x = F.relu(x)

x = self.fc3(x)

action = F.tanh(x)

return action

# 22.CriticNNクラスを新規作成する

class CriticNN(nn.Module):

def __init__(self, beta=0.001, n_obs_space=17, n_action_space=6,

layer1_size=256, layer2_size=256, batch_size=64):

#print('CriticNN.__init__ is working.')

super(CriticNN, self).__init__()

# クリティックNNは観察空間+行動空間の２つを入力とする構造

input_dim = n_obs_space + n_action_space

self.fc1 = nn.Linear(input_dim, layer1_size)

self.fc2 = nn.Linear(layer1_size, layer2_size)

self.fc3 = nn.Linear(layer2_size, 1) # 最後は1個で良い

#27.最適化処理としてアダムを設定する

self.optimizer = optim.Adam(self.parameters(), lr=beta)

# 49. criticパラメータの読み出し

# もし、パラメータのデータが存在していたらそのパラメータで初期化する。

# パラメータファイルの存在チェック

if T.cuda.is_available():

map_location = 'cuda'

else:

map_location = 'cpu'

if os.path.isfile('critic_params.pt'):

# パラメータファイルが存在する場合はロード

self.load_state_dict(T.load('critic_params.pt', map_location=map_location))

print("パラメータファイルをロードしました:", 'critic_params.pt')

else:

print("パラメータファイルが見つかりません:", 'critic_params.pt')

def forward(self, obs, action):

input_data = T.cat([obs, action], dim=1)

x = self.fc1(input_data)

x = F.relu(x)

x =self.fc2(x)

x = F.relu(x)

x = self.fc3(x)

return x #一つの状態価値を出力する。

# 3.エージェントクラスを定義する

class AgentDDPG:

def __init__(self, alpha=0.000025, beta=0.00025, gamma=0.99, tau=0.001,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=64, layer2_size=64, batch_size=64, mode='train_mode'):

#print('AgentDDPG.__init__ is working.')

# 5.ActorNNクラスのインスタンスを生成する

self.alpha = alpha

self.beta = beta

self.gamma = gamma

self.tau = tau

self.n_obs_space = n_obs_space

self.n_action_space = n_action_space

self.n_state_action_value = n_state_action_value

self.layer1_size = layer1_size

self.layer2_size = layer2_size

# 13.バッチサイズを決めておく

self.batch_size = batch_size

self.actor = ActorNN(alpha=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, batch_size=64)

# 9.memoryインスタンスを追加

self.MAX_MEMORY_SIZE = 10000

self.memory = ReplayBuffer(max_memory_size=self.MAX_MEMORY_SIZE,

n_obs_space=self.n_obs_space,

n_action_space=self.n_action_space)

# 19.ターゲットアクターネットワークインスタンスtarget_actorを作成する

# actorとtarget_actorのネットワークは同じActorNNで良い

self.target_actor = ActorNN(alpha=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, batch_size=64)

# 21.ターゲットクリティックネットワークインスタンスtareget_criticを作成する

self.target_critic = CriticNN(beta=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, batch_size=64)

# 24.クリティックネットワークインスタンスcriticを作成する。

self.critic = CriticNN(beta=0.000025, n_obs_space=17, n_action_space=6,

layer1_size=64, layer2_size=64, batch_size=64)

# アクターロスとクリティックロス

self.actor_loss = 0

self.critic_loss = 0

# 45.行動ノイズのインスタンス化

self.mode = mode

if self.mode == 'train_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space))

elif self.mode == 'eval_mode':

self.noise = OUActionNoise(mu=np.zeros(n_action_space), sigma=0)

else:

print('mode error')

def choose_action(self, obs):

#print('AgentDDPG.choose_action is working.')

# 4.方策（アクター）はニューラルネットワークで表現する。

# ActorNNクラスを新規作成し、インスタンスactorとして使用する。

action = self.actor.forward(obs)

# 46.行動ノイズを入れて探索性を向上させる。

action += T.tensor(self.noise(), dtype=T.float32)

action = action.detach().numpy()

return action

# 8.remenberメソドを追加

def remember(self, obs, action, reward, next_state, done):

self.memory.store_transition(obs, action, reward, next_state, done)

# 13.learnメソドを追加

def learn(self):

# 14.バッチサイズ分のトランジションが集まるまでは何も実行しない。

if self.memory.memory_count < self.batch_size:

return

# 15.メモリバッファからデータを抜き出す sample_buffer()

# バッチ化されているので変数名を複数形にする

observations, actions, rewards, next_states, terminals = self.memory.sample_buffer(self.batch_size)

#print('s:', observations)

#print(observations.shape)

#print('a :', actions)

#print('r :', rewards)

#print('s_ :', next_states)

#print('terminal :', terminals)

# 17.抜き出したデータをpytorchで微分可能なようにtorch.tensor化する

observations = T.tensor(observations, dtype=T.float32)

actions = T.tensor(actions, dtype=T.float32)

rewards = T.tensor(rewards, dtype=T.float32)

next_states = T.tensor(next_states, dtype=T.float32)

terminals = T.tensor(terminals, dtype=T.float32)

# 18.ターゲットアクターネットワークインスタンスtarget_actorに

# 次の状態next_satesを入れて、ターゲットアクションtarget_actionsとして取り出す。

# このターゲットネットワークはターゲットでないネットワークとNNパラメータを共有させる。

#print('next_states :', next_states)

target_actions = self.target_actor.forward(next_states)

# 20.ターゲットクリティックネットワークインスタンスtarget_criticに

# 次の状態next_statesと上記より算出したターゲットアクションの２つを入力して

# 価値関数の推定値ターゲットバリューを出力する。

# TDターゲット：r + γ*V(w)[s_t+1] の部分のこと。

# ターゲットクリティックバリューはターゲットアクターネットワークを使う

target_critic_values = self.target_critic.forward(next_states, target_actions)

# 23.ベースラインとして機能するクリティックネットワーク（価値関数V(w)[s_t]ネットワーク）に

# 現在の状態observationsと行動actionsを入力して

# クリティックバリューを算出する

critic_values = self.critic.forward(observations, actions)

# 25.TDターゲットを算出する：r + γ*V(w)[s_t+1]

td_targets = []

for i in range(self.batch_size):

td_target = rewards[i] + self.gamma * target_critic_values[i] * terminals[i]

td_targets.append(td_target)

# TDターゲットの形をバッチに整える

td_targets = T.tensor(td_targets, dtype=T.float32)

td_targets = td_targets.view(self.batch_size, 1) #viewはreshapeと同じ。64x1に見え方を変更した、という意味

#print('td_targets :', td_targets)

# ==== （１）クリティックの学習 ====

# 28.クリティックの勾配をゼロに初期化する

self.critic.optimizer.zero_grad()

# 29. TDターゲットと状態価値の二乗誤差を算出して、クリティックの損失関数とする。バッチサイズは６４個

critic_loss = F.mse_loss(td_targets, critic_values)

self.critic_loss = critic_loss

#print('critic_loss : ', critic_loss) # tensor(0.0485, grad_fn=<MseLossBackward0>)

# 30. クリティックの損失関数を微分して、勾配を算出する

critic_loss.backward()

# 31. 勾配からオプティマイザーによってクリティックのパラメータ（重みとバイアス）を更新する

self.critic.optimizer.step()

# ==== （２）アクターの学習 ====

# 32. アクターの勾配をゼロに初期化する

self.actor.optimizer.zero_grad()

# 33. アクターに観測情報を入力して行動を算出する。バッチサイズは６４個

predicted_actions = self.actor.forward(observations)

# 34.アクターの損失関数を算出する

# Actorの目的は、Criticネットワークの出力（行動価値）を最大化するような行動を選択すること。

# なので、actorNN→criticNNのDDPG構造全体の出力結果をactor_lossとして、actorNNとcriticNNの両方をbackwardし、

# actorだけをパラメータ更新することによりactorの学習をすることができる。

actor_loss = -self.critic.forward(observations, predicted_actions)

actor_loss = T.mean(actor_loss)

self.actor_loss = actor_loss

#print(f'actor_loss: {actor_loss}, critic_loss: {critic_loss}')

# 35. DDPG構造全体の損失関数actor_lossを微分し、勾配を算出する

actor_loss.backward()

# 36. 勾配からオプティマイザーによってアクターのパラメータだけを（重みとバイアス）を更新する

self.actor.optimizer.step()

# 37. 全ニューラルネットワークのパラメータを更新する。

self.update_network_parameters()

# 37. パラメータ更新メソド。

def update_network_parameters(self, tau=None):

if tau is None:

tau = self.tau

# 38. actor, critic, target_actor, target_criticのネットワーク内の全てのパラメータ（重みとバイアス）とその名前を取得する

# actorとcriticは先ほど更新されたばかりのパラメーター

actor_params = self.actor.named_parameters()

critic_params = self.critic.named_parameters()

target_actor_params = self.target_actor.named_parameters()

target_critic_params = self.target_critic.named_parameters()

#print('actor_params : ', actor_params) # actor_params : <generator object Module.named_parameters at 0x000001661B2D9D48>

# 39. パラメータをディクショナリとして取り出す。

actor_params_dict = dict(actor_params)

critic_params_dict = dict(critic_params)

target_actor_params_dict = dict(target_actor_params)

target_critic_params_dict = dict(target_critic_params)

#print('actor_params_dict : ', actor_params_dict)

#print(actor_params_dict.keys())

"""

actor_params_dict : {'fc1.weight': Parameter containing:

tensor([[-0.1895, -0.0343, 0.1138, ..., 0.2157, 0.0527, -0.1173],/

dict_keys(['fc1.weight', 'fc1.bias', 'fc2.weight', 'fc2.bias', 'fc3.weight', 'fc3.bias'])

"""

# 40. クリティックの各パラメーター毎に更新重みtau=0.0001の分だけほんの少しcriticパラメータをtarget_criticパラメータに近づける。

for name in critic_params_dict:

critic_params_dict[name] = tau * critic_params_dict[name].clone() + \

(1-tau) * target_critic_params_dict[name].clone()

# 41. 更新したcriticパラメータをtarget_criticのパラメータとしてロードする。

self.target_critic.load_state_dict(critic_params_dict)

# 42.アクターの各パラメーター毎に更新重みtau=0.0001の分だけほんの少しactorパラメータをtarget_actorパラメータに近づける。

for name in actor_params_dict:

actor_params_dict[name] = tau * actor_params_dict[name].clone() + \

(1 - tau) * target_actor_params_dict[name].clone()

# 43. 更新したactorパラメータをtarget_actorのパラメータとしてロードする。

self.target_actor.load_state_dict(actor_params_dict)

#### =================== メインスクリプト ======================= ####

EVAL_TRAIN_MODE = 'train_mode' # 評価モードか訓練モードかを選択

EPISODES = 1001# episodes

STEPS = 500 # steps

DELAY_TIME = 0.00 # sec

# 2.エージェントクラスのインスタンスを生成する

agent = AgentDDPG(alpha=0.01, beta=0.01, gamma=0.99, tau=0.01,

n_obs_space=17 , n_action_space=6, n_state_action_value=1,

layer1_size=256, layer2_size=256, batch_size=64, mode=EVAL_TRAIN_MODE)

if EVAL_TRAIN_MODE == 'train_mode':

env = gym.make("HalfCheetah-v4", render_mode='depth_array')

elif EVAL_TRAIN_MODE == 'eval_mode':

env = gym.make("HalfCheetah-v4", render_mode= 'human')

total_rewards = []

actor_losses = []

critic_losses = []

for episode in range(EPISODES):

obs = env.reset()

obs = T.tensor(obs[0], dtype=T.float)

# tensor([ 0.0040, 0.0199, -0.0622, 0.0594, -0.0605, 0.0577, -0.0056, 0.0333, -0.0072, 0.0532, -0.0512, 0.0173, -0.0529, -0.1104, 0.0946, -0.0559, 0.0824])

#print(type(obs))

# observation_space : Box(-inf, inf, (17,), float64)

#print('observation_space : ', env.observation_space)

#print('obs :', obs)

reward: float = 0

total_reward: float = 0

done: bool = False

for j in range(STEPS):

env.render()

# ここをDDPGに置き換えていく

action = agent.choose_action(obs) # 1.Agentクラスを定義していく

#action : [ 0.06660474 -0.11753064 0.02527559 0.06465236 0.1050786 0.05048539]

#print('====ここまではOK4====')

#print('action_space : ', env.action_space)

#print('action : ', action)

next_state, reward, done, _, info = env.step(action)

#print('next_state, reward, done, _, info :', next_state, reward, done, _, info)

"""

action : [ 0.06660474 -0.11753064 0.02527559 0.06465236 0.1050786 0.05048539]

next_state, reward, done, _, info :

[-0.00265179 0.0229547 0.00463243 -0.04729936 -0.00959038 0.04734605

0.03672746 0.02857842 0.09980254 -0.32065693 0.04221647 1.58668951

-2.31089174 1.30338924 -0.25465526 1.08250465 -0.14134398]

0.07553858359316026

False

{'x_position': -0.09233384215910741, 'x_velocity': 0.07920445513883267, 'reward_run': 0.07920445513883267, 'reward_ctrl': -0.0036658715456724168}

"""

#7. トラジェクトを保存する。経験再生(ReplayBuffer)

agent.remember(obs, action, reward, next_state, int(done))

#12. ニューラルネットワークを学習する

agent.learn()

# 26.エピソード内での報酬を累積していく

total_reward += reward

# 27. next_stateをobsとして再出発する

#print('next_state:', next_state)

obs = next_state

obs = T.tensor(obs, dtype=T.float)

# 28. チーターの動きを見たいのでスリープを入れる

time.sleep(DELAY_TIME)

#print('total_reward : ', total_reward)

total_rewards.append(total_reward)

actor_losses.append(float(agent.actor_loss))

critic_losses.append(float(agent.critic_loss))

# print('epsisode', i, 'score %.2f' % score, '100 game sverage %.2f' % np.mean(score_history[-100:]))

# 47. 各ニューラルネットワークのパラメータを１０エピソード毎に保存する

print('episode, total_reward : ', episode , total_reward)

if episode % 10 == 0:

T.save(agent.actor.state_dict(), 'actor_params.pt')

T.save(agent.critic.state_dict(), 'critic_params.pt')

T.save(agent.target_actor.state_dict(), 'target_actor_params.pt')

T.save(agent.target_critic.state_dict(), 'target_critic_params.pt')

print('==== params were saved. ====')

#print('total_rewards : ', total_rewards)

#plt.plot(total_rewards)

#plt.plot(actor_losses, label='actor_losses')

#plt.plot(critic_losses, label='critic_losses')

plt.plot(total_rewards, label='total_rewards')

plt.legend()

plt.grid(True)

plt.ioff()

plt.show()

env.close() # 空なんですけど・・・

print('script is done.')

# https://gymnasium.farama.org/

2024年11月
月	火	水	木	金	土	日
				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