GANでの画像生成について

Question

### 実現したいこと
MNIST画像を生成・識別するGANのモデルを作りたい

### 発生している問題・分からないこと
簡易的なGANのモデルを作成しているのですが、generatorによって生成した画像が、次のようなmnist画像にかすりもしないような画像しか生成されません。どうすればmnist画像が生成されるようになるのでしょうか。![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2026-03-30/5d1ce868-6c17-4281-b161-402793f3da48.png)

上がデータローダーから取り出したMNIST,下が生成画像です。

### エラーメッセージ
```error
エラーが表示されてはいませんが、出力画像が異なっています
```

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

```python
前準備

import PIL
PIL.PILLOW_VERSION = PIL.__version__

import torch, time, os, pickle
import numpy as np
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torch.nn import Parameter
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
from torch.autograd import grad
from IPython import display
import pylab as pl
import time
import torch.nn.functional as F

%matplotlib inline

import os
os.environ['CUDA_VISIBLE_DEVICES '] = '0'

input_size=32
seed=42
batch_size=128
epochs=20
device=torch.device("cuda" if torch.cuda.is_available() else "cpu")

def initialize(m):
  if(type(m)==nn.Linear or type(m)==nn.ConvTranspose2d or type(m)==nn.Conv2d):
    nn.init.kaiming_normal_(m.weight)
    #m.bias.data.fill_(0.0)

transform=transforms.Compose( [transforms.Resize(input_size),
                              transforms.ToTensor(),
                              transforms.Normalize(mean=(0.5,),std=(0.5,)),
                             ])

pr_dataset=datasets.MNIST("data/mnist",train=True,download=True,transform=transform)
test_dataset=datasets.MNIST("data/mnist",train=False,download=True,transform=transform)

train_dataset,valid_dataset=torch.utils.data.random_split(pr_dataset,[int(len(pr_dataset)*0.8),len(pr_dataset)-int(len(pr_dataset)*0.8)],generator=torch.Generator().manual_seed(seed))

train_loader=DataLoader(train_dataset,shuffle=True,batch_size=batch_size)
valid_loader=DataLoader(valid_dataset,shuffle=False,batch_size=batch_size)
test_loader=DataLoader(test_dataset,shuffle=False,batch_size=batch_size)
```

```python
モデルの定義

class generator(nn.Module):
  def __init__(self,input_size,input_dim=10,output_dim=3):##画像の形状は、（バッチサイズ、クラス数、画像サイズ）
    super().__init__()
    self.fc=nn.Sequential(
        nn.Linear(input_dim,1024),
        nn.BatchNorm1d(1024),
        nn.ReLU(),
        nn.Linear(1024,128*(input_size//4)**2),
        nn.BatchNorm1d(128*(input_size//4)**2),
        nn.ReLU(),
    )
    self.conv=nn.Sequential(
        nn.ConvTranspose2d(128,64,kernel_size=4,stride=2,padding=1),
        nn.BatchNorm2d(64),
        nn.ReLU(),
        nn.ConvTranspose2d(64,output_dim,kernel_size=4,stride=2,padding=1),
        nn.Tanh()
    )

def forward(self,x):
    x=self.fc(x)
    x=x.view(-1,128,input_size//4,input_size//4)
    x=self.conv(x)
    return x

class discriminator(nn.Module):
  def __init__(self,input_size=32,input_dim=3,output_dim=1,sig=False):
    super().__init__()
    self.sig=sig
    self.conv=nn.Sequential(
        nn.Conv2d(input_dim,64,kernel_size=4,stride=2,padding=1),
        nn.LeakyReLU(0.2),
        nn.Conv2d(64,128,kernel_size=4,stride=2,padding=1),
        nn.BatchNorm2d(128),
        nn.LeakyReLU(0.2),
    )
    self.fc=nn.Sequential(
        nn.Linear(128*(input_size//4)**2,1024),
        nn.BatchNorm1d(1024),
        nn.LeakyReLU(0.2),
        nn.Linear(1024,output_dim)
    )

def forward(self,x):
    x=self.conv(x)
    x=x.view(-1,128*(input_size//4)**2)
    x=self.fc(x)
    if(self.sig):
      x=torch.sigmoid(x)
    return x

gen=generator(input_size=input_size,input_dim=10,output_dim=1)
dis=discriminator(input_size=input_size,input_dim=1,output_dim=1,sig=True)
gen.apply(initialize)
dis.apply(initialize)
gen=gen.to(device)
dis=dis.to(device)
gen_optim=optim.Adam(gen.parameters(),lr=0.01)
dis_optim=optim.Adam(dis.parameters(),lr=0.01)
lossfc=nn.BCELoss()

```

```python
学習とテスト

for epoch in range(epochs):
  gen.train()
  dis.train()
  for x,t in train_loader:
    t=F.one_hot(t,num_classes=10).float()
    nowbatch=np.size(t,0)
    t=t.to(device)
    pic_real=x.to(device)
    real_label=torch.ones(nowbatch,1).to(device)
    fake_label=torch.zeros(nowbatch,1).to(device)

gen_optim.zero_grad()
    pic_fakeone=gen(t)
    pred_fakeone=dis(pic_fakeone)
    pred_real=dis(pic_real)
    gen_loss=lossfc(pred_fakeone,real_label)
    gen_loss.backward()
    gen_optim.step()

dis_optim.zero_grad()
    pic_faketwo=gen(t).detach()
    pred_faketwo=dis(pic_faketwo)
    dis_loss=lossfc(pred_real,real_label)+lossfc(pred_faketwo,fake_label)
    dis_loss.backward()
    dis_optim.step()

gen.eval()
  dis.eval()
  num=0
  tr=0
  gen_lossline=np.array([])
  dis_lossline=np.array([])
  for x,t in valid_loader:
    t=F.one_hot(t,num_classes=10).float()
    t=t.to(device)
    nowbatch=np.size(t,0)
    pic_real=x.to(device)
    real_label=torch.ones(nowbatch,1).to(device)
    fake_label=torch.zeros(nowbatch,1).to(device)
    pic_fakeone=gen(t)
    pred_fakeone=dis(pic_fakeone)
    pred_real=dis(pic_real)
    gen_loss=lossfc(pred_fakeone,real_label)
    pic_faketwo=gen(t).detach()
    pred_faketwo=dis(pic_faketwo)
    dis_loss=lossfc(pred_real,real_label)+lossfc(pred_faketwo,fake_label)
    gen_lossline=np.append(gen_lossline,gen_loss.item())
    gen_lossline=np.append(dis_lossline,dis_loss.item())
    num+=np.size(t,0)
    sirasu=pred_real-real_label
    ama=pred_faketwo-fake_label
    tr+=torch.sum((sirasu<0.5).float()).item()
    tr+=torch.sum((ama<0.5).float()).item()
  print(str(epoch+1)+"回目の正答率は"+str((tr/num/2)))

testdata=test_loader.__iter__()
image_num=int(input())
image=0
label=0

for ro1 in range(image_num):
  image,label=next(testdata)

# Display the first real image from the batch
plt.imshow(image[0].permute(1, 2, 0).cpu().numpy()) # Select first image, permute, convert to numpy for display
plt.axis('off')
plt.show()

# Generate an image using the first label from the batch and display it
gen_input_label = F.one_hot(label[0], num_classes=10).float().to(device) # One-hot encode the first label and move to device
generated_image = gen(gen_input_label.unsqueeze(0)).cpu().detach()[0].permute(1, 2, 0) # Fixed: Take the first image from the batch output before permuting
plt.imshow(generated_image.numpy()) 
plt.axis('off')
plt.show()
```

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

##### 上記の詳細・結果
Heの初期化などでパラメータの最適化も行いましたが、全く改善されませんでした

### 補足
特になし

Answer

生成AIに聞いて初期化部分とオプティマイザーを下記に変えたところ数字（らしきもの）を生成できました。

```ここに言語を入力
def initialize(m):
    classname = m.__class__.__name__
    if classname.find('Conv') != -1 or classname.find('Linear') != -1:
        nn.init.normal_(m.weight.data, 0.0, 0.02) # GANの定番
    elif classname.find('BatchNorm') != -1:
        nn.init.normal_(m.weight.data, 1.0, 0.02)
        nn.init.constant_(m.bias.data, 0)
```
```ここに言語を入力
gen_optim=optim.Adam(gen.parameters(),lr=0.0002, betas=(0.5, 0.999))
dis_optim=optim.Adam(dis.parameters(),lr=0.0002, betas=(0.5, 0.999))
```

```ここに言語を入力
1回目の正答率は1.0
2回目の正答率は0.9070833333333334
3回目の正答率は0.9509583333333333
4回目の正答率は0.9006666666666666
5回目の正答率は0.8587083333333333
6回目の正答率は0.79975
7回目の正答率は0.9030416666666666
8回目の正答率は1.0
9回目の正答率は1.0
10回目の正答率は1.0
11回目の正答率は1.0
12回目の正答率は0.59225
13回目の正答率は0.691625
14回目の正答率は0.802125
15回目の正答率は0.64175
16回目の正答率は0.9070833333333334
17回目の正答率は0.6455833333333333
18回目の正答率は0.8482083333333333
19回目の正答率は0.6017916666666666
20回目の正答率は0.6985833333333333
```
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2026-04-01/faa680a6-4afb-4253-ae97-b105dd4b8f50.png)

AIが言うには下記理由で改善するそうです。
> DCGANなどで推奨される「平均0、標準偏差0.02」の正規分布に変えます。
重みの初期化を 「平均0、標準偏差0.02の正規分布」 に変えたことで、ネットワークの各層の出力が極端に偏らなくなり、GeneratorとDiscriminatorが「お互いに学習のヒント（勾配）を出し合える状態」になった証拠です。

> 通常の分類タスクなどで使われるは、GANにとっては高すぎます。
GANの損失関数は非凸で複雑なため、過去の勾配を引きずりすぎると、更新方向が大きく振動して学習が不安定になります。
ベータを0.5に設定することで、この振動（Oscillation）を抑え、学習を安定させる効果があります。

実現したいこと

発生している問題・分からないこと

エラーメッセージ

該当のソースコード

試したこと・調べたこと

上記の詳細・結果

補足

関連した質問