机器学习技法:Homework #5 特征变换&Soft-Margin SVM相关习题

原文地址:https://www.jianshu.com/p/6bf801bdc644

特征变换

问题描述


程序实现

# coding: utf-8

import numpy as np
from cvxopt import matrix, solvers
from sklearn import svm

def gen_data():
    X = [[1, 0], [0, 1], [0, -1], [-1, 0], [0, 2], [0, -2], [-2, 0]]
    X = np.array(X)
    y = [-1, -1, -1, 1, 1, 1, 1]
    y = np.array(y)
    assert X.shape[0] == y.shape[0] and X.shape[1] == 2, "wrong data shape!"
    return X, y

def explict_transform(X):
    assert X.shape[1] == 2, "wrong shape of X!"
    num = X.shape[0]
    X1 = X[:, 0]
    X2 = X[:, 1]
    new_X1 = X2 ** 2 - 2 * X1 + 3
    new_X2 = X1 ** 2 - 2 * X2 - 3
    new_X = np.concatenate((new_X1.reshape((num, 1)), new_X2.reshape(num, 1)), axis=1)
    return new_X

def svm_hard_linear(X, y):
    num, dim = X.shape
    P = matrix(np.concatenate((np.zeros((1, 1 + dim)),
                               np.concatenate((np.zeros((dim, 1)), np.eye(dim)), axis=1)), axis=0), tc='d')
    q = matrix(np.zeros((1 + dim, 1)), tc='d')
    G = matrix(-y * np.concatenate((np.ones((num, 1), dtype=np.float), X), axis=1), tc='d')
    h = matrix(-np.ones((num, 1)), tc='d')
    sol = solvers.qp(P, q, G, h)
    return sol['x']

def implicit_transform(X):
    assert X.shape[1] == 2, "wrong shape of X!"
    num=X.shape[0]
    X1 = X[:, 0]
    X2 = X[:, 1]
    new_X1=np.ones((num,1))
    new_X2=2**(0.5)*X1
    new_X3=2**(0.5)*X2
    new_X4=X1**2
    new_X5=X2**2
    new_X6=2**(0.5)*X1*X2
    new_X = np.concatenate((new_X1.reshape((num, 1)), new_X2.reshape(num, 1),new_X3.reshape(num, 1),
                            new_X4.reshape(num, 1),new_X5.reshape(num, 1),new_X6.reshape(num, 1)), axis=1)
    return new_X

if __name__ == "__main__":
    np.set_printoptions(precision=6,suppress=True)
    X, y = gen_data()

    # explicit
    # 2
    exp_X= explict_transform(X)
    u = np.array(svm_hard_linear(exp_X, y.reshape(y.shape[0],1)))
    b = u[0, :]
    w = u[1:, :]
    print("b:\n", b)
    print("w:\n", w)

    # implicit
    clf=svm.SVC(C=1000000,kernel='poly',degree=2,gamma=1,coef0=1)
    clf.fit(X,y)
    # 3
    alpha_y=clf.dual_coef_
    alpha_y=alpha_y.reshape((alpha_y.shape[1],))
    sv_ID=clf.support_
    sv_y=[]
    for i in range(sv_ID.shape[0]):
        sv_y.append(y[sv_ID[i]])
    alpha=[alpha_y[i]/sv_y[i] for i in range(sv_ID.shape[0])]
    print("alpha*y:\n",alpha_y)
    print("alpha:\n",alpha)
    sv_X=clf.support_vectors_
    print("support vectors:\n",sv_X)
    # 4
    b=clf.intercept_
    print("b:\n",b)
    w=np.dot(alpha_y,implicit_transform(sv_X)).reshape((6,1))
    print("w:\n",w)

运行结果

Soft-Margin SVM

问题描述



程序实现

# coding: utf-8

import numpy as np
from sklearn import svm
import matplotlib.pyplot as plt

def read_data(dataFile):
    with open(dataFile,'r') as f:
        lines=f.readlines()
        data_list=[]
        for line in lines:
            line=line.strip().split()
            data_list.append([float(l) for l in line])
        dataArray=np.array(data_list)
        num_data=dataArray.shape[0]
        num_dim=dataArray.shape[1]-1
        dataX=dataArray[:,1:].reshape((num_data,num_dim))
        dataY=dataArray[:,0].reshape((num_data,))
        return dataX,dataY

data_X,data_Y=read_data("features.train")
test_X,test_Y=read_data("features.test")

def convert_label(dataY,chosen_class):
    num=dataY.shape[0]
    new_Y=-np.ones_like(dataY)
    for i in range(num):
        if dataY[i]==chosen_class:
            new_Y[i]=1
    return new_Y

def zero_one_cost(pred,Y):
    assert pred.shape==Y.shape,"wrong shape of pred and Y!"
    return np.sum(np.not_equal(pred,Y))/Y.shape[0]

def question15():
    c_list=[-6,-4,-2,0,2]
    w_list=[]
    new_Y=convert_label(data_Y,0)
    for i in c_list:
        clf=svm.LinearSVC(loss="hinge",C=10**i)
        clf.fit(data_X,new_Y)
        w_list.append(np.sqrt(np.sum(clf.coef_**2)))
    plt.figure(figsize=(10,6))
    plt.plot(c_list,w_list,'b')
    plt.plot(c_list,w_list,'ro')
    for (c,w) in zip(c_list,w_list):
        plt.text(c+0.1,w,str(round(w,4)))
    plt.xlabel("log10(C)")
    plt.ylabel("||w||")
    plt.xlim(-8,4)
    plt.title("||w|| versus log10(C)")
    plt.savefig("15.png")

def question16and17():
    # 16
    c_list = [-6, -4, -2, 0, 2]
    Ein_list=[]
    alpha_sum_list=[]
    new_Y=convert_label(data_Y,8)
    for i in c_list:
        clf=svm.SVC(C=10**i,kernel='poly',degree=2,gamma=1,coef0=1)
        clf.fit(data_X,new_Y)
        pred=clf.predict(data_X)
        Ein_list.append(zero_one_cost(pred,new_Y))
        alpha_sum_list.append(np.sum(np.abs(clf.dual_coef_)))
        # print(np.sum(clf.dual_coef_))
        # print(clf.n_support_)
    plt.figure(figsize=(10,6))
    plt.plot(c_list,Ein_list,'b')
    plt.plot(c_list,Ein_list,'ro')
    for (c,e) in zip(c_list,Ein_list):
        plt.text(c+0.1,e,str(round(e,4)))
    plt.xlabel("log10(C)")
    plt.ylabel("Ein")
    plt.xlim(-8, 4)
    plt.title("Ein versus log10(C)")
    plt.savefig("16.png")
    # 17
    plt.figure(figsize=(10,6))
    plt.plot(c_list,alpha_sum_list,'b')
    plt.plot(c_list,alpha_sum_list,'ro')
    for (c,a) in zip(c_list,alpha_sum_list):
        plt.text(c+0.1,a,str(round(a,6)))
    plt.xlabel("log10(C)")
    plt.ylabel("sum of alpha")
    plt.xlim(-8, 4)
    plt.title("sum of alpha versus log10(C)")
    plt.savefig("17.png")

def question18():
    c_list=[-3,-2,-1,0,1]
    dis_list=[]
    new_Y=convert_label(data_Y,0)
    for i in c_list:
        clf=svm.SVC(C=10**i,kernel='rbf',gamma=100)
        clf.fit(data_X,new_Y)
        sv_ID=clf.support_
        dis_list.append(new_Y[sv_ID[0]]*clf.decision_function(data_X)[sv_ID[0]])
    plt.figure(figsize=(10,6))
    plt.plot(c_list,dis_list,'b')
    plt.plot(c_list,dis_list,'ro')
    for (c,w) in zip(c_list,dis_list):
        plt.text(c+0.1,w,str(round(w,4)))
    plt.xlabel("log10(C)")
    plt.ylabel("free sv's function distance to hyperplane")
    plt.xlim(-5, 3)
    plt.ylim(ymax=1.01)
    plt.title("free sv's function distance to hyperplane versus log10(C)")
    plt.savefig("18.png")

def question19():
    new_Y=convert_label(data_Y,0)
    new_test_Y=convert_label(test_Y,0)
    gamma_list=[0,1,2,3,4]
    Eout_list=[]
    for i in gamma_list:
        clf=svm.SVC(C=0.1,kernel='rbf',gamma=10**i)
        clf.fit(data_X,new_Y)
        pred=clf.predict(test_X)
        Eout_list.append(zero_one_cost(pred,new_test_Y))
    plt.figure(figsize=(10,6))
    plt.plot(gamma_list,Eout_list,'b')
    plt.plot(gamma_list,Eout_list,'ro')
    for (c,w) in zip(gamma_list,Eout_list):
        plt.text(c+0.1,w,str(round(w,4)))
    plt.xlabel("log10(gamma)")
    plt.ylabel("Eout")
    plt.xlim(-1, 5)
    plt.ylim(ymax=0.19)
    plt.title("Eout versus log10(C)")
    plt.savefig("19.png")

def question20():
    new_Y=convert_label(data_Y,0)
    gamma_list=[0,1,2,3,4]
    chosen_gamma=[]
    for t in range(100):
        np.random.seed(t)
        chosenID=np.random.randint(0,data_X.shape[0],1000)
        train_X=[]
        train_Y=[]
        val_X=[]
        val_Y=[]
        for i in range(data_X.shape[0]):
            if(i not in chosenID):
                train_X.append(data_X[i,:])
                train_Y.append(new_Y[i])
            else:
                val_X.append(data_X[i,:])
                val_Y.append(new_Y[i])
        train_X=np.array(train_X)
        train_Y=np.array(train_Y)
        val_X=np.array(val_X)
        val_Y=np.array(val_Y)
        Eval_list=[]
        for g in gamma_list:
            clf=svm.SVC(C=0.1,kernel='rbf',gamma=10**g)
            clf.fit(train_X,train_Y)
            pred=clf.predict(val_X)
            Eval_list.append(zero_one_cost(pred,val_Y))
        chosen_gamma.append(gamma_list[Eval_list.index(min(Eval_list))])
    times=[]
    for i in gamma_list:
        times.append(chosen_gamma.count(i))
    plt.figure(figsize=(10,6))
    plt.bar(left=(gamma_list),height=(times),width=1,align="center",yerr=0.000001)
    for (c,w) in zip(gamma_list,times):
        plt.text(c,w*1.03,str(round(w,4)))
    plt.xlabel("log10(gamma)")
    plt.ylabel("the number of chosen times")
    plt.xlim(-1, 5)
    plt.ylim(0,80)
    plt.title("the number of chosen times for gamma")
    plt.savefig("20.png")

if __name__=="__main__":

    question15()
    question16and17()
    question18()
    question19()
    question20()

运行结果






原文地址:https://www.cnblogs.com/cherrychenlee/p/10802685.html

时间: 2024-10-24 04:15:10

机器学习技法:Homework #5 特征变换&Soft-Margin SVM相关习题的相关文章

SVM3 Soft Margin SVM

之前分为两部分讨论过SVM.第一部分讨论了线性SVM,并且针对线性不可分的数据,把原始的问题转化为对偶的SVM求解.http://www.cnblogs.com/futurehau/p/6143178.html 然后考虑到特征数量特别特别多的时候,引入核函数的求解.http://www.cnblogs.com/futurehau/p/6149558.html 但是,之前也遗留了一个问题,就是比如高斯核函数或其他的核函数,虽然large margin能够在一定程度上防止过拟合,但是加入你的核函数太

机器学习技法(5)--Kernel Logistic Regression

回顾一下soft margin SVM的知识: 然而从另一个角度来看,分为真的有犯错和没有犯错: 在没有犯错的时候,ξn=0就好了.于是ξn就可以写成一个求max的过程.根据这个思路,我们有了SVM的新形式: 这样一来,ξn就不再是一个独立的变量,它变成了一个由b和w决定的变量,这样的话,式子又被简化了. 简化后的式子和L2的正则差不多: SVM和正则化有很多相似的点: 这些联系可以帮助我们以后换一种视角看待SVM. 下面从错误衡量的视角看LR和SVM: 由此可以看出SVM≍L2的LR. 那么再

机器学习技法——第1-2讲.Linear Support Vector Machine

本栏目(机器学习)下机器学习技法专题是个人对Coursera公开课机器学习技法(2015)的学习心得与笔记.所有内容均来自Coursera公开课Machine Learning Techniques中Hsuan-Tien Lin林轩田老师的讲解.(https://class.coursera.org/ntumltwo-001/lecture) 第1讲-------Linear Support Vector Machine 在机器学习基石介绍的基本工具(主要围绕特征转换Feature Transf

机器学习技法课之Aggregation模型

Courses上台湾大学林轩田老师的机器学习技法课之Aggregation 模型学习笔记. 混合(blending) 本笔记是Course上台湾大学林轩田老师的<机器学习技法课>的学习笔记,用于学习之后的一些总结. 首先,对于Aggregation模型,其基本思想就是使用不同的 g t 来合成最后的预测模型 G t . 对于合成的方式主要有四种: 方法 数学描述 1. 选择.选择最值得可信的 g t 来当做最终的模型,而这个 gt 可以使用validation set 来进行选择 $$G(x)

【CS】尺度不变特征变换匹配算法SIFT(2)

尺度不变特征变换匹配算法SIFT(2) e-mail:[email protected] SIFT算法 在10月初,草草学习了一下SIFT(可以戳这里查看),主要是调用opencv函数库了的函数进行了实践,而并没有深入了解SIFT描述子的原理以及opencv中相关函数的用法和参数说明.本篇blog作为LZ的小笔记,记录一下opencv中相关函数的说明,对于SIFT特征的原理后续将花时间继续了解. C++代码 环境:vs2010+opencv2.3.1+win7 ×64 这部分代码还是使用上一篇S

【作业四】林轩田机器学习技法 + 机器学习公开新课学习个人体会

这次作业的coding任务量比较大,总的来说需要实现neural network, knn, kmeans三种模型. Q11~Q14为Neural Network的题目,我用单线程实现的,运行的时间比较长,因此把这几道题的正确答案记录如下: Q11: 6 Q12: 0.001 Q13: 0.01 Q14: 0.02 ≤ Eout ≤ 0.04 其中Q11和Q14的答案比较明显,Q12和Q13有两个答案比较接近(参考了讨论区的内容,最终也调出来了) neural network的代码实现思路如下:

特征提取之SIFT(尺度不变性特征变换)

SIFT(Scale-invariant feature transform,尺度不变性特征变换)是一种检测局部特征的算法,该算法通过求一幅图中的特征点(interest points,or corner points)及其有关scale和orientation的描述子得到特征并进行图像特征点匹配,获得了良好效果,详细解析如下: 算法描述 整个算法分为以下几个部分: 1.构建尺度空间 尺度空间理论目的是模拟图像数据的多尺度特性,高斯卷积核是实现尺度变换的唯一卷积核,于是一副二维图像的尺度空间定义

Coursera台大机器学习技法课程笔记01-linear hard SVM

极其淡腾的一学期终于过去了,暑假打算学下台大的这门机器学习技法. 第一课是对SVM的介绍,虽然之前也学过,但听了一次感觉还是很有收获的.这位博主总结了个大概,具体细节还是 要听课:http://www.cnblogs.com/bourneli/p/4198839.html 这位博主总结的很详细:http://www.cnblogs.com/xbf9xbf/p/4617120.html

Support Vector Machine(3):Soft Margin 平衡之美

很多材料上面讲道"引入Soft Margin的原因是因为数据线性不可分",个人认为有些错误,其实再难以被分解的数据,如果我们用很复杂的弯弯绕曲线去做,还是可以被分解,并且映射到高维空间后认为其线性可分.但如果我们细细思考,其实很多算法都有一样的索求:寻求一种之于"最大限度拟合训练集"and"获得更好归纳能力"的平横,也就是所谓的Overfitting and Underfitting.也像人的性格,太过纠结细节或者神经太过大条,都难以和人相处愉快