导语 | 本文是
腾讯云技术社区 作者
谭正中 首发在社区的系列文章，记录了作者在初学神经网络和机器学习所遇到的坑，目前已经发布了3篇。链接如下：
TensorFlow 入门（2）：使用DNN分类器对数据进行分类
TensorFlow入门（3）：使用神经网络拟合N元一次方程
背景
上一篇 《TensorFlow 入门：求 N 元一次方程》根据官网的入门教程，使用基础的 API 稍作修改解决了 N 个数据的权重问题，再继续看官网后面的教程，有一篇 高级 API 入门教程教我们如何使用 DNN（深度神经网络）分类器实现对鸢尾花的分类。刚看到这篇文章的时候，中间出现了几种鸢尾花的图案，我还以为输入是图片，API 会进行图片识别，后来发现输入的训练集只是一组组特征数据（包含花萼的长度宽度和花瓣的长度宽度）对应分类，可以看做能够解决这样的一个问题：给定一组特征数据，求这组数据的分类。 和之前一样，先分析一下原文中的示例，很多文章对原文中的示例进行翻译，但是并没有举一反三，这样其实学习效果并不好，本文会在学习后使用原文的方法，解决一个新的问题。 由于作者能力有限，目前仅停留在使用阶段，先培养机器学习思维方式，对于原理部分，可以参考其他的资料。能保证的是，阅读本文不会让你过于枯燥，也不会很难，我的宗旨是用简单的语言将复杂的问题说清楚。
原文示例
原文链接在这里，我们先逐行分析一下，首先进行必要的包含工作，我对 python 不是特别熟悉，前面这 3 行我还专门去查了一下是什么含义，具体可以参考 这篇文章：
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import urllib
import tensorflow as tf
import numpy as np
然后定义训练集和测试集的路径，这次的数据是以 csv 的格式加载进来：
IRIS_TRAINING = "iris_training.csv"
IRIS_TRAINING_URL = "http://download.tensorflow.org/data/iris_training.csv"
IRIS_TEST = "iris_test.csv"
IRIS_TEST_URL = "http://download.tensorflow.org/data/iris_test.csv"
然后进入到主函数，主函数首先是将训练集和测试集的 csv 文件下载下来：
# If the training and test sets aren't stored locally, download them. if not os.path.exists(IRIS_TRAINING):
raw = urllib.urlopen(IRIS_TRAINING_URL).read()
with open(IRIS_TRAINING, "w") as f:
f.write(raw)
if not os.path.exists(IRIS_TEST):
raw = urllib.urlopen(IRIS_TEST_URL).read()
with open(IRIS_TEST, "w") as f:
f.write(raw)
下载下来的文件可以打开看看，我们打开训练集：
120,4,setosa,versicolor,virginica
6.4,2.8,5.6,2.2,2
5,2.3,3.3,1,1
4.9,2.5,4.5,1.7,2
4.9,3.1,1.5,0.1,0
5.7,3.8,1.7,0.3,0
4.4,3.2,1.3,0.2,0
5.4,3.4,1.5,0.4,0
6.9,3.1,5.1,2.3,2
...
可以发现首行的格式看起来并不是一个表头，这个格式是有规范的，但是原文没有讲，我们继续往后看它是怎么读取的：
# Load datasets.
training_set = tf.contrib.learn.datasets.base.load_csv_with_header(
filename=IRIS_TRAINING,
target_dtype=np.int,
features_dtype=np.float32)
test_set = tf.contrib.learn.datasets.base.load_csv_with_header(
filename=IRIS_TEST,
target_dtype=np.int,
features_dtype=np.float32)
TensorFlow 使用 tf.contrib.learn.datasets.base.load_csv_with_header 对 CSV 文件进行读取，它有 3 个参数：
- filename：CSV 文件名
- target_dtype：目标数据的类型，本例中为分类 ID，使用整形表示
- features_dtype：特征值的类型，本例中是花萼花瓣的长宽度，使用浮点数表示
打开 load_csv_with_header 的源代码，可以看到它的实现方式：
def load_csv_with_header(filename,
target_dtype,
features_dtype,
target_column=-1):
"""Load dataset from CSV file with a header row."""
with gfile.Open(filename) as csv_file:
data_file = csv.reader(csv_file)
header = next(data_file)
n_samples = int(header[0])
n_features = int(header[1])
data = np.zeros((n_samples, n_features), dtype=features_dtype)
target = np.zeros((n_samples,), dtype=target_dtype)
for i, row in enumerate(data_file):
target[i] = np.asarray(row.pop(target_column), dtype=target_dtype)
data[i] = np.asarray(row, dtype=features_dtype)
return Dataset(data=data, target=target)
这样就很清楚了，使用 load_csv_with_header 函数读取的 CSV 文件首行前两列分别表示数据组的个数和每个数据组的特征数，训练集中一共有 120 组数据，每组数据包含 4 个特征。首行的另外 3 个数据，实际上并不会读取到。具体的特征数据从第二行开始，最后一列为目标值（即训练完毕后期望的输出值），前面的 4 列为特征数据（即训练完毕后的输入值），这个 4 必须和第一行第二列相等，否则就会读取失败了。 数据读取完毕后，可以把结果打印出来看看：
print(training_set)
Dataset(data=array([
[ 6.4000001 , 2.79999995, 5.5999999 , 2.20000005],
[ 5. , 2.29999995, 3.29999995, 1. ],
[ 4.9000001 , 2.5 , 4.5 , 1.70000005],
...
[ 4.80000019, 3. , 1.39999998, 0.1 ],
[ 5.5 , 2.4000001 , 3.70000005, 1. ]], dtype=float32),
target=array([2, 1, 2,..., 0, 1]))
因为篇幅问题，上面省略了很多数据，可以看到和 load_csv_with_header 代码中一致，结果为一个 Dataset 结构，其中 data 为 120 组数据，每组数据包含 4 个特征值，而 target 为一个长度为 120 的数组，表示这 120 组数据的分类。 这样就完成了训练集和测试集的数据加载工作，之后创建一个 DNN 分类器：
# Specify that all features have real-value data
feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]
# Build 3 layer DNN with 10, 20, 10 units respectively.
classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns,
hidden_units=[10, 20, 10],
n_classes=3,
model_dir="/tmp/iris_model")
这段代码，我目前的知识还无法理解全部参数的含义，先看看第一行 real_valued_column的参数：
- column_name 填的是””，这个我还不明白有什么作用
- dimension 填 4，对应每组数据有 4 个特征值。
DNNClassifier的参数：
- feature_columns：把之前创建的特征列传入，具体有什么含义还没深入理解。
- hidden_units：每层神经元数量，跟 DNN 原理有关。
- n_classes：目标的类型的个数，目前是 3 个。
- model_dir：训练模型保存的路径，这个很重要。
然后要构造一个输入函数，用于将训练数据输入到 TensorFlow 中用来训练，这个函数返回 2 个 Tensor 数据，一个是大小为 [120,4]的输入数据，表示 120 组数据，每组数据包含 4 个特征值，还有就是 120 个输出数据，这 120 组数据用于训练模型。因为返回的数据是 Tensor 常量，直接打印会显示出他们的属性：
print(x,y)
Tensor("Const:0", shape=(120, 4), dtype=float32) Tensor("Const_1:0", shape=(120,), dtype=int64)
如果想看看他们的值，可以创建一个 Session 执行一下：
sess = tf.Session()
print(sess.run([x,y]))
[array([[ 6.4000001 , 2.79999995, 5.5999999 , 2.20000005],
[ 5. , 2.29999995, 3.29999995, 1. ],
[ 4.9000001 , 2.5 , 4.5 , 1.70000005],
...
[ 4.80000019, 3. , 1.39999998, 0.1 ],
[ 5.5 , 2.4000001 , 3.70000005, 1. ]], dtype=float32),
array([2, 1, 2, 0, 0, 0, 0, 2, 1, 0, 1, 1, 0, 0, 2, 1, 2, 2, 2, 0, 2, 2, 0,
2, ..., 0, 1])]
接下来就开始训练，使用 classifier 的 fit 函数进行训练，次数为 2000 次：
# Fit model.
classifier.fit(input_fn=get_train_inputs, steps=2000)
训练的结果会保存在之前创建 classifier 传入的 model_dir 中，本例中是”/tmp/iris_model”，这是一个目录，训练结束后，可以看到该目录保存了一些数据：
$ tree -h /tmp/iris_model
/tmp/iris_model
├── [ 178] checkpoint
├── [4.0K] eval
│ └── [156K] events.out.tfevents.1493025734.dev
├── [493K] events.out.tfevents.1493025732.dev
├── [312K] graph.pbtxt
├── [4.0K] model.ckpt-1.data-00000-of-00001
├── [ 721] model.ckpt-1.index
├── [123K] model.ckpt-1.meta
├── [4.0K] model.ckpt-2000.data-00000-of-00001
├── [ 721] model.ckpt-2000.index
└── [123K] model.ckpt-2000.meta
如果再执行 2000 次训练，会发现目录中数据量增加：
xxxx$ tree -h /tmp/iris_model
/tmp/iris_model
├── [ 302] checkpoint
├── [4.0K] eval
│ ├── [156K] events.out.tfevents.1493025734.dev
│ └── [156K] events.out.tfevents.1493025839.dev
├── [493K] events.out.tfevents.1493025732.dev
├── [496K] events.out.tfevents.1493025837.dev
├── [312K] graph.pbtxt
├── [4.0K] model.ckpt-1.data-00000-of-00001
├── [ 721] model.ckpt-1.index
├── [123K] model.ckpt-1.meta
├── [4.0K] model.ckpt-2000.data-00000-of-00001
├── [ 721] model.ckpt-2000.index
├── [123K] model.ckpt-2000.meta
├── [4.0K] model.ckpt-2001.data-00000-of-00001
├── [ 721] model.ckpt-2001.index
├── [123K] model.ckpt-2001.meta
├── [4.0K] model.ckpt-4000.data-00000-of-00001
├── [ 721] model.ckpt-4000.index
└── [123K] model.ckpt-4000.meta
可见，训练的结果在执行完训练后，就已经保留下来了，后续对于数据的分类，可以直接使用当前的训练数据而不用重新训练：
# Specify that all features have real-value data
feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]
# Build 3 layer DNN with 10, 20, 10 units respectively.
classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns,
hidden_units=[10, 20, 10],
n_classes=3,
model_dir="/tmp/iris_model")
训练结束后，通过 30 组测试集来对训练效果进行测试，与训练时一样，同样构建一个数据输入函数 get_test_inputs，将数据和结果传入，使用 classifier.evaluate 对数据进行测试：
# Define the test inputs
def get_test_inputs():
x = tf.constant(test_set.data)
y = tf.constant(test_set.target)
return x, y
# Evaluate accuracy.
accuracy_score = classifier.evaluate(input_fn=get_test_inputs,
steps=1)["accuracy"]
print("nTest Accuracy: {0:f}n".format(accuracy_score))
注意到例子中把 classifier.evaluate 返回的结果的”accuracy”字段打印出来，其实返回的结果是一个字典，可以打印出来看看是什么：
print(classifier.evaluate(input_fn=get_test_inputs, steps=1))
{'loss': 0.082033969, 'auc': 0.99833333, 'global_step': 4000, 'accuracy': 0.96666664}
可以看到打印结果中有损失函数、训练次数、准确率和 AUC 信息，auc 信息我还不太能理解它的具体含义，但是可以看做是评价模型效果的一个指标，有兴趣的同学可以顺手 Google 一下。 可以看到测试集的准确率是 96.67%，总共 30 个测试数据，错了 1 个。 那么未来对于单个输入数据，我们怎么使用训练好的模型对其进行分类呢？继续看代码：
# Classify two new flower samples.
def new_samples():
return np.array([[6.4, 3.2, 4.5, 1.5],[5.8, 3.1, 5.0, 1.7]], dtype=np.float32)
predictions = list(classifier.predict(input_fn=new_samples))
print("New Samples, Class Predictions: {}n".format(predictions))
还是创建一个输入函数，把数据传入，使用 classifier.predict 对数据进行分类，返回值是一个 生成器 generator，所以用 list 包一下，结果为：
New Samples, Class Predictions: [1, 2]
表示这 2 组数据分别被分类为 1 和 2。 这就是我对于官方的 DNN 分类器示例的一些理解，希望能帮助读者学习，完整代码：
#!/usr/bin/python
#coding=utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
import numpy as np
import os
import urllib
tf.logging.set_verbosity(tf.logging.ERROR) #日志级别设置成 ERROR，避免干扰
np.set_printoptions(threshold='nan') #打印内容不限制长度
# Data sets
IRIS_TRAINING = "iris_training.csv"
IRIS_TRAINING_URL = "http://download.tensorflow.org/data/iris_training.csv"
IRIS_TEST = "iris_test.csv"
IRIS_TEST_URL = "http://download.tensorflow.org/data/iris_test.csv"
def main():
# If the training and test sets aren't stored locally, download them.
if not os.path.exists(IRIS_TRAINING):
raw = urllib.urlopen(IRIS_TRAINING_URL).read()
with open(IRIS_TRAINING, "w") as f:
f.write(raw)
if not os.path.exists(IRIS_TEST):
raw = urllib.urlopen(IRIS_TEST_URL).read()
with open(IRIS_TEST, "w") as f:
f.write(raw)
# Load datasets.
training_set = tf.contrib.learn.datasets.base.load_csv_with_header(filename=IRIS_TRAINING,
target_dtype=np.int,
features_dtype=np.float32)
test_set = tf.contrib.learn.datasets.base.load_csv_with_header(filename=IRIS_TEST,
target_dtype=np.int,
features_dtype=np.float32)
# Specify that all features have real-value data
feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]
# Build 3 layer DNN with 10, 20, 10 units respectively.
classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns,
hidden_units=[10, 20, 10],
n_classes=3,
model_dir="/tmp/iris_model")
# Define the training inputs
def get_train_inputs():
x = tf.constant(training_set.data)
y = tf.constant(training_set.target)
return x, y
# Fit model.
classifier.fit(input_fn=get_train_inputs, steps=2000)
# Define the test inputs
def get_test_inputs():
x = tf.constant(test_set.data)
y = tf.constant(test_set.target)
return x, y
# Evaluate accuracy.
#print(classifier.evaluate(input_fn=get_test_inputs, steps=1))
accuracy_score = classifier.evaluate(input_fn=get_test_inputs, steps=1)["accuracy"]
print("nTest Accuracy: {0:f}n".format(accuracy_score))
# Classify two new flower samples.
def new_samples():
return np.array([[6.4, 3.2, 4.5, 1.5],[5.8, 3.1, 5.0, 1.7]], dtype=np.float32)
predictions = list(classifier.predict(input_fn=new_samples))
print("New Samples, Class Predictions: {}n".format(predictions))
if __name__ == "__main__":
main()
exit(0)
举一反三
学习了 DNN 分类器的用法之后，我们可以用它来做什么呢？先随便举个例子吧，给出一个坐标，输出它所在的象限，比如(1,1) 的象限为 1，(1,-1) 的象限为 4，其中比较特殊的，令在坐标轴上的数据点的象限为 0，比如(0,1) 和(0,0) 的象限输出为 0。 要完成这个测试，首先要生成训练集和测试集 csv 文件，使用一个 gen_data 函数生成数据，首行为数据组数和特征的数量，在本例中，特征数量为 2。我们使用随机数生成一个坐标(x,y)，它们的值限制在 [-10,10) 的范围内，x 和 y 低于 0.2 的部分，将其置为 0，用来表示坐标轴上的点：
QUADRANT_TRAINING = "quadrant_training.csv"
QUADRANT_TEST = "quadrant_test.csv"
def gen_data(file,count):
with open(file,"w") as f:
#首行，写入数据集的组数和特征的数量
f.write("%d,2n" % count)
#原点
f.write("0,0,0n")
#产生一个随机坐标(x,y)
for i in range(1,count):
x = random.uniform(-10, 10)
y = random.uniform(-10, 10)
if abs(x) < 0.2:
x = 0
if abs(y) < 0.2:
y = 0
#获得坐标的象限
quadrant = 0
if x > 0 and y > 0:
quadrant = 1
elif x < 0 and y > 0:
quadrant = 2
elif x < 0 and y < 0:
quadrant = 3
elif x > 0 and y < 0:
quadrant = 4
f.write("%f,%f,%dn" % (x,y,quadrant))
在 main 函数中，判断数据文件是否存在，不存在则生成数据，其中训练集包含 2000 个数据，测试集包含 5000 个数据：
# 生成训练集和测试集
if not os.path.exists(QUADRANT_TRAINING):
gen_data(QUADRANT_TRAINING,2000)
if not os.path.exists(QUADRANT_TEST):
gen_data(QUADRANT_TEST,5000)
训练的内容和前面的例子几乎完全没有变化，这里我认为可以调整的参数有神经网络的层数以及每层的神经元数，这个目前我还没有经验对其进行调整：
# 加载数据
training_set = tf.contrib.learn.datasets.base.load_csv_with_header(filename=QUADRANT_TRAINING,
target_dtype=np.int, features_dtype=np.float32)
test_set = tf.contrib.learn.datasets.base.load_csv_with_header(filename=QUADRANT_TEST,
target_dtype=np.int, features_dtype=np.float32)
# 2 维数据
feature_columns = [tf.contrib.layers.real_valued_column("", dimension=2)]
# 改造一个分类器
classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns,
hidden_units=[10, 20, 10],
n_classes=5,
model_dir="/tmp/quadrant_model")
# 构造训练输入函数
def get_train_inputs():
x = tf.constant(training_set.data)
y = tf.constant(training_set.target)
return x, y
# 训练模型
classifier.fit(input_fn=get_train_inputs, steps=2000)
# 构造测试输入函数
def get_test_inputs():
x = tf.constant(test_set.data)
y = tf.constant(test_set.target)
return x, y
# 评估准确度
print(classifier.evaluate(input_fn=get_test_inputs, steps=1))
accuracy_score = classifier.evaluate(input_fn=get_test_inputs, steps=1)["accuracy"]
print("nTest Accuracy: {0:f}n".format(accuracy_score))
最后传入几个测试数据，由模型对数据进行分类，这样可以直观的看到训练的效果，其中包含了几个在训练集中没有的数据，训练集中的坐标点绝对值都限制在 10 以内，测试中传入了坐标值为 100 的点，看是否能够得到正确的结果：
# 传入数据，对其进行分类
def new_samples():
return np.array([[1,1],[100,100],[-1,1],[-100,100],[-1,-1],[-100,-100],[1,-1],[100,-100],[100,0],[0,100],[-100,0],[0,-100],[0,0]], dtype=np.float32)
predictions = list(classifier.predict(input_fn=new_samples))
print("New Samples, Class Predictions: {}n".format(predictions))
完整代码如下：
#!/usr/bin/python
#coding=utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
import numpy as np
import os
import urllib
import random
tf.logging.set_verbosity(tf.logging.ERROR) #日志级别设置成 ERROR，避免干扰
np.set_printoptions(threshold='nan') #打印内容不限制长度
QUADRANT_TRAINING = "quadrant_training.csv"
QUADRANT_TEST = "quadrant_test.csv"
def gen_data(file,count):
with open(file,"w") as f:
#首行，写入数据集的组数和特征的数量
f.write("%d,2n" % count)
#原点
f.write("0,0,0n")
#产生一个随机坐标(x,y)
for i in range(1,count):
x = random.uniform(-10, 10)
y = random.uniform(-10, 10)
if abs(x) < 0.2:
x = 0
if abs(y) < 0.2:
y = 0
#获得坐标的象限
quadrant = 0
if x > 0 and y > 0:
quadrant = 1
elif x < 0 and y > 0:
quadrant = 2
elif x < 0 and y < 0:
quadrant = 3
elif x > 0 and y < 0:
quadrant = 4
f.write("%f,%f,%dn" % (x,y,quadrant))
def main():
# 生成训练集和测试集
if not os.path.exists(QUADRANT_TRAINING):
gen_data(QUADRANT_TRAINING,2000)
if not os.path.exists(QUADRANT_TEST):
gen_data(QUADRANT_TEST,5000)
# 加载数据
training_set = tf.contrib.learn.datasets.base.load_csv_with_header(filename=QUADRANT_TRAINING,
target_dtype=np.int, features_dtype=np.float32)
test_set = tf.contrib.learn.datasets.base.load_csv_with_header(filename=QUADRANT_TEST,
target_dtype=np.int, features_dtype=np.float32)
# 2 维数据
feature_columns = [tf.contrib.layers.real_valued_column("", dimension=2)]
# 改造一个分类器
classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns,
hidden_units=[10, 20, 10],
n_classes=5,
model_dir="/tmp/quadrant_model")
# 构造训练输入函数
def get_train_inputs():
x = tf.constant(training_set.data)
y = tf.constant(training_set.target)
return x, y
# 训练模型
classifier.fit(input_fn=get_train_inputs, steps=2000)
# 构造测试输入函数
def get_test_inputs():
x = tf.constant(test_set.data)
y = tf.constant(test_set.target)
return x, y
# 评估准确度
print(classifier.evaluate(input_fn=get_test_inputs, steps=1))
accuracy_score = classifier.evaluate(input_fn=get_test_inputs, steps=1)["accuracy"]
print("nTest Accuracy: {0:f}n".format(accuracy_score))
# 传入数据，对其进行分类
def new_samples():
return np.array([[1,1],[100,100],[-1,1],[-100,100],[-1,-1],[-100,-100],[1,-1],[100,-100],[100,0],[0,100],[-100,0],[0,-100],[0,0]], dtype=np.float32)
predictions = list(classifier.predict(input_fn=new_samples))
print("New Samples, Class Predictions: {}n".format(predictions))
if __name__ == "__main__":
main()
exit(0)
执行上述代码，每执行一次，程序会训练 2000 次，多次执行，可以逐步提高训练准确度，首次执行的结果如下：
{'loss': 0.0097644748, 'auc': 0.99999833, 'global_step': 2000, 'accuracy': 0.99879998}
Test Accuracy: 0.998800
New Samples, Class Predictions: [1, 1, 2, 2, 3, 3, 4, 4, 0, 0, 0, 0, 0]
可以看到达到了 99.88%的准确度，手工传入的测试数据全部正确，可见效果确实很不错。 再多执行几次程序，提高训练的次数，loss 函数值会越来越小，分类准确率越来越高。本例中，在进行 14000 次训练后，准确度达到了 100%：
{'loss': 0.0038823907, 'auc': 0.99999958, 'global_step': 4000, 'accuracy': 0.99900001}
{'loss': 0.002235481, 'auc': 1.0, 'global_step': 6000, 'accuracy': 0.99959999}
{'loss': 0.0015281083, 'auc': 1.0, 'global_step': 8000, 'accuracy': 0.99959999}
{'loss': 0.0011556753, 'auc': 0.99999994, 'global_step': 10000, 'accuracy': 0.99980003}
{'loss': 0.00092803896, 'auc': 1.0, 'global_step': 12000, 'accuracy': 0.99980003}
{'loss': 0.00077638833, 'auc': 1.0, 'global_step': 14000, 'accuracy': 1.0}
{'loss': 0.0006688094, 'auc': 1.0, 'global_step': 16000, 'accuracy': 1.0}
{'loss': 0.00058882247, 'auc': 1.0000001, 'global_step': 18000, 'accuracy': 1.0}
在我的机器上，执行 2000 次训练耗时将近 8s，14000 次差不多耗时 1 分钟，在训练完毕后，如果只是需要对数据进行分类，则耗时可以降低到 0.5s 左右，其中加载训练数据耗时 0.22s，对数据进行分类耗时 0.2s，其他则是脚本本身的开销。从这里也可以看到，DNN 分类器的训练过程是比较耗时的，具体执行的过程并不算特别耗时。 学会使用 DNN 分类器之后，如果有一些数据，有几个输入特征值，需要将其分类，就可以采用 DNN 分类器很方便地对其进行处理，前提是训练的数据集数量足够，这样才能达到比较好的训练效果。 比如我能想到的一个例子是文字识别，或者验证码识别，通过对图像的特征描述，达到识别文字或者验证码的目的。特征可以是简单的文字二维点阵描述，或者复杂点，描述为文字中封闭区域，转折的数量、方向等。其他还有很多问题可以通过 DNN 分类器解决，了解这个工具后，遇到问题时可以想想能否用这些机器学习的工具帮忙解决问题，在使用过程中，逐步理解各种神经网络的知识，如果直接看理论，难度很大也很枯燥，在实践中学习会更加容易，记忆也更加深刻，这也是我学习 TensorFlow 的一个目的。
参考资料
相关阅读
