import keras
from keras.models import Model
from keras.layers import ...

from keras.datasets import mnist
(x_train,y_train),(x_test,y_test)=mnist.load_data()
x_train=x_train.reshape((-1,28,28,1))
x_test=x_test.reshape((-1,28,28,1))

"""每次處理幾筆資料:"""
batch_size=32
"""生成batch_size個隨機的seed:"""
seed=np.random.normal(size=(batch_size,128))
"""根據seeds生成圖片:"""
generated_img=generator.predict(seed)
"""取得真實的圖片:"""
true_img=get_true_img(batch_size)
"""discriminator要將真實圖片辨別成1(true)，生成圖片辨別成0(faked):"""
discriminator.train_on_batch(true_img,np.ones((bacth_size,)))
discriminator.train_on_batch(generated_img,np.zeros((bacth_size,)))

"""每次處理幾筆資料:"""
batch_size=32
"""生成batch_size個隨機的seed:"""
seed=np.random.normal(size=(batch_size,128))
"""訓練結合的網路:"""
train_gen.train_on_batch(seed,np.ones((batch_size,)))

IN=Input((128,))
IMG=generator(IN)
discriminator.trainable=False
OUT=discriminator(IMG)
train_gen=Model(IN,OUT)
train_gen.compile(loss='binary_crossentropy',optimizer='Adam')

from keras.datasets import mnist
(x1,y1),(x2,y2)=mnist.load_data()
"""取的所有標籤是0的圖片:"""
indices=[]
for i in range(len(y1)):
    if y1[i]==0:
        indices.append(i)
"""隨機出batch_size個indices，並回傳這些indices對應的圖片:"""
def get_true_img(bacth_size):
    random_indices=np.random.randint(0,len(indices),size=(batch_size,))
    return x1[random_indices]
"""
a=[0,1,4,9,16]
b=[4,2,1,0,1]
a[b]==[16,4,1,0,1]
"""

batch_size=32
epochs=50
"""預先設置好全0和全1的陣列:"""
true=np.ones(batch_size)
false=np.zeros(batch_size)
for epoch in range(epochs):
    """產生隨機的batch_size個種子:"""
    seed=np.random.normal(size=(batch_size,))
    """根據seed生成圖片:"""
    gen_img=generator.predict(seed)
    """取得batch_size張真實圖片:"""
    true_img=get_true_img(batch_size)
    """訓練:"""
    discriminator.train_on_batch(gen_img,false)
    discriminator.train_on_batch(true_img,true)
    train_gen.train_on_batch(seed,true)

import numpy as np
from keras.models import Model
from keras.layers import Input
from keras.optimizers import Adam
from keras.datasets import mnist
seed_shape=(128,)
img_shape=(28,28)
########################################################################

# building generator

########################################################################

# building discriminator

########################################################################
IN=Input((128,))
IMG=generator(IN)
discriminator.trainable=False
OUT=discriminator(IMG)
train_gen=Model(IN,OUT)
train_gen.compile(loss='binary_crossentropy',optimizer=Adam())
########################################################################
(x1,y1),(x2,y2)=mnist.load_data()
"""取的所有標籤是0的圖片:"""
indices=[]
for i in range(len(y1)):
    if y1[i]==0:
        indices.append(i)
"""隨機出batch_size個indices，並回傳這些indices對應的圖片:"""
def get_true_img(bacth_size):
    random_indices=np.random.randint(0,len(indices),size=(batch_size,))
    return x1[random_indices]
########################################################################
batch_size=32
epochs=1000
"""預先設置好全0和全1的陣列:"""
true=np.ones(batch_size)
false=np.zeros(batch_size)
for epoch in range(epochs):
    """產生隨機的batch_size個種子:"""
    seed=np.random.normal(size=(batch_size,))
    """根據seed生成圖片:"""
    gen_img=generator.predict(seed)
    """取得batch_size張真實圖片:"""
    true_img=get_true_img(batch_size)
    """訓練:"""
    discriminator.train_on_batch(gen_img,false)
    discriminator.train_on_batch(true_img,true)
    train_gen.train_on_batch(seed,true)

def sample():
    n,m=4,6
    """建立n*m格圖:"""
    fig,ax=plt.subplots(n,m)
    """隨機n*m個seeds:"""
    seed=np.random.normal(size=(n*m,)+seed_shape)
    """取得generator根據seeds生成的圖片:"""
    img=generator.predict(seed).reshape((n,m)+img_shape)
    """畫圖:"""
    for i in range(n):
        for j in range(m):
            ax[i][j].axis('off')
            ax[i][j].imshow(img[i][j],cmap='binary_r')
    plt.show()

import numpy as np
from keras.optimizers import Adam
from keras.layers import Dense, Activation, Input, Dropout, Reshape, Conv2DTranspose, Activation, Conv2D, Flatten, LeakyReLU, BatchNormalization, UpSampling2D, ZeroPadding2D
from keras.models import Model, Sequential
from keras.datasets import mnist, fashion_mnist
import matplotlib.pyplot as plt
# https://github.com/eriklindernoren/Keras-GAN/blob/master/acgan/acgan.py
# ==================================================
img_shape=(28,28)
noise_shape=(128,)
opt=Adam(0.0002, 0.5)
rate=0.
act=LeakyReLU()
# ==================================================
gen_input=Input(shape=noise_shape)
x=Dense(7*7*64)(gen_input)
x=Dropout(rate)(x)
x=act(x)
x=Reshape(target_shape=(7,7,64))(x)
x=Conv2D(64,(3,3),padding='same')(x)
x=Dropout(rate)(x)
x=act(x)
x=UpSampling2D()(x)
x=Conv2D(32,(3,3),padding='same')(x)
x=Dropout(rate)(x)
x=act(x)
x=UpSampling2D()(x)
x=Conv2D(16,(3,3),padding='same')(x)
x=Dropout(rate)(x)
x=act(x)
x=Conv2D(1,(3,3),padding='same')(x)
x=Reshape(target_shape=img_shape)(x)
x=Activation('tanh')(x)
generator=Model(gen_input,x)
# generator.summary()
# ==================================================
dis_input=Input(shape=img_shape)
x=Reshape(target_shape=img_shape+(1,))(dis_input)
# img_shape+(1,) = (28,28)+(1,) = (28,28,1)
x=Conv2D(16,(3,3),padding='valid')(x)
x=Dropout(rate)(x)
x=act(x)
x=Conv2D(32,(3,3),padding='valid')(x)
x=Dropout(rate)(x)
x=act(x)
x=Conv2D(64,(3,3),padding='valid')(x)
x=Dropout(rate)(x)
x=act(x)
x=Conv2D(128,(3,3),padding='valid')(x)
x=Dropout(rate)(x)
x=act(x)
x=Flatten()(x)
x=Dense(1)(x)
x=Activation('sigmoid')(x)
discriminator=Model(dis_input,x)
# discriminator.summary()
# ==================================================
x=Input(shape=img_shape)
y=discriminator(x)
dis_train=Model(x,y)
dis_train.compile(loss='binary_crossentropy',optimizer=opt)
# dis_train.summary()

discriminator.trainable=False
x=Input(shape=noise_shape)
y=generator(x)
y=discriminator(y)
gen_train=Model(x,y)
gen_train.compile(loss='binary_crossentropy',optimizer=opt)
# gen_train.summary()
# ==================================================
def sample():
    n,m=4,6
    fig,ax=plt.subplots(n,m)
    noise=np.random.normal(size=(n*m,)+noise_shape)
    img=generator.predict(noise).reshape((n,m)+img_shape)
    for i in range(n):
        for j in range(m):
            ax[i][j].axis('off')
            # img[i][j]=(img[i][j]+0.5).astype('int32')
            ax[i][j].imshow(img[i][j],cmap='binary_r')
    plt.show()
# ==================================================
(x1,y1),(x2,y2)=mnist.load_data()
x1=x1/255
x2=x2/255
# x_train=x1
indices=[i for i in range(len(y1)) if y1[i]==8]
x_train=x1[indices]

batch_size=32
epochs=3000
# ==================================================
true=np.ones((batch_size,))
false=np.zeros((batch_size,))
for epoch in range(1,epochs+1):
    indices=np.random.randint(0,len(x_train),size=(batch_size,))
    true_img=x_train[indices]
    noise=np.random.normal(size=(batch_size,)+noise_shape)
    # true_img=[]
    # for i in indices:
    #     true_img.append(x_train[i])
    gen_img=generator.predict(noise)
    gen_train.train_on_batch(noise,true)
    dis_train.train_on_batch(true_img,true)
    dis_train.train_on_batch(gen_img,false)
    if epoch%200==0:
        print('%5d/%5d'%(epoch,epochs))
        sample()