tensorflow安装教程 连载 | Tensorflow教程一：30行代码搞定手写识别

去年买了几本关于张量流的书，今年看的时候发现样本代码里用的一些API已经过时了。看来维护一个更新的张量流教程还是有意义的。这是写这个系列的开始。

快餐教程系列希望尽可能降低门槛，少说话，讲透。

为了让大家一开始就看到美好的一幕，而不是停留在基础知识的长时间积累上，参考网上的一些教程，我们在开始直接展示一个用张量流实现MNIST手写识别的例子。然后慢慢说基础。

Tensorflow安装快速教程

由于Python是跨平台语言，所以在所有系统上安装张量流相对容易。后面再说GPU加速。

Tensorflow安装在Linux平台上

我们以Ubuntu版为例，先安装python3和pip3。Pip是python的包管理工具。

1sudo apt installpython3

2sudo apt installpython3-pip

张量流可以通过管道3安装:

1 ip3 installtensorflow-升级

MacOS安装tensorflow

建议自制安装python。

1brewinstall python3

安装python3后，通过pip3安装张量流。

1 ip3 installtensorflow-升级

张量流安装在Windows平台上

建议在Windows平台上通过Anaconda安装Tensorflow。

然后打开Anaconda提示符，输入:

1conda create-n tensorflow pip

2激活张量流

3pip安装-忽略-安装-升级tensorflow

这样就安装了张量流。

让我们快速举个例子来尝试一下:

1将张量流作为tf导入

2a = tf .常数

3b = tf .常数

4c = a * b

5sess = tf。会话

6print)

输出为2。

张量流，顾名思义，是由张量张量流组成的运算。

操作需要运行会话。如果打印，您将获得

1传感器，dtype=int32)

也就是说，这是一个乘法张量，需要通过Session.run来执行。

入门捷径:线性回归

我们先来看看最简单的机器学习模型，一个线性回归的例子。

线性回归的模型是矩阵乘法:

1tf .乘法

然后，我们调用张量流计算梯度下降函数TF。火车。梯度下降优化器实现优化。

让我们看看这个示例代码。只有三十多行，逻辑还是很清晰的。

这个例子来自丹尼尔在github上的作品:https://github.com/nlintz/TensorFlow-Tutorials,不是我的原作。

1将张量流作为tf导入

2将numpy导入为np

3trX = np.linspace

4 try = 2 * Trx+NP . random . randn* 0.33 #在线性值附近创建一些随机值

5X = tf.placeholder

6Y = tf.placeholder

7def型号:

8返回TF。多重 # x * w线性评估，非常简单

9w = tf。变量

10y_model = model

11cost = tf.square #以平方误差为优化目标

12train _ op = TF。train . gradientdeponentoptimizer。最小化#梯度下降优化

13#开始创建会话！

14带tf。会话作为会话:

15#需要先初始化全局变量，这是Tensorflow的要求

16tf . global _ variables _ initializer。运行

17对于范围内的I:

18for in :

19sess.run

20print)

我最终会得到一个接近2的值，比如我这次运行的值是1.9183811

手写识别在许多方面

线性回归是不够的，所以我们一步开始手写识别。

我们以深度学习三巨头之一Yann Lecun教授的MNIST数据为例。如上图所示，MNIST的数据是一个28x28的图像，并且标记了它的值应该是多少。

线性模型:逻辑回归

首先不考虑3721，我们用线性模型分类。

算上评论和空行加起来大概30行，就可以解决手写识别的难题了！看看代码:

1importtensorflow astf

2importnumpy asnp

3 front sensorflow . examples . tutorials . mnist importinput _ data

4定义重量:

5returntf。变量)

6defmodel:

7returntf.matmul #模型或矩阵乘法

8 NIST = input _ data . read _ data _ set

9trX，trY，teX，teY = mnist.train.images，mnist.train.labels，mnist.test.images，mnist.test.labels

10X = tf.placeholder

11Y = tf.placeholder

12w = init_weights

13py_x =型号

14成本= TF。reduce _ mean ) #计算错误

15 train _ op = TF . train . GradientDescentoptimizer。最小化#构造优化器

16predict_op = tf.argmax

17withtf。会议评估:

18tf . global _ variables _ initializer。运行

19 ori in range:

20forstart，end in，128)，range+1，128)):

21 ess . run

22print ==

23 ess . run)

经过100轮训练，我们的准确率是92.36%。

无脑浅层神经网络

我们用最简单的线性模型，用经典的神经网络来实现这个功能。神经网络图如下图所示。

让我们构建一个隐藏层，使用最传统的sigmoid函数作为激活函数。它的核心逻辑是矩阵乘法，没什么技巧在里面。

1h = tf.nn.sigmoid)

2returntf.matmul

完整的代码如下，还有40多行，不长:

1importtensorflow astf

2importnumpy asnp

3 front sensorflow . examples . tutorials . mnist importinput _ data

4#所有连接随机生成权重

5定义重量:

6returntf。变量)

7defmodel:

8h = tf.nn.sigmoid)

9returntf.matmul

10 NIST = input _ data . read _ data _ set

11trX，trY，teX，teY = mnist.train.images，mnist.train.labels，mnist.test.images，mnist.test.labels

12X = tf.placeholder

13Y = tf.placeholder

14w_h = init_weights

15w_o = init_weights

16py_x =型号

17成本= TF。reduce _ mean ) #计算错误损失

18 train _ op = TF . train . GradientDescentoptimizer。最小化#构建优化器

19predict_op = tf.argmax

20withtf。会议评估:

21tf . global _ variables _ initializer。运行

22 fori inrange:

23 forstart，end in，128)，range+1，128)):

24 sess.run

25 print =

26 sess.run)

第一轮操作，我这次准确率只有69.11%，第二次提高到82.29%。最终结果是95.41%，强于Logistic回归！

请注意，我们模型核心的两行代码完全是无脑的，连接成一个隐藏的层，里面没有任何技术。完全取决于神经网络的建模能力。

深度学习时代的方案——ReLU与辍学秀头像

上次技术含量有点低。现在是深度学习的时候，我们取得了很大的进步。比如我们知道sigmoid函数应该用ReLU函数代替。

我们也知道我们将成为一名辍学生。所以我们还是隐藏层，写一个更现代的模型:

1X = TF . nn . drop

2h = tf.nn.relu)

3h = tf.nn.dropout

4h2 = tf.nn.relu

5h2 = tf.nn.dropout

6returntf.matmul

除了ReLU和drop，我们还是只有一个隐藏层，表达能力没有大的提升。不是深度学习。

1将张量流作为tf导入

2将numpy导入为np

3 from tensorflow . examples . tutorials . mnist import input _ data

4def init_weights:

5返回tf。变量)

6def模型:

7X = tf.nn .压差

8h = tf.nn.relu)

9h = tf.nn.dropout

10h2 = tf.nn.relu

11 H2 = TF . nn . drop

12return tf.matmul

13 NIST = input _ data . read _ data _ set

14trX，trY，teX，teY = mnist.train.images，mnist.train.labels，mnist.test.images，mnist.test.labels

15X = tf.placeholder

16Y = tf.placeholder

17w _ h = init _ weight

18w _ H2 = init _ weight

19w_o = init_weights

20p _ keep _ input = TF . placeholder

21p _ keep _ hidden = TF . placeholder

22py_x = model

23 cost = TF . reduce _ mean)

24 train _ op = TF . train . rmsproptimizer。最小化

25predict_op = tf.argmax

26带tf。会话作为会话:

27#你需要初始化所有变量

28tf . global _ variables _ initializer。运行

29对于I范围:

30开始，结束于，128)，范围+1，128)):

33ss . run

33print ==

34 ess . run)

从结果可以看出，第二次准确率在96%以上。此后一直徘徊在98.4%左右。只有ReLU和from将准确率从95%提高到98%以上。

卷积神经网络的出现

CNN，深度学习的真正武器，是卷积神经网络出来的。与之前的无脑模型相比，这个模型确实更加复杂。它涉及卷积层和汇集层。这个需要后面详细说。

1将张量流作为tf导入

2将numpy导入为np

3 from tensorflow . examples . tutorials . mnist import input _ data

4批处理大小= 128

5test_size = 256

6def init_weights:

7返回tf。变量)

8def型号:

9l1a = tf.nn.relu

10s三叉戟=，填充='SAME '))

11l1 = tf.nn.max_pool

12叉=，填充= '相同')

13l 1 = TF . nn . drop

14l 2a = TF . nn . relu

15步=，填充='SAME '))

16l2 = tf.nn.max_pool

17步=，填充= '相同')

18 L2 = TF . nn . drop

19l3a = TF . nn . relu

20步=，填充='SAME '))

21 l3 = tf.nn.max_pool

22个字符=，填充= '相同')

23l 3 = TF . resform。as_list]) #整形为

24 L3 = TF . nn . drop

25 l4 = tf.nn.relu)

26l 4 = TF . nn . drop

27pyx = tf.matmul

28返回pyx

29 NIST = input _ data . read _ data _ set

30trX，trY，teX，teY = mnist.train.images，mnist.train.labels，mnist.test.images，mnist.test.labels

31trX = trX.reshape # 28x28x1 input img31trX = TRx . resform # 28x28x1输入img

32teX = teX.reshape # 28x28x1 input img32teX = TEx . resform # 28x28x1输入img

33X = tf.placeholder

34Y = tf.placeholder

35w = init_weights # 3x3x1 conv，32路输出

36w2 = init_weights # 3x3x32 conv，64路输出

37w3 = init_weights # 3x3x32 conv，128个输出

38w4 = init_weights # FC 128 * 4 * 4输入，625输出

39w_o = init_weights # FC 625输入，10输出

40p _ keep _ conv = TF . placeholder

41p _ keep _ hidden = TF . placeholder

42py_x = model

43 cost = TF . reduce _ mean)

44 train _ op = TF . train . rmsproptimizer。最小化

45predict_op = tf.argmax

46带tf。会话作为会话:

你需要初始化所有的变量

48tf . global _ variables _ initializer。运行

49对于I范围:

50training_batch = ，batch_size)，

51范围+1，批次大小))

52开始、结束于培训_批次:

53 ess . run

55测试_指数= np.arange) #获取测试批次

56np . random . shuffle

57 test _ indexs = test _ indexs

58print ==

59sess.run)

我们来看看这次的运营数据:

10 0.95703125

21 0.9921875

32 0.9921875

43 0.98046875

54 0.97265625

65 0.98828125

76 0.99609375

在第六轮中，它获得了99.6%的高分，与ReLU和Dropout隐藏层的98.4%的神经网络相比有了很大的提高。因为越到后面难度越大。

第16轮，我跑出了100%的准确率:

17 0.99609375

28 0.99609375

39 0.98828125

410 0.98828125

511 0.9921875

612 0.98046875

713 0.99609375

814 0.9921875

915 0.99609375

1016 1.0

综上所述，借助Tensorflow和机器学习工具，我们只有几十行代码，解决了这个级别的手写识别问题，准确率可以达到这个级别。

作者博客链接:

https://blog.csdn.net/lusing/article/details/79965160

-结束-

有自己的个性化机器人！