scikit-learn 常见使用方法
文章目录
特征工程 —— 转换器
数据集
sklearn数据集的使用
from sklearn.datasets import load_iris
# 获取鸢尾花数据集
iris = load_iris()
# 返回值是一个继承自字典的Bench
print("鸢尾花数据集：\n", iris)
# 特征值：花瓣、花萼长度、宽度
print("鸢尾花的特征值:\n", iris["data"])
# 目标值：特征最终属于哪种结果
print("鸢尾花的目标值：\n", iris.target)
print("鸢尾花的特征名：\n", iris.feature_names)
print("鸢尾花的目标名：\n", iris.target_names)
print("鸢尾花的描述：\n", iris.DESCR)
数据集划分
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
# 获取鸢尾花数据集
iris = load_iris()
# 对鸢尾花数据集进行分割
# random_state:随机种子
xl_tezheng, cs_tezheng, xl_mubiao, cs_mubiao = train_test_split(iris.data, iris.target, random_state=22)
print("训练集-特征值：\n",xl_tezheng)
print("测试集-特征值：\n",cs_tezheng)
print("训练集-目标值：\n",xl_mubiao)
print("测试集-目标值：\n",cs_mubiao)
特征抽取
字典特征提取
from sklearn.feature_extraction import DictVectorizer
data = [
{'city': '北京','temperature':100},
{'city': '上海','temperature':60},
{'city': '深圳','temperature':30}
]
# 实例化一个转换器类
transfer = DictVectorizer(sparse=False)
# 调用fit_transform
data = transfer.fit_transform(data)
print("特征结果:\n", data)
print("特征名字：\n", transfer.get_feature_names())
文本特征提取
from sklearn.feature_extraction.text import CountVectorizer
# 只能提取空格分开的词
data = [
"life is short,i like like python",
"life is too long,i dislike python"
]
# 实例化一个转换器类
transfer = CountVectorizer()
# 调用fit_transform
data = transfer.fit_transform(data)
# data.toarray()转换成数组形式
print("文本特征结果：\n", data.toarray())
print("文本特征名字：\n", transfer.get_feature_names())
jieba中文分词
import jieba
data = "我爱北京天安门，天安门上太阳升"
text = list(jieba.cut(data))
print(text)
Tf-idf文本特征提取(TfidfVectorizer)
# TF-IDF的主要思想是：如果某个词或短语在一篇文章中出现的概率高，并且在其他文章中很少出现,则认为此词或者短语具有很好的类别区分能力，适合用来分类。
# 假如一篇文件的总词语数是100个，而词语"非常"出现了5次，那么"非常"一词在该文件中的词频就是5/100=0.05。
from sklearn.feature_extraction.text import TfidfVectorizer
import jieba
...和上面文本特征提取一样...
# 实例化一个转换器类
transfer = TfidfVectorizer()
...和上面文本特征提取一样...
特征预处理
归一化（把数据按照指定范围缩放）
from sklearn.datasets import load_iris
from sklearn.preprocessing import MinMaxScaler
# 获取鸢尾花数据集
iris = load_iris()
# 鸢尾花特征集
x_train = iris["data"]
# 实例化一个转换器类
# feature_range 设置范围
transfer = MinMaxScaler(feature_range=(2, 3))
# 调用fit_transform
data = transfer.fit_transform(x_train)
print("归一化结果：\n", data)
标准化（把数据按比例缩放）
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
# 获取鸢尾花数据集
iris = load_iris()
# 鸢尾花特征集
xl_tezheng = iris["data"]
# 实例化一个转换器类
transfer = StandardScaler()
# 调用fit_transform
# fit()：计算标准差、平均值
# transform()：做计算
# fit_transform()：带入标准差、平均值并
xl_tezheng = transfer.fit_transform(xl_tezheng)
print("标准化的结果:\n", xl_tezheng)
print("每一列特征的平均值：\n", transfer.mean_)
print("每一列特征的方差：\n", transfer.var_)
特征降维
低方差特征过滤
如果多个特征中的大部分值相近，就意味着可以把这些列特征合并成一列
from sklearn.datasets import load_iris
from sklearn.feature_selection import VarianceThreshold
# 获取鸢尾花数据集
iris = load_iris()
# 鸢尾花特征集
xl_tezheng = iris["data"]
# 实例化一个转换器类
# threshold 方差系数
transfer = VarianceThreshold(threshold=2)
# 调用fit_transform
data = transfer.fit_transform(xl_tezheng)
print("删除低方差特征的结果：\n", data)
print("形状：\n", data.shape)
相关系数
import pandas as pd
from scipy.stats import pearsonr
# data文件的列：pe_ratio pb_ratio market_cap return_on_asset_net_profit du_return_on_equity ev earnings_per_share revenue total_expense
data = pd.read_csv("factor_returns.csv")
# 皮尔逊相关系数
r = pearsonr(data["revenue"],data["total_expense"])
# r>0时,正相关。r<0时,负相关。
# |r|=1时,完全相关。当r=0时,不相关。
# 一般|r|按三级划分：(0.0 ~ 0.4)低度相关。(0.4 ~ 0.7)显著相关；(0.7 ~ 1.0)高度相关
print(r[0])
# 特征与特征之间相关度高：1.选取其中一个 2.相加求平均值
matplotlib绘图
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
# 获取鸢尾花数据集
iris = load_iris()
# 鸢尾花特征集
xl_tezheng = iris["data"]
# figsize宽高
plt.figure(figsize=(6, 6), dpi=100)
# 传输两个数组
plt.scatter(xl_tezheng[0],xl_tezheng[1])
plt.show()
主成分分析（降维）
from sklearn.decomposition import PCA
xl_tezheng = [[2,8,4,5], [6,3,0,8], [5,4,9,1]]
# 实例化PCA
# 小数 = 保留多少信息(0.4 = 40%)
# 整数 = 降到指定维数(降至3维)
transfer = PCA(n_components=0.4)
# 调用fit_transform
xl_tezheng = transfer.fit_transform(xl_tezheng)
print(xl_tezheng)
分类算法 —— 估计器
KNN算法
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
# 获取鸢尾花数据集
iris = load_iris()
# 对鸢尾花数据集进行分割
# random_state:随机种子
xl_tezheng, cs_tezheng, xl_mubiao, cs_mubiao = train_test_split(iris.data, iris.target, random_state=22)
# KNN预估器初始化
# K值：理论上：k = 根号(样本数)
knn = KNeighborsClassifier(n_neighbors=3)
# 调用fit，开始训练模型()
knn.fit(xl_tezheng, xl_mubiao)
# 计算测试数据集
test = knn.predict(cs_tezheng)
print("测试集计算结果：", test)
#计算准确率（百分比）
accuracy = knn.score(cs_tezheng,cs_mubiao)
print("准确率为：", accuracy)
模型选择与调优
交叉验证
训练集：训练集+验证集
测试集：测试集
82% 75% 78% 80% 验证集 训练集 训练集 训练集 训练集 验证集 训练集 训练集 训练集 训练集 验证集 训练集 训练集 训练集 训练集 验证集
超参数搜索-网格搜索
- 有很多参数需要手动指定（如k值），这种叫超参数。
- 但是手动过程繁杂，所以要对模型预设几种超参数组合。
- 每组超参数都采用交叉验证评估。
- 最后选出最优参数组合建立模型。
模型调优总体API
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
# 获取鸢尾花数据集
iris = load_iris()
# 对鸢尾花数据集进行分割
# random_state:随机种子
xl_tezheng, cs_tezheng, xl_mubiao, cs_mubiao = train_test_split(iris.data, iris.target, random_state=22)
# KNN预估器初始化
# K值：理论上：k = 根号(样本数)
# K值：后面会使用参数调优方法，去轮流试出最好的参数[1,3,5,10,20,100,200]
knn = KNeighborsClassifier(n_neighbors=3)
knn = GridSearchCV(knn,param_grid={"n_neighbors":[7,8,9,10,11,12,13]},cv=10)
# 调用fit，开始训练模型()
knn.fit(xl_tezheng, xl_mubiao)
# 计算测试数据集
test = knn.predict(cs_tezheng)
print("测试集计算结果：", test)
# 计算准确率（百分比）
accuracy = knn.score(cs_tezheng,cs_mubiao)
print("准确率为：", accuracy)
# 训练验证集的结果
print("最佳结果：", knn.best_params_)
print("最佳结果：", knn.best_score_)
print("最佳估计器：", knn.best_estimator_)
#print("每次交叉验证结果：", knn.cv_results_
FaceBook用户签到地点预测案例（KNN实现）
from datetime import date,time
import pandas as pd
from pandas.core import groupby
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV
#加载文件（nrows=x:前x行）
data = pd.read_csv('facebook2335/FBlocation/train.csv')
#过滤数据
data = data.query("x>1 & x<1.5 & y>1 & y<1.5")
#时间戳转换成时间
times = pd.to_datetime(data["time"],unit="s")
#将object类型的日期列，转换为普通索引
times = pd.DatetimeIndex(times)
#为data添加列
#day几号 | weekday周几 | hour几点
data["day"] = times.day
data["weekday"] = times.weekday
data["hour"] = times.hour
#group by聚合函数，计算每个place_id出现几次
data_count = data.groupby("place_id").count()["row_id"]
#保留大于3次的行
data_count = data_count[data_count > 3]
#A.isin(B):B数组是否在A数组（list类型）出现过,每行返回布尔值
#index：只获取索引，返回list类型
#values：将list类型结果转换为单纯数组
data_final = data["place_id"].isin(data_count.index.values)
#保留布尔值为True的行
data_final = data[data_final]
#保留指定列
tezheng = data_final[["x","y","accuracy","day","weekday","hour"]]
mubiao = data_final["place_id"]
# random_state:随机种子
xl_tezheng, cs_tezheng, xl_mubiao, cs_mubiao = train_test_split(tezheng, mubiao, random_state=22)
# 实例化一个转换器类
transfer = StandardScaler()
# 调用fit_transform
xl_tezheng = transfer.fit_transform(xl_tezheng)
# 为了保证每次计算新的数据都保持一致
# 这里用训练集的标准差来对测试集的标准差进行计算
# 所以只调用transform()
cs_tezheng = transfer.transform(cs_tezheng)
# KNN预估器初始化
# K值：理论上：k = 根号(样本数)
knn = KNeighborsClassifier(n_neighbors=6)
# 调用fit，开始训练模型()
knn.fit(xl_tezheng, xl_mubiao)
# 计算测试数据集
test = knn.predict(cs_tezheng)
print("测试集计算结果：", test == cs_mubiao)
#计算准确率（百分比）
accuracy = knn.score(cs_tezheng,cs_mubiao)
print("准确率为：", accuracy)
朴素贝叶斯（文本分类|单词做特征）
朴素贝叶斯原理
| 样本数 | 职业 | 体型 | 女神是否喜欢 |
|---|---|---|---|
| 1 | 程序员 | 超重 | 不喜欢 |
| 2 | 产品 | 匀称 | 喜欢 |
| 3 | 程序员 | 匀称 | 喜欢 |
| 4 | 程序员 | 超重 | 喜欢 |
| 5 | 美工 | 匀称 | 不喜欢 |
| 6 | 美工 | 超重 | 不喜欢 |
| 7 | 产品 | 匀称 | 喜欢 |
| 条件 | 结论 |
|---|---|
| 1、女神喜欢的概率 | p(喜欢) = 4/7 |
| 2、职业是程序员，并且体型匀称的概率 | p(程序员,匀称) = 1/7 |
| 3、在女神喜欢的条件下，职业是程序员的概率 | p(程序员|喜欢) = 1/2 |
| 4、在女神喜欢的条件下，职业是产品，体重是超重的概率 | p(产品,超重|喜欢) = ? |
联合概率：P(A,B)
条件概率：P(A,B|C)
相互独立：P(A,B) = P(A)*P(B)
朴素贝叶斯：朴素 + 贝叶斯
朴素：假设特征与特征之间相互独立
贝叶斯：贝叶斯公式
贝叶斯公式
P
(
C
∣
W
)
=
P
(
W
∣
C
)
P
(
C
)
P
(
W
)
P(C|W)=\frac{P(W|C)P(C)}{P(W)}
P(C∣W)=P(W)P(W∣C)P(C) C:类别 W:特征值
P
(
产
品
,
超
重
∣
喜
欢
)
=
P
(
产
品
,
超
重
∣
喜
欢
)
P
(
喜
欢
)
P
(
产
品
,
超
重
)
P(产品,超重|喜欢)=\frac{P(产品,超重|喜欢)P(喜欢)}{P(产品,超重)}
P(产品,超重∣喜欢)=P(产品,超重)P(产品,超重∣喜欢)P(喜欢)
=
P
(
产
品
∣
喜
欢
)
∗
P
(
超
重
∣
喜
欢
)
∗
P
(
喜
欢
)
P
(
产
品
)
∗
P
(
超
重
)
=\frac{P(产品|喜欢)*P(超重|喜欢)*P(喜欢)}{P(产品)*P(超重)}
=P(产品)∗P(超重)P(产品∣喜欢)∗P(超重∣喜欢)∗P(喜欢)
=
2
4
∗
1
4
∗
4
7
2
7
∗
3
7
=
7
12
=\frac{\frac{2}{4}*\frac{1}{4}*\frac{4}{7}}{\frac{2}{7}*\frac{3}{7}}=\frac{7}{12}
=72∗7342∗41∗74=127
朴素贝叶斯对新闻分类
from sklearn.naive_bayes import MultinomialNB
from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
# 下载20万新闻数据集
new = fetch_20newsgroups(subset="all")
xl_tezheng, cs_tezheng, xl_mubiao, cs_mubiao = train_test_split(new.data, new.target)
# 实例化一个转换器类
transfer = TfidfVectorizer()
# 调用fit，开始训练模型()
xl_tezheng = transfer.fit_transform(xl_tezheng)
# 贝叶斯预估器初始化
estimator = MultinomialNB()
estimator.fit(xl_tezheng,xl_mubiao)
# 处理将要测试的数据
cs_tezheng = transfer.transform(cs_tezheng)
# 计算测试数据集
test = estimator.predict(cs_tezheng)
print("测试集计算结果：", test)
#计算准确率（百分比）
accuracy = estimator.score(cs_tezheng,cs_mubiao)
print("准确率为：", accuracy)
决策树
信息熵
| ID | 年龄 | 有工作 | 有自己的房子 | 信贷情况 | 类别 |
|---|---|---|---|---|---|
| 1 | 青年 | 否 | 否 | 一般 | 否 |
| 2 | 青年 | 否 | 否 | 好 | 否 |
| 3 | 青年 | 是 | 否 | 好 | 是 |
| 4 | 青年 | 是 | 是 | 一般 | 是 |
| 5 | 青年 | 否 | 否 | 一般 | 否 |
| 6 | 中年 | 否 | 否 | 一般 | 否 |
| 7 | 中年 | 否 | 否 | 好 | 否 |
| 8 | 中年 | 是 | 是 | 好 | 是 |
| 9 | 中年 | 否 | 是 | 非常好 | 是 |
| 10 | 中年 | 否 | 是 | 非常好 | 是 |
| 11 | 老年 | 否 | 是 | 非常好 | 是 |
| 12 | 老年 | 否 | 是 | 好 | 是 |
| 13 | 老年 | 是 | 否 | 好 | 是 |
| 14 | 老年 | 是 | 否 | 非常好 | 是 |
| 15 | 老年 | 否 | 否 | 一般 | 否 |
H
(
D
)
=
−
(
9
15
l
o
g
2
9
15
+
6
15
l
o
g
2
6
15
)
≈
0.971
（
类
别
熵
）
H(D) = -(\frac{9}{15}log_2\frac{9}{15}+\frac{6}{15}log_2\frac{6}{15})\approx0.971（类别熵）
H(D)=−(159log2159+156log2156)≈0.971（类别熵）
H
(
青
年
)
=
−
(
2
5
l
o
g
2
2
5
+
3
5
l
o
g
2
3
5
)
≈
0.971
（
年
龄
：
青
年
熵
）
H(青年) = -(\frac{2}{5}log_2\frac{2}{5}+\frac{3}{5}log_2\frac{3}{5})\approx0.971（年龄：青年熵）
H(青年)=−(52log252+53log253)≈0.971（年龄：青年熵）
H
(
中
年
)
=
−
(
1
5
l
o
g
2
1
5
+
4
5
l
o
g
2
4
5
)
≈
0.722
（
年
龄
：
中
年
熵
）
H(中年) = -(\frac{1}{5}log_2\frac{1}{5}+\frac{4}{5}log_2\frac{4}{5})\approx0.722（年龄：中年熵）
H(中年)=−(51log251+54log254)≈0.722（年龄：中年熵）
H
(
老
年
)
=
−
(
2
5
l
o
g
2
2
5
+
3
5
l
o
g
2
3
5
)
≈
0.971
（
年
龄
：
老
年
熵
）
H(老年) = -(\frac{2}{5}log_2\frac{2}{5}+\frac{3}{5}log_2\frac{3}{5})\approx0.971（年龄：老年熵）
H(老年)=−(52log252+53log253)≈0.971（年龄：老年熵）
H
(
D
∣
年
龄
)
=
5
15
H
(
D
∣
青
年
)
+
5
15
H
(
D
∣
中
年
)
+
5
15
H
(
D
∣
老
年
)
≈
0.888
（
年
龄
熵
）
H(D|年龄)=\frac{5}{15}H(D|青年)+\frac{5}{15}H(D|中年)+\frac{5}{15}H(D|老年)\approx0.888（年龄熵）
H(D∣年龄)=155H(D∣青年)+155H(D∣中年)+155H(D∣老年)≈0.888（年龄熵）
信息增益（决策树划分依据之一）
g
(
D
∣
年
龄
)
=
H
(
D
)
−
H
(
D
∣
年
龄
)
≈
0.083
（
年
龄
的
信
息
增
益
）
g(D|年龄)=H(D)-H(D|年龄)\approx0.083（年龄的信息增益）
g(D∣年龄)=H(D)−H(D∣年龄)≈0.083（年龄的信息增益）
↑由此类推其他条件的信息增益分别为：
g
(
D
,
有
工
作
)
≈
0.324
g(D,有工作)\approx0.324
g(D,有工作)≈0.324
g
(
D
,
有
房
子
)
≈
0.420
g(D,有房子)\approx0.420
g(D,有房子)≈0.420
g
(
D
,
有
信
贷
情
况
)
≈
0.363
g(D,有信贷情况)\approx0.363
g(D,有信贷情况)≈0.363
特征“有房子”的信息增益比较大，所以最终选择“有房子”作为最优特征。
决策树三种实现算法
- ID3:
信息增益:最大的准则- C4.5:
信息增益比:最大的准则- CART:
分类树：基尼系数 最小的准则 在sklearn中可以选择划分的默认原则
优势：划分更加细致（从后面例子的树显示来理解）
代码实现
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier,export_graphviz
# 获取鸢尾花数据集
iris = load_iris()
# 对鸢尾花数据集进行分割
# random_state:随机种子
xl_tezheng, cs_tezheng, xl_mubiao, cs_mubiao = train_test_split(iris.data, iris.target, random_state=22)
# 决策树预估器初始化
# criterion选择决策树算法，entropy=信息增益，默认是'gini'系数
tree = DecisionTreeClassifier(criterion="entropy")
# 调用fit，开始训练模型()
tree = tree.fit(xl_tezheng,xl_mubiao)
# 计算测试数据集
test = tree.predict(cs_tezheng)
print("测试集计算结果：", test)
# 计算准确率（百分比）
accuracy = tree.score(cs_tezheng,cs_mubiao)
print("准确率为：", accuracy)
# 决策树可视化
# feature_names=数组格式的特征名
export_graphviz(tree,out_file="tree.dot",feature_names=iris.feature_names)
泰坦尼克号乘客生存预测
######################获取筛选数据######################
import pandas as pd
# http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt
path = "titanic.txt"
titanic = pd.read_csv(path)
# 筛选特征值、目标值
tezheng = titanic[["pclass","age","sex"]]
mubiao = titanic[["survived"]]
######################缺失值处理&转换成字典######################
# 处理缺失值
# fillna=填充缺失数据
# mean()=该列数据的平均值
tezheng["age"].fillna(tezheng["age"].mean(),inplace=True)
# 转换成字典
tezheng = tezheng.to_dict(orient="records")
# 字典特征抽取
from sklearn.feature_extraction import DictVectorizer
# 实例化一个转换器类
transfer = DictVectorizer(sparse=False)
# 调用fit_transform
tezheng = transfer.fit_transform(tezheng)
# 获取特征名
tezheng_name = transfer.get_feature_names()
######################划分数据集######################
from sklearn.model_selection import train_test_split
# 划分数据集
xl_tezheng, cs_tezheng, xl_mubiao, cs_mubiao = train_test_split(tezheng,mubiao,random_state=22)
######################决策树计算######################
from sklearn.tree import DecisionTreeClassifier,export_graphviz
# 决策树预估器初始化
# criterion选择决策树算法，entropy=信息增益，默认是'gini'系数
tree = DecisionTreeClassifier(criterion="entropy")
# 调用fit，开始训练模型()
tree = tree.fit(xl_tezheng,xl_mubiao)
# 计算测试数据集
test = tree.predict(cs_tezheng)
print("测试集计算结果：", test)
# 计算准确率（百分比）
accuracy = tree.score(cs_tezheng,cs_mubiao)
print("准确率为：", accuracy)
# 决策树可视化
# feature_names=数组格式的特征名
export_graphviz(tree,out_file="titanic.dot",feature_names=tezheng_name)
集成学习方法—随机森林
集成学习方法
生成多个分类器/模型，分别对单一问题做出学习和作出预测。
这些预测最后结合成组合预测，因此优于任何一个单分类的做出预测。
随机森林
随机：训练集随机、特征随机。
森林：包含多个决策树的分类器。
例：如果你训练了5个树, 其中有4个树的结果是True，1个数的结果是False，那么最终投票结果就是True。