sklearn 笔记

    scikit-learn (sklearn) 官方文档中文版          【sklearn: API Reference & .datasets】

---

 sklearn 实现简单的KNN分类 和线性回归

from __future__ import print_function   # python 3
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
# KNN分类问题
iris = datasets.load_iris()
iris_X = iris.data
iris_y = iris.target
# test train split #
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=4)
# X_train, X_test, y_train, y_test = train_test_split(iris_X, iris_y, test_size=0.3)
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
print(knn.score(X_test, y_test))
# this is cross_val_score #
from sklearn.cross_validation import cross_val_score
knn = KNeighborsClassifier(n_neighbors=5)
scores = cross_val_score(knn, X, y, cv=5, scoring='accuracy')
print(scores)

#  线性回归问题
from __future__ import print_function
from sklearn import datasets
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

loaded_data = datasets.load_boston()
data_X = loaded_data.data
data_y = loaded_data.target   #  只是属性，所以不加括号

model = LinearRegression()  # 用模型的默认参数
model.fit(data_X, data_y)  # 训练  拟合  分类问题的模型评估常用精度accuracy

print(model.predict(data_X[:4, :]))  
print(model.coef_)   # 回归系数
print(model.intercept_)  # 截距项
print(model.get_params())   #返回 model 定义时的参数
print(model.score(data_X, data_y)) # R^2 coefficient of determination 可决系数可用于回归问题 
print(data_y[:4])

交叉验证确定 KNN的最佳近邻数K

# 自行生成回归数据集，样本数为100， 特征数为1， noise越大则点越离散 
X, y = datasets.make_regression(n_samples=100, n_features=1, n_targets=1, noise=10)
plt.scatter(X, y)
plt.show()
#生成分类数据  
from sklearn import preprocessing
from sklearn.datasets.samples_generator import make_classification
import matplotlib.pyplot as plt
            
X, y = make_classification(n_samples=300, n_features=2 , n_redundant=0, n_informative=2,
                           random_state=22, n_clusters_per_class=1, scale=100)
plt.scatter(X[:, 0], X[:, 1], c=y)
plt.show()
# 数据预处理
X = preprocessing.scale(X)    # normalization step
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.3)
clf = SVC()
clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))

# 使用 cross_val_score 来选择 model and configs 
from sklearn.cross_validation import cross_val_score
import matplotlib.pyplot as plt
k_range = range(1, 31)
k_scores = []
for k in k_range:
    knn = KNeighborsClassifier(n_neighbors=k)
##  loss = cross_val_score(knn, X, y, cv=10, scoring='neg_mean_squared_error') # for regression  
    scores = cross_val_score(knn, X, y, cv=10, scoring='accuracy') # for classification
    k_scores.append(scores.mean())

plt.plot(k_range, k_scores)
plt.xlabel('Value of K for KNN')
plt.ylabel('Cross-Validated Accuracy')
plt.show()

 如何用交叉验证确定 SVC的参数gamma的最佳取值，如何选择最优参数

from __future__ import print_function
from sklearn.learning_curve import  learning_curve
from sklearn.datasets import load_digits
from sklearn.svm import SVC
import matplotlib.pyplot as plt
import numpy as np

digits = load_digits()
X = digits.data
y = digits.target
train_sizes, train_loss, test_loss= learning_curve(
        SVC(gamma=0.01), X1, y1, cv=10, scoring='neg_mean_squared_error',
        train_sizes=[0.1, 0.25, 0.5, 0.75, 1])
train_loss_mean = -np.mean(train_loss, axis=1)
test_loss_mean = -np.mean(test_loss, axis=1)

plt.plot(train_sizes, train_loss_mean, 'o-', color="r",
             label="Training")
plt.plot(train_sizes, test_loss_mean, 'o-', color="g",
             label="Cross-validation")

plt.xlabel("Training examples")
plt.ylabel("Loss")
plt.legend(loc="best")
plt.show()

# 交叉验证确定最佳参数，绘制gamma 与loss的图像
param_range = np.logspace(-6, -2.3, 5)
train_loss, test_loss = validation_curve(
        SVC(), X, y, param_name='gamma', param_range=param_range, cv=10,
        scoring='mean_squared_error')
train_loss_mean = -np.mean(train_loss, axis=1)
test_loss_mean = -np.mean(test_loss, axis=1)

plt.plot(param_range, train_loss_mean, 'o-', color="r",
             label="Training")
plt.plot(param_range, test_loss_mean, 'o-', color="g",
             label="Cross-validation")

plt.xlabel("gamma")
plt.ylabel("Loss")
plt.legend(loc="best")
plt.show()

 

模型保存：

# method 1: pickle
import pickle
# save
with open('save/clf.pickle', 'wb') as f:
    pickle.dump(clf, f)
# restore
with open('save/clf.pickle', 'rb') as f:
   clf2 = pickle.load(f)
   print(clf2.predict(X[0:1]))

# method 2: joblib
from sklearn.externals import joblib
# Save
joblib.dump(clf, 'save/clf.pkl')
# restore
clf3 = joblib.load('save/clf.pkl')
print(clf3.predict(X[0:1]))

---

用sklearn实现决策树

 

树模型参数:

• 1. criterion:   gini or entropy; 基尼系数  or 交叉熵

• 2. splitter :  best or random；默认 best 在所有特征中找最好的切分点 ；random在数据量大时，在部分特征中切分

• 3. max_features ：默认None（所有），log2，sqrt，N 特征小于50的时候一般使用所有的

• 4. max_depth： 预剪枝的核心模块，模型样本量& 特征多的情况下可以设置，否则可以不设。

• 5. min_samples_split ：如果某节点的样本数少于min_samples_split，则停止划分；样本量非常大时推荐增大这个值。

• 6. min_samples_leaf ：限制叶子节点最少的样本数，如果某叶子节点数目小于样本数，则会和兄弟节点一起被剪枝，如果样本量大些（如10W）可尝试下5

• 7. min_weight_fraction_leaf  限制叶子节点所有样本权重和的最小值，如果小于这个值，则会和兄弟节点一起被剪枝；默认是0（不考虑权重问题）。一般来说样本缺失值较多，或分类树样本的分布类别偏差很大，就会引入样本权重。

• 8. max_leaf_nodes 最大叶子节点数，默认是"None”，即不限制最大的叶子节点数。如果加了限制，算法会建立在最大叶子节点数内最优的决策树。如果特征分层多的话，可以通过交叉验证设置某个值来限制，防止过拟合。

• 9. class_weight  指定样本各类别的的权重，主要是为了防止训练集某些类别的样本过多导致训练的决策树过于偏向这些类别。可自行指定各个样本权重，如果使用“balanced”，则算法会自己计算权重，样本量少的类别所对应的样本权重会高。

• 10. min_impurity_split  如果某节点的不纯度(基尼系数，信息增益，均方差，绝对差)小于这个阈值则该节点不再生成子节点。即为叶子节点 。用于限制决策树的增长。

• n_estimators:要建立树的个数

 

 

---

scikit-learn (sklearn) 官方文档中文版         

下图出自【Scikit-Learn cheat sheet】