sklearn 的基本机器学习（分类方法）

１．

ＫＮＮ原理：

存在一个样本数据集合，也称作训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一个数据与所属分类的对应关系。输入没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本集中最相似数据（最近邻）的分类标签。一般来说，只选择样本数据集中前个最相似的数据，这就是KNN算法 的出处, 通常 是不大于20的整数。最后，选择 个最相似数据中出现次数最多的分类，作为新数据的分类。

代码：

   
   

     
     

      
      

     
     
     
     

      
      

       
       #-*-coding:utf-8 -*-
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       from sklearn 
       
       import datasets
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       #导入内置数据集模块
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       from sklearn.neighbors 
       
       import KNeighborsClassifier
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       #导入sklearn.neighbors模块中KNN类
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       import numpy 
       
       as np
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       iris=datasets.load_iris()
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       #导入鸢尾花的数据集，iris是一个数据集，内部有样本数据
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       iris_x=iris.data
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       iris_y=iris.target
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       indices = np.random.permutation(len(iris_x))
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       #permutation接收一个数作为参数(150),产生一个0-149一维数组，只不过是随机打乱的
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       iris_x_train = iris_x[indices[:
       
       -10]]
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
       
       #随机选取140个样本作为训练数据集
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       iris_y_train = iris_y[indices[:
       
       -10]]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 并且选取这140个样本的标签作为训练数据集的标签
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       iris_x_test = iris_x[indices[
       
       -10:]]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 剩下的10个样本作为测试数据集
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       iris_y_test = iris_y[indices[
       
       -10:]]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 并且把剩下10个样本对应标签作为测试数据及的标签
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       knn = KNeighborsClassifier()
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 定义一个knn分类器对象
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       knn.fit(iris_x_train, iris_y_train)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 调用该对象的训练方法，主要接收两个参数：训练数据集及其样本标签
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       iris_y_predict = knn.predict(iris_x_test)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 调用该对象的测试方法，主要接收一个参数：测试数据集
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       score = knn.score(iris_x_test, iris_y_test, sample_weight=
       
       None)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 调用该对象的打分方法，计算出准确率
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       print(
       
       ‘iris_y_predict = ‘)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       print(iris_y_predict)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 输出测试的结果
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       print(
       
       ‘iris_y_test = ‘)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       print(iris_y_test)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 输出原始测试数据集的正确标签，以方便对比
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       print 
       
       ‘Accuracy:’, score
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 输出准确率计算结果
      
      
     
     
   
   

２．

ＳＶＭ原理：

SVM既可以用来分类，就是SVC；又可以用来预测，或者成为回归，就是SVR

代码：

   
   

     
     

      
      

     
     
     
     

      
      

       
       from sklearn 
       
       import svm
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       X = [[
       
       0, 
       
       0], [
       
       1, 
       
       1], [
       
       1, 
       
       0]]  
       
       # 训练样本
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       y = [
       
       0, 
       
       1, 
       
       1]  
       
       # 训练目标
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       clf = svm.SVC()  
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       clf.fit(X, y)  
       
       # 训练ＳＶＣ模型
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       result = clf.predict([
       
       2, 
       
       2])  
       
       # 预测　测试样本
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       print result  
       
       # 得出预测值
      
      
     
     
   
   

此外补充一个训练模型的加载与保存：

   
   

     
     

      
      

     
     
     
     

      
      

       
       # 将训练好的模型保存到train_model.m中
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       joblib.dump(clf, 
       
       "train_model.m")
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 模型的加载
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       clf = joblib.
       
       load(
       
       "train_model.m")
      
      
     
     
   
   

３．

集成方法　随机森林原理：

集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型，各自独立地学习和作出预测。这些预测最后结合成单预测，因此优于任何一个单分类的做出预测。随机森林是集成学习的一个子类．

代码：

   
   

     
     

      
      

     
     
     
     

      
      

       
       #coding=utf-8
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       from sklearn 
       
       import datasets
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       from sklearn.ensemble 
       
       import  RandomForestClassifier
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       #应用iris数据集
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       import numpy 
       
       as np
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       iris=datasets.load_iris()
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       #导入鸢尾花的数据集，iris是一个数据集，内部有样本数据
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       iris_x=iris.data
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       iris_y=iris.target
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       indices = np.random.permutation(len(iris_x))
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       #permutation接收一个数作为参数(150),产生一个0-149一维数组，只不过是随机打乱的
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       x_train = iris_x[indices[:
       
       -10]]
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
       
       #随机选取140个样本作为训练数据集
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       y_train = iris_y[indices[:
       
       -10]]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 并且选取这140个样本的标签作为训练数据集的标签
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       x_test = iris_x[indices[
       
       -10:]]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 剩下的10个样本作为测试数据集
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       y_test = iris_y[indices[
       
       -10:]]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       # 并且把剩下10个样本对应标签作为测试数据及的标签
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       #分类器：自由森林
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       clfs = {
       
       'random_forest' : RandomForestClassifier(n_estimators=
       
       50)}
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       #构建分类器，训练样本，预测得分
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       def try_different_method(clf):
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           clf.fit(x_train,y_train.ravel())
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           score = clf.score(x_test,y_test.ravel())
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           print(
       
       'the score is :', score)
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       for clf_key 
       
       in clfs.keys():
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           print(
       
       'the classifier is :',clf_key)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           clf = clfs[clf_key]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           try_different_method(clf)
      
      
     
     
   
   

            </div>