前面 有篇博文讲了多层感知器，也就是一般的前馈神经网络，文章里使用 CIFAR10 数据集得到的测试准确率是 46.98%。今天我们使用更适合处理图像的卷积神经网络来处理相同的数据集 - CIFAR10，来看下准确率能达到多少。

本文代码基于 TensorFlow 的官方文档 做了些许修改，完整代码及结果图片可从 这里 下载。

这篇 文章是对本文的一个升级，增加了 TensorBoard 的实现，可以在浏览器中查看可视化结果，包括准确率、损失、计算图、训练时间和内存信息等。

主成分分析（PCA）是一种常用的数据降维方法，可以将高维数据在二维或者三维可视化呈现。具体原理我在这里就不再详述，网上有很多教程都不错，可以参考 这里 或者 PCA 的维基百科页面。

之前 写过一篇在 ubuntu 下安装 TensorFlow 的教程，那个时候 TensorFlow 官方还不支持 Windows 系统，虽然可以通过其他方法安装，但是终究不是原生的，而且安装过程繁琐易错。好消息是，Google官方在11月29号的开发者博客中宣布新的版本（0.12）将 增加对Windows的支持，我11月30号知道的，立马就安装试了试，安装过程非常简单，不过也有一些需要手动调整。

这里写图片描述

更新

这里我会列出对本文的更新。

• 2017 年 3 月 1 日：cuDNN 版本从 5.0 升级到 5.1 版本，更新 cuda 和 cudnn 下载地址。
• 2017 年 3 月 20 日：标记 安装前准备 中的第五条 确保你安装了 VS2015 或者 2013 或者 2010。 为存疑。这是我之前在 TensorFlow 官网看到的，但是现在去翻了翻找不到了。如果有同学没有安装 VS 就把 TensorFlow 安装成功了的话，请在下方评论区说明下，到时候我会将这个要求标记为删除。谢谢。
• 2017 年 3 月 26 日：更新 TensorFlow 安装命令。
• 2017 年 4 月 18 日：
  • 安装前准备 第五条标记为删除，经过我再次试验发现不需要 VS 的支持。
  • 增加问题 Cannot remove entries from nonexistent file 的解决办法。
• 2017 年 7 月 20 日：增加问题 ImportError: DLL load failed: 找不到指定的模块。 、ImportError: No module named '_pywrap_tensorflow_internal' 和 ImportError: No module named 'tensorflow.python.pywrap_tensorflow_internal 的时候` 的解决办法。
• 2017 年 7 月 31日：更新关于 Python 版本的说明，TensorFlow 从 1.2 开始在 Windows 上支持 Python 3.6。感谢评论区 @Vince_Ace 提供的信息。
• 2017 年 8 月 20 日：TensorFlow 1.3 发布，更新 cuDNN 版本说明。感谢评论区 @myseth1023 提供的信息。
• 2017 年 8 月 21 日：删除 安装cuDNN 中容易误导人的部分（关于添加环境变量）。
• 2018 年 3 月 12 日：TensorFlow 1.6 发布，更新相关说明，详细发布说明参考 Release TensorFlow 1.6.0。
• 2018 年 3 月 18 日：增加问题 #4 及其解决办法。
• 2019 年 4 月 5 日：增加问题 #5 及其解决办法（针对 TensorFlow 1.13）。

安装前准备

TensorFlow 有两个版本：CPU 版本和 GPU 版本。GPU 版本需要 CUDA 和 cuDNN 的支持，CPU 版本不需要。如果你要安装 GPU 版本，请先确认你的显卡支持 CUDA。我安装的是 GPU 版本，采用 pip 安装方式，所以就以 GPU 安装为例，CPU 版本只不过不需要安装 CUDA 和 cuDNN。

1. 在 这里 确认你的显卡支持 CUDA。
2. 确保你的 Python 版本是 3.5 64 位及以上。（TensorFlow 从 1.2 开始支持 Python 3.6，之前的官方是不支持的）
3. 确保你有稳定的网络连接。
4. 确保你的 pip 版本 >= 8.1。用 pip -V 查看当前 pip 版本，用 python -m pip install -U pip 升级pip 。
5. 确保你安装了 VS2015 或者 2013 或者 2010。此条非必须，删除。

此外，建议安装 Anaconda，因为这个集成了很多科学计算所必需的库，能够避免很多依赖问题，安装教程可以参考 这里。

以上条件符合，那么恭喜你可以开始下载 CUDA 和 cuDNN 的安装包了，注意版本号会由于 TensorFlow 不同版本有变化，此处请结合下面的安装 CUDA 和安装 cuDNN 说明）。

安装 TensorFlow

由于 Google 那帮人已经把 TensorFlow 打成了一个 pip 安装包，所以现在可以用正常安装包的方式安装 TensorFlow 了，就是进入命令行执行下面这一条简单的语句：

1
2
3
4
5

# GPU版本
pip3 install --upgrade tensorflow-gpu

# CPU版本
pip3 install --upgrade tensorflow

然后就开始安装了，速度视网速而定。

安装网之后你试着在 Python 中import tensorflow会告诉你没有找到 CUDA 和 cuDNN，所以下一步就是安装这两个东西。

安装 CUDA

• TensorFlow 1.6：CUDA 9.0
• TensorFlow 1.13.1：CUDA 10.0

这个也是很简单的，首先根据上面的版本去官网下载对应的安装包（~ 1.4 GB）。下载完那个 exe 文件就是 CUDA 的安装程序，直接双击执行就可以了，就像安装正常的其他软件一样，安装过程屏幕可能会闪烁，不要紧，而且安装时间有点长。

安装完之后系统变量会自动为你添加上，这个不用管。

测试一下是否安装成功，命令行输入 nvcc -V ，看到版本信息就表示安装成功了。

nvcc

安装 cuDNN

前面有几篇博文讲了使用 TensorFlow 实现线性回归和逻辑斯蒂回归，这次来说下多层感知器（Multi-Layer Perceptron）的 TensorFlow 实现。

本篇博文的代码及结果图片等可以在这里下载，里面包含TensorFlow的实现和sklearn的实现，以及各自的结果图片。

前面提到了使用 TensorFlow 进行线性回归以及学习率、迭代次数和初始化方式对准确率的影响，这次来谈一下如何使用 TensorFlow 进行 Logistics Regression（以下简称 LR）。关于LR的理论内容我就不再赘述了，网上有很多资料讲，这里我就写下 LR 所用的损失函数：

其实整个程序下来和线性回归差不多，只不过是损失函数的定义不一样了，当然数据也不一样了，一个是用于回归的，一个是用于分类的。

数据集

数据集不再是经典的MNIST数据集，而是我在UCI上找的用于二分类的数据集，因为我觉得老用经典的数据集不能很好的理解整个程序。数据集可以从这里下载，数据集是关于房屋居住的，给出一些影响房屋居住的因素和是否居住（二分类），例如光照、温度等。数据集有3个txt文件，本篇使用的是datatraining.txt,数据量是8143×7，删除日期数据，然后按照75:25的比例拆分成训练集和测试集，然后做一些必要的reshape。

数据集大致是这样子的：

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

from __future__ import print_function, division
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn
from sklearn.cross_validation import train_test_split
import random

# 读取数据
data = pd.read_csv("datatraining.txt")
# 拆分数据
X_train, X_test, y_train, y_test = train_test_split(data[["Temperature", "Humidity", "Light", "CO2", "HumidityRatio"]].values, data["Occupancy"].values.reshape(-1, 1), random_state=42)
# one-hot 编码
y_train = tf.concat(1, [1 - y_train, y_train])
y_test = tf.concat(1, [1 - y_test, y_test])

# 设置模型
learning_rate = 0.001
training_epochs = 50
batch_size = 100
display_step = 1

n_samples = X_train.shape[0]
n_features = 5
n_class = 2
x = tf.placeholder(tf.float32, [None, n_features])
y = tf.placeholder(tf.float32, [None, n_class])

# 模型参数
W = tf.Variable(tf.zeros([n_features, n_class]))
b = tf.Variable(tf.zeros([n_class]))
# W = tf.Variable(tf.truncated_normal([n_features, n_class-1]))
# b = tf.Variable(tf.truncated_normal([n_class]))

# 定义模型，此处使用与线性回归一样的定义
# 因为在后面定义损失的时候会加上映射
pred = tf.matmul(x, W) + b

# 定义损失函数
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))
# cost = tf.nn.sigmoid_cross_entropy_with_logits(pred, y)

# 梯度下降
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

# 准确率
correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# 初始化所有变量
init = tf.initialize_all_variables()

# 训练模型
with tf.Session() as sess:
    sess.run(init)
    for epoch in range(training_epochs):
        avg_cost = 0
        total_batch = int(n_samples / batch_size)
        for i in range(total_batch):
            _, c = sess.run([optimizer, cost], 
                            feed_dict={x: X_train[i * batch_size : (i+1) * batch_size], 
                                      y: y_train[i * batch_size : (i+1) * batch_size, :].eval()})
            avg_cost = c / total_batch
        plt.plot(epoch+1, avg_cost, 'co')
        
        if (epoch+1) % display_step == 0:
            print("Epoch:", "%04d" % (epoch+1), "cost=", avg_cost)
            
    print("Optimization Finished!")
    
    print("Testing Accuracy:", accuracy.eval({x: X_train, y:y_train.eval()}))
    plt.xlabel("Epoch")
    plt.ylabel("Cost")
    plt.show()

结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

Epoch: 0001 cost= 0.402052676091
Epoch: 0002 cost= 0.384176723293
Epoch: 0003 cost= 0.174337043137
Epoch: 0004 cost= 0.131257948328
Epoch: 0005 cost= 0.116865955415
Epoch: 0006 cost= 0.167843505984
Epoch: 0007 cost= 0.0734717650492
Epoch: 0008 cost= 0.134278797712
Epoch: 0009 cost= 0.107930605529
Epoch: 0010 cost= 0.0559994509963
Epoch: 0011 cost= 0.0894105786183
Epoch: 0012 cost= 0.112936254408
Epoch: 0013 cost= 0.0598722950357
Epoch: 0014 cost= 0.0590479530272
Epoch: 0015 cost= 0.085669126667
Epoch: 0016 cost= 0.0516053653154
Epoch: 0017 cost= 0.0587136237348
Epoch: 0018 cost= 0.0668616529371
Epoch: 0019 cost= 0.0612989566365
Epoch: 0020 cost= 0.0527745035828
Epoch: 0021 cost= 0.0758241278226
Epoch: 0022 cost= 0.0845051749808
Epoch: 0023 cost= 0.0364650820122
Epoch: 0024 cost= 0.0526885400053
Epoch: 0025 cost= 0.0451166786131
Epoch: 0026 cost= 0.0508907896573
Epoch: 0027 cost= 0.0619052668087
Epoch: 0028 cost= 0.0560943103227
Epoch: 0029 cost= 0.0425660180264
Epoch: 0030 cost= 0.0601769588033
Epoch: 0031 cost= 0.0461903712789
Epoch: 0032 cost= 0.0437817573547
Epoch: 0033 cost= 0.102960703803
Epoch: 0034 cost= 0.0599972771817
Epoch: 0035 cost= 0.10071516037
Epoch: 0036 cost= 0.101918243971
Epoch: 0037 cost= 0.102948681253
Epoch: 0038 cost= 0.0239826597151
Epoch: 0039 cost= 0.02541697807
Epoch: 0040 cost= 0.039644296052
Epoch: 0041 cost= 0.0564842145951
Epoch: 0042 cost= 0.0651661059895
Epoch: 0043 cost= 0.0559316267733
Epoch: 0044 cost= 0.058336042967
Epoch: 0045 cost= 0.0420891652342
Epoch: 0046 cost= 0.0113296391534
Epoch: 0047 cost= 0.0151269641079
Epoch: 0048 cost= 0.070616901898
Epoch: 0049 cost= 0.0543320648006
Epoch: 0050 cost= 0.0490373939764
Optimization Finished!
Testing Accuracy: 0.973473

可以看到最终准确率达到了97%，这里注意标签要进行one-hot编码。

与sklearn的比较

我用相同的数据集使用sklearn实现了LR,

1
2
3

clf = LogisticRegression()
clf.fit(X_train, y_train)
clf.score(X_test, y_test)

结果准确率是0.98624754420432215，而且训练时间大为缩短。

END

想必学过机器学习的人都知道，学习率、训练迭代次数和模型参数的初始化方式都对模型最后的准确率有一定的影响，那么影响到底有多大呢？

我初步做了个实验，在 TensorFlow 框架下使用 Logistics Regression 对经典的 MNIST 数据集进行分类。

使用sklearn库可以很方便的实现各种基本的机器学习算法，例如今天说的逻辑斯谛回归（Logistic Regression），我在实现完之后，可能陷入代码太久，忘记基本的算法原理了，突然想不到 coef_ 和 intercept_ 具体是代表什么意思了，就是具体到公式中的哪个字母，虽然总体知道代表的是模型参数。
阅读全文

前面 有篇博文 讲了讲Ubuntu环境下安装TensorFlow，今天来说一说在TensorFlow中如何进行线性回归。

今天来说一下机器学习库 TensorFlow 的在 Ubuntu14.04 64位下的安装。

在亚马逊上买了Peter Flach教授写的段菲博士翻译的《机器学习》一书，开始机器学习之旅。开始之前，先介绍下Peter Flach教授：
阅读全文