【转】机器学习教程 十四-利用tensorflow做手写数字识别

什么是tensorflow

tensorflow安装

sudopipinstall'target='_blank'>https://storage.googleapis.com/tensorflow/mac/tensorflow-0.9.0-py2-none-any.whl[/code]

不同平台找对应的whl包

可能遇到的问题：

发现无法importtensorflow，问题在于protobuf版本不对，必须先卸载掉，再安装tensorflow，这样会自动安装3.0版本的protobuf

sudopipuninstallprotobuf
sudobrewremoveprotobuf260
sudopipinstall--upgrade'target='_blank'>https://storage.googleapis.com/tensorflow/mac/tensorflow-0.9.0-py2-none-any.whl[/code]


手写数字数据集获取
在http://yann.lecun.com/exdb/mnist/可以下载手写数据集，http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz和http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz，下载解压后发现不是图片格式，而是自己特定的格式，为了说明这是什么样的数据，我写了一段程序来显示这些数字：

/************************
*author:SharEDITor
*date:2016-08-02
*brief:readMNISTdata
************************/
#include<stdio.h>
#include<stdint.h>
#include<assert.h>
#include<stdlib.h>

unsignedchar*lables=NULL;

/**
*AlltheintegersinthefilesarestoredintheMSBfirst(highendian)format
*/
voidcopy_int(uint32_t*target,unsignedchar*src)
{
*(((unsignedchar*)target)+0)=src[3];
*(((unsignedchar*)target)+1)=src[2];
*(((unsignedchar*)target)+2)=src[1];
*(((unsignedchar*)target)+3)=src[0];
}

intread_lables()
{
FILE*fp=fopen("./train-labels-idx1-ubyte","r");
if(NULL==fp)
{
return-1;
}
unsignedcharhead[8];
fread(head,sizeof(unsignedchar),8,fp);
uint32_tmagic_number=0;
uint32_titem_num=0;
copy_int(&magic_number,&head[0]);
//magicnumbercheck
assert(magic_number==2049);
copy_int(&item_num,&head[4]);

uint64_tvalues_size=sizeof(unsignedchar)*item_num;
lables=(unsignedchar*)malloc(values_size);
fread(lables,sizeof(unsignedchar),values_size,fp);

fclose(fp);
return0;
}

intread_images()
{
FILE*fp=fopen("./train-images-idx3-ubyte","r");
if(NULL==fp)
{
return-1;
}
unsignedcharhead[16];
fread(head,sizeof(unsignedchar),16,fp);
uint32_tmagic_number=0;
uint32_timages_num=0;
uint32_trows=0;
uint32_tcols=0;
copy_int(&magic_number,&head[0]);
//magicnumbercheck
assert(magic_number==2051);
copy_int(&images_num,&head[4]);
copy_int(&rows,&head[8]);
copy_int(&cols,&head[12]);

uint64_timage_size=rows*cols;
uint64_tvalues_size=sizeof(unsignedchar)*images_num*rows*cols;
unsignedchar*values=(unsignedchar*)malloc(values_size);
fread(values,sizeof(unsignedchar),values_size,fp);

for(intimage_index=0;image_index<images_num;image_index++)
{
//printthelabel
printf("=========================================%d======================================\n",lables[image_index]);
for(introw_index=0;row_index<rows;row_index++)
{
for(intcol_index=0;col_index<cols;col_index++)
{
//printthepixelsofimage
printf("%3d",values[image_index*image_size+row_index*cols+col_index]);
}
printf("\n");
}
printf("\n");
}

free(values);
fclose(fp);
return0;
}

intmain(intargc,char*argv[])
{
if(-1==read_lables())
{
return-1;
}
if(-1==read_images())
{
return-1;
}
return0;
}


下载并解压出数据集文件train-images-idx3-ubyte和train-labels-idx1-ubyte放到源代码所在目录后，编译并执行：

gcc-oread_imagesread_images.c
./read_images




展示出来的效果如下：



一共有60000个图片，从代码可以看出数据集里存储的实际就是图片的像素

softmax模型
我们在《机器学习教程十三-用scikit-learn做逻辑回归》中介绍了逻辑回归模型。逻辑回归是用于解决二类分类问题(使用sigmoid函数)，而softmax模型是逻辑回归模型的扩展，用来解决多类分类问题。

softmax意为柔和的最大值，也就是如果某个zj大于其他z，那么这个映射的分量就逼近于1，其他的分量就逼近于0，从而将其归为此分类，多个分量对应的就是多分类，数学形式和sigmoid不同，如下：



它的特点是，所有的softmax加和为1，其实它表示的是一种概率，即x属于某个分类的概率。

在做样本训练时，这里的xi计算方法是：



其中W是样本特征的权重，xj是样本的特征值，bi是偏置量。

详细来说就是：假设某个模型训练中我们设计两个特征，他们的值分别是f1和f2，他们对于第i类的权重分别是0.2和0.8，偏置量是1，那么

xi=f1*0.2+f2*0.8+1

如果所有的类别都计算出x的值，如果是一个训练好的模型，那么应该是所属的那个类别对应的softmax值最大

softmax回归算法也正是基于这个原理，通过大量样本来训练这里的W和b，从而用于分类的

tensorflow的优点
tensorflow会使用外部语言计算复杂运算来提高效率，但是不同语言之间的切换和不同计算资源之间的数据传输耗费很多资源，因此它使用图来描述一系列计算操作，然后一起传给外部计算，最后结果只传回一次，这样传输代价最低，计算效率最高

举个例子：

importtensorflowastf
x=tf.placeholder(tf.float32,[None,784])



这里的x不是一个实际的x，而是一个占位符，也就是一个描述，描述成了二维浮点型，后面需要用实际的值来填充，这就类似于printf("%d",10)中的占位符%d，其中第一维是None表示可无限扩张，第二维是784个浮点型变量

如果想定义可修改的张量，可以这样定义：

W=tf.Variable(tf.zeros([784,10]))
b=tf.Variable(tf.zeros([10]))



其中W的维度是[784,10]，b的形状是[10]

有了这三个变量，我们可以定义我们的softmax模型：

y=tf.nn.softmax(tf.matmul(x,W)+b)

这虽然定义，但是没有真正的进行计算，因为这只是先用图来描述计算操作

其中matmul是矩阵乘法，因为x的维度是[None,784]，W的维度是[784,10]，所以矩阵乘法得出的是[None,10]，这样可以和向量b相加

softmax函数会计算出10维分量的概率值，也就是y的形状是[10]

数字识别模型实现
基于上面定义的x、W、b，和我们定义的模型：

y=tf.nn.softmax(tf.matmul(x,W)+b)


我们需要定义我们的目标函数，我们以交叉熵(衡量预测用于描述真相的低效性)为目标函数，让它达到最小：



其中y'是实际分布，y是预测的分布，即：

y_=tf.placeholder("float",[None,10])
cross_entropy=-tf.reduce_sum(y_*tf.log(y))



利用梯度下降法优化上面定义的Variable：

train_step=tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)


其中0.01是学习速率，也就是每次对变量做多大的修正

按照上面的思路，最终实现的代码digital_recognition.py(放在文件夹MNIST_data的上一级目录下)如下：

#coding:utf-8

importsys
reload(sys)
sys.setdefaultencoding("utf-8")

fromtensorflow.examples.tutorials.mnistimportinput_data
importtensorflowastf

flags=tf.app.flags
FLAGS=flags.FLAGS
flags.DEFINE_string('data_dir','MNIST_data/','Directoryforstoringdata')

mnist=input_data.read_data_sets(FLAGS.data_dir,one_hot=True)

x=tf.placeholder(tf.float32,[None,784])
W=tf.Variable(tf.zeros([784,10]))
b=tf.Variable(tf.zeros([10]))
y=tf.nn.softmax(tf.matmul(x,W)+b)
y_=tf.placeholder("float",[None,10])
cross_entropy=-tf.reduce_sum(y_*tf.log(y))
train_step=tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

init=tf.initialize_all_variables()
sess=tf.InteractiveSession()
sess.run(init)
foriinrange(1000):
batch_xs,batch_ys=mnist.train.next_batch(100)
sess.run(train_step,feed_dict={x:batch_xs,y_:batch_ys})

correct_prediction=tf.equal(tf.argmax(y,1),tf.argmax(y_,1))
accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
print(accuracy.eval({x:mnist.test.images,y_:mnist.test.labels}))


运行效果如下：

[root@mymac$]pythondigital_recognition.py
Extracting./train-images-idx3-ubyte.gz
Extracting./train-labels-idx1-ubyte.gz
Extracting./t10k-images-idx3-ubyte.gz
Extracting./t10k-labels-idx1-ubyte.gz
0.9039




解释一下

flags.DEFINE_string('data_dir','MNIST_data/','Directoryforstoringdata')


表示我们用MNIST_data的上一级目录作为训练数据的存储目录，如果我们没有提前下好训练数据和测试数据，程序会自动帮我们下载到./

mnist=input_data.read_data_sets(FLAGS.data_dir,one_hot=True)


这句直接用库里帮我们实现好的读取训练数据的方法，无需自行解析

foriinrange(1000):
batch_xs,batch_ys=mnist.train.next_batch(100)
sess.run(train_step,feed_dict={x:batch_xs,y_:batch_ys})



这几行表示我们循环1000次，每次从训练样本里选取100个样本来做训练，这样我们可以修改配置来观察运行速度

最后几行打印预测精度，当调整循环次数时可以发现总训练的样本数越多，精度就越高

原文链接：http://www.shareditor.com/blogshow/?blogId=94