常連

### 前提・実現したいこと

質問1: LSTMの隠れ層について
質問2: LSTMのパラメータについて．


私は，LSTMへ時系列画像の特徴量を入力して時系列画像のクラス分類を行いたいです．
ここでLSTMへ時系列特徴を入力するところまでは実装済みです．

以下で例として,LSTMへの入力時系列特徴を(3,10,1)とします．
（バッチサイズ，時系列画像のフレーム数，1フレームに対する一次元特徴量）です．
つまり，10枚の連続する画像からそれぞれ一つずつ特徴量を抽出，それが3セットとします．


ここでLSTMへ入力するとき，LSTMを時間方向に展開した図(ネット上などによくある図)で構造を理解していました．つまり，例に示すデータでは，一つの入力動画像の長さが10なのでt=1~t=10まで．
つまりLSTMの隠れ層は10であると思っていましたが，色々調べて見ると64であったり256であったり．．

ここで質問ですが，隠れ層の数は時系列データの数(上記では動画像の長さ=10)と一致するものではないのですか？


また，質問2としてLSTMモデルのパラメータ数です．
これも質問1の通り，私がLSTMの構造をよく理解できていないので起こる
質問なのですが，こちらのサイト（https://qiita.com/Phoeboooo/items/b92c35f6739a9e765a80）
でパラメータ数の数え方について学びました．
こちらのLSTMの項で多分，長さ20の32次元特徴量を入力としていると思います．
しかし，パラメータの数え方で入力に対しての重み32*64*4の32*64の部分がわかりません．
私の中では，一つの隠し層に一つの時間(t=1~20のどれか)が入力するという認識だったので，
隠し層64に長さ20のデータを入力するという考え方がよくわかりません．



すみません，文が長くなってしまいましたが考え方で誤っているところを教えて頂けたら嬉しいです．
また，何か質問がある方もコメントして頂けたらその部分の説明をしたいと思います．
よろしくお願いします．



＜追記＞
model = Sequential()
model.add(LSTM(64,input_shape=(10,1024)))
model.add(Dense(output_dim, activation="linear"))

LSTMの隠れ層の理解とパラメータについて

DNN分野では「End-to-end training」という言葉がよく出てきますが、
公式的な解釈はなく、個別な解釈を読んでも、分かるような分からないような気分です。

原因は恐らく反対の概念**「End-to-endではないtraining」**は何ですか
というのは分かっていないためかなと思います。

どなたかご解釈いただけませんか。

「End-to-end training」 とは？

## テーマ、知りたいこと

深層学習における学習データやテストデータの増やし方について教えてください。
Data Augumentation ではありません。

## 背景、状況

　現在、自己データを用いた「物体検出」タスクに取り組んでいます。まず、ある程度の量のデータを用意して、学習用、テスト用、検証用に分割しデータセットAとします。モデルを学習して評価を行い、モデルの精度が判明しました。

　この後、モデルの精度を向上させたいので、追加でデータを収集しました。新たに収集したデータの量は、前回に比べて少なかったとします。このデータを同じように学習用、テスト用、検証用に分割してデータセットBとします。学習にはデータセットA＋Bとしてデータを用いて学習を行い。以下の表の用な結果が出ました（数値は適当）。

|| 学習データA(mAP)| 学習データA+B(mAP)|
|-|-|-|
|テストデータA|90%|85%|
|テストデータB|80%|90%|
|テストデータA+B|85%|80%|

　期待していた結果としてはテストデータA+Bでの精度が向上している状態でしたが、期待した結果は得られませんでした。このような結果になった理由としては追加したデータが少なかったため、テストデータA＋Bのデータ内のデータセットAのテストデータの比率が高かったことが考えられます。このような場合はテストデータAとテストデータBの比率が同じになるようにするか、そもそも追加するデータの量を前回のデータの量と同じだけ収集することが必要ではないかと考えております。

　このような場合でのデータセットの増やし方を教えていただけませんでしょうか？



深層学習におけるデータセットの増やし方（not拡張)について教えてください。

### 前提・実現したいこと

DCGAN-tensorflow-masterをダウンロードし自前の画像を使って学習させ、新しく画像生成を行いたいのですがうまくいきません。
サンプルの実行は成功しました。
初めて質問するので情報が不足しているかもしれません。
お答えいただける範囲で教えていただけると幸いです。
よろしくお願いします。

### 発生している問題・エラーメッセージ
```ここに言語を入力
raise TypeError("Cannot handle this data type: %s, %s" % typekey)
TypeError: Cannot handle this data type: (1, 1, 3), <f8
```

```
エラーメッセージ

Traceback (most recent call last):
File "main.py", line 147, in <module>
tf.app.run()
File "/Users/shimauchi_namiki/Library/Python/3.6/lib/python/site-packages/tensorflow/python/platform/app.py", line 126, in run
_sys.exit(main(argv))
File "main.py", line 120, in main
dcgan.train(FLAGS)
File "/Users/shimauchi_namiki/DCGAN-tensorflow-master/model.py", line 195, in train
grayscale=self.grayscale) for sample_file in sample_files]
File "/Users/shimauchi_namiki/DCGAN-tensorflow-master/model.py", line 195, in <listcomp>
grayscale=self.grayscale) for sample_file in sample_files]
File "/Users/shimauchi_namiki/DCGAN-tensorflow-master/utils.py", line 44, in get_image
resize_height, resize_width, crop)
File "/Users/shimauchi_namiki/DCGAN-tensorflow-master/utils.py", line 102, in transform
resize_height, resize_width)
File "/Users/shimauchi_namiki/DCGAN-tensorflow-master/utils.py", line 94, in center_crop
im = Image.fromarray(x[j:j+crop_h, i:i+crop_w])
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/PIL/Image.py", line 2716, in fromarray
raise TypeError("Cannot handle this data type: %s, %s" % typekey)
TypeError: Cannot handle this data type: (1, 1, 3), <f8

```


### 該当のソースコード
```ここに言語を入力
python3 main.py --dataset water --input_height=128 --output_height=128 --train --crop
```

 

### 試したこと

DCGAN-tensorflow-masterをダウンロードしました。そこにdataフォルダを作り、その中に学習させる画像を128×128のサイズに加工したものをwaterというフォルダに入れました。その後以下のコードを実行しました。
python3 main.py --train --dataset water --input_height 128 --output_height 128 --crop
Macのターミナルで実行しました。
### 補足情報（FW/ツールのバージョンなど）

ここにより詳細な情報を記載してください。

TypeError: Cannot handle this data type: (1, 1, 3), <f8 を解決したい

resnetベースで転移学習を行おうとしています。(torchvisionのmodelを使用)
resnet含むImagenet系のモデルを扱う場合、入力サイズを224×224にする必要がある、との記載をよく見るのですが、
サイズを合わせなくても学習/推定が実行でき、かつ、それなりに良い学習ができています。
resizeする時間がもったいないので可能であれば入力サイズを整えずに学習したいのですが、
処理が不明なため判断がついていません。

画像サイズが224×224でない場合、どのような処理を実行しているのでしょうか？
また、どのような問題が発生する可能性があるのでしょうか？
・内部でリサイズしている
・入力画像が小さい場合は、ゼロパディングしている。
・入力画像が大きい場合は、ランダムクロップしている。
など

Resnet 画像サイズが224×224以外の場合の処理

### 前提・実現したいこと
yolov5を用いて物体検出をしたい。
### 教えていただきたいこと
学習時に以下のエラーメッセージが表示され、学習がストップしてしまう。
```
CUDA out of memory. Tried to allocate 12.50 MiB (GPU 0; 10.92 GiB total capacity; 8.57 MiB already allocated; 9.28 GiB free; 4.68 MiB cached)
```

### 該当のソースコード

```ここに言語名を入力
python train.py --img 640 --batch 32 --epochs 100 --data training/dataset.yaml --cfg training/yolov5x-custom.yaml --weights 'yolov5x.pt '
```

### 試したこと
・海外のサイトを読んだのですが、どう具体的にGPUの容量を減らしているのか分からなかったです。
・batch数を16に変更すると学習するのですが、損失関数の値が大きくなってしまいます。
・他のyolov5l.ptの場合、batch数32のエポック数100でも学習はできましたが、損失関数のグラフが横ばいになってしまいます。

### 補足情報（FW/ツールのバージョンなど）

参考サイト：
yolov5：https://github.com/ultralytics/yolov5.git
CUDA out of memoyの対策：https://github.com/pytorch/pytorch/issues/16417

yolov5の学習時に「CUDA out of memory」とエラー表示される

Pythonで機械学習のコードを書いているのですが、
下記のエラーが発生しており、うまく実行できません。
予測結果を取得　のところで、

AttributeError: 'Sequential' object has no attribute 'predict_classes'

というエラーがでます。
対処方法わかる方がいらっしゃれば教えていただけますでしょうか。
コードは下記の通りです。
よろしくお願いいたします。

```python

# 予測結果を取得
y_pred = model.predict_classes(X_test)

# 混同行列を作成pa
cnf_matrix = confusion_matrix(y_test, y_pred)

# 混同行列を描画
sns.heatmap(cnf_matrix, annot=True, fmt='d', cmap='summer')
plt.xlabel("prediction")
plt.ylabel("target")
plt.show()

```

```python
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-131-3f14d059f4b0> in <module>()
      1 # 予測結果を取得
----> 2 y_pred = model.predict_classes(X_test)
      3 
      4 # 混同行列を作成
      5 cnf_matrix = confusion_matrix(y_test, y_pred)

AttributeError: 'Sequential' object has no attribute 'predict_classes'
```



```Python
# 数値計算用ライブラリ numpy をインポート
import numpy as np

# データフレームを提供するライブラリ pandas をインポート
import pandas as pd

# 機械学習用ライブラリ sklearn（scikit-learn）内にあるライブラリ  から
# モデル構築（訓練用）/検証データ分割用メソッド train_test_split をインポート
from sklearn.model_selection import train_test_split

# 自分のデータを読み込むために便利なメソッドをインポート
import os
import re
from tensorflow.keras.preprocessing.image import array_to_img, img_to_array, load_img

# ディープラーニング用フレームワーク、TensorFlow のラッパーである
# keras をインポート
from tensorflow.keras.models import Sequential, Model, load_model
from tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, Flatten, Dropout, BatchNormalization, Activation
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# 描画用ライブラリをインポート
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib import gridspec, cm

# 混合行列作成用メソッド confusion_matrix をインポート
from sklearn.metrics import confusion_matrix

def list_pictures(directory, ext='jpg|jpeg|bmp|png|ppm'):
    return [os.path.join(root, f)
            for root, _, files in os.walk(directory) for f in files
            if re.match(r'([\w]+.(?:' + ext + '))', f.lower())]
```
```ここに言語を入力
#モデルの構造を定義
def define_model():
  model = Sequential()
  model.add(BatchNormalization(input_shape=(96, 96, 3)))
  model.add(Conv2D(filters=32, kernel_size=(3,3), strides=(1,1)))
  model.add(BatchNormalization())
  model.add(Activation('relu'))
  model.add(Conv2D(filters=32, kernel_size=(3,3), strides=(1,1)))
  model.add(BatchNormalization())
  model.add(Activation('relu'))
  model.add(MaxPool2D(pool_size=(2,2)))
  model.add(Dropout(0.2))

  model.add(Conv2D(filters=64, kernel_size=(3,3), strides=(1,1)))
  model.add(BatchNormalization())
  model.add(Activation('relu'))

  model.add(Conv2D(filters=64, kernel_size=(3,3), strides=(1,1)))
  model.add(BatchNormalization())
  model.add(Activation('relu'))
  
  model.add(Conv2D(filters=64, kernel_size=(3,3), strides=(1,1)))
  model.add(BatchNormalization())
  model.add(Activation('relu'))
  model.add(MaxPool2D(pool_size=(2,2)))
  model.add(Dropout(0.2))

  model.add(Flatten())

  model.add(Dense(256, activation="relu"))
  model.add(Dropout(0.2))
  model.add(Dense(256, activation="relu"))
  model.add(Dropout(0.2))
  model.add(Dense(2, activation='softmax'))

  return model

model = define_model()
```

```Python
model.compile(loss='sparse_categorical_crossentropy', optimizer=Adam(lr=0.005), metrics=['sparse_categorical_accuracy'])

```

```Python

datagen = ImageDataGenerator(rotation_range=30, width_shift_range=0.3, height_shift_range=0.3, horizontal_flip=True)
datagen.fit(X_train)

#　訓練を実行（訓練しながら ImageDataGenerator が機能し、Data Augumentation を行っている）
batch_size = 10
valid_samples = 25
train_samples = len(X_train) - valid_samples
mc = ModelCheckpoint("cnn_model_02.h5", monitor="val_loss", save_best_only=True, verbose=1)
es = EarlyStopping(monitor='val_loss', patience=15)
hist = model.fit_generator(datagen.flow(X_train[:train_samples], y_train[:train_samples], batch_size=batch_size),
                           steps_per_epoch= train_samples / batch_size,
                           epochs=40,
                           callbacks=[mc, es],
                           validation_data=datagen.flow(X_train[-valid_samples:], y_train[-valid_samples:], batch_size=batch_size),
                           validation_steps=valid_samples / batch_size)
```

'Sequential' object has no attribute 'predict_classes'　Pythonエラーの解決

pythonで機械学習、深層学習によって宝くじ当選番号予測プログラム　ロト7Versionを作っています。
参考資料は[こちら](https://www.microstone.info/ai技術で宝くじ当選番号を予測、億万長者の夢を実/)
（実行時は時間短縮のためself.epochsを1にしています。）

整理整頓しました。

質問
個人的にパラメータの部分がよくわからないのですが、コメントのような理解でよろしいでしょうか？self.units = 6これについては何の意味があるのか　単位？単位が6？

ロト７のcsvは[こちら](https://loto7.thekyo.jp/download/index)からダウンロードしています。ボーナス数字以下については使わないため、削除しています。


```python
#各インポート宣言
#numpy 数値計算を効率的に行うためのライブラリ
#pandas データ分析を効率的に行うためのライブラリ
#tflearn 深層学習ライブラリ
#time 時刻に関するさまざまな関数を提供
#itertools 効率的なループ実行のためのイテレータ生成関数
#sklearn 機械学習ライブラリ
#preprocessing 前処理用のライブラリ
import numpy as np
import pandas as pd
import tflearn
import time
import itertools
from sklearn import preprocessing

#予測LSTMクラス
class PredictionLSTM:
    def __init__(self):
        #LSTM訓練パラメータ
        #steps_of_history いくつ前のデータまでを学習に用いるか
        #steps_of_history いくつ先のデータを予測するか
        #units よくわからない
        #epochs 一つの訓練データを何回繰り返して学習させるか
        #batch_size バッチサイズ
        self.steps_of_history = 10
        self.steps_of_future = 1
        self.units = 6
        self.epochs = 1
        self.batch_size = 1

     #データセット作成
    def create_dataset(self,data):
        x,y = [],[]
        for i in range(0,len(data) - self.steps_of_history,self.steps_of_future):
            a = i + self.steps_of_history
            x.append(data[i:a])
            y.append(data[a])
        x = np.reshape(np.array(x),[-1,self.steps_of_history,1])
        y = np.reshape(np.array(y),[-1,1])
        return x,y

        #予測データ作成
    def create_predict_dataset(self,data):
        latest_x = np.array([data[-self.steps_of_history:]])
        latest_x = np.reshape(latest_x,(-1,self.steps_of_history,1))
        return latest_x

    #訓練評価データ分割
    def split_dataset(self,x,y,test_size=0.1):
        pos = round(len(x) * (1 - test_size))
        train_x,train_y = x[:pos],y[:pos]
        test_x,test_y = x[pos:],y[pos:]
        return train_x,train_y,test_x,test_y

    #モデル作成
    def _create_model_by_tflearn(self):
        net = tflearn.input_data(shape=[None,self.steps_of_history,1])

        #LSTM
        net = tflearn.lstm(net,n_units = self.units)

        net = tflearn.fully_connected(net,1,activation = "linear")
        net = tflearn.regression(net,optimizer = "adam",learning_rate = 0.001,loss = "mean_square")

        model = tflearn.DNN(net,tensorboard_verbose = 0)

        return model

    #訓練
    def train(self,train_x,train_y):
        model = self._create_model_by_tflearn()
        model.fit(train_x,train_y,validation_set = 0.1,batch_size = self.batch_size,n_epoch = self.epochs)

        return model

    #予測
    def predict(self,model,data):
        return model.predict(data)

    #評価誤差アルゴリズム
    def rmse(self,y_pred,y_true):
        return np.sqrt(((y_true - y_pred) ** 2).mean())

    def rmsle(self,y_pred,y_true):
        return np.sqrt(np.square(np.log(y_true + 1) - np.log(y_pred + 1)).mean())

    def mae(self,y_pred,y_true):
        return np.mean(np.abs((y_true - y_pred)))

    def mape(self,y_pred,y_true):
        return np.mean(np.abs((y_true - y_pred) / y_true)) * 100

#メイン処理
if __name__ == "__main__":

    #処理の速さを図る
    START_TIME = time.time()

    #1~37までの数字を用意
    a = {m for m in range(1,38)}
    d = {tuple(p): i for i, p in enumerate(itertools.combinations(a,7))}
    e = {v: k for k, v in d.items()}

    dataframe = pd.read_csv("./loto7.csv",encoding='cp932')
    dataframe = dataframe[["第1数字","第2数字","第3数字","第4数字","第5数字","第6数字","第7数字"]]
    data = dataframe.index.map(
        lambda _:d[ tuple(sorted(
            [(dataframe.第1数字[_]),
            (dataframe.第2数字[_]),
            (dataframe.第3数字[_]),
            (dataframe.第4数字[_]),
            (dataframe.第5数字[_]),
            (dataframe.第6数字[_]),
            (dataframe.第7数字[_])
            ]
            ))
            ]
        )
    data = data.values.reshape(data.shape[0], 1).astype(dtype=np.float32)

    #正規化
    #データが0~1に入るよう変換
    #fit_transform()について
    #fit()を実施した後に、同じデータに対してtransform()を実施する
    #fit()とは
    #渡されたデータの最大値、最小値、平均、標準偏差、傾き...などの統計を取得して、内部メモリに保存する
    #transform()とは
    #fit()で取得した統計情報を使って、渡されたデータを実際に書き換える
    scaler = preprocessing.MinMaxScaler()
    data = scaler.fit_transform(data)

    #LSTMインスタンス作成
    lstm = PredictionLSTM()

    #訓練,評価データ作成
    #create_datasetの処理を正規化したデータを用いてx,yに代入
    #split_datasetの処理をx,yを用いて訓練、評価データに代入
    x,y = lstm.create_dataset(data)
    train_x,train_y,test_x,test_y = lstm.split_dataset(x,y)

    #訓練
    #trainの処理を作成したtrain_x,train_yを使って行い、結果をmodelに代入
    model = lstm.train(train_x,train_y)

    #評価
    #訓練予測にpredictの処理を訓練したデータとtrain_xを用いて行う
    #評価予測にpredictの処理を訓練したデータとtest_xを用いて行う
    train_predict = lstm.predict(model,train_x)
    test_predict = lstm.predict(model,test_x)

    #RMSE(Root Mean Squared Error) この値が小さければ小さいほど、誤差の小さいモデルである
    #訓練誤差にrmseの処理をtrain_yと訓練予測データを用いて行う
    #評価誤差にrmseの処理をtest_yと評価予測データを用いて行う
    #Train ScoreとTest Scoreを出力
    train_score = lstm.rmse(train_y,train_predict)
    test_score = lstm.rmse(test_y,test_predict)
    print("Train Score: {0:.3f} RMSE".format(train_score))
    print("Test Score: {0:.3f} RMSE".format(test_score))

    #予測
    #latest_xにcreate_predict_datasetの処理を正規化したデータを用いて行う
    #次の予測に訓練データをlatest_xを用いて行う
    #予測に正規化のinverse_transformを”次の予測”を用いて行う
    latest_x = lstm.create_predict_dataset(data)
    next_prediction = model.predict(latest_x)
    next_prediction = scaler.inverse_transform(next_prediction)
    #予測結果を出力
    print("次の当選番号の予測は: {}".format(e[np.round(next_prediction[0][0])]))

    #測定時間を出力
    print("時間: {0:.1f}sec".format(time.time() - START_TIME))
```