常連

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

「End-to-end training」 とは？

### 前提・実現したいこと

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以外の場合の処理

### 前提・実現したいこと

質問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の隠れ層の理解とパラメータについて

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

Python AI　宝くじ当選番号予測　ロト7

CUDAでGPUを使用した機械学習を実行しています。

#### 知りたいこと
"nvidia-smi"コマンドで、GPUの状態を確認したところ、

- GPU Memory UsageがN/Aになってしまう　->  表示させる方法はあるでしょうか？
- Process nameのパスが省略される　-> フルパスを表示させる方法はあるでしょうか？

一通り調べましたが、それらしいやり方が分からず。
継続して調べますが お知恵をお貸しいただける方がいらっしゃればと思い質問を立てました。

尚、環境は下記です。
`Windows 10`
`GeForce GTX 1650`

********
#### NVIDIA-SMIコマンドの出力画面

```
C:\Users\koyamashinji>nvidia-smi
Sun Nov 29 09:04:35 2020
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 445.87       Driver Version: 445.87       CUDA Version: 11.0     |
|-------------------------------+----------------------+----------------------+
| GPU  Name            TCC/WDDM | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX 1650   WDDM  | 00000000:08:00.0  On |                  N/A |
| 50%   31C    P8     8W /  75W |    506MiB /  4096MiB |      1%      Default |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU                  PID   Type   Process name                  GPU Memory |
|                                                                  Usage      |
|=============================================================================|
|    0                 1164    C+G   Insufficient Permissions        N/A      |
|    0                 2140    C+G   ...8bbwe\Microsoft.Notes.exe    N/A      |
|    0                 3188    C+G   C:\Windows\explorer.exe         N/A      |
|    0                 4492    C+G   ...me\Application\chrome.exe    N/A      |
|    0                 6156    C+G   ...artMenuExperienceHost.exe    N/A      |
|    0                 6488    C+G   ...w5n1h2txyewy\SearchUI.exe    N/A      |
|    0                 7156    C+G   ...ekyb3d8bbwe\YourPhone.exe    N/A      |
|    0                 7844    C+G   ...y\ShellExperienceHost.exe    N/A      |
|    0                 8840    C+G   ...LINE\bin\current\LINE.exe    N/A      |
|    0                10156    C+G   ...b3d8bbwe\WinStore.App.exe    N/A      |
|    0                11340    C+G   ...lPanel\SystemSettings.exe    N/A      |
|    0                12932    C+G   ...es.TextInput.InputApp.exe    N/A      |
+-----------------------------------------------------------------------------+
```

Nvidia GPUで使用中のプロセス名とメモリ使用量を表示させる方法

### 前提・実現したいこと
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」とエラー表示される

### 前提・実現したいこと

kerasのfit関数の引数batch_sizeについてです。
半年ほどニューラルネットワークを勉強しているんですが、つまずきました。
batch_sizeについてですが、以下の事が解だと思っています。

１， バッチ分データを分割して学習（batch_size=2, data_set=400の場合、400/2回学習）、割り切れなかったりした場合は切り捨て？して計算してくれる（はず）
2, batch_size=1であれば確率的になる。
3, 指定しない場合はDefault=32となる（Noneでも）。
4, batch_sizeは2^nで決めると良い。（ケースバイケース）

これらのことから、あまり深く決める必要はないと感じました。
が、しかし、

### 発生している問題・エラーメッセージ
batch_size=8の場合です。
なぜでしょうか。
これはどの部分を指しているのでしょうか。
```
Incompatible shapes: [8] vs. [8,64,64]
```
また、batch_size=64にした場合、こうなります。
よく分かりません。

```
Incompatible shapes: [24] vs. [24,64,64]
```
合わすことができれば、こういう風に計算できると思うんですが…
```
x = np.ones(64)
y = np.ones((64, 64, 64))
dot = np.dot(x, y)
```
### 該当のソースコード
長いので、関連がありそうな部分だけを載せます。
trainは664、validateは166
Convが１層しかない簡単なネットワークです。

h = 64
w = 64
d = 3
入出力は、
Input
in  :(None, 64, 64, 3)
out:(None, 64, 64, 3)
Conv2D
in  :(None, 64, 64, 3)
out:(None, 64, 64, 64)
Dense
in  :(None, 64, 64, 64)
out:(None, 64, 64, 64)
Dense
in  :(None, 64, 64, 64)
out:(None, 64, 64, 3)

```Python3
class teratail(object):
    def __init__(self, h, w, d, label):
        self.inputs = Input(shape=(h, w, d), name="inputs")
        self.x = Conv2D(64, 3, padding="same", activation="relu")(self.inputs)
        self.x = Dense(64, activation="relu")(self.x)
        self.outputs = Dense(label, activation="softmax")(self.x)

    def create_model(self):
        self.model = Model(self.inputs, self.outputs, name="network")

    def model_compile(self):
        loss_object = tf.losses.CategoricalCrossentropy()
        optimizer = tf.optimizers.Adam(lr=1e-4)

        self.model.compile(loss=loss_object,
                           optimizer=optimizer,
                           metrics=["accuracy"])

    def model_fit(self, x_train, y_train, epochs=10):

        _return = self.model.fit(x_train, y_train,
                                 batch_size=8,
                                 epochs=epochs,
                                 validation_split=0.2,
                                 )
        self.model.summary()

```
お願いします。