可视化解释 SVM 超参数
C 和γ是用来做什么的
照片由 Unsplash 上的 Aziz Acharki 拍摄
支持向量机(SVM)是一种广泛使用的监督机器学习算法。它主要用于分类任务，但也适用于回归任务。
在这篇文章中，我们深入探讨了支持向量机的两个重要的超参数， C 和**γ，**并用可视化的方法解释了它们的作用。所以我假设你对算法有一个基本的了解，并关注这些超参数。
SVM 使用决策边界来分离属于不同类别的数据点。当确定决策边界时，软边界 SVM(软边界意味着允许一些数据点被错误分类)试图解决具有以下目标的优化问题:
- 增加决策边界到类别(或支持向量)的距离
- 最大化训练集中正确分类的点数
软边界 SVM 的决策边界(图片由作者提供)
很明显，这两个目标之间有一个折衷，它由 C 控制，对每个错误分类的数据点增加一个惩罚。
如果 C 很小，则对误分类点的惩罚也很低，因此以更大数量的误分类为代价选择了具有大余量的决策边界。
如果 C 很大，SVM 会尽量减少错误分类的例子，因为高惩罚会导致决策边界具有较小的余量。对于所有分类错误的例子，惩罚是不一样的。它与到决策边界的距离成正比。
举例之后会更清楚。让我们首先导入库并创建一个合成数据集。
import numpy as np
import pandas as pdimport matplotlib.pyplot as plt
%matplotlib inlinefrom sklearn.svm import SVC
from sklearn.datasets import make_classificationX, y = make_classification(n_samples=200, n_features=2,
n_informative=2, n_redundant=0, n_repeated=0, n_classes=2,random_state=42)plt.figure(figsize=(10,6))
plt.title("Synthetic Binary Classification Dataset", fontsize=18)
plt.scatter(X[:,0], X[:,1], c=y, cmap='cool')
(图片由作者提供)
我们将首先训练一个只需要调整 c 的线性 SVM，然后我们将实现一个具有 RBF 核的 SVM，并调整伽马参数。
为了绘制决策边界，我们将使用 Jake VanderPlas 的 Python 数据科学手册的 SVM 章节中的函数。
我们现在可以创建两个具有不同 C 值的线性 SVM 分类器。
clf = SVC(C=0.1, kernel='linear').fit(X, y)plt.figure(figsize=(10,6))
plt.title("Linear kernel with C=0.1", fontsize=18)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='cool')
plot_svc_decision_function(clf)
(图片由作者提供)
只需将 C 值更改为 100，即可生成如下图。
(图片由作者提供)
当我们增加 C 值时，边距变小。因此，具有低 C 值的模型倾向于更一般化。随着数据集越来越大，这种差异变得越来越明显。
超参数的影响仅在线性核的情况下达到一定程度。对于非线性核，超参数的影响变得更加明显。
伽马是与非线性 SVM 一起使用的超参数。最常用的非线性核之一是径向基函数(RBF)。RBF 的 Gamma 参数控制单个训练点的影响距离。
低 gamma 值表示较大的相似性半径，这将导致更多的点被组合在一起。对于高 gamma 值，这些点需要彼此非常接近，才能被视为在同一组(或类)中。因此，gamma 值非常大的模型往往会过度拟合。
让我们用不同的伽马值绘制三个支持向量机的预测。
clf = SVC(C=1, kernel='rbf', gamma=0.01).fit(X, y)
y_pred = clf.predict(X)plt.figure(figsize=(10,6))
plt.title("Predictions of RBF kernel with C=1 and Gamma=0.01", fontsize=18)
plt.scatter(X[:, 0], X[:, 1], c=y_pred, s=50, cmap='cool')
plot_svc_decision_function(clf)
(图片由作者提供)
只需改变伽马值，以产生以下图形。
(图片由作者提供)
(图片由作者提供)
随着 gamma 值的增加，模型变得过拟合。数据点需要非常接近才能分组在一起，因为相似性半径随着灰度值的增加而减小。
伽马值为 0.01、1 和 5 的数据集上的 RBF 核的精度分别为 0.89、0.92 和 0.93。这些值表明随着 gamma 值的增加，模型过度适应训练集。
伽马与 C 参数
对于线性核，我们只需要优化 c 参数。然而，如果我们想使用 RBF 核，c 和 gamma 参数需要同时优化。如果γ很大，c 的影响可以忽略不计。如果 gamma 很小，c 会像影响线性模型一样影响模型。c 和γ的典型值如下。然而，根据应用可能存在特定的最佳值:
0.0001 < gamma < 10
0.1 < c < 100
参考值
从零开始的 SVM——Python
重要概念总结
如果你明白了，干杯😉
本博客将涵盖的内容:
- SVM 简介T2 2。读取数据集
3。特色工程
4。拆分数据集
5。成本函数
6。成本函数的梯度
7。列车型号使用 SGD8。停机判据为 SGD9
。测试型号
10。具有相关性的特征选择& P 值
11。给我代码
在深入代码或技术细节之前，我想提一下，虽然有许多库/框架可用于实现 SVM(支持向量机)算法，而无需编写大量代码，但我决定用尽可能少的高级库来编写代码，以便您和我可以很好地掌握训练 SVM 模型(准确率为 99%，召回率为 0.98%，精确度为 0.98%)所涉及的重要组件。如果你正在寻找 SVM 的快速实现，那么你最好使用像 scikit-learn 、 cvxopt 等这样的包。要不，我们开始吧！
SVM 简介
图 1: SVM 用一张图表概括— Ireneli.eu
SVM (支持向量机)是一种监督的 机器学习算法，通常用于二元分类问题。它通过输入带有标签示例的数据集*来训练(xᵢ，yᵢ).*例如，如果您的示例是电子邮件，而您的问题是垃圾邮件检测，那么:
- 示例电子邮件消息 xᵢ 被定义为能够在 n 维空间上绘制的 n 维特征向量。
- 特征向量，顾名思义，包含特征(如字数、链接数等。)以数字形式显示
- 每个特征向量都标有一个类别
- 类别可以是+ve 或-ve(例如，spam=1，而非-spam=-1)**
使用这个数据集，算法找到一个超平面(或决策边界)，该超平面理想地应该具有以下属性:
- 它以最大的裕度在两个类的示例之间创建了分离
- 它的等式 (w.x + b = 0) 对于来自+ve 类的例子产生≥ 1 的值，对于来自-ve 类的例子产生≤-1 的值
****它是怎么找到这个超平面的？**通过找到定义该超平面的最优值 w(权重/法线)和b (截距)。通过最小化成本函数找到最佳值。一旦算法识别出这些最优值，则 SVM 模型 f(x) 被定义如下:
数学表达的 SVM 模型
在我们继续之前，让我们导入本教程所需的包，并创建我们程序的框架 svm.py :
*****# svm.py***
import numpy as np *# for handling multi-dimensional array operation*
import pandas as pd *# for reading data from csv*
import statsmodels.api as sm *# for finding the p-value*
from sklearn.preprocessing import MinMaxScaler *# for normalization*
from sklearn.model_selection import train_test_split as tts
from sklearn.metrics import accuracy_score
from sklearn.utils import shuffle*# >> FEATURE SELECTION << #*
def remove_correlated_features(X):
def remove_less_significant_features(X, Y):*# >> MODEL TRAINING << #*
def compute_cost(W, X, Y):
def calculate_cost_gradient(W, X_batch, Y_batch):
def sgd(features, outputs):def init():**
读取数据集
我们将使用 Kaggle 上的乳腺癌数据集。数据集中的特征是根据乳腺肿块细针抽吸(FNA)的数字化图像计算得出的。它们描述了图像中出现的细胞核的特征。基于这些特征，我们将训练我们的 SVM 模型来检测肿块是良性的 B (一般无害)还是恶性的 M (癌变)。
下载数据集并将 data.csv 文件放在与 svm.py 相同的文件夹中。然后将这段代码添加到 init() 函数中:
****def init():
** data = pd.read_csv('./data.csv') *# SVM only accepts numerical values.
# Therefore, we will transform the categories M and B into
# values 1 and -1 (or -1 and 1), respectively.*
diagnosis_map = {'M':1, 'B':-1}
data['diagnosis'] = data['diagnosis'].map(diagnosis_map) # drop last column (extra column added by pd)
# and unnecessary first column (id)
data.drop(data.columns[[-1, 0]], axis=1, inplace=True)**
read _ CSV()Pandas包的函数从。csv 文件并将其存储在数据帧和**中。**把DataFrame 想象成一个数据结构的实现，它看起来像一个带有标记的列和行的表格。下面是从 data.csv 中读取的数据在 DataFrame 中的样子:
图 2: 在 PyCharm IDE 中查看的数据帧中乳腺癌数据集的一部分
如您所见，我们的数据集的标签和结构得以保留，这使得 DataFrame 变得直观。
特征工程
**机器学习算法在一个数据集上操作，该数据集是一个由特征和标签组成的带标签的例子的集合，即在我们的情况下诊断是一个标签，【半径 _ 平均，结构 _ 平均，纹理 _ 平均……特征，并且每一行都是一个例子。
在大多数情况下，您最初收集的数据可能是原始的；它要么与你的模型不兼容，要么妨碍它的性能。这时特征工程来拯救。它包括预处理技术，通过从原始数据中提取特征来编译数据集。这些技术有两个共同的特点:
- 准备与模型兼容的数据
- 提高机器学习算法的性能
****标准化是我们将要使用的众多特征工程技术之一。归一化是将数值范围转换为标准数值范围的过程，通常在区间[1，1]或[0，1]内。这不是一个严格的要求，但它提高了学习的速度(例如，在梯度下降中更快的收敛)并防止数值溢出。在 init() 函数中添加以下代码，以规范化您的所有功能:
*****# inside init()*** *# put features & outputs in different DataFrames for convenience* Y = data.loc[:, 'diagnosis'] # all rows of 'diagnosis'
X = data.iloc[:, 1:] # all rows of column 1 and ahead (features)*# normalize the features using MinMaxScalar from
# sklearn.preprocessing* X_normalized = MinMaxScaler().fit_transform(X.values)
X = pd.DataFrame(X_normalized)**
分割数据集
我们将使用sk learn . model _ selection中的 train_test_split() 函数将数据集分成训练集和测试集。我们需要一个单独的数据集来进行测试，因为我们需要看看我们的模型在看不见的观察上表现如何。将此代码添加到 init() 中:
*****# inside init()****# first insert 1 in every row for intercept b*
X.insert(loc=len(X.columns), column='intercept', value=1)# test_size is the portion of data that will go into test set
# random_state is the seed used by the random number generator
print("splitting dataset into train and test sets...")
X_train, X_test, y_train, y_test = tts(X, Y, test_size=0.2, random_state=42)**
如果你对我们为什么在每一行加 1 感到困惑，那么不要担心。你会在下一节得到答案。
价值函数
图 3: H1 并没有把阶级分开。H2 有，但幅度很小。H3 以最大的差距将他们分开— 维基百科
也称为目标函数。每个机器学习算法的构建模块之一，它是我们试图最小化或最大化以实现我们目标的函数。
我们在 SVM 的目标是什么？我们的目标是找到一个超平面，它以最大的裕度分隔+ve 和-ve 示例，同时保持尽可能低的错误分类(见图 3)。
我们如何实现这个目标？我们将最小化成本/目标函数，如下所示:
在训练阶段，较大的 C 导致较窄的裕度(对于无限大的 C，SVM 变成硬裕度)，而较小的 C 导致较宽的裕度。
您可能见过另一个版本的成本函数，如下所示:
较大的λ给出较宽的余量，较小的λ导致较窄的余量(对于无限小的λ，SVM 变成硬余量)。
在这个成本函数中，λ基本上等于 1/C ，并且具有相反的效果，即较大的λ给出较宽的余量，反之亦然。我们可以使用任何上述成本函数，记住每个正则化参数(C 和λ)的作用，然后相应地调整它们。让我们看看如何计算(1)中给出的总成本，然后我们将继续讨论其梯度，该梯度将用于训练阶段以使其最小化:
****def compute_cost(W, X, Y):**
# calculate hinge loss
N = X.shape[0]
distances = 1 - Y * (np.dot(X, W))
distances[distances < 0] = 0 # equivalent to max(0, distance)
hinge_loss = reg_strength * (np.sum(distances) / N)
# calculate cost
cost = 1 / 2 * np.dot(W, W) + hinge_loss
return cost**
您可能已经注意到，截距术语 b 不见了。这是因为我们把它推进了重量向量，就像这样:
将截距项推入权重向量。
这就是为什么我们在拆分数据集之前添加了一个全 1 的额外列。在本教程的剩余部分，请记住这一点。
成本函数的梯度
成本函数的梯度
*您可能已经注意到，等式(4)中的成本函数有一些变化。不要担心，如果你解析地解决它，它是相同的。现在让我们使用等式(5)实现*calculate _ cost _ gradient()函数:
**# I haven't tested it but this same function should work for
# vanilla and mini-batch gradient descent as well
**def calculate_cost_gradient(W, X_batch, Y_batch):**
# if only one example is passed (eg. in case of SGD)
if type(Y_batch) == np.float64:
Y_batch = np.array([Y_batch])
X_batch = np.array([X_batch]) distance = 1 - (Y_batch * np.dot(X_batch, W))
dw = np.zeros(len(W)) for ind, d in enumerate(distance):
if max(0, d) == 0:
di = W
else:
di = W - (reg_strength * Y_batch[ind] * X_batch[ind])
dw += di dw = dw/len(Y_batch) # average
return dw**
使用 SGD 训练模型
记得我在上面说过，“为了实现我们的目标，我们试图最小化或最大化成本函数”。在 SVM 算法中，我们最小化成本函数。
我们为什么要最小化成本函数？因为成本函数本质上是衡量我们的模型在实现目标方面做得有多差的指标。如果你仔细观察 J(w)，为了找到它的最小值，我们必须:
- 最小化∣∣w∣∣t13】哪个最大化边距* (2/∣∣w∣∣)***
- 最小化铰链损耗的总和，其中最小化错误分类。
铰链损失函数
因为我们的两个 SVM 目标都是通过最小化成本函数来实现的，这就是为什么我们要最小化它。
我们如何将它最小化？嗯，有多种方法，但我们将使用一种叫做随机梯度下降或 SGD 的方法。在深入 SGD 之前，我首先简单解释一下梯度下降是如何工作的。
图 4: 梯度下降
梯度下降算法的工作原理如下:
- 找到成本函数的梯度，即∇J(w’)
- 以一定的速率向梯度的相反方向移动，即 w’ = w’ — ∝(∇J(w’))
- 重复步骤 1-3，直到收敛，即我们发现 w '其中 J(w)最小
为什么它的运动方向与梯度方向相反？因为梯度是函数增长最快的方向。我们需要向相反的方向移动，使函数 J(w)最小。因此，在梯度下降中使用“下降”一词。
在典型的梯度下降(又名普通梯度下降)中，使用所有示例(1…N)计算上述步骤 1。然而，在 SGD 中，一次只使用一个示例。我不会在这里讨论 SGD 的好处，但是你可以在这个博客的末尾找到一些有用的链接。下面是如何用代码实现 SGD:
***def sgd(features, outputs):
** max_epochs = 5000
weights = np.zeros(features.shape[1])
*# stochastic gradient descent*
for epoch in range(1, max_epochs):
*# shuffle to prevent repeating update cycles*
X, Y = shuffle(features, outputs)
for ind, x in enumerate(X):
ascent = calculate_cost_gradient(weights, x, Y[ind])
weights = weights - (learning_rate * ascent)
return weights*
让我们通过添加以下代码在 init() 函数内部调用它:
****# inside init()****# train the model*
print("training started...")
W = sgd(X_train.to_numpy(), y_train.to_numpy())
print("training finished.")
print("weights are: {}".format(W))*
SGD 的停止标准
在上面的 sgd() 实现中，我们运行了 5000 次循环(可能是任何次数)。每次迭代都花费我们时间和额外的计算。我们不需要完成所有的迭代。当满足中断标准时，我们可以终止循环。
***停工标准应该是什么？*有多个选项，但我们将使用最简单的一个。与之前的成本相比，当当前的成本没有降低很多时，我们将停止培训。下面是我们如何用停止标准定义 sgd() :
***def sgd(features, outputs):**
max_epochs = 5000
weights = np.zeros(features.shape[1])
nth = 0
prev_cost = float("inf")
cost_threshold = 0.01 # in percent
# stochastic gradient descent
for epoch in range(1, max_epochs):
# shuffle to prevent repeating update cycles
X, Y = shuffle(features, outputs)
for ind, x in enumerate(X):
ascent = calculate_cost_gradient(weights, x, Y[ind])
weights = weights - (learning_rate * ascent) # convergence check on 2^nth epoch
if epoch == 2 ** nth or epoch == max_epochs - 1:
cost = compute_cost(weights, features, outputs)
print("Epoch is:{} and Cost is: {}".format(epoch, cost))
# stoppage criterion
if abs(prev_cost - cost) < cost_threshold * prev_cost:
return weights
prev_cost = cost
nth += 1
return weights*
测试模型
在使用 SGD 训练模型之后，我们最终获得了最优权重 w ，其定义了分离两个类的最佳可能超平面。让我们用这个超平面来测试我们的模型。将此代码添加到 init() 函数中:*
****# inside init()****# testing the model on test set*
y_test_predicted = np.array([])
for i in range(X_test.shape[0]):
yp = np.sign(np.dot(W, X_test.to_numpy()[i])) #model
y_test_predicted = np.append(y_test_predicted, yp)print("accuracy on test dataset: {}".format(accuracy_score(y_test.to_numpy(), y_test_predicted)))
print("recall on test dataset: {}".format(recall_score(y_test.to_numpy(), y_test_predicted)))
print("precision on test dataset: {}".format(recall_score(y_test.to_numpy(), y_test_predicted)))*
现在让我们调用 init() 函数:
**# set hyper-parameters and call init
# hyper-parameters are normally tuned using cross-validation
# but following work good enough*
reg_strength = 10000 # regularization strength
learning_rate = 0.000001
init()*
以下是输出结果:
***# OUTPUT**
reading dataset...
applying feature engineering...
splitting dataset into train and test sets...
training started...
Epoch is: 1 and Cost is: 5333.266133501857
Epoch is: 2 and Cost is: 3421.9128432834573
Epoch is: 4 and Cost is: 2437.2790231100216
Epoch is: 8 and Cost is: 1880.2998267933792
Epoch is: 16 and Cost is: 1519.5578612139725
Epoch is: 32 and Cost is: 1234.642324549297
Epoch is: 64 and Cost is: 977.3285621274708
Epoch is: 128 and Cost is: 804.8893546235923
Epoch is: 256 and Cost is: 703.407799431284
Epoch is: 512 and Cost is: 645.8275191300031
Epoch is: 1024 and Cost is: 631.6024252740094
Epoch is: 2048 and Cost is: 615.8378582171482
Epoch is: 4096 and Cost is: 605.0990964730645
Epoch is: 4999 and Cost is: 606.8186618758745
training finished.
weights are: [ 1.32516553 0.83500639 1.12489803 2.16072054 -1.24845441 -3.24246498
3.27876342 6.83028706 -0.46562238 0.10063844 5.68881254 -1.93421932
3.27394523 3.77331751 1.67333278 -2.43170464 -1.7683188 0.84065607
-1.9612766 -1.84996828 2.69876618 5.32541102 1.0380137 3.0787769
2.2140083 -0.61998182 2.66514199 0.02348447 4.64797917 2.17249278
-9.27401088]
testing the model...
accuracy on test dataset: 0.9736842105263158
recall on test dataset: 0.9534883720930233
precision on test dataset: 0.9534883720930233*
请注意模型的准确性、召回率和精确度分数，以及完成模型所需的时期。现在让我们尝试使用特征选择来改进它。
具有相关性和 P 值的特征选择
特征选择包括帮助过滤不相关或冗余特征的统计技术。相关性和 p 值就是这些统计技术中的一种。使用它们，我们将从我们的原始特征集中选择一个相关和重要的特征子集
什么是相关性？相关性是两个变量之间线性依赖(或线性关系)的程度。如果一个特征的值可以用第二个特征的某种线性关系来解释，则称两个特征相关。这种关系的程度由相关系数(或“r”)给出。范围从-1.0 到+1.0。r 越接近+1 或-1，这两个变量的关系就越密切。
为什么我们要删除其中一个相关特征？有多种原因，但最简单的原因是相关特征对因变量的影响几乎相同。此外，相关特征不会改善我们的模型，而且很可能会恶化它，因此我们最好只使用其中的一个。毕竟特征越少，学习速度越快，模型越简单(特征越少的模型)。
什么是 p 值？**这个博客涉及的范围太广了。但是，在特征选择的背景下，p 值帮助我们找到在解释因变量(y) 的变化中最重要的特征。
在解释这种变化时，p 值低的要素意义更大，而 p 值高的要素意义较小。通常，我们设置一个显著性水平 SL (阈值)，如果一个特征的 p 值高于这个水平，它将被丢弃。我会在这篇博客的最后留下一些链接，对 p 值进行深入研究。
为什么我们要移除高 p 值的特征？因为它们不能说明因变量的行为。因此，当它们不能帮助我们预测结果时，为什么要保留它们，并不必要地增加我们模型的复杂性。
我们有两个名为remove _ correlated _ features()remove _ less _ significant _ features()的函数，分别用于移除高度相关的特征和不太重要的特征(使用 p 值和向后消除):
*# >> FEATURE SELECTION << #
**def remove_correlated_features(X):**
corr_threshold = 0.9
corr = X.corr()
drop_columns = np.full(corr.shape[0], False, dtype=bool)
for i in range(corr.shape[0]):
for j in range(i + 1, corr.shape[0]):
if corr.iloc[i, j] >= corr_threshold:
drop_columns[j] = True
columns_dropped = X.columns[drop_columns]
X.drop(columns_dropped, axis=1, inplace=True)
return columns_dropped**def remove_less_significant_features(X, Y):**
sl = 0.05
regression_ols = None
columns_dropped = np.array([])
for itr in range(0, len(X.columns)):
regression_ols = sm.OLS(Y, X).fit()
max_col = regression_ols.pvalues.idxmax()
max_val = regression_ols.pvalues.max()
if max_val > sl:
X.drop(max_col, axis='columns', inplace=True)
columns_dropped = np.append(columns_dropped, [max_col])
else:
break
regression_ols.summary()
return columns_dropped*
在应用规范化之前，让我们在 init() 中调用这些函数:
****# inside init()***# filter features
remove_correlated_features(X)
remove_less_significant_features(X, Y)*
重新运行代码并检查输出:
***# OUTPUT WITH FEATURE SELECTION** reading dataset...
applying feature engineering...
splitting dataset into train and test sets...
training started...
Epoch is: 1 and Cost is: 7198.889722245353
Epoch is: 2 and Cost is: 6546.424590270085
Epoch is: 4 and Cost is: 5448.724593530262
Epoch is: 8 and Cost is: 3839.8660601754004
Epoch is: 16 and Cost is: 2643.2493061396613
Epoch is: 32 and Cost is: 2003.9830891013514
Epoch is: 64 and Cost is: 1595.2499320295813
Epoch is: 128 and Cost is: 1325.7502330505054
Epoch is: 256 and Cost is: 1159.7928936478063
Epoch is: 512 and Cost is: 1077.5846940303365
Epoch is: 1024 and Cost is: 1047.208390340501
Epoch is: 2048 and Cost is: 1040.2241600540974
training finished.
weights are: [ 3.53520254 11.03169318 -2.31444264 -7.89186867 10.14516174 -1.28905488
-6.4397589 2.26113987 -3.87318997 3.23075732 4.94607957 4.81819288
-4.72111236]
testing the model...
accuracy on test dataset: 0.9912280701754386
recall on test dataset: 0.9767441860465116
precision on test dataset: 0.9767441860465116*
可以看到准确率(99%)* ，精度(0.98) ，以及召回(0.98) 的分数都有所提高。而且，新币收敛得更快；训练在 2048 个纪元内结束，这与之前的一次(5000 个纪元)相比要少得多*
完全码
您可以在这个 Github 资源库中获得完整的代码:
* [## qandeelabbassi/python-svm-sgd
SVM 随机次梯度下降算法的 Python 实现- qandeelabbassi/python-svm-sgd
github.com](https://github.com/qandeelabbassi/python-svm-sgd)*
有用链接
SVM 内核:他们实际上做什么？
直观的视觉解释
你可能听说过所谓的核技巧，这是一种允许支持向量机(SVM)很好地处理非线性数据的策略。这个想法是将数据映射到一个高维空间，在这个空间中数据变成线性的，然后应用一个简单的线性 SVM。听起来很复杂，在某种程度上确实如此。然而，尽管可能很难理解内核是如何工作的，但理解它们试图实现的目标是相当容易的。请继续阅读，自己去看看吧！
当数据是线性可分的:线性 SVM
首先:香草 SVM 是如何工作的？我们可以将支持向量机用于分类和回归任务，但是在本文中，我们将关注前者。让我们首先考虑具有线性可分的两个类的数据。我们将创建两个独立的点，并使用 scikit-learn 为它们拟合一个线性 SVM。请注意，我们在拟合模型之前对数据进行了归一化，因为支持向量机对特征的尺度很敏感。
自定义的plot_svm()函数，你可以在下面看到它的输出，由相当多的 matplotlib 代码组成——如果你好奇，可以在thisjupyter notebook中查看。
具有线性可分数据的线性 SVM 效果很好。
有许多线条完美地分隔了这两个阶级，确切地说是无限多。由 SVM 拟合的线是特殊的，因为它是用虚线标记的波段的中线，并且该波段是可以在两个类别之间挤压的最宽的波段。这样，SVM 决策线(标记为黑色实线)尽可能远离这两个类，确保模型能够很好地推广到新的示例。
用红色圈出的波段边界上的观察值称为支持向量，因为它们支持或确定波段的位置。如果我们增加一些波段外的观察，它不会改变位置。
作为一个旁注:这是一个硬边界分类的例子，这意味着不允许任何观察值进入波段。或者，我们可以做一个软边界分类:允许对波段进行一些观察，但不要太多，同时使波段更宽。这将对异常值更加鲁棒，并且可以通过LinearSVC()中的参数 C 来控制:我们已经将其设置为 1，但是例如将其降低到 0.1，将会产生更宽的波段，但是其中会有一些观察值。不管怎样，这和我们的故事没多大关系。
大多数现实生活中的数据集不是漂亮的、线性可分的斑点。让我们看看线性 SVM 如何处理月亮形状的数据。
具有线性不可分数据的线性 SVM 根本不起作用。
这看起来不太好，是吗？让我们看看我们能做些什么。
映射到更高维度
在我们讨论内核和它们做什么之前，让我们先来看看它们利用的一个强大的思想:在高维空间中，数据有更大的机会变成线性可分的。
**下面的一对图清楚地说明了这一点。当我们只有一个特征时， x1 ，我们不能用一行来分隔数据。添加另一个特征， x2，等于 x1 的平方，使得区分这两个类变得容易。
添加另一个特征使得数据可以线性分离。
内核到底是什么？
那么，内核的诀窍是什么呢？内核只是向数据添加更多特征的一种聪明方式，希望使数据线性分离。聪明，因为它们不是实际添加它们，这会使模型变慢，而是利用一些神奇的数学属性(这超出了本文的范围)，使我们能够获得与我们实际添加这些特性完全相同的结果，而不会使模型变慢。****
两个流行的内核是多项式内核和高斯径向基函数，或 RBF，内核**。它们的不同之处在于它们(假装)添加的功能类型。让我们看看他们是怎么做的！**
具有多项式核的多项式特征
创建更多特征的一种方法是在一定程度上使用它们的多项式组合。例如，对于两个特征 A 和 B，2 次多项式将产生 6 个特征:1(任何 0 次幂的特征)、A、B、A、B 和 AB。我们可以使用 scikit-learn 的PolynomialFeatures()轻松地手动添加这些功能:
或者我们可以简单地使用多项式核:
您可以自己验证两种实现产生大致相同的图，有点像这样:
具有多项式核的决策边界。
使用内核化版本的优点是，您可以指定较大的程度，从而增加数据在这个高维空间中线性分离的机会，而不会降低模型的速度。
对于我们的月球数据示例，从散点图可以清楚地看出，3 次多项式就足够了。然而，对于更复杂的数据集，您可能需要使用更高的度数。这就是内核技巧的威力被释放出来的时候。
高斯 RBF 核的相似性特征
**向数据添加更多特征的另一种方法是使用所谓的相似性特征。相似性特征测量现有特征的值与地标的距离。让我们实际一点:我们有一个具有单一特征的数据集， x1 。我们想要创建两个相似性特征，因此我们选择两个界标，即来自我们的单个特征的参考值。让我们以-1 和 1 为例。然后，对于 x1，的每个值，我们计算它离第一个地标有多远(继续阅读，看看如何定义‘远’)。这是我们新的相似性特征， x2 。然后我们做同样的事情，将 x1 的值与第二个界标进行比较，以获得 x3 。现在我们甚至不需要原来的功能 x1 ！这两个新的相似性特征使我们的数据很容易分离。
相似性特征使得数据可以线性分离。
那么，我们如何计算每次观测到地标的距离呢？一个流行的选择是使用高斯径向基函数，或 RBF。它被定义为:
其中 x 是我们的原始特征，γ是一个参数，我将其设置为 0.3。
例如，在我们唯一的原创特性上，第一个观察得分为-3。我们计算出 x2 为 exp(-0.3 * (-3-(-1)) )≈0.30，而 x3 为 exp(-0.3 * (-3-(1)) )≈0.01。这是右边图上最底部的点。
在上面的例子中，我们幸运地选择了两个工作正常的地标。在实践中，可能需要大量的界标，这转化为许多新的相似性特征。这将大大降低 SVM 的速度——除非我们使用内核技巧！与多项式核类似，RBF 核允许我们获得完全相同的结果，就好像我们在原始要素的每个值处添加了一个界标，而不需要实际这样做。让我们用我们的月亮形状的数据来试试吧。
具有 RBF 核的决策边界，γ=0.3。
决策边界看起来相当不错，但是您可能已经注意到一些错误分类的例子。我们可以通过调整γ参数来修复它。它作为一个正则化因子，它越小，决策边界越平滑，从而防止过度拟合。然而，在这种情况下，我们似乎实际上欠拟合，所以让我们将γ增加到 0.5。
具有 RBF 核的决策边界，γ=0.5。
现在所有的例子都被正确分类了！
摘要
- 支持向量机通过寻找尽可能远离数据的线性决策边界来执行分类。对于线性可分的数据，它们工作得很好，但在其他情况下却很糟糕。
- 为了使非线性数据线性可分(从而便于支持向量机)，我们可以向数据添加更多特征，因为在更高维度的空间中，数据线性可分的概率增加。
- 要添加的两种常见类型的新特征是现有特征的多项式组合(多项式特征)和与地标的观察距离，即一些参考值(相似性特征)。
- 实际上，添加它们可能会使模型变慢到无用的程度。
- 内核技巧是一个聪明的策略，它利用了一些数学属性，以提供相同的结果，就好像我们添加了额外的功能，但实际上并没有添加。
- 多项式和 RBF 核(假装)分别增加了多项式和相似性特征。
来源
- Geron A .，2019，第二版，使用 Scikit-Learn 和 TensorFlow 进行机器学习:构建智能系统的概念、工具和技术
感谢阅读！
如果你喜欢这篇文章，为什么不在我的新文章上 订阅电子邮件更新 ？通过 成为媒介会员 ，你可以支持我的写作，并无限制地访问其他作者和我自己的所有故事。
需要咨询？你可以问我任何事情，也可以在这里 预定我 1:1 。
也可以试试 我的其他文章 中的一篇。不能选择？从这些中选择一个:
你确定你的模型返回概率吗？🎲
towardsdatascience.com](/calibrating-classifiers-559abc30711a) [## 线性回归中收缩法和选择法的比较
详细介绍 7 种流行的收缩和选择方法。
towardsdatascience.com](/a-comparison-of-shrinkage-and-selection-methods-for-linear-regression-ee4dd3a71f16) [## 非线性回归:基础扩展、多项式和样条
如何用多项式和样条捕捉非线性关系？
towardsdatascience.com](/non-linear-regression-basis-expansion-polynomials-splines-2d7adb2cc226)**
SVM(支持向量机)用于分类
SVM 用于分类和回归
SVM:支持向量机是一种监督分类算法，我们在两个不同的类别之间画一条线来区分它们。SVM 也被称为支持向量网络。
考虑一个例子，我们有猫和狗在一起。
狗和猫(作者图片)
我们希望我们的模型能够区分猫和狗。
SVM 术语(图片来自作者)
在许多情况下，区分并不像上面显示的那样简单。在这种情况下，超平面维数需要从 1 维变为第 n 维。这叫内核。更简单地说，这是两个观测值之间的函数关系。这将为数据增加更多的维度，因此我们可以很容易地区分它们。
我们有三种类型的内核。
- 线性核
- 多项式核
- 径向基函数核
在实际生活中，很难得到一个直的超平面。考虑下图中混合在一起的点。您不能使用直线 2d 超平面来分离这些点。
作者图片
SVM 的一些使用案例:
- 人脸检测
- 笔迹检测
- 图像分类
- 文本和超文本分类
让我们看看 SVM 是如何进行回归的。
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
path = 'https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DA0101EN/automobileEDA.csv'
df = pd.read_csv(path)
df.head()
作者图片
df.head()将给出每一列的前 5 行的详细信息。我们可以使用 df.tail()获得最后 5 行，类似地，使用 df.head(10)获得前 10 行。
这些数据是关于汽车的，我们需要使用上面的数据来预测汽车的价格
我们将使用决策树来获得汽车的价格。
df.dtypessymboling int64
normalized-losses int64
make object
aspiration object
num-of-doors object
body-style object
drive-wheels object
engine-location object
wheel-base float64
length float64
width float64
height float64
curb-weight int64
engine-type object
num-of-cylinders object
engine-size int64
fuel-system object
bore float64
stroke float64
compression-ratio float64
horsepower float64
peak-rpm float64
city-mpg int64
highway-mpg int64
price float64
city-L/100km float64
horsepower-binned object
diesel int64
gas int64
dtype: object
dtypes 给出列的数据类型
df.describe()
作者图片
在上面的数据框中，一些列不是数字。因此，我们将只考虑那些数值为数字的列，并使所有的数字都浮动。
df.dtypes
for x **in** df:
if df[x].dtypes == "int64":
df[x] = df[x].astype(float)
print (df[x].dtypes)
出局:
float64
float64
float64
float64
float64
float64
float64
float64
准备数据与分类任务一样，在本节中，我们将把数据划分为属性和标签，从而划分为训练集和测试集。我们将创建 2 个数据集，一个用于价格，另一个用于(df-price)。由于我们的数据框包含各种对象格式的数据，因此在本次分析中，我们将删除所有对象类型的列，对于所有 NaN 值，我们将删除该行。
df = df.select_dtypes(exclude=['object'])
df=df.fillna(df.mean())
X = df.drop('price',axis=1)
y = df['price']
这里，X 变量包含数据集中的所有列，除了标签“价格”列。y 变量包含“价格”列中的值，这意味着 X 变量包含属性集，y 变量包含相应的标签。
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
训练 SVM
from sklearn.svm import SVR
我们将使用函数 SVM 创建一个对象 svr。我们将使用内核作为线性。
svr = SVR(kernel = 'linear',C = 1000)
为了高效工作，我们将对数据进行标准化。SVM 的工作地点相距很远，所以我们所有的数据都必须采用相同的标准。
from sklearn.preprocessing import StandardScalerX_train_std = sc.transform(X_train)
X_test_std = sc.transform(X_test)
X_test_std
sc= StandardScaler().fit(X_train)
出局:
array([[ 0.17453157, -0.7473421 , -0.70428107, -1.4995245 , -1.05619832,
-0.67877552, -1.30249126, -0.87278899, -1.15396095, -0.47648372,
-0.09140157, -0.90774727, 0.59090608, 2.00340082, 1.79022864,
-1.50033307, -0.29738086, 0.29738086],
[-1.42118568, -1.74885637, 0.63398001, 0.14076744, 0.30739662,
0.50614488, -0.1142863 , -0.38613195, -0.24348674, 0.32881569,
3.4734668 , -0.82496629, -1.30634872, 0.73955013, 0.31375141,
-0.82735207, 3.36269123, -3.36269123],
[-0.62332705, -0.01896807, 2.63290164, 2.08080815, 1.2007864 ,
2.05879919, 1.74841125, 0.63584784, 1.38777956, 0.89923611,
3.05894722, -0.2179058 , -2.04417004, -0.05035655, -0.86743037,
-0.18802012, 3.36269123, -3.36269123],
[-0.62332705, 0.16312543, 0.29517974, 0.64867509, 0.30739662,
0.58786352, 1.09156527, 1.34150055, 0.36349607, 0.06038255,
-0.2572094 , 1.35493275, 0.16929391, -1.31420724, -1.31037354,
1.61715245, -0.29738086, 0.29738086],
[-1.42118568, -0.01896807, 0.9897203 , 1.15658275, 0.30739662,
0.17927028, 1.20136639, 0.85484351, -0.24348674, 0.32881569,
-0.20194012, 1.46530738, 0.16929391, -0.99824457, -1.0150781 ,
1.02334568, -0.29738086, 0.29738086],
[ 0.9723902 , -0.86873777, -0.22996069, -0.18396041, -0.16280853,
0.83301947, -0.51623682, -0.4104648 , -0.54697814, 0.4965864 ,
-0.2572094 , -0.49384238, 0.27469695, 0.26560612, 0.46139913,
-0.47216765, -0.29738086, 0.29738086],
[ 0.9723902 , -0.01896807, 0.19353966, 0.28231547, 0.21335559,
-0.22932296, -0.06134647, 0.24652221, -0.54697814, 0.4965864 ,
-0.39538259, 0.19599908, 0.80171217, -0.99824457, -0.86743037,
1.02334568, -0.29738086, 0.29738086],
[ 0.17453157, -1.08118019, -0.50100091, -1.26638656, -1.05619832,
0.34270758, -1.08484976, -0.82412328, -1.07808809, -0.74491686,
-0.2572094 , -1.12849654, -0.67393045, 1.52945681, 1.19963775,
-1.28401775, -0.29738086, 0.29738086],
[-0.62332705, 1.98406049, 0.43069985, 0.2406837 , -0.49195214,
0.26098893, 0.44452297, 0.92784206, -0.09174103, -0.20805059,
-0.2572094 , 0.49952933, -1.83336395, -0.6822819 , -0.4244872 ,
0.54264497, -0.29738086, 0.29738086],
[-0.62332705, -0.95978452, -0.50100091, -0.63358358, -0.6800342 ,
-0.27018228, -0.89661927, -0.67812617, -0.54697814, -0.74491686,
-0.2572094 , -0.90774727, -0.67393045, 0.73955013, 0.9043423 ,
-0.82735207, -0.29738086, 0.29738086],
[-0.62332705, -0.2314105 , 0.02413952, 0.32394725, 0.30739662,
0.75130082, -0.22212668, -0.09413772, 0.21175037, 0.46303226,
-0.36774795, -0.52143604, -0.67393045, 0.10762479, 0.16610369,
-0.33555826, -0.29738086, 0.29738086],
[ 1.77024883, -0.01896807, -1.55128176, -0.41709835, -0.39791111,
-0.84221282, 0.51314867, 1.65782762, 1.53952526, -1.18112071,
-0.11903621, 2.87258398, 1.64493653, -1.31420724, -0.86743037,
1.61715245, -0.29738086, 0.29738086],
[ 0.9723902 , -0.86873777, -0.22996069, -0.18396041, -0.16280853,
0.83301947, -0.5378049 , -0.70245902, -1.2298338 , 0.4965864 ,
3.61163999, -1.40443312, -0.67393045, 1.84541948, 2.23317181,
-1.43212554, 3.36269123, -3.36269123],
[-0.62332705, -0.95978452, -0.50100091, -0.63358358, -0.6800342 ,
-0.27018228, -0.51623682, -0.38613195, -0.24348674, 0.32881569,
3.4734668 , -1.29405849, -1.30634872, 1.37147547, 0.75669458,
-1.20342969, 3.36269123, -3.36269123],
[ 1.77024883, -0.01896807, -0.46712088, -0.05906508, 0.21335559,
-1.41424335, 0.75039751, 0.73317925, 0.97047888, 2.04007695,
-0.80990217, 1.16177714, -0.25231827, -0.99824457, -1.0150781 ,
1.02334568, -0.29738086, 0.29738086],
[ 0.17453157, -0.01896807, 1.20994048, 1.56457414, 2.61140185,
0.83301947, 0.81510174, 0.24652221, -0.54697814, 0.4965864 ,
-0.39538259, 0.19599908, 0.80171217, -0.99824457, -0.86743037,
1.02334568, -0.29738086, 0.29738086],
[ 0.17453157, -0.65629534, -0.83980118, -1.99077944, -0.86811626,
-0.43361958, -1.14171105, -0.82412328, -1.60919805, 0.53014054,
-0.20194012, -0.74218531, 1.85574262, 0.73955013, 0.46139913,
-0.82735207, -0.29738086, 0.29738086],
[ 1.77024883, 0.83080162, 0.07495956, 1.05666649, 0.30739662,
0.99645676, 0.33080038, -0.11847057, -3.01284579, -3.96611452,
-0.17430548, 0.19599908, 0.27469695, -0.6822819 , -0.4244872 ,
0.54264497, -0.29738086, 0.29738086],
[-0.62332705, -0.50455075, -0.3654808 , -0.53366732, -0.30387008,
-0.14760431, -0.48878654, -0.38613195, -0.69872384, 1.10056096,
-0.2572094 , -0.46624873, 1.43413044, 0.26560612, 0.31375141,
-0.47216765, -0.29738086, 0.29738086],
[ 0.9723902 , 1.16463971, -0.83980118, -1.38295553, -0.6800342 ,
-1.16908741, -1.16523986, -0.82412328, -1.3815795 , -0.07383402,
-0.14667084, -0.96293458, 0.80171217, 0.89753147, 1.05199003,
-0.93047013, -0.29738086, 0.29738086],
[ 0.9723902 , -0.86873777, -0.22996069, -0.18396041, -0.16280853,
0.83301947, -0.42996451, -0.70245902, -1.2298338 , 0.4965864 ,
3.61163999, -0.96293458, -1.30634872, 1.84541948, 1.64258092,
-1.43212554, 3.36269123, -3.36269123],
[-0.62332705, -1.14187802, -0.29772074, -0.02575966, -0.20982905,
0.50614488, 0.21903853, -0.43479765, 1.08428815, -2.05352841,
-0.6164597 , 0.22359274, -0.67393045, -0.36631922, -1.16272582,
0.14554438, -0.29738086, 0.29738086],
[-0.62332705, -0.01896807, 2.42962147, 2.13909264, 1.76503258,
-0.35190093, 2.99543824, 3.21513015, 1.12222458, 3.08025536,
-0.50592114, 2.01718056, -0.7793335 , -1.63016991, -1.75331671,
2.36930768, -0.29738086, 0.29738086],
[ 0.17453157, 1.37708213, -0.70428107, -0.43375106, -0.86811626,
-0.43361958, -0.72407465, -0.67812617, -0.54697814, -0.74491686,
-0.2572094 , -0.90774727, -0.67393045, 0.58156879, 0.46139913,
-0.71712242, -0.29738086, 0.29738086],
[-0.62332705, -0.01896807, 0.02413952, 0.32394725, 0.30739662,
0.75130082, -0.18683347, -0.09413772, 0.21175037, 0.46303226,
3.52873607, -1.07330922, -0.99013959, 1.68743815, 1.64258092,
-1.3601287 , 3.36269123, -3.36269123],
[ 1.77024883, -0.01896807, -1.55128176, -0.41709835, -0.39791111,
-0.84221282, 0.42687636, 1.65782762, 1.53952526, -1.18112071,
-0.11903621, 2.87258398, 1.64493653, -1.31420724, -0.86743037,
1.61715245, -0.29738086, 0.29738086],
[ 0.9723902 , -0.01896807, -0.22996069, -0.18396041, -0.16280853,
0.83301947, -0.64564528, -0.4104648 , -0.54697814, 0.4965864 ,
-0.2572094 , -0.49384238, 0.27469695, 0.26560612, 0.46139913,
-0.47216765, -0.29738086, 0.29738086],
[ 1.77024883, -0.01896807, -0.70428107, -1.21642843, -0.77407523,
0.79216014, -0.55741224, -0.4104648 , -0.54697814, 0.4965864 ,
-0.39538259, -0.35587409, 0.80171217, -0.20833789, -0.27683948,
-0.02818713, -0.29738086, 0.29738086],
[ 1.77024883, 1.92336265, -0.70428107, -0.41709835, 1.15376589,
-1.41424335, 0.47001251, 0.61151499, 2.29825376, -0.47648372,
-0.11903621, 1.10658982, 0.80171217, -0.99824457, -0.57213493,
1.02334568, -0.29738086, 0.29738086],
[-0.62332705, 0.67905703, 2.42962147, 2.13909264, 1.76503258,
-0.35190093, 2.99543824, 3.21513015, 1.12222458, 3.08025536,
-0.50592114, 2.01718056, -0.7793335 , -1.63016991, -1.75331671,
2.36930768, -0.29738086, 0.29738086],
[-0.62332705, -0.01896807, 1.92142106, 1.92260741, 2.37629928,
1.07817541, 1.89546632, 2.0228204 , 1.08428815, 0.46303226,
-0.53355578, 2.18274251, 0.59090608, -1.63016991, -1.60566899,
2.36930768, -0.29738086, 0.29738086],
[ 1.77024883, 0.83080162, -0.56876096, -0.40877199, -0.0687675 ,
-1.6593993 , -0.07507161, -1.11611751, -0.01681188, 0.01643855,
-0.14667084, 0.88584055, 1.85574262, -1.47218858, -1.16272582,
1.96972521, -0.29738086, 0.29738086],
[-0.62332705, -1.26327369, -0.50100091, -0.35048751, -1.05619832,
2.22223648, -0.48682581, -0.82412328, -1.07808809, -0.74491686,
-0.2572094 , -1.12849654, -0.67393045, 0.26560612, 0.16610369,
-0.47216765, -0.29738086, 0.29738086],
[-0.62332705, -0.01896807, 2.63290164, 2.08080815, 1.2007864 ,
2.05879919, 1.85625163, 0.63584784, 1.38777956, 0.89923611,
3.05894722, -0.2179058 , -2.04417004, -0.05035655, -0.86743037,
-0.18802012, 3.36269123, -3.36269123],
[ 0.17453157, -0.14036374, -0.83980118, -1.38295553, -0.96215729,
-1.16908741, -0.80446476, -0.67812617, -1.15396095, 0.46303226,
-0.64409434, -0.02475019, 0.80171217, -0.20833789, -0.12919176,
-0.02818713, -0.29738086, 0.29738086],
[-0.62332705, -0.01896807, 0.29517974, 0.76524406, 0.49547868,
0.58786352, 0.04845465, -0.4104648 , -0.54697814, 0.4965864 ,
-0.2572094 , -0.41106141, 0.80171217, -0.05035655, 0.01845597,
-0.18802012, -0.29738086, 0.29738086],
[ 0.9723902 , -0.56524859, 0.07495956, 1.05666649, 0.30739662,
0.99645676, 0.30727157, -0.11847057, 0.78079675, -0.61070029,
-0.17430548, 0.19599908, 0.27469695, -0.6822819 , -0.4244872 ,
0.54264497, -0.29738086, 0.29738086],
[ 0.9723902 , 1.25568646, 0.1257796 , 0.22403099, 0.2603761 ,
0.26098893, 0.56020629, 0.24652221, -0.54697814, 0.4965864 ,
-0.53355578, 0.33396738, 0.80171217, -1.1562259 , -1.31037354,
1.30375443, -0.29738086, 0.29738086],
[ 0.17453157, 0.07207868, -0.39936082, -0.12567592, -0.20982905,
-0.84221282, -0.26134137, -0.09413772, 0.06000467, 0.69791126,
-0.39538259, -0.41106141, -0.25231827, -0.05035655, 0.16610369,
-0.18802012, -0.29738086, 0.29738086],
[-0.62332705, -0.01896807, 2.63290164, 2.08080815, 1.2007864 ,
2.05879919, 1.3562644 , -0.14280343, 0.47730535, -0.20805059,
-0.42301723, -0.16271848, -0.25231827, -0.99824457, -1.0150781 ,
1.02334568, -0.29738086, 0.29738086],
[ 0.9723902 , -1.20257586, -0.83980118, -1.41626095, -1.15023935,
0.01583299, -0.95740203, -0.70245902, 1.08428815, -2.99304439,
-0.2572094 , -0.93534092, -0.46312436, 0.89753147, 0.75669458,
-0.93047013, -0.29738086, 0.29738086]])
我们的数据已经标准化了。
svr.fit(X_train_std,y_train)
y_test_pred = svr.predict(X_test_std)
y_train_pred = svr.predict(X_train_std)
检查我们的预测值
y_test_pred
出局:
array([ 5957.14966842, 14468.92070095, 20448.68298715, 21478.92571603,
20124.68107731, 9079.70352739, 15827.33391626, 6005.66841863,
16069.42347072, 7254.92359917, 9776.48212662, 20670.10877046,
12433.67581456, 11143.00652033, 13539.9142024 , 19226.71716277,
6548.30452181, 20166.24495046, 8818.8454487 , 6470.62142339,
12170.16325257, 10461.81392719, 30525.17977575, 6766.09198268,
13432.63305394, 20616.74081099, 8883.9869784 , 8581.12259715,
14982.54291298, 30430.16956057, 28911.77849742, 13980.97058004,
7824.82285653, 20515.39293649, 8003.99866007, 11357.89548277,
13718.79721617, 16467.89155357, 9304.60919156, 18705.27852977,
6421.02399024]
检查模态性能的时间到了。
from sklearn.metrics import r2_score
r2_score(y_train,y_train_pred)
出局:
0.8510467833352241r2_score(y_test,y_test_pred)
出局:
0.720783662521954
我们对测试数据的 R sqrt 得分是 0.72，对训练数据的 R sqrt 得分是 0.85，这是一个很好的值。
import seaborn as sns
plt.figure(figsize=(5, 7)) ax = sns.distplot(y, hist=False, color="r", label="Actual Value")
sns.distplot(y_test_pred, hist=False, color="b", label="Fitted Values" , ax=ax) plt.title('Actual vs Fitted Values for Price') plt.show()
plt.close()
实际值与拟合值
以上是实际值和预测值之间的曲线图。
SVM 进行分类
在这里，我们将使用我在之前关于 KNN 的故事中使用的糖尿病数据。https://towards data science . com/KNN-algorithm-what-when-why-how-41405 c 16 c 36 f
让我们使用 SVM 进行分类来预测相同的数据集结果。
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as pltdata = pd.read_csv("../input/diabetes.csv")
data.head()
数据集的数据。
我们将通过 pd.read.csv 读取 CSV 文件，通过 head()我们可以看到前 5 行。有些因素的值不能为零。例如，人的葡萄糖值不能为 0。同样，人类的血压、皮肤厚度、胰岛素和身体质量指数也不可能为零。
non_zero = ['Glucose','BloodPressure','SkinThickness','Insulin','BMI']
for coloumn **in** non_zero:
data[coloumn] = data[coloumn].replace(0,np.NaN)
mean = int(data[coloumn].mean(skipna = True))
data[coloumn] = data[coloumn].replace(np.NaN,mean)
print(data[coloumn])from sklearn.model_selection import train_test_split
X =data.iloc[:,0:8]
y =data.iloc[:,8]
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=0, stratify=y)
X.head()
作者图片
对于数据 X，我们取范围从 0 到 7 的所有行和列。类似地，对于 y，我们取第 8 列的所有行。
我们有在程序开始时导入的 train_test_split，我们将测试大小定义为 0.2，这意味着所有数据中的 20%将被保留，以便在稍后阶段测试数据。
from sklearn.preprocessing import StandardScaler
sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.transform(X_test)from sklearn import svm
svm1 = svm.SVC(kernel='linear', C = 0.01)
svm1.fit(X_test,y_test)SVC(C=0.01, kernel='linear')y_train_pred = svm1.predict(X_train)
y_test_pred = svm1.predict(X_test)
y_test_pred
出局:
array([0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0,
1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0,
1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0])
我们有一组数据，但我们需要评估我们的模型，以检查准确性。让我们从混淆矩阵开始
from sklearn.metrics import accuracy_score,confusion_matrix
让我们检查一下混淆矩阵
confusion_matrix(y_test,y_test_pred)
出局:
array([[92, 8],
[26, 28]])
我们有混淆矩阵，其中对角线 118 和 36 显示正确的值，0，0 显示我们错过的预测。
我们将检查准确度分数
accuracy_score(y_test,y_test_pred)
出局:
0.7792207792207793
我们的准确率是 0.78
让我们算出实际值和预测值之间的差异。
df=pd.DataFrame({'Actual':y_test, 'Predicted':y_test_pred})
df
实际与预测
我们创建了 C 为 0.01 的线性模型。但是如何确保它的最佳价值。一种选择是改为手动。我们可以分配不同的值，然后逐个运行代码。但是这个过程非常漫长和耗时。
我们将使用网格搜索，其中我们将分配不同的 C 值，并且从该值的字典中，我们的模型将告诉用户根据模型哪一个是 C 的最佳值。为此，我们需要导入 GridsearchCV
from sklearn.model_selection import GridSearchCVparam = {'C':(0,0.01,0.5,0.1,1,2,5,10,50,100,500,1000)}
这里我们为 c 定义了 10 个不同的值。
svm1 = svm.SVC(kernel = 'linear')svm.grid = GridSearchCV(svm1,param,n_jobs=1,cv=10,verbose=1,scoring='accuracy')
cv 代表交叉验证。verbose 为 1:表示布尔值，将创建消息。
svm.grid.fit(X_train,y_train)[Parallel(n_jobs=1)]: Done 120 out of 120 | elapsed: 43.8s finished
出局:
GridSearchCV(cv=10, estimator=SVC(kernel='linear'), n_jobs=1,
param_grid={'C': (0, 0.01, 0.5, 0.1, 1, 2, 5, 10, 50, 100, 500,
1000)},
scoring='accuracy', verbose=1)svm.grid.best_params_
出局:
{'C': 0.1}
这将为我们提供模型的最佳 C 值的结果
linsvm_clf = svm.grid.best_estimator_accuracy_score(y_test,linsvm_clf.predict(X_test))
出局:
0.7597402597402597
这是我们能从上述 C 值中得到的最佳精度。
以类似的方式，我们可以尝试 Kernel =‘poly ‘。但是对于“rbf ”,我们也需要定义 gaama 值。param = {‘C’:(0，0.01，0.5，0.1，1，2，5，10，50，100，500，1000)}，’ gamma’:(0，0.1，0.2，2，10)并且用正常的一个值 C 从 sklearn 导入 svm svm1 = svm。SVC(kernel='rbf '，gamma=0.5，C = 0.01) svm1.fit(X_test，y_test)。
以上代码可在 https://www.kaggle.com/adityakumar529/svm-claasifier 的查看。
你可以检查我的代码
[## Aditya Kumar | Kaggle
Kaggle 是世界上最大的数据科学社区，拥有强大的工具和资源来帮助您实现您的数据…
www.kaggle.com](https://www.kaggle.com/adityakumar529) [## adityakumar 529/Coursera _ Capstone
Coursera_Capstone。在 GitHub 上创建一个帐户，为 adityakumar 529/Coursera _ Capstone 开发做贡献。
github.com](https://github.com/adityakumar529/Coursera_Capstone)
支持向量机——万金油？
线性和非线性数据集的 SVM 解释
以下解释假设您对监督机器学习以及线性判别函数有基本的了解。
然而，如果你和我一样，拥有金鱼般的记忆力，让我们提醒自己以下几点:
监督机器学习 需要创建一种算法，该算法能够基于示例输入-输出对将输入映射到输出。换句话说，输入神经网络的数据已经预先分类，实际上是在“监督”这个过程。
在监督机器学习中，对我们的输入数据进行分类的一种原始而有效的方法是线性分类器，如 线性判别函数 。这些函数通过超平面决策表面有效地划分了我们的特征空间，该超平面决策表面有助于对存在于两侧的数据进行分类。
听着耳熟？让我们开始吧！
支持向量机(SVM)
简介
作为线性判别函数的子集，SVM 也用 N 维超平面对每个预定义类别的标记训练数据进行分类。n 是所考虑的属性的数量。
让我们考虑下面的红蓝圈数据集。在这种情况下，只有两个属性，x 和 y，导致超平面成为二维线。
多种可能的超平面方向
从图中可以清楚地看出，对于分隔两个类别的绿色超平面，存在多个可能的方向，这影响了模型的方差和偏差。
因此，SVM 试图解决这样一个问题:哪一个超平面是最优选择？
边缘和支持向量
为此，边缘被定义为超平面表面和数据集中最近点之间的距离，称为支持向量。事实上，根据所选的支持向量，边距的宽度和方向可能会有所不同。因此，相应地选择它们以最大化分类的裕度。
位于边缘两侧的数据点被归类为属于相应的数据集。
边距选择
线性判别函数的基本形式如下，
其中 w 是与数据点 x 相关联的权重向量，w0 是偏差或阈值权重。
在超平面 g(x) = 0 上，然后根据 g(x)>0 还是 g(x) <0, points are classified accordingly. If we plot g(x) for our dataset, we expect the final outcome to look as follows,
Now, let us define the vector b, which consists of -1s and 1s depending on which side of the hyperplane each data point x, is situated.
If we multiply g(x) with b(x), we expect all the data points to be translated on the right-hand side of the previous diagram, as all g(x)<0 points will be multiplied by -1.
As a result, the distance M, between g(x) =0 and the leftmost data point is defined as the margin.
However, if a support vector happens to be an outlier, an erroneous point in the dataset, it can result in poor classification as it skews the hyperplane.
As evident from the diagram, the rightmost red data point skews the hyperplane as it overfits to compensate for the anomaly. In fact, the optimum hyperplane remains the one positioned at a steeper gradient located equally between the two datasets.
如果有一种方法可以使 SVM 对支持向量不那么敏感，从而得到一个更一般化的结果呢？
软边缘分类器
我们可以定义一个软度值 C，它定义了数据点可以超过边界准则的程度，从而错误的支持向量不会危及我们的模型的准确性。C 的值可以从交叉验证技术中选择。
如果 C 的值太大，我们允许许多点超出确定的边界。然而，如果 C 的值太小，我们就定义了一个硬边界，并冒着过度拟合数据的风险。
随后，可以用新定义的与软度 C 相关的参数ε来更新余量最大化方程，如下所示，
- 如果ε = 0
，则数据点位于页边距的正确一侧 - 如果ε > 0
，数据点位于页边距的错误一侧 - 如果ε>1
数据点位于超平面的错误一侧
非线性映射
在某些情况下，不可能线性分离数据集，相反，非线性映射能够将数据集分类到更准确的程度。常见的例子包括 XOR 数据集或循环数据集。
循环数据集
因此，需要非线性映射，将数据集放入可以确定合适分离超平面的高阶空间。该映射由变换函数φ执行，并且线性支持向量点积现在可以用φ(x)重新表示。
也许一个例子会使这更直观，
考虑上面的循环数据集。有可能用下面的变换函数将数据点从不可分的二维空间映射到可分的三维空间，
利用前述的φ(x ),判别函数更新如下，
此外，可以示出的是， w 总是 x(或φ(x ),如果在变换空间中操作的话)的线性组合，
结果，为了确定 SVM 判定边界，需要确定以下更高维度的点积[1]，
尽管解决了问题，但是这种方法具有更高数量的计算操作。有 3×2 个操作来转换到 3 维空间，另外还有 3 个操作来执行点积。另外，计算复杂度为 O(n)。
核
为了简化过程，降低计算复杂度和成本，存在被称为内核的函数。
内核将线性不可分的数据转换为线性可分的数据，而无需将数据转换到更高维的空间并计算点积。
因此，可以使用如下内核来解决前面的示例，
与前面的方法相比，核方法使用 2 次计算操作，计算复杂度为 O(n)。
以下是线性内核的示例，其他常见内核包括:
多项式内核
其中 c 和 d 表示多项式次数，由用户定义，以优化分类。
线性分类器有 c=0 和 d=1。
径向内核
其中 d 是多项式次数，γ定义所选支持向量的接近度。高伽玛值选择最近的支持向量，而低伽玛值选择更远的支持向量。
更多内核类型可以在这里找到。
结论
参考
[1] 内核和内核技巧:讲座(犹他大学)
不平衡类:用支持向量机预测酒店取消
当试图构建分类算法时，人们必须经常应对不平衡数据集的问题。
不平衡数据集是指类别之间的样本大小不相等，这会导致分类器的预测出现重大偏差。
来源:照片由 Antranias 从 Pixabay 拍摄。
在这个特定的例子中(可从下面的参考资料部分获得)，支持向量机(SVM)分类模型用于根据取消风险对酒店预订客户进行分类，即如果模型预测客户将取消预订，则为 1 ，如果客户将坚持预订，则为 0 。
H1 数据集用于训练和验证模型，而来自结果模型的预测则使用 H2 数据进行测试。
在这个特定的数据集中，非抵消类(0)的样本大小明显大于抵消类(1)。在前面的例子中，这是通过删除大量的 0 条目来处理的，以便在两个类之间具有相等的样本大小。但是，这不一定是最佳方法，因为在此过程中会丢弃许多数据点。
相反，SVM 模型可以被修改，以惩罚对小类的错误预测。让我们看看这是如何影响分析的。
使用树外分类器和向前向后特征选择方法进行分析时，所识别的特征如下:
- 研制周期
- 原产国
- 细分市场
- 存款类型
- 客户类型
- 所需的停车位
- 到达日期:年
- 抵达日期:月
- 到达日期:周数
- 到达日期:当月的某一天
什么是 SVM？
SVM 是一种监督学习模型，可用于分类和回归任务。
当定义两个类之间的决策限制时，SVM 模型提供了对每个训练点的重要性的评估。
来源:图片由作者创建
位于两个类别之间的决策边界上的少数训练点被称为支持向量。
精确度与召回率和 f1 分数
当比较准确度分数时，我们看到在每个混淆矩阵中都提供了大量的读数。
然而，在精度和召回之间存在一个特别重要的区别。
Precision = ((True Positive)/(True Positive + False Positive))Recall = ((True Positive)/(True Positive + False Negative))
这两个读数经常相互矛盾，也就是说，通常不可能在不降低召回率的情况下提高精确度，反之亦然。
对理想指标的评估很大程度上取决于所分析的具体数据。例如，癌症检测筛查出现假阴性(即表明患者没有患癌症，而事实上他们患有癌症)是一大禁忌。在这种情况下，召回是理想的衡量标准。
然而，对于电子邮件，人们可能更喜欢避免误报，例如，将一封重要的电子邮件发送到垃圾邮件文件夹，而实际上它是合法的。
f1 分数在设计一个更通用的分数时考虑了精确度和召回率。
哪个因素对预测酒店取消更重要？
从酒店的角度来看，他们可能希望更准确地识别出最终会取消预订的客户，这使得酒店能够更好地分配房间和资源。确定不打算取消预订的客户不一定会增加酒店分析的价值，因为酒店知道，无论如何，很大一部分客户最终都会坚持预订。
SVM 和不平衡数据集
上面概述的相关特征包括在内，用于确定客户是否将取消他们的预订。
y1 = y
x1 = np.column_stack((leadtime,countrycat,marketsegmentcat,deposittypecat,customertypecat,rcps,arrivaldateyear,arrivaldatemonthcat,arrivaldateweekno,arrivaldatedayofmonth))
x1 = sm.add_constant(x1, prepend=True)
然后，数据被分为训练数据和验证数据:
x1_train, x1_val, y1_train, y1_val = train_test_split(x1, y1, random_state=0)
可以将“平衡的”类别权重添加到 SVM 配置中，这对于次要类别(在这种情况下，取消类别)上的错误分类增加了更大的惩罚。
from sklearn import svm
clf = svm.SVC(gamma='scale',
class_weight='balanced')
clf.fit(x1_train, y1_train)
prclf = clf.predict(x1_val)
prclf
以下是该模型在验证集上的分类性能:
[[5142 2124]
[ 865 1884]]
precision recall f1-score support 0 0.86 0.71 0.77 7266
1 0.47 0.69 0.56 2749 accuracy 0.70 10015
macro avg 0.66 0.70 0.67 10015
weighted avg 0.75 0.70 0.72 10015
第一类的回忆率为 69%，而 f1 分数的准确率为 70%。现在，让我们在 H2(测试集)上测试预测性能。
[[25217 21011]
[ 8436 24666]]
precision recall f1-score support 0 0.75 0.55 0.63 46228
1 0.54 0.75 0.63 33102 accuracy 0.63 79330
macro avg 0.64 0.65 0.63 79330
weighted avg 0.66 0.63 0.63 79330
我们看到，1 类的召回率现在达到了 75%，而 f1 分数的准确率达到了 63%。值得注意的是，我们可以看到测试集上的 f1 分数较低，但召回率现在高于验证集。
在这方面，如果假设在这种情况下假阳性比假阴性更可容忍，那么人们可以认为该模型在此基础上表现得相当好。
结论
在这个例子中，我们看到了如何使用支持向量机来处理不平衡的数据集，以及如何解释混淆矩阵以提高分类的准确性。
您可以在这里找到原始文章，以及本例中所示的数据集和笔记本的相关存储库的链接。
免责声明:本文是在“原样”的基础上编写的，没有担保。本文旨在提供数据科学概念的概述，不应以任何方式解释为专业建议。
参考
SWAP:soft max-加权平均池
提高梯度精度的探讨
布莱克伊利亚 是新英格兰复杂系统研究所 的研究员。肖恩·贾恩 是微软研究院 的一名 AI 常驻者。
我们的方法 softmax-加权平均池(SWAP)应用平均池，但是通过每个窗口的 soft max 对输入重新加权。
我们提出了一种卷积神经网络的池化方法，作为最大池化或平均池化的替代方法。我们的方法 softmax-加权平均池(SWAP)应用平均池，但是通过每个窗口的 soft max 对输入重新加权。虽然向前传递的值与最大池化的值几乎相同，但 SWAP 的向后传递具有这样的属性，即窗口中的所有元素都接收渐变更新，而不仅仅是最大值。我们假设这些更丰富、更精确的梯度可以改善学习动力。在这里，我们实例化这个想法，并在 CIFAR-10 数据集上研究学习行为。我们发现交换既不能让我们提高学习速度，也不能提高模型性能。
起源
在观看来自 DeepMind / UCL 深度学习课程的詹姆斯·马腾斯关于优化的讲座时，我们注意到他的观点，即随着学习的进行，你必须降低学习速率或增加批量以确保收敛。这些技术中的任何一种都会导致对梯度的更精确的估计。这让我们开始思考精确梯度的必要性。另外，我们一直在深入研究反向传播如何为所有类型的层计算梯度。在进行卷积和池化的练习时，我们注意到最大池化仅计算相对于窗口中最大值的梯度。这丢弃了信息——我们如何才能做得更好？通过使用所有的信息，我们能得到一个更精确的梯度估计吗？
Max-pooling 丢弃了梯度信息——我们如何能做得更好？
进一步背景
最大池通常在视觉任务的 CNN 中用作下采样方法。例如，AlexNet 使用 3x3 Max-Pooling。【引用
在视觉应用中，max-pooling 将一个特征图作为输入，并输出一个较小的特征图。如果输入影像为 4x4，则步幅为 2(无重叠)的 2x2 最大池操作符将输出 2x2 要素地图。max-pooling 运算符的 2x2 内核在输入要素地图上有 2x2 个不重叠的“位置”。对于每个位置，选择 2x2 窗口中的最大值作为输出特征图中的值。其他值将被丢弃。
图 1:最大池化的结果。来源:斯坦福 CS231n(通过 quora )。
隐含的假设是“值越大越好”，即，值越大对最终输出越重要。这种建模决策是由我们的直觉推动的，尽管可能不是绝对正确的。[艾德。:也许其他价值观也很重要！在接近平局的情况下，将梯度传播到第二大值可能会使其成为最大值。这可能会改变模型学习的轨迹。也更新第二大值，可能是更好的学习轨迹。]
你可能会想，这是可微的吗？毕竟，深度学习要求模型中的所有操作都是可微分的，以便计算梯度。在纯数学意义上，这不是一个可微的运算。实际上，在向后传递中，对应于最大值的所有位置简单地复制入站梯度；所有非最大值位置简单地将其梯度设置为零。PyTorch 将其实现为一个定制的 CUDA 内核(这个函数调用这个函数)。
换句话说，最大池生成稀疏梯度。而且很管用！从 AlexNet [ cite 到 ResNet [ cite 再到强化学习[citecite]，应用广泛。
已经开发了许多变体；Average-Pooling 输出窗口中的平均值，而不是最大值。扩大的最大池使窗口不连续；相反，它使用类似棋盘的图案。
图 2:扩大的最大池。来源: arXiv (通过 StackOverflow )。
有争议的是，Geoff Hinton 不喜欢 Max-Pooling:
卷积神经网络中使用的池操作是一个很大的错误，它如此有效的事实是一场灾难。
如果池不重叠，池将丢失关于事物位置的有价值的信息。我们需要这些信息来检测物体各部分之间的精确关系。的确，如果这些池有足够的重叠，那么特征的位置将通过“粗略编码”得到精确的保留(参见我在 1986 年关于“分布式表示”的论文中对这种效果的解释)。但是我不再相信粗略编码是表示物体相对于观察者的姿态的最佳方式(我所说的姿态是指位置、方向和比例)。
【来源:Reddit 上的 Geoff Hinton。]
动机
最大池生成稀疏梯度。有了更好的梯度估计，我们能否通过提高学习速率来迈出更大的步伐，从而更快地收敛？
稀疏渐变丢弃了太多信息。有了更好的梯度估计，我们能否通过提高学习速率来迈出更大的步伐，从而更快地收敛？
虽然由最大池生成的出站梯度是稀疏的，但是该操作通常用于 Conv →最大池操作链中。注意，可训练参数(即滤波器值，)都在 Conv 算子中。还要注意的是:
dL/dF = Conv(X，dL/dO) ，其中:
- dL/dF 是相对于卷积滤波器的梯度
- dL/dO 是来自 Max-Pool 的出站梯度，并且
- X 是对 Conv 的输入(正向)。
因此，卷积滤波器 F 中的所有位置都获得梯度。然而，这些梯度是从稀疏矩阵 dL/dO 而不是密集矩阵计算的。(稀疏程度取决于最大池窗口大小。)
向前:
向后:
图 3:最大池生成稀疏梯度。(作者图片)
还要注意的是， dL/dF 是而不是稀疏，因为 dL/dO 的每个稀疏条目都将一个渐变值发送回所有条目dL/dF。
但这就提出了一个问题。虽然 dL/dF 本身不是稀疏的，但是它的条目是基于稀疏输入的平均来计算的。如果它的输入(dL/dO—Max-Pool 的出站梯度)是密集的，那么 dL/dF 会是真实梯度的更好估计吗？我们如何使 dL/dO 密集，同时仍然保留 Max-Pool 的“值越大越好”假设？**
一种解决办法是平均分摊。在那里，所有的激活都向后传递一个梯度，而不仅仅是每个窗口中的最大值。但是，它违反了 MaxPool 的假设“值越大越好”。
输入 soft max-加权平均池(SWAP)。正向传递最好解释为伪代码:
average_pool(O，weights = soft max _ per _ window(O))
图 4: SWAP 产生一个与 max-pooling 几乎相同的值——但是将渐变传递回窗口中的所有条目。(作者图片)
softmax 运算符将值归一化为概率分布，但是，它更倾向于大值。这给了它一个类似最大池的效果。
在向后传递中， dL/dO 是密集的，因为中的每个出站激活都依赖于其窗口中的所有激活—而不仅仅是最大值。 O 中的非最大值现在接收相对较小但非零的渐变。答对了！
实验设置
我们在 CIFAR10 上进行实验。我们的代码可在这里获得。我们将网络架构固定为:
我们测试了“池”层的三种不同变体:两个基线(最大池和平均池)，以及交换。使用 SGD，LR=1e-3 对模型进行 100 个时期的训练(除非另有说明)。
我们还训练了 LR 增加{25，50，400}%的 SWAP。这是为了测试这样一个想法，使用更精确的梯度，我们可以采取更大的步骤，而使用更大的步骤，模型会收敛得更快。
结果
讨论
与两个基准相比，SWAP 的性能更差。我们不明白为什么会这样。LR 的增加没有带来任何好处；一般来说，随着 LR 的增加，观察到的性能比基线更差。我们将 LR 性能提高 400%比提高 50%归因于随机性；我们只测试了一个随机种子，并且只报道了一个试验。对于 400%的增长表现更好的另一个可能的解释是，用更高的 LR“覆盖更多的地面”的能力。
LR 的增加没有带来任何好处；一般来说，随着 LR 的增加，观察到的性能比基线更差。
未来工作及结论
虽然 SWAP 没有显示出改进，但我们仍然想尝试几个实验:
- ****重叠池窗口。一种可能性是使用重叠的池窗口(即步距= 1)，而不是我们这里使用的不相交窗口(步距= 2)。现代卷积架构，如 AlexNet 和 ResNet 都使用重叠池窗口。因此，为了公平的比较，明智的做法是与更接近艺术水平的东西进行比较，而不是我们在这里为了简单而使用的架构。事实上，Hinton 对最大池的批评在非重叠池窗口的情况下是最严格的，理由是这丢弃了空间信息。
- ****激活直方图。我们希望使用完全相同的初始化来尝试 Max-Pool & SWAP，训练两者，并比较梯度的分布。调查梯度的差异可以更好地理解训练行为中的鲜明对比。
提高梯度精度仍然是一个令人兴奋的领域。我们还能如何修改模型或梯度计算来提高梯度精度？
群体智能——基于群体的降维
利用群体智能优化多元数据
一群椋鸟——由詹姆斯·温斯科特在 Unsplash 上拍摄
Ab——一种基于群体的降维方法，受群体智能(SI)和主成分分析(PCA)的启发。它使用粒子群优化(PSO)的矢量化实现，以提高计算效率。该模型以标准 PCA 为基准。
介绍
这些年来，技术发生了巨大的变化，随着个人和企业越来越能够访问更高的处理和计算能力、更大的内存容量、更智能和更高效的数据存储技术等等，无论是在内部还是在云中，技术访问差距都在逐年缩小。尽管如此，数据量仍呈指数级增长，预计这一趋势在可预见的未来还将继续。因此，降低海量数据集的维度是创建更有效的机器学习模型的最重要的方面之一。
降维
目标是产生一个具有较低维度的新数据集，而不丢失其原始特征。与 PCA 一样，我们将使用协方差矩阵来确定方差和协方差。
考虑一个由 N 个特征和 M 个观察值组成的数据集。可以描述为一系列的 N 维向量，表示为一个 MN* 矩阵。
其中 i ∈ {0，…，M} 和 j ∈ {0，…，N} 。X 的协方差矩阵是通过从数据中减去平均值并乘以其转置，然后除以样本数而获得的。这是至关重要的，以便不同尺度的特征被同等地解释。它由下式给出:
如果已经扣除了特征的平均值，协方差矩阵可以写成:
请注意，您可能会遇到略有不同的符号版本 C_x ，特别是我们使用行向量来表示数据，而大多数引用将数据表示为列向量，这允许点积元素。尽管如此，使用这两种方法都会得到相同的结果。
我们对协方差矩阵感兴趣的原因是，它描述了数据集内的方差以及元素间的协方差。视觉上，主对角线元素保存方差，而协方差信息跨越非对角线元素。例如，给定一个具有标记为 {x，y，z} 的特征的三维数据集，我们得到以下表示:
PCA 的目的是找到一个线性变换，给定 X ，生成一个低维数据集 Y 。最终，我们会寻找另一个与原始基线性相关的基，它可以更有效地表示数据。这可以表示为:
其中 P 是线性变换矩阵。考虑到这一点，主成分分析设定了转换数据的两个主要目标，即:
- 最大化方差，即所有特征样本的可变性或信号。
- 最小化协方差，即冗余数据，以进一步压缩数据集。
在实践中，我们需要优化线性变换 P ，以便产生的数据集 Y 在强调数据信号和抑制噪声或冗余信号方面更有效地表示数据。为此，我们需要最大化主对角元素，最小化对应协方差矩阵 C_y 的非对角元素。
现在很清楚，这是一个最大化/最小化问题，非常适合优化算法，其中包括群体智能模型，我们将使用该模型将低维数据集 Y 拟合到最佳协方差矩阵 C_y 。
基于群体的方法
我们将在这里使用与前面描述的相似的符号，稍作修改以适应基于群体和矢量化的计算。我们为低维数据定义了以下符号:
其中 X 是一批 Np 输入，每个输入的尺寸为 MN* ，如前所述。
我们将 Y 定义为一批 Np 输出，其中每个输出的维数为 MK，其中 K∈ R 和 K < N ，以及 P 一批维数为 NK 的 Np 变换矩阵。变换矩阵的集合是要被训练并适合解的粒子。
遵循这种模式，并参考 C_y 定义，我们得出结论，矢量化协方差矩阵 C_y 将具有维度 NpKK 。
健身功能
适应度函数必须反映我们数据集的准确性，尽可能多地保留原始数据特征，并消除冗余或有噪声的数据。我们将提出两种适合度评估的方法，其中一种来自文献，而另一种已被证明在 Iris 数据集上优于它，因此将被使用。
我们可以将适应度定义为信噪比(SNR) [1]:
其中 σ_signal 表示方差， σ_noise 表示协方差。高 SNR (≫ 1)表示高精度数据，而低 SNR 表示受噪声污染的数据。请注意，本文中的适应度是一个真正的正数 SNR≥0 ，而不是一个百分比或有界数字。为确保信号最大化(方差→+∞)且噪声抵消(协方差→0)，我们将 SNR 定义为:
通过使用上面的 SNR 定义作为我们的适应度函数，该模型将惩罚低方差和高协方差。我们使用对数标度来获得更好的适应性解释能力。
在 Iris 数据集预测上胜过 SNR 度量的另一种方法是通过将适应度函数视为方差和协方差的加权和:
其中 α_1 和 α_2 是控制各项贡献的加权系数。例如，为了进一步优化惩罚低方差，您可以使用 α_1=5 和 α_2=1 。
粒子运动
一旦评估了适应度，粒子被移动以扫描更好的解决方案，即实现更高适应度分数的解决方案。粒子运动由以下方程控制，该方程将粒子向其个人最佳值 p 和全局最佳值 g 的方向移动。
其中 v[i] 代表第 np 个 NK 个维质点在 i 时段的速度，其中NP∈{ 0；Np}* ， v[i-1] 前一历元中的速度，R1和*R2Np**N * K*-均匀分布随机数的维矩阵，以及最后 ω 控制前一速度对新速度的贡献的加权系数。
上面执行了 Np 粒子速度的矢量化计算。之后，我们在知道每个粒子的速度的情况下计算粒子的新值:
一旦粒子被移动，我们可以重新评估适应值，并更新个人最佳值和全局最佳值。这要重复几次，直到满足终止标准。最终的全局最佳解决方案是最佳转换矩阵，在此基础上我们可以检索原始数据集 X 的低维表示 Y 。
绩效基准
我们将通过数据表达能力来评估模型。低维数据集的可表达性将根据加权方差和协方差总和来测量，但也可以根据前面描述的信噪比来测量。
在 Iris 数据集上进行的 1000 次 SBDR 运行的样本测试，每次有 100 个时期和 40 个粒子，获得了 5.87 的平均适应度得分，而标准 PCA 获得了 1.96 的适应度得分。下图显示了 SBDR 的表现，以适应度得分表示，并与标准 PCA 并列显示。
此外，生成的数据集用于在该数据集上训练随机森林模型，并在测试集上进行预测。标准 PCA 实现了 80%的预测准确度，而 SBDR 在 1000 次运行中实现了 86.5%的平均准确度。
结束了👋
如果你能走到这一步，谢谢你留下来！
[1] J. Shlens，2014，《主成分分析教程》
[2] J .肯尼迪，r .埃伯哈特，1995，“粒子群优化”
迈向更好的冠状病毒预测
利用机器学习的最新进展进行新冠肺炎预报
从 5 月 9 日开始，我们的一个模型在纽约市布朗克斯县的投影图像。实际案例显示为橙色，我们模型的预测显示为蓝色。你可以看到我们的模型准确地预测了总体下降轨迹，但是仍然没有捕捉到所有的日常噪音。
编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
随着新冠肺炎席卷全球，人们(尤其是美国人)急于重返工作岗位，我们现在比以往任何时候都更需要模型来有效预测新冠肺炎的传播。然而，目前许多模型在估计疾病传播和社会距离的整体影响方面表现不佳。在这篇文章中，我将回顾为什么疾病预测模型是有用的，当前模型采用的方法的问题/限制，以及使用深度学习方法的好处和障碍。
为什么我们需要更好的预测
在讨论当前新冠肺炎预测模型的问题之前，让我们来看看它们为什么有用:
- (1)让决策者了解社会距离的影响
- (2)确定风险最高的具体县/市/镇
- (3)帮助医院规划人员、床位和设备
- (4)通知病毒学家和流行病学家研究什么因素
(1)一个好的模型应该有效地告知当选官员和决策者冠状病毒及其对其社区的影响。具体而言，该模型不仅应该提供预测，还应该提供可操作的见解，说明不同的政府政策将如何影响新增病例和死亡人数，以及病毒将如何给医院带来负担。与理想情况相反，该模型还应基于观察值运行。这是一个数据驱动的方法，而不是纯粹的数学方法，有意义的领域。例如，一个将社会距离政策作为输入，然后基于公民遵守该政策假设某种结果的模型，在现实中可能不会表现得很好。相反，模型需要了解政府社交距离政策的因果影响，首先，它们与移动数据的关系，其次，实际的病毒传播。
(2)另一个问题与特定地区的预测有关。虽然在国家层面预测病例和死亡的模型在广泛估计所需的个人防护设备和呼吸机数量方面有一定的效用，但它们没有太多进一步的用途。美国有许多不同的州，每个州都有不同的人口、资源和气候。在某些情况下，即使是州一级的预测也可能过于宽泛。例如，病毒在纽约市的传播方式可能与它在北部各县的传播方式非常不同。同样，病毒在芝加哥的传播方式可能与在卡本代尔的传播方式不同。县或市/镇一级的预报为地方官员提供了最大的价值。这些预测使城市/城镇能够仅根据其风险来计划应对措施。这有可能使更多的领域开放。例如，如果模型预测某个城市/城镇的风险较高，但该州另一边的另一个地区的风险较低，那么关闭后者但允许前者保持开放就没有什么意义了(当然，您也希望确保这些地区之间没有太多的旅行)。
(3)理想情况下，模型还可以预测特定县的入院人数，甚至更好地预测特定城市/城镇每天的入院人数。这将使医院能够规划人员配备、应急响应人员，并以最佳方式获得 PPE。特别是，如果模型提前一两周预测到高峰，那么医院有足够的时间准备应对。此外，预测 ICU 床位利用率对于及时建造野战医院至关重要。
(4)最后，好的模型可以潜在地突出各种促进进一步研究的传输机制。例如，假设说，如果一个模型发现紫外线是传播的一个主要因素，这可能会促进额外的流行病学研究。当然，对于这一点，我们必须非常小心，模型不仅仅是学习噪声。然而，机器学习确实有潜力在寻找包括病毒学在内的各种研究领域的新研究方向方面发挥核心作用。
当前大多数型号的困难
Nate Silver 在文章“为什么做一个好的新冠肺炎模式如此困难”中列举了新冠肺炎建模的许多困难。然而，这些困难中的许多来自于试图构建精确的数学/统计公式来预测新冠肺炎。Silver 讨论了使用无症状率和感染率等变量。这是有问题的，因为在经典 SEIR 模型中，我们必须为这些参数假定某些值。此外，像 IMHE 这样的模型，例如，主要依赖于曲线拟合。CurveFit 利用各种各样的变量提供给模型。首先，IMHE 利用样条曲线来拟合新冠肺炎曲线，然后依靠一些额外的调整来拟合数据。对于那些不知道的人来说，样条是一个数学多项式公式，用于绘制平滑曲线。这种方法仍然需要大量的手动参数和特征。四月份的一篇 VOX 文章指出了与 IMHE 模型相关的许多问题。具体来说，本文讨论了模型的置信区间的变化和更新预测的问题。例如，VOX 指出“该模型假设死亡人数会增加，然后又会下降；“虽然从广义上讲这可能是真的，但在日常层面进行预测时，报告中会有很多噪音和差异。第二，有许多不同的因素可以阻止真实数据有这样的轨迹。模型必须足够稳健，以确定噪声，从而不做一般假设。
其他模型，如日内瓦大学、加州理工学院、麻省理工学院、MOBS 大学、加州大学洛杉矶分校、弗吉尼亚大学和德克萨斯大学，在进行预测时，假设社会距离将继续以目前的形式存在。随着限制的放松，他们的数量可能会因此发生巨大变化。最后，大量模型仅在州和国家层面进行预测。这是深度学习最具潜力的领域，因为它能够学习输入特征之间的许多复杂交互，如季节性、社交距离和地理位置。此外，通过足够的数据扩充技术和迁移学习，该模型应该能够处理分布的变化，如社会距离的结束。然而，正如我们将在下面讨论的那样，使用深度学习来预测新冠肺炎仍然存在许多障碍。
我们的方法有何不同
我们的目标是整合深度学习的最新研究，用于时间序列预测，以解决这些问题。尽管许多人对流行病学中的深度学习保持警惕，但使用它有许多优势。例如，与纯统计模型不同，深度学习模型从现有的实际数据中学习。深度学习模型也有可能更好地整合所有复杂的变量，如天气和症状调查。然而，深度学习方法仍然存在许多挑战。使用深度学习最明显的最初挑战围绕着训练数据的缺乏:目前我们仍然只有 110 个时间步骤，对于许多美国县来说。此外，对于大多数县/州，我们有不到 90 个时间步长。另一个问题是时间步骤的不平衡，没有新病例。对于移动性，在疫情开始之前，我们几乎没有数据可以提供给模型。因此，利用迁移学习和数据扩充是取得良好结果的关键。
在 CoronaWhy 做志愿者并组建跨学科团队
我们的团队是 CoronaWhy 唯一专注于时间序列预测的团队。CoronaWhy 是一个由 900 多名志愿者组成的全球组织，致力于应用机器学习来更好地了解冠状病毒。大多数其他团队专注于白宫挑战 和利用 NLP 。我们的团队成立于 3 月初，旨在分析与冠状病毒相关的时间数据。从那时起，我们已经吸纳了来自世界各地的 30 多名成员。除了病毒传播预测，我们还有其他计划，如预测医院中的患者预后(不幸的是，由于缺乏 ICU 数据，这一计划受阻)。我们的团队与其他 CoronaWhy 团队密切合作，如 datasets 和 task-geo。
由于我们是一个全球性的志愿者团队，因此很难安排会议，因为我们在世界各地的成员也忙于他们的日常工作。出于这个原因，我们总是记录我们的会议，以便那些无法参加的人可以回放。此外，我们会在一整天的空闲时间积极沟通。虽然分散存在挑战，但也有一些优势。例如，当一些团队成员在睡觉时，其他人可以积极地工作并为项目做出贡献。我们在特雷罗董事会上管理所有问题，并尝试每周计划我们的工作。
对于像 COVID 这样的问题，拥有一个真正的跨学科团队至关重要。这就是为什么从一开始，我们的目标是搭载领域专家。到目前为止，我们有一位流行病学家和一位生物信息学家定期为这个项目做出贡献。拥有领域专家让我们能够以只有机器学习成员的团队无法做到的方式专注于我们的研究。例如，这些专家可以帮助我们了解这种疾病在生物层面上是如何传播的。同样，拥有各种各样的机器学习专家可以启发对模型的讨论。我们有来自更传统的统计背景的个人，NLP 研究人员，计算机视觉专家，和软件工程师。正如我们将在后面讨论的，计算机视觉和 NLP 的许多技术也可以直接应用于时间序列预测。
用于时间序列预测的元学习/迁移学习
如上所述，在这种情况下，有限的数据是有效利用机器学习的主要障碍之一。通常在这种情况下，我们会求助于已被证实的少量学习技巧。然而，尽管迁移学习在 NLP 和计算机视觉中取得了广泛的成功，但很少有文献研究它在时间序列预测中的效用。 TimeNet 使用预训练的 RNN 进行了测试，发现它提高了临床时间序列预测数据集的性能。然而，除了 TimeNet，只有少数论文研究了这个问题。拉普捷夫，于等。艾尔。，描述使用重建损失来帮助迁移学习。除了翻译研究之外，一些论文还探讨了其他方法。一篇题为“从多个城市学习:元学习方法”的论文着眼于美国各个城市的元学习出租车和自行车模式。在时间序列预测方面，我们可以考虑利用 NLP 和计算机视觉中的许多其他技术。采用流行的算法，如爬行动物和计算机视觉的 MAML，是另一种可能的途径，可以导致整体更好的少数镜头时间序列预测方法。在我们的一些初始模型迭代中，我们确实在选定的县看到了一些积极的转移(例如纽约市和芝加哥似乎受益于预培训)，但是我们没有严格评估这些结果。这为未来的研究留下了大量的空间。
垂直合并数据
可以对各种时间序列预测数据集进行迁移学习。然而，最相似的数据可能导致最积极的转移。因此，我们正在努力从类似的流行病和病毒中收集数据。从 SARs、MERs 和 Zika 等疫情中收集数据可以帮助模型学习。我们也在研究更通用的迁移学习技术。我们还旨在回答几个关键问题:例如，通过通用嵌入层，风能/太阳能数据的预训练能否提高性能？有没有可以从任何时间数据中找到的一般地理空间模式？我们的思维过程是，即使数据完全不相关，它也可以作为迁移学习的有效方法，因为它可以帮助初始层有效地提取时间模式。另一种可能更有效的转移方法是在每个县、州和国家反复训练。这些只是我们垂直整合的数据类型的一些例子。当然，自相矛盾的是，疫情持续的时间越长，我们的模型就应该变得越好。这就是为什么我们正与基础设施和工程团队合作，随着更多数据的可用，创建一个持续改进/重新训练模型的框架。
对库克县四月份为期十天的迁移学习的预测。MSE 26515.275
未进行县调学习的同期预测。最终 MSE 30200.779(MSE 越低越好)。虽然转移似乎有助于这种情况下，我们没有进行严格的平衡研究，所以它可能是由于其他原因。此外，值得注意的是，在某些情况下，确诊病例数量的激增可能是由于报告延迟，而不是实际病例数量减少。因此，直接拟合数据的效用是另一个讨论的话题。
横向合并数据
我们正在横向集成各种各样的数据源。或许最重要的是，我们正在考虑整合来自谷歌、脸书和其他提供商的移动数据。我们还增加了天气数据，如湿度、温度、紫外线和风。我们仔细监控模型中的每一项添加对整体性能的影响。例如，我们从以前的案例和星期几变量开始。现在，我们正在整合移动数据和天气数据。接下来，我们将考虑纳入一个县的医院数量、到医院的平均距离、平均年龄、人口密度、总人口等人口统计数据。，以更好地预测录取和 COVID 传播。我们也在寻找增加来自 FB 和其他数据源的患者调查的方法。此外，更先进的地理空间数据可能证明是有价值的。
最初，当我们添加关于移动性的数据时，我们注意到与之前的新案例相比，性能有所下降。只有当我们扩展 forecast_history 时，性能才似乎有所提高。这可能是由于新冠肺炎的潜伏期较长。
接受移动数据+新案例培训的模特 Emilia Italy。这里我们注意到模型需要更长的预测历史来准确预测未来的情况。这与我们通常认为病毒在患者出现症状前需要几天时间的理解是一致的。特别是，我们发现 10 天或 11 天的回看窗口似乎可以为我们提供移动性数据的一些最佳结果。然而，我们也可以尝试探索更长的范围(15 天以上)
数据增强
有几种方法可以生成时间序列数据。TSAug 是一个提供不同方法来扩充 TS 数据的库。在 TSAug 中创建合成数据的一种简单方法是使用裁剪和漂移。还存在其他库和技术，如用于创建合成时间序列数据的 GANs。另一种可能增加数据的方法是创建更多的地理位置。例如，我们可以将邻近的县相加。这将具有为模型提供更多训练数据点的效果。
混合动力车型
有一些潜在的混合方法值得探索。例如，我们可以将深度学习与 SEIR 模型或上面提到的曲线拟合方法相结合。混合动力车型很有吸引力；例如，在“M5 预测竞赛”中获胜的模型使用了 RNN 和指数平滑的组合。此外，前面提到的谷友洋模型是一种混合 SEIR/ML 方法。
为有效转移创建模型
对时间序列数据使用迁移学习的部分困难在于缺乏统一的维度。不同的多元时间序列数据可能不包含所有相同的特征。寨卡数据包含感染信息，但没有相同的伴随移动数据。SARs 和 MERs 是最相似的病毒，但是官员们没有对它们进行广泛的追踪。因此，我们的模型需要处理可变数量的“特征”时间序列。处理这个问题的一个方法是实际交换“上层”在大多数迁移学习任务中，我们通常交换较低的层。然而，如果我们想要将多元时间序列数据映射到一个公共的嵌入维度，这里我们至少需要一个可交换的“上层”。
超参数
我们方法的另一个“缺点”是参数数量太多。因此，我们利用参数扫描来帮助我们搜索最有效的组合。为此，我们使用 Wandb 扫描工具，并可视化结果/参数重要性:
使用变压器模型时的参数扫描；在这里，我们查看编码器层数和 sequence_len 等参数如何影响整体 MSE。
安特卫普参数重要性图表示例。绿色表示较大的值导致较高的 MSE 损失(坏),而红色表示较大的值导致较低的 MSE 损失。
交代
将深度学习用于 COVID 的另一个障碍与解释和解释研究结果有关。许多统计模型因缺乏透明度而招致负面报道。这个问题可能会因 DL 模型而恶化，因为它有着充当黑箱的负面名声。然而，这个问题有潜在的补救措施，尤其是在使用变压器和其他变体时。例如，我们可以很容易地用变形金刚查看热图中模型的特征。类似地，各种方法，如利用卷积热图或交叉维度关注输入特征，可以帮助我们理解模型是如何学习的。最后，利用贝叶斯学习等方法可以帮助模型衡量自身的不确定性并生成区间。我们最近成功地将置信区间添加到我们的模型输出中，并计划将它们包含在所有未来的结果中。
评测
即使有各种各样的数据可用，评估一个模型也是复杂的。不幸的是，对于 COVID，我们的时态数据非常有限。因此，评估最多限于 40 个左右的时间步。最初，我们仅在 4 月份的一周时间内评估模型，但是我们很快发现我们的超参数搜索超过了一周的测试集。因此，我们最近在 5 月份将评估时间延长至两周。然而，这仍然有过度适应的可能。我们目前计划添加代码来自动评估测试集中每两周的排列。虽然不完美，但这确实提供了更多的评估数据点，并减少了仅将超参数调整到一个两周周期的机会。随着越来越多的数据在更大范围的季节、疫情的阶段和地点变得可用，我们希望开发出更强大的评估方法，包括在滚动的基础上评估数据。
选择合适的评估指标是另一个困难的决定。在我们的例子中，现在我们使用均方差(MSE)。然而，MSE 确实有一个基本问题，即它不是规模不可知的。因此，虽然比较特定县的模型很容易，但跨县的模型并不好。这就是标准化 MSE 或平均绝对百分比误差等指标发挥作用的地方。此外，平均绝对平方误差或 MASE 可能是另一种选择。
工作流程
从技术角度来看，我们如何训练和评估模型与权重和偏见密切相关。我们使用权重和偏差来有效地跟踪我们所有的实验。其次，Wandb 用于记录模型的各种性能结果，并在发布时将其导出到 Latex。我们还使用其他技术，如协同实验室、人工智能笔记本(当需要更多计算能力时)、GCS 以及 Travis-CI。然而，我们所有的关键代码都存储在一个中央存储库中，并通过单元测试进行跟踪。我们只使用笔记本来定义配置文件和从中央存储库导入功能/模型。然后将这些配置文件记录到 W&B，供以后分析。砝码和自动 UUID 一起自动存储在 GC 上，以识别它们的配置文件/结果。用于创建我们的组合数据集(即移动数据、新病例、天气、症状调查等)的代码。)存储在我们的存储库中。目前，这个代码必须手动运行，但我们正在努力建立数据管道与工具，如气流运行在日常基础上。我们正在积极努力的另一个领域是与我们的数据集团队一起改进整体数据架构。具体来说，我们正在考虑如何在成本方面最好地利用我们的资源，并使我们的架构能够在任何云环境中工作。
一个我们用来预测冠状病毒的配置的例子。您可以在这里看到，我们包括了各种各样的参数。这些参数中的一些权重和偏差在其扫描中进行优化，而一些是静态的。排除的层是不在原始配置文件中的层
更完整的例子请见这一要点
透明度
不像其他项目有封闭的源代码模型和/或不解释他们的决定，我们致力于尽可能的透明。我们的大部分代码都是开源的，在 GitHub 上(我们计划在接下来的几周内开源更多的部分)。我们所有的会议和讨论都发布在我们的 GitHub 页面上，因此任何人都可以观看。关于数据，大多数数据来源都是公开的，并将定期上传(仍在最后确定中)到 Dataverse。不幸的是，由于患者隐私，我们的一些数据必须保持隐私，但我们确实计划彻底概述人们如何申请访问这些数据源。此外，我们所有的结果都被记录到关于权重和偏差的公共项目中，这样任何人都可以分析我们所有的实验结果。无论背景或专业知识如何，来自外部社区的反馈总是受欢迎的。
结论
深度学习有可能帮助创建更好的 COVID 预测模型，进而帮助公共政策规划。然而，有效使用 COVID 数据仍然存在许多障碍。这就是为什么我们目前正在加大努力，利用机器学习领域的前沿技术来克服这些挑战。如果你有兴趣志愿参加这项任务，请直接联系我或 CoronaWhy。我们对获得更多病毒学和流行病学领域的专家和合作者特别感兴趣。我们还希望获得更多的公共政策专家来思考我们的模型如何产生最积极的影响。最后，一如既往，我们继续寻找迁移学习、元学习、时间序列预测和数据工程方面的专家来充实我们的团队。
更多资源
除了上面列出的资源，您还可以在其他地方找到关于我们项目和其他工作的信息:
内特·西尔弗关于我们前进方向的博客文章(5 月 1 日发表)
sweet viz:Python 中的自动化 EDA
使用 Sweetviz python 库进行探索性数据分析
探索性数据分析是一个过程，在这个过程中，我们往往使用可视化方法来分析数据集并总结数据集的主要特征。EDA 真的很重要，因为如果你不熟悉你正在处理的数据集，那么你将无法从这些数据中推断出一些东西。但是，EDA 一般需要很多时间。
但是，如果我告诉你 python 可以在一些库的帮助下自动化 EDA 的过程呢？不会让你的工作更轻松吗？那么让我们开始学习自动化 EDA 吧。
在本文中，我们将使用 Sweetviz 致力于自动化 EDA。它是一个 python 库，可以生成漂亮、高密度的可视化效果来启动您的 EDA。让我们详细探索一下 Sweetviz。
安装 Sweetviz
像任何其他 python 库一样，我们可以使用下面给出的 pip install 命令来安装 Sweetviz。
pip install sweetviz
分析数据集
在本文中，我使用了一个包含 4 个属性和 200 行的广告数据集。首先，我们需要加载正在使用的熊猫。
import pandas as pd
df = pd.read_csv('Advertising.csv')
广告数据集。
Sweetviz 有一个名为 Analyze()的函数，它分析整个数据集并提供详细的可视化报告。
让我们使用下面给出的命令来分析我们的数据集。
# importing sweetviz
import sweetviz as sv#analyzing the dataset
advert_report = sv.analyze(df)#display the report
advert_report.show_html('Advertising.html')
EDA 报告
我们开始了，正如您在上面看到的，我们的 EDA 报告已经准备好，包含了所有属性的大量信息。它很容易理解，只用 3 行代码就准备好了。
除此之外，Sweetviz 还可用于可视化测试和训练数据的比较。为了进行比较，让我们将此数据分为两部分，前 100 行用于训练数据集，其余 100 行用于测试数据集。
Sweetviz 的 Compare()函数用于数据集的比较。下面给出的命令将创建和比较我们的测试和训练数据集。
df1 = sv.compare(df[100:], df[:100])
df1.show_html('Compare.html')
使用 sweetviz 进行对比分析
除此之外，Sweetviz 还提供了更多功能，您可以通过 进行操作。
你觉得这个漂亮的图书馆怎么样？继续尝试，并在回复部分提及你的经历。
还有其他一些自动化 EDA 过程的库，其中之一是 Pandas Profiling，我在下面的一篇文章中已经解释过了。
创建您自己的数据并对其执行操作。
towardsdatascience.com](/creating-dataset-using-faker-and-use-it-for-pandas-profiling-6fe26e1b9557) [## 逐步了解数据分析
对数据集应用数据分析以获得关于数据的见解。
towardsdatascience.com](/understanding-data-analysis-step-by-step-48e604cb882)
在你走之前
感谢 的阅读！如果你想与我取得联系，请随时通过 hmix13@gmail.com 联系我或我的 LinkedIn 个人资料 。 您也可以在我的*Github中查看我在这里使用的代码和数据。*
Swift 符合照片框架和 CoreML:智能整理应用背后的技术细节
使用 Photos/Vision framework 和 CoreML 的图像整理应用程序背后的技术分享
卡尔·帕夫洛维奇在 Unsplash 的照片
在上一篇文章中，我分享了我的应用程序的产品创意，它使用智能建议来帮助整理手机上的照片，紧密基于KonMarie组织策略。
在这一部分，我分享了一些我开始 iOS 开发之旅的技术笔记和思考，重点是 AI/ML 和图像技术。我还讨论了在设备上构建个性化的 ML 模型*。希望它能为未来的企业家或开始应用程序开发的人提供一些实用的技巧。*
开始
学习 Swift
来源:Mindfire Solutions 的 Swift 发展
我是带着这个项目开始第一次学习 Swift 的。接触一些类似的编程语言确实大大加快了我的学习过程。
我对 Swift 的主要看法是:
- Swift 是一种现代、简洁的编程语言，它拥有来自其他编程语言的许多范例，如委托和生命周期方法(类似于 React 中的那些)，作为第一类的功能，强类型安全和空安全(在安全方面，代码的便利性和可靠性之间有一个权衡)。
- Swift 本身是一个多语种者——覆盖广泛的用例，从前端开发到深度 NeuralNets 模型的脚本批量训练。我发现它在每个角色中都表现得很好。
- 我发现 Swift 功能强大，是一种精心设计的语言，但学习曲线有点陡。事后看来，投资学习基本概念(如委托、异步处理、异常处理、包装和解包等)确实是值得的，因为随着学习的进展，这将加速后面的阶段。
就我个人而言，斯威夫特给人的感觉是一个聪明、老练的角色，这需要时间来熟悉，不像 Python 或 Ruby 那样友好、务实。
Xcode
大多数时候，VS 代码是我首选的 ide。然而，对于 iOS 开发，我认为使用 Xcode 是更合适的选择。
Xcode 有助于调试、分析、运行模拟、所见即所得编辑器、管理构建和发布应用程序。它对于检查和管理 CoreML 格式的 ML 模型也很有用。它与 Xcode 服务器集成，用于 CI/CD 管道。
总的来说，良好集成的工具的重要性胜过其他问题，这让我免去了在多种工具之间切换的麻烦。
更先进的图像处理技术
图像处理
我很兴奋地用我的 iPhone 尝试一些神奇的照片。我对此并不失望，因为苹果确实提供了很好的库支持，用照片框架来处理图像。
最重要的是，使用照片框架确保了 iOS 用户一致且熟悉的 UX。例如，删除的照片将在“最近删除的”照片中保留 30 天，与通过默认相册应用程序删除的行为相同。
照片框架是现代和成熟的。作为另一个例子，它负责对共享照片资源的同步共享访问。这对于保持用户相册的一致状态非常重要，因为可能会有许多应用程序同时访问它们。下面是几行代码的例子。
PHPhotoLibrary.shared().performChanges({PHAssetChangeRequest.deleteAssets(delShotsAsset)}, completionHandler: {(success, error)**in****var** msg = String()**if** success {msg = "Successfully deleted."
图像缓存
照片框架也很好地支持缓存。我错误地了解了这件事。在最初的几次尝试中，如果没有缓存，渲染速度会非常慢。无论图像是来自 web 服务器还是本地存储，渲染大量照片(每张照片的大小都有几兆字节)都是一个很大的瓶颈。
就清理照片而言，浏览图像是一个核心功能，我希望它是正确的。
在这里，懒惰装载来拯救。Photos 框架支持预取，它可以在用户滚动时预测并缓存传入的图像，并适当地使缓存失效。可以按照下面的代码片段来完成。
结果是更流畅的渲染体验。
将机器学习引入 iOS 应用
核心毫升
人工智能/人工智能技术正在迅速成为移动世界的一种规范，尤其是在 iOS 生态系统中。神经引擎(基本上是神经网络的加速硬件，像 Edge TPU)现在默认内置于最新的 iPhones 中。每个单元每秒能够执行万亿次矩阵运算，而不会损害手机的电池或计算资源。
Core ML 提供了一系列选项来将 ML 模型集成到 iOS 应用程序中，从面向消费者的“拖放”方式使用 CreateML 来训练 ML，到使用 Swift 的脚本方法(完全可定制)来训练定制的 ML 模型。
在下面的例子中，我正在制作一个模型来识别照片中的主体。基于这些信息，应用程序可以了解应该推荐保留什么。
将 ML 模型添加到 iOS 应用程序
CoreML 提供了许多现成的模型。mlmodel 格式。有用于图像识别、语音、声音和文本识别的 dnn。还有一些转换器可以将其他 DNN 模型格式(如 Tensorflow 或 tf-lite)转换成 CoreML 格式。
预先构建的模型，如 MobileNetV2、YOLO 或 SqueezeNet，针对移动推理进行了量化，并针对小型移动设备的使用进行了优化。它们可以按原样使用，也可以在分类/预测层进行微调，以用于后续的任务。
在检测照片中的主题的例子中，MobileV2 Net 可以通过几行代码来使用
**lazy** **var** classificationRequest: VNCoreMLRequest = {**do** {
**let** model = **try** VNCoreMLModel(for: MobileNet().model)
**let** request = VNCoreMLRequest(model: model, completionHandler: { [**weak** **self**] request, error **in
self**?.processClassifications(for: request, error: error)
})request.imageCropAndScaleOption = .centerCrop
**return** request
}
Xcode 提供了方便的集成工具来检查模型的层，理解它的元数据，或者探测它的预测结果来动态地检测模型。
使用 MobileNet ML 模型识别的主题示例。有些模糊的照片无法分类或接近决策边界。
设备上的个性化机器学习模型
iOS 支持设备上的在线分布式培训，这使得为的每个用户建立真正个性化的 ML 成为可能。
(为了澄清，在某种意义上，正常的 ML 模型也可以被认为是个性化的，因为它们是用长尾数据训练的，并且在推理时，它们基于个人用户输入进行预测。然而，底层模型仍然在用户之间共享。这一特性不仅如此，还使得在每个设备上定制一个模型成为可能。
考虑这样一个场景，我想要一个 ML 模型来建议(二元决策)是否保留一个图像。理想情况下，该应用通过持续使用收集用户通常保留哪些照片的反馈。它是相关反馈的一种形式。
例如，如果我是一名敏捷教练，我可能想保存更多的便利贴照片，或者，如果我是一名家长，我可能想保存更多的孩子照片。
基于我的设备上的这种特定数据(这捕获了我的偏好)，CoreML 可以通过 MLUpdate 任务更新“通用”模型。所得到的重新训练的模型可以被保存在设备上，换句话说，每个用户将拥有他们自己的个性化 ML。下面是一个代码示例:
do {
let updateTask = try MLUpdateTask(
forModelAt: url,
trainingData: trainingData,
configuration: nil,
completionHandler: completionHandler)
updateTask.resume()
} catch {
print("Couldn't create an MLUpdateTask.")
}
这篇文章没有详细讨论 CoreML 的实现，我将在另一篇文章中讨论。我希望分享更多关于不同 CoreML 模型的优缺点，Core ML 从训练、微调到推理和监控的生命周期。
高价值低挂水果特色
虽然 CoreML 是构建智能建议的一个强大选项，但有时，非 ML 替代方案也足够了。有时候，关注问题(不管是什么能解决问题)比关注解决方案更好。
就清理而言，我认为以下问题最适合应用 ML:
- 识别主题或图像类别
- 推荐最佳保留照片
- 预测某种“质量”指标
- 了解用户的偏好
另一方面，还有其他一些唾手可得的功能，这些功能易于实现，对日常用户同样有效:
- 识别重复项
- 识别照片中的人脸(最重要的质量指标之一)
使用哈希值识别重复项
这是一个 ML 解决方案听起来很诱人的例子，但是有一个更简单的算法也可以完成这项工作，而且更快，更容易实现和测试。
这个想法很简单——将图像转换成哈希——相似的图像应该产生相似的哈希数，这样就可以比较接近程度。汉明距离就是为此而存在的。一些散列算法(查看相邻像素中的差异)是合适的。
资料来源:pyimagesearch.com
使用苹果 iOS 的内置人脸检测功能识别人脸
我利用的另一个东西是视觉框架，它内置了人脸检测功能，可以异步请求。它像用于 FaceID 一样工作稳定，并且很容易解决人脸识别的问题。下面是照片中人脸识别的一些例子的截图。
人脸识别示例
事后看来，拥有有效且准确的 ML 模型是很好的，但这不是我面临的最困难的挑战，也不是最有影响力的挑战。最大的问题是如何以有用、有价值和直观的方式将这些模型集成到应用程序中。
其他技术说明
异步很重要
许多前端开发人员已经证实了处理异步事件和非阻塞 I/O 的重要性。Swift 提供了充分的支持，如 DispatchQueue /后台队列，以处理从用户交互到 ML 推理请求的事件，同时保持应用程序平稳运行。
可扩展建筑
随着时间的推移，代码库只会变得更加复杂和混乱。我发现对组织原则进行一些思考是很重要的，以确保项目可以持续迭代。
一些有用的提示包括:
- 利用扩展分解复杂的 Swift 类
- 利用 Swift 惯例和模式，如生命周期方法
- 遵循视图/控制器命名模式
最终反射
为了成功启动 iOS 开发热潮，经过思考，我发现最重要的事情是:
- 拥抱并尊重 Swift 的学习曲线——它在开始时感觉有点臃肿，但它是一种强大且得到良好支持的语言。
- 注意关键的移动开发和性能问题，包括处理异步、使用委托和生命周期方法，或者缓存等等。
- 从一开始就建立一个可扩展的代码架构。
- 使用 CoreML——在构建更复杂的 ML 模型之前，有一些轻量级的方法可以开始。
- 最后，利用 iOS 框架和 Xcode 集成工具——对 ML 开发的调试、剖析有很大的支持。
这就是我的博客。我期待着在接下来的帖子中分享更多关于 CoreML、产品和设计思维的内容，这些都是我在应用开发中的经验。
嗖嗖:从激活功能王座引导 ReLU
未修改的来源，图片免费分享。
Swish 如何在深度学习激活函数竞赛中击败 ReLU
答激活函数长期以来一直是神经网络的兴趣焦点——它们反复归纳输入，是神经网络成功的关键。长期以来，ReLU 一直被默认为深度学习社区中最好的激活函数，但现在有一个新的激活函数——Swish——来夺取这一宝座。
激活函数有着悠久的历史。首先，选择 sigmoid 函数是因为它容易求导，范围在 0 到 1 之间，并且具有平滑的概率形状。tanh 函数也被认为是 sigmoid 函数的替代函数，适合于-1 和 1 之间的范围，但是这些经典的激活函数已经被 ReLU 代替。整流线性单元(ReLU)是目前最流行的激活函数，因为当 ReLU 函数的输入为正时，梯度可以流动。它的简单性和有效性推动了 ReLU 和分支方法，如漏 ReLU 和参数化 ReLU，超越了 sigmoid 和 tanh 单元。
各种激活函数图示。来源:Swish Paper。
Prajit Ramachandran、Barret Zoph 和 Quoc V. Le 在他们的论文中提出了一个新的激活函数(底部的链接)，他们称之为 Swish。Swish 很简单——它是 sigmoid 函数的 x 倍。
论文作者的研究表明，简单地用 Swish 单元替换 ReLU 单元可以将 ImageNet 上的最佳分类精度提高 0.9%，对于 Mobile NASNet-A 和 Inception-ResNet-v2 分别提高 0.6%。
什么是 Swish 激活功能？
Swish 激活功能。上面画着德斯莫斯。
正式来说，Swish 激活功能是…
像 ReLU 一样，Swish 在下面是有界的(意味着当 x 接近负无穷大， y 接近某个常数值)，但是在上面是无界的(意味着当 x 接近正无穷大， y 接近无穷大)。然而，与 ReLU 不同，Swish 是平滑的(它没有运动或顶点的突然变化):
此外，Swish 是非单调的，这意味着在整个函数中并不总是有一个奇异且连续的正(或负)导数。(重申一下，Swish 函数在某些点上具有负导数，在其他点上具有正导数，而不是像 Softplus 或 Sigmoid 那样在所有点上都只有正导数。
Swish 函数的导数是…
Swish 的一阶和二阶导数，标绘:
来源:Swish paper
对于小于约 1.25 的输入，导数的大小小于 1。
Swish 的属性
对于激活函数来说，无界是可取的，因为它避免了在近零梯度期间的缓慢训练时间 sigmoid 或 tanh 等函数上下有界，因此网络需要仔细初始化，以保持在这些函数的限制范围内。
ReLU 函数是对 tanh 的改进，因为它是上界的——这个属性非常重要，以至于 ReLU 之后的每个成功的激活函数都是上界的。
由于强正则化，在下面有界可能是有利的-在负无穷大的极限中接近零的函数在正则化方面很好，因为大的负输入被丢弃。这在训练开始时很重要，因为大量的负面激活输入是常见的。
这些界限由 Softplus、ReLU 和 Swish 满足，但 Swish 的非单调性增加了输入的“表现力”并改善了梯度流。
输入，在通过 Swish 之前和之后。来源:Swish paper
此外，平滑度有助于优化和推广神经网络。在下面的输出景观中，显而易见的是，ReLU 的输出景观由于其不平滑的性质而显得尖锐和不和谐，而 Swish 网络景观则平滑得多。
来源:Swish paper
输出景观平滑度与误差景观直接相关。更平滑的误差空间更容易遍历和找到最小值，就像走在喜马拉雅山脉不和谐的高度范围内，而不是走在英国乡村平滑起伏的山丘上。
嗖嗖性能
Swish 论文的作者将 Swish 与以下其他激活功能进行了比较:
- 漏 ReLU，其中f(x)=x如果 x ≥ 0，以及 ax 如果 x < 0，其中 a = 0.01。当x为 0 时，这允许少量的信息流动，并且被认为是对 ReLU 的改进。
- 参数 Relu 与泄漏 ReLU 相同，但 a 是一个可学习的参数，初始化为 0.25。
- Softplus 由f(x)= log(1+exp(x))定义，是一个平滑函数，具有类似 Swish 的性质，但严格为正且单调。
- 指数线性单位(ELU)，定义为f(x)=xifx≥0 和a(exp(x)—1)ifx<0 其中 a = 1。
- 比例指数线性单位(SELU)，与 ELU 相同，但输出乘以一个值 s 。
下表显示了在 9 次实验中，Swish 比概述的基线激活功能执行得更好、相等或更差的次数。
表格数据:Swish 纸
Swish vs. ReLU
作者发现，通过用 ReLU 单元代替 Swish 单元，当层数从 42 层增加时(当优化变得更加困难时)，与 ReLU 相比有显著的改进。
来源:Swish paper
作者还发现，对于不同大小的批处理，Swish 的性能优于 ReLU。
在各种数据集上测试
作者针对以下基线激活功能测试了 Swish，结果如下:
- CIFAR-10 和 CIFAR-100 数据集——Swish 在 CIFAR-10 和 CIFAR-100 的每个型号上都始终与 ReLU 相当或超过 ReLU。
- ImageNet——Swish 比 ReLU 高出 0.6%，在 Mobile NASNet-A 上高出 0.9%，在 MobileNet 上高出 2.2%。
- WMT 2014 英语到德语— Swish 在所有四个测试数据集上都优于 ReLU。
实施
实现 Swish 非常简单——大多数深度学习库应该支持 Swish…
tn.nn.swish(x)
…或者可以表示为 x 乘以 sigmoid 函数
*x ** tf.sigmoid(x)
相信了吗？
下次你在训练深度神经网络的时候，试试 Swish 吧！
感谢阅读！如果你喜欢，也可以看看我的其他作品。
此处可找到 Swish paper。
30 多岁转行做数据科学。
不要纠结于已经有答案的问题。在开始向数据科学的职业转型之前，我希望知道以下三件事。
罗斯·芬登在 Unsplash 上的照片
你已经到了职业生涯中的一个点，继续做同样的事情是没有意义的。也许你很无聊，没有挣到你应得的那么多，或者像我一样，根本就不喜欢你的工作。在职业混乱中，你偶然发现了数据科学，并注意到转行有巨大的机会。另外，你已经在 YouTube 上找到了一些数据科学家的编码教程。
然而，尽管网上有许多专家，但他们中的一些人可能已经开始了向数据科学的职业转型。可能更少的人在 40 多岁时从一个完全不相关的领域做出这样的改变。这表明你一直在看/读的东西可能不适用于你的现实。也就是说，你应该半信半疑地看那些视频。毕竟，你不想浪费你的宝贵时间。因此，在转行从事数据科学之前，我希望处于类似职业和生活阶段的人能告诉我以下三件事:
1-选择 Python，继续前进。
如果您已经做了功课，那么您应该知道基本上有两种编程语言最适合从事数据科学:R 和 Python。虽然 R 在统计学家和研究人员中使用，并且它可以用于数据科学，但是 Python 是迄今为止你最好的选择。
对于那些很少或没有编程背景的人来说，Python 是最容易理解的编程语言。由于其简化的语法，它非常容易学习，这使得与其他编程语言(如 Java)相比，它的编码速度更快。这是一个优势，因为 Python 允许那些业余程序员阅读你的代码并与你合作。因此，Python 可以提高生产力，加速你的职业转换。
Python 允许您直接从 web 上获取数据，这对于那些想要进行数据分析并产生见解或预测某些人类行为的人来说是完美的。数据收集将是无痛的，这意味着你可以按照自己的节奏在 GitHub 上建立自己的投资组合。更重要的是，大部分使用机器学习的数据处理和围绕人工智能的研究都是用 Python 语言开发的。这是因为 Python 提供了数百个库，例如用于神经网络的 TensorFlow 和用于处理数组、矩阵和高级数学函数的 NumPy 。
不要纠结于需要学习哪种编程语言。这个决定可以为你节省宝贵的时间，尤其是如果你已经 30 多岁了。所以，选择 Python，继续前进。
2-不要沉迷于快速教程，优先考虑结构化课程。
由于数据科学是一个热门话题，许多 YouTubers 网站为初学者提供了快速替代方案:“快速轻松地学习 Python”或“10 分钟内学会熊猫”。然而，研究人员表示，学习过程相对缓慢，需要重复，并且当分布在间隔时间间隔内时最有效。因此，一个结构良好的课程对于建立一个新技能(如编程)的坚实基础至关重要。另外，不要忘记编程既需要认知能力(新语法)，也需要运动技能(打字)。这意味着初学者几乎不可能在几个小时内学会 Python，更不用说在 10 分钟内通过手机观看视频了。
解决方法是什么？看你现阶段想投入多少了。以下是三个选项:
**-无证书免费:**只需去 Coursera 搜索密歇根大学的‘面向所有人的编程(Python 入门)’。
**-一次性付款，成本低:**去 Udemy 搜索何塞·波尔蒂利亚的《从零到 Python 中的英雄的完整 Python Bootcamp》。
**-包月会员并且有点贵:**在这个类别中，你可以从三个平台中选择( DataCamp 、 Codecademy 或者 DataQuest )。所有这些平台都提供了 Python track 数据科学。
我的推荐是试试 DataQuest 。不仅仅是因为结构良好的课程，还因为一些可能会让你感到惊讶的事情，这也是我希望有人之前告诉我的第三件事，也是最后一件事。
从实践中学习，而不是从观察中学习。
看视频教程似乎是 21 世纪首选的学习方法。网上找个视频很容易；你只需要点击播放，甚至可以多任务。但是在学习数据科学和编程的时候，看视频并不是最优的学习形式。
我相信你看过一个关于如何编写函数或代码的视频。但是，你有没有一边看着它，一边试图理解代码背后的逻辑并在键盘上打字？随着 Python 和函数变得越来越复杂，从视频中学习是行不通的。结果，你将不得不经常反复观看相同的解释，这是低效和费时的。基本上，你会花很多时间暂停视频，并试图找到你想再次开始观看的精确分钟/秒。这很烦人。
也就是说，我强烈推荐 DataQuest，因为他们的讲座不是视频而是文本。你必须阅读，然后开始把你读到的东西打出来。这看起来有点老派，但是对于初学者来说效果很好，他们需要更多的时间来处理他们所学的东西。它们为您提供了在同一屏幕上测试代码的指令和脚本区域。他们的形式对于那些寻求优化学习时间的人来说简直是完美的。
DataQuest 讲座的截图。
最后但同样重要的是，DataQuest 课程是基于现实生活中的数据创建的，如 Android & iOS 应用程序、MoMa 艺术品、S&P500。这很重要，因为你将在实践中学习。他们的方法将显著提高你的学习曲线。同样，这将为你节省宝贵的时间，并让你更有动力转行，因为你看到了作为一名数据科学家工作的感觉。我将在 DataQuest 上写一篇更深入的评论，所以请关注这个空间。
结论
总之，如果你正处于向数据科学的职业转型中，可能是在 30 多岁的时候，那么你不会想在已经有明确答案的问题上浪费时间。出于这个原因，我列出了我希望有人在我开始转行之前告诉我的话:
(1) 专注于 Python。
(2) 选择一门结构良好的课程，在你向更复杂的主题(如机器学习)前进时，获得坚实的基础。
(3) 通过做真实的项目来学习，而不是看简单的视频。
希望这篇帖子对你有所帮助。如果你想试试 DataQuest，那么只需访问他们的网站，开始免费试用。作为免责声明，我没有从 DataQuest 或这篇帖子中提到的任何其他平台获得任何报酬来换取我的推荐。所以，我们开始工作吧。
想获得 Medium 文章的全部访问权限并支持我的工作？使用以下链接订阅:
[## 通过我的推荐链接加入 Medium—Renato Boemer
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
boemer.medium.com](https://boemer.medium.com/membership)
参考文献:
J. D .卡皮克和 a .鲍恩施密特。间隔提取:无论相对间隔如何，绝对间隔都能增强学习 (2011)。J. Exp 心理学。37 (5) 1250–1257.
**【2】**n . j . Cepeda，等。学习中的间隔效应。最佳保持力的时间脊线 (2008)。Sage 期刊心理科学 19(11):1095–1102
塞比尔·特里劳妮和置信区间难题
今天我将尝试一些不同的东西，我将我喜欢谈论的两个(完全不相关的)话题结合起来，希望创造一些有趣且有教育意义的东西。
…实际上，算了吧。如果你曾经读过我在 Medium 上写的任何东西，这实际上是很棒的品牌(向迈克尔·斯科特解释线性回归，有人吗？)在今天的文章中，我将解释什么是置信区间，如何计算置信区间，以及如何解释置信区间——所有这些都是通过哈利波特臭名昭著的占卜老师这个用例来实现的。
或者至少是对未来的一种统计上可能的猜测。GIF 由 gyfcat 提供
对于那些不熟悉哈利·波特和塞比尔·特里劳妮的人(我假设目前没有人在读这篇文章，因为这意味着你已经有 20 多年没有互联网了)，她是一个女巫，她可以通过 99%的有根据的猜测和 1%的真实预言“预见未来”。至少在我看来，置信区间是非常相似的:基于一小组观察对整个人口做出有根据的猜测。但是，我们的工具不是水晶球和茶叶，而是标准差和样本均值。
什么是置信区间，人们为什么使用它们？
特里劳妮教授在霍格沃茨任职期间有数千名学生，邓布利多正在审核她的工作，看看她在预测未来方面到底有多准确。然而，邓布利多是一个忙碌的家伙(试图追捕魂器和管理一所学校)，无法接触到每一个上过特里劳妮课的学生。因此，他随机选择了 300 名以前的学生作为样本，并询问他们到目前为止，她的预测实现的比例是多少。
特里劳妮预测精度的左偏分布。图片由作者提供。
邓布利多收集了回答，发现回答的分布是左偏的，这意味着学生们更有可能发现特里劳妮的预测不准确。事实上，样本平均值为 55.6%，这意味着特里劳妮的“预测”比随机猜测好不了多少。
这让邓布利多非常担心，因为他不想要一个在教授占卜课时本质上是猜测的老师。他想知道她的预测的真实平均准确性是多少，如果他联系了她教过的每一个学生，是否会低于样本平均值 55.6%。
幸运的是，邓布利多记得一个麻瓜概念叫做中心极限定理(我能说什么呢，他是一个多面的家伙)这让他有能力接近特里劳妮预测的真实平均准确度。中心极限定理假设，当你有一个数据样本，你想找到真正的人口统计(即，一个常见的例子是均值，所以我将在本文中使用它，但它也可以是其他措施)，你可以采取更小的样本组，并找到他们的均值(即，随机抽样 30 人一次，当你有 300 人的总样本和 30，000 人的总人口)。如果你有足够多的样本，并且这些样本满足一定的标准，那么样本均值将属于正态分布(不考虑数据的原始分布)，样本均值(我有时讨厌统计)的样本分布的均值将接近真实的总体均值(如果你实际上调查了总体中的所有 30，000 人，这个均值)。
中心极限定理的应用。在这幅图中，你有 4 个从总体中随机抽取的样本，它们都是非正态分布的。但是当你从每个样本(以及更多随机样本)中取平均值时，样本平均值的分布就形成了一条正态曲线。这条曲线的平均值是真实的总体平均值(如果我们对总体中的每一个人进行抽样，我们只能得到真实的总体平均值)。图片由分析公司 Vidhya 提供
基于这个概念，邓布利多知道 55.6%的平均准确率是样本均值正态分布曲线上的某处，真正的准确率在这个同分布的中间。
老实说，他们应该让我上教科书信息图。奥雷利·HMU。图片由作者提供(因为还有谁会制作这个 LOL)。
然而，他仍然不知道样本均值在分布上的确切位置，以及它与实际总体均值的接近程度(表示为 μ )。这就是置信区间的由来。
置信区间创建以样本均值为中心的标准差区间。根据间隔的大小，您可以声明该间隔将包含 x%时间的真实总体平均值。许多研究人员和公司使用 95%的置信区间(每侧距离样本均值 2 个标准差)，但根据您的使用情况，您可以提高或降低置信度(即距离均值 3 个标准差为 99.7%的置信度)。
样本均值分布的 4 种不同均值的 95%置信区间示例。浅紫色代表包含在以每个样本平均值为中心的 95%置信区间内的值。深紫色线代表理论总体平均值的 2 个标准偏差。
基于上面的例子，您可以看到落在总体均值(深紫色线内)的 2 个标准偏差内的样本均值如何将总体均值(蓝色虚线)包含在其 95%置信区间内。但是，距离总体均值超过 2 个标准差的样本均值不会将总体均值包含在其置信区间内。
由于正态分布中 95%的值位于平均值的 2 个标准偏差内，我们可以确信 95%的样本平均值将位于总体平均值的 2 个标准偏差内。据此，我们也可以说从该人群中抽取的所有随机样本的 95%将包括其 95%置信区间中的真实总体均值。
如何计算置信区间
现在我们对置信区间的用途和作用有了一个大致的了解，我们可以回到霍格沃茨，帮助邓布利多计算特里劳妮教授预测准确度的置信区间。
置信区间计算公式。图片由统计如何提供
以上是计算置信区间的通用公式，其中 x̅ 是样本均值，t11】zt13】是我们希望区间跨越的均值的标准差个数，t15【s】t16是样本的标准差，t19】nt21】是组中样本的个数。
公式的后半部分(z * s / √n)计算出 z 标准差是什么的实际值( z = 2 为 95%置信区间)，你将这个值从**【x̅】**中加减，就可以求出你的置信区间的上下界。
如果邓布利多把评估值代入这个公式，他会得到:
上限
= 55.6 + (2 x (12.9/√300)
= 57.08%
下界
= 55.6 - (2 x (12.9/√300)
= 54.12%
这意味着特里劳妮教授预测的真实准确性很有可能在 54.12% — 57.08% 之间。然而，由于邓布利多只评估了一个样本，我们不能说这个样本平均值(55.6%)是否在总体平均值的 2 个标准差之内，以及它的置信区间是否成功地捕捉了真实的总体平均值。样本平均值有可能恰好在与平均值相差> 2 个标准差的 5%的数据中(也就是下面红色的坏 BOIS 之一)，因此完全错过了总体平均值。
图片由麻省理工提供，由您真实标注。
特里劳妮教授的命运(又名邓布利多的下一步)
邓布利多对下一步有几个选择:
- 他可以将调查问卷发送给另外几组，每组 300 名学生，然后开始绘制各组学生的平均值分布图。这将使他更好地了解 55.6%落在哪里(即，接近其他值，可能在总体平均值的 2 个标准偏差内，或明显远离其他值，可能大于 2 个标准偏差)。
- 他可以重新进行同样的分析，这次从他的 300 个回答中取出更小的组，并将它们的平均值绘制成分布图(即 100 个随机组，每个组 30 名学生，替换)。这种分布的平均值将使他很好地了解实际人口的平均值，而不需要使用置信区间。样本量为 30 (n=30)是中心倾向定理的“经验法则”,所以邓布利多实际上超过了他最初的样本量 300。
邓布利多考虑了他的选择，决定暂时接受 54.12% — 57.08% 预测准确率的置信区间。他对结果并不十分激动，但看到区间的下限仍然大于 50%，他松了一口气，这意味着——至少——特里劳妮教授的预测比随机猜测要好！
他总结了自己发现，并将在特里劳妮教授下一次绩效评估中向她展示。也许他会建议她在未来几年的🧙教学大纲中增加置信区间🏼♀️🔮
GIF 由 Giphy 提供。
扫一扫
724
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
