机器学习：sklearn入门

机器学习库sklearn

在搞python爬虫之前草草地学了一下python数据分析和机器学习实战这两本书，懂一点数据结构和算法。但是最方便的莫过于
import sklearn 了。当时是看某个视频学习了一下，只有一点印象。刚好过几天要国赛，就简单复习一下库的使用好了。

搞机一套流程：获取数据 -> 数据预处理 -> 训练建模 -> 模型评估 -> 预测，分类

一、获取数据

很多大学都有自己的数据库。练习就直接用自带的。有多少自己去包里看下。

• load_name：已经有了
• fetch_name：在线下载
• make_name：自己创建

from sklearn import datasets

digits = load_digits()
X, y = digits.data, digits.target
# 获取数据集的特征向量和标签向量
print(X.shape)
print(y)
print(digits.target_names)

# (1797, 64)
# [0 1 2 ... 8 9 8]
# [0 1 2 3 4 5 6 7 8 9]
# 这里不是列表全是numpy.ndarray基本类型

因为我们标签向量按数字从0开始连续递增，因此可以使用np.bincount()进行标签统计，
或者用标准库里的Counter进行计数

from collections import Counter

print(np.bincount(y))
print(sorted(dict(Counter(y)).items()))
# [178 182 177 183 181 182 181 179 174 180] 对应0-9
# [(0, 178), (1, 182), (2, 177), (3, 183), (4, 181), (5, 182), (6, 181), (7, 179), (8, 174), (9, 180)]

生成数据集

make_classification
还有好多就官方文档看吧
http://scikit-learn.org/stable/modules/classes.html

X, y = make_classification(10, 5, n_classes=2)
# 维度数要大于redundant和informative和
print(X)
print(y)

二、数据预处理

1、归一、标准化

这个是肯定要的，数量级的差异对比如kNN算法影响很大，其它的我也不了解，挠头。可以自己写个函数，把每列抽出来，折算成比例范围。这个对应了 MinMaxScaler

MinMaxScaler() 归一

scaler = preprocessing.MinMaxScaler(feature_range=(0, 1), copy=True).fit(X)
# copy=True表示transform后不会替代原来的矩阵X，否则会作用于原来的数据

StandardScaler() 标准

公式为：(X-mean)/std 计算时对每个属性/每列分别进行。
* 或者直接使用preprocessing.scale(X)，这种就是一次性的，无法保留属性值。
得到的结果是，对于每个属性/每列来说所有数据都聚集在0附近，方差为1。
scale_就是标准差，对应上式std，即缩放比例。

scaler = preprocessing.StandardScaler().fit(X)
print(scaler.mean_)
print(scaler.var_)
print(scaler.scale_)

# [-0.02684518 -0.29076701 -0.18421849  0.00273831 -0.12265151]
# [0.07617365 1.48030047 2.02875924 2.08120969 0.76262873]
# [1.51812173 0.69300469 0.7411775  1.6262615  1.68514421]

print(scaler.transform(X))
print(scaler.inverse_transform(scaler.transform(X)))
# inverse_transform 反向变换

2、正则化 normalize

正则化的过程是将每个样本缩放到单位范数（每个样本的范数为1），如果后面要使用如二次型（点积）或者其它核方法计算两个样本之间的相似性这个方法会很有用。

X = [[ 1., -1.,  2.],
    [ 2.,  0.,  0.],
    [ 0.,  1., -1.]]
normalized = preprocessing.normalize(X, norm="l2")
print(normalized)

# [[ 0.40824829 -0.40824829  0.81649658]
# [ 1.          0.          0.        ]
# [ 0.          0.70710678 -0.70710678]]

3、one-hot编码

如果不加 toarray() 的话，输出的是稀疏的存储格式，即索引加值的形式。

>>> from sklearn.preprocessing import  OneHotEncoder
>>> enc = OneHotEncoder()
>>> enc.fit([[0, 0, 3],
...          [1, 1, 0],
...          [0, 2, 1],
...          [1, 0, 2]])
OneHotEncoder(categorical_features='all', dtype=<class 'numpy.float64'>,
       handle_unknown='error', n_values='auto', sparse=True)
>>> ans = enc.transform([[0, 1, 3]])
>>> ans
<1x9 sparse matrix of type '<class 'numpy.float64'>'
        with 3 stored elements in Compressed Sparse Row format>
>>> print(ans)
  (0, 8)        1.0
  (0, 3)        1.0
  (0, 0)        1.0
>>> ans.A 
array([[1., 0., 0., 1., 0., 0., 0., 0., 1.]])

三、数据集划分

1.train_test_split

在得到训练数据集时，通常我们经常会把训练数据集进一步拆分成训练集和验证集，这样有助于我们模型参数的选取。
test_size：
if float: 测试样本相对比例 （默认：0.25）
if int: 测试样本绝对个数
random_state:
int - 随机种子（种子固定，实验可复现）
shuffle
是否在分割之前对数据进行洗牌（默认True）

from sklearn.mode_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

2.StratifiedShuffleSplit(n_splits=10, test_size=’default’, train_size=None, random_state=None)

n_splits=10: 训练测试对的组数
注意返回的是原数据对应的index，有点交叉验证的感觉，1是就分一次，这个分好几次。

from sklearn.model_selection import StratifiedShuffleSplit

X, y = make_classification(10, 5, n_classes=2)
ss = StratifiedShuffleSplit(5, test_size=0.3, random_state=0)
for train_index, test_index in ss.split(X, y):
    print("train:", train_index, "test:", test_index)

# train: [0 3 8 5 2 7 9] test: [1 6 4]
# train: [4 6 0 9 1 5 3] test: [2 8 7]
# train: [5 3 9 8 6 4 2] test: [7 0 1]
# train: [3 2 0 7 4 5 6] test: [9 1 8]
# train: [9 8 0 2 6 4 1] test: [7 3 5]

四、定义模型

sklearn为所有模型提供了非常相似的接口，用法很简单。这里我列举一下我看书认识到的一些模型。

model.fit(X_train, y_train)
model.predict(X_test)

# 获得这个模型的参数
model.get_params()

# 为模型进行打分
model.score(data_X, data_y) # 线性回归：R square； 分类问题： acc

1.分类

1）逻辑回归
penalty：使用指定正则化项（默认：l2）
dual: n_samples > n_features取False（默认）
C：正则化强度的反，值越小正则化强度越大
n_jobs: 指定线程数
random_state：随机数生成器
fit_intercept: 是否需要常量

from sklearn import linear_model
from sklearn import datasets
from sklearn.model_selection import train_test_split

model = linear_model.LinearRegression()
data = datasets.load_iris()

X_train, X_test, y_train, y_test = train_test_split(data.data, data.target)
model.fit(X_train, y_train)

print(model.score(X_test, y_test))
# 0.9264048837779195

2）k-近邻算法
n_neighbors： 使用邻居的数目
n_jobs：并行任务数

from sklearn import neighbors
model = neighbors.KNeighborsClassifier(n_neighbors=5)
......
# 0.8947368421052632

3）决策树
criterion ：特征选择准则gini/entropy
max_depth：树的最大深度，None-尽量下分
min_samples_split：分裂内部节点，所需要的最小样本树
min_samples_leaf：叶子节点所需要的最小样本数
max_features: 寻找最优分割点时的最大特征数
max_leaf_nodes：优先增长到最大叶子节点数
min_impurity_decrease：如果这种分离导致杂质的减少大于或等于这个值，则节点将被拆分。

from sklearn import tree

model = tree.DecisionTreeClassifier(criterion="gini")

4）朴素贝叶斯
alpha：平滑参数
fit_prior：是否要学习类的先验概率；false-使用统一的先验概率
class_prior: 是否指定类的先验概率；若指定则不能根据参数调整
binarize: 二值化的阈值，若为None，则假设输入由二进制向量组成

from sklearn import naive_bayes
model = naive_bayes.GaussianNB() 
model = naive_bayes.MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None)
# 文本分类问题常用MultinomialNB
model = naive_bayes.BernoulliNB(alpha=1.0, binarize=0.0, fit_prior=True, class_prior=None)

5）支持向量机
C：误差项的惩罚参数C
gamma: 核相关系数。浮点数，If gamma is ‘auto’ then 1/n_features will be used instead.

from sklearn.svm import SVC
model = SVC(C=1.0, kernel="rbf", gamma="auto")

6）多层感知机
hidden_layer_sizes: 元祖
activation：激活函数
solver ：优化算法{‘lbfgs’, ‘sgd’, ‘adam’}
alpha：L2惩罚(正则化项)参数。

from sklearn.neural_network import MLPClassifier
model = MLPClassifier(activation='relu', solver='adam', alpha=0.0001)

2.回归预测

1）线性回归
fit_intercept：是否计算截距。False-模型没有截距
normalize： 当fit_intercept设置为False时，该参数将被忽略。 如果为真，则回归前的回归系数X将通过减去平均值并除以l2-范数而归一化。
n_jobs：指定线程数

from sklearn.linear_model import LinearRegression
model = LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=1)

这块认识的比较少，有空来填坑。。。

3.无监督学习

1）聚类
KMeans

from sklearn.cluster import KMeans
y_pred = KMeans(n_clusters=3, random_state=9).fit_predict(X)

五、模型评估

1).交叉验证

model：拟合数据的模型
cv ： k-fold 即将数据分成k份
scoring: 打分参数-‘accuracy’、‘f1’、‘precision’、‘recall’ 、‘roc_auc’、’neg_log_loss’等等

from sklearn.model_selection import cross_val_score
# 这里直接用原始数据了
print(cross_val_score(model, data.data, data.target, cv=5))
# [0.96666667 1.         0.96666667 0.96666667 1.        ] 长度=cv

2).检验曲线

model:用于fit和predict的对象
X, y: 训练集的特征和标签
param_name：将被改变的参数的名字
param_range： 参数的改变范围
cv：k-fold

from sklearn.model_selection import validation_curve
train_score, test_score = validation_curve(model, X, y, param_name, param_range, cv=None, scoring=None, n_jobs=1)

六、保存模型

1）保存为pickle文件

import pickle

# 保存模型
with open('model.pickle', 'wb') as f:
    pickle.dump(model, f)

# 读取模型
with open('model.pickle', 'rb') as f:
    model = pickle.load(f)
model.predict(X_test)

2）sklearn自带方法joblib

from sklearn.externals import joblib

# 保存模型
joblib.dump(model, 'model.pickle')

#载入模型
model = joblib.load('model.pickle')

其它

诶，前段时间学算法实现学的头发掉光。数学分析要好好复习了，一年没应用已经忘得差不多。
学习理论么花半天，写算法么花半天。
直接 import sklearn 真的爽爆！！