1. tf.nn.moments(x, axes=[0, 1, 2]) # 对前三个维度求平均值和标准差，结果为最后一个维度，即对每个feature_map求平均值和标准差
参数说明：x为输入的feature_map, axes=[0, 1, 2] 对三个维度求平均，即每一个feature_map都获得一个平均值和标准差
2.with tf.control_dependencies([train_mean, train_var])： 即执行with里面的操作时，会先执行train_mean 和 train_var
参数说明：train_mean表示对pop_mean进行赋值的操作，train_var表示对pop_var进行赋值的操作
3.tf.cond(is_training, bn_train, bn_inference) # 如果is_training为真，执行bn_train函数操作，如果为假，执行bn_inference操作
参数说明：is_training 为真和假，bn_train表示训练的normalize， bn_inference表示测试的normalize
4. tf.nn.atrous_conv2d(x, filters, dilated, padding) # 进行空洞卷积操作，用于增加卷积的感受野
参数说明：x表示输入样本，filter表示卷积核，dilated表示卷积核的补零个数，padding表示对feature进行补零操作
5. tf.nn.conv2d_transpose(x, filters, output_size, strides) # 进行反卷积操作
参数说明：x表示输入样本，filter表示卷积核，output_size表示输出的维度， strides表示图像扩大的倍数
6.tf.nn.batch_normalization(x, mean, var, beta, scale, episilon) # 进行归一化操作
参数说明： x表示输入样本，mean表示卷积的平均值，var表示卷积的标准差，beta表示偏差，scale表示标准化后的范围，episilon防止分母为0
7.tf.train.get_checkpoint_state(\'./backup\') # 判断用于进行model保存的文件中是否有checkpoint，即是否之前已经有过保存的sess
参数说明：\'./backup\'进行sess保存的文件名
原理的话,使用论文中的图进行说明， 这是论文中的效果图，我们可以看出不管是场景还是人脸都有较好的复原效果
下面是论文的结构图， 主要是有2个结构组成，
第一个结构是全卷机填充网络：首先使用一个mask和图片进行组合，构成了具有空缺的图片，将空缺图片输入到全卷积中，经过stride等于2，做两次的向下卷积，然后经过4个dilated_conv(空洞卷积)，为了在不损失维度的情况下，增加卷积核的视野，最后使用补零的反转卷积进行维度的升高，再经过最后两层卷积构成了图片。
第二个结构是global_discrimanator 和 local_discimanator
对于global_x输入的大小为全图的大小，而local_x的输入大小为全图大小的一半，上图的mask的大小为96-128且在local_x的内部，取值的范围为随机值
global_x 和 local_x经过卷积后，输出1024的输出，我们将输出进行串接tf.concat，对最后的输出结果[1]进行预测,判别图片为实际图片(真)还是经过填充的图片(假)
网络系数的展示
填充网络(卷积-空洞卷积-反卷积) 全局判别网络(卷积-全连接) 局部判别网络(卷积-全连接) 串接网络(全连接)
训练步骤：为了使得对抗网络训练更加的有效，我们需要先对填充网络进行预训练，然后是对判别网络进行训练，最后将生成网络和判别网络放在一起进行训练
这里说明一下，填充 网络的损失值是mse，即tf.l2_loss() 判别网络的损失值是tf.reduce_mean(tf.nn.softmax...logits)
代码：代码主要由五个.py文件构建，
1.to_npy进行图片的预处理，并将数据保存为.npy文件，
2.load.py 使用np.load进行x_train和x_test数据的读取
3.train.py 主要进行参数的训练，并且构造出mask_batch, local_x和local_complement
4.network用于进行模型结构的搭建，构建生成网络和判别网络，同时获得生成网络和判别网络的损失值
5.layer 用于卷积，反卷积，全连接，空洞卷积等函数的构建
数据的准备：to_npy
import numpy as np import tensorflow as tf import glob import cv2 import os # 将处理好的图片进行保存，为了防止经常需要处理图片 # 进行数据的压缩 IMAGE_SIZE = 128 # 训练集的比例 train_ep = 0.9 x = [] # 循环文件中的所有图片的地址 pathes = glob.glob(\'/data/*jpg\') # 循环前500个图片的地址 for path in pathes[:500]: # 使用cv2.imread读取图片 img = cv2.imread(path) # 将图片进行维度的变换 img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE)) # 将读入的图片从BGR转换为RGB img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # 将图片添加到列表中 x.append(img) # 如果不存在./npy文件 if not os.path.exists(\'./npy\'): # 使用os.makedirs进行创建文件npy os.makedirs(\'./npy\') # 获得train的索引 p = len(x) * train_ep # 训练集x train_x = x[:p] # 测试集x test_x = x[p:] # 将预处理好的图片保存为.npy文件 np.save(\'./npy/x_train.npy\', train_x) np.save(\'./npy/x_test.npy\', test_x)
train.py
import numpy as np import tensorflow as tf import os from network import * import load import tqdm import cv2 # 第一步：定义超参数 IMAGE_SIZE = 128 # 输入图片的大小 LOCAL_SIZE = 64 # local的大小 HOL_MIN = 24 # 洞的最小值 HOL_MAX = 48 # 洞的最大值 LEARNING_RATE = 1e-3 # 学习率 BATCH_SIZE = 1 # batch_size大小 PRETRAIN_NUM = 100 # 对生成网络预训练的次数 def train(): # 第二步：构造输入的初始化参数 x = tf.placeholder(tf.float32, [BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 3]) # 图片x，维度为1, 128, 128, 3 mask = tf.placeholder(tf.float32, [BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 1]) # 掩模mask, 1, 128, 128, 1用于生成图片空白区域 x_local = tf.placeholder(tf.float32, [BATCH_SIZE, LOCAL_SIZE, LOCAL_SIZE, 3]) # 图片x部分图像，维度为1, 64, 64, 3 completion_global = tf.placeholder(tf.float32, [BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 3]) # 生成图像的维度，1， 128，128，3 completion_local = tf.placeholder(tf.float32, [BATCH_SIZE, LOCAL_SIZE, LOCAL_SIZE, 3]) # 生成图像部分图像，1, 64, 64, 3 is_training = tf.placeholder(tf.bool, []) # 是够进行训练，在batch_normalize中使用 # 第三步：调用network,构造网络框架，包括生成网络，判别网络，以及其生成和判别的损失值 model = Network(x, mask, x_local, completion_global, completion_local, is_training, BATCH_SIZE) # 第四步：使用tf.session 构造sess sess = tf.Session() # 第五步：初始化global_step和epoch global_step = tf.Variable(0, name=\'global_step\', trainable=False) epoch = tf.Variable(0, name=\'epoch\', trainable=False) # 第六步：构造自适应梯度下降器，获得生成网络和判别网络损失值下降操作 opt = tf.train.AdamOptimizer(LEARNING_RATE) g_loss_op = opt.minimize(model.g_loss, global_step=global_step) d_loss_op = opt.minimize(model.d_loss, global_step=global_step) # 第七步：使用sess.run进行初始化操作 init = tf.global_variables_initializer() sess.run(init) # 第八步：如果存在./backup文件，就使用saver.restore()加载sess if tf.train.get_checkpoint_state(\'./backup\'): saver = tf.train.Saver() saver.restore(sess, \'./backup/latest\') # 第九步：获得训练集和测试集，使用load中定义的load函数， 并对读取的图片做归一化操作 x_train, x_test = load.load() x_train = np.array([a/127.5 - 1 for a in x_train]) x_test = np.array([a/127.5 - 1 for a in x_test]) # 定义一个epoch迭代的次数 step_num = int(len(x_train)/BATCH_SIZE) while True: # 第十步：将epoch值进行+1操作 sess.run(tf.assign_add(epoch, 1)) # 对输入的x_train进行洗牌操作，每次迭代 np.random.shuffle(x_train) # 第十一步：如果当前迭代的次数小于预训练，进行生成网络的训练 if sess.run(epoch) <= PRETRAIN_NUM: # 迭代每个epoch，每次迭代的大小为一个batch_size for i in tqdm.tqdm(range(step_num)): # 获得一个batch_size的图片 x_batch = x_train[BATCH_SIZE*i:(i+1)*BATCH_SIZE] # 获得points_batch, 和一个batch_size的掩模 points_batch, masks_batch = get_points() # 将x和mask_batch,is_training 传入，进行g_loss_op即损失值的降低 _, _g_loss = sess.run([g_loss_op, model.g_loss], feed_dict={x:x_batch, mask:masks_batch, is_training:True}) # 进行验证操作 # 对x_test进行洗牌操作 np.random.shuffle(x_test) # 获得一个BATHC_SIZE的大小 x_batch = x_test[:BATCH_SIZE] # 获得一个batch_size 的生成图片，执行model.completion completion = sess.run([model.completion], feed_dict={x:x_batch, mask:masks_batch, is_training:False}) # 取出其中一张图片，做归一化的反操作，还原回原始图片 sample = np.array((completion[0] + 1) * 127.5, dtype=np.uint8) # 将图片进行保存，使用cv2.imwrite cv2.imwrite(\'{}_epoch.jpg\'.format(\'{0:06d}\'.format(epoch)), cv2.cvtColor(sample, cv2.COLOR_RGB2BGR)) # 将参数保存在./backup/latest saver = tf.train.Saver() saver.save(sess, \'./backup/latest\', write_meta_graph=False) # 如果次数为100次，就将参数保存在/backup/pre_train if sess.run(epoch) == PRETRAIN_NUM: saver.save(sess, \'./backup/pre_train\', write_meta_graph=False) # 第十二步：如果epoch大于预训练的次数，就对生成网络和判别网络进行同时的训练 else: # 循环一个epoch for i in tqdm.tqdm(range(step_num)): # 获得一个batch的图片 x_batch = x_train[BATCH_SIZE*i:(i+1)*BATCH_SIZE] # 获得一个batch的点坐标，和一个batch的掩模 points_batch, masks_batch = get_points() # 初始化g_loss g_loss_value = 0 # 初始化d_loss d_loss_value = 0 # 执行g_loss_op降低g_loss损失值，同时执行self.completion,获得生成图片completion _, completion, g_loss = sess.run([g_loss_op, model.completion, model.g_loss], feed_dict={x:x_batch, mask:masks_batch, is_training:True}) # 将g_loss添加到g_loss_value g_loss_value += g_loss # 构造一个batch的x_local x_local_batch = [] # 构造一个batch的completion_batch completion_local_batch = [] # 循环batch_size for i in range(BATCH_SIZE): # 获得point_batch中一个点坐标 x1, y1, x2, y2 = points_batch[i] # 构造一个x_local, 添加到x_local_batch x_local_batch.append(x_batch[i][y1:y2, x1:x2, :]) # 构造一个completion_local, 添加到completion_local_batch completion_local_batch.append(completion[i][y1:y2, x1:x2]) # 执行d_loss_op，降低d_loss的损失值 _, d_loss = sess.run([d_loss_op, model.d_loss], feed_dict={x:x_batch, mask:masks_batch, x_local:x_local_batch, completion_global:completion, completion_local:completion_local_batch, is_training:True}) # 将损失值进行添加 d_loss_value += d_loss # 清洗x_test np.random.shuffle(x_test) # 获得一个x_batch x_batch = x_test[:BATCH_SIZE] # 输入测试图片获得生成图片 completion = sess.run([model.completion], feed_dict={x:x_batch, mask:masks_batch, is_training:False}) # 取生成图片的第一张图片，进行反归一化 sample = np.array((completion[0] + 1) * 127.5, dtype=np.uint8) # 使用cv2.imwrite保存图片 cv2.imwrite(\'{}.epoch\'.format(\'{0:06d}\'.format(epoch)), cv2.cvtColor(sample, cv2.COLOR_RGB2BGR)) # 构造tf.train.Saver() 进行sess的保存操作 saver = tf.train.Saver() saver.save(sess, \'./backup/latest\', write_meta_graph=False) def get_points(): # 构造点列表，用于构建局部图像 points = []
# 构造掩模列表，用于构造残缺的原始图像 maskes = [] for i in range(BATCH_SIZE):
# 获得左上角两个点，范围为[0, IMAGE_SIZE-LOCAL_SIZE] x1, y1 = np.random.randint(0, IMAGE_SIZE-LOCAL_SIZE, 2)
# 获得右下角的两个点，分别进行相加操作 x2, y2 = np.array([x1, y1]) + LOCAL_SIZE
# 将坐标添加到points points.append([x1, y1, x2, y2]) # 在H0L_MIN和HOL_MAX范围内构造w，h w, h = np.random.randint(HOL_MIN, HOL_MAX, 2)
# 左上角x轴的坐标为x1+(0, LOCAL_SIZE-w)的范围内 p1 = x1 + np.random.randint(0, LOCAL_SIZE-w)
# 左上角y轴的坐标为y1+(0, LOCAL_SIZE-h)的范围内 q1 = y1 + np.random.randint(0, LOCAL_SIZE-h) # 右边的x坐标为p1+w p2 = p1 + w
# 右边的y坐标为q1+h q2 = q1 + h
# 构造全为0的3维矩阵 m = np.zeros(shape=[IMAGE_SIZE, IMAGE_SIZE, 1])
# 在该范围内的值为1， 并进行添加 m[q1:q2, p1:p2, :] = 1 maskes.append(m) # 返回points和掩模的数组 return np.array(points), np.array(maskes) if __name__ == \'__main__\': train()
代码：network.py： 构建Network类，构造生成网络，生成self.completion, 构造判别网络，获得x,x_local的输出结果self.real，获得global_completion, local_completion的输出结果self.fake, 使用l2_loss构造生成网络的损失值g_loss, 使用交叉熵构造判别网络的损失值d_loss
第一步：使用self.generator构造生成网络， 输入为x*(1-mask), is_training
第二步：使用self.imition * mask + x * (1-mask) 构造self.completion 即生成的图片
第三步：使用self.discrimator, 输入为x, x_local, is_training, reuse=False, 用于真实样本的判别self.real
第四步：使用self.discrimator, 输入为global_complement, local_complement, is_training, reuse=True, 用于生成样本的判别self.fake
第五步：使用tf.nn.l2_loss生成mse的损失值，用于生成网络的损失值，self.g_loss
第六步：使用tf.reduce_mean(tf.sotfmax..logits(labels=tf.ones_like(real), logits=real)) 获得真实的交叉熵，同理获得生成样本的交叉熵，将两者进行加和乘以系数，获得最终的损失值即self.d_loss。
第七步：使用tf.get_collection(tf.GraphKey.TRAINABEL_VARIABLES, scope=‘generator’) 和scope = ‘discrimator’获得生成网络和判别网络的参数
import tensorflow as tf import numpy as np from layer import * class Network: def __init__(self, x, mask, x_local, completion_global, completion_local, is_training, batch_size): self.batch_size = batch_size # 第一步： 构造生成网络，获得生成的图片，(1-mask) * x 构成残缺空白的输入图片 self.imition = self.generator((1-mask)*x, is_training) # 第二步：将生成图片部分区域与残缺空白的输入图片进行拼接，获得最终的图片 self.completion = mask * self.imition + (1-mask)*x # 第三步：定义discriminator，对x和x_local判断real结果 self.real = self.discrimator(x, x_local, is_training, reuse=False) # 第四步：使用discrimanator,对completion_global 和 completion_local判断fake结果 self.fake = self.discrimator(completion_global, completion_local, is_training, reuse=True) # 第五步：定义生成网络的损失值，使用mse self.g_loss = self.cal_g_loss(x, self.completion) # 第六步：定义判别网络的损失值，使用交叉熵, 即real判别为1，fake判别为0 self.d_loss = self.cal_d_loss(self.real, self.fake) # 第七步：获得生成网络的参数 g_variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=\'generator\') d_variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=\'discrimator\') # 判别网络的损失值，输入为 def cal_d_loss(self, real, fake): # 损失值系数 epsilon = 4e-4 # 真实样本的交叉熵损失值， 标签为1 real_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=real, labels=tf.ones_like(real))) # 生成样本的交叉熵损失值，标签为0 fake_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=fake, labels=tf.zeros_like(fake))) # 将真实样本和生成样本的损失值进行加和，并进行损失系数的乘积 return tf.add(real_loss, fake_loss) * epsilon # 生成网络的损失值计算，使用的是mse def cal_g_loss(self, x, completion): # 使用l2_loss损失值计算 return tf.nn.l2_loss(x - completion) # 构建判别网络 def discrimator(self, x, x_local, is_training, reuse): # 构建完整图片的判别网络 def global_discrimator(x): # 设置完整图片判别网络参数的范围 with tf.variable_scope(\'global\'): # 第一层卷积，卷积大小为5*5*3*64，步长为2 with tf.variable_scope(\'conv1\'): x = conv_layer(x, [5, 5, 3, 64], 2) x = batch_normalize(x, is_training) x = tf.nn.relu(x) # 第二层卷积，卷积大小为5*5*3*64，步长为2 with tf.variable_scope(\'conv2\'): x = conv_layer(x, [5, 5, 64, 128], 2) x = batch_normalize(x, is_training) x = tf.nn.relu(x) # 第三层卷积，卷积大小为5*5*3*64，步长为2 with tf.variable_scope(\'conv3\'): x = conv_layer(x, [5, 5, 128, 256], 2) x = batch_normalize(x, is_training) x = tf.nn.relu(x) # 第四层卷积，卷积大小为5*5*3*64，步长为2 with tf.variable_scope(\'conv4\'): x = conv_layer(x, [5, 5, 256, 512], 2) x = batch_normalize(x, is_training) x = tf.nn.relu(x) # 第五层卷积，卷积大小为5*5*3*64，步长为2 with tf.variable_scope(\'conv5\'): x = conv_layer(x, [5, 5, 512, 512], 2) x = batch_normalize(x, is_training) x = tf.nn.relu(x) # 构建全连接层，输出为1024 with tf.variable_scope(\'fc\'): # 对卷积层的输出进行维度变换 x = flatten_conv(x) # 进行全连接操作，输出的维度为1024 x = fc_layer(x, 1024) return x # 构造局部图像的判别网络 def local_discrimator(x): # 设置局部网络判别的参数范围 with tf.variable_scope(\'local\'): # 第一层卷积，卷积大小为5*5*3*64，步长为2 with tf.variable_scope(\'conv1\'): x = conv_layer(x, [5, 5, 3, 64], 2) x = batch_normalize(x, is_training) x = tf.nn.relu(x) # 第二层卷积，卷积大小为5*5*3*64，步长为2 with tf.variable_scope(\'conv2\'): x = conv_layer(x, [5, 5, 64, 128], 2) x = batch_normalize(x, is_training) x = tf.nn.relu(x) # 第三层卷积，卷积大小为5*5*3*64，步长为2 with tf.variable_scope(\'conv3\'): x = conv_layer(x, [5, 5, 128, 256], 2) x = batch_normalize(x, is_training) x = tf.nn.relu(x) # 第四层卷积，卷积大小为5*5*3*64，步长为2 with tf.variable_scope(\'conv4\'): x = conv_layer(x, [5, 5, 256, 512], 2) x = batch_normalize(x, is_training) x = tf.nn.relu(x) # 构造全连接网络，输出结构为1024 with tf.variable_scope(\'fc\'): x = flatten_conv(x) x = fc_layer(x, 1024) return x # 设置判别网络的参数范围 with tf.variable_scope(\'discrimator\', reuse=reuse): # 带入x_local获得局部图像的判别输出值 local_disc = local_discrimator(x_local) # 带入x获得完整图像的判别输出值 global_disc = global_discrimator(x) with tf.variable_scope(\'concatenation\'): # 将局部图像输出值与全局图像进行串接，维度为[batch_size, 2048] output = tf.concat((local_disc, global_disc), axis=1) # 接上一个全连接，最后的输出值维度为1 output = fc_layer(output, 1) # 返回判别结果 return output # 用于进行生成网络，输入为拥有空白区域的图片，is_training表示是否是在训练 def generator(self, x, is_training): # 定义参数的范围为\'generator\' with tf.variable_scope(\'generator\'): # 第一层卷积层 with tf.variable_scope(\'conv1\'): # 卷积核的大小为[5, 5, 3, 64]，步长为1 x = conv_layer(x, [5, 5, 3, 64], 1) # 归一化操作 x = batch_normalize(x, is_training) # 非线性激活 x = tf.nn.relu(x) # 第二层卷积 with tf.variable_scope(\'conv2\'): # 卷积核的大小为[3, 3, 64, 128], 步长为2， 维度变为原来的1/2 x = conv_layer(x, [3, 3, 64, 128], 2) # 归一化操作 x = batch_normalize(x, is_training) # 非线性激活 x = tf.nn.relu(x) # 第三层卷积操作 with tf.variable_scope(\'conv3\'): # 卷积核的大小为[3, 3, 128, 128], 步长为1 x = conv_layer(x, [3, 3, 128, 128], 1) # 归一化操作 x = batch_normalize(x, is_training) # 非线性激活 x = tf.nn.relu(x) # 第四层卷积操作 with tf.variable_scope(\'conv4\'): # 卷积核的大小为[3, 3, 128, 256], 步长为2 x = conv_layer(x, [3, 3, 128, 256], 2) # 归一化操作 x = batch_normalize(x, is_training) # 非线性激活 x = tf.nn.relu(x) # 第五层卷积操作 with tf.variable_scope(\'conv5\'): # 卷积核的大小为[3, 3, 256, 256], 步长为1 x = conv_layer(x, [3, 3, 256, 256], 1) # 归一化操作 x = batch_normalize(x, is_training) # 非线性激活 x = tf.nn.relu(x) # 第六层卷积操作 with tf.variable_scope(\'conv6\'): # 卷积核的大小为[3, 3, 256, 256], 步长为1 x = conv_layer(x, [3, 3, 256, 256], 1) # 归一化操作 x = batch_normalize(x, is_training) # 非线性激活 x = tf.nn.relu(x) # 第一层空洞卷积 with tf.variable_scope(\'dilated1\'): # 卷积核的大小为[3, 3, 256, 256]， 卷积补零的个数为1 x = dilated_conv_layer(x, [3, 3, 256, 256], 2) # 归一化操作 x = batch_normalize(x, is_training) # 非线性激活 x = tf.nn.relu(x) # 第二层空洞卷积 with tf.variable_scope(\'dilated2\'): # 卷积核的大小为[3, 3, 256, 256], 卷积补零的个数为3 x = dilated_conv_layer(x, [3, 3, 256, 256], 4) # 归一化 x = batch_normalize(x, is_training) # 非线性激活 x = tf.nn.relu(x) # 第三层空洞卷积 with tf.variable_scope(\'dilated3\'): # 卷积核的大小为[3, 3, 256, 256], 卷积补零的个数为7 x = dilated_conv_layer(x, [3, 3, 256, 256], 8) # 归一化操作 x = batch_normalize(x, is_training) # 非线性激活 x = tf.nn.relu(x) # 第四层空洞卷积 with tf.variable_scope(\'dilated4\'): # 卷积核的大小为[3, 3, 256, 256], 卷积补零的个数为15 x = dilated_conv_layer(x, [3, 3, 256, 256], 16) # 归一化操作 x = batch_normalize(x, is_training) # 非线性激活 x = tf.nn.relu(x) # 第七层卷积 with tf.variable_scope(\'conv7\'): # 卷积的维度为[3, 3, 256, 256], 步长为1 x = conv_layer(x, [3, 3, 256, 256], 1) # 归一化操作 x = batch_normalize(x, is_training) # 激活 x = tf.nn.relu(x) # 第八层卷积 with tf.variable_scope(\'conv8\'): # 卷积的维度为[3, 3, 256, 256], 步长为1 x = conv_layer(x, [3, 3, 256, 256], 1) # 归一化操作 x = batch_normalize(x, is_training) # 激活操作 x = tf.nn.relu(x) # 第一层反卷积，将维度提升为原来的2倍，即从32,32变为64,64 with tf.variable_scope(\'deconv1\'): # 反卷积，[4, 4, 128, 256] 4 和 4表示卷积的大小，256表示输入维度，128表示输出维度，[self.batch_size, 64, 64, 128]表示输出的大小，2表示扩张的倍数 x = deconv_layer(x, [4, 4, 128, 256], [self.batch_size, 64, 64, 128], 2) # 归一化操作 x = batch_normalize(x, is_training) # 激活操作 x = tf.nn.relu(x) with tf.variable_scope(\'conv9\'): # 第九层卷积，卷积核大小为[3, 3, 128, 128]， 步长为1 x = conv_layer(x, [3, 3, 128, 128], 1) # 归一化操作 x = batch_normalize(x, is_training) # 激活操作 x = tf.nn.relu(x) with tf.variable_scope(\'deconv2\'): # 进行反卷积，将维度变为[128, 128] x = deconv_layer(x, [4, 4, 64, 128], [self.batch_size, 128, 128, 64], 2) # 归一化操作 x = batch_normalize(x, is_training) # 激活 x = tf.nn.relu(x) with tf.variable_scope(\'conv10\'): # 第十层卷积，进行维度的降低，即把64降维32 x = conv_layer(x, [3, 3, 64, 32], 1) x = batch_normalize(x, is_training) x = tf.nn.relu(x) with tf.variable_scope(\'conv11\'): # 第十一层，进行维度的降低，把32层的维度转换为3层的维度，即图像的维度值 x = conv_layer(x, [3, 3, 32, 3], 1) x = batch_normalize(x, is_training) x = tf.nn.relu(x) return x
layer.py 用于构建一些基础的网络结构，如卷积层，全连接层，反卷积层，空洞卷积层，归一化层，维度变化层，
import tensorflow as tf # 构造卷积层, 使用的是tf.nn.conv2d def conv_layer(x, shape, stride): # 构造卷积核，大小为shape，进行参数更新 filter = tf.get_variable(\'weight\', shape=shape, dtype=tf.float32, initializer=tf.contrib.layers.xavier_initializer(), trainable=True) # 进行卷积操作 return tf.nn.conv2d(x, filter, strides=[1, stride, stride, 1], padding=\'SAME\') # 构造归一化操作，测试阶段使用的mean和var为训练阶段的动量平均的mean和var def batch_normalize(x, is_training, decay=0.99, epsilon=0.001): # 进行训练时的归一化 def bn_train(): # batch的mean和batch的var， 使用tf.nn.moments获得标准差和均值 batch_mean, batch_var = tf.nn.moments(x, axes=[0, 1, 2]) # 将pop_mean 使用tf.assign进行更新操作,为动量梯度的平均值 train_mean = tf.assign(pop_mean, pop_mean * decay + batch_mean * (1-decay)) # 将pop_var 使用tf.assign进行更新操作，为动量梯度的标准差 train_var = tf.assign(pop_var, pop_var * decay + batch_var * (1-decay)) # 使用tf.control_dependencies,先执行更新操作 with tf.control_dependencies([train_mean, train_var]): # 进行归一化操作，使用的平均值为当前的batch_mean 和 batch_var, beta和scale需要进行参数更新 return tf.nn.batch_normalization(x, batch_mean, batch_var, beta, scale, epsilon) def bn_inference(): # 测试时的归一化操作，pop_mean和pop_var表示训练时动量梯度的平均值和标准差, beta为偏度，scale为范围 return tf.nn.batch_normalization(x, pop_mean, pop_var, beta, scale, epsilon) # 获得最后一个维度 dim = x.get_shape().as_list()[-1] # 构造训练过程中的偏度bata beta = tf.get_variable( name=\'beta\', shape=[dim], dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=0.0), trainable=True ) # 构造训练过程中的范围scale scale = tf.get_variable( name=\'scale\', shape=[dim], dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=0.1), trainable=True ) # 构造动量平均的平均值的初始值 pop_mean = tf.get_variable( name = \'pop_mean\', shape=[dim], dtype=tf.float32, initializer=tf.constant_initializer(0.0), trainable=False ) # 构造动量平均的标准差的初始值 pop_var = tf.get_variable( name=\'pop_var\', shape=[dim], dtype=tf.float32, initializer=tf.constant_initializer(1.0), trainable=False) # 如果is_training为true执行bn_train, 否者执行bn_inference return tf.cond(is_training, bn_train, bn_inference) # 构造空洞卷积，dilation表示卷积补零的个数 def dilated_conv_layer(x, shape, dilation): # filter表示卷积核的构造 filters = tf.get_variable(\'filters\', shape=shape, dtype=tf.float32, initializer=tf.contrib.layers.xavier_initializer(), trainable=True) # 进行空洞卷积，dilation表示卷积核补零的大小 return tf.nn.atrous_conv2d(x, filters, dilation, padding=\'SAME\') # 构造反卷积，output_shape表示输出的维度，stride表示扩大的倍数 def deconv_layer(x, filter_shape, output_shape, stride): # 构造卷积 filters = tf.get_variable( name = \'weight\', shape=filter_shape, dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=0.1), trainable=True ) return tf.nn.conv2d_transpose(x, filters, output_shape, [1, stride, stride, 1]) # 进行维度的变化，用于进行全连接 def flatten_conv(x): num = x.shape[0] return tf.reshape(x, [num, -1]) # 构造全连接函数 def fc_layer(x, output_dim): # 获得输入的最后一个维度，用于构造w input_dim = x.get_shape().as_list()[-1] # w的维度为input_dim, output_dim w = tf.get_variable( name=\'w\', shape=[input_dim, output_dim], dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=0.1), trainable=True ) # b的维度为output_dim b = tf.get_variable( name=\'b\', shape=[output_dim], dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=0.0), trainable=True ) # 进行点乘操作 return tf.add(tf.matmul(x, w), b)
load.py 进行.npy数据的载入操作
import numpy as np import tensorflow as tf import os # dir为data的路径 def load(dir=\'../data/npy\'): # 使用np.load获得存储好的数据 # 加载训练集 train_x = np.load(os.path.join(dir, \'x_train.npy\')) # 加载验证集 test_x = np.load(os.path.join(dir, \'x_test.npy\')) # 返回训练集和验证集 return train_x, test_x
微信扫一扫 
支付宝扫一扫 