DCGANでノイズ画像しか生成されない

Question

PythonでGANを用いた画像生成プログラムを作っています。
教師データとしてMNISTデータセットを用い、偽の手書き数字画像を生成するのが目標です。

画像を生成するGeneratorは、ランダムなノイズベクトルから、UpSampling2DレイヤーまたはDeconvolution2D(Conv2DTranspose)レイヤー、Convolution2Dレイヤー、活性化関数(主にRelu)を6層ほど(何度か層を変えて試してみていますが拡大縮小したデータサイズを合わせるためにだいたい6層ほどでやっています)経て画像として出力します。
一方、本物の画像と生成画像を判別するDiscriminatorは、入力画像を数層のConvolution2Dレイヤーと活性化関数へ渡し、Dense(Affine)レイヤーを5層ほど経て判別結果を出力します。
本物・偽物を1,0で表現し、0~1の範囲のDiscriminatorの出力との差を使って損失関数を定義しています。(Kerasではbinary_crossentropyを用いています)

しかし何度実験してみても出来上がった画像はノイズのようなものばかりです。
(以下がいくつかの生成画像です,
上5つが外部ライブラリに頼らずに作ったもの, 下5つがKerasを用いて作ったもの)

===============================================

これまでに試してみたこととしては、

• 様々な組み合わせのハイパーパラメーターで学習する
• GeneratorとDiscriminatorのバランスを取る(それぞれの精度を加味しながら)
• Relu以外の活性化関数を使ってみる
• Batch Normalizationを使う
• レイヤーの組み合わせも様々に試す
• 画像分類などは問題なく作れる

インターネットで手当たり次第に調べたり、書籍で参考になりそうな情報を探したり、手を尽くしましたがなぜ全くうまくいかないのかわかりません。問題がレイヤーの組み方なのか、何か決定的に重要な処理を飛ばしてしまっているのか、損失関数などの評価の仕方が悪いのかも見当もつきません。
なにか見落としているポイントなどがありますでしょうか？PythonでGANを用いた画像生成プログラムを作っています。
教師データとしてMNISTデータセットを用い、偽の手書き数字画像を生成するのが目標です。

画像を生成するGeneratorは、ランダムなノイズベクトルから、UpSampling2DレイヤーまたはDeconvolution2D(Conv2DTranspose)レイヤー、Convolution2Dレイヤー、活性化関数(主にRelu)を6層ほど(何度か層を変えて試してみていますが拡大縮小したデータサイズを合わせるためにだいたい6層ほどでやっています)経て画像として出力します。
一方、本物の画像と生成画像を判別するDiscriminatorは、入力画像を数層のConvolution2Dレイヤーと活性化関数へ渡し、Dense(Affine)レイヤーを5層ほど経て判別結果を出力します。
本物・偽物を1,0で表現し、0~1の範囲のDiscriminatorの出力との差を使って損失関数を定義しています。(Kerasではbinary_crossentropyを用いています)

しかし何度実験してみても出来上がった画像はノイズのようなものばかりです。
(以下がいくつかの生成画像です,
上5つが外部ライブラリに頼らずに作ったもの, 下5つがKerasを用いて作ったもの)

===============================================

これまでに試してみたこととしては、

• 様々な組み合わせのハイパーパラメーターで学習する
• GeneratorとDiscriminatorのバランスを取る(それぞれの精度を加味しながら)
• Relu以外の活性化関数を使ってみる
• Batch Normalizationを使う
• レイヤーの組み合わせも様々に試す
• 画像分類などは問題なく作れる

インターネットで手当たり次第に調べたり、書籍で参考になりそうな情報を探したり、手を尽くしましたがなぜ全くうまくいかないのかわかりません。問題がレイヤーの組み方なのか、何か決定的に重要な処理を飛ばしてしまっているのか、損失関数などの評価の仕方が悪いのかも見当もつきません。
なにか見落としているポイントなどがありますでしょうか？

コード

import numpy as np
from PIL import Image

from keras.datasets import mnist
from keras.layers import *
from keras.models import *
from keras.optimizers import *


# --- プログレスバーを表示するクラス(学習自体には関係ありません) ---------
class ProgressBar:
    def __init__(self, entireJob):
        self.job = entireJob
        self.width = 40
    def draw(self, progress):
        print( ("\r["+"#"*int((progress+1)*self.width/self.job)+" "*(self.width-int((progress+1)*self.width/self.job) ) +"]  %d/%d")%(progress+1,self.job), end="")


# --- Generatorモデルの定義 -----------
class Generator:
    def __init__(self):
        layer0 = Input(shape=(1,1,100))
            
        layer1 = UpSampling2D(size=(3,3))(layer0)
        layer1 = Conv2D(
            filters=100,
            kernel_size=(2,2),
            strides=(1,1),
            padding='same',
            activation='relu' )(layer1)
        layer1 = BatchNormalization()(layer1)

        layer2 = UpSampling2D(size=(3,3))(layer1)
        layer2 = Conv2D(
            filters=100,
            kernel_size=(2,2),
            strides=(1,1),
            padding='same',
            activation='relu' )(layer2)
        layer2 = BatchNormalization()(layer2)
            
        layer3 = UpSampling2D(size=(2,2))(layer2)
        layer3 = Conv2D(
            filters=80,
            kernel_size=(3,3),
            strides=(1,1),
            padding='valid',
            activation='elu' )(layer3)
        layer3 = BatchNormalization()(layer3)

        layer4 = UpSampling2D(size=(2,2))(layer3)
        layer4 = Conv2D(
            filters=50,
            kernel_size=(3,3),
            strides=(1,1),
            padding='same',
            activation='elu' )(layer4)
        layer4 = BatchNormalization()(layer4)

        layer5 = UpSampling2D(size=(2,2))(layer4)
        layer5 = Conv2D(
            filters=20,
            kernel_size=(4,4),
            strides=(2,2),
            padding='valid',
            activation='elu' )(layer5)
        layer5 = BatchNormalization()(layer5)
            
        layer6 = Conv2D(
            filters=1,
            kernel_size=(4,4),
            strides=(1,1),
            padding='valid',
            activation='tanh' )(layer5)

        self.model = Model(layer0, layer6)
        self.model.summary()

# --- Discriminatorモデルの定義 -------
class Discriminator:
    def __init__(self):
        layer0 = Input(shape=(28,28,1))
        layer1 = Conv2D(
            filters=5,
            kernel_size=(3,3),
            strides=(2,2),
            padding='valid',
            activation='elu' )(layer0)
        layer1 = BatchNormalization()(layer1)

        layer2 = Conv2D(
            filters=10,
            kernel_size=(3,3),
            strides=(2,2),
            padding='valid',
            activation='elu' )(layer1)
        layer2 = BatchNormalization()(layer2)
            
        layer3 = Conv2D(
            filters=5,
            kernel_size=(3,3),
            strides=(1,1),
            padding='valid',
            activation='relu' )(layer2)
        layer3 = BatchNormalization()(layer3)

        layer4 = Flatten()(layer3)
        layer4 = Dense(units=30, activation='tanh')(layer4)
        layer4 = BatchNormalization()(layer4)

        layer5 = Dense(units=1, activation='sigmoid' )(layer4)

        self.model = Model(layer0, layer5)
        self.model.summary()



class Main:
    def __init__(self):
        # --- Discriminatorの定義 -----------------
        self.discriminator = Discriminator().model
        self.discriminator.compile(
            optimizer=SGD(learning_rate=1e-4),
            loss='binary_crossentropy',
            metrics=['accuracy'] )
        
        # --- GeneratorとDiscriminatorを連結したモデルの定義 ---
        self.generator = Generator().model
        z = Input(shape=(1,1,100))
        img = self.generator(z)
        self.discriminator.trainable = False    # Discriminatorを更新しないよう設定
        valid = self.discriminator(img)
        self.combined = Model(z, valid)
        self.combined.compile(
            optimizer=Adam(learning_rate=1e-6),
            loss='binary_crossentropy',
            metrics=['accuracy'] )
        
        # --- MNISTデータセットの用意 ---------------
        (x_train, t_train), (x_test, t_test) = mnist.load_data()
        x_train = x_train.reshape(60000, 28, 28, 1)
        x_test = x_test.reshape(10000, 28, 28, 1)
        self.x_train = x_train.astype('float32')
        self.x_test = x_test.astype('float32')          

    # --- 学習 -------------------------------------
    def _train(self, iteration, batch_size):
        progress = ProgressBar(iteration)       # プログレスバーを用意
        for i in range(iteration):
            z = np.random.uniform(-1,1,(batch_size//2,1,1,100))     # ノイズベクトルの生成
            f_img = self.generator.predict(z)                       # f_img(fake_img)の生成
            r_img = self.x_train[np.random.randint(0, 60000, batch_size//2)]        # r_img(real_img)を読み込み
            loss_d, acc_d = self.discriminator.train_on_batch(f_img, np.zeros((batch_size//2,1)))   # Discriminatorの学習
            loss_d_, acc_d_ = self.discriminator.train_on_batch(r_img, np.ones( (batch_size//2,1))) # acc_d = Discriminatorのaccuracy
            acc_d += acc_d_

            z = np.random.uniform(-1,1,(batch_size,1,1,100))        # ノイズベクトルの生成
            loss_g, acc_g = self.combined.train_on_batch(z, np.ones((batch_size,1)))    # Generatorの学習
            progress.draw(i)        # プログレスバーの表示
            print("   Accuracy=(%f,%f)"%(acc_g, acc_d/2), end="")
    
    def train(self, iteration, batch_size, epoch):
        for i in range(epoch):
            print("Epoch %d/%d\n"%(i+1, epoch))
            self._train(iteration, batch_size)      # _train()をepoch回繰り返します
        
    # --- 学習が終わった時の確認用に一枚だけ画像を作ります -------
    def create_image(self):
        z = np.random.uniform(-1,1,(1,1,1,100))
        img = self.generator.predict(z)
        return img.reshape(1,28,28)


if __name__ == "__main__":
    main = Main()
    main.train(iteration=1875, batch_size=32, epoch=1)

    # --- 画像を表示　-----------------------
    img = main.create_image()
    img = Image.fromarray(np.uint8(img.reshape(28,28) * 255))
    img.show()
    img.save("gan_generated_img.png")

Comments

[tiitoi]

コピペで動くコードを記載できますか？

[tomoki_fab]

返信ありがとうございます！
Python3で、 kerasとpillowのインストールが必要です。
プログレスバーの表示などいくらか余計なものもついていますが、よろしくおねがいします。

[tiitoi]

すいません。インデントが崩れてしまうので、コードはマークダウン記法を使って、質問欄を編集して記載いただけますか。
https://qiita.com/Qiita/items/c686397e4a0f4f11683d#code---%E3%82%B3%E3%83%BC%E3%83%89%E3%81%AE%E6%8C%BF%E5%85%A5

[tomoki_fab]

本当ですね、すみません。
修正しました。

[tiitoi]

ありがとうございます。今、GPU 使える環境がないので、試すのが明日とかになってしまうかもしれないです。

[tomoki_fab]

わざわざありがとうございます、よろしくおねがいします。

Answer 1

とりあえず、一番の問題はわかりました。
MNIST の画像は画素値が [0, 255] のままモデルに流すのではなく、[-1, 1] の範囲に正規化してから流す必要があります。

画素値は [0, 255] の整数なので、以下の手順で [-1, 1] の float に変換します。

1. float に変換
2. 127.5 で減算して、範囲を [-127.5, 127.5] にする
3. 127.5 で除算して、範囲を [-1, 1] にする

def get_data():
    '''MNIST から入力データを作成する。
    '''
    (x_train, y_train), (x_test, y_test) = mnist.load_data()

    # 学習データとテストデータを合わせる。
    x_samples = np.concatenate([x_train, x_test])
    # 各画素の範囲を [0, 255] から [-1, 1] に変換する。
    x_samples = (x_samples.astype(np.float32) - 127.5) / 127.5
    # チャンネル分の次元を追加する。 (N, H, W) -> (N, H, W, C)
    x_samples = x_samples[..., np.newaxis]

    return x_samples

1000イテレーション時の画像

5000イテレーション時の画像

検証したコード

上記問題に気づくまでにあれこれ試行錯誤したので、モデルや最適化手法とかも変えてしまいましたが、とりあえず現状うまくいったコードを以下に貼ります。

import numpy as np
from PIL import Image

# tensorflow の keras を使ってますが、keras を使う場合は tensorflow. を消してください
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import *
from tensorflow.keras.models import *
from tensorflow.keras.optimizers import *
from IPython.display import display

# --- プログレスバーを表示するクラス(学習自体には関係ありません) ---------
class ProgressBar:
    def __init__(self, entireJob):
        self.job = entireJob
        self.width = 40
    def draw(self, progress):
        print( ("\r["+"#"*int((progress+1)*self.width/self.job)+" "*(self.width-int((progress+1)*self.width/self.job) ) +"]  %d/%d")%(progress+1,self.job), end="")


# Generator
class Generator:
    def __init__(self):
        model = Sequential()

        model.add(Dense(1024, input_dim=100))
        model.add(BatchNormalization())
        model.add(Activation('tanh'))

        model.add(Dense(7 * 7 * 128))
        model.add(BatchNormalization())
        model.add(Activation('tanh'))

        model.add(Reshape((7, 7, 128)))

        model.add(UpSampling2D(size=(2, 2)))
        model.add(Conv2D(64, 5, padding='same'))
        model.add(BatchNormalization())
        model.add(Activation('tanh'))

        model.add(UpSampling2D(size=(2, 2)))
        model.add(Conv2D(1, 5, padding='same'))
        model.add(Activation('tanh'))

        self.model = model

# --- Discriminatorモデルの定義 -------
class Discriminator:
    def __init__(self):
        model = Sequential()

        model.add(Conv2D(64, 5, padding='same', input_shape=(28, 28, 1)))
        model.add(LeakyReLU(0.2))
        model.add(Conv2D(64, 2, strides=2, padding='same'))

        model.add(Conv2D(128, (5, 5)))
        model.add(LeakyReLU(0.2))
        model.add(Conv2D(128, 2, strides=2, padding='same'))

        model.add(Flatten())
        model.add(Dense(1024))
        model.add(LeakyReLU(0.2))

        model.add(Dense(1, activation='sigmoid'))

        self.model = model

def get_data():
    '''MNIST から入力データを作成する。
    '''

    (x_train, y_train), (x_test, y_test) = mnist.load_data()

    # 学習データとテストデータを合わせる。
    x_samples = np.concatenate([x_train, x_test])
    # 各画素の範囲を [0, 255] から [-1, 1] に変換する。
    x_samples = (x_samples.astype(np.float32) - 127.5) / 127.5
    # チャンネル分の次元を追加する。 (N, H, W) -> (N, H, W, C)
    x_samples = x_samples[..., np.newaxis]

    return x_samples

class Main:
    def __init__(self):
        # Generator を作成する。
        self.generator = Generator().model
        # Discriminator を作成する。
        self.discriminator = Discriminator().model
        # DCGAN モデルを作成する。
        z = Input(shape=100)
        img = self.generator(z)
        self.discriminator.trainable = False    # Discriminatorを更新しないよう設定
        valid = self.discriminator(img)
        self.combined = Model(z, valid)
        self.combined.compile(
            optimizer="adam",
            loss='binary_crossentropy',
            metrics=['accuracy'] )
        self.combined.summary()

        #  Discriminator をコンパイルする。
        self.discriminator.trainable = True
        self.discriminator.compile(
            optimizer="adam",
            loss='binary_crossentropy',
            metrics=['accuracy'] )
        # --- MNISTデータセットの用意 ---------------
        self.x_train = get_data()

    # --- 学習 -------------------------------------
    def _train(self, iteration, batch_size):
        progress = ProgressBar(iteration)       # プログレスバーを用意
        for i in range(iteration):
            z_batch = np.random.uniform(-1,1,(batch_size,100))     # ノイズベクトルの生成
            f_img = self.generator.predict(z_batch)                       # f_img(fake_img)の生成
            r_img = self.x_train[np.random.randint(0, len(self.x_train), batch_size)]        # r_img(real_img)を読み込み

            # 偽物のデータと本物のデータをあわせる
            x_batch = np.concatenate([f_img, r_img])
            # Discriminator の学習ラベルは偽物のデータでは 0、本物のデータでは1
            y_batch = np.array([0] * batch_size + [1] * batch_size)

            loss_d, acc_d = self.discriminator.train_on_batch(x_batch, y_batch)   # Discriminatorの学習

            z_batch = np.random.uniform(-1,1,(batch_size,100))  # ノイズベクトルの生成
            # Generator のラベルは 1
            y_batch =np.array([1] * batch_size)

            self.discriminator.trainable = False
            loss_g, acc_g = self.combined.train_on_batch(z_batch, y_batch)    # Generatorの学習
            self.discriminator.trainable = True
            progress.draw(i)        # プログレスバーの表示
            print("   Accuracy=(%f,%f)"%(acc_g, acc_d/2), end="")

            if i % 1000 == 0:
                display(main.create_image())

    def train(self, iteration, batch_size, epoch):
        for i in range(epoch):
            print("Epoch %d/%d\n"%(i+1, epoch))
            self._train(iteration, batch_size)      # _train()をepoch回繰り返します

    def create_image(self):
        # 100枚の画像を生成する。
        z = np.random.uniform(-1,1,(100, 100))
        images = main.generator.predict(z)

        images = images * 127.5 + 127.5  # [-1, 1] -> [0, 255]

        # 画像を正方形に並べる。
        n, h, w, c = images.shape
        cols = int(np.sqrt(n))
        rows = int(np.ceil(n / cols))
        image = np.zeros((rows * h, cols * w), dtype=images.dtype)

        for i, img in enumerate(images):
            r = i // cols
            c = i % cols
            image[r * h:(r + 1) * h, c * w:(c + 1) * w] = img[..., 0]
        image =  image.astype(np.uint8)
        image =  Image.fromarray(image)

        return image


main = Main()
main.train(iteration=5000, batch_size=32, epoch=1)

Comments

[tomoki_fab]

ありがとうございます！
ご指摘の通り画像データを変換する過程を飛ばしてしまっていました。
また、どうやら問題はそこだけではなかったようで、作り直して頂いたコードと比較して試行錯誤してみたところ、Generatorのノイズベクトルの入力をはじめにDenseレイヤーに通すことで大幅に改善しました。
まだ送っていただいたコードほどの性能のものを自分では再現できませんが、引き続きコードを熟読して参考にさせていただきます。
とても丁寧な手ほどきありがとうございます。