求帮忙看一个python的SVM程序改主成分维度改哪里 200C

从zouxy大神那里拷贝来的程序

源程序在这里

from numpy import *
import time
import matplotlib.pyplot as plt 


# calulate kernel value
def calcKernelValue(matrix_x, sample_x, kernelOption):
    kernelType = kernelOption[0]
    numSamples = matrix_x.shape[0]
    kernelValue = mat(zeros((numSamples, 1)))

    if kernelType == 'linear':
        kernelValue = matrix_x * sample_x.T
    elif kernelType == 'rbf':
        sigma = kernelOption[1]
        if sigma == 0:
            sigma = 1.0
        for i in xrange(numSamples):
            diff = matrix_x[i, :] - sample_x
            kernelValue[i] = exp(diff * diff.T / (-2.0 * sigma**2))
    else:
        raise NameError('Not support kernel type! You can use linear or rbf!')
    return kernelValue


# calculate kernel matrix given train set and kernel type
def calcKernelMatrix(train_x, kernelOption):
    numSamples = train_x.shape[0]
    kernelMatrix = mat(zeros((numSamples, numSamples)))
    for i in xrange(numSamples):
        kernelMatrix[:, i] = calcKernelValue(train_x, train_x[i, :], kernelOption)
    return kernelMatrix


# define a struct just for storing variables and data
class SVMStruct:
    def __init__(self, dataSet, labels, C, toler, kernelOption):
        self.train_x = dataSet # each row stands for a sample
        self.train_y = labels  # corresponding label
        self.C = C             # slack variable
        self.toler = toler     # termination condition for iteration
        self.numSamples = dataSet.shape[0] # number of samples
        self.alphas = mat(zeros((self.numSamples, 1))) # Lagrange factors for all samples
        self.b = 0
        self.errorCache = mat(zeros((self.numSamples, 2)))
        self.kernelOpt = kernelOption
        self.kernelMat = calcKernelMatrix(self.train_x, self.kernelOpt)


# calculate the error for alpha k
def calcError(svm, alpha_k):
    output_k = float(multiply(svm.alphas, svm.train_y).T * svm.kernelMat[:, alpha_k] + svm.b)
    error_k = output_k - float(svm.train_y[alpha_k])
    return error_k


# update the error cache for alpha k after optimize alpha k
def updateError(svm, alpha_k):
    error = calcError(svm, alpha_k)
    svm.errorCache[alpha_k] = [1, error]


# select alpha j which has the biggest step
def selectAlpha_j(svm, alpha_i, error_i):
    svm.errorCache[alpha_i] = [1, error_i] # mark as valid(has been optimized)
    candidateAlphaList = nonzero(svm.errorCache[:, 0].A)[0] # mat.A return array
    maxStep = 0; alpha_j = 0; error_j = 0

    # find the alpha with max iterative step
    if len(candidateAlphaList) > 1:
        for alpha_k in candidateAlphaList:
            if alpha_k == alpha_i: 
                continue
            error_k = calcError(svm, alpha_k)
            if abs(error_k - error_i) > maxStep:
                maxStep = abs(error_k - error_i)
                alpha_j = alpha_k
                error_j = error_k
    # if came in this loop first time, we select alpha j randomly
    else:           
        alpha_j = alpha_i
        while alpha_j == alpha_i:
            alpha_j = int(random.uniform(0, svm.numSamples))
        error_j = calcError(svm, alpha_j)

    return alpha_j, error_j


# the inner loop for optimizing alpha i and alpha j
def innerLoop(svm, alpha_i):
    error_i = calcError(svm, alpha_i)

    ### check and pick up the alpha who violates the KKT condition
    ## satisfy KKT condition
    # 1) yi*f(i) >= 1 and alpha == 0 (outside the boundary)
    # 2) yi*f(i) == 1 and 0<alpha< C (on the boundary)
    # 3) yi*f(i) <= 1 and alpha == C (between the boundary)
    ## violate KKT condition
    # because y[i]*E_i = y[i]*f(i) - y[i]^2 = y[i]*f(i) - 1, so
    # 1) if y[i]*E_i < 0, so yi*f(i) < 1, if alpha < C, violate!(alpha = C will be correct) 
    # 2) if y[i]*E_i > 0, so yi*f(i) > 1, if alpha > 0, violate!(alpha = 0 will be correct)
    # 3) if y[i]*E_i = 0, so yi*f(i) = 1, it is on the boundary, needless optimized
    if (svm.train_y[alpha_i] * error_i < -svm.toler) and (svm.alphas[alpha_i] < svm.C) or\
        (svm.train_y[alpha_i] * error_i > svm.toler) and (svm.alphas[alpha_i] > 0):

        # step 1: select alpha j
        alpha_j, error_j = selectAlpha_j(svm, alpha_i, error_i)
        alpha_i_old = svm.alphas[alpha_i].copy()
        alpha_j_old = svm.alphas[alpha_j].copy()

        # step 2: calculate the boundary L and H for alpha j
        if svm.train_y[alpha_i] != svm.train_y[alpha_j]:
            L = max(0, svm.alphas[alpha_j] - svm.alphas[alpha_i])
            H = min(svm.C, svm.C + svm.alphas[alpha_j] - svm.alphas[alpha_i])
        else:
            L = max(0, svm.alphas[alpha_j] + svm.alphas[alpha_i] - svm.C)
            H = min(svm.C, svm.alphas[alpha_j] + svm.alphas[alpha_i])
        if L == H:
            return 0

        # step 3: calculate eta (the similarity of sample i and j)
        eta = 2.0 * svm.kernelMat[alpha_i, alpha_j] - svm.kernelMat[alpha_i, alpha_i] \
                  - svm.kernelMat[alpha_j, alpha_j]
        if eta >= 0:
            return 0

        # step 4: update alpha j
        svm.alphas[alpha_j] -= svm.train_y[alpha_j] * (error_i - error_j) / eta

        # step 5: clip alpha j
        if svm.alphas[alpha_j] > H:
            svm.alphas[alpha_j] = H
        if svm.alphas[alpha_j] < L:
            svm.alphas[alpha_j] = L

        # step 6: if alpha j not moving enough, just return     
        if abs(alpha_j_old - svm.alphas[alpha_j]) < 0.00001:
            updateError(svm, alpha_j)
            return 0

        # step 7: update alpha i after optimizing aipha j
        svm.alphas[alpha_i] += svm.train_y[alpha_i] * svm.train_y[alpha_j] \
                                * (alpha_j_old - svm.alphas[alpha_j])

        # step 8: update threshold b
        b1 = svm.b - error_i - svm.train_y[alpha_i] * (svm.alphas[alpha_i] - alpha_i_old) \
                                                    * svm.kernelMat[alpha_i, alpha_i] \
                             - svm.train_y[alpha_j] * (svm.alphas[alpha_j] - alpha_j_old) \
                                                    * svm.kernelMat[alpha_i, alpha_j]
        b2 = svm.b - error_j - svm.train_y[alpha_i] * (svm.alphas[alpha_i] - alpha_i_old) \
                                                    * svm.kernelMat[alpha_i, alpha_j] \
                             - svm.train_y[alpha_j] * (svm.alphas[alpha_j] - alpha_j_old) \
                                                    * svm.kernelMat[alpha_j, alpha_j]
        if (0 < svm.alphas[alpha_i]) and (svm.alphas[alpha_i] < svm.C):
            svm.b = b1
        elif (0 < svm.alphas[alpha_j]) and (svm.alphas[alpha_j] < svm.C):
            svm.b = b2
        else:
            svm.b = (b1 + b2) / 2.0

        # step 9: update error cache for alpha i, j after optimize alpha i, j and b
        updateError(svm, alpha_j)
        updateError(svm, alpha_i)

        return 1
    else:
        return 0


# the main training procedure
def trainSVM(train_x, train_y, C, toler, maxIter, kernelOption = ('rbf', 1.0)):
    # calculate training time
    startTime = time.time()

    # init data struct for svm
    svm = SVMStruct(mat(train_x), mat(train_y), C, toler, kernelOption)

    # start training
    entireSet = True
    alphaPairsChanged = 0
    iterCount = 0
    # Iteration termination condition:
    #   Condition 1: reach max iteration
    #   Condition 2: no alpha changed after going through all samples,
    #                in other words, all alpha (samples) fit KKT condition
    while (iterCount < maxIter) and ((alphaPairsChanged > 0) or entireSet):
        alphaPairsChanged = 0

        # update alphas over all training examples
        if entireSet:
            for i in xrange(svm.numSamples):
                alphaPairsChanged += innerLoop(svm, i)
            print '---iter:%d entire set, alpha pairs changed:%d' % (iterCount, alphaPairsChanged)
            iterCount += 1
        # update alphas over examples where alpha is not 0 & not C (not on boundary)
        else:
            nonBoundAlphasList = nonzero((svm.alphas.A > 0) * (svm.alphas.A < svm.C))[0]
            for i in nonBoundAlphasList:
                alphaPairsChanged += innerLoop(svm, i)
            print '---iter:%d non boundary, alpha pairs changed:%d' % (iterCount, alphaPairsChanged)
            iterCount += 1

        # alternate loop over all examples and non-boundary examples
        if entireSet:
            entireSet = False
        elif alphaPairsChanged == 0:
            entireSet = True

    print 'Congratulations, training complete! Took %fs!' % (time.time() - startTime)
    return svm


# testing your trained svm model given test set
def testSVM(svm, test_x, test_y):
    test_x = mat(test_x)
    test_y = mat(test_y)
    numTestSamples = test_x.shape[0]
    supportVectorsIndex = nonzero(svm.alphas.A > 0)[0]
    supportVectors      = svm.train_x[supportVectorsIndex]
    supportVectorLabels = svm.train_y[supportVectorsIndex]
    supportVectorAlphas = svm.alphas[supportVectorsIndex]
    matchCount = 0
    for i in xrange(numTestSamples):
        kernelValue = calcKernelValue(supportVectors, test_x[i, :], svm.kernelOpt)
        predict = kernelValue.T * multiply(supportVectorLabels, supportVectorAlphas) + svm.b
        if sign(predict) == sign(test_y[i]):
            matchCount += 1
    accuracy = float(matchCount) / numTestSamples
    return accuracy


# show your trained svm model only available with 2-D data
def showSVM(svm):
    if svm.train_x.shape[1] != 2:
        print "Sorry! I can not draw because the dimension of your data is not 2!"
        return 1

    # draw all samples
    for i in xrange(svm.numSamples):
        if svm.train_y[i] == -1:
            plt.plot(svm.train_x[i, 0], svm.train_x[i, 1], 'or')
        elif svm.train_y[i] == 1:
            plt.plot(svm.train_x[i, 0], svm.train_x[i, 1], 'ob')

    # mark support vectors
    supportVectorsIndex = nonzero(svm.alphas.A > 0)[0]
    for i in supportVectorsIndex:
        plt.plot(svm.train_x[i, 0], svm.train_x[i, 1], 'oy')

    # draw the classify line
    w = zeros((2, 1))
    for i in supportVectorsIndex:
        w += multiply(svm.alphas[i] * svm.train_y[i], svm.train_x[i, :].T) 
    min_x = min(svm.train_x[:, 0])[0, 0]
    max_x = max(svm.train_x[:, 0])[0, 0]
    y_min_x = float(-svm.b - w[0] * min_x) / w[1]
    y_max_x = float(-svm.b - w[0] * max_x) / w[1]
    plt.plot([min_x, max_x], [y_min_x, y_max_x], '-g')
    plt.show()

测试代码在这里

 from numpy import *
import SVM

################## test svm #####################
## step 1: load data
print ("step 1: load data...")
dataSet = []
labels = []
fileIn = open('D:\Python33\SVM\testSet.txt')
for line in fileIn.readlines():
    lineArr = line.strip().split('\t')
    dataSet.append([float(lineArr[0]), float(lineArr[1])])
    labels.append(float(lineArr[2]))

dataSet = mat(dataSet)
labels = mat(labels).T
train_x = dataSet[0:81, :]
train_y = labels[0:81, :]
test_x = dataSet[80:101, :]
test_y = labels[80:101, :]

## step 2: training...
print ("step 2: training...")
C = 0.6
toler = 0.001
maxIter = 50
svmClassifier = SVM.trainSVM(train_x, train_y, C, toler, maxIter, kernelOption = ('linear', 0))

## step 3: testing
print ("step 3: testing...")
accuracy = SVM.testSVM(svmClassifier, test_x, test_y)

## step 4: show the result
print ("step 4: show the result...")    
print ('The classify accuracy is: %.3f%%' % (accuracy * 100))
SVM.showSVM(svmClassifier)

测试的数据在这里

3.542485 1.977398 -1
3.018896 2.556416 -1
7.551510 -1.580030 1
2.114999 -0.004466 -1
8.127113 1.274372 1
7.108772 -0.986906 1
8.610639 2.046708 1
2.326297 0.265213 -1
3.634009 1.730537 -1
0.341367 -0.894998 -1
3.125951 0.293251 -1
2.123252 -0.783563 -1
0.887835 -2.797792 -1
..........

现在我想把这个二维主成分的SVM改成分类五维主成分的

就是把测试的数据改成比如
3.125951 0.293251 2.123252 -0.783563 0.887835 -1
0.887835 -2.797792 3.634009 1.730537 -2.797792 -1
但还是二分类,
请问源程序代码和测试代码应该改哪里?

2
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
权重确定方法之主成分分析法
转载自:http://www.itongji.cn/article/042620032013.html 什么是权重呢?所谓权重,是指某指标在整体评价中的相对重要程度。权重越大则该指标的重要性越高,对整体的影响就越高。       权重要满足两个条件:每个指标的权重在0、1之间。所有指标的权重和为1。     权重的确定方法有很多,这里我们学习用主成分分析确定权重。
协方差矩阵和主成分分析
今天看论文的时候又看到了协方差矩阵这个破东西,以前看模式分类的时候就特困扰,没想到现在还是搞不清楚,索性开始查协方差矩阵的资料,恶补之后决定马上记录下来,嘿嘿~本文我将用自认为循序渐进的方式谈谈协方差矩阵。 统计学的基本概念 学过概率统计的孩子都知道,统计里最基本的概念就是样本的均值,方差,或者再加个标准差。首先我们给你一个含有n个样本的集合,依次给出这些概念的公式描述,这些高中学过数学的孩子
PCA主成分数量(降维维度)选择
用PCA做降维,降到多少维合适呢?
Python之数组维度
a=np.array([[[1],[2]] ,[[3],[4]] ,[[5],[6]]]) print(a.shape)&amp;gt;&amp;gt;(3,2,1)
请实习生帮忙改Bug!
(点击上方公众号,可快速关注):)推荐程序员必备微信号 ▼程序员内参微信号:programmer0001推荐理由:在这里,我们分享程序员相关技术,职场生活,行业热点资讯。不定期还会分享IT趣文和趣图。这里属于我们程序员自己的生活,工作和娱乐空间。 ▼长按下方↓↓↓二维码识别关注
python PCA主成分分析进行降维度
#PCA对数据进行降维 from numpy import * def confloat(x): r=[float(i) for i in x] return r def loadDataSet(fileName, delim='\t'): fr = open(fileName) stringArr = [line.strip().split(delim) f...
协方差矩阵与主成分分析(PCA)
转自:http://pinkyjie.com/2011/02/24/covariance-pca/ 上次谈了协方差矩阵之后,感觉写这种科普性文章还不错,那我就再谈一把协方差矩阵吧。上次那篇文章在理论层次介绍了下协方差矩阵,没准很多人觉得这东西用处不大,其实协方差矩阵在好多学科里都有很重要的作用,比如多维的正态分布,再比如今天我们今天的主角——主成分分析(Principal Compone
请求高手帮忙把程序的分组框背景改一下
请求高手帮忙把程序的分组框背景改一下.............................
如何从python调用svm
最近在用svm ,用的是台湾M
SD敢达改机详细资料
教你改机的步骤,改机的详细改法,该改哪里一眼就可以看出
SVM分类器-LS-SVM(二)
LS-SVM工具箱的使用: 一、安装LS-SVM 下载ls-svm,然后安装即可,可以参考1. 二、使用LS-SVM (1)分类 (2)回归 参考1.http://blog.csdn.net/ahuang1900/article/details/8971670
主成分分析法以及python实现
本文主要介绍一种降维算法,主成分分析法,Principal Components Analysis,简称PCA,这种方法的目标是找到一个数据近似集中的子空间,至于如何找到这个子空间,下文会给出详细的介绍,PCA比其他降维算法更加直接,只需要进行一次特征向量的计算即可。(在Matlab,python,R中这个可以轻易的用eig()函数来实现)。 假设我们给出这样一个数据集代表m辆不同种类的汽车
帮忙写个小程序,可以双击后把电脑的IP地址和DNS服务器地址改为我想要的?
设置IP地址批处理,将如下代码用记事本保存为.bat文件,如:IPadd.bat, 双击运行即可。 @echo off echo 修改IP地址工具 http://www.zreading.com/ rem 设置变量 set Nic=本地连接  rem //可以根据你的需要更改, set Add=192.168.1.99 echo —————————————
基于libsvm的图像分割(小黄鸭子)
基于libsvm的图像分割 ——30cases与40cases&25cases“联谊”第一弹 By faruto 2010/6/2          很早就想用libsvm来做图像相关的一些东西,因为libsvm我自认为还算熟悉,图像基本的一些东西也都零散的学过,但用libsvm来做图像相关的,还未曾“染指”。正好rocwoods的25cases有这个相关的,所以详细研究学习了一下~
python 按不同维度求和,最值,均值
当变量维数加大时很难想象是怎样按不同维度求和的,高清楚一个,其他的应该就很清楚了,什么都不说了,上例子,例子一看便明白…..a=range(27) a=np.array(a) a=np.reshape(a,[3,3,3])输出a的结果是:array([[[ 0, 1, 2], [ 3, 4, 5], [ 6, 7, 8]], [[ 9, 10
主成分分析法原理及其python实现
主成分分析法原理及其python实现
SVM-SVR
使用Python 的sklearn包来训练svm,当然也可以使用libsvm。 主要想用svr做预测,我们知道svm是做分类的,同样基于svm的改进版svr也同样和可以做预测。 from sklearn import svm.SVR() svr的初始化:     clf=svm.SVR(         C=c_value,         cache_si
机器学习 之 SVM VC维度、样本数目与经验风险最小化的关系
VC维在有限的训练样本情况下,当样本数 n 固定时,此时学习机器的 VC 维越高学习机器的复杂性越高。VC 维反映了函数集的学习能力,VC 维越大则学习机器越复杂(容量越大)。         所谓的结构风险最小化就是在保证分类精度(经验风险)的同时,降低学习机器的 VC 维,可以使学习机器在整个样本集上的期望风险得到控制。         经验风险和实际风险之间的关系,注意引入这个原因是
如何输出python中list的维度
import numpy as np a = [[1,2],[3,4]] print(np.array(a).shape)
numpy求平均值的维度设定
>>> a = np.array([[1, 2], [3, 4]]) >>> np.mean(a) # 将上面二维矩阵的每个元素相加除以元素个数(求平均数) 2.5 >>> np.mean(a, axis=0) # axis=0,计算所有子数组的平均值 array([ 2., 3.]) >>> np.mean(a, axis=1) # axis=1,对每一个子数组,计算它的平均
python:numpy库ndarray多维数组的维度变换方法:reshape、resize、swapaxes、flatten
numpy库对多维数组有非常灵巧的处理方式,主要的处理方法有: .reshape(shape) : 不改变数组元素,返回一个shape形状的数组,原数组不变 .resize(shape) : 与.reshape()功能一致,但修改原数组 In [22]: a = np.arange(20) #原数组不变 In [23]: a.reshape([4,5]) Out[23]: array([[ ...
R语言手动计算主成分分析(PCA)及其在R函数的实现
R语言手动计算主成分分析(PCA)及其在R函数的实现了解PCA的原理,但总是无法用R语言实现,这次算是有个教程。  转自:http://blog.163.com/xiaoji0106@126/blog/static/13613466120133185842687/       主成分分析(principal component analysis,PCA)是一种降维技术,把多个变量化为能够反映原始变
opencv类:PCA降低数据的维度(主成分分析法的学习)
PCA降维的学习以下代码是在opencv中的函数pca.cpp的基础上进行了一些更改,主要更改体现在读取降维样本方面,并对代码加上了一些自己理解的注释: `#include <iostream> #include <fstream> #include <sstream> #include <opencv2/core/core.hpp> #include <opencv2/highgui/high
改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名
cat &amp;gt; ca-config.json &amp;lt;&amp;lt;EOF { &quot;signing&quot;: { &quot;default&quot;: { &quot;expiry&quot;: &quot;87600h&quot; }, &quot;profiles&quot;: { &quot;kubernetes&quot;: { &quot;usages&quot;: [
测试改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端改名称看移动端
一、环境说明 操作系统 主机名 节点及功能 IP 备注 CentOS7.5 X86_64                                      k8s-master                             master/etcd/registry                              ...
tf.transpose()交换张量位置(矩阵转置)
tf.transpose()交换张量位置(矩阵转置) tf.transpose() 是TensorFlow中用于矩阵,张量转置用的,除了可以交换二维矩阵的行和列之外,还可以交换张量的不同轴之间的顺序,函数使用方法如: transpose( a, perm=None, name='transpose' ) 其中,perm参数用于指定交换后的张量的轴是原先张量的轴的位
数组的维度
一个数组中的某个元素,当用数组下标表示的时候,需要用几个数字来表示才能唯一确定这个元素,这个数组就是几维。例如,一个数字确定一个元素:a[7]就是一维的 两个数字确定一个元素:b[5][9]是二维 三个数字:c[6][8][1]是三维 ………… n个数字就是n维可以把数组的维看成是“数组套数组的层数”例如,数组{ 1, 5, 9, 0 }是一维数组,要找到数字9只需找第三个数字。x={ {1
一个改程序小记
原文首发 CC98 白洪欢老师答疑版(http://10.71.45.99/dispbbs.asp?boardID=323&ID=1979518)今天的改程序小记昨晚逛 WZ 水区,居然有个人问怎么改程序。是这么一个东西:文件名叫“补丁.exe”……(那改了后是不是该叫“补丁过的补丁.exe”之类的了?)按菜单上这个“设置”,会出来这么个框。那个人说要让那个框出来时编辑框里面就有文字,直接改资源没
系统学习机器学习之维度归约
这里,我们讨论特征选择和特征提取,前者选取重要的特征子集,后者由原始输入形成较少的新特征,理想情况下,无论是分类还是回归,我们不应该将特征选择或特征提取作为一个单独的进程,分类或者回归方法应该能够利用任何必要的特征,而丢弃不相关的特征。但是,考虑到算法存储量和时间的复杂度,或者输入不必要的特征等原因,还是需要降维。较简单的模型在小数据上更为鲁棒,有小方差,模型的变化更依赖于样本的特殊性,包括噪声,
求大神 帮忙改一下代码
&amp;lt;form action=&quot;https://www.baidu.com/s&quot;&amp;gt;&amp;lt;div align=&quot;center&quot;&amp;gt; &amp;lt;input name=tn type=hidden value=baidu&amp;gt;&amp;lt;a href=&quot;http://www.baidu.com/&quot;&amp;gt;&amp;lt;img src=&quot;https://ss0.bdsta
主成分分析(PCA)算法的简单推导和实例
问题1:为什么要降维?    我们在处理实际问题的时候,进行特征提取过程中,提取的特征维数太多经常会导致特征匹配时过于复杂,消耗计算资源。   问题2:降维的方法有哪些? 特征降维一般分为两类:特征提取和特征抽取。特征选择就是简单的从高纬度的特征中选择其中一个子集来作为新的特征。特征抽取是将高纬度的特征经过一些函数映射到低纬度,将其作为新的特征。 我们常见的分析方法包括有因子分析和主成分
SVM学习笔记(三)---核函数
转载自:http://www.cnblogs.com/jerrylead/archive/2011/03/18/1988406.html  7 核函数(Kernels) 考虑我们最初在“线性回归”中提出的问题,特征是房子的面积x,这里的x是实数,结果y是房子的价格。假设我们从样本点的分布中看到x和y符合3次曲线,那么我们希望使用x的三次多项式来逼近这些样本点。那么首先需要将特征x扩
SVM—当样本数小于维度的时候
比如:人脸识别的时候,两个人脸的样本数分别为5,PCA降维后维度为35。 用SVM训练的模型进行分类时候,往往发现线性核要比高斯核正确率高。这是为什么? 我想到的原因如下,并不一定正确,欢迎网友指正: (1)一般来说,当选取高斯核函数时候,训练得到的函数(就是那个分类超平面)可以以任意高的精度逼近给定的连续函数,这意味着用高斯核的效果至少不会比线性核差。但是问题在于,g值的选择会对得到的分类
基于Python和Numpy的主成分分析
主成分分析(Principal Component Analysis)是一种对特征进行降维的方法。在机器学习以及影像分类中广泛使用,能够极大提高无监督特征学习的速度。由于观测指标间存在相关性,将导致信息的重叠与低效。为此,我们更倾向于用更少量的、尽可能多的能反映源特征的新特征来代替原始观测指标。这就是主成分分析,其可以看作是高维空间通过旋转坐标系,找到最佳投影的过程。换言之,即将n维特征映射到k维
腾讯视频统一调用代码
//加载腾讯视频 (注意,默认情况下,视频处为最高级,总是处于页面的最上层,应当设置其透明,player.addParam("wmode","transparent");) 一般: Js:  type="text/javascript" src="js/swfobject.js"> type="text/javascript" src="http://qzs.qq.c
主成份分析(PCA)详解
主成分分析法(Principal Component Analysis)大多在数据维度比较高的时候,用来减少数据维度,因而加快模型训练速度。另外也有些用途,比如图片压缩(主要是用SVD,也可以用PCA来做)、因子分析等。具体怎么用,看个人需求如何,这篇文章主要解释一下PCA的原理。
SVM中matlab版本的交叉验证和参数选择
进行SVM时运用高斯核,需要参数选择,改程序用来参数选择
Python_主成分分析
Python实现简单主成分分析
Python 之 sklearn 计算 SVM 隶属度
python中的sklean已经集成SVM算法,其中包含fit(), predict()等,我们只要输入训练样本和标记,以及模型参数,就可得到分类的结果。 关于这个的代码实现已有很多,SVC 参数详见: 详址:http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC 但对于libsvm之中实现的隶属度计算仍未找到相似讲解与示例,先给出源码如下。
matlab实现主成分分析 并计算累积贡献率
使用MATLAB实现主成分分析所使用的函数主要是【princomp函数】,本博客主要讲述代码实现及部分关键名词解释,理论部分请读者自行百度。贡献率:每一维数据对于区分整个数据的贡献,贡献率最大的显然是主成分,第二大的是次主成分......[coef,score,latent,t2] = princomp(x);(个人观点):x:为要输入的n维原始数据。带入这个matlab自带函数,将会生成新的n维...
文章热词 机器学习教程 Objective-C培训 交互设计视频教程 颜色模型 设计制作学习
相关热词 mysql关联查询两次本表 native底部 react extjs glyph 图标 哪里看区块链价格 svm教程python