ACGAN(Auxiliary Classifier GAN)详解与实现（tensorflow2

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。

二、Python必备开发工具

工具都帮大家整理好了，安装就可直接上手！

三、最新Python学习笔记

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。

四、Python视频合集

观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

五、实战案例

纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

六、面试宝典

简历模板

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

activation (string): 输出层激活函数

num_labels (int): 类别数

Returns:

Model: 鉴别网络

“”"

kernel_size = 5

layer_filters = [32,64,128,256]

x = inputs

for filters in layer_filters:

if filters == layer_filters[-1]:

strides = 1

else:

strides = 2

x = keras.layers.LeakyReLU(0.2)(x)

x = keras.layers.Conv2D(filters=filters,

kernel_size=kernel_size,

strides=strides,

padding=‘same’)(x)

x = keras.layers.Flatten()(x)

outputs = keras.layers.Dense(1)(x)

if activation is not None:

print(activation)

outputs = keras.layers.Activation(activation)(outputs)

if num_labels:

#ACGAN有第二个输出，用于输出图片的类别

layer = keras.layers.Dense(layer_filters[-2])(x)

labels = keras.layers.Dense(num_labels)(layer)

labels = keras.layers.Activation(‘softmax’,name=‘label’)(labels)

outputs = [outputs,labels]

return keras.Model(inputs,outputs,name=‘discriminator’)

模型构建

def build_and_train_models():

“”"The ACGAN training

“”"

#数据加载及预处理

(x_train,y_train),_ = keras.datasets.mnist.load_data()

image_size = x_train.shape[1]

x_train = np.reshape(x_train,[-1,image_size,image_size,1])

x_train = x_train.astype(‘float32’) / 255.

num_labels = len(np.unique(y_train))

y_train = keras.utils.to_categorical(y_train)

#超参数

model_name = ‘acgan-mnist’

latent_size = 100

batch_size = 64

train_steps = 40000

lr = 2e-4

decay = 6e-8

input_shape = (image_size,image_size,1)

label_shape = (num_labels,)

#discriminator

inputs = keras.layers.Input(shape=input_shape,name=‘discriminator_input’)

discriminator = discriminator(inputs,num_labels=num_labels)

optimizer = keras.optimizers.RMSprop(lr=lr,decay=decay)

loss = [‘binary_crossentropy’,‘categorical_crossentropy’]

discriminator.compile(loss=loss,optimizer=optimizer,metrics=[‘acc’])

discriminator.summary()

#generator

input_shape = (latent_size,)

inputs = keras.layers.Input(shape=input_shape,name=‘z_input’)

labels = keras.layers.Input(shape=label_shape,name=‘labels’)

generator = generator(inputs,image_size,labels=labels)

generator.summary()

optimizer = keras.optimizers.RMSprop(lr=lr0.5,decay=decay0.5)

discriminator.trainable = False

adversarial = keras.Model([inputs,labels],discriminator(generator([inputs,labels])),

name=model_name)

adversarial.compile(loss=loss,optimizer=optimizer,metrics=[‘acc’])

adversarial.summary()

models = (generator,discriminator,adversarial)

data = (x_train,y_train)

params = (batch_size,latent_size,train_steps,num_labels,model_name)

train(models,data,params)

模型训练

def train(models,data,params):

“”"Train the discriminator and adversarial Networks

Arguments:

models (list): generator,discriminator,adversarial

data (list): x_train,y_train

params (list): network parameter

“”"

generator,discriminator,adversarial = models

x_train,y_train = data

batch_size,latent_size,train_steps,num_labels,model_name = params

save_interval = 500

noise_input = np.random.uniform(-1.,1.,size=[16,latent_size])

noise_label = np.eye(num_labels)[np.arange(0,16) % num_labels]

train_size = x_train.shape[0]

print(model_name,'Labels for generated images: ',np.argmax(noise_label,axis=1))

for i in range(train_steps):

#训练鉴别器

rand_indexes = np.random.randint(0,train_size,size=batch_size)

real_images = x_train[rand_indexes]

real_labels = y_train[rand_indexes]

#产生伪造图片

noise = np.random.uniform(-1.,1.,size=(batch_size,latent_size))

fake_labels = np.eye(num_labels)[np.random.choice(num_labels,batch_size)]

fake_images = generator.predict([noise,fake_labels])

#构造输入

x = np.concatenate((real_images,fake_images))

#训练类别标签

labels = np.concatenate((real_labels,fake_labels))

#标签

y = np.ones([2*batch_size,1])

y[batch_size:,:] = 0.0

#训练模型

metrics = discriminator.train_on_batch(x,[y,labels])

fmt = ‘%d: [disc loss: %f, srcloss: %f],’

fmt += ‘lbloss: %f, srcacc: %f, lblacc: %f’

log = fmt % (i,metrics[0],metrics[1],metrics[2],metrics[3],metrics[4])

#train adversarial network for 1 batch

noise = np.random.uniform(-1.,1.,size=(batch_size,latent_size))

fake_labels = np.eye(num_labels)[np.random.choice(num_labels,batch_size)]

y = np.ones([batch_size,1])

metrics = adversarial.train_on_batch([noise,fake_labels],[y,fake_labels])

fmt = “%s [advr loss: %f, srcloss: %f,”

fmt += “lblloss: %f, srcacc: %f, lblacc: %f]”

log = fmt % (log, metrics[0], metrics[1], metrics[2], metrics[3], metrics[4])

print(log)

if (i + 1) % save_interval == 0:

绘制生成图片

plot_images(generator,noise_input=noise_input,

noise_label=noise_label,show=False,

step=(i + 1),

model_name=model_name)

generator.save(model_name + “.h5”)

虚假图像生成及绘制plot_images函数

def plot_images(generator,

noise_input,

noise_label=None,

noise_codes=None,

show=False,

step=0,

model_name=“gan”):

“”"生成虚假图片及绘制

Arguments

generator (Model): 生成模型

noise_input (ndarray): 潜在模型

show (bool): 是否展示

step (int): step值

model_name (string): 模型名称

“”"

os.makedirs(model_name, exist_ok=True)

filename = os.path.join(model_name, “%05d.png” % step)

rows = int(math.sqrt(noise_input.shape[0]))

if noise_label is not None:

noise_input = [noise_input, noise_label]

if noise_codes is not None:

noise_input += noise_codes

images = generator.predict(noise_input)

plt.figure(figsize=(2.2, 2.2))

num_images = images.shape[0]

image_size = images.shape[1]

for i in range(num_images):

plt.subplot(rows, rows, i + 1)

image = np.reshape(images[i], [image_size, image_size])

plt.imshow(image, cmap=‘gray’)

plt.axis(‘off’)

plt.savefig(filename)

if show:

plt.show()

else:

plt.close(‘all’)

训练结果

#运行

if name == ‘main’:

build_and_train_models()

step=1000：

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！