sklearn在分类及聚类中的使用总结

一. sklearn包函数的使用

1.1 划分数据集

from sklearn.model_selection import train_test_split
(trainX,testX,trainY,testY) = train_test_split(X,y,test_size=0.2,random_state=42)

1.2 特征标准化

1.2.1 第一种

使用scale模块直接计算标准化，将标准化的array放在x_scale中，同时可以查看均值和标准差，但是该方式的一个不足是当存在新的样本到来时，无法利用已有的模块直接复用，需要利用mean和std自己计算。

x_scale = preprocessing.scale(DatMat)  
x_scale.mean(axis=0)
x_scale.std(axis=0)

1.2.2 第二种

第二种：使用StandardScaler模块计算标准化，可以利用训练集数据建立一个转化的类，类似于实现将mean和std存储在该类中，将数据输入，就可以直接求出结果。

scaler = preprocessing.StandardScaler().fit(datingDatMat)
datingDatMat = scaler.transform(datingDatMat)
new_date = numpy.array([1, 2, 3])
new_date_std = scaler.transform(new_date.reshape(1, -1))

这里的scaler更象是扮演一个计算器的角色，本身并不存储数据。

1.3 交叉验证——查验模型稳定性

from sklearn.model_selection import cross_val_score
 model_stability = cross_val_score(model,
                              trainX,trainY,cv=10,scoring="accuracy")
mean_score_model = model_stability.mean()

1.4 模型评估方式——混淆矩阵

from sklearn.metrics import confusion_matrix
print(confusion_matrix(testY,y_pred))

1.5 分类结果展示（准确性，召回率，f1-score）

from sklearn.metrics import classification_report
print(confusion_matrix(testY,y_pred))

1.6 模型的保存和加载

import pickle
# 保存模型
pickle.dump(rf_clf, open('model/model.model', 'wb'))
# 导入模型
model = pickle.load(open('model_save/model.model','wb'))

1.7 数据样本不均衡——SMOTEENN

from imblearn.combine import SMOTEENN
smote_enn = SMOTEENN(random_state=42)
X_resampled,y_resampled = smote_enn.fit_sample(X,y)

1.8 自动超参调节

1.8.1 自动调参——GridSearchCV

from sklearn.model_selection import GridSearchCV
rcl=RandomForestClassifier(min_samples_split=100,min_samples_leaf=20,max_depth=8,max_features='sqrt',random_state=10)
# 现在不确定RandomForest其中一个参数n_estimators的个数
param_test1 = {'n_estimators':range(10,71,10)}
gsearch1= GridSearchCV(estimator =rcl,param_grid=                                              param_test1,scoring='roc_auc',cv=5)
gsearch1.fit(X,y)
print(gsearch1.grid_scores_, gsearch1.best_params_, 	           gsearch1.best_score_)

1.8.2 自动调参神器——Hyperopt

from hyperopt import fmin, tpe, hp, rand
import numpy as np
from sklearn.metrics import accuracy_score
from sklearn import svm
from sklearn import datasets

# SVM的三个超参数：C为惩罚因子，kernel为核函数类型，gamma为核函数的额外参数（对于不同类型的核函数有不同的含义）
# 有别于传统的网格搜索（GridSearch），这里只需要给出最优参数的概率分布即可，而不需要按照步长把具体的值给一个个枚举出来
parameter_space_svc ={
    # loguniform表示该参数取对数后符合均匀分布
    'C':hp.loguniform("C", np.log(1), np.log(100)),
    'kernel':hp.choice('kernel',['rbf','poly']),
    'gamma': hp.loguniform("gamma", np.log(0.001), np.log(0.1)),
}

# 鸢尾花卉数据集，是一类多重变量分析的数据集
# 通过花萼长度，花萼宽度，花瓣长度，花瓣宽度4个属性预测鸢尾花卉属于（Setosa，Versicolour，Virginica）三个种类中的哪一类
iris = datasets.load_digits()

#--------------------划分训练集和测试集--------------------
train_data = iris.data[0:1300]
train_target = iris.target[0:1300]
test_data = iris.data[1300:-1]
test_target = iris.target[1300:-1]
#-----------------------------------------------------------

# 计数器，每一次参数组合的枚举都会使它加1
count = 0

def function(params):
    c = params["C"]
    kernel = params["kernel"]
    gamma = params["gamma"]

    # **可以把dict转换为关键字参数，可以大大简化复杂的函数调用
    clf = svm.SVC(C=c,kernel = kernel,gamma = gamma)

    # 训练模型
    clf.fit(train_data,train_target)

    # 预测测试集
    prediction = clf.predict(test_data)

    global count
    count = count + 1
    score = accuracy_score(test_target,prediction)
    print("第%s次，测试集正确率为：" % str(count),score)

    # 由于hyperopt仅提供fmin接口，因此如果要求最大值，则需要取相反数
    return -score

# algo指定搜索算法，目前支持以下算法：
# ①随机搜索(hyperopt.rand.suggest)
# ②模拟退火(hyperopt.anneal.suggest)
# ③TPE算法（hyperopt.tpe.suggest，算法全称为Tree-structured Parzen Estimator Approach）
# max_evals指定枚举次数上限，即使第max_evals次枚举仍未能确定全局最优解，也要结束搜索，返回目前搜索到的最优解
best = fmin(function, parameter_space_svc, algo=tpe.suggest, max_evals=100)

# best["kernel"]返回的是数组下标，因此需要把它还原回来
kernel_list = ['rbf','poly']
best["kernel"] = kernel_list[best["kernel"]]

print("最佳参数为：",best)

clf = svm.SVC(**best)
print(clf)

1.9 to_categorical

功能：将label转为one_hot形式，源于keras.utils包

from keras.utils import to_categorical
y_onehot = to_categorical(y,num_classes(总类别数))

1.10 绘制ROC曲线

from sklearn.metrics import roc_curve, auc
def draw_ROC_curve(y_test, y_predict, savepath):
    '''画ROC曲线'''
    false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_predict)
    roc_auc = auc(false_positive_rate, true_positive_rate)
    plt.title('ROC')
    plt.plot(false_positive_rate, true_positive_rate, 'b', label='AUC = %0.2f' % roc_auc)
    plt.legend(loc='lower right')
    plt.plot([0, 1], [0, 1], 'r--')
    plt.ylabel('TPR')
    plt.xlabel('FPR')
    plt.savefig(savepath)
    plt.show()
    plt.close(0)

二.分类模型

2.1 随机森林

from sklearn.ensemble import RandomForestClassifier
rf_clf = RandomForestClassifier(n_estimators=700
,n_jobs=-1,max_leaf_nodes=30)
rf_clf.fit(trainX,trainY)
y_pred = rf_clf.predict(testX)
# 特征重要性
feature_importance = rf_clf.feature_importances_

2.2.Xgboost

优势：表现快，训练时可以用所有的 CPU 内核来并行化建树；用分布式计算来训练非常大的模型；对于非常大的数据集还可以进行 Out-of-Core Computing)。参数：learning_rate ＝ 0.1 或更小，越小就需要多加入弱学习器；tree_depth ＝ 2～8；subsample ＝ 训练集的 30%～80%。

from xgboost import XGBClassifier
model = XGBClassifier()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
# 可以在每加入一颗树后打印出 logloss
eval_set = [(X_test, y_test)]
model.fit(X_train, y_train, early_stopping_rounds=10, eval_metric="logloss", eval_set=eval_set, verbose=True)
# 输出特征重要性
from xgboost import plot_importance
from matplotlib import pyplot
plot_importance(model)
pyplot.show()

2.3 SVM

from sklearn.svm import SVC
clf = SVC(gamma='auto',C,kernel = "RBF")
clf.fit(X, y)
y_pred = clf.predict(testX)

三.聚类模型

3.1 轮廓系数

评估聚类效果好坏——轮廓系数（Silhouette Coefficient）结合了聚类的凝聚度（Cohesion）和分离度（Separation），用于评估聚类的效果。该值处于-1~1之间，值越大，表示聚类效果越好。

#聚类评估：轮廓系数
from sklearn.metrics import silhouette_score
# Kmeans的聚类结果来进行测试
labels = KMeans(n_clusters=k).fit(data).labels_
score = silhouette_score(data, labels)

喜欢我的文章，还请大大们关注一波，当然可以直接访问我的主页：lixiaofei2yy.website