Page History

Generalized Linear Models ( 广义线性模型 )

以下是一组用于回归的方法，他们的目标值是输入变量的线性组合。假设数学符号 表示预测值。

在整个模块中，我们指定coef_ 代表向量, intercept_ 代表 。

要使用广义线性回归进行分类，请参阅 Logistic 回归。

Ordinary Least Squares ( 普通最小二乘法 )

LinearRegression 类拟合系数为  的线性模型， 来最小化，样本集中观测点和线性近似的预测点之间的残差平方和。

其实就是解决如下的一个数学问题：

LinearRegression类的成员函数 fit 以数组X和y为输入，并将线性模型的系数  存储在其成员变量coef_ 中：

>>> from sklearn import linear_model
>>> reg = linear_model.LinearRegression()
>>> reg.fit ([[0, 0], [1, 1], [2, 2]], [0, 1, 2])
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)
>>> reg.coef_
array([ 0.5,  0.5])

然而，最小二乘的系数估计依赖于model terms的独立性。当terms相关并且design matrix 然而，最小二乘的系数估计依赖于模型特征项的独立性。当特征项相关并且设计矩阵 的列近似的线性相关时，design matrix便接近于一个奇异矩阵，因此最小二乘估计对观测点中的随机误差变得高度敏感，产生大的方差。例如，当没有试验设计的收集数据时，可能会出现这种复共线性设计矩阵便接近于一个奇异矩阵，因此最小二乘估计对观测点中的随机误差变得高度敏感，产生大的方差。例如，当没有试验设计的收集数据时，可能会出现这种多重共线性(multicollinearity )的情况。

Ordinary Least Squares Complexity ( 普通最小二乘法复杂度 )

该方法通过对X进行 singular value decomposition ( 奇异值分解 ) 来计算最小二乘法的解。如果 X 是大小为(n, p) 的矩阵，则该方法的复杂度为 ，假设 。

Ridge Regression ( 岭回归 )

岭回归通过对系数的大小施加惩罚来解决 普通最小二乘 的一些问题。 ridge coefficients ( 岭系数 ) 最小化一个带罚项的残差平方和，

这里，  是控制收缩量的复杂度参数：  是控制缩减量的复杂度参数：  值越大，收缩量越大，因此系数变得对共线性变得更加鲁棒。 值越大，缩减量越大，因此系数变得对共线性变得更加鲁棒。

与其他线性模型一样，Ridge 将采用其拟合方法数组 X ， y 并将其线性模型的系数 Image Removed 存储在其 coef_ 成员中： 类成员函数 fit 以数组X和y为输入，并将线性模型的系数 Image Added 存储在其成员变量coef_ 中：

>>> from sklearn import linear_model
>>> reg = linear_model.Ridge (alpha = .5)
>>> reg.fit ([[0, 0], [0, 0], [1, 1]], [0, .1, 1]) 
Ridge(alpha=0.5, copy_X=True, fit_intercept=True, max_iter=None,
      normalize=False, random_state=None, solver='auto', tol=0.001)
>>> reg.coef_
array([ 0.34545455,  0.34545455])
>>> reg.intercept_ 
0.13636...

Ridge Complexity ( 岭复杂性 )

这种方法与 Ordinary Least Squares ( 普通最小二乘方法 ) 的复杂度相同。

Setting the regularization parameter: generalized Cross-Validation ( 设置正则化参数：广义交叉验证 )

RidgeCV 通过内置的 Alpha 参数的交叉验证来实现岭回归。 该对象的工作方式与 GridSearchCV 相同，只是它默认为 Generalized Cross-Validation ( 通用交叉验证 ) （GCV），这是一种有效的一对一交叉验证形式：），这是一种有效的留一交叉验证法：

>>> from sklearn import linear_model
>>> reg = linear_model.RidgeCV(alphas=[0.1, 1.0, 10.0])
>>> reg.fit([[0, 0], [0, 0], [1, 1]], [0, .1, 1])       
RidgeCV(alphas=[0.1, 1.0, 10.0], cv=None, fit_intercept=True, scoring=None,
    normalize=False)
>>> reg.alpha_                                      
0.1

Lasso

Lasso 是估计稀疏系数的线性模型。它在一些情况下是有用的，因为它倾向于使用具有较少参数值的解决方案，有效地减少给定解决方案所依赖的变量的数量。为此，Lasso 及其变体是 compressed sensing ( 压缩感测领域 ) 的基础。在某些条件下，它可以恢复精确的非零权重集（参见 Compressive sensing: tomography reconstruction with L1 prior (Lasso) ( 压缩感测：使用 L1 先验（ Lasso ）进行断层扫描重建 ) ）。

在数学上，它由一个使用  作为正则化预先训练的线性模型组成。目标函数最小化是：  先验作为正则化项的线性模型组成。最小化的目标函数是：

因此，lasso estimate 解决了加上 解决了加上罚项  的最小二乘法的最小化，其中，  是常数，  是参数向量的-norm 范数 。

Lasso 类中的实现使用坐标下降作为算法来拟合系数。查看  Least Angle Regression ( 最小角度回归 ) 用于另一个实现：

>>> from sklearn import linear_model
>>> reg = linear_model.Lasso(alpha = 0.1)
>>> reg.fit([[0, 0], [1, 1]], [0, 1])
Lasso(alpha=0.1, copy_X=True, fit_intercept=True, max_iter=1000,
   normalize=False, positive=False, precompute=False, random_state=None,
   selection='cyclic', tol=0.0001, warm_start=False)
>>> reg.predict([[1, 1]])
array([ 0.8])

对于较低级别的任务也很有用的是函数 lasso_path 来计算可能值的完整路径上的系数。

Setting regularization parameter ( 设置正则化参数 )

alpha 参数控制 degree of sparsity of the coefficients estimated ( 估计的系数的稀疏度 ) 。

Using cross-validation ( 使用交叉验证 )

scikit-learn 通过交叉验证来公开设置 Lasso alpha 参数的对象：LassoCV 和 LassoLarsCV 。  LassoLarsCV 是基于下面解释的  Least Angle Regression  ( 最小角度回归 ) 算法。
对于具有许多共线回归的高维数据集， LassoCV 最常见。然而， LassoLarsCV 具有探索更相关的 alpha 参数值的优点，并且如果样本数量与观察次数相比非常小，则通常比 LassoCV 快。

Information-criteria based model selection ( 基于信息标准的模型选择 )

估计器 LassoLarsIC 建议使用 Akaike 信息准则（AIC）和贝叶斯信息准则（BIC）。当使用 k-fold 交叉验证时，正则化路径只计算一次而不是 k + 1 次，所以找到 α 的最优值是一个计算上更便宜的替代方法。然而，这样的标准需要对解决方案的自由度进行适当的估计，为大样本（渐近结果）导出，并假设模型是正确的，即数据实际上是由该模型生成的。当问题条件差时，它们也倾向于打破（比样本更多的特征）。

Multi-task Lasso ( 多任务套索 )

MultiTaskLasso 是一个线性模型，它联合估计多个回归问题的稀疏系数：y 是一个二维数组，shape(n_samples，n_tasks)。约束是所选的特征对于所有的回归问题都是相同的，也称为 tasks ( 任务 )。

下图比较了使用简单 Lasso 或 MultiTaskLasso 获得的 W 中非零的位置。 Lasso 估计产生分散的非零，而 MultiTaskLasso 的非零是全列。

拟合 time-series model ( 时间序列模型 )，强制任何活动的功能始终处于活动状态。

在数学上，它由一个线性模型组成，训练有混合的   之前的正则化。目标函数最小化是：

其中 表示 Frobenius 规范：

和   读取：

MultiTaskLasso 类中的实现使用坐标下降作为拟合系数的算法。

Elastic Net ( 弹性网 )

ElasticNet 是一种线性回归模型，以 L1 和 L2 训练为正规化。这种组合允许学习一个稀疏模型，其中很少的权重是非零的，如 Lasso ，同时仍然保持 Ridge 的正则化属性。我们使用 l1_ratio 参数控制 L1 和 L2 的凸组合。
当有多个相互关联的特征时，Elastic-net 是有用的。 Lasso 有可能随机选择其中之一，而 elastic-net 则很可能选择两者。

Lasso 和 Ridge 之间的一个实际的优势是允许 Elastic-Net 继承 Ridge 在一些旋转下的稳定性。
在这种情况下，最小化的目标函数

ElasticNetCV 类可用于通过交叉验证来设置参数 alpha(  )和 l1_ratio (  )。

Multi-task Elastic Net ( 多任务弹性网 )

MultiTaskElasticNet 是一个弹性网络模型，可以联合估计多个回归问题的稀疏系数： Y 是 2D array，shape(n_samples, n_tasks)。constraint ( 约束 ) 是所选的特征对于所有的回归问题都是相同的，也称为 tasks ( 任务 )。
在数学上，它由一个线性模型组成，训练有混合的   之前和  之前的正规化。目标函数最小化是：

MultiTaskElasticNet 类中的实现使用坐标下降作为拟合系数的算法。
MultiTaskElasticNetCV 类可用于通过交叉验证来设置参数 alpha(  ) 和 l1_ratio()。

Least Angle Regression ( 最小角度回归 )

Least-angle regression ( 最小二乘回归 ) ( LARS ) 是由 Bradley Efron，Trevor Hastie，Iain Johnstone 和 Robert Tibshirani 开发的高维数据回归算法。
LARS 的优点是：

• 在p >> n的情况下（即，当维数显着大于点数时）的数值效率较高
• 它在计算上与正向选择一样快，并且具有与普通最小二乘法相同的复杂度。
• 它产生一个完整的分段线性解决路径，这在交叉验证或类似的调试模型尝试中很有用。
• 如果两个变量与响应几乎相等，那么它们的系数应该以大致相同的速率增加。因此，算法的行为就像直觉所期望的那样，并且也更稳定。
• 它很容易被修改为其他估计器产生解决方案，如 Lasso 。

LARS 方法的缺点包括：

• 因为 LARS 是基于对残差进行迭代重新设计的，所以它似乎对噪声的影响特别敏感。 Weisberg 在 Efron 等人的讨论部分详细讨论了这个问题。 (2004) Annals of Statistics article 。

LARS 模型可以使用估计器 Lars 或其低级实现 lars_path 来使用。

LARS Lasso

LassoLars 是使用 LARS 算法实现的 lasso model ( 套索模型 ) ，与基于 coordinate_descent 的实现不同，这产生了精确的解，其作为其系数范数的函数是分段线性的。

>>> from sklearn import linear_model
>>> reg = linear_model.LassoLars(alpha=.1)
>>> reg.fit([[0, 0], [1, 1]], [0, 1])  
LassoLars(alpha=0.1, copy_X=True, eps=..., fit_intercept=True,
     fit_path=True, max_iter=500, normalize=True, positive=False,
     precompute='auto', verbose=False)
>>> reg.coef_    
array([ 0.717157...,  0.        ])

Lars 算法提供了沿着正则化参数的系数的完整路径，几乎是免费的，因此一个常见的操作包括使用函数 lars_path 检索路径。

Mathematical formulation ( 数学表达 )

该算法类似于 forward stepwise regression ( 前向逐步回归 ) ，而不是在每个步骤中包含变量，估计参数在等于每个与残差相关的方向上增加。
代替给出向量结果，LARS 解决方案由表示参数向量的 L1 norm ( 范数 ) 的每个值的解的曲线组成。完整系数路径存储在具有 size(n_features, max_features + 1) 的数组 coef_path_ 中。第一列始终为零。

Orthogonal Matching Pursuit (OMP) ( 正交匹配追踪（OMP） )

OrthogonalMatchingPursuit  ( 正交匹配追踪 ) 和 orthogonal_mp 实现了 OMP 算法，用于近似线性模型的拟合，并对非零系数（即 L 0 伪范数）施加约束。
作为  Least Angle Regression (  最小角度回归 ) 的前向特征选择方法，正交匹配追踪可以用固定数量的非零元素逼近最优解矢量：

或者，正交匹配追踪可以针对特定错误而不是特定数量的非零系数。这可以表示为：

OMP 基于一个贪心算法，每个步骤都包含与当前残差最相关的原子。它类似于更简单的匹配追求（ MP ）方法，但是在每次迭代中更好，使用在先前选择的词典元素的空间上的正交投影重新计算残差。

Bayesian Regression ( 贝叶斯回归 )

贝叶斯回归技术可以用于在估计过程中包括正则化参数：正则化参数不是硬的设置，而是调整到手头的数据。
这可以通过对模型的超参数引入 uninformative priors ( 不知情的先验 ) 来完成。Ridge Regression  中使用的 正则化等价于在精度为 的参数  之前，在高斯下找到最大 a-postiori 解。而不是手动设置 lambda ，可以将其视为从数据估计的随机变量。
为了获得一个完全概率模型，输出y被假定为高斯分布在  周围：

Alpha 再次被视为从数据估计的随机变量。
贝叶斯回归的优点是：

• 它适应了 data at hand ( 手头的数据 ) 。
• 它可以用于在估计过程中包括正则化参数。

贝叶斯回归的缺点包括：

• 模型的推论可能是耗时的。

Bayesian Ridge Regression ( 贝叶斯岭回归 )

BayesianRidge estimates ( 贝叶斯岭方差估计 ) 如上所述的回归问题的概率模型。参数  的先验由球面高斯给出：

选择  和  的先验是  gamma distributions ( 伽马分布 ) ，即 conjugate prior for the precision of the Gaussian ( 高斯精度之前的共轭 ) 。
所得到的模型称为 Bayesian Ridge Regression ( 贝叶斯岭回归 )  ，与 classical Ridge ( 古典岭 ) 相似。参数 ，  和  在模型拟合期间联合估计。剩余的超参数是  和  之后的伽玛先验的参数。这些通常被选为 non-informative ( 非资料性 ) 的。通过最大化边际对数似然估计参数。

默认情况下，

贝叶斯回归用于回归：

>>> from sklearn import linear_model
>>> X = [[0., 0.], [1., 1.], [2., 2.], [3., 3.]]
>>> Y = [0., 1., 2., 3.]
>>> reg = linear_model.BayesianRidge()
>>> reg.fit(X, Y)
BayesianRidge(alpha_1=1e-06, alpha_2=1e-06, compute_score=False, copy_X=True,
       fit_intercept=True, lambda_1=1e-06, lambda_2=1e-06, n_iter=300,
       normalize=False, tol=0.001, verbose=False)

安装后，该模型可用于预测新值：

>>> reg.predict ([[1, 0.]])
array([ 0.50000013])

模型的权重  可以访问：

>>> reg.coef_
array([ 0.49999993,  0.49999993])

由于贝叶斯框架，发现的权重与普通最小二乘法发现的权重略有不同。然而，贝叶斯岭回归对于不适当的问题更为强大。

Automatic Relevance Determination - ARD ( 自动相关性测定 - ARD )

 ARDRegression 与 Bayesian Ridge Regression ( 贝叶斯岭回归 ) 非常相似，但可以导致更稀疏的权重   [1] [2] 。 ARDREgression 通过放弃高斯为球面的假设，构成了与  之前不同的先验。
相反，假定  上的分布是轴平行的椭圆高斯分布。
这意味着每个权重  从高斯分布绘制，以零为中心，精度为  ：

与  。
与贝叶斯岭回归相反，每个  的坐标都有自己的标准偏差 。 先前的所有  被选择为由超参数 和  给出的相同的伽马分布。

ARD 在文献中也被称为稀疏贝叶斯学习与  Relevance Vector Machine [3] [4]。

Logistic regression ( 逻辑回归 )

Logistic regression ( 逻辑回归 ) ，尽管它的名字是回归，是一个用于分类的线性模型而不是用于回归。 Logistic Regression 在文献中也被称为 logit 回归，maximum-entropy classification ( MaxEnt ) ( 最大熵分类 ) 或 log-linear classifier ( 对数线性分类器 ) 。在这个模型中，描述单个试验的结果的概率使用 logistic function ( 逻辑函数 ) 进行建模。

可以从 LogisticRegression 类中访问 scikit-learn 中 logistic regression ( 逻辑回归 ) 的实现。该实现可以拟合 binary ( 二进制 ) ，One-vs- Rest ( 一对一休息 ) 或 multinomial logistic regression ( 多项逻辑回归 ) 与可选的 L2 或 L1 regularization ( 正则化 ) 。

作为优化问题，binary class L2 penalized logistic regression ( 二进制类 L2 惩罚逻辑回归 ) 使以下 cost function ( 成本函数 ) 最小化：

类似地， L1 regularized logistic regression ( L1 正则化逻辑回归 ) 解决了以下优化问题:

在 Logistic 回归类中实现的 solver ( 求解器 ) 是 “liblinear”, “newton-cg”, “lbfgs” and “sag”：

solver ( 求解器 )  “liblinear” 使用 coordinate descent ( 坐标下降 ) (CD) 算法，并依赖于与 scikit-learn 一起提供的优秀 C ++ LIBLINEAR library 。然而，在 liblinear 中实现的 CD 算法不能学习一个真正的 multinomial (multiclass)  多项（多类）模型;相反，优化问题以 “one-vs-rest” 的方式分解，因此对所有类进行单独的二进制分类。这发生在 hood 下，所以使用此求解器的 LogisticRegression 实例表现为 multiclass classifiers ( 多类分类器 ) 。对于 L1 惩罚，sklearn.svm.l1_min_c 允许计算 C 的下限，以获得非 “null” （所有特征权重为零）模型。

 “lbfgs”, “sag” 和 “newton-cg” 求解器仅支持  L2 penalization ( L2 惩罚 ) ，并且发现某些高维度数据的收敛速度更快。这些求解器将多类设置为“多项式”可以学习一个真正的 multinomial logistic regression model  ( 多项式逻辑回归模型  )  [5] ，这意味着它的概率估计应该比默认的 “one-vs-rest” 设置更好地校准。 “lbfgs”，“sag” 和 “newton-cg” 求解器不能优化 L1-penalized ( L1 惩罚 )  模型，因此 "multinomial" 设置不会学习 sparse models ( 稀疏模型 ) 。

求解器 “sag” 使用 Stochastic Average Gradient descent  ( 随机平均梯度下降 )  [6]。当样本数量和特征数量都很大时，它比其他大型数据集的求解器更快。

简而言之，可以选择具有以下规则的 solver ( 求解器 ) ：

对于较大的数据集，您还可以考虑使用 SGDClassifier 与 "log" loss ( 损失 )。

LogisticRegressionCV 通过  builtin cross-validation ( 内建交叉验证 ) 实现 Logistic Regression ( Logistic 回归 ) ，找出最优 C 参数。由于热启动，“newton-cg”，“sag” 和 “lbfgs” solvers ( 求解器 ) 被发现对于 high-dimensional dense data ( 高维密度数据 ) 来说更快。对于多类的情况，如果multi_class 选项设置为 “ovr” ，则为每个类获得最佳 C ，如果 multi_class 选项设置为 “multinomial” ，则通过最小化交叉熵损失获得最佳 C 。

Stochastic Gradient Descent - SGD ( 随机梯度下降 )

Stochastic gradient descent ( 随机梯度下降 ) 是一种简单但非常有效的拟合线性模型的方法。当 samples ( 样本 ) 数量（和 features ( 特征 ) 数量）非常大时，这是特别有用的。 partial_fit 方法 only/out-of-core 学习。
SGDClassifier 和 SGDRegressor 类提供了使用不同（凸）损失函数和不同惩罚的分类和回归的线性模型的功能。例如，当 loss=“log” 时，SGDC 分类器适合逻辑回归模型，而 loss="hinge" 则适合线性支持向量机（ SVM ）。

Perceptron ( 感知 )

Perceptron ( 感知器 ) 是适用于大规模学习的另一种简单算法。默认：

• 它不需要 learning rate ( 学习率 ) 。
• 它不是 regularized (penalized) ( 正规化（惩罚） ) 。
• 它 updates its model only on mistakes ( 仅在错误时更新其模型 ) 。

最后一个特征意味着 Perceptron  ( 感知器 ) 比 hinge loss 比 SGD 稍快一点，并且所得到的模型更加 sparser ( 稀疏 ) 。

Passive Aggressive Algorithms ( 被动侵略性算法 )

passive-aggressive algorithms ( 被动侵略算法 ) 是用于 large-scale learning ( 大规模学习 ) 的一系列算法。它们与 Perceptron  ( 感知器 ) 类似，因为它们不需要 learning rate ( 学习率 ) 。然而，与 Perceptron ( 感知器 ) 相反，它们包括正则化参数 C 。
对于分类，PassiveAggressiveClassifier 可以与 loss ='hinge' （ PA-I ）或 loss =“squared_hinge” （ PA-II ）一起使用。对于回归，PassiveAggressiveRegressor 可以与 loss ='epsilon_insensitive' （ PA-I ）或 loss ='squared_epsilon_insensitive' （ PA-II ）一起使用。

Robustness regression: outliers and modeling errors ( 鲁棒性回归：异常值和建模误差 )

Robust regression ( 鲁棒性回归 ) 有兴趣在存在 presence of corrupt data ( 腐败数据 ) 的情况下拟合回归模型：outliers ( 异常值 ) 或模型中的错误。

Different scenario and useful concepts ( 不同的场景和有用的概念 ) 

处理由异常值损坏的数据时，请记住不同的事项：

Outliers in X or in y?

               Outliers in the y direction                                         Outliers in the X direction

Fraction of outliers versus amplitude of error ( 异常值与误差幅度的分数 ) 

The number of outlying points matters, but also how much they are outliers. ( 离岸点的数量很重要，但也是离群点多少 )

                           Small outliers                                                  Large outliers

robust fitting 的一个重要概念就是 breakdown point ( 分解点 ) ：可以离开的数据的分数，以适合开始丢失内部数据。

注意，一般来说，在高维度设置（大 n_features ）中的 robust fitting ( 鲁棒拟合 ) 是非常困难的。这里的  robust models ( 健壮模型 ) 可能无法在这些设置中使用。

RANSAC: RANdom SAmple Consensus 

RANSAC ( RANdom SAmple Consensus ) 适合来自完整数据集的来自随机子集的模型。
RANSAC 是一种 non-deterministic ( 非确定性 ) 算法，只产生具有一定概率的合理结果，这取决于迭代次数（参见 max_trials 参数）。它通常用于线性和非线性回归问题，在摄影测量计算机视觉领域尤其受欢迎。
该算法将完整的输入采样数据分解为可能受到噪声的一组内联集，以及异常值。由数据的错误测量或无效假设引起。然后，所得到的模型仅来自确定的内部估计。

Details of the algorithm ( 算法的细节 )

每次迭代执行以下步骤：

1. 从原始数据中选择 min_samples  random samples ( 随机样本 ) ，并检查数据集是否有效（请参阅 is_data_valid）。
2. 将模型拟合为 random subset ( 随机子集 ) （ base_estimator.fit ），并检查估计模型是否有效（请参阅 is_model_valid ）。
3. 通过计算 estimated model  ( 估计模型 ) 的残差（base_estimator.predict（X） - y））将所有数据作为内部值或异常值进行分类 - all 绝对残差小于 residual_threshold ( 残差阈值 ) 的数据样本均被视为内部值。
4. 如果 Inlier 样本数量最大，则将拟合模型保存为最佳模型。如果当前估计的模型具有相同数量的内部值，则只有当其具有较好的分数时才被认为是最佳模型。

这些步骤最大次数（ max_trials ）执行，或直到满足特殊停止条件之一（参见 stop_n_inliers 和 stop_score ）。最终模型使用先前确定的最佳模型的所有 Inlier 样本（一致集合）进行估计。

is_data_valid 和 is_model_valid 函数允许识别和拒绝随机子样本的退化组合。如果估计的模型不需要用于识别退化情况，则应使用 is_data_valid ，因为它在拟合模型之前被调用，从而导致更好的计算性能。

Theil-Sen estimator: generalized-median-based estimator ( Theil-Sen 估计：广义中位数估计 )

TheilSenRegressor 估计器使用 generalization of the median in multiple dimensions ( 多维度中值的泛化 ) 。因此，多变量离群值是非常 robust  ( 鲁棒 ) 的。但是请注意，估计器的鲁棒性随着问题的维数而迅速降低。它失去了其鲁棒性，并且在高维度上变得不如普通的最小二乘法。

Theoretical considerations ( 理论考虑 )

TheilSenRegressor 在渐近效率方面与普通最小二乘法（ OLS ）相当，作为无偏估计。与 OLS 相反，Theil-Sen 是一种非参数方法，这意味着它不会对数据的基本分布做出假设。由于 Theil-Sen 是一个基于中位数的估计器，它对于破坏的数据而言更为强大。在单变量设置中，Theil-Sen 在简单线性回归的情况下的崩溃点约为 29.3% ，这意味着它可以容忍高达 29.3% 的任意损坏的数据。

在 scikit-learn 中 TheilSenRegressor 的实现遵循多变量线性回归模型 [#f1]_  的推广，使用空间中值，这是中位数到多维度的推广  [8]。
在时间和空间复杂性方面， Theil-Sen scales 根据:

这使得对于大量样品和特征的问题进行彻底的应用是不可行的。因此，可以通过仅考虑所有可能组合的随机子集来选择子群体的大小来限制时间和空间复杂性。

Huber Regression ( 胡伯回归 )

HuberRegressor 与 Ridge 不同，因为它将线性损失应用于被分类为异常值的样本。如果该样本的绝对误差小于某一阈值，则样本被归类为一个异常值。它不同于 TheilSenRegressor 和 RANSACRegressor ，因为它不会忽视异常值的影响，但对它们的重视程度较小。

HuberRegressor 最小化的损失函数由

where

建议将参数ε设定为 1.35 ，达到 95% 的统计效率。

Notes ( 注意事项 )

HuberRegressor 不同于使用 SGDRegressor ，损失设置为 huber ，具体如下。

• HuberRegressor 是缩放不变的。一旦设置了 epsilon ，通过不同的值将 X 和 Y 缩小或缩小将产生与以前一样的离群值的相同鲁棒性。与 SGDRegressor 相比，当 X 和 Y 被缩放时，必须再次设置 epsilon 。
• 对于具有少量样本的数据，HuberRegressor 应该更有效率，而 SGDRegressor 需要对训练数据进行多次传递才能产生相同的鲁棒性。

此外，这个 estimator ( 估计量 ) 与 R 的 Robust Regression ( 鲁棒回归 ) 实现（http://www.ats.ucla.edu/stat/r/dae/rreg.htm）不同，因为 R 实现是一个 weighted least squares ( 加权最小二乘 ) 实现， 每个样本基于剩余量大于一定阈值的多少。

Polynomial regression: extending linear models with basis functions ( 多项式回归：用基函数扩展线性模型 )

机器学习中的一种常见模式是使用训练数据非线性函数的线性模型。这种方法保持线性方法的 generally fast performance ( 一般快速性能 ) ，同时允许它们适应更广泛的数据。
例如，可以通过从 constructing polynomial features ( 系数构造多项式特征 ) 来扩展简单的线性回归。在标准线性回归的情况下，您可能有一个类似于二维数据的模型：

如果我们想要将数学拟合为抛物面而不是平面，我们可以将 second-order polynomials ( 二阶多项式 ) 的特征组合起来，使得模型如下所示：

（有时令人惊讶）的观察是，这仍然是一个线性模型：要看到这一点，想象一下创建一个新的变量

通过对数据的重新标注，可以写出我们的问题

我们看到所得到的多项式回归与上面我们考虑过的线性模型相同（即模型在 w 中是线性的），并且可以通过相同的技术来解决。通过考虑使用这些基本功能构建的更高维度空间内的线性拟合，该模型具有适应更广泛范围的数据的灵活性。

以下是使用不同程度的多项式特征将这一想法应用于一维数据的示例：

该图是使用 PolynomialFeatures 预处理器创建的。该预处理器将输入数据矩阵转换为给定度的新数据矩阵。它可以使用如下：

>>> from sklearn.preprocessing import PolynomialFeatures
>>> import numpy as np
>>> X = np.arange(6).reshape(3, 2)
>>> X
array([[0, 1],
       [2, 3],
       [4, 5]])
>>> poly = PolynomialFeatures(degree=2)
>>> poly.fit_transform(X)
array([[  1.,   0.,   1.,   0.,   0.,   1.],
       [  1.,   2.,   3.,   4.,   6.,   9.],
       [  1.,   4.,   5.,  16.,  20.,  25.]])

X 的特征已经从  转换为  ，现在可以在任何线性模型中使用。
这种预处理可以使用 Pipeline 进行简化。可以创建表示简单多项式回归的单个对象，并使用如下：

>>> from sklearn.preprocessing import PolynomialFeatures
>>> from sklearn.linear_model import LinearRegression
>>> from sklearn.pipeline import Pipeline
>>> import numpy as np
>>> model = Pipeline([('poly', PolynomialFeatures(degree=3)),
...                   ('linear', LinearRegression(fit_intercept=False))])
>>> # fit to an order-3 polynomial data
>>> x = np.arange(5)
>>> y = 3 - 2 * x + x ** 2 - x ** 3
>>> model = model.fit(x[:, np.newaxis], y)
>>> model.named_steps['linear'].coef_
array([ 3., -2.,  1., -1.])

训练多项式特征的线性模型能够准确地恢复输入多项式系数。
在某些情况下，没有必要包含任何单个功能的更高的功能，而只包含所有交互功能，这些功能可以在多达  个不同的功能中进行叠加。这些可以通过设置 interaction_only = True 从 PolynomialFeatures 获得。
例如，当处理布尔特征时，所有 n 的  因此是无用的;但  表示两个布尔值的连接。这样，我们可以使用线性分类器来解决 XOR 问题：

>>> from sklearn.linear_model import Perceptron
>>> from sklearn.preprocessing import PolynomialFeatures
>>> import numpy as np
>>> X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
>>> y = X[:, 0] ^ X[:, 1]
>>> y
array([0, 1, 1, 0])
>>> X = PolynomialFeatures(interaction_only=True).fit_transform(X).astype(int)
>>> X
array([[1, 0, 0, 0],
       [1, 0, 1, 0],
       [1, 1, 0, 0],
       [1, 1, 1, 1]])
>>> clf = Perceptron(fit_intercept=False, n_iter=10, shuffle=False).fit(X, y)

And the classifier “predictions” are perfect: ( 分类器“预测”是完美的 ) ：

>>> clf.predict(X)
array([0, 1, 1, 0])
>>> clf.score(X, y)
1.0