目录

一、引言​

​ 二、卷积神经网络（CNN）

三、生成对抗神经网络（GAN）

---

一、引言

 二、卷积神经网络（CNN）

 

一共有七层，分别为：

C1：第一次卷积；

S2：第一次池化；

C3：第二次卷积；

S4：第二次池化；

C5：第一次全连接层；

F6：第二次全连接层；

OUTPUT:输出层。

局部连接（权值共享）：每个隐层神经元的权值是相同的，如下图：

 全连接层：每个输入神经元都与每个隐层神经元相连接，如下图。

以下扫描的过程，实际上就是特征提取的过程（自动）。

 

图像的边缘检测，实际上就是像素点突变的地方。

 池化层（欠采样的操作）：会将一些细节的信息过滤掉，特征降维，可以降低计算量，抑制过拟合的现象发生。池化也可以理解成特征提取的过程。

 

使用多个filters扫描时，就会加深厚度。

#%%深度神经网络
#卷积&池化操作

import tensorflow as tf
from tensorflow.keras import layers,models
import matplotlib.pyplot as plt

image = plt.imread(r'D:\上课文件\python\泰迪杯\tensorflow2实战PPT&数据&代码\tensorflow2实战PPT&数据&代码\数据&代码\testimages\8.jpg')
#plt.imshow(image,cmap='gray')  #cmap='gray' 表示设置为灰度图
image = image.reshape([1,28,28,1]) #保证输入与输出有相同的格式

#%%卷积的操作

model = models.Sequential() #实例化
model.add(layers.Conv2D(32,(3,3),activation='relu',input_shape=(28,28,1)))
'''
32-表示卷积核的个数
(3,3)-卷积核的尺寸
'''

'''
print(model.summary())

打印结果如下：
Model: "sequential_10"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d (Conv2D)             (None, 26, 26, 32)        320       
                                                                 
=================================================================
Total params: 320
Trainable params: 320
Non-trainable params: 0
_________________________________________________________________
None


输出为：(None, 26, 26, 32)  第一个None表示的是几张图片，32表示卷积核的个数
'''

conv2D = model.predict(image)  #输出的是一个四维的结构
#通过画子图的方式画出来
plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.imshow(conv2D[0,:,:,i],cmap='gray')
#print(conv2D.shape)

#%%池化的操作
model_1 = models.Sequential() #实例化
model_1.add(layers.MaxPool2D((2,2),input_shape=(26,26,32)))

#print(model_1.summary())
pool_1 = model_1.predict(conv2D)
#通过画子图的方式画出来
plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.imshow(conv2D[0,:,:,i],cmap='gray')
#print(pool_1.reshape)

三、生成对抗神经网络（GAN）

 

 

 注意：以下代码保存的图片显示不出来

#%%生成对抗神经网络
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.keras import layers
import time
import numpy as np

# 读取数据
mnist = np.load(r'D:\上课文件\python\泰迪杯\tensorflow2实战PPT&数据&代码\tensorflow2实战PPT&数据&代码\数据&代码\mnist.npz')
train_images = mnist['x_train'] #样本自变量
train_images = train_images.reshape(train_images.shape[0],28,28,1).astype('float32') #转换数据维度及数据类型
#train_images.shape[0]=60000,表示样本的总量

train_images = (train_images - 127.5)/127.5 #将图片标准化到[-1,1]之间

BUFFER_SIZE = 60000 #样本顺序打乱缓冲区
BATCH_SIZE = 256    #单批样本数据量

#数据批量化处理及顺序打乱操作
train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
#这里有转化为tensor数据类型   


#生成器网络
def make_generator_model():
    model = tf.keras.Sequential()
    model.add(layers.Dense(7*7*256,use_bias=False,input_shape=(100,))) #全连接层
    model.add(layers.BatchNormalization()) #批标准化层
    model.add(layers.LeakyReLU())            #激活层
    model.add(layers.Reshape((7,7,256)))   #转变数据维度
    model.add(layers.Conv2DTranspose(128,(5,5),strides=(1,1),padding='same',use_bias=False))  #转置卷积(反卷积)层
    model.add(layers.BatchNormalization()) #批标准化层
    model.add(layers.LeakyReLU())            #激活层
    model.add(layers.Conv2DTranspose(64,(5,5),strides=(2,2),padding='same',use_bias=False))  #转置卷积(反卷积)层
    model.add(layers.BatchNormalization()) #批标准化层
    model.add(layers.LeakyReLU())            #激活层
    model.add(layers.Conv2DTranspose(1,(5,5),strides=(2,2),padding='same',use_bias=False,activation='tanh'))  #转置卷积(反卷积)层
    return model
     
#判别器网络
def make_discrinimator_model():
    model = tf.keras.Sequential()
    model.add(layers.Conv2D(64,(5,5),strides=(2,2),padding='same',input_shape=[28,28,1])) #卷积层
    model.add(layers.LeakyReLU())  #激活层
    model.add(layers.Dropout(0.3)) #dropout层，可以防止过拟合
    model.add(layers.Conv2D(128,(5,5),strides=(2,2),padding='same')) #卷积层
    model.add(layers.LeakyReLU())  #激活层
    model.add(layers.Dropout(0.3)) #dropout层，可以防止过拟合
    model.add(layers.Flatten())    #展平层
    model.add(layers.Dense(1))     #输出层（全连接），输出一个神经元
    return model

#判别器网络损失函数
def discriminator_loss(real_output,fake_output):
    real_loss = cross_entropy(tf.ones_like(real_output),real_output) #判别真样本的损失值，与1作比较
    fake_loss = cross_entropy(tf.zeros_like(fake_output),fake_output) #判别假样本的损失值,与0作比较
    total_loss = real_loss + fake_loss
    return total_loss
'''
对于判别器网络来说，希望能够准确的判别真假照片
'''


#生成器网络损失函数
def generator_loss(fake_output):
    return cross_entropy(tf.ones_like(fake_output),fake_output)#生成器损失值（判别器输出和1做比较）
'''
tf.ones_like(fake_output)---这个值始终等于1
对于生成器网络来说，希望产生以假乱真的照片，所以希望输出的fake_output为1
如果输出的fake_output为1，说明说明损失值等于0，也就是生成器网络非常厉害了
如果输出的fake_output为0，说明说明损失值很大，也就是生成器网络还得好好学习
'''
    
#生成器输出照片保存函数
def generate_and_save_images(model,epoch,test_input):
    #注意 training 设定为False
    #因此，所有层都在推理模式下运行（batchnorm）
    predictions = model(test_input,training=False)
    plt.figure(figsize=(4,4))
     
    for i in range(predictions.shape[0]):
        plt.subplot(4,4,i+1)
        plt.imshow(predictions[i,:,:0]*127.5 + 127.5,cmap='gray')
        plt.axis('off')
    fig = plt.gcf()
    plt.show()
    fig.savefig('image_at_epoch_{:04d}.png'.format(epoch),dpi=100)  #保存生成器生成的照片

generator = make_generator_model()  #生成器
discriminator = make_discrinimator_model()  #判别器

cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True) #该方法返回计算交叉熵损失的辅助函数
generator_optimizer = tf.keras.optimizers.Adam(1e-4) #生成器训练时的优化器
discriminator_optimizer = tf.keras.optimizers.Adam(1e-4) #判别器训练时的优化器

EPOCHS = 1 #训练轮数
noise_dim = 100 #单个噪声样本的维度
num_examples_to_generate = 16 #每次生成的噪声样本个数

seed = tf.random.normal([num_examples_to_generate,noise_dim]) #固定的噪声数据

@tf.function  #注意'@tf.function' 的使用，该注解使函数被'编译'，能加快在GPU上的训练速度

def train_step(images):
    noise = tf.random.normal([BATCH_SIZE,noise_dim])  #生成随机数据，噪声
    with tf.GradientTape() as gen_tape,tf.GradientTape() as disc_tape:
        generated_images = generator(noise,training=True)  #利用生成器生成照片
        real_output = discriminator(images,training=True)  #判别器接受真样本时的输出
        fake_output = discriminator(generated_images, training=True)    # 判别器接收假样本时的输出
        
        gen_loss = generator_loss(fake_output)                          # 生成器的损失值
        disc_loss = discriminator_loss(real_output, fake_output)        # 判别器的损失值


    #分别计算生成器和判别器的梯度
    gradients_of_generator = gen_tape.gradient(gen_loss,generator.trainable_variables)
    gradients_of_discriminator = disc_tape.gradient(gen_loss,discriminator.trainable_variables)

    #根据梯度优化网络参数
    generator_optimizer.apply_gradients(zip(gradients_of_generator,generator.trainable_variables))
    discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator,discriminator.trainable_variables))

def train(dataset,epochs):
    for epoch in range(epochs):
        start = time.time() #迭代开始时间
        
    for image_batch in dataset:
        train_step(image_batch)  #模型训练
    
    generate_and_save_images(generator,
                             epoch + 1,
                             seed)  #保存训练迭代中生成的照片
    
    print('Time for epoch{} is {} sec'.format(
        epoch + 1,time.time() - start))
    
    
if __name__ == '__main__':
    train(train_dataset,EPOCHS)