1. 在pickle.load可能会出现代码的读取错误，这里使用代码
import pickle import sys import importlib importlib.reload(sys) with open('1.set', 'rb') as f: data = pickle.load(f, encoding='latin1') # 也可以尝试为'bytes' print(data)
2.进行图片的展示，生成的是25张图片 代码来源 对抗生成网络dcgan_mnist
def plot_samples(samples): fig, axes = plt.subplots(nrows=1, ncols=25) for img, ax in zip(samples, axes): ax.imshow(img, cmap='Greys_r') ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) fig.tight_layer(pad=0) plt.show()
3.对图片进行预处理，并进行保存成.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)
4. 使用已经存在sess文件，就进行sess的读取, 代码来源高原卷积分类
with tf.Session() as sess: # 参数初始化操作 sess.run(tf.global_variables_initializer()) # 进行sess的重新加载 if tf.train.get_checkpoint_state('model_w'): saver = tf.train.Saver() saver.restore(sess, './model_w/latest')
5. 读取sess文件，进行模型的预测工作，代码来源对抗生成网络gan_mnist
# 将训练好的数据载入 saver = tf.train.Saver(var_list=g_var) saver.restore(sess, './checkpoints/generator.ckpt') batch_noise = np.random.uniform(-1, 1, (25, noise_size)) # noise_image 是由tf.placeholder('float32', [None, 100])生成的, input_size表示最后生成的维度 samples = sess.run(get_generator(noise_img, g_units, input_size, reuse=True), feed_dict={noise_img:batch_noise}) views_sample(0, [samples])
6.进行折线图的作图
fig = plt.figure() plt.subplot(2, 1, 1) plt.plot(losses, label='loss') plt.ylabel('loss') plt.legend() plt.subplot(2, 1, 2) plt.plot(train_accur, label='train_accur') plt.plot(test_accur, label='test_accur') plt.xlabel('epoch') plt.ylabel('accuracy') plt.legend() # 设置坐标轴的范围 plt.ylim(0, 1) plt.show()
7. 图片的读入，再加上标签 来自高原卷积分类
import numpy as np import glob import pandas as pd import random x = [] y = [] for idx in range(4): pathes = glob.glob('{}/*.mat'.format(idx)) for path in pathes: print(path) datas = pd.read_table(path, header=None).values print(datas.shape) for column in range(1, datas.shape[1], 81): label = [0, 0, 0, 0] label[idx] = 1 data = np.transpose(datas[:, column:column + 81].tolist()) if data.shape[0] == 81: x.append(data) y.append(label) # 进行洗牌操作 index = np.arange(0, len(x)) random.shuffle(index) x = np.array(x) y = np.array(y) x_shuffle = x[index] y_shuffle = y[index] print(x_shuffle[0:3]) print(y_shuffle.shape) # 进行标准化操作 x_mean = (x_shuffle - np.mean(x_shuffle))/ np.std(x_shuffle) print(x_mean[0:3]) # 拆分成训练集和测试集数据 p = int(len(x) * 0.85) train_x = x_mean[:p] train_y = y_shuffle[:p] test_x = x_mean[p:] test_y = y_shuffle[p:] np.save('npy/x_train', train_x) np.save('npy/y_train', train_y) np.save('npy/x_test', test_x) np.save('npy/y_test', test_y) print(len(train_x)) print(len(test_x))
8. 根据参数的训练名字，获得特定名字的训练参数，以此进行参数的训练
# 获得用于降低损失的g_opt 和 d_opt def get_opt(d_loss, g_loss, learning_rate=0.001): # 获得训练过程中的所有训练参数 varies = tf.trainable_variables() # 循环训练参数，根据参数名字的开头获得生成网络的参数 g_var = [var for var in varies if var.name.startswith('generator')] # 根据参数名字的开头获得判别网络的参数 d_var = [var for var in varies if var.name.startswith('discrimator')] d_opt = tf.train.AdamOptimizer(learning_rate).minimize(d_loss, var_list=d_var) g_opt = tf.train.AdamOptimizer(learning_rate).minimize(g_loss, var_list=g_var) return d_opt, g_opt
9.使用pickle.dump对图片进行保存， 使用pickle.load进行图片的读取
# 图片的保存 with open('train_sample.pkl', 'wb') as f: pickle.dump(samples, f) # 图片的读取 with open('train_sample.pkl') as f: samples = pickle.load(f)
10. 对标签进行one-hot编码
def make_one_hot(indices, size): as_one_hot = np.zeros((indices.shape[0], size)) as_one_hot[np.arange(0, indices.shape[0]), indices] = 1.0 return as_one_hot
11. 将rgb数据转换为brg数据
# 将输入的rgb图像转换为bgr with tf.variable_scope('VGG19', reuse=reuse) as vs: start_time = time.time() print('build the model') input_image = input_image * 255 # 将其添加为0,255 red, green, blue = tf.split(input_image, 3, 3) #使用tf.split将数据拆分成三个维度 assert red.get_shape().as_list()[1:] == [224, 224, 1] # 判别每个维度的数据维度是否是当前维度 assert green.get_shape().as_list()[1:] == [224, 224, 1] assert blue.get_shape().as_list()[1:] == [224, 224, 1] # 使用tf.concat将数据的维度重新进行构建，这里进行了去均值化操作 bgr = tf.concat([blue-VGG_MEAN[0], green-VGG_MEAN[1], red-VGG_MEAN[2]], axis=3) assert input_image.get_shape().as_list()[1:] == [224, 224, 3]
12.画条形图，去除刻度和标签值
one = [] two = [] three = [] four = [] for row in rows: line = [col.value for col in row] one.append(line[0]) two.append(line[1]) three.append(line[2]) four.append(line[3]) x_one = np.arange(10) x_two = np.arange(13, 23) x_three = np.arange(26, 36) x_four = np.arange(39, 49) fig,axes = plt.subplots() # 对第一个方框进行画图bar axes.bar(x_one, one, color='lightblue') axes.bar(x_two, two, color='green') axes.bar(x_three, three, color='green') axes.bar(x_four, four, color='green') plt.ylim([3000000, 6000000]) # 去除刻度和数值 plt.xticks(ticks=[]) # 去除刻度 plt.tick_params(bottom='off', left='off', right='off', top='off') plt.show()
13.边界损失值，构造[-1, 0, 1]的卷积来获得边界损失值
def edge_loss(logits, gt): gt = tf.cast(gt, tf.float32) # 标签 sigmoid_p = tf.nn.sigmoid(logits) # sigmoid损失值 x_weight = tf.reshape(tf.constant([-1, 0, +1], tf.float32), [1, 3, 1, 1]) # 构造了一个卷积核 y_weight = tf.reshape(x_weight, [3, 1, 1, 1]) # 构造了卷积核 # 获得其标签边缘的梯度值, 获得x边缘的损失值 xgrad_gt = tf.nn.conv2d(gt, x_weight, [1, 1, 1, 1], 'SAME') ygrad_gt = tf.nn.conv2d(gt, y_weight, [1, 1, 1, 1], 'SAME') # 获得y边缘的损失值 # 获得输出结果的边缘梯度值 xgrad_sal = tf.nn.conv2d(sigmoid_p, x_weight, [1, 1, 1, 1], 'SAME') ygrad_sal = tf.nn.conv2d(sigmoid_p, y_weight, [1, 1, 1, 1], 'SAME') # 计算平方根误差 loss = tf.losses.mean_squared_error(xgrad_gt, xgrad_sal) + tf.losses.mean_squared_error(ygrad_gt, ygrad_sal) return loss
14.读取一个batch_size的图片
import numpy as np import cv2 def read_data_some(path, bacth_size): data = np.array(np.load('npy/' + path)) num = len(data) indx = np.random.randint(0, num, bacth_size) deep_img, GT_img, Img_imgs = data[indx][:, 0], data[indx][:, 1], data[indx][:, 2] deep_imgs = [] GT_imgs = [] for i in range(bacth_size): deep_imgs.append(cv2.cvtColor(deep_img[i], cv2.COLOR_BGR2GRAY)) GT_imgs.append(cv2.cvtColor(GT_img[i], cv2.COLOR_BGR2GRAY)) return deep_imgs, GT_imgs, Img_imgs if __name__ == '__main__': read_train_data(64)
15.获得当前文件的主路径
src_path,_ = os.path.split(os.path.realpath(__file__))
16.图片的对比度，亮度，色相，图片饱和度的随机调整 MTCNN代码
def image_color_distort(inputs): inputs = tf.image.random_contrast(inputs, lower=0.5, upper=1.5) # 在某个范围随机调整图片对比度 inputs = tf.image.random_brightness(inputs, max_delta=0.2) # 在某个范围内随机调整图片的亮度 inputs = tf.image.random_hue(inputs,max_delta= 0.2) # 在某个范围内随机调整图片的色相 inputs = tf.image.random_saturation(inputs,lower = 0.5, upper= 1.5) # 在某个范围内随机调整图片的饱和度 return inputs
# 测试图片对比度发生变化
img = cv2.imread('Abba_Eban_0001.jpg')
cv2.imshow('img', img)
cv2.waitKey(0)
img = cv2.imread('Abba_Eban_0001.jpg')
inputs = tf.image.random_contrast(img, lower=0.5, upper=1.5)
sess = tf.Session()
inputs = sess.run(inputs)
cv2.imshow('img_1', inputs)
cv2.waitKey(0)
17.将图片进行左右翻转 MTCNN代码
img = cv2.imread('Abba_Eban_0001.jpg') cv2.imshow('img', img) cv2.waitKey(0) cv2.flip(img, 1, img) cv2.imshow('img_1', img) cv2.waitKey(0)
18. 进行学习率的衰减
tf.train.exponential_decay(0.1, 1000, 500, 0.9, staircase=True)
# 参数说明：0.1表示基础学习率，1000表示global_step即当前的步数，500表示衰减步数，0.9表示衰减的比例，staircase表示是逐步变换，还是突变
sess = tf.Session() lr = tf.train.exponential_decay(0.1, 1000, 500, 0.9, staircase=True) print(sess.run(lr))
19.清空文件夹中的文件
import shutil, os path = '1/' shutil.rmtree(path) os.makedirs('1/')