sklearn-从案例入手

sklearn.tree

tree.DecisionTreeClassifier	分类树
tree.DecisionTreeRegressor	回归树
tree.export_graphviz	将生成的决策树导出为DOT格式，画图专用
tree.ExtraTreeClassifier	高随机版本的分类树
tree.ExtraTreeRegressor	高随机版本的回归树

三个小案例

import pandas as pd
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split # 老版本是cross_validation
from sklearn.neighbors import KNeighborsClassifier # K近邻
from sklearn.linear_model import LinearRegression # 线性模型
import matplotlib.pyplot as plt
##############################
iris =datasets.load_iris()	# 鸢尾花 的数据
iris_X = iris.data	# 数据
iris_Y = iris.target # 标签
X_train,X_test,Y_train,Y_test = train_test_split(
    iris_X,iris_Y,test_size=0.3
) # 分为训练集和测试集
knn = KNeighborsClassifier()
knn.fit(X_train,Y_train) # 投喂训练
print(knn.predict(X_test))	# 测试
print(Y_test) # 测试集的真实标签
###############################
loaded_data = datasets.load_boston() # 楼房价格
data_X = loaded_data.data # 数据
data_Y = loaded_data.target # 标签
model = LinearRegression() # 线性回归模型
model.fit(data_X,data_Y) # 投喂数据
print(model.predict(data_X[:4,:])) # 测试
print(data_Y[:4]) # 真实值
print(model.coef_) # 系数矩阵
print(model.intercept_) # 截距矩阵
print(model.score(data_X,data_y))  
# 用data_X做测试,用data_y做对比 进行打分   R^2 coefficient of determination
###############################
X,Y=datasets.make_regression(
    n_samples=100,n_features=1,n_targets=1,noise=1
) # 产生一个回归问题
model = LinearRegression()
model.fit(X,Y)
print('这个模型的系数:\n',model.coef_)
print('这个模型的常量:\n',model.intercept_)
print('这个模型的参数:\n',model.get_params())
print('这个模型的评分:\n',model.score(X,Y))
print('这个模型预测:\n',[X[0]],model.predict([X[0]]))
plt.scatter(X,Y) # 蓝色的点是真实值
plt.plot(X,model.predict(X),color='red',) # 红色的线是训练出来的

数据集

scikit-learn数据集API介绍

• sklearn.datasets
  • 加载获取流行数据集
  • datasets.lod_*()
    • 获取小规模数据集，数据包含在datasets里
  • datasets.fetch_*()
    • 获取大规模数据集，需要从网上下载，函数的第一个参数是data_home,表示数据集下载的目录，默认是 ~/scikit_learn_data/
      

sklearn小数据集

• sklearn.datasets.load_iris()
  加载并返回鸢尾花数据集

名称	数量
类别	3
特征	4
样本数量	150
每个类别的数量	50

• sklearn.datasets.load_boston()
  加载并返回波士顿房价数据集

名称	数量
目标类别	5-50
特征	13
样本数量	506

sklearn大数据集

• sklearn.datasets.fech_20newsgroups(data_home=None,subset=‘train’)
  • subset:‘train’或者’test’,‘all’，可选，选择要加载的数据集。
  • 训练集的“训练”，测试集的“测试”，两者的“全部”
    

sklearn数据集返回值介绍

• load和fetch返回的数据类型datasets.base.Bunch(字典格式)
  • data: 特征数据数组，是[n_samples*n_features]的二维numpy.ndarray数组
  • target: 标签数组，是n_samples的一维numpy.ndarray数组
  • DESCR: 数据描述
  • feature_names: 特征名，新闻数据，手写数字\回归数据集没有
  • target_names: 标签名
    

产生一个单分类问题

• sklearn.datasets.make_blobs
  • n_features 表示每一个样本有多少特征值
  • n_samples 表示样本的个数
  • centers 是聚类中心点的个数，可以理解为label的种类数
  • random_state 是随机种子，可以固定生成的数据
  • cluster_std 设置每个类别的方差,若要指定需要传入长度为centers的列表
    

产生一个随机回归问题

• sklearn.datasets.make_regression
  • n_features(default=100) 表示每一个样本有多少特征值
  • n_samples (default=100)表示样本的个数
  • n_informative(default=10)有信息的特征数量，也就是用来构造线性模型，生成输出的特征数量
  • n_targets(default=1)回归目标的数量，也就是对应于一个样本输出向量y的维度。默认输出是标量
  • noise(default=0.0)施加于输出的高斯噪声的标准差（越大越离散）
    

数据处理

数据划分api

• sklearn.model_selection.teain_test_split(arrays,*options)
  • x 数据集的特征值
  • y 数据集的标签值
  • test_size 测试集的大小，一般为float
  • random_state 随机数种子，不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。
  • return 训练集的特征值，测试集的特征值，训练集的目标值，测试集的目标值
    x_train x_test y_train y_test
    

特征提取

• sklearn.feature_extraction
  

字典特征提取

• sklearn.feature_extraction.DictVectorizer(sparse=True,…)
  • DictVectorizer.fit_transform(X) X:array数组或者sparse矩阵（稀疏矩阵）；返回值sparse矩阵。
  • DictVectorizer.inverse_transform(X) X:array数组或者sparse矩阵；返回值:转换之前数据格式。
  • DictVectorizer.get_feature_names() 返回类别名称
    get_feature_names_out() 将代替这个方法

data = [{'city':'北京','temperature':100},{'city':'上海','temperature':60},{'city':'深圳','temperature':30},]
transfer = feature_extraction.DictVectorizer()
data_new = transfer.fit_transform(data)
print('sparse矩阵 稀疏矩阵：\n',data_new)
print('标签：\n',transfer.get_feature_names_out())
print('array数组:\n',data_new.toarray())
"""
sparse矩阵 稀疏矩阵：
   (0, 1)	1.0
  (0, 3)	100.0
  (1, 0)	1.0
  (1, 3)	60.0
  (2, 2)	1.0
  (2, 3)	30.0
标签：
 ['city=上海' 'city=北京' 'city=深圳' 'temperature']
array数组:
 [[  0.   1.   0. 100.]
 [  1.   0.   0.  60.]
 [  0.   0.   1.  30.]]

"""

文本特征提取

• sklearn.feature_extraction.text.CountVectorizer(stop_words=[])
  • 返回词频矩阵
  • CountVectorizer.fit_transform(X) X:文本或者包含文本字符串的可迭代对象 返回值：返回sparse矩阵
  • CountVectorizer.inverse_transform(X) X:array数组或者sparse矩阵 返回值：转换之前数据格
  • CountVectorizer.get_feature_names() 返回值：单词列表
    get_feature_names_out() 将代替这个方法

data = ['life is short, i like python','life is too long, i dislike python']
transfer = feature_extraction.text.CountVectorizer()
data_new = transfer.fit_transform(data)
data_new.toarray()
"""
array([[0, 1, 1, 1, 0, 1, 1, 0],
       [1, 1, 1, 0, 1, 1, 0, 1]], dtype=int64)
"""
transfer.get_feature_names_out()
"""
array(['dislike', 'is', 'life', 'like', 'long', 'python', 'short', 'too'],
      dtype=object)
"""
data = ' '.join(jieba.lcut("人生苦短，我爱python。"))
transfer = feature_extraction.text.CountVectorizer()
data_new = transfer.fit_transform([data])
print(data_new.toarray())
print(transfer.get_feature_names_out())
"""
[[1 1 1]]
['python' '人生' '苦短']
"""

词权重

• sklearn.feature_extraction.text.TfidfVectorizer(stop_words=None,…)
• 返回词的权重矩阵
  • TfidfVectorizer.fit_transform(X)
    • X:文本或者包含文本字符串的可迭代对象
    • 返回值：返回sparse矩阵
    • TfidfVectorizer.inverse_transform(X)
    • X:array数组或者sparse矩阵
    • 返回值:转换之前数据格式
    • TfidVectorizer.get_feature_names()
    • 返回值：单词列表

data = ' '.join(jieba.lcut("人生苦短，我爱python。"))
transfer = feature_extraction.text.TfidfVectorizer()
data_new = transfer.fit_transform([data,data])
print(data_new.toarray())
"""
[[0.57735027 0.57735027 0.57735027]
 [0.57735027 0.57735027 0.57735027]]
"""

数据归一化

• sklearn.preprocessing.MinMaxScaler(feature_range=(0,1)…)
  • MinMaxScalar.fit_transform(X)
    • X:numpy array格式的数据[n_samples,n_features]
  • 返回值：转换后的形状相同的array
    

数据标准化

• sklearn.preprocessing.StandardScaler()
  • 处理之后，对于每列来说，所有的数据都聚集在均值0附近，标准差为1
  • StandardScaller.fit_transform(X)
    • 通过fit_params调整数据X,y得到一个调整后的X
    • X:numpy array格式的数据[n_samples,n_features]
  • StandardScaller.transform(X):
    • 基于现有的对象规则，标准化新的参数
  • 返回值：转换后的形态相同的array
    

特征选择

sklearn.feature_selection

过滤式

• sklearn.feature_selection.VarianceThreshold(threshold=0.0)
  • 删除所有低方差特征
  • Variance.fit_transform(X)
    • X:numpy arry格式的数据[n_samples,n_features]
    • 返回值:训练集差异低于threshold的特征将被删除。默认值是保留所有非零方差特征，即删除所有样本中具有相同值的特征
      

相关性

• scipy.stats.pearsonr
  • x: (N,) array_like
  • y: (N,) array_like Returns: (Pearson,s correlation coefficient,pvalue)
    

数据降维

• sklearn.decomposition.PCA(n_components=None)
  • 将数据分解为较低纬数空间
  • n_components:
    • 小数：表示保留百分之多少的信息
    • 整数：减少到多少特征
  • PCA.fit_transform(X) X:numpy arry格式的数据
    [n_samples,n_features]
  • 返回值：转换后指定维度的array

data = [[2,8,4,5],[6,3,0,8],[5,4,9,1]]
transfer = decomposition.PCA(n_components=2)
data_new = transfer.fit_transform(data)
print(data_new)
"""
[[ 1.28620952e-15  3.82970843e+00]
 [ 5.74456265e+00 -1.91485422e+00]
 [-5.74456265e+00 -1.91485422e+00]]
"""

数据评估

回归

均方差

metrics.mean_squared_error(y_true,y_pred)

平均绝对误差

metrics.mean_absolute_error(y_true,y_pred)

中值绝对误差

metrics.median_absolute_error(y_true,y_pred)

R2 决定系数

metrics.r2_score(y_test,y_pred)

分类评价指标

准确率

# 其中average参数有五种：(None, ‘micro’, ‘macro’, ‘weighted’, ‘samples’)
y_pred = [0, 2, 1, 3,9,9,8,5,8]
y_true = [0, 1, 2, 3,2,6,3,5,9]
from sklearn import metrics
metrics.accuracy_score(y_true, y_pred) 
# 0.33333333333333331

# 类似海明距离，每个类别求准确后，再求微平均
metrics.accuracy_score(y_true, y_pred, normalize=False)
# 3

# 微平均，精确率
metrics.precision_score(y_true, y_pred, average='micro')  
# 0.33333333333333331

# 宏平均，精确率
metrics.precision_score(y_true, y_pred, average='macro')  
# 0.375

# 指定特定分类标签的精确率
metrics.precision_score(y_true,y_pred,labels=[0,1,2,3],average='macro')
# 0.5

召回率

y_pred = [0, 2, 1, 3,9,9,8,5,8]
y_true = [0, 1, 2, 3,2,6,3,5,9]
metrics.recall_score(y_true, y_pred, average='micro')
#  0.33333333333333331

metrics.recall_score(y_true, y_pred, average='macro')
#  0.3125

F1分数

metrics.f1_score(y_true, y_pred, average='weighted')  
# 0.37037037037037035

混淆矩阵

from sklearn import metrics
metrics.confusion_matrix(y_true, y_pred)
"""
Out[137]: 
array([[1, 0, 0, ..., 0, 0, 0],
       [0, 0, 1, ..., 0, 0, 0],
       [0, 1, 0, ..., 0, 0, 1],
       ..., 
       [0, 0, 0, ..., 0, 0, 1],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 1, 0]])
 """

ROC

# roc计算
import numpy as np
from sklearn.metrics import roc_auc_score
y_true = np.array([0, 0, 1, 1])
y_scores = np.array([0.1, 0.4, 0.35, 0.8])
roc_auc_score(y_true, y_scores)

# roc曲线
y = np.array([1, 1, 2, 2])
scores = np.array([0.1, 0.4, 0.35, 0.8])
fpr, tpr, thresholds = roc_curve(y, scores, pos_label=2)