首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >TensorFlow 入门(2):使用DNN分类器对数据进行分类

TensorFlow 入门(2):使用DNN分类器对数据进行分类

原创
作者头像
谭正中
修改于 2017-07-04 01:50:11
修改于 2017-07-04 01:50:11
21.8K00
代码可运行
举报
文章被收录于专栏:谭正中的专栏谭正中的专栏
运行总次数:0
代码可运行

背景

上一篇 《TensorFlow 入门:求 N 元一次方程》根据官网的入门教程,使用基础的 API 稍作修改解决了 N 个数据的权重问题,再继续看官网后面的教程,有一篇 高级 API 入门教程教我们如何使用 DNN(深度神经网络)分类器实现对鸢尾花的分类。刚看到这篇文章的时候,中间出现了几种鸢尾花的图案,我还以为输入是图片,API 会进行图片识别,后来发现输入的训练集只是一组组特征数据(包含花萼的长度宽度和花瓣的长度宽度)对应分类,可以看做能够解决这样的一个问题:给定一组特征数据,求这组数据的分类。 和之前一样,先分析一下原文中的示例,很多文章对原文中的示例进行翻译,但是并没有举一反三,这样其实学习效果并不好,本文会在学习后使用原文的方法,解决一个新的问题。 由于作者能力有限,目前仅停留在使用阶段,先培养机器学习思维方式,对于原理部分,可以参考其他的资料。能保证的是,阅读本文不会让你过于枯燥,也不会很难,我的宗旨是用简单的语言将复杂的问题说清楚。

原文示例

原文链接在这里,我们先逐行分析一下,首先进行必要的包含工作,我对 python 不是特别熟悉,前面这 3 行我还专门去查了一下是什么含义,具体可以参考 这篇文章

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
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 的格式加载进来:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
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 文件下载下来:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# 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)

下载下来的文件可以打开看看,我们打开训练集:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
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
...

可以发现首行的格式看起来并不是一个表头,这个格式是有规范的,但是原文没有讲,我们继续往后看它是怎么读取的:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# 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 的源代码,可以看到它的实现方式:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
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 必须和第一行第二列相等,否则就会读取失败了。 数据读取完毕后,可以把结果打印出来看看:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
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 分类器:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# 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 常量,直接打印会显示出他们的属性:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
print(x,y)

Tensor("Const:0", shape=(120, 4), dtype=float32) Tensor("Const_1:0", shape=(120,), dtype=int64)

如果想看看他们的值,可以创建一个 Session 执行一下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
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 次:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# Fit model.
classifier.fit(input_fn=get_train_inputs, steps=2000)

训练的结果会保存在之前创建 classifier 传入的 model_dir 中,本例中是"/tmp/iris_model",这是一个目录,训练结束后,可以看到该目录保存了一些数据:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
$ 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 次训练,会发现目录中数据量增加:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
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

可见,训练的结果在执行完训练后,就已经保留下来了,后续对于数据的分类,可以直接使用当前的训练数据而不用重新训练:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# 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 对数据进行测试:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# 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"字段打印出来,其实返回的结果是一个字典,可以打印出来看看是什么:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
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 个。 那么未来对于单个输入数据,我们怎么使用训练好的模型对其进行分类呢?继续看代码:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# 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 包一下,结果为:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
New Samples, Class Predictions:    [1, 2]

表示这 2 组数据分别被分类为 1 和 2。 这就是我对于官方的 DNN 分类器示例的一些理解,希望能帮助读者学习,完整代码:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
#!/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,用来表示坐标轴上的点:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
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 个数据:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# 生成训练集和测试集
if not os.path.exists(QUADRANT_TRAINING):
        gen_data(QUADRANT_TRAINING,2000)

if not os.path.exists(QUADRANT_TEST):
        gen_data(QUADRANT_TEST,5000)

训练的内容和前面的例子几乎完全没有变化,这里我认为可以调整的参数有神经网络的层数以及每层的神经元数,这个目前我还没有经验对其进行调整:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# 加载数据
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 的点,看是否能够得到正确的结果:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# 传入数据,对其进行分类
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))

完整代码如下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
#!/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 次,多次执行,可以逐步提高训练准确度,首次执行的结果如下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
{'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%:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
{'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 的一个目的。

参考资料

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

评论
登录后参与评论
暂无评论
推荐阅读
nginx优化 突破十万并发
文章转载于:http://9388751.blog.51cto.com/9378751/1676821
用户1214487
2018/07/31
3.2K0
nginx优化 突破十万并发
Installing sentry 9.0.0 with postgresql in Centos7
Sentry是一个开源错误跟踪工具,可帮助您实时监控和修复bug。支持 Python、OC、Java、Go、Node、Django、RoR 等主流编程语言和框架,还提供了 GitHub、Slack、Trello 等常见开发工具的集成。
阿dai学长
2019/04/03
1.3K0
Installing sentry 9.0.0 with postgresql in Centos7
重传问题四阶段优化分享
使用wrk模拟http压力打nginx时,发现压测过程中持续出现重传现象,而且在高压下和低压下都会出现不同程度的重传。
mingjie
2022/05/12
1.1K0
重传问题四阶段优化分享
Sentry9-1-2部署
Sentry 是一个开源的实时错误报告工具,支持 web 前后端、移动应用以及游戏,支持 Python、OC、Java、Go、Node.js、Django、RoR 等主流编程语言和框架 ,还提供了 GitHub、Slack、Trello 等常见开发工具的集成。
YP小站
2020/06/04
1.8K0
K8S OS 内核性能参数调优
[1] ES Configuration: https://www.elastic.co/guide/en/elasticsearch/reference/2.1/setup-configuration.html#vm-max-map-count [2] root cause kernel soft lockups · Issue #37853 · kubernetes/kubernetes (github.com): https://github.com/kubernetes/kubernetes/issues/37853 [3] service-node-port-range and ip_local_port_range collision · Issue #6342 · kubernetes/kops (github.com): https://github.com/kubernetes/kops/issues/6342 [4] Image: We should tweak our sysctls · Issue #261 · kubernetes-retired/kube-deploy (github.com): https://github.com/kubernetes-retired/kube-deploy/issues/261 [5] Upgrading docker 1.13 on nodes causes outbound container traffic to stop working · Issue #40182 · kubernetes/kubernetes (github.com): https://github.com/kubernetes/kubernetes/issues/40182 [6] arp_cache: neighbor table overflow! · Issue #4533 · kubernetes/kops (github.com): https://github.com/kubernetes/kops/issues/4533
东风微鸣
2022/04/22
2.1K0
推荐一款Python应用错误追踪神器!
Sentry 是一个开源的实时错误追踪系统,用于监视应用程序中的错误并提供详细的错误报告。它支持多种编程语言和框架,如 Python、JavaScript、Node.js、Django、Flask 等,帮助开发人员快速诊断和解决问题,以确保应用程序稳定运行。Sentry 的服务分为服务端和客户端 SDK 两部分,服务端可以直接使用其提供的在线服务,也可以本地自行搭建;客户端 SDK 则提供了对多种主流语言和框架的支持。
测试开发技术
2024/07/11
3810
推荐一款Python应用错误追踪神器!
为最佳性能调优 Nginx
通常来说,一个优化良好的 Linux 服务器可以达到 500,000 – 600,000 次/秒 的请求处理性能,然而我的 Nginx 服务器可以稳定地达到 904,000 次/秒 的处理性能,并且我以此高负载测试超过 12 小时,服务器工作稳定。 这里需要特别说明的是,本文中所有列出来的配置都是在我的测试环境验证的,而你需要根据你服务器的情况进行配置: 从 EPEL 源安装 Nginx: yum -y install nginx 备份配置文件,然后根据你的需要进行配置: cp /etc/nginx/ngi
用户1263954
2018/01/30
2.4K0
django开发个人简易Blog—nginx+uwsgin+django1.6+mysql 部署到CentOS6.5
前面说完了此项目的创建及数据模型设计的过程。如果未看过,可以到这里查看,并且项目源码已经放大到github上,可以去这里下载。 代码也已经部署到sina sea上,地址为http://fengzhen
古时的风筝
2018/01/08
1.2K0
django开发个人简易Blog—nginx+uwsgin+django1.6+mysql 部署到CentOS6.5
Airflow2.2.3 + Celery + MYSQL 8构建一个健壮的分布式调度集群
前面聊了Airflow基础架构🔗,以及又讲了如何在容器化内部署Airflow🔗,今天我们就再来看看如何通过Airflow和celery构建一个健壮的分布式调度集群。 1集群环境 同样是在Ubuntu 20.04.3 LTS机器上安装Airflow集群,这次我们准备三台同等配置服务器,进行测试,前篇文章🔗[1]中,我们已经在Bigdata1服务器上安装了airflow的所有组件,没看过的可以点击链接先看下之前的文章,现在只需要在其他两个节点安装worker组件即可。 Bigdata1(A) Bigdata2
公众号: 云原生生态圈
2022/02/16
2K0
Airflow2.2.3 + Celery + MYSQL 8构建一个健壮的分布式调度集群
从源码与实战分析TCP半连接队列溢出故障
hping3是一个基于C语言编写的网络性能测试工具,由Salvatore Sanfilippo开发。它能够模拟各种类型的网络包,对服务器进行压力测试,并提供丰富的选项来定制测试。hping3不仅适用于HTTP协议,还支持TCP、UDP、ICMP等多种协议,使其成为一个多功能的网络性能测试工具。
五分钟学SRE
2024/05/01
4500
Sentry 监控 - 私有 Docker Compose 部署与故障排除详解
除了公开提供其源代码外,Sentry 还提供并维护了一个最小的设置,可以为简单的用例开箱即用。该存储库还可以作为各种 Sentry 服务如何连接以进行完整设置的蓝图,这对于愿意维护更大安装的人很有用。为简单起见,我们为此选择使用 Docker 和 Docker Compose, 以及基于 bash 的安装和升级脚本。
为少
2021/12/15
3.3K0
Sentry 监控 - 私有 Docker Compose 部署与故障排除详解
Nakama Server,服务器配置
YAML 配置文件配置 Nakama 服务器运行方式的许多方面。您可以在不指定配置文件的情况下运行 Nakama(而是依赖默认设置)。
为少
2021/05/27
1.6K0
Nakama Server,服务器配置
案例篇:服务吞吐量下降很厉害,怎么分析?
在 Linux 系统中,常见的动态追踪方法包括 ftrace、perf、eBPF/BCC 以及 SystemTap 等。
早起的鸟儿有虫吃
2020/06/28
2.6K0
案例篇:服务吞吐量下降很厉害,怎么分析?
测试格式
因为系统已经装了 python3.6 所以接下来直接装虚拟环境 virtualvenv
py3study
2020/01/02
7380
Python网络框架——Web服务器
小编说:Web服务器是连接用户浏览器与Python服务器端程序的中间节点,在网站建立的过程中起着重要的作用。目前最主流的Web服务器包括Nginx、Apache、lighthttpd、IIS等。Python服务器端程序在Linux平台下使用最广泛的是Nginx。
博文视点Broadview
2020/06/12
2.1K0
Python网络框架——Web服务器
linux中TCP三次握手与四次挥手介绍及调优
TCP是一种面向连接的单播协议,在发送数据前,通信双方必须在彼此间建立一条连接。所谓的“连接”,其实是客户端和服务器的内存里保存的一份关于对方的信息,如ip地址、端口号等。
没有故事的陈师傅
2021/08/13
8980
分布式任务系统gearman的python实战
Gearman是一个用来把工作委派给其他机器、分布式的调用更适合做某项工作的机器、并发的做某项工作在多个调用间做负载均衡、或用来在调用其它语言的函数的系统。Gearman是一个分发任务的程序框架,可以用在各种场合,开源、多语言支持、灵活、快速、可嵌入、可扩展、无消息大小限制、可容错,与Hadoop相比,Gearman更偏向于任务分发功能。它的任务分布非常简单,简单得可以只需要用脚本即可完成。Gearman最初用于LiveJournal的图片resize功能,由于图片resize需要消耗大量计算资 源,因此需要调度到后端多台服务器执行,完成任务之后返回前端再呈现到界面。
sunsky
2020/08/20
8800
Nginx工作原理和优化、漏洞。
http://blog.csdn.net/hguisu/article/details/8930668 (排名100多bolg写的很好)
bear_fish
2018/09/20
2.6K0
Nginx工作原理和优化、漏洞。
ARM 环境中部署 Dify
将下面内容保存为 arm-images.yaml,执行 docker compose -f arm-images.yaml pull 拉取所需镜像:
AlphaHinex
2024/11/25
1.8K1
ARM 环境中部署 Dify
『学习笔记』Nginx日志分析与性能调优
🎈今日推荐——https://cloud.tencent.com/developer/article/2472042
二一年冬末
2024/11/29
4620
相关推荐
nginx优化 突破十万并发
更多 >
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档