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, ))
迭代的结果