コード例 #1
0
def gan_model_test():
    latent_dim = 10
    input_dim = 5
    generator = model_generator(input_dim=input_dim, latent_dim=latent_dim)
    discriminator = model_discriminator(input_dim=input_dim)
    gan = simple_gan(generator, discriminator, normal_latent_sampling((latent_dim,)))

    # build adversarial model
    model = AdversarialModel(base_model=gan,
                             player_params=[generator.trainable_weights, discriminator.trainable_weights],
                             player_names=["generator", "discriminator"])
    adversarial_optimizer = AdversarialOptimizerSimultaneous()
    opt_g = Adam(1e-4)
    opt_d = Adam(1e-3)
    loss = 'binary_crossentropy'
    model.adversarial_compile(adversarial_optimizer=adversarial_optimizer,
                              player_optimizers=[opt_g, opt_d],
                              loss=loss)

    # train model
    batch_size = 32
    n = batch_size * 8
    x = np.random.random((n, input_dim))
    y = gan_targets(n)
    fit(model, x, y, nb_epoch=3, batch_size=batch_size)
コード例 #2
0
def main():
    latent_dim = 100
    input_shape = (1, 28, 28)

    generator = model_generator()
    discriminator = model_discriminator(input_shape=input_shape)
    gan = simple_gan(generator, discriminator,
                     normal_latent_sampling((latent_dim, )))

    generator.summary()
    discriminator.summary()
    gan.summary()

    model = AdversarialModel(base_model=gan,
                             player_params=[
                                 generator.trainable_weights,
                                 discriminator.trainable_weights
                             ],
                             player_names=["generator", "discriminator"])
    model.adversarial_compile(
        adversarial_optimizer=AdversarialOptimizerSimultaneous(),
        player_optimizers=[Adam(1e-4, decay=1e-4),
                           Adam(1e-3, decay=1e-4)],
        loss='binary_crossentropy')

    generator_cb = ImageGridCallback(
        "output/gan_convolutional/epoch-{:03d}.png",
        generator_sampler(latent_dim, generator))

    xtrain, xtest = mnist_data()
    xtrain = dim_ordering_fix(xtrain.reshape((-1, 1, 28, 28)))
    xtest = dim_ordering_fix(xtest.reshape((-1, 1, 28, 28)))
    y = gan_targets(xtrain.shape[0])
    ytest = gan_targets(xtest.shape[0])
    history = model.fit(x=xtrain,
                        y=y,
                        validation_data=(xtest, ytest),
                        callbacks=[generator_cb],
                        nb_epoch=100,
                        batch_size=32)
    df = pd.DataFrame(history.history)
    df.to_csv("output/gan_convolutional/history.csv")

    generator.save("output/gan_convolutional/generator.h5")
    discriminator.save("output/gan_convolutional/discriminator.h5")
コード例 #3
0
def main():
    # Uncomment this for debugging
    # sess = K.get_session()
    # sess = tf_debug.LocalCLIDebugWrapperSession(sess)
    # K.set_session(sess)

    xtrain = imageloader.preprocess(
        imageloader.filter_paintings(imageloader.load_training_data()))
    y = gan_targets(xtrain.shape[0])
    y[-1] -= 0.1  # 1-sided label smoothing "hack"
    z = np.random.normal(size=(xtrain.shape[0], latent_dim))

    catalog_file = catalog.load_catalog()
    numerical_categories = catalog.transform_categorical_to_numerical(
        catalog.types(catalog_file))
    one_hots = transform_to_one_hot_vectors(numerical_categories)

    current_epoch, discriminator, generator = load_models()

    generator.summary()
    discriminator.summary()
    gan = simple_gan(generator=generator,
                     discriminator=discriminator,
                     latent_sampling=None)

    # build adversarial model
    model = AdversarialModel(base_model=gan,
                             player_params=[
                                 generator.trainable_weights,
                                 discriminator.trainable_weights
                             ],
                             player_names=["generator", "discriminator"])
    model.adversarial_compile(adversarial_optimizer=optimizer,
                              player_optimizers=[opt_g, opt_d],
                              loss={
                                  "yfake": "binary_crossentropy",
                                  "yreal": "binary_crossentropy",
                                  "yreal_label": "categorical_crossentropy",
                                  "yfake_label": "categorical_crossentropy"
                              })

    callbacks = initialize_callbacks(path, generator, discriminator,
                                     latent_dim)

    y = y[:2] + [one_hots] * 2 + y[2:] + [one_hots] * 2
    history = fit(
        model,
        x=[z, numerical_categories[imageloader.painting_filter()], xtrain],
        y=y,
        callbacks=callbacks,
        nb_epoch=nb_epoch,
        initial_epoch=current_epoch,
        batch_size=32)
コード例 #4
0
def train_on_data_batch(model, data_file, print_interval):
    data = np.load(open_file_in_bucket(data_file, 'song-embeddings-dataset'))
    num_batches = data.shape[0]/batch_size + 1
    batch_losses = []
    batch_indices = [
        get_batch_range(i, batch_size, data.shape[0]) for i in range(num_batches)
    ]
    for i in range(len(batch_indices)):
        start, end = batch_indices[i]
	#batch = rescale_batch(data[start:end, :, :, None])
	batch = data[start:end, :, :, None]
	targets = gan_targets(end - start)
	targets[0] *= np.random.uniform(0.7, 0.9, end - start)[:, None]
	targets[3] *= np.random.uniform(0.7, 0.9, end - start)[:, None]
        losses = model.train_on_batch(batch, targets)
	batch_losses.append(losses)
        if i % print_interval == 0:
	    print losses
	    print np.mean(np.reshape(model.predict(data[start:end, :, :, None]), (4, -1)), axis=1)

    return batch_losses
コード例 #5
0
def main():
    # set path
    root_dir = os.path.abspath('.')
    data_dir = os.path.join(root_dir, 'MData')
            
    # load data
    train = pd.read_csv(os.path.join(data_dir, 'Train', 'train.csv'))
    # test = pd.read_csv(os.path.join(data_dir, 'test.csv'))

    temp = []
    for img_name in train.filename:
        image_path = os.path.join(data_dir, 'Train', 'Images', 'train', img_name)
        img = imread(image_path, flatten=True)
        img = img.astype('float32')
        temp.append(img)
        
    train_x = np.stack(temp)
    train_x = train_x / 255

    epochs = 1 
    batch_size = 128    

    model_1 = model_generator_cifar()
    model_2 = model_discriminator_cifar()

    # gan = simple_gan(model_1, model_2, normal_latent_sampling((100,)))
    latent_dim = 100
    gan = simple_gan(model_1, model_2, latent_sampling=normal_latent_sampling((latent_dim,)))

    model = AdversarialModel(base_model=gan,player_params=[model_1.trainable_weights, model_2.trainable_weights])
    model.adversarial_compile(adversarial_optimizer=AdversarialOptimizerSimultaneous(), player_optimizers=['adam', 'adam'], loss='binary_crossentropy')
    
    history = model.fit(x=train_x, y=gan_targets(train_x.shape[0]), epochs=epochs, batch_size=batch_size)    
    zsamples = np.random.normal(size=(10, 100))
    pred = model_1.predict(zsamples)
    for i in range(pred.shape[0]):
        plt.imshow(pred[i, :], cmap='gray')
        plt.savefig('out/animals/'+str(i)+'.png')
コード例 #6
0
    model = AdversarialModel(base_model=gan,
                             player_params=[
                                 generator.trainable_weights,
                                 descriminator.trainable_weights
                             ],
                             player_names=["generator", "discrminator"])
    model.adversarial_compile(
        adversarial_optimizer=AdversarialOptimizerSimultaneous(),
        player_optimizers=[Adam(1e-4, decay=1e-4),
                           Adam(1e-3, decay=1e-4)],
        loss='binary_crossentropy')
    #train model
    generator_cb = ImageGridCallback(
        'output/gan_convolutional/epoch-{:03d}.png',
        generator_samples(latent_dim, generator))
    xtrain, xtest = mnist_data()
    xtrain = dim_ordering_fix(xtrain.reshape((-1, 1, 28, 28)))
    xtest = dim_ordering_fix(xtest.reshape((-1, 1, 28, 28)))
    y = gan_targets(xtest.shape[0])
    xtest = gan_targets(xtest.shape[0])
    history = model.fit(x=xtrain,
                        y=y,
                        validation_data=(xtest, y),
                        callbacks=[generator_cb],
                        nb_epoch=10,
                        batch_size=32)
    df = pd.DataFrame(history.history)
    df.to_csv('output/gan_convolutional/history.csv')
    generator.save("output/gan_convolutional/generator.h5")
    descriminator.save("output/gan_convolutional/desrimiknator.h5")
コード例 #7
0
gerador.add(Reshape((28, 28)))

# Discriminador
discriminador = Sequential()
discriminador.add(InputLayer(input_shape=(28, 28)))
discriminador.add(Flatten())
discriminador.add(
    Dense(units=500, activation='relu', kernel_regularizer=L1L2(1e-5, 1e-5)))
discriminador.add(
    Dense(units=500, activation='relu', kernel_regularizer=L1L2(1e-5, 1e-5)))
discriminador.add(
    Dense(units=1, activation='sigmoid', kernel_regularizer=L1L2(1e-5, 1e-5)))

gan = simple_gan(gerador, discriminador, normal_latent_sampling((100, )))
modelo = AdversarialModel(
    base_model=gan,
    player_params=[gerador.trainable_weights, discriminador.trainable_weights])
modelo.adversarial_compile(
    adversarial_optimizer=AdversarialOptimizerSimultaneous(),
    player_optimizers=['adam', 'adam'],
    loss='binary_crossentropy')
modelo.fit(x=previsores_treinamento,
           y=gan_targets(60000),
           epochs=100,
           batch_size=256)

amostras = np.random.normal(size=(20, 100))
previsao = gerador.predict(amostras)
for i in range(previsao.shape[0]):
    plt.imshow(previsao[i, :], cmap='gray')
    plt.show()
コード例 #8
0
          kernel_regularizer=L1L2(1e-5, 1e-5)),
    Dense(units=d_output_num_units,
          activation='sigmoid',
          kernel_regularizer=L1L2(1e-5, 1e-5)),
])
"""
print(model_1.summary())
print(model_2.summary())
"""

from keras_adversarial import AdversarialModel, simple_gan, gan_targets
from keras_adversarial import AdversarialOptimizerSimultaneous, normal_latent_sampling

gan = simple_gan(model_1, model_2, normal_latent_sampling((100, )))
model = AdversarialModel(
    base_model=gan,
    player_params=[model_1.trainable_weights, model_2.trainable_weights])
model.adversarial_compile(
    adversarial_optimizer=AdversarialOptimizerSimultaneous(),
    player_optimizers=['adam', 'adam'],
    loss='binary_crossentropy')
print(gan.summary())
history = model.fit(x=train_x,
                    y=gan_targets(train_x.shape[0]),
                    epochs=10,
                    batch_size=batch_size)
print(gan.summary())

plt.plot(history.history['player_0_loss'])
plt.plot(history.history['player_1_loss'])
plt.plot(history.history['loss'])
コード例 #9
0
def gan():
    # define variables
    # 初始化一些参数
    g_input_shape = 100  # 生成器输入层节点数
    d_input_shape = (28, 28)  # 辨别器输入层节点数
    hidden_1_num_units = 500
    hidden_2_num_units = 500
    g_output_num_units = 784  # 生成器输出层节点数28*28
    d_output_num_units = 1  # 辨别器输出层节点数1个,辨别是否是真实图片
    epochs = 100
    batch_size = 128

    # 定义生成器,用于生成图片
    model_g = Sequential([
        Dense(units=hidden_1_num_units,
              input_dim=g_input_shape,
              activation='relu',
              kernel_regularizer=L1L2(1e-5, 1e-5)),
        Dense(units=hidden_2_num_units,
              activation='relu',
              kernel_regularizer=L1L2(1E-5, 1E-5)),
        Dense(units=g_output_num_units,
              activation='sigmoid',
              kernel_regularizer=L1L2(1E-5, 1E-5)),
        Reshape(d_input_shape)
    ])

    # 定义分辨器,用于辨别图片
    model_d = Sequential([
        InputLayer(input_shape=d_input_shape),
        Flatten(),
        Dense(units=hidden_1_num_units,
              activation='relu',
              kernel_regularizer=L1L2(1E-5, 1E-5)),
        Dense(units=hidden_2_num_units,
              activation='relu',
              kernel_regularizer=L1L2(1E-5, 1E-5)),
        Dense(units=d_output_num_units,
              activation='sigmoid',
              kernel_regularizer=L1L2(1E-5, 1E-5))
    ])
    # model_g.summary()
    # model_d.summary()

    from keras_adversarial import AdversarialModel, simple_gan, gan_targets
    from keras_adversarial import AdversarialOptimizerSimultaneous, normal_latent_sampling
    # 开始训练gan网络
    gan = simple_gan(model_g, model_d, normal_latent_sampling((100, )))
    # gan.summary()
    # 在keras2.2.x版本中,下面的代码会报错,keras2.1.2中不会
    model = AdversarialModel(
        base_model=gan,
        player_params=[model_g.trainable_weights, model_d.trainable_weights])
    model.adversarial_compile(
        adversarial_optimizer=AdversarialOptimizerSimultaneous(),
        player_optimizers=['adam', 'adam'],
        loss='binary_crossentropy')
    # 使用训练数据进行训练
    # 把keras_adversarial clone到了本地,然后替换掉了pip安装的keras_adversarial
    # 解决了这个报错AttributeError: 'AdversarialModel' object has no attribute '_feed_output_shapes'
    history = model.fit(x=train_x,
                        y=gan_targets(train_x.shape[0]),
                        epochs=epochs,
                        batch_size=batch_size)
    # 保存为h5文件
    model_g.save_weights('gan1_g.h5')
    model_d.save_weights('gan1_d.h5')
    model.save_weights('gan1.h5')

    # 绘制训练结果的loss
    plt.plot(history.history['player_0_loss'], label='player_0_loss')
    plt.plot(history.history['player_1_loss'], label='player_1_loss')
    plt.plot(history.history['loss'], label='loss')
    plt.show()

    # 训练之后100次之后生成的图像
    # 随机生成10组数据,生成10张图像
    zsample = np.random.normal(size=(10, 100))
    pred = model_g.predict(zsample)
    print(pred.shape)  # (10,28,28)
    for i in range(pred.shape[0]):
        plt.imshow(pred[i, :], cmap='gray')
        plt.show()
コード例 #10
0
def main():
    # z \in R^100
    latent_dim = 100
    # x \in R^{28x28}
    input_shape = (28, 28)

    # generator (z -> x)
    generator = model_generator(latent_dim, input_shape)
    # encoder (x ->z)
    encoder = model_encoder(latent_dim, input_shape)
    # autoencoder (x -> x')
    autoencoder = Model(encoder.inputs, generator(encoder(encoder.inputs)))
    # discriminator (x -> y)
    discriminator = model_discriminator(latent_dim, input_shape)
    # bigan (x - > yfake, yreal), z generated on GPU
    bigan = simple_bigan(generator, encoder, discriminator,
                         normal_latent_sampling((latent_dim, )))

    generative_params = generator.trainable_weights + encoder.trainable_weights

    # print summary of models
    generator.summary()
    encoder.summary()
    discriminator.summary()
    bigan.summary()
    autoencoder.summary()

    # build adversarial model
    model = AdversarialModel(
        base_model=bigan,
        player_params=[generative_params, discriminator.trainable_weights],
        player_names=["generator", "discriminator"])
    model.adversarial_compile(
        adversarial_optimizer=AdversarialOptimizerSimultaneous(),
        player_optimizers=[Adam(1e-4, decay=1e-4),
                           Adam(1e-3, decay=1e-4)],
        loss='binary_crossentropy')

    # train model
    xtrain, xtest = mnist_data()

    def generator_sampler():
        zsamples = np.random.normal(size=(10 * 10, latent_dim))
        return generator.predict(zsamples).reshape((10, 10, 28, 28))

    generator_cb = ImageGridCallback("output/bigan/generated-epoch-{:03d}.png",
                                     generator_sampler)

    def autoencoder_sampler():
        xsamples = n_choice(xtest, 10)
        xrep = np.repeat(xsamples, 9, axis=0)
        xgen = autoencoder.predict(xrep).reshape((10, 9, 28, 28))
        xsamples = xsamples.reshape((10, 1, 28, 28))
        x = np.concatenate((xsamples, xgen), axis=1)
        return x

    autoencoder_cb = ImageGridCallback(
        "output/bigan/autoencoded-epoch-{:03d}.png", autoencoder_sampler)

    y = gan_targets(xtrain.shape[0])
    ytest = gan_targets(xtest.shape[0])
    history = model.fit(x=xtrain,
                        y=y,
                        validation_data=(xtest, ytest),
                        callbacks=[generator_cb, autoencoder_cb],
                        nb_epoch=100,
                        batch_size=32)
    df = pd.DataFrame(history.history)
    df.to_csv("output/bigan/history.csv")

    encoder.save("output/bigan/encoder.h5")
    generator.save("output/bigan/generator.h5")
    discriminator.save("output/bigan/discriminator.h5")
コード例 #11
0
# discriminator
model_2 = Sequential([
    InputLayer(input_shape=d_input_shape),
    
    Flatten(),
        
    Dense(units=hidden_1_num_units, activation='relu', kernel_regularizer=L1L2(1e-5, 1e-5)),

    Dense(units=hidden_2_num_units, activation='relu', kernel_regularizer=L1L2(1e-5, 1e-5)),
        
    Dense(units=d_output_num_units, activation='sigmoid', kernel_regularizer=L1L2(1e-5, 1e-5)),
])

print model_1.summary()
print model_2.summary()

from keras_adversarial import AdversarialModel, simple_gan, gan_targets
from keras_adversarial import AdversarialOptimizerSimultaneous, normal_latent_sampling

gan = simple_gan(model_1, model_2, normal_latent_sampling((100,)))
model = AdversarialModel(base_model=gan,player_params=[model_1.trainable_weights, model_2.trainable_weights])
model.adversarial_compile(adversarial_optimizer=AdversarialOptimizerSimultaneous(), player_optimizers=['adam', 'adam'], loss='binary_crossentropy')

print gan.summary()

history = model.fit(x=train_x, y=gan_targets(train_x.shape[0]), epochs=10, batch_size=batch_size)




コード例 #12
0
    # print summary of models
    generator.summary()
    discriminator.summary()
    gan.summary()

    # build adversarial model
    model = AdversarialModel(base_model=gan,
                             player_params=[generator.trainable_weights, discriminator.trainable_weights],
                             player_names=["generator", "discriminator"])
    model.adversarial_compile(adversarial_optimizer=AdversarialOptimizerSimultaneous(),
                              player_optimizers=[Adam(1e-4, decay=1e-4), Adam(1e-3, decay=1e-4)],
                              loss='binary_crossentropy')

    # train model
    generator_cb = ImageGridCallback("output/gan_convolutional/epoch-{:03d}.png",
                                     generator_sampler(latent_dim, generator))

    xtrain, xtest = mnist_data()
    xtrain = dim_ordering_fix(xtrain.reshape((-1, 1, 28, 28)))
    xtest = dim_ordering_fix(xtest.reshape((-1, 1, 28, 28)))
    y = gan_targets(xtrain.shape[0])
    ytest = gan_targets(xtest.shape[0])
    history = model.fit(x=xtrain, y=y, validation_data=(xtest, ytest), callbacks=[generator_cb], nb_epoch=100,
                        batch_size=32)
    df = pd.DataFrame(history.history)
    df.to_csv("output/gan_convolutional/history.csv")

    generator.save("output/gan_convolutional/generator.h5")
    discriminator.save("output/gan_convolutional/discriminator.h5")
コード例 #13
0
 def test_generator():
     g = test_datagen.flow(xtest, batch_size=batch_size)
     for d in g:
         yield (d, gan_targets(batch_size), None)
コード例 #14
0
 def train_generator():
     g = train_datagen.flow(xtrain, batch_size=batch_size)
     for d in g:
         yield (d, gan_targets(batch_size), None)
コード例 #15
0
def main():
    # z \in R^100
    latent_dim = 100
    # x \in R^{28x28}
    input_shape = (28, 28)

    # generator (z -> x)
    generator = model_generator(latent_dim, input_shape)
    # encoder (x ->z)
    encoder = model_encoder(latent_dim, input_shape)
    # autoencoder (x -> x')
    autoencoder = Model(encoder.inputs, generator(encoder(encoder.inputs)))
    # discriminator (x -> y)
    discriminator = model_discriminator(latent_dim, input_shape)
    # bigan (x - > yfake, yreal), z generated on GPU
    bigan = simple_bigan(generator, encoder, discriminator, normal_latent_sampling((latent_dim,)))

    generative_params = generator.trainable_weights + encoder.trainable_weights

    # print summary of models
    generator.summary()
    encoder.summary()
    discriminator.summary()
    bigan.summary()
    autoencoder.summary()

    # build adversarial model
    model = AdversarialModel(base_model=bigan,
                             player_params=[generative_params, discriminator.trainable_weights],
                             player_names=["generator", "discriminator"])
    model.adversarial_compile(adversarial_optimizer=AdversarialOptimizerSimultaneous(),
                              player_optimizers=[Adam(1e-4, decay=1e-4), Adam(1e-3, decay=1e-4)],
                              loss='binary_crossentropy')

    # train model
    xtrain, xtest = mnist_data()

    def generator_sampler():
        zsamples = np.random.normal(size=(10 * 10, latent_dim))
        return generator.predict(zsamples).reshape((10, 10, 28, 28))

    generator_cb = ImageGridCallback("output/bigan/generated-epoch-{:03d}.png", generator_sampler)

    def autoencoder_sampler():
        xsamples = n_choice(xtest, 10)
        xrep = np.repeat(xsamples, 9, axis=0)
        xgen = autoencoder.predict(xrep).reshape((10, 9, 28, 28))
        xsamples = xsamples.reshape((10, 1, 28, 28))
        x = np.concatenate((xsamples, xgen), axis=1)
        return x

    autoencoder_cb = ImageGridCallback("output/bigan/autoencoded-epoch-{:03d}.png", autoencoder_sampler)

    y = gan_targets(xtrain.shape[0])
    ytest = gan_targets(xtest.shape[0])
    history = model.fit(x=xtrain, y=y, validation_data=(xtest, ytest), callbacks=[generator_cb, autoencoder_cb],
                        nb_epoch=100, batch_size=32)
    df = pd.DataFrame(history.history)
    df.to_csv("output/bigan/history.csv")

    encoder.save("output/bigan/encoder.h5")
    generator.save("output/bigan/generator.h5")
    discriminator.save("output/bigan/discriminator.h5")
コード例 #16
0
ファイル: m_gan.py プロジェクト: mbc1990/animal-generator
def main():
    data_dir = "goldens_filtered_32x32_gray/"
    out_dir = "m_gan_out/"
    epochs = 1
    batch_size = 64

    # TODO: Research why these values were chosen
    opt_g = Adam(1e-4, decay=1e-5)
    opt_d = Adam(1e-3, decay=1e-5)
    loss = 'binary_crossentropy'
    latent_dim = 100
    adversarial_optimizer = AdversarialOptimizerSimultaneous()

    # My simple models
    # generator = get_generator()
    # discriminator = get_discriminator()

    # CIFAR example convolutional models
    generator = get_generator_cifar()
    discriminator = get_discriminator_cifar()

    gan = simple_gan(generator, discriminator,
                     normal_latent_sampling((latent_dim, )))

    # print summary of models
    generator.summary()
    discriminator.summary()
    gan.summary()

    # build adversarial model
    model = AdversarialModel(base_model=gan,
                             player_params=[
                                 generator.trainable_weights,
                                 discriminator.trainable_weights
                             ],
                             player_names=["generator", "discriminator"])
    model.adversarial_compile(adversarial_optimizer=adversarial_optimizer,
                              player_optimizers=[opt_g, opt_d],
                              loss=loss)

    temp = []
    for img_name in os.listdir(data_dir):
        image_path = data_dir + img_name
        img = imread(image_path)
        img = img.astype('float32')
        temp.append(img)

    train_x = np.stack(temp)
    train_x = train_x / 255

    # Side effects
    model.fit(x=train_x,
              y=gan_targets(train_x.shape[0]),
              epochs=epochs,
              batch_size=batch_size)

    zsamples = np.random.normal(size=(10, latent_dim))
    pred = generator.predict(zsamples)
    for i in range(pred.shape[0]):
        plt.imshow(pred[i, :])
        plt.savefig(out_dir + str(i) + '.png')
コード例 #17
0
def example_bigan(path, adversarial_optimizer):
    # z \in R^100
    latent_dim = 25
    # x \in R^{28x28}
    input_shape = (28, 28)

    # generator (z -> x)
    generator = model_generator(latent_dim, input_shape)
    # encoder (x ->z)
    encoder = model_encoder(latent_dim, input_shape)
    # autoencoder (x -> x')
    autoencoder = Model(encoder.inputs, generator(encoder(encoder.inputs)))
    # discriminator (x -> y)
    discriminator_train, discriminator_test = model_discriminator(
        latent_dim, input_shape)
    # bigan (z, x - > yfake, yreal)
    bigan_generator = simple_bigan(generator, encoder, discriminator_test)
    bigan_discriminator = simple_bigan(generator, encoder, discriminator_train)
    # z generated on GPU based on batch dimension of x
    x = bigan_generator.inputs[1]
    z = normal_latent_sampling((latent_dim, ))(x)
    # eliminate z from inputs
    bigan_generator = Model([x],
                            fix_names(bigan_generator([z, x]),
                                      bigan_generator.output_names))
    bigan_discriminator = Model([x],
                                fix_names(bigan_discriminator([z, x]),
                                          bigan_discriminator.output_names))

    generative_params = generator.trainable_weights + encoder.trainable_weights

    # print summary of models
    generator.summary()
    encoder.summary()
    discriminator_train.summary()
    bigan_discriminator.summary()
    autoencoder.summary()

    # build adversarial model
    model = AdversarialModel(
        player_models=[bigan_generator, bigan_discriminator],
        player_params=[
            generative_params, discriminator_train.trainable_weights
        ],
        player_names=["generator", "discriminator"])
    model.adversarial_compile(
        adversarial_optimizer=adversarial_optimizer,
        player_optimizers=[Adam(1e-4, decay=1e-4),
                           Adam(1e-3, decay=1e-4)],
        loss='binary_crossentropy')

    # load mnist data
    xtrain, xtest = mnist_data()

    # callback for image grid of generated samples
    def generator_sampler():
        zsamples = np.random.normal(size=(10 * 10, latent_dim))
        return generator.predict(zsamples).reshape((10, 10, 28, 28))

    generator_cb = ImageGridCallback(
        os.path.join(path, "generated-epoch-{:03d}.png"), generator_sampler)

    # callback for image grid of autoencoded samples
    def autoencoder_sampler():
        xsamples = n_choice(xtest, 10)
        xrep = np.repeat(xsamples, 9, axis=0)
        xgen = autoencoder.predict(xrep).reshape((10, 9, 28, 28))
        xsamples = xsamples.reshape((10, 1, 28, 28))
        x = np.concatenate((xsamples, xgen), axis=1)
        return x

    autoencoder_cb = ImageGridCallback(
        os.path.join(path, "autoencoded-epoch-{:03d}.png"),
        autoencoder_sampler)

    # train network
    y = gan_targets(xtrain.shape[0])
    ytest = gan_targets(xtest.shape[0])
    history = model.fit(x=xtrain,
                        y=y,
                        validation_data=(xtest, ytest),
                        callbacks=[generator_cb, autoencoder_cb],
                        nb_epoch=100,
                        batch_size=32)

    # save history
    df = pd.DataFrame(history.history)
    df.to_csv(os.path.join(path, "history.csv"))

    # save model
    encoder.save(os.path.join(path, "encoder.h5"))
    generator.save(os.path.join(path, "generator.h5"))
    discriminator_train.save(os.path.join(path, "discriminator.h5"))
コード例 #18
0
# Gerador
gerador = Sequential()
gerador.add(Dense(units = 500, input_dim = 100, activation = 'relu', 
                  kernel_regularizer = L1L2(1e-5, 1e-5)))
gerador.add(Dense(units = 500, activation = 'relu', 
                  kernel_regularizer = L1L2(1e-5, 1e-5)))
gerador.add(Dense(units = 784, activation = 'sigmoid', kernel_regularizer = L1L2(1e-5, 1e-5)))
gerador.add(Reshape((28,28)))

# Discriminador
discriminador = Sequential()
discriminador.add(InputLayer(input_shape=(28,28)))
discriminador.add(Flatten())
discriminador.add(Dense(units = 500, activation = 'relu', kernel_regularizer = L1L2(1e-5, 1e-5)))
discriminador.add(Dense(units = 500, activation = 'relu', kernel_regularizer = L1L2(1e-5, 1e-5)))
discriminador.add(Dense(units = 1, activation = 'sigmoid', kernel_regularizer = L1L2(1e-5, 1e-5)))

gan = simple_gan(gerador, discriminador, normal_latent_sampling((100,)))
modelo = AdversarialModel(base_model = gan,
                          player_params = [gerador.trainable_weights, 
                                           discriminador.trainable_weights])
modelo.adversarial_compile(adversarial_optimizer = AdversarialOptimizerSimultaneous(),
                           player_optimizers = ['adam', 'adam'],
                           loss = 'binary_crossentropy')
modelo.fit(x = previsores_treinamento, y = gan_targets(60000), epochs = 100, batch_size = 256)

amostras = np.random.normal(size = (20,100))
previsao = gerador.predict(amostras)
for i in range(previsao.shape[0]):
    plt.imshow(previsao[i, :], cmap='gray')
    plt.show()
コード例 #19
0
ファイル: tutorial.py プロジェクト: mbc1990/animal-generator
def main():
    # to stop potential randomness
    seed = 128
    rng = np.random.RandomState(seed)

    # set path
    root_dir = os.path.abspath('.')
    data_dir = os.path.join(root_dir, 'Data')

    # load data
    train = pd.read_csv(os.path.join(data_dir, 'Train', 'train.csv'))
    # test = pd.read_csv(os.path.join(data_dir, 'test.csv'))

    temp = []
    for img_name in train.filename:
        image_path = os.path.join(data_dir, 'Train', 'Images', 'train',
                                  img_name)
        img = imread(image_path, flatten=True)
        img = img.astype('float32')
        temp.append(img)

    train_x = np.stack(temp)

    train_x = train_x / 255

    # print image
    img_name = rng.choice(train.filename)
    filepath = os.path.join(data_dir, 'Train', 'Images', 'train', img_name)

    img = imread(filepath, flatten=True)

    # pylab stuff, who f****n knows
    # pylab.imshow(img, cmap='gray')
    # pylab.axis('off')
    # pylab.show()

    # Levers
    g_input_shape = 100
    d_input_shape = (28, 28)
    hidden_1_num_units = 500
    hidden_2_num_units = 500
    g_output_num_units = 784
    d_output_num_units = 1
    epochs = 25
    batch_size = 128

    # generator
    model_1 = Sequential([
        Dense(units=hidden_1_num_units,
              input_dim=g_input_shape,
              activation='relu',
              kernel_regularizer=L1L2(1e-5, 1e-5)),
        Dense(units=hidden_2_num_units,
              activation='relu',
              kernel_regularizer=L1L2(1e-5, 1e-5)),
        Dense(units=g_output_num_units,
              activation='sigmoid',
              kernel_regularizer=L1L2(1e-5, 1e-5)),
        Reshape(d_input_shape),
    ])

    # discriminator
    model_2 = Sequential([
        InputLayer(input_shape=d_input_shape),
        Flatten(),
        Dense(units=hidden_1_num_units,
              activation='relu',
              kernel_regularizer=L1L2(1e-5, 1e-5)),
        Dense(units=hidden_2_num_units,
              activation='relu',
              kernel_regularizer=L1L2(1e-5, 1e-5)),
        Dense(units=d_output_num_units,
              activation='sigmoid',
              kernel_regularizer=L1L2(1e-5, 1e-5)),
    ])
    gan = simple_gan(model_1, model_2, normal_latent_sampling((100, )))
    model = AdversarialModel(
        base_model=gan,
        player_params=[model_1.trainable_weights, model_2.trainable_weights])
    model.adversarial_compile(
        adversarial_optimizer=AdversarialOptimizerSimultaneous(),
        player_optimizers=['adam', 'adam'],
        loss='binary_crossentropy')

    history = model.fit(x=train_x,
                        y=gan_targets(train_x.shape[0]),
                        epochs=10,
                        batch_size=batch_size)
    zsamples = np.random.normal(size=(10, 100))
    pred = model_1.predict(zsamples)
    for i in range(pred.shape[0]):
        plt.imshow(pred[i, :], cmap='gray')
        plt.savefig('out/numbers/' + str(i) + '.png')
コード例 #20
0
          kernel_regularizer=L1L2(1e-5, 1e-5),
          bias_initializer='ones',
          bias_constraint=non_neg()))

gan = simple_gan(generator, discriminator, normal_latent_sampling((25, )))
model = AdversarialModel(base_model=gan,
                         player_params=[
                             generator.trainable_weights,
                             discriminator.trainable_weights
                         ])
model.adversarial_compile(
    adversarial_optimizer=AdversarialOptimizerSimultaneous(),
    player_optimizers=['adam', 'adam'],
    loss='binary_crossentropy')
test = model.fit(x=x_train,
                 y=gan_targets(np.array(x_train).shape[0]),
                 epochs=100,
                 batch_size=50,
                 shuffle=True)

discriminator.save('discriminator.h5')
generator.save('generator.h5')

generator = load_model('generator.h5')

houseTest = []
pred = generator.predict(np.random.uniform(-1.0, 1.0, size=(1, 25)))

for i in range(len(pred)):
    houseTest.append(normalizationVector[i] * pred[i])
print(houseTest)
コード例 #21
0
# print(generator.summary())
# print(discriminator.summary())

# Build a GAN
gan = simple_gan(generator=generator,
                 discriminator=discriminator,
                 latent_sampling=normal_latent_sampling((100, )))
model = AdversarialModel(
    base_model=gan,
    player_params=[
        generator.trainable_weights, discriminator.trainable_weights
    ],
)

model.adversarial_compile(
    adversarial_optimizer=AdversarialOptimizerSimultaneous(),
    player_optimizers=['adam', 'adam'],
    loss='binary_crossentropy')
history = model.fit(train_data,
                    gan_targets(train_data.shape[0]),
                    epochs=10,
                    batch_size=batch_size)

sample = np.random.normal(size=(10, 100))
pred = generator.predict(sample)

for i in range(pred.shape[0]):
    plt.imshow(pred[i, :], cmap='gray')
    plt.show()

# print(model.summary())
コード例 #22
0
def driver_gan(path, adversarial_optimizer):
    # z \in R^100
    latent_dim = 3
    # x \in R^{28x28}
    input_shape = (15, 6)

    # generator (z -> x)
    generator = model_generator(latent_dim, input_shape)
    # encoder (x ->z)
    encoder = model_encoder(latent_dim, input_shape)
    # autoencoder (x -> x')
    autoencoder = Model(encoder.inputs, generator(encoder(encoder.inputs)))
    # discriminator (x -> y)
    discriminator_train, discriminator_test = model_discriminator(latent_dim, input_shape)
    # bigan (z, x - > yfake, yreal)
    bigan_generator = simple_bigan(generator, encoder, discriminator_test)
    bigan_discriminator = simple_bigan(generator, encoder, discriminator_train)
    # z generated on GPU based on batch dimension of x
    x = bigan_generator.inputs[1]
    z = normal_latent_sampling((latent_dim,))(x)
    # eliminate z from inputs
    bigan_generator = Model([x], fix_names(bigan_generator([z, x]), bigan_generator.output_names))
    bigan_discriminator = Model([x], fix_names(bigan_discriminator([z, x]), bigan_discriminator.output_names))

    # Merging encoder weights and generator weights
    generative_params = generator.trainable_weights + encoder.trainable_weights

    # print summary of models
    generator.summary()
    encoder.summary()
    discriminator_train.summary()
    bigan_discriminator.summary()
    autoencoder.summary()

    # build adversarial model
    model = AdversarialModel(player_models=[bigan_generator, bigan_discriminator],
                             player_params=[generative_params, discriminator_train.trainable_weights],
                             player_names=["generator", "discriminator"])
    model.adversarial_compile(adversarial_optimizer=adversarial_optimizer,
                              player_optimizers=[Adam(1e-7, decay=1e-7), Adam(1e-6, decay=1e-7)],
                              loss='binary_crossentropy')

    # load driver data
    train_dataset = [1,2,5]
    test_dataset = [3,4]
    train_reader = data_base(train_dataset)
    test_reader = data_base(test_dataset)
    xtrain, xtest = train_reader.read_files(),test_reader.read_files()
    # ---------------------------------------------------------------------------------
    # callback for image grid of generated samples
    def generator_sampler():
        zsamples = np.random.normal(size=(1 * 1, latent_dim))  #---------------------------------> (10,10)
        return generator.predict(zsamples).reshape((1, 1, 15, 6))# confused ***********************************default (10,10,28,28)


    # callback for image grid of autoencoded samples
    def autoencoder_sampler():
        xsamples = n_choice(xtest, 10) # the number of testdata set
        xrep = np.repeat(xsamples, 5, axis=0) # the number of train dataset
        xgen = autoencoder.predict(xrep).reshape((1, 1, 15, 6))
        xsamples = xsamples.reshape((1, 1, 15, 6))
        x = np.concatenate((xsamples, xgen), axis=1)
        return x


    # train network
    y = gan_targets(xtrain.shape[0])
    ytest = gan_targets(xtest.shape[0])
    history = model.fit(x=xtrain, y=y, validation_data=(xtest, ytest),
                        nb_epoch=25, batch_size=10, verbose=0)

    # save history
    df = pd.DataFrame(history.history)
    df.to_csv(os.path.join(path, "history.csv"))

    # save model
    encoder.save(os.path.join(path, "encoder.h5"))
    generator.save(os.path.join(path, "generator.h5"))
    discriminator_train.save(os.path.join(path, "discriminator.h5"))
コード例 #23
0
        dictio = pickle.load(fp)

    data = dictio['SSTMW']
    x = data[:, :92, :92].astype(np.float32)
    xtrain = x[:-10]
    xtest = x[-10:]

    mini = np.min(xtrain.ravel())
    maxi = np.max(xtrain.ravel())
    xtrain = (xtrain - mini) / (maxi - mini)
    xtest = (xtest - mini) / (maxi - mini)

    xtrain = dim_ordering_fix(xtrain.reshape((-1, 1, 92, 92)))
    xtest = dim_ordering_fix(xtest.reshape((-1, 1, 92, 92)))

    y = gan_targets(xtrain.shape[0])
    ytest = gan_targets(xtest.shape[0])
    history = model.fit(x=xtrain,
                        y=y,
                        validation_data=(xtest, ytest),
                        callbacks=[generator_cb],
                        nb_epoch=100,
                        batch_size=10)
    df = pd.DataFrame(history.history)
    df.to_csv("output/gan_convolutional/history.csv")

    generator.save("output/gan_convolutional/generator.h5")
    discriminator.save("output/gan_convolutional/discriminator.h5")

    #  print(xtrain[0])
    """
コード例 #24
0
def example_bigan(path, adversarial_optimizer):
    # z \in R^100
    latent_dim = 25
    # x \in R^{28x28}
    input_shape = (28, 28)

    # generator (z -> x)
    generator = model_generator(latent_dim, input_shape)
    # encoder (x ->z)
    encoder = model_encoder(latent_dim, input_shape)
    # autoencoder (x -> x')
    autoencoder = Model(encoder.inputs, generator(encoder(encoder.inputs)))
    # discriminator (x -> y)
    discriminator_train, discriminator_test = model_discriminator(latent_dim, input_shape)
    # bigan (z, x - > yfake, yreal)
    bigan_generator = simple_bigan(generator, encoder, discriminator_test)
    bigan_discriminator = simple_bigan(generator, encoder, discriminator_train)
    # z generated on GPU based on batch dimension of x
    x = bigan_generator.inputs[1]
    z = normal_latent_sampling((latent_dim,))(x)
    # eliminate z from inputs
    bigan_generator = Model([x], fix_names(bigan_generator([z, x]), bigan_generator.output_names))
    bigan_discriminator = Model([x], fix_names(bigan_discriminator([z, x]), bigan_discriminator.output_names))

    generative_params = generator.trainable_weights + encoder.trainable_weights

    # print summary of models
    generator.summary()
    encoder.summary()
    discriminator_train.summary()
    bigan_discriminator.summary()
    autoencoder.summary()

    # build adversarial model
    model = AdversarialModel(player_models=[bigan_generator, bigan_discriminator],
                             player_params=[generative_params, discriminator_train.trainable_weights],
                             player_names=["generator", "discriminator"])
    model.adversarial_compile(adversarial_optimizer=adversarial_optimizer,
                              player_optimizers=[Adam(1e-4, decay=1e-4), Adam(1e-3, decay=1e-4)],
                              loss='binary_crossentropy')

    # load mnist data
    xtrain, xtest = mnist_data()

    # callback for image grid of generated samples
    def generator_sampler():
        zsamples = np.random.normal(size=(10 * 10, latent_dim))
        return generator.predict(zsamples).reshape((10, 10, 28, 28))

    generator_cb = ImageGridCallback(os.path.join(path, "generated-epoch-{:03d}.png"), generator_sampler)

    # callback for image grid of autoencoded samples
    def autoencoder_sampler():
        xsamples = n_choice(xtest, 10)
        xrep = np.repeat(xsamples, 9, axis=0)
        xgen = autoencoder.predict(xrep).reshape((10, 9, 28, 28))
        xsamples = xsamples.reshape((10, 1, 28, 28))
        x = np.concatenate((xsamples, xgen), axis=1)
        return x

    autoencoder_cb = ImageGridCallback(os.path.join(path, "autoencoded-epoch-{:03d}.png"), autoencoder_sampler)

    # train network
    y = gan_targets(xtrain.shape[0])
    ytest = gan_targets(xtest.shape[0])
    history = model.fit(x=xtrain, y=y, validation_data=(xtest, ytest), callbacks=[generator_cb, autoencoder_cb],
                        nb_epoch=100, batch_size=32)

    # save history
    df = pd.DataFrame(history.history)
    df.to_csv(os.path.join(path, "history.csv"))

    # save model
    encoder.save(os.path.join(path, "encoder.h5"))
    generator.save(os.path.join(path, "generator.h5"))
    discriminator_train.save(os.path.join(path, "discriminator.h5"))