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, ))

迭代的结果

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

  1. 深度学习原理与框架-Tensorflow卷积神经网络-卷积神经网络mnist分类 1.tf.nn.conv2d(卷积操作) 2.tf.nn.max_pool(最大池化操作) 3.tf.nn.dropout(执行dropout操作) 4.tf.nn.softmax_cross_entropy_with_logits(交叉熵损失) 5.tf.truncated_normal(两个标准差内的正态分布)

    1. tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME')  # 对数据进行卷积操作 参数说明:x表示输入数据,w表示卷积核, stride ...

  2. 深度学习原理与框架-Tensorflow卷积神经网络-神经网络mnist分类

    使用tensorflow构造神经网络用来进行mnist数据集的分类 相比与上一节讲到的逻辑回归,神经网络比逻辑回归多了隐藏层,同时在每一个线性变化后添加了relu作为激活函数, 神经网络使用的损失值为 ...

  3. 深度学习原理与框架-Tensorflow基本操作-mnist数据集的逻辑回归 1.tf.matmul(点乘操作) 2.tf.equal(对应位置是否相等) 3.tf.cast(将布尔类型转换为数值类型) 4.tf.argmax(返回最大值的索引) 5.tf.nn.softmax(计算softmax概率值) 6.tf.train.GradientDescentOptimizer(损失值梯度下降器)

    1. tf.matmul(X, w) # 进行点乘操作 参数说明:X,w都表示输入的数据, 2.tf.equal(x, y) # 比较两个数据对应位置的数是否相等,返回值为True,或者False 参 ...

  4. 深度学习原理与框架-Tensorflow基本操作-实现线性拟合

    代码:使用tensorflow进行数据点的线性拟合操作 第一步:使用np.random.normal生成正态分布的数据 第二步:将数据分为X_data 和 y_data 第三步:对参数W和b, 使用t ...

  5. 深度学习原理与框架-Tensorflow基本操作-变量常用操作 1.tf.random_normal(生成正态分布随机数) 2.tf.random_shuffle(进行洗牌操作) 3. tf.assign(赋值操作) 4.tf.convert_to_tensor(转换为tensor类型) 5.tf.add(相加操作) tf.divide(相乘操作) 6.tf.placeholder(输入数据占位

    1. 使用tf.random_normal([2, 3], mean=-1, stddev=4) 创建一个正态分布的随机数 参数说明:[2, 3]表示随机数的维度,mean表示平均值,stddev表示 ...

  6. 深度学习原理与框架-Tfrecord数据集的读取与训练(代码) 1.tf.train.batch(获取batch图片) 2.tf.image.resize_image_with_crop_or_pad(图片压缩) 3.tf.train.per_image_stand..(图片标准化) 4.tf.train.string_input_producer(字符串入队列) 5.tf.TFRecord(读

    1.tf.train.batch(image, batch_size=batch_size, num_threads=1) # 获取一个batch的数据 参数说明:image表示输入图片,batch_ ...

  7. 深度学习原理与框架-Tensorflow基本操作-Tensorflow中的变量

    1.tf.Variable([[1, 2]])  # 创建一个变量 参数说明:[[1, 2]] 表示输入的数据,为一行二列的数据 2.tf.global_variables_initializer() ...

  8. UFLDL深度学习笔记 （六）卷积神经网络

    UFLDL深度学习笔记 (六)卷积神经网络 1. 主要思路 "UFLDL 卷积神经网络"主要讲解了对大尺寸图像应用前面所讨论神经网络学习的方法,其中的变化有两条,第一,对大尺寸图像 ...

  9. 神经网络与深度学习笔记 Chapter 6之卷积神经网络

    深度学习 Introducing convolutional networks:卷积神经网络介绍 卷积神经网络中有三个基本的概念:局部感受野(local receptive fields), 共享权重 ...

随机推荐

  1. bat中errorlevel与%errorlevel%的区别

    bat中errorlevel与%errorlevel%的区别? 他们都是判断上个命令的返回值.当使用if errorlevel 值 cmmand 句式时,它的含义是:如果返回的错误码值大于或等于值 的 ...

  2. mysql 分组排序取最值

    查各个用户下单最早的一条记录 查各个用户下单最早的前两条记录 查各个用户第二次下单的记录 一.建表填数据: SET NAMES utf8mb4; -- 取消外键约束 ; -- ------------ ...

  3. php优秀框架codeigniter学习系列——CI_Security类学习

    这篇文章主要介绍CI核心框架工具类CI_Security. 安全类包含了一些方法,用于安全的处理输入数据,帮助你创建一个安全的应用.以下选取类中的重点方法进行说明. __construct() 在构造 ...

  4. Vue编译提示警告

    There are multiple modules with names that only differ in casing.有多个模块同名仅大小写不同This can lead to unexp ...

  5. git创建分支并上传仓库

    1. 新建分支 xxx 2.  git pull (目录下 命令行将线上分支拉倒本地) 3. git checkout xxx (切换到到该分支 ) (可使用 git status 查看目前处于哪一个 ...

  6. ubuntu下安装mysql和配置远程访问

    ubuntu下安装mysql和配置远程访问   下载安装mysql sudo apt-get install mysql-client mysql-server 安装的时候会提示要设置root密码,如 ...

  7. zombodb 索引创建

      索引的创建是zombodb 的核心,我们都是需要先创建table,然后创建索引,创建的时候我们可以指定es 集群的地址,同时可能需要使用 一些地址api(比如数据直接存储在es 中而不是pg 中) ...

  8. maven+dubbo+zookeeper 基础实例

    1.maven  引入依赖 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http:/ ...

  9. 【C++】atof()

    转自:https://blog.csdn.net/zhaoyl03/article/details/8176387 atof 是ascII to float的缩写,它将ascII字符串转换为相应的单精 ...

  10. PHP 获取数组是几维数组

    // 判断数组是几维数组$data = array(); // 是你要判断的数组$al = array(0);function aL($data,&$al,$level=0){ if(is_a ...