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表示系数

深度学习原理与框架-Tensorflow卷积神经网络-cifar10图片分类(代码)  1.tf.nn.lrn(局部响应归一化操作)  2.random.sample(在列表中随机选值) 3.tf.one_hot(对标签进行one_hot编码) 

          局部响应的公式 

针对上述公式,做了一个试验代码:

# 自己编写的代码, 对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)

深度学习原理与框架-Tensorflow卷积神经网络-cifar10图片分类(代码)  1.tf.nn.lrn(局部响应归一化操作)  2.random.sample(在列表中随机选值) 3.tf.one_hot(对标签进行one_hot编码)

第二部分:选择一张图片,作为输入数据,对卷积过程中的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)

深度学习原理与框架-Tensorflow卷积神经网络-cifar10图片分类(代码)  1.tf.nn.lrn(局部响应归一化操作)  2.random.sample(在列表中随机选值) 3.tf.one_hot(对标签进行one_hot编码)  深度学习原理与框架-Tensorflow卷积神经网络-cifar10图片分类(代码)  1.tf.nn.lrn(局部响应归一化操作)  2.random.sample(在列表中随机选值) 3.tf.one_hot(对标签进行one_hot编码)  深度学习原理与框架-Tensorflow卷积神经网络-cifar10图片分类(代码)  1.tf.nn.lrn(局部响应归一化操作)  2.random.sample(在列表中随机选值) 3.tf.one_hot(对标签进行one_hot编码) 深度学习原理与框架-Tensorflow卷积神经网络-cifar10图片分类(代码)  1.tf.nn.lrn(局部响应归一化操作)  2.random.sample(在列表中随机选值) 3.tf.one_hot(对标签进行one_hot编码) 深度学习原理与框架-Tensorflow卷积神经网络-cifar10图片分类(代码)  1.tf.nn.lrn(局部响应归一化操作)  2.random.sample(在列表中随机选值) 3.tf.one_hot(对标签进行one_hot编码)

            原始图像                              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, ))

深度学习原理与框架-Tensorflow卷积神经网络-cifar10图片分类(代码)  1.tf.nn.lrn(局部响应归一化操作)  2.random.sample(在列表中随机选值) 3.tf.one_hot(对标签进行one_hot编码)

                           迭代的结果