第二章 处理线性模型

本章包括以下主题：

1. [线性回归模型]
   
2. [评估线性回归模型]
   
3. [用岭回归弥补线性回归的不足]
   
4. [优化岭回归参数]
   
5. [LASSO正则化]
   
6. [LARS正则化]
   
7. [用线性方法处理分类问题——逻辑回归]
   
8. [贝叶斯岭回归]
   
9. [用梯度提升回归从误差中学习]
   

线性模型是统计学和机器学习的基础。很多方法都利用变量的线性组合描述数据之间的关系。

2.1 线性回归模型

我们从最简单的线性回归（Linear regression）开始。线性回归是最早的也是最基本的模型——把数据拟合成一条直线。boston数据集很适合用来演示线性回归。

from sklearn import datasets
boston = datasets.load_boston()

from sklearn.linear_model import LinearRegression
lr = LinearRegression()

lr.fit(boston.data, boston.target)

2.2 评估线性回归模型

在这个主题中，我们将介绍回归模型拟合数据的效果。上一个主题我们拟合了数据，但是并没太关注拟合的效果。每当拟合工作做完之后，我们应该问的第一个问题就是“拟合的效果如何?"

from sklearn import datasets
boston = datasets.load_boston()

from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(boston.data, boston.target)

predictions = lr.predict(boston.data)

%matplotlib inline
from matplotlib import pyplot as plt
f, ax = plt.subplots(figsize=(7, 5))
f.tight_layout()
ax.hist(boston.target - predictions,bins=40, label='Residuals Linear', 
color='b', alpha=.5);
ax.set_title("Histogram of Residuals")
ax.legend(loc='best');

误差项服从均值为0的正态分布。残差就是误差，所以这个图也应该近似正态分布。看起来拟合挺好的，只是有点偏。我们计算一下残差的均值，应该很接近0：

import numpy as np
np.mean(boston.target - predictions)
# 4.296958046296258e-15

另一个图是分位数概率分布，我们用Scipy来实现图形，因为它内置这个概率分布图的方法：

from scipy.stats import probplot
f = plt.figure(figsize=(7, 5))
ax = f.add_subplot(111)
probplot(boston.target - predictions, plot=ax);

我们还可以观察拟合其他量度，最常用的还有均方误差（mean squared error，MSE），平均绝对误差（mean absolute deviation，MAD）。让我们用Python实现这两个量度。后面我们用scikit-learn内置的量度来评估回归模型的效果：

def MSE(target, predictions):
    squared_deviation = np.power(target - predictions, 2)
    return np.mean(squared_deviation)
MSE(boston.target, predictions)
# 21.894831181729206

def MAD(target, predictions):
    absolute_deviation = np.abs(target - predictions)
    return np.mean(absolute_deviation)
MAD(boston.target, predictions)
# 3.270862810900317

相关系数是随机变量，因此它们是有分布的。让我们用bootstrapping（重复试验）来看看犯罪率的相关系数的分布情况。bootstrapping是一种学习参数估计不确定性的常用手段：

n_bootstraps = 1000
len_boston = len(boston.target)
subsample_size = np.int(0.5*len_boston)
subsample = lambda: np.random.choice(np.arange(0, len_boston),size=subsample_size)
coefs = np.ones(n_bootstraps) #相关系数初始值设为1
for i in range(n_bootstraps):
    subsample_idx = subsample()
    subsample_X = boston.data[subsample_idx]
    subsample_y = boston.target[subsample_idx]
    lr.fit(subsample_X, subsample_y)
    coefs[i] = lr.coef_[0]
    
f = plt.figure(figsize=(7, 5))
ax = f.add_subplot(111)
ax.hist(coefs, bins=50, color='b', alpha=.5)
ax.set_title("Histogram of the lr.coef_[0].")

# 我们还想看看重复试验后的置信区间：
np.percentile(coefs, [2.5, 97.5])
# array([-0.18831405,  0.05032466])

置信区间的范围表面犯罪率其实不影响房价，因为0在置信区间里面，表面犯罪率可能与房价无关。值得一提的是，bootstrapping可以获得更好的相关系数估计值，因为使用bootstrapping方法的均值，会比普通估计方法更快地收敛（converge）到真实均值。

2.3 用岭回归弥补线性回归的不足

岭回归和线性回归不同，它引入了正则化参数来“缩减”相关系数。当数据集中存在共线因素时，岭回归会很有用。

# 首先我们用make_regression建一个有3个自变量的数据集，但是其秩为2，
# 因此3个自变量中有两个自变量存在相关性。

from sklearn.datasets import make_regression
reg_data, reg_target = make_regression(n_samples=2000, n_features=3, 
effective_rank=2, noise=10)

# 首先，我们用普通的线性回归拟合：
import numpy as np
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
def fit_2_regression(lr):

    n_bootstraps = 1000
    coefs = np.ones((n_bootstraps, 3))
    len_data = len(reg_data)
    subsample_size = np.int(0.75*len_data)
    subsample = lambda: np.random.choice(np.arange(0, len_data),
     size=subsample_size)
    for i in range(n_bootstraps):
        subsample_idx = subsample()
        subsample_X = reg_data[subsample_idx]
        subsample_y = reg_target[subsample_idx]
        lr.fit(subsample_X, subsample_y)
        coefs[i][0] = lr.coef_[0]
        coefs[i][1] = lr.coef_[1]
        coefs[i][2] = lr.coef_[2]
    %matplotlib inline
    import matplotlib.pyplot as plt
    f, axes = plt.subplots(nrows=3, sharey=True, sharex=True, figsize=(7, 5))
    f.tight_layout()
    for i, ax in enumerate(axes):
        ax.hist(coefs[:, i], color='b', alpha=.5)
        ax.set_title("Coef {}".format(i))
    return coefs

coefs = fit_2_regression(lr)

# 我们再用Ridge来拟合数据，对比结果：
from sklearn.linear_model import Ridge
coefs_r = fit_2_regression(Ridge())

两个回归算法的结果看着好像差不多，其实不然。岭回归的相关系数更接近0。让我们看看两者相关系数的差异：

np.mean(coefs - coefs_r, axis=0)
# array([ 65.29814078,  59.2729781 , -19.31712032])

np.var(coefs, axis=0)
# array([233.05179112, 204.6986085 , 228.77835216])

np.var(coefs_r, axis=0)
# array([24.0402546 , 26.0985284 , 19.94299558])

从均值上看，线性回归比岭回归的相关系数要更很多。均值显示的差异其实是线性回归的相关系数隐含的偏差。

岭回归的相关系数方差也会小很多。这就是机器学习里著名的偏差-方差均衡(Bias-Variance Trade-off)。下一个主题我们将介绍如何调整岭回归的参数正则化，那是偏差-方差均衡的核心内容。

2.4 优化岭回归参数

当你使用岭回归模型进行建模时，需要考虑Ridge的alpha参数。

这是我们第一个进行模型参数优化的主题，通常用交叉检验（cross validation）完成。在后面的主题中，还会有更简便的方式实现这些，但是这里我们一步一步来实现岭回归的优化。

在scikit-learn里面，岭回归的参数就是RidgeRegression的alpha参数；因此，问题就是最优的alpha参数是什么。

from sklearn.datasets import make_regression
reg_data, reg_target = make_regression(n_samples=100, 
n_features=2, effective_rank=1, noise=10)

在linear_models模块中，有一个对象叫RidgeCV，表示岭回归交叉检验（ridge cross-validation）。这个交叉检验类似于留一交叉验证法（leave-one-out cross-validation，LOOCV）。这种方法是指训练数据时留一个样本，测试的时候用这个未被训练过的样本.

import numpy as np
from sklearn.linear_model import RidgeCV
rcv = RidgeCV(alphas=np.array([.1, .2, .3, .4]))
rcv.fit(reg_data, reg_target)
rcv.alpha_
# 0.1

# 这里，0.1是最优参数，我们还想看到0.1附近更精确的值：

rcv = RidgeCV(alphas=np.array([.08, .09, .1, .11, .12]))
rcv.fit(reg_data, reg_target)
rcv.alpha_
# 0.08

在交叉检验的每一步里，模型的拟合效果都是用测试样本的误差表示。默认情况使用平方误差。我们可以让RidgeCV储存交叉检验的数据，这样就可以可视化整个过程：

alphas_to_test = np.linspace(0.0001, 0.05)
rcv3 = RidgeCV(alphas=alphas_to_test, store_cv_values=True)
rcv3.fit(reg_data, reg_target)

你会看到，我们测试了0.0001到0.05区间中的50个点。由于我们把store_cv_values设置成true，我们可以看到每一个值对应的拟合效果：

rcv3.cv_values_.shape
# (100, 50)

通过100个样本的回归数据集，我们获得了50个不同的alpha值。我们可以看到50个误差值，最小的均值误差对应最优的alpha值：

smallest_idx = rcv3.cv_values_.mean(axis=0).argmin()
alphas_to_test[smallest_idx]
# 0.027595918367346938

rcv3.alpha_
0.027595918367346938

通过可视化图形可以更直观的显示出来。我们画出50个测试alpha值的图：

%matplotlib inline
import matplotlib.pyplot as plt
f, ax = plt.subplots(figsize=(7, 5))
ax.set_title(r"Various values of $\alpha$")
xy = (alphas_to_test[smallest_idx], 
rcv3.cv_values_.mean(axis=0)[smallest_idx])
xytext = (xy[0] + .01, xy[1] + .1)
ax.annotate(r'Chosen $\alpha$', xy=xy, xytext=xytext,
            arrowprops=dict(facecolor='black', shrink=0, width=0)
            )
ax.plot(alphas_to_test, rcv3.cv_values_.mean(axis=0));

如果我们想用其他误差自定义评分函数，也是可以实现的。前面我们介绍过MAD误差，我们可以用它来评分。首先我们需要定义损失函数：

def MAD(target, prediction):
    absolute_deviation = np.abs(target - prediction)
    return absolute_deviation.mean()

定义损失函数之后，我们用sklearn量度中的make_scorer函数来处理。这样做可以标准化自定义的函数，让scikit-learn对象可以使用它。另外，由于这是一个损失函数不是一个评分函数，是越低越好，所以要用sklearn来把最小化问题转化成最大化问题：

import sklearn
MAD = sklearn.metrics.make_scorer(MAD, greater_is_better=False)
rcv4 = RidgeCV(alphas=alphas_to_test, store_cv_values=True, scoring=MAD)
rcv4.fit(reg_data, reg_target)
smallest_idx = rcv4.cv_values_.mean(axis=0).argmin()
alphas_to_test[smallest_idx]
# 0.05

2.5 LASSO正则化

LASSO（ least absolute shrinkage and selection operator，最小绝对值收缩和选择算子）方法与岭回归和LARS（least angle regression，最小角回归）很类似。与岭回归类似，它也是通过增加惩罚函数来判断、消除特征间的共线性。与LARS相似的是它也可以用作参数选择，通常得出一个相关系数的稀疏向量。

# 首先，我们还是用make_regression函数来建立数据集：
from sklearn.datasets import make_regression
reg_data, reg_target = make_regression(n_samples=200, 
n_features=500, n_informative=5, noise=5)

# 之后，我们导入`lasso`对象：
from sklearn.linear_model import Lasso
lasso = Lasso()

lasso.fit(reg_data, reg_target)

# 再让我们看看还有多少相关系数非零：
import numpy as np
np.sum(lasso.coef_ != 0)
# 8

lasso_0 = Lasso(0)
lasso_0.fit(reg_data, reg_target)
np.sum(lasso_0.coef_ != 0)
# 500

# LASSO交叉检验
from sklearn.linear_model import LassoCV
lassocv = LassoCV()
lassocv.fit(reg_data, reg_target)

lassocv.alpha_
# 0.8357255768559891

# 计算的相关系数也可以看到：
lassocv.coef_[:5]

np.sum(lassocv.coef_ != 0)
# 12

LASSO特征选择

LASSO通常用来为其他方法做特征选择。例如，你可能会用LASSO回归获取适当的特征变量，然后在其他算法中使用。要获取想要的特征，需要创建一个非零相关系数的列向量，然后再其他算法拟合：

mask = lassocv.coef_ != 0
new_reg_data = reg_data[:, mask]
new_reg_data.shape
# (200, 12)

2.6 LARS正则化

LARS是一种回归手段，适用于解决高维问题，也就是p>>n的情况，其中p表示列或者特征变量，n表示样本数量。

# 首先让我们导入必要的对象。这里我们用的数据集是200个数据，500个特征。
# 我们还设置了一个低噪声，和少量提供信息的（informative）特征：
import numpy as np
from sklearn.datasets import make_regression
reg_data, reg_target = make_regression(n_samples=200,n_features=500, 
n_informative=10, noise=2)

reg_data.shape, reg_target.shape
# ((200, 500), (200,))​

由于我们用了10个信息特征，因此我们还要为LARS设置10个非0的相关系数。我们事先可能不知道信息特征的准确数量，但是出于试验的目的是可行的。

from sklearn.linear_model import Lars
lars = Lars(n_nonzero_coefs=10)
lars.fit(reg_data, reg_target)
# 我们可以检验一下看看LARS的非0相关系数的和：
np.sum(lars.coef_ != 0)
# 10

问题在于为什么少量的特征反而变得更加有效。要证明这一点，让我们用一半数量来训练两个LARS模型，一个用12个非零相关系数，另一个非零相关系数用默认值。这里用12个是因为我们对重要特征的数量有个估计，但是可能无法确定准确的数量：

train_n = 100
lars_12 = Lars(n_nonzero_coefs=12)
lars_12.fit(reg_data[:train_n], reg_target[:train_n])

lars_500 = Lars() #默认就是500
lars_500.fit(reg_data[:train_n], reg_target[:train_n])

np.mean(np.power(reg_target[train_n:] - lars.predict(reg_data[train_n:]), 2))
# 5.98715309047699
np.mean(np.power(reg_target[train_n:] - lars_12.predict(reg_data[train_n:]), 2))
# 53.48472292916442
np.mean(np.power(reg_target[train_n:] - lars_500.predict(reg_data[train_n:]), 2))
# 5.124946479008267e+32

测试集的误差明显高很多。高维数据集问题就在于此；通常面对大量的特征时，想找出一个对训练集拟合很好的模型并不难，但是拟合过度却是更大的问题。

LARS通过重复选择与残存变化相关的特征。从图上看，相关性实际上就是特征与残差之间的最小角度；这就是LARS名称的由来。选择第一个特征之后，LARS会继续沿着最小角的方向移动，直到另一个特征与残差有同样数量的相关性。然后，LARS会沿着两个特征组合的角度移动。如下图所示：

%matplotlib inline
import matplotlib.pyplot as plt
def unit(*args):
    squared = map(lambda x: x**2, args)
    distance = sum(squared) ** (.5)
    return map(lambda x: x / distance, args)
 
f, ax = plt.subplots(nrows=3, figsize=(5, 10))
plt.tight_layout()
ax[0].set_ylim(0, 1.1)
ax[0].set_xlim(0, 1.1)

x, y = unit(1, 0.02)
ax[0].arrow(0, 0, x, y, edgecolor='black', facecolor='black')
ax[0].text(x + .05, y + .05, r"$x_1$")

x, y = unit(.5, 1)
ax[0].arrow(0, 0, x, y, edgecolor='black', facecolor='black')
ax[0].text(x + .05, y + .05, r"$x_2$")

x, y = unit(1, .45)
ax[0].arrow(0, 0, x, y, edgecolor='black', facecolor='black')
ax[0].text(x + .05, y + .05, r"$y$")

ax[0].set_title("No steps")

# step 1
ax[1].set_title("Step 1")
ax[1].set_ylim(0, 1.1)
ax[1].set_xlim(0, 1.1)

x, y = unit(1, 0.02)
ax[1].arrow(0, 0, x, y, edgecolor='black', facecolor='black')
ax[1].text(x + .05, y + .05, r"$x_1$")

x, y = unit(.5, 1)
ax[1].arrow(0, 0, x, y, edgecolor='black', facecolor='black')
ax[1].text(x + .05, y + .05, r"$x_2$")

x, y = unit(.5, 1)
ax[1].arrow(.5, 0.01, x, y, ls='dashed', edgecolor='black', facecolor='black')
ax[1].text(x + .5 + .05, y + .01 + .05, r"$x_2$")

ax[1].arrow(0, 0, .47, .01, width=.0015, edgecolor='black', facecolor='black')
ax[1].text(.47-.15, .01 + .03, "Step 1")

x, y = unit(1, .45)
ax[1].arrow(0, 0, x, y, edgecolor='black', facecolor='black')
ax[1].text(x + .05, y + .05, r"$y$")

# step 2
ax[2].set_title("Step 2")
ax[2].set_ylim(0, 1.1)
ax[2].set_xlim(0, 1.1)

x, y = unit(1, 0.02)
ax[2].arrow(0, 0, x, y, edgecolor='black', facecolor='black')
ax[2].text(x + .05, y + .05, r"$x_1$")

x, y = unit(.5, 1)
ax[2].arrow(0, 0, x, y, edgecolor='black', facecolor='black')
ax[2].text(x + .05, y + .05, r"$x_2$")

x, y = unit(.5, 1)
ax[2].arrow(.5, 0.01, x, y, ls='dashed', edgecolor='black', facecolor='black')
ax[2].text(x + .5 + .05, y + .01 + .05, r"$x_2$")

ax[2].arrow(0, 0, .47, .01, width=.0015, edgecolor='black', facecolor='black')
ax[2].text(.47-.15, .01 + .03, "Step 1")

##  step 2
x, y = unit(1, .45)
ax[2].arrow(.5, .02, .4, .35, width=.0015, edgecolor='black', facecolor='black')
ax[2].text(x, y - .1, "Step 2")

x, y = unit(1, .45)
ax[2].arrow(0, 0, x, y, edgecolor='black', facecolor='black')
ax[2].text(x + .05, y + .05, r"$y$");

具体过程是，我们把$x2$x2沿着$x1$x1方向移动到一个位置：$x1$x1与$y$y的点积与$x1$x1与$y$y的点积相同。到了这个位置之后，我们再沿着$x1$x1和$x2$x2夹角的一半的方向移动。

用交叉检验来优化领回归模型一样，我们可以对LARS做交叉检验：

from sklearn.linear_model import LarsCV
lcv = LarsCV()
lcv.fit(reg_data, reg_target)

# 用交叉检验可以帮助我们确定需要使用的非零相关系数的最佳数量。
np.sum(lcv.coef_ != 0)
# 10

2.7 用线性方法处理分类问题——逻辑回归

实际上线性模型也可以用于分类任务。方法是把一个线性模型拟合成某个类型的概率分布，然后用一个函数建立阈值来确定结果属于哪一类。

这里用的函数是经典的逻辑函数。一个非常简单的函数：
$f(x)= \frac 1 {1+e^{-t}}$f(x)=1+e−t1​

它的图形如下图所示：

import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
f, ax = plt.subplots(figsize=(10, 5))
rng = np.linspace(-5, 5)
log_f = np.apply_along_axis(lambda x:1 / (1 + np.exp(-x)), 0, rng)
ax.set_title("Logistic Function between [-5, 5]")
ax.plot(rng, log_f);

# 让我们用make_classification方法创建一个数据集来进行分类：
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=1000, n_features=4)

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()

X_train = X[:-200]
X_test = X[-200:]
y_train = y[:-200]
y_test = y[-200:]

lr.fit(X_train, y_train)
y_train_predictions = lr.predict(X_train)
y_test_predictions = lr.predict(X_test)

(y_train_predictions == y_train).sum().astype(float) / y_train.shape[0]
# 0.89
(y_test_predictions == y_test).sum().astype(float) / y_test.shape[0]
# 0.835

下面的内容你以后肯定会遇到。一种情况是一个类型与其他类型的权重不同(也就是正负样本的比例)；例如，一个能可能权重很大，99%。这种情况在分类工作中经常遇到。经典案例就是信用卡虚假交易检测，大多数交易都不是虚假交易，但是不同类型误判的成本相差很大。

让我们建立一个分类问题，类型yy的不平衡权重95%，我们看看基本的逻辑回归模型如何处理这类问题：

X, y = make_classification(n_samples=5000, n_features=4, weights=[.95])
sum(y) / (len(y)*1.) #检查不平衡的类型
# 0.0536

X_train = X[:-500]
X_test = X[-500:]
y_train = y[:-500]
y_test = y[-500:]

lr.fit(X_train, y_train)
y_train_predictions = lr.predict(X_train)
y_test_predictions = lr.predict(X_test)

(y_train_predictions == y_train).sum().astype(float) / y_train.shape[0]
# 0.9817777777777777
(y_test_predictions == y_test).sum().astype(float) / y_test.shape[0]
# 0.976

结果看着还不错，但这是说如果我们把一个交易预测成正常交易（或者称为类型0），那么我们有95%左右的可能猜对。如果我们想看看模型对类型1的预测情况，可能就不是那么好了：

(y_test[y_test==1] == y_test_predictions[y_test==1]).sum().
astype(float) / y_test[y_test==1].shape[0]
# 0.7142857142857143

如果相比正常交易，我们更关心虚假交易；那么这是由商业规则决定的，我们可能会改变预测正确和预测错误的权重。

通常情况下，虚假交易与正常交易的权重与训练集的类型权重的倒数一致。但是，因为我们更关心虚假交易，所有让我们用多重采样（oversample）方法来表示虚假交易与正常交易的权重。

lr = LogisticRegression(class_weight={0: .15, 1: .85})
lr.fit(X_train, y_train)
y_train_predictions = lr.predict(X_train)
y_test_predictions = lr.predict(X_test)
(y_test[y_test==1] == y_test_predictions[y_test==1]).
sum().astype(float) / y_test[y_test==1].shape[0]
# 0.7857142857142857
(y_test_predictions == y_test).sum().astype(float) / y_test.shape[0]
# 0.968 准确率降低了

2.8 贝叶斯岭回归

岭回归和套索回归（lasso regression）用贝叶斯观点来解释，与频率优化观点解释相反。scikit-learn只实现了贝叶斯岭回归。

from sklearn.datasets import make_regression
X, y = make_regression(1000, 10, n_informative=2, noise=20)

from sklearn.linear_model import BayesianRidge
br = BayesianRidge()

有两组相关系数，分别是alpha_1 / alpha_2和lambda_1 / lambda_2。其中，alpha_*是先验概率分布的$\alpha$α超参数，lambda_*是先验概率分布的$\lambda$λ超参数。

# 首先，让我们不调整参数直接拟合模型
br.fit(X, y)
br.coef_

br_alphas = BayesianRidge(alpha_1=10, lambda_1=10)
br_alphas.fit(X, y)
br_alphas.coef_

因为是贝叶斯岭回归，我们假设先验概率分布带有误差和$\alpha$α参数，先验概率分布都服从$\Gamma$Γ分布。

$\Gamma$Γ分布是一种极具灵活性的分布。不同的形状参数和尺度参数的$\Gamma$Γ分布形状有差异。1e-06是 scikit-learn里面BayesianRidge形状参数的默认参数值。

import matplotlib.pyplot as plt
%matplotlib inline
from scipy.stats import gamma
import numpy as np
form = lambda x, y: "loc={}, scale={}".format(x, y)
g = lambda x, y=1e-06, z=1e-06: gamma.pdf(x, y, z)
g2 = lambda x, y=1e-06, z=1: gamma.pdf(x, y, z)
g3 = lambda x, y=1e-06, z=2: gamma.pdf(x, y, z)
rng = np.linspace(0, 5)
f, ax = plt.subplots(figsize=(8, 5))
ax.plot(rng, list(map(g, rng)), label=form(1e-06, 1e-06), color='r')
ax.plot(rng, list(map(g2, rng)), label=form(1e-06, 1), color='g')
ax.plot(rng, list(map(g3, rng)), label=form(1e-06, 2), color='b')
ax.set_title("Different Shapes of the Gamma Distribution")
ax.legend();

你会看到，相关系数最终都会收缩到0，尤其当形状参数特别小的时候。

还有一种套索回归的贝叶斯解释。我们把先验概率分布看出是相关系数的函数；它们本身都是随机数。对于套索回归，我们选择一个可以产生0的分布，比如双指数分布（Double Exponential Distribution，也叫Laplace distribution）。

from scipy.stats import laplace
form = lambda x, y: "loc={}, scale={}".format(x, y)
g = lambda x: laplace.pdf(x)
rng = np.linspace(-5, 5)
f, ax = plt.subplots(figsize=(8, 5))
ax.plot(rng, list(map(g, rng)), color='r')
ax.set_title("Example of Double Exponential Distribution");

2.9 用梯度提升回归从误差中学习

梯度提升回归（Gradient boosting regression，GBR）是一种从它的错误中进行学习的技术。它本质上就是集思广益，集成一堆较差的学习算法进行学习。有两点需要注意：

• 每个学习算法准备率都不高，但是它们集成起来可以获得很好的准确率。
• 这些学习算法依次应用，也就是说每个学习算法都是在前一个学习算法的错误中学习

import numpy as np
from sklearn.datasets import make_regression
X, y = make_regression(1000, 2, noise=10)

from sklearn.ensemble import GradientBoostingRegressor as GBR
gbr = GBR()
gbr.fit(X, y)
gbr_preds = gbr.predict(X)

# 对比模型
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(X, y)
lr_preds = lr.predict(X)

gbr_residuals = y - gbr_preds
lr_residuals = y - lr_preds

%matplotlib inline
from matplotlib import pyplot as plt
f, ax = plt.subplots(figsize=(7, 5))
f.tight_layout()
ax.hist(gbr_residuals,bins=20,label='GBR Residuals', color='b', alpha=.5);
ax.hist(lr_residuals,bins=20,label='LR Residuals', color='r', alpha=.5);
ax.set_title("GBR Residuals vs LR Residuals")
ax.legend(loc='best');

看起来好像GBR拟合的更好，但是并不明显。让我们用95%置信区间（Confidence interval,CI）对比一下：

np.percentile(gbr_residuals, [2.5, 97.5])
# array([-16.83708393,  16.22875202])
np.percentile(lr_residuals, [2.5, 97.5])
# array([-20.33516214,  19.84516844])

GBR的置信区间更小，数据更集中，因此其拟合效果更好；我们还可以对GBR算法进行一些调整来改善效果。我用下面的例子演示一下，然后在下一节介绍优化方法：

n_estimators = np.arange(100, 1100, 350)
gbrs = [GBR(n_estimators=n_estimator) for n_estimator in n_estimators]
residuals = {}
for i, gbr in enumerate(gbrs):
    gbr.fit(X, y)
    residuals[gbr.n_estimators] = y - gbr.predict(X)

f, ax = plt.subplots(figsize=(7, 5))
f.tight_layout()
colors = {800:'r', 450:'g', 100:'b'}
for k, v in residuals.items():
    ax.hist(v,bins=20,label='n_estimators: %d' % k, color=colors[k], alpha=.5);
ax.set_title("Residuals at Various Numbers of Estimators")
ax.legend(loc='best');

上面例子中GBR的第一个参数是n_estimators，指GBR使用的学习算法的数量。通常，如果你的设备性能更好，可以把n_estimators设置的更大，效果也会更好。还有另外几个参数要说明一下。

你应该在优化其他参数之前先调整max_depth参数。因为每个学习算法都是一颗决策树，max_depth决定了树生成的节点数。选择合适的节点数量可以更好的拟合数据，而更多的节点数可能造成拟合过度。

loss参数决定损失函数，也直接影响误差。ls是默认值，表示最小二乘法（least squares）。还有最小绝对值差值，Huber损失和分位数损失（quantiles）等等。

第三章 使用距离向量构建模型

本章包括以下主题：

1. [使用 KMeans 对数据聚类]
   
2. [优化形心数量]
   
3. [评估聚类的正确性]
   
4. [使用 MiniBatch KMeans 处理更多数据]
   
5. [使用 KMeans 聚类来量化图像]
   
6. [寻找特征空间中的最接近对象]
   
7. [使用高斯混合模型的概率聚类]
   
8. [将 KMeans 用于离群点检测]
   
9. [将 KNN 用于回归]
   

3.1 使用 KMeans 对数据聚类

from sklearn.datasets import make_blobs 
blobs, classes = make_blobs(500, centers=3)

import matplotlib.pyplot as plt
import numpy as np

f, ax = plt.subplots(figsize=(7.5, 7.5)) 
rgb = np.array(['r', 'g', 'b']) 
ax.scatter(blobs[:, 0], blobs[:, 1], color=rgb[classes]) 
ax.set_title("Blobs")
plt.show()

现在我们可以使用 KMeans 来寻找这些簇的形心。第一个例子中，我们假装知道有三个形心。

from sklearn.cluster import KMeans 
kmean = KMeans(n_clusters=3) 
kmean.fit(blobs) 

kmean.cluster_centers_

f, ax = plt.subplots(figsize=(7.5, 7.5)) 
ax.scatter(blobs[:, 0], blobs[:, 1], color=rgb[classes]) 
ax.scatter(kmean.cluster_centers_[:, 0],
               kmean.cluster_centers_[:, 1], marker='*', s=250,
               color='black', label='Centers')
ax.set_title("Blobs") 
ax.legend(loc='best')
plt.show()

其它属性也很实用。例如，labels_属性会产生每个点的预期标签。

kmean.labels_[:5] 

classes[:5] 

# rtansform函数十分有用，它会输出每个点到形心的距离。
kmean.transform(blobs)[:5]

3.2 优化形心数量

形心难以解释，并且也难以判断是否数量正确。理解你的数据是否是未分类的十分重要，因为这会直接影响我们可用的评估手段。

from sklearn.datasets import make_blobs 
import numpy as np 
blobs, classes = make_blobs(500, centers=3)
from sklearn.cluster import KMeans 
kmean = KMeans(n_clusters=3) 
kmean.fit(blobs) 

首先，我们查看轮廓（Silhouette）距离。轮廓距离是簇内不相似性、最近的簇间不相似性、以及这两个值最大值的比值。它可以看做簇间分离程度的度量。让我们看一看数据点到形心的距离分布，理解轮廓距离非常有用。

from sklearn import metrics 
silhouette_samples = metrics.silhouette_samples(blobs,
                         kmean.labels_) 
np.column_stack((classes[:5], silhouette_samples[:5]))

f, ax = plt.subplots(figsize=(10, 5))
ax.set_title("Hist of Silhouette Samples") 
ax.hist(silhouette_samples)
plt.show()

要注意，通常接近 1 的系数越高，分数就越高。

轮廓系数的均值通常用于描述整个模型的拟合度。

silhouette_samples.mean() 
# 0.6812179506374529

这十分普遍，事实上，metrics模块提供了一个函数来获得刚才的值。现在，让我们训练多个簇的模型，并看看平均得分是什么样：

# first new ground truth 
blobs, classes = make_blobs(500, centers=10) 
sillhouette_avgs = []
# this could take a while 
for k in range(2, 60):
    kmean = KMeans(n_clusters=k).fit(blobs)
    sillhouette_avgs.append(metrics.silhouette_score(blobs,kmean.labels_))
f, ax = plt.subplots(figsize=(7, 5)) 
ax.plot(sillhouette_avgs) 
plt.show()

这个绘图表明，轮廓均值随着形心数量的变化情况。我们可以看到最优的数量是 3，根据所生成的数据。但是最优的数量看起来是 6 或者 7。这就是聚类的实际情况，十分普遍，我们不能获得正确的簇数量，我们只能估计簇数量的近似值。

3.3 评估聚类的正确性

我们之前讨论了不知道真实情况的条件下的聚类评估。但是，我们还没有讨论簇已知条件下的 KMeans 评估。在许多情况下，这都是不可知的，但是如果存在外部的标注，我们就会知道真实情况，或者至少是代理。

from sklearn.cluster import KMeans 
kmean = KMeans(n_clusters=3) 
kmean.fit(blobs) 

f, ax = plt.subplots(figsize=(7, 5))
colors = ['r', 'g', 'b']
ground_truth=kmean.labels_
for i in range(3):
    p = blobs[ground_truth == i]
    ax.scatter(p[:,0], p[:,1], c=colors[i],
    label="Cluster {}".format(i))
ax.set_title("Cluster With Ground Truth") 
ax.legend()
f.savefig("9485OS_03-16")
plt.show()

既然我们已经训练了模型，让我们看看簇的形心：

f, ax = plt.subplots(figsize=(7, 5))
colors = ['r', 'g', 'b']
for i in range(3):
       p = blobs[ground_truth == i]
       ax.scatter(p[:,0], p[:,1], c=colors[i],label="Cluster {}".format(i))
ax.scatter(kmean.cluster_centers_[:, 0],
               kmean.cluster_centers_[:, 1], s=100,
               color='black',
               label='Centers') 
ax.set_title("Cluster With Ground Truth") 
ax.legend()
f.savefig("9485OS_03-17") 
plt.show()

既然我们能够将聚类表现看做分类练习，在其语境中有用的方法在这里也有用：

for i in range(3):
    print((kmean.labels_ == classes)[classes == i].astype(int).mean())

很显然我们有一些错乱的簇。所以让我们将其捋直，之后我们查看准确度。

new_ground_truth = classes.copy()
new_ground_truth[classes == 0] = 2 
new_ground_truth[classes == 2] = 0
for i in range(3):
       print((kmean.labels_ == new_ground_truth)[classes == i].astype(int).mean())

第二个相似性度量是互信息（ mutual information score）得分。

from sklearn import metrics
metrics.normalized_mutual_info_score(classes, kmean.labels_)
# 0.6177336423149696

分数靠近 0，就说明标签的分配可能不是按照相似过程生成的。但是分数靠近 1，就说明两个标签有很强的一致性。

metrics.normalized_mutual_info_score(classes, classes)
# 1.0

metrics.mutual_info_score(classes, kmean.labels_)
# 0.9191046569854725

# 每个数据点和它所分配的簇的平方差之和
kmean.inertia_ 
# 7728.505035843488

3.4 使用 MiniBatch KMeans 处理更多数据

from sklearn.datasets import make_blobs 
blobs, labels = make_blobs(int(1e6), 3)
print(blobs.shape)
from sklearn.cluster import KMeans, MiniBatchKMeans
kmeans = KMeans(n_clusters=3) 
minibatch = MiniBatchKMeans(n_clusters=3)

%time kmeans.fit(blobs)

%time minibatch.fit(blobs)

# 聚类性能上的差异在下面展示：
kmeans.cluster_centers_[0]

minibatch.cluster_centers_[0]

# 我们可能要问的下一个问题就是，两个形心距离多远。

from sklearn.metrics import pairwise 
pairwise.pairwise_distances(kmeans.cluster_centers_[0].reshape(1,-1),
minibatch.cluster_centers_[0].reshape(1,3))

# 看起来十分接近了。对角线包含形心的差异：
np.diag(pairwise.pairwise_distances(kmeans.cluster_centers_,
minibatch.cluster_centers_)) 

3.5 使用 KMeans 聚类来量化图像

目标是使用聚类来把图像变模糊

from scipy import ndimage 
img = ndimage.imread("headshot.jpg") 
plt.imshow(img)
plt.show()

img.shape 
# (227, 227, 3)

x, y, z = img.shape 
long_img = img.reshape(x*y, z) 
long_img.shape

对点进行聚类来降低图像中的不同颜色的数量 – 这是一个简单的量化方式。

from sklearn import cluster 
k_means = cluster.KMeans(n_clusters=5) 
k_means.fit(long_img)

centers = k_means.cluster_centers_ 
centers

既然我们拥有了形心，我们需要的下一个东西就是标签。它会告诉我们，哪个点关联哪个簇。

labels = k_means.labels_ 
labels[:5]

pic=centers[labels].reshape(x, y, z)
pic.shape

plt.imshow(pic.astype(int)) 
plt.show()

3.6 寻找特征空间中的最接近对象

有时，最简单的事情就是求出两个对象之间的距离。我们刚好需要寻找一些距离的度量，计算成对（Pairwise）距离，并将结果与我们的预期比较。

Scikit-learn 中，有个叫做sklearn.metrics.pairwise的底层工具。它包含一些服务函数，计算矩阵X中向量之间的距离，或者X和Y中的向量距离。

我们会使用pairwise_distances函数来判断对象的接近程度。要记住，接近程度就像我们用于聚类/分类的距离函数。

from sklearn.metrics import pairwise 
from sklearn.datasets import make_blobs 
points, labels = make_blobs() 

points.shape
# (100,100)

# 用于检查距离的最简单方式是pairwise_distances：
distances = pairwise.pairwise_distances(points) 
distances.shape
# (100, 100)

# distances是个 NxN的矩阵，对角线为 0。在最简单的情况中，
# 让我们先看看每个点到第一个点的距离：
np.diag(distances) [:5] 

# 现在我们可以查找最接近于第一个点的点：
distances[0][:5] 

# 将点按照接近程度排序，很容易使用np.argsort做到：
ranks = np.argsort(distances[0]) 
ranks.shape
# (100,)
ranks[:5] 
# array([ 0, 10, 61, 46, 42], dtype=int64)

points[ranks][:5] 

给定一些距离函数，每个点都以成对函数来度量。通常为欧几里得距离，它是：
$d(x, y)=\sqrt{\sum_{t}\left(x_{i}-y_{i}\right)^{2}}$d(x,y)=∑t​(xi​−yi​)2​

def euclid_distances(x, y):
    return np.power(np.power(x - y, 2).sum(), .5) 
euclid_distances(points[0], points[1])

Scikit-learn 中存在一些其他函数，但是 Scikit-learn 也会使用 SciPy 的距离函数。Scikit-learn 距离函数支持稀疏矩阵。距离函数的更多信息请查看 SciPy 文档。

• cityblock
• cosine
• euclidean
• l1
• l2
• manhattan

我们现在可以解决问题了。例如，如果我们站在原点处的格子上，并且线是街道，为了到达点(5,5)，我们需要走多远呢？

pairwise.pairwise_distances([[0, 0], [5, 5]], metric='cityblock')[0]
# array([ 0., 10.])

使用成对距离，我们可以发现位向量之间的相似性。这是汉明距离的事情，它定义为：$\sum_{i} I_{x_{i} \neq y_{i}}$∑i​Ixi​̸​=yi​​

X = np.random.binomial(1, .5, size=(2, 4)).astype(np.bool) 

pairwise.pairwise_distances(X, metric='hamming')

3.7 使用高斯混合模型的概率聚类

在 KMeans 中，我们假设簇的方差是相等的。这会导致空间的细分，这决定了簇如何被分配。但是，如果有一种场景，其中方差不是相等的，并且每个簇中的点拥有一个与之相关的概率，会怎么样？

有一种更加概率化的方式，用于查看 KMeans 聚类。KMeans 聚类相当于将协方差矩阵S应用于高斯混合模型，这个矩阵可以分解为单位矩阵成误差。对于每个簇，协方差结构是相同的。这就产生了球形聚类。

但是，如果我们允许S变化，就可以估计 GMM，并将其用于预测。我们会以单变量的角度看到它的原理，之后扩展为多个维度。

首先，我们需要创建一些数据。例如，让我们模拟女性和男性的身高。这是个简单的例子，但是会展示出我们在 N 维空间中想要完成的东西，这比较易于可视化：

import numpy as np 
N = 1000
in_m = 72 
in_w = 66
s_m = 2 
s_w = s_m
m = np.random.normal(in_m, s_m, N) 
w = np.random.normal(in_w, s_w, N) 
from matplotlib import pyplot as plt 
f, ax = plt.subplots(figsize=(7, 5))
ax.set_title("Histogram of Heights") 
ax.hist(m, alpha=.5, label="Men"); 
ax.hist(w, alpha=.5, label="Women"); 
ax.legend()
plt.show()

w.shape,m.shape
# ((1000,), (1000,))

random_sample = np.random.choice([True, False], size=m.size) 
m_test = m[random_sample] 
m_train = m[~random_sample]
w_test = w[random_sample] 
w_train = w[~random_sample] 

# 现在我们需要获得男性和女性高度的经验分布，基于训练集：
from scipy import stats 
m_pdf = stats.norm(m_train.mean(), m_train.std()) 
w_pdf = stats.norm(w_train.mean(), w_train.std())

# 对于测试集，我们要计算，基于数据点从每个分布中生成的概率，
# 并且最可能的分布会分配合适的标签。当然，我们会看到有多么准确。
m_pdf.pdf(m[0]) 
# 0.19978402252176347

w_pdf.pdf(m[0]) 
# 0.0018615006196173731

# 要注意概率中的差异。假设当男性的概率更高时，我们会猜测，
# 但是如果女性的概率更高，我们会覆盖它。
guesses_m = np.ones_like(m_test) 
guesses_m[m_pdf.pdf(m_test) < w_pdf.pdf(m_test)] = 0
guesses_m.mean() 
# 0.9343936381709742

guesses_w = np.ones_like(w_test) 
guesses_w[m_pdf.pdf(w_test) > w_pdf.pdf(w_test)] = 0 
guesses_w.mean()
# 0.952286282306163

# 让我们允许两组间的方差不同。首先，创建一些新的数组：
s_m = 1 
s_w = 4
m = np.random.normal(in_m, s_m, N) 
w = np.random.normal(in_w, s_w, N) 

# 之后，创建训练集：
m_test = m[random_sample] 
m_train = m[~random_sample]
w_test = w[random_sample] 
w_train = w[~random_sample] 
f, ax = plt.subplots(figsize=(7, 5)) 
ax.set_title("Histogram of Heights") 
ax.hist(m_train, alpha=.5, label="Men"); 
ax.hist(w_train, alpha=.5, label="Women"); 
ax.legend()
plt.show()

让我们看看男性和女性之间的方差差异：现在我们可以创建相同的 PDF：

m_pdf = stats.norm(m_train.mean(), m_train.std()) 
w_pdf = stats.norm(w_train.mean(), w_train.std()) 

你可以在多维空间中想象他：

class_A = np.random.normal(0, 1, size=(100, 2)) 
class_B = np.random.normal(4, 1.5, size=(100, 2)) 
f, ax = plt.subplots(figsize=(7, 5))
ax.scatter(class_A[:,0], class_A[:,1], label='A', c='r')
ax.scatter(class_B[:,0], class_B[:,1], label='B')
plt.show()

工作原理

from sklearn.mixture import GaussianMixture

gmm = GaussianMixture(n_components=2) 
X = np.row_stack((class_A, class_B)) 
y = np.hstack((np.ones(100), np.zeros(100)))

train = np.random.choice([True, False], 200) 
gmm.fit(X[train]) 

gmm.predict(X[train])[:5] 

f, ax = plt.subplots(figsize=(7, 5))
colors = ['r', 'g']
ground_truth=gmm.predict(X[train])
for i in range(2):
    p = X[train][ground_truth == i]
    ax.scatter(p[:,0], p[:,1], c=colors[i],
    label="Cluster {}".format(i))
ax.set_title("Cluster With Ground Truth") 
ax.legend()
plt.show()

3.8 将 KMeans 用于离群点检测

我们会查看 Kmeans 离群点检测的机制和正义。它对于隔离一些类型的错误很实用，但是使用时应多加小心。

我们会使用 KMeans，对簇中的点执行离群点检测。要注意，提及离群点和离群点检测时有很多“阵营”。以便面，我们可能通过移除离群点，来移除由数据生成过程生成的点。另一方面，离群点可能来源于测量误差或一些其它外部因素。

我们的假设是，我们移除离群点的选择是合理的。

离群点检测的操作是，查找簇的形心，之后通过点到形心的距离来识别潜在的离群点。

# 首先，我们会生成 100 个点的单个数据块，之后我们会识别 5 个离形心最远的点。
# 它们就是潜在的离群点。

from sklearn.datasets import make_blobs 
X, labels = make_blobs(100, centers=1) 
import numpy as np 

# 非常重要的是，Kmeans 聚类只有一个形心。这个想法类似于用于离群点检测的单类 SVM。

from sklearn.cluster import KMeans 
kmeans = KMeans(n_clusters=1) 
kmeans.fit(X)

f, ax = plt.subplots(figsize=(7, 5)) 
ax.set_title("Blob") 
ax.scatter(X[:, 0], X[:, 1], label='Points') 
ax.scatter(kmeans.cluster_centers_[:, 0],
                kmeans.cluster_centers_[:, 1],
                label='Centroid',
                color='r') 
ax.legend()
plt.show()

# 现在，让我们识别五个最接近的点：
distances = kmeans.transform(X) 
# argsort returns an array of indexes which will 
# sort the array in ascending order 
# so we reverse it via [::-1] and take the top five with [:5] 
sorted_idx = np.argsort(distances.ravel())[::-1][:5]
sorted_idx
# array([ 6, 97, 42,  8, 78], dtype=int64)

# 现在，让我们看看哪个点离得最远：

f, ax = plt.subplots(figsize=(7, 5)) 
ax.set_title("Single Cluster") 
ax.scatter(X[:, 0], X[:, 1], label='Points') 
ax.scatter(kmeans.cluster_centers_[:, 0],
                kmeans.cluster_centers_[:, 1],
                label='Centroid', color='r') 
ax.scatter(X[sorted_idx][:, 0], X[sorted_idx][:, 1],
                label='Extreme Value', edgecolors='g',
                facecolors='none', s=100) 
ax.legend(loc='best') 
plt.show()

# 如果我们喜欢的话，移除这些点很容易。
new_X = np.delete(X, sorted_idx, axis=0)

# 同样，移除这些点之后，形心明显变化了。

new_kmeans = KMeans(n_clusters=1) 
new_kmeans.fit(new_X) 

# 让我们将旧的和新的形心可视化：
f, ax = plt.subplots(figsize=(7, 5)) 
ax.set_title("Extreme Values Removed") 
ax.scatter(new_X[:, 0], new_X[:, 1], label='Pruned Points') 
ax.scatter(kmeans.cluster_centers_[:, 0],
               kmeans.cluster_centers_[:, 1], label='Old Centroid',
               color='r', s=80, alpha=.5) 
ax.scatter(new_kmeans.cluster_centers_[:, 0],
               new_kmeans.cluster_centers_[:, 1], label='New Centroid',
               color='m', s=80, alpha=.5) 
ax.legend(loc='best') 
plt.show()

显然，形心没有移动多少，仅仅移除五个极端点时，我们的预期就是这样。这个过程可以重复，知道我们对数据表示满意。

高斯分布和 KMeans 聚类之间有本质联系。让我们基于形心和样本的协方差矩阵创建一个经验高斯分布，并且查看每个点的概率 – 理论上是我们溢出的五个点。这刚好展示了，我们实际上溢出了拥有最低可能性的值。

使用下列命令来创建经验高斯分布：

from scipy import stats 
emp_dist = stats.multivariate_normal(
               kmeans.cluster_centers_.ravel()) 
lowest_prob_idx = np.argsort(emp_dist.pdf(X))[:5] 
lowest_prob_idx
# array([70,  4, 19, 83, 88], dtype=int64)

3.9 将 KNN 用于回归

对于 KNN 回归来说，我们使用特征空间中的 K 个最近点，来构建回归，而不像常规回归那样使用整个特征空间。

# 我们使用iris数据集：
from sklearn import datasets 
iris = datasets.load_iris() 
iris.feature_names 

# 我们尝试基于萼片长度和宽度来预测花瓣长度。我们同时训练一个线性回归，
# 来对比观察 KNN 回归有多好。
X=iris.data[:,[0,1]]
y=iris.data[:,2]
X.shape,y.shape
# ((150, 2), (150,))

from sklearn.linear_model import LinearRegression 
lr = LinearRegression() 
lr.fit(X, y) 
print("The MSE is: {:.2}".format(np.power(y - lr.predict(X),2).mean()) )
# The MSE is: 0.41

# 现在，对于 KNN 回归，使用下列代码：

from sklearn.neighbors import KNeighborsRegressor 
knnr = KNeighborsRegressor(n_neighbors=10) 
knnr.fit(X, y) 
print("The MSE is: {:.2}".format(np.power(y - knnr.predict(X),2).mean())) 
# The MSE is: 0.17

# 让我们看看，当我们让它使用最接近的 10 个点用于回归时，KNN 回归会做什么？

f, ax = plt.subplots(nrows=2, figsize=(7, 10))
ax[0].set_title("Predictions")
ax[0].scatter(X[:, 0], X[:, 1], s=lr.predict(X)*80, label='LRPredictions', 
color='c', edgecolors='black') 
ax[1].scatter(X[:, 0], X[:, 1], s=knnr.predict(X)*80, label='k-NNPredictions',
 color='m', 
edgecolors='black')
ax[0].legend() 
ax[1].legend()
plt.show()

很显然，预测大部分都是接近的。但是让我们与实际情况相比，看看 Setosa 物种的预测：

setosa_idx = np.where(iris.target_names=='setosa') 
print(setosa_idx)
setosa_mask = iris.target == setosa_idx[0] 
print(setosa_mask)
print(y[setosa_mask][:5]) 
knnr.predict(X)[setosa_mask][:5] 

lr.predict(X)[setosa_mask][:5] 

example_point = X[0]

lr.predict(example_point.reshape(1,-1))

knnr.predict(example_point.reshape(1,-1))

现在，我们需要获取离我们的our_example_point最近的 10 个点：

from sklearn.metrics import pairwise 
distances_to_example = pairwise.pairwise_distances(X)[0] 
print(distances_to_example.shape)
ten_closest_points = X[np.argsort(distances_to_example)][:10] 
ten_closest_y = y[np.argsort(distances_to_example)][:10]
ten_closest_y.mean()