DCGANによる半教師あり学習の実装

Question

前提・実現したいこと

GANを使用した半教師あり学習により、MNITSの教師あり画像を100枚使用しただけで精度90%の汎化性能を達成するべく、コード作成に取り組んでおります。

発生している問題・エラーメッセージ

一方、実際の精度は60-70%程度で向上せず、何が原因なのか頭を悩ませております。
過学習が発生している可能性があるため、とりあえず画像の水増しなども実装してみたのですが、やはり汎化精度が向上しません。
もし何かわかる方がいらっしゃいましたらアドバイス頂けると大変助かります。

該当のソースコード

import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np

from keras import backend as K
from keras.datasets import mnist
from keras.layers import Activation, BatchNormalization, Concatenate, Dense, Dropout, Flatten, Input, Lambda, Reshape
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.convolutional import Conv2D, Conv2DTranspose
from keras.models import Model, Sequential
from keras.optimizers import Adam
from keras.utils import to_categorical
from keras.preprocessing.image import ImageDataGenerator

## モデルの入力次元の定義
img_rows = 28
img_cols = 28
channels = 1

#入力画像の解像度
img_shape = (img_rows, img_cols, channels)

#Generatorに入力するノイズベクトルzのサイズ
z_dim = 100

#データセット内のクラスの数
num_classes = 10

##訓練と検証のためのデータの設定 num_labeledで指定された枚数の画像のみを使用（残りはラベルなしとして使用）
class Dataset:
    def __init__(self, num_labeled):

        # 訓練用に使用するラベル付き画像の数
        self.num_labeled = num_labeled

        # MNISTデータのDL
        (self.x_train, self.y_train), (self.x_test, self.y_test) = mnist.load_data()

        def preprocess_imgs(x):
            # [0, 255] のグレースケール画素値を [-1, 1]の値に変換する
            x = (x.astype(np.float32) - 127.5) / 127.5
            # xの画像の次元を横幅×縦幅×チャンネル数に拡張する
            x = np.expand_dims(x, axis=3)
            return x

        def preprocess_labels(y):
            return y.reshape(-1, 1)

        # 訓練データ
        self.x_train = preprocess_imgs(self.x_train)
        self.y_train = preprocess_labels(self.y_train)

        # テストデータ
        self.x_test = preprocess_imgs(self.x_test)
        self.y_test = preprocess_labels(self.y_test)

    def batch_labeled(self, batch_size):
        # ラベル付き画像とそのラベルをランダムに取り出してバッチをつくる
        idx = np.random.randint(0, self.num_labeled, batch_size)
        imgs = self.x_train[idx]
        labels = self.y_train[idx]

　      datagen = ImageDataGenerator(rotation_range = 50)
        g = datagen.flow(imgs, labels, batch_size, shuffle=False)
        imgs, labels = g.next()

        return imgs, labels

    def batch_unlabeled(self, batch_size):
        # ラベルなし画像をランダムに取り出してバッチをつくる
        idx = np.random.randint(self.num_labeled, self.x_train.shape[0],batch_size)
        imgs = self.x_train[idx]
        return imgs

    def training_set(self):
        x_train = self.x_train[range(self.num_labeled)]
        y_train = self.y_train[range(self.num_labeled)]
        return x_train, y_train

    def test_set(self):
        return self.x_test, self.y_test

## ラベル付き訓練データの数の指定

num_labeled = 100

dataset = Dataset(num_labeled)

## 生成器（Generator）の実装

def build_generator(z_dim):

    model = Sequential()

    # 入力を全結合により7×7×256のテンソルに変形する
    model.add(Dense(256 * 7 * 7, input_dim=z_dim))
    model.add(Reshape((7, 7, 256)))

    # 転置畳み込み層により14x14x128のテンソルに変形する（転置畳み込みにより、幅と高さを拡大する代わりに深さを小さくできる⇔普通の畳み込みと逆）
    model.add(Conv2DTranspose(128, kernel_size=3, strides=2, padding='same'))

    # Batch normalization（バッチ正規化）
    model.add(BatchNormalization())

    # Leaky ReLU による活性化
    model.add(LeakyReLU(alpha=0.01))

    # 転置畳み込み層により14x14x64のテンソルに変形する
    model.add(Conv2DTranspose(64, kernel_size=3, strides=1, padding='same'))

    # Batch normalization （バッチ正規化）
    model.add(BatchNormalization())

    # Leaky ReLU による活性化
    model.add(LeakyReLU(alpha=0.01))

    # 転置畳み込み層により28x28x1のテンソルに変形する
    model.add(Conv2DTranspose(1, kernel_size=3, strides=2, padding='same'))

    # tanhによる活性化を行った出力層（tanhにすることでよりはっきりした画像になる）
    model.add(Activation('tanh'))

    return model

## 識別機（Discriminator）の実装

def build_discriminator_net(img_shape):

    model = Sequential()

    # 畳み込み層により14x14x32のテンソルに変形する
    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=img_shape, padding='same'))

    # Leaky ReLU による活性化
    model.add(LeakyReLU(alpha=0.01))

    # 畳み込み層により7x7x64のテンソルに変形する
    model.add(Conv2D(64, kernel_size=3, strides=2, input_shape=img_shape, padding='same'))

    # Batch normalization （バッチ正規化）
    model.add(BatchNormalization())

    # Leaky ReLU による活性化
    model.add(LeakyReLU(alpha=0.01))

    # 畳み込み層により3x3x128のテンソルに変形する
    model.add(Conv2D(128, kernel_size=3, strides=2, input_shape=img_shape, padding='same'))

    # Batch normalization （バッチ正規化）
    model.add(BatchNormalization())

    # Leaky ReLU による活性化
    model.add(LeakyReLU(alpha=0.01))

    # ドロップアウト
    model.add(Dropout(0.5))

    # テンソルを一列に変形する
    model.add(Flatten())

    # num_classesニューロンへの全結合層
    model.add(Dense(num_classes))

    return model

## 教師あり部分のSGAN識別機の実装

def build_discriminator_supervised(discriminator_net):

    model = Sequential()

    model.add(discriminator_net)

    # ソフトマックスによる活性化により、本物のクラスの中のどれに該当するのか推定確率を出力
    model.add(Activation('softmax'))

    return model

## 教師なし部分のSGAN識別機の実装

def build_discriminator_unsupervised(discriminator_net):

    model = Sequential()

    model.add(discriminator_net)

    def predict(x):
        # 本物のクラスごとの確率分布を、本物か偽物かの2値の確率に変換する
        prediction = 1.0 - (1.0 /(K.sum(K.exp(x), axis=-1, keepdims=True) + 1.0))
        return prediction

    # 本物か偽物かを出力する
    model.add(Lambda(predict))

    return model

## モデル構築

def build_gan(generator, discriminator):

    model = Sequential()

    # 生成器と識別器を結合する
    model.add(generator)
    model.add(discriminator)

    return model

# 教師ありと教師なしで共有される層
discriminator_net = build_discriminator_net(img_shape)

# 教師あり学習のための識別機をコンパイルする
discriminator_supervised = build_discriminator_supervised(discriminator_net)
discriminator_supervised.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer=Adam())

# 教師なし学習のための識別機をコンパイルする
discriminator_unsupervised = build_discriminator_unsupervised(discriminator_net)
discriminator_unsupervised.compile(loss='binary_crossentropy', optimizer=Adam())

# 生成器の作成
generator = build_generator(z_dim)

# 生成器の訓練中は識別機のパラメータは定数
discriminator_unsupervised.trainable = False

# 生成器の訓練を行うため、識別機のパラメータを固定したGANモデルを構築し、コンパイルする
gan = build_gan(generator, discriminator_unsupervised)
gan.compile(loss='binary_crossentropy', optimizer=Adam())

''''''''''''''''''''''
SGAN訓練アルゴリズムの実装

①教師あり識別機の訓練

ラベリングされた本物のデータからランダムにサンプルを取り出し、ミニバッチを作成
このミニバッチからロスを計算し、誤差逆伝播によってパラメータθを更新
②生成器の訓練

ラベルのない本物データからランダムにミニバッチを作成
ここからロスを計算し、2値分類の誤差逆伝播によってθを更新
ノイズベクトルzから偽サンプルのミニバッチを作成
このミニバッチからもロスを計算し、2値分類の誤差逆伝播によってθを更新
③生成器の訓練

ノイズベクトルzから偽の生成サンプルからなるミニバッチを作成
このミニバッチからロスを計算し、2値分類の誤差逆伝播によってθを更新
'''''''''''''''''''''''

supervised_losses = []
iteration_checkpoints = []


def train(iterations, batch_size, sample_interval):

    # 本物の画像のラベル: すべて1
    real = np.ones((batch_size, 1))

    # 偽物の画像のラベル: すべて0
    fake = np.zeros((batch_size, 1))

    #識別機の訓練
    for iteration in range(iterations):

        # ラベル付きデータの取得
        imgs, labels = dataset.batch_labeled(batch_size)

        # ワンホットエンコードされたラベル
        labels = to_categorical(labels, num_classes=num_classes)

        # ラベルなしデータの取得
        imgs_unlabeled = dataset.batch_unlabeled(batch_size)

        # 偽画像のバッチ作成
        z = np.random.normal(0, 1, (batch_size, z_dim))
        gen_imgs = generator.predict(z)

        # ラベル付き本物データによる訓練
        d_loss_supervised, accuracy = discriminator_supervised.train_on_batch(imgs, labels)

        # ラベルなしの本物サンプルによる訓練
        d_loss_real = discriminator_unsupervised.train_on_batch(imgs_unlabeled, real)

        # 偽のサンプルによる訓練
        d_loss_fake = discriminator_unsupervised.train_on_batch(gen_imgs, fake)

        d_loss_unsupervised = 0.5 * np.add(d_loss_real, d_loss_fake)

        # 生成器の訓練

        # 偽画像のバッチ作成
        z = np.random.normal(0, 1, (batch_size, z_dim))
        gen_imgs = generator.predict(z)

        # 生成器の訓練
        g_loss = gan.train_on_batch(z, np.ones((batch_size, 1)))

        if (iteration + 1) % sample_interval == 0:

            # 生成器の教師ありの分類損失を、訓練後にプロットするために保存しておく
            supervised_losses.append(d_loss_supervised)
            iteration_checkpoints.append(iteration + 1)

            # 訓練の進捗を出力
            print("%d [D loss supervised: %.4f, acc.: %.2f%%] [D loss unsupervised: %.4f] [G loss: %f]" % (iteration + 1, d_loss_supervised, 100 * accuracy, d_loss_unsupervised, g_loss))

# ハイパーパラメータの設定
iterations = 8000
batch_size = 32
sample_interval = 800

# SGANを指定した回数だけ反復訓練させる
train(iterations, batch_size, sample_interval)

x, y = dataset.test_set()
y = to_categorical(y, num_classes=num_classes)

# テストデータの分類データの測定
_, accuracy = discriminator_supervised.evaluate(x, y)
print("Test Accuracy: %.2f%%" % (100 * accuracy))

試したこと

補足情報に記載したGitHubコード（とあるDCGANに関する書籍のサンプルコードです）の単純なコピペではうまくいかなかったため、kerasのImageDataGeneratorを使用して、（Class:Dataset内に）以下のコードを追加してみたのですが、汎化精度が向上しませんでした。

    datagen = ImageDataGenerator(rotation_range = 50)
    g = datagen.flow(imgs, labels, batch_size, shuffle=False)
    imgs, labels = g.next()

補足情報（FW/ツールのバージョンなど）

GitHubソースコード
https://github.com/GANs-in-Action/gans-in-action/tree/master/chapter-7

その他参考情報
https://sinyblog.com/deaplearning/gansemi-supervised-gan-001/

Comments

[meg_]

> 精度90%の汎化性能を達成するコードを作成
> 一方、精度は60-70%程度で向上せず
文言が矛盾していますがどういう状況でしょうか？

[kentaro189]

ご質問ありがとうございます。当方、日本語がいまいちでお手数おかけしました。
記載を修正いたしました。
状況としましては、90%以上の汎化精度を目指しているものの、実際には60-70%程度にしか達していないというものです。

また、日本語の修正のほか、ImageDataGeneratorを使用し、見よう見まねでコードを追記してみております。やはり精度は変わらなかったので、コードがおかしいのか、ほかに原因があるのか、もし何かわかればご指摘頂き度く、宜しくお願い致します。

Answer 1

引数なしのadamを指定するとlr=0.001が適用されると思います。
うまくいく保証はありませんが、これを２桁～４桁くらい落として試してはいかがでしょうか？
少なくとも、別のDCGANではlr=0.0002が使われていますので、これくらいを目安に下げた方がよさそうな気がします。