7）Python模块：sklearn

机器学习分为四大块，分别是 classification (分类)， clustering (聚类), regression (回归), dimensionality reduction (降维)。

官网

scikit-learn 是机器学习领域非常热门的一个开源库，基于Python 语言写成。专门用于机器学习的模块。 可以免费使用。

SKlearn包含的机器学习方式： 分类，回归，无监督，数据降维，数据预处理等等，包含了常见的大部分机器学习方法。 

scikit-learn中学习模式的调用，有很强的统一性，很多都是类似的。

from sklearn.linear_model importLinearRegression #导入模型

regressor = LinearRegression() #建立模型

regressor = regressor.fit(X_train, Y_train) #训练模型

regressor.predict(X_test) #预测

总结起来就是8个字：导入-建模-训练-预测

数据库网址：http://scikit-learn.org/stable/modules/classes.html#module-sklearn.datasets 
里面包含了很多数据，可以直接拿来使用。 

简单实例：

实例1
from sklearn import datasets
from sklearn.model_selection import train_test_split
iris = datasets.load_iris()
iris_X = iris.data
iris_y = iris.target
X_train, X_test, y_train, y_test = train_test_split(iris_X, iris_y, test_size=0.3)#划分为训练集和测试集数据


from sklearn.neighbors import KNeighborsClassifier #导入模型，k近邻函数
knn = KNeighborsClassifier() #建立模型
knn.fit(X_train,y_train) #训练模型
print(knn.predict(X_test)) #预测
print(y_test) #实际结果对照


实例2
from sklearn import datasets
loaded_data = datasets.load_boston()
data_X = loaded_data.data
data_y = loaded_data.target

from sklearn.linear_model import LinearRegression#调用线性回归函数
model = LinearRegression()
model.fit(data_X, data_y)
print(model.predict(data_X[:4,:]))
print(data_y[:4])

xgboost本质上还是GBDT，只是对GBDT进行了一些更改，叫X (Extreme) GBoosted，它把速度和效率做到了极致。在scikit-learn目前还没有这个分类器，因此要进行单独的安装。pip3 install xgboost

 

  以最广泛的分类算法为例，大致可以分为线性和非线性两大派别。线性算法有著名的逻辑回归、朴素贝叶斯、最大熵等，非线性算法有随机森林、决策树、神经网络、核机器等等。线性算法举的大旗是训练和预测的效率比较高，但最终效果对特征的依赖程度较高，需要数据在特征层面上是线性可分的。因此，使用线性算法需要在特征工程上下不少功夫，尽量对特征进行选择、变换或者组合等使得特征具有区分性。而非线性算法则牛逼点，可以建模复杂的分类面，从而能更好的拟合数据。

       那在我们选择了特征的基础上，哪个机器学习算法能取得更好的效果呢？谁也不知道。实践是检验哪个好的不二标准。那难道要苦逼到写五六个机器学习的代码吗？No，机器学习社区的力量是强大的，码农界的共识是不重复造轮子！因此，对某些较为成熟的算法，总有某些优秀的库可以直接使用，省去了大伙调研的大部分时间。

       基于目前使用python较多，而python界中远近闻名的机器学习库要数scikit-learn莫属了。这个库优点很多。简单易用，接口抽象得非常好，而且文档支持实在感人。本文中，我们可以封装其中的很多机器学习算法，然后进行一次性测试，从而便于分析取优。当然了，针对具体算法，超参调优也非常重要。
 本次使用mnist手写体库进行实验：http://deeplearning.net/data/mnist/mnist.pkl.gz。共5万训练样本和1万测试样本。

#!usr/bin/env python
# -*- coding: utf-8 -*-

import os
import time
from sklearn import metrics
import numpy as np
import pickle
import sys


# Multinomial Naive Bayes Classifier
def naive_bayes_classifier(train_x, train_y):
    from sklearn.naive_bayes import MultinomialNB
    model = MultinomialNB(alpha=0.01)
    model.fit(train_x, train_y)
    return model


# KNN Classifier
def knn_classifier(train_x, train_y):
    from sklearn.neighbors import KNeighborsClassifier
    model = KNeighborsClassifier()
    model.fit(train_x, train_y)
    return model


# Logistic Regression Classifier
def logistic_regression_classifier(train_x, train_y):
    from sklearn.linear_model import LogisticRegression
    model = LogisticRegression(penalty='l2')
    model.fit(train_x, train_y)
    return model


# Random Forest Classifier
def random_forest_classifier(train_x, train_y):
    from sklearn.ensemble import RandomForestClassifier
    model = RandomForestClassifier(n_estimators=8)
    model.fit(train_x, train_y)
    return model


# Decision Tree Classifier
def decision_tree_classifier(train_x, train_y):
    from sklearn import tree
    model = tree.DecisionTreeClassifier()
    model.fit(train_x, train_y)
    return model


# GBDT(Gradient Boosting Decision Tree) Classifier
def gradient_boosting_classifier(train_x, train_y):
    from sklearn.ensemble import GradientBoostingClassifier
    model = GradientBoostingClassifier(n_estimators=200)
    model.fit(train_x, train_y)
    return model


# SVM Classifier
def svm_classifier(train_x, train_y):
    from sklearn.svm import SVC
    model = SVC(kernel='rbf', probability=True)
    model.fit(train_x, train_y)
    return model


# SVM Classifier using cross validation
def svm_cross_validation(train_x, train_y):
    from sklearn.model_selection import GridSearchCV
    from sklearn.svm import SVC
    model = SVC(kernel='rbf', probability=True)
    param_grid = {'C': [1e-3, 1e-2, 1e-1, 1, 10, 100, 1000], 'gamma': [0.001, 0.0001]}
    grid_search = GridSearchCV(model, param_grid, n_jobs=1, verbose=1)
    grid_search.fit(train_x, train_y)
    best_parameters = grid_search.best_estimator_.get_params()
    for para, val in best_parameters.items():
        print(para, val)
    model = SVC(kernel='rbf', C=best_parameters['C'], gamma=best_parameters['gamma'], probability=True)
    model.fit(train_x, train_y)
    return model


def read_data(data_file):
    import gzip
    # f = gzip.open(data_file, "rb")
    # train, val, test = pickle.load(f)
    f = gzip.open(data_file, "rb")
    Myunpickle = pickle._Unpickler(file=f, fix_imports=True, encoding='bytes', errors="strict")
    train, val, test = Myunpickle.load()
    f.close()
    train_x = train[0]
    train_y = train[1]
    test_x = test[0]
    test_y = test[1]
    return train_x, train_y, test_x, test_y


if __name__ == '__main__':
    data_file = "d:/mnist.pkl.gz"
    thresh = 0.5
    model_save_file = None
    model_save = {}

    test_classifiers = ['NB', 'KNN', 'LR', 'RF', 'DT', 'SVM', 'GBDT']
    classifiers = {'NB': naive_bayes_classifier,
                   'KNN': knn_classifier,
                   'LR': logistic_regression_classifier,
                   'RF': random_forest_classifier,
                   'DT': decision_tree_classifier,
                   'SVM': svm_classifier,
                   'SVMCV': svm_cross_validation,
                   'GBDT': gradient_boosting_classifier
                   }

    print('reading training and testing data...')
    train_x, train_y, test_x, test_y = read_data(data_file)
    num_train, num_feat = train_x.shape
    num_test, num_feat = test_x.shape
    is_binary_class = (len(np.unique(train_y)) == 2)
    print( '******************** Data Info *********************')
    print( '#training data: %d, #testing_data: %d, dimension: %d' % (num_train, num_test, num_feat))

    for classifier in test_classifiers:
        print('******************* %s ********************' % classifier)
        start_time = time.time()
        model = classifiers[classifier](train_x, train_y)
        print('training took %fs!' % (time.time() - start_time))
        predict = model.predict(test_x)
        if model_save_file != None:
            model_save[classifier] = model
        if is_binary_class:
            precision = metrics.precision_score(test_y, predict)
            recall = metrics.recall_score(test_y, predict)
            print('precision: %.2f%%, recall: %.2f%%' % (100 * precision, 100 * recall))
        accuracy = metrics.accuracy_score(test_y, predict)
        print('accuracy: %.2f%%' % (100 * accuracy))

    if model_save_file != None:
        pickle.dump(model_save, open(model_save_file, 'wb'))

  在这个数据集中，由于数据分布的团簇性较好（如果对这个数据库了解的话，看它的t-SNE映射图就可以看出来。由于任务简单，其在deep learning界已被认为是toy dataset），因此KNN的效果不赖。GBDT是个非常不错的算法，在kaggle等大数据比赛中，状元探花榜眼之列经常能见其身影。三个臭皮匠赛过诸葛亮，还是被验证有道理的，特别是三个臭皮匠还能力互补的时候！

       还有一个在实际中非常有效的方法，就是融合这些分类器，再进行决策。例如简单的投票，效果都非常不错。建议在实践中，大家都可以尝试下。
 

印第安人糖尿病案例