python_基于Scikit learn库中KNN,SVM算法的笔迹识别 - 简书
python_基于Scikit learn库中KNN,SVM算法的笔迹识别
之前我们用自己写KNN算法识别了MNIST手写识别数据 这里介绍，如何运用Scikit learn库中的KNN，SVM算法进行笔迹识别。
数据说明：
数据共有785列，第一列为label，剩下的784列数据存储的是灰度图像(0~255)的像素值 28*28=784
安装scikit learn库
看了很多安装教程，都没有安装成功。最后参考了官方网站的安装文档，只需要一步步照着做下来就能成功安装
函数介绍：
主成分分析（Principal components analysis，PCA）：
一种分析、简化数据集的技术。主成分分析经常用于减少数据集的维数，同时保持数据集中的对方差贡献最大的特征。过程是求协方差矩阵的特征值与特征向量，通过保留低阶主成分，忽略高阶主成分。这样低阶成分往往能够保留住数据的最重要方面。c.f.:svd奇异值分析实际中会用svd奇异值分析去代替它，因为pca计算量比较大。
from sklearn.decomposition import PCA
#从sklearn中导入PCA
pca = PCA(n_components=0.8,whiten=True)
#设置PCA参数
#n_components:
#设为大于零的整数，会自动的选取n个主成分,
#设为分数时，选择特征值占总特征值大于n的，作为主成分
#True表示做白化处理，白化处理主要是为了使处理后的数据方差都一致
pca.fit_transform(data)
pca.transform(data)
#对数据data进行主成分分析
KNeighborsClassifier
from sklearn.neighbors import KNeighborsClassifier
#导入Scikit learn库中的KNN算法
neighbors=kneighbors([X, n_neighbors, return_distance])
#找到一个点的K近邻，n_neighbors近邻的数目
neighbors.fit(Training data,Target values)
#对训练集的输入和输出进行训练
pre= neighbors.predict(Test samples)
#对测试集的输入进行预测，返回预测出的标签
KNN完整程序及注解
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.neighbors import KNeighborsClassifier
import time
if __name__ =="__main__":
train_num = 20000
test_num = 30000
data = pd.read_csv('train.csv')
train_data = data.values[0:train_num,1:]
train_label = data.values[0:train_num,0]
test_data = data.values[train_num:test_num,1:]
test_label = data.values[train_num:test_num,0]
t = time.time()
pca=PCA(n_components = 0.8)
train_x = pca.fit_transform(train_data)
test_x = pca.transform(test_data)
neighbors = KNeighborsClassifier(n_neighbors=4)
neighbors.fit(train_x,train_label)
pre= neighbors.predict(test_x)
acc = float((pre==test_label).sum())/len(test_x)
print u'准确率：%f,花费时间：%.2fs' %(acc,time.time()-t)
运行结果：
准确率：0.946000,花费时间：7.98s
支持向量机（Support Vector Machine，常简称为SVM）是一种监督式学习的方法，可广泛地应用于统计分类以及回归分析。支持向量机建构一个或多个高维的超平面来分类资料点，这个超平面即为分类边界。直观来说，好的分类边界要距离最近的训练资料点越远越好。在支持向量机中，分类边界与最近的训练资料点之间的距离称为间隔（margin）；支持向量机的目标即为找出间隔最大的超平面来作为分类边界。,
是三种用于对数据进行多类分类的类，我们这里主要用到SVC(class sklearn.svm.SVC)。
from sklearn import svm
#从sklearn库中导入svm
svc=svm.SVC(*C=1.0*, *kernel='rbf'*, *degree=3*)
#C是惩罚因子
#kernel核方法，常用的核方法有：‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’
svc.fit(X, y, sample_weight=None)
#对训练集的输入和输出进行训练
svc.predict(x)
#对测试集的输入进行预测，返回预测出的标签
#####SVM完整程序及注解
import pandas as pd
from sklearn.decomposition import PCA
from sklearn import svm
import time
if __name__ =="__main__":
train_num = 5000
test_num = 7000
data = pd.read_csv('train.csv')
train_data = data.values[0:train_num,1:]
train_label = data.values[0:train_num,0]
test_data = data.values[train_num:test_num,1:]
test_label = data.values[train_num:test_num,0]
t = time.time()
pca = PCA(n_components = 0.8,whiten = True)
train_x = pca.fit_transform(train_data)
test_x = pca.transform(test_data)
svc = svm.SVC(kernel = 'rbf',C = 10)
svc.fit(train_x,train_label)
pre = svc.predict(test_x)
acc = float((pre==test_label).sum())/len(test_x)
print u'准确率：%f,花费时间：%.2fs' %(acc,time.time()-t)
运行结果：
准确率：0.953000,花费时间：13.95s
在对5000个数据进行训练，2000个数据进行测试的过程中，SVM比KNN的准确率更高，所用时间更长。使用gensim和sklearn搭建一个文本分类器（一）：流程概述
总的来讲，一个完整的文本分类器主要由两个阶段，或者说两个部分组成：一是将文本向量化，将一个字符串转化成向量形式；二是传统的分类器，包括线性分类器，SVM, 神经网络分类器等等。
之前看的THUCTC的技术栈是使用 tf-idf 来进行文本向量化，使用卡方校验(chi-square)来降低向量维度，使用liblinear(采用线性核的svm) 来进行分类。而这里所述的文本分类器，使用lsi (latent semantic analysis, 隐性语义分析) 来进行向量化， 不需要降维， 因为可以直接指定维度， 然后使用线性核svm进行分类。lsi的部分主要使用gensim来进行， 分类主要由sklearn来完成。
1. 文档向量化
这部分的内容主要由gensim来完成。gensim库的一些基本用法在我之前的文章中已经有过介绍
这里就不再详述， 直接按照流程来写了。采用lsi进行向量化的流程主要有下面几步：
将各文档分词，从字符串转化为单词列表 统计各文档单词，生成词典(dictionary) 利用词典将文档转化成词频表示的向量，即指向量中的各值对应于词典中对应位置单词在该文档中出现次数 再进行进一步处理，将词频表示的向量转化成tf-idf表示的向量 由tf-idf表示的向量转化成lsi表示的向量
接下来按照上述流程来分别阐述
1.1 文档分词及预处理
分词有很多种方法，也有很多现成的库，这里仅介绍结巴的简单用法
import jieba
content = &&&面对当前挑战，我们应该落实2030年可持续发展议程，促进包容性发展&&&
content = list(jieba.cut(content, cut_all=False))
print(content)
&&&['面对', '当前', '挑战', '，', '我们', '应该', '落实', '2030', '年', '可', '持续', '发展', '议程', '，', '促进', '包容性', '发展']
注意上面的cut_all选项，如果cut_all=False， 则会列出最优的分割选项； 如果cut_all=True, 则会列出所有可能出现的词
content = list(jieba.cut(content, cut_all=True))
print(content)
&&&['面对', '当前', '挑战', '', '', '我们', '应该', '落实', '2030', '年', '可', '持续', '发展', '议程', '', '', '促进', '包容', '包容性', '容性', '发展']
应该观察到，在分词后的直接结果中，有大量的无效项，例如空格，逗号等等。因此，一般在分词以后，还要进行预处理。例如去掉停用词(stop words， 指的是没什么意义的词，例如空格，逗号，句号，啊，呀， 等等)， 去掉出现出现频率过低和过高的词等等。
我这一部分的程序是
def convert_doc_to_wordlist(str_doc,cut_all):
# 分词的主要方法
sent_list = str_doc.split('\n')
sent_list = map(rm_char, sent_list) # 去掉一些字符，例如\u3000
word_2dlist = [rm_tokens(jieba.cut(part,cut_all=cut_all)) for part in sent_list] # 分词
word_list = sum(word_2dlist,[])
return word_list
def rm_char(text):
text = re.sub('\u3000','',text)
return text
def get_stop_words(path='/home/multiangle/coding/python/PyNLP/static/stop_words.txt'):
# stop_words中，每行放一个停用词，以\n分隔
file = open(path,'rb').read().decode('utf8').split('\n')
return set(file)
def rm_tokens(words): # 去掉一些停用次和数字
words_list = list(words)
stop_words = get_stop_words()
for i in range(words_list.__len__())[::-1]:
if words_list[i] in stop_words: # 去除停用词
words_list.pop(i)
elif words_list[i].isdigit():
words_list.pop(i)
return words_list
主程序是convert_doc_to_wordlist方法，拿到要分词的文本以后，首先去掉一些字符，例如\u3000等等。然后进行分词，再去掉其中的停用词和数字。 最后得到的单词，其顺序是打乱的，即单词间的相关信息已经丢失
1.2 统计单词，生成词典
一般来讲, 生成词典应该在将所有文档都分完词以后统一进行，不过对于规模特别大的数据，可以采用边分词边统计的方法。将文本分批读取分词，然后用之前生成的词典加入新内容的统计结果，如下面所示
from gensim import corpora,models
import jieba
from pprint import pprint
files = [&但是现在教育局非要治理这么一个情况&,
&然而又不搞明白为什么这些词会出现&]
dictionary = corpora.Dictionary()
for file in files:
file = convert_doc_to_wordlist(file, cut_all=True)
dictionary.add_documents([file])
pprint(sorted(list(dictionary.items()),key=lambda x:x[0]))
&&&[(0, '教育'),
&&& (1, '治理'),
&&& (2, '教育局'),
&&& (3, '情况'),
&&& (4, '非要'),
&&& (5, '搞'),
&&& (6, '明白'),
&&& (7, '词')]
对于已经存在的词典，可以使用dictionary.add_documents来往其中增加新的内容。当生成词典以后，会发现词典中的词太多了，达到了几十万的数量级， 因此需要去掉出现次数过少的单词，因为这些代词没什么代表性。
small_freq_ids = [tokenid for tokenid, docfreq in dictionary.dfs.items() if docfreq & 5 ]
dictionary.filter_tokens(small_freq_ids)
1.3 将文档转化成按词频表示的向量
继续沿着之前的思路走，接下来要用dictionary把文档从词语列表转化成用词频表示的向量，也就是one-hot表示的向量。所谓one-hot，就是向量中的一维对应于词典中的一项。如果以词频表示，则向量中该维的值即为词典中该单词在文档中出现的频率。其实这个转化很简单，使用dictionray.doc2bow方法即可。
for file in files:
count += 1
if count%100 == 0 :
print('{c} at {t}'.format(c=count, t=time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())))
word_list = convert_doc_to_wordlist(file, cut_all=False)
word_bow = dictionary.doc2bow(word_list)
bow.append(word_bow)
pprint(bow)
&&&[[(1, 1), (2, 1), (4, 1)], [(5, 1), (6, 1)]]
1.4 转化成tf-idf和lsi向量
之所以把这两部分放到一起，并不是因为这两者的计算方式或者说原理有多相似（实际上两者完全不同），而是说在gensim中计算这两者的调用方法比较类似，都需要调用gensim.models库。
tfidf_model = models.TfidfModel(corpus=corpus,
dictionary=dictionary)
corpus_tfidf = [tfidf_model[doc] for doc in corpus]
lsi_model = models.LsiModel(corpus = corpus_tfidf,
id2word = dictionary,
num_topics=50)
corpus_lsi = [lsi_model[doc] for doc in corpus]
可以看到gensim的方法还是比较简洁的。
1.5 实践中的一些问题
由于之前THUCTC的时候下载了THUCTCNews文档集，大概1G多点，已经帮你分好类，放在各个文件夹下面了。为了便于分析，各个环节的中间结果(词频向量，tfidf向量等)也都会存放到本地。为了便于以后标注，各个类的中间结果也是按类别存储的。
2. 分类问题
在将文本向量化以后，就可以采用传统的分类方法了, 例如线性分类法，线性核的svm，rbf核的svm，神经网络分类等方法。我在这个分类器中尝试了前3种，都可以由sklearn库来完成
2.1 从gensim到sklearn的格式转换
一个很尴尬的问题是，gensim中的corpus数据格式，sklearn是无法识别的。即gensim中对向量的表示形式与sklearn要求的不符。
在gensim中，向量是稀疏表示的。例如[(0,5),(6,3)] 意思就是说，该向量的第0个元素值为5，第6个元素值为3，其他为0.但是这种表示方式sklearn是无法识别的。sklearn的输入一般是与numpy或者scipy配套的。如果是密集矩阵，就需要输入numpy.array格式的； 如果是稀疏矩阵，则需要输入scipy.sparse.csr_matrix.由于后者可以转化成前者，而且gensim中向量本身就是稀疏表示，所以这边只讲如何将gensim中的corpus格式转化成csr_matrix.
去去找相关文档，可以看到csr_matrix的构造有如下几种方法。
&vcD4NCjxwPrXa0rvW1srH08nP1tPQtcTD3LyvvtjV88C0ubm9qM+hyui+2NXzo6y12rb+1tayu8rHutzH5bP+o6y12sj91ta5ub2o0ru49r/VvtjV86GjtdrLxNbWus212s7l1ta3+7rPztLDx7XE0qrH86GjxuTW0LXay8TW1tfuzqrWsbnbo6y5ub2oyP249sr91+mjrLfWsfC05rSiw7+49tSqy9i1xNDQo6zB0LrNyv3Wtby0v8mhozxiciAvPg0KudnN+Lj4s/a1xMq+wP20+sLryOfPwqOsu7nKx7HIvc/WsbnbtcShozwvcD4NCjxwcmUgY2xhc3M9"brush:">
row = np.array([0, 0, 1, 2, 2, 2])
col = np.array([0, 2, 2, 0, 1, 2])
data = np.array([1, 2, 3, 4, 5, 6])
print(csr_matrix((data, (row, col)), shape=(3, 3)).toarray())
&&&array([[1, 0, 2],
[0, 0, 3],
[4, 5, 6]])
依样画葫芦，gensim转化到csr_matrix的程序可以写成
line_count = 0
for line in lsi_corpus_total:
# lsi_corpus_total 是之前由gensim生成的lsi向量
for elem in line:
rows.append(line_count)
cols.append(elem[0])
data.append(elem[1])
line_count += 1
lsi_sparse_matrix = csr_matrix((data,(rows,cols))) # 稀疏向量
lsi_matrix = lsi_sparse_matrix.toarray()
# 密集向量
在将所有数据集都转化成sklearn可用的格式以后，还要将其分成训练集和检验集，比例大概在8:2.下面的代码就是关于训练集和检验集的生成的
line_count = 0
for line in lsi_corpus_total:
for elem in line:
rows.append(line_count)
cols.append(elem[0])
data.append(elem[1])
line_count += 1
lsi_matrix = csr_matrix((data,(rows,cols))).toarray()
rarray=np.random.random(size=line_count)
train_set = []
train_tag = []
test_set = []
test_tag = []
for i in range(line_count):
if rarray[i]&0.8:
train_set.append(lsi_matrix[i,:])
train_tag.append(tag_list[i])
test_set.append(lsi_matrix[i,:])
test_tag.append(tag_list[i])
2.2 线性判别分析
sklearn中，可以使用sklearn.discriminant_analysis.LinearDiscriminantAnalysis来进行线性分类。
import numpy as np
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
lda = LinearDiscriminantAnalysis(solver=&svd&, store_covariance=True)
X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
Y = np.array([1, 1, 2, 2])
lda_res = lda.fit(X, Y)
print(lda_res.predict([[-0.8, -1]]))
在上面的例子中，X代表了训练集。上面的X是一个4*2的矩阵，代表训练集中含有4各样本，每个样本的维度是2维。而Y代表的是训练集中各样本所期望的分类结果。回到文本分类的任务，易知上面代码的X对应于train_set, 而Y对应于train_tag
lda = LinearDiscriminantAnalysis(solver=&svd&, store_covariance=True)
lda_res = lda.fit(train_set, train_tag)
train_pred
= lda_res.predict(train_set)
# 训练集的预测结果
test_pred = lda_res.predict(test_set)
# 检验集的预测结果
lda_res即是得到的lda模型。 train_pred, test_pred 分别是训练集和检验集根据得到的lda模型获得的预测结果。
向量化方法
训练集错误率
检验集错误率
2.3 SVM分类
总的来说，使用SVM与上面LDA的使用方法比较类似。使用sklearn.svm类可以完成。不过与lda相比，svm可以接受稀疏矩阵作为输入，这是个好消息。
# clf = svm.SVC()
# 使用RBF核
clf = svm.LinearSVC() # 使用线性核
clf_res = clf.fit(train_set,train_tag)
train_pred
= clf_res.predict(train_set)
= clf_res.predict(test_set)
可以使用RBF核，也可以使用线性核。不过要注意，RBF核在数据集不太充足的情况下有很好的结果，但是当数据量很大是就不太明显，而且运行速度非常非常非常的慢！ 所以我推荐使用线性核，运算速度快，而且效果比线性判别稍好一些
向量化方法
训练集错误率
检验集错误率
svm_linear
svm_linear
svm_linear
svm_linear程序员训练机器学习 SVM算法分享
发表于 16:12|
来源Yaksis|
作者Greg Lamp
摘要：支持向量机（SVM）已经成为一种非常受欢迎的算法。本文主要阐述了SVM是如何进行工作的，同时也给出了使用Python Scikits库的几个示例。SVM作为一种训练机器学习的算法，可以用于解决分类和回归问题，还使用了kernel trick技术进行数据的转换，再根据转换信息在可能的输出之中找到一个最优的边界。
【CSDN报道】支持向量机（Support Vector Machine）已经成为一种非常受欢迎的算法。，Greg Lamp简单解释了它是如何进行工作的，同时他也给出了使用Python Scikits库的几个示例。所有代码在Github上都是可用的，Greg Lamp以后还会对使用Scikits以及Sklearn的细节问题进行更深一步的阐述。CSDN对本篇技术性文章进行了编译整理：
SVM是什么？
SVM是一种训练机器学习的算法，可以用于解决分类和回归问题，同时还使用了一种称之为kernel trick的技术进行数据的转换，然后再根据这些转换信息，在可能的输出之中找到一个最优的边界。简单来说，就是做一些非常复杂的数据转换工作，然后根据预定义的标签或者输出进而计算出如何分离用户的数据。
是什么让它变得如此的强大？
当然，对于SVM来说，完全有能力实现分类以及回归。在这篇文章中，Greg Lamp主要关注如何使用SVM进行分类，特别是非线性的SVM或者SVM使用非线性内核。非线性SVM意味着该算法计算的边界没有必要是一条直线，这样做的好处在于，可以捕获更多数据点集之间的复杂关系，而无需靠用户自己来执行困难的转换。其缺点就是由于更多的运算量，训练的时间要长很多。
什么是kernel trick？
kernel trick对接收到的数据进行转换：输入一些你认为比较明显的特征进行分类，输出一些你完全不认识的数据，这个过程就像解开一个DNA链。你开始是寻找数据的矢量，然后把它传给kernel trick，再进行不断的分解和重组直到形成一个更大的数据集，而且通常你看到的这些数据非常的难以理解。这就是神奇之处，扩展的数据集拥有更明显的边界，SVM算法也能够计算一个更加优化的超平面。
其次，假设你是一个农场主，现在你有一个问题&&你需要搭建一个篱笆来防止狼对牛群造成伤害。但是篱笆应该建在哪里呢？如果你是一个以数据为驱动的农场主，那么你就需要在你的牧场上，依据牛群和狼群的位置建立一个&分类器&，比较这几种（如下图所示）不同的分类器，我们可以看到SVM完成了一个很完美的解决方案。Greg Lamp认为这个故事漂亮的说明了使用非线性分类器的优势。显而易见，逻辑模式以及决策树模式都是使用了直线方法。
如下：farmer.py &Python&
import&numpy&as&np&import&pylab&as&pl&from&sklearn&import&svm&from&sklearn&import&linear_model&from&sklearn&import&tree&import&pandas&as&pd&&&&&def&plot_results_with_hyperplane(clf,&clf_name,&df,&plt_nmbr):&&&&&x_min,&x_max&=&df.x.min()&-&.5,&df.x.max()&+&.5&&&&&y_min,&y_max&=&df.y.min()&-&.5,&df.y.max()&+&.5&&&&&&&#&step&between&points.&i.e.&[0,&0.02,&0.04,&...]&&&&&step&=&.02&&&&&#&to&plot&the&boundary,&we're&going&to&create&a&matrix&of&every&possible&point&&&&&#&then&label&each&point&as&a&wolf&or&cow&using&our&classifier&&&&&xx,&yy&=&np.meshgrid(np.arange(x_min,&x_max,&step),np.arange(y_min,&y_max,&step))&&&&&Z&=&clf.predict(np.c_[xx.ravel(),&yy.ravel()])&&&&&#&this&gets&our&predictions&back&into&a&matrix&&&&&ZZ&=&Z.reshape(xx.shape)&&&&&&&#&create&a&subplot&(we're&going&to&have&more&than&1&plot&on&a&given&image)&&&&&pl.subplot(2,&2,&plt_nmbr)&&&&&#&plot&the&boundaries&&&&&pl.pcolormesh(xx,&yy,&Z,&cmap=pl.cm.Paired)&&&&&&&#&plot&the&wolves&and&cows&&&&&for&animal&in&df.animal.unique():&&&&&&&&&pl.scatter(df[df.animal==animal].x,&&&&&&&&&&&&&&&&&&&&df[df.animal==animal].y,&&&&&&&&&&&&&&&&&&&&marker=animal,&&&&&&&&&&&&&&&&&&&&label=&cows&&if&animal==&x&&else&&wolves&,&&&&&&&&&&&&&&&&&&&&color='black',&&&&&&&&&&&&&&&&&&&&c=df.animal_type,&cmap=pl.cm.Paired)&&&&&pl.title(clf_name)&&&&&pl.legend(loc=&best&)&&&&&data&=&open(&cows_and_wolves.txt&).read()&data&=&[row.split('\t')&for&row&in&data.strip().split('\n')]&&&animals&=&[]&for&y,&row&in&enumerate(data):&&&&&for&x,&item&in&enumerate(row):&&&&&&&&&#&x's&are&cows,&o's&are&wolves&&&&&&&&&if&item&in&['o',&'x']:&&&&&&&&&&&&&animals.append([x,&y,&item])&&&df&=&pd.DataFrame(animals,&columns=[&x&,&&y&,&&animal&])&df['animal_type']&=&df.animal.apply(lambda&x:&0&if&x==&x&&else&1)&&&#&train&using&the&x&and&y&position&coordiantes&train_cols&=&[&x&,&&y&]&&&clfs&=&{&&&&&&SVM&:&svm.SVC(),&&&&&&Logistic&&:&linear_model.LogisticRegression(),&&&&&&Decision&Tree&:&tree.DecisionTreeClassifier(),&}&&&plt_nmbr&=&1&for&clf_name,&clf&in&clfs.iteritems():&&&&&clf.fit(df[train_cols],&df.animal_type)&&&&&plot_results_with_hyperplane(clf,&clf_name,&df,&plt_nmbr)&&&&&plt_nmbr&+=&1&pl.show()&&
让SVM做一些更难的工作吧！
诚然，如果自变量和因变量之间的关系是非线性的，是很难接近SVM的准确性。如果还是难以理解的话，可以看看下面的例子：假设我们有一组数据集，它包含了绿色以及红色的点集。我们首先标绘一下它们的坐标，这些点集构成了一个具体的形状&&拥有着红色的轮廓，周围充斥着绿色（看起来就像孟加拉国的国旗）。如果因为某些原因，我们丢失了数据集当中1/3的部分，那么在我们恢复的时候，我们就希望寻找一种方法，最大程度地实现这丢失1/3部分的轮廓。
那么我们如何推测这丢失1/3的部分最接近什么形状？一种方式就是建立一种模型，使用剩下接近80%的数据信息作为一个&训练集&。Greg Lamp选择三种不同的数据模型分别做了尝试：
逻辑模型(GLM)
决策树模型(DT)
Greg Lamp对每种数据模型都进行了训练，然后再利用这些模型推测丢失1/3部分的数据集。我们可以看看这些不同模型的推测结果：
如下：svmflag.py Python
import&numpy&as&np&import&pylab&as&pl&import&pandas&as&pd&&&from&sklearn&import&svm&from&sklearn&import&linear_model&from&sklearn&import&tree&&&from&sklearn.metrics&import&confusion_matrix&&&x_min,&x_max&=&0,&15&y_min,&y_max&=&0,&10&step&=&.1&#&to&plot&the&boundary,&we're&going&to&create&a&matrix&of&every&possible&point&#&then&label&each&point&as&a&wolf&or&cow&using&our&classifier&xx,&yy&=&np.meshgrid(np.arange(x_min,&x_max,&step),&np.arange(y_min,&y_max,&step))&&&df&=&pd.DataFrame(data={'x':&xx.ravel(),&'y':&yy.ravel()})&&&df['color_gauge']&=&(df.x-7.5)**2&+&(df.y-5)**2&df['color']&=&df.color_gauge.apply(lambda&x:&&red&&if&x&=&15&else&&green&)&df['color_as_int']&=&df.color.apply(lambda&x:&0&if&x==&red&&else&1)&&&print&&Points&on&flag:&&print&df.groupby('color').size()&print&&&figure&=&1&&&#&plot&a&figure&for&the&entire&dataset&for&color&in&df.color.unique():&&&&&idx&=&df.color==color&&&&&pl.subplot(2,&2,&figure)&&&&&pl.scatter(df[idx].x,&df[idx].y,&colorcolor=color)&&&&&pl.title('Actual')&&&&&train_idx&=&df.x&&&&&train&=&df[train_idx]&test&=&df[-train_idx]&&&&&print&&Training&Set&Size:&%d&&%&len(train)&print&&Test&Set&Size:&%d&&%&len(test)&&&#&train&using&the&x&and&y&position&coordiantes&cols&=&[&x&,&&y&]&&&clfs&=&{&&&&&&SVM&:&svm.SVC(degree=0.5),&&&&&&Logistic&&:&linear_model.LogisticRegression(),&&&&&&Decision&Tree&:&tree.DecisionTreeClassifier()&}&&&&&#&racehorse&different&classifiers&and&plot&the&results&for&clf_name,&clf&in&clfs.iteritems():&&&&&figure&+=&1&&&&&&&#&train&the&classifier&&&&&clf.fit(train[cols],&train.color_as_int)&&&&&&&#&get&the&predicted&values&from&the&test&set&&&&&test['predicted_color_as_int']&=&clf.predict(test[cols])&&&&&test['pred_color']&
=&test.predicted_color_as_int.apply(lambda&x:&&red&&if&x==0&else&&green&)&&&&&&&&&&#&create&a&new&subplot&on&the&plot&&&&&pl.subplot(2,&2,&figure)&&&&&#&plot&each&predicted&color&&&&&for&color&in&test.pred_color.unique():&&&&&&&&&#&plot&only&rows&where&pred_color&is&equal&to&color&&&&&&&&&idx&=&test.pred_color==color&&&&&&&&&pl.scatter(test[idx].x,&test[idx].y,&colorcolor=color)&&&&&&&#&plot&the&training&set&as&well&&&&&for&color&in&train.color.unique():&&&&&&&&&idx&=&train.color==color&&&&&&&&&pl.scatter(train[idx].x,&train[idx].y,&colorcolor=color)&&&&&&&#&add&a&dotted&line&to&show&the&boundary&between&the&training&and&test&set&&&&&#&(everything&to&the&right&of&the&line&is&in&the&test&set)&&&&&#this&plots&a&vertical&line&&&&&train_line_y&=&np.linspace(y_min,&y_max)&#evenly&spaced&array&from&0&to&10&&&&&train_line_x&=&np.repeat(10,&len(train_line_y))
&#repeat&10&(threshold&for&traininset)&n&times&&&&&#&add&a&black,&dotted&line&to&the&subplot&&&&&pl.plot(train_line_x,&train_line_y,&'k--',&color=&black&)&&&&&&&&&&pl.title(clf_name)&&&&&&&print&&Confusion&Matrix&for&%s:&&%&clf_name&&&&&print&confusion_matrix(test.color,&test.pred_color)&pl.show()&
从这些实验结果来看，毫无疑问，SVM是绝对的优胜者。但是究其原因我们不妨看一下DT模型和GLM模型。很明显，它们都是使用的直线边界。Greg Lamp的输入模型在计算非线性的x, y以及颜色之间的关系时，并没有包含任何的转换信息。假如Greg Lamp它们能够定义一些特定的转换信息，可以使GLM模型和DT模型能够输出更好的效果，他们为什么要浪费时间呢？其实并没有复杂的转换或者压缩，SVM仅仅分析错了117/5000个点集（高达98%的准确率，对比而言，DT模型是51%，而GLM模型只有12%！）
局限性在哪里？
很多人都有疑问，既然SVM这么强大，但是为什么不能对一切使用SVM呢？很不幸，SVM最神奇的地方恰好也是它最大的软肋！复杂的数据转换信息和边界的产生结果都难以进行阐述。这也是它常常被称之为&black box&的原因，而GLM模型和DT模型刚好相反，它们很容易进行理解。（编译/，审校/仲浩）
本文为CSDN编译整理，未经允许不得转载。如需转载请联系
推荐阅读相关主题：
CSDN官方微信
扫描二维码,向CSDN吐槽
微信号：CSDNnews
相关热门文章