精华内容
下载资源
问答
  • LinearSVC
    千次阅读
    2020-08-04 09:33:35
    1. LinearSVC与SVC的区别
      LinearSVC

    基于liblinear库实现
    有多种惩罚参数和损失函数可供选择
    训练集实例数量大(大于1万)时也可以很好地进行归一化
    既支持稠密输入矩阵也支持稀疏输入矩阵
    多分类问题采用one-vs-rest方法实现
    SVC

    基于libsvm库实现
    训练时间复杂度为 [公式]
    训练集实例数量大(大于1万)时很难进行归一化
    多分类问题采用one-vs-rest方法实现
    2. LinearSVC详细说明
    LinearSVC实现了线性分类支持向量机,它是给根据liblinear实现的,可以用于二类分类,也可以用于多类分类。其原型为:class 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)

    初始化参数

    C:一个浮点数,惩罚参数
    loss:字符串。表示损失函数。可取值为
    ‘hinge’:合页损失函数;
    ‘squared_hinge’:合页损失函数的平方
    penalty:字符串。可取值为’l1’和’l2’分别对应1范数和2范数
    dual:布尔值。如果为true,则求解对偶问题。如果为false,解决原始问题。当样本数量>特征数量时,倾向采用解原始问题
    tol:浮点数,指定终止迭代的阈值
    multi_class: 字符串,指定多分类问题的策略
    ‘ovr’: 采用one-vs-rest分类策略;
    ‘crammer_singer’: 多类联合分类,很少用。因为它的计算量大,而且精度不会更佳,此时忽略loss,penalty,dual参数
    fit_intercept: 布尔值。如果为true,则计算截距,即决策函数中的常数项;否则忽略截距
    intercept_scaling: 浮点值。如果提供了,则实例X变成向量[X,intercept_scaling]。此时相当于添加了一个人工特征,该特征对所有实例都是常数值
    class_weight: 可以是个字典,或者字符串’balanced’。指定各个类的权重,若未提供,则认为类的权重为1
    如果是字典,则指定每个类标签的权重;
    如果是’balanced’,则每个类的权重是它出现频率的倒数
    verbose: 一个整数,表示是否开启verbose输出
    random_state: 一个整数或者一个RandomState实例,或者None
    如果为整数,则它指定随机数生成器的种子
    如果为RandomState实例,则指定随机数生成器
    如果为None,则使用默认的随机数生成器
    max_iter:一个整数,指定最大的迭代次数
    属性

    coef_: 一个数组,它给出了各个特征的权重
    intercept_:一个数组,它给出了截距,即决策函数中的常数项
    方法

    fix(X,y): 训练模型
    predict(X): 用模型进行预测,返回预测值
    score(X,y[, sample_weight]):返回在(X, y)上预测的准确率

    更多相关内容
  • Construct a linear SVM classifier from the training Samples and Labels
  • Pyspark分类--LinearSVC

    千次阅读 2022-03-11 07:27:00
    LinearSVC:支持向量机线性分类LINEARSVC模型 class pyspark.ml.classification.LinearSVC(featuresCol=‘features’, labelCol=‘label’, predictionCol=‘prediction’, maxIter=100, regParam=0.0, tol=1e-06, ...

    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])

    展开全文
  • 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=...

    原理

    线性支持向量机原始最优化问题:
    m i n : 1 2 ∥ w ∥ 2 + C ∑ i = 1 N ξ i min:\frac{1}{2}\parallel{w}\parallel^{2}+C\sum_{i=1}^{N}\xi_{i} min:21w2+Ci=1Nξi
    s . t .   y i ( w ∙ x i + b ) ≥ 1 − ξ i , i = 1 , 2 , ⋯   , N s.t.\ y_{i}(w\bullet{x_{i}}+b)\ge1-\xi_{i},i=1,2,\cdots,N s.t. yi(wxi+b)1ξi,i=1,2,,N
    ξ i ≥ 0 , i = 1 , 2 , ⋯   , N \xi_{i}\ge0,i=1,2,\cdots,N ξi0,i=1,2,,N
    等价于最优化问题:
    m i n :   C ∑ i = 1 N m a x ( 0 , [ 1 − y i ( w ∙ x i + b ) ] ) + 1 2 ∥ w ∥ 2 min:\ C\sum_{i=1}^{N}max(0,[1-y_{i}(w\bullet{x_{i}}+b)])+\frac{1}{2}\parallel{w}\parallel^{2} min: Ci=1Nmax(0,[1yi(wxi+b)])+21w2
    第一项为合页损失函数,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
    
    sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)labels
    05.13.51.40.20
    14.93.01.40.20
    24.73.21.30.20
    34.63.11.50.20
    45.03.61.40.20
    55.43.91.70.40
    64.63.41.40.30
    75.03.41.50.20
    84.42.91.40.20
    94.93.11.50.10
    105.43.71.50.20
    114.83.41.60.20
    124.83.01.40.10
    134.33.01.10.10
    145.84.01.20.20
    155.74.41.50.40
    165.43.91.30.40
    175.13.51.40.30
    185.73.81.70.30
    195.13.81.50.30
    205.43.41.70.20
    215.13.71.50.40
    224.63.61.00.20
    235.13.31.70.50
    244.83.41.90.20
    255.03.01.60.20
    265.03.41.60.40
    275.23.51.50.20
    285.23.41.40.20
    294.73.21.60.20
    ..................
    1206.93.25.72.32
    1215.62.84.92.02
    1227.72.86.72.02
    1236.32.74.91.82
    1246.73.35.72.12
    1257.23.26.01.82
    1266.22.84.81.82
    1276.13.04.91.82
    1286.42.85.62.12
    1297.23.05.81.62
    1307.42.86.11.92
    1317.93.86.42.02
    1326.42.85.62.22
    1336.32.85.11.52
    1346.12.65.61.42
    1357.73.06.12.32
    1366.33.45.62.42
    1376.43.15.51.82
    1386.03.04.81.82
    1396.93.15.42.12
    1406.73.15.62.42
    1416.93.15.12.32
    1425.82.75.11.92
    1436.83.25.92.32
    1446.73.35.72.52
    1456.73.05.22.32
    1466.32.55.01.92
    1476.53.05.22.02
    1486.23.45.42.32
    1495.93.05.11.82

    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])
    
    展开全文
  • "Class 2"]) # plt.show() # 在数据集上训练一个LinearSVC分类器 linear_svm = LinearSVC().fit(X, y) print("Coefficient_shape: ", linear_svm.coef_.shape) print("Interceprt_shape: ", linear_svm.intercept_....

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

    多分类

    许多线性分类模型只适用于二分类问题,不能轻易推广到多类别问题(除了Logistic回归)。将二分类算法推广到多分类算法的一种常见方法是“一对其余”(one-vs.-rest)方法。在“一对其余”方法中,对每个类别都学习一个二分类模型,将这个类别与所有其他类别尽量分开,这样就生成了与类别个数一样多的二分类模型。在测试点上运行所有二类分类器来进行预测。在对应类别上分数最高的分类器“胜出”,将这个类别标签返回作为预测结果。
    每个类别都对应一个二类分类器,这样每个类别也都有一个系数(w)向量和一个截距(b)。下面给出的是分类置信方程,其结果中最大值对应的类别即为预测的类别标签:
    w [ 0 ] ∗ x [ 0 ] + w [ 1 ] ∗ x [ 1 ] + ⋯ + w [ p ] ∗ x [ p ] + b w[0] * x[0] + w[1] * x[1] + \cdots + w[p] * x[p] + b w[0]x[0]+w[1]x[1]++w[p]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()
    
    
    展开全文
  • 换句话说,如果参数 C 值较大,那么 LogisticRegression 和 LinearSVC 将尽可能将训练集拟合到最好,而如果 C 值较小,那么模型更强调使系数向量 (w)接近于 0。 参数 C 还有另一个作用。较小的 C 值可以让算法尽量...
  • LinearSVC与SVC的区别

    千次阅读 2020-12-17 23:45:45
    LinearSVC 基于liblinear库实现 有多种惩罚参数和损失函数可供选择 训练集实例数量大(大于1万)时也可以很好地进行归一化 既支持稠密输入矩阵也支持稀疏输入矩阵 多分类问题采用one-vs-rest方法实现 SVC 基于libsvm...
  • 当我尝试使用我的数据运行以下代码时(从this example开始)X_new = LinearSVC(C=0.01, penalty="l1", dual=False).fit_transform(X, y)我明白了:"Invalid threshold: all features are discarded"我尝试指定自己的...
  • How can I get the probability estimates of predictions from a sklearn.svm.LinearSVC model in similar fashion to sklearn.svm.SVC's probability=True option that allows predict_proba() I need to avoid th...
  • SVM有监督学习LinearSVC, LinearSVR,SVC,SVR -- 024

    千次阅读 多人点赞 2020-03-21 09:00:00
    微信公众号:python宝关注可了解更多的python相关知识。若有问题或建议,请公众号留言;内容目录一、支持向量机 SVM 简介二、LinearSVC...
  • vs one scheme while LinearSVC uses one vs the rest. It is possible to implement one vs the rest with SVC by using the :class:`sklearn.multiclass.OneVsRestClassifier` wrapper. Finally SVC can fit ...
  • test_split from sklearn.preprocessing import StandardScaler from sklearn.svm import LinearSVC from sklearn.metrics import classification_report ''' 支持向量机 根据训练样本的分布,搜索所有可能的线性...
  • LinearSVC:该算法使用了支撑向量机的思想; 数据标准化 from sklearn.preprocessing import StandardScaler standardScaler = StandardScaler() standardScaler.fit(X) X_standard = standardScaler....
  • 参考文章:【学习笔记】【LinearSVC】 参考文章:https://cloud.tencent.com/developer/ask/49387 参考内容:scikit-learn提供了可以用来解决这个问题的CalibratedClassifierCV:它允许将概率输出添加到LinearSVC或...
  • 支持向量机(SVC,NuSVC,LinearSVC

    千次阅读 2019-07-30 19:04:29
    首先我们来看看SVC,NvSVC,LinearSVC的区别和样例 SVC(C-Support Vector Classification): 支持向量分类,基于libsvm实现的(libsvm详情参考 或者百科),数据拟合的时间复杂度是数据样本的二次方,这使得他很...
  • LinearSVC() 与 SVC(kernel='linear') 的区别概括如下:LinearSVC() 最小化 hinge loss的平方,SVC(kernel='linear') 最小化 hinge loss;LinearSVC() 使用 one-vs-rest 处理多类问题,SVC(kernel='linear') 使用 ...
  • 在线性可分离数据集上训练“LinearSVC”。然后在同一个数据集上训练一个“SVC”和一个“sgdclassizer”。 导入数据: from sklearn import datasets iris = datasets.load_iris() X = iris["data"][:, (2, 3)] # ...
  • 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...
  • 首先创建可以分离的样本数据集(假定二分类),然后使用sklearn所提供的线性支持向量机(LinearSVC)方法对其进行分类,求取一个支持向量集并绘图 import numpy as np import matplotlib.pyplot as plt from sklearn...
  • sklearn.svm.LinearSVC与sklearn.svm.SVC区别

    千次阅读 2020-04-02 22:05:06
    1.LinearSVC与SVC的区别 LinearSVC 基于liblinear库实现 有多种惩罚参数和损失函数可供选择 训练集实例数量大(大于1万)时也可以很好地进行归一化 既支持稠密输入矩阵也支持稀疏输入矩阵 多分类问题采用one-vs-...
  • test_LinearSVC_loss(X_train,X_test,y_train,y_test) def test_LinearSVC_L12(* data): ''' 测试 LinearSVC 的预测性能随正则化形式的影响 ''' X_train,X_test,y_train,y_test = data L12 =[ ' ...
  • 使用linearsvc.predict_proba()报了这个错误,可以使用 svmPreds=svm_classifier.decision_function(vectorised_test_documents) 这个来替代
  • sklearn svm.LinearSVC的参数说明

    万次阅读 多人点赞 2018-07-27 14:29:11
    Sklearn.svm.LinearSVC参数说明 与参数kernel ='linear'的SVC类似,但是以liblinear而不是libsvm的形式实现,因此它在惩罚和损失函数的选择方面具有更大的灵活性,并且应该更好地扩展到大量样本。 此类支持密集和...
  • 获取线性支持向量机LinearSVC模型的重要特征 模型训练之后,想要得到比较重要的特征,可以通过python的sklearn包来实现。 python实现代码如下所示:  LinearSVC.py # -*- coding: utf-8 -*- import IOUtil ...
  • 其实sklearn中产生数据、训练数据、预测结果都非常的简单。 就是打印这个决策边界有些麻烦,自己写了个函数,就是用...from sklearn.svm import LinearSVC from sklearn.svm import NuSVC from sklearn import ...
  • sklearn.svm.LinearSVC

    千次阅读 2019-07-14 10:41:11
    classsklearn.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=Non...
  • 参考代码manoveg/ML_with_python​github.com数据来源https://github.com/gaussic/text-classification-cnn-rnn​github.comimport pandas as pdcontents, labels = [], []with open("C:/R_Py/Jupyter/text-...
  • Hard Margin SVM from sklearn.svm import LinearSVC # 当C无限大时,ζ约为 0,此时就是Hard Margin SVM svc = LinearSVC(C=1e9) svc.fit(X_standard,y)C 绘制图像 def plot_svc_decision_boundary(model, axis): ...
  • from sklearn.svm import LinearSVC from sklearn import metrics from sklearn.model_selection import KFold import csv import numpy as np csv_file = r"F:\train.csv" test_file = r"F:\test.csv" def load_...
  • 【学习笔记】【LinearSVC

    千次阅读 2019-08-31 15:43:56
    如何将LinearSVC的决策函数转换为概率? 参考文章:https://cloud.tencent.com/developer/ask/49387 参考内容:scikit-learn提供了可以用来解决这个问题的CalibratedClassifierCV:它允许将概率输出添加到LinearSVC...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,169
精华内容 2,067
关键字:

LinearSVC