Tensorflow–神经网络处理分类问题
一.TFRecord文件
TFRecord是Tensorflow设计的一种存储数据的内置文件格式，可以方便高效地管理数据及这些数据的相关信息，利用它可以将数据快速加载到内存中。接下来介绍如何将数据写入TFRecord文件和从TFRecord中解析数据的过程
1.将ndarray写入TFRecord文件
假设有3个三维的ndarray，尺寸依次为2行3列4深度，3行3列3深度和2行2列3深度。将这3个ndarray及其对应的尺寸(高，宽，深度)写入文件名为data1.tfrecord的TFRecord文件中
import tensorflow as tf
import numpy as np
# 创建文件
record=tf.python_io.TFRecordWriter("dataTest1.tfrecord")
# 高为2，宽为3，深度为4的三维ndarray
array1=np.array(
[
[[1,2,1,2],[3,4,2,9],[5,6,0,3]],
[[7,8,1,6],[9,6,1,7],[1,2,5,9]]
]
,np.float32
)
# 高为3，宽为3，深度为3的三维ndarray
array2=np.array(
[
[[11,12,11],[13,14,12],[15,16,13]],
[[17,18,11],[19,10,11],[11,12,15]],
[[13,14,15],[18,11,12],[19,14,10]]
]
,np.float32
)
# 高为2，宽为2，深度为3的三维ndarray
array3=np.array(
[
[[21,23,21],[23,24,22]],
[[27,28,24],[29,20,21]]
]
,np.float32
)
# 将上述3个ndarray存入一个列表
arrays=[array1,array2,array3]
# 循环处理上述列表中的每一个ndarray
for array in arrays:
# 计算每一个ndarray的形状
height,width,depth=array.shape
# 将ndarray中的值转为字节类型
array_raw=array.tostring()
# ndarray的值及对应的高，宽及深度
feature={
'array_raw':
tf.train.Feature(
bytes_list=tf.train.BytesList(value=[array_raw])
),
'height':
tf.train.Feature(int64_list=tf.train.Int64List(value=[height])),
'width':
tf.train.Feature(int64_list=tf.train.Int64List(value=[width])),
'depth':
tf.train.Feature(int64_list=tf.train.Int64List(value=[depth]))
}
features=tf.train.Features(feature=feature)
example=tf.train.Example(features=features)
# 字符串序列化后写入文件
record.write(example.SerializeToString())
record.close()
在上述程序中，首先得到每一个ndarray的高，宽和深度，然后利用ndarray的成员函数tostring()将ndarray转换为字节类型，并将这些数据存储在tf.train.Example对象中，再利用其成员函数SerializeToString()序列化为二进制字符串，最后利用TFRecordWriter对象的成员函数Write将序列化后的二进制字符串写入TFRecord文件中
2.从TFRecord解析数据
首先利用函数tr.train.string_input_producer读取一个TFRecord文件列表，然后创建一个TFRecordReader对象，利用其成员函数读取TFRecord文件列表，最后利用函数tf,parse_single_example解析文件中的数据
import tensorflow as tf
import numpy as np
# 读取tfrecord文件列表
record_queue=tf.train.string_input_producer(['dataTest1.tfrecord'],num_epochs=2)
# 创建一个TFRecordReader对象
reader=tf.TFRecordReader()
_,serialized_example=reader.read(record_queue)
# j解析tfrecord中的数据，每次只解析一个
features=tf.parse_single_example(
serialized_example,
features={
'array_raw':tf.FixedLenFeature([],tf.string),
'height':tf.FixedLenFeature([],tf.int64),
'width':tf.FixedLenFeature([],tf.int64),
'depth':tf.FixedLenFeature([],tf.int64)
}
)
# 解析出对应的值
array_raw=features['array_raw']
array=tf.decode_raw(array_raw,tf.float32) # 解码
height=features['height']
width=features['width']
depth=features['depth']
# 创建会话
session=tf.Session()
session.run(tf.global_variables_initializer())
session.run(tf.local_variables_initializer())
coord=tf.train.Coordinator()
threads=tf.train.start_queue_runners(sess=session,coord=coord)
# 循环5次解析文件流中的数据
for i in range(5):
ndarray,h,w,d=session.run([array,height,width,depth])
print("---第%(num)d次解析到的ndarray---"%{"num":i+1})
print(ndarray)
coord.request_stop()
coord.join(threads)
session.close()
---第1次解析到的ndarray---
[ 1. 2. 1. 2. 3. 4. 2. 9. 5. 6. 0. 3. 7. 8. 1. 6. 9. 6.
1. 7. 1. 2. 5. 9.]
---第2次解析到的ndarray---
[ 11. 12. 11. 13. 14. 12. 15. 16. 13. 17. 18. 11. 19. 10. 11.
11. 12. 15. 13. 14. 15. 18. 11. 12. 19. 14. 10.]
---第3次解析到的ndarray---
[ 21. 23. 21. 23. 24. 22. 27. 28. 24. 29. 20. 21.]
---第4次解析到的ndarray---
[ 1. 2. 1. 2. 3. 4. 2. 9. 5. 6. 0. 3. 7. 8. 1. 6. 9. 6.
1. 7. 1. 2. 5. 9.]
---第5次解析到的ndarray---
[ 11. 12. 11. 13. 14. 12. 15. 16. 13. 17. 18. 11. 19. 10. 11.
11. 12. 15. 13. 14. 15. 18. 11. 12. 19. 14. 10.]
从打印结果可以看出，解析出的每个ndarray都是一维的，这是因为在写入文件时，首先将原数据转换为字节类型。当然我们也可以根据解析到的每个ndarray对应的高，宽和深度将其转换为三维的ndarray
import tensorflow as tf
import numpy as np
# 读取tfrecord文件列表
record_queue=tf.train.string_input_producer(['dataTest1.tfrecord'],num_epochs=2)
# 创建一个TFRecordReader对象
reader=tf.TFRecordReader()
_,serialized_example=reader.read(record_queue)
# j解析tfrecord中的数据，每次只解析一个
features=tf.parse_single_example(
serialized_example,
features={
'array_raw':tf.FixedLenFeature([],tf.string),
'height':tf.FixedLenFeature([],tf.int64),
'width':tf.FixedLenFeature([],tf.int64),
'depth':tf.FixedLenFeature([],tf.int64)
}
)
# 解析出对应的值
array_raw=features['array_raw']
array=tf.decode_raw(array_raw,tf.float32) # 解码
height=features['height']
width=features['width']
depth=features['depth']
# 创建会话
session=tf.Session()
session.run(tf.global_variables_initializer())
session.run(tf.local_variables_initializer())
coord=tf.train.Coordinator()
threads=tf.train.start_queue_runners(sess=session,coord=coord)
# 循环5次解析文件流中的数据
for i in range(5):
ndarray,h,w,d=session.run([array,height,width,depth])
ndarray=np.reshape(ndarray,[h,w,d])
print('---第%(num)d次解析到ndarray---'%{'num':i+1})
print(ndarray)
coord.request_stop()
coord.join(threads)
session.close()
---第1次解析到ndarray---
[[[ 1. 2. 1. 2.]
[ 3. 4. 2. 9.]
[ 5. 6. 0. 3.]]
[[ 7. 8. 1. 6.]
[ 9. 6. 1. 7.]
[ 1. 2. 5. 9.]]]
---第2次解析到ndarray---
[[[ 11. 12. 11.]
[ 13. 14. 12.]
[ 15. 16. 13.]]
[[ 17. 18. 11.]
[ 19. 10. 11.]
[ 11. 12. 15.]]
[[ 13. 14. 15.]
[ 18. 11. 12.]
[ 19. 14. 10.]]]
---第3次解析到ndarray---
[[[ 21. 23. 21.]
[ 23. 24. 22.]]
[[ 27. 28. 24.]
[ 29. 20. 21.]]]
---第4次解析到ndarray---
[[[ 1. 2. 1. 2.]
[ 3. 4. 2. 9.]
[ 5. 6. 0. 3.]]
[[ 7. 8. 1. 6.]
[ 9. 6. 1. 7.]
[ 1. 2. 5. 9.]]]
---第5次解析到ndarray---
[[[ 11. 12. 11.]
[ 13. 14. 12.]
[ 15. 16. 13.]]
[[ 17. 18. 11.]
[ 19. 10. 11.]
[ 11. 12. 15.]]
[[ 13. 14. 15.]
[ 18. 11. 12.]
[ 19. 14. 10.]]]
从TFRecord文件中随机解析数据
假设有3个尺寸同为1行2列3深度的ndarray，写入文件名为data2.tfrecord的TFRecord文件中，因为已经知道这3个ndarray的尺寸都是1行2列3深度，所以一般只存储原数据即可，不存储其高，宽，深度等信息
import tensorflow as tf
import numpy as np
record=tf.python_io.TFRecordWriter("dataTest2.tfrecord")
array1=np.array(
[
[[1,2,3],[4,5,6]],
]
,np.float32
)
array2=np.array(
[
[[11,12,13],[14,15,16]],
]
,np.float32
)
array3=np.array(
[
[[21,23,21],[23,24,22]],
]
,np.float32
)
arrays=[array1,array2,array3]
for array in arrays:
array_raw=array.tostring()
feature={
'array_raw':
tf.train.Feature(
bytes_list=tf.train.BytesList(value=[array_raw])
),
}
features=tf.train.Features(feature=feature)
example=tf.train.Example(features=features)
record.write(example.SerializeToString())
record.close()
import tensorflow as tf
import numpy as np
# 创建一个TFRecordReader对象
epochs=2
reader=tf.TFRecordReader()
record_queue=tf.train.string_input_producer(['dataTest2.tfrecord'],num_epochs=epochs)
_,serialized_example=reader.read(record_queue)
# 解析文件中的图像及其对应的标签
features=tf.parse_single_example(
serialized_example,
features={
'array_raw':tf.FixedLenFeature([],tf.string)
}
)
# 解码二进制数据
array_raw=features['array_raw']
array_raw=tf.decode_raw(array_raw,tf.float32) # 解码
array=tf.reshape(array_raw,[1,2,3])
# 每次从文件中读取2个数据
BatchSize=2
arrays=tf.train.shuffle_batch([array],BatchSize,1000+3*BatchSize,1000)
# 创建会话
session=tf.Session()
session.run(tf.global_variables_initializer())
session.run(tf.local_variables_initializer())
coord=tf.train.Coordinator()
threads=tf.train.start_queue_runners(sess=session,coord=coord)
# 循环2次,从文件中随机读取
for i in range(2):
arrs=session.run([arrays])
print('---第%(num)d次解析到ndarray---'%{'num':i+1})
print(arrs)
coord.request_stop()
coord.join(threads)
session.close()
二.建立分类问题的数学模型
1.数据类别
Tensorflow通过函数one_hot实现类别的数字化
import tensorflow as tf
v=tf.one_hot([9,2,7,3,0,4,8,6,1,3,4,8,6,1],depth=10,axis=1,dtype=tf.float32)
session=tf.Session()
print(session.run(v))
[[ 0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
[ 0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]
[ 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
[ 1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]
[ 0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]
[ 0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]]
以上代码中，函数one_hot中的参数depth=10代表有10个类别，axis代表按照每一行存储类别的数字化，因为有10类，所以返回结果有10列
2.图像与TFRecorder
将ndarray写入TFRecord的方法，分别将每一个文件夹下的数字图像保存到一个TFRecord文件中，代码如下：
import tensorflow as tf
import os
import matplotlib.image as mp_image
N=10
for label in range(N):
record=tf.python_io.TFRecordWriter(os.path.curdir+'/data/'+'data%(label)d.tfrecord'%{'label':label})
curDir=os.path.curdir+'/data/'+str(label)+'/'
fileList=os.listdir(curDir)
for name in fileList:
# 图片的路径和名称
imagePath=curDir+name
# 读取图片，数字化为ndarray
image=mp_image.imread(imagePath)
# 将ndarray二进制化
img_raw=image.tostring()
feature={
'img_raw':
tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw])),
'label':
tf.train.Feature(int64_list=tf.train.Int64List(value=[label]))
}
features=tf.train.Features(feature=feature)
example=tf.train.Example(features=features)
# 字符串序列化后写入文件
record.write(example.SerializeToString())
# 关闭文件流
record.close()
介绍如何从这10个TFRecord文件中，每次随机读取3幅图片和对应的分类标签
import os
import tensorflow as tf
import matplotlib.pyplot as plt
H,W=28,28
files=tf.train.match_filenames_once(os.path.curdir+"/data/"+"data*.tfrecord")
# 创建TFRecordReader对象
reader=tf.TFRecordReader()
records_queue=tf.train.string_input_producer(files,num_epochs=2)
_,serialized_example=reader.read(records_queue)
# 解析文件中的图像及其对应的标签
features=tf.parse_single_example(
serialized_example,
features={
'img_raw':tf.FixedLenFeature([],tf.string),
'label':tf.FixedLenFeature([],tf.int64),
}
)
# 解码二进制数据
img_raw=features['img_raw']
img_raw=tf.decode_raw(img_raw,tf.uint8)
# 转换成图片
img=tf.reshape(img_raw,[H,W])
# 标签
label=features['label']
label=tf.cast(label,tf.int64)
# 每次从文件中读取3张图片
BatchSize=3
img,label=tf.train.shuffle_batch([img,label],BatchSize,1000+3*BatchSize,1000)
session=tf.Session()
session.run(tf.global_variables_initializer())
session.run(tf.local_variables_initializer())
coord=tf.train.Coordinator()
threads=tf.train.start_queue_runners(sess=session,coord=coord)
print(session.run(files))
# 循环2次解析文件流中的数据
for i in range(2):
print("---第%(num)d批图像---"%{'num':i+1})
imgs,labels=session.run([img,label])
for j in range(BatchSize):
print("---第%(num)d批图像中的第%(index)d张：标签为%(l)d---"%{"num":i+1,"index":j+1,"l":labels[j]})
plt.imshow(imgs[j,:,:])
plt.show()
coord.request_stop()
coord.join(threads)
session.close()
[b'.\data\data0.tfrecord' b'.\data\data1.tfrecord'
b'.\data\data2.tfrecord' b'.\data\data3.tfrecord'
b'.\data\data4.tfrecord' b'.\data\data5.tfrecord'
b'.\data\data6.tfrecord' b'.\data\data7.tfrecord'
b'.\data\data8.tfrecord' b'.\data\data9.tfrecord']
---第1批图像---
---第1批图像中的第1张：标签为2---
---第1批图像中的第2张：标签为5---
---第1批图像中的第3张：标签为6---
---第2批图像---
---第2批图像中的第1张：标签为7---
---第2批图像中的第2张：标签为1---
---第2批图像中的第3张：标签为3---
3.建立模型
全连接神经网络的输入层都是一维张量，而图像是高维张量(灰色图像是二维张量，彩色图像是三维张量)。如果把图像转换为一个全连接神经网络的输入，直接将高维张量拉伸为一个一维张量即可
import tensorflow as tf
# 构建全连接神经网络
def net(tensor):
# 输入层，隐含层，输出层的神经元个数
I,H1,O=784,200,10
# 第1层的权重矩阵和偏置
w1=tf.random_normal([I,H1],0,1,tf.float32)
b1=tf.random_normal([H1],0,1,tf.float32)
# 隐含层的结果，采用sigmoid激活函数
l1=tf.matmul(tensor,w1)+b1
sigma1=tf.nn.sigmoid(l1)
# 第2层的权重矩阵和偏置
w2=tf.random_normal([H1,O],0,1,tf.float32)
b2=tf.random_normal([O],0,1,tf.float32)
# 输出层的结果
l2=tf.matmul(sigma1,w2)+b2
return l2
# 读取图片文件
image=tf.read_file("0.jpg","r")
# 将图片文件解码为Tensor
image_tensor=tf.image.decode_jpeg(image)
# 图像张量的形状
length=tf.size(image_tensor) # length=28*28
# 改变形状，拉伸为1个一维张量，按行存储
t=tf.reshape(image_tensor,[1,length])
# 数据类型转换，转换为float32类型
t=tf.cast(t,tf.float32)
# 标准化处理
t=t/255.0
output=net(t)
session=tf.Session()
print(session.run(output))
[[-13.0977354 4.13779497 5.97057438 -7.29600286 -11.34489727
-4.86154842 -2.60884142 0.13025093 -1.98705816 -0.21878564]]
最理想的情况是经过全连接神经网络的输出结果_y(即全连接神经网络输出层的值)与人工分类的结果y相等
三.损失函数与训练模型
对于分类问题的损失函数，常用的是sigmoid交叉熵和softmax交叉熵
1.sigmoid损失函数
Tensorflow通过函数sigmoid_cross_entropy_with_logits(labels,logits,name)实现sigmoid交叉熵，其中labels代表人工分类标签，是一个N行C列的二维张量，代表N个样本的标签，每一行代表一个样本的分类标签，logits代表输出层的结果，与labels的尺寸相同，每一行代表一个样本经过全连接神经后的输出值，利用求和函数reduce_sum对函数sigmoid_cross_entropy_logits返回的结果求和，其结果为sigmoid交叉熵损失函数
import tensorflow as tf
# 输出层的值
logits=tf.constant(
[
[-13.0977354,4.13779497,5.97057438,-7.29600286,-11.34489727,-4.86154842,-2.60884142,0.13025093,-1.98705816,-0.21878564]
]
)
# 人工分类的标签
labels=tf.constant([[1,0,0,0,0,0,0,0,0,0]],tf.float32)
# sigmoid交叉熵
entroy=tf.nn.sigmoid_cross_entropy_with_logits(logits=logits,labels=labels)
# 损失值
loss=tf.reduce_sum(entroy)
session=tf.Session()
print(session.run(loss))
24.7825
2.softmax损失函数
softmax计算原理
Tensorflow通过函数softmax(logits,axis=None,name=None,dim=None)实现softmax处理
import tensorflow as tf
# 输入张量
t=tf.constant([2,5,3],tf.float32)
x=tf.log(t)
# softmax处理
s=tf.nn.softmax(x,0)
# 创建会话
session=tf.Session()
print(session.run(s))
[ 0.19999999 0.5 0.29999998]
函数tf.nn.softmax可以处理多维张量
import tensorflow as tf
# 输入张量
x=tf.constant(
[
[1,2,1],
[2,2,2]
]
,tf.float32
)
# 分别对每一行(沿"1"方向)进行softmax处理
s=tf.nn.softmax(x,1)
session=tf.Session()
print(session.run(s))
[[ 0.21194157 0.57611692 0.21194157]
[ 0.33333334 0.33333334 0.33333334]]
softmax交叉熵及softmax损失函数
利用Tensorflow的求和函数reduce_sum和函数tf.nn.softmax定义softmax损失函数为tf.reduce_sum(-y*tf.nn.softmax(_y,1))
import tensorflow as tf
# 假设_y为全连接神经网络的输出(输出层有3个神经元)
_y=tf.constant(
[
[0,2,-3],
[4,-5,6]
]
,tf.float32
)
# 人工分类结果
y=tf.constant(
[
[1,0,0],
[0,0,1]]
,tf.float32
)
# softmax熵
_y_softmax=tf.nn.softmax(_y)
entroy=tf.reduce_sum(-y*tf.log(_y_softmax),1)
# loss损失函数
loss=tf.reduce_sum(entroy)
session=tf.Session()
print(session.run(loss))
2.25979
以上代码实现中，使用了乘法运算符*和函数tf.nn.softmax实现softmax熵，Tensorflow将这两个运算封装成了一个函数softmax_cross_entroy_with_logits_v2,
即tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(logits,labels))
import tensorflow as tf
# 假设_y为全连接神经网络的输出(输出层有3个神经元)
_y=tf.constant([[0,2,-3],[4,-5,6]],tf.float32)
# 人工分类结果
y=tf.constant([[1,0,0],[0,0,1]],tf.float32)
# softmax熵
entroy=tf.nn.softmax_cross_entropy_with_logits(logits=_y,labels=y)
# loss损失函数
loss=tf.reduce_sum(entroy)
session=tf.Session()
print(session.run(loss))
2.25979
3.训练和评估模型
直到现在我们已经掌握了：
1.从TFRecord中解析数据
2.构建全连接神经网络
3.构造损失函数
4.梯度下降法
import tensorflow as tf
import os
# 占位符
x=tf.placeholder(tf.float32,[None,28*28])
labels=tf.placeholder(tf.float32,[None,10])
# 第1步：解析数据
nums=33 # 所有训练样本的个数
# 得到文件夹./data/下的所有tfrecord文件
files=tf.train.match_filenames_once(os.path.curdir+"/data/"+"data*.tfrecord")
# 创建TFRecordReader对象
num_epochs=1000
reader=tf.TFRecordReader()
records_queue=tf.train.string_input_producer(files,num_epochs=num_epochs)
_,serialized_example=reader.read(records_queue)
# 解析文件中的图像及其对应的标签
features=tf.parse_single_example(
serialized_example,
features={
'img_raw':tf.FixedLenFeature([],tf.string),
'label':tf.FixedLenFeature([],tf.int64),
}
)
# 解码二进制数据
img_raw=features['img_raw']
img_raw=tf.decode_raw(img_raw,tf.uint8)
img=tf.reshape(img_raw,[28*28])
img=tf.cast(img,tf.float32)
img=img/255.0
# 标签
label=features['label']
label=tf.cast(label,tf.int64)
label_onehot=tf.one_hot(label,10,dtype=tf.float32)
# 每次从文件中读取3张图片
BatchSize =3
imgs,labels_onehot=tf.train.shuffle_batch([img,label_onehot],BatchSize,1000+3*BatchSize,1000)
# 第2步：构建全连接神经网络
# 输入层，隐含层，输出层的神经元个数
I,H1,O=784,200,10
# 输入层到隐含层的权重矩阵和偏置
w1=tf.Variable(tf.random_normal([I,H1],0,1,tf.float32),dtype=tf.float32,name='w1')
b1=tf.Variable(tf.random_normal([H1],0,1,tf.float32),dtype=tf.float32,name='b1')
# 隐含层的结果，采用sigmoid激活函数
l1=tf.matmul(x,w1)+b1
sigma1=tf.nn.sigmoid(l1)
# 第2层的权重及偏置
w2=tf.Variable(tf.random_normal([H1,O],0,1,tf.float32),dtype=tf.float32,name='w2')
b2=tf.Variable(tf.random_normal([O],0,1,tf.float32),dtype=tf.float32,name='b2')
# 输出层的结果
logits=tf.matmul(sigma1,w2)+b2
# 第3步：构造损失函数
loss=tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(labels=labels_onehot,logits=logits))
# 第4步：梯度下降
opti=tf.train.AdamOptimizer(0.001,0.9,0.999,1e-8).minimize(loss)
session=tf.Session()
session.run(tf.global_variables_initializer())
session.run(tf.local_variables_initializer())
coord=tf.train.Coordinator()
threads=tf.train.start_queue_runners(sess=session,coord=coord)
for i in range(num_epochs):
for n in range(int(nums/BatchSize)):
imgs_arr,lables_onehot_arr=session.run([imgs,labels_onehot])
session.run(opti,feed_dict={x:imgs_arr,labels:lables_onehot_arr})
coord.request_stop()
coord.join(threads)
session.close()
以上代码中函数tf.train.shuffle_batch和tf.train.AdamOptimizer的组合使用其实就实现了用随机梯度下降法处理函数的最小值