原文：LearningTensorFlow.com

译者：飞龙

协议：CC BY-NC-SA 4.0

自豪地采用谷歌翻译

聚类和 KMeans

我们现在冒险进入我们的第一个应用，即使用 k-means 算法进行聚类。 聚类是一种数据挖掘练习，我们获取大量数据并找到彼此相似的点的分组。 K-means 是一种非常善于在许多类型的数据集中查找簇的算法。

对于簇和 k-means的 更多信息，请参阅 k-means 算法的 scikit-learn 文档或观看此视频。

生成样本

首先，我们需要生成一些样本。 我们可以随机生成样本，但这可能会给我们提供非常稀疏的点，或者只是一个大分组 – 对于聚类来说并不是非常令人兴奋。

相反，我们将从生成三个质心开始，然后在该点周围随机选择（具有正态分布）。 首先，这是一个执行此操作的方法

import tensorflow as tf
import numpy as np


def create_samples(n_clusters, n_samples_per_cluster, n_features, embiggen_factor, seed):
    np.random.seed(seed)
    slices = []
    centroids = []
    # 为每个簇创建样本
    for i in range(n_clusters):
        samples = tf.random_normal((n_samples_per_cluster, n_features),
                                   mean=0.0, stddev=5.0, dtype=tf.float32, seed=seed, name="cluster_{}".format(i))
        current_centroid = (np.random.random((1, n_features)) * embiggen_factor) - (embiggen_factor/2)
        centroids.append(current_centroid)
        samples += current_centroid
        slices.append(samples)
    # 创建一个大的“样本”数据集
    samples = tf.concat(slices, 0, name='samples')
    centroids = tf.concat(centroids, 0, name='centroids')
    return centroids, samples

这种方法的工作方式是随机创建n_clusters个不同的质心（使用np.random.random((1, n_features))）并将它们用作tf.random_normal的质心。 tf.random_normal函数生成正态分布的随机值，然后我们将其添加到当前质心。 这会在该形心周围创建一些点。 然后我们记录质心（centroids.append）和生成的样本（slices.append(samples)）。 最后，我们使用tf.concat创建“一个大样本列表”，并使用tf.concat将质心转换为 TensorFlow 变量。

将create_samples方法保存在名为functions.py的文件中，允许我们为这个（以及下一个！）课程，将这些方法导入到我们的脚本中。 创建一个名为generate_samples.py的新文件，其中包含以下代码：

import tensorflow as tf
import numpy as np

from functions import create_samples

n_features = 2
n_clusters = 3
n_samples_per_cluster = 500
seed = 700
embiggen_factor = 70

np.random.seed(seed)

centroids, samples = create_samples(n_clusters, n_samples_per_cluster, n_features, embiggen_factor, seed)

model = tf.global_variables_initializer()
with tf.Session() as session:
    sample_values = session.run(samples)
    centroid_values = session.run(centroids)

这只是设置了簇和特征的数量（我建议将特征的数量保持为 2，以便我们以后可以可视化它们），以及要生成的样本数。 增加embiggen_factor将增加簇的“散度”或大小。 我在这里选择了一个提供良好学习机会的值，因为它可以生成视觉上可识别的集群。

为了使结果可视化，我们使用matplotlib创建绘图函数。 将此代码添加到functions.py：

def plot_clusters(all_samples, centroids, n_samples_per_cluster):
    import matplotlib.pyplot as plt
    # 绘制出不同的簇
    # 为每个簇选择不同的颜色
    colour = plt.cm.rainbow(np.linspace(0,1,len(centroids)))
    for i, centroid in enumerate(centroids):
        # 为给定簇抓取样本，并用新颜色绘制出来
        samples = all_samples[i*n_samples_per_cluster:(i+1)*n_samples_per_cluster]
        plt.scatter(samples[:,0], samples[:,1], c=colour[i])
        # 还绘制质心
        plt.plot(centroid[0], centroid[1], markersize=35, marker="x", color='k', mew=10)
        plt.plot(centroid[0], centroid[1], markersize=30, marker="x", color='m', mew=5)
     plt.show()

所有这些代码都是使用不同的颜色绘制每个簇的样本，并在质心位置创建一个大的红色X。 质心提供为参数，稍后会很方便。

更新generate_samples.py，通过将import plot_clusters添加到文件顶部来导入此函数。 然后，将这行代码添加到底部：

plot_clusters(sample_values, centroid_values, n_samples_per_cluster)

运行generate_samples.py现在应该提供以下绘图：

image

初始化

k-means 算法从初始质心的选择开始，初始质心只是数据中实际质心的随机猜测。 以下函数将从数据集中随机选择多个样本作为此初始猜测：

def choose_random_centroids(samples, n_clusters):
    # 第 0 步：初始化：选择 n_clusters 个随机点
    n_samples = tf.shape(samples)[0]
    random_indices = tf.random_shuffle(tf.range(0, n_samples))
    begin = [0,]
    size = [n_clusters,]
    size[0] = n_clusters
    centroid_indices = tf.slice(random_indices, begin, size)
    initial_centroids = tf.gather(samples, centroid_indices)
    return initial_centroids

这段代码首先为每个样本创建一个索引（使用tf.range(0, n_samples)，然后随机打乱它。从那里，我们使用tf.slice选择固定数量（n_clusters）的索引。这些索引与我们的初始质心相关，然后使用tf.gather组合在一起形成我们的初始质心数组。

将这个新的choose_random_centorids函数添加到functions.py中，并创建一个新脚本（或更新前一个脚本），写入以下内容：

import tensorflow as tf
import numpy as np

from functions import create_samples, choose_random_centroids, plot_clusters

n_features = 2
n_clusters = 3
n_samples_per_cluster = 500
seed = 700
embiggen_factor = 70

centroids, samples = create_samples(n_clusters, n_samples_per_cluster, n_features, embiggen_factor, seed)
initial_centroids = choose_random_centroids(samples, n_clusters)

model = tf.global_variables_initializer()
with tf.Session() as session:
    sample_values = session.run(samples)
    updated_centroid_value = session.run(initial_centroids)

plot_clusters(sample_values, updated_centroid_value, n_samples_per_cluster)

这里的主要变化是我们为这些初始质心创建变量，并在会话中计算其值。 然后，我们将初始猜测绘制到plot_cluster，而不是用于生成数据的实际质心。

运行此操作会将得到与上面类似的图像，但质心将处于随机位置。 尝试运行此脚本几次，注意质心移动了很多。

更新质心

在开始对质心位置进行一些猜测之后，然后 k-means 算法基于数据更新那些猜测。 该过程是为每个样本分配一个簇号，表示它最接近的质心。 之后，将质心更新为分配给该簇的所有样本的平均值。 以下代码处理分配到最近的簇的步骤：

def assign_to_nearest(samples, centroids):
    # 为每个样本查找最近的质心

    # START from http://esciencegroup.com/2016/01/05/an-encounter-with-googles-tensorflow/
    expanded_vectors = tf.expand_dims(samples, 0)
    expanded_centroids = tf.expand_dims(centroids, 1)
    distances = tf.reduce_sum( tf.square(
               tf.subtract(expanded_vectors, expanded_centroids)), 2)
    mins = tf.argmin(distances, 0)
    # END from http://esciencegroup.com/2016/01/05/an-encounter-with-googles-tensorflow/
    nearest_indices = mins
    return nearest_indices

请注意，我从这个页面借用了一些代码，这些代码具有不同类型的 k-means 算法，以及许多其他有用的信息。

这种方法的工作方式是计算每个样本和每个质心之间的距离，这通过distances =那行来实现。 这里的距离计算是欧几里德距离。 这里重要的一点是tf.subtract会自动扩展两个参数的大小。 这意味着将我们作为矩阵的样本，和作为列向量的质心将在它们之间产生成对减法。 为了实现，我们使用tf.expand_dims为样本和质心创建一个额外的维度，强制tf.subtract的这种行为。

下一步代码处理质心更新：

def update_centroids(samples, nearest_indices, n_clusters):
    # 将质心更新为与其相关的所有样本的平均值。
    nearest_indices = tf.to_int32(nearest_indices)
    partitions = tf.dynamic_partition(samples, nearest_indices, n_clusters)
    new_centroids = tf.concat([tf.expand_dims(tf.reduce_mean(partition, 0), 0) for partition in partitions], 0)
    return new_centroids

此代码选取每个样本的最近索引，并使用tf.dynamic_partition将这些索引分到单独的组中。 从这里开始，我们在一个组中使用tf.reduce_mean来查找该组的平均值，从而形成新的质心。 我们只需将它们连接起来形成我们的新质心。

现在我们有了这个部分，我们可以将这些调用添加到我们的脚本中（或者创建一个新脚本）：

import tensorflow as tf
import numpy as np

from functions import *

n_features = 2
n_clusters = 3
n_samples_per_cluster = 500
seed = 700
embiggen_factor = 70


data_centroids, samples = create_samples(n_clusters, n_samples_per_cluster, n_features, embiggen_factor, seed)
initial_centroids = choose_random_centroids(samples, n_clusters)
nearest_indices = assign_to_nearest(samples, initial_centroids)
updated_centroids = update_centroids(samples, nearest_indices, n_clusters)

model = tf.global_variables_initializer()
with tf.Session() as session:
    sample_values = session.run(samples)
    updated_centroid_value = session.run(updated_centroids)
    print(updated_centroid_value)

plot_clusters(sample_values, updated_centroid_value, n_samples_per_cluster)

此代码将：

• 从初始质心生成样本
• 随机选择初始质心
• 关联每个样本和最近的质心
• 将每个质心更新为与关联的样本的平均值

这是 k-means 的单次迭代！ 我鼓励你们练习一下，把它变成一个迭代版本。

1）传递给generate_samples的种子选项可确保每次运行脚本时，“随机”生成的样本都是一致的。 我们没有将种子传递给choose_random_centroids函数，这意味着每次运行脚本时这些初始质心都不同。 更新脚本来为随机质心包含新的种子。

2）迭代地执行 k 均值算法，其中来自之前迭代的更新的质心用于分配簇，然后用于更新质心，等等。 换句话说，算法交替调用assign_to_nearest和update_centroids。 在停止之前，更新代码来执行此迭代 10 次。 你会发现，随着 k-means 的更多迭代，得到的质心平均上更接近。 （对于那些对 k-means 有经验的人，未来的教程将研究收敛函数和其他停止标准。）

训练和收敛

大多数人工智能和机器学习的关键组成部分是循环，即系统在多次训练迭代中得到改善。 以这种方式训练的一种非常简单的方法，就是在for循环中执行更新。 我们在第 2 课中看到了这种方式的一个例子：

import tensorflow as tf


x = tf.Variable(0, name='x')

model = tf.global_variables_initializer()

with tf.Session() as session:
    for i in range(5):
        session.run(model)
        x = x + 1
        print(session.run(x))

我们可以改变此工作流，使用变量来收敛循环，如下所示：

import tensorflow as tf

x = tf.Variable(0., name='x')
threshold = tf.constant(5.)

model = tf.global_variables_initializer()

with tf.Session() as session:
    session.run(model)
    while session.run(tf.less(x, threshold)):
        x = x + 1
        x_value = session.run(x)
        print(x_value)

这里的主要变化是，循环现在是一个while循环，测试（tf.less用于小于测试）为真时继续循环。 在这里，我们测试x是否小于给定阈值（存储在常量中），如果是，我们继续循环。

梯度下降

任何机器学习库都必须具有梯度下降算法。 我认为这是一个定律。 无论如何，Tensorflow 在主题上有一些变化，它们可以直接使用。

梯度下降是一种学习算法，尝试最小化某些误差。 你问哪个误差？ 嗯，这取决于我们，虽然有一些常用的方法。

让我们从一个基本的例子开始：

import tensorflow as tf
import numpy as np

# x 和 y 是我们的训练数据的占位符
x = tf.placeholder("float")
y = tf.placeholder("float")
# w 是存储我们的值的变量。 它使用“猜测”来初始化
# w[0] 是我们方程中的“a”，w[1] 是“b”
w = tf.Variable([1.0, 2.0], name="w")
# 我们的模型是 y = a*x + b
y_model = tf.multiply(x, w[0]) + w[1]

# 我们的误差定义为差异的平方
error = tf.square(y - y_model)
# GradientDescentOptimizer 完成繁重的工作
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(error)

# TensorFlow 常规 - 初始化值，创建会话并运行模型
model = tf.global_variables_initializer()

with tf.Session() as session:
    session.run(model)
    for i in range(1000):
        x_value = np.random.rand()
        y_value = x_value * 2 + 6
        session.run(train_op, feed_dict={x: x_value, y: y_value})

    w_value = session.run(w)
    print("Predicted model: {a:.3f}x + {b:.3f}".format(a=w_value[0], b=w_value[1]))

这里的主要兴趣点是train_op = tf.train.GradientDescentOptimizer(0.01).minimize(error)，其中定义了训练步长。 它旨在最小化误差变量的值，该变量先前被定义为差的平方（常见的误差函数）。 0.01 是尝试学习更好的值所需的步长。

其它优化器

TensorFlow 有一整套优化器，并且你也可以定义自己的优化器（如果你对这类事情感兴趣）。 如何使用它们的 API，请参阅此页面。 列表如下：

• GradientDescentOptimizer
• AdagradOptimizer
• MomentumOptimizer
• AdamOptimizer
• FtrlOptimizer
• RMSPropOptimizer

其他优化方法可能会出现在 TensorFlow 的未来版本或第三方代码中。 也就是说，上述优化对于大多数深度学习技术来说已经足够了。 如果你不确定要使用哪一个，请使用AdamOptimizer，除非失败。

译者注：原文推荐随机梯度优化器，在所有优化器里是最烂的，已更改。

这里一个重要的注意事项是，我们只优化了一个值，但该值可以是一个数组。 这就是为什么我们使用w作为变量，而不是两个单独的变量a和b。

绘制误差

image

这个代码是上面的一个小改动。 首先，我们创建一个列表来存储误差。然后，在循环内部，我们显式地计算train_op和误差。 我们在一行中执行此操作，因此误差仅计算一次。 如果我们在单独的行中这样做，它将计算误差，然后是训练步骤，并且在这样做时，它将需要重新计算误差。

下面我把代码放在上一个程序的tf.global_variables_initializer()行下面 – 这一行上面的所有内容都是一样的。

errors = []
with tf.Session() as session:
    session.run(model)
    for i in range(1000):
        x_train = tf.random_normal((1,), mean=5, stddev=2.0)
        y_train = x_train * 2 + 6
        x_value, y_value = session.run([x_train, y_train])
        _, error_value = session.run([train_op, error], feed_dict={x: x_value, y: y_value})
        errors.append(error_value)
    w_value = session.run(w)
    print("Predicted model: {a:.3f}x + {b:.3f}".format(a=w_value[0], b=w_value[1]))

import matplotlib.pyplot as plt
plt.plot([np.mean(errors[i-50:i]) for i in range(len(errors))])
plt.show()
plt.savefig("errors.png")

你可能已经注意到我在这里采用窗口平均值 – 使用np.mean(errors[i-50:i])而不是仅使用errors[i]。 这样做的原因是我们只在循环中测试一次，所以虽然误差会减小，但它会反弹很多。 采用这个窗口平均值可以平滑一点，但正如你在上面所看到的，它仍然会跳跃。

1）创建第 6 课中的 k-means 示例的收敛函数，如果旧质心与新质心之间的距离小于给定的epsilon值，则停止训练。

2）尝试从梯度下降示例（w）中分离a和b值。

3）我们的例子一次只训练一个示例，这是低效的。 扩展它来一次使用多个（例如 50 个）训练样本来学习。

TFLearn

已更新到最新的 TFLearn API。

这些教程主要关注 TensorFlow 的机制，但真正的用例是机器学习。 TensorFlow 有许多用于构建机器学习模型的方法，其中许多可以在官方 API 页面上找到。 这些函数允许你从头开始构建模型，包括自定义层面，例如如何构建神经网络中的层。

在本教程中，我们将查看 TensorFlow Learn，它是名为skflow的软件包的新名称。 TensorFlow Learn（以下简称：TFLearn）是一个机器学习包装器，基于 scikit-learn API，允许你轻松执行数据挖掘。 这意味着什么？ 让我们一步一步地完成它：

机器学习

机器学习是一种概念，构建从数据中学习的算法，以便对新数据执行操作。 在这种情况下，这意味着我们有一些输入的训练数据和预期结果 – 训练目标。 我们将看看著名的数字数据集，这是一堆手绘数字的图像。 我们的输入训练数据是几千个这些图像，我们的训练目标是预期的数字。

任务是学习一个模型，可以回答“这是什么数字？”，对于这样的输入：

image

这是一个分类任务，是数据挖掘最常见的应用之一。 还有一些称为回归和聚类的变体（以及许多其他变体），但在本课中我们不会涉及它们。

如果你想了解数据挖掘的更多信息，请查看我的书“Python 数据挖掘”。

Scikit-Learn API

Scikit-learn 是一个用于数据挖掘和分析的 Python 包，它非常受欢迎。 这是因为它广泛支持不同的算法，令人惊叹的文档，以及庞大而活跃的社区。 其他一个因素是它的一致接口，它的 API，允许人们构建可以使用 scikit-learn 辅助函数训练的模型，并允许人们非常容易地测试不同的模型。

我们来看看 scikit-learn 的 API，但首先我们需要一些数据。 以下代码加载了一组可以使用matplotlib.pyplot显示的数字图像：

from sklearn.datasets import load_digits
from matplotlib import pyplot as plt


digits = load_digits()

我们可以使用pyplot.imshow显示其中一个图像。 在这里，我设置interpolation ='none'来完全按原样查看数据，但是如果你删除这个属性，它会变得更清晰（也尝试减小数字大小）。

fig = plt.figure(figsize=(3, 3))

plt.imshow(digits['images'][66], cmap="gray", interpolation='none')

plt.show()

在 scikit-learn 中，我们可以构建一个简单的分类器，训练它，然后使用它来预测图像的数字，只需使用四行代码：

from sklearn import svm

classifier = svm.SVC(gamma=0.001)
classifier.fit(digits.data, digits.target)
predicted = classifier.predict(digits.data)

第一行只是导入支持向量机模型，这是一种流行的机器学习方法。

第二行构建“空白”分类器，gamma设置为 0.001。

第三行使用数据来训练模型。 在这一行（这是该代码的大部分“工作”）中，调整 SVM 模型的内部状态来拟合训练数据。 我们还传递digits.data，因为这是一个展开的数组，是该算法的可接受输入。

最后，最后一行使用这个训练好的分类器来预测某些数据的类，在这种情况下再次是原始数据集。

要了解这是多么准确，我们可以使用 NumPy 计算准确度：

import numpy as np
print(np.mean(digits.target == predicted))

结果非常令人印象深刻（近乎完美），但这些有点误导。 在数据挖掘中，你永远不应该在用于训练的相同数据上评估你的模型。 潜在的问题被称为“过拟合”，其中模型准确地学习了训练数据所需的内容，但是无法很好地预测新的没见过的数据。 为解决这个问题，我们需要拆分我们的训练和测试数据：

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target)

结果仍然非常好，大约 98%，但这个数据集在数据挖掘中是众所周知的，其特征已有详细记录。 无论如何，我们现在知道我们要做什么，让我们在 TFLearn 中实现它！

TFLearn

TensorFlow Learn 接口距离 scikit-learn 的接口只有一小步之遥：

from tensorflow.contrib import learn
n_classes = len(set(y_train))
classifier = learn.LinearClassifier(feature_columns=[tf.contrib.layers.real_valued_column("", dimension=X_train.shape[1])],
                                    n_classes=n_classes)
classifier.fit(X_train, y_train, steps=10)

y_pred = classifier.predict(X_test)

唯一真正的变化是import语句和模型，它来自不同的可用算法列表。 一个区别是分类器需要知道它将预测多少个类，可以使用len(set(y_train))找到，或者换句话说，训练数据中有多少个唯一值。

另一个区别是，需要告知分类器预期的特征类型。 对于这个例子，我们有真正重要的连续特征，所以我们可以简单地指定feature_columns值（它需要在列表中）。 如果你使用类别特征，则需要单独说明。 这方面的更多信息，请查看 TFLearn 示例的文档。

可以像以前一样评估结果，来计算准确性，但 scikit-learn 有 classification_report，它提供了更深入的了解：

from sklearn import metrics
print(metrics.classification_report(y_true=y_test, y_pred=y_pred))

结果显示每个类的召回率和精度，以及总体值和 f 度量。这些分数比准确性更可靠，更多信息请参阅维基百科上的此页面。

这是 TFLearn 的高级概述。你可以定义自定义分类器，你将在练习 3 中看到它们，并将分类器组合到流水线中（对此的支持很小，但正在改进）。该软件包有可能成为工业和学术界广泛使用的数据挖掘软件包。

1）将分类器更改为DNNClassifier并重新运行。随意告诉所有朋友你现在使用深度学习来做数据分析。

2）DNNClassifier的默认参数是好的，但不完美。尝试更改参数来获得更高的分数。

3）从 TFLearn 的文档中查看此示例并下载 CIFAR 10 数据集。构建一个使用卷积神经网络预测图像的分类器。你可以使用此代码加载数据：

def load_cifar(file):
    import pickle
    import numpy as np
    with open(file, 'rb') as inf:
        cifar = pickle.load(inf, encoding='latin1')
    data = cifar['data'].reshape((10000, 3, 32, 32))
    data = np.rollaxis(data, 3, 1)
    data = np.rollaxis(data, 3, 1)
    y = np.array(cifar['labels'])

    # 最开始只需 2 和 9
    # 如果要构建大型模型，请删除这些行
    mask = (y == 2) | (y == 9)
    data = data[mask]
    y = y[mask]

    return data, y