k 表示用 Dask(猫图片的图像过滤器)聚类
300+ colors to 24 colors.
对图像应用滤镜对任何人来说都不是新概念。我们拍了一张照片，对它做了一些修改，现在它看起来更酷了。但是人工智能从何而来？让我们用 K 表示 Python 中的聚类来尝试一下无监督机器学习的有趣用法。
我以前写过关于 K 表示聚类的文章，所以这次我假设你对算法很熟悉。如果你不是，这是我写的的深度介绍。
我还用自动编码器尝试过图像压缩(嗯，重建)，获得了不同程度的成功。
然而这一次，我的目标是不重建最佳可能的图像，而只是看看用最少可能的颜色重建一张图片的效果。
我不想让图片看起来尽可能地与原始图片相似，我只想让我们看着它说“真漂亮！”。
那么我们如何做到这一点呢？很高兴你问了。
如何用 K 均值聚类做图像滤波
首先，记住一个图像只是一个像素的向量总是好的。每个像素是一个由 0 到 255(无符号字节)之间的三个整数值组成的元组，表示该像素颜色的 RGB 值。
我们希望使用 K 均值聚类来找到最能表征图像的 k 颜色。这只是意味着我们可以将每个像素视为一个单个数据点(在三维空间中)，并对它们进行聚类。
所以首先，我们想用 Python 把一个图像转换成一个像素矢量。我们是这样做的。
作为题外话，我不认为 vector_of_pixels 函数需要使用 Python 列表。我确信一定有什么方法可以让变平一个 numpy 数组，我就是找不到任何方法(至少没有一个方法能按照我想要的顺序做到)。如果你能想到任何方法，请在评论中告诉我！
下一步是将模型拟合到图像，这样将像素聚集成 k 颜色。然后，只需要给图像中的每个位置分配相应的聚类颜色。
例如，也许我们的图片只有三种颜色:两种红色和一种绿色。如果我们把它分成两类，所有的红色像素会变成不同的红色(聚集在一起)，其他的会变成绿色。
但是解释得够多了，让我们来看看程序的运行吧！像往常一样，你可以用任何你想要的图片自由地运行它，这里是带有代码的 GitHub 库。
结果呢
我们将把滤镜应用到小猫的照片上，这些照片取自令人惊叹的“猫狗大战” kaggle 数据集。
我们从一张猫的图片开始，对 k 应用不同值的滤镜。下面是原图:
首先，我们来看看这张图原本有多少种颜色。
仅用一行 numpy ，我们就能计算出一个像素在这张图片上的唯一值。特别是这幅图像有 243 种不同的颜色，尽管它总共有 166167 个像素。
现在，让我们来看看仅将其聚类为 2、5 和 10 种不同颜色的结果。
只有两种颜色，它所做的只是标记最暗和最亮的区域。然而，如果你是一个艺术家，正在画一些黑白的东西(比如用墨水),并且想看看你的参考资料的轮廓是什么样的，这可能是有用的。
With only 5 different colors, the cat is already recognizable!
The 10 colors picture may look a bit trippy, but it represents the original’s content pretty clearly.
你注意到一个趋势了吗？我们添加的每种颜色都有递减的回报。拥有 2 种颜色和拥有 5 种颜色之间的差别，远远大于 5 和 10 之间的差别。然而，对于 10 色，平面区域更小，我们有更多的粒度。转向 15 色和 24 色！
虽然很明显这是一张经过过滤的图片，用 24 种颜色(原始数量的 10%)我们已经足够好地表现了猫的细节。
继续看另一张图:这是原图(256 种不同的颜色)，这是压缩图(还是 24 种颜色)。
有趣的是，“压缩”图像重 18KB，未压缩图像重 16KB。我真的不知道这是为什么，因为压缩机是非常复杂的动物，但很乐意在评论中阅读你的理论。
结论
我们能够只用原始图像的 10%的颜色来制作新图像，这些图像看起来与原始图像非常相似。由于 K 均值聚类，我们还得到了一些看起来很酷的过滤器。您还能想到其他有趣的集群应用吗？你认为其他聚类技术会产生更有趣的结果吗？
如果你想回答这些问题中的任何一个，请随时通过 Twitter 、 Medium 或 Dev.to 联系我。
你有兴趣在数据科学领域开始职业生涯吗？你想成为一名出色的机器学习专家吗？来看看我的推荐阅读清单:《帮助你提升数据科学家水平的 3 本机器学习书籍》。其中一个实际上教会了我我所知道的 K 的意思是聚类。
原载于 2019 年 6 月 2 日http://www . data stuff . tech。
使用 scikit-learn 的 K-Means 聚类
了解流行的 k-means 聚类算法背后的基础知识和数学知识，以及如何在scikit-learn中实现它！
聚类(或聚类分析)是一种技术，它允许我们找到相似对象的组，这些对象彼此之间的相关性比其他组中的对象更大。面向业务的集群应用程序的示例包括按不同主题对文档、音乐和电影进行分组，或者基于共同的购买行为来寻找具有相似兴趣的客户，以此作为推荐引擎的基础。
在本教程中，我们将了解最流行的聚类算法之一， k-means ，它在学术界和工业界都有广泛的应用。我们将涵盖:
- k-均值聚类的基本概念
- k-means 算法背后的数学
- k-means 的优缺点
- 如何使用
scikit-learn在样本数据集上实现算法 - 如何可视化集群
- 如何用肘法选择最佳的 k
我们开始吧！
本教程改编自 Next Tech 的 Python 机器学习 系列的 Part 3 ，带你从 0 到 100 用 Python 进行机器学习和深度学习算法。它包括一个浏览器内沙盒环境，预装了所有必要的软件和库，以及使用公共数据集的项目。你可以在这里免费上手！
K-均值聚类的基础
正如我们将看到的，与其他聚类算法相比，k-means 算法非常容易实现，并且计算效率非常高，这可能是它受欢迎的原因。k-means 算法属于基于原型聚类的范畴。
基于原型的聚类是指每个聚类由一个原型表示，该原型可以是具有连续特征的相似点的形心 ( 平均值)，也可以是分类特征的形心(最具代表性的或最频繁出现的点)。
虽然 k-means 非常善于识别具有球形形状的聚类，但是这种聚类算法的一个缺点是我们必须先验地指定聚类的数量 k 。对 k 的不适当选择会导致较差的聚类性能——我们将在本教程的后面讨论如何选择 k 。
尽管 k-means 聚类可以应用于更高维度的数据，但是为了可视化的目的，我们将使用一个简单的二维数据集来完成下面的示例。
你可以通过使用 Next Tech 沙箱跟随本教程中的代码，沙箱已经预装了所有必要的库，或者如果你愿意，你可以在你自己的本地环境中运行代码片段。
一旦你的沙盒加载完毕，让我们从scikit-learn导入玩具数据集并可视化数据点:
我们刚刚创建的数据集由 150 个随机生成的点组成，这些点大致分为三个密度较高的区域，通过二维散点图进行可视化。
在聚类的实际应用中，我们没有关于这些样本的任何基本事实类别信息(作为经验证据而不是推断提供的信息)；否则，它将属于监督学习的范畴。因此，我们的目标是根据样本的特征相似性对样本进行分组，这可以通过使用 k-means 算法来实现，k-means 算法可以概括为以下四个步骤:
- 从样本点中随机选取 k 个形心作为初始聚类中心。
- 将每个样本分配到最近的质心 μ^(j)，j ∈ {1，…，k}。
- 将质心移动到指定给它的样本的中心。
- 重复第 2 步和第 3 步，直到聚类分配不变或达到用户定义的容差或最大迭代次数。
现在，下一个问题是我们如何测量对象之间的相似性*？我们可以将相似度定义为距离的反义词，一种常用的对具有连续特征的样本进行聚类的距离是 m 维空间中两点 x 和 y 之间的平方欧氏距离😗
注意，在前面的等式中，索引 j 是指样本点 x 和 y 的第 j 维(特征列)。我们将使用上标 i 和 j 分别指代样本索引和集群索引。
基于这种欧几里德距离度量，我们可以将 k-means 算法描述为一个简单的优化问题，一种用于最小化组内误差平方和 ( SSE )的迭代方法，有时也称为组 惯性:
这里，
和
请注意，当我们使用欧几里德距离度量将 k-means 应用于真实世界的数据时，我们希望确保在相同的尺度上测量特征，并在必要时应用 z 分数标准化或最小-最大缩放。
使用scikit-learn的 k-均值聚类
现在我们已经了解了 k-means 算法是如何工作的，让我们使用来自scikit-learn的cluster模块的KMeans类将它应用于我们的样本数据集:
使用前面的代码，我们将期望的集群数量设置为3。我们设置n_init=10使用不同的随机质心独立运行 k-means 聚类算法 10 次，以选择最终模型作为 SSE 最低的模型。通过max_iter参数，我们指定每次运行的最大迭代次数(这里是300)。
注意，如果在达到最大迭代次数之前收敛，那么scikit-learn中的 k-means 实现会提前停止。然而，对于特定的运行，k-means 可能不会达到收敛，如果我们为max_iter选择相对较大的值，这可能会有问题(计算开销)。
处理收敛问题的一种方法是为tol选择更大的值，T10 是一个参数，它控制关于组内平方和误差变化的容限，以表明收敛。在前面的代码中，我们选择了公差1e-04 (= 0.0001)。
k-means 的一个问题是一个或多个聚类可能是空的。然而，在scikit-learn中的当前 k-means 实现中考虑到了这个问题。如果一个聚类是空的，该算法将搜索离空聚类的质心最远的样本。然后，它会将质心重新分配到这个最远的点。
既然我们已经预测了聚类标签y_km，让我们将 k-means 在数据集中识别的聚类与聚类质心一起可视化。这些存储在适合的KMeans对象的cluster_centers_属性下:
在生成的散点图中，我们可以看到 k-means 将三个质心放置在每个球体的中心，对于给定的数据集，这看起来是一个合理的分组。
肘法
虽然 k-means 在这个玩具数据集上工作得很好，但重要的是要重申，k-means 的一个缺点是，在我们知道最优的 k 是什么之前，我们必须指定聚类的数量 k 。在现实世界的应用程序中，要选择的聚类数量可能并不总是那么明显，尤其是当我们处理无法可视化的高维数据集时。
肘方法是一个有用的图形工具，可以估计给定任务的最佳集群数量 k 。直观地，我们可以说，如果 k 增加，组内 SSE(失真)将减少。这是因为样本将更接近它们被分配到的质心。
肘方法背后的思想是确定失真开始下降最快的 k 的值，如果我们绘制不同的 k 值的失真，这将变得更加清楚:
正如我们在结果图中看到的，肘部位于 k = 3 处，这证明 k = 3 确实是这个数据集的一个好选择。
我希望你喜欢这个关于 k-means 算法的教程！我们探讨了 k-means 算法背后的基本概念和数学，如何实现 k-means，以及如何选择最佳数量的聚类， k 。
*如果您想了解更多，Next Tech 的 **Python 机器学习(第三部分)*课程将进一步探索聚类算法和技术，例如:
- 剪影图，另一种用于选择最优 k 的方法
- k-means++ ，k-means 的一个变种，通过对初始聚类中心更巧妙的播种来改善聚类结果。
- 其他类别的聚类算法，如分层和基于密度的聚类，不需要我们预先指定聚类的数量或假设我们的数据集中的球形结构。
本课程还探讨了回归分析、情感分析以及如何将动态机器学习模型部署到 web 应用程序中。这里可以开始！
基于 K-均值的实用聚类
在数据科学领域，无监督学习通常被视为有点“非传统”，尤其是当需要经验证明的结果时。然而，K-Means 聚类具有持久的流行性，因为它使用起来相对简单，还因为它是一种强大的(尽管有时)探索性数据分析工具。
正如我在上一篇文章中承诺的，我将在下面介绍一些简单的 K 均值聚类的基础知识！
无监督学习与聚类的比较综述；
与本博客中的其他实际例子相反，明眼人会注意到我们没有“真实的”、可测试的数据可以比较！当不存在测试案例时，K-means (KM)和其他无监督学习算法最有帮助——我们将继续假设数据集的可测试数据不存在或已被排除在考虑范围之外。
我们开始吧！
K-均值聚类理论；
K-Means 聚类只是聚类算法家族中的一个分支，我们将在这里暂时忽略它。KM 是这个家族中最受欢迎的成员之一，因为它相当简单，易于可视化，并且使用概念上简单的度量标准。具体来说，KM 算法寻求围绕“质心”点对数据观察进行聚类。在我们进入质心之前，先看一下聚类前的样本数据图:
Pre-Clustered Data
正如您所看到的，有三组明显不同的数据，几乎可以肯定地代表了基本数据的趋势，我们在这一点上可能知道，也可能不知道。本例中使用的数据非常简洁，因为我们将在 Python 3 环境中用下面的单元格生成它。如果你愿意，继续复制这段代码；
### Building k-means example, step by step!#### Made sure to import and/or download the following libraries:from sklearn.datasets import make_blobs # tool to create our sample data
import matplotlib.pylab as plt # standard plotting
import pandas as pd, numpy as np %matplotlib inline # very handy 'magic' commandfigsize=(8, 6)colors = ["r", "b", "g"]
columns = ["x1", "x2", "color"] # We'll work with a managable sample of 50 observations in 3 distinct clusters. You can follow these specifications in the arguments below:
X, color = make_blobs(n_samples=50, random_state=42, centers=3, cluster_std=1.75)# setting the colors we'll use in a little while
X = map(lambda x: (x[0][0], x[0][1], colors[x[1]]), zip(X, color))# Starting centroid points. These can be arbitrary, but it helps to give intelligently-designated starting points:
centroids = pd.DataFrame([(-8, 0, "g"), (-7.5, 8, "r"), (2.5, -2, "b")], columns=columns)# Training points
gaus_df = pd.DataFrame(list(X), columns=columns)
现在，通过下面的代码，我们可以将颜色应用到我们的数据中，并使其更加清晰地可视化！
ax = gaus_df.plot(kind="scatter", x="x1", y="x2", figsize=figsize)
ax.set_title("Begin: Load Data Points", fontsize=15)
继续运行该单元格，您应该会生成右边的简单图形！
请注意，数据本身仍然是单色的，我们创建的彩色质心都有点，嗯，没有从它们似乎相关的集群中分离出来。
正如我前面提到的，K-Means 聚类就是要最小化数据观察值和它们的质心之间的均方距离(MSD)。在某些情况下(就像在这个例子中)，我们甚至会在这里使用纯欧氏距离作为度量，因此 K-Means 有时会与 K 最近邻分类模型混淆，但这两种算法的操作有点不同。
非常重要的是，KM 将迭代地从它们的起始位置“行走”所选择的质心，朝向使从数据到最近的或最相似的质心的 MSD 最小化的质心。作为参考，我将在这里包含一个代码来生成欧几里得距离的可视检查:
import numpy as np
import pandas as pd
from sklearn.metrics import euclidean_distances
from sklearn.datasets.samples_generator import make_blobs
import matplotlib.pyplot as plt%matplotlib inlineX = np.array([[2, -1], [-2, 2]])plt.figure(figsize=(12, 7))
for i, (x, y) in enumerate(X):
plt.scatter(y, x)
plt.text(y + .05, x -.05, "$X_%d$" % (i+1), size=22)
plt.plot(X[0], X[1], "g--")
plt.text(.5, .5, "$\sqrt{\sum_{i=1}^N (x_{1i} - x_{2i})^2}$", size=25)
plt.title("Euclidean Distance Between $x_1$ and $x_2$", size=15)
当 KM 在数据中循环移动质心时，它学会识别你我在初始数据图中可以直观看到的不同簇！这是一个非常简单的例子，所以 KM 收敛到一个很好的、不同的集群只需要很少的工作。查看下面的示例图，一步一步地展示这一过程:
Step 1: Initializing Centroids
我们已经检查了上面的单元格，但是我将再次包括它，以浏览 K-Means 的逻辑流程
这里，我们的质心是“任意”选择的，因此它们可以应用于观察数据的聚类
Step 2: Calculating Centroid Point-Distances (Euclidean)
在右边，注意每个质心是如何考虑每个数据点的。当在非常大的数据集上运行时，这个算法在计算上可能有点昂贵！
Step 3: Assigning Data Points to Nearest Centroid
就编码而言，这是我们的新领域。我们将在下面回顾如何产生这种结果，但是现在只需观察数据是如何被整齐地分成不同的组的！
此外，请注意，质心没有移动，这适用于简单数据，但对于更复杂的数据，需要更多的步骤。
Step 3 — Onwards: Repeat Step 2 and 3 until Convergence
在这里，我们通过步骤 2 和 3(上面)循环，直到数据收敛！这只是意味着质心将逐渐在图上移动，直到它们从自身到最近的数据点的总 MSD 最小！
Output
一旦实现了融合，我们就有了清晰的数据集群！这些聚类将共享原始数据中的特征，其中一些特征从数据帧本身来看可能并不明显。
现在，让我们从头到尾看一个实际的例子:
应用的 K 均值:
首先，我们将生成一些样本数据:
%matplotlib inlinefrom sklearn.cluster import KMeans, k_means
from sklearn.metrics import silhouette_score
from sklearn.datasets.samples_generator import make_blobsimport numpy as np
import pandas as pdimport seaborn as sns
import matplotlib.pyplot as plt
import matplotlibmatplotlib.style.use('ggplot')# # Let's make some more blobs to test K-Means on
X, color = make_blobs(n_samples=100, random_state=29, centers=3, cluster_std=1.5)
df = pd.DataFrame(X, columns=["x1", "x2"])
df['color'] = color
df.head()
Sample of Generated Data
使用 Matplotlib 绘制数据:
# Plot the scatter -- we need to code the previous cell to get "df"
ax = df.plot(kind="scatter", x="x1", y="x2", figsize=(12,6), s=50)
plt.xlabel("$X_1$", fontsize=18)
plt.ylabel("$X_2$", fontsize=18)
ax.tick_params(axis='both', which='major', labelsize=18)
Neat Clusters from make_blobs
现在我们可以进入有趣的部分了；用 Sklearn 的软件包拟合数据:
## Take note that the latest version of Kmeans my behave slightly different.
kmeans = KMeans(n_clusters=3)
model = kmeans.fit(df[['x1', 'x2']])# Now, we can get the predicted model labels, or Centroids, in the form of an array:
model.cluster_centers_
现在，我们将这些标签附加到数据框上，用于将来的绘图，并将质心分配给它们自己的数据框:
# attach predicted cluster to original points
df['predicted'] = model.labels_# Create a dataframe for cluster_centers (centroids)
centroids = pd.DataFrame(model.cluster_centers_, columns=["x1", "x2"])
这应该生成一个基本的，但示范性的，K-均值聚类图！
from matplotlib import pyplot as pltplt.figure(figsize=(7,7))## Plot scatter by cluster / color, and centroids
colors = ["red", "green", "blue"]
df['color'] = df['predicted'].map(lambda p: colors[p])ax = df.plot(
kind="scatter",
x="x1", y="x2",
figsize=(10,8),
c = df['color']
)centroids.plot(
kind="scatter",
x="x1", y="x2",
marker="*", c=["r", "g", "b"], s=550,
ax=ax
)
Final Plot of Distinct Clusters
这是对 K-Means 聚类的简单概述！请注意，许多异常和错误标记的数据点很可能出现在不太完美的真实数据中，但这应该可以帮助您入门。特别要注意“whispy”数据，或者沿 X、Y 或两个轴聚集成细长簇的数据，这个简单的模型无法区分这些种类的簇，只能找到最近的点进行簇分配，从而导致一些交叉污染！我将在以后继续举例说明如何避免这种情况。感谢阅读！
Iris 数据集上的 K-Medoids 聚类
几乎在任何机器学习课程中， K-Means Clustering 将是第一批引入无监督学习的算法之一。由于这一点，它比它的表亲 K-Medoids 集群更受欢迎。如果你谷歌一下“k-means”，会弹出 14.9 亿个结果。对“k-medoids”这样做，只有 23.1 万个结果返回。
当我在一次期末考试中被要求实现 k-medoids 聚类算法时，这就是我的挣扎。这花了一段时间，但我设法做到了。因此，为了帮助 k-medoid 的概念看到更多的行动，我决定将我构建和实现的算法放在这里，这一次，基于“臭名昭著”的虹膜数据集。
简介
k-means 和 k-medoids 算法都是分区的，这涉及到将数据集分成组。K-means 旨在最小化每个聚类中心位置的总平方误差。这些中心位置被称为质心。另一方面，k-medoids 试图最小化被标记为在聚类中的对象和被指定为该聚类的代表的对象之一之间的不相似性的总和。这些代表被称为水母。
与 k-means 算法相反，k-medoids 从集合中的数据点选择 medoids，k-means 算法认为质心是中心的平均位置，可能不是集合中的数据点。
数据准备
我们将使用来自 sklearn 库中的虹膜数据集的副本。为了演示算法，我将跳过将数据集分为训练集和测试集的步骤，而是使用一个数据集来训练和拟合模型。
下面是萼片长度、宽度的测量数据；3 种不同类型的鸢尾的花瓣长度和宽度:[‘setosa ‘，’ versicolor ‘，’ virginica’]，标记为[0，1，2]:
我有一个习惯，当数据在不同的列上时，我会针对这些类型的问题缩放数据。因为没有丢失数据，所以让我们继续缩放。我使用了同一个库 sklearn 的 MinMaxScaler 类。以下是换算后的数据:
有 4 个特征对于聚类模型的可视化和拟合可能不理想，因为它们中的一些可能高度相关。因此，我们将采用主成分分析(PCA)将 4 维数据转换为 3 维数据，同时保持那些预测值的显著性，这些预测值具有来自 sklearn 的 PCA 类。降维后的数据如下:
我们最终可以在三维平面上看到这些:
实施
我们首先开始看相异度函数。有很多选择但是在这里，我们将使用常见的 闵可夫斯基距离 函数的给定顺序。我们将要实现的算法叫做**Medoids(PAM)**算法(Kaufman 和 Rousseeuw 1990)。可以总结如下:
- 初始化:随机选择𝑚数据点的𝑘作为 medoids
- 赋值:根据闵可夫斯基距离将每个数据点关联到最近的 medoid
- 更新:对于每个 medoid 𝑗和每个与𝑗关联的数据点𝑖，交换𝑗和𝑖，并计算配置的总成本(即𝑖与所有与𝑗).关联的数据点的平均相异度选择配置成本最低的 medoid 𝑗。在第 2 步和第 3 步之间重复，直到分配没有变化。
在下面的代码中，使用我们通常的“数据矩阵”约定会很方便，也就是说，在数据矩阵𝑋中，每一行𝑥̂是𝑚的一个观测值，每一列𝑥是𝑓的一个特征。
1。Medoid 初始化
为了开始算法，我们需要一个初始猜测。让我们从数据中随机选择𝑘观测值。在这种情况下，𝑘 = 3，代表 3 种不同类型的虹膜。
接下来，我们将创建一个函数 init_medoids(X，k ),以便它随机选择给定观测值的𝑘作为 medoids。它应该返回一个大小为𝑘×𝑑的 NumPy 数组，其中𝑑是 x 的列数
从数据点初始化 3 个随机 medoids 后，我们有:
2。计算距离
实现计算距离矩阵的函数，𝑆 = (s_𝑖𝑗)使得 s_𝑖𝑗 = 𝑑^ 𝑝_𝑖𝑗是从𝑥_𝑖点到𝜇_𝑖.的𝑝阶的闵可夫斯基距离它应该返回一个 NumPy 矩阵𝑆与形状(𝑚,𝑘).
𝑝^𝑡ℎ命令𝑥和𝜇两点之间的闵可夫斯基距离由下式给出:
因此，对于矩阵𝑆的元素，
闵可夫斯基距离通常与𝑝1 或 2 一起使用，分别对应于 曼哈顿距离 和 欧几里德距离 。我们将在计算中使用欧几里得距离。
基于此，矩阵 S 的前 5 个元素是:
3。集群分配
现在，我们构建一个作用于距离矩阵 S 的函数，使用最小距离为每个点分配 0，1，2 的“聚类标签”,以找到“最相似”的 medoid。
也就是说，对于由行索引𝑖指示的每个点，如果𝑠_𝑖𝑗是点𝑖的最小距离，则索引𝑗是𝑖的聚类标签。换句话说，该函数应该返回长度为𝑚的一维数组𝑦，如下所示:
然后，我们获得第一次迭代的数据点的标签:
4。交换测试
在此步骤中，对于每个 medoid 𝑗和与𝑗关联的每个数据点𝑖，交换𝑗和𝑖，并计算配置的总成本(即𝑖与∑𝑠_𝑖𝑗所有数据点的平均差异)，如步骤 3 所示。选择配置成本最低的 medoid 𝑗。
也就是说，对于每个聚类，搜索该聚类中的任何点是否降低了平均相异系数。选择降低该系数最大的点作为该聚类的新 medoid。
最后，我们还需要一个函数来检查 medoid 是否已经“移动”，给定 med oid 值的两个实例。这是检查 medoids 是否不再移动以及迭代是否应该停止的函数。
4。将所有这些放在一起
当我们组合上述所有函数时，我们本质上组合了 K-Medoids 算法的步骤。
通过对我们拥有的数据点运行该函数，最终的 medoids 被发现为:
每个数据点的聚类标签是:
通过考虑“不精确”匹配，上面的 K-Medoids 算法正确标记了 94.7%的数据点。这只是为了演示算法如何工作，这个数字没有太大意义，因为我们没有将数据分成训练集和测试集。
使用 ATS 的 K-Medoids 聚类:释放模板的力量
使用模板在 ATS 中实现 k-medoids。为 natanielruiz/ats-kmedoids 的发展作出贡献。
github.com](https://github.com/natanielruiz/ats-kmedoids)
(您可以在上面找到所有相关的代码)
k-medoids 聚类是一种经典的聚类机器学习算法。它是 k-means 算法的一种推广。唯一的区别是聚类中心只能是数据集的元素之一，这产生了一种可以使用任何类型的距离函数的算法，而 k-means 只能使用 L2 范数证明收敛。
当我在波斯顿大学学习 CS520 编程语言课程，并与 ATS 编程语言的创始人 Xi 教授一起工作时，我意识到 ATS 是处理这种算法的天然选择。事实上，模板允许 k-medoids 的一个非常通用的实现。在实现了模板函数之后，要在数据集上运行它，剩下的唯一需要实现的就是距离函数。这意味着以这种方式编写的算法可以在用户希望的任何数据集上工作，假设用户可以在数据集中的点之间实现良好定义的距离函数。
让我们一步一步地展示这是如何工作的。
Import all necessary libraries — the mylib function which defines the mylist type is included in the GitHub repo
The outline of the k-medoids algorithm
在解析和理解了 k-medoids 算法之后，我们可以看到我们必须实现几个模板函数。但是首先让我们定义一些方便的数据类型。注意，这些数据类型有一个内部数据类型**“a”**，它将在实现距离函数时定义。这意味着我们的代码是完全通用的——允许任何有限长度和任何类型(例如整数、双精度、浮点、字符)的数据集点。
point(a) is a list of type a and pointlst(a) is a dataset of points of type
接下来我们定义大家伙。我们 k-medoid 算法的模板。KMedoidsTrain 接收数据集 p 和聚类数，施展魔法，输出最终配置的 medoids、聚类和 cost 。
We define templates for the k-medoids training function and the k-medoids loop function
我们定义了一些模板来
- 初始化 medoids
- 将数据集中的点与最近的 medoid 相关联
- 查找特定点的 medoid
- 给定 medoid 索引列表，查找 med oid 的坐标
- 用 medoid i 替换数据集中的点 j
也有一些模板来计算成本和距离。
在这一点上，我们可以问:这些函数中的哪一个可以被完整地定义并应用于我们想要解决的任何聚类问题？
实际上，请停止滚动，我们来玩个游戏。请回答这个问题:每当我们想改变距离度量的定义时，我们必须定义哪些函数？(答案在下面)
.
.
.
.
.
.
.
.
答案只有距离功能。也许您认为成本函数也需要针对每个问题单独实现，但事实并非如此。成本函数应该基本上计算所有点和它们的中面之间的距离，并将这些距离相加-它取决于距离函数，并且可以独立编码。
所有这些都是好消息。一套函数实现可以解决你想解决的任何问题。您只需要为数据集定义一个距离函数。
实际上，让我们看看这是如何工作的。让我们实现 costf 函数，该函数在给定点 p、中面和聚类的数据集的情况下，给出了这些点和它们的中面之间的所有距离的总和。
通常在 ATS 中，我们使用递归来计算这个结果，并使用一个辅助函数 costf_aux 来计算这个结果。请记住，在这种情况下，我们有 medoids，它是包含 medoids 的 ndis 的列表(数据集中的哪些点是 medoids ),我们使用 lookup_medoids 函数获得的 medoid _ pts 是包含 medoids 的坐标的列表。
在辅助成本函数中，我们使用模式匹配(case+ p of)遍历数据集 p 。当数据集已经被迭代通过时，我们输出累加器 res。当我们仍然迭代通过数据集时，我们获得点 p1 所属的聚类，我们获得对应于该聚类的 medoid 坐标 m，然后使用仍然未指定的距离函数简单地计算距离。
下面我们来快速看一下 lookup_medoids。它只是一个辅助函数，接受数据集和 medoid 索引，并为我们提供 medoid 坐标。你不希望在不必要的时候到处传递 medoid 坐标！
让我们回到算法上。
KMedoidsTrain 接受数据集 p 和数量的簇，使用辅助函数 KMedoidsTrainIter 给我们结果。
代码非常简单明了。但是如果您需要一些帮助来解析它，步骤如下:
如果聚类没有完成:
- 将 medoid j 换成点 I
- 获取所有点的新聚类
- 获取下一次迭代的索引(I，j，step )(我使用下面的帮助函数使代码更整洁)
- 如果新成本低于旧成本，则使用新的 medoids！如果不是，继续用旧的。
相当简单！
如何初始化 medoids？只需使用辅助函数获取数据集的“n_cluster”个第一元素。抓取随机元素会更好，但这仍然是初始化算法的有效方式。
for loops are for beginners
好的，最后，我们如何将数据集中的每个点与其对应的 medoid 关联起来？首先，我们定义一个函数来为一个特定的点 p1 找到相应的 medoid。然后我们用它在 associate_points 函数中寻找所有对应的 medoids。
Simple recursion with pattern matching where, at each step, we compare the distance to the old medoid to the distance to the new medoid. If the distance is lesser then the new medoid is carried on!
Here we are basically finding the medoids for all points in the dataset. A simple recurrence.
还有一件事。我们如何把 medoid i 换成 j 点？使用 mylib 中的一个可以在 GitHub 上查找的函数:)
我们开始有趣的部分了！
让我们定义一个新文件 l2_medoids.dats，并将最后一个文件命名为 clustering.dats
导入包含模板函数定义的前一个文件。还要导入 C 库调用平方根函数。
ATS can call external C functions to do math
我们有一个像这样的数据集。我们希望使用 k-medoids 算法和 L2 距离函数进行聚类(使用 2 个聚类)。你能看到结果会是什么吗？
好吧，有趣的部分。定义两点之间的距离函数。请记住，到目前为止，点是未指定长度和未指定类型 a 的列表。非常一般！现在我们实际上告诉编译器，我们正在处理类型为 double 的点。我们还告诉编译器如何计算数据集的距离。
Recurrence through the point coordinates. d = sqrt((p1 — p2) ** 2)
是时候在同一个文件中定义 L2 距离的 k-medoids 函数了。
还有一个与上面画的 2D 例子相对应的小例子！让我们看看我们是否做对了。
使用 ATS 编译器“patscc”编译所有这些内容。咻没有错误！ATS 是一种强类型语言，许多潜在的错误会在编译时被清除。调试时，编译器捕获了我的大部分实现错误，因为有些函数没有被输入正确的类型。大多数情况下，运行时错误将是越界错误，尽管使用高级 ATS 编程(如定理证明)甚至可以在编译时捕获这些错误。
所有这些特点使 ATS 成为一种有趣的编程语言。
无论如何，让我们运行代码
我们有相关的几何图列表、最终几何图以及最终配置的成本函数。让我们画出最终状态，看看是否正确。
Two clusters in red and blue. The highlighted points are the cluster medoids.
完美！如果您想在数据集上使用这些代码，请随意。请记住，您只需实现距离函数，就万事俱备了。
就这么简单。作为告别，让我们定义一下 L1 距离，它可以用在同样的问题上。
L1 distance function
Different results. Makes sense!
Same clusters, different medoids!
Python 中从头开始的 k 近邻分类器
“让我看看谁是你的朋友，我就能知道你是谁？”
k-最近邻分类器的概念几乎不能被更简单地描述。这是一句老话，在许多语言和许多文化中都可以找到。圣经中的其他话也提到:“与智慧人同行的，必得智慧；与愚昧人作伴的，必受伤害”(箴言 13:20)
这意味着 k-最近邻分类器的概念是我们日常生活和判断的一部分:想象你遇到一群人，他们都非常年轻，时尚和爱运动。他们谈论他们的朋友本，谁没有和他们在一起。那么，你对本的想象是怎样的？没错，你认为他年轻、时尚、富有运动精神。
如果你知道本住在一个人们投保守党票的社区，而且平均年收入超过 20 万美元？他的两个邻居年收入甚至超过 30 万美元？你觉得本怎么样？最有可能的是，你不认为他是一个失败者，你可能会怀疑他也是一个保守派？
最近邻分类背后的原理在于找到距离新样本最近的训练样本的预定数量，即“k”，该新样本必须被分类。新样本的标签将根据这些邻居来定义。k-最近邻分类器对于必须确定的邻居数量具有固定的用户定义常数。还有基于半径的邻居学习算法，该算法基于点的局部密度具有不同数量的邻居，所有样本都在固定半径内。一般来说，距离可以是任何度量单位:标准欧几里得距离是最常见的选择。基于邻居的方法被称为非一般化机器学习方法，因为它们只是“记住”所有的训练数据。可以通过未知样本的最近邻的多数投票来计算分类。
现在让我们从数学角度来看:
与其他分类方法相比，k-最近邻分类器(k-NN)直接在学习的样本上工作，而不是创建规则。
最近邻算法:
给定一组类别{c1，c2，…cn}也称为类，例如{“男性”，“女性”}。还有一个由带标签的实例组成的学习集 LSLS。
分类的任务在于给一个任意的实例指定一个类别。如果实例 oo 是 LSLS 的一个元素，将使用实例的标签。
现在，我们来看看 oo 不在 LSLS 的情况:
oo 与 LSLS 的所有实例相比较。距离度量用于比较。我们确定 oo 的 kk 个最近邻居，即具有最小距离的项目。kk 是用户定义的常数，是一个正整数，通常很小。
最常见的 LSLS 类将被分配给实例 oo。如果 k = 1，那么该对象被简单地分配给该单个最近邻的类。
k-最近邻分类器的算法是所有机器学习算法中最简单的。k-NN 是一种基于实例的学习，或称惰性学习，在这种学习中，当我们进行实际的分类时，只对函数进行局部近似，并执行所有的计算。
在我们真正开始编写最近邻分类器之前，我们需要考虑数据，即学习集。我们将使用 sklearn 模块的数据集提供的“iris”数据集。
数据集由来自三种鸢尾的每一种的 50 个样本组成
- 鸢尾，
- 北美鸢尾和
- 杂色鸢尾。
测量每个样本的四个特征:萼片和花瓣的长度和宽度，以厘米为单位。
import numpy as np
from sklearn import datasets
iris = datasets.load_iris()
iris_data = iris.data
iris_labels = iris.target
print(iris_data[0], iris_data[79], iris_data[100])
print(iris_labels[0], iris_labels[79], iris_labels[100])
这是预期的输出:
[5.1 3.5 1.4 0.2] [5.7 2.6 3.5 1\. ] [6.3 3.3 6\. 2.5]
0 1 2
我们从上面的集合中创建一个学习集。我们使用 np.random 中的排列来随机拆分数据。
np.random.seed(42)
indices = np.random.permutation(len(iris_data))
n_training_samples = 12
learnset_data = iris_data[indices[:-n_training_samples]]
learnset_labels = iris_labels[indices[:-n_training_samples]]
testset_data = iris_data[indices[-n_training_samples:]]
testset_labels = iris_labels[indices[-n_training_samples:]]
print(learnset_data[:4], learnset_labels[:4])
print(testset_data[:4], testset_labels[:4])
输出:
[[6.1 2.8 4.7 1.2]
[5.7 3.8 1.7 0.3]
[7.7 2.6 6.9 2.3]
[6\. 2.9 4.5 1.5]] [1 0 2 1]
[[5.7 2.8 4.1 1.3]
[6.5 3\. 5.5 1.8]
[6.3 2.3 4.4 1.3]
[6.4 2.9 4.3 1.3]] [1 2 1 1]
下面的代码只是可视化我们的 learnset 的数据所必需的。我们的数据由每个 iris 项目的四个值组成，因此我们将通过对第三和第四个值求和来将数据减少到三个值。这样，我们能够在三维空间中描述数据:
# following line is only necessary, if you use ipython notebook!!!
%matplotlib inline
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
X = []
for iclass in range(3):
X.append([[], [], []])
for i in range(len(learnset_data)):
if learnset_labels[i] == iclass:
X[iclass][0].append(learnset_data[i][0])
X[iclass][1].append(learnset_data[i][1])
X[iclass][2].append(sum(learnset_data[i][2:]))
colours = ("r", "g", "y")
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
for iclass in range(3):
ax.scatter(X[iclass][0], X[iclass][1], X[iclass][2], c=colours[iclass])
plt.show()
确定邻居
为了确定两个实例之间的相似性，我们需要一个距离函数。在我们的例子中，欧几里德距离是理想的:
def distance(instance1, instance2):
# just in case, if the instances are lists or tuples:
instance1 = np.array(instance1)
instance2 = np.array(instance2)
return np.linalg.norm(instance1 - instance2)
print(distance([3, 5], [1, 1]))
print(distance(learnset_data[3], learnset_data[44]))4.47213595499958
3.4190641994557516
函数“get_neighbors”返回一个包含“k”个邻居的列表，这些邻居离实例“test_instance”最近:
def get_neighbors(training_set,
labels,
test_instance,
k,
distance=distance):
"""
get_neighors calculates a list of the k nearest neighbors
of an instance 'test_instance'.
The list neighbors contains 3-tuples with
(index, dist, label)
where
index is the index from the training_set,
dist is the distance between the test_instance and the
instance training_set[index]
distance is a reference to a function used to calculate the
distances
"""
distances = []
for index in range(len(training_set)):
dist = distance(test_instance, training_set[index])
distances.append((training_set[index], dist, labels[index]))
distances.sort(key=lambda x: x[1])
neighbors = distances[:k]
return(neighbors)
我们将使用虹膜样本测试该功能:
for i in range(5):
neighbors = get_neighbors(learnset_data,
learnset_labels,
testset_data[i],
3,
distance=distance)
print(i,
testset_data[i],
testset_labels[i],
neighbors)
输出:
0 [5.7 2.8 4.1 1.3] 1 [(array([5.7, 2.9, 4.2, 1.3]), 0.14142135623730995, 1), (array([5.6, 2.7, 4.2, 1.3]), 0.17320508075688815, 1), (array([5.6, 3\. , 4.1, 1.3]), 0.22360679774997935, 1)]
1 [6.5 3\. 5.5 1.8] 2 [(array([6.4, 3.1, 5.5, 1.8]), 0.1414213562373093, 2), (array([6.3, 2.9, 5.6, 1.8]), 0.24494897427831783, 2), (array([6.5, 3\. , 5.2, 2\. ]), 0.3605551275463988, 2)]
2 [6.3 2.3 4.4 1.3] 1 [(array([6.2, 2.2, 4.5, 1.5]), 0.2645751311064586, 1), (array([6.3, 2.5, 4.9, 1.5]), 0.574456264653803, 1), (array([6\. , 2.2, 4\. , 1\. ]), 0.5916079783099617, 1)]
3 [6.4 2.9 4.3 1.3] 1 [(array([6.2, 2.9, 4.3, 1.3]), 0.20000000000000018, 1), (array([6.6, 3\. , 4.4, 1.4]), 0.2645751311064587, 1), (array([6.6, 2.9, 4.6, 1.3]), 0.3605551275463984, 1)]
4 [5.6 2.8 4.9 2\. ] 2 [(array([5.8, 2.7, 5.1, 1.9]), 0.3162277660168375, 2), (array([5.8, 2.7, 5.1, 1.9]), 0.3162277660168375, 2), (array([5.7, 2.5, 5\. , 2\. ]), 0.33166247903553986, 2)]
投票以获得单一结果
我们现在要写一个投票函数。这个函数使用集合中的类“Counter”来计算实例列表中类的数量。这个实例列表当然是邻居。函数“vote”返回最常见的类:
from collections import Counter
def vote(neighbors):
class_counter = Counter()
for neighbor in neighbors:
class_counter[neighbor[2]] += 1
return class_counter.most_common(1)[0][0]
我们将在训练样本上测试“投票”:
for i in range(n_training_samples):
neighbors = get_neighbors(learnset_data,
learnset_labels,
testset_data[i],
3,
distance=distance)
print("index: ", i,
", result of vote: ", vote(neighbors),
", label: ", testset_labels[i],
", data: ", testset_data[i])
…
index: 0 , result of vote: 1 , label: 1 , data: [5.7 2.8 4.1 1.3]
index: 1 , result of vote: 2 , label: 2 , data: [6.5 3\. 5.5 1.8]
index: 2 , result of vote: 1 , label: 1 , data: [6.3 2.3 4.4 1.3]
index: 3 , result of vote: 1 , label: 1 , data: [6.4 2.9 4.3 1.3]
index: 4 , result of vote: 2 , label: 2 , data: [5.6 2.8 4.9 2\. ]
index: 5 , result of vote: 2 , label: 2 , data: [5.9 3\. 5.1 1.8]
index: 6 , result of vote: 0 , label: 0 , data: [5.4 3.4 1.7 0.2]
index: 7 , result of vote: 1 , label: 1 , data: [6.1 2.8 4\. 1.3]
index: 8 , result of vote: 1 , label: 2 , data: [4.9 2.5 4.5 1.7]
index: 9 , result of vote: 0 , label: 0 , data: [5.8 4\. 1.2 0.2]
index: 10 , result of vote: 1 , label: 1 , data: [5.8 2.6 4\. 1.2]
index: 11 , result of vote: 2 , label: 2 , data: [7.1 3\. 5.9 2.1]
我们可以看到，除了索引为 8 的项目之外，预测与标注的结果一致。
“vote_prob”是一个类似于“vote”的函数，但它返回类名和该类的概率:
def vote_prob(neighbors):
class_counter = Counter()
for neighbor in neighbors:
class_counter[neighbor[2]] += 1
labels, votes = zip(*class_counter.most_common())
winner = class_counter.most_common(1)[0][0]
votes4winner = class_counter.most_common(1)[0][1]
return(winner, votes4winner/sum(votes))
…
for i in range(n_training_samples):
neighbors = get_neighbors(learnset_data,
learnset_labels,
testset_data[i],
5,
distance=distance)
print("index: ", i,
", vote_prob: ", vote_prob(neighbors),
", label: ", testset_labels[i],
", data: ", testset_data[i])
…
index: 0 , vote_prob: (1, 1.0) , label: 1 , data: [5.7 2.8 4.1 1.3]
index: 1 , vote_prob: (2, 1.0) , label: 2 , data: [6.5 3\. 5.5 1.8]
index: 2 , vote_prob: (1, 1.0) , label: 1 , data: [6.3 2.3 4.4 1.3]
index: 3 , vote_prob: (1, 1.0) , label: 1 , data: [6.4 2.9 4.3 1.3]
index: 4 , vote_prob: (2, 1.0) , label: 2 , data: [5.6 2.8 4.9 2\. ]
index: 5 , vote_prob: (2, 0.8) , label: 2 , data: [5.9 3\. 5.1 1.8]
index: 6 , vote_prob: (0, 1.0) , label: 0 , data: [5.4 3.4 1.7 0.2]
index: 7 , vote_prob: (1, 1.0) , label: 1 , data: [6.1 2.8 4\. 1.3]
index: 8 , vote_prob: (1, 1.0) , label: 2 , data: [4.9 2.5 4.5 1.7]
index: 9 , vote_prob: (0, 1.0) , label: 0 , data: [5.8 4\. 1.2 0.2]
index: 10 , vote_prob: (1, 1.0) , label: 1 , data: [5.8 2.6 4\. 1.2]
index: 11 , vote_prob: (2, 1.0) , label: 2 , data: [7.1 3\. 5.9 2.1]
摘要
在本教程中，您了解了如何使用 Python 从头开始实现 k 近邻算法。
具体来说，您学到了:
- 如何逐步编写 k-最近邻算法的代码？
- 如何在真实数据集上计算 k 近邻？
- 如何使用 k 近邻对新数据进行预测？
记住你可以在我的 github 库这里找到完整的工作代码。
感谢的阅读，我很乐意讨论你可能有的任何问题或纠正:)如果你想讨论机器学习或其他任何问题，请在 LinkedIn 上找到我。
Python 中的 k 近邻算法
https://www.pexels.com/photo/photo-of-woman-standing-in-front-of-blackboard-5212320/
k 近邻，简称 KNN，是最简单的机器学习算法之一，被广泛应用于各种机构。KNN 是一个非参数的，懒惰的学习算法。当我们说一种技术是非参数化的，这意味着它不对底层数据做任何假设。换句话说，它根据与其他数据点的接近程度进行选择，而不管数值代表什么特征。成为一个懒惰的学习算法暗示着几乎没有训练阶段。因此，当新数据点出现时，我们可以立即对其进行分类。
KNN 的一些利弊
优点:
- 没有关于数据的假设
- 简单的算法—易于理解
- 可用于分类和回归
缺点:
- 高内存要求-所有训练数据都必须存在于内存中，以便计算最近的 K 个邻居
- 对不相关的特征敏感
- 对数据规模敏感，因为我们正在计算到最近的 K 个点的距离
算法
- 为 K 选择一个值(即 5)。
2.根据新数据点的欧氏距离，取其最近的 K 个邻居。
3.在这些相邻点中，计算每个类别中的数据点数量，并将新数据点分配到您计算的相邻点最多的类别。
密码
让我们看看如何使用 Python 中的 K 近邻算法对数据进行分类。在本教程中，我们将使用来自sklearn.datasets模块的乳腺癌数据集。我们需要从导入过程库开始。
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import confusion_matrix
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
import seaborn as sns
sns.set()
该数据集将肿瘤分为两类(恶性和良性)，包含大约 30 个特征。在现实世界中，你可以查看相关性，并选择在确定肿瘤是否为恶性时起最大作用的特征子集。然而，为了简单起见，我们将随机选择几个。我们必须对分类数据进行编码，以便模型对其进行解释(即恶性= 0和良性= 1)。
breast_cancer = load_breast_cancer()
X = pd.DataFrame(breast_cancer.data, columns=breast_cancer.feature_names)
X = X[['mean area', 'mean compactness']]
y = pd.Categorical.from_codes(breast_cancer.target, breast_cancer.target_names)
y = pd.get_dummies(y, drop_first=True)
正如在另一个教程中提到的，构建模型的目的是用未定义的标签对新数据进行分类。因此，我们需要将数据放在一边，以验证我们的模型在分类数据方面是否做得很好。默认情况下，train_test_split在原始数据集中留出 25%的样本进行测试。
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)
sklearn库在 Python 之上提供了一个抽象层。因此，为了利用 KNN 算法，创建一个KNeighborsClassifier的实例就足够了。默认情况下，KNeighborsClassifier会寻找 5 最近的邻居。我们必须明确地告诉分类器使用欧几里德距离来确定相邻点之间的接近度。
knn = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
knn.fit(X_train, y_train)
使用我们新训练的模型，我们根据肿瘤的平均密度和面积来预测肿瘤是否是良性的。
y_pred = knn.predict(X_test)
我们直观地将我们的模型做出的预测与测试集中的样本进行比较。
sns.scatterplot(
x='mean area',
y='mean compactness',
hue='benign',
data=X_test.join(y_test, how='outer')
)
plt.scatter(
X_test['mean area'],
X_test['mean compactness'],
c=y_pred,
cmap='coolwarm',
alpha=0.7
)
评估我们模型的另一种方法是计算混淆矩阵。混淆矩阵对角线上的数字对应于正确的预测，而其他数字意味着假阳性和假阴性。
confusion_matrix(y_test, y_pred)
给定我们的混淆矩阵，我们的模型具有 121/143 = 84.6%的准确度。
结论
当新数据可用时，K 最近邻算法不需要任何额外的训练。相反，它根据某种距离度量来确定 K 个最近的点(样本必须驻留在存储器中)。然后，它查看每个邻居的目标标签，并将新发现的数据点放入与大多数数据点相同的类别中。鉴于 KNN 计算距离，我们必须扩展我们的数据。此外，由于 KNN 忽略了潜在的特征，我们有责任过滤掉任何被认为不相关的特征。
k 近邻和维数灾难
为什么 k-最近邻算法对额外的维度特别敏感
在我的上一篇文章中，我们学习了 k 近邻建模算法。该算法基于附近数据点与测试点相似的假设，对所需数据点进行分类预测。为了发挥作用，它需要两样东西:
- 首先，它需要你相信它附近的邻居与它相似的假设。在某些情况下，这是正确的。例如，杂货店中的产品通常被分类到相似的组中。嘎拉苹果和嘎拉苹果存放在一起，嘎拉苹果存放在富士苹果旁边。假设一个节日苹果旁边的物品是另一个节日苹果是非常安全的，假设相邻的物品是一个苹果也是非常安全的。然而，在其他情况下，相邻项目相似的假设是没有用的。我醉抽屉里的一个物品是电池，不代表旁边的物品也是电池。它很可能是一支记号笔、一个回形针或一根橡皮筋。
- 第二，你需要有一种测量距离的方法。注意，这是空间距离，不一定是物理距离。它指的是你试图比较的两个数据点之间的差异。在上面的例子中，我使用物理距离作为距离，但它也可以是两个房子的平方英尺的差异，两个设备之间的效率差异，等等。
这意味着使用 k-最近邻算法的成功很大程度上取决于拥有密集的数据集。这使得它特别容易受到“维数灾难”的影响。
什么是“维数灾难”？
“维数灾难”是一种半开玩笑的说法，即在高维数据集中有大量的空间。数据空间的大小随着维度的数量呈指数增长。这意味着，为了保持相同的密度，数据集的大小也必须呈指数增长。如果你不这样做，那么数据点开始变得越来越远。
为什么这对于 k 近邻来说特别成问题？
从表面上看，k 近邻似乎对这个问题并不特别敏感。每个机器学习算法都需要密集的数据集，以便在整个数据空间中进行准确预测。如果数据之间有间隙，所有算法都会出错。那么是什么让 k 近邻变得特别呢？
k-最近邻的特殊挑战是它要求一个点在每一维上都是接近的。一些算法可以基于单个维度创建回归，并且只需要点沿着该轴靠近。k 近邻不是这样工作的。它需要所有的点在数据空间的每个轴上都是靠近的。而每增加一个新的轴，通过增加一个新的维度，使得每一个轴上的两个特定点越来越难相互靠近。
Joel Grus 在《从零开始的数据科学》中很好地描述了这个问题。在那本书里，他计算了随着维度数量的增加，一个维度空间中两点之间的平均和最小距离。他计算了 10，000 个点之间的距离，维数从 0 到 100 不等。然后，他继续绘制两点之间的平均和最小距离，以及最近距离与平均距离的比率(Distance _ Closest/Distance _ Average)。
在这些图中，Joel 显示了最近距离与平均距离的比率从 0 维的 0 增加到 100 维的 0.8。这显示了当使用 k-最近邻算法时对维度的基本挑战；随着维数的增加，最近距离与平均距离的比率接近 1，算法的预测能力降低。如果最近点几乎与平均点一样远，那么它的预测能力仅比平均点略高。
思考这个问题如何应用到我们上面的苹果例子中。这有点违背直觉，因为苹果的例子本来就是三维的，但是想象一下，到农产品区中下一个最近的商品的距离大约与平均距离相同。突然，你不能确定最近的东西是另一个苹果，还是一个富士苹果，或者一个橘子，或者一束欧芹。就 k-最近邻算法而言，整个生产部分将会混杂在一起。
当使用 k-最近邻算法时，我如何克服维数灾难？
从根本上来说，问题在于没有足够的数据来衡量维度的数量。随着维度数量的增加，数据空间的大小也会增加，保持密度所需的数据量也会增加。如果数据集的大小没有显著增加，k 近邻将失去所有的预测能力。这使得这个问题的一个可能的解决方案很简单:添加更多的数据。添加越来越多的数据以确保即使在添加更多维度时也有足够的数据密度是完全可能的。如果你有硬件来处理这么大的数据量，这是一个完全合理的解决方案。
当然，您不可能总是拥有添加那么多数据所必需的硬件。不是每个数据科学家都买得起超级计算机。即使这样，也有可能有足够大的数据集，即使是超级计算机也无法在合理的时间内处理它。这就是降维概念发挥作用的地方。降维超出了本文的范围，但是我将在下一篇文章中讨论它。本质上，它指的是识别数据集中的趋势，这些趋势沿着数据集中没有明确指出的维度运行。然后，您可以创建与这些轴匹配的新维度，并删除原始轴，从而减少数据集中的轴总数。
举个例子，假设你在一个城市里绘制了花园侏儒的位置。你得到每个花园侏儒的 GPS 坐标，并把它们标在地图上。你有南北和东西两个维度。现在想象一下，出于某种原因，所有的花园侏儒都被放置在一条穿过城镇的近乎对角线的线上。一个在东南角，一个在西北角，两者之间几乎是一条直线。现在，您可以创建一个名为东南-东北轴的新轴(或者，如果您想变傻，也可以称为“花园侏儒分界线”)，并删除南北和东西轴。这样你就把你的数据集从二维减少到了一维，并且使得 k-最近邻算法更容易成功。
包装它
k-最近邻算法依赖于数据点相互靠近。随着维数的增加，这变得具有挑战性，被称为“维数灾难”对于 k-nearest neighbors 算法来说尤其困难，它要求两个点在每个轴的上非常接近，并且增加一个新的维度为点的远离创造了另一个机会。随着维数的增加，两点之间的最近距离接近两点之间的平均距离，从而消除了 k-最近邻算法提供有价值的预测的能力。
为了克服这一挑战，您可以向数据集中添加更多的数据。通过这样做，您可以增加数据空间的密度，使最近的点更加接近，并恢复 k-最近邻算法提供有价值的预测的能力。只要您有在数据集上执行计算所需的硬件，这就是一个有价值的解决方案。随着数据集变得越来越大，您需要越来越多的计算能力来处理它。最终，数据集的规模将超过你的计算能力。此时，您需要使用维度缩减来用更少的维度呈现所有有价值的信息。该主题将在未来的文章中进行更详细的描述。
k 近邻法:预测乳腺 x 线肿块病变的严重程度
“通过立即更换临床医生，[该算法]将允许我们实际上加快对潜在威胁生命的情况的及时诊断。”雷切尔·卡尔卡特博士。
Feature Image Source: iStock.com/Aleutie
本文阐述了理解 k-最近邻和调整超参数所需的基本背景。
基于实例的学习(也称为基于记忆的学习)是一个学习算法家族，它不是执行数据点的泛化，而是试图将新的问题实例(测试数据)与提供的数据点(训练数据)进行比较。
基于实例的学习算法的最简单形式之一是最近邻(NN)算法。简而言之，最近邻算法倾向于基于问题空间中数据点的最近邻来对测试数据点进行分类。最近邻算法的主要缺点之一是对噪声非常敏感。现在，最近邻算法的一个广泛使用的扩展是k-最近邻(k-NN)算法。与 k-最近邻中的最近邻不同，我们倾向于寻找测试数据点的 k-最近邻，并且在这些 k-最近邻中的多数投票预测测试数据点的类别。深入挖掘 k-NN 的最佳帖子之一是 Onel Harrison 的关于 K-最近邻算法的机器学习基础。
问题陈述
乳房 x 线照相术是目前乳腺癌筛查最有效的方法。然而，从乳房 x 光片判读得到的乳房活检的低阳性预测值导致大约 70%的不必要活检具有良性结果。为了减少大量不必要的乳腺活检，近年来已经提出了几种计算机辅助诊断(CAD)系统。这些系统帮助医生决定对乳房 x 线照片中看到的可疑病变进行乳房活检，或者改为进行实用的机器学习短期随访检查。
我们能否找到 k-NN 系统的最佳变体，用于根据 BI-RADS 属性和患者年龄预测乳腺 x 线肿块病变的严重程度(良性或恶性)?
特征信息
有 5 个数字特征和一个二元目标类，如下所述:
Features in Mammographic Dataset
数据分为—测试和训练集:
创建了四个数据集，每个测试和训练有两个，因此一个数据集中有要素，另一个数据集中有目标变量。
Train and Test Distribution of dataset
用于评估的 k-NN 变量和超参数:
通过改变距离矩阵来创建 k-NN 变体。改变距离矩阵也引入了许多与该距离相关的超参数。
使用的 k-NN 变体在下面描述
- **欧氏距离:**这是最常见的距离度量，它度量的是两点之间的直线距离。下面提供了计算到数据点 p 和 q 的欧几里德距离的数学公式:
Formula to compute Euclidean distance
欧几里德距离的代码:
def calculateDistances(compArray, queryArray):
“””
Computes Euclidean distance-
:param compArray: takes in 2d array i.e. training dataset
:param queryArray: takes in 1d array i.e. instance of test dataset
:return: sqrtArray :distance between the querry point and each point in training dataset
sortedIndex : sorted index based on the distance between the querry point and each point in training dataset
“””
subArray =np.subtract(compArray,queryArray)
powArray = subArray**2
sumArray = np.sum(powArray,axis =1)
sqrtArray = np.sqrt(sumArray)
#sorts index of array based on respective location value
sortedIndex = np.argsort(sqrtArray)
return sqrtArray,sortedIndex
2.**曼哈顿距离:**第二种最常见的距离度量是曼哈顿距离，它测量平行于每个轴的距离，而不是像欧几里德距离中观察到的那样对角距离。下面提供了计算到数据点 p 和 q 的曼哈顿距离的数学公式:
Formula to compute Manhattan distance
曼哈顿距离代码:
def calculateManhattanDistances(compArray, queryArray):
“””
Computes Manhattan distance-
:param compArray: takes in 2d array i.e. training dataset
:param queryArray: takes in 1d array i.e. instance of test dataset
:return: sumArray :distance between the querry point and each point in training dataset
sortedIndex : sorted index based on the distance between the querry point and each point in training dataset
“””
subArray =np.subtract(compArray,queryArray)
subArray= np.absolute(subArray)
sumArray = np.sum(subArray,axis =1)
#sorts index of array based on respective location value
sortedIndex = np.argsort(sumArray)
return sumArray,sortedIndex
3.**闵可夫斯基距离:**闵可夫斯基距离提供了一个一般化的公式，以找到适用于不同问题域的复杂距离度量。下面提供了计算到数据点 p 和 q 的闵可夫斯基距离的数学公式:
Formula to compute Minkowski distance
对于上面的等式，如果’ a’ 被认为是 1，我们将得到曼哈顿距离，如果’ a’ 被认为是 2，我们将得到欧几里德距离。
闵可夫斯基距离代码:
def calculateMinkowskiDistances(compArray, queryArray, alpha):
“””
Computes Euclidean distance-
:param compArray: takes in 2d array i.e. training dataset
:param queryArray: takes in 1d array i.e. instance of test dataset
:param alpha: this value allow us to play with multiple values in which 1 =manhattan distance and 2= euclidean distance
:return: sqrtArray :distance between the querry point and each point in training dataset
sortedIndex : sorted index based on the distance between the querry point and each point in training dataset
“””
subArray =np.subtract(compArray,queryArray)
np.absolute(subArray)
powArray = subArray**alpha
sumArray = np.sum(powArray,axis =1)
sqrtArray = np.power(sumArray, (1./float(alpha)))
#sorts index of array based on respective location value
sortedIndex = np.argsort(sqrtArray)
return sqrtArray,sortedIndex
4.**加权欧氏距离:**上述距离度量的最大缺点是没有考虑 k 近邻之间的距离有多远或多近，导致 k-NN 模型的误分类。在距离加权 k-NN 中，来自每个邻居的投票被累积，并且基于最近邻居到测试数据点的距离来计算它们对投票的贡献，因此更近的邻居点对类的预测影响更大。计算到数据点 x 和 y 的加权欧几里德距离的数学公式如下:
Formula to compute Weighted Euclidean distance
加权欧几里德距离的代码:
def getWtPrediction(computedListValue, k, n):
“””
This functions helps in generating prediction for each test data point-
:param computedListValue: takes in list in which distance of that respective test point to all training datapoint are available
:param k: It is hyper parameter which decides how many nearest neighbour should be kept in consideration while doing prediction.
:param n: It is another hyper-parameter which decides the power to the inverse distance.
:return: ndComputedList : which contains prediction based on the given input
“””
ndComputedList= np.array(computedListValue)
ndComputedList.sort(axis=1)
ndComputedList= ndComputedList[:, :k]
ndComputedList = 1/pow(ndComputedList,n)
ndComputedList = np.sum(ndComputedList, axis =1)
return ndComputedList
下面提供了基于距离度量的与每个 k-NN 变量相关联的超参数:
- 欧氏距离: ’ k '表示数据集中聚类的个数。
Hyper-parameter for k-NN with Euclidean distance
2.曼哈顿距离: ’ k '表示数据集中的聚类数。
Hyper-parameter for k-NN with Manhattan distance
3.闵可夫斯基距离: ’ k '表示数据集中聚类的数量。 alpha 表示调节距离测量的整数。
Hyper-parameter for k-NN with Minkowski distance
4.加权欧氏距离: ’ k 表示数据集中聚类的个数。 n 表示基于它们之间的距离的最近邻居的贡献。
Hyper-parameter for k-NN with Weighted Euclidean distance
k-NN 变体和超参数观察:
如上所述，针对超参数评估 k-NN 变体。对于一个以上的超参数，该测试发展为结合来自 sklearn 库的 ParameterGrid，以进行网格搜索优化。下面，我们将展示不同距离测量和精度所涉及的超参数。
- 基于欧氏距离的 k-NN；
因为在使用欧几里德距离时只有一个超参数。因此**‘k’**相对于精度的散点图如下所示:
k-Value V/S Accuracy for Euclidean distance based k-NN
2.基于曼哈顿距离的 k-NN；
因为在使用曼哈顿距离时只有一个超参数。因此**‘k’**相对于精度的散点图如下所示:
k-Value V/S Accuracy for Manhattan distance based k-NN
3.基于闵可夫斯基距离的 k-NN；
因为在使用闵可夫斯基距离时有两个超参数。因此**‘k’和‘alpha’**关于精度的散点图如下所示:
k-Value V/S Accuracy for Minkowski distance based k-NN
alpha-Value V/S Accuracy for Minkowski distance based k-NN
4.基于加权欧氏距离的 k-NN；
因为在使用闵可夫斯基距离时有两个超参数。因此**‘k’和‘n’**关于精度的散点图如下所示:
k-Value V/S Accuracy for Minkowski distance based k-NN
n-Value V/S Accuracy for Minkowski distance based k-NN
k-NN 变体总体观察:
k-NN 变体的最佳性能在本节中进行评估。
Distance Matrix and Accuracy
在条形图上显示相同的内容:
Distance Matrix and Accuracy
结论:
通过上述观察，可以推断出基于加权欧几里德距离的矩阵在根据 BI-RADS 属性和患者年龄预测乳房 x 线摄影肿块病变的严重程度(良性或恶性)方面非常有效
参考文献:
实用机器学习 课程来自 CIT:
链接到数据集:https://archive.ics.uci.edu/ml/datasets/Mammographic+Mass
卡夫多普
一个开源的 Kafka UI
作为一个信息平台，Kafka 无需介绍。自成立以来，它几乎重写了关于事件流的书籍，并促进了现在家喻户晓的设计模式的采用——微服务、事件源和 CQRS。
作为天赐之物，它几乎逃脱了臭名昭著的缺乏工具的惩罚。你很难找到一个开发人员没有看过内置的 CLI 工具，捧着他们的脸说:“就是这个吗？开什么玩笑？”
外面有什么
随着 Kafka 的流行，一些商业供应商抓住机会通过提供他们自己的工具来赚钱也就不足为奇了。卡夫卡工具、兰多普、和卡德克就是一些例子，但它们都是仅供个人使用的，除非你愿意付费。(这并不是说你不应该这样做，恰恰相反，但这不是重点。)在商业环境中的任何非平凡使用都将违反其许可条款。在家里用它们做教程或个人项目是一回事；当你在没有适当许可的情况下使用商业工具时，你是在让你的雇主面临诉讼的风险，是在拿你的职业生涯玩俄罗斯轮盘赌。
但是开源呢？
说到 Kafka 主题查看器和 web UIs，首选的开源工具是 Kafdrop 。在撰写本文时，Docker pulls 已经达到 80 万，享受到这种采用水平的 Kafka 工具并不多。这背后有一个原因:Kafdrop 做了一项惊人的工作，填补了 Kafka 的可观察性工具中的明显空白，解决了社区已经指出太久的问题。
Kafdrop 是一个 Apache 2.0 许可项目，就像 Apache Kafka 本身一样。所以不会花你一分钱。如果你还没有使用过它，你可能应该使用它。所以让我们深入了解一下。
它能做什么？
- 查看 Kafka brokers —主题和分区分配，以及控制器状态
- 查看主题 —分区计数、复制状态和自定义配置
- 浏览消息 — JSON、纯文本和 Avro 编码
- 查看消费者群体 —每个分区的停放偏移量、组合偏移量和每个分区的延迟偏移量
- 创建新主题
- 查看 ACL
入门指南
Kafdrop web UI 项目托管在 GitHub 上:
Kafdrop 是一个用于查看 Kafka 主题和浏览消费群体的 web UI。该工具显示如下信息…](https://github.com/obsidiandynamics/kafdrop)
你有几个选择。你可以通过克隆库并从源代码开始构建来显示一点勇气。这是一个 Java (JDK 11) Spring Boot 项目，只要安装了 JDK，就可以用一个 Maven 命令来构建它。如果你想走这条路，回购的README.md文件将引导你通过这些步骤。现在，让我们采取简单的方法——Docker。(我当然会。)
启动 Kafdrop
Docker 图片托管在 DockerHub 上。图像标有 Kafdrop 发布号。标签指向最新的稳定版本。
要在前台启动容器，请运行以下命令:
docker run -it --rm -p 9000:9000 \
-e KAFKA_BROKERCONNECT=<host:port,host:port> \
obsidiandynamics/kafdrop
必须将KAFKA_BROKERCONNECT环境变量设置为代理的引导列表。
就是这样。我们应该开始运作了。一旦启动，您可以通过导航到 localhost:9000 来启动 Kafka web UI。
注意: 上面的例子假设一个通过明文 TCP 套接字的认证连接。如果您的集群配置为使用身份验证和/或传输层加密，请咨询
*README.md*了解连接选项。为 SASL/SSL 锁定集群配置 Kafdrop 实际上非常容易。
在卡夫卡的沙盒中奔跑
没有卡夫卡经纪人吗？别担心。只需使用下面的docker-compose.yaml文件来调出一个 Kafka + Kafdrop 栈:
version: "2"
services:
kafdrop:
image: obsidiandynamics/kafdrop
restart: "no"
ports:
- "9000:9000"
environment:
KAFKA_BROKERCONNECT: "kafka:29092"
depends_on:
- "kafka"
kafka:
image: obsidiandynamics/kafka
restart: "no"
ports:
- "2181:2181"
- "9092:9092"
environment:
KAFKA_LISTENERS: "INTERNAL://:29092,EXTERNAL://:9092"
KAFKA_ADVERTISED_LISTENERS: "INTERNAL://kafka:29092,EXTERNAL://localhost:9092"
KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: "INTERNAL:PLAINTEXT,EXTERNAL:PLAINTEXT"
KAFKA_INTER_BROKER_LISTENER_NAME: "INTERNAL"
现在用docker-compose up启动堆栈。一旦启动，浏览到 localhost:9000 。
浏览 Kafka Web 用户界面
浏览集群
集群概述屏幕是网络用户界面的登录页面。
您可以看到集群的整体布局——组成集群的各个代理、它们的地址和一些关键的代理统计信息——它们是否是控制器以及每个代理拥有的分区数量。后者非常重要——随着集群规模和主题数量(以及分区数量)的增长，您通常希望看到分区在集群中的大致水平分布。
接下来是主题列表，在大多数情况下，这就是你在这里的真正目的。任何合理规模的基于微服务的生态系统可能有数百个，如果不是数千个主题的话。如你所料，这个列表是可搜索的。每个主题旁边显示的统计数据相当单调。值得注意的是复制不足的列。本质上，它告诉我们落后于主分区的分区副本的数量。零是个好数字。任何其他情况都表示需要立即关注的代理或网络问题。
注: Kafdrop 是发现探索工具；它不是实时监控工具。当出现问题时，你应该通知你的经纪人并发出警报。
列出主题
点击列表上的主题，进入主题概述屏幕。
屏幕分为四个部分。
在左上角，有一个主题 stats 的摘要—这是一个方便的视图，与您在集群概述中看到的没有什么不同。
在右上角，您可以查看自定义配置。在上面的例子中，主题运行一个股票标准配置，所以没有什么可看的。如果配置被覆盖，您会看到一组自定义值，如下例所示。
左下部分列举了分区。分区索引是链接—点击将显示主题中的前 100 条消息。
该部分显示了几个有趣的参数:
- 分区 ID :分区在其包含主题内的从零开始的索引。
- 第一个偏移量:分区中最早消息的偏移量。如果分区为空，则第一个偏移量与高水位线相同。
- Last offset :分区的高水位线，是将分配给下一个发布的消息的偏移量。
- 大小:分区中消息的数量。
- Leader Node :当前充当 Leader 的代理节点的 ID。
- 副本节点:持有分区副本的所有代理节点的 id。这包括领导者 ID。
- 同步复制节点:同步复制节点的 id，包括首节点。
- 离线副本节点:当前离线的副本节点的 id。在正常情况下，这应该是一个空集。
- 首选首领:当前首领节点是否恰好是首选首领节点。
- 复制不足:分区是否复制不足，即至少有一个副本与主分区不同步。
右下方的消费者部分列出了消费者组名称以及它们的总延迟(所有单个分区延迟的总和)。
查看消费者群体
点击主题 Overview 上的消费者组，进入消费者视图。该屏幕提供了单个消费者群体的全面细分。
视图按主题划分。对于每个主题，单独的表列出了基础分区。针对每个分区，我们可以看到提交的偏移量，我们可以将它与第一个和最后一个偏移量进行比较，以了解我们的使用者是如何跟踪的。方便的是，Kafdrop 显示每个分区的计算滞后，它聚集在每个主题表的页脚。
注: 有些量的滞后在所难免。对于发布的每条消息，在发布点和消费点之间总会有一段时间。在 Kafka 中，这个时间通常是几十或几百毫秒，取决于生产者和消费者客户端选项、网络配置、代理 I/O 能力、页面缓存的大小和无数其他因素。你需要注意的是增长滞后——表明消费者要么跟不上，要么已经完全停滞。在后一种情况下，您还会注意到，即使在生成器空闲时，滞后也没有被耗尽。这是你需要从 Kafdrop 切换到你最喜欢的调试器的时候。
查看邮件
消息视图屏幕是梦寐以求的主题查看器，很可能就是它把你带到了这里。您可以通过以下两种方式之一进入邮件视图:
- 点击主题概览屏幕上的查看消息按钮。
- 单击主题概述中的单个分区链接。
这正是您所期望的——一个按时间顺序排列的消息列表(或者用 Kafka 的说法是记录)。
每个条目都方便地显示了偏移量、记录键(如果设置了的话)、发布的时间戳以及生产者可能添加的任何头。
凯卓的袖子里还有一个小把戏。如果消息碰巧是有效的 JSON 文档，主题查看器可以很好地格式化它。单击消息左侧的绿色箭头将其展开。
最后
使用 Kafka 的次数越多，您就越会发现并欣赏它的真正潜力——不仅仅是作为一个多功能的事件流平台，而是作为一个通用的消息中间件，允许您从异步、松散耦合的服务组装复杂的业务系统。
与过去更成熟的 MQ 经纪人相比，您总是会经历一项最近才进入主流的技术所带来的挫折。令人欣慰的是，开源社区并没有停滞不前，而是产生了一个不断发展的生态系统，为我们继续工作提供了必要的文档和工具。作为回报，我们至少可以偶尔提出一个 pull 请求，或者回答一个或三个 StackOverflow 问题。
这篇文章对你有用吗？我很想听到你的反馈，所以不要退缩！如果你对卡夫卡或者事件流感兴趣，或者只是有什么疑问， 在 Twitter 上关注我 。
巴黎 2019 年 Kaggle Days
Kaggle Days 是数据科学家和 ka ggler 的第一个全球线下活动系列。这样的盛会为创建和构建数据科学社区提供了机会。2018 年，首次在华沙举办的名为 Kaggle Days 的活动取得了成功。100 多名参与者在生动的演示和研讨会中向 Kaggle 大师学习。对许多人来说，亮点是有史以来第一次 Kaggle 线下比赛，一整天的现场挑战。
第二个 Kaggle Days 发生在巴黎。参与者数量增加了一倍:从 400 多个应用程序中选择了大约 200 名数据科学家、Kagglers 和对机器学习感兴趣的人。标准的讲座、研讨会和竞赛项目被一些新的形式所丰富，如头脑风暴会议和有经验的导师的咨询。
参与者的动机
可以将当前的数据科学和机器学习分为 3 大类:商业、学术和竞赛(见下图)。每个领域都有自己的目标和目的:企业努力实现利润最大化，研究人员努力增加高质量出版物的数量，竞争对手努力实现最高职位竞争数量的最大化。每个领域对数据科学和机器学习的“适当”方法都有自己的理解:例如，为分数增加 1%而进行几层下注是机器学习竞赛的常见做法，但通常是生产中部署的禁忌；科学上没有新颖性的方法可能不会在期刊上发表，但可以很容易地应用于学术或工业。
3 major Data Science and Machine Learning fields (picture from Vladimir Iglovikov’s blog post)
然而，电流场是紧密相连的，尽管它们在空间中不是独立存在的。思想、方法和技巧可以通过一些改变从一个领域转移到另一个领域，以达到最佳效果。大概 Kaggle，这个举办各种机器学习比赛的地方，就是在这个意义上检验思想和方法的最佳场所之一。
每个参与者都希望在比赛中在排行榜上获得尽可能高的分数。这需要想出各种各样的想法，然后测试它们。当然，绝大多数的想法不会是好的，但是剩下的那些可以提高你的分数的想法是非常有价值的。竞赛结束后，您可以在工作、做研究或参加各种竞赛时使用这些想法。因此，Kaggle 是一个在 DS 和 ML 领域选择可行的想法和方法的平台。最近发表了一篇很棒的关于如何正确“养殖”Kaggle 的文章。
Kaggle Days 是一个顶级 kag gler 通常分享他们对某些任务的愿景的地方，这些任务已经在比赛、生产和研究中得到验证。对我来说，这是一个很好的机会来看看同样的问题，但从他们的角度来看。所以，我利用这个机会学习了一些新的东西。
第一天
第一天是讲座和研讨会。很难讲清楚每场演讲的每一个细节，因此，我决定提到其中最有趣的三个，并对它们补充一些想法。
“超越特征工程和超参数优化”，作者江泽龙·普吉特
江泽龙讲述了他在 Kaggle 和工作期间解决数据科学问题的方法。他从一个简单的想法开始:许多数据科学家不太重视探索性数据分析(EDA)，这是结果不佳和得分低的一个原因。EDA 的目标是在数据中发现一些隐藏的模式，这可能会导致对特征工程的见解，但不是绘制花哨的图形和可视化。伟大的 EDA 提出问题，然后提供问题的答案。如果你不熟悉 EDA，一定要读一读 Cole Nussbaumer Knaflic 写的关于当前主题的最伟大的书《用数据讲故事》。我强烈推荐看一看一个简短的摘要:用两种语言写的:英语、俄语和 T2 语。
关于特性工程和选择的另一个展示点是:创建一个小的特性数量，而不是大的，但是要让它有意义。总的想法很简单:问问你自己，在当前任务中什么是真正重要的特性，你如何利用现有的数据来创建它。就我而言，我认为当前的方法在应用于商业问题时要好得多，因为它允许有意识地选择要收集的数据。有时，新数据收集并不需要太多的努力，但它在很大程度上影响模型的质量。
但是创造好的特性的最好方法是什么呢？我们可以通过检查以前类似任务的比赛来找到特征工程的灵感，以便找到最重要的特征并将相同的逻辑应用于给定的问题。另一种方法是使用问题领域知识。在这种情况下，我们可能会受到我们对问题的理解方式的限制，因此，没有能力找到新的模式。此外，数据科学家并不总是任务领域的专家。在这种情况下，关于当前主题的论文和文章可能会有所帮助。
结论:开始创建有意义的 EDA，它提出问题，然后试图利用可用数据回答这些问题。从“使用数据时我们可以创建什么功能？”的角度来思考思维模式的转变到“当前任务中有哪些好的特性，在使用给定数据时如何创建它们？如果我们不能，我们如何获得相关数据？”。
Alberto Danese 的“ML 可解释性”和 Konstantin Lopukhin 的“图像和文本的可解释神经网络”
这两个讲座有许多共同之处，因此，我决定把它们结合在一起。两场讲座都在谈论一个常见的现代数据科学主题——模型的可解释性——模型以人类可以理解的方式呈现预测的能力。根据 2018 年 6 月 O’Reilly 的调查，11400 名数据专家中约有一半(49%)表示他们处于机器学习的探索阶段，尚未将任何机器学习模型部署到生产中。65%的受访者表示，可解释性和透明度是他们的模型构建清单的一部分，相比之下，48%的受访者表示遵从，45%的受访者表示确保用户对数据和模型的控制。
因此，我们可以得出结论，在选择是否部署模型时，模型的决策方式实现是重要的。在这样的分析过程中，我们想要回答几个简单的问题:这个模型是否偏向于某些特性？它能对新数据进行很好的归纳吗？我们能相信它的预测吗？通常，我们将所有可用的数据分成训练、验证和测试部分，以便回答这些问题。然后，我们在训练部分训练我们的模型，在验证数据集上调整超参数，并通过测试数据获得我们的管道分数。我们假设测试部分与我们在模型使用过程中得到的数据相似，因此测试部分的分数是可靠的。
然而，《T2》中描述的“哈士奇大战狼”实验，我为什么要相信你解释任何分类器的预测，向我们展示了这种方法的一些局限性。在当前的实验中，卷积神经网络被训练成在有偏差的数据集上对哈士奇/狼进行分类——狼的图片总是包含雪。作者没有提供这样的分类准确性，但我假设它在训练和测试部分都很高，因此上述模型评估方法会给我们体面的分数，因此我们可以部署该模型。
向参与者展示了分类解释-免费图片，并询问了三个问题:
- 你相信这种算法在现实世界中能很好地工作吗？
- 你为什么这么想？
- 你认为算法如何区分这些狼和哈士奇的照片？
在他们回答之后，会展示预测解释图片(见下图),参与者会被问同样的三个问题。正如您所料，对模型的整体信任度显著下降。
“Husky vs Wolf” experiment results (“Why Should I Trust You?” Explaining the Predictions of Any Classifier)
这个实验过于简单，但我们仍然可以得出几个结论，我认为最重要的结论如下:我们可以从模型的预测实现中找到机器学习管道的“弱点”。在与这些点合作后，我们的管道质量将会提高。例如，我们可能会发现数据中的偏差，用没有雪的狼的图片丰富我们的数据集，或者删除图片背景。
结论:理解模型的预测可以通过消除“弱点”来增加机器学习管道的良好性。
斯坦尼斯拉夫·谢苗诺夫的《机器学习的技巧和诀窍》
Stanislav 的演示结合了他多年参加机器学习竞赛的经验，形成了独特的技巧列表。在我看来，最有趣的是最后一条，它显示了任务重组的重要性，我们可以利用我们的优势。
任务来自希腊媒体监督多标签分类。在当前的竞争中，我们必须为印刷媒体文章选择合适的标签。每篇文章可以有几个标签(例如体育、英格兰、足球)。主题数量事先是未知的，可能是一个、两个甚至五十个主题，度量标准会惩罚我们选择太少或太多的主题。那么我们应该如何选择呢？
解决这一挑战的可能方法是选择具有较高概率的恒定主题数，或者选择概率大于某个阈值的主题。第一种情况下的主题数量和第二种情况下的阈值是超参数，可以使用验证数据集进行优化。然而，让我们从另一个角度来看这个问题。我们将在术语中表述相同的问题，这将允许我们在使用数据驱动的方法时解决它。
对于每篇文章，我们可以预测训练部分的某些主题可能性(进行折叠预测)。此外，我们知道基本事实——实际的主题数量。我们可以为每个示例计算一个最佳阈值，并将其用作附加后处理模型的目标。
我们用术语来表述这个问题，这允许我们在使用数据驱动的方法时解决它。在这种情况下，我们的目标是精心制作一些基本事实标签(给定文章的实际主题数量或最佳概率阈值)和描述每篇文章的特征(文章特征、输出主题概率的统计数据等)。
结论:如果你在任务上停滞不前，尝试以某种方式重新制定它，允许生成特征和地面实况目标，然后使用机器学习工具解决它。
第二天
第二天组织了 11 小时的 ka ggle-like 比赛。路易威登提供了这项任务——根据前 7 天销售的各种信息(销售数量、价格、社交网络的情绪分析、经济因素、照片、网站数据)预测未来三个月的产品销售数量(各种商品:包、鞋、皮带等)。为我们提供了产品的培训数据和目标，这些数据和目标在 2017 年发布，测试期包含 2018 年发布的产品。
Similar to Data Scientists free time 😃
由于导师会议，整个比赛流程非常有趣和愉快。每个参与者都可以和有经验的棋手(大师、特级大师)一对一交谈，并问任何问题。我没有错过这个机会，并询问他们关于在比赛和实际工作中突出工程的想法；此外，我从经验丰富的大师那里收到了关于我的比赛进程的非常有建设性的反馈。
最终，我在 77 支队伍中获得了第 22 名，这是一个不错的成绩。其中一名获胜者公布了他们的方法——对过度拟合说是。
希望在接下来的几天里我会改进它。
From left to right: Yana Pleskova, Stanislav Semenov (former top 1 in Kaggle rankings), Denis Vorotyntsev (author of this blog post), Anthony Goldbloom (CEO of Kaggle), Pavel Pleskov (currently top 5 in Kaggle rankings), Pavel Ostyakov (currently top 4 in Kaggle rankings)
Kaggle For 初学者:入门
本文的目的是帮助你开始使用 Kaggle 并加入世界上最大的机器学习和数据科学社区。
那么 Kaggle 是什么？
正如他们所说，Kaggle 是“数据科学的家园”。这是通过动手的数据科学和机器学习项目学习和拓展技能的最佳场所。
你还在等什么？前往 Kaggle ，点击一下就可以注册🏃。
Kaggle 上的编程语言
Python 和 R 都在 Kaggle 上很受欢迎，你可以使用其中任何一个进行 kaggle 比赛。
卡格尔服务公司
1.机器学习竞赛
这就是 kaggle 出名的原因。找到你觉得有趣的问题，比赛构建最好的算法。
卡格尔比赛的常见类型
你可以在 kaggle 上按类别搜索比赛，我会告诉你如何获得新手“入门”比赛的列表，这些比赛总是可用的，没有截止日期😃。
- 特色比赛大概是 Kaggle 最为人熟知的比赛类型。它们通常由公司、组织甚至政府赞助。他们提供高达 100 万美元的奖金。
- 研究竞赛的特色问题比特色竞赛问题更具实验性。由于他们的实验性质，他们通常不提供奖励或积分。
- 入门竞赛的结构类似于特色竞赛，但它们没有奖金池。它们具有更简单的数据集、大量的教程，并且没有截止日期——这正是新手需要开始的！😃。入门竞赛的一个例子是:
泰坦尼克号:机器从灾难中学习——预测泰坦尼克号上的幸存者
- 游乐场竞赛是一种“为了好玩”的 Kaggle 竞赛，比入门难度高一步。奖品从荣誉到小额现金不等。操场竞赛的一个例子是:
狗对猫——创造一种算法来区分狗和猫
how to find getting started competitions
Kaggle 竞争环境
kaggle competition environment
下面是选项卡的快速浏览
- **概述:**问题的简要描述、评估标准、奖品和时间表。
- **数据:**是你可以下载和了解比赛中使用的数据的地方。您将使用一个训练集来训练模型，并使用一个测试集来进行预测。在大多数情况下，数据或其子集也可以在内核中访问。
- **内核:**你和其他竞争对手以前做过的工作。回顾流行的内核可以激发更多的想法。您可以通读其他脚本和笔记本，然后复制代码(称为“Fork”)进行编辑和运行。
- **讨论:**另一个有用的资源，你可以在这里找到来自比赛主持人和其他参赛者的对话。这是一个提问和学习他人答案的好地方。
- **排行榜:**每场比赛都有公开排行榜和私人排行榜。注意，排行榜是非常不同的。公共排行榜根据提交数据的代表性样本提供公开可见的提交分数。该排行榜在整个比赛过程中都可以看到。虽然它给你一个好主意，但它并不总是反映谁会赢谁会输。私人排行榜才是真正重要的。它根据参与者看不到的数据跟踪模型性能。因此，私人排行榜对谁的模型最好，以及谁将成为比赛的赢家和输家有最终决定权。比赛结束才算。
- **规则:**包含管理您参与赞助商竞赛的规则。开始前阅读规则是非常重要的。
- **团队:**您可以在此选项卡上执行许多不同的团队相关操作。
- **我的参赛作品:**查看您之前的参赛作品，选择最终参赛作品。
- **提交预测:**要提交新预测，请使用“提交预测”按钮。这将打开一个允许您上传提交文件的模式。
2.数据集
Kaggle 数据集是发现、探索和分析开放数据的最佳场所。您可以找到许多不同类型和大小的有趣数据集，您可以免费下载并提高您的技能。
how to choose a dataset
3. Kaggle 学习课程
Jupyter 笔记本中教授的免费微课，帮助您提高当前技能。
4.讨论:
一个向 Kaggle 社区的数千名数据科学家提问和寻求建议的地方。
共有六个通用站点论坛:
- Kaggle 论坛 :针对 Kaggle 社区的事件和话题
- 入门 :新手提问讨论的第一站
- 产品反馈 :告诉 kaggle 你喜欢什么，讨厌什么，或者希望什么
- 问题&答案 :其他数据科学家的技术建议
- 数据集 :开放数据的请求和讨论
- 学习 :与 相关的问题、答案、请求 Kaggle 学习课程
Types of Kaggle discussions
5.内核
Kaggle 内核本质上是浏览器中的 Jupyter 笔记本。这些内核完全免费运行(你甚至可以添加一个 GPU)。这意味着您可以省去设置本地环境的麻烦。它们还允许您共享 Python 或 r 中的代码和分析。它们还可以用于参加 Kaggle 比赛和完成 kaggle 学习课程。探索和阅读其他 Kagglers 的代码是学习新技术和参与社区的好方法。
选择一个数据集，然后点击几下就可以旋转出一个新的内核
Click the Kernel tab of the competition then click new kernel
Kaggle 内核环境
以下是如何打开 GPU、更改内核语言、公开内核、添加合作者以及安装未预装的包，因为 kaggle 内核预装了最流行的 python 和 R 包😃。
Remember kaggle’s run time limitly is currently 9 hours
向内核添加数据集
您可以从您的计算机、kaggle 竞赛或其他 ka ggler 的公共内核向您的内核加载额外的数据集。
内核版本
当您提交并运行内核时，它会运行您的所有代码，并将其保存为一个稳定的版本，供您以后参考。然而，你的代码总是保存你去😃。
Committing a kernel
分叉 Kaggle 内核
您可以从其他用户那里复制并构建现有的内核😃。
Don’t forget to vote for kernels you liked
Click the three dots to learn about what else Kaggle has to offer you 😃
你一路赶到这里？！感谢阅读。😆
恭喜你！你现在是卡格勒了👏🎉。
如果您有任何问题或意见，请在下面留下您的反馈，或者您可以随时通过 Twitter 联系我。在那之前，下一篇文章再见！✋.
参考
[## 如何使用 Kaggle
编辑描述
www.kaggle.com](https://www.kaggle.com/docs)
Kaggle 内核初学者指南—循序渐进教程
不久前，我写了一篇名为“用 Kaggle 内核展示你的数据科学技能”的文章，后来我意识到，尽管这篇文章很好地说明了 Kaggle 内核对于数据科学家来说是一个强大的投资组合，但它并没有说明一个完全的初学者如何开始使用 Kaggle 内核。
这是一次尝试，握住一个完全初学者的手，带他们走过 Kaggle 内核的世界——让他们开始。
享受 78%的 DataCamp 折扣
在 Kaggle 上注册—【https://www.kaggle.com/
如果你没有 Kaggle 账号，第一步是在 Kaggle 上注册。你可以使用你的谷歌账户或脸书账户创建新的 Kaggle 账户并登录。如果以上都不是，您可以输入您的电子邮件 id 和您的首选密码，并创建您的新帐户。
Kaggle Registration Page
登录 Kaggle
如果您已经有了一个帐户或者刚刚创建了一个帐户，请单击页面右上角的登录按钮启动登录过程。同样，你可以选择用你创建账户时输入的用户名和密码登录谷歌/脸书/雅虎或者最后一个。
Kaggle Login/Signin Screen
Kaggle 仪表盘
登录后，您将被带到 Kaggle 仪表盘。(只是欢迎页面，不知道还能叫什么，所以叫它仪表板)。
这是您登录后立即出现的登录页面(如果您从https://www.kaggle.com/登录)。它有许多组成部分，其中有几个:
- Kaggle 最近更新或推荐给您的 Kaggle 内核提要
- 个人资料摘要(右侧边栏的第一个)
- 招聘广告(右侧栏)
- 您的竞争对手(右侧栏—向下滚动后)
- 您的内核(右侧栏—向下滚动后)
我们接下来要去的地方是导航栏中顶部的内核按钮。
Kaggle 内核列表(最热门):
一旦我们在 Kaggle 旅程的任何地方点击顶部内核按钮，我们就会进入这个屏幕。
这是每个人都试图看到他们的内核的屏幕，因为这就像是内核的首页，这意味着如果它出现在这里，你的内核更有可能获得更多的可见性。内核页面的默认排序顺序是热度，这是基于 Kaggle 的秘密酱算法，以保持显示相关的内核，但它也有其他选项(排序)，如新，大多数投票等。Kaggle 也使用这个页面来宣传是否有任何内核竞争正在发生/将要发生。
当我们在这里时，内核竞赛是 Kaggle 竞赛，它不属于竞赛层，因为竞赛的性质是输出是 Kaggle 内核，并且更经常地专注于讲故事。《为好的数据科学》就是这样一系列核心竞赛之一，数据科学家/卡格勒希望利用数据科学帮助解决一个社会问题。为了更好地理解它，你应该看看内核大师 希瓦姆·班萨尔 的内核，他已经养成了多次赢得它们的习惯。
Kaggle 内核—新的/创建的:
现在，我们已经理解了 Kaggle 内核的元，我们可以直接进入新内核的创建。创建 Kaggle 内核有两种主要方法:
- 从 Kaggle 内核(首页)使用新的内核按钮
- 使用新内核按钮从数据集页面
方法#1:从 Kaggle 内核(首页)使用新内核按钮
正如你在上面的截图中所看到的，点击内核页面中的新内核按钮可以创建一个新的内核。如果您正在尝试练习自己的东西或计划输入自己的数据集，这种方法很好。如果你想为 Kaggle 上已经存在的数据集创建一个内核，这种方法是不可取的(在我看来)。
方法#2:使用新内核按钮从数据集页面
这是创建新内核最常用的方法之一(至少对我来说)。您可以打开您感兴趣的数据集的数据集页面(就像下面截图中的那个)，然后在那里单击新建内核按钮。这种方法的优点是，与方法#1 不同，在方法#2 中，创建内核的 Kaggle 数据集附带在内核中(默认情况下),从而使向内核输入数据集这一枯燥的过程变得更加容易、快速和简单。
https://www.kaggle.com/google/google-landmarks-dataset
Kaggle 内核—内核类型:
不管方法#1 还是#2，一旦你点击了新的内核，你将会看到这个模态屏幕来选择你想要创建的 Kaggle 内核的类型。
大体上分为两类——1 .剧本 vs . 2。笔记本。
众所周知，笔记本(基于单元格的布局)就是 Jupyter 笔记本，脚本就是你可能要编写的代码——py charm 或 Sublime Text 或 RStudio。此外，对于 R 用户来说，该脚本是 RMarkdown 的内核类型——这是从 R 以编程方式生成报告的一种很好的方式。
总结一下内核的类型:
- 脚本
- Python
- R
- RMarkdown
- **笔记本
*** Python ***** R
Kaggle 内核—内核语言:
第二级内核语言选择只发生在第一级内核类型选择之后。
如上面脚本类型的 Kaggle 内核的 GIF 图所示，内核的语言可以通过进入设置，然后选择所需的语言——R/Py/RMarkdown 来更改。相同的设置还提供了使内核共享公开的选项(除非公开，否则默认情况下是私有的)。如果你正在做你的大学作业或者自学，而你不想公开代码，那么通常使用私有内核。私有内核也被 Kaggler 使用，他们参与竞争以利用 ka ggle 的计算能力，但不透露他们的代码/方法。
笔记本内核:
类似于上面的 GIF，在选择了内核类型脚本的地方，也可以选择笔记本来创建笔记本内核。
RMarkdown 内核—(内核类型:脚本> RMarkdown)
RMarkdown 结合使用 R 和 Markdown 来生成嵌入了交互式可视化的分析报告。虽然这是解释 RMarkdown 的最简单的方式，但它的用途和潜力远远超出了定义。
幸运的是，Kaggle 内核脚本支持 Rmarkdown，这意味着它可以帮助创建交互式文档和更多在基于笔记本的场景中不可能实现的内容。这是一个由 Saba Tavoosi 在 Kaggle 内核上构建的成熟的交互式仪表盘，它不仅展示了 Kaggle 内核在构建机器学习模型方面的潜力，也展示了以最佳形式进行交互式讲故事的潜力。如果你有兴趣学习如何使用 flexdashboard 构建仪表盘，请查看本课程。
Kernel Courtesy: Saba Tavoosi
复制和编辑(以前称为分叉)
类似于 Github 中的 Fork 选项，如果你想获取一个现有的 Kaggle 内核并在你自己的空间中使用它——修改或赋予你自己的风格——你需要使用右上角的蓝色按钮Copy and Edit。事实上，在 Kaggle 竞赛赛道上的许多机器学习竞赛中，许多高分公共内核通常是forks of forks forks，其中一个 Kaggler 会改进其他 Kaggler 已经建立的模型，并将其作为公共内核提供。
Marked Symbol denotes a Forked / Copied and Edited Kernel
公共/私有内核
正如我们在前面另一节中看到的，Kaggle 内核的访问设置可以是公共的，也可以是私有的。公共内核(顾名思义)对每个人(包括 ka ggler 和非 ka ggler)都是可用的和可见的。私有内核只对拥有者(创建者)和与拥有者共享内核的人开放。公共内核也可以建立在私有数据集上。比方说，这是一场机器学习比赛，你已经用一些第三方数据做了一些特征工程，你不想在比赛期间透露这些数据。这是一个典型的场景，Kagglers 通常将他们的数据集保持私有，但将内核设为公共，这样其他人就可以看到他们的方法并从中学习。
上面的屏幕截图展示了如何将现有内核的访问设置更改为私有或公共。默认情况下，所有新创建的内核都是私有的(在撰写本文时)，如果需要，所有者可以将其更改为公共的。
TL；DR——如何创建新的 Kaggle 内核
如果上面的一切乍看起来有点太沉重而难以理解，这一节将帮助你创建你的第一个 Kaggle 内核。
步骤:
- 使用您的凭证登录 Kaggle
- 转到任何公共 Kaggle 数据集
- 点击右上角的新内核(蓝色按钮)
- 选择您感兴趣的笔记本/脚本
- 如果 Python 是您选择的语言，请保持原样，如果是 R，则转到右侧的设置并单击展开项目，您可以看到语言旁边的 Python ，您可以单击该语言以更改为 R
- 转到屏幕的编辑器部分/窗格(左侧),开始编写漂亮的代码(上面的 GIF 也说明了如何使用创建内核的数据集)
- 一旦您的代码完成，点击右上角的提交(蓝色按钮)
- 如果您的内核执行成功(没有任何错误)，公开您的内核(通过编辑内核设置>共享(公共)或者通过再次打开内核并点击顶部的访问按钮)
- 在这个阶段，你的第一个 Kaggle 内核必须准备好通过你的网络与你的朋友分享！
查看此 Kaggle 视频寻求帮助。
结局
对于许多 ka ggler 来说，竞赛赛道是他们的乐趣所在，但对我来说，Kaggle Kernels 赛道是我的事情，它为我们提供了完成全栈数据科学之旅的巨大潜力，从数据准备到数据可视化——从机器学习建模到讲故事。希望你也会喜欢。祝你的 Kaggle 内核之旅好运。
在我的 Kaggle 个人资料 查看我的 Kaggle 内核，并在 我的 Linkedin 个人资料 与我分享您的反馈。本教程使用的视频/gif/截图可在my github上获得。
ka ggle vs . Colab face off——哪个免费 GPU 提供商是 Tops？
规格，UX，以及 fastai 和混合精度训练的深度学习实验
谷歌有两款产品可以让你在云中免费使用 GPU:Colab 和 Kaggle。如果你对深度学习和人工智能感兴趣，它们会非常棒。本文的目标是帮助您更好地选择何时使用哪个平台。
Kaggle 刚刚获得了 Nvida 特斯拉 P100 图形处理器的速度提升。🚀然而，正如我们将在计算机视觉实验中看到的，Colab 的混合精度训练有助于缩小速度差距。* * 2019 年 4 月 25 日更新— Colab 现在有了 Nvidia T4s。对于混合精度来说，它们真的很快。另外，随着硬件的改进，我不打算继续更新这篇文章。😄**
在本文中，我们将向您展示如何比较硬件规格和探索 UX 的差异。我们还将把计算机视觉任务的训练时间与迁移学习、混合精度训练、学习速率退火和测试时间增加进行比较。
我们开始吧！👍
Twin peaks Colab and Kaggle, side by side in the Google range
Kaggle 和 Colab 是相当相似的产品。卡格尔和科拉布
- 提供免费的 GPU
- 在浏览器中提供 Jupyter 笔记本——尽管有他们自己独特的风格
- 旨在促进机器学习的合作。
- 是谷歌的产品
- 并不完美，但在许多情况下非常有用——尤其是当你开始深度学习的时候。😄
- 不要提供关于他们硬件规格的大量信息
最后一点我们一会儿会深入探讨。不幸的是，当你使用他们的环境时，Kaggle 和 Colab 都不会告诉你确切的规格。确实存在的文件往往已经过时(见此处截至 2019 年 3 月 11 日)。此外，屏幕上的小部件讲述了一些故事，但与我发掘的不同。我将向您展示常见的 profiler 命令，您可以使用这些命令来查看您的环境规格。
首先，简单介绍一下 GPU 的背景——如果这是老一套的话👒对你来说，请随意跳过前面。
什么是 GPU？
GPU 是图形处理单元的简称。GPU 是专门的芯片，最初是为了加速视频游戏的图形而开发的。他们快速地做许多矩阵计算。对于深度学习应用来说，这是一个非常方便的特性。有趣的事实:出于同样的原因，GPU 也是加密货币挖掘的首选工具。
Nvidia P100 GPU
为什么要用 GPU？
使用具有足够内存的 GPU 使训练深度学习网络的速度比单独使用 CPU 快很多倍。因为在几分钟或几小时内而不是几天或几周内获得反馈要好得多，所以如果你对深度学习感兴趣，你会想要使用 GPU。毫无疑问。😃
规范
截至 2019 年 3 月初，Kaggle 已经将其 GPU 芯片从 Nvidia Tesla K80 升级为 Nvidia Telsa P100 。Colab 还是给你一个 K80。关于 Nvida 芯片类型的简要讨论，请参见我的文章比较云 GPU 提供商这里。
有很多不同的方法可以找到你的硬件信息。两个有用的命令是用于 GPU 信息的!nvidia-smi和用于 CPU 信息的!cat /proc/cpuinfo。即使你想用 GPU 训练你的模型，你也仍然需要一个 CPU 来进行深度学习。
每当您在 Jupyter 笔记本代码行的开头使用感叹号时，您都在运行一个 bash 命令。这是我写的关于 bash 命令的文章，包括cat，如果你想知道更多关于它们的信息。
请看这张谷歌表中我在下面的快照中编辑的规格。
内存和磁盘空间很难衡量。一旦 Colab 和 Kaggle 安装了他们的软件并启动了他们的程序，总数就无法得到了。下面是对!cat /proc/meminfo profiler 命令与 Colab 和 Kaggle 小部件之间内存差异的分析。
Total 是总内存。可用是在没有额外运行进程的情况下启动后观察到的可用内存量。您可以看到，分析的数量很接近，但是与 Colab 和 Kaggle 小部件中显示的数量不完全一致。
Mouseover in Colab
Kaggle Sidebar
这里有一个 Kaggle 内核，这里有一个 Colab 笔记本，上面有命令，所以你可以在你自己的环境中查看规格。确保首先启用 GPU 运行时，如本文末尾所示。
请注意，来自命令分析器的 GPU 规格将以兆字节为单位返回，这与兆字节几乎相同，但不完全相同。兆字节可以通过谷歌搜索转换成兆字节——只需输入标记的数量进行转换。谷歌无处不在——不是吗？😄
Kaggle 小部件显示的磁盘空间也比我们看到的报告少得多。Kaggle 可以限制您在当前工作环境中可以使用的磁盘空间，而不管理论上有多少可用空间。
Kaggle 在他们的文档中声明你有 9 个小时的执行时间。然而，内核环境在屏幕右侧的小部件中显示每个会话最多 6 小时。注意，重启内核会重启时钟。Kaggle 还会在 60 分钟不活动后重新启动您的会话。
Colab 给你 12 小时的执行时间，但是如果你空闲超过 90 分钟，它也会把你踢出去。
让我们来看看最重要的问题:在这些平台上进行一些深度学习需要多长时间！
计算机视觉速度比较
我在一个深度学习图像分类任务上对比了 Kaggle 和 Colab。目标是预测一张图片是猫还是狗。该数据集由 25，000 张图片组成，猫和狗的数量相等。该数据集被分成 23，000 个用于训练的图像和 2，000 个用于验证的图像。数据集可以在 Kaggle 这里获得。
Cat and dog images from the dataset
我使用 FastAI 库构建了一个卷积神经网络，并使用 ResNet30 的迁移学习对其进行了训练。该模型使用了几个技巧进行训练，包括数据扩充和学习速率退火。对测试集的预测是通过增加测试时间来实现的。代码改编自这个 FastAI 的例子。
Kaggle 内核可以在这里访问，Colab 笔记本可以在这里访问。批量大小设置为 16，FastAI 版本为 1.0.48。对 FastAI 的内置分析器报告的几个训练阶段和一个预测阶段的时间进行求和。
Note that the y-axis does not start at 0.
在所有情况下，验证集的准确性都超过 99%。三次迭代的平均时间在 Kaggle 上是 11:17，在 Colab 上是 19:54。Kaggle 运行时环境比 Colab 环境快 40%。
批量
为了在 Kaggle 中成功运行图像分类，我不得不将批量大小从 64 个图像减少到 16 个。较大批量的错误似乎是由 Docker 容器中的共享内存设置得太低引起的。有趣的是，我在 2018 年末向谷歌 Colab 提出了这个确切的问题——他们在一周内就解决了这个问题。截至 2019 年 3 月中旬，Kaggle 的同一问题仍未解决。
接下来，我用上面在 Colab 上使用的相同代码运行了两次迭代，但是将批处理大小改为 256。这一变化导致平均运行时间为 18:38。Colab 中批处理大小为 64 的两个额外迭代导致平均时间为 18:14。因此，Colab 降低了批量大于 16 的时间。
尽管如此，较小的批量在这个任务中并不是一个大问题。各种各样的批量参数通常都很有效——关于讨论，请参见这篇论文、这篇文章和这篇 SO 回答。
当我在批量大小为 256 的 Colab 上训练模型时，出现了一个警告，说我正在使用我的 11.17 GB GPU RAM 的大部分。见下文。
这个警告很好，但是由于上面讨论的分析练习，我了解了 Gibibytes 和 Gigabytes 之间的区别。我们之前看到 Colab GPUs 拥有 11.17 千兆字节(12 千兆字节)的 RAM。因此，与警告所说的相反，我们实际上有 12gb 的 RAM 可以使用。尽管如此，如果内存不足，那就是内存不足。😃因此，对于这些图像大小、默认的工作线程数和 32 位精度数，看起来批处理大小 256 是最大值。
混合精确训练
然后，我尝试了混合精度训练，以减少训练时间。混合精度训练意味着在计算中尽可能使用 16 位精度数，而不是 32 位精度数。Nvidia 声称使用 16 位精度可以产生两倍于 P100 的吞吐量。
点击了解混合精度 FastAI 模块。请注意，在使用测试时间增强进行预测之前，您需要将 FastAI 学习者对象切换到 32 位模式，因为 torch.stack 还不支持半精度。
通过在 Colab 上使用混合精度训练，我能够在批量为 16 的情况下实现 16:37 的平均完成时间。我测试了两次。所以我们在减少时间。
然而，混合精度训练将 Kaggle 上的总时间增加了一分半钟，达到 12:47！其他规格没有变化。所有地方的验证集准确率都保持在 99%以上。
Note that the y-axis does not start at 0.
我发现 Kaggle 的默认包包括稍微老一点的 torch 和 torchvision 版本。将软件包更新到 Colab 使用的最新版本对培训时间没有影响。总的来说，我注意到 Colab 上的默认包比 Kaggle 上的更新更快。
上面提到的硬件差异似乎不太可能导致 Kaggle 上观察到的性能下降。观察到的唯一软件差异是 Kaggle 运行 CUDA 9.2.148 和 cuDNN 7.4.1，而 Colab 运行 CUDA 10.0.130 和 cuDNN 7.5.0。
CUDA 是 Nvidia 的 API，可以直接访问 GPU 的虚拟指令集。cuDNN 是 Nvidia 基于 CUDA 构建的深度学习原语库。据英伟达的这篇文章称，Kaggle 的软件应该能提升 P100 的速度。然而，正如在 cuDNN 更改注释中看到的，阻止加速的 bug 会定期被发现并修复。
还得等 Kaggle 升级 CUDA 和 cuDNN，看看混合精度训练是不是变快了。目前，如果使用 Kaggle，我仍然鼓励你尝试混合精确训练，但它可能不会给你带来速度提升。如果使用 Colab，混合精度训练应该与批量相对较小的 CNN 一起工作。
让我们看看使用 Colab 和 Kaggle 的其他方面。
UX
谷歌是一家希望你为你的 GPU 付费的企业，所以不应该指望它免费赠送农场。🐖
Colab 和 Kaggle 有令人沮丧和缓慢的方面。例如，两个运行时断开连接的频率比我们希望的要高。然后，您需要在重启时重新运行您的笔记本。😦
在过去，甚至不能保证你会得到一个 GPU 运行时。看起来他们现在总是有空。如果您发现没有，请在 Twitter @discdiver 上告诉我。
让我们来看看科 lab 和 Kaggle 的优缺点。
科拉布
赞成的意见
- 可以将笔记本保存到 Google Drive。
- 您可以向笔记本单元格添加注释。
- 与 GitHub 的良好集成——你可以直接将笔记本保存到 GitHub repos。
- Colab 有免费的 TPU。TPU 类似于 GPU，只是速度更快。TPU 是谷歌自己定制的芯片。不幸的是，TPUs 与 py torch,还不能顺利工作，尽管计划集成两者。如果实验是用 TensorFlow 而不是 FastAI/PyTorch 编写的，那么使用 TPU 的 Colab 可能会比使用 GPU 的 Kaggle 更快。
骗局
- 在 Colab 中，一些用户的共享内存限制很低。似乎至少有一个用户的问题已经解决(此处讨论为)。
- 使用 Google Drive 有点痛苦。您必须验证每个会话。此外，你不能很容易地解压驱动器中的文件。
- 键盘快捷键和普通的 Jupyter 笔记本有不同的绑定。如果你想知道这种情况是否会改变，下面是 GitHub 的第期。
现在我们来看看 Kaggle 的利弊。
卡格尔
赞成的意见
- Kaggle 社区非常适合学习和展示你的技能。
- 把你的工作交给 Kaggle 会创造一段美好的历史。
- 许多 Jupyter 笔记本的键盘快捷键完全可以转移到 Kaggle 环境中。
- Kaggle 有许多数据集可以导入。
骗局
- Kaggle 通常会自动保存你的工作，但如果你不提交，然后重新加载你的页面，你可能会发现你失去了一切。这不好玩。😦
- 如上所述，Docker 容器中的 PyTorch 共享内存在 Kaggle 中较低。当批量大于 16 张图像时，这导致图像分类任务的
RuntimeError: DataLoader worker (pid 41) is killed by signal: Bus error.。 - Kaggle 内核通常看起来有点滞后。
我不知道有其他云提供商提供免费的 GPU 时间(除了入门学分)，所以这次讨论并不是对谷歌的批评。感谢免费的 GPU，谷歌！👍如果你知道其他人有免费的(不仅仅是介绍性的)GPU 资源，请告诉我。
结论
Colab 和 Kaggle 都是在云中开始深度学习的绝佳资源。我发现自己在使用这两个平台。你甚至可以在两者之间下载和上传笔记本。😄
看到 Colab 和 Kaggle 增加更多的资源令人兴奋。在我们研究的图像分类任务中，使用 P100 GPU，Kaggle 在训练和预测方面肯定比 Colab GPU 更快。如果你正在运行一个密集的 PyTorch 项目，并希望提高速度，那么在 Kaggle 上开发它是值得的。
如果你想更灵活地调整批量大小，你可以使用 Colab。使用 Colab，您还可以将您的模型和数据保存到 Google Drive，尽管这个过程可能会有点令人沮丧。如果您使用 TensorFlow，您可能希望在 Colab 上使用 TPUs。
如果你需要更多的能力或更多的时间来运行更长时间的进程，我之前的实验表明谷歌云平台是最具成本效益的云解决方案。
我希望您发现 Colab 和 Kaggle 的这一比较很有用。如果你有，请分享到你最喜欢的社交媒体频道，这样其他人也可以找到它。👏
我撰写关于 Python、开发运营、数据科学和其他技术主题的文章。如果你对这些感兴趣，请查看并跟随我到这里。
快乐深度学习！
Head down either path you like 😄
卡尔曼滤波器(1)——基础知识
自动驾驶汽车本地化的基础知识
我试图学习卡尔曼滤波器，一种结合你的猜测和一些不确定的测量值并做出更好的估计的方法，并发现没有这样容易理解的话题。但是后来，我遇到了这个课程，它从最基本的方面介绍了这个想法。所以在这篇文章中，我将按照课程中的结构，简单介绍一下自动驾驶汽车定位的基础知识，这也是卡尔曼滤波器的起点。
问题设置
在自动驾驶汽车定位中，通常有两个组成部分— 第一个是运动，当汽车踩下油门时，我们肯定可以估计(猜测)它可以走多远，第二个是测量，安装在汽车上的传感器能够检测环境并测量它的位置。现在问题来了，我们的估计(猜测)和传感器测量都可能不准确，结合这两个不确定的因素，我们是否仍然能够对汽车的位置做出猜测，甚至做出更好的猜测？
答案是肯定的，让我们来看一个具体的例子，看看如何用基本的统计学来解决这个问题:
感觉
假设我们的汽车行驶在一维世界中，那里只有 5 个网格和 2 种不同的颜色——绿色和红色。一开始，我们的汽车有相等的概率停留在 5 个网格中的任何一个，它也有一个传感器Z，它检测世界的颜色，然而，传感器并不总是正确的，当传感器说网格是red时，我们给red一个较高的权重pHit = 0.6，给green一个较低的权重pMiss = 0.2(这里我们使用权重，事实上当加起来是 1 时，它可以归一化为概率)。现在的问题是，当我们的传感器Z = red，我们的车的位置的概率是多少？
解决方案很简单，我们的传感器看到的网格是red，所以它更有可能在第二个和第三个单元格中。对于红细胞，我们给出较高的权重，绿色细胞给出较低的权重:
最终概率需要归一化，以便加起来等于 1。运行这个程序，我们得到的结果是:
array([0.11111111, 0.33333333, 0.33333333, 0.11111111, 0.11111111])
显然，第二个和第三个单元比其余单元具有更高的概率。
事实上，其背后的统计数据是贝叶斯法则:
以cell 2(X_2)中的概率为例，结合公式(2)和(3)，可以很容易地计算出概率为:
0.2*0.6 / (0.2*(0.2+0.6+0.6+0.2+0.2))
分母是一个规格化器，对于上面代码中对应于sum(combine_prob)的每个单元格都是一样的。
现在我们能够在感知环境后计算后验概率，让我们移动汽车，看看它如何影响定位。
移动
在这个水平的 5 格世界中，我们的汽车能够以定义为U的步数左右移动。然而，它可能不准确地移动到不期望的单元，并且移动概率具有如下分布:
它有 0.8 的几率正确移动，0.1 的几率比原计划多移动一步，0.1 的几率短移动一步。现在的问题是给一个先验分布p(每个单元格内的概率)，走一步U后验概率q是多少？
让我们看一个例子:
假设我们的车被指示移动 1 步，那么在 3 号单元格落地的概率是多少？
我们反过来考虑问题:移动 1 步后，汽车会在什么场景下降落在 3 号单元格？它可以从小区 2 以概率 0.3 正确移动，从小区 3 以概率 0.1 下冲，从小区 1 以概率 0.1 上冲。
这里的统计称为总概率:
到达X_j的概率等于从每个可能的小区X_i开始的概率之和乘以从X_i移动到X_j的概率。
注意这里的U大于单元总数n，汽车将循环回到步骤U % n。
结合在一起
现在我们有了两个最重要的部分——感知和移动，我们的车已经准备好移动了。过程如下:汽车感知环境→移动→感知环境→移动，…
在本例中，我们的汽车从均匀分布开始，有 2 次连续测量red和green，每次移动 1 步。我们得到最终概率:
[0.21157, 0.15157, 0.08105, 0.1684, 0.3873]
所以经过一系列步骤后，它最有可能以 0.3873 的概率落在最后一个单元格。
参考:
卡尔曼滤波器(2) —网格世界定位
将基础知识应用于二维空间
在上一篇文章中，我们应用了基本的贝叶斯规则和全概率来定位一维世界中的一辆移动的汽车。让我们加强我们的理解，并将它们应用到二维世界中。
问题设置
考虑一个二维世界，机器人只能向左、向右、向上或向下移动。它不能斜向移动。此外，对于这个任务，机器人永远不会越过它的目的地广场；它要么运动，要么保持静止。
对于每个运动，它遵循:
并且测量和运动被设置为:
该设置表示，在这个 3x3 的世界中，有两种不同的颜色——绿色和红色。机器人在每个单元中以相等的概率开始，测量值为R，传感器有概率0.8是正确的。然后机器人做一个动作[0, 0]，保持静止，这个动作有一个概率1.0被正确执行。问题是机器人在每个细胞中的当前概率是多少？
履行
初始化
最初，每个单元具有相等的概率:
感觉
基于传感器的测量值(测量概率)和初始概率(先验概率)，应用贝叶斯规则，我们可以得到后验概率。
移动
在运动中，我们应用全概率，
也就是说，每个单元的概率等于它来自的单元的概率和转移概率的乘积。
这里的情况更简单，因为机器人只能移动或保持静止((i, j)是当前小区，(i-U[0], j-U[1])是它移动的小区)。
本土化
现在让我们组装零件:
相应地，我们得到的结果是:
[[0.06666667 0.06666667 0.06666667]
[0.06666667 0.26666667 0.26666667]
[0.06666667 0.06666667 0.06666667]]
所以在测量和动作之后，机器人最有可能待在牢房(1, 1) or (1, 2)。
更多完整的测试，请点击查看的完整实现。
参考:
卡尔曼滤波器(3)——连续状态空间中的定位
将高斯分布应用于连续状态空间
在过去的会议中，我们尝试在网格世界中进行定位，在网格世界中，我们的机器人有不同的概率位于不同的单元中。总之，状态空间是离散的。为了将问题设置推广到连续状态空间，我们将到达卡尔曼滤波器的核心。
在我们讨论卡尔曼滤波器的任何细节之前，请记住我们在这里学到的东西，卡尔曼滤波器总是有两个步骤:
- 传感(测量):基于机器人所看到的，更新后验分布
- 移动(预测):估计机器人移动后的新位置
以下是的结构:
- 扩展到连续状态空间的想法
- 用高斯分布实现 sense(测量)
- 用高斯分布实现移动(预测)
- 结合在一起
- 多维卡尔曼滤波器
原则
在离散世界中，每个状态都有一个单独的概率，其总和为 1，将其扩展到连续状态空间的关键是找到一个连续的分布，而在卡尔曼滤波器中，该分布是高斯分布。
这就是说，无论是步进测量还是预测，我们对机器人位置的估计总是符合高斯分布。高斯的两个参数分别代表:
μ:机器人位置最可能的估计σ:检测器和预测的不精确等造成的我们估计的不确定性。
任务是在一系列测量和预测之后，找到最终的高斯分布参数μ和σ。让我们把它分成两部分。
测量(感觉)
在测量阶段，我们根据机器人的传感器更新我们的信念。假设X是位置Z是测量(机器人观察到的)，我们正在解决的问题是:
我们之前的信念是p(X)，但是我们的传感器看到的分布p(Z|X)不同，现在我们正在尝试计算我们的后验分布p(X|Z)，这是给定的我们所看到的(Z)，我们现在的最佳估计是什么？
请记住，这里所有的分布都是高斯分布，为了得到后验分布，我们只需要应用贝叶斯规则，即将这两个分布相乘:
以上是更新分布的参数。注意σ_new比σ和γ都小！这告诉我们，倍增后不确定性降低了，这符合我们的知识，即传感实际上是获取信息和降低不确定性。实施将是:
预测(移动)
移动是直接向前的加法。初始分布N(μ, σ)，移动不确定度U``γ^2，移动后的分布为N(μ+U, σ^2+γ^2)，即均值加U，不确定度加γ^2。
注意，通过进行不确定的运动，方差(不确定性)增加，这与减少方差(不确定性)的测量相反。
1D 卡尔曼滤波器
现在结合测量和预测，我们得到:
在这个例子中，我们设置了初始位置mu = 0和不确定度sig = 10000，这意味着我们对机器人的初始位置非常不确定。经过几轮迭代，我们得到了结果:
我们看到，通过进行第一次测量，不确定性立即下降到3.998，它小于初始方差和测量方差。最后，我们用方差4.0058预测我们的机器人在位置10.9999着陆。
多维卡尔曼滤波器
在上面的例子中，我们只有一个变量，即位置p。现在让我们考虑第二个变速v，然后我们的任务将是得到x = (p, v)和不确定矩阵P = cov(x)的最终估计。
预言；预测；预告
在预测阶段，假设我们有以下关系:
from reference
给定速度和时间t，我们可以得到下一个位置，我们假设的速度保持不变。然后我们得到了它的矩阵形式:
这里F称为状态转移矩阵，P为协方差矩阵，μ为外部运动矢量(比如有加速度或踏板油门)。
尺寸
测量也是一样，有一个测量转移矩阵H。以最简单的形式，让我们假设H = (1, 0)和，
μ_0 = Hx = (1, 0)(p, v)^T = p
这就是说，我们的测量只能测量机器人的位置，而看不到速度。现在问题变成我们有两个高斯分布，一个是(先验分布):
第二个是(测量分布):
看起来很熟悉我们之前的例子，对吧？现在我们需要将这两个分布组合成后验分布。这里涉及到一系列的推导(一个精彩的解释这里，我把结果放在这里:
现在让我们将它们结合在一起，得到最终的卡尔曼滤波函数:
完整的实现，请点击查看。
参考:
- https://classroom.udacity.com/courses/cs373
- https://www . bzarg . com/p/how-a-Kalman-filter-works-in-pictures/
分类策略的美丽视觉模型解读——卡纳达语 MNIST 数字识别
此处为副标题
Kannada handwritten digits
卡纳达语 MNIST 数据集是一个很棒的近期作品(细节在此)，我很高兴它也对公众开放。我相信很快这里的社区就会在这个数据集上发布最先进的准确性数据。所以，我在做一些不同的事情。
相反，我们将尝试可视化，尝试看到模型所看到的，逐个像素地评估事物。我们的目标是可解释性。在本文中，我将从“最简单的”、最容易解释的算法开始。希望我会在后面的文章中公布其他建模技术的结果。
重申并澄清:我不会专注于获得最佳表现。相反，我将着重于可视化输出，理解模型的意义，并理解它失败的地方和原因。当模型运行得不太好时，评估哪个更有趣。😃
可视化数字数据
函数绘制一个随机数字及其标签
def plot_random_digit():
random_index = np.random.randint(0,X_train.shape[0])
plt.imshow(X_train[random_index], cmap='BuPu_r')
plt.title(y_train[random_index])
plt.axis("Off")plt.figure(figsize=[2,2])
plot_random_digit()
A random Kannada digit plotted as image
一口气看 50 个样本
plt.figure(figsize=[10,6])
for i **in** range(50):
plt.subplot(5, 10, i+1)
plt.axis('Off')
if i < 10:
plt.title(y_train[i])
plt.imshow(X_train[i], cmap='BuPu_r')
作为一个不擅长阅读卡纳达文字的人，对我来说这些符号看起来有些相似
- 第三和第七条
- 第 6 和第 9 条
在开始时，我期望这些预测者在这两对之间会有些混淆。尽管这不一定是真的——也许我们的模型能比我更好地识别数字。
重塑数据集以构建预测模型
个别例子是 28 X 28。对于 scikit learn 中的大多数预测建模方法，我们需要将示例展平为 1D 数组。
我们将使用 numpy 数组的整形方法。
X_train_reshape = X_train.reshape(X_train.shape[0], 784)
X_test_reshape = X_test.reshape(X_test.shape[0], 784)
建立和理解逻辑回归模型
让我们为我们的多类分类问题建立一个逻辑回归模型。
请再次注意，我们不会关注获得最佳性能，而是关注如何理解模型所学的内容。
逻辑回归模型将很容易和有趣地分析系数，以了解模型学到了什么。
在 SciKit-learn 中，可以通过多种方式制定多类分类。他们是-
- 一对休息
- 多项式
1。一人 vs 其余:
也称为一对一，这种策略包括为每个类安装一个分类器。对于每个分类器，该类与所有其他类相匹配。这种方法的一个优点是它的可解释性。
因为每个类仅由一个分类器表示，所以可以通过检查相应的分类器来获得关于该类的知识。这是多类分类最常用的策略，也是一个公平的默认选择。
对于我们的例子，这意味着构建 10 个不同的分类器。
2。多项式:
在此策略中，我们使用线性预测器对看到给定输出的概率的对数进行建模。
对于multinomial，最小化的损失是整个概率分布的多项式损失拟合。softmax 函数用于查找每个类别的预测概率。
在这里阅读更多相关内容:
https://en . Wikipedia . org/wiki/Multinomial _ logistic _ regression # As _ a _ log-linear _ model
注意:这种区别很重要，需要你为模型解释不同的系数。
首先，让我们使用 One vs. Rest 方案来构建我们的模型
from sklearn.linear_model import LogisticRegression
lr1 = LogisticRegression(solver="liblinear", multi_class="ovr")
*# Fitting on first 10000 records for faster training*
lr1.fit(X_train_reshape[:10000], y_train[:10000])
评估列车组的性能
模型对训练数据的预测
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report
y_train_pred = lr1.predict(X_train_reshape[:10000])cm = confusion_matrix(y_train[:10000], y_train_pred[:10000])
plt.figure(figsize=[7,6])
sns.heatmap(cm, cmap="Reds", annot=True, fmt='.0f')
plt.show()
那可是非常高的训练准确率！过度拟合？
还有，看起来模型是不是在 3 和 7，6 和 9 之间非常混淆，至少在火车布景上不是。
错误分析:检查错误分类的案例
为了便于索引，我们将转换到熊猫系列，隔离错误分类的案例，绘制一些示例。
11 例分类错误
- 研究一些案例
- 选择 9 个随机案例——我们将绘制数字，以及真实和预测的标签
The mis-classified cases
你能看出为什么这个模型是混乱的吗？让我们看看模型在测试集上表现如何。
测试集上的混淆矩阵
对测试数据进行预测，并绘制混淆矩阵。
Confusion Matrix on test set — smells like over-fitting
看着混乱矩阵和分类报告-
3、7 的回忆最少—模型明显混淆了它们。同样，4 和 5 之间也有混淆。还有，很多 0 被误认为 1 和 3。
好吧！所以看起来在测试集上性能急剧下降。很有可能我们在列车上过度适应了。
我们承认这一模式可以改进。
但是，我们现在先不要担心这个。让我们关注理解模型所学内容的方式。
模型解释
了解每个像素的贡献
我们现在学习的每个像素的系数都是基于一对静止方案的。
让我们继续分析我们的 OVR 模型的系数。
系数 lr1.coef_ 的形状。“形状”是(10。784)，即每个标签有 784 个系数——每个数字的每个像素有 784 个系数！
正系数意味着该像素上的高值增加了该标签的机会，与所有其他类相比。因此，系数告诉我们这个像素如何将这个标签与所有其他标签区分开来。
提取像素系数并绘制在标签 0 的热图上
plt.figure(figsize=[3,3])
coefs = lr1.coef_[0].reshape(28,28)
plt.imshow(coefs,cmap="RdYlGn",vmin=-np.max(coefs),vmax=np.max(coefs)) *#setting mid point to 0*
plt.show()
Heatmap for 0 — OVR
我用了一种不同的颜色来区分正负符号。
在上图中，绿色像素是正值像素。图像告诉我们，某些像素中的值有助于将数字归类为 0。不出所料，中间的红色表示该范围内的值意味着该数字为零的可能性较低。黄色接近于 0，这意味着像素对区分没有任何帮助。
制作所有数字的像素热图
Heatmap — all digits — OVR scheme
好好看看这些热图。这将揭示模型已经学习了什么。请注意，我们有“一与其余”的公式，特别是在与其他数字的热图进行比较时。
现在，让我们使用多项式方案建立一个模型。
- 我们需要将
multi_class参数指定为“多项式” - “liblinear”解算器不支持这一点，所以我们选择“sag”解算器。
lr2 = LogisticRegression(random_state=42, multi_class="multinomial", solver="sag")
lr2.fit(X_train_reshape[:10000], y_train[:10000])
在测试集上评估性能
绘制混淆矩阵
了解每个像素的贡献
每个标签有 784 个系数——每个像素的系数。
现在，一个正的系数意味着是什么使得这个标签成为现在这个样子！但是，如果 3 个标签在特定像素中具有相似的存在，则所有 3 个标签的系数可能具有相似的值。
提取像素系数并绘制在标签 0 的热图上
这与 OVR 模型的热图有多不同/相似？
让我们制作所有像素的热图。
为所有数字制作这样的像素热图
这些热图与每个标签的平均图像相比如何？
绘制每个数字的平均图像。
plt.figure(figsize=(10, 4))
for i **in** range(10):
plt.subplot(2,5,i+1), plt.title(i)
plt.imshow(np.mean(X_train[y_train==i],axis=0),cmap='gray')
plt.suptitle('Mean images for each digit')
把它们都画在一起——好好看看。
Mean images vs. OVR vs. Mutinomial
锻炼-
你已经看到了 OVR 方法和多项式方法的热图。你也有每个标签的平均图像。
- 将热图与平均图像进行比较和对比。
- 你认为这是怎么回事？你能试着理解每个数字的模型都学到了什么吗？
- 为什么模型在某些数字上表现不佳？热图有助于理解吗？
对于那些有兴趣尝试更多东西的人来说
我建议你试试下面的-
- 使用带有正则化(ridge、lasso、elasticnet)的逻辑回归和使用交叉验证的超参数优化来减少过度拟合。
- 利用奇异值分解/主成分分析对原始数据进行去噪和重构；接下来是一个优化的逻辑回归模型。
好了，这就是我们这里的小演示！我将很快分享更多不同建模技术的演示，解释它们的方法，以及更多使用监督和非监督技术的相同数据集的实验。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
