1.tf.nn.lrn(pool_h1, 4, bias=1.0, alpha=0.001/9.0, beta=0.75) # 局部响应归一化，使用相同位置的前后的filter进行响应归一化操作
参数说明：pool_h1表示输入数据，4表示使用前后几层进行归一化操作，bias表示偏移量，alpha和beta表示系数
局部响应的公式
针对上述公式，做了一个试验代码：
# 自己编写的代码， 对x的[1, 1, 1, 1]进行局部响应归一化操作，最后结果是相同的
x = np.array([i for i in range(1, 33)]).reshape([2, 2, 2, 4]) sqr_sum = np.zeros_like(x) sqr_sum[1, 1, 1, 1] = sum(x[1, 1, 1, 0:3] ** 2) print(sqr_sum[1, 1, 1, 1]) z = (x[1, 1, 1, 1] / (0 + sqr_sum[1, 1, 1, 1]*1)) ** 1 print(z)
# 调用的代码 sess = tf.Session() y = tf.nn.lrn(input=x, depth_radius=1, bias=0, alpha=1, beta=1) print(sess.run(y[1, 1, 1, 1]))
2.random.sample(np.arange(N), cols*rows) # 从列表n中，挑选出cols*rows个数据
参数说明：np.arange(N) 表示列表，cols*rows表示挑选的数字个数
3.tf.one_hot(X, len(names), axis=-1) # 将一维标签转换为one-hot类型
参数说明：X表示输入的一维标签，len(names)表示一个数字变成多少个维度，axis表示所在的位置
使用Tensorflow卷积神经网络对cifar10进行分类
数据说明：cifar数据是由data ：50000*3072， labels=3072个横向量组成，类别名为['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
在下面的操作中，需要使用tf,one_hot(labels, len(names), axis=-1) # 将标签转换为one-hot的编码类型
代码说明：
代码由三部分组成：第一部分，数据的读入和裁剪以及标准化处理
第二部分：对W和卷积过程中的卷积结果进行展示
第三部分：对图像卷积参数进行训练
第一部分：模型的读入和裁剪以及标准化操作
第一步：构建unpickle函数进行数据的读入
第二步：构建clean函数，
第一步：改变矩阵的维度为[-1, 3, 32, 32]
第二步：.mean(1) 对3这个通道求平均值，表示对图像进行灰度化处理，即RGB三个通道求平均
第三步：使用[:, 4:28, 4:28] 对图像进行裁剪
第四步：.reshape([(len(), -1)]) 将图像转换为二维矩阵
第五步：使用np.mean() 计算图像的平均值， 并使用.reshape([len(), 1]) 对维度进行重构
第六步：使用np.std计算图像的标准差，并使用.reshape([len(), 1]) 对维度进行重构，对于一些标准差较大的值，使用1/sqrt(len()) 代替
第七步：对图像减去均值除以标准差来进行标准化操作
第三步：数据的读入
第一步：读入标签的名字
第二步：循环，读取data和labels，将每次读取的data，使用np.vstack进行竖着串接，对于labels使用np.hstack进行横着串接
第三步：使用clean来对数据做预处理，.astype转换数据的类型
第四步：返回名字，data和labels
第四步：随机的图片展示
第一步：定义rows和cols的大小
第二步：使用random.sample(np.arange(N), rows*cols) 从数组中随机挑选rows*cols个数作为索引值
第三步：循环，plt.subplot构造子图，plt.title(name[label[randix[i]]]) 构造题目
第四步：对图像进行维度变化，使用plt.imshow()进行作图操作
import numpy as np import matplotlib.pyplot as plt import tensorflow as tf import pickle import random # 设置随机种子 random.seed(1) # 第一步：构造unpick用于读取数据 def unpickle(filename): # 打开文件，二进制格式 f = open(filename, 'rb') # 文件的载入，编码方式为'latin1' out = pickle.load(f, encoding='latin1') f.close() return out # 第二步：对图片进行预处理，灰度化，裁剪，标准化 def clean(data): # 图像的维度转换 data_reshaped = data.reshape(-1, 3, 32, 32) # 进行灰度化处理 gray_img = data_reshaped.mean(1) # 对图像进行裁剪 gray_img_crop = gray_img[:, 4:28, 4:28] # 将图像的维度转换为原来的二维数据 gray_img_crop = gray_img_crop.reshape([len(gray_img_crop), -1]) # 求得图像的均值 mean = np.mean(gray_img_crop, axis=1) # 将均值的维度转换为2维，以便用于后续的相减操作 meanT = mean.reshape([len(mean), 1]) # 求得图像的标准差 std = np.std(gray_img_crop, axis=1) # 将标准差转换为2维形式 stdT = std.reshape([len(std), 1]) # 如果标准差过大，使用1/np.sqrt(len(stdT)代替) adj_std = np.maximum(stdT, 1/np.sqrt(len(stdT))) # 进行标准化操作 normalize = (gray_img_crop - meanT) / adj_std return normalize # 第三步：数据的载入 def load_data(filename): # 数据标签名的读入 names = unpickle('{}/batches.meta'.format(filename))['label_names'] data = [] labels = [] for i in range(1, 6): # 循环读取，每一个文件的数据和标签名 data_dict = unpickle('{}/data_batch_{}'.format(filename, i)) if len(data) > 0 : # 对数据进行竖着串接 data = np.vstack((data, data_dict['data'])) # 对标签进行横着串接 labels = np.hstack((labels, data_dict['labels'])) else: data = data_dict['data'] labels = data_dict['labels'] # 对数据进行预处理操作 data = clean(data) # 将数据的类型转换为np.float32 data = data.astype(np.float32) # 返回标签名，数据，标签 return names, data, labels names, data, labels = load_data('./cifar-10-batches-py') print(names) # 第四步：进行图像的随机展示 def show_random_img(names, data, labels): # 数据的大小 N = data.shape[0] # 横和列的个数 rows, cols = 4, 8 # 从N个数据列表中，随机挑选4*8个数据的索引值 randix = random.sample(range(N), rows*cols) plt.figure() for i in range(rows * cols): # 循环，构造每一个图的子图 plt.subplot(rows, cols, i+1) # 获得单个的索引值 j = randix[i] # 文章名 ，使用标签对应的类别名 plt.title(names[labels[j]]) # 图像的维度转换 img = data[j,:].reshape([24, 24]) # 图片的展示 plt.imshow(img, cmap='Greys_r') plt.axis('off') plt.tight_layout() plt.show() show_random_img(names, data, labels)
第二部分：选择一张图片，作为输入数据，对卷积过程中的W，conv，pool分别进行展示
第一步：选择一张图片，进行维度的变化，使用plt.imshow() 进行图像的展示
第二步：构造初始参数
第一步：使用tf.reshape[row_img, [-1, 24, 24, 1]] 对x进行维度的变化
第二步：构造W和b，同时对x进行卷积，激活和池化操作
第三步：构造展示卷积层的函数，构造cols和rows进行子图展示，循环通道数，展示第一张图片的第i个通道的图片
第四步：构造展示W参数的函数，构造cols和rows进行子图展示，循环filter数，展示第一个通道的第i个filter的图片
第五步：构造执行函数sess，使用sess.run()获得数组，调用函数进行展示
# 第二部分：进行卷积过程中的图像展示 # 第一步：随机选择一张图，进行卷积图和参数图的演示 row_img = data[4,:] # 图像维度的变化 row_img = row_img.reshape([24, 24]) plt.figure() plt.imshow(row_img, cmap='Greys_r') plt.show() # 第二步：将图片进行维度变换，构造参数，并进行卷积，激活和池化操作 x = tf.reshape(row_img, shape=[-1, 24, 24, 1]) # 卷积的维度为[5, 5, 1, 32] 5和5表示维度，1表示通道数，32表示filter个数 W1 = tf.Variable(tf.random_normal([5, 5, 1, 32])) # 构造b1参数，维度为[32] b1 = tf.Variable(tf.random_normal([32])) # 进行一次卷积操作，strides表示步长 conv = tf.nn.conv2d(x, W1, strides=[1, 1, 1, 1], padding='SAME') # 加上偏置项b conv_with_b = tf.add(conv, b1) # 使用激活函数进行激活 conv_out = tf.nn.relu(conv_with_b) # 池化操作 k = 2 max_pool = tf.nn.max_pool(conv_out, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME') # 第三步：构造函数，进行卷积过程中的图像展示 def show_conv_img(conv_out, filename=None): # rows，cols的大小 rows, cols = 4, 8 # 循环，卷积图像的通道数 for i in range(conv_out.shape[3]): # 选择第一个图像的i通道 img = conv_out[0, :, :, i] # 构造子图 plt.subplot(rows, cols, i+1) # 图像的展示 plt.imshow(img, cmap='Greys_r') # 关闭坐标轴 plt.axis('off') # 图像更窄的显示 plt.tight_layout() if filename: plt.savefig(filename) else: plt.show() # 第四步：进行W参数的展示 def show_W(W, filename=None): # rows，cols的表示 rows, cols = 4, 8 plt.figure() # 循环W的filter个数 for i in range(W.shape[3]): # 图片表示为第1个通道的i个filter img = W[:, :, 0, i] # 构造子图 plt.subplot(rows, cols, i+1) plt.imshow(img, cmap='Greys_r') plt.axis('off') plt.tight_layout() if filename: plt.savefig(filename) else: plt.show() # 第五步：进行卷积图像和w的展示 with tf.Session() as sess: # 变量的初始化操作 sess.run(tf.global_variables_initializer()) # 将tf数据类型转换为数组类型，用于展示， 卷积层的展示 conv_val = sess.run(conv) print('conv:') show_conv_img(conv_val) # W1参数的展示 W_val = sess.run(W1) print('w:') show_W(W_val) # 卷积+激活后的图像展示 conv_out_val = sess.run(conv_out) print('conv_out') show_conv_img(conv_out_val) # 池化后的图像展示 pool_val = sess.run(max_pool) print('pool') show_conv_img(pool_val)
原始图像 w参数 第一次卷积 激活后 池化后
第三部分：进行正式的图像的训练操作
第一步：使用tf.placeholder(tf.float32, shape=[None, 24*24]) tf.placeholder(tf.float32, shape=[None, len(names)]) # 构造x和y
第二步：构造卷积层和全连接层的参数
第一层卷积： w:5,5,1,64 b:64
第二层卷积： w: 5,5,64.64 b:64
第三层全连接： w: 6*6*64, 1024 b:1024
第四层全连接： w：1024，len(names) b:len(names)
第三步：构造conv函数：用于进行卷积，激活操作
第四步：构造pool函数：用于进行最大值池化操作
第五步：构造model函数：进行卷积和全连接操作
第一步：使用tf.reshape(x, [None, 28, 28, 1]) 进行矩阵的维度变化
第二步：进行第一次卷积和池化操作
第三步：使用tf.nn.lrn对数据进行局部最大值响应
第四步：进行第二次卷积操作
第五步：使用tf.nn.lrn对数据进行局部最大值响应
第六步：进行第二次池化操作
第七步：改变池化后的矩阵的维度，为[-1, 6*6*64]，进行第一次全连接操作
第八步：进行第二次全连接操作
第六步：将返回的model_op得分，使用tf.reduce_mean(tf.nn.softmax) 构造softmax的损失函数
第七步： 使用tf.nn.Adaoptimer() 自适应梯度下降来进行损失值得降低
第八步：使用tf.equal() 和 tf.reduce_mean 计算accur
第九步：构造sess执行函数，并进行初始化操作
第十步：使用tf.one_hot将标签转换为one_hot格式，并使用sess.run将tf格式的标签重新转换为数组格式
第十一步：进入循环，设置batch的大小，以及平均准确率为0
第十二步：使用np.arange(0, len(data), batch_size) 进行一个batch的循环，使用data_batch = data[j:j+batch, :] 获得一个batch的数据，同理获得一个标签的数据
第十三步：将batch数据带入到sess.run([opt, accr]) 进行梯度下降和准确率的计算，
第十四步：计算平均准确率，并打印
#第三部分： 开始进行正式的模型训练 # 第一步：使用tf.placeholder()进行输入数据的初始化 x = tf.placeholder(tf.float32, [None, 24*24]) y = tf.placeholder(tf.float32, [None, len(names)]) # 第二步：构造卷积和全连接的参数 # W1的维度为5,5,1, 64 W1 = tf.Variable(tf.random_normal([5, 5, 1, 64])) # b1的维度为64 b1 = tf.Variable(tf.random_normal([64])) # W2的维度为5,5,64,64 W2 = tf.Variable(tf.random_normal([5, 5, 64, 64])) # b2的维度为64 b2 = tf.Variable(tf.random_normal([64])) # W3的维度为6*6*64， 1024 W3 = tf.Variable(tf.random_normal([6*6*64, 1024])) # b3的维度为64 b3 = tf.Variable(tf.random_normal([1024])) # W_out的维度为1024,10 W_out = tf.Variable(tf.random_normal([1024, len(names)])) # b_out的维度为10 b_out = tf.Variable(tf.random_normal([len(names)])) # 第三步：构建卷积和激活层的函数 def conv(x, w, b): return tf.nn.relu(tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME') + b) # 第四步：构建池化层的函数 def pool(x, k=2): return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') # 第五步：构建模型，进行卷积和全连接的操作 def model(): # 进行输入x的维度变换，以便进行后续的卷积操作 x_reshapedd = tf.reshape(x, shape=[-1, 24, 24, 1]) # 进行卷积操作 conv_h1 = conv(x_reshapedd, W1, b1) # 进行池化操作 pool_h1 = pool(conv_h1) # 进行非极大值抑制操作 norm1 = tf.nn.lrn(pool_h1, 4, bias=1.0, alpha=0.001/9.0, beta=0.75) # 进行第二次卷积操作 conv_h2 = conv(norm1, W2, b2) # 进行非极大值抑制操作 norm2 = tf.nn.lrn(conv_h2, 4, bias=1.0, alpha=0.001/9.0, beta=0.75) # 进行池化操作 pool_h2 = pool(norm2) # 重构池化层后的矩阵维度，为了进行全连接操作 fc1_input = tf.reshape(pool_h2, [-1, 6*6*64]) # 进行第一次全连接操作 fc_h1 = tf.nn.relu(tf.matmul(fc1_input, W3) + b3) # 进行第二次全连接操作 fc_out = tf.matmul(fc_h1, W_out) + b_out return fc_out # 第六步：获得得分，使用tf.nn.softmax_cross获得softmax的损失值 model_op = model() cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=model_op, labels=y)) # 第七步：使用自适应损失值优化器，进行损失值的下降 train_op = tf.train.AdamOptimizer(0.001).minimize(cost) # 第八步：使用tf.equal和tf.reduce_mean求出准确度 correct_pred = tf.equal(tf.argmax(model_op, 1), tf.argmax(y, 1)) accur = tf.reduce_mean(tf.cast(correct_pred, 'float')) batch_size = 50 # 第九步：构造sess，并进行初始化 with tf.Session() as sess: sess.run(tf.global_variables_initializer()) # 第十步：对标签使用one-hot编码，并使用sess.run()转换回数据类型 train_labels = tf.one_hot(labels, len(names), axis=-1) train_labels = sess.run(train_labels) for j in range(1000): # 第十一步：设置batchsize大小，即average的平均值为0 average = 0 batch_num = 0 for i in range(0, len(data), batch_size): # 第十二步：使用data[i:i+batch_size, :] 获得batch数据和batch标签值 train_data = data[i:i+batch_size, :] train_label = train_labels[i:i+batch_size, :] # 第十三步：将batch数据和标签值带入，用于进行损失值的降低和准确率的计算 _, accurracy = sess.run([train_op, accur], feed_dict={x:train_data, y:train_label}) average += accurracy batch_num += 1 # 第十四步：求出平均准确率并打印 average /= batch_num print('epoch average accurracy %g'%(average, ))
迭代的结果