在中，我们对BIRCH聚类算法的原理做了总结，本文就对scikit-learn中BIRCH算法的使用做一个总结。
1. scikit-learn之BIRCH类
　　　　在scikit-learn中，BIRCH类实现了原理篇里讲到的基于特征树CF Tree的聚类。因此要使用BIRCH来聚类，关键是对CF Tree结构参数的处理。
　　　　在CF Tree中，几个关键的参数为内部节点的最大CF数B，&叶子节点的最大CF数L，&叶节点每个CF的最大样本半径阈值T。这三个参数定了，CF Tree的结构也基本确定了，最后的聚类效果也基本确定。可以说BIRCH的调参就是调试B,L和T。
　　　　至于类别数K，此时反而是可选的，不输入K，则BIRCH会对CF Tree里各叶子节点CF中样本的情况自己决定类别数K值，如果输入K值，则BIRCH会CF Tree里各叶子节点CF进行合并，直到类别数为K。
2. BIRCH类参数
　　　　在scikit-learn中，BIRCH类的重要参数不多，下面一并讲解。
　　　　1) threshold:即叶节点每个CF的最大样本半径阈值T，它决定了每个CF里所有样本形成的超球体的半径阈值。一般来说threshold越小，则CF Tree的建立阶段的规模会越大，即BIRCH算法第一阶段所花的时间和内存会越多。但是选择多大以达到聚类效果则需要通过调参决定。默认值是0.5.如果样本的方差较大，则一般需要增大这个默认值。
　　　　2) branching_factor：即CF Tree内部节点的最大CF数B，以及叶子节点的最大CF数L。这里scikit-learn对这两个参数进行了统一取值。也就是说，branching_factor决定了CF Tree里所有节点的最大CF数。默认是50。如果样本量非常大，比如大于10万，则一般需要增大这个默认值。选择多大的branching_factor以达到聚类效果则需要通过和threshold一起调参决定
　　　　3）n_clusters：即类别数K，在BIRCH算法是可选的，如果类别数非常多，我们也没有先验知识，则一般输入None，此时BIRCH算法第4阶段不会运行。但是如果我们有类别的先验知识，则推荐输入这个可选的类别值。默认是3，即最终聚为3类。
　　　　4）compute_labels：布尔值，表示是否标示类别输出，默认是True。一般使用默认值挺好，这样可以看到聚类效果。
　　　　在评估各个参数组合的聚类效果时，还是推荐使用Calinski-Harabasz Index，Calinski-Harabasz Index在scikit-learn中对应的方法是metrics.calinski_harabaz_score.
3. BIRCH运用实例
　　　　这里我们用一个例子来学习BIRCH算法。
　　　　首先，我们载入一些随机数据，并看看数据的分布图：
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.datasets.samples_generator import make_blobs
# X为样本特征，Y为样本簇类别， 共1000个样本，每个样本2个特征，共4个簇，簇中心在[-1,-1], [0,0],[1,1], [2,2]
X, y = make_blobs(n_samples=1000, n_features=2, centers=[[-1,-1], [0,0], [1,1], [2,2]], cluster_std=[0.4, 0.3, 0.4, 0.3],
random_state =9)
plt.scatter(X[:, 0], X[:, 1], marker='o')
plt.show()
　　　　输出图如下：
　　　　现在我们用BIRCH算法来聚类，首先我们选择不输入可选的类别数K，看看聚类效果和Calinski-Harabasz 分数。
from sklearn.cluster import Birch
y_pred = Birch(n_clusters = None).fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=y_pred)
plt.show()
from sklearn import metrics
print "Calinski-Harabasz Score", metrics.calinski_harabaz_score(X, y_pred)
　　　　输出图如下：
　　　　对应的Calinski-Harabasz 分数输出为：
Calinski-Harabasz Score 5
　　　　由于我们知道数据是4个簇随机产生的，因此我们可以通过输入可选的类别数4来看看BIRCH聚类的输出。代码如下：
y_pred = Birch(n_clusters = 4).fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=y_pred)
plt.show()
print "Calinski-Harabasz Score", metrics.calinski_harabaz_score(X, y_pred)
　　　　输出图如下：　　
　　　　对应的Calinski-Harabasz 分数输出为：
Calinski-Harabasz Score 8　　　　　
　　　　可见如果我们不输入类别数的话，在某些时候BIRCH算法的聚类效果并不一定好，因此这个可选的类别数K一般还是需要调参的。
　　　　对于threshold和branching_factor我们前面还没有去调参，使用了默认的threshold值0.5和默认的branching_factor值50.
　　　　现在我们将threshold从0.5降低为0.3，让BIRCH算法第一阶段的CF Tree规模变大，并观察Calinski-Harabasz 分数。
y_pred = Birch(n_clusters = 4, threshold = 0.3).fit_predict(X)
print "Calinski-Harabasz Score", metrics.calinski_harabaz_score(X, y_pred)
　　　　对应的Calinski-Harabasz 分数输出为：
Calinski-Harabasz Score 3
　　　　可见此时的聚类效果有了进一步的提升，那么是不是threshold越小越好呢？我们看看threshold从0.3降低为0.1时的情况。
y_pred = Birch(n_clusters = 4, threshold = 0.1).fit_predict(X)
print "Calinski-Harabasz Score", metrics.calinski_harabaz_score(X, y_pred)
　　　　对应的Calinski-Harabasz 分数输出为：
Calinski-Harabasz Score 8
　　　　也就是说threshold不是越小聚类效果越好。
　　　　我们基于threshold为0.3的情况，调试下branching_factor，将branching_factor从50降低为20.让BIRCH算法第一阶段的CF Tree规模变大。
y_pred = Birch(n_clusters = 4, threshold = 0.3, branching_factor = 20).fit_predict(X)
print "Calinski-Harabasz Score", metrics.calinski_harabaz_score(X, y_pred)
　　　　对应的Calinski-Harabasz 分数输出为：
Calinski-Harabasz Score 4
　　　　可见调试branching_factor也可以让聚类分数提高。那么和threshold类似，是不是branching_factor越小越好呢？我们将branching_factor从20降低为10，观察聚类分数：
y_pred = Birch(n_clusters = 4, threshold = 0.3, branching_factor = 10).fit_predict(X)
print "Calinski-Harabasz Score", metrics.calinski_harabaz_score(X, y_pred)
　　　　对应的Calinski-Harabasz 分数输出为：
Calinski-Harabasz Score 2
　　　　也就是说和threshold类似，branching_factor不是越小聚类效果越好，需要调参。
　　　　以上就是BIRCH算法的一些经验，希望可以帮到朋友们。
（欢迎转载，转载请注明出处。欢迎沟通交流： pinard.）
阅读(...) 评论()scikit-learn估计器-KNN均值聚类
时间： 22:44:26
&&&& 阅读：162
&&&& 评论：
&&&& 收藏：0
标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&scikit-learn库实现了一系列的数据挖掘，提供通用的编程接口、标准化的测试和调参工具主要包含：估计器：用于聚类、回归、分类分析转化器：用于数据的预处理和数据抓换流水线：组合数据挖掘的流程，便于再次使用估计器：为了实现大量的分类算法，该库把相关功能封装成所谓的估计器，主要包括两个函数：&&&&&&&&fit():训练算法，设置内部参数。接受训练集和类别这两个参数　　predict():参数为测试集，预测测试机的类别，并且返回一个测试集识别后级别的数组大多scikit-learn库接受和输出的数据格式都为numpy　的数组格式scikit-learn库提供了很多估计器，例如随机森林，svm，神经网络近邻算法：距离测度方法：欧式距离：两个特征响亮的长度平方和的平方根曼哈顿距离余弦距离# -*- coding: utf-8 -*-"""Created on Thu Mar &2 21:43:06 2017@author: zzpp220"""from pandas import DataFrame,Seriesimport pandas as pdimport numpy as npimport os,csvfrom sklearn.cross_validation import train_test_splitfrom sklearn.cross_validation import cross_val_score#交叉验证from matplotlib import pyplot as pltdata_folder=‘/media/zzpp220/Data/Linux_Documents/DOWNLOAD/python-DataAnalysis/xianku_book‘data=os.path.join(data_folder,‘ionosphere.data‘)#csv --comma-seperated-valuesX=np.zeros((351,34),dtype=‘float‘)y=np.zeros((351,),dtype=‘bool‘)with open(data,‘r‘) as input: & &reader=csv.reader(input)# & &X=np.array([]) & &for i ,row in enumerate(reader): & & & &data=[float(datum) for datum in row[:-1]] & & & &X[i]=data#读数据至数组Ｘ & & & &y[i]=row[-1]==‘g‘#读类别值数组y & &## set train_set and test_set & &X_train,X_test,y_train,y_test=train_test_split(X,y,random_state=14) & &##导入ｋ近邻分类器，并为其初始化一个实例，参数用默认的，以后再讲调参，该算法默认选择５个近邻作为分类一句 & &from sklearn.neighbors import &KNeighborsClassifier
& &estimator=KNeighborsClassifier()# 建立实例 & &#估计器创建号之后，就要用进行数据训练， & &#k近邻估计器分析训练集中　的数据，比较待分类的新数据点和训练集中的数据，找到新数据点的　近邻 & &estimator.fit(X_train,y_train) & &#用测试集测试孙发，【评估在测试集上的表现 & &y_predicted=estimator.predict(X_test) & &accuracy=np.mean(y_test==y_predicted)*100 & &print ‘the accuracy is {0:.1f}%‘.format(accuracy) & & & &scores=cross_val_score(estimator,X,y,scoring=‘accuracy‘) & &average_accuracy=np.mean(scores)*100 & &print ‘the accuracy is {0:.1f}%‘.format(average_accuracy) & & & &##调参优化结果 & #ｋ近邻算法有多个参数，最终药店　是初始紧邻点的选择，想测试一系列的紧邻点的值，可以进行多次实验 & &avg_Scores,all_score=[],[] & &parameter_values=range(1,21) & &for num_neighbor in parameter_values: & & & &multi_test_estimator=KNeighborsClassifier(n_neighbors=num_neighbor) & & & &multi_testscore=cross_val_score(multi_test_estimator,X,y,scoring=‘accuracy‘) & & & &all_score.append(multi_testscore) & & & &avg_Scores.append(np.mean(multi_testscore)) & &plt.plot(parameter_values,avg_Scores,‘-o‘)#画图，横坐标，纵坐标，点的标志 & &plt.savefig(‘knn-multi-neighbor-test.pdf‘,dpi=400,bbox_inchs=‘tight‘)#保存成pdf格式，后面是像素和白边的设置附件列表&标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&国之画&&&& &&&&chrome插件&&
版权所有 京ICP备号-2
迷上了代码！71744人阅读
Data Mining（25）
Machine Learning（48）
Python（24）
文本挖掘的paper没找到统一的benchmark，只好自己跑程序，走过路过的前辈如果知道20newsgroups或者其它好用的公共数据集的分类（最好要所有类分类结果，全部或取部分特征无所谓）麻烦留言告知下现在的benchmark，万谢！嗯，说正文。上给出了3个数据集，这里我们用最原始的。分为以下几个过程：加载数据集提feature分类Naive BayesKNNSVM聚类说明： 上有参考，但是看着有点乱，而且有bug。本文中我们分块来看。Environment：Python 2.7 + Scipy （scikit-learn）1.加载数据集从下载数据集，解压到scikit_learn_data文件夹下，加载数据，详见code注释。#first extract the 20 news_group dataset to /scikit_learn_data
from sklearn.datasets import fetch_20newsgroups
#all categories
#newsgroup_train = fetch_20newsgroups(subset='train')
#part categories
categories = ['comp.graphics',
'comp.os.ms-windows.misc',
'comp.sys.ibm.pc.hardware',
'comp.sys.mac.hardware',
'comp.windows.x'];
newsgroup_train = fetch_20newsgroups(subset = 'train',categories = categories);可以检验是否load好了：#print category names
from pprint import pprint
pprint(list(newsgroup_train.target_names))
结果：['comp.graphics',&'comp.os.ms-windows.misc',&'comp.sys.ibm.pc.hardware',&'comp.sys.mac.hardware',&'comp.windows.x']2. 提feature：刚才load进来的newsgroup_train就是一篇篇document，我们要从中提取feature，即词频啊神马的，用fit_transformMethod 1. HashingVectorizer，规定feature个数#newsgroup_train.data is the original documents, but we need to extract the
#feature vectors inorder to model the text data
from sklearn.feature_extraction.text import HashingVectorizer
vectorizer = HashingVectorizer(stop_words = 'english',non_negative = True,
n_features = 10000)
fea_train = vectorizer.fit_transform(newsgroup_train.data)
fea_test = vectorizer.fit_transform(newsgroups_test.data);
#return feature vector 'fea_train' [n_samples,n_features]
print 'Size of fea_train:' + repr(fea_train.shape)
print 'Size of fea_train:' + repr(fea_test.shape)
#11314 documents, 130107 vectors for all categories
print 'The average feature sparsity is {0:.3f}%'.format(
fea_train.nnz/float(fea_train.shape[0]*fea_train.shape[1])*100);
结果：Size of fea_train:()Size of fea_train:()The average feature sparsity is 1.002%因为我们只取了10000个词，即10000维feature，稀疏度还不算低。而实际上用TfidfVectorizer统计可得到上万维的feature，我统计的全部样本是13w多维，就是一个相当稀疏的矩阵了。**************************************************************************************************************************上面代码注释说TF-IDF在train和test上提取的feature维度不同，那么怎么让它们相同呢？有两种方法：Method 2. CountVectorizer+TfidfTransformer让两个CountVectorizer共享vocabulary：#----------------------------------------------------
#method 1:CountVectorizer+TfidfTransformer
print '*************************\nCountVectorizer+TfidfTransformer\n*************************'
from sklearn.feature_extraction.text import CountVectorizer,TfidfTransformer
count_v1= CountVectorizer(stop_words = 'english', max_df = 0.5);
counts_train = count_v1.fit_transform(newsgroup_train.data);
print &the shape of train is &+repr(counts_train.shape)
count_v2 = CountVectorizer(vocabulary=count_v1.vocabulary_);
counts_test = count_v2.fit_transform(newsgroups_test.data);
print &the shape of test is &+repr(counts_test.shape)
tfidftransformer = TfidfTransformer();
tfidf_train = tfidftransformer.fit(counts_train).transform(counts_train);
tfidf_test = tfidftransformer.fit(counts_test).transform(counts_test);
结果：*************************CountVectorizer+TfidfTransformer*************************the shape of train is ()the shape of test is ()Method 3.&TfidfVectorizer让两个TfidfVectorizer共享vocabulary：#method 2:TfidfVectorizer
print '*************************\nTfidfVectorizer\n*************************'
from sklearn.feature_extraction.text import TfidfVectorizer
tv = TfidfVectorizer(sublinear_tf = True,
max_df = 0.5,
stop_words = 'english');
tfidf_train_2 = tv.fit_transform(newsgroup_train.data);
tv2 = TfidfVectorizer(vocabulary = tv.vocabulary_);
tfidf_test_2 = tv2.fit_transform(newsgroups_test.data);
print &the shape of train is &+repr(tfidf_train_2.shape)
print &the shape of test is &+repr(tfidf_test_2.shape)
analyze = tv.build_analyzer()
tv.get_feature_names()#statistical features/terms
结果：*************************TfidfVectorizer*************************the shape of train is ()the shape of test is ()此外，还有sklearn里封装好的抓feature函数，fetch_20newsgroups_vectorizedMethod 4.&fetch_20newsgroups_vectorized但是这种方法不能挑出几个类的feature，只能全部20个类的feature全部弄出来：print '*************************\nfetch_20newsgroups_vectorized\n*************************'
from sklearn.datasets import fetch_20newsgroups_vectorized
tfidf_train_3 = fetch_20newsgroups_vectorized(subset = 'train');
tfidf_test_3 = fetch_20newsgroups_vectorized(subset = 'test');
print &the shape of train is &+repr(tfidf_train_3.data.shape)
print &the shape of test is &+repr(tfidf_test_3.data.shape)
结果：*************************fetch_20newsgroups_vectorized*************************the shape of train is (1)the shape of test is ()3. 分类3.1 Multinomial Naive Bayes Classifier见代码&comment，不解释######################################################
#Multinomial Naive Bayes Classifier
print '*************************\nNaive Bayes\n*************************'
from sklearn.naive_bayes import MultinomialNB
from sklearn import metrics
newsgroups_test = fetch_20newsgroups(subset = 'test',
categories = categories);
fea_test = vectorizer.fit_transform(newsgroups_test.data);
#create the Multinomial Naive Bayesian Classifier
clf = MultinomialNB(alpha = 0.01)
clf.fit(fea_train,newsgroup_train.target);
pred = clf.predict(fea_test);
calculate_result(newsgroups_test.target,pred);
#notice here we can see that f1_score is not equal to 2*precision*recall/(precision+recall)
#because the m_precision and m_recall we get is averaged, however, metrics.f1_score() calculates
#weithed average, i.e., takes into the number of each class into consideration.注意我最后的3行注释，为什么f1≠2*（准确率*召回率）/（准确率+召回率）其中，函数calculate_result计算f1：def calculate_result(actual,pred):
m_precision = metrics.precision_score(actual,pred);
m_recall = metrics.recall_score(actual,pred);
print 'predict info:'
print 'precision:{0:.3f}'.format(m_precision)
print 'recall:{0:0.3f}'.format(m_recall);
print 'f1-score:{0:.3f}'.format(metrics.f1_score(actual,pred));
3.2 KNN：######################################################
#KNN Classifier
from sklearn.neighbors import KNeighborsClassifier
print '*************************\nKNN\n*************************'
knnclf = KNeighborsClassifier()#default with k=5
knnclf.fit(fea_train,newsgroup_train.target)
pred = knnclf.predict(fea_test);
calculate_result(newsgroups_test.target,pred);3.3 SVM:######################################################
#SVM Classifier
from sklearn.svm import SVC
print '*************************\nSVM\n*************************'
svclf = SVC(kernel = 'linear')#default with 'rbf'
svclf.fit(fea_train,newsgroup_train.target)
pred = svclf.predict(fea_test);
calculate_result(newsgroups_test.target,pred);结果：*************************Naive Bayes*************************predict info:precision:0.764recall:0.759f1-score:0.760*************************KNN*************************predict info:precision:0.642recall:0.635f1-score:0.636*************************SVM*************************predict info:precision:0.777recall:0.774f1-score:0.7744. 聚类######################################################
#KMeans Cluster
from sklearn.cluster import KMeans
print '*************************\nKMeans\n*************************'
pred = KMeans(n_clusters=5)
pred.fit(fea_test)
calculate_result(newsgroups_test.target,pred.labels_);
结果：*************************KMeans*************************predict info:precision:0.264recall:0.226f1-score:0.213本文全部代码下载：貌似准确率好低……那我们用全部特征吧……结果如下：*************************Naive Bayes*************************predict info:precision:0.771recall:0.770f1-score:0.769*************************KNN*************************predict info:precision:0.652recall:0.645f1-score:0.645*************************SVM*************************predict info:precision:0.819recall:0.816f1-score:0.816*************************KMeans*************************predict info:precision:0.289recall:0.313f1-score:0.266关于Python更多的学习资料将继续更新，敬请关注本博客和新浪微博。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：7975179次
积分：52641
积分：52641
排名：第58名
原创：484篇
转载：36篇
评论：4711条
百度深度学习实验室RD，关注计算机视觉，机器学习，算法研究，人工智能， 移动互联网等学科和产业，希望结识更多同道中人。
新浪微博：
(1)(1)(1)(1)(4)(3)(1)(7)(7)(2)(1)(1)(9)(1)(1)(5)(2)(1)(3)(4)(6)(6)(5)(4)(1)(1)(1)(6)(1)(2)(7)(6)(7)(11)(20)(12)(23)(29)(37)(37)(6)(24)(6)(1)(1)(2)(2)(1)(7)(23)(20)(32)(17)(5)(22)(58)(8)(8)从网上看到一篇总结的很不错的sklearn使用文档，备份勿忘。
对于一些开始搞机器学习算法有害怕下手的小朋友，该如何快速入门，这让人挺挣扎的。在从事数据科学的人中，最常用的工具就是R和Python了，每个工具都有其利弊，但是Python在各方面都相对胜出一些，这是因为scikit-learn库实现了很多机器学习算法。
加载数据(Data Loading)
我们假设输入时一个特征矩阵或者csv文件。首先，数据应该被载入内存中。scikit-learn的实现使用了NumPy中的arrays，所以，我们要使用NumPy来载入csv文件。以下是从UCI机器学习数据仓库中下载的数据。
1 import numpy as np
2 import urllib
3 # url with dataset
4 url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
5 # download the file
6 raw_data = urllib.urlopen(url)
7 # load the CSV file as a numpy matrix
8 dataset = np.loadtxt(raw_data, delimiter=",")
9 # separate the data from the target attributes
10 X = dataset[:,0:7]
11 y = dataset[:,8]
我们要使用该数据集作为例子，将特征矩阵作为X，目标变量作为y。
注意事项：
（1）可以用浏览器打开那个url，把数据文件保存在本地，然后直接用&np.loadtxt('data.txt', delemiter=",")&就可以加载数据了；
（2）X = dataset[:, 0:7]的意思是：把dataset中的所有行，所有0-7列的数据都保存在X中；
数据归一化(Data Normalization)
大多数机器学习算法中的梯度方法对于数据的缩放和尺度都是很敏感的，在开始跑算法之前，我们应该进行归一化或者标准化的过程，这使得特征数据缩放到0-1范围中。scikit-learn提供了归一化的方法，具体解释参考：
1 from sklearn import preprocessing
2 #scale the data attributes
3 scaled_X = preprocessing.scale(X)
5 # normalize the data attributes
6 normalized_X = preprocessing.normalize(X)
8 # standardize the data attributes
9 standardized_X = preprocessing.scale(X)
特征选择(Feature Selection)
在解决一个实际问题的过程中，选择合适的特征或者构建特征的能力特别重要。这成为特征选择或者特征工程。特征选择时一个很需要创造力的过程，更多的依赖于直觉和专业知识，并且有很多现成的算法来进行特征的选择。下面的树算法(Tree algorithms)计算特征的信息量：
1 from sklearn import metrics
2 from sklearn.ensemble import ExtraTreesClassifier
3 model = ExtraTreesClassifier()
4 model.fit(X, y)
5 # display the relative importance of each attribute
6 print(model.feature_importances_)
输出每个特征的重要程度：
[ 0.......]
算法的使用
scikit-learn实现了机器学习的大部分基础算法，让我们快速了解一下。
逻辑回归（）
大多数问题都可以归结为二元分类问题。这个算法的优点是可以给出数据所在类别的概率。
1 from sklearn import metrics
2 from sklearn.linear_model import LogisticRegression
3 model = LogisticRegression()
4 model.fit(X, y)
5 print('MODEL')
6 print(model)
7 # make predictions
8 expected = y
9 predicted = model.predict(X)
10 # summarize the fit of the model
11 print('RESULT')
12 print(metrics.classification_report(expected, predicted))
13 print('CONFUSION MATRIX')
14 print(metrics.confusion_matrix(expected, predicted))
2 LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, max_iter=100, multi_class='ovr',
penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
verbose=0)
12 avg / total
14 CONFUSION MATRIX
输出结果中的各个参数信息，可以参考官方文档。
朴素贝叶斯（）
这也是著名的机器学习算法，该方法的任务是还原训练样本数据的分布密度，其在多类别分类中有很好的效果。
1 from sklearn import metrics
2 from sklearn.naive_bayes import GaussianNB
3 model = GaussianNB()
4 model.fit(X, y)
5 print('MODEL')
6 print(model)
7 # make predictions
8 expected = y
9 predicted = model.predict(X)
10 # summarize the fit of the model
11 print('RESULT')
12 print(metrics.classification_report(expected, predicted))
13 print('CONFUSION MATRIX')
14 print(metrics.confusion_matrix(expected, predicted))
GaussianNB()
avg / total
CONFUSION MATRIX
k近邻算法常常被用作是分类算法一部分，比如可以用它来评估特征，在特征选择上我们可以用到它。
1 from sklearn import metrics
2 from sklearn.neighbors import KNeighborsClassifier
3 # fit a k-nearest neighbor model to the data
4 model = KNeighborsClassifier()
5 model.fit(X, y)
6 print(model)
7 # make predictions
8 expected = y
9 predicted = model.predict(X)
10 # summarize the fit of the model
11 print(metrics.classification_report(expected, predicted))
12 print(metrics.confusion_matrix(expected, predicted))
KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
metric_params=None, n_neighbors=5, p=2, weights='uniform')
avg / total
决策树（）
分类与回归树(Classification and Regression Trees ,CART)算法常用于特征含有类别信息的分类或者回归问题，这种方法非常适用于多分类情况。
1 from sklearn import metrics
2 from sklearn.tree import DecisionTreeClassifier
3 # fit a CART model to the data
4 model = DecisionTreeClassifier()
5 model.fit(X, y)
6 print(model)
7 # make predictions
8 expected = y
9 predicted = model.predict(X)
10 # summarize the fit of the model
11 print(metrics.classification_report(expected, predicted))
12 print(metrics.confusion_matrix(expected, predicted))
DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,
max_features=None, max_leaf_nodes=None, min_samples_leaf=1,
min_samples_split=2, min_weight_fraction_leaf=0.0,
random_state=None, splitter='best')
avg / total
支持向量机（）
SVM是非常流行的机器学习算法，主要用于分类问题，如同逻辑回归问题，它可以使用一对多的方法进行多类别的分类。
1 from sklearn import metrics
2 from sklearn.svm import SVC
3 # fit a SVM model to the data
4 model = SVC()
5 model.fit(X, y)
6 print(model)
7 # make predictions
8 expected = y
9 predicted = model.predict(X)
10 # summarize the fit of the model
11 print(metrics.classification_report(expected, predicted))
12 print(metrics.confusion_matrix(expected, predicted))
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0, degree=3, gamma=0.0,
kernel='rbf', max_iter=-1, probability=False, random_state=None,
shrinking=True, tol=0.001, verbose=False)
avg / total
除了分类和回归算法外，scikit-learn提供了更加复杂的算法，比如聚类算法，还实现了算法组合的技术，如Bagging和Boosting算法。
如何优化算法参数
一项更加困难的任务是构建一个有效的方法用于选择正确的参数，我们需要用搜索的方法来确定参数。scikit-learn提供了实现这一目标的函数。下面的例子是一个进行正则参数选择的程序：
（模块使用）&&（原理详解）
1 import numpy as np
2 from sklearn.linear_model import Ridge
3 from sklearn.grid_search import GridSearchCV
4 # prepare a range of alpha values to test
5 alphas = np.array([1,0.1,0.01,0.001,0.0001,0])
6 # create and fit a ridge regression model, testing each alpha
7 model = Ridge()
8 grid = GridSearchCV(estimator=model, param_grid=dict(alpha=alphas))
9 grid.fit(X, y)
10 print(grid)
11 # summarize the results of the grid search
12 print(grid.best_score_)
13 print(grid.best_estimator_.alpha)
GridSearchCV(cv=None, error_score='raise',
estimator=Ridge(alpha=1.0, copy_X=True, fit_intercept=True, max_iter=None,
normalize=False, solver='auto', tol=0.001),
fit_params={}, iid=True, loss_func=None, n_jobs=1,
param_grid={'alpha': array([
1.00000e+00,
1.00000e-01,
1.00000e-02,
1.00000e-03,
1.00000e-04,
0.00000e+00])},
pre_dispatch='2*n_jobs', refit=True, score_func=None, scoring=None,
verbose=0)
有时随机从给定区间中选择参数是很有效的方法，然后根据这些参数来评估算法的效果进而选择最佳的那个。
RandomizedSearchCV（模块使用）&（原理详解）
1 import numpy as np
2 from scipy.stats import uniform as sp_rand
3 from sklearn.linear_model import Ridge
4 from sklearn.grid_search import RandomizedSearchCV
5 # prepare a uniform distribution to sample for the alpha parameter
6 param_grid = {'alpha': sp_rand()}
7 # create and fit a ridge regression model, testing random alpha values
8 model = Ridge()
9 rsearch = RandomizedSearchCV(estimator=model, param_distributions=param_grid, n_iter=100)
10 rsearch.fit(X, y)
11 print(rsearch)
12 # summarize the results of the random parameter search
13 print(rsearch.best_score_)
14 print(rsearch.best_estimator_.alpha)
我们总体了解了使用scikit-learn库的大致流程，希望这些总结能让初学者沉下心来，一步一步尽快的学习如何去解决具体的机器学习问题。
参考文献：/p/1c6efdbce226
阅读(...) 评论()}