精华内容
下载资源
问答
  • 具体分析了网格法、遗传算法和粒子群算 法在 SVM参数优化方面的性能以及优缺点,提出了一种改进的网格法. 先在较大范围内进行搜索,在得到的优化结果 附近区域再进行精确搜索. 实验表明改进的网格搜索法耗时短,更适用...
  • SVM参数寻优,寻找最佳的C和g,还可以做数据集的交叉验证。
  • 针对支持向量机(SVM)参数难以选择和确定的问题,采用一种新式元启发式优化算法——多元宇宙优化算法(MVO).并在传统多元宇宙优化算法(MVO)的基础上针对TDR值下降速度慢而导致旅行距离增加的问题,提出改进多元宇宙优化...
  • 一篇关于蚁群算法优化SVM参数的论文,具有很好的参考价值
  • 但是,SVM参数的选择大多数是凭经验选取,这种方法依赖于使用者的水平,这样不仅不能获得最佳的函数逼近效果,而且采用人工的方法选择SVM参数比较浪费时间,这在很大程度上限制了它的应用。为了能够自动地获得最佳的...
  • matlab环境下使用PSO算法对SVM多分类器的参数进行优化的案例,代码有详细的注释,另有一篇博客对算法的大致过程有介绍.
  • SVM(支持向量机)参数寻优,用到的方法是交叉验证法。
  • 本文提出一种SVM参数优化的新方法。应用遗传算法先对SVM参数进行初步的优化,把得到的优化结果邻近的一段区域再作为粒子群算法的搜索区间进行二次优化,以提高支持向量机的泛化能力,缩短sVM参数寻优的时间。仿真...
  • SVM参数设置

    千次阅读 2021-02-03 00:43:09
    主要参考了一些博客以及自己使用经验。收集来觉得比较有用的。...数据格式转换----------------------当数据较少时,可以用formatdatalibsvm轻松地将文本数据转换成为svm工具使用的数据。使用方法为:1,打开Form...

    主要参考了一些博客以及自己使用经验。收集来觉得比较有用的。

    LIBSVM

    数据格式需要----------------------

    决策属性 条件属性a 条件属性b ...

    2 1:7 2:5 ...

    1 1:4 2:2 ...

    数据格式转换----------------------

    当数据较少时,可以用formatdatalibsvm轻松地将文本数据转换成为svm工具使用的数据。

    使用方法为:

    1,打开FormatDataLibsvm.xls然后将数据粘贴到sheet1的topleft单元。

    输入格式为:

    条件属性a 条件属性b ... 决策属性

    7 5 ... 2

    4 2 ... 1

    输出数据格式是

    决策属性 条件属性a 条件属性b ...

    2 1:7 2:5 ...

    1 1:4 2:2 ...

    2,再"工具"-->"宏"-->执行下面有一个选项(FormatDatatoLibsvm)-->执行,要选中这个然后运行就可以了,这时数据转换的问题就解决了(如果没有宏选项,点击“开始--excel选项---在功能区显示“开发工具”选项卡”)

    3,可以copy到一个记事本中即可。但是注意在用libsvm的时候要在命令行输入.txt后缀。

    svm参数说明----------------------

    如果你要输出类的概率,一定要有-b参数

    svm-train training_set_file model_file

    svm-predict test_file model_fileoutput_file

    自动脚本:python easy.py train_data

    test_data

    自动选择最优参数,自动进行归一化。

    对训练集合和测试结合,使用同一个归一化参数。

    -c:参数

    -g:参数

    -v:交叉验证数

    -s svm_type : set type of SVM (default 0)

    0

    -- C-SVC

    1

    -- nu-SVC

    2

    -- one-class SVM

    3

    -- epsilon-SVR

    4

    -- nu-SVR

    -t kernel_type : set type of kernelfunction (default 2)

    0

    -- linear: u'*v

    1

    -- polynomial: (gamma*u'*v + coef0)^degree

    2

    -- radial basis function: exp(-gamma*|u-v|^2)

    3

    -- sigmoid: tanh(gamma*u'*v + coef0)

    -d degree : set degree in kernel function(default 3)

    -g gamma : set gamma in kernel function(default 1/num_features)

    -r coef0 : set coef0 in kernel function(default 0)

    -c cost : set the parameter C of C-SVC,epsilon-SVR, and nu-SVR

    (default 1)

    -n nu : set the parameter nu of nu-SVC,one-class SVM, and nu-SVR

    (default 0.5)

    -p epsilon : set the epsilon in lossfunction of epsilon-SVR

    (default 0.1)

    -m cachesize : set cache memory size in MB(default 100)

    -e epsilon : set tolerance of terminationcriterion (default

    0.001)

    -h shrinking: whether to use the shrinkingheuristics, 0 or 1

    (default 1)

    -b probability_estimates: whether to traina SVC or SVR model for

    probability estimates, 0 or 1 (default 0)(如果需要估计分到每个类的概率,则需要设置这个)

    -wi weight: set the parameter C of class ito weight*C, for C-SVC

    (default 1)

    Thek in the -g option means the number of

    attributes in the input data.

    libsvm使用误区----------------------

    (1) 直接将训练集合和测试集合简单归一化到[0,1]区间,可能导致实验结果很差。

    (2) 如果样本的特征数非常多,那么就不必使用RBF核将样本映射到高维空间。

    a) 在特征数非常多的情况下,使用线性核,结果已经非常好,并且只需要选择参数C即可。

    b) 虽然说RBF核的结果至少比线性核好,前提下搜索整个的空间。

    (3) 样本数<

    a) 推荐使用线性核,可以达到与RBF同样的性能。

    (4) 样本数和特征数都非常多:推荐使用liblinear,更少的时间和内存,可比的准确率。

    (5) 样本数>>特征数:如果想使用线性模型,可以使用liblinear,并且使用-s

    2参数

    libsvm在训练model的时候,有如下参数要设置,当然有默认的参数,但是在具体应用方面效果会大大折扣。

    Options:可用的选项即表示的涵义如下

    -s svm类型:SVM设置类型(默认0)

    0 -- C-SVC

    1 --v-SVC

    2–一类SVM

    3 -- e -SVR

    4 -- v-SVR

    -t核函数类型:核函数设置类型(默认2)

    0–线性:u'v

    1–多项式:(r*u'v + coef0)^degree

    2–RBF函数:exp(-gamma|u-v|^2)

    3–sigmoid:tanh(r*u'v + coef0)

    -d degree:核函数中的degree设置(针对多项式核函数)(默认3)

    -g r(gama):核函数中的gamma函数设置(针对多项式/rbf/sigmoid核函数)(默认1/ k)

    -r coef0:核函数中的coef0设置(针对多项式/sigmoid核函数)((默认0)

    -c cost:设置C-SVC,e -SVR和v-SVR的参数(损失函数)(默认1)

    -n nu:设置v-SVC,一类SVM和v- SVR的参数(默认0.5)

    -p p:设置e -SVR中损失函数p的值(默认0.1)

    -m cachesize:设置cache内存大小,以MB为单位(默认40)

    -e eps:设置允许的终止判据(默认0.001)

    -h shrinking:是否使用启发式,0或1(默认1)

    -wi weight:设置第几类的参数C为weight*C(C-SVC中的C)(默认1)

    -v n: n-fold交互检验模式,n为fold的个数,必须大于等于2

    其中-g选项中的k是指输入数据中的属性数。option -v随机地将数据剖分为n部

    当构建完成model后,还要为上述参数选择合适的值,方法主要有Gridsearch,其他的感觉不常用,Gridsearch说白了就是穷举。

    网格参数寻优函数(分类问题):SVMcgForClass

    [bestCVaccuracy,bestc,bestg]=

    SVMcgForClass(train_label,train,

    cmin,cmax,gmin,gmax,v,cstep,gstep,accstep)

    输入:

    train_label:训练集的标签,格式要求与svmtrain相同。

    train:训练集,格式要求与svmtrain相同。

    cmin,cmax:惩罚参数c的变化范围,即在[2^cmin,2^cmax]范围内寻找最佳的参数c,默认值为cmin=-8,cmax=8,即默认惩罚参数c的范围是[2^(-8),2^8]。

    gmin,gmax:RBF核参数g的变化范围,即在[2^gmin,2^gmax]范围内寻找最佳的RBF核参数g,默认值为gmin=-8,gmax=8,即默认RBF核参数g的范围是[2^(-8),2^8]。

    v:进行Cross

    Validation过程中的参数,即对训练集进行v-fold

    Cross Validation,默认为3,即默认进行3折CV过程。

    cstep,gstep:进行参数寻优是c和g的步进大小,即c的取值为2^cmin,2^(cmin+cstep),…,2^cmax,,g的取值为2^gmin,2^(gmin+gstep),…,2^gmax,默认取值为cstep=1,gstep=1。

    accstep:最后参数选择结果图中准确率离散化显示的步进间隔大小([0,100]之间的一个数),默认为4.5。

    输出:

    bestCVaccuracy:最终CV意义下的最佳分类准确率。

    bestc:最佳的参数c。

    bestg:最佳的参数g。

    网格参数寻优函数(回归问题):SVMcgForRegress

    [bestCVmse,bestc,bestg]=

    SVMcgForRegress(train_label,train,

    cmin,cmax,gmin,gmax,v,cstep,gstep,msestep)

    其输入输出与SVMcgForClass类似,这里不再赘述。

    而当你训练完了model,在用它做classification或regression之前,应该知道model中的内容,以及其含义。

    用来训练的是libsvm自带的heart数据

    model =

    Parameters:

    [5x1 double]

    nr_class:

    2

    totalSV:

    259 %支持向量的数目

    rho:

    0.0514 % b

    Label:

    [2x1

    double] % classification中标签的个数

    ProbA:

    []

    ProbB:

    []

    nSV:

    [2x1

    double] % 每类支持向量的个数

    sv_coef:

    [259x1 double] % 支持向量对应的Wi

    SVs:

    [259x13 double] % 装的是259个支持向量

    model.Parameters参数意义从上到下依次为:

    -s svm类型:SVM设置类型(默认0)

    -t核函数类型:核函数设置类型(默认2)

    -d degree:核函数中的degree设置(针对多项式核函数)(默认3)

    -g r(gama):核函数中的gamma函数设置(针对多项式/rbf/sigmoid核函数) (默认类别数目的倒数)

    -r coef0:核函数中的coef0设置(针对多项式/sigmoid核函数)((默认0)

    SVM怎样能得到好的结果

    1. 对数据做归一化(simple

    scaling)

    2. 应用RBF

    kernel

    3. 用cross-validation和grid-search得到最优的c和g

    4. 用得到的最优c和g训练训练数据

    5. 测试

    关于svm的C以及核函数参数设置----------------------

    参考自:对支持向量机几种常用核函数和参数选择的比较研究

    C一般可以选择为:10^t , t=-

    4..4就是0.0001到10000

    选择的越大,表示对错误例惩罚程度越大,可能会导致模型过拟合

    在LIBSVM中-t用来指定核函数类型(默认值是2)。

    0)线性核函数

    (无其他参数)

    1)多项式核函数

    (重点是阶数的选择,即d,一般选择1-11:1 3 5 7 9 11,也可以选择2,4,6…)

    2)RBF核函数

    (径向基RBF内核,exp{-|xi-xj|^2/均方差},其中均方差反映了数据波动的大小。

    参数通常可选择下面几个数的倒数:0.1 0.2 0.4

    0.6 0.8 1.6 3.2 6.4 12.8,默认的是类别数的倒数,即1/k,2分类的话就是0.5)

    3)sigmoid核函数又叫做S形内核

    两个参数g以及r:g一般可选1 2

    3 4,r选0.2 0.4 0.60.8 1

    4)自定义核函数

    常用的四种核函数对应的公式如下:

    与核函数相对应的libsvm参数:

    1)对于线性核函数,没有专门需要设置的参数

    2)对于多项式核函数,有三个参数。-d用来设置多项式核函数的最高此项次数,也就是公式中的d,默认值是3。-g用来设置核函数中的gamma参数设置,也就是公式中的第一个r(gamma),默认值是1/k(k是类别数)。-r用来设置核函数中的coef0,也就是公式中的第二个r,默认值是0。

    3)对于RBF核函数,有一个参数。-g用来设置核函数中的gamma参数设置,也就是公式中的第一个r(gamma),默认值是1/k(k是类别数)。

    4)对于sigmoid核函数,有两个参数。-g用来设置核函数中的gamma参数设置,也就是公式中的第一个r(gamma),默认值是1/k(k是类别数)。-r用来设置核函数中的coef0,也就是公式中的第二个r,默认值是0。

    展开全文
  • PSO优化SVM参数

    2018-05-11 15:57:30
    PSO优化SVM参数 PSO优化SVM参数 PSO优化SVM参数 PSO优化SVM参数
  • 一种有效的SVM参数优化选择方法支持向量机(support vector machines,SVM) 是在统计学习理论的基础之上发展起来的新一代 机器学习算法
  • SVM参数寻优

    2016-03-22 18:02:08
    SVM参数寻优
  • 为了提高煤矿主扇风机故障诊断的准确性,将网格搜索法和支持向量机(SVM)应用到主扇风机的故障诊断中。首先,建立主扇风机运行故障的知识库,并...实验结果表明,网格搜索法SVM参数优化非常适合于煤矿主扇风机的故障系统中。
  • SVM参数参数介绍以及python实现GA对SVM参数的优化

    万次阅读 多人点赞 2018-12-15 15:41:53
    最近开始玩起了机器学习,以前都是用matlab做一些机器学习的东西,毕竟要真正放到工程上应用还是python用起来比较好,所以今天就开始学习下使用SVM进行回归(分类)预测。 SVM 使用的一般步骤是: 1)准备数据集,...

     

    最近开始玩起了机器学习,以前都是用matlab做一些机器学习的东西,毕竟要真正放到工程上应用还是python用起来比较好,所以今天就开始学习下使用SVM进行回归(分类)预测。

    SVM 使用的一般步骤是:
    1)准备数据集,转化为 SVM支持的数据格式 :
    [label] [index1]:[value1] [index2]:[value2] ...
    即 [l类别标号] [特征1]:[特征值] [特征2]:[特征值] ...
    2)对数据进行简单的缩放操作(scale);(为什么要scale,这里不解释了)
    3)考虑选用核函数(通常选取径函数,程序默认);
    4)优化算法选择最佳参数C与g ;
    5)用得到的最佳参数C与g 对整个训练集进行训练得到SVM模型;
    6)用得到的SVM模型进行测试

    在这个基本操作中,优化算法起到了关键作用,常见优化算法有网格搜索算法、遗传算法、粒子群算法、蚁群算法。这些优化算法主要实现对SVM参数进行优化。在sklearn 中有对svm的实现,其中回归的构造函数中的参数就是模型的参数,包括核函数,惩罚因子C、不敏感系数gRBF中的核宽度epsilon。

    参数:

    l C:C-SVC的惩罚参数C?默认值是1.0

    C越大,相当于惩罚松弛变量,希望松弛变量接近0,即对误分类的惩罚增大,趋向于对训练集全分对的情况,这样对训练集测试时准确率很高,但泛化能力弱。C值小,对误分类的惩罚减小,允许容错,将他们当成噪声点,泛化能力较强。

    l kernel :核函数,默认是rbf,可以是‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’

      0 – 线性:u’v

       1 – 多项式:(gamma*u’*v + coef0)^degree

      2 – RBF函数:exp(-gamma|u-v|^2)

      3 –sigmoid:tanh(gamma*u’*v + coef0)

    l degree :多项式poly函数的维度,默认是3,选择其他核函数时会被忽略。

    l gamma : ‘rbf’,‘poly’ 和‘sigmoid’的核函数参数。默认是’auto’,则会选择1/n_features

    l coef0 :核函数的常数项。对于‘poly’和 ‘sigmoid’有用。

    l probability :是否采用概率估计?.默认为False

    l shrinking :是否采用shrinking heuristic方法,默认为true

    l tol :停止训练的误差值大小,默认为1e-3

    l cache_size :核函数cache缓存大小,默认为200

    l class_weight :类别的权重,字典形式传递。设置第几类的参数C为weight*C(C-SVC中的C)

    l verbose :允许冗余输出?

    l max_iter :最大迭代次数。-1为无限制。

    l decision_function_shape :‘ovo’, ‘ovr’ or None, default=None3

    l random_state :数据洗牌时的种子值,int值

    主要调节的参数有:C、kernel、degree、gamma、coef0。
     

    因此我们使用sklearn 中的SVm时候,要选择好参数

    from sklearn import svm
    X = [[0, 0], [2, 2]]
    y = [0.5, 2.5]
    clf = svm.SVR()
     clf.fit(X, y) 
    SVR(C=1.0, cache_size=200, coef0=0.0, degree=3, epsilon=0.1,
        gamma='auto_deprecated', kernel='rbf', max_iter=-1, shrinking=True,
        tol=0.001, verbose=False)
    clf.predict([[1, 1]])
    array([1.5])

    那么问题来了,优化函数又该怎么使用呢?ok,这就开始!

    以GA(遗传算法为例),代码如下

    ObjFunction.py  这是你得适应度值函数作为目标函数定义的地方

    import math
    from sklearn import svm
    
    def msefunc(predictval,realval):
        squaredError = []
        absError = []
        for i in range(len(predictval)):
            val=predictval[i-1]-realval[i-1]
            squaredError.append(val * val)  # target-prediction之差平方 
    
        print("Square Error: ", squaredError)
        print("MSE = ", sum(squaredError) / len(squaredError))  # 均方误差MSE
        return sum(squaredError) / len(squaredError)
    
    def SVMResult(vardim, x, bound):
        X = [[0, 0], [2, 2]]
        y = [0.5, 2.5]
        c=x[0]
        e=x[1]
        g=x[2]
        clf = svm.SVR(C=c, epsilon=e,gamma=g, kernel='rbf')
        clf.fit(X, y)
        predictval=clf.predict(realval)
        print(predictval)
        '''返回mse作为适应度值'''
        return msefunc(predictval,realval)  
        

    GAIndividual.py

    import numpy as np
    import ObjFunction
    
    
    class GAIndividual:
    
        '''
        individual of genetic algorithm
        '''
    
        def __init__(self,  vardim, bound):
            '''
            vardim: dimension of variables
            bound: boundaries of variables
            '''
            self.vardim = vardim
            self.bound = bound
            self.fitness = 0.
    
        def generate(self):
            '''
            generate a random chromsome for genetic algorithm
            '''
            len = self.vardim
            rnd = np.random.random(size=len)
            self.chrom = np.zeros(len)
            for i in xrange(0, len):
                self.chrom[i] = self.bound[0, i] + \
                    (self.bound[1, i] - self.bound[0, i]) * rnd[i]
    
        def calculateFitness(self):
            '''
            calculate the fitness of the chromsome
            '''
            self.fitness = ObjFunction.GrieFunc(
                self.vardim, self.chrom, self.bound)

    GeneticAlgorithm.py

    import numpy as np
    from GAIndividual import GAIndividual
    import random
    import copy
    import matplotlib.pyplot as plt
    
    
    class GeneticAlgorithm:
    
        '''
        The class for genetic algorithm
        '''
    
        def __init__(self, sizepop, vardim, bound, MAXGEN, params):
            '''
            sizepop: population sizepop
            vardim: dimension of variables
            bound: boundaries of variables
            MAXGEN: termination condition
            param: algorithm required parameters, it is a list which is consisting of crossover rate, mutation rate, alpha
            '''
            self.sizepop = sizepop
            self.MAXGEN = MAXGEN
            self.vardim = vardim
            self.bound = bound
            self.population = []
            self.fitness = np.zeros((self.sizepop, 1))
            self.trace = np.zeros((self.MAXGEN, 2))
            self.params = params
    
        def initialize(self):
            '''
            initialize the population
            '''
            for i in xrange(0, self.sizepop):
                ind = GAIndividual(self.vardim, self.bound)
                ind.generate()
                self.population.append(ind)
    
        def evaluate(self):
            '''
            evaluation of the population fitnesses
            '''
            for i in xrange(0, self.sizepop):
                self.population[i].calculateFitness()
                self.fitness[i] = self.population[i].fitness
    
        def solve(self):
            '''
            evolution process of genetic algorithm
            '''
            self.t = 0
            self.initialize()
            self.evaluate()
            best = np.max(self.fitness)
            bestIndex = np.argmax(self.fitness)
            self.best = copy.deepcopy(self.population[bestIndex])
            self.avefitness = np.mean(self.fitness)
            self.trace[self.t, 0] = (1 - self.best.fitness) / self.best.fitness
            self.trace[self.t, 1] = (1 - self.avefitness) / self.avefitness
            print("Generation %d: optimal function value is: %f; average function value is %f" % (
                self.t, self.trace[self.t, 0], self.trace[self.t, 1]))
            while (self.t < self.MAXGEN - 1):
                self.t += 1
                self.selectionOperation()
                self.crossoverOperation()
                self.mutationOperation()
                self.evaluate()
                best = np.max(self.fitness)
                bestIndex = np.argmax(self.fitness)
                if best > self.best.fitness:
                    self.best = copy.deepcopy(self.population[bestIndex])
                self.avefitness = np.mean(self.fitness)
                self.trace[self.t, 0] = (1 - self.best.fitness) / self.best.fitness
                self.trace[self.t, 1] = (1 - self.avefitness) / self.avefitness
                print("Generation %d: optimal function value is: %f; average function value is %f" % (
                    self.t, self.trace[self.t, 0], self.trace[self.t, 1]))
    
            print("Optimal function value is: %f; " %
                  self.trace[self.t, 0])
            print "Optimal solution is:"
            print self.best.chrom
            self.printResult()
    
        def selectionOperation(self):
            '''
            selection operation for Genetic Algorithm
            '''
            newpop = []
            totalFitness = np.sum(self.fitness)
            accuFitness = np.zeros((self.sizepop, 1))
    
            sum1 = 0.
            for i in xrange(0, self.sizepop):
                accuFitness[i] = sum1 + self.fitness[i] / totalFitness
                sum1 = accuFitness[i]
    
            for i in xrange(0, self.sizepop):
                r = random.random()
                idx = 0
                for j in xrange(0, self.sizepop - 1):
                    if j == 0 and r < accuFitness[j]:
                        idx = 0
                        break
                    elif r >= accuFitness[j] and r < accuFitness[j + 1]:
                        idx = j + 1
                        break
                newpop.append(self.population[idx])
            self.population = newpop
    
        def crossoverOperation(self):
            '''
            crossover operation for genetic algorithm
            '''
            newpop = []
            for i in xrange(0, self.sizepop, 2):
                idx1 = random.randint(0, self.sizepop - 1)
                idx2 = random.randint(0, self.sizepop - 1)
                while idx2 == idx1:
                    idx2 = random.randint(0, self.sizepop - 1)
                newpop.append(copy.deepcopy(self.population[idx1]))
                newpop.append(copy.deepcopy(self.population[idx2]))
                r = random.random()
                if r < self.params[0]:
                    crossPos = random.randint(1, self.vardim - 1)
                    for j in xrange(crossPos, self.vardim):
                        newpop[i].chrom[j] = newpop[i].chrom[
                            j] * self.params[2] + (1 - self.params[2]) * newpop[i + 1].chrom[j]
                        newpop[i + 1].chrom[j] = newpop[i + 1].chrom[j] * self.params[2] + \
                            (1 - self.params[2]) * newpop[i].chrom[j]
            self.population = newpop
    
        def mutationOperation(self):
            '''
            mutation operation for genetic algorithm
            '''
            newpop = []
            for i in xrange(0, self.sizepop):
                newpop.append(copy.deepcopy(self.population[i]))
                r = random.random()
                if r < self.params[1]:
                    mutatePos = random.randint(0, self.vardim - 1)
                    theta = random.random()
                    if theta > 0.5:
                        newpop[i].chrom[mutatePos] = newpop[i].chrom[
                            mutatePos] - (newpop[i].chrom[mutatePos] - self.bound[0, mutatePos]) * (1 - random.random() ** (1 - self.t / self.MAXGEN))
                    else:
                        newpop[i].chrom[mutatePos] = newpop[i].chrom[
                            mutatePos] + (self.bound[1, mutatePos] - newpop[i].chrom[mutatePos]) * (1 - random.random() ** (1 - self.t / self.MAXGEN))
            self.population = newpop
    
        def printResult(self):
            '''
            plot the result of the genetic algorithm
            '''
            x = np.arange(0, self.MAXGEN)
            y1 = self.trace[:, 0]
            y2 = self.trace[:, 1]
            plt.plot(x, y1, 'r', label='optimal value')
            plt.plot(x, y2, 'g', label='average value')
            plt.xlabel("Iteration")
            plt.ylabel("function value")
            plt.title("Genetic algorithm for function optimization")
            plt.legend()
            plt.show()
    if __name__ == "__main__":
    
       bound = np.tile([[-600], [600]], 3)  '''代表模型中的三个参数选择'''
       ga = GA(60, 3, bound, 1000, [0.9, 0.1, 0.5])
       ga.solve()

    其实简单讲就是通过运行ga算法,每次计算的是适应度值的过程就是希望每个基因的位置就是三个参数的值,算法计算每个参数值与适应度值之间的关系,在解空间内进行搜索,找到适应度值最大时候的参数,返回出来,就是你模型中的最优参数。所以优化的的结果影响着模型预测的性能。当然每次预测结果的可能不同,但会在最优解附近(在不是陷入局部最优的时候)。

     

     

    参考:http://www.cnblogs.com/biaoyu/p/4857881.html

    https://scikit-learn.org/stable/modules/svm.html#regression

    展开全文
  • 本程序有算例分析,详细介绍了三种优化SVM方法:遗传算法、PSO、网格搜索法
  • SVM参数详解

    千次阅读 2018-07-06 17:49:03
    svm参数说明----------------------如果你要输出类的概率,一定要有-b参数svm-train training_set_file model_filesvm-predict test_file model_fileoutput_file自动脚本:python easy.py train_data test_data自动...

    svm参数说明----------------------

    如果你要输出类的概率,一定要有-b参数

    svm-train training_set_file model_file

    svm-predict test_file model_fileoutput_file

    自动脚本:python easy.py train_data test_data

    自动选择最优参数,自动进行归一化。

    对训练集合和测试结合,使用同一个归一化参数。

    -c:参数

    -g: 参数

    -v:交叉验证数

    -s svm_type : set type of SVM (default 0)

            0 -- C-SVC

            1 -- nu-SVC

            2 -- one-class SVM

            3 -- epsilon-SVR

            4 -- nu-SVR

    -t kernel_type : set type of kernelfunction (default 2)

            0 -- linear: u'*v

            1 -- polynomial: (gamma*u'*v + coef0)^degree

            2 -- radial basis function: exp(-gamma*|u-v|^2)

            3 -- sigmoid: tanh(gamma*u'*v + coef0)

    -d degree : set degree in kernel function(default 3)

     

    -g gamma : set gamma in kernel function(default 1/num_features)

    -r coef0 : set coef0 in kernel function(default 0)

    -c cost : set the parameter C of C-SVC,epsilon-SVR, and nu-SVR (default 1)

    -n nu : set the parameter nu of nu-SVC,one-class SVM, and nu-SVR (default 0.5)

    -p epsilon : set the epsilon in lossfunction of epsilon-SVR (default 0.1)

    -m cachesize : set cache memory size in MB(default 100)

    -e epsilon : set tolerance of terminationcriterion (default 0.001)

    -h shrinking: whether to use the shrinkingheuristics, 0 or 1 (default 1)

    -b probability_estimates: whether to traina SVC or SVR model for probability estimates, 0 or 1 (default 0)(如果需要估计分到每个类的概率,则需要设置这个)

    -wi weight: set the parameter C of class ito weight*C, for C-SVC (default 1)

     Thek in the -g option means the number of attributes in the input data.

     

     

    libsvm使用误区----------------------

    (1)      直接将训练集合和测试集合简单归一化到[0,1]区间,可能导致实验结果很差。

    (2)      如果样本的特征数非常多,那么就不必使用RBF核将样本映射到高维空间。

    a)        在特征数非常多的情况下,使用线性核,结果已经非常好,并且只需要选择参数C即可。

    b)        虽然说RBF核的结果至少比线性核好,前提下搜索整个的空间。

    (3)      样本数<<特征数的情况:

    a)        推荐使用线性核,可以达到与RBF同样的性能。

    (4)      样本数和特征数都非常多:推荐使用liblinear,更少的时间和内存,可比的准确率。

    (5)      样本数>>特征数:如果想使用线性模型,可以使用liblinear,并且使用-s 2参数

     

    libsvm在训练model的时候,有如下参数要设置,当然有默认的参数,但是在具体应用方面效果会大大折扣。 

    Options:可用的选项即表示的涵义如下

    -s svm类型:SVM设置类型(默认0)

    0 -- C-SVC

    1 --v-SVC

    2 –一类SVM

    3 -- e -SVR

    4 -- v-SVR 

     

    -t 核函数类型:核函数设置类型(默认2)

    0 –线性:u'v

    1 –多项式:(r*u'v + coef0)^degree

    2 – RBF函数:exp(-gamma|u-v|^2)

    3 –sigmoid:tanh(r*u'v + coef0)

     

     

    -d degree:核函数中的degree设置(针对多项式核函数)(默认3)

    -g r(gama):核函数中的gamma函数设置(针对多项式/rbf/sigmoid核函数)(默认1/ k)

    -r coef0:核函数中的coef0设置(针对多项式/sigmoid核函数)((默认0)

    -c cost:设置C-SVC,e -SVR和v-SVR的参数(损失函数)(默认1)

    -n nu:设置v-SVC,一类SVM和v- SVR的参数(默认0.5)

    -p p:设置e -SVR 中损失函数p的值(默认0.1)

    -m cachesize:设置cache内存大小,以MB为单位(默认40)

    -e eps:设置允许的终止判据(默认0.001)

    -h shrinking:是否使用启发式,0或1(默认1)

    -wi weight:设置第几类的参数C为weight*C(C-SVC中的C)(默认1)

    -v n: n-fold交互检验模式,n为fold的个数,必须大于等于2

      其中-g选项中的k是指输入数据中的属性数。option -v 随机地将数据剖分为n部

     

    当构建完成model后,还要为上述参数选择合适的值,方法主要有Gridsearch,其他的感觉不常用,Gridsearch说白了就是穷举。

     

    网格参数寻优函数(分类问题):SVMcgForClass

    [bestCVaccuracy,bestc,bestg]=

    SVMcgForClass(train_label,train,

    cmin,cmax,gmin,gmax,v,cstep,gstep,accstep)

    输入:

    train_label:训练集的标签,格式要求与svmtrain相同。

    train:训练集,格式要求与svmtrain相同。

    cmin,cmax:惩罚参数c的变化范围,即在[2^cmin,2^cmax]范围内寻找最佳的参数c,默认值为cmin=-8,cmax=8,即默认惩罚参数c的范围是[2^(-8),2^8]。

    gmin,gmax:RBF核参数g的变化范围,即在[2^gmin,2^gmax]范围内寻找最佳的RBF核参数g,默认值为gmin=-8,gmax=8,即默认RBF核参数g的范围是[2^(-8),2^8]。

    v:进行Cross Validation过程中的参数,即对训练集进行v-fold Cross Validation,默认为3,即默认进行3折CV过程。

    cstep,gstep:进行参数寻优是c和g的步进大小,即c的取值为2^cmin,2^(cmin+cstep),…,2^cmax,,g的取值为2^gmin,2^(gmin+gstep),…,2^gmax,默认取值为cstep=1,gstep=1。

    accstep:最后参数选择结果图中准确率离散化显示的步进间隔大小([0,100]之间的一个数),默认为4.5。

    输出:

    bestCVaccuracy:最终CV意义下的最佳分类准确率。

    bestc:最佳的参数c。

    bestg:最佳的参数g。

     

    网格参数寻优函数(回归问题):SVMcgForRegress

    [bestCVmse,bestc,bestg]=

    SVMcgForRegress(train_label,train,

    cmin,cmax,gmin,gmax,v,cstep,gstep,msestep)

    其输入输出与SVMcgForClass类似,这里不再赘述。


    而当你训练完了model,在用它做classification或regression之前,应该知道model中的内容,以及其含义。

     

    用来训练的是libsvm自带的heart数据

     

    model =

       Parameters: [5x1 double]

         nr_class: 2

          totalSV: 259                   % 支持向量的数目

              rho: 0.0514               %  b

            Label: [2x1 double]     %  classification中标签的个数

            ProbA: []

            ProbB: []

              nSV: [2x1 double]     %  每类支持向量的个数

           sv_coef: [259x1 double]  %   支持向量对应的Wi

     

              SVs: [259x13 double]  %   装的是259个支持向量

     

    model.Parameters参数意义从上到下依次为:

    -s svm类型:SVM设置类型(默认0)

    -t 核函数类型:核函数设置类型(默认2)

    -d degree:核函数中的degree设置(针对多项式核函数)(默认3)

    -g r(gama):核函数中的gamma函数设置(针对多项式/rbf/sigmoid核函数) (默认类别数目的倒数)

    -r coef0:核函数中的coef0设置(针对多项式/sigmoid核函数)((默认0)

     

    SVM 怎样能得到好的结果

    1.   对数据做归一化(simple scaling)

    2.   应用 RBF kernel 

    3.   用cross-validation和grid-search 得到最优的c和g

    4.   用得到的最优c和g训练训练数据

    5.   测试


     

    关于svmC以及核函数参数设置----------------------

    参考自:对支持向量机几种常用核函数和参数选择的比较研究

      

    C一般可以选择为:10^t , t=- 4..4就是0.0001 到10000

     选择的越大,表示对错误例惩罚程度越大,可能会导致模型过拟合

     

    在LIBSVM中-t用来指定核函数类型(默认值是2)。

    0)线性核函数

    (无其他参数)

    1)多项式核函数

    (重点是阶数的选择,即d,一般选择1-11:1 3 5 7 9 11,也可以选择2,4,6…)

    2)RBF核函数

    (径向基RBF内核,exp{-|xi-xj|^2/均方差},其中均方差反映了数据波动的大小。

    参数通常可选择下面几个数的倒数:0.1 0.2 0.4 0.6 0.8 1.6 3.2 6.4 12.8,默认的是类别数的倒数,即1/k,2分类的话就是0.5)

    3)sigmoid核函数 又叫做S形内核

    两个参数g以及r:g一般可选1 2 3 4,r选0.2 0.4 0.60.8 1

    4)自定义核函数

     

    常用的四种核函数对应的公式如下:

     

    与核函数相对应的libsvm参数:

    1)对于线性核函数,没有专门需要设置的参数

    2)对于多项式核函数,有三个参数。-d用来设置多项式核函数的最高此项次数,也就是公式中的d,默认值是3。-g用来设置核函数中的gamma参数设置,也就是公式中的第一个r(gamma),默认值是1/k(k是类别数)。-r用来设置核函数中的coef0,也就是公式中的第二个r,默认值是0。

    3)对于RBF核函数,有一个参数。-g用来设置核函数中的gamma参数设置,也就是公式中的第一个r(gamma),默认值是1/k(k是类别数)。

    4)对于sigmoid核函数,有两个参数。-g用来设置核函数中的gamma参数设置,也就是公式中的第一个r(gamma),默认值是1/k(k是类别数)。-r用来设置核函数中的coef0,也就是公式中的第二个r,默认值是0。


    关于cost和gamma

    SVM模型有两个非常重要的参数C与gamma。其中 C是惩罚系数,即对误差的宽容度。c越高,说明越不能容忍出现误差,容易过拟合。C越小,容易欠拟合。C过大或过小,泛化能力变差

               gamma是选择RBF函数作为kernel后,该函数自带的一个参数。隐含地决定了数据映射到新的特征空间后的分布,gamma越大,支持向量越少,gamma值越小,支持向量越多。支持向量的个数影响训练与预测的速度。

              此外大家注意RBF公式里面的sigma和gamma的关系如下:

        

            这里面大家需要注意的就是gamma的物理意义,大家提到很多的RBF的幅宽,它会影响每个支持向量对应的高斯的作用范围,从而影响泛化性能。我的理解:如果gamma设的太大,会很小,很小的高斯分布长得又高又瘦, 会造成只会作用于支持向量样本附近,对于未知样本分类效果很差,存在训练准确率可以很高,(如果让无穷小,则理论上,高斯核的SVM可以拟合任何非线性数据,但容易过拟合)而测试准确率不高的可能,就是通常说的过训练;而如果设的过小,则会造成平滑效应太大,无法在训练集上得到特别高的准确率,也会影响测试集的准确率。

    此外,可以明确的两个结论是:
    结论1:样本数目少于特征维度并不一定会导致过拟合,这可以参考余凯老师的这句评论:
    这不是原因啊,呵呵。用RBF kernel, 系统的dimension实际上不超过样本数,与特征维数没有一个trivial的关系。

    结论2:RBF核应该可以得到与线性核相近的效果(按照理论,RBF核可以模拟线性核),可能好于线性核,也可能差于,但是,不应该相差太多。
    当然,很多问题中,比如维度过高,或者样本海量的情况下,大家更倾向于用线性核,因为效果相当,但是在速度和模型大小方面,线性核会有更好的表现。

    老师木还有一句评论,可以加深初学者对SVM的理解:
    须知rbf实际是记忆了若干样例,在sv中各维权重重要性等同。线性核学出的权重是feature weighting作用或特征选择 。
    以上摘录了:http://blog.sina.com.cn/s/blog_6ae183910101cxbv.html


    Grid Search

    Grid Search是用在Libsvm中的参数搜索方法。很容易理解:就是在C,gamma组成的二维参数矩阵中,依次实验每一对参数的效果。

                                                        


    使用grid Search虽然比较简单,而且看起来很naïve。但是他确实有两个优点:

    1. 可以得到全局最优
    2. (C,gamma)相互独立,便于并行化进行
    1. # SVM Classifier using cross validation
    2. def svm_cross_validation(train_x, train_y):
    3. from sklearn.grid_search import GridSearchCV
    4. from sklearn.svm import SVC
    5. model = SVC(kernel= 'rbf', probability= True)
    6. param_grid = { 'C': [ 1e-3, 1e-2, 1e-1, 1, 10, 100, 1000], 'gamma': [ 0.001, 0.0001]}
    7. grid_search = GridSearchCV(model, param_grid, n_jobs = 8, verbose= 1)
    8. grid_search.fit(train_x, train_y)
    9. best_parameters = grid_search.best_estimator_.get_params()
    10. for para, val in list(best_parameters.items()):
    11. print(para, val)
    12. model = SVC(kernel= 'rbf', C=best_parameters[ 'C'], gamma=best_parameters[ 'gamma'], probability= True)
    13. model.fit(train_x, train_y)
    14. return model


    SVM有如下主要几个特点:
    
    (1)非线性映射是SVM方法的理论基础,SVM利用内积核函数代替向高维空间的非线性映射;
    (2)对特征空间划分的最优超平面是SVM的目标,最大化分类边际的思想是SVM方法的核心;
    (3)支持向量是SVM的训练结果,在SVM分类决策中起决定作用的是支持向量;
    (4)SVM 是一种有坚实理论基础的新颖的小样本学习方法。
    它基本上不涉及概率测度及大数定律等,因此不同于现有的统计方法。
    从本质上看,它避开了从归纳到演绎的传统过程,实现了高效的从训练样本到预报样本的“转导推理”,
    大大简化了通常的分类和回归等问题; (5)SVM 的最终决策函数只由少数的支持向量所确定,计算的复杂性取决于支持向量的数目,
    而不是样本空间的维数,这在某种意义上避免了“维数灾难”。
    (6)少数支持向量决定了最终结果,这不但可以帮助我们抓住关键样本、“剔除”大量冗余样本,
    而且注定了该方法不但算法简单,而且具有较好的“鲁棒”性。
    这种“鲁棒”性主要体现在:
    ①增、删非支持向量样本对模型没有影响; ②支持向量样本集具有一定的鲁棒性;
    ③有些成功的应用中,SVM 方法对核的选取不敏感
    两个不足:
    (1) SVM算法对大规模训练样本难以实施 由于SVM是借助二次规划来求解支持向量,
    而求解二次规划将涉及m阶矩阵的计算(m为样本的个数),当m数目很大时该矩阵的存储和计算
    将耗费大量的机器内存和运算时间。
    针对以上问题的主要改进有
    J.Platt的SMO算法、
    T.Joachims的SVM、
    C.J.C.Burges等的PCGC、
    张学工的CSVM
    以及O.L.Mangasarian等的SOR算法
    (2) 用SVM解决多分类问题存在困难
    经典的支持向量机算法只给出了二类分类的算法,
    而在数据挖掘的实际应用中,一般要解决多类的分类问题。
    可以通过多个二类支持向量机的组合来解决。
    主要有
    一对多组合模式、一对一组合模式和SVM决策树;
    再就是通过构造多个分类器的组合来解决。
    主要原理是克服SVM固有的缺点,结合其他算法的优势,解决多类问题的分类精度。
    如:

    与粗集理论结合,形成一种优势互补的多类问题的组合分类器。

    https://blog.csdn.net/bryan__/article/details/51506801

    展开全文
  • SVM参数优化问题

    2019-03-22 08:46:52
    SVM参数优化问题,对比随机参数与优化后的参数对网络性能的影响
  • 提出了一种基于多特征...最后,采用粒子群算法优化SVM的参数并使用优化的SVM参数进行运动车辆的车型识别。实验结果表明:提出的多特征提取和SVM参数优化相结合的车型识别方法能够取得很好的识别效果,识别率达到90%以上。
  • SVM_svmmatlab_svm参数寻优_SVM参数_交叉验证SVM_交叉验证,SVM_源码.zip
  • SVM_svmmatlab_svm参数寻优_SVM参数_交叉验证SVM_交叉验证,SVM_源码.rar
  • svm参数优化及相关优化算法代码 svm参数优化及相关优化算法代码!svm参数优化及相关优化算法代码
  • SVM参数说明

    千次阅读 2020-12-22 02:09:53
    English: libsvm_options: -s svm_type : set type of SVM (default 0) 0 -- C-SVC 1 -- nu-SVC 2 -- one-class SVM 3 -- epsilon-SVR 4 -- nu-SVR -t kernel_type : set type of kernel ...

    English:

    libsvm_options:

    -s svm_type : set type of SVM (default 0)

    0 -- C-SVC

    1 -- nu-SVC

    2 -- one-class SVM

    3 -- epsilon-SVR

    4 -- nu-SVR

    -t kernel_type : set type of kernel function (default 2)

    0 -- linear: u'*v

    1 -- polynomial: (gamma*u'*v + coef0)^degree

    2 -- radial basis function: exp(-gamma*|u-v|^2)

    3 -- sigmoid: tanh(gamma*u'*v + coef0)

    4 -- precomputed kernel (kernel values in training_instance_matrix)

    -d degree : set degree in kernel function (default 3)

    -g gamma : set gamma in kernel function (default 1/k)

    -r coef0 : set coef0 in kernel function (default 0)

    -c cost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default 1)

    -n nu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default 0.5)

    -p epsilon : set the epsilon in loss function of epsilon-SVR (default 0.1)

    -m cachesize : set cache memory size in MB (default 100)

    -e epsilon : set tolerance of termination criterion (default 0.001)

    -h shrinking: whether to use the shrinking heuristics, 0 or 1 (default 1)

    -b probability_estimates: whether to train a SVC or SVR model for probability estimates, 0 or 1

    (default 0)

    -wi weight: set the parameter C of class i to weight*C, for C-SVC (default 1)

    -v n: n-fold cross validation mode

    ==========================================================

    Chinese:

    Options

    :可用的选项即表示的涵义如下

    -s svm

    类型:

    SVM

    设置类型

    (

    默认

    0)

    0 -- C-SVC

    1 --v-SVC

    2

    –一类

    SVM

    3 -- e -SVR

    4 -- v-SVR

    -t

    核函数类型:核函数设置类型

    (

    默认

    2)

    0

    –线性:

    u'v

    1

    –多项式:

    (r*u'v + coef0)^degree

    2

    RBF

    函数:

    exp(-r|u-v|^2)

    3

    sigmoid

    tanh(r*u'v + coef0)

    -d degree

    :核函数中的

    degree

    设置

    (

    针对多项式核函数

    )(

    默认

    3)

    -g r(gama)

    :核函数中的

    gamma

    函数设置

    (

    针对多项式

    /rbf/sigmoid

    核函数

    )(

    默认

    1/ k)

    -r coef0

    :核函数中的

    coef0

    设置

    (

    针对多项式

    /sigmoid

    核函数

    )((

    默认

    0)

    展开全文
  • SVM参数搜索

    2017-12-28 10:01:55
    利用网格搜索进行参数寻优,效果很好,时间复杂度也可以
  • 利用PSO优化SVM参数的一点小探索

    千次阅读 2020-12-08 18:18:15
    其中PSO代码思路,参照版主 shi01fg的进行的修改..O(∩_∩)O.============利用PSO优化SVM中的c和g图:结果:Elapsed time is 64.799304 seconds.bestc =45.3915bestg =0.0100bestCVaccuarcy =97.7528Accuracy = 97.7528...
  • PSO优化SVM参数.rar

    2020-07-06 17:18:23
    该软件还有一个特点,就是对 SVM 所涉及的参数调节相对比较少,提供了很多的默认参数,利用这些默认参数就可以解决很多问题;并且提供了交互检验(Cross-SVM回归等问题,包括基于一对一算法的多类模式识别问题。
  • MATLAB中使用LIBSVM进行SVM参数寻优

    千次阅读 2019-07-08 15:43:01
    MATLAB中使用LIBSVM进行SVM参数寻优一些资源网站配置svmtrainsvmParams-t:表示选择的核函数类型-g为核函数的参数系数-c为惩罚因子系数-v为交叉验证的数,默认为5具体介绍c,g选择 一些资源网站 1、libSVM 3.23 这套...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,699
精华内容 25,879
关键字:

svm参数

友情链接: server.zip