TensorFlow 学习指南 三、学习

原文: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现在应该提供以下绘图:

《TensorFlow 学习指南 三、学习》 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_nearestupdate_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作为变量,而不是两个单独的变量ab

绘制误差

《TensorFlow 学习指南 三、学习》 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)中分离ab值。

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

TFLearn

已更新到最新的 TFLearn API。

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

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

机器学习

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

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

《TensorFlow 学习指南 三、学习》 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
    原文作者:ApacheCN_飞龙
    原文地址: https://www.jianshu.com/p/bb58041d3ec1
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注