【SVM】soft margin SVM 代码以及详解

于 2021-05-16 22:29:32 发布
阅读量819 收藏 4
点赞数
分类专栏： python 机器学习 文章标签： 支持向量机 深度学习 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/miracleoa/article/details/116903573
版权
该博客介绍了如何使用Python实现支持向量机（SVM）的软间隔分类，并详细阐述了线性核函数、多项式核函数和高斯核函数的使用。代码包括数据预处理、优化问题设置、支持向量计算、模型训练和预测等功能，展示了SVM在二分类问题中的应用。
摘要由CSDN通过智能技术生成

文章目录

导包

import matplotlib.pyplot as plt
import numpy as np
import scipy as sp
import cvxopt
from cvxopt import matrix
from cvxopt import solvers
from numpy import linalg

10-------------------------------------------------

Make the function H = make_H_k(X,t, kernel_function, param) to compute the matrix H H H for a data matrix X and an associated target vector t given a kernel function kernel_function with parameter param.


def make_H_k(X, t, kernel_function, param):
    n_samples, n_feature = X.shape
    X_prime = np.zeros((n_samples, n_samples))
    for i in range(n_samples):
        for j in range(n_samples):
            X_prime[i, j] = kernel_function(X[i], X[j], param)
    H = np.outer(t, t) * X_prime
    return H

- 在这一个步骤，kernel_function可以为线性核函数（对应教案中的例子），多项式核函数（对应soft margin SVM），和高斯核函数。这里核函数的输入 x i , x j ∈ X x_i, x_j \in{X} xi​,xj​∈X，

11-------------------------------------------------

Make the function P, q, G, h, A, b = setup_optimization_soft_k(X, t, C, kernel_function, param) to compute the necessary matrices to solve the QP problem associated to the soft margin kernelized classification task using the library cvxopt. The function receives in input a data matrix X, an associated target vector t, a regularization parameter C and a kernel function kernel_function with parameter param.

def setup_optimization_soft_k(X, t, C, kernel_function, param):
    m, n = X.shape
    t = t.reshape(-1, 1).astype(float)
    H = make_H_k(X, t, kernel_function, param)
    P = matrix(H)
    q = matrix(-np.ones((m, 1)))
    G = matrix(np.vstack((-np.eye(m), np.eye(m))))
    h = matrix(np.hstack((np.zeros(m), np.ones(m) * C)))
    A = matrix(t.reshape(1, -1))
    b = matrix(np.zeros(1))

    return P, q, G, h, A, b

- 此处未作更改

12-------------------------------------------------

Make the function support_vectors, support_targets, support_alphas, support_ids = compute_support_vectors(X,t,alphas) to compute:

  • support_vectors the support vectors
  • support_targets the target vector associated to the support vectors
  • support_alphas the vector of the dual variables α i \alpha_i αi​ associated to the support vectors
  • support_ids a boolean vector that indicates if a position is associated to a support vector (w.r.t. the original data matrix) (i.e. if the first instance is a support vector and the second one it is not, then support_ids = [True, False])

def compute_support_vectors(X, t, alphas):
    t = t.reshape(-1, 1).astype(float)
    support_ids = (alphas > 1e-4).flatten()
    support_vectors = X[support_ids]
    support_targets = t[support_ids]
    support_alphas = alphas[support_ids]
    return support_vectors, support_targets, support_alphas, support_ids

- 此处未作更改

13-------------------------------------------------

Make the function model = train_slmkc(X, t, C, kernel_function, param) to compute the necessary elements to represent a kernelized soft large margin classifier trained over an input data matrix X with an associated target vector t, for a regularization parameter C and a kernel function kernel_function with parameter param.

Note: you may implement model as a tuple containing information on the support vectors and the dual variables, i.e. model = (support_vectors,support_targets,support_alphas, support_ids).


def train_slmkc(X, t, C, kernel_function, param):
    P, q, G, h, A, b = setup_optimization_soft_k(X, t, C, kernel_function, param)

    # Setting solver parameters (change default to decrease tolerance)
    solvers.options['show_progress'] = False
    solvers.options['abstol'] = 1e-10
    solvers.options['reltol'] = 1e-10
    solvers.options['feastol'] = 1e-10

    # Run solver
    solution_dict = solvers.qp(P, q, G, h, A, b)
    alphas = np.array(solution_dict['x'])

    support_vectors, support_targets, support_alphas, support_ids = compute_support_vectors(X, t, alphas)

    model = (support_vectors, support_targets, support_alphas, support_ids)

    return model

- 此处未作更改

14-------------------------------------------------

Given the kernelized soft large margin discriminant function of the form:
y ( x ) = ∑ n ∈ S V α n t n K ( x n , x ) + b y(x) = \sum_{n \in SV} \alpha_n t_n K(x_n,x) + b y(x)=n∈SV∑​αn​tn​K(xn​,x)+b

and given the encoded model to represent the necessary elements for a trained kernelized soft large margin classifier

make the function b = compute_bias(kernel_function, param, C, model) to compute the offset/bias term b, for a regularization parameter C and a kernel function kernel_function with parameter param.

def compute_bias(kernel_function, param, C, model):
    support_vectors, support_targets, support_alphas, support_ids = model
    if param == None:
        w = ((support_targets * support_alphas).T @ support_vectors).reshape(-1, 1)
        b = np.mean(support_targets - np.dot(support_vectors, w))
    else:
        w = None
        b = 0
        for n in range(len(support_targets)):
            b += support_targets[n]
            b -= np.sum(
                support_alphas * support_targets * kernel_function(support_ids[n], support_alphas, param))
        b /= len(support_alphas)
    return w, b

- 此处b的计算为重点，对于线性核函数，与教案中计算公式相同。对于非线性核函数或者高斯核函数，应该对上方公式移项，得下方公式计算b值，w值为None，上方因此没有给出w得计算公式。

b = y ( x ) − ∑ n ∈ S V α n t n K ( x n , x ) b = y(x) - \sum_{n \in SV} \alpha_n t_n K(x_n,x) b=y(x)−n∈SV∑​αn​tn​K(xn​,x)

15-------------------------------------------------

Make the function scores = score_slmkc(X_test, kernel_function, param, C, model) to compute the scores for the kernelized soft large margin discriminant function over the data matrix X_test, for a regularization parameter C, a kernel function kernel_function with parameter param and an encoded model model.

def score_slmkc(X_test, kernel_function, param, C, model):
    w, b = compute_bias(kernel_function, param, C, model)
    if param == None:
        scores = np.dot(X_test, w) + b
        return scores.flatten()
    else:
        support_vectors, support_targets, support_alphas, support_ids = model
        X = X_test
        y_predict = np.zeros(len(X))
        for i in range(len(X)):
            s = 0
            for a, sv_y, sv in zip(support_alphas, support_targets, support_vectors):
                s += a * sv_y * kernel_function(X[i], sv, param)
            y_predict[i] = s
        return y_predict + b

分为线性与非线性情况，线性下，与教案相同，非线性下，如上述代码所示

16-------------------------------------------------

Make the function preds = test_slmkc(X_test, kernel_function, param, C, model) to predict the class label for the kernelized soft large margin discriminant function over the data matrix X_test, for a regularization parameter C, a kernel function kernel_function with parameter param and an encoded model model.

def test_slmkc(X_test, kernel_function, param, C, model):
    preds = np.sign(score_slmkc(X_test, kernel_function, param, C, model)).astype(int)
    return preds.flatten()

# this function is provided to you, you do not need to alter it in any way.
class MySoftLargeMarginKernelClassfier(object):
    def __init__(self, C, kernel_function, param):
        self.kernel_function = kernel_function
        self.param = param
        self.C = C
        self.support_vectors = None
        self.support_targets = None
        self.support_alphas = None
        self.support_ids = None

    def fit(self, X_train, y_train):
        self.model = train_slmkc(X_train, y_train, self.C, self.kernel_function, self.param)
        self.support_vectors, self.support_targets, self.support_alphas, self.support_ids = self.model
        return self

    def predict(self, X_test):
        return test_slmkc(X_test, self.kernel_function, self.param, self.C, self.model)

    def decision_function(self, X_test):
        return score_slmkc(X_test, self.kernel_function, self.param, self.C, self.model)

    def predict_proba(self, X_test):
        scores = self.decision_function(X_test)
        probs = 1 / (1 + np.exp(-scores))
        return probs

- 此处未作改变

17-------------------------------------------------

Make the function linear_kernel_function(x1,x2,param=None) corresponding to the linear kernel defined as:
K ( x 1 , x 2 ) = x 1 T x 2 K(x_1,x_2) = x_1^T x_2 K(x1​,x2​)=x1T​x2​
where x 1 x_1 x1​ and x 2 x_2 x2​ are vectors.

def linear_kernel_function(x1, x2, param):
    x_prime = x1.T.dot(x2)
    return x_prime

此处为线性核函数

18-------------------------------------------------

Make the function polynomial_kernel_function(x1,x2,param) corresponding to the polynomial kernel defined by the parameter r = r= r=param:
K ( x 1 , x 2 ) = ( 1 + x 1 T x 2 ) r K(x_1,x_2) = (1 + x_1^T x_2)^r K(x1​,x2​)=(1+x1T​x2​)r
where x 1 x_1 x1​ and x 2 x_2 x2​ are vectors.

def polynomial_kernel_function(x1, x2, param):
    result = np.power(np.dot(x1.T, x2) + 1, param)
    return result

def gaussian_kernel(x, y, sigma=5.0):
    return np.exp(-linalg.norm(x - y) ** 2 / (2 * (sigma ** 2)))

此处为多项式核函数与高斯核函数，高斯核函数是我扩充的内容

测试部分

def plot(X, y, support_vectors=None, predict_func=None):
    cmap = 'bwr'
    res = 100
    x_min, x_max = X[:, 0].min(), X[:, 0].max()
    y_min, y_max = X[:, 1].min(), X[:, 1].max()
    delta = max((x_max - x_min) / 5, (y_max - y_min) / 5)
    x_min -= delta
    y_min -= delta
    x_max += delta
    y_max += delta
    xx, yy = np.meshgrid(np.linspace(x_min, x_max, res), np.linspace(y_min, y_max, res))
    if predict_func is None:
        Z = np.ones(xx.shape) * .5
    else:
        Z = predict_func(np.hstack([xx.reshape(-1, 1), yy.reshape(-1, 1)]))
        if Z.ndim == 1:
            Z = Z.reshape(xx.shape)
        else:
            Z = Z[:, -1].reshape(xx.shape)
    if support_vectors is None:
        edge_colors = 'w'
        sizes = 50
    else:
        edge_colors = ['k' if s else 'w' for s in support_vectors]
        sizes = [100 if s else 50 for s in support_vectors]
    plt.figure(figsize=(5, 5))
    plt.contourf(xx, yy, Z, levels=20, cmap=cmap, alpha=.5)
    plt.scatter(X[:, 0], X[:, 1], c=y, s=sizes, edgecolors=edge_colors, cmap=cmap)
    plt.grid()
    plt.axis('equal')
    plt.show()


# Just run the following code, do not modify it

from sklearn.datasets import make_classification

X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, n_repeated=0, n_classes=2,
                           n_clusters_per_class=2, weights=None, flip_y=0.0, class_sep=1.0, random_state=5)
y[y == 0] = -1

线性核函数

est = MySoftLargeMarginKernelClassfier(C=1e2, kernel_function=linear_kernel_function, param=None).fit(X, y)
plot(X, y, support_vectors=est.support_ids, predict_func=est.predict_proba)

在这里插入图片描述

多项式核函数

est = MySoftLargeMarginKernelClassfier(C=1e-2, kernel_function=polynomial_kernel_function, param=5).fit(X, y)
plot(X, y, support_vectors=est.support_ids, predict_func=est.predict_proba)

在这里插入图片描述

高斯核函数

est = MySoftLargeMarginKernelClassfier(C=1e-2, kernel_function=gaussian_kernel, param=5).fit(X, y)
plot(X, y, support_vectors=est.support_ids, predict_func=est.predict_proba)

在这里插入图片描述

整体代码

import matplotlib.pyplot as plt
import numpy as np
import scipy as sp
import cvxopt
from cvxopt import matrix
from cvxopt import solvers
from numpy import linalg


# 10-------------------------------------------------
def make_H_k(X, t, kernel_function, param):
    n_samples, n_feature = X.shape
    X_prime = np.zeros((n_samples, n_samples))
    for i in range(n_samples):
        for j in range(n_samples):
            X_prime[i, j] = kernel_function(X[i], X[j], param)
    H = np.outer(t, t) * X_prime
    return H


# 11-------------------------------------------------
def setup_optimization_soft_k(X, t, C, kernel_function, param):
    m, n = X.shape
    t = t.reshape(-1, 1).astype(float)
    H = make_H_k(X, t, kernel_function, param)
    P = matrix(H)
    q = matrix(-np.ones((m, 1)))
    G = matrix(np.vstack((-np.eye(m), np.eye(m))))
    h = matrix(np.hstack((np.zeros(m), np.ones(m) * C)))
    A = matrix(t.reshape(1, -1))
    b = matrix(np.zeros(1))

    return P, q, G, h, A, b


# 12-------------------------------------------------
def compute_support_vectors(X, t, alphas):
    t = t.reshape(-1, 1).astype(float)
    support_ids = (alphas > 1e-4).flatten()
    support_vectors = X[support_ids]
    support_targets = t[support_ids]
    support_alphas = alphas[support_ids]
    return support_vectors, support_targets, support_alphas, support_ids


# 13-------------------------------------------------
def train_slmkc(X, t, C, kernel_function, param):
    P, q, G, h, A, b = setup_optimization_soft_k(X, t, C, kernel_function, param)

    # Setting solver parameters (change default to decrease tolerance)
    solvers.options['show_progress'] = False
    solvers.options['abstol'] = 1e-10
    solvers.options['reltol'] = 1e-10
    solvers.options['feastol'] = 1e-10

    # Run solver
    solution_dict = solvers.qp(P, q, G, h, A, b)
    alphas = np.array(solution_dict['x'])

    support_vectors, support_targets, support_alphas, support_ids = compute_support_vectors(X, t, alphas)

    model = (support_vectors, support_targets, support_alphas, support_ids)

    return model


# 14-------------------------------------------------
def compute_bias(kernel_function, param, C, model):
    support_vectors, support_targets, support_alphas, support_ids = model
    if param == None:
        w = ((support_targets * support_alphas).T @ support_vectors).reshape(-1, 1)
        b = np.mean(support_targets - np.dot(support_vectors, w))
    else:
        w = None
        b = 0
        for n in range(len(support_targets)):
            b += support_targets[n]
            b -= np.sum(
                support_alphas * support_targets * kernel_function(support_ids[n], support_vectors, param))
        b /= len(support_alphas)
    return w, b


# 15-------------------------------------------------
def score_slmkc(X_test, kernel_function, param, C, model):
    w, b = compute_bias(kernel_function, param, C, model)
    if param == None:
        scores = np.dot(X_test, w) + b
        return scores.flatten()
    else:
        support_vectors, support_targets, support_alphas, support_ids = model
        X = X_test
        y_predict = np.zeros(len(X))
        for i in range(len(X)):
            s = 0
            for a, sv_y, sv in zip(support_alphas, support_targets, support_vectors):
                s += a * sv_y * kernel_function(X[i], sv, param)
            y_predict[i] = s
        return y_predict + b


# 16-------------------------------------------------
def test_slmkc(X_test, kernel_function, param, C, model):
    preds = np.sign(score_slmkc(X_test, kernel_function, param, C, model)).astype(int)
    return preds.flatten()


# this function is provided to you, you do not need to alter it in any way.

class MySoftLargeMarginKernelClassfier(object):
    def __init__(self, C, kernel_function, param):
        self.kernel_function = kernel_function
        self.param = param
        self.C = C
        self.support_vectors = None
        self.support_targets = None
        self.support_alphas = None
        self.support_ids = None

    def fit(self, X_train, y_train):
        self.model = train_slmkc(X_train, y_train, self.C, self.kernel_function, self.param)
        self.support_vectors, self.support_targets, self.support_alphas, self.support_ids = self.model
        return self

    def predict(self, X_test):
        return test_slmkc(X_test, self.kernel_function, self.param, self.C, self.model)

    def decision_function(self, X_test):
        return score_slmkc(X_test, self.kernel_function, self.param, self.C, self.model)

    def predict_proba(self, X_test):
        scores = self.decision_function(X_test)
        probs = 1 / (1 + np.exp(-scores))
        return probs


# 17-------------------------------------------------
def linear_kernel_function(x1, x2, param):
    x_prime = x1.T.dot(x2)
    return x_prime


# 18-------------------------------------------------
def polynomial_kernel_function(x1, x2, param):
    result = np.power(np.dot(x1.T, x2) + 1, param)
    return result


def gaussian_kernel(x, y, sigma=5.0):
    return np.exp(-linalg.norm(x - y) ** 2 / (2 * (sigma ** 2)))


# 测试部分
def plot(X, y, support_vectors=None, predict_func=None):
    cmap = 'bwr'
    res = 100
    x_min, x_max = X[:, 0].min(), X[:, 0].max()
    y_min, y_max = X[:, 1].min(), X[:, 1].max()
    delta = max((x_max - x_min) / 5, (y_max - y_min) / 5)
    x_min -= delta
    y_min -= delta
    x_max += delta
    y_max += delta
    xx, yy = np.meshgrid(np.linspace(x_min, x_max, res), np.linspace(y_min, y_max, res))
    if predict_func is None:
        Z = np.ones(xx.shape) * .5
    else:
        Z = predict_func(np.hstack([xx.reshape(-1, 1), yy.reshape(-1, 1)]))
        if Z.ndim == 1:
            Z = Z.reshape(xx.shape)
        else:
            Z = Z[:, -1].reshape(xx.shape)
    if support_vectors is None:
        edge_colors = 'w'
        sizes = 50
    else:
        edge_colors = ['k' if s else 'w' for s in support_vectors]
        sizes = [100 if s else 50 for s in support_vectors]
    plt.figure(figsize=(5, 5))
    plt.contourf(xx, yy, Z, levels=20, cmap=cmap, alpha=.5)
    plt.scatter(X[:, 0], X[:, 1], c=y, s=sizes, edgecolors=edge_colors, cmap=cmap)
    plt.grid()
    plt.axis('equal')
    plt.show()


# Just run the following code, do not modify it

from sklearn.datasets import make_classification

X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, n_repeated=0, n_classes=2,
                           n_clusters_per_class=2, weights=None, flip_y=0.0, class_sep=1.0, random_state=5)
y[y == 0] = -1

est = MySoftLargeMarginKernelClassfier(C=1e2, kernel_function=linear_kernel_function, param=None).fit(X, y)
plot(X, y, support_vectors=est.support_ids, predict_func=est.predict_proba)

est = MySoftLargeMarginKernelClassfier(C=1e-2, kernel_function=polynomial_kernel_function, param=5).fit(X, y)
plot(X, y, support_vectors=est.support_ids, predict_func=est.predict_proba)

est = MySoftLargeMarginKernelClassfier(C=1e-2, kernel_function=gaussian_kernel, param=5).fit(X, y)
plot(X, y, support_vectors=est.support_ids, predict_func=est.predict_proba)
miracleo_
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
soft-margin SVM
m0_37937932的博客
07-06 409
本篇文章讨论如何防止SVM的过拟合：kernel function参数的选取（转化函数太复杂）和资料完全separable的要求将会导致过拟合！ 一、primal soft-margin SVM 也许资料中含有Noise，资料本身就不是separable的，利用pocket演算法的思路，对于不完全可分的资料，我们只希望在学得的hypothesis上，资料犯的错误越少越好，因此可得到新的优化目标函...
（ 保证能看懂系列）SVM系列（二）soft-margin SVM 详细原理以及一点点的kernel SVM
Lee_Yu_Rui的博客
07-19 1472
本篇继续针soft-margin 软间隔SVM原理进行梳理，需要先对hard-margin SVM 有所掌握，具体见SVM系列（一）hard-margin SVM 详细原理 https://blog.csdn.net/Lee_Yu_Rui/article/details/107420870 soft-margin SVM 思想 感谢https://www.youtube.com/watch?v=ZF2QR7nSUhg&list=PLOxMGJ_8X74Z1N3OcacUaCxiXaGNHtFw.
11-3 Soft Margin SVM
Jacqueline_CSDN的博客
08-25 321
* 固执己见的支持Hard Margin SVM可能会出错 上图若还是用Hard Margin SVM的化，它的泛化能力是不高的 最上面蓝色的点是outlier,错误的点 下面的线作为决策边界是更好的：容错能力，可以错误分类，泛化能力高 此时就是线性不可分的，没有任何的直线可将数据分成两类。 无法应用Hard Margin SVM...
一文详解SVM的Soft-Margin机制
红色石头的专栏
05-10 5476
AI有道一个有良心的公众号Hard-Margin SVM，必须将所有的样本都分类正确才行。这往往需要更多更复杂的特征转换，甚至造成过拟合。本文将介绍一种Soft-Marg...
svm soft margin
11-23
SVM支持向量机引入软间隔的概念，最大化软间隔，提高容错率，对训练样本中outliers点引入容错参数。
SVM_SoftMargin.py
04-18
利用python实现对线性不可分数据集使用线性支持向量机并进行了交叉验证，选择效果最好的惩罚参数。代码通俗易懂，附有注释，有需要的可以看看
Archive.zip_SUM_Soft!_hard svm_soft margin svm_svm hard
07-14
_hard svm_soft margin svm_svm hard"表明这是一个关于支持向量机（Support Vector Machine, SVM）的压缩包文件，其中涵盖了硬间隔（hard margin）和软间隔（soft margin）的概念。SVM是一种强大的监督学习算法，常...
SVM(莺尾花)代码
03-01
在这个“SVM(莺尾花)代码”示例中，我们将深入探讨如何利用Python编程语言和scikit-learn（sklearn）库来实现SVM，特别是针对鸢尾花数据集（Iris dataset）的应用。** **1. 鸢尾花数据集：** 鸢尾花数据集是机器...
svm.rar_svm源代码
09-24
在提供的"svm.rar"压缩包中，包含了SVM的源代码和相关示例，这对于学习和理解SVM的工作原理以及实际应用是非常宝贵的资源。下面我们将深入探讨SVM的关键概念、实现细节和应用。 1. **SVM的基本概念** - 支持向量：...
SVM.rar_svm matlab代码
最新发布
09-24
在本资源" SVM.rar_svm matlab代码 "中，包含了一个使用MATLAB实现SVM的程序代码，适用于MATLAB版本7.0及以上。MATLAB是一个强大的数学计算软件，它为数据处理、算法开发和应用创建提供了便利的环境。 SVM的基本...
knn，最小二乘，softsvm分类器的matlab实现，以及简单的交叉验证等
04-19
knn，最小二乘，softsvm分类器的matlab实现，以及简单的交叉验证等 knn，最小二乘，softsvm分类器的matlab实现，以及简单的交叉验证等
机器学习技法--学习笔记04--Soft SVM
weixin_34294649的博客
01-11 120
背景 之前所讨论的SVM都是非常严格的hard版本，必须要求每个点都被正确的区分开。但是，实际情况时很少出现这种情况的，因为噪声数据时无法避免的。所以，需要在hard SVM上添加容错机制，使得可以容忍少量噪声数据。  "软"化问题 软化SVM的思路有点类似正规化，在目标函数添加错误累加项，然后加一个系数，控制对错误的容忍度，并且在约束中添加错误容忍度的约束，形式如下： ...
SVM学习笔记（二）——软间隔（soft-margin）
姚巨龙的博客
12-21 1655
SVM学习笔记（二）——软间隔（soft-margin）软间隔软间隔优化目标函数优化目标函数替代损失函数软间隔支持向量机 软间隔 软间隔是相对于硬间隔定义的。 在上一篇文章：学习笔记（一）中的SVM算法是线性可分的SVM算法，属于硬间隔。 所谓硬间隔，就是存在所有样本必须划分正确的约束条件，即所有样本必须严格满足： 而对于软间隔，则是允许某些样本不满足以上约束条件。 硬间隔要求间隔之间不存在任...
SVM(Support Vector Machine)读书笔记三(Soft-margin SVM)
热门推荐
Jackie_Zhu的专栏
08-03 1万+
上两篇讲到了hard-margin的SVM以及kernel的原理，利用高斯kernel可以将低维空间转换到无穷维，将所有样本分开。但是如果数据中存在一定的噪声数据，SVM也会将噪声数据拟合，存在过拟合的风险。Soft-margin SVM原理就是让SVM能够容忍一定的噪声数据，以减少过拟合的风险。Hard-margin过拟合问题 先看一下上面的相同数据集中的两个模型，左图中的模型能够容忍数据中存在
机器学习---背后数学原理--soft-margin SVM
丁磊_ml的博客
06-28 286
文章目录 所以soft-margin SVM的中心实现： 在原hard-margin SVM模型的基础上，允许样本操作一定的误差。
SVM→6.软间隔问题(soft-margin)
xiangrongweng0547的博客
10-08 606
SVM→6.软间隔问题(soft-margin) .card { font-family: arial; font-size: 20px; text-align: left; color: black; background-color: white } .cloze { font-weight: bold; color: red } .myCode { f...
A basic soft-margin kernel SVM implementation in Python
澍yeah的博客
07-27 611
http://tullo.ch/articles/svm-py/ https://github.com/ajtulloch/svmpy We consider our training set to be \begin{equation} D = { (\mathbf{x}_{i}, y_{i}), \mathbf{x} \in \mathbb{R}^d, y \in \{ -1, 1 \}...
Soft Margin SVM可以解释成正则化的model
qq_36695866的博客
12-30 533
首先，复习一下sotf margin SVM： 其中的kesi n是记录第n个样本是否违反支持向量的假设以及违反了多少假设。 从另外一个角度上看，由约束条件，我们可以等价的将kesi n写成以下的形式： 那么，这样的话 soft margin SVM就可以表示成下边的式子： 那么，第二项实际上就可以表示成error的形式，也就是data fitting term，而
机器学习——SVM(4 Soft-Margin SVM)
daocaoren_的博客
07-24 1063
Soft-Margin 的含义 所谓的Hard-Margin,就是指所有的资料都要完全分开，即separable,这是SVM产生过拟合的原因之一(还有一个原因就是过于复杂的转换 Φ\PhiΦ)。 所以引入Soft-Margin, 即不必让所有的资料都完全分开，让SVM容许一部分的错误分类点的存在，从而在一定程度上减少过拟合，即要在large margin 和错误分类点容忍度（noise toler...
支持向量机(SVM)分类详解与代码实践
"支持向量机（SVM）汇报ppt及其代码大全，涵盖了从线性SVM分类器原理到非线性SVM、核函数、手动推导以及上机演示的内容，旨在深入理解和应用SVM分类器。" 支持向量机（SVM）是一种有效的机器学习算法，尤其在分类和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值