LinearSVC:支持向量机线性分类LINEARSVC模型

class pyspark.ml.classification.LinearSVC(featuresCol=‘features’, labelCol=‘label’, predictionCol=‘prediction’, maxIter=100, regParam=0.0, tol=1e-06, rawPredictionCol=‘rawPrediction’, fitIntercept=True, standardization=True, threshold=0.0, weightCol=None, aggregationDepth=2)

这个二元分类器使用 OWLQN 优化器优化铰链损失。目前只支持 L2 正则化(当前版本2.4.5)

maxIter = Param(parent=‘undefined’, name=‘maxIter’, doc=‘最大迭代次数 (>= 0).’)

predictionCol = Param(parent=‘undefined’, name=‘predictionCol’, doc=‘预测列名.’)

regParam = Param(parent=‘undefined’, name=‘regParam’, doc=‘正则化参数 (>= 0).’)

tol = Param(parent=‘undefined’, name=‘tol’, doc=‘迭代算法的收敛容差 (>= 0).’)

rawPredictionCol= Param(parent=‘undefined’, name=‘rawPredictionCol’, doc=‘原始预测(a.k.a. confidence) column name.’)*

fitIntercept = Param(parent=‘undefined’, name=‘fitIntercept’, doc=‘是否适合截取项。’)

standardization = Param(parent=‘undefined’, name=‘standardization’, doc=‘在拟合模型之前是否对训练特征进行标准化。’)

threshold = Param(parent=‘undefined’, name=‘threshold’, doc=‘二进制分类中应用于线性模型预测的阈值。这个阈值可以是任何实数，其中 Inf 将使所有预测为 0.0，-Inf 将 做出所有预测 1.0。’）

weightCol = Param(parent=‘undefined’, name=‘weightCol’, doc=‘weight 列名。如果未设置或为空，我们将所有实例权重视为 1.0。’)

aggregationDepth = Param(parent=‘undefined’, name=‘aggregationDepth’, doc=‘树聚合 (>= 2) 的建议深度。’)

model.coefficients:线性 SVM 分类器的模型系数

model.numClasses:类数（标签可以采用的值）

model.numFeatures:返回模型训练的特征数量。如果未知，则返回 -1

01.创建数据集

from pyspark.sql import SparkSession
from pyspark.sql.types import Row
from pyspark.ml.linalg import Vectors
spark = SparkSession.builder.appName("LinearSVC")\
    .master("local[*]").getOrCreate()
sc = spark.sparkContext
df = sc.parallelize([
    Row(label=1.0, features=Vectors.dense(1.0, 1.0, 1.0)),
    Row(label=0.0, features=Vectors.dense(1.0, 2.0, 3.0))
]).toDF()
df.show()

​ 输出结果：

+-------------+-----+
|     features|label|
+-------------+-----+
|[1.0,1.0,1.0]|  1.0|
|[1.0,2.0,3.0]|  0.0|
+-------------+-----+

02.使用LinearSVC转换

from pyspark.ml.classification import LinearSVC
svm = LinearSVC(maxIter=5, regParam=0.01)
model = svm.fit(df)
model.transform(df).show()
model.transform(df).head(3)

​ 输出结果：

+-------------+-----+--------------------+----------+
|     features|label|       rawPrediction|prediction|
+-------------+-----+--------------------+----------+
|[1.0,1.0,1.0]|  1.0|[-0.5581623056159...|       1.0|
|[1.0,2.0,3.0]|  0.0|[0.08756571302736...|       0.0|
+-------------+-----+--------------------+----------+
[Row(features=DenseVector([1.0, 1.0, 1.0]), label=1.0, rawPrediction=DenseVector([-0.5582, 0.5582]), prediction=1.0),
 Row(features=DenseVector([1.0, 2.0, 3.0]), label=0.0, rawPrediction=DenseVector([0.0876, -0.0876]), prediction=0.0)]

03.线性 SVM 分类器的模型系数

model.coefficients

​ 输出结果：DenseVector([0.0, -0.2792, -0.1833])

04.类数（标签可以采用的值）

model.numClasses

​ 输出结果：2

05.模型训练的特征数量

model.numFeatures

​ 输出结果：3

06.生成数据进行预测

test0 = sc.parallelize([Row(features=Vectors.dense(-1.0, -1.0, -1.0))]).toDF()
result = model.transform(test0).head()
result.prediction

​ 输出结果：1.0

07.查看原始预测

result.rawPrediction

​ 输出结果：DenseVector([-1.4831, 1.4831])

原理

线性支持向量机原始最优化问题：
$$min:\frac{1}{2}\parallel w{\parallel }^2+C\sum _{i=1}^N{\xi }_i$$
$$s.t.y_i(w\bullet x_i+b)\ge 1-{\xi }_i,i=1,2,\cdots ,N$$
$${\xi }_i\ge 0,i=1,2,\cdots ,N$$
等价于最优化问题：
$$min:C\sum _{i=1}^{N}max(0,[1-y_i(w\bullet x_i+b)])+\frac{1}{2}\parallel w{\parallel }^2$$
第一项为合页损失函数，C为正则化系数的倒数–惩罚系数。

sklearn实现

模型：
sklearn.svm.linearSVC(penalty=‘l2’, loss=‘squared_hinge’, *, dual=True, tol=0.0001, C=1.0, multi_class=‘ovr’, fit_intercept=True, intercept_scaling=1, class_weight=None, verbose=0, random_state=None, max_iter=1000)
主要参数：

1. penalty：{‘l1’, ‘l2’}, default=’l2’，正则化方法
2. loss：{‘hinge’, ‘squared_hinge’}, default=’squared_hinge’，即hinge的平方
3. dual：bool, default=True，Prefer dual=False when n_samples > n_features.
4. C：float, default=1.0，The strength of the regularization is inversely proportional to C.
5. max_iter：int, default=1000，The maximum number of iterations to be run.

主要方法：

1. decision_function(X):输入数据，输出置信水平
2. fit(X_train,y_train):拟合模型
3. score(X_test,y_test):输出结果

二元分类

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import  train_test_split
import matplotlib.pyplot as plt
%matplotlib notebook
def create_data():  #处理鸢尾花数据，获取前两项特征与标签进行分类
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df['label'] = iris.target
    df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']
    data = np.array(df.iloc[:100, [0, 1, -1]])
    for i in range(len(data)):
        if data[i,-1] == 0:
            data[i,-1] = -1
    # print(data)
    return data[:,:2], data[:,-1]
X, y = create_data()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
plt.scatter(X[:50,0],X[:50,1], label='0')
plt.scatter(X[50:,0],X[50:,1], label='1')
plt.legend()

<IPython.core.display.Javascript object>

<matplotlib.legend.Legend at 0x228908ddac8>

from sklearn.svm import LinearSVC
model = LinearSVC()
model.fit(X_train,y_train)
model.score(X_test,y_test)

1.0

#绘制分类曲线
w = model.coef_   
b = model.intercept_
plt.scatter(X[:50,0],X[:50,1], label='0')
plt.scatter(X[50:,0],X[50:,1], label='1')
x = np.linspace(3.0,8.0,20)
y = -w[0][0]*x/w[0][1]-b/w[0][1]
plt.plot(x,y)
plt.legend()

<IPython.core.display.Javascript object>

<matplotlib.legend.Legend at 0x22890494fd0>

多元分类–采用one vs rest方法

from sklearn.datasets import load_iris
import pandas as pd
iris = load_iris()
X = iris.data
y = iris.target
feature_names = iris.feature_names
data = pd.DataFrame(X,columns=feature_names)
data['labels'] = y
data

150 rows × 5 columns

from sklearn.svm import LinearSVC
model = LinearSVC(penalty='l2',loss='hinge',C=5.0,max_iter=1000)
model

LinearSVC(C=5.0, class_weight=None, dual=True, fit_intercept=True,
     intercept_scaling=1, loss='hinge', max_iter=1000, multi_class='ovr',
     penalty='l2', random_state=None, tol=0.0001, verbose=0)

#利用支持向量机进行多元分类，求得3个二元分类模型
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3)
model.fit(X_train,y_train)   
model.score(X_test,y_test)

0.91111111111111109

model.coef_   #求得参数w(3*4)

array([[ 0.09122994,  0.68795258, -0.89771321, -0.46878047],
       [ 0.63845111, -2.53659412,  0.56076395, -2.09711552],
       [-0.93766893, -1.60206571,  1.61178485,  3.44670505]])

model.intercept_  #参数b,截距

array([ 0.02498646,  3.58805562, -2.9032515 ])

print(model.decision_function(X_test))  #类别预测的置信水平,选取值最大的类别进行预测
y_test

[[  7.10150829e-01   7.26777649e-01  -7.67818099e+00]
 [ -2.63877237e+00   1.34370998e+00   1.81745975e-01]
 [  1.61727503e+00  -2.58289007e+00  -1.03215239e+01]
 [ -1.91526895e+00  -2.76549708e-01  -1.98082316e+00]
 [ -3.19493369e+00  -1.71267056e+00   1.95280407e+00]
 [ -2.01050042e+00  -3.60258900e-01  -2.19276841e+00]
 [ -2.51660439e+00  -1.27416100e+00   6.05174156e-01]
 [ -4.29851520e+00   9.64553122e-01   3.08328234e+00]
 [ -1.69251111e+00  -1.03050471e-01  -2.18095999e+00]
 [  1.50066057e+00  -1.87798823e+00  -1.00020827e+01]
 [ -1.75373537e+00   1.57268128e+00  -1.70777554e+00]
 [ -2.27403231e+00   4.99195848e-01  -1.39738111e+00]
 [ -3.69443294e+00   1.00181579e+00   2.36162361e+00]
 [  2.06559741e+00  -3.18851211e+00  -1.18432668e+01]
 [ -2.09932222e+00  -1.48025719e+00  -1.00726573e+00]
 [  1.13697130e+00  -9.16788189e-01  -9.07591398e+00]
 [ -2.09122537e+00   7.82175918e-01  -8.17325781e-01]
 [ -1.86566083e+00   3.05463735e-03  -2.13893179e+00]
 [  1.07090611e+00  -5.93235984e-01  -8.72914554e+00]
 [  1.60721089e+00  -1.98578120e+00  -1.04131929e+01]
 [ -3.70431871e+00  -1.99146410e+00   2.17055764e+00]
 [ -3.55621482e+00  -1.23301770e+00   3.12680656e+00]
 [  1.37984905e+00  -1.42238598e+00  -9.93160127e+00]
 [ -2.14042657e+00  -4.83622474e-01  -1.18963172e+00]
 [ -2.64474161e+00  -6.66677804e-01   1.60943687e+00]
 [  1.62272680e+00  -1.92798377e+00  -1.07872886e+01]
 [ -2.29899315e+00  -1.73886667e-01  -8.68246668e-01]
 [  1.06544596e+00  -7.33021571e-01  -9.10226928e+00]
 [ -1.93257380e+00  -1.06519391e+00  -1.60785352e+00]
 [  1.01489669e+00  -3.51671937e-01  -9.12959650e+00]
 [ -3.76293090e+00  -5.08358729e-01   2.82980981e+00]
 [ -3.38338703e+00  -1.89056278e+00   3.14605024e+00]
 [  2.03790650e+00  -3.93148742e+00  -1.15006942e+01]
 [ -1.72407717e+00  -5.43885397e-01  -2.14861910e+00]
 [ -3.48953042e+00  -2.76896386e+00   3.02674585e+00]
 [ -2.38813687e+00  -1.84532494e+00   3.78527906e-01]
 [  1.49247035e+00  -2.08766661e+00  -1.05617683e+01]
 [ -3.21108558e+00   4.72167391e-01   4.02415283e-01]
 [ -4.75628250e+00   9.54890080e-01   4.76006397e+00]
 [ -3.05742817e+00  -6.82355356e-01   2.10153361e+00]
 [ -1.83975047e+00  -4.99937538e-01  -1.64374203e+00]
 [ -1.65202598e+00   1.12708763e-01  -2.24530173e+00]
 [  1.36706321e+00  -1.41029061e+00  -9.37094374e+00]
 [ -1.81059256e+00   4.22444570e-01  -1.92391668e+00]
 [  1.12511823e+00  -1.05052609e+00  -9.16870896e+00]]





array([0, 1, 0, 1, 2, 1, 2, 2, 1, 0, 1, 1, 2, 0, 1, 0, 1, 1, 0, 0, 2, 2, 0,
       1, 2, 0, 1, 0, 1, 0, 2, 2, 0, 1, 2, 1, 0, 2, 2, 2, 1, 1, 0, 1, 0])

上一篇：Logistic回归&线性支持向量机

多分类

许多线性分类模型只适用于二分类问题，不能轻易推广到多类别问题（除了Logistic回归）。将二分类算法推广到多分类算法的一种常见方法是“一对其余”（one-vs.-rest）方法。在“一对其余”方法中，对每个类别都学习一个二分类模型，将这个类别与所有其他类别尽量分开，这样就生成了与类别个数一样多的二分类模型。在测试点上运行所有二类分类器来进行预测。在对应类别上分数最高的分类器“胜出”，将这个类别标签返回作为预测结果。
每个类别都对应一个二类分类器，这样每个类别也都有一个系数（w）向量和一个截距（b）。下面给出的是分类置信方程，其结果中最大值对应的类别即为预测的类别标签：
$$w[0]\ast x[0]+w[1]\ast x[1]+\cdots +w[p]\ast x[p]+b$$
多分类Logistic回归背后的数学与“一对其余”方法稍有不同，但它也是对每个类别都有一个系数向量和一个截距，也使用了相同的预测方法。

实践

我们将“一对其余”方法应用在一个简单的三分类数据集上。我们用到了一个二维数据集，每个类别的数据都是从一个高斯分布中采样得出的：

from sklearn.datasets import make_blobs
import mglearn as mglearn
import matplotlib.pyplot as plt

X, y = make_blobs(random_state=42)
mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
plt.xlabel("Feature 0")
plt.ylabel("Feature 1")
plt.legend(["Class 0", "Class 1", "Class 2"])
plt.show()

![在这里插入图片描述](https://img-blog.csdnimg.cn/14bb4eaaf7b现在，在这个数据集上训练一个LinearSVC分类器：

linear_svm = LinearSVC().fit(X, y)
print("Coefficient_shape: ", linear_svm.coef_.shape)
print("Interceprt_shape: ", linear_svm.intercept_.shape)
=============================================
Coefficient_shape:  (3, 2)
Interceprt_shape:  (3,)

我们看到，coef的形状是(3, 2)，说明coef每行包含三个类别之一的系数向量，每列包含某个特征（这个数据集有2个特征）对应的系数值。现在intercept是一维数组，保存每个类别的截距。
我们将这3个二类分类器给出的直线可视化：

mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
line = np.linspace(-15, 15)
for coef, intercept, color in zip(linear_svm.coef_, linear_svm.intercept_, ['b', 'r', 'g']):
    plt.plot(line, -(line * coef[0] + intercept) / coef[1], c=color)
plt.ylim(-10, 15)
plt.xlim(-10, 8)
plt.xlabel("Feature 0")
plt.ylabel("Feature 1")
plt.legend(
    ["Class 0", "Class 1", "Class 2",
     "Line_class 0", "Line_Class 1", "Line_class 2"],
    loc=(1.01, 0.3))
plt.show()

你可以看到，训练集中：

• 所有属于类别0的点都在与类别0对应的直线上方，这说明它们位于这个二类分类器属于“类别0”的那一侧。
• 属于类别0的点位于与类别2对应的直线上方，这说明它们被类别2的二类分类器划为“其余”。
• 属于类别0的点位于与类别1对应的直线左侧，这说明类别1的二元分类器将它们划为“其余”。
• 因此，这一区域的所有点都会被最终分类器划为类别0（类别0的分类器的分类置信方程的结果大于0，其他两个类别对应的结果都小于0）。

但图像中间的三角形区域属于哪一个类别呢，3个二类分类器都将这一区域内的点划为“其余”。这里的点应该划归到哪一个类别呢？答案是分类方程结果最大的那个类别，即最接近的那条线对应的类别。

下面的例子给出了二维空间中所有区域的预测结果：

# 二维空间所有区域的预测结果
mglearn.plots.plot_2d_classification(linear_svm, X, fill=True, alpha=.7)
mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
line = np.linspace(-15, 15)
for coef, intercept, color in zip(linear_svm.coef_, linear_svm.intercept_, ['b', 'r', 'g']):
    plt.plot(line, -(line * coef[0] + intercept) / coef[1], c=color)

plt.xlabel("Feature 0")
plt.ylabel("Feature 1")
plt.legend(
    ["Class 0", "Class 1", "Class 2",
     "Line_class 0", "Line_Class 1", "Line_class 2"],
    loc=(1.01, 0.3))
plt.show()

完整代码

from sklearn.datasets import make_blobs
from sklearn.svm import LinearSVC
import mglearn as mglearn
import matplotlib.pyplot as plt
import numpy as np

X, y = make_blobs(random_state=42)

# # 包含三个类别的二维玩具数据集
# mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
# plt.xlabel("Feature 0")
# plt.ylabel("Feature 1")
# plt.legend(["Class 0", "Class 1", "Class 2"])
# plt.show()

# 在数据集上训练一个LinearSVC分类器
linear_svm = LinearSVC().fit(X, y)
print("Coefficient_shape: ", linear_svm.coef_.shape)
print("Interceprt_shape: ", linear_svm.intercept_.shape)

# # 把这3个二类分类器给出的直线可视化
# mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
# line = np.linspace(-15, 15)
# for coef, intercept, color in zip(linear_svm.coef_, linear_svm.intercept_, ['b', 'r', 'g']):
#     plt.plot(line, -(line * coef[0] + intercept) / coef[1], c=color)
# plt.ylim(-10, 15)
# plt.xlim(-10, 8)
# plt.xlabel("Feature 0")
# plt.ylabel("Feature 1")
# plt.legend(
#     ["Class 0", "Class 1", "Class 2",
#      "Line_class 0", "Line_Class 1", "Line_class 2"],
#     loc=(1.01, 0.3))
# plt.show()

# 二维空间所有区域的预测结果
mglearn.plots.plot_2d_classification(linear_svm, X, fill=True, alpha=.7)
mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
line = np.linspace(-15, 15)
for coef, intercept, color in zip(linear_svm.coef_, linear_svm.intercept_, ['b', 'r', 'g']):
    plt.plot(line, -(line * coef[0] + intercept) / coef[1], c=color)

plt.xlabel("Feature 0")
plt.ylabel("Feature 1")
plt.legend(
    ["Class 0", "Class 1", "Class 2",
     "Line_class 0", "Line_Class 1", "Line_class 2"],
    loc=(1.01, 0.3))
plt.show()