复盘一篇讲sklearn库的文章(下)

skleran-处理流程

获取数据

以用sklearn的内置数据集, 先导入datasets模块.

最经典的iris数据集作为例子.

from sklearn import datasets

iris = datasets.load_iris()  # 导入数据集, json格式
X = iris.data  # 获取特征向量
y = iris.target # 获取样本标签

print('特征向量:', X[:3])
print("样本标签:", y[40:60])

特征向量: [[5.1 3.5 1.4 0.2]
 [4.9 3.  1.4 0.2]
 [4.7 3.2 1.3 0.2]]
样本标签: [0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1]

手写数字数据集 (load_digits)

包含1797个0-9的手写数字数据, 每个数据由8 x 8大小的矩阵构成, 矩阵中值的范围是0-16, 代表颜色的深度.

digits = datasets.load_digits()

print('特征向量shape:', digits.data.shape)
print('目标值shape:', digits.target.shape)
print('图片形状:', digits.images.shape)

特征向量shape: (1797, 64)
目标值shape: (1797,)
图片形状: (1797, 8, 8)

# 显示如下

import matplotlib.pyplot as plt
from sklearn.datasets import load_digits

digits = load_digits()

# plt.matshow(digits.images[1])  # 下标索引
# plt.show()

创建数据集

除了用sklearn自带的数据集外, 也可以自己创建训练样本.

参考: https://scikit-learn.org/stable/datasets/

# eg. 用分类问题的样本生成器举例
from sklearn.datasets.samples_generator import make_classification

# n_samples: 样本数
# n_features: 特征数
# n_classes: 几分类
# random_state: 随机种子, 使得随机状态可重复
X, y = make_classification(
    n_samples=6,
    n_features=5,
    n_informative=2,
    n_redundant=2,
    n_classes=2,
    n_clusters_per_class=2,
    scale=1.0,
    random_state=20
)

# test
for x, y in zip(X, y):
    print(y, end=': ')
    print(x)

0: [-0.6600737  -0.0558978   0.82286793  1.1003977  -0.93493796]
1: [ 0.4113583   0.06249216 -0.90760075 -1.41296696  2.059838  ]
1: [ 1.52452016 -0.01867812  0.20900899  1.34422289 -1.61299022]
0: [-1.25725859  0.02347952 -0.28764782 -1.32091378 -0.88549315]
0: [-3.28323172  0.03899168 -0.43251277 -2.86249859 -1.10457948]
1: [ 1.68841011  0.06754955 -1.02805579 -0.83132182  0.93286635]

用sklearn.datasets.make_blobs生成聚类测试数据

make_blobs()会根据用户指定的特征数量, 中心点数, 范围等来生成基类数据.

输入:

• n_samples: 样本量(row)
• n_features: 数据的维数(columns)
• centers: 数据中心点(int, 个数) or 坐标值
• cluster_std: 分布的标准差

输出

• X, [n-samples, n_features]形状的样本矩阵
• y, [n_samples]形状的数据, 表示每个点(row)的标签(类别)

from sklearn.datasets import make_blobs
from matplotlib import pyplot as plt

# 生成一个100x2, center=5的样本, 2维是为方便可视化
# cluster_std: 为每个类别设置不同方差
data, lable = make_blobs(n_samples=100, n_features=2, centers=5, cluster_std=[0,1,2,1,3])

# 可视化这100个2维的点
# ndarray: [row, column], 下标从0开始
# plt.scatter(data[:, 0], data[:,1], c=lable)

用sklearn.datasets.make_classification生成分类数据

输入:

• n_features
• n_infomative: 多信息特征个数
• n_redundant: 容易信息
• n_repeated: 重复信息
• n_classes: 分类类别
• n_cluster_per_class: 某一个类别是有几个cluster组成的

用make_gaussian和make_hastie_10_2生成数据

用Hastie算法, 生成二分类数据

# from matplotlib import pyplot as plt

# from sklearn.datasets import make_classification
# from sklearn.datasets import make_gaussian_quantiles  # 高斯分布
# from sklearn.datasets import make_blobs, make_hastie_10_2

# plt.figure(figsize=(9,9))
# plt.subplots_adjust(bottom=0.05, top=0.8, left=0.05, right=0.95)

# plt.subplot(111)
# plt.title("One informative feature, one cluster per class", fontsize='small')
# X1, Y1 = make_classification(n_samples=1000,n_features=2, n_redundant=0, n_informative=1,
#                              n_clusters_per_class=1)
# plt.scatter(X1[:, 0], X1[:, 1], marker='o', c=Y1)

# plt.subplot(222)
# plt.title("Two informative features, one cluster per class", fontsize='small')
# X1, Y1 = make_classification(n_samples=1000,n_features=2, n_redundant=0, n_informative=2,
#                              n_clusters_per_class=1, n_classes=3)
# plt.scatter(X1[:, 0], X1[:, 1], marker='o', c=Y1)

# 不画了, 画图其实没多大意思还麻烦
# plt.show()

数据预处理 preprocessing

其实就是为了消除数值数据的量纲, 即通常说的归一化, 标准化等

from sklearn import preprocessing

• StandardScaler -> scale()
• MaxAbsScaler -> maxabs_scale()
• MinMaxScaler -> minmax_sclale()
• RobusSclaler -> robust_scale()
• Normalizer -> normaizer()

sklearn.preprocessing.scale(X)

标准化

\[X' = \frac{X-\mu}{\sigma}
\]

即用特征值减去均值, 除以标准差

fit

用来计算训练数据的均值和方差等.

fit_transform

基于fit再进一步来转换训练数据, 从而将数据转换为标准的正态分布

transform

只是对训练数据进行转换.通常是先fit, 再transform

from sklearn import preprocessing

data = [[1,2],[2,1],[1,1],[0,0]]

scaler = preprocessing.StandardScaler()
scaler.fit(data)
scaler.transform(data)

StandardScaler(copy=True, with_mean=True, with_std=True)

array([[ 0.        ,  1.41421356],
       [ 1.41421356,  0.        ],
       [ 0.        ,  0.        ],
       [-1.41421356, -1.41421356]])

最小-最大规范化

对原始数据进行线性变换,变换到[0,1]区间

\[X' = \frac{X-X_{min}}{X_{max} - X_{min}}
\]

scaler = preprocessing.MinMaxScaler()
# 对训练数据 fit+transform, 对测试数据只transform
# scaler.fit(train_data)

scaler.transform(train_data)
scaler.transform(test_data)

规范化(normalize)

就是向量的标准化嘛, 先求出样本的p范数, 然后用每个点都的值除以该范数. 即将不同变化范围的值映射到相同的固定范围, 最常见的是[0,1]

X = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
]

preprocessing.normalize(X)

array([[0.26726124, 0.53452248, 0.80178373],
       [0.45584231, 0.56980288, 0.68376346],
       [0.50257071, 0.57436653, 0.64616234]])

one-hot 编码

是对离散特征值的编码方式, 这个对于文本, 简直太重要了

data = [['a', 'b', 'c'], ['c', 'd', 'f']]

encoder = preprocessing.OneHotEncoder().fit(data)
encoder.transform(data).toarray()

array([[1., 0., 1., 0., 1., 0.],
       [0., 1., 0., 1., 0., 1.]])

标签编码

x = ['今晚', '月色', '真美', '真美']

lable = preprocessing.LabelEncoder().fit(x)
lable.transform(x)

array([0, 1, 2, 2], dtype=int64)

数据集拆分

将数据集拆分为4部分: X_train, X_test, y_train, y_test

from sklearn.model_selection import train_test_split

x_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=20)

训练模型(API)

说到调api, 兄嘚, 这是我的强项呀, 工作也是, 工作任务上尽可能不造轮子, 直接调api或C,V. 真的发现自己, 从不生产代码, 只想做代码的搬运工.

咋搬运呢? Python一切皆对象吗,这些封装不就是在一个个的类里面嘛, 即实例化一个类对象, 然后就用方法呀,这对我太熟悉了.

# 0. 特征工程
# 1. 实例化一个模型对象
model = ModelClassName()
# 2. 训练模型
model.fit(X_train, y_train)
# 3. 模型预测
model.predict(X_test)
# 4. 模型评分
model.score(X_test, y_test)
# 5. 查看模型参数
model.get_params()
# 6. 模型优化(超参数, 重写特征工程)
# 7. 反复调参....
# 8. 保存模型

常用模型api

线性回归

from sklearn.linear_model import LinearRegression

model = LinearRegression()

# 参数
# fit_intercept: 是否计算截距, default True
# normalize: 归一化
# n_jobs: 指定线程数

逻辑回归LR

from sklearn.linear_model import LogisticRegression 

model = LogisticRegression()

# 参数
# penalty: 默认L2正则化
# dual: n_samples > n_features 取False
# C: 该值与正则化强度呈反比
# random_state: 随机数生成器(保留相同采样值次数)
# fit_intercept: 是否需要常量

朴素贝叶斯(Naive Bayes)

from sklearn import naive_bayes

m1 = naive_bayes.MultinomialNB() # 用于文本分类

m2 = naive_bayes.GaussianNB()  # 高斯贝叶斯

m3 = naive_bayes.BernoulliNB() # 伯努利概型

# 参数
# alpha: 平滑参数, 不让分母为0, 服从拉普拉斯分布
# fit_prior: 使用学习类的先验概率, false: 使用同一的先验概率
# class_prior: 指定类的先验概率
# binarize: 二值化阀值,若为None, 则假设输入有二进制向量组成 

决策树DT

from sklearn import tree

model = tree.DecisionTreeClassifier()

# 参数
# criterion: 算法选择, 如ID3, CART4, 基尼...
# max_depth: 数的最大深度, None-尽量下分
# min_samples_split: 分裂内部节点,所需最小样本数
# .....

支持向量机SVM

from sklearn.svm import SVC 

model = SVC(C=1.0, kernel='rbf', gamma='auto')

# C: 误差项惩罚数c
# gamma: 核相关系数

K近邻算法KNN

from sklearn import neighbors

m1 = neighbors.KNeighborsClassifier()  # 分类

m2 = neighbors.KNeighborsRegressor()  # 回归

# 参数
# n_neighbors: 使用邻居的数目...

多层感知机(神经网络)

from sklearn.neural_network import MLPClassifier

m1 = MLPClassifier(activation='relu', solver='adam')

# 参数
# hidden_layer_sizes: (n,m)元组, n个隐藏单元, m个隐藏层
# activation: 激活函数
# solver: 优化算法(lbfgs, sgd, adam)
# alpha: L2惩罚参数

交叉验证

什么5折交叉验证, 网格搜索的, 这部分, 就是调参的过程, 就不展开了, 总之, 耐心和恒心, 总会获得收获的.

保存模型

保存为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)
# call
model.predict(X_test)

sklean 自带方法 joblib

from sklearn.externals import joblib

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

# 载入模型
model = joblib.load('model.picle')
# call
model.predict(X_test)

模型评分

1. 模型的score方法: 调用自己模型

print(model.score(X_test, y_test))

1. sklearn指标函数, 如常用的classification_report方法
2. 支持自定义开发的评价方法

集中交叉验证的方式比较

train_test_split

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

import matplotlib.pyplot as plt
import warnings

warnings.filterwarnings('ignore')  # 忽略警告信息

# 获取数据
cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    cancer.data, cancer.target, test_size=0.30)

# 训练模型
logstic = LogisticRegression().fit(X_train, y_train)

# score
print('score:', round(logstic.score(X_test, y_test),3))

score: 0.947

k-fold cross validation

from sklearn.datasets import load_iris
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.linear_model import LogisticRegression

import warnings

warnings.filterwarnings('ignore')

iris = load_iris()
lg = LogisticRegression()

k_fold = StratifiedKFold(n_splits=3, shuffle=False)
scores = cross_val_score(lg, iris.data, iris.target, cv=k_fold)

print('scores:', scores)
print('mean_scores:', round(scores.mean()))

scores: [0.96078431 0.92156863 0.95833333]
mean_scores: 1.0