常連

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

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

ここに実現したいことを箇条書きで書いてください。
タイトルの通り、学習モデルの重みを取り出したいです。

### 前提
複数の学習モデルの重みの平均を取り、１つのモデルにしたいと考えています。
なお、言語はpythonを使用しています。
### 発生している問題・エラーメッセージ
モデルを保存する際以下の形式のファイルが保存されます。
・checkpoint
・data-00000-of-oooo1
・index
・meta

しかし、この中のどこに重みが保存されているのか、またどのように呼び出せば良いのかが分からない状態です。

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

    def train(self):
        total_step = self.train_inputs.shape[0] * FLAGS.num_epoch // FLAGS.batch_size
        print(self.train_inputs.shape[0])
        print('total step is %d' % total_step)
        config = tf.compat.v1.ConfigProto()
        config.gpu_options.allow_growth = True #メモリを必要分確保
        min_validation_loss = 10
        best_epoch = 0
        with tf.compat.v1.Session(config=config) as sess:
            
            sess.run(tf.global_variables_initializer()) #変数の初期化
            if FLAGS.restore == True:
                self.saver.restore(sess, self.save_path)

            for step in range(total_step):
                print(step)
                sample = random.sample(range(self.train_inputs.shape[0]), FLAGS.batch_size) #入力から、バッチサイズ分の要素をランダムに取り出す
                train_batch = self.train_inputs[sample]
                train_label = self.train_labels[sample]
                sess.run(self.optimizer, feed_dict={self.signal_input: train_batch, self.signal_label: train_label, #学習の実行
                                                    self.rnn_keep_prob: FLAGS.rnn_keep_prob, self.dense_drop_rate: FLAGS.drop_rate})
                
                if step % 100 == 0:
                    # print('-----------------------------------------------------------')
                    train_loss = sess.run(self.loss,
                                          feed_dict={self.signal_input: train_batch, self.signal_label: train_label,
                                                     self.rnn_keep_prob: FLAGS.rnn_keep_prob, self.dense_drop_rate: 0})
                    fft_train_loss = sess.run(self.fft_loss,
                                              feed_dict={self.signal_input: train_batch,
                                                         self.signal_label: train_label,
                                                         self.rnn_keep_prob: FLAGS.rnn_keep_prob, self.dense_drop_rate: 0})
                    valid_loss = sess.run(self.loss, feed_dict={self.signal_input: self.valid_inputs,
                                                                self.signal_label: self.valid_labels,
                                                                self.rnn_keep_prob: 1,
                                                                self.dense_drop_rate: 0})
                    fft_valid_loss = sess.run(self.fft_loss, feed_dict={self.signal_input: self.valid_inputs,
                                                                        self.signal_label: self.valid_labels,
                                                                        self.rnn_keep_prob: 1,
                                                                        self.dense_drop_rate: 0})


                    print('current step is %d' % step)
                    num_epoch = step * FLAGS.batch_size // self.train_inputs.shape[0]
                    print('current epoch is %d' % (num_epoch))
                    print('')
                    print('train loss is: %f' % train_loss)
                    print('fft train loss is: %f' % fft_train_loss)
                    print('sum_train loss is: %f' % (train_loss + fft_train_loss))
                    print('')
                    print('valid loss is: %f' % valid_loss)
                    print('fft valid loss is: %f' % fft_valid_loss)
                    print('sum_valid real loss is: %f' % (valid_loss + fft_valid_loss))

                    print('minimum valid loss is: {0:0.4f} in epoch {1}'.format(min_validation_loss, best_epoch))

                    if valid_loss < min_validation_loss:
                        best_epoch = num_epoch
                        min_validation_loss = valid_loss
                        self.saver.save(sess, self.save_path)
                        print(self.save_path)
                     
                        print('best model saved!!')

                
                
            

      
       

   
    
       


### 試したこと

色々調べてみたのですが、他の方のやり方では、コードを一から書き直す必要があるように見えたので、少し自分には難易度が高く、打つ手がありません…

### 補足情報（FW/ツールのバージョンなど）
私自身機械学習に関して初心者なのと、今回初めてteratailを使用したため、かなり分かりにくい質問内容になっているかと思いますが、ご回答いただけますと幸いです。



学習モデルの重みを取り出したい

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

「End-to-end training」 とは？

### 実現したいこと
ここに実現したいことを箇条書きで書いてください。
- [松尾研究室が公開している学習コンテンツ](https://github.com/matsuolab-edu/dl4us)の Keras による RNN 実装を PyTorch で実現したい。

### 前提
現在、東京大学松尾研究室が公開している、機械学習・深層学習の教材 DL4US を利用して深層学習の独習をしています。学習において、教材を読むのに合わせてコードを写経しているのですが、ただ写経するだけでは「分かったつもり」で流してしまうかもしれませんので、自分の理解度を確認するため Pytorch で同じ機能の実装しながら進めています。

現在、[Lesson3 の Section2](https://github.com/matsuolab-edu/dl4us/blob/master/lesson3/lesson3_sec2_exercise.ipynb) で RNN の実装を学習しているところですが、教材の Keras による RNN 実装を Pytorch で実現しようとしても、明らかに性能が劣ったものしか作れていません。私の実装の問題点をご指摘いただき、どのように改善すれば教材の実装と同程度の性能を実現できるか、ご教示よろしくお願いします。

### 教材の実装の Fix 版
上記教材は公開が2019年と古く、2023年4月8日現在、ダウンロードを指定された ECG5000 のデータの仕様が変わっているため、その点を私的にフィックスしたソースが以下になります。
```Python
!wget -P ./data/ http://timeseriesclassification.com/Downloads/ECG5000.zip
!unzip -d ./data/ /content/data/ECG5000.zip 

from scipy.io import arff
import numpy as np

# TEST.arff のデータが4500件、TRAIN.arff のデータが500件、
# これは多分名前が取り違えられてると思うので、TRAIN と TESTの役割を入れ替え
train_dataset, train_meta = arff.loadarff('data/ECG5000_TEST.arff')
train_ds = np.asarray(train_dataset.tolist(), dtype=np.float32)
x_train_dataset = train_ds[:, :140]
y_train_dataset = np.asarray(train_ds[:,-1].tolist(), dtype=np.int8)-1

test_dataset, test_meta = arff.loadarff('data/ECG5000_TRAIN.arff')
test_ds = np.asarray(test_dataset.tolist(), dtype=np.float32)
x_test_dataset = test_ds[:, :140]
y_test_dataset = np.asarray(test_ds[:,-1].tolist(), dtype=np.int8)-1

print(x_train_dataset.shape)
print(y_train_dataset.shape)
print(x_test_dataset.shape)
print(y_test_dataset.shape)

#(4500, 140)
#(4500,)
#(500, 140)
#(500,)

from sklearn.model_selection import train_test_split
from tensorflow.keras.utils import to_categorical

x_train = x_train_dataset[:,:,np.newaxis] 
y_train = to_categorical(y_train_dataset)

x_test = x_test_dataset[:,:,np.newaxis] 
y_test = to_categorical(y_test_dataset)

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Activation, SimpleRNN

hid_dim = 10

# SimpleRNNにDenseを接続し、分類
model = Sequential()

model.add(SimpleRNN(hid_dim, input_shape=x_train.shape[1:])) # input_shape=(系列長T, x_tの次元), output_shape=(units(=hid_dim),)
model.add(Dense(y_train.shape[1], activation='softmax'))

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

model.fit(x_train, y_train, epochs=50, batch_size=100, verbose=2, validation_split=0.2)

score = model.evaluate(x_test, y_test, verbose=0)
print('test_loss:', score[0])
print('test_acc:', score[1])
```
上記コードの [Colab リンク](https://colab.research.google.com/drive/1IuYDdDcoZgzP5Rfv74J8IByCigImAEZI?usp=sharing)
以上のコードを実行して頂くと、テストデータに対してだいたい90%前後の正解を出せるモデルが完成します。

### 教材版の RNN と同機能を実現したいと思うも上手くいっていない私の Pytorch 実装
```Python
from scipy.io import arff
import numpy as np
import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
from torch import nn
from tqdm.notebook import tqdm

!wget -P ./data/ http://timeseriesclassification.com/Downloads/ECG5000.zip 
!unzip -d ./data/ /content/data/ECG5000.zip

# TEST.arff のデータが4500件、TRAIN.arff のデータが500件、
# これは多分名前が取り違えられてると思うので、TRAIN と TESTの役割を入れ替え
down_loaded_train_data, train_meta = arff.loadarff("data/ECG5000_TEST.arff")
down_loaded_test_data, test_meta = arff.loadarff('data/ECG5000_TRAIN.arff')

print(len(down_loaded_train_data)) # 4500
print(len(down_loaded_train_data[0])) # 141

print(len(down_loaded_test_data)) # 500
print(len(down_loaded_test_data[0])) # 141

class CustomDataset(Dataset):
    def __init__(self, dataset=None, time_series_size=None):
        dataset = np.array(dataset.tolist(), dtype=np.float32)
        labels_index = torch.from_numpy(dataset[:, -1]).to(torch.long) - 1

        self.X = torch.from_numpy(dataset[:, :time_series_size]).unsqueeze(2)
        self.y = labels_index
    
    def __len__(self):
        return len(self.X)
    
    def __getitem__(self, idx):
        return self.X[idx], self.y[idx]

time_series_size = 140 # 一件のデータの時系列サイズが140 で、ラベルが1つ
train_data = CustomDataset(down_loaded_train_data, time_series_size)
test_data = CustomDataset(down_loaded_test_data, time_series_size)

# Dataset から DataLoader を作成
batch_size=100
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_data, batch_size=batch_size)

class MyRNN(nn.Module):
    def __init__(self, input_size=1, hidden_size=1):
        super().__init__()
        
        self.num_rnn_layers = 1
        self.input_size = input_size
        self.hidden_size = hidden_size

        self.rnn = nn.RNN(input_size, hidden_size)
        self.fc = nn.Linear(hidden_size, 5)
    
    def hidden_initialize(self, time_series_size):
        return torch.zeros((self.num_rnn_layers, time_series_size, self.hidden_size))
    
    def forward(self, x, hidden):
        output, hidden = self.rnn(x, hidden)
        output = self.fc(output[:, -1])
        return output, hidden

hidden_size = 10
model = MyRNN(1, hidden_size)
optimizer = torch.optim.Adam(model.parameters(), lr=0.002)
criterion = nn.CrossEntropyLoss()

EPOCHS = 50
losses = []

for epoch in range(EPOCHS):

    with tqdm(train_loader) as progress:
    
        for X, y in progress:
            optimizer.zero_grad()
            hidden = model.hidden_initialize(time_series_size)
            output, hidden = model(X, hidden)
            loss = criterion(output, y)
            loss.backward()
            optimizer.step()

            with torch.no_grad():
                acc = (output.argmax(dim=1) == y).sum() / batch_size
                losses.append(loss.item())
           
            progress.set_postfix(acc=acc.item())
        
        print("loss: ", loss.item()) 
        print("acc_cal: ", acc.item())

print(acc.item())
```
上記コードの [Colab リンク](https://colab.research.google.com/drive/1IbquXXOhpJZvRondafBt35aKfuttAd7v?usp=sharing)
以上のコードを実行しても、正解率は60%を中心に、しかも上下に10%ほど激しく正解率のブレるモデルしか作れずにいます。
![loss の推移をプロットした画像](https://ddjkaamml8q8x.cloudfront.net/questions/2023-04-08/d9a0e3c5-6511-4771-8f6b-5053e1d51f37.png)loss の推移をプロットした画像

これがまったく何も学習していないようなら諦めて挫折もできるのですが、一応最序盤に少しだけ学習は出来ているようなのでなかなか諦めきれず、私のモデルをどのように改善すれば教材のモデルと同程度の性能のモデルになるかお教えいただきたく思っております。よろしくお願いします。

Keras による RNN 実装サンプルを PyTorch で実装したいが上手くいかない

### 前提・実現したいこと

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 を解決したい

### 実現したいこと

- [ ] はじめてのディープラーニング２（著者：我妻幸長）の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

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

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

Pytorchで書かれた深層学習のコードがネット上で多く見られますが、
Kerasで実行できるように書き換えるにはどのように調べるとよいでしょうか。

## 背景、状況

私自身何とかKerasでSRCNNなどの超解像を実行しています。
Keras自体も今年度始めたばかりの初学者で、
ネットに頼りながら日々格闘しています。
ご意見をお聞かせください。
よろしくお願いいたします。
