Tensorflow2 深度学习原理与实战
作者：互联网
目录
一、引言
二、卷积神经网络（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