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

次はカメラの動作を確認します。

ESP32のカメラモジュールの動作を確認するためには、いくつかのステップを踏む必要があります。以下に一般的な手順を示しますが、具体的な手順は使用しているカメラモジュールとプログラミング環境に依存します。

カメラモジュールの接続を確認する:
- カメラモジュールがESP32ボードに正しく物理的に接続されているかを確認してください。
- ピン配列を再確認し、カメラモジュールが正しいピンに接続されていることを確認してください。
ライブラリとドライバをインストールする:
- 使用している開発環境に必要なライブラリやドライバをインストールします。Arduino IDEを使用している場合は、ESP32のカメラを扱うためのライブラリをインストールする必要があります。
サンプルコードを試す:
- 多くの開発環境にはカメラモジュールの動作を確認するためのサンプルコードが用意されています。これを使って、基本的な動作をテストすることができます。
- サンプルコードをボードにアップロードし、シリアルモニターまたは指定されたIPアドレスをウェブブラウザで開いて、カメラの映像を確認します。
動作確認:
- サンプルコードが正常に動作すれば、カメラが写真を撮影したり、ビデオストリームを送信したりできるはずです。
- ウェブインターフェースやアプリケーションを通じて、カメラの映像が表示されるかどうかを確認してください。
トラブルシューティング:
- もしカメラが期待通りに動作しない場合は、トラブルシューティングが必要になります。
- カメラの電源供給が適切か、接続ピンに問題がないか、ソフトウェアの設定が正しいかなど、一つ一つ確認していきます。

最大1310720バイトのフラッシュメモリのうち、スケッチが247221バイト（18%）を使っています。最大327680バイトのRAMのうち、グローバル変数が21040バイト（6%）を使っていて、ローカル変数で306640バイト使うことができます。 esptool.py v4.5.1 Serial port COM1 Connecting……………………………….. A fatal error occurred: Failed to connect to ESP32: No serial data received. For troubleshooting steps visit: https://docs.espressif.com/projects/esptool/en/latest/troubleshooting.html Failed uploading: uploading error: exit status 2

「Failed to connect to ESP32: No serial data received」というエラーメッセージは、ESP32デバイスとコンピュータ間の通信に何らかの問題があることを示しています。このエラーを解決するためには、いくつかのトラブルシューティングのステップを実行する必要があります。

以下に、問題解決のための一般的なステップをいくつか紹介します：

シリアルポートを確認:
- コンピュータに接続されている正しいシリアルポートが選択されているか確認してください。Arduino IDEなどの開発環境でポートをチェックします。
USBケーブルを確認:
- USBケーブルがきちんと接続されていること、または壊れていないことを確認します。必要であれば、異なるUSBケーブルを試してみてください。
ドライバを確認:
- ESP32をコンピュータに接続するための適切なドライバがインストールされていることを確認します。CP210xやCH340などのドライバがよく使われます。
ESP32ボードのリセット:
- アップロードが開始する直前にESP32のリセットボタンを押すことで、アップロードモードに入ることができます。
ブートモード:
- ESP32が正しくブートモードに入っているかを確認します。IO0をGNDに接続してからリセットすることでブートモードに入ります。
PCやIDEの再起動:
- コンピュータや開発環境の再起動で問題が解決する場合もあります。
開発ボードの交換:
- ESP32ボード自体に問題があるかもしれません。可能であれば別のボードで試してみてください。

USBをPCへ挿すとドライバが自動的にインストールされます。IDE側が認識するまで数分時間がかかりました。COM1しかなかったところ、COM3が新しくリストに出てきたので選択したところ問題なく動きました。

ひとまずPCを変えたのでLED点滅の確認。

  int LED = 12;
  
  void setup() {
  // put your setup code here, to run once:
  pinMode(LED, OUTPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  digitalWrite(LED, HIGH);
  delay(500);
  digitalWrite(LED, LOW);
  delay(500);
}

int LED = 12;

void setup() {

// put your setup code here, to run once:

pinMode(LED, OUTPUT);

}

void loop() {

// put your main code here, to run repeatedly:

digitalWrite(LED, HIGH);

delay(500);

digitalWrite(LED, LOW);

delay(500);

}

ESP32-CAMを使用してカメラの映像を取得し、それを確認するプロセスはいくつかのステップに分けられます。以下は、基本的なガイドラインです。

必要なもの

ESP32-CAMボード
USB to Serialコンバータ（ボードをプログラムするため）
カメラがボードに接続されていること
Arduino IDEまたはその他のプログラミング環境

ステップ

Arduino IDEのセットアップ
ESP32のサポートをArduino IDEに追加します。Arduino IDEの「ファイル」→「環境設定」で「追加のボードマネージャのURL」にESP32のURLを追加します。
ボードの選択
ツール→ボード→ボードマネージャで「ESP32」を検索し、インストールします。その後、ボードリストからESP32 Wrover Moduleを選択します。
カメラサンプルのロード
ファイル→例→ESP32→Camera→CameraWebServerを開きます。
設定のカスタマイズ
スケッチ内のWIFI_SSIDとWIFI_PASSWORDを適切なものに変更します。
ボードへのアップロード
適切なCOMポートを選択し、アップロードします。
シリアルモニタの使用
ボードがリセットされた後、シリアルモニタを開き、IPアドレスを探します。そのIPアドレスにWebブラウザでアクセスすると、カメラの映像を確認できるはずです。

もしカメラの映像が見られない場合、いくつかのトラブルシューティングを試みる必要があります。配線の確認、ボードのリセット、電源の供給などの基本的なことから始めてみてください。また、使用するカメラモデルに合わせてスケッチ内のカメラモデル設定を適切に選択することも忘れないでください。

このプロセスがうまく行くと、カメラの映像をWebブラウザでリアルタイムに見ることができるようになります。もしステップごとの詳しい説明や、具体的なコード例が必要な場合は教えてください。

Wi-FiネットワークのSSID（Service Set Identifier）とパスワードを見つけるには以下の方法を試すことができます。

SSIDを見つける方法:

Wi-Fiルーターをチェック: 多くのルーターにはSSIDが記載されているステッカーが貼られています。
既に接続されているデバイスをチェック: スマートフォンやPCなど、既にネットワークに接続されているデバイスで利用可能なネットワークのリストを表示し、SSIDを探します。
ルーターの管理ページにアクセス: ブラウザからルーターのIPアドレスにアクセスし、ログインしてSSIDを確認します。

パスワードを見つける方法:

ルーターをチェック: ルーターのステッカーにパスワードが記載されていることがあります。
既に接続されているデバイスを利用: 一部のデバイスでは、セキュリティ設定で保存されたWi-Fiパスワードを表示するオプションがあります。
ルーターの管理ページ: ブラウザからルーターの管理ページにアクセスし、Wi-Fiのセキュリティ設定でパスワードを確認または変更できます。
ルーターのマニュアルを確認: マニュアルにデフォルトのパスワードが記載されていることがあります。ただし、セキュリティ向上のために変更されていることが多いです。
リセット: 他の方法が使えない場合、ルーターを工場出荷時の状態にリセットするとデフォルトのSSIDとパスワードが適用されます。この操作は、ルーター上のリセットボタンを使って行いますが、この方法では全ての設定が失われるので注意が必要です。

安全を保つために、パスワードは他人と共有しないようにし、不明なデバイスからのアクセスがないように管理することが重要です。また、パスワードを変更する際は、十分な強度のあるものにすることをお勧めします。

#include "esp_camera.h"
#include <WiFi.h>
//
// WARNING!!! PSRAM IC required for UXGA resolution and high JPEG quality
//            Ensure ESP32 Wrover Module or other board with PSRAM is selected
//            Partial images will be transmitted if image exceeds buffer size
//

// Select camera model
#define CAMERA_MODEL_WROVER_KIT // Has PSRAM

#include "camera_pins.h"

const char* ssid = "ルーターの機種名のような記述";
const char* password = "暗号キー";

void startCameraServer();

void setup() {
  Serial.begin(115200);
  Serial.setDebugOutput(true);
  Serial.println();

  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 25000000;
  config.pixel_format = PIXFORMAT_JPEG;
  
  // if PSRAM IC present, init with UXGA resolution and higher JPEG quality
  //                      for larger pre-allocated frame buffer.
  if(psramFound()){
    config.frame_size = FRAMESIZE_UXGA;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }

  // camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }

  sensor_t * s = esp_camera_sensor_get();
  // drop down frame size for higher initial frame rate
  s->set_framesize(s, FRAMESIZE_VGA);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");

  startCameraServer();

  Serial.print("Camera Ready! Use 'http://");
  Serial.print(WiFi.localIP());
  Serial.println("' to connect");
}

void loop() {
  // put your main code here, to run repeatedly:
  delay(10000);
}

#include "esp_camera.h"

#include <WiFi.h>

// WARNING!!! PSRAM IC required for UXGA resolution and high JPEG quality

// Ensure ESP32 Wrover Module or other board with PSRAM is selected

// Partial images will be transmitted if image exceeds buffer size

// Select camera model

#define CAMERA_MODEL_WROVER_KIT // Has PSRAM

#include "camera_pins.h"

const char* ssid = "ルーターの機種名のような記述";

const char* password = "暗号キー";

void startCameraServer();

void setup() {

Serial.begin(115200);

Serial.setDebugOutput(true);

Serial.println();

camera_config_t config;

config.ledc_channel = LEDC_CHANNEL_0;

config.ledc_timer = LEDC_TIMER_0;

config.pin_d0 = Y2_GPIO_NUM;

config.pin_d1 = Y3_GPIO_NUM;

config.pin_d2 = Y4_GPIO_NUM;

config.pin_d3 = Y5_GPIO_NUM;

config.pin_d4 = Y6_GPIO_NUM;

config.pin_d5 = Y7_GPIO_NUM;

config.pin_d6 = Y8_GPIO_NUM;

config.pin_d7 = Y9_GPIO_NUM;

config.pin_xclk = XCLK_GPIO_NUM;

config.pin_pclk = PCLK_GPIO_NUM;

config.pin_vsync = VSYNC_GPIO_NUM;

config.pin_href = HREF_GPIO_NUM;

config.pin_sscb_sda = SIOD_GPIO_NUM;

config.pin_sscb_scl = SIOC_GPIO_NUM;

config.pin_pwdn = PWDN_GPIO_NUM;

config.pin_reset = RESET_GPIO_NUM;

config.xclk_freq_hz = 25000000;

config.pixel_format = PIXFORMAT_JPEG;

// if PSRAM IC present, init with UXGA resolution and higher JPEG quality

// for larger pre-allocated frame buffer.

if(psramFound()){

config.frame_size = FRAMESIZE_UXGA;

config.jpeg_quality = 10;

config.fb_count = 2;

} else {

config.frame_size = FRAMESIZE_SVGA;

config.jpeg_quality = 12;

config.fb_count = 1;

}

// camera init

esp_err_t err = esp_camera_init(&config);

if (err != ESP_OK) {

Serial.printf("Camera init failed with error 0x%x", err);

return;

}

sensor_t * s = esp_camera_sensor_get();

// drop down frame size for higher initial frame rate

s->set_framesize(s, FRAMESIZE_VGA);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(500);

Serial.print(".");

}

Serial.println("");

Serial.println("WiFi connected");

startCameraServer();

Serial.print("Camera Ready! Use 'http://");

Serial.print(WiFi.localIP());

Serial.println("' to connect");

}

void loop() {

// put your main code here, to run repeatedly:

delay(10000);

}

提供されたコードは、ESP32カメラモジュールをセットアップしてWi-Fiネットワークに接続し、カメラサーバーを起動するためのものです。映像を確認するには、以下の手順を実行します。

シリアルモニタを確認する: ESP32デバイスがWi-Fiに接続されると、シリアルモニタにローカルIPアドレスが表示されます。このIPアドレスは、デバイスがローカルネットワーク内で使用しているアドレスです。もし、IPアドレスがシリアルモニタに表示さらない場合は、シリアルモニタのボーレート（通信速度）がコードに設定されている値と一致していることを確認します。コードでは Serial.begin(115200); と設定されているので、シリアルモニタも115200に設定する必要があります。設定を変更したら再度書き込みをします。
ウェブブラウザを使用する: コンピューターやスマートフォンのウェブブラウザを開き、シリアルモニタに表示されたIPアドレスをURLバーに入力します。例えば、IPアドレスが 192.168.1.10 だった場合、ブラウザに http://192.168.1.10 と入力します。
カメラインターフェースにアクセスする: 正しいIPアドレスをブラウザに入力すると、ESP32カメラのウェブインターフェースにアクセスできます。このインターフェースを通じて映像を見ることができるだけでなく、カメラ設定を変更したり、写真を撮ったりすることも可能です。

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))