2023/12/24 株式市場の現況: 連続上昇記録と今後の展望

株式市場の現況: 連続上昇記録と今後の展望

株式市場の現況と注目ポイント

金曜日の株式市場は僅かな上昇に留まったものの、SP500指数は8週連続の上昇を記録し、過去6年間で最長となった。ナスダックもわずかながら上昇し、ダウも同様に8週連続の上昇を遂げた。特に注目されるのは1万5000ポイントを超えたナスダックと2000ポイントを上回ったラッセル2000の動きである。

総合的な市場の動向

2023年の株式市場は大型株から小型株、金融株まで幅広いセクターが上昇を示している。経済指標はソフトランディングを示唆しており、国際利回りは低下傾向にある。季節要因としてのサンタクロースラリーも市場にプラスの影響を与えているが、株式市場の連続上昇に伴う反落の可能性も考慮すべきである。

インフレとFRBの政策

11月のPCE総合価格指数は前年比で2.6%上昇し、FRBの2%ターゲットに近づいている。また、前月比では0.1%の低下を記録し、インフレ率が目標に近づいていることが示されている。これは投資家やFRBにとって良いニュースであり、来年には利下げが始まる可能性が高い。

中国経済の影響

中国経済の低迷は、Appleなど多くの米国企業に影響を与えている。中国の不動産セクターの不安定さが消費者心理に影響を及ぼし、デフレの兆しも見られる。しかし、中国の物価安がアメリカのインフレ圧力を低下させる可能性もあり、米国にとっては良いニュースとも言える。

米国消費者の財務状況

米国の消費者は力強い消費を続けているが、クレジットカード残高の増加により負債も増加している。多くのアメリカ人が貯蓄を使い果たし、日々の支出にクレジットカードや負債を頼っている状況が見られる。これは経済の成長を示す反面、消費者債務の増加によるリスクも示唆している。

トランプ氏の株価に対する見解

トランプ氏は、現在の株式市場の上昇が富裕層をより豊かにしていると批判している。彼は、もし再選されれば、以前の株高支持のスタンスに戻る可能性がある。

市場の将来展望

エドヤルデニ氏は、今後2年間で株価がさらに26%上昇し、S&P500指数が6000ポイントに達する可能性があると予測している。これは米国経済の強化と市場を牽引するイノベーションによるものと考えられる。特に、住宅市場の回復や消費者の購入増加は、経済の健全な成長を示している。また、人工知能の導入による生産性の向上が、経済にさらなる強みをもたらすと予測されている。

人工知能の影響と「新たな黄金の20年代」

ヤルデニ氏は、人工知能の導入が生産性を大幅に向上させ、経済成長を加速させることを指摘している。この生産性の向上は、1920年代の米株式市場の黄金期に匹敵する可能性を秘めており、株式市場に「新たな黄金の20年代」をもたらすと主張している。イノベーションが経済と市場を牽引するこの時代において、投資家はAIの影響を特に注視すべきだとされている。

結論: 市場の健全な成長と今後の展望

総じて、株式市場は健全な成長を示しており、イノベーションや技術進歩がさらなる上昇を後押しする可能性がある。一方で、消費者債務の増加や中国経済の低迷など、注意すべきリスク要因も存在している。投資家はこれらの要因を踏まえつつ、慎重かつ戦略的なアプローチで市場に臨むべきである。

ANOGAN 第一話

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

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

異常検知システム

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

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

に分けられます。

異常検知の難しい点

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

AutoEncoder

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

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

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

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

 

GAN

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

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

 

大まかな手順

  1. ライブラリのインストール
  2. データセットの準備
  3. Generator(生成器)の定義
  4. Discriminator(識別器)の定義
  5. モデルのトレーニング
  6. 異常スコアの計算
  7. 異常の検出と評価
  8. ハイパーパラメータのチューニング

 

 

  1. ライブラリのインストール: Pytorch, TensorFlowやKerasをインストールします。私はPytorchを使ってます。
  2. データセットの準備: 正常データだけあればモデルを作れるのがANOGANのメリットですが、異常が含まれるデータも検証で使いますので、結局は正常、異常の両方のデータを準備する必要があります。
  3. Generator(生成器)とDiscriminator(識別器)の定義: anoganは、生成器と識別器の2つのネットワークで構成されます。生成器は、正常なデータを生成し、識別器は正常なデータと異常なデータを識別します。
  4. モデルのトレーニング: 正常なデータセットを使用してモデルをトレーニングします。トレーニング中に生成器と識別器を交互に更新し、互いに競い合わせることで、正常なデータの特徴を学習します。
  5. 異常スコアの計算: モデルがトレーニングされたら、生成器を使用して異常スコアを計算します。異常スコアは、生成器が正常なデータをどれだけ正確に再現できるかを示す指標です。異常スコアが高いほど、異常と判断される可能性が高くなります。
  1. 異常の検出と評価: 異常スコアを閾値と比較し、異常と判断されるデータを検出します。また、モデルの性能を評価するために、テストデータセットを使用して評価指標(精度、再現率、F値など)を計算します。
  2. ハイパーパラメータのチューニング: モデルのパフォーマンスを改善するために、ハイパーパラメータのチューニングを行います。モデルのアーキテクチャ、学習率、バッチサイズなどのパラメータを調整し、最適な結果を得るようにします。

 

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

 

ではやっていこう。

 

DDPG by gymnasium 17日目

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

学習のステップ

  1. 100Steps x 1000Epsodes
  2. 200Steps x 1000Epsodes
  3. 300Steps x 1000Epsodes

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

走りも安定しています。

 

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

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

 

 

DDPG by gymnasium 16日目

前回

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

考えうる原因

  • ノード数が多すぎる?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にして始めています。
300回やったあと、続けて1000回やってみました。頑張ってる?
ここで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を過ぎたあたりで悪化していますが、何とか持ち直しています。どうやら、スタートダッシュで前傾姿勢になりすぎて逆に速度が遅くなっているようです。ひっくり返っているのでしょう。1000回超えたあたりでStepを伸ばしたので前のめりが修正されつつあると考えます。よってStep300にして1000回続けてみます。

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

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

600回~900回あたりで、変な癖を覚えてしまったようです。

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

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

 

DDPG by gymnasium 15日目

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

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

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

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

標準化

Z-scor normalization

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

正規化

Min-Max normalization

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

 

使い分け

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

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

戦闘力は標準化が良い

住宅価格も標準化が良い

弱点

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

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

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

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

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

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

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

 

バッチ正規化

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

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

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

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

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

やりかた

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

標準化:

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

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

線形変換:

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

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

ActorNNクラスの改造:

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

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

各層の入力値を正規化

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

CriticNNクラスの改造:

こちらも考え方は同じです。

学習結果

1000エピソード以上学習しましたが、どういうことでしょう調子いいのは300エピソードくらいのところで、そこから一気に悪化しています。

横軸:エピソード、縦軸:収益

ハーフチーターは一体何をやっているのでしょうか?

開始直後に素早く美しく前転し、ひっくり返りながらバタバタしていました。どうやら300回転超えたあたりから学習するべきデータが間違ったものしかない状況になり、回復しなかったと推測します。負のスパイラルに落ち込んでいったのでしょう。

反省

今回の条件を確認します。

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):
です。

現在までのまとめ

学習率とノード数を間違って入れていましたが、これが悪いとは現時点では言えません。

可能性としてはバッファメモリが10000で1エピソード2000ステップなので5回連続でダメな収益結果の場合、「ひっくり返ってお終い」、のようなダメな経験しか持ってない状態になります。

これが、二度とまともな状態に学習が継続できない要因ではないでしょうか。

(メモ:ステップを400とすると1エピソードがなぜか5倍の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追加
がネットワーク生成までこのパラメータが適用されるように修正しました。
これの結果:学習が進みません。チーターの様子を見ると開始直後に静止してお終いです。ぐーたらになってしまいました。

ノード数が多すぎる?256

学習率が小さすぎる?0.01

パラメータの初期値 Heがうまくいってない?/1√256は小さすぎる?

レイヤー正規化が上手くいってない?

次回へ続きます。

DDPG by gymnasium 9日目

前回まででうまいこと学習が進むようになりましたので、今回はパラメータの保存と読出をやってみましょう。

例えば、エピソードを100回繰り返しある程度ハーフチーターが前に進む方策を得たらパラメータをいったん保存します。

プログラムを止めて次回動かすときは保存したパラメータを読み込んで、学習済みの状態から動かすことができます。

これで突然プログラムが途中で止まってしまっても被害を最小限にできますね。

パラメータ保存

メインスクリプトでエピソードの終わり、次のエピソードが始まる直前に下記コードを入れます。

パラメータ読込

ActorNN(n.Module)クラスの__init__()内に入れて、actor, target_actorのインスタンス生成と同時にパラメータを引き継いでもらうようにします。

CriticNN(nn.Module)クラスも同様に。

これで、動きます。

学習のノウハウ

学習のコツを編み出しました。

学習初期はエージェントの動きが小さくなかなか前進しません。

最初はステップ数を10~100程度に小さくして、スタートダッシュだけを覚えさせました。

そこでいったん止めて、ステップ数を200、400と増やしていくと安定して走り続けるハーフチーターが得られます。

計算の高速化(3Dモデルの表示をオフにする)

env = gym.make(“HalfCheetah-v4”, render_mode= ‘human’)
の中のrender_modeを’depth_array’に変更すればOKです。

学習の進行状況のリアルタイム可視化

エピソード数とそのリワードだけを表示しています。
print(‘episode, total_reward : ‘, episode , total_reward)
パラメータの保存を10エピソード毎にやっています。
if episode % 10 == 0:
print(‘==== params were saved. ====’)
↓↓↓出力

解決できた課題

  1. パラメータのセーブとロード
  2. 途中で止まった時に続行可能にしたい
  3. 計算の高速化(print文の無効化)
  4. 計算の高速化(3Dモデルの表示をオフにする)
  5. 学習の進行状況のリアルタイム可視化
  6. 適切なステップ数
  7. 適切なニューラルネットワーク構造

未解決の課題・疑問点

  1. 計算の高速化(GPUの利用)
  2. 適切なエピソード数
  3. 適切なメモリバッファ数
  4. model.train()とmodel.eval()の使い方が分からない。
  5. ネットワークの入力値?パラメータ?の正規化。
  6. 保存したパラメータを読み出すのはactorとtarget_actorまたcriticとtarget_criticで共通で良いのだろうか。

これまでのスクリプト

 

DDPG by gymnasium2日目

前回

前回はハーフチーター環境をランダムな行動で動かすところまでいきました。

actionの決定は、行動空間からのランダムサンプリング

action = env.action_space.sample()

になっています。いわゆる「方策:ポリシー」と呼ばれるものです。
エージェント(行動する者)はポリシー(方策・方針)を定めることによって、その状況(環境、観測情報)に応じて行動を選択します。その決定は確率的であったり一意的あるいは決定論的であったりします。
このポリシーを何かしらのアルゴリズムで調整・改善することで最大収益が得られるようにしていくのがDDPGなどの強化学習手法の目的です。
「収益が最大になるようにポリシーを改善していく」のほうが正しい言い方でしょうか。

改善案

Agentクラスを新規作成して、インスタンスagentを作り、DDPG的な学習ができるようなメソドを作成していく。

ではAgentDDPGクラスを作成していく。

メインスクリプトでagent = AgenDDPG()インスタンスを生成してから
action = agent.choose_action(obs)メソドを実行することで、行動空間action_spaceから行動をランダムに選択してactionをひとつ選択されたものを戻り値とすることができました。まだこの時点ではDDPG的な要素を入れていません。

DDPG部分を作っていく

DDPGは方策勾配法を基礎としており、目的関数J= E[ Σ G(τ) * grad log π(θ)]を最大化するために最初は適当な方策πをちょっとずつ自動調整していく方法です。

勾配 grad Jを使って、パラメータθを最適化していくのですがどう表現したらよいでしょうか。方策勾配法の発展経緯を追っていくと、下記のように読み取れます。

  1. 基本の方策勾配法: E[ Σ G(τ) * grad log π(θ)]
  2. REINFORCE的に収益ノイズ除去: E[Σ G(t) * grad log π(θ)]  ]
  3. ベースライン付き: E[Σ ( G(t)-b) * grad log π(θ)]  ]
  4. ベースラインを価値関数とする:E[Σ ( G(t)-V(w) )* grad log π(θ)]  ]
  5. TD法であること:( r+γV(w)[s_t+1] – V(w) [s_t]) *  grad log π(θ)
  6. 方策π(θ)をニューラルネットワークで表現:actorという。入力s、出力π(a|s)(行動確率probと表現することもある)
  7. 価値関数V(w)をニューラルネットワークで表現:criticという。※真の価値関数vは求めない。Vは中途半端な推定値でも方策πは学習できる。入力はactorと同じs、加えてactorの出力であるπがcriticの入力として使用されます。

「actorの出力をcriticの入力とする」部分がDDPGが連続値に対応できるポイントです。この要素を除くと出力が離散的になりそのアルゴリズムはactor-criticと呼んでいました。actor-criticは行動の選択肢が左右の2つある場合、「右に行く」と決めるような状況で使います。

DDPGは連続値なので、「車のハンドルを右へ15.2°回転させつつ、ブレーキを20%踏み込む」という出力が得られます。(のはず!)

では、ちょっとずつコーディングしていく。

python、プログラミング初級者でも理解できるようにちょっとずつ変えていきます。

 1.エージェントインスタンスのchoose_actionメソドを使って行動actionを得るように変更する。

        変更前:action = env.action_space.sample()
        変更後:action = agent.choose_action(obs)
 2.エージェントクラスのインスタンスを生成する
agent = AgentDDPG()
3.エージェントクラスを定義する
class AgentDDPG:
    def __init__(self):
    def choose_action(self, obs):

4.方策(アクター)はニューラルネットワークで表現する。ActorNNクラスを新規作成し、インスタンスactorとして使用する。

    def choose_action(self, obs):
        action = self.actor.forward(obs)
        return action

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

    def __init__(self):
        self.actor = ActorNN()

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

class ActorNN:
    def __init__(self):
    def forward(self, obs):
        action = [0.0 for i in range(6)]
        return action
まだニューラルネットワーク構造まで作成していないので、obsは入力として使っていませんし、actionも仮出力として[0,0,0,0,0,0]にしています。

ActorNNクラスを作りこんでいく

3層の全結合ネットワーク、そして活性化関数はreluにしています。

AgentDDPGクラスを作りこんでいく

 

メインスクリプトと整合性を合わせる

こんな感じで作っていきました。

訓練について

  1. actorは目的関数J(θ)が最大になるように学習する。実際の計算は-J(θ)が最小になるように学習する。
  2. target_actorを正解データとして教師あり学習する
  3. criticはtarget_actorを正解データとして教師あり学習する

PySimpleGUI のメモ

PySimpleGUI のメモ

 

 

Dog_to_Headのpythonバージョン AndroidスマホのPyroid3

 

以前Kotlinで作ったDog_to_Headのpythonバージョンです。

AndroidスマホのPyroid3で動かすために作りました。GUIつくるのめんどくさかったのでCUIのまま使ってください。