你的机器学习模型还能准确预测吗？
使用直接比率来衡量“模型漂移”——以比特币价格为例
塞尔吉奥·马丁内斯在 Unsplash 上的照片
当我们建立一个机器学习模型时，我们以各种方式验证和测试它的准确性/性能。虽然在测试集中准确率相当高，但是预测最终会随着时间漂移。这通常是由于将来的数据“漂移”到与训练数据集不同的状态。但是我们如何有效地检测这种漂移呢？这篇博文展示了使用直接比率估计来检测比特币每日价格数据的变化点。
这篇文章的代码可以在我的 GitHub repo 上找到。
目录
1。变化点检测概念
2。直接比率(KL 散度和相对无约束最小二乘重要性拟合)估计
3。比特币价格数据示例
3.1。比特币及其数据简介
3.2。应用 KL 散度估计来检测状态变化
3.3。使用 Bolinger 带的状态变化阈值
4。结论和后续步骤
5。参考文献
- 改变点检测概念
正如我上面提到的，变化点检测(CPD)基本上是试图发现时间序列序列的不相似性。
刘等(2013)将 CPD 问题定义为测量两个连续子序列 y(t) 和 *y(t+n)之间的差异。*这些子序列有一定时间段的窗口 k 来评估。下图展示了 PCD 的概念。
来自刘等人(2013)的 PCD 概念图像
例如，假设上图中的“a”是 2020–04–01，那么“b”是 2020–04–02，“c”是 2020–04–03，以此类推。同样设窗口‘k’为图中的 3，则 Y(t)包含 a、b 和 c，Y(t+1)包含 b、c 和 d，包含从 2020–04–02 到 2020–04–05。设 n = 2，则 y(t) 是由 y(t)和 Y(t+1)组成的子序列。我们想知道由 from Y(t+n)=[2020–04–06，2020–04–08]和 Y(t+n+1)=[2020–04–05，2020–04–07]组成的 y(t) 和 y(t+n) 的不同之处。
这也可以通过使用统计假设检验来正式化(Harchaoui 等人，2009)。
H _ 0:y(t)= y(t+1)= y(t+2)=…= y(t+n-1)= y(t+n)
H_1:存在 1 个< k 个< n 使得
y(t)= y(t+1)=……= y(t+k)≠y(t+k+1)=……= y(t+n-1)= y(t+n)
以上是对 CDP 概念的简单介绍。下一节将介绍我们如何计算直接比率估计值。
2。直接比率(KL 散度和相对无约束最小平方重要性拟合)估计
这里我们将讨论这两种直接比率估计方法。首先，给定概率分布 p(x)和 p’(x)的著名的 KL 散度方程可以表示如下。
KL 散度是非负的和非归一化的度量，例如KL[p(x)| | p '(x)]in[0，inf+) 。较高的值表明这些概率分布更远。
在我们讨论相对无约束最小二乘重要性拟合之前，让我们先来看看无约束最小二乘重要性拟合(uLSIF)。这使用皮尔逊(PE)散度如下。
然而，根据 p’(x)的条件，PE 散度值可以是无界的。为了克服这个性质，RuLSIF 将凸组合引入到第二个给定的概率分布中，可以表示如下。
，其中0≤𝛂**<1***。***
当取凸组合时，RuLSIF 的计算值总是有界的。
当我们计算上述值时，窗口的长度也是这种方法的关键点之一。当您将窗口设置得较小时，它对变化更敏感。它可以快速检测甚至很小的变化，但是也可以捕获假阳性情况，例如变量的暂时漂移。另一方面，当你设置一个更大的窗口时，它的估计会更稳定，得到更少的假阳性情况。然而，实际检测状态变化需要一段时间。因此，找到合适的窗口来使用这种方法至关重要。如果即使是很小的状态变化对机器学习模型预测也是至关重要的(例如，基于最小值的股票价格预测)，那么使用较小的窗口更合适。如果你的机器学习模型没有受到影响或者可以容忍很小的状态变化，那么最好应用更大的窗口。
由于 KL 散度和 RuLSIF 值都没有归一化，也没有正式的阈值，因此有必要决定如何使用这些值来检测变化点。例如，我们可以应用 95%的置信区间。，2007)，还有一些更像金融技术分析工具的东西——比如说博林格带和移动平均线。使用适当的决策规则来发现状态变化是非常重要的。
下一节将展示如何使用这些直接比率估计方法来检测比特币价格数据的状态变化的示例。
3。比特币价格数据示例
安德烈·弗朗索瓦·麦肯齐在 Unsplash 上的照片
3.1 比特币及数据简介
那么比特币是什么？比特币是目前最受欢迎的去中心化虚拟货币。它的价格仅仅由供求关系决定(来自bitcoin.org)。所以简单来说，当对比特币的需求高时，比特币的价值增加，然后需求低时，价值降低。此外，比特币的数量是有限的，并将以可预测的递减速度新创造出来，这意味着为了保持比特币价格稳定，它需要有轻微的通货膨胀。此时此刻，由于市场容量与其可能达到的规模相比仍然相对较小，比特币的价格波动很大——与股票市场相比，它相对更容易受到需求的影响。
现在我们来看看比特币的数据。数据是从 CoinMarketCap 中检索的。它包括 2013 年 4 月 29 日至 2020 年 3 月 28 日的日期、开盘价、最高价、最低价、收盘价、成交量和市值(所有价格均以美元计)。在这篇文章中，我们将使用接近的价格。
这是数据框的外观
这是比特币每天的收盘价。
我们可以看到比特币的价格波动很大。如上所述，价格由供需决定，当需求增加时，价格就会上涨，例如，在 2013 年底左右，因为塞浦路斯的金融危机，而在 2020 年初，由于冠状病毒造成的不确定性，价格就会下跌。
3.2。应用 KL 散度估计来检测状态变化
这里我们尝试使用直接比率估计方法来机器学习模型漂移。为了使 CPD 问题适合这种设置，我们需要修改上面的公式。我们将在训练集中使用固定窗口，而不是使用移动窗口来获得原始概率分布。以便我们可以计算训练集和看不见数据有多相似。
这里假设我们建立了一个机器学习模型，通过使用其 2013 年 4 月 29 日至 2018 年底的数据，可以预测第二天的比特币收盘价。因此，我们将比较火车设置和看不见的未来价格的一些子序列。在这里，我们将尝试查看月水平的模型漂移，因此将窗口设置为 30。
让我们计算每个日期的 KL 散度，并绘制这些值。
*from scipy.stats import entropy
from datetime import date, timedelta start_date = date(2019,2,1)
end_date = date(2020,3,28)
delta = timedelta(days=1)kl = []
date = []while start_date <= end_date: kld = entropy(np.array(df[df['date'] <
'2019-01-01'].close.tail(30)),
np.array(df[df['date'] <=
start_date].close.tail(30))) kl += [kld]
date += [start_date]
start_date+=delta kl = pd.DataFrame(list(zip(date,kl)),columns=['date','kl'])*
正如我们可以观察到的那样，2019 年几乎每个月都有相当多的峰值。然而，峰值在一段时间后下降，所以这些可能只是由季节性引起的。然而，在 2020 年 3 月有一个巨大的峰值。这显然是由于冠状病毒的冲击。
现在我们可以比较 KL 散度图和实际的比特币价格分布，看看它们是如何相互关联的。
**
在比特币价格图中，假设的“训练集”中的子序列显示为红色，其余为未知价格。因此，这些直接比率估计是用 30 天窗口的红色子序列对蓝色子序列计算的。
我们注意到，当价格在短时间内大幅上涨时，估计价值也会飙升。有趣的是，尽管比特币价格自 2019 年初以来一直呈上升趋势，直到 2019 年 7 月左右达到最高值，然后呈下降趋势，但估计的 KL 散度值在 2020 年前显示出“恒定波动”。这可能是因为训练集的分布已经考虑了比特币价格的波动性和理论上的常数通货膨胀帐户，因此估计的 KL 散度值并没有真正响应价格的逐渐增加，而是突然的价格变化。
3.3。带 Bolinger 带的状态变化阈值
最后，我们将探讨状态变化检测的决策阈值。在这里，我们将尝试看看如何博林格带可以用于这一目的。Bolinger 波段常用于金融技术分析。它应用了简单的移动平均线和移动标准差。下面是计算 Bolinger 波段的代码片段。
*# Bolinger bandskl['ma21'] = kl.kl.rolling(21).mean()
kl['mstd2'] = kl.kl.rolling(2).std()
kl['bolinger_high'] = kl.ma21+(kl.mstd2*2)
kl['bolinger_low'] = kl.ma21-(kl.mstd2*2)*
这里，我们使用 21 天简单移动平均线和 2 天移动标准偏差，通过使用每个定义的 2 个标准偏差(95%区间)来计算“波段”。此外，我们只对作为问题特征的 Bolinger 带的上界感兴趣(我们只想知道分布何时变得远离)，我们只画出上界。
正如我们可以看到的，有几个时间段，估计的 KL 散度超过了 Bolinger 带的上限，这意味着状态发生了变化。通过这种方法，我们可以系统地辨别变化点，并且通过改变移动平均的窗口，我们可以修改检测的灵敏度(窗口越小，对变化越不敏感)。
4。结论和后续步骤
这篇博文经历了以下几点:
- CPD 旨在检测时间序列概率分布中两个子序列的不相似性。
- 因为 KL 散度和 RuLSIF 都不是标准化的比率，并且没有明确的阈值来确定“状态变化”。因此，确定适当的规则来检测变化是很重要的。
- 窗口的长度也是这种方法的关键点之一。当您将窗口设置得较小时，它对变化更敏感。它可以快速检测甚至很小的变化，但是也可以捕获假阳性情况，例如变量的暂时漂移。另一方面，当你设置一个更大的窗口时，它的估计会更稳定，得到更少的假阳性情况。然而，实际检测状态变化需要一段时间。
- 仅仅通过检查目标变量，我们并不知道是什么导致了状态变化，通常我们感兴趣的是是什么导致了变化。其中一个解决方案是监控模型中的所有特征，这样我们就可以看到模型的哪个部分正在发生变化。
希望你对这篇文章感兴趣。如果你想和我联系，这是我的 LinkedIn 页面。
5。参考文献
哈尔查乌伊，z .，穆林斯，e .，，巴赫，F. R. (2009)。内核变点分析。在神经信息处理系统的进展*(第 609–616 页)。*
刘，s .，山田，m .，柯里尔，n .，杉山，M. (2013)。用相对密度比估计检测时间序列数据中的变点。神经网络， 43 ，72–83。
Sebastiã，r .，& Gama，J. (2007 年 12 月)。从数据流中学习直方图的变化检测。在葡萄牙人工智能会议*(第 112-123 页)。斯普林格，柏林，海德堡。*
估计量及其效率
无偏估计量的方差/均方误差的 Cramer-Rao 下界介绍
简介——什么是评估者？
假设你在抛硬币，你想凭经验估计正面的概率。为此，你决定抛硬币 n 次，根据你得到的是正面还是反面，记录 1 或 0。
估计概率最直接的方法是计算你在 n 次投掷中获得的正面的比例，我们称之为p̂.n变得越大，你就越确定 p̂ 准确地估计了 p ，即获得正面的真实概率。在统计学中，我们说 p̂ 是 p 的估计量**。直观地说，估计器只是在给定一些数据的情况下，估计统计模型中未知参数的一种方式。**
维吉尔·卡亚萨在 Unsplash 上拍摄的照片
估计量是统计学的基础。在上面的例子中，我们的估计量是无偏的，这意味着它的期望值就是我们试图估计的参数。除了让我们的估计量无偏之外，我们的估计量尽可能接近期望值也非常重要，即方差最小化。
hat 的方差，θ的估计量
当使用无偏估计量时，方差与均方误差(MSE) 相同，这对于之前有机器学习经验的人来说应该很熟悉。
马克 A 在 Unsplash 上的照片
这里有一个非常直观的例子，通常用来解释估计量。假设你在射箭。目标是击中靶心(参数)。粘在棋盘上的单个飞镖是你的评估者(你，扔飞镖的人)做出的评估。不偏不倚只是意味着你的飞镖的预期位置是靶心，实际上并没有说你平均会有多接近靶心。这就是我们关注 MSE 的原因。在这种情况下，高 MSE 只是意味着从单个飞镖到靶心的平均距离相当高。成为一个好的玩家(评估者)意味着你的飞镖聚集在中心周围——也就是说，你的 MSE 非常小。
既然我们理解了为什么我们需要我们的估计量具有最小的 MSE，问题就变成了:给定一个估计量，我们如何知道它是否是最有效的估计量，即具有最小 MSE 的估计量？这就是 Cramer-Rao 界派上用场的地方。
克莱姆-拉奥界
Cramer-Rao 界产生于 20 世纪 40 年代，它给出了无偏估计量的方差/均方误差的一个下界。这意味着给定参数的最佳可能估计量将具有由界限规定的 MSE。
假设我们想从 n 个样本中估计 θ 。克莱姆-拉奥定理陈述如下(在 iid 假设和其他正则性条件下):
克莱姆-拉奥界
如果我们在界上有等式，那么我们知道估计量是有效的！这并不意味着总是存在这样的估计量；然而，它确实声明了最佳可能估计量的 MSE 将大于或等于由界限给出的 MSE。
费希尔信息
现在，你可能想知道等式中的 I(θ) 到底代表什么。它被称为费希尔信息，直观地说，它是我们对样本来自哪个数据分布有多少信息的一种度量。
在 iid 假设下，大小为 n 的样本中的费希尔信息是单个样本中的信息乘以 n 。我们期望，随着我们获得更多的数据和 n 变得更大，我们应该有更多的关于数据是从什么分布抽样的“信息”，因此，我们应该能够更好地估计 θ 。
现在让我们努力理解费雪信息的公式。我们首先需要定义什么叫做得分函数。如果我们考虑一个随机变量X∞f(X；θ) ，则得分由下式给出
分数函数
然后，Fisher 信息被定义为得分平方的期望值。
费希尔信息
或者，通过一些简单的操作，我们可以获得 Fisher 信息的替代表达式:
Fisher 信息的替代表达
根据这些表达式，计算费希尔信息相对简单。
结论
我希望你现在对估计量的 Cramer-Rao 界有了更好的理解。此外，我希望你现在准备好计算和评估你自己的估算器的效率。
参考文献
[1]马丁，《统计理论讲义》(2015)，http://home pages . math . UIC . edu/~ rg Martin/Teaching/stat 411/Notes/411 Notes . pdf
你的模型是否过拟合？或者不合身？使用神经网络的示例
过拟合，欠拟合，泛化能力，交叉验证。一切都简单解释了。我还提供了一个使用神经网络的 python 示例。
作者创作的人物。
1.介绍
大多数时候，机器学习(ML)模型的差 性能的原因要么是过拟合要么是欠拟合。一个好的模型应该能够推广并克服过拟合和欠拟合问题。但是什么是过度拟合呢？但是什么是不适合呢？对于一个模型来说，什么时候能够概括学习到的功能/规则？
继续读下去，你就能回答所有这些问题。
2.ML 中的泛化是什么
ML 模型的泛化是指如何很好地ML 模型学习的规则/模式/功能，应用于模型学习时没有看到的具体例子**。这通常被称为匿集或测集测集。**
一个好的 ML 模型的目标是从训练数据很好地推广到来自问题领域的任何数据。这允许对模型以前从未见过的一些数据进行预测(即，对未来进行预测)。
如果你想在交互式路线图和活跃的学习社区的支持下自学数据科学，看看这个资源:https://aigents.co/learn
3.什么是机器学习中的过拟合
过度拟合意味着我们的 ML 模型对训练数据建模(已经学习)得太好了。
从形式上来说，过拟合指的是模型学习数据以及作为训练数据的一部分的噪声的情况，其程度是负面地 影响模型在新的未知数据上的性能。
在其他世界中，训练集中的噪声(即随机波动)被模型学习为规则/模式。然而，这些有噪声的学习表示不适用于新的看不见的数据，因此，模型的性能(即准确性、MSE、MAE)受到负面影响。
过拟合的一个教科书案例是当 模型的错误 上的 训练 设定(即训练期间)是低 但接着，模型的 错误
4.机器学习中的不足是什么
欠拟合意味着我们的 ML 模型既不能对训练数据建模，也不能推广到新的看不见的数据。
数据拟合不足的模型在训练数据上的性能会很差。例如，在有人使用线性模型来捕捉数据中的非线性趋势的情况下，该模型会对数据进行欠拟合。
欠拟合的一个教科书案例是当模型的误差对训练 和 测试 集合(即在训练和测试期间)非常高时。****
5.最佳位置和好的模型
很明显，过拟合和欠拟合之间存在权衡。
理想情况下，一个好的模型是在欠拟合和过拟合之间找到最佳平衡点的模型。
哪个是最佳点？
最佳点被定义为模型在训练集和测试集(不可见)上的误差都保持较低的点。
换句话说，最佳点是测试集上的误差开始增加的点，同时，模型在训练集上的误差是可接受的(低)。
6.如何(潜在地)限制过度拟合
ML 学习领域最常见的问题是过拟合**。**
能够(潜在地)限制过度拟合的行动:
- 我们可以使用交叉验证** (CV)方案。**
- 降低模型的复杂度(使模型不那么复杂)。
说到方案 1 即交叉验证的使用，最著名的 CV 方案就是 KFolds 交叉验证。使用 KFolds 方案，我们在训练数据的不同子集上训练和测试您的模型 k 次，并使用测试(看不见的)数据估计性能指标。其他选项包括留一个留一个交叉验证( LOOCV )、留一个 P 出来交叉验证( LpOCV )等。**
KFold 的视觉表现。作者创作的人物。
说到方案 2 即 降低模型的复杂度 有助于减少过拟合。例如，如果有人使用 RBF 核的 SVM 模型，那么降低复杂度就意味着使用线性核。在另一种情况下，如果有人用多项式来拟合一些数据，那么降低复杂性就意味着用线性模型来代替(线性回归)。
7.如何(潜在地)限制欠拟合
在这种情况下，有两种黄金标准方法:
- 尝试另一种模式
- 增加当前模型的复杂性
解决方案 1 很简单。关于解决方案 2，一个例子如下:如果有人对一些数据进行线性回归拟合，那么增加的复杂度将意味着拟合多项式模型。
8.结论
过拟合 或欠拟合是大多数机器学习(ML)模型性能 差的最常见原因。此外，过度拟合比欠拟合更常见。
- ****过度拟合是指模型在训练集(即训练期间)上的误差非常低，但模型在测试集(即未知样本)上的误差很大！
- 欠拟合**是指训练和测试**集合(即在训练和测试期间)的模型误差非常高。****
为了克服这些问题，通常使用交叉验证来估计模型在未知数据上的表现。
额外收获:Python 中的工作示例
数据集
我们将使用 Iris 数据集，正如我们在我以前的所有帖子中所做的那样。数据集包含鸢尾属三个品种四个** 特征(萼片和花瓣的长度和宽度) 50 个样本(鸢尾属 setosa 、鸢尾属 virginica 和鸢尾属 versicolor )。******
模型
我们将使用一个多层感知器【MLP】。MLP 是一类前馈 人工神经网络 (ANN)。术语 MLP 使用含糊，有时不严格地指任何前馈神经网络，有时严格地指多层感知器组成的网络。********
********from sklearn.neural_network import MLPRegressor
from sklearn.metrics import mean_absolute_error
import numpy as np
from sklearn.model_selection import validation_curve
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
from sklearn.model_selection import KFold
np.random.seed(0)
plt.style.use(‘ggplot’)********
让我们加载虹膜 数据:****
******iris = load_iris()
X, y = iris.data, iris.target******
我们将使用 KFolds 交叉 - 验证与 20 折( K=20) 来评估我们模型的泛化 能力。在每个文件夹中，我们将分别使用训练和测试集来估计训练和测试误差。****
******kf = KFold(n_splits=20)
list_training_error = []
list_testing_error = []for train_index, test_index in kf.split(X):
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
model = MLPRegressor()
model.fit(X_train, y_train)
y_train_data_pred = model.predict(X_train)
y_test_data_pred = model.predict(X_test) fold_training_error = mean_absolute_error(y_train, y_train_data_pred)
fold_testing_error = mean_absolute_error(y_test, y_test_data_pred)
list_training_error.append(fold_training_error)
list_testing_error.append(fold_testing_error)******
绘制培训阶段的 MAE 和测试阶段的 MAE:
******plt.subplot(1,2,1)
plt.plot(range(1, kf.get_n_splits() + 1), np.array(list_training_error).ravel(), ‘o-’)
plt.xlabel(‘number of fold’)
plt.ylabel(‘training error’)
plt.title(‘Training error across folds’)
plt.tight_layout()plt.subplot(1,2,2)
plt.plot(range(1, kf.get_n_splits() + 1), np.array(list_testing_error).ravel(), ‘o-’)
plt.xlabel(‘number of fold’)
plt.ylabel(‘testing error’)
plt.title(‘Testing error across folds’)
plt.tight_layout()plt.show()******
现在让我们解释结果，并尝试找出过度拟合和欠拟合点。
提醒:
- 过度拟合是指模型在训练集(即训练期间)上的误差非常低，但模型在测试集(即看不见的样本)上的误差很大！
- 欠拟合是指模型在训练集和测试集(即在训练和测试期间)的误差都非常高。
在折叠编号 10 处可以识别出一个欠拟合点。在第 10 次折叠期间，训练集和测试集上的误差同时很高！因此，该模型对传入 fold 10 中用于训练的那部分训练数据进行了欠填充。****
在折叠 20 处可以看到一个过度拟合点(不是真正的极端)。训练 MAE 约为 0.16，对于相同的倍数，测试集上的 MAE 高于 0.20。****
免责声明:这些都不是过度拟合/欠拟合的极端情况，但我只是想表明我的观点，并将其与我在本文中讨论的理论联系起来。
那都是乡亲们！希望你喜欢这篇文章！
敬请关注并支持这一努力
如果你喜欢这篇文章并且觉得它有用，那么关注我就可以看到我所有的新帖子。****
这是我的简介。点击关注！****
****** [## Serafeim Loukas -走向数据科学
阅读 Serafeim Loukas 在《走向数据科学》中的文章。电气和计算机工程文凭(NTUA)。主人…
towardsdatascience.com](https://towardsdatascience.com/@seralouk)
有问题吗？把它们作为评论贴出来，我会尽快回复。******
最新帖子
****** [## 时间序列预测:用脸书的先知模型预测股票价格
使用可从《先知脸书》公开获得的预测模型预测股票价格
towardsdatascience.com](/time-series-forecasting-predicting-stock-prices-using-facebooks-prophet-model-9ee1657132b5) [## 用新冠肺炎假设的例子解释 ROC 曲线:二分类和多分类…
在这篇文章中，我清楚地解释了什么是 ROC 曲线以及如何阅读它。我用一个新冠肺炎的例子来说明我的观点，我…
towardsdatascience.com](/roc-curve-explained-using-a-covid-19-hypothetical-example-binary-multi-class-classification-bab188ea869c) [## 支持向量机(SVM)解释清楚:分类问题的 python 教程…
在这篇文章中，我解释了支持向量机的核心，为什么以及如何使用它们。此外，我还展示了如何绘制支持…
towardsdatascience.com](/support-vector-machines-svm-clearly-explained-a-python-tutorial-for-classification-problems-29c539f3ad8) [## PCA 清楚地解释了——如何、何时、为什么使用它以及特性的重要性:Python 指南
在这篇文章中，我解释了什么是 PCA，何时以及为什么使用它，以及如何使用 scikit-learn 在 Python 中实现它。还有…
towardsdatascience.com](/pca-clearly-explained-how-when-why-to-use-it-and-feature-importance-a-guide-in-python-7c274582c37e) [## 关于 Python 中的最小-最大规范化，您需要知道的一切
在这篇文章中，我将解释什么是最小-最大缩放，什么时候使用它，以及如何使用 scikit 在 Python 中实现它
towardsdatascience.com](/everything-you-need-to-know-about-min-max-normalization-in-python-b79592732b79) [## Scikit-Learn 的标准定标器如何工作
在这篇文章中，我将解释为什么以及如何使用 scikit-learn 应用标准化
towardsdatascience.com](/how-and-why-to-standardize-your-data-996926c2c832)
和我联系
- LinkedIn:【https://www.linkedin.com/in/serafeim-loukas/
- https://www.researchgate.net/profile/Serafeim_Loukas研究之门:
- https://people.epfl.ch/serafeim.loukasEPFL简介:
- 堆栈 溢出:https://stackoverflow.com/users/5025009/seralouk******
你的创业公司在负责任地使用 AI 吗？
为什么模型的公平性和的可解释性不能满足它
更新:你现在可以用 日文 阅读这篇文章！(感谢 Koki Yoshimoto)。
自从科技公司开始利用这项技术以来，他们已经收到了无数关于不道德使用人工智能的指控。
一个例子来自 Alphabet 的谷歌，它创造了一种仇恨言论检测算法，给非裔美国人的言论分配了比白人更高的“毒性分数”。
华盛顿大学的研究人员分析了数千条被算法视为“冒犯”或“仇恨”的推文的数据库，发现黑人对齐的英语更有可能被贴上仇恨言论的标签。
这是人工智能算法出现偏见的无数例子之一。可以理解的是，这些问题引起了很多关注。关于伦理和偏见的对话是最近人工智能领域的热门话题之一。
各行各业的组织和行动者都在从事研究通过公平、问责、透明和道德(FATE)来消除偏见。然而，仅仅专注于模型架构和工程的研究必然会产生有限的结果。那么，如何解决这个问题呢？
消除对抗人工智能偏见的误解
马库斯·斯皮斯克在 Unsplash 上拍摄的照片
修复模型是不够的，因为这不是根本原因所在。为了找出哪些措施可以产生更好的效果，我们必须首先了解真正的原因。然后，我们可以通过研究我们在现实世界中如何应对这种偏见来寻找潜在的解决方案。
人工智能模型通过研究模式和从历史数据中识别洞察力来学习。但人类历史(以及我们的现在)远非完美。因此，毫不奇怪，这些模型最终模仿并放大了用于训练它们的数据中的偏差。
这是我们大家都相当清楚的。但是，我们如何处理我们世界中这种固有的偏见呢？
在现实世界中，我们必须注入偏见以对抗偏见。
当我们觉得一个社区或一部分人口可能处于不利地位时，我们会避免仅仅根据过去的情况得出结论。有时，我们会更进一步，进行包容，为这些细分市场提供机会。这是扭转趋势的一小步。
这正是我们在教授模型时必须采取的步骤。那么，我们如何注入人类偏见来对抗模型固有的“习得性”偏见呢？以下是实现这一目标的一些步骤。
1。为您的数据科学团队添加不同的角色
在构建负责任的人工智能模型时，你需要你的团队超越技术。虽然对数据科学专业人员进行数据隐私教育很重要，但这种做法的好处有限。通过引入来自社会科学和人文学科的人，你可以获得技能和专业知识，这将帮助你减轻人工智能模型中的潜在偏见。
来自这些背景的人将会更好地理解用户和伦理考虑，并从人的角度提供见解。人类学家和社会学家可以发现模型中可能被创建模型的数据科学家忽略的刻板印象，并可以纠正数据中潜在的偏见。
数据科学团队中的行为心理学家可以帮助弥合用户和技术之间的差距，并确保模型结果的公平性。
在构建负责任的人工智能模型时，你必须超越技术。
除了重视不同的技能组合，数据科学团队引入更多不同性别、种族或国籍的成员也至关重要。多元化的团队提供新的视角，质疑可能过时的古老规范，并防止团队陷入群体思维的陷阱。
例如，开发 iOS YouTube 应用程序的谷歌团队在添加移动上传时没有考虑左撇子用户，因为团队中的所有人都是右撇子。
这意味着在左撇子视角下录制的视频会上下颠倒。只需要几个左撇子就能让这款应用对占全球人口 10%的人更加友好。
2。将人类融入循环
无论你的模型有多复杂，都需要人工干预。人类可以是故障安全机制的一部分，或者更好的是，数据科学团队可以在持续的基础上结合人类的判断并逐步丰富模型。
随着人工智能被用于涉及人类健康或生命的关键领域，它应该被视为零容忍的任务关键型——不仅仅是宕机或错误，还包括偏差。实现这一点的唯一方法是让人类负责，以确保避免人工智能偏见。
计划模型的零容忍，不仅仅是停机时间或错误，还有偏差。
佛罗里达州朱庇特一家医院的医生举例说明了永远不要盲目信任人工智能算法的必要性:他们拒绝了 IBM Watson 关于癌症治疗的建议，这些建议可能会产生致命的后果。数据科学团队不断面临构建更好的模型和万无一失的系统的挑战。
然而，这并不意味着人类可以被排除在系统之外。事情确实会出错，即使是在少数情况下。我们必须将人设计到决策过程中，以便在每一个这样的情况下进行控制。
3。让您的数据科学团队负起责任
谢恩·艾弗里在 Unsplash 上拍摄的照片
大多数业务数据科学团队的主要目标都围绕着创造更多收入、设计最精确的模型和自动化流程以实现最高效率。然而，这些目标忽略了某人(或多人)必须确保“正确的”事情正在被做。
数据科学团队必须对结果负责，必须确保他们解决的业务问题不会以牺牲道德准则为代价。扪心自问:您的数据科学团队是否仅仅受到收入和时间表的激励？或者他们是否认为负责任的产品使用和公平的结果是项目成功的标准？
如果是前者，你需要重新思考驱动你的团队的目标。
为了确保负责任地使用人工智能，你必须提升你的数据科学团队的道德品质。
为了确保负责任地使用人工智能，你必须提升你的数据科学团队的道德品质。这需要积极的保护和持续的教育。此外，你还必须为高级职位做好准备，比如首席道德官或 T2 道德委员会，他们将成为你产品的道德监督人。
然而，这并没有消除将责任推给其他相关人员的需要:你需要在所有层面上承担责任。例如，宝拉·戈德曼成为 Salesforce 的首位首席道德和人道使用官。
通过持续讨论人工智能解决方案的质量及其对整个社会的影响，你可以从高层灌输一种责任感，并确保对团队其他成员产生涓滴效应。也有可用的最佳实践和指南，比如谷歌的这些。
虽然大型科技公司普遍存在人工智能道德失误，但我们也看到了一些正确的举措。微软和 IBM 都公开承诺解决他们自己和第三方程序中的偏见。
4。让你的用户知道人工智能并不完美
公司内部和更广泛的消费者群体中的许多个人过于信任人工智能，而不了解它的能力和缺陷。虽然商业领袖经常忽视这一点，但我们不能指望所有消费者都理解今天人工智能的前景。
人们认为人工智能可以创造奇迹，但如果没有数据、人才或正确的流程，它将注定失败。教育团队成员和消费者人工智能仍处于初始阶段——并且应该被如此对待——对于避免导致灾难性结果和更大失望的盲目信任至关重要。
用户必须明白，人工智能解决方案是用来提供信息，而不是发号施令。
对人工智能算法能力的期望必须保持现实。就像你可能不愿意让你的汽车在拥挤的街道上以自动驾驶模式行驶一样，我们今天必须了解它的局限性。人们需要理解，人工智能解决方案应该以同样的方式来看待——它们是为了提供信息，而不是发号施令。
5。建立一种促进好奇心、质疑信念的意愿和改变的灵活性的文化
约瑟夫·罗萨莱斯在 Unsplash 上的照片
最终，为了实现负责任地使用人工智能，你需要在你组织的核心中嵌入某些属性。文化是经年累月形成的，极难改变。渴望成为数据驱动的组织必须在其文化核心中拥有某些属性。当你的创业处于早期阶段，而不是几年后，就播下这些种子。
那么，对于负责任和合乎道德地使用人工智能来说，这些至关重要的属性是什么呢？
**好奇心。**问自己:所有团队成员都愿意尝试必要的步骤来找到他们需要的答案吗？或者，他们是否乐于执行设计好的步骤和流程？一个好奇的团队将找到让人工智能工作以满足结果的方法。
接下来是质疑信念的意愿:你的公司是否有一个健康的环境让团队质疑既定的实践？上级会听取并鼓励具有挑战性的反馈吗？团队必须有一种开放的文化，当他们看到 AI 的实现方式不符合组织的理想时，他们可以大胆地说出来。
最后，公司文化必须促进改变的灵活性。与技术和数据科学打交道自然会涉及许多变化——无论是在创建解决方案还是采用解决方案方面。团队是否愿意根据他们通过好奇和质疑设定的流程所发现的东西来进行调整？
拥有正确的公司文化为合乎道德的人工智能使用奠定了基础。众所周知，脸书提倡“快速行动，打破常规”的文化考虑到这个科技巨头面临的无数关于用户隐私和滥用数据的丑闻，这个咒语显然没有导致合理的人工智能使用。
负责任地使用人工智能不会仅仅通过对模型进行一些调整就发生。
负责任地使用 AI 不是一蹴而就的事情，也不是简单地对模型进行一次调整就能确保并期待奇迹般的结果的事情。
正如我们在当前席卷科技行业的“道德洗涤的指责浪潮中所看到的，简单地声明你将打击人工智能偏见，而没有什么行动来支持这一声明是不会成功的。
避免人工智能偏差只能通过在不同阶段以多种方式增加人类输入来实现。通过使数据科学团队多样化，将人融入流程，让团队负起责任，对人工智能的能力设定现实的预期，以及最后——也许是最重要的——建立正确的公司文化，你可以为人工智能在你的组织中的道德使用铺平道路。
这篇文章最初是在 TechCrunch 的会员版 ExtraCrunch 上发表的。增加了插图。封面图片由*组成***
你的虚拟聊天机器人是否免受攻击？
随着人工智能的全面接管，近年来人类已经非常习惯于与智能语音助理或聊天机器人交谈。
由 Freepik 设计
但本质上，VA 到底是什么？
简单来说，聊天机器人或智能虚拟设备是一种模拟人类对话的软件程序。这种互动可以通过语音或书面信息进行。这些自动化 VA 程序利用自然语言处理或 NLP 与客户进行交互，就像真人一样。
聊天机器人的发展前景
越来越多的企业使用增值服务，特别是聊天机器人，来提升他们的客户体验。
无论是医疗保健、保险、银行还是客户服务，每个行业都在使用聊天机器人来提升用户体验并提供主动帮助。事实上，预计到 2020 年底，80%的公司将使用虚拟化。
聊天机器人——攻击的棋子
降低客户支持成本、持续连接和即时确认的结合使聊天机器人比其他机器人更胜一筹。然而，在将虚拟设备整合到您的业务中之前，了解它的安全含义是很重要的。虽然这并不广为人知，但有必要建立一个可靠的、详细的、多层的安全解决方案来确保聊天机器人的安全。
借助达美航空 2017 年数据泄露案例，可以轻松证明保护增值服务的必要性。达美航空公司起诉其人工智能供应商，因为其安全政策薄弱。虚拟助理提供公司未能安装多因素认证，这导致黑客能够修改聊天机器人的源代码，并暴露数十万客户的信用卡信息。黑客能够看到达美航空的网站活动，并将顾客转移到一个欺诈网站，在那里他们可以保护用户数据。在当今数据驱动的世界，未能保护您客户的数据可能是一个巨大的疏忽。这就是为什么聊天机器人系统必须有一层监控和保护，以防止机密数据落入坏人之手。
这个案例揭示了当聊天机器人系统被入侵时会发生什么，这是非常必要的，并且对不同形式的攻击进行了更多的研究。在很大程度上，聊天机器人攻击可以分为两种形式——第一种是修改系统行为的内部或操纵攻击，第二种是谨慎检测隐藏信息和攻击系统弱点的外部或提取攻击。
聊天机器人安全-当务之急
越来越多的企业倾向于使用增值服务，这也助长了对这些自动化系统的网络攻击。让我们从更大的角度来看，使用聊天机器人的整个目的是提供一个简化的个性化的客户服务，全天候可用。但是使用无保护的聊天机器人会增加数据窃取和侵犯隐私的可能性。更重要的是，它甚至可能导致消费者集体诉讼，这可能会使公司损失数百万美元，并牺牲其客户和公司数据的完整性。
早期的聊天机器人主要用于提供通用信息，如公开的地址或分支机构信息，但世界已经迅速转向自动化和节约成本。此外，人类在提供准确信息时容易出错。如今，聊天机器人被用来支持或取代许多重要的人类任务。从安全角度来看，这意味着聊天机器人现在可以访问敏感和私人信息。机器学习以极快的速度发展，却没有将安全性视为其关键部分。目前，在世界范围内部署了大量聊天机器人，这些机器人对敏感信息的访问程度如此之高，以至于这些系统的安全性成为一个迫切的要素。
现在，让我们深入到事物的生产方面。市场上挤满了致力于提供更加动态和易于管理的聊天机器人的玩家，但是，明显缺乏提供解决方案来保护聊天机器人免受各种安全风险的供应商。为此，企业忽略了一个具有重大影响的基本方面。
那么，你如何防止你的公司成为下一个反面教材呢？
VAs 像任何其他软件一样容易受到威胁，但在聊天机器人的情况下，这些攻击很难防御，主要是因为机器学习系统的内在构成。聊天机器人被认为是类似人类的物体，但它们不是。他们的智能来自数据集、模型及其超参数，加上他们从周围的环境中学习。机器学习系统的这些核心组件不容易保护，因为它们来自公共存储库，因此这些数据很容易被发现，并且可能在黑客的范围内。需要一个拥有广泛人工智能、机器学习、自然语言处理和数据科学知识的组织来设计一种可以保护这些聊天机器人的产品。
这就是我们的问题所在，我们 Scanta 知道一个简单的网络应用或网络防火墙不足以保护你的虚拟聊天机器人。这就是为什么我们开发了我们的旗舰产品 VA Shield，这是一种聊天机器人安全解决方案，它可以分析系统的请求、响应和对话，以提供增强的监控层。不仅如此，VA Shield 还跟踪分析，以提供关于虚拟助手 Chatbot 使用的更深入的商业见解。
确保聊天机器人或 ML 系统的安全是一个复杂的问题，构建这样的解决方案需要对系统有透彻的了解。机器学习系统不是将安全性作为组件之一来构建的，它们已经深深植根于各种任务关键型系统中。不仅如此，由于 NLP 接口的自由形式，基于 NLP 的接口给安全问题带来了额外的复杂性，并且考虑到 NLP 仍然是一个发展中的领域，还没有人掌握该领域。
我们对机器学习和人工智能根深蒂固的理解，为 VA Shield 的发明奠定了基础。这个聊天机器人安全解决方案为您的虚拟助理聊天机器人系统添加了一个关键的零信任安全框架，使其平稳安全地运行，而不会干扰现有的安全企业。
结束语
本文只是触及了如果您正在部署一个未受保护的虚拟设备会发生什么的表面，其后果是深远的。这就是为什么我们的任务是确保你的虚拟助理聊天机器人得到新的安全级别的加强，以阻止机器学习攻击。
在 https://scanta.io/了解更多关于我们的信息
零更接近八还是一？
应用 t-SNE 可视化 2D 图中的 MNIST 数字数据集
作者:罗莎丽娅·西里波米莎·利索夫伊 ，克尼梅
零更接近八还是一？这是三分还是五分？几周前，当我们检查一个图像分类应用程序的结果时，我们就在思考这类问题。
是的，事实上，0 更接近于 8 而不是 1，2 更接近于 5 而不是 3——当然，这是从图像识别的角度而不是从严格的数学意义上来说。在我们准备的最后一个数据科学示例中，我们训练了一个机器学习模型来识别手写数字的图像。最后，在检查结果的时候，我们意识到人们的笔迹是多么的潦草，有时很难区分 8 和 0，2 和 5，1 和 7，0 和 3，以及其他有时意想不到的类似数字。
由于时间和其他义务的明显原因，我们不能一个接一个地检查所有的数字图像和它们的错误分类。然而，对数据集中最容易混淆的重叠数字有一个总体的了解是很有趣的。说起来容易做起来难。每个数据行都是一幅图像，由 784 个输入要素描述。试着想象一下！
我们需要将输入维度从 784 大幅减少到 2 或最多 3，以便通过 2D 或 3D 绘图实现数据可视化，同时还能提供信息。如果我们能从一个图表中了解最大的困惑在哪里，哪些数字在书写风格上有最大的延伸，那就太好了。
t 分布随机邻居嵌入(t-SNE)
图一。应用 t-SNE 投影后的可视化示例
t-分布式随机近邻嵌入(t-SNE)是一种相对较新的技术，通常用于在二维或三维空间中以图形方式表示复杂的多维数据集。t-SNE 是一种非线性降维技术，它基于数据点之间的非线性局部关系，将数据集的原始 n 坐标转换为一组新的m = 2–3坐标。具体而言，它将每个高维对象建模为二维或三维点，以这种方式，在新的较低维空间中，相似的对象由附近的点建模，不相似的对象由远处的点建模。
在第一步中，通过数值属性的多元正态分布对数据点进行建模。为高维空间中的对象对创建概率分布。相似的物体被一起拾取的概率高，而不相似的物体被一起拾取的概率低。
在第二步中，这个分布被低维空间中的 t-分布代替，该 t-分布必须尽可能地遵循原始的多元正态分布。第二步的目标是找到具有尽可能相似的 t 分布的低维空间——通过最小化 Kullback-Leibler 散度——然后在新找到的低维空间中投影物体。第二个 t 分布必须模拟在数据集中挑选另一个点作为低维空间中当前点的邻居的概率，就像在高维空间中一样。
困惑度参数将 t 分布的形状控制为“任意点的有效邻点数”较低的困惑值(2)会找到受数据中局部变化支配的聚类形状。较高的困惑值(30)在多次迭代后会产生更稳定的聚类。也就是说，困惑值越大，数据中考虑的全局结构就越多。
这项技术主要用于可视化。事实上，将数据集维度积极缩减到两个或三个坐标，将数据点对的可能性转换为视觉邻域属性，以及由于投影的非线性而能够表现数据组的奇怪形状，这些都使 t-SNE 特别适合大多数数据可视化技术。
请注意，t-SNE 技术仅适用于当前数据集。无法导出模型并将其应用于新数据。事实上，所有可用的数据都必须用来寻找新的低维空间。也就是说，新的数据不能被投影。
MNIST 数字数据集
图二。MNIST 数字数据集中的一些数字图像
位于 LeCun 网站上的 MNIST 手写数字数据库包含 70，000 个手写数字 iii 的 28x28 黑白图像样本。在这个例子中，我们使用了 10，000 个这样的图像的子集。
通常在处理图像时，可以直接从标准格式如 PNG、JPG 和 TIFF 中读取。不幸的是，MNIST 数据集只有非标准的二进制格式。幸运的是，下载数据集并把文件转换成易于阅读的 CSV 格式非常简单。
在将数字图像转换成数字向量后，每个图像由 784 个灰度级的向量表示，即由 784 个输入特征表示。
应用 t-SNE 可视化 2D 图中的 MNIST 数据集
图 3。KNIME 分析平台中的 t-SNE 节点
一方面，我们有一个想要在 2D 散点图上可视化的高维数据集；另一方面，将维度从高的 n 降低到低的 m 的技术(例如 m=2)。然后，我们将 t-SNE 变换应用于 MNIST 数据集，并将结果绘制在 2D 散点图上(图 3)。
这是一个 t-SNE 变换如何帮助在二维图上可视化高维数据集的示例。每个图像的原始尺寸 28×28 = 784 像素仅通过 t-SNE 被减少到二维，并且产生的数据点被绘制在散点图上，其中代表相似图像的数据点被紧密定位。784 个输入特征来自“展开”成单个数组或值序列的 28x28 像素图像。
例如，“6”位于两种不同类型的“0”之间数字“4”和“9”在形状上接近且部分重叠，伸展成类似于“1”的形状“0”和“8”数字的位置也很接近，因为它们的形状通常相似；“3”和“5”也一样因此，图 4 中的散点图是每个数字不同形状的拓扑图。
图 4。t-SNE 变换后散点图上的 MNIST 数据集。
KNIME 工作流程
现在，让我们快速浏览一下在 MNIST 数据集上实施 t-SNE 变换并在 2D 散点图上绘制结果的工作流，该工作流在 KNIME Hub 上以“ t-SNE 对 MNIST 数据集”的形式提供
名为“读取 MNIST 数据”的元节点列出并读取 10，000 个 MNIST 文件，每个文件都包含一个手写数字的图像。然后，通过“预处理图像”元节点中的“图像到数据行”节点，图像被转换成数字(灰度级)的集合。然后将数值向量输入“t-SNE (L. Jonsson)”节点，计算两个 t-SNE 分量。在并行分支中，提取数字类别并用于对不同的数字图像进行颜色编码。最后，使用“散点图(Plotly)”节点在经典的传统散点图上绘制颜色编码的 t-SNE 变换的二维向量。
图 5。工作流"MNIST 数据集上的 t-SNE"实现 MNIST 数字数据的 t-SNE 变换并将结果绘制在散点图上。
结论
t-SNE 是一种非常强大的变换，可以将数据从任何维度空间投影到二维空间，并显示数据集中的数据组有多接近。
在本例中，我们已经将 MNIST 数字数据集从 784 维空间转换到二维空间，但我们仍然可以检查哪些数字最容易与其他数字混淆，如“8”与“0”或“7”与“1”
参考文献
1.Laurens van der Maaten，Geoffrey Hinton，“使用 t-SNE 可视化数据”，《机器学习研究杂志》2008 年第 9 期
2.k .栗田(2018 年 9 月 14 日)。论文剖析:“使用 t-SNE 可视化数据”讲解【博客文章在“机器学习”中讲解】
3.Y. LeCun、L. Bottou、Y. Bengio 和 P. Haffner。"基于梯度的学习应用于文档识别."IEEE 会议录，86(11):2278–2324，1998 年 11 月
2020 年 7 月 8 日首次发表于 Datanamihttps://www . Datanami . com/2020/07/08/is-zero-closer-to-eight-or-to-one/
使用 T-SQL 窗口函数的孤岛冒险
使用 T-SQL 窗口函数可以轻松解决传统的“间隙和孤岛”问题
拉胡尔从派克斯拍摄的照片
最近，我公司的一位业务用户请求我创建一个报告，显示资金周转率大于 X 值的连续天数。当我开始准备来自 SQL Server 数据库的数据时，有一些棘手的问题需要解决。
抽样资料
为了演示我是如何解决这个问题的，我将使用栈溢出 示例数据库。让我们将业务请求转化为以下内容:找出连续几天有超过 50 篇帖子并且每篇帖子都有超过 50，000 次浏览的情况。
表 dbo。Posts 包含大约 1720 万行。首先，让我们看看每天有多少帖子的浏览量超过 50，000:
*SELECT convert(date,CreationDate) as CreationDate
,count(Id) as TotalPosts
FROM Posts
WHERE CreationDate >= '20080731'
AND CreationDate < '20140101'
AND ViewCount > 50000
GROUP BY convert(date,CreationDate)
ORDER BY CreationDate*
当我运行这个查询时，我得到以下结果:
为了更好地处理正在运行的查询，我在 CreationDate 列上创建了一个非聚集索引，包括 ViewCount 列。现在，当我运行查询来检查有超过 50 篇帖子、超过 50，000 次浏览的日期时，我得到了以下结果:
*;WITH CTE_POSTS as(
select convert(date,CreationDate) CreationDate
,count(Id) totalPosts
from Posts
where CreationDate >= '20080731'
and CreationDate < '20140101'
and ViewCount > 50000
group by convert(date,CreationDate)
)
SELECT *
FROM CTE_POSTS
WHERE totalPosts > 50
order by CreationDate*
正如你所注意到的，从 2008 年 9 月 15 日到 9 月 19 日，所有日期都包括在内。然后，第 20 个和第 21 个不见了……这个问题就是众所周知的 【缺口与孤岛】 问题。在这里，第一桶日期(15 日—19 日)代表“岛”，20 日和 21 日代表“沟”。
欢迎来到这个岛…
让我们首先确定我们的“岛”(满足标准的连续日期的桶:在我们的例子中，超过 50 个帖子的日期有 50.000 以上的浏览量):
*; WITH CTE_POSTS as(
SELECT CONVERT(DATE,CreationDate) CreationDate
,COUNT(Id) totalPosts
from Posts
WHERE CreationDate >= '20080731'
AND CreationDate < '20140101'
AND ViewCount > 50000
GROUP BY convert(date,CreationDate)
HAVING COUNT(Id) > 50
)
,starting as (
SELECT CreationDate
,ROW_NUMBER() OVER(ORDER BY CreationDate) rnm
FROM CTE_POSTS as CTE1
WHERE NOT EXISTS (
SELECT *
FROM CTE_POSTS as CTE2
WHERE DATEDIFF(dd,CTE2.CreationDate,CTE1.CreationDate) = 1)
)
,ending as (
SELECT CreationDate
,ROW_NUMBER() OVER(ORDER BY CreationDate) rnm
FROM CTE_POSTS as CTE1
WHERE NOT EXISTS (
SELECT *
FROM CTE_POSTS as CTE2
WHERE DATEDIFF(dd,CTE2.CreationDate,CTE1.CreationDate) = -1)
)
SELECT s.CreationDate as startingDate
,e.CreationDate as endingDate
,DATEDIFF(dd,s.CreationDate,e.CreationDate) as ConsecutiveDays
FROM starting s
INNER JOIN ending e on s.rnm = e.rnm*
这样，我们确定了我们的“岛屿”，正如您在下面的截图中看到的:
利用领先/落后优势
如果您运行的 SQL Server 版本是 2012 年或更高版本，您可以利用时间偏移函数超前和滞后*。默认情况下，LEAD 将返回序列中的下一个值，但是也可以使用可选参数来调整偏移量，而后者将执行完全相反的操作，即返回序列中的上一个值(默认情况下)。*
让我们看看 LEAD 在我们的场景中是如何工作的:
*; WITH CTE_POSTS as(
select CONVERT(DATE,CreationDate) CreationDate
,COUNT(Id) totalPosts
FROM Posts
WHERE CreationDate >= '20080731'
AND CreationDate < '20140101'
AND ViewCount > 50000
GROUP BY CONVERT(DATE,CreationDate)
HAVING COUNT(Id) > 50
)
,CTE_LEAD AS
(
SELECT CreationDate
, DATEADD(day, -1 * DENSE_RANK() OVER(ORDER BY CreationDate), CreationDate) AS DateGroup
FROM CTE_POSTS
)
SELECT MIN(CreationDate) AS start_range
,MAX(CreationDate) AS end_range
,DATEDIFF(dd,MIN(CreationDate),MAX(CreationDate)) AS consecutiveDays
FROM CTE_LEAD
GROUP BY DateGroup;*
这个解决方案更加直观，因为您避免了自连接的复杂性，但是更重要的是，这段代码运行得更快。
这里，我从 ROW_NUMBER() 函数开始，而不是 DENSE_RANK() 。但是，后来我从 Itzik Ben-Gan 的书“使用窗口函数的 Microsoft SQL Server 2012 高性能 T-SQL”中找到了一个很好的解释，他在书中阐明了 DENSE_RANK() 保证即使我们的序列中有重复值，代码也会正常工作，而 ROW_NUMBER() 则不会。
结果和预期的一样:
寻找差距
在某些情况下，您希望检查业务请求未得到满足的范围。例如，您希望检查您的销售额低于某个阈值的日期，或者您的系统无法正常工作的日期。
在我的例子中，我将显示不超过 50 个帖子有 50，000 以上的浏览量的日期。
传统 T-SQL 解决方案
与寻找“孤岛”相反，我们需要检查连续的值并检测它们之间的“间隙”在哪里。
*; WITH CTE_POSTS as(
select CONVERT(DATE,CreationDate) CreationDate
,COUNT(Id) totalPosts
FROM Posts
WHERE CreationDate >= '20080731'
AND CreationDate < '20140101'
AND ViewCount > 50000
GROUP BY CONVERT(DATE,CreationDate)
HAVING COUNT(Id) > 50
)
SELECT DATEADD(dd,1,CreationDate) AS startDate
,DATEADD(dd,-1,(SELECT MIN(t2.CreationDate)
FROM CTE_POSTS t2
WHERE t2.CreationDate > t1.CreationDate)) AS endDate
FROM CTE_POSTS t1
WHERE NOT EXISTS (
SELECT *
FROM CTE_POSTS t2
WHERE t2.CreationDate = DATEADD(dd,1,t1.CreationDate)
AND CreationDate < (SELECT MAX(CreationDate) from CTE_POSTS))*
使用窗口功能变得复杂
至于“孤岛”问题，可以实施类似的逻辑来寻找“缺口”。因此，和前面的例子一样，我们将使用 LEAD 函数来实现我们的目标:
*; WITH CTE_POSTS as(
select CONVERT(DATE,CreationDate) CreationDate
,COUNT(Id) totalPosts
FROM Posts
WHERE CreationDate >= '20080731'
AND CreationDate < '20140101'
AND ViewCount > 50000
GROUP BY CONVERT(DATE,CreationDate)
HAVING COUNT(Id) > 50
)
,CTE_LEAD AS
(
SELECT CreationDate AS startDate
, LEAD(CreationDate) OVER(ORDER BY CreationDate) AS endDate
FROM CTE_POSTS
)
SELECT DATEADD(dd, 1, startDate) AS startDate
,DATEADD(dd, -1, endDate) endDate
FROM CTE_LEAD
WHERE DATEDIFF(dd, startDate, endDate) > 1;*
同样，有了的引导*，代码更加直观，可读性更好。在这里，我们只是检查连续日期之间的范围，如果它大于 1，这意味着我们的序列中有一个缺口。当满足该标准时，我们只是在序列中的最后一个“岛”日期上加一天，以获得第一个“间隔”日期，同时从下一个序列中的第一个“岛”日期减去一天，以获得“间隔”的最后一个日期。*
线性回归如何有资格成为机器学习算法？
机器学习，数据科学
线性回归是最知名的和简单的统计和机器学习工具。
来源:自己的工作
在本文中，您可以探索线性回归算法，它是如何操作的，以及如何更好地使用它？
线性回归(LR) 是一种简单而强大的监督学习技术。它在很多情况下都有应用。
LR 决定称为解释变量的输入变量如何影响称为响应变量的输出变量。它使用具有最小数量的平方残差的最佳拟合直线，俗称回归线或最小平方线。
简单线性模型只包含一个自变量，称为简单线性回归。而多元线性回归有多个解释变量。
LR 处理连续变量的研究。这有利于公司根据经验预测未来的市场趋势和薪酬关系。LR 用于预测、时间序列、因果关系。例如，鲁莽驾驶和道路伤害之间的联系。
LR 可以是正的，也可以是负的。两个变量之间的正关系意味着一个变量的值的增加总是会增加另一个变量的值。
另一方面，两个变量之间的负关系意味着一个变量的值的增加意味着另一个变量的值的减少。
线性回归的假设
Artem Sapegin 在 Unsplash 上拍照
- 因变量 y 和自变量 x 之间的关系总是线性的。x 的系数必须是线性的，不相关的。你不能允许系数是彼此的函数。
- 在非金融应用中，自变量也必须是非随机的。此外，在金融场景中，只要误差变量和自变量不相关，对随机自变量的近似就可以是准确的。
- 多重共线性发生在自变量相关联时。其中所有变量的相关系数必须小于 1。容差是多重共线性的另一种度量。公差由 T=1-R2 定义，其中 T < 0.1 可以是多重共线，T < 0.01 是多重共线。对于变量通货膨胀系数 (VIF)，VIF > 10 是变量间的多重共线性。
- 错误这个词通常会被传播。它测试形成直方图或 Q-Q 残差图。直方图应该是对称的钟形，并且 Q-Q 图的点应该在 45 度轴上。
- 误差定义的方差是常数。这称为同方差约束或恒误差方差。它使用散点图进行评估。 Breusch-Pagan 检验用于检验同质性。对独立变量执行额外的平方残差分析。
- 自相关发生在残基彼此不独立的地方。德宾-沃森 (DW)检查残基不自相关的零假设。低于 2 的 DW 统计表明附近的残差彼此相关。
- 如果 LR 做出可靠的预测，你的输入输出变量将是高斯分布。多元正态性在这种正态性下，所有变量都期望是多元的和正则的。使用直方图或 Q-Q 图识别。此外，使用 Kolmogorov-Smirnov 测试验证体能测试的正常性。当数据通常不用于翻译时，日志转换完成。
预测的准确度等级
Bermix 工作室在 Unsplash 拍摄的照片
- 残差的比例给出了一个清晰的例子，说明回归线如何有效地从 X 值估计 Y 值。这种计算被称为估计的标准误差。这是估计值的标准差。数字越小，预测就越精确。
- 使用公式 R2 测试模型的可靠性，该公式是 x 和 y 之间关联的平方。R2 越强，越适合。现在还在 0 和 1 之间。线性排列越强，R 越接近 1。
- 调整后的 R2 是一种额外的方法，将 R2 应用于方程中的解释变量的数量。这用于控制额外的解释变量是否是等式的一部分。R2 是这种联系的最强近似。调整后的 R2 可能为负，尽管事实并非如此。在过拟合设置中，实现了导致可预测性降低的高 R2 值。调整后的 R2 并非如此。添加到模型中的每个变量都会增加 R2，而不会减少。而调整后的 R2 仅在新的预测器加强 LR 模型时上升。
建立关系模型的替代方法
- 许多可供选择的解释因素是分类的，不能在定量尺度上测试。使用虚拟变量是一个技巧。虚拟变量是潜在值在 0 和 1 之间的变量。性别示例，季度。
- 你可能有两个解释变量的交互变量组合。在回归方程中包含一个交互变量，如果，你假设一个解释变量对 y 的影响依赖于另一个解释变量的值。
- 作为散点图中曲率结果的变量的非线性变换。你应该转换因变量 y 或者解释变量 x，或者你可以全部转换。它包括标准对数、平方根、倒数和平方。
为什么要在回归中记录变量？
- 变量有正确的偏斜，取一个对数将使变换后的变量的分布对称。但是这并不是记录变量的足够借口。没有将自变量或因变量控制为正态的回归规则。如果您的因变量或自变量中有异常值，对数变换会减少这种影响。
- 回归残差的方差随着回归预测的增加而增加。取因变量或自变量的对数可能会降低异方差。
- 您的回归残差方差随着您的回归预测而增长。取切异方差的因变量或自变量的对数。
- 你的回归残差不正常。这对你来说可能是也可能不是问题。即使残留物不常见。您应该记录因变量或自变量，并验证对数变换后的残差是否有规律。
- 如果因变量和自变量没有线性和指数关系。例如，收入的多少与食物消费相关。收入的成比例增长会使消费增加到一定的数量，之后，食品消费要么持平，要么下降。
自变量的相关性
T 他的潜在想法是吝啬用最少的东西展示最多的东西。它支持一个解释变量较少的模型。以下技术可用于确定线性回归方程中解释变量的显著性。
相关系数描述了 x 和 y 之间线性关系的强度和方向。假设检验有助于确定总体相关系数值是否接近零，或者是否不同于零。
当测试确定相关系数不为零时，相关系数很重要。如果测试显示相关系数接近于零，我们假设相关系数不显著。
有两种方法来检验使用 p 值和 t 统计量的显著性。
- 回归系数的 T 值，用于在回归方程中包括或排除解释变量。如果在 95%的置信水平下 p 值 <为 0.05，且回归方程中使用 t 统计量> 2，则假设该变量很重要。如果 t 统计量小于 1，那么这是一个统计事实，即如果该变量被排除在回归方程之外，标准误差将会减小，调整后的 R2 将会增加。
- F 检验确定已解释的变异相对于未解释的变异是否较高的方法。显著性的 f 检验是对线性关系的假设检验。它有一个允许测试运行的相关 p 值。如果 ANOVA 表的 F 值较大，而相应的 p 值较小。拒绝零假设，假设解释变量有一定的价值。
结论
R 广义上的回归分析。然而，它侧重于量化与自变量调整相关的因变量变化。这是因为所有的线性或非线性回归模型都将因变量与自变量联系起来。
现在，带着你对TwitterLinkedin，以及Github的想法！！**
同意 还是 不同意 与绍拉夫·辛拉的观点和例子？想告诉我们你的故事吗？
他乐于接受建设性的反馈——如果您对此分析有后续想法，请在下面 评论 或联系我们！！
推文@ SauravSingla _ 08，评论Saurav _ Singla，还有明星SauravSingla马上！
隔离森林:一种基于树的异常检测算法
关于异常检测算法的小数据科学
托德·夸肯布什在 Unsplash 拍摄的照片
这是我写的关于异常检测中常用的算法的一系列小文章中的第 10 篇(我会在最后放上所有其他文章的链接)。在今天的文章中，我将重点介绍一种基于树的机器学习算法——隔离森林——它可以有效地从多维数据集中隔离出离群值。
我在这里的目的是给出算法如何工作的直觉，以及如何用几行代码实现它作为演示。所以我不会深入理论，但足以帮助读者理解基础知识。如果您对算法的某个特定部分感兴趣，您可以随时搜索和查找细节。所以让我们开始吧！
什么是隔离林？
隔离森林或 iForest 是较新的算法之一，于 2008 年首次提出[1]，后来在 2012 年的一篇论文中发表[2]。大约在 2016 年，它被并入 Python Scikit-Learn 库。
它是一种基于树的算法，围绕决策树和随机森林理论构建。当呈现数据集时，该算法根据随机阈值将数据分成两部分。这个过程递归地继续，直到每个数据点被隔离。一旦该算法贯穿整个数据，它就过滤掉比其他数据点花费更少步骤的数据点，以将其隔离。sklearn中的隔离森林是集合模型类的一部分，它返回每个实例的异常分数来衡量异常。
图:分割数据以隔离隔离林中的异常(来源: Scikit-Learn )
在大多数非监督方法中，首先对“正常”数据点进行分析，如果异常数据点与该分析不相似，则报告异常数据点。另一方面，隔离森林采取了不同的方法；它明确地隔离异常数据点。
值得一提的是，隔离森林是一种无监督的机器学习算法。也就是说，该过程中不涉及实际的“训练”或“学习”,并且在数据集中不存在预先确定的“异常值”或“非异常值”标签。所以没有传统机器学习意义上的精度测试。
现在让我们用 5 个步骤来实现这个算法。
第一步:导入库
你将需要pandas和numpy来处理数据，需要matplotlib来进行数据可视化，当然，还需要sklearn库中的算法本身。
# libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import IsolationForest
第二步:准备数据
为了便于您理解，我没有导入任何外部数据集，而是创建了一个简单的二维numpy数组，其中只有一个异常值，如二维图所示。
# dataset
X = np.array([[1, 2], [2, 1], [3, 2], [0, 1], [25, 30], [3, 5]])# using just numpy array for visualization
plt.scatter(X[:,0], X[:,1], color = "r", s = 50)
plt.grid()
带有异常值的二维 numpy 数组
步骤 3:实例化并拟合模型
像 Scikit Learn 库中的大多数算法一样，实例化和拟合模型只需要几行代码。
构建模型的两个重要参数是 n_estimators 和contaminance，后者指定被识别为异常值的数据的百分比。
# instantiate model
model = IsolationForest(n_estimators = 10)# fit model
model.fit(X)
第四步:预测
当进行预测时，该过程包括向模型显示一个二维数组，该模型将对正常数据给出 1，对异常值给出-1。
# predict on new data
new_data = np.array([[10, 15]])
model.predict(new_data)>> array([-1])
第五步:异常分数
就像我在开始所说的，算法使用异常分数作为度量，它代表输入样本的平均异常分数。
# average anomaly score
model.decision_function(np.array(new_data))>> array([-0.11147288])
最后一个字
感谢您的阅读，希望这篇文章有助于您直观地了解什么是隔离林以及如何在 Python sklearn库中实现它。我在这份出版物中写了一系列文章，重点关注其他几种算法。如果你有兴趣去看看，下面是链接。和往常一样，请随时通过 Twitter 或 LinkedIn 联系我，并在 Medium 上关注我，获取最新文章的通知。
参考文献
[1]刘，费托尼，丁，，周，张志华.“隔离林。”数据挖掘，2008。08 年的 ICDM。第八届 IEEE 国际会议。
[2]刘，费托尼，丁，，周，张志华.“基于隔离的异常检测。”《美国计算机学会数据知识发现汇刊》6.1 (2012): 3。
隔离森林和 Pyspark 第 2 部分
经验教训
调试 PySpark 和隔离森林—图片由作者提供
因此，在使用隔离森林的 PySpark ml 实现运行了几次之后，我偶然发现了一些事情，我想我应该写下来，这样你就不会浪费我在故障诊断上浪费的时间。
只有密集向量
在上一篇文章中，我使用了VectorAssembler来收集特征向量。碰巧我的测试数据只创建了DenseVectors，但是当我在不同的数据集上尝试这个例子时，我意识到:
**VectorAssembler**可以在同一个数据帧中创建密集和稀疏向量(这很聪明，其他 spark ml 算法可以利用它并使用它)**Isolation Forest**(或者至少实现发现这里的 ) 不支持上面的，所以输入必须只有DenseVectors。
要演示该问题:
目前的解决方法是将所有矢量转换为密集矢量，不幸的是使用了 udf。
避免 OOM 和执行者的沟通问题
为大型数据集设置approxquantilerrelativeerror或 阈值 参数
如果你计划在一个大数据集上进行训练，比如超过 10M 行，即使你设置了maxSamples和maxFeatures这样的参数来降低维数，你也需要将approxQuantileRelativeError参数设置得合理一些，比如0.2。原因是approxQuantile函数是一个使用起来非常昂贵的函数，尤其是如果我们期望approxQuantileRelativeError是0.(这是默认值)。这样做，大大减少了训练时间和 OOM 与执行者的沟通问题，而且，到目前为止，我还没有看到预测准确性的任何下降。
从实施的评论来看:
*** The proportion of outliers in the data set (0< contamination < 1).
* It will be used in the prediction. In order to enhance performance,
* Our method to get anomaly score threshold adopts DataFrameStsFunctions.approxQuantile,
* which is designed for performance with some extent accuracy loss.
* Set the param approxQuantileRelativeError (0 < e < 1) to calculate
* an approximate quantile threshold of anomaly scores for large dataset.**
或者，在 fit 中预先设置threshold并避免approxQuantile计算，如下所示:
*model = iforest.fit(df, {**'threshold'**: 0.5})
print(model.getThreshold())> 0.49272560194039505*
希望这对您有所帮助并节省一些时间:)如果您有任何建议、更正或想法，请告诉我。
在此阅读有关如何将隔离林与 pyspark 一起使用的更多信息:
PySpark 隔离带的主要特点和使用方法
towardsdatascience.com](/isolation-forest-and-spark-b88ade6c63ff)
接下来去哪里？
理解模型的预测:
[## 机器学习的可解释性——带有 PySpark 的 Shapley 值
解读隔离森林的预测——不仅仅是
medium.com](https://medium.com/mlearning-ai/machine-learning-interpretability-shapley-values-with-pyspark-16ffd87227e3)*
从零开始隔离森林
从零开始实现隔离森林，以便进一步理解算法
最近，我一直在阅读隔离森林及其在异常值/异常检测方面的表现。在仔细阅读了算法之后(并且没有找到任何我喜欢的香草教程)。为了更好地掌握算法，我决定用最简单的方式从头开始编码。
这篇文章的目的是在阅读后，你可以深入了解隔离森林，它的优点，缺点，参数，你可以随时使用它，只要你考虑与算法的知识。
对于这个博客/实现，我使用了这篇关于隔离森林的论文作为伪代码，这篇扩展的隔离森林论文作为可视化(与另一篇博客文章相对应)，并使用了这个 youtube 教程示例来自 Sebastian Mantey 的随机森林实现
一点理论背景
在开始写代码之前，我认为需要一点理论。
什么是隔离林？
- 隔离林用于异常值/异常检测
- 隔离森林是一种无监督学习技术(不需要标签)
- 使用二进制决策树 bagging(类似监督学习中的随机森林)
假设
该方法将异常与正常情况隔离开来，为此，对异常进行了以下假设:
- 它们是由较少实例组成的少数
- 它们具有不同于普通实例的属性值
换句话说，异常是“少数和不同的。”
由于前两个假设，异常很容易被隔离，这使得它们更接近树根。
简要描述
隔离林为给定数据集构建一个二叉树集合。异常，由于它们的性质，它们在树中有比正常情况下最短的路径。
隔离森林使用非常少的树快速收敛，子采样使我们能够在计算高效的同时获得良好的结果。
代码
总体编码策略如下。首先对一棵树进行编码，然后进行树的森林(集合)，最后测量某个实例在每棵树中走了多远，并确定它是否是离群值。
让我们从树开始
隔离树:对树进行编码
[1]中的隔离树伪代码
输入将是数据样本、当前树高和最大深度。
对于输出，我们将有一个构建好的树。
为了更容易理解，我正在使用熊猫数据框，即使它在性能方面不是最佳的，也能让普通用户更容易理解。
- 选择数据的特征(列)
def select_feature(data):
return random.choice(data.columns)
- 在范围内选择一个随机值
def select_value(data,feat):
mini = data[feat].min()
maxi = data[feat].max()
return (maxi-mini)*np.random.random()+mini
- 分割数据
def split_data(data, split_column, split_value): data_below = data[data[split_column] <= split_value]
data_above = data[data[split_column] > split_value]
return data_below, data_above
- 一起:隔离树。
其思想如下:选择一个特征、该特征的值以及分割数据。如果分支中只有一个数据点，或者树已经达到最大深度:停止。
def isolation_tree(data,counter=0, max_depth=50,random_subspace=False):
# End Loop if max depth or isolated
if (counter == max_depth) or data.shape[0]<=1:
classification = classify_data(data)
return classification
else:
# Counter
counter +=1
# Select feature
split_column = select_feature(data)
# Select value
split_value = select_value(data,split_column) # Split data
data_below, data_above = split_data(data,split_column,split_value)
# instantiate sub-tree
question = "{} <= {}".format(split_column, split_value)
sub_tree = {question: []}
# Recursive part
below_answer = isolation_tree(data_below, counter,max_depth=max_depth)
above_answer = isolation_tree(data_above, counter,max_depth=max_depth)
if below_answer == above_answer:
sub_tree = below_answer
else:
sub_tree[question].append(below_answer)
sub_tree[question].append(above_answer)
return sub_tree
隔离森林
[1]中的隔离林伪代码
一旦我们有了自己的树，我们就要把它们变成一片森林。伪代码如下:
给定一个输入数据、一些树和一个采样大小(每棵树有多少数据),我们根据需要拟合尽可能多的树并返回一个森林。
实际代码:
def isolation_forest(df,n_trees=5, max_depth=5, subspace=256):
forest = []for i in range(n_trees):
# Sample the subspace
if subspace<=1:
df = df.sample(frac=subspace)
else:
df = df.sample(subspace) # Fit tree
tree = isolation_tree(df,max_depth=max_depth)
# Save tree to forest
forest.append(tree)
return forest
路径长度
在构建了隔离林之后，我们必须评估实例，为此我们定义了路径长度
来自[1]的路径长度伪代码
给定一个实例和一个隔离树，我们计算每个实例在被隔离或达到最大深度之前要经过多少个节点。
伪代码摘自隔离林论文。
def pathLength(example,iTree,path=0,trace=False): # Initialize question and counter
path=path+1
question = list(iTree.keys())[0]
feature_name, comparison_operator, value = question.split()
# ask question
if example[feature_name].values <= float(value):
answer = iTree[question][0]
else:
answer = iTree[question][1]
# base case
if not isinstance(answer, dict):
return path
# recursive part
else:
residual_tree = answer
return pathLength(example, residual_tree,path=path)return path
这只是根据以前存储数据的方式来计算一个实例经过了多少个节点。
估价
让我们四处看看
mean = [0, 0]
cov = [[1, 0], [0, 1]] # diagonal covariance
Nobjs = 2000
x, y = np.random.multivariate_normal(mean, cov, Nobjs).T
#Add manual outlier
x[0]=3.3
y[0]=3.3
X=np.array([x,y]).T
X = pd.DataFrame(X,columns=['feat1','feat2'])
plt.figure(figsize=(7,7))
plt.plot(x,y,'bo');
数据样本
我们将用我们的数据进行训练和评估。
iForest = isolation_forest(X,n_trees=20, max_depth=100, subspace=256)# Evaluate one instance
def evaluate_instance(instance,forest):
paths = []
for tree in forest:
paths.append(pathLength(instance,tree))
return paths
我们选择数据的一个正常实例(随机选择)和一个异常值(记得我们在开始时硬编码了一个异常值作为第一行)。我们看它在树上落下多远，然后画出结果。
outlier = evaluate_instance(X.head(1),iForest)
normal = evaluate_instance(X.sample(1),iForest)
蓝色表示随机正态样本，红色表示异常值。
np.mean(outlier)
# 4.85
np.mean(normal)
# 12.55
异常值和正常样本的每棵树的树深度
我们可以看到，在正常样本和异常值之间，在每个树中实例的深度方面存在视觉和统计差异。
从扩展隔离森林的论文中，有另一种放射状的可视化形式，提供了对离群值的清晰直觉
如果节点深度(a)和径向深度(b)由[2]形成，则为正常与异常值
评估森林的更正式的方法是使用实例(x)的异常分数:
异常分数
其中 H(i)是谐波数，可以通过 ln(i) + 0.5772156649(欧拉常数)来估算。由于 c(n)是给定 n 的 h(x)的平均值，我们用它来归一化 h(x)。
def c_factor(n) :
"""
Average path length of unsuccesful search in a binary search tree given n points
Parameters
----------
n : int
Number of data points for the BST.
Returns
-------
float
Average path length of unsuccesful search in a BST
"""
return 2.0*(np.log(n-1)+0.5772156649) - (2.0*(n-1.)/(n*1.0))def anomaly_score(data_point,forest,n):
'''
Anomaly Score
Returns
-------
0.5 -- sample does not have any distinct anomaly
0 -- Normal Instance
1 -- An anomaly
'''
# Mean depth for an instance
E = np.mean(evaluate_instance(data_point,forest))
c = c_factor(n)
return 2**-(E/c)
使用这种方法，我们可以得到异常值的数学定义，但我相信，到此为止，您已经可以直观地了解算法是如何工作的，参数是什么，以及在哪些情况下它可能会成功。
请随意发表任何评论或给我发短信，告诉我你的建议或其他任何事情。
参考
这个博客已经完成如下
- [1] 隔离林论文为伪代码出自费托尼刘、廷和
- [2] 扩展隔离森林用于可视化(与另一篇博文相对应)
- [3] Youtube 随机森林实现来自 Sebastian Mantey
完整的代码、笔记本和图片可以在这个资源库中看到
隔离林存储库。通过在 GitHub 上创建帐户，为 cmougan/IsolationForest 的发展做出贡献。
github.com](https://github.com/cmougan/IsolationForest)
隔离森林是目前针对大数据的最佳异常检测算法
理解大数据
Isolation forest 或“iForest”是一个非常漂亮、非常简单的算法，可以用很少的参数识别异常。原始论文面向广大读者，包含最少的数学内容。在本文中，我将解释为什么 iForest 是目前针对大数据的最佳异常检测算法，提供该算法的摘要、该算法的历史，并分享一个代码实现。
为什么 iForest 是目前大数据的最佳异常检测算法
同类最佳的性能概括了。基于 ROC 性能和精度，iForest 在各种数据集上的表现优于大多数其他离群点检测(OD)算法。我从PythonOut lierDdetection package(PyOD；原始论文)并在 Excel 中应用了逐行绿-红渐变条件格式。深绿色表示数据集的最佳算法，深红色表示性能最差:
我从 PyOD(PythonOut lierDdetection toolbox)获取基准数据，并在 Excel 中应用行范围的绿-红渐变条件格式。绿色表示“好”，红色表示“坏”。我们看到，iForest 在大多数数据集和总体上领先，如均值、中值和标准差颜色所示。图片来源:作者。数据来源:https://pyod.readthedocs.io/en/latest/benchmark.html
我们看到，iForest 在大多数数据集和总体上领先，如我计算的均值、中值和标准差行的颜色所示。iForest 的出色结果同样适用于 precision @ N 性能:
图片来源:作者。数据来源:【https://pyod.readthedocs.io/en/latest/benchmark.html
扩展性。就其性能而言，iForest 是执行速度最快的算法。PCA 和基于直方图的异常值分数(HBOS论文、海报)在所有数据集上都比预期的要快。k-最近邻(KNN)要慢得多，并且随着更多的观察而可怕地扩展。
在集群环境中，我已经成功地用包含 100 万个观察值的数据集构建了隔离森林，这些观察值有 36 列，数量级为几分钟。我不能对 sk-learn 的 KNN 说同样的话。
图片来源:作者。数据来源:https://pyod.readthedocs.io/en/latest/benchmark.html
算法要点/总结
我将提供一份 10 页纸的简要总结，概述如下:
- 大多数其他异常值检测(OD)算法试图建立“正常”实例的轮廓，然后标记不符合该正态轮廓的实例。iForest 通过利用异常的固有属性来明确隔离异常记录:它们对于协变量集具有不寻常的值。
- 由于计算开销，现有方法局限于低维数据和小数据量。例证:有没有在大数据上尝试过
[sklearn.neighbo](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.neighbors)r.KNeighborsClassifier？😃 - 此外，iForest 具有“低常数和低内存需求”，即低开销。细节:外部节点的数量是 n ，因为每个观察值 n 都是独立的。内部节点总数明明是 n-1 ，节点总数是 *2n-1。*因此，我们看到了为什么内存需求是有限的，并且随着 n. 线性增长
- 隔离树节点定义: T 或者是无子外部节点，或者是具有一个测试和恰好两个子节点的内部节点(Tₗ，Tᵣ).为了构建一个 iTree，我们通过随机选择一个属性 q 和一个分割值 p 来递归分割 X ，直到(I)树达到一个高度限制，(ii)所有的观察值在它们自己的外部节点被隔离，或者(iii)所有的数据对于所有的属性具有相同的值。
- 路径长度。观察值 x 的路径长度 h(x) 由从根节点到外部节点终止的横向遍历 iTree 的边数 x 测量。 E(h(x)) 是来自隔离树集合的 h(x) 的平均值。异常分数 s(x，n) 可以从平均路径长度 E(h(x)) : s(x，n) = 2^[− E(h(x)) / c(n)】中导出。基本上， s 和 E(h(x)) 之间存在单调关系(详见最后的附录和说明它们关系的帮助图)。我不会讨论术语 c(n) ，所以我可以保持简短，但它对于任何给定的静态数据集都是常数。
- 仅要求用户设置两个变量:要构建的树的数量和子采样大小。作者提出了使用生成的高斯分布数据的实验，该实验显示了如何用很少的树和小的子样本相对快速地实现平均路径长度的收敛。
- 小的子采样(样本中的样本)解决了淹没和掩蔽问题。淹没和掩蔽是由对于异常检测目的而言太大的输入数据引起的。淹没是当一个“正常”的观察被误认为是一个“异常”的观察，因为它被异常所包围，而掩蔽是相反的。换句话说，当一棵树被提供了一个包含大部分异常的样本时，一个正常的数据点可能看起来是异常的。作者提出了这种现象的乳房 x 线照片数据的例子。
- 小的子样本允许每个隔离树特殊化，
因为每个子样本包括一组不同的异常或
甚至没有异常 - iForest 不依赖任何基于距离或密度的措施来识别异常，因此它速度快，计算成本低，这就引出了下一点
- 线性时间复杂度，O(n)。通俗地说，这意味着运行时间最多随着输入的大小线性增加**。这个不错😗*
11.对于具有相关背景的读者来说，论文中的以下图表清楚地说明了算法是如何工作的:
图片来源:刘、汀、周的《隔离林》。
算法历史
博览群书的读者都知道，一个伟大的新想法和更广泛的采用之间的时滞可能长达几十年。例如，逻辑函数在 1845 年被发现，在 1922 年被重新发现(阅读更多)，现在被现代数据科学家定期用于逻辑回归。近几十年来，一个新想法和它被更广泛地采用之间的时间差已经缩短了，但仍然可以说是一段很长的时间。iForest 于 2008 年首次共享，商业上可行的应用程序直到 2018 年底才发布！下面的时间线:
2008 年 12 月— iForest 发布的原始论文(论文)
2009 年 7 月—I forest 作者最后一次修改他们的代码实现(代码)
2018 年 10 月— h2o 团队向 R 和 Python 用户提供 I forest(代码)
2019 年 1 月— PyOD 为 Python 用户发布离群点检测(OD)工具包(代码，论文)
代码实现
因为本文是关于大数据的，所以我假设一个集群环境。我下面的实现可以处理存储在 AWS S3 中的数据，但只需稍加修改就可以在其他地方使用。代码搭建(QA 对象、调试等的代码。)大多省略。需要为 AWS 集群环境安装软件包的帮助吗？参见我的中型文章:如何为 SparkSQL 设置经济高效的 AWS EMR 集群和 Jupyter 笔记本
我发现 iForest 可以轻松快速地处理 750 万行和 36 个特征，在几分钟内完成计算。
Python (h2o):
下面的直方图由上面的代码生成。对于我的数据框predictions_fullX中的观察结果，大多数观察结果并不异常，如较大平均路径长度的频率所证明的。
图片来源:作者使用专有数据集
如果您的数据有您想要用 iForest 确证的标签，您可以将正常实例集的分布与异常实例集的分布进行比较，并与原始数据集进行比较，以便进一步推断。例如，您可以通过原始数据集中要素的不同组合来查看计数，如下所示:
N = df.count()
df[['v1', 'v2', 'id']].groupby(['v1', 'v2']).count() / N
df[['v1', 'v3', 'id']].groupby(['v1', 'v3']).count() / N
...
并与 iForest 确定的正常/异常实例集进行比较，如下所示:
我完成了所有这些工作，还将我的数据导出到 Excel 中，以快速生成一些累积分布函数，如下所示:
图片来源:作者本人作品。绿线代表 label=1，或已知的正态观测值；红线代表标签=1 的观察值，确认为可能异常或可能不异常。
Python (pyod) (如果评论中有要求，我会添加代码！)
更新(2020 年 12 月 15 日)，PyOD 代码:
在 PyOD github ( link )上有很多很棒的例子，所以我不认为我有必要编造一个。如果你对 GitHub repo 上没有的 PyOD 代码有特殊要求，请在评论中告诉我。Github 不会向您显示结果应该是什么样子，所以我的增值功能可以向您显示代码应该输出什么，以防您在这方面遇到困难。
https://github . com/yzhao 062/pyod/blob/master/examples/ocsvm _ example . py 的输出应该类似于:
图片来源:作者
Scala (即将推出)
我使用 LinkedIn 团队对 Scala 的 iForest ( github )实现，因为 PyOD 和 h2o 是针对 Python 的。目前还不能让它工作，但当我可以的时候会更新。
参考
- F.刘铁男、丁国明、周志宏。隔离林。摘自:《第八届 IEEE 数据挖掘国际会议论文集》(ICDM’08) ，意大利比萨，2008 年，第 413–422 页。本文获得了 2008 年 IEEE ICDM 会议理论/算法亚军最佳论文奖
- 赵，杨，纳斯鲁拉，和李，2019。PyOD:用于可伸缩异常检测的 Python 工具箱。机器学习研究杂志(JMLR)，20(96)，第 1–7 页。
关于作者
安德鲁·杨是 Neustar 的 R&D 数据科学家经理。例如，Neustar 是一家信息服务公司，从航空、银行、政府、营销、社交媒体和电信等领域的数百家公司获取结构化和非结构化的文本和图片数据。Neustar 将这些数据成分结合起来，然后向企业客户出售具有附加值的成品，用于咨询、网络安全、欺诈检测和营销等目的。在这种情况下，Young 先生是 R&D 一个小型数据科学团队的实践型首席架构师，负责构建、优化和维护一个为所有产品和服务提供信息的系统，该系统为 Neustar 带来了超过 10 亿美元的年收入。在 LinkedIn 上关注 Andrew，了解数据科学的最新趋势！
更多热门文章:
附录
算法要点/总结，第 5 点细节:
- 当 E(h(x)) → c(n)，s → 0.5(观测不是明显异常)
- 当 E(h(x)) → 0，s → 1(异常)
- 当 E(h(x))→n1，s → 0 时(非异常)
所以用这篇论文的话来概括上述内容:
- (a)如果实例返回的 s 非常接近 1，那么它们肯定是异常，
- (b)如果实例的 s 远小于 0.5，那么它们被视为正常实例是相当安全的，并且
- 如果所有实例都返回 s ≈ 0.5，那么整个样本实际上没有任何明显的异常。
说明异常分数 s 和平均路径长度 E(h(x)) 之间关系的有用图
图 2 来自隔离林纸。
It from Bit:人工智能如何塑造我们的物理世界
人工智能只是一个“数字事物”，还是它正在彻底改变我们的物理世界？
它只是“一点”？
先驱物理学家约翰·阿奇博尔德·惠勒曾用诗意的“比特的信息”总结了信息的“空灵”概念和我们的物质物理现实之间错综复杂的相互联系。像充斥在我们电子设备中的由 1 和 0 组成的无形实体，实际上正在“构成”和塑造我们的物理世界。
人工智能:一堆比特……以及它如何影响物理世界。
人工智能是一个同样虚无缥缈的概念，由 0 和 1 构建的抽象数学实体组成，这些实体对模拟神经元和突触的结构和功能进行编码，最终赋予人工智能学习和预测真实世界的能力，这些真实世界类似于我们生物大脑产生的世界。
然而，我们生活在一个由物质构成的世界:人、房子、桌椅、建筑、飞机、火车和汽车。人工智能这个抽象的东西对我们日常的物理现实有什么真正的影响？
虽然人工智能已经被证明能够为聊天机器人提供动力，能够与客户互动，查看安全摄像头，寻找你心爱的亚马逊包裹的可能小偷，并帮助脸书和谷歌了解如何为你看到更多广告，但它对我们的物理世界有何影响？
很微妙，但是很大。让我给你举一个例子，我认为这是地球上存在的最有形的“东西”之一……制造业，正是这个过程构建了构成我们人类世界的万物。
人工智能如何塑造我们建造事物的方式
人工智能正在改变我们的物理世界的一个主要领域是制造业，从产品一致性到质量控制，在简化制造供应链和主动设备维护方面。
人工智能是真实的…例如，在制造业。
想象一个充满制造机器的现代化工厂。例如，在质量控制方面，人工监督只能做这么多，而机器每小时生产数百种产品。人类工人，在制造业中是一种微不足道的商品，根本不能也没有能力发现每一个不完美和缺陷。
人工智能在制造车间的引入极大地改变了工厂提高产品缺陷检测和质量保证的方式，将生产率提高了 50%或更多。这些都是真实的，人工智能的物理效果，每个人都可以触摸和量化！
而这只是冰山一角！根据 IDC 的数据，到 2021 年，20%的领先制造商将依赖人工智能和其他技术，麦肯锡发现，在未来五到七年内，将人工智能嵌入数据密集型制造流程的 50%的公司将有机会使现金流翻倍。
除了制造业中精致的物理例子，影响我们物理世界的其他人工智能包括，例如，零售业，智能软件能够理解客户行为，帮助商店在销售点向他们提供更有针对性的有趣产品。或者医疗保健，在人工智能的帮助下，我们的身体将得到更好、更快、更普遍的诊断。由于物联网中集成的高级人工智能，我们的家正在通过管理照明、温度和其他设置来改变我们大部分时间所在的物理环境。此外，最重要的是，我们自己的钱包将受到人工智能的好处(积极)影响，人工智能可以根据用户的风险偏好准确有效地优化股票投资组合。
数字化正成为我们现实中越来越不可或缺的一部分，数十亿物联网传感器、移动设备和联网机器正在进入我们的物理世界，重新融入 it 动作、见解，并从根本上改变它，人工智能技术是其核心。
所以，下次你坐在咖啡店里阅读下一篇关于人工智能的文章时，记住它不仅仅是比特。相反，它是夹在真实物理系统之间的一个非常重要的软件，在真实物理系统中，信息一直被不断地获取、理解和处理。
欢迎来到无处不在的物理智能时代。
学习“如何学习数据科学”是一门技能
有助于你轻松学习的有用建议
数据科学领域发展迅速，导致员工供不应求。尝试实施和利用数据科学的企业数量也在不断增加。因此，越来越多的人选择在数据科学领域开始职业生涯。在大多数情况下，在开始数据科学职业生涯之前，您需要学习一定程度的知识。根据你的策略，学习过程可以是顺利的、愉快的或彻底的。
这篇文章的目的不是给你一个学习的指南或者你需要知道的事情的清单。我宁愿分享一些在学习过程中对我帮助很大的小技巧。
Jelleke Vanooteghem 在 Unsplash 上拍摄的照片
资源的数量实在是太多了。你可能会遇到这样的帖子:
- 你必须阅读的 5 本书…
- 你应该参加的 10 门在线课程…
- 阅读 12 篇博客…
- 关注 20 个 youtube 频道…
去学数据科学。
这样的例子不胜枚举。轻松获取资源学习绝对是好事。大量的资源使自学过程成为可能。然而，你需要一个结构良好的计划来学习而不浪费时间，因为时间(最重要的资源)是有限的。我们当然应该利用各种容易获取的资源，但是要以一种系统的、结构良好的方式。
我不会分享一个需要学习的东西的清单或者为你画一个路线图，而是分享我作为一个喜欢学习新事物的人的经验和想法。
数据科学领域是一个新兴领域。这个领域正在进行大量的研究，因此这个领域的进步和新技术不断涌现。新的库和框架很快就会发布。现有的正在不断更新。一个常用的框架可能会在很短的时间内失去其受欢迎程度或被一个新的框架所取代。我绝对不反对这些更新或新版本。跟上技术的进步是非常好的，每个新版本都在现有版本的基础上增加了一些东西。然而，我们不可能用数据科学所有子领域的每一个新版本来更新自己。
数据科学是一个广阔的领域，存在特定于领域的技术。例如，BERT 是一种用于自然语言处理(NLP)的技术。如果你不打算在 NLP 工作，你不必学习 BERT。数据科学中也有特定于某个领域的技术。因此，请不要对这巨大的资源感到疲惫。我们不能什么都学，而应该专注于我们所在的领域或计划工作的领域。
学习基础知识
我们需要对基础知识有一个全面的了解。所有这些技术的基础构件是线性代数。数据可以是数字、文本、图像、声音或视频的形式，但计算机只有一种形式的数据源。那是数字。每一个数据源都必须转换成数字，以便计算机或模型进行分析。这些数字可以是很长的数组或高维矩阵的形式。这是线性代数的领域。如果我们彻底学习线性代数，我们可以很容易地适应新技术，并理解背后的理论。
另一个非常重要的学习主题是统计学，它有助于我们理解数据。统计数据可以推断出乍一看很难看出的趋势。它提供了关于数据底层结构的有用而强大的见解。例如，概率和频率分布的概念允许很好地使用和感知数据。无论您使用什么工具，全面的统计学知识在任何数据科学领域都是至关重要的。
欺骗没有任何好处！
我在网上看到了很多熊猫，小熊猫，Scikit Learn 或者其他一些小抄。你不应该试图用小抄来学习，除非你自己做。浏览小抄似乎更容易，你会觉得你理解了上面的一切。是的，你理解但不学习。如果你总是使用小抄来学习，你可能最终不得不经常看它们。然而，如果你准备自己的小抄，你就在准备的时候学习。
理解和学习是不一样的！
我想在这里举个例子。假设你有一节数学课。讲师会在课堂上解释这个主题，并给你 20 个问题来巩固你的知识。你有一个朋友是这方面的专家，你有两个选择:
- 请你的朋友帮忙。他在一小时内为你解释并解决 20 个问题。
- 你试着自己解决问题。你花了 5 个小时，只能完成 3 道题。
我坚信你在第二种选择中学到了更多。我不是神经科学家，但我认为当我们努力学习时，我们的大脑建立了强大的连接。请记住，我们的大脑是一个巨大而复杂的神经网络。
根据尼克·达姆的这篇文章
当学习经历不活跃时，作为大脑学习基础的神经连接的变化似乎不会发生。许多研究表明，积极参与是大脑变化的先决条件。
因此，积极的体验对学习来说是至关重要的，很明显，按照小抄做并不是积极的体验。
主动学习的一个好方法是做个人项目。
做个人项目！
你可能会在许多博客文章、故事甚至是工作面试中遇到这个建议。是的，做个人数据科学项目非常关键。我不会提到个人项目是展示你知识的有力方式，这个话题留给招聘经理吧。
我想提一下个人项目如何帮助学习过程:
- 您将了解从数据收集到模型评估的典型数据科学项目流程。
- 您将学习如何收集和清理原始数据。
- 如果你提出一个问题，并使用数据科学技术来解决它，那就更好了。通过这种方式，您还将了解数据科学为什么有用以及如何有用。你甚至可能会想出一个绝妙的主意。
- 你肯定会遇到一个问题，却不知道如何解决它。当你在 medium、stackoverflow 或其他网站上搜索答案时，你不仅找到了问题的解决方案，还找到了许多其他有用的东西。这类似于花几个小时在一个数学问题上。你最终会学到永远不会忘记。
- 熟能生巧。
结论
最后，我想总结一下我的建议:
- 不要因为大量的信息和工具而感到疲惫。你不必学所有的。
- 准备好自己的学习路线图。
- 掌握线性代数和统计的基本概念。
- 准备你自己的小抄。
- 做个人项目。
一如既往，熟能生巧。
感谢您的阅读。如果您有任何反馈，请告诉我。
使用 Python 进行意大利新冠肺炎分析
照片由 Gerd Altmann 从 Pixabay 拍摄
本教程分析了意大利民间保护组织发布的关于新冠肺炎的数据，并建立了流行病结束的预测。在下面的文章中描述了这个预测器背后的一般概念:https://medium . com/@ angelica . lo duca/predicting-the-end-of-the-coronavirus-epiderations-in-Italy-8da 9811 f 7740。代码可以从我的 github 资源库下载:https://github . com/alod 83/data-science/tree/master/data analysis/新冠肺炎。
本教程的主要目的在于建立一个预测器，用于预测意大利新冠肺炎疫情新发病例的可能结束时间。建议的教程是基于意大利的数据，但它也可以推广到其他国家的数据。例如，关于西班牙的数据可在此链接获得:https://github . com/data dista/datasets/tree/master/COVID % 2019。
到目前为止，已经提出了不同的方法，例如 R0 传染指数(详见此处和)。然而，在新冠肺炎流行病的情况下，估计 R0 并不简单。相反，本教程中提出的模型是基于对真实数据的观察，并且使用哪条曲线来拟合数据的决定是基于这样的观察。
本教程的一个可能的扩展是构建一个预测意大利整个流行病结束的预测器，即没有新的阳性病例登记的时间。这方面将是未来文章的主题。
笔记本利用了pandas和scikit-learn库。
输入数据
从 Github 存储库导入 CSV 并构建 EPI
首先，我们从意大利 Protezione Civile 的 Github 库导入数据，然后计算流行病进展指数(EPI)。我们提取列totale_casi，其中包含自疫情开始以来的新冠肺炎感染总数，以及tamponi，其中包含自疫情开始以来的新冠肺炎拭子总数。我们将 EPI 存储在y变量中。最后，我们打印所有有数据的日期列表(data['data'])。
data = pd.read_csv(“[https://raw.githubusercontent.com/pcm-dpc/COVID-19/master/dati-andamento-nazionale/dpc-covid19-ita-andamento-nazionale.csv](https://raw.githubusercontent.com/pcm-dpc/COVID-19/master/dati-andamento-nazionale/dpc-covid19-ita-andamento-nazionale.csv)")
tc = data[‘totale_casi’]
tt = data[‘tamponi’]
y = []
tt_increase = []
for i in range(1, len(tt)):
current_epi = (tc[i] — tc[i-1])/(tt[i]-tt[i-1])*100
tt_increase.append(tt[i]-tt[i-1])
y.append(current_epi)
data[‘data’]
现在我们计算有数据的日子。我们可以使用变量data['data']。但是，这个变量是一个字符串，所以很难用它来拟合预测值。因此，我们使用一个通用变量X，它包含一个数字序列，从 1 到样本总数。
X = []
for i in range(1, len(y)+1):
X.append([i])
初步情节
绘制 EPI 与天数的关系图，以及两条垂直线，分别代表限制法的开始及其效果
现在我们可以绘制 y 对 X，也就是绘制 EPI 对天数。我们还绘制了两条额外的线:1)对应于限制法则开始的日期，2)曲线开始下降的日期(一周后)。这两条线在剧情展示的时候就可以理解了。
在意大利，限制法律始于 3 月 9 日，相当于第 14 天。换句话说，它对应于y和X变量中的 14 行。从 3 月 9 日开始的一个星期后，限购令的效果就会显现出来。他们就这样在第 21 天开始了。
# vertical line corresponding to the beginning of restriction laws.
di = 14
restrictions_x = [di,di,di,di,di,di]
restrictions_y = [0,10,20,30,40,50]# vertical line corresponding to the beginning of effects of restriction laws (after a week)
de = di + 7
effects_x = [de,de,de,de,de,de]
effects_y = [0,10,20,30,40,50]
de
现在我们可以绘制图表。我们可以通过xticks()函数将X值转换成日期。
import matplotlib.pyplot as pltplt.scatter(X, y, color=’black’)
plt.plot(restrictions_x,restrictions_y, color=’red’, linewidth=2)
plt.plot(effects_x,effects_y, color=’green’, linewidth=2)
plt.grid()
plt.xlabel(‘Days’)
plt.xlim(0,40)
plt.ylim(0,50)
plt.xticks([0,5,10,15,20,25,30,35,40],
[“24 Febr”, “29 Febr”, “5 Mar”, “10 Mar”, “15 Mar”, “20 Mar”, “25 Mar”, “30 Mar”, “4 Apr”])plt.ylabel(‘Epidemics Progression Index (EPI)’)
plt.savefig(“EPI-all.png”)
plt.show()
我们注意到 EPI 从 3 月 16 日开始下降，也就是限制法令颁布后整整一周。因此，我们可以用线性回归来逼近从 3 月 16 日开始的曲线，该曲线递减。
建立模型
建立代表 EPI 的线性回归方程，拟合回归方程并计算分数
我们从sklearn库中导入linear_model。然后我们从 3 月 16 日之前的X和y数据中剔除，并用X和y拟合LinearRegression模型。最后，我们通过score()函数计算模型的得分。
import numpy as np
from sklearn import linear_model
X = X[de:]
y = y[de:]print(X)
# Linear Regression
linear_regr = linear_model.LinearRegression()# Train the model using the training sets
linear_regr.fit(X, y)linear_regr.score(X,y)
预测未来趋势
使用回归变量预测未来趋势。也计算误差
拟合后，我们通过函数predict()建立代表数据的线性曲线，并通过应用于y的真实值和预测值y_pred的函数max_error()计算模型的最大误差。该误差将用于构建两条新的线，最大线和最小线，这两条线将定义新样本移动的范围。
from sklearn.metrics import max_error
import mathy_pred = linear_regr.predict(X)
error = max_error(y, y_pred)
error
现在，我们可以应用该模型来预测未来几天的 EPI。我们构建了一个变量X_test，它包含过去的日子(即数据已经可用的日子)和未来的日子。我们定义包含预测天数的变量gp。
然后我们将我们的模型应用到X_test。
X_test = []gp = 40for i in range(de, de + gp):
X_test.append([i])y_pred_linear = linear_regr.predict(X_test)
变量y_pred_linear包含未来几天的预测 IPE。然而，我们也应该考虑模型产生的误差。因此，我们构建两个新变量y_pred_max和y_pred_min，分别包含y_pred + error和y_pred - error。
y_pred_max = []
y_pred_min = []
for i in range(0, len(y_pred_linear)):
y_pred_max.append(y_pred_linear[i] + error)
y_pred_min.append(y_pred_linear[i] — error)
绘图结果
画三条线，分别代表预测的输出，最大误差和最小误差
现在我们准备绘制数据(y_pred、y_pred_max和y_pred_min)。为了让情节更吸引人，我们应该将数字(由X_test变量表示)转换成日期。因此，我们维护两个变量x_ticks和date_prev，它们分别包含X_test和相应标签的子集…
为了建立x_ticks和date_prev之间的映射，我们从变量data['data']中提取限制的日期，并通过函数datetime.strptime()将其转换为日期。我们将结果存储在变量data_eff中。
我们构建x_ticks，通过对X_test的每一个step物品进行抽样。我们定义date_prev[0] = data_eff。对于每一项，我们可以通过将step添加到前一项来构建date_prev。
from datetime import datetime
from datetime import timedeltadata_eff = datetime.strptime(data[‘data’][de], ‘%Y-%m-%dT%H:%M:%S’)
# date previsione
date_prev = []
x_ticks = []
step = 5
data_curr = data_eff
x_current = de
n = int(gp/step)
for i in range(0, n):
date_prev.append(str(data_curr.day) + “/” + str(data_curr.month))
x_ticks.append(x_current)
data_curr = data_curr + timedelta(days=step)
x_current = x_current + step
现在我们可以画出所有的线。
plt.grid()
plt.scatter(X, y, color=’black’)plt.plot(X_test, y_pred_linear, color=’green’, linewidth=2)
plt.plot(X_test, y_pred_max, color=’red’, linewidth=1, linestyle=’dashed’)
plt.plot(X_test, y_pred_min, color=’red’, linewidth=1, linestyle=’dashed’)plt.xlabel(‘Days’)
plt.xlim(de,de+gp)plt.xticks(x_ticks, date_prev)
plt.ylabel(‘Epidemics Progression Index (EPI)’)
plt.yscale(“log”)plt.savefig(“EPI-prediction.png”)
plt.show()
EPI 的 0 值预测
预测 EPI 何时为 0，即代表 EPI 的线何时穿过 X 轴
首先，我们计算一个辅助函数，它将数字转换为日期。该功能将视为开始日期data_eff。
def n_to_date(n):
return data_eff + timedelta(days=n-de)
现在我们可以计算这条线何时穿过 x 轴。提醒一下，一条线的方程是 y = ax + b，x 轴的方程是 y = 0。因此，我们必须求解包含这两个方程的系统。结果 x = -b/a。
data_zero = round(- linear_regr.intercept_ / linear_regr.coef_[0])
n_to_date(data_zero)
前面的计算只对回归定义的直线进行。现在我们还应该计算y_pred_max和y_pred_min的值。我们定义一个辅助函数，叫做build_line()，从两点构建一条线，返回这条线的系数。
def build_line(x1,y1,x2,y2):
m = float(y2 — y1)/(x2-x1)
q = y1 — (m*x1)
return [m,q]
现在我们可以计算出y_pred_min和y_pred_max的结束日期。我们将 max 的零日期近似为获得值的ceil()，将 min 的零日期近似为获得值的floor()。
import math
line_max = build_line(X_test[0][0], y_pred_max[0], X_test[1][0], y_pred_max[1])
data_zero_max = math.ceil(- line_max[1] / line_max[0])
n_to_date(data_zero_max)line_min = build_line(X_test[0][0], y_pred_min[0], X_test[1][0], y_pred_min[1])
data_zero_min = math.floor(- line_min[1] / line_min[0])
n_to_date(data_zero_min)
预测一般日期的 EPI 值
通过添加代码来计算一般日期的 EPI 值，从而扩展本教程
我们定义了一个名为date_to_n()的辅助函数，它将一个通用日期转换为自开始日期起的天数。然后，我们将模型应用于获得的值。
def date_to_n(my_date):
initial_date = datetime.strptime(data[‘data’][0], ‘%Y-%m-%dT%H:%M:%S’)
return (my_date — initial_date).days + 1my_date = datetime.strptime(“2020–04–05”, ‘%Y-%m-%d’)
n = date_to_n(my_date)
predict = linear_regr.predict([[n]])
预测感染的最大数量
在 EPI 的基础上，用逆方程计算感染总数。情节也是结果
现在我们可以建立感染总数的最大值。我们可以利用 EPI 的公式:y_pred[i] = (tc[i] - tc[i-1])/(tt[i]-tt[i-1])*100来计算tt[i] = y_pred[i]*/(tt[i]-tt[i-1])*100) + tc[i]的值。差值tt[i]-tt[i-1]代表i时刻的拭子数量，因此我们可以将其近似为data['tamponi']的平均值(存储在变量tt_increase中)。或者，我们也可以将差值计算为最小值或最大值。因此，我们计算tt(称为avg_tt)的平均值作为tt_increase[de:]的度量。度量作为函数的参数传递。
def average(mylist):
return sum(mylist)/len(mylist)# calculate the plateau considering the average increase of swabs
def plateau(y_pred,data_end,metrics):
avg_tt = metrics(tt_increase[de:])np_avg = []
#np_start = data[‘totale_casi’][len(data[‘totale_casi’])-1]
np_start = data[‘totale_casi’][de]
np_avg.append(np_start)for i in range(0, data_end-de):
np = y_pred[i]*avg_tt/100 + np_avg[i-1]
np_avg.append(np)
last_value = max(np_avg)
for i in range(0, gp-len(np_avg)):
np_avg.append(last_value)
return np_avg
现在，我们可以通过将最大值视为度量来计算y_pred_min、y_pred_max和y_pred_linear的平稳状态。
plateau_min = plateau(y_pred_min,data_zero_min, max)
plateau_max = plateau(y_pred_max,data_zero_max, max)
plateau_avg = plateau(y_pred_linear,int(data_zero), max)
最后，我们绘制结果并打印最大值。
plt.plot(X_test,plateau_min, color=’red’, linewidth=1, linestyle=’dashed’)
plt.plot(X_test,plateau_max, color=’red’, linewidth=1, linestyle=’dashed’)
plt.plot(X_test,plateau_avg, color=’green’, linewidth=2)
plt.scatter(X,tc[de+1:], color=’black’, linewidth=2)
plt.xlabel(‘Days’)
plt.xlim(de,de+gp)
#plt.ylim(0,50)
plt.xticks(x_ticks, date_prev)
#plt.yticks([0,20,30,40,50,60])plt.ylabel(‘Total number of positives’)
plt.grid()
plt.show()
吸取的教训
本教程描述了一个简单的方法来建立一个预测意大利新冠肺炎流行病的结束。从本教程中，我们了解到:
- 在构建预测器之前，必须进行初步的数据探索。事实上，如果我们在所有可用数据上建立预测器(即从 2 月 24 日开始)，我们就不会使用线性回归来建立它；
- 预测器的建立还应考虑到现实生活(在我们的案例中，是意大利政府引入的限制法及其一周后的效果)；
- 一旦建立了预测器，也应该考虑误差。因此，必须计算误差范围，以便有更准确的预测；
- 真实(新)数据和预测值之间的比较总是受欢迎的，因为它允许您验证模型是否正确。
编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
Python 中的迭代器和迭代器
Python 中的可迭代对象、迭代器和迭代
凯文·Ku 在 Unsplash 上的照片
在本文中，我们将学习迭代、可迭代和迭代器之间的区别，如何识别可迭代和迭代器，以及为什么这样做是有用的。
什么是可迭代的？
广义地说，iterable 是可以循环的东西。循环遍历某物，或者一个接一个地获取其中的每一项的过程，就是迭代。例如，当我们使用 For 循环来循环遍历一个列表时，循环遍历这个列表的过程就是迭代(或者我们正在迭代遍历这个列表)，这个列表就是 iterable。元组、字典、字符串、文件和生成器也是可迭代的，因为它们也可以被迭代。
例如，我们可以使用 For 循环来循环或迭代列表，如下所示:
num_list = [1,2,3,4,5]for num in num_list:
print(num)
但是是什么让一个东西成为可重复的呢？
换句话说，是什么使得某些东西能够被迭代，比如在 for 循环中？要成为可迭代的，一个对象将有一个 iter()方法。因此，如果一个对象有 iter()方法，那么它就是 iterable，因此我们可以使用 for 循环来遍历它。
从技术上来说，如果一个对象有 getitem()方法，它也可以是 iterable。然而，我们在这里将关注 iter()方法，因为它是 python 中迭代的较新协议。
如果我们在 num_list 上使用 dir()函数，它将显示列表对象的所有方法和属性:
列表对象的方法和属性
注意列表对象 num_list 有一个 iter()方法，这使它成为可迭代的。具有双前导和双尾随下划线的方法因此被称为 dunder 方法(也称为魔术方法或特殊方法)。这些方法旨在被间接调用，因为大多数 python 操作符都有相关的魔法方法。
那么这个 iter()方法是做什么的呢？
iter()方法将返回一个迭代器对象。要循环遍历一个 iterable，比如一个 list，我们通常不会手动这么做。例如，For 循环首先调用对象上的 iter()方法，该方法返回一个迭代器对象。然后 for 循环遍历这个迭代器。所有这些都是在后台完成的。
这就把我们带到了迭代器。
用 python 创建列表的更优雅、更简洁的方式
towardsdatascience.com](/list-comprehensions-in-python-28d54c9286ca)
什么是迭代器？
列表是可迭代的。但它不是迭代器。如果我们在列表上运行 iter()方法，它将返回一个迭代器。迭代器是一个对象，它有一个在迭代过程中记得自己位置的状态。迭代器也知道如何获得它们的下一个值。它们通过 next()方法获得下一个值。因此，要知道一个对象是否是迭代器，我们可以检查它是否有 next()方法。
我们可以先调用 num_list 上的 iter()函数(iter()函数调用传入的对象上的 iter()方法)，返回一个迭代器，然后我们将在迭代器上使用 dir()函数查看其属性和方法:
迭代器的方法和属性
注意我们的迭代器 num_list_iterator 有一个 next()方法。列表对象不是迭代器，因为它没有 next()方法。因此，在列表上调用 next()函数(如果有对象的话，它会在对象上调用 next()方法)会导致类型错误，因为我们的列表对象不是迭代器，因此没有 next()方法。但是，list 对象是可迭代的，因为它有一个 iter()方法，调用该方法时，返回一个迭代器，该迭代器将有一个 next()方法。
注意 num_list_iterator 也有一个 iter()方法。因此，迭代器也是可迭代的，或自迭代的，因为在迭代器上调用 iter()方法会返回 self。
下一个方法是做什么的？
在迭代器上调用 next()方法将返回迭代中的下一个值。因此，在我们从 num_list 或 num_list_iterator 创建的迭代器上调用 next()方法，将返回迭代器中的第一个值。在同一个迭代器上调用 next()方法将返回迭代器中的第二个值(记住迭代器有一个状态，它能记住它在迭代过程中的位置)。一旦我们遍历了迭代器的所有值，在迭代器上再次调用 next()方法将导致 StopIteration 错误，因为我们的迭代器现在已经用完了。一旦一个迭代器用完了，我们必须通过 iterable 的 iter()方法创建一个新的迭代器。
注意:迭代器只能向前。这意味着我们只能通过 next()方法获得迭代器中的下一个值。为了从头开始，我们必须通过在我们想要迭代的 iterable 上调用 iter()方法来创建一个新的 iterator 对象。
[## * Python 中的 args 和**kwargs
理解什么是*args 和**kwargs 以及如何使用它们
towardsdatascience.com](/args-and-kwargs-in-python-6d991a3c1b5e)
for 循环是如何工作的？
for 循环的工作原理是在后台执行上述操作。使用 for 循环遍历 list(或其他 iterable)首先通过 iter()方法创建一个迭代器对象，然后调用该迭代器上的 next()方法，返回值，直到返回 StopIteration 错误(它没有向我们显示)，这让它知道迭代器已经用尽，因为迭代器中没有更多的值了。这可以从下面看出:
在 for 循环的背景中
请注意，我们可以使用内置的 iter()和 next()函数，而不是键入 dunder 方法，这些函数为我们调用 iter()和 next()方法。但是，我们也可以像下面这样调用方法:
num_list.__iter__()num_list_iterator.__next__()
如果您熟悉 while 循环和 try/except 语句，那么上面的 for 循环类似于下面的 while 循环:
类似于 while 循环和 for 循环
为什么知道这些很有用？
在用 python 编码时，知道一个对象是可迭代的(还是可被迭代的)会非常有帮助。例如，知道一个对象是否是 iterable 将告诉我们一个对象是否可以在 For 循环中使用。
在上面的例子中，我们使用了一个 for 循环来遍历 num_list ，这是一个从 1 开始到 5 结束的整数列表，即[1，2，3，4，5]。好吧，不像上面那样创建 num_list 并遍历它，我们可以检查一下是否可以使用 range()函数来创建一个 range 对象，我们可以使用 for 循环来遍历它，给我们相同的数字序列来迭代:
range 对象的方法和属性
正如我们所看到的，range 对象是一个可迭代的对象，因为它有 iter()方法！因此，可以使用 for 循环对其进行迭代，因为 for 循环将首先创建迭代器对象，然后使用 next()方法对该迭代器对象进行迭代。
for num in range(1,6):
print(num)
如果你喜欢阅读这样的故事，并想支持我成为一名作家，考虑注册成为一名媒体成员。每月 5 美元，你可以无限制地阅读媒体上的故事。如果你用我的 链接 注册，我会赚一小笔佣金。
阅读卢艾·马塔尔卡的每一个故事(以及媒体上成千上万的其他作家)。您的会员费直接支持…
lmatalka90.medium.com](https://lmatalka90.medium.com/membership)
结论
在本教程中，我们讨论了迭代、可迭代对象和迭代器的含义。我们了解了 iterable 是一个具有 iter()方法的对象，该方法将创建一个迭代器对象。我们还了解到迭代器是一个对象，它有一个在迭代过程中记得它在哪里的状态，并且知道如何通过 next()方法获得下一个值。最后，我们看到了将一个对象标识为 iterable 是如何帮助我们编写更多 pythonic 代码的。
高效迭代您的 R 代码！
在 r 中执行干净有效的迭代的一步一步的指南。
因纽特人实际上并没有一百个关于雪的名字。原来这是部分神话和部分误解。将类似的类比扩展到 web speak，大约有一百种迭代代码的方法！除此之外，语法可能会令人困惑，我们中的一些人还会冒险懒散地求助于复制粘贴代码 4 次。但重要的是要认识到，这是一条次优路线，坦率地说不切实际。根据一般经验，如果我们需要运行一个代码块两次以上，迭代是一个好主意！这有两个原因可以让你的代码更加丰富
- 它将注意力吸引到不同的代码部分，从而更容易发现操作的意图。
- 由于其简洁的本质，您可能会遇到更少的错误。
可能需要一些时间来理解迭代的概念，但是相信我，这是值得的。
既然你已经被说服去迭代——让我们直接开始吧！
让我们挑选内置的 R 数据集- *空气质量。*以下是其中的一个片段-
Ozone Solar.R Wind Temp Month Day
41 190 7.4 67 5 1
36 118 8.0 72 5 2
12 149 12.6 74 5 3
18 313 11.5 62 5 4
23 299 8.6 65 5 7
19 99 13.8 59 5 8
问题 1 :你想求数据集中每个变量的标准差-
你可以为每一列复制粘贴相同的代码
sd(airquality$Ozone)
*33.27597*sd(airquality$Solar.R)
*91.1523*sd(airquality$Wind)
*3.557713*sd(airquality$Temp)
*9.529969*sd(airquality$Month)
*1.473434*sd(airquality$Day)
*8.707194*
然而，这对于大型数据集来说是不切实际的，并且打破了相同操作不运行两次以上的经验法则。我们有一个坚实的案例来迭代！
我们可以写一个for()循环-
stddev = vector("double", ncol(airquality))for(i in seq_along(airquality))
{
stddev[[i]] = sd(airquality[[i]])
}
stddev
*33.275969 91.152302 3.557713 9.529969 1.473434 8.707194*
该循环消除了任何重复，确实比第一种方法更有效。
还必须暂停一下，注意虽然seq_along()和length()在 for 循环中通常交替使用来构建序列，但是有一个关键的区别。在零长度向量的情况下，seq_along()做正确的事情，但是length()取 0 和 1 的值。虽然您可能不会故意创建零长度向量，但很容易意外地创建它们。如果你使用1:length()而不是seq_along()，你可能会得到一个令人困惑的错误信息
或者你可以跳过循环，用只用一行来自 base R 的apply()系列的sapply()代码来完成这个技巧
sapply(airquality, sd) Ozone Solar.R Wind Temp Month Day
*33.275969 91.152302 3.557713 9.529969 1.473434 8.707194*
这是对 R 函数式编程能力的一个很好的应用，确实非常灵活地完成了工作。
现在让我们在复杂性的阶梯上再跨一步，看看另一个问题。
问题 2 :你想求出你的数据集中每一列的标准差和中位数。
因为我们已经确定第一种方法复制粘贴是不切实际的，我们权衡我们的迭代选项。
我们从编写一个for()循环开始-
stddev =vector("double", ncol(airquality))
median =vector("double", ncol(airquality))for(i in seq_along(airquality))
{
stddev[[i]] = sd(airquality[[i]])
median[[i]] = median(airquality[[i]])
} stddev
33.275969 91.152302 3.557713 9.529969 1.473434 8.707194
median
31.0 207.0 9.7 79.0 7.0 16.0
接下来，我们走函数式编程路线。这里，不像前面的例子，我们可以直接使用 R 的内置sd()函数来计算标准偏差并通过sapply()传递，我们需要创建一个自定义函数，因为我们需要计算标准偏差和中位数。
f <- function(x){
list(sd(x),median(x))
}sapply(airquality, f)Ozone Solar.R Wind Temp Month Day
33.27597 91.1523 3.557713 9.529969 1.473434 8.707194
31 207 9.7 79 7 16
这是一个非常坚实的想法！将用户构建的函数传递给另一个函数的能力令人激动，并且清楚地展示了 R 解决各种任务的函数式编程能力。事实上，经验丰富的 R 用户很少使用循环，而是求助于函数式编程技术来解决所有的迭代任务。如上所述，在 base R 中应用函数族(apply()、lapply()、tapply()等)是一种很好的方式，但是即使在函数式编程领域，也有一个包成为了人们的最爱——Purrr。 purrr 系列函数具有更加一致的语法，并且内置了执行各种常见迭代任务的功能。
Map() 函数构成了 purrr 迭代能力的基础。这是它的一些表现形式-
map()列清单。map_lgl()做一个逻辑向量。map_int()生成一个整数向量。map_dbl()生成双向量。map_chr()生成一个字符向量。
让我们用这个想法来解决我们之前计算每一列的中值和标准差的问题-
map_df(airquality, ~list(med = median(.x), sd = sd(.x)))
接下来，为了在复杂性阶梯上的另一个飞跃，让我们从 gapminder 库中挑选 gapminder 数据集。下面是其中的一个片段。(注:如果你没有听说过 gapminder 基金会，请点击这里查看它的网站。该基金会在将基本的全球事实放入背景中做了一些开创性的工作)
country continent year lifeExp pop gdpPercap
Afghanistan Asia 1952 28.8 8425333 779.
Afghanistan Asia 1957 30.3 9240934 821.
Afghanistan Asia 1962 32.0 10267083 853.
Afghanistan Asia 1967 34.0 11537966 836.
Afghanistan Asia 1972 36.1 13079460 740.
Afghanistan Asia 1977 38.4 14880372 786.
**问题三:**我想知道各大洲，各年份，哪个国家的人均 GDP 最高？
使用for()循环方法-
list = c(“continent”, “year”)
DF= data.frame()for( i in list)
{
df = gapminder %>% group_by_at(i) %>%
top_n(1, gdpPercap) %>%
mutate(Remark = paste0(“Country Max GDP Per capita in the “,i)) %>%
data.frame()
DF = rbind(df,DF)
}
DF
使用Apply()方法-
do.call(rbind, lapply(list, function(x)
{
gapminder %>% group_by_at(x) %>%
top_n(1, gdpPercap)%>%
mutate(Remark = paste0("Country with the max GDP Per capita in the ",x)) %>%
data.frame
}))
使用Purrr::Map()方法-
gapminder$year = as.character(gapminder$year)
map_dfr(list, ~gapminder %>% group_by(!!sym(.x)) %>%
top_n(1, gdpPercap)%>%
mutate(Remark = paste0(“Country with the max GDP Per capita in the “,.x)) %>% data.frame()
以上三种方法都产生相同的输出(为了简洁起见，我没有在这里包括输出。你可以在我的 Github 这里看看。同样，虽然您可以选择想要采用的迭代路线，但是函数式编程方式在 cogency 方面是明显的赢家。
Purrr 也有一些处理日常迭代任务的内置函数！下面我列出了几个受欢迎的。
任务 :对每一段数据进行分段回归。(这里，大陆):
Purrr 解决方案 :
gapminder %>%
split(.$Continent) %>%
map(~lm(gdpPercap ~ lifeExp, data = .))
任务:保持变量基于任意条件。(此处，如果变量是因子):
:
*gapminder %>%
keep(is.factor) %>%
str()*
***任务:*检查任意变量是否满足任意条件(此处，任意变量是否为字符):
Purrr 解决方案:
*gapminder%>%
some(is_character)*
***任务:*检查每个变量是否满足任意条件(这里，如果每个变量都是整数):
Purrr 解决方案:
*gapminder %>%
every(is.integer))*
一旦你习惯了 purrr 的语法，你将需要更少的时间来用 r 编写迭代代码。然而，你绝不能因为用 r 编写循环而感觉不好。事实上，它们是编程的基本模块之一，并且在其他语言中被大量使用。有些人甚至称循环为慢。他们错了！(好吧至少它们已经相当过时了，至于 loops 已经很多年没慢过了)。使用像map()和apply()这样的函数的主要好处不是速度，而是清晰:它们使你的代码更容易编写和阅读。
重要的是你要解决你正在处理的问题，而不是写出最简洁优雅的代码(尽管那绝对是你想要努力的方向！)——哈德利·韦翰
感谢阅读！你可以在我的 Github 这里查看代码，或者在这里联系我。
Python 中的迭代器和可迭代对象
迭代器和可迭代对象简介
在这篇文章中，我们将讨论 python 迭代器和可迭代对象。我们将回顾每个对象的定义，并努力理解每个对象背后的基本概念。
我们开始吧！
Iterables 是 python 中能够一次返回一个元素的对象。此外，这些对象有一个名为“iter()”的双下划线(也称为 dunder )方法，其中“iter()”方法返回一个迭代器(稍后将详细介绍)。列表就是 iterable 的一个例子。为了帮助我们理解列表作为可迭代对象意味着什么，让我们定义一个列表。让我们根据 滚石 : 来定义一个包含有史以来最好的五张专辑的列表
best_albums = ["Sgt. Pepper’s Lonely Hearts Club Band", "Pet Sounds", "Revolver", "Highway 61 Revisited", "Rubber Soul"]
我们对 iterables 定义的第一部分指出，它们允许我们一个接一个地返回它们的元素。让我们通过循环我们的列表来演示这一点:
for album in best_albums:
print(album)
iterables 的这个特性非常明显。我们还指定了“iter()”方法，该方法也将 python 对象限定为可迭代对象。我们可以使用内置的“dir()”方法检查对象可用的方法和属性:
print(dir(best_albums))
我们可以看到“iter()”方法出现在对象的方法和属性列表中。一般来说，任何带有“iter()”方法的对象都可以循环。
此外，当我们在 iterables 上使用 for 循环时，我们调用“iter()”方法。当调用“iter()”方法时，它返回一个迭代器。
现在，让我们定义迭代器。
迭代器是有状态的对象，其中状态指定迭代期间的当前值。迭代器还有一个名为“next()”的 dunder 方法，允许我们访问后续值。如果我们查看列表的属性和方法，我们可以看到没有’ next()'，这意味着列表不是迭代器。
我们可以通过尝试使用列表中的“下一个”方法来证明这一点:
print(next(best_albums))
我们得到一个错误，告诉我们列表对象不是迭代器。因为我们知道列表对象是可迭代的，这意味着它们有“iter()”方法，所以我们可以在列表上调用“iter()”来返回一个迭代器:
iter_best_albums = best_albums.__iter__()
定义迭代器的一种更简洁的等效方法如下:
iter_best_albums = iter(best_albums)
让我们打印我们的迭代器:
print(iter_best_albums)
我们看到我们的对象确实是一个迭代器。现在，让我们打印迭代器对象的属性和方法:
print(dir(iter_best_albums))
我们可以看到我们的迭代器对象有“next()”方法。让我们在迭代器上调用这个方法:
print(next(iter_best_albums))
print(next(iter_best_albums))
print(next(iter_best_albums))
我们可以看到，每次我们调用“next”时，我们的对象会记住它停止的地方,“next”方法会指向后续的值。让我们看看如果我们调用’ next '直到用完所有值会发生什么。我们再打 6 次电话:
print(next(iter_best_albums))
print(next(iter_best_albums))
print(next(iter_best_albums))
print(next(iter_best_albums))
print(next(iter_best_albums))
print(next(iter_best_albums))
我们可以用“StopIteration”异常来处理此错误:
while True:
try:
element = next(iter_best_albums)
print(element)
except(StopIteration):
break
我们得到的结果和之前循环链表得到的结果是一样的。当我们用 for 循环遍历列表时，这就是本质上发生的事情。
我就讲到这里，但是您可以自己随意摆弄代码。如果你有兴趣学习更多关于迭代器和可迭代对象的知识，科里·斯查费的 YouTube 教程是一个很好的资源。
结论
总之，在这篇文章中，我们讨论了 python 中的迭代和迭代器。Iterables 是具有方法“iter()”的对象，该方法返回迭代器对象。迭代器是具有方法’ next() '的对象，该方法允许我们访问后续值。此外，迭代器有关于迭代过程中状态的信息。简而言之，迭代器是 python 中每个 for 循环背后发生的事情。我希望你觉得这有用/有趣。这篇文章的代码可以在 GitHub 上找到。感谢您的阅读！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
