Sklearn官方文档中文整理3——内核岭回归和支持向量机篇

1. 监督学习

1.3. 内核岭回归【kernel_ridge.KernelRidge】

内核岭回归(Kernel ridge regression-KRR）[1] 由使用内核方法的岭回归（使用 l2 正则化的最小二乘法）所组成。因此，它所拟合到的在空间中不同的线性函数是由不同的内核和数据所导致的。对于非线性的内核，它与原始空间中的非线性函数相对应。

由 KernelRidge 学习的模型的形式与支持向量回归( SVR 是一样的。但是他们使用不同的损失函数：内核岭回归（KRR）使用 squared error loss （平方误差损失函数）而 support vector regression （支持向量回归）（SVR）使用 $ϵ-insensitiveloss$ ( ε-不敏感损失 )，两者都使用 l2 regularization （l2 正则化）。与SVR 相反，拟合 KernelRidge 可以以 closed-form （封闭形式）完成，对于中型数据集通常更快。另一方面，学习的模型是非稀疏的，因此比 SVR 慢。在预测时间内，SVR 拟合的是ε>0的稀疏模型。

下图比较了人造数据集上的 KernelRidge 和 SVR的区别，它由一个正弦目标函数和每五个数据点产生一个强噪声组成。图中分别绘制了由 KernelRidge 和 SVR学习到的回归曲线。两者都使用网格搜索优化了 RBF 内核的 complexity/regularization （复杂性/正则化）和 bandwidth （带宽）。它们的 learned functions （学习函数）非常相似;但是，拟合 KernelRidge 大约比拟合 SVR快七倍（都使用 grid-search ( 网格搜索 ) ）。然而，由于 SVR 只学习了一个稀疏模型，所以 SVR 预测 10 万个目标值比使用 KernelRidge 快三倍以上。SVR 只使用了大约1/3的数据点做为支撑向量。

下图显示不同大小训练集的KernelRidge 和 SVR的fitting （拟合）和 prediction （预测）时间。

• 对于中型训练集（小于 1000 个样本），拟合 KernelRidge 比 SVR快; 然而，对于更大的训练集 SVR通常更好。
• 关于预测时间，由于学习的稀疏解， SVR 对于所有不同大小的训练集都比 KernelRidge 快。

注意，稀疏度和预测时间取决于 SVR的参数 $ϵ$ 和 $C$ ; $ϵ=0$ 将对应于密集模型。

sklearn.kernel_ridge.KernelRidge

参数	解释
alpha：float or array-like of shape (n_targets,), default=1.0	正则化强度；必须是正浮点数。正则化改善了问题的条件，并减少了估计的方差。值越大，正则化越强。在其他线性模型中，Alpha对应于1/（2C），如logisticReturnation或LinearSVC。如果传递了数组，则假定惩罚是特定于目标的。因此它们必须在数量上对应。公式见岭回归和分类。
kernel：string or callable, default=”linear”	内部使用的内核映射。这个参数直接传递给成对的内核。如果kernel是一个字符串，那么它必须是pairwise.PAIRWISE_KERNEL_FUNCTIONS的指标. 如果内核是 “precomputed”的，则假设X是一个核矩阵。或者，如果kernel是一个可调用函数，则对每对实例（行）调用它，并记录结果值。callable应该从X中取两行作为输入，并以单个数字的形式返回相应的内核值。这意味着sklearn.metrics.pairwise不被允许，因为它们在矩阵上操作，而不是单个样本。请改用标识内核的字符串。
gamma：float, default=None	RBF,laplacian, polynomial, exponential chi2 和sigmoid核的Gamma参数。默认值的解释由内核负责；该参数被其他内核忽略。
degree：float, default=3	polynomial 核的次数。其他内核忽略此参数。
coef0：float, default=1	polynomial 和sigmoid核的零系数。其他内核忽略此参数。
kernel_params：mapping of string to any, default=None	作为可调用对象传递的内核函数的附加参数（关键字参数）。

属性	解释
dual_coef_：ndarray of shape (n_samples,) or (n_samples, n_targets)	权向量在核空间中的表示
X_fit_：{ndarray, sparse matrix} of shape (n_samples, n_features)	预测所需的训练数据。如果kernel==“precomputed”，则这是形状（n_samples, n_samples）的预计算训练矩阵。

方法	解释
fit(X, y[, sample_weight])	拟合核岭回归模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。

例：

>>> from sklearn.kernel_ridge import KernelRidge
>>> import numpy as np
>>> n_samples, n_features = 10, 5
>>> rng = np.random.RandomState(0)
>>> y = rng.randn(n_samples)
>>> X = rng.randn(n_samples, n_features)
>>> clf = KernelRidge(alpha=1.0)
>>> clf.fit(X, y)
KernelRidge(alpha=1.0)

1.4. 支持向量机

支持向量机 (SVMs) 可用于以下监督学习算法: 分类, 回归 和 异常检测.

支持向量机的优势在于:

• 在高维空间中非常高效.
• 即使在数据维度比样本数量大的情况下仍然有效.
• 在决策函数（称为支持向量）中使用训练集的子集,因此它也是高效利用内存的.
• 通用性: 不同的核函数与特定的决策函数一一对应.常见的 kernel 已经提供,也可以指定定制的内核.

支持向量机的缺点包括:

• 如果特征数量比样本数量大得多,在选择核函数时要避免过拟合, 而且正则化项是非常重要的.
• 支持向量机不直接提供概率估计,这些都是使用昂贵的五次交叉验算计算的. (详情见 得分和概率).

在 scikit-learn 中,支持向量机提供 dense(numpy.ndarray ,可以通过 numpy.asarray 进行转换) 和 sparse (任何 scipy.sparse) 样例向量作为输出.然而,要使用支持向量机来对 sparse 数据作预测,它必须已经拟合这样的数据.使用行优先存储（C-order）的 numpy.ndarray (dense) 或者带有dtype=float64 的 scipy.sparse.csr_matrix (sparse) 来优化性能.

1.4.1. 分类【svm.SVC，svm.NuSVC，svm.LinearSVC】

SVC, NuSVC 和 LinearSVC 能在数据集中实现多元分类.

SVC 和 NuSVC 是相似的方法, 但是接受稍许不同的参数设置并且有不同的数学方程. 另一方面, LinearSVC 是另一个实现线性核函数的支持向量分类. 记住 LinearSVC 不接受关键词 kernel, 因为它被假设为线性的. 它也缺少一些 SVC 和 NuSVC 的成员(members) 比如 support_ .

和其他分类器一样, SVC, NuSVC 和 LinearSVC 将两个数组作为输入: [n_samples, n_features] 大小的数组 X 作为训练样本, [n_samples] 大小的数组 y 作为类别标签(字符串或者整数):

>>> from sklearn import svm
>>> X = [[0, 0], [1, 1]]
>>> y = [0, 1]
>>> clf = svm.SVC(gamma='scale')
>>> clf.fit(X, y)  
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
 decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',
 max_iter=-1, probability=False, random_state=None, shrinking=True,
 tol=0.001, verbose=False)

在拟合后, 这个模型可以用来预测新的值:

>>> clf.predict([[2., 2.]])
array([1])

SVMs 决策函数取决于训练集的一些子集, 称作支持向量. 这些支持向量的部分特性可以在 support_vectors_, support_ 和n_support 找到:

>>> # 获得支持向量
>>> clf.support_vectors_
array([[ 0.,  0.],
 [ 1.,  1.]])
>>> # 获得支持向量的索引
>>> clf.support_
array([0, 1]...)
>>> # 为每一个类别获得支持向量的数量
>>> clf.n_support_
array([1, 1]...)

sklearn.svm.SVC

参数	解释
C：float, default=1.0	正则化参数。正则化的强度与C成反比。必须严格正。惩罚是l2的平方。
kernel：{‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’}, default=’rbf’	指定要在算法中使用的内核类型。它必须是“linear”、“poly”、“rbf”、“sigmoid”、“precomputed”或callable之一。如果没有给出，则使用“rbf”。如果给定了一个可调用函数，它将用于根据数据矩阵预先计算内核矩阵；该矩阵应该是一个形状数组(n_samples, n_samples)。
degree：float, default=3	polynomial 核的次数。其他内核忽略此参数。
gamma：{‘scale’, ‘auto’} or float, default=’scale’	“rbf”、“poly”和“sigmoid”的核系数。如果gamma=‘scale’ (默认)那么使用 1 / (n_features * X.var()) 作为gamma的值；若为 ‘auto’, 使用1 / n_features.
coef0：float, default=0.0	核函数中的截距项。只有‘poly’ 和“sigmoid”才有意义。
shrinking：bool, default=True	是否使用收缩启发式。
probability：bool, default=False	是否启用概率估计。这必须在调用fit之前启用，这将减慢该方法的速度，因为它内部使用5倍交叉验证，并且predict_proba可能与predict不一致。
tol：float, default=1e-3	停止训练的标准
cache_size：float, default=200	指定内核缓存的大小（以MB为单位）。
class_weight：dict or ‘balanced’, default=None	对于SVC，将i类的参数C设置为class_weight[i]*C，如果没有给出，所有的类都应该有一个权重。 “balanced”模式使用y值自动调整权重，使其与输入数据中的类频率成反比，即n_samples / (n_classes * np.bincount(y))
verbose：bool, default=False	启用详细输出。请注意，此设置利用了libsvm中的每进程运行时设置，如果启用该设置，则可能无法在多线程上下文中正常工作。
max_iter：int, default=-1	解算器内迭代的硬限制，或-1表示无限制。
decision_function_shape：{‘ovo’, ‘ovr’}, default=’ovr’	是否像所有其他分类器一样返回shape（n_samples，n_classes）的one vs rest（‘ovr’）决策函数，还是返回具有shape（n_samples，n_classes*（n_classes-1）/2）的libsvm的原始one vs one（‘ovo’）决策函数。然而，一对一（“ovo”）通常被用作多类策略。对于二进制分类，忽略该参数。
break_ties：bool, default=False	如果为true，则decision_function_shape=‘ovr’，且类数>2，则predict将根据 decision_function的置信值断开连接，否则返回绑定类中的第一个类。请注意，与简单的预测相比，打破联系的计算成本相对较高。
random_state：int, RandomState instance or None, default=None	控制伪随机数的生成，以对概率估计的数据进行洗牌。概率为假时忽略。在多个函数调用之间传递一个int以获得可复制的输出。

属性	解释
class_weight_：ndarray of shape (n_classes,)	每个类的参数C的乘数。基于class_weight参数计算。
classes_：ndarray of shape (n_classes,)	类标签。
coef_：ndarray of shape (n_classes * (n_classes - 1) / 2, n_features)	分配给特征的权重（原始问题中的系数）。这只在线性核的情况下可用。
dual_coef_：ndarray of shape (n_classes -1, n_SV)	决策函数中支持向量的对偶系数（见数学公式），乘以其目标。对于多类，所有1-vs-1分类器的系数。在多类情况下，系数的布局有点不平凡。
fit_status_：int	如果正确拟合，则为0，否则为1（将发出警告）
intercept_：ndarray of shape (n_classes * (n_classes - 1) / 2,)	决策函数中的常数。
support_：ndarray of shape (n_SV)	支持向量指数。
support_vectors_：ndarray of shape (n_SV, n_features)	支持向量。
n_support_：ndarray of shape (n_classes,), dtype=int32	每个类的支持向量数。
probA_：ndarray of shape (n_classes * (n_classes - 1) / 2)
probB_：ndarray of shape (n_classes * (n_classes - 1) / 2)	如果probability=True则它对应于在Platt标度中学习的参数，以根据决策值生成概率估计值。如果probability=False，则为空数组。Platt scaling使用逻辑函数1 / (1 + exp(decision_value * probA_ + probB_))，其中probA_和 probB_从数据集学习
shape_fit_：tuple of int of shape (n_dimensions_of_X,)	训练向量X的数组维数。

方法	解释
decision_function(X)	计算X中样本的决策函数。
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回给定测试数据和标签的平均精度。
set_params(**params)	设置此估计器的参数。

例子：

>>> import numpy as np
>>> from sklearn.pipeline import make_pipeline
>>> from sklearn.preprocessing import StandardScaler
>>> X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
>>> y = np.array([1, 1, 2, 2])
>>> from sklearn.svm import SVC
>>> clf = make_pipeline(StandardScaler(), SVC(gamma='auto'))
>>> clf.fit(X, y)
Pipeline(steps=[('standardscaler', StandardScaler()),
                ('svc', SVC(gamma='auto'))])
>>>
>>> print(clf.predict([[-0.8, -1]]))
[1]

sklearn.svm.NuSVC

参数	解释
nu：float, default=0.5	边距误差分数的上限（参见用户指南）和支持向量分数的下限。应在间隔(0, 1]内。
kernel：{‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’}, default=’rbf’	指定要在算法中使用的内核类型。它必须是“linear”、“poly”、“rbf”、“sigmoid”、“precomputed”或callable之一。如果没有给出，则使用“rbf”。如果给定了一个可调用函数，它将用于根据数据矩阵预先计算内核矩阵；该矩阵应该是一个形状数组(n_samples, n_samples)。
degree：float, default=3	polynomial 核的次数。其他内核忽略此参数。
gamma：{‘scale’, ‘auto’} or float, default=’scale’	“rbf”、“poly”和“sigmoid”的核系数。如果gamma=‘scale’ (默认)那么使用 1 / (n_features * X.var()) 作为gamma的值；若为 ‘auto’, 使用1 / n_features.
coef0：float, default=0.0	核函数中的截距项。只有‘poly’ 和“sigmoid”才有意义。
shrinking：bool, default=True	是否使用收缩启发式。
probability：bool, default=False	是否启用概率估计。这必须在调用fit之前启用，这将减慢该方法的速度，因为它内部使用5倍交叉验证，并且predict_proba可能与predict不一致。
tol：float, default=1e-3	停止训练的标准
cache_size：float, default=200	指定内核缓存的大小（以MB为单位）。
class_weight：dict or ‘balanced’, default=None	对于SVC，将i类的参数C设置为class_weight[i]*C，如果没有给出，所有的类都应该有一个权重。 “balanced”模式使用y值自动调整权重，使其与输入数据中的类频率成反比，即n_samples / (n_classes * np.bincount(y))
verbose：bool, default=False	启用详细输出。请注意，此设置利用了libsvm中的每进程运行时设置，如果启用该设置，则可能无法在多线程上下文中正常工作。
max_iter：int, default=-1	解算器内迭代的硬限制，或-1表示无限制。
decision_function_shape：{‘ovo’, ‘ovr’}, default=’ovr’	是否像所有其他分类器一样返回shape（n_samples，n_classes）的one vs rest（‘ovr’）决策函数，还是返回具有shape（n_samples，n_classes*（n_classes-1）/2）的libsvm的原始one vs one（‘ovo’）决策函数。然而，一对一（“ovo”）通常被用作多类策略。对于二进制分类，忽略该参数。
break_ties：bool, default=False	如果为true，则decision_function_shape=‘ovr’，且类数>2，则predict将根据 decision_function的置信值断开连接，否则返回绑定类中的第一个类。请注意，与简单的预测相比，打破联系的计算成本相对较高。
random_state：int, RandomState instance or None, default=None	控制伪随机数的生成，以对概率估计的数据进行洗牌。概率为假时忽略。在多个函数调用之间传递一个int以获得可复制的输出。

属性	解释
class_weight_：ndarray of shape (n_classes,)	每个类的参数C的乘数。基于class_weight参数计算。
classes_：ndarray of shape (n_classes,)	类标签。
coef_：ndarray of shape (n_classes * (n_classes - 1) / 2, n_features)	分配给特征的权重（原始问题中的系数）。这只在线性核的情况下可用。
dual_coef_：ndarray of shape (n_classes -1, n_SV)	决策函数中支持向量的对偶系数（见数学公式），乘以其目标。对于多类，所有1-vs-1分类器的系数。在多类情况下，系数的布局有点不平凡。
fit_status_：int	如果正确拟合，则为0，否则为1（将发出警告）
intercept_：ndarray of shape (n_classes * (n_classes - 1) / 2,)	决策函数中的常数。
support_：ndarray of shape (n_SV)	支持向量指数。
support_vectors_：ndarray of shape (n_SV, n_features)	支持向量。
n_support_：ndarray of shape (n_classes,), dtype=int32	每个类的支持向量数。
probA_：ndarray of shape (n_classes * (n_classes - 1) / 2)
probB_：ndarray of shape (n_classes * (n_classes - 1) / 2)	如果probability=True则它对应于在Platt标度中学习的参数，以根据决策值生成概率估计值。如果probability=False，则为空数组。Platt scaling使用逻辑函数1 / (1 + exp(decision_value * probA_ + probB_))，其中probA_和 probB_从数据集学习
shape_fit_：tuple of int of shape (n_dimensions_of_X,)	训练向量X的数组维数。

方法	解释
decision_function(X)	计算X中样本的决策函数。
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回给定测试数据和标签的平均精度。
set_params(**params)	设置此估计器的参数。

例子：

>>> import numpy as np
>>> X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
>>> y = np.array([1, 1, 2, 2])
>>> from sklearn.pipeline import make_pipeline
>>> from sklearn.preprocessing import StandardScaler
>>> from sklearn.svm import NuSVC
>>> clf = make_pipeline(StandardScaler(), NuSVC())
>>> clf.fit(X, y)
Pipeline(steps=[('standardscaler', StandardScaler()), ('nusvc', NuSVC())])
>>> print(clf.predict([[-0.8, -1]]))
[1]

sklearn.svm.LinearSVC

参数	解释
penalty：{‘l1’, ‘l2’}, default=’l2’	指定惩罚中使用的规范。“l2”惩罚是SVC中使用的标准。“l1”导致系数向量稀疏。
loss：{‘hinge’, ‘squared_hinge’}, default=’squared_hinge’	指定损失函数。“hinge”是标准SVM损耗（例如SVC类使用），而“squared_hinge”是hinge loss的平方。不支持penalty='l1’和loss='hinge’的组合。
dual：bool, default=True	选择求解对偶优化问题或原始优化问题的算法。当n_samples>n_features时，最好dual=False。
tol：float, default=1e-4	停止训练的标准
C：float, default=1.0	正则化参数。正则化的强度与C成反比。必须严格正。
multi_class：{‘ovr’, ‘crammer_singer’}, default=’ovr’	如果y包含两个以上的类，则确定多类策略。"ovr"训练n_classes一对rest分类器，而“crammer_singer”优化所有类的联合目标。虽然crammer_singer从理论角度来看是有趣的，因为它是一致的，但很少在实践中使用，因为它很少导致更好的精度和更昂贵的计算。如果选择了“crammer_singer”，那么loss, penalty和dual将被忽略。
fit_intercept：bool, default=True	是否计算此模型的截距。如果设置为false，则在计算中不会使用截距（即数据应该已经居中）。
intercept_scaling：float, default=1	什么时候self.fit_intercept如果为True，实例向量x变为[x, self.intercept_scaling]也就是说，在实例向量中附加一个常值等于截距缩放的“synthetic”特征。intercept 变为 intercept_scaling * synthetic特征权重注释！合成特征权重和所有其他特征一样，都要经过l1/l2正则化。为了减少正则化对合成特征权重（因此对截距）的影响，必须增加 intercept_scaling。
class_weight：dict or ‘balanced’, default=None	对于SVC，将i类的参数C设置为class_weight[i]*C，如果没有给出，所有的类都应该有一个权重。 “balanced”模式使用y值自动调整权重，使其与输入数据中的类频率成反比，即n_samples / (n_classes * np.bincount(y))
verbose：bool, default=False	启用详细输出。请注意，此设置利用了libsvm中的每进程运行时设置，如果启用该设置，则可能无法在多线程上下文中正常工作。
random_state：int, RandomState instance or None, default=None	控制伪随机数的生成，以对概率估计的数据进行洗牌。概率为假时忽略。在多个函数调用之间传递一个int以获得可复制的输出。
max_iter：int, default=1000	解算器内迭代的硬限制

属性	解释