常連

### 実現したいこと
実験で得られたパルス信号をシミュレーションで再現することを行っています。

　画像の青色の信号が実験データ、赤色がシミュレーションデータです。
シミュレーションのパラメータは6つあり、パラメータをいじってシミュレーション結果を実験結果にフィットさせたいと考えています。

　パラメータを手動で変更してフィッティングをするのは大変なため機械学習によってどうにかパラメータを推測できないかと考えています。

　機械学習は触ったことがないのであまりいい方法が思いつきませんが、１つ考えている方法としては、適当なパラメータの組み合わせとその出力パルスをデータセットとして作成、学習させ、そのモデルを用いて実験データからパラメータを推測するといったことを考えています。

　この方法を用いる際に有効な機械学習手法にはどういったものがあるでしょうか？
また、他に良い方法があれば教えていただきたいです。

![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2024-01-22/4591c42c-841f-4f0f-bebf-aa3dbfc408d9.png)

### 発生している問題・分からないこと
パラメータ推測のための機械学習の手法として何を選べば良いか、またその実装方法が分からない。




### 該当のソースコード

```
特になし
```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [ ] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
調べると時系列データの回帰に有効なRNN、CNNなどが上がりましたが、何が最適か判断がつきませんでした。

### 補足
特になし

パルスフィッティングパラメータ推測のための機械学習手法について（Python）

モバイルネットV3で二値分類を使った学習についてです。
ファインチューニングもしているのですが、以下のコードです。

```python
import os
import pandas as pd
from sklearn.model_selection import train_test_split
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import MobileNetV3Small
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
import matplotlib.pyplot as plt
import tensorflow as tf

# ハイパーパラメータ
image_size = (224, 224)
batch_size = 32
learning_rate = 0.0001
epochs = 100
fine_tune_at = -5

# データセットを格納するディレクトリへのパス
base_dir = 'C:/Users/admin/Documents/CNN_224/'

# 訓練データセット、検証データセットを配置するディレクトリ
positive_path = os.path.join(base_dir, 'cnn_a')
negative_path = os.path.join(base_dir, 'cnn_n')

# train_set.filenamesからファイルパスを取得
positive_files = [os.path.join(positive_path, filename) for filename in os.listdir(positive_path)]
negative_files = [os.path.join(negative_path, filename) for filename in os.listdir(negative_path)]

# データフレームを作成
positive_df = pd.DataFrame({'filepath': positive_files, 'class': 'positive'})
negative_df = pd.DataFrame({'filepath': negative_files, 'class': 'negative'})
df = pd.concat([positive_df, negative_df], ignore_index=True)

# 訓練データと検証データに分割
train_df, test_df = train_test_split(df, test_size=0.2, random_state=42)

# データの前処理とデータ拡張
train_datagen = ImageDataGenerator(rescale=1./255, shear_range=0.8, zoom_range=0.8, horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1./255)

# データを読み込むためのジェネレータを作成
train_set = train_datagen.flow_from_dataframe(train_df, x_col='filepath', y_col='class', target_size=image_size, batch_size=batch_size, class_mode='binary')
test_set = test_datagen.flow_from_dataframe(test_df, x_col='filepath', y_col='class', target_size=image_size, batch_size=batch_size, class_mode='binary')

# モデルの構築
base_model = MobileNetV3Small(weights='imagenet', include_top=False, input_shape=(*image_size, 3))

# 最後のブロックの一部の層を解凍
for layer in base_model.layers[:fine_tune_at]:
    layer.trainable = False

# モデルに新しい出力層を追加
model = tf.keras.Sequential([
    base_model,
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

# モデルのコンパイル
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=learning_rate),
              loss='binary_crossentropy',
              metrics=['accuracy'])

# EarlyStoppingとModelCheckpointのパラメータ変更例
early_stopping = EarlyStopping(monitor='val_loss', patience=2, restore_best_weights=True)
model_checkpoint = ModelCheckpoint('best_model.h5', save_best_only=True, monitor='val_accuracy')

# モデルの概要表示
model.summary()

# モデルのトレーニング
history = model.fit(train_set, epochs=epochs, validation_data=test_set, callbacks=[early_stopping, model_checkpoint])

# モデルの保存先パス
model_save_path = 'C:/Users/admin/Documents/CNN_224/a1.keras'

# モデルの保存
model.save(model_save_path)

# 訓練損失と検証損失のグラフ
plt.figure(figsize=(12, 5))

# 訓練精度と検証精度のグラフ
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Train Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.ylim(0, 1)
plt.legend()

# 訓練損失と検証損失のグラフ
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.ylim(0, 1)  # Y座標は0から1まで
plt.legend()

# グラフ上に数値を表示
print(f"最終訓練精度: {history.history['accuracy'][-1]:.4f}")
print(f"最終検証精度: {history.history['val_accuracy'][-1]:.4f}")
print(f"最終訓練損失: {history.history['loss'][-1]:.4f}")
print(f"最終検証損失: {history.history['val_loss'][-1]:.4f}")

plt.tight_layout()
plt.show()
```


●実行結果●

Found 3200 validated image filenames belonging to 2 classes.
Found 800 validated image filenames belonging to 2 classes.
Model: "sequential_71"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 MobilenetV3small (Function  (None, 7, 7, 576)         939120    
 al)                                                             
                                                                 
 global_average_pooling2d_7  (None, 576)               0         
 0 (GlobalAveragePooling2D)                                      
                                                                 
 dense_94 (Dense)            (None, 1)                 577       
                                                                 
=================================================================
Total params: 939697 (3.58 MB)
Trainable params: 112513 (439.50 KB)
Non-trainable params: 827184 (3.16 MB)
_________________________________________________________________
Epoch 1/100
100/100 [==============================] - ETA: 0s - loss: 0.6889 - accuracy: 0.5731
100/100 [==============================] - 80s 729ms/step - loss: 0.6889 - accuracy: 0.5731 - val_loss: 0.7155 - val_accuracy: 0.5275
Epoch 2/100
100/100 [==============================] - 66s 662ms/step - loss: 0.6816 - accuracy: 0.6153 - val_loss: 0.7061 - val_accuracy: 0.5275
Epoch 3/100
100/100 [==============================] - 68s 680ms/step - loss: 0.6662 - accuracy: 0.7319 - val_loss: 0.7009 - val_accuracy: 0.5275
Epoch 4/100
100/100 [==============================] - 67s 665ms/step - loss: 0.6411 - accuracy: 0.7066 - val_loss: 0.6971 - val_accuracy: 0.5275
Epoch 5/100
100/100 [==============================] - 65s 649ms/step - loss: 0.5886 - accuracy: 0.8319 - val_loss: 0.6939 - val_accuracy: 0.5275
Epoch 6/100
100/100 [==============================] - 67s 664ms/step - loss: 0.5381 - accuracy: 0.8397 - val_loss: 0.6931 - val_accuracy: 0.5275
Epoch 7/100
100/100 [==============================] - 66s 657ms/step - loss: 0.4948 - accuracy: 0.8697 - val_loss: 0.6923 - val_accuracy: 0.5275
Epoch 8/100
100/100 [==============================] - 64s 644ms/step - loss: 0.4434 - accuracy: 0.8844 - val_loss: 0.6918 - val_accuracy: 0.5275
Epoch 9/100
100/100 [==============================] - 65s 649ms/step - loss: 0.3913 - accuracy: 0.8994 - val_loss: 0.6923 - val_accuracy: 0.5275
Epoch 10/100
100/100 [==============================] - 68s 682ms/step - loss: 0.3495 - accuracy: 0.9106 - val_loss: 0.6930 - val_accuracy: 0.5275
最終訓練精度: 0.9106
最終検証精度: 0.5275
最終訓練損失: 0.3495
最終検証損失: 0.6930
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2024-01-15/659dcb8e-2a08-44e6-9eb2-f12d79b60c06.png)

このように出たのですが、最終的には訓練データは悪くない結果なのですが、val_lossと val_accuracyが一定になってしまいます。これは何が足りないのでしょうか？学習率、学習回数、ファインチューニングの層（最後のブロックの一部の層を解凍）の設定などいろいろしても何も変化がありません。

もしかしたらプログラミングが間違っている可能性が高いです。自分がやりたいのはモバイルネットV3を使ってファインチューニングして二値分類（正解画像と不正解画像を分類する）モデルを作りたいと考えています。誤差関数は二値交差エントロピーで出力層の出力関数はシグモイド関数です。

検証データが全く学習されない

## 説明変数がどのくらい時系列データに影響を与えるか検証したい。



## 背景、状況
とある講義で、時系列データに関する予測モデルの作成をしています(事業提案資料の作成）。
与えられたデータセットにはCMの放送フラグ（0:放送した、1:放送していない）と新規アカウントの獲得件数、日付データがあります。

CMの放送フラグによって、新規アカウントの獲得数を予測するモデルを作成したいのですが、ARIMAモデル、SARIMAモデル等のモデルで予測モデルを作成することは可能なのでしょうか？

個人的には機械学習的モデルを作成するのがベストなのかな思っています。




【時系列予測モデル】説明変数がどのくらい時系列データに影響を与えるか検証したい

### 実現したいこと

- [ ] 学習用データを用いて作成した決定木モデルを、そのモデルと検証用データを入力としたpredict関数を用いて正解率の評価をしたい。
- [ ] 作成した決定木モデルの図示をしたい。

### 前提

R言語を用いて、データ「[cust1.csv](https://ux.getuploader.com/subtest/download/1)」の決定木分析を行いたいです。cust1.csvはこちらのリンクからダウンロードできます。
https://ux.getuploader.com/subtest/download/1

cust1.csvのデータ項目は以下の通りで、目的変数がhotel、説明変数がidを除くそれ以外となっています。
```
gender   性別 
  1 : 男性　
  2 : 女性
age      年齢
income   収入 
  1 : 100万円未満 
  4 : 100万円以上 
  5 : 300万円以上
  6 : 500万円以上 
  7 : 700万円以上
  8 :1000万円以上
marriage  婚姻
  1 : 既婚
  2 : 未婚
usage   クレジットカード年間総利用額(以下からジャンルごとの金額)
retail  小売
rest    飲食
enter   エンタメ
trans   交通
other   その他
hotel   宿泊利用
```
目的変数であるhotelは0-1変数で、0が宿泊未利用、1が宿泊利用を表しています。ここでは説明変数から目的変数を予測する決定木モデルを作成し、未知のデータに対してどれだけ予測精度が良いのかを検証していくことが目標です。

このデータを変数cust.1に格納し、学習用データをcustTrainに、検証用データをcustTestにそれぞれ格納しております。(後述のソースコードに記載しております)

### 発生している問題・エラーメッセージ

発生している問題点は、以下の2点です。
1. ライブラリpartykitを用いた決定木の箱ひげ図の表示がすべて同じであり、かつ、データの四分位範囲が極端に狭いことであることからも結果がおかしいこと。
```R
install.packages("rpart.plot")
library(rpart.plot)
install.packages("partykit")
library(partykit)

model.rp <- rpart(hotel~., data = custTrain) # すべての説明変数からhotelの値を予測する
rpart.plot(model.rp)
model.rpo <- as.party(model.rp, type='simple')
plot(model.rpo)　#以下の画像がこの行の実行結果です
```
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-12-21/8fa8a2a7-6103-492a-89a0-8b6774d18652.png)
2. 作成した決定木モデルと未知のデータcustTestを入力としてpredict関数で予測を行った結果の値が0.03865975と0.11043432の2つのみになってしまうこと。
理想としては、すべてのデータに対する予測値を表示させるのではなく、混同行列のような形式で正解率を表示させたいのですが、調べてもわかりませんでした。
```R
# 未知データ(検証用データ)に対して予測を行う
model.pred <- predict(model.rp, custTest)
model.pred #この行の実行結果が以下です
```
```
・・・(前略)
65975 0.03865975 0.03865975 0.03865975 0.03865975 0.17823882 0.11043432 
    125737     125740     125743     125746     125749     125752     125755 
0.11043432 0.11043432 0.03865975 0.11043432 0.03865975 0.03865975 0.03865975 
    125758     125761     125764     125767     125770     125773     125776 
0.03865975 0.11043432 0.11043432 0.03865975 0.03865975 0.03865975 0.03865975 
    125779     125782     125785     125788     125791     125794     125797 
0.03865975 0.03865975 0.17823882 0.03865975 0.11043432 0.03865975 0.03865975 
    125800     125803     125806     125809     125812     125815     125818 
0.03865975 0.03865975 0.17823882 0.11043432 0.03865975 0.03865975 0.03865975 
    125821     125824     125827     125830     125833     125836     125839 
0.03865975 0.17823882 0.11043432 0.03865975 0.03865975 0.11043432 0.17823882 
    125842     125845     125848     125851     125854     125858     125861 
0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 
    125864     125867     125870     125874     125877     125880     125885 
0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 0.17823882 0.03865975 
    125888     125891     125894     125897     125900     125903     125906 
0.17823882 0.03865975 0.03865975 0.11043432 0.03865975 0.03865975 0.17823882 
    125909     125912     125915     125919     125922     125925     125928 
0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 
    125931     125934     125937     125940     125943     125946     125949 
0.03865975 0.03865975 0.03865975 0.17823882 0.03865975 0.03865975 0.11043432 
    125952     125955     125958     125961     125964     125967     125970 
0.03865975 0.03865975 0.03865975 0.11043432 0.03865975 0.03865975 0.03865975 
    125973     125976     125979     125982     125985     125989     125992 
0.03865975 0.11043432 0.03865975 0.03865975 0.17823882 0.03865975 0.03865975 
    125996     125999     126002     126005     126008     126011     126014 
0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 0.11043432 0.17823882 
    126017     126020     126023     126026     126029     126032     126035 
0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 
    126038     126041     126044     126047     126050     126053     126056 
0.17823882 0.03865975 0.03865975 0.11043432 0.03865975 0.03865975 0.17823882 
    126059     126062     126065     126068     126071     126074     126077 
0.17823882 0.03865975 0.17823882 0.11043432 0.11043432 0.03865975 0.11043432 
    126080     126083     126086     126090     126095     126098     126101 
0.03865975 0.11043432 0.03865975 0.03865975 0.03865975 0.03865975 0.11043432 
    126104     126108     126111     126114     126117     126120     126123 
0.17823882 0.11043432 0.03865975 0.03865975 0.11043432 0.11043432 0.03865975 
    126126     126130     126133     126136     126139     126142     126145 
0.17823882 0.03865975 0.03865975 0.11043432 0.03865975 0.11043432 0.17823882 
    126148     126151     126154     126157     126160     126163     126166 
0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 0.11043432 0.03865975 
    126169     126172     126175     126178     126181     126184     126187 
0.11043432 0.03865975 0.17823882 0.17823882 0.17823882 0.17823882 0.17823882 
    126190     126193     126196     126199     126202     126205     126208 
0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 0.11043432 0.17823882 
    126211     126214     126217     126220     126223     126226     126229 
0.11043432 0.03865975 0.03865975 0.11043432 0.03865975 0.03865975 0.03865975 
    126232     126235     126238     126241     126244     126247     126250 
0.11043432 0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 0.03865975 
    126253     126256     126259     126262     126265     126268     126272 
0.03865975 0.03865975 0.03865975 0.11043432 0.03865975 0.03865975 0.11043432 
```

### 該当のソースコード

ソースコードの全体を掲載いたします。
```R
install.packages("rpart")
library(rpart)
install.packages("rpart.plot")
library(rpart.plot)
install.packages("partykit")
library(partykit)

# データのインポート
getwd()
cust <- read.csv(file = "cust1.csv")
head(cust)

# id列を説明変数から除外
cust$id = NULL

# データの各列のサマリーの確認
summary(cust)

# 異常値の除外
cust.1 <- cust
cust.1$age <- ifelse(cust.1$age>122, NA, cust.1$age)
cust.1$retail <- ifelse(cust.1$retail<0, NA, cust.1$retail)
cust.1$rest <- ifelse(cust.1$rest<0, NA, cust.1$rest)
cust.1$trans <- ifelse(cust.1$trans<0, NA, cust.1$trans)
cust.1$other <- ifelse(cust.1$other<0, NA, cust.1$other)
cust.1$usage <- ifelse(cust.1$usage<0, NA, cust.1$usage)
summary(cust.1)

# 欠損値の削除
cust.1 <- na.omit(cust.1)

# 箱ひげ図を用いて、外れ値を確認する
boxplot(cust.1$age)
boxplot(cust.1$retail)
boxplot(cust.1$rest)
boxplot(cust.1$enter)
boxplot(cust.1$trans)
boxplot(cust.1$other)
boxplot(cust.1$usage)
boxplot(cust.1[,c("age","retail","rest","enter","trans","other","usage")])

# 外れ値を除外する
higher.retail = quantile(cust.1$retail, probs=0.99)
cust.1$retail <- ifelse(cust.1$retail>higher.retail, NA, cust.1$retail)
higher.rest = quantile(cust.1$rest, probs=0.99)
cust.1$rest <- ifelse(cust.1$rest>higher.rest, NA, cust.1$rest)
higher.trans = quantile(cust.1$trans, probs=0.99)
cust.1$trans <- ifelse(cust.1$trans>higher.trans, NA, cust.1$trans)
higher.other = quantile(cust.1$other, probs=0.99)
cust.1$other <- ifelse(cust.1$other>higher.other, NA, cust.1$other)
higher.usage = quantile(cust.1$usage, probs=0.99)
cust.1$usage <- ifelse(cust.1$usage>higher.usage, NA, cust.1$usage)

# 欠損値の削除
cust.1 <- na.omit(cust.1)
summary(cust.1)

# custを学習用データと検証用データの2つに分類しておく
index <- which(1:nrow(cust.1)%%3 == 0)
custTrain <- cust.1[-index,] #3の倍数以外を学習用データにする
custTest <- cust.1[index,] #3の倍数は検証用データ
head(custTrain)
head(custTest)

# 学習用データを用いて決定木モデルを作成
model.rp <- rpart(hotel~., data = custTrain)
model.rp
rpart.plot(model.rp)

model.rpo <- as.party(model.rp, type='simple')
plot(model.rpo)

# 未知データ(検証用データ)に対して予測を行う
model.pred <- predict(model.rp, custTest)
head(model.pred)

```

### 試したこと

上記ソースコードの17行目「summary(cust)」の出力結果から、「[cust1.csv](https://ux.getuploader.com/subtest/download/1)」には異常値があること、また、33～40行目にある箱ひげ図の出力結果から、外れ値があることが判明しました。
ageに122歳以上のデータがあることや、ジャンルごとのクレジットカードの利用金額に負の値があることから、これらのデータをいったん欠損値NAに変え、「na.omit(cust.1)」によってNAの行を除外しています。
```R
# 異常値の除外
cust.1 <- cust
cust.1$age <- ifelse(cust.1$age>122, NA, cust.1$age)
cust.1$retail <- ifelse(cust.1$retail<0, NA, cust.1$retail)
cust.1$rest <- ifelse(cust.1$rest<0, NA, cust.1$rest)
cust.1$trans <- ifelse(cust.1$trans<0, NA, cust.1$trans)
cust.1$other <- ifelse(cust.1$other<0, NA, cust.1$other)
cust.1$usage <- ifelse(cust.1$usage<0, NA, cust.1$usage)
summary(cust.1)
```

また、箱ひげ図の結果から異常に大きな値（外れ値）があることを確認したため、データの上位0.01%を除外してみました。
```R
# 外れ値を除外する
higher.retail = quantile(cust.1$retail, probs=0.99)
cust.1$retail <- ifelse(cust.1$retail>higher.retail, NA, cust.1$retail)
higher.rest = quantile(cust.1$rest, probs=0.99)
cust.1$rest <- ifelse(cust.1$rest>higher.rest, NA, cust.1$rest)
higher.trans = quantile(cust.1$trans, probs=0.99)
cust.1$trans <- ifelse(cust.1$trans>higher.trans, NA, cust.1$trans)
higher.other = quantile(cust.1$other, probs=0.99)
cust.1$other <- ifelse(cust.1$other>higher.other, NA, cust.1$other)
higher.usage = quantile(cust.1$usage, probs=0.99)
cust.1$usage <- ifelse(cust.!1$usage>higher.usage, NA, cust.1$usage)
# 欠損値の削除
cust.1 <- na.omit(cust.1)
summary(cust.1)
```
Rによる決定木分析についてネットで何時間も調べていましたが、結局問題解決には至りませんでした。どなたかお力をお借りしたいです。よろしくお願いいたします。

### 補足情報（FW/ツールのバージョンなど）

R Gui 4.3.2 (Windows版)

### 追記2(検証用データによるモデルの評価について)
```R
#学習用データを用いて決定木モデルを作成
install.packages("rpart")
library(rpart)
install.packages("partykit")
library(partykit)
install.packages("dplyr")
library(dplyr)
model <
rpart(hotel~., data = custTrain, cp=0.002, method=' anova')
plot(as.party(model), type='simple')

# 未知データ(検証用データ)に対して予測を行う
threshold <- 0.1
model.pred <- predict(model, newdata = custTest, type = "vector") >= threshold
table(model.pred, custTest[,4])
```
実行結果
```
model.pred 0 1
FALSE 29647 1434
TRUE 7825 1526
```
そもそも閾値を0.5にした時点でFALSEの判定(hote=0)しか表示されない点で何かがおかしいと感じております。type = "vector"としているのは、以下のサイトを参考にしたためです。
https://www.appsloveworld.com/r/100/148/invalid-prediction-for-rpart-object-error

R言語で実装した決定木モデルの予測が意図した結果になりません

### 実現したいこと
機械学習flask kerasを使ってwebカメラで撮った顔写真から芸能人の写真と比較し類似度を出すゲームを作りたい！
ここに実現したいことを箇条書きで書いてください。
- [ ] ▲▲機能を動作するようにする

### 前提
僕たちプログラミングに関しての知識が浅く困っています。ここができなくて困っているとかではなく一から助けてほしいです。
ここに質問の内容を詳しく書いてください。
（例）
TypeScriptで●●なシステムを作っています。
■■な機能を実装中に以下のエラーメッセージが発生しました。

### 発生している問題・エラーメッセージ

```
エラーメッセージ
```

### 該当のソースコード
python
```ここに言語名を入力
ソースコード
```

### 試したこと

ここに問題に対して試したことを記載してください。

### 補足情報（FW/ツールのバージョンなど）

ここにより詳細な情報を記載してください。


Raspberry pi 4を使って顔写真から芸能人の写真と比較して類似度を出したい！

### 実現したいこと

MILプログラムを正しく動かしたい

### 前提

入力が(1, 64, 2048)の形状（センタークロップ、正常・異常を結合したブロック数、次元の大きさ）の場合、ブロックごとに異常度スコアを出力したい。
具体的には
正常データでの異常度スコア：32個
異常データでの異常度スコア：32個
が出力されるようにしたい。
MILのプログラム(main.py)は
https://github.com/seominseok0429/Real-world-Anomaly-Detection-in-Surveillance-Videos-pytorch/blob/main/main.py
を、ネットワーク(Learner4.py)には
https://github.com/yaegasikk/attention_anomaly_detector/blob/main/network/video_classifier.py
のVideoclassifierを用いた。

### 発生している問題・エラーメッセージ

ネットワーク部分で内積を取得する関係上、1データにつきスコアが1つしか出力されない

### 該当のソースコード

```main.py
from torch.utils.data import DataLoader
from learner4 import Learner4
# from learner import Learner
from loss import *
from dataset import *
import os
from sklearn import metrics
import argparse
from FFC import *
from radam import RAdam
import matplotlib.pyplot as plt

parser = argparse.ArgumentParser(description='PyTorch MIL Training')
parser.add_argument('--lr', default=0.001, type=float, help='learning rate')
parser.add_argument('--w', default=0.0010000000474974513, type=float, help='weight_decay')
parser.add_argument('--modality', default='RGB', type=str, help='modality')
parser.add_argument('--input_dim', default=2048, type=int, help='input_dim')
parser.add_argument('--drop', default=0.6, type=float, help='dropout_rate')
parser.add_argument('--FFC', '-r', action='store_true',help='FFC')
args = parser.parse_args()

best_auc = 0

normal_train_dataset = Normal_Loader(is_train=1, modality=args.modality)
normal_test_dataset = Normal_Loader(is_train=0, modality=args.modality)

anomaly_train_dataset = Anomaly_Loader(is_train=1, modality=args.modality)
anomaly_test_dataset = Anomaly_Loader(is_train=0, modality=args.modality)

normal_train_loader = DataLoader(normal_train_dataset, batch_size=1, shuffle=True)
normal_test_loader = DataLoader(normal_test_dataset, batch_size=1, shuffle=True)

anomaly_train_loader = DataLoader(anomaly_train_dataset, batch_size=1, shuffle=True)
anomaly_test_loader = DataLoader(anomaly_test_dataset, batch_size=1, shuffle=True)

device = 'cuda' if torch.cuda.is_available() else 'cpu'

if args.FFC:
    model = Learner2(input_dim=args.input_dim, dropout=args.drop).to(device)
else:
    model = Learner4(input_dim=args.input_dim, dropout=args.drop).to(device)

optimizer = RAdam(model.parameters())
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[25, 50])
criterion = MIL
train_loss_history = []

def train(epoch):
    print('\nEpoch: %d' % epoch)
    model.train()
    train_loss = 0
    correct = 0
    total = 0
    for batch_idx, (normal_inputs, anomaly_inputs) in enumerate(zip(normal_train_loader, anomaly_train_loader)):
        
        inputs = torch.cat((anomaly_inputs, normal_inputs), 0)
        # print('first inputs shape : ', inputs.shape)
        # batch_size = inputs.shape[0]
        inputs = inputs.view(-1, inputs.size(-2), inputs.size(-1)).to(device)
        batch_size = inputs.shape[0]
        # inputs = inputs.view(-1, inputs.size(-1)).to(device)
        # print('after inputs shape : ', inputs.shape)
        outputs = model(inputs)
        print(outputs.shape)
        loss = criterion(outputs, batch_size)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
    train_loss_history.append(train_loss/len(normal_train_loader))    
    print('loss = ', train_loss/len(normal_train_loader))
    scheduler.step()
    

def test_abnormal(epoch):
    model.eval()
    global best_auc
    auc = 0
    with torch.no_grad():
        for i, (data, data2) in enumerate(zip(anomaly_test_loader, normal_test_loader)):
            inputs, gts, frames = data
            # inputs = inputs.view(-1, inputs.size(-1)).to(torch.device('cuda'))
            # inputs = inputs.to(torch.device('cuda'))
            inputs = inputs.view(-1, inputs.size(-2), inputs.size(-1)).to(torch.device('cuda'))
            # print(inputs.shape)
            score = model(inputs)
            score = score.cpu().detach().numpy()
            score_list = np.zeros(frames[0])
            step = np.round(np.linspace(0, frames[0]//16, 33))

            for j in range(32):
                score_list[int(step[j])*16:(int(step[j+1]))*16] = score[j]

            gt_list = np.zeros(frames[0])
            for k in range(len(gts)//2):
                s = gts[k*2]
                e = min(gts[k*2+1], frames)
                gt_list[s-1:e] = 1

            inputs2, gts2, frames2 = data2
            # inputs2 = inputs2.view(-1, inputs2.size(-1)).to(torch.device('cuda'))
            inputs2 = inputs2.view(-1, inputs2.size(-2), inputs2.size(-1)).to(torch.device('cuda'))
            score2 = model(inputs2)
            score2 = score2.cpu().detach().numpy()
            score_list2 = np.zeros(frames2[0])
            step2 = np.round(np.linspace(0, frames2[0]//16, 33))

            for kk in range(32):
                score_list2[int(step2[kk])*16:(int(step2[kk+1]))*16] = score2[kk]

            gt_list2 = np.zeros(frames2[0])
            score_list3 = np.concatenate((score_list, score_list2), axis=0)
            gt_list3 = np.concatenate((gt_list, gt_list2), axis=0)

            fpr, tpr, thresholds = metrics.roc_curve(gt_list3, score_list3, pos_label=1)
            auc += metrics.auc(fpr, tpr)

        print('auc = ',auc/140) 

        if best_auc < auc/140:
            print('Saving..')
            state = {
                'net': model.state_dict(),
            }
            if not os.path.isdir('checkpoint'):
                os.mkdir('checkpoint')
            torch.save(state, './checkpoint/ckpt.pth')
            best_auc = auc/140

def plot_loss(train_loss_history, save_path='Loss.png'):
    plt.figure(figsize=(10, 5))
    plt.plot(train_loss_history, label='Training Loss')
    plt.title('Training Loss Over Epochs')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    plt.grid(True)
    plt.savefig(save_path)

for epoch in range(0, 1620):
    train(epoch)
    test_abnormal(epoch)

print("Best AUC:", best_auc)
plot_loss(train_loss_history, save_path='Loss.png')

```

```Learner4.py
import torch
import torch.nn as nn
import numpy as np
import torch.nn.functional as F
import matplotlib.pyplot as plt
import os
import seaborn as sns

class Learner4(nn.Module):
    def __init__(self, input_dim = 2048, dropout = 0.0, attention=False):
        super().__init__()
        self.self_anttention = nn.Sequential(nn.Linear(input_dim,64),nn.Tanh(),nn.Linear(64,3))
        self.fc1 = nn.Linear(input_dim*3,32)
        self.fc2 = nn.Linear(32,1)
        self.dropout = nn.Dropout(dropout)
        self.sig = nn.Sigmoid()

        self.return_attention = attention

    def forward(self,x):
        bs,t,f = x.shape
        attentionweight = self.dropout(F.softmax(self.self_anttention(x),dim=1))
        m = torch.bmm(x.permute(0,2,1),attentionweight)
        x = m.view(bs,-1)
        x = self.fc1(x)
        x = self.fc2(x)
        x = self.sig(x)
        x = x.view(bs, -1) #[batch]

        if self.return_attention:
            return x, attentionweight
        else:
            return x
```



Multiple Instance Learningプログラムについて

### 実現したいこと

ここに実現したいことを箇条書きで書いてください。
- [ ] 辺の長さが1から100のランダムな長方形が約1000個あるリストがあります。
- [ ] （9割程度は高さが30以下です。高さと横幅は異なり、イレギュラーはありますが、高さは横幅の概ね0.5～1.5倍程度です。）
- [ ] 横幅が約4000のスペースに上から左詰めで長方形を配置します。
- [ ] すべての長方形は重ねて配置してできません。
- [ ] スペースの横幅をはみ出る場合には改行し、下に作成する次の行に配置します。
- [ ] 行の高さは30です。
- [ ] 長方形の高さが行の高さをはみ出る場合には、上の行に配置済みの長方形を右にずらして配置しなおします。
- [ ] 長方形を配置しなおした結果、スペースの横幅をはみ出す場合には改行位置を変更します。
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-12-10/ef7d4ee0-4492-4586-bc53-f0e729b1f33d.png)
### 前提

python
長方形のリストはpandas DataFrameに入っています。
DataFrameのままでもリストにしてもらっても構いません。

### 試したこと

いろいろ試していますが、上にはみ出す長方形がなかなかうまく配置できません。
長方形の下部をベースに上部の行番号と位置が決まりますが、上部を挿入することで下部の位置が変わります。
再度下部の位置を変更することで、行からはみ出すケースがあり、その場合下部の位置が次の行になるため、
再度上部の位置を変更する必要が発生します。
上部の位置を変更すると下部の位置が変わり、という感じで最適な位置が決まらないです。

サンプルを実装できる方がいると大変ありがたいですが、
こうすればよい、というアルゴリズムの提示だけでも助かりますので、
ご教示ください。


長方形をきれいに並べたい

### 実現したいこと

・作成したコードが学習できるようにしたい

### 前提

Pytorchでcifar10の画像を4枚つなげた1枚の画像のマルチラベル分類をするコードを作っています。


### 発生している問題・エラーメッセージ

実行すると、はじめから損失が低く出てしまっていて、学習している様子がありません。
実際に正解率も低いです。

### 試したこと
損失関数や評価関数、モデルを見直しましたがうまくいきません

### 補足情報（FW/ツールのバージョンなど）

python3.10.10

### 該当のソースコード
・net.py
```python
import torch
import torch.nn as nn
import torchvision
import torch.nn.functional as F


class MyResNet50(nn.Module):
    def __init__(self, my_pretrained_model):
        super(MyResNet50, self).__init__()
        self.pretrained = my_pretrained_model
        num_classes = 10  # マルチラベル分類のクラス数
        
        # ドロップアウト率を設定
        dropout_rate = 0.5
        self.my_new_layers = nn.Sequential(   
                                nn.Linear(1000, 4096), # 例として追加の全結合層を挿入
                                nn.Dropout(p=dropout_rate),
                                nn.ReLU(inplace=True),
                                nn.Dropout(p=dropout_rate),
                                nn.Linear(4096, num_classes),
                                nn.Sigmoid()  # 最終層にSigmoid関数を追加
                                )
    
    def forward(self, x):
        x = self.pretrained(x)
        x = self.my_new_layers(x)
        return x
``` 

・コード本体
````python
import torch
import torch.nn as nn
import os
import torch.optim as optim
import torchvision
import numpy as np
import matplotlib.pyplot as plt
import torchvision.models as models
from torch.utils.data import Dataset
import torchvision.transforms as transforms
import torch.optim.lr_scheduler as lr_scheduler
import torch.nn.functional as F
import pdb
import wandb
from net import MyResNet50


# start a new wandb run to track this script
wandb.init(
    # set the wandb project where this run will be logged
    project="multi_label_classification4",
    
    # track hyperparameters and run metadata
    config={
    "learning_rate": 0.001,
    "architecture": "CNN",
    "dataset": "CIFAR-10",
    "epochs": 10,
    }
)
def combine_single_image(X, y):
    out_image = np.zeros((64, 64, 3), dtype=np.uint8)
    out_label = np.zeros(10, dtype=np.float32)
    category_idx = np.random.permutation(np.arange(10))[:4]

    for i, category in enumerate(category_idx):
        filters = np.where(y==category)[0]
        item_idx = np.random.permutation(filters)[i]
        if i == 0:
            out_image[:32, :32, :] = X[item_idx, :, :, :]
        elif i == 1:
            out_image[:32, 32:,:] = X[item_idx, :, :, :]
        elif i == 2:
            out_image[32:, :32, :] = X[item_idx, :, :, :]
        else:
            out_image[32:, 32:, :] = X[item_idx, :, :, :]
        out_label[category] = 1.0
    return out_image, out_label

def create_data(X, y, num):
    images=[]
    labels=[]
    for i in range(num):
        X_item, y_item = combine_single_image(X, y)
        images.append(X_item)
        labels.append(y_item)
    return (images,labels)

train = torchvision.datasets.CIFAR10(root='./data/cifar10',
                                           train=True,
                                           download=True,
                                           )
test = torchvision.datasets.CIFAR10(root='./data/cifar10',
                                          train=False, 
                                          download=True,
                                          )

X_train = np.zeros((len(train),32,32,3),dtype=np.uint8)
y_train = np.zeros(len(train),dtype=np.int32) 
for i in range(len(train)):
    img, label = train[i]
    X_train[i] = np.array(img)
    y_train[i] = label
train_data = create_data(X_train, y_train, 500)


X_test = np.zeros((len(test),32,32,3),dtype=np.uint8)
y_test = np.zeros(len(test),dtype=np.int32)
for i in range(len(test)):
    img, label = test[i]
    X_test[i] = np.array(img)
    y_test[i] = label
test_data = create_data(X_test, y_test, 100)

transform = transforms.Compose([
    transforms.ToPILImage(),
    transforms.ToTensor(),  # Tensorに変換
    transforms.Resize((224, 224)),  # 画像サイズの変更
    transforms.RandomHorizontalFlip(),  # ランダムな水平反転
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),  # 正規化
    transforms.RandomErasing(p=0.5, scale=(0.02, 0.33), ratio=(0.3, 3.3), value=0, inplace=False)  # ランダム化2
])

class MultiLabelTrainDataset(Dataset):
    def __init__(self, train_data, transform=transform):
        self.images = train_data[0]
        self.labels = train_data[1]
        self.transform = transform
    
    def __getitem__(self, idx):
        image = self.images[idx]
        label = self.labels[idx]

        if self.transform is not None:
            image = self.transform(image)
        
        return (image, label)

    def __len__(self):
        return len(self.images)
    
class MultiLabelTestDataset(Dataset):
    def __init__(self, test_data, transform=transform):
        self.images = test_data[0]
        self.labels = test_data[1]
        self.transform = transform
    
    def __getitem__(self, idx):
        image = self.images[idx]
        label = self.labels[idx]

        if self.transform:
            image = self.transform(image)
        
        return (image, label)

    def __len__(self):
        return len(self.images)
    
train_data=train_data
test_data=test_data

train_dataset = MultiLabelTrainDataset(train_data)
test_dataset = MultiLabelTestDataset(test_data)

train_dataloader =torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)
test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=32,shuffle=False)

def binary_loss(y_true, y_pred):
    bce = F.binary_cross_entropy(y_pred, y_true)
    return torch.sum(bce, dim=-1)

# 完全正解の評価
def evaluate_exact(y_true, y_pred):
    y_pred = torch.where(y_pred>0.5, 1, 0)
    correct = (y_true == y_pred).all(dim=1).sum().item()
    total = y_true.size(0)
    accuracy = correct / total
    return accuracy

# 部分正解の評価
def evaluate_partial(y_true, y_pred):
    y_pred = torch.where(y_pred>0.5, 1, 0)
    correct = (y_true == y_pred).sum().item()
    total = y_true.size(0) * y_true.size(1)  # データポイントの総数 × ラベルの数
    accuracy = correct / total # 正解率をパーセンテージ（%）で表現
    return accuracy


pretrained = torchvision.models.resnet50(pretrained=True)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = MyResNet50(my_pretrained_model=pretrained)
model = model.to(device)


# オプティマイザの定義
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=0.0001)

#スケジューラーの定義
scheduler = lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)

# モデルのトレーニング
num_epochs = 5  # トレーニングのエポック数

total_step = len(train_dataloader)
for epoch in range(num_epochs):
    model.train()
    exact_accuracy = 0
    partial_correct = 0
    total = 0

    for ind, (images, labels) in enumerate(train_dataloader):
        images = images.to(device)
        labels = labels.to(device)
        optimizer.zero_grad()

        outputs = model(images)
        
        loss = binary_loss(labels, outputs)
        loss.backward()
        optimizer.step()
        scheduler.step()
        loss.item()
        #import pdb;pdb.set_trace()
        # 完全正解の評価
        exact_accuracy += evaluate_exact(labels, outputs)
        # 部分正解の評価
        partial_correct += evaluate_partial(labels, outputs)
        total += labels.size(0)
        
    epoch_loss = loss.item() / total
    epoch_exact_accuracy = exact_accuracy / total
    epoch_partial_accuracy = partial_correct / total
    # log metrics to wandb
    wandb.log({"exact_acc": epoch_exact_accuracy, "partial_acc": epoch_partial_accuracy, "loss": epoch_loss})

    print(f"Epoch {epoch+1}/{num_epochs} - Loss: {epoch_loss:.4f} - Exact Accuracy: {epoch_exact_accuracy*100:.2f}% - Partial Accuracy: {epoch_partial_accuracy*100:.2f}%")
    
 # Save weights
torch.save(model.state_dict(), './out/model.ckpt')
    
model.eval()
test_exact_accuracy = 0
test_partial_correct = 0
test_total = 0

with torch.no_grad():
    for test_inputs, test_labels in test_dataloader:
      test_inputs = test_inputs.to(device)
      test_labels = test_labels.to(device)
      test_outputs = model(test_inputs)
      
      
      # 完全正解の評価
      test_exact_accuracy += evaluate_exact(test_labels, test_outputs)
      # 部分正解の評価
      test_partial_correct += evaluate_partial(test_labels, test_outputs)

      test_total = len(test_dataloader)

      test_exact_accuracy = test_exact_accuracy / test_total
      test_partial_accuracy = test_partial_correct / test_total

      # log metrics to wandb
      wandb.log({"exact_acc(test)": test_exact_accuracy, "partial_acc(test)": test_partial_accuracy})


    print(f"Exact Accuracy: {test_exact_accuracy*100:.2f}% - Partial Accuracy: {test_partial_accuracy*100:.2f}%")

# [optional] finish the wandb run, necessary in notebooks
wandb.finish()


cifar10を4枚つなげてマルチラベル分類をするコードが学習しない

### 実現したいこと

2値分類で正例を予測する場合と正例・負例の両方を予測する場合の違いについて理解する

### 試したこと

2値分類で正例を予測する場合と正例・負例の両方を予測する場合でなにか異なるアプローチをとる必要があるのかどうかを調べています。
（機械学習で分類モデルを作成する場合を想定しています。）

特に今まで意識していなかったのですが、評価や前処理でなにか異なるアプローチをする必要があるのでしょうか？

どちらのケースでも以下のような対応をしています。
・前処理でのアプローチとしてはデータの正例・負例に偏りがあればアンダーサンプリングする。
・評価関数に混合行列を用いて評価する

調べたのですが、値分類で正例を予測する場合と正例・負例の両方を予測する場合の違いについて
言及している記事が見つからなかったため質問させていただきました。

よろしくお願いします。

2値分類で正例を予測する場合と正例・負例の両方を予測する場合の違いについて

### 実現したいこと

numyとthreadingでOpen AI gym のcartpole-v1を学習させたい

### 前提
https://qiita.com/s05319ss/items/2fe9bfe562fea1707e79

上の記事を参考にA3CでOpen AI gym のcartpole-v1を学習させているが、うまく学習ができない

### 発生している問題・エラーメッセージ
獲得報酬が20ほどであり、最大報酬である300(私が報酬をいじっています)を獲得できるよううまく学習ができていない


### 該当のソースコード

```Python
import numpy as np
import gym
import matplotlib.pylab as plt
import random
import threading
import copy

class Environment:
    def __init__(self,batchsize=1):
        self.batchsize=batchsize
        self.state=np.zeros((batchsize, 4))
        self.step=np.zeros(batchsize)
        self.score=np.zeros(batchsize)
        self.flag=np.ones(batchsize).astype(bool)
        self.environment=gym.make('CartPole-v1', render_mode='rgb_array')
        initial_state, info = self.environment.reset()
        for i in range(4):
            self.state[0][i] = initial_state[i]
            
    def transition(self,action):
        a = np.copy(action)
        for i in range(self.batchsize):
            next_state, reward, terminated, truncated, info = self.environment.step(int(a[i]))
            self.flag[i] = not terminated
            if self.flag[i]==True:
                self.score[i]+= reward
                self.step[i]+=1
                if self.step[i]>=200:
                    self.flag[i]=False
                    self.score[i]+= 100
            else:
                self.score[i]+= (-1)
            for j in range(4):
                self.state[i][j] = next_state[j]
        

    def initialize(self, flag=None):
        if flag is None:
            flag = np.ones(self.state.shape[0], dtype=bool)
        self.state[flag]*=0
        self.step[flag]*=0
        self.score[flag]*=0
        self.flag[flag]=np.ones(np.sum(flag)).astype(bool)
        initial_state, info = self.environment.reset()
        for i in range(4):
            self.state[0][i] = initial_state[i]


# Agent to play the above RL task with finite, discrete action space.
class Agent_Ex1_Discrete:
    def __init__(self):
        self.sharedbody=SharedBody()
        self.vhead=Affine()
        self.pihead=Affine()
        self.V=None
        self.probdist=None
        self.a=None
        self.action_kinds=None
        self.H=None
        self.action_number = 2
        
    def action(self,state,params):
        s=copy.deepcopy(state)
        latentvect=self.sharedbody.forward(s,params['sharedbody'])
        self.V=self.vhead.forward(latentvect,params['vhead'])
        preprobdist=self.pihead.forward(latentvect,params['pihead'])
        self.probdist=softmax(preprobdist)
        self.action_kinds = np.zeros(self.probdist.shape[0])
        self.a=np.zeros([self.probdist.shape[0],self.action_number])
        for i in range(self.action_kinds.shape[0]):
            self.action_kinds[i] = np.random.choice(a=self.action_number,p=self.probdist[i, :])
            self.a[i][int(self.action_kinds[i])] = 1
        self.H=-np.sum(self.probdist*np.log(self.probdist),axis=1).reshape(-1,1)
        return self.a
  #def gradsは元の記事と同じ
　def initialparams(self):
        params={}
        params['sharedbody']={}
        params['vhead']={}
        params['pihead']={}
        params['sharedbody']['W1']=np.random.randn(4,10)* 0.01
        params['sharedbody']['b1']=np.zeros(10)
        params['sharedbody']['W2']=np.random.randn(10,10)/np.sqrt(10)
        params['sharedbody']['b2']=np.zeros(10)
        params['vhead']['W']=np.random.randn(10,1)/np.sqrt(10)
        params['vhead']['b']=np.zeros(1)
        params['pihead']['W']=np.random.randn(10,2)/np.sqrt(10)
        params['pihead']['b']=np.zeros(2)
        return params

#def softmax,class SharedBody,class Affine, class Sigmoid, class Tanhは元の記事と同じ

    
# Global computation in the A3C algorithm.
class A3C:
    def __init__(self,t_max,T_max,agents,environments,params=None,gamma=0.99,alpha=0.99,learningrate=7e-4,vweight=0.5,entropyweight=0.01,epsilon=0.1,epoch=10):
        self.t_max=t_max
        self.T_max=T_max
        self.N=len(agents)
        self.gamma=gamma
        self.lr=learningrate
        self.kappa=vweight
        self.beta=entropyweight
        self.epsilon=epsilon
        self.c=epoch
        self.scorehistory=np.array([])
        if params==None:
            self.params=agents[0].initialparams()
        else:
            self.params=params.copy
        self.g={}
        for key1 in self.params.keys():
            self.g[key1]={}
            for key2 in self.params[key1].keys():
                self.g[key1][key2]=np.zeros_like(self.params[key1][key2])
        self.alpha=alpha
        self.T=0
        self.threadinstances={}
        for i in range(self.N):
            self.threadinstances[i]=A3Cthread(agents[i],environments[i])
        self.accumulatedscores=0.0
        self.numberofsamples=0
    def update(self,threadinstance):
        while self.T<self.T_max:
            eta=-self.T*self.lr/float(self.T_max)+self.lr
            threadgrads,cnt,ifterminated,threadscore=threadinstance.grads(self.params,self.gamma,self.t_max,self.kappa,self.beta)
            for key1 in self.params.keys():
                for key2 in self.params[key1].keys():
                    self.g[key1][key2]*=self.alpha
                    self.g[key1][key2]+=(1-self.alpha)*threadgrads[key1][key2]**2
                    self.params[key1][key2]-=eta*threadgrads[key1][key2]/np.sqrt(self.g[key1][key2]+self.epsilon)
            self.T+=cnt
            self.accumulatedscores+=ifterminated*threadscore
            self.numberofsamples+=ifterminated
            if self.numberofsamples>self.c:
                self.scorehistory=np.append(self.scorehistory,self.accumulatedscores/float(max(1,self.numberofsamples)))
                self.accumulatedscores*=0
                self.numberofsamples*=0
                print(str(self.T)+" steps done with average score:")
                print(self.scorehistory[-1])
    def train(self):
        threads=[]
        for i in range(self.N):
            threads.append(threading.Thread(target=self.update,args=(self.threadinstances[i],)))
        for i in range(self.N):
            threads[i].start()
        for i in range(self.N):
            threads[i].join()
        return self.params

# Local computation for each A3C thread.
class A3Cthread:
    def __init__(self,agent,environment):
        self.agent=agent
        self.environment=environment
        self.environment.initialize()
        self.t=0
        self.vlast=None
        self.alast=None
        
    def grads(self,globalparams,gamma,t_max,kappa=0.5,beta=0.01):
        params={}
        grads={}
        for key1 in globalparams.keys():
            params[key1]={}
            grads[key1]={}
            for key2 in globalparams[key1].keys():
                params[key1][key2]=globalparams[key1][key2].copy()
                grads[key1][key2]=np.zeros_like(globalparams[key1][key2])
        gradstoaccumulate={}
        rewards={}
        vvalues={}
        t_start=self.t
        while bool((self.t-t_start<t_max)*(np.prod(self.environment.flag))):
            rewards[self.t]=-self.environment.score.copy()
            if bool((self.t>0)*(self.t==t_start)):
                a=self.alast.copy()
                vvalues[self.t]=self.vlast.copy()
            else:
                a=self.agent.action(self.environment.state,params)
                vvalues[self.t]=self.agent.V.copy()
            gradstoaccumulate[self.t]=self.agent.grads(1,2*kappa,beta)
            self.environment.transition(self.agent.action_kinds)
            rewards[self.t]+=self.environment.score.copy()
            self.t+=1
        self.alast=self.agent.action(self.environment.state,params)
        self.vlast=self.agent.V.copy()
        R=self.vlast
        for i in range(self.t-t_start):
            R=gamma*R+rewards[self.t-i-1]
            for key1 in globalparams.keys():
                for key2 in globalparams[key1].keys():
                    grads[key1][key2]-=np.sum(R-vvalues[self.t-i-1])*gradstoaccumulate[self.t-i-1][0][key1][key2]+gradstoaccumulate[self.t-i-1][1][key1][key2]
        threadscore=np.sum(self.environment.score.copy())
        ifterminated=not(bool(np.prod(self.environment.flag)))
        if ifterminated:
            self.environment.initialize()
        return grads,self.t-t_start,ifterminated,threadscore

# Showing how the agent with finite, discrete action space performs before training.
testagent=Agent_Ex1_Discrete()
untrainedparams=testagent.initialparams()
testenvironment=Environment()
while np.sum(testenvironment.flag)>0:
    a=testagent.action(testenvironment.state,untrainedparams)
    testenvironment.transition(testagent.action_kinds)
print("Average performance of the agent with finite, discrete action space before training:")
print(np.sum(testenvironment.score))
# Training the agent.
agents=[Agent_Ex1_Discrete()]
environments=[Environment()]
for i in range(7):
    agents.append(Agent_Ex1_Discrete())
    environments.append(Environment())
trainer=A3C(t_max=5,T_max=90000,agents=agents,environments=environments)
print("Training the agent by the A3C algorithm:")
trainedparams=trainer.train()
scorehistory_discrete=trainer.scorehistory.copy()
# Showing how the A3C-trained agent with finite, discrete action space performs.
testagent=Agent_Ex1_Discrete()
testenvironment=Environment()
while np.sum(testenvironment.flag)>0:
    a=testagent.action(testenvironment.state,trainedparams)
    testenvironment.transition(testagent.action_kinds)
print("Average performance of the A3C-trained agent with finite, discrete action space:")
print(np.sum(testenvironment.score))
```

### 試したこと

T_maxを大きめに取ったりはしていますがうまくいってないです



A3Cでcarttpole-v1の学習がうまくいっていない件

### 実現したいこと

kerasでIndexError: tuple index out of rangeが出てしまったので解決したい。

### 前提

pythonのkerasで画像認識を学習中に前述のエラーが出てしまいました。
kerasを始めたばかりで、調べてみても具体的な原因や解決方法がわかりませんでした。

### 発生している問題・エラーメッセージ

```python
2023-11-22 09:12:44.959479: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.
To enable the following instructions: SSE SSE2 SSE3 SSE4.1 SSE4.2 AVX AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
Traceback (most recent call last):
  File "c:\Users\user\Documents\AI\ai_test2.py", line 54, in <module>
    model.fit(x, y, epochs=1)
  File "C:\Users\user\AppData\Local\Programs\Python\Python311\Lib\site-packages\keras\src\utils\traceback_utils.py", line 70, in error_handler
    raise e.with_traceback(filtered_tb) from None
  File "C:\Users\user~1\AppData\Local\Temp\__autograph_generated_file5q6yansm.py", line 15, in tf__train_function
    retval_ = ag__.converted_call(ag__.ld(step_function), (ag__.ld(self), ag__.ld(iterator)), None, fscope)
    ^^^^^
TypeError: in user code:

    File "C:\Users\user\AppData\Local\Programs\Python\Python311\Lib\site-packages\keras\src\engine\training.py", line 1377, in train_function  *       
        return step_function(self, iterator)
    File "C:\Users\user\AppData\Local\Programs\Python\Python311\Lib\site-packages\keras\src\engine\training.py", line 1360, in step_function  **       
        outputs = model.distribute_strategy.run(run_step, args=(data,))
    File "C:\Users\user\AppData\Local\Programs\Python\Python311\Lib\site-packages\keras\src\engine\training.py", line 1349, in run_step  **
        outputs = model.train_step(data)
    File "C:\Users\user\AppData\Local\Programs\Python\Python311\Lib\site-packages\keras\src\engine\training.py", line 1126, in train_step
        y_pred = self(x, training=True)
    File "C:\Users\user\AppData\Local\Programs\Python\Python311\Lib\site-packages\keras\src\utils\traceback_utils.py", line 70, in error_handler       
        raise e.with_traceback(filtered_tb) from None
    File "C:\Users\user\AppData\Local\Programs\Python\Python311\Lib\site-packages\keras\src\engine\base_layer.py", line 2800, in _name_scope
        name_scope += "/"

    TypeError: unsupported operand type(s) for +=: 'Dense' and 'str'

PS C:\Users\user\Documents\AI> & C:/Users/user/AppData/Local/Programs/Python/Python311/python.exe c:/Users/user/Documents/AI/ai_test2.py
2023-11-22 09:13:06.603065: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.
To enable the following instructions: SSE SSE2 SSE3 SSE4.1 SSE4.2 AVX AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
Traceback (most recent call last):
  File "c:\Users\user\Documents\AI\ai_test2.py", line 54, in <module>
    model.fit(x, y, epochs=1)
  File "C:\Users\user\AppData\Local\Programs\Python\Python311\Lib\site-packages\keras\src\utils\traceback_utils.py", line 70, in error_handler
    raise e.with_traceback(filtered_tb) from None
  File "C:\Users\user\AppData\Local\Programs\Python\Python311\Lib\site-packages\tensorflow\python\framework\tensor_shape.py", line 959, in __getitem__ 
    return self._dims[key]
           ~~~~~~~~~~^^^^^
IndexError: tuple index out of range
```

### 該当のソースコード

```python
import keras
from keras.models import Sequential
from keras.layers import Dense
from keras.preprocessing.image import load_img
import numpy as np
import glob

# 'test_data/train/'の中のrock, paper, scissorsディレクトリの中に
# 各5枚ずつ画像が入っている

rps = ['rock/', 'paper/', 'scissors/']

BASE_DIR = 'test_data/train/'

# 学習用データを格納
x = []
# 学習用データに対応するラベルを格納
y = []

# rock, paper, scissorsのラベルはそれぞれ0, 1, 2
for idx, name in enumerate(rps):
    path = BASE_DIR + name + '*.jpg'
    files = glob.glob(path)
    for file in files:
        image = load_img(file)
        image = np.asarray(image)/255.0
        x.append(image)
        y.append(np.asarray(idx))

# モデルを作成
model = Sequential(
    Dense(784, input_shape=(300, 300), activation='relu'),
    Dense(3, activation='softmax')
)

model.compile(
    optimizer='adam',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# 学習中なのでepochsは1
model.fit(x, y, epochs=1)

model.summary()

```

### 試したこと
範囲外を指定している可能を考慮し、
model.fit(x[0:15], y[0:15], epochs=1)
としてみたが以前同じ結果だった。

### 補足情報（FW/ツールのバージョンなど）

```python
>>> tensorflow.__version__
'2.14.0'
>>> keras.__version__ 
'2.14.0'
```


kerasでIndexError: tuple index out of rangeが出てしまったので解決したい。

### 実現したいこと
Llama2に入力するフォーマットに対して、特定の応答トークン以降の文章のみを損失計算の対象とする DataCollatorForCompletionOnlyLM を適切に実行し、ファインチューニングを行いたいと考えています。

### 前提

Google Colab上でKaggleデータセットを使用して、Llama2によるテキスト生成のためのファインチューニングを行っています。データセットを作成した後、SFTTrainerに渡すdata_collatorであるDataCollatorForCompletionOnlyLMの実行中にエラーが発生しています。

### 発生している問題・エラーメッセージ

```
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-9-a1778daa049a> in <cell line: 50>()
     48 
     49 # Train model
---> 50 trainer.train()

7 frames
/usr/local/lib/python3.10/dist-packages/transformers/trainer.py in train(self, resume_from_checkpoint, trial, ignore_keys_for_eval, **kwargs)
   1537             self._inner_training_loop, self._train_batch_size, args.auto_find_batch_size
   1538         )
-> 1539         return inner_training_loop(
   1540             args=args,
   1541             resume_from_checkpoint=resume_from_checkpoint,

/usr/local/lib/python3.10/dist-packages/transformers/trainer.py in _inner_training_loop(self, batch_size, args, resume_from_checkpoint, trial, ignore_keys_for_eval)
   1785 
   1786             step = -1
-> 1787             for step, inputs in enumerate(epoch_iterator):
   1788                 total_batched_samples += 1
   1789                 if rng_to_sync:

/usr/local/lib/python3.10/dist-packages/accelerate/data_loader.py in __iter__(self)
    382         # We iterate one batch ahead to check when we are at the end
    383         try:
--> 384             current_batch = next(dataloader_iter)
    385         except StopIteration:
    386             yield

/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py in __next__(self)
    631                 # TODO(https://github.com/pytorch/pytorch/issues/76750)
    632                 self._reset()  # type: ignore[call-arg]
--> 633             data = self._next_data()
    634             self._num_yielded += 1
    635             if self._dataset_kind == _DatasetKind.Iterable and \

/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py in _next_data(self)
    675     def _next_data(self):
    676         index = self._next_index()  # may raise StopIteration
--> 677         data = self._dataset_fetcher.fetch(index)  # may raise StopIteration
    678         if self._pin_memory:
    679             data = _utils.pin_memory.pin_memory(data, self._pin_memory_device)

/usr/local/lib/python3.10/dist-packages/torch/utils/data/_utils/fetch.py in fetch(self, possibly_batched_index)
     52         else:
     53             data = self.dataset[possibly_batched_index]
---> 54         return self.collate_fn(data)

/usr/local/lib/python3.10/dist-packages/transformers/data/data_collator.py in __call__(self, features, return_tensors)
     43             return self.tf_call(features)
     44         elif return_tensors == "pt":
---> 45             return self.torch_call(features)
     46         elif return_tensors == "np":
     47             return self.numpy_call(features)

/usr/local/lib/python3.10/dist-packages/trl/trainer/utils.py in torch_call(self, examples)
     91 
     92             if response_token_ids_start_idx is None:
---> 93                 raise RuntimeError(
     94                     f'Could not find response key {response_token_ids} in token IDs {batch["labels"][i]}'
     95                 )

RuntimeError: Could not find response key [29871, 13, 2277, 29937, 673, 29901] in token IDs tensor([    1,     1,   835,  ..., 29900, 29929,   491])

```
### 該当のソースコード
※Configやライブラリのバージョンなどの具体的な数値は、文字数制限のため、返答の際に記載したいと思います。
```python:ライブラリ
import os
import torch
import pandas
from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    HfArgumentParser,
    TrainingArguments,
    pipeline,
    logging,
)
from peft import LoraConfig, PeftModel
from trl import SFTTrainer, DataCollatorForCompletionOnlyLM
```
```python:dataset
import pandas as pd
from datasets import Dataset as dt
import re

train_essays = pd.DataFrame(pd.read_csv("/train_essays.csv"))
train_prompts = pd.DataFrame(pd.read_csv("/train_prompts.csv"))
test_essays = pd.DataFrame(pd.read_csv("/test_essays.csv"))
def remove_newline(text):
  return str(text).replace("\n", " ")

train_essays["text"] = train_essays["text"].apply(remove_newline)
merged_df = pd.merge(train_essays, train_prompts, on='prompt_id')
student_df = merged_df[merged_df["generated"] == 0]

def remove_paragraph_numbers(dataframe):
  source_text_pattern = r'\n\n\d+|#|\n\n|\n'
  dataframe["source_text"] = dataframe["source_text"].astype(str).apply(lambda x: re.sub(source_text_pattern, '', x))

  return dataframe

def instruction_dataset(example):
  example["input"] = f'<s>[INST]<<SYS>>\n{example["instructions"]}\n<</SYS>>\n\n{example["source_text"]}[/INST]'
  return example

removed_student_df = remove_paragraph_numbers(student_df)
student_dataset =  dt.from_pandas(removed_student_df[["text", "instructions", "source_text"]])
train_dataset = student_dataset.map(
    instruction_dataset, remove_columns=["instructions", "source_text","__index_level_0__"]
)

def formatting_prompts_func(example):
  output_texts = []
  for i in range(len(example['instructions'])):
    text = f'<s>[INST]<<SYS>>\n{example["instructions"][i]}\n<</SYS>>\n{example["source_text"][i]}\n[/INST]{example["text"][i]}</s>'
    output_texts.append(text)

  return output_texts

```
```python:model_tokenizer
compute_dtype = getattr(torch, bnb_4bit_compute_dtype)

bnb_config = BitsAndBytesConfig(
    load_in_4bit=use_4bit,
    bnb_4bit_quant_type=bnb_4bit_quant_type,
    bnb_4bit_compute_dtype=compute_dtype,
    bnb_4bit_use_double_quant=use_nested_quant,
)


if compute_dtype == torch.float16 and use_4bit:
    major, _ = torch.cuda.get_device_capability()
    if major >= 8:
        print("=" * 80)
        print("Your GPU supports bfloat16: accelerate training with bf16=True")
        print("=" * 80)


model_name = "meta-llama/Llama-2-7b-hf"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map=device_map
)

model.config.use_cache = False
model.config.pretraining_tp = 1

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right" # Fix weird overflow issue with fp16 training
```
```python:train:build_trainer（エラーが発生した部分）
# ここが原因であると考えられます
response_template = "\n[/INST]"
data_collator = DataCollatorForCompletionOnlyLM(response_template, tokenizer=tokenizer)


peft_config = LoraConfig(
    lora_alpha=lora_alpha,
    lora_dropout=lora_dropout,
    r=lora_r,
    bias="none",
    task_type="CAUSAL_LM",
)


training_arguments = TrainingArguments(
    output_dir=output_dir,
    num_train_epochs=num_train_epochs,
    per_device_train_batch_size=per_device_train_batch_size,
    gradient_accumulation_steps=gradient_accumulation_steps,
    gradient_checkpointing=gradient_checkpointing,
    optim=optim,
    save_steps=save_steps,
    logging_steps=logging_steps,
    learning_rate=learning_rate,
    weight_decay=weight_decay,
    fp16=fp16,
    bf16=bf16,
    max_grad_norm=max_grad_norm,
    max_steps=max_steps,
    warmup_ratio=warmup_ratio,
    group_by_length=group_by_length,
    lr_scheduler_type=lr_scheduler_type,
    report_to="tensorboard"
)

trainer = SFTTrainer(
    model=model,
    train_dataset=student_dataset,
    peft_config=peft_config,
    max_seq_length=None,
    tokenizer=tokenizer,
    formatting_func=formatting_prompts_func,
    args=training_arguments,
    data_collator=data_collator,
    packing=packing,
)

trainer.train()
```
### 試したこと
data_collatorを使用せず、formatting_funcのみで実行したところ、ファインチューニングを実行できました。しかし、テキスト生成部分のみの損失に注目したいので、 DataCollatorForCompletionOnlyLMを使用しています。[こちら](https://huggingface.co/docs/trl/sft_trainer#using-tokenids-directly-for-responsetemplate)のhugging_faceのリンクに記載してある**Using token_ids directly for response_template**の項目や、[こちら](https://qiita.com/m__k/items/23ced0db6846e97d41cd)のQiita記事を参考に、以下もコードでも実行してみました。しかし、また異なるエラーが発生してしまいました。公式リファレンスと同じ書式にしても、同様のエラーが発生しました。
```python:エラー該当部分
response_template = "\n[/instr]"
response_template_ids = tokenizer.encode(response_template, add_special_tokens=False)[2:]
data_collator = DataCollatorForCompletionOnlyLM(response_template_ids, tokenizer=tokenizer)

#公式リファレンスの書式
def formatting_prompts_func2(example):
  output_texts = []
  for i in range(len(example['instructions'])):
    text =f"<s>### Instruction: {example['instructions'][i]}\n\n### Source: {example['source_text'][i]}\n\n### Answer: {example['text'][i]}</s>"
    output_texts.append(text)

  return output_texts

response_template = "\n### Answer:"
response_template_ids = tokenizer.encode(response_template, add_special_tokens=False)[2:]
data_collator = DataCollatorForCompletionOnlyLM(response_template_ids, tokenizer=tokenizer)

#以下は同様に実行します
```
```python:エラー
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-11-c8befe0be2b2> in <cell line: 51>()
     49 
     50 # Train model
---> 51 trainer.train()

11 frames
/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_fast.py in _batch_encode_plus(self, batch_text_or_text_pairs, add_special_tokens, padding_strategy, truncation_strategy, max_length, stride, is_split_into_words, pad_to_multiple_of, return_tensors, return_token_type_ids, return_attention_mask, return_overflowing_tokens, return_special_tokens_mask, return_offsets_mapping, return_length, verbose)
    423         )
    424 
--> 425         encodings = self._tokenizer.encode_batch(
    426             batch_text_or_text_pairs,
    427             add_special_tokens=add_special_tokens,

TypeError: TextEncodeInput must be Union[TextInputSequence, Tuple[InputSequence, InputSequence]]
```



Llama-2-7b-hfのファインチューニングにおける、SFTTrainer内のDataCollatorForCompletionOnlyLMのエラーについて

### 実現したいこと

- ある施策(以下施策X)の効果を測定したい

### 前提

商品販売に関する施策Xの効果を測定したいと思っています。
施策Xに効果があるかどうかはまだはっきりと分かっていないのですが、チームの方針的に、一旦停止するということが難しく、施策Xをやらない場合のデータが取れません。また、施策の特性上、全員に対して影響するため、一般的なA/Bテストを行うことができません。また、施策Xは商品ごとに対して影響するものであり、施策Xの影響しない商品と影響する商品があります。

### 取れるデータ
(一部は改変してあります。)

- 日付
- 商品ごとの販売数
- 商品価格
- ポイント還元率
- 施策Xに関する量的変数x

### 考えた方法
一旦時系列データであるということは考慮せず、LightGBMに放り込んでモデルを作成、特徴量の重要度を可視化することで施策Xの効果が判断できると考えました。LightGBMを選択した理由は決定木系であり、どの特徴量が効いているかわかりやすいかなと判断したためです。

### 聞きたいこと
この方法で実現したいことが達成できるのか、他にいいやり方があるか知りたいです。普段はWebアプリケーション開発者として勤務しており、機械学習については、殆ど触ったことがありません。見当違いなことを言っていたら申し訳ありませんが、何卒回答よろしくお願いします。

機械学習を使用した施策の効果測定について

### 実現したいこと

Mask R-CNNで1枚の画像から車を検出をしました．  
**重複して抽出したものをどのように処理するのが一般的か**知りたいです．

### 前提

- 学会で車を検出する深層学習＋画像処理手法の提案をしたい．
- Mask R-CNNは比較手法なので，特別精度を上げたいわけでない．
- Pytorchを使って実装，学習，推論は完了．
- Mask R-CNNがRPN（領域提案ネットワーク）が提案したRoIそれぞれについてマスクを出してくれており，一つの車に対して複数のマスクが出ている．
- 画像には4~18台の車が含まれる．大きく重なっている車もあれば，独立しているものもある．

### お聞きしたいこと

以下のように，**Confidence Score（確信度）が低いものを削除する**のが素直だと思いますが，合っていますでしょうか？

Validationデータで：
1. 閾値t=0.5とする．
1. 閾値以下のConfidence Scoreのマスクを削除する．
1. 残ったマスクは全て抽出されたとして，AP，ARのような指標で評価する．
1. 1~3を様々なtについて繰り返す．

Testデータで：
1. Validationデータで最適だった閾値tを使ってマスクを選別．
1. AP，ARなどで評価する．

他にも以下のようなことが考えられると思います．

- Confidence Scoreでフィルタせず，そのまま使う．
- RPNの提案する領域候補の数を最適化すべき．

Mask R-CNNは比較手法にすぎないので，どこまでやれば専門家から指摘が入らなくなるか，感覚でも良いので教えてほしいです．

よろしくお願い致します．

### 調査したこと・試したこと（追記）

簡単にConfidence Scoreの閾値を変化させて実験しました．

- Confidence Scoreで閾値（t=0.9）で選別すると，しなかったときに比べて，
  - 抽出したマスクの精度が向上する
  - 未抽出の車が増える
- Confidence Scoreで閾値（t=0.2）で選別すると，t=0.5に比べて，
  - 抽出したマスクの精度が低下する
  - 未抽出の車は減る

やはり閾値を変化させることによって，精度は変化しそうです．最適化によってAP，ARのバランスが最適になる値を見つける必要があるのでしょうか．

また調査もしたのですが，

- Mask R-CNNの原論文では，RPNで12,000個を提案し，IoUが0.7以上のものを1つにし，残ったものをさらにNMSで2,000個に減らしている．
- 他のブログとかも20ほど目を通したのですが，抽出結果をどのように選別するのかに言及しているものは見つからず．

という現状です．なにとぞ，回答よろしくお願い致します…!!!

Mask R-CNNで重複して抽出したものに対する処理を知りたいです．

### 実現したいこと

raspberry piについて質問します。
顔認証において目の周りに緑の枠をつけたいのですが、目以外の所にも枠がついてしまい困っています。
以下のurlにおいて、最初のプログラムである「顔と目に枠を描画するプログラム」ではしっかり目に枠がついていまして成功しました。コードはそのままです。
私が枠組みをつけたいのは最後のプログラムである「動画の中で顔を捕捉、追従するプログラム」です。
https://www.pc-koubou.jp/magazine/19205

実行結果は画像を見てください。映しているのはraspberry piの基盤なのですが、なぜか目と認識してしまい緑の枠が表示されてしまいます。

![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-10-31/73cd3977-3175-4ccf-9ea9-ccedd01c9c85.jpeg)

### 該当のソースコード

```python
# -*- coding: utf-8 -*-
import picamera
import picamera.array
import cv2 as cv

# カメラ初期化
with picamera.PiCamera() as camera:
    # カメラの画像をリアルタイムで取得するための処理
    with picamera.array.PiRGBArray(camera) as stream:
        # 解像度の設定
        camera.resolution = (512, 384)

        while True:
            # カメラから映像を取得する（OpenCVへ渡すために、各ピクセルの色の並びをBGRの順番にする）
            camera.capture(stream, 'bgr', use_video_port=True)
            # 顔検出の処理効率化のために、写真の情報量を落とす（モノクロにする）
            grayimg = cv.cvtColor(stream.array, cv.COLOR_BGR2GRAY)

            # 顔検出のための学習元データを読み込む
            face_cascade = cv.CascadeClassifier('haarcascades/haarcascade_frontalface_default.xml')
            # 目検出のための学習元データを読み込む
            eye_cascade = cv.CascadeClassifier('haarcascades/haarcascade_eye.xml')
            # 顔検出を行う
            facerect = face_cascade.detectMultiScale(grayimg, scaleFactor=1.2, minNeighbors=2, minSize=(100, 100))
            # 目検出を行う
            eyerect = eye_cascade.detectMultiScale(grayimg)
            
            # 顔が検出された場合
            if len(facerect) > 0:
                # 検出した場所すべてに赤色で枠を描画する
                for rect in facerect:
                    cv.rectangle(stream.array, tuple(rect[0:2]), tuple(rect[0:2]+rect[2:4]), (0, 0, 255), thickness=3)

            # 目を検出した場合
            if len(eyerect) > 0:
                # 検出した場所すべてに緑色で枠を描画する
                for rect in eyerect:
                    cv.rectangle(stream.array, tuple(rect[0:2]), tuple(rect[0:2]+rect[2:4]), (0, 255, 0), thickness=3)

            # 結果の画像を表示する
            cv.imshow('camera', stream.array)

            # カメラから読み込んだ映像を破棄する
            stream.seek(0)
            stream.truncate()
            
            # 何かキーが押されたかどうかを検出する（検出のため、1ミリ秒待つ）
            if cv.waitKey(1) > 0:
                break

        # 表示したウィンドウを閉じる
        cv.destroyAllWindows()
```

### 試したこと

前のソースコードをもとに、目を認識させるようにプログラムを変更しました。
変更箇所
eye_cascade = cv.CascadeClassifier('haarcascades/haarcascade_eye.xml')
eyerect = eye_cascade.detectMultiScale(grayimg)
if len(eyerect) > 0:
for rect in eyerect:
cv.rectangle(stream.array, tuple(rect[0:2]), tuple(rect[0:2]+rect[2:4]), (0, 255, 0), thickness=3)


opencvの顔認証について

### 実現したいこと

配列での0番目から任意の場所nまで、一動作に消す

### 前提

[1,2,3,4,5,・・・・・・・10000,・・・100000,・・・・]と数万、数十万の数の要素の配列があります。
このうち頭からある場所まで一気に不要になるので一挙に消去したいです。
かつ相当数の数の要素数があるので、高速化の観点を知りたいです。
例えば別途関数でn=計算式=567とだし,567番目まで一挙に削除し
[568,569,570・・・・・・・1000,・・・10000]としたいです。
軽量高速化の観点ではどのような手法が合理的でしょうか？


### 補足情報（FW/ツールのバージョンなど）

python3


配列の一括消去の高速処理

### 実現したいこと

表示される予測期間のグラフがほぼ平坦になってしまいます。
推定された値（auto ARIMA）を見てみましたが、ほぼ数値が変わらない状態になっています。
こういう結果になるのが普通か、あるいは修正する方法があるのかを教えていただきたいです
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-05-23/a21761af-dc78-4f12-b707-faa075e15ec8.png)
### 前提

Google ColabにおいてPythonコードを使って推定を進めています。


### 該当のソースコード

```Python
# ライブラリのインポート
!pip install pmdarima
import pandas as pd
import numpy as np
from scipy import signal
from statsmodels.tsa.seasonal import seasonal_decompose
from statsmodels.tsa.seasonal import STL
from statsmodels.tsa.stattools import adfuller
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
import matplotlib.pyplot as plt
import pmdarima as pm
from pmdarima import utils
from pmdarima import arima
from pmdarima import model_selection
from statsmodels.tsa.statespace.sarimax import SARIMAX
from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_absolute_percentage_error




TOYOTA_stock_Source = pd.read_csv("/content/drive/MyDrive/7203トヨタ自動車株価.csv",  index_col=['日付'], parse_dates=True) 

# 終値の抽出
TOYOTA_stock = TOYOTA_stock_Source['終値']
# データの前処理
TOYOTA_stock = TOYOTA_stock_Source['終値'].str.replace(',', '').astype(float)
#欠損値の置換
TOYOTA_stock_imp_pd = TOYOTA_stock.fillna(TOYOTA_stock.mean())

plt.plot(TOYOTA_stock_imp_pd)

dfr = TOYOTA_stock_imp_pd.pct_change(1).dropna()

# 対数変換後、階差をとったものにADF検定
dftest = adfuller(np.diff(np.log(TOYOTA_stock_imp_pd)))
print('ADF Statistic: %f' % dftest[0])
print('p-value: %f' % dftest[1])

dftest = adfuller(np.diff(np.log(TOYOTA_stock_imp_pd),n=2))
print('ADF Statistic: %f' % dftest[0]) #検定統計量を表示させる
print('p-value: %f' % dftest[1])
print('Critical values :') 
for k, v in dftest[4].items(): #1%,5%,10%信頼区間を表示させている
    print('\t', k, v)

# 対数化後、階差数列化後、季節階差を除いたものにADF検定
dftest = adfuller(pd.DataFrame(np.diff(np.log(TOYOTA_stock_imp_pd))).diff(12).dropna())
print('p-value: %f' % dftest[1])

# 原系列
plot_acf(TOYOTA_stock_imp_pd, lags=20)
plot_pacf(TOYOTA_stock_imp_pd, lags=20)

# 対数化後、階差数列化後、季節階差を除いたもの
syori_dt = pd.DataFrame(np.diff(np.log(TOYOTA_stock_imp_pd))).diff(12).dropna()
acf = plot_acf(syori_dt, lags=20)
pacf = plot_pacf(syori_dt, lags=20)

# データ分割（train:学習データ、test:テストデータ）
train, test = model_selection.train_test_split(TOYOTA_stock_imp_pd, train_size=700)

arima_model = pm.auto_arima(train, 
                            seasonal=True,
                            m = 12,
                            trace=True,
                            n_jobs=-1,
                            maxiter=10)

# 予測
##学習データの期間の予測値
train_pred = arima_model.predict_in_sample()
##テストデータの期間の予測値
test_pred, test_pred_ci = arima_model.predict(
    n_periods=test.shape[0], 
    return_conf_int=True
)

print(test_pred)

# テストデータで精度検証
print('RMSE:')
print(np.sqrt(mean_squared_error(test, test_pred)))
print('MAE:')
print(mean_absolute_error(test, test_pred)) 
print('MAPE:')
print(mean_absolute_percentage_error(test, test_pred))

# グラフ化
fig, ax = plt.subplots()
ax.plot(train[24:].index, train[24:].values, label="actual(train dataset)")
ax.plot(test.index, test.values, label="actual(test dataset)", color="gray")
ax.plot(train[24:].index, train_pred[24:], color="c")
ax.plot(test.index, test_pred, label="auto ARIMA", color="c") 
ax.fill_between(
    test.index,
    test_pred_ci[:, 0],
    test_pred_ci[:, 1],
    color='c',
    alpha=.2)
ax.legend()
```

### 試したこと
データの欠損を埋める方法などを変えてみましたが大きく値が変動しませんでした。

### 補足情報（FW/ツールのバージョンなど）
csvファイルのリンクです。
[トヨタ株価](https://www.dropbox.com/s/4xq6s0shmms1vky/7203%E3%83%88%E3%83%A8%E3%82%BF%E8%87%AA%E5%8B%95%E8%BB%8A%E6%A0%AA%E4%BE%A1.csv?dl=0)
初心者ゆえ抽象的な質問をして申し訳ありません。よろしくお願いします。



ARIMAモデルによる株価の時系列モデル推定

全くの勉強不足で稚拙な質問ご容赦願います。
また、参照先URLの筆者の方にも失礼をご容赦願います。
ごく一例として、
https://supersoftware.jp/tech/20220907/17599/
にてご紹介されている内容なのですが
（他にも同様のものを見たことがあります）、
この一番最後の結果として、
予測値と正解値がほぼ一致していて驚いたのですが、
よく考えると、
predictions = model.predict(x_test)
で予測を実行しているのですが、
x_testには正解値が入っており、
予測のために正解値を使っていると思われ反則と思うのですが、
LSTMとはこういうものなのでしょうか？


KerasのLSTMによる時系列データ予測につきまして

### 実現したいこと

- [ ] はじめてのディープラーニング２（著者：我妻幸長）のGANの実装を完全に実行できるものにしたい。

### 前提

はじめてのディープラーニング２（著者：我妻幸長）のGANの実装を参考にプログラムの修正を図りながら最低限実行できるように修正しましたが、以下のランタイムワーニングに遭遇しました。
ソースコードの修正すべき箇所がありましたら、お手数おかけしますがご指摘よろしくお願い致します。

### 発生している問題

```terminal
gan_.py:134: RuntimeWarning: invalid value encountered in log
  return -np.sum(t*np.log(y+eps) + (1-t)*np.log(1-y+eps)) / len(y)
n_learn: 0
Error_fake: 0.0 Acc_fake: 0.0
Error_fake: nan Acc_fake: 0.1875
n_learn: 1000
Error_fake: 0.0 Acc_fake: 0.0
Error_fake: 11.512925464970229 Acc_fake: 0.0
n_learn: 2000
Error_fake: 0.0 Acc_fake: 0.0
Error_fake: 11.512925464970229 Acc_fake: 0.0
n_learn: 3000
Error_fake: 0.0 Acc_fake: 0.0
Error_fake: 11.512925464970229 Acc_fake: 0.0
n_learn: 4000
Error_fake: 0.0 Acc_fake: 0.0
Error_fake: 11.512925464970229 Acc_fake: 0.0
n_learn: 5000
Error_fake: 0.0 Acc_fake: 0.0
Error_fake: 11.512925464970229 Acc_fake: 0.0
n_learn: 6000
Error_fake: 0.0 Acc_fake: 0.0
Error_fake: 11.512925464970229 Acc_fake: 0.0
n_learn: 7000
Error_fake: 0.0 Acc_fake: 0.0
Error_fake: 11.512925464970229 Acc_fake: 0.0
n_learn: 8000
Error_fake: 0.0 Acc_fake: 0.0
Error_fake: 11.512925464970229 Acc_fake: 0.0
n_learn: 9000
Error_fake: 0.0 Acc_fake: 0.0
Error_fake: 11.512925464970229 Acc_fake: 0.0
n_learn: 10000
Error_fake: 0.0 Acc_fake: 0.0
Error_fake: 11.512925464970229 Acc_fake: 0.0
```

### 該当のソースコード

```python
import numpy as np
from sklearn import datasets
import matplotlib.pyplot as plt


img_size = 8
n_noise=16
eta = 0.001
n_learn=10001
interval = 1000
batch_size = 32

digits_data = datasets.load_digits()
x_train = np.asarray(digits_data.data)
x_train = x_train / 15*2-1
t_train = digits_data.target

class BaseLayer:
    def update(self,eta):
        self.w -= eta * self.grad_w
        self.b -= eta * self.grad_b

class MiddleLayer(BaseLayer):
    def __init__(self,n_upper,n):
        self.w = np.random.randn(n_upper,n) * np.sqrt(2/n_upper)
        self.b = np.zeros(n)
        
    def forward(self,x):
        self.x = x
        self.u = np.dot(x, self.w) + self.b
        self.y = np.where(self.u <= 0,0,self.u)
        
    def backward(self,grad_y):
        delta = grad_y * np.where(self.u <= 0,0,1)
        
        self.grad_w = np.dot(self.x.T,delta)
        self.grad_b = np.sum(delta,axis=0)
        self.grad_x = np.dot(delta,self.w.T)

class GenOutLayer(BaseLayer):
    def __init__(self,n_upper,n):
        self.w = np.random.randn(n_upper,n) / np.sqrt(n_upper)
        self.b = np.zeros(n)
    
    def forward(self,x):
        self.x = x
        u = np.dot(x,self.w) + self.b
        self.y = np.tanh(u)
    
    def backward(self,grad_y):
        delta = grad_y * (1-self.y**2)
        
        self.grad_w = np.dot(self.x.T,delta)
        self.grad_b = np.sum(delta,axis=0)
        self.grad_x = np.dot(delta,self.w.T)

class DiscOutLayer(BaseLayer):
    def __init__(self,n_upper,n):
        self.w = np.random.randn(n_upper,n) / np.sqrt(n_upper)
        self.b = np.zeros(n)
        
    def forward(self,x):
        self.x = x
        u = np.dot(x,self.w) + self.b
        self.y = 1/(1+np.exp(-u))
        
    def backward(self, t):
        delta = self.y - t
        
        self.grad_w = np.dot(self.x.T,delta)
        self.grad_b = np.sum(delta,axis=0)
        self.grad_x = np.dot(delta,self.w.T)

gen_layers = [MiddleLayer(n_noise,32),
              MiddleLayer(32,64),
              GenOutLayer(64,img_size*img_size)]

disc_layers = [MiddleLayer(img_size*img_size,64),
               MiddleLayer(64,32),
               MiddleLayer(32,1)]

def forward_propagation(x,layers):
    for layer in layers:
        layer.forward(x)
        x = layer.y
    return x

def backpropagation(t,layers):
    grad_y = t
    for layer in reversed(layers):
        layer.backward(grad_y)
        grad_y = layer.grad_x
        x = layer.y
    return grad_y

def update_params(layers):
    for layer in layers:
        layer.update(eta)

def get_error(y,t):
    eps = 1e-5
    return -np.sum(t*np.log(y+eps) + (1-t)*np.log(1-y+eps)) / len(y)

def get_accuracy(y,t):
    correct = np.sum(np.where(y<0.5,0,1)==t)
    return correct / len(y)

def train_model(x,t,prop_layers,update_layers):
    y = forward_propagation(x,prop_layers)
    backpropagation(t,prop_layers)
    update_params(update_layers)
    return (get_error(y,t),get_accuracy(y,t))

def generate_images(i):
    n_rows = 16
    n_cols = 16
    noise = np.random.normal(0,1,(n_rows,n_cols,n_noise))
    g_imgs = forward_propagation(noise,gen_layers)
    g_imgs = g_imgs/2 + 0.5
    
    img_size_spaced = img_size+2
    matrix_image = np.zeros((img_size_spaced*n_rows,
                             img_size_spaced*n_cols))
    
    for r in range(n_rows):
        for c in range(n_cols):
            g_img = g_imgs[r,c].reshape(img_size,img_size)
            
            top = r*img_size_spaced
            left = c*img_size_spaced
            matrix_image[top : top+img_size,
                         left : left+img_size] = g_img
    
    plt.figure(figsize=(8,8))
    plt.imshow(matrix_image.tolist(),cmap="Greys_r")
    plt.tick_params(labelbottom=False,labelleft=False,bottom=False,left=False)
    plt.show()

batch_half = batch_size // 2
error_record = np.zeros((n_learn,2))
acc_record = np.zeros((n_learn,2))

for i in range(n_learn):
    noise = np.random.normal(0,1,(batch_half,n_noise))
    imgs_fake = forward_propagation(noise,gen_layers)
    t = np.zeros((batch_half,1))
    error,accuracy = train_model(imgs_fake,t,disc_layers,disc_layers)
    error_record[i][1] = error
    acc_record[i][1] = accuracy
    
    
    rand_ids = np.random.randint(len(x_train),size=batch_half)
    imgs_real = x_train[rand_ids,:]
    t = np.ones((batch_half,1))
    error, accuracy = train_model(imgs_real,t,disc_layers,disc_layers)
    error_record[i][1] = error
    acc_record[i][1] = accuracy
    
    
    noise = np.random.normal(0,1,(batch_size,n_noise))
    t = np.ones((batch_size,1))
    train_model(noise,t,gen_layers+disc_layers,gen_layers)
    
    if i % interval == 0:
        print("n_learn:",i)
        print("Error_fake:",error_record[i][0],
              "Acc_fake:",acc_record[i][0])
        print("Error_fake:",error_record[i][1],
              "Acc_fake:",acc_record[i][1])
        generate_images(i)

```

### 補足情報（FW/ツールのバージョンなど）

Python 3.10.0
numpy 1.21.0
matplotlib 3.7.0


はじめてのディープラーニング２（著者：我妻幸長）のGANの実装でWarning

### 実現したいこと

y=sin(x)を[0,2π]の区間で学習する

### 前提

Pythonでy=sin(x)を学習するプログラムを作っています
データ数は20、それを正規化し±0.001%の誤差を加えて3倍のデータ拡張を行っています

### 発生している問題・エラーメッセージ

```
valの損失関数がどうしても下がらないです
```

### 該当のソースコード

```Pyhon
import numpy as np
import matplotlib.pyplot as plt
from tqdm.auto import tqdm
from collections import OrderedDict

class Adam:

    def __init__(self, lr=0.01, beta1=0.9, beta2=0.999):
        self.lr = lr
        self.beta1 = beta1
        self.beta2 = beta2
        self.iter = 0
        self.m = None
        self.v = None
        
    def update(self, params, grads):
        if self.m is None:
            self.m, self.v = {}, {}
            for key, val in params.items():
                self.m[key] = np.zeros_like(val)
                self.v[key] = np.zeros_like(val)
        
        self.iter += 1
        lr_t  = self.lr * np.sqrt(1.0 - self.beta2**self.iter) / (1.0 - self.beta1**self.iter)         
        
        for key in params.keys():
            #self.m[key] = self.beta1*self.m[key] + (1-self.beta1)*grads[key]
            #self.v[key] = self.beta2*self.v[key] + (1-self.beta2)*(grads[key]**2)
            self.m[key] += (1 - self.beta1) * (grads[key] - self.m[key])
            self.v[key] += (1 - self.beta2) * (grads[key]**2 - self.v[key])
            
            params[key] -= lr_t * self.m[key] / (np.sqrt(self.v[key]) + 1e-7)

            
class Affine:
    def __init__(self, W, b):
        self.W = W
        self.b = b
        
        self.x = None
        self.original_x_shape = None
        # 重み・バイアスパラメータの微分
        self.dW = None
        self.db = None

    def forward(self, x):
        # テンソル対応
        self.original_x_shape = x.shape
        x = x.reshape(x.shape[0], -1)
        self.x = x
        out = np.dot(self.x, self.W) + self.b

        return out

    def backward(self, dout):
        dx = np.dot(dout, self.W.T)
        self.dW = np.dot(self.x.T, dout)
        self.db = np.sum(dout, axis=0)
        dx = dx.reshape(*self.original_x_shape)  # 入力データの形状に戻す（テンソル対応）
        
        return dx

class Relu:
    def __init__(self):
        self.mask = None

    def forward(self, x):
        self.mask = (x <= 0)
        out = x.copy()
        out[self.mask] = 0
        
        return out

    def backward(self, dout):
        dout[self.mask] = 0
        dx = dout
        
        return dx
    
class Mseloss:
    def __init__(self):
        self.loss = None
        self.y = None 
        self.t = None #target

    def forward(self, x, t):
        self.t = t
        self.y = x
        self.loss = sum_squared_error(self.y, self.t)
        
        return self.loss

    def backward(self, dout=1):
        batch_size = self.t.shape[0]
        if self.t.size == self.y.size: #targetデータがone-hot-vectorの場合
            dx = (self.y - self.t) / batch_size
        else:
            dx = self.y.copy()
            dx[np.arange(batch_size), self.t] -= 1
            dx = dx / batch_size
        
        return dx
    
    
class TwoLayerNet:

    def __init__(self, input_size, hidden_size, output_size, weight_init_std = 0.01):
        # 重みの初期化
        self.params = {}
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, hidden_size) 
        self.params['b2'] = np.zeros(hidden_size)
        self.params['W3'] = weight_init_std * np.random.randn(hidden_size, hidden_size)
        self.params['b3'] = np.zeros(hidden_size)
        self.params['W4'] = weight_init_std * np.random.randn(hidden_size, output_size)
        self.params['b4'] = np.zeros(output_size)

        # レイヤの生成
        self.layers = OrderedDict()
        self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1'])
        self.layers['activation function1'] = Relu()
        self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])
        self.layers['activation function2'] = Relu()
        self.layers['Affine3'] = Affine(self.params['W3'], self.params['b3'])
        self.layers['activation function3'] = Relu()
        self.layers['Affine4'] = Affine(self.params['W4'], self.params['b4'])
        self.lastLayer = Mseloss()
        
    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)
        
        return x
        
    # x:入力データ, t:target
    def loss(self, x, t):
        y = self.predict(x)
        return self.lastLayer.forward(y, t)
    

    def gradient(self, x, t):
        # forward
        self.loss(x, t)

        # backward
        dout = 1
        dout = self.lastLayer.backward(dout)
        
        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)

        # 設定
        grads = {}
        grads['W1'], grads['b1'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
        grads['W2'], grads['b2'] = self.layers['Affine2'].dW, self.layers['Affine2'].db
        grads['W3'], grads['b3'] = self.layers['Affine3'].dW, self.layers['Affine3'].db
        grads['W4'], grads['b4'] = self.layers['Affine4'].dW, self.layers['Affine4'].db

        return grads

def sum_squared_error(y, t):
    return 0.5 * np.sum((y-t)**2)

def min_max(x,x_min,x_max,axis=None):
    x_normalized = (x-x_min)/(x_max-x_min)
    return x_normalized

def re_min_max(x_normalized,x_min,x_max,axis=None):
    re_normalized = x_normalized*(x_max-x_min)+x_min
    return re_normalized

x = np.random.uniform(0,2*np.pi, 20)

#データの分割
x_train = x[0:int(len(x)*0.6)]
x_val   = x[int(len(x)*0.6):int(len(x)*0.9)]
x_test  = x[int(len(x)*0.9):int(len(x))]

#最小・最大の獲得
x_train_min = x_train.min()
x_train_max = x_train.max()

x_val_min = x_val.min()
x_val_max = x_val.max()

x_test_min = x_test.min()
x_test_max = x_test.max()

#教師データの作成
t_train = np.sin(x_train)
t_val = np.sin(x_val)
t_test = np.sin(x_test)

t_train_copy1 = np.copy(t_train)
t_train_copy2 = np.copy(t_train)
t_train = np.concatenate([t_train,t_train_copy1,t_train_copy2])

t_val_copy1 = np.copy(t_val)
t_val_copy2 = np.copy(t_val)
t_val = np.concatenate([t_val,t_val_copy1,t_val_copy2])

t_test_copy1 = np.copy(t_test)
t_test_copy2 = np.copy(t_test)
t_test = np.concatenate([t_test,t_test_copy1,t_test_copy2])

#入力データの正規化
x_train_normalized = min_max(x_train,x_train_min,x_train_max)
x_val_normalized = min_max(x_val,x_val_min,x_val_max)
x_test_normalized = min_max(x_test,x_test_min,x_test_max)

#誤差を加える(""変えるとこ"")
gosaritsu = 0.001
for i in range(x_train.shape[0]):
    z = np.random.uniform([0],[gosaritsu],[1])
    x_train_plus_error = x_train_normalized+z
    x_train_minus_error = x_train_normalized-z
    
    z = np.random.uniform([0],[gosaritsu],[1])
    x_val_plus_error = x_val_normalized+z
    x_val_minus_error = x_val_normalized-z
    
    z = np.random.uniform([0],[gosaritsu],[1])
    x_test_plus_error = x_test_normalized+z
    x_test_minus_error = x_test_normalized-z
    
#入力データの連結
x_train = np.concatenate([x_train_normalized,x_train_plus_error,x_train_minus_error])

x_val = np.concatenate([x_val_normalized,x_val_plus_error,x_val_minus_error])

x_test = np.concatenate([x_test_normalized,x_test_plus_error,x_test_minus_error])

train_size = x_train.shape[0]
val_size = x_val.shape[0]
test_size = x_test.shape[0]

train_loss_list = []
val_loss_list = []
test_loss_list = []

network = TwoLayerNet(input_size=1, hidden_size=40, output_size=1)
iters_num = 6000 # 繰り返しの回数を適宜設定する
data_divs = 5
batch_size = int(len(x_train) / data_divs) # 実際は2^nにするのが普通
optimizer = Adam()

for i in tqdm(range(iters_num)):
  
    batch_mask_train = np.random.choice(train_size, batch_size)
    batch_mask_val = np.random.choice(val_size, batch_size)
    batch_mask_test = np.random.choice(test_size, batch_size)
    
    x_batch_train = x_train[batch_mask_train]
    x_batch_val = x_val[batch_mask_val]
    x_batch_test = x_test[batch_mask_test]
    
    x_batch_train = np.reshape(x_batch_train, (batch_size,1))
    x_batch_val = np.reshape(x_batch_val, (batch_size,1))
    x_batch_test = np.reshape(x_batch_test, (batch_size,1))
    
    
    t_batch_train = t_train[batch_mask_train]
    t_batch_train = np.reshape(t_batch_train, (batch_size,1))
    
    t_batch_val = t_val[batch_mask_val]
    t_batch_val = np.reshape(t_batch_val, (batch_size,1))
    
    t_batch_test = t_test[batch_mask_test]
    t_batch_test = np.reshape(t_batch_test, (batch_size,1))
    
    # 勾配の計算
    grad = network.gradient(x_batch_train, t_batch_train)
    
    # パラメータの更新
    params = network.params
    optimizer.update(params, grad)
    
    loss_train = network.loss(x_batch_train, t_batch_train)
    loss_val = network.loss(x_batch_val, t_batch_val)
    loss_test = network.loss(x_batch_test, t_batch_test)
    
    train_loss_list.append(loss_train)
    val_loss_list.append(loss_val)
    test_loss_list.append(loss_test)
    
pre_train = network.predict(x_train)
pre_val = network.predict(x_val)
pre_test= network.predict(x_test)

re_x_train = re_min_max(x_train,x_train_min,x_train_max)
re_x_val = re_min_max(x_val,x_val_min,x_val_max)
re_x_test = re_min_max(x_test,x_test_min,x_test_max)

X = np.arange(0,2*np.pi, 0.01)
Y = np.sin(X)

plt.plot(re_x_train,pre_train,marker='.',ls='',color="red", label='pre_train')
plt.plot(re_x_val,pre_val,marker='.',ls='',color="green", label='pre_val')
plt.plot(X,Y,marker='',ls='-',color="blue", label='x=^2')
plt.grid()
plt.xlabel('x',fontsize='16')
plt.ylabel('y_pred',fontsize='16')
plt.legend(edgecolor='k',fontsize='16')
plt.show()
plt.close()

plt.plot(train_loss_list,color="blue",label="train_loss")
plt.plot(val_loss_list,color="red",label="val_loss")
plt.yscale('log')
plt.grid()
plt.legend(edgecolor='k',fontsize='16')
plt.show()
plt.close()
```

### 試したこと

ハイパーパラメータをある程度いじってみたりしたのですが改善が見られませんでした。

### 補足情報（FW/ツールのバージョンなど）
Python3.0
