标签：Tensorflow2 实战 layers 卷积 add 深度 tf output model

目录

一、引言​

​ 二、卷积神经网络（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)

标签：Tensorflow2,实战,layers,卷积,add,深度,tf,output,model
来源： https://blog.csdn.net/weixin_43901260/article/details/123022455

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。