GANを実装したいです

Question

前提・実現したいこと

kerasをつかって
CIFAR-10の画像を生成するGANの実装をしたいです

https://github.com/oreilly-japan/deep-learning-with-keras-ja/tree/master/ch04
の中の
example_gan_cifar10.py
というコードを修正を加えつつ写しています。

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

実行しようとしたところ以下のようなエラーメッセージが出てしまいました。

ValueError: Negative dimension size caused by subtracting 4 from 2 for 'sequential_2/average_pooling2d_1/AvgPool' (op: 'AvgPool') with input shapes: [?,2,2,1].

該当のソースコード

# coding: utf-8

# 4.4 CIFAR-10の画像を生成するGANの実装

# cifar10      p121
import os
import pandas as pd
import numpy as np
import matplotlib as mpl
mpl.use("Agg")
import keras
import keras.backend as K #
#
import keras.backend
keras.backend.set_image_dim_ordering("th")
from numpy import transpose
#
from keras.layers import Reshape, Flatten, LeakyReLU, Input, Activation, Dense, BatchNormalization, SpatialDropout2D

from keras.layers.convolutional import Conv2D, UpSampling2D, MaxPooling2D, AveragePooling2D

from keras.regularizers import L1L2
from keras.models import Sequential, Model
from keras.optimizers import Adam
from keras.callbacks import TensorBoard
from keras.datasets import cifar10
from keras_adversarial.image_grid_callback import ImageGridCallback
from keras_adversarial import AdversarialModel, simple_gan, gan_targets, fix_names
from keras_adversarial import AdversarialOptimizerSimultaneous, normal_latent_sampling

# i tried below
# from keras_adversarial.examples.image_utils import *
from numpy import *
#

# # 
# from image_utils import dim_ordering_unfix
# from image_utils import dim_ordering_shape

#image_dim_ordering　
def dim_ordering_fix(x):
    if keras.backend.image_dim_ordering() == "th":
        return x
    else:
        pass# return numpy.transpose(x, (0, 2, 3, 1))
        # return x.transpose((0, 2, 3, 1))
        return x.transpose(0, 2, 3, 1)
        # return numpy.transpose(x, (0, 2, 3, 1))

#　めんどいエラー出たERROR
def dim_ordering_unfix(x):
    if keras.backend.image_dim_ordering() == "th":
        return x
    else:
        pass#return numpy.transpose(x, (0, 3, 1, 2))
        # return x.transpose((0, 3, 1, 2))
        return x.transpose(0, 3, 1, 2)
        # return numpy.transpose(x, (0, 3, 1, 2))

def dim_ordering_shape(input_shape):
    if keras.backend.image_dim_ordering() == "th":
        return input_shape
    else:
        return (input_shape[1], input_shape[2], input_shape[0])

def dim_ordering_input(input_shape, name):
    if keras.backend.image_dim_ordering() == "th":
        return Input(input_shape, name=name)
    else:
        return Input((input_shape[1], input_shape[2], input_shape[0]), name=name)

def dim_ordering_reshape(k, w, **kwargs):
    if keras.backend.image_dim_ordering() =="th":
        return Reshape((k, w, w), **kwargs)
    else:
        return Reshape((w, w, k), **kwargs)

def channel_axis():
    if keras.backend.image_dim_ordering() =="th":
        return 1
    else:
        return 3





def model_generator():
    model = Sequential()
    nch = 256
    reg = lambda: L1L2(l1=1e-7, l2=1e-7)
    h = 5
    model.add(Dense(nch * 4 * 4, input_dim=100, kernel_regularizer=reg()))
    pass
    model.add(BatchNormalization())
    model.add(
        Reshape(dim_ordering_shape((nch, 4,  4)))
    )
    model.add(
        Conv2D(int(nch/2), (h,h), padding="same", kernel_regularizer=reg(), data_format="channels_first")
    )
    pass
    model.add(BatchNormalization(axis=1))
    model.add(LeakyReLU(0.2))
    model.add(UpSampling2D(size=(2,2)))
    model.add(Conv2D(int(nch/4), (h,h), padding="same", kernel_regularizer=reg(), data_format="channels_first"))
    pass
    model.add(BatchNormalization(axis=1))
    model.add(LeakyReLU(0.2))
    model.add(UpSampling2D(size=(2,2)))
    model.add(Conv2D(3, (h,h), padding="same", kernel_regularizer=reg(), data_format="channels_first"))
    pass
    model.add(Activation("sigmoid"))
    return model

def model_discriminator():
    nch=256
    h=5
    reg = lambda: L1L2(l1=1e-7, l2=1e-7)
    pass
    c1 = Conv2D(
        int(nch / 4), (h,h),   padding="same", kernel_regularizer=reg(), input_shape=dim_ordering_shape((3,32, 32)), data_format="channels_first"
    )
    pass
    c2 = Conv2D(
        int(nch / 2), (h, h), padding="same",
        kernel_regularizer=reg(), data_format="channels_first"
    )
    pass
    c3 = Conv2D(
        nch, (h,h), padding="same", kernel_regularizer=reg(), data_format="channels_first"
    )
    pass
    c4 = Conv2D(
        1, (h, h), padding="same", kernel_regularizer=reg(), data_format="channels_first"
    )


    def m(dropout):
        model = Sequential()
        model.add(c1)
        model.add(SpatialDropout2D(dropout))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(LeakyReLU(0.2))
        pass
        model.add(c2)
        model.add(SpatialDropout2D(dropout))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(LeakyReLU(0.2))
        pass
        model.add(c3)
        model.add(SpatialDropout2D(dropout))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(LeakyReLU(0.2))
        pass
        model.add(c4)
        model.add(AveragePooling2D(pool_size=(4, 4), padding="valid"))
        model.add(Flatten())
        model.add(Activation("sigmoid"))
        return model
    pass
    return m

def cifar10_process(x):
    x = x.astype(np.float32) / 255.0
    return x

def cifar10_data():
    (xtrain, ytrain), (xtest, ytest) = cifar10.load_data()
    return cifar10_process(xtrain), cifar10_process(xtest)

#　def example_gan 

def example_gan(
        adversarial_optimizer, path, opt_g, opt_d, nb_epoch, generator, discriminator, latent_dim, targets=gan_targets, loss="binary_crossentropy"
    ):
    csvpath = os.path.join(path, "history.csv")
    if os.path.exists(csvpath):
        print("Already exists:{}".format(csvpath))
        return
    print("Training: {}".format(csvpath))
    pass # gan (x -> yfake, yreal), z is gaussian generated on GPU
    pass # can also experiment with uniform_latent_sampling
    d_g = discriminator(0)
    d_d = discriminator(0.5)
    generator.summary()
    d_d.summary()
    gan_g = simple_gan(generator, d_g, None)
    gan_d = simple_gan(generator, d_d, None)
    x = gan_g.inputs[1]
    z = normal_latent_sampling((latent_dim,))(x)
    pass # eliminate z from inputs
    gan_g = Model(
        [x],  fix_names(gan_g([z,x]),gan_g.output_names)
    )
    gan_d = Model(
        [x],
        fix_names(gan_d([z,x]),gan_d.output_names)
    )
    pass # build adversarial model
    model = AdversarialModel(
        player_models=[gan_g, gan_d],
        player_params=[generator.traineble_weights, d_d.trainable_weights],
        player_names=["generator", "discriminator"]
    )
    model.adversarial_compile(
        adversarial_optimizer=adversarial_optimizer,
        player_optimizer=[opt_g, opt_d],
        loss=loss
    )
    pass # create callback to generate images
    zsample = numpy.random.normal(size=(10 * 10, latent_dim))
    pass
    def generator_sampler():
        xpred = generator.predict(zsamples)
        xpred = dim_ordering_unfix(
            xpred(transpose((0, 2, 3, 1)))
        )
        return xpred.reshape((10, 10) + xpred.shape[1:])
    pass
    generator_cb = ImageGridCallback(
        os.path.join(path, "epoch-{:03d}.png"),
        generator_sampler, cmap=None
    )
    pass
    callbacks = [generator_cb]
    if keras.backend.backend() == "tensorflow":
        callbacks.append(
            TensorBoard(log_dir=os.path.join(path, "logs"), histogram_freq=0, write_graph=True, write_images=True)
        )
    pass #train model
    xtrain, xtest = cifar10_data()
    y = targets(xtrain.shape[0])
    pass
    y_test = targets(xtest.shape[0])
    history = model.fit(
        x=xtrain, y=y, validation_data=(xtest, ytest), callbacks=callbacks, epochs=epoch, batch_size=32
    )
    pass # save history to csv
    df = pandas.DataFrame(history.history)
    df.to_csv(csvpath)
    pass #save models
    generator.save(
        os.path.join(path, "generator.h5")
    )
    d_d.save(os.path.join(path, "discriminator.h5"))



def main ():
    pass # z \in R^100
    latent_dim = 100
    pass # x \in R^{28x28}
    pass # generator (z -> x)
    generator = model_generator()
    pass # discriminator (x->y)
    discriminator = model_discriminator()
    if not os.path.exists("output/gan-cifar10"):
        os.makedirs("output/gan-cifar10")
    example_gan(
        AdversarialOptimizerSimultaneous(), "output/gan-cifar10", opt_g=Adam(1e-4, decay=1e-5), opt_d=Adam(1e-3, decay=1e-5),
        nb_epoch=1,
        generator=generator,
        discriminator=discriminator,
        latent_dim=latent_dim
    )





print("A")


if __name__=="__main__":
    main()

# dim_ordering_shape dim_ordering_unfix


print("A")

if __name__ == "__main__":
    print("B")











#

試したこと

githubのisssuesを参考にして、

keras.backend.set_image_dim_ordering("th")
を追記してみたり、

model.add(Conv2D(int(nch/4), (h,h), padding="same", kernel_regularizer=reg())
を以下のようにdata_format="channel_first"を追加したりしました。
model.add(Conv2D(int(nch/4), (h,h), padding="same", kernel_regularizer=reg(), data_format="channels_first"))

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