复盘一篇讲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)
模型评分
- 模型的score方法: 调用自己模型
print(model.score(X_test, y_test))
- sklearn指标函数, 如常用的classification_report方法
- 支持自定义开发的评价方法
集中交叉验证的方式比较
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
耐心和恒心, 总会获得回报的.
