ML-Day02: k-近邻、朴素贝叶斯、决策树、随机森林、交叉验证、网格搜索
1.数据分类
离散型数据：可以列举出
连续型数据：在区间内可任意划分，不可一一列举
2.机器学习算法分类
监督学习（预测）：有特征值和目标值，有标准答案
分类[离散]：k近邻、贝叶斯、决策树与随机森林、逻辑回归、神经网络
回归[连续]：线性回归、岭回归
非监督学习： 只有特征值，没有保准答案
聚类：k-means
3.机器学习开发流程
- 原始数据： 公司本身有数据/ 合作数据/ 购买数据/
- 明确公司要做什么： 建立模型，是分类还是回归？
- 数据基本的处理： pd 去处理数据（缺失值，合并表等等）
- 特征工程：特征抽取/ 归一化/ 标准化/ 特征选择/ 主成分分析
- 找对应的算法去生产模型： 模型 = 算法 + 数据
- 模型的评估： 判定效果
- 评估优秀，上线使用，进行数据预测
- 评估失败，特征工程是否有问题、调参数、换算法等
4.划分数据集
- 训练集 75% - 用于训练，构建模型
- 测试集 25% - 用于检测模型，评估模型是否有效
- sklearn.model_selection.train_test_split
- li = load_iris()
# 注意返回值的顺序
# 训练特征值x_train
# 测试特征值x_test
# 训练目标值y_train
# 测试目标值y_test
x_train, x_test, y_train, y_test = \
train_test_split(li.data, li.target, test_size=0.25)
5.获取sklearn.datasets 内置数据集分类
- datasets.load_xxx() 加载小规模数据集，数据在内存中
- datasets.fetch_xxx(datahome=None) 获取大数据集，数据会先下载到本地
- 两种方法的返回值都是 datasets.base.Bunch - 一种字典格式
1.datasets.base.Bunch.data 特征数据数组
2.datasets.base.Bunch.target 标签数组
3.datasets.base.Bunch.DESCR 数据描述
- 分类数据集[目标值是离散的]
1.小数据集
sklearn.datasets.load_iris()
sklearn.datasets.load_digits()
2.大数据集
sklearn.datasets.fetch_20newsgroups(subset='all')
- 回归数据集[目标值是连续的]
1.小数据集
sklearn.datasets.load_boston()
sklearn.datasets.load_diabetes()
- 聚类数据集
6.转换器 Transformer
- 是一类特征工程的API
- fit: 对输入数据进行一系列的计算，形成一种模型，一种标准
- transform： 使用fit的模型，去转换传入的数据
- fit_transform = fir + transform
7.估计器 Estimator
- 是一类各种计算算法的API
- 用于分类的估计器
1.sklearn.neighbors k-近邻
2.sklearn.naive_bayes 贝叶斯
3.sklearn.linear_model.LogisticRegression 逻辑回归
4.sklearn.tree 决策树与随机森林
- 用于回归的估计器
1.sklearn.linear_model.LinearRegression 线性回归
2.sklearn.linear_model.Ridge 岭回归
- 估计器流程
1.输入训练集到指定的估计器，包括训练集的特征值样本x_train 以及训练集的目标值y_train
estimator.fit(x_train,y_train)
2.指定的估计器, 对测试特征值样本 进行预测,得到预测目标值
y_test = estimator.predict(x_test)
3.评估预测的准确率
estimator.score(y_train,y_test)
8.k-近邻算法
- 通过你的邻居来判断你的类型，找到距离你最近的邻居
- 相似的样本，特征一般都是相近的。距离也是近的
- 定义：如果一个样本空间中的k个最相似（最邻近）的样本中，大多数属于某一个类别。则该样本也属于这个类别
- 如何求距离？欧氏距离
[(a1 - b1)^2 + (a2 - b2)^2 + (a3 - b3)^2]^0.5
- 使用k近邻，需要对数据进行标准化[防止不同特征值的数据单位不一致]
- sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm='auto')
n_neighbors:查询使用的邻居数 默认5
algorithm：计算最近邻居的算法。默认'auto', 可选 ball_tree, kd_tree, brute
- 案例：Facebook V: Predicting Check Ins
- 分析特征值 和 目标值
- 特征值： x,y 坐标，定位准确性，以及时间[考虑所有可能影响到入住位置的因素]
- 目标值： 入住位置的id[可以列举的，非连续，考虑使用分类算法]
- 分析特征值，并且根据评估的结果判断，是否需要增加特征值。
比如，时间戳不好用 - 是否可以考虑抽取年月日周时，当做新的特征
- 入住类别作为目标值，类别太多了。考虑，入住位置人少于一定阈值的，砍掉
- 特征工程
1.必须进行标准化
- 思考
1.k值取多大? 有什么影响
k值很小，容易受异常点影响
k值很大，容易受样本的目标值类别影响
2.性能问题？
3.优点
简单，易于理解，易于实现，无需估计参数，无需迭代训练，一次训练即可。样本不变，结果不变
4.缺点
懒惰计算，对测试样本分类时的计算量大，内存开销大
必须指定k值，k值选择不当，分类精度不能保证
5.场景
小数据场景，几千~几万样本，具体场景具体业务到时候去测试，看看score得分情况
9.朴素贝叶斯
- 条件概率：事件A在事件B已经发生的条件下发生的概率
P(a|b) = P(ab) / P(b)
P(a1,a2|b) = P(a1|b) * P(a2|b), 且a1,a2相互独立
- 联合概率：多个条件同时成立的概率
P(ab) = P(a) * P(b)
- 贝叶斯公式 ：邮件过滤
P(c|w) = P(w|c) * P(c) / P(w)
P(c|f1,f2,f3...) = P(f1,f2,f3...| c) * P(c) / P(f1,f2,f3...)
w: 给定文档的特征词们
c: 文档的类别，目标值类别
fn: 具体的特征值
P(c): 每个文档类别的概率（该类别文档数 / 总文档数）
P(w|c): 指定类别文档的条件下，被预测的特征词 出现的概率
P(f1|c) = n/N
n:特征词 在所有c类型文档中出现的总次数
N:所有c类型文档，所有词语的总和
P(f1)：预测的所有文档中，该词f1出现的概率
- 前提： 特征独立
- 拉普拉斯平滑 - 去除零概率
如果词频列表里面有很多词语出现的次数为0，很可能计算结果都为0
所以需要拉普拉斯平滑
P(f1|c) = (n + &) / (N + &m)
n:特征词 在所有c类型文档中出现的总次数
N:所有c类型文档，所有词语的总和
&:指定系数，一般为1， m 为特征词的个数，本次训练一共有几个特征词
- sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
alpha : 拉普拉斯平滑系数
- 特征工程
1.必须进行文本特征抽取
- 案例：新闻文章分类
1.加载数据
2.数据分割
3.文本特征抽取，生成特征词组.中文的话要分词
4.应用算法
- 特点
1.朴素贝叶斯不需要调节参数
2.主要应用文本分类
- 优点
1.稳定的分类效率
2.对缺失数据不敏感，算法也比较简单，常用于文本分类
3.分类准确度高，速度快
- 缺点
- 特征之间要相互独立： 由于使用了样本特征值独立性的假设，所以如果特征值之间有关联时，分类效果不好
- 训练数据准确性影响很大： 如果训练集，特征词误差很大，一大堆没用的特征词，结果肯定不好
10.分类模型好坏的评估
- 准确率 estimator.score(): ，最常见。预测结果正确的百分比
- 混淆矩阵： 真正例， 伪正例， 真反例， 伪反例
- 召回率a：真实结果中，预测为真正例的比例（查的全，对正样本的区分能力）
- 精确率b：预测结果中，预测为真正例的比例（查的准，一般不考虑）
- F1-Score: F1 = 2 * a . b / (a + b) -- a: 召回率 b:精确率
- sklearn.metrics.classification_report(y_true,y_pred,target_names)
1.y_true: 真实目标 的值
2.y_pred: 估计器预测的目标 的值
3.target_names: 目标类别名称
4.rerurn: 每个类别精确率与召回率
11.决策树
- 决策树思想就是条件分支结构，if-then结构，不是他，就是她
- 信息熵H： H = -(p1 * logp1 + p2 * logp2 + ... + pn * logpn) 单位为比特bit
- 信息增益：当得知某一个条件之后，减少的信息熵的大小
1. 求已知特征值类别A [A1,A2,A3]之后， 对目标值类别D[D1,D2] 的信息增益G(D,A)
2. 信息增益表示：在得知特征A 的信息之后，使特征集D 目标值的不确定性减少的程度
3. G(D|A) = H(D) - H(D|A)
4. H(D): 初始信息熵 - 样本集为所有样本的前提下，各个目标类别的概率p 与 log p 的乘积，再求和
5. H(D) = -[P(D1) * log(P(D1)) + P(D2) * log(P(D2))] -- 样本为所有样本
6. H(D|A) = P(A1) * H(A1) + P(A2) * H(A2) + P(A3) * H(A3)
7. H(A1)：具体类别信息熵 - 样本集范围限定为A类型的前提下， 各个目标类别的概率p 与 log p 的乘积，再求和
8. H(A1) = -[P(D1) * log(P(D1)) + P(D2) * log(P(D2))] -- 样本为限定A类型的样本
- 通过计算出的信息增益的从大到小排列，就是决策树分类依据的从强到弱排列
- 决策树确定分类的准则
1. ID3 信息增益最大原则
2. C4.5 信息增益比最大原则
3. CART 回归树：平方误差最小
分类树：基尼系数 最小的准则，在sklearn 中划分使用的的默认原则
- sklearn.tree.DecisionTreeClassifier(criterion='gini',max_depth=None,random_state=None)
1. 决策树分类器
2. criterion：分类原则 - 默认基尼系数'gini' 也可以信息增益'entropy'
3. max_depth: 决策树的深度
4. random_state: 随机数种子
5. 返回值：决策树的路径 decision_path
- 案例： 分析泰坦尼克生存或者死亡情况
1. 数据地址：http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt
2. 特征值： 票的类别，乘坐班，年龄，登录地，home.dest, 房间，票，船和性别
3. 目标值：是否存活
4. 说明： age特征存在缺失
- 决策树结构的本地保存
1. sklearn.tree.export_graphviz(estimator,out_file='tree',feature_names=[","])
2. 导出格式为DOT格式
3. 可以通过 graphviz 工具转换成 pdf png
- linux: sudo apt-get install graphviz
- Mac: brew install graphviz
4. 运行命令
- dot -Tpng tree.dot -o tree.png
- 决策树的优缺点以及改进
1.优点
- 理解简单，树木结构可视化
- 准确率高
- 适用于各种数据
- 需要很少的数据准备，比如不需要归一化（其他技术一般都要归一化）
2.缺点
- 过拟合：总是希望将所有的点都考虑进去，形成决策分支，而如果该点是异常点，容易造成结果误差
- 树的建立太深
3.改进
- 剪枝cart算法
- 随机森林
12.集成学习方法 - 随机森林
- 集成学习
1. 通过建立几个模型的组合解决一个预测问题
2. 原理是生成多个分类器/模型。各自独立的学习和作出预测。最后整合成一个预测结果
3. 因此 优于任何一个单独的预测
- 随机森林
1. 多个决策树算法集成的一个预测算法，就是随机森林
2. 随机森林就是一个包含了多个决策树的分类器，并且其输出的类别是由个别树输出的类别的众数而定
3. 即： 如果训练了5颗树，其中4颗树都是True, 一颗是False,那么结果就是True
- 随机森林建立多个决策树的过程
例： N个样本（n行数据），M个特征，1个目标
1. 单个树的建立过程（随机有放回抽样 bootstrap）
- 随机在N个样本中，抽取一个样本（1行数据）的复制，重复N次，得到一个新的N个样本集N1（有重复）
- 随机N1样本集的M个特征当中，选出m 个特征（m <= M）
2. 重复1, 建立多个决策树
- 随机森林分类器
1. sklearn.ensemble.RandomForestClassifier(n_estimators=10,criterion='gini',max_depth=None,bootstrap=True,random_state=None)
2. n_estimators: integer 森林里树木的数量： 一般为120/200/300/500/800/1200
3. criteria: string 分割特征[特征分类]的测量方法、依据 default='gini'
4. max_depth: integer 或None 树的最大深度，一般为 5/8/15/25/30
5. max_features[m] = 'auto' 每个决策树的最大特征的数量
- auto m = M ^ 0.5
- sqrt m = M ^ 0.5
- log2 m = log2(M)
- None m = M
6.bootstrap: boolean default = True 是否在构建树的时候使用放回抽样
- 随机森林的优点
1. 具有极好的准确率
2. 能够有效的运行在大数据集上
3. 能够处理具有高维特征的样本，而且不需要降维
4. 能够评估各个特征在分类问题上的重要性
13. 网格搜索 - 模型调参利器 gridSearchCV
- GridSearchCV用于系统地遍历多种参数组合，通过交叉验证确定最佳效果参数
- class sklearn.model_selection.GridSearchCV(estimator, param_grid, scoring=None, fit_params=None, n_jobs=1, iid=True, refit=True, cv=None, verbose=0, pre_dispatch=‘2*n_jobs’, error_score=’raise’, return_train_score=’warn’)
1.estimator
- 选择使用的分类器，并且传入除需要确定最佳的参数之外的其他参数。
- 每一个分类器都需要一个scoring参数，或者score方法：
- estimator=RandomForestClassifier(min_samples_split=100,min_samples_leaf=20,max_depth=8,max_features='sqrt',random_state=10),
2. param_grid
- 需要最优化的参数的取值，值为字典或者列表，
- 例如：param_grid =param_test1，param_test1 = {'n_estimators':range(10,71,10)}。
3.scoring=None
- 模型评价标准，默认None,这时需要使用score函数；或者如scoring='roc_auc'，根据所选模型不同，评价准则不同。
- 字符串（函数名），或是可调用对象，需要其函数签名形如：scorer(estimator, X, y)；
- 如果是None，则使用estimator的误差估计函数。具体值的选取看本篇第三节内容。
4. fit_params=None
-
5.n_jobs=1
- n_jobs: 并行数，int：个数,-1：跟CPU核数一致, 1:默认值
6.iid=True
- iid:默认True,为True时，默认为各个样本fold概率分布一致，误差估计为所有样本之和，而非各个fold的平均。
7.refit=True
- 默认为True,程序将会以交叉验证训练集得到的最佳参数，重新对所有可用的训练集与开发集进行，作为最终用于性能评估的最佳模型参数。
- 即在搜索参数结束后，用最佳参数结果再次fit一遍全部数据集。
8.cv=None 进行几折交叉验证
- 交叉验证参数，默认None，使用三折交叉验证。指定fold数量，默认为3，也可以是yield训练/测试数据的生成器。
9.verbose=0, scoring=None
- verbose：日志冗长度，int：冗长度，0：不输出训练过程，1：偶尔输出，>1：对每个子模型都输出。
10.pre_dispatch=‘2*n_jobs’
- 指定总共分发的并行任务数。
- 当n_jobs大于1时，数据将在每个运行点进行复制，这可能导致OOM，
- 而设置pre_dispatch参数，则可以预先划分总共的job数量，使数据最多被复制pre_dispatch次
11.error_score=’raise’
-
12.return_train_score=’warn’
- 如果“False”，cv_results_属性将不包括训练分数
- score: 准确率
- 结果分析
1. best_score: 在交叉验证中验证的最好结果
2. best_estimator_ : 最好的参数模型
3. cv_results: 每次交叉验证后的验证集准确率结果和训练集的准确率结果
14. 交叉验证
- K折交叉验证 KFold
1. 将数据集平均分割成K个等份
2. 使用1份数据作为测试数据，其余作为训练数据
3. 计算测试准确率
4. 使用不同的测试集，重复2、3步骤
5. 对测试准确率做平均，作为对未知数据预测准确率的估计
from sklearn.model_selection import KFold
import numpy as np
X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
y = np.array([1, 2, 3, 4])
kf = KFold(n_splits=2)
for train_index, test_index in kf.split(X):
print('train_index', train_index, 'test_index', test_index)
train_X, train_y = X[train_index], y[train_index]
test_X, test_y = X[test_index], y[test_index]
- cross_value_score: 使用交叉验证来计算模型的评分情况
- 上面讲的是如何使用交叉验证进行数据集的划分。当我们用交叉验证的方法并且结合一些性能度量方法来评估模型好坏的时候，
- 我们可以直接使用sklearn当中提供的交叉验证评估方法，这些方法如下
- clf是我们使用的算法，
- cv是我们使用的交叉验证的生成器或者迭代器，它决定了交叉验证的数据是如何划分的，当cv的取值为整数的时候，使用(Stratified)KFold方法。
- 还有一个参数是 scoring，决定了其中的分数计算方法
from sklearn import datasets
from sklearn import svm
from sklearn.model_selection import cross_val_score
iris = datasets.load_iris()
clf = svm.SVC(kernel='linear', C=1)
# cv=5 表示KFold的n_split = 5 / 5折交叉验证
scores = cross_val_score(clf, iris.data, iris.target, cv=5)
print(scores)
- cross_val_predict:
- cross_val_predict 和 cross_val_score的使用方法是一样的，
- 但是它返回的是一个使用交叉验证以后的输出值，而不是评分标准。
- 它的运行过程是这样的，使用交叉验证的方法来计算出每次划分为测试集部分数据的值，
- 直到所有的数据都有了预测值。
- 假如数据划分为[1,2,3,4,5]份，它先用[1,2,3,4]训练模型，计算出来第5份的目标值，然后用[1,2,3,5]计算出第4份的目标值，直到都结束为止。
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_predict
from sklearn import metrics
iris = load_iris()
knn = KNeighborsClassifier(n_neighbors=5)
predict = cross_val_predict(knn, iris.data, iris.target, cv=5)
print(predict)
print(metrics.accuracy_score(predict, iris.target))
15.源码
import jieba
import pandas as pd
from sklearn.datasets import load_iris, fetch_20newsgroups, load_boston
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_extraction import DictVectorizer
from sklearn.metrics import classification_report
from sklearn.naive_bayes import MultinomialNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split, cross_val_score, cross_val_predict
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris, fetch_20newsgroups
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn.model_selection import GridSearchCV
from sklearn import metrics
# 加载分类数据集
def loadDataSets():
li = load_iris()
print("获取特征值")
print(li.data)
print("获取目标值")
print(li.target)
print(li.DESCR)
return li
# 分割数据集
def splitDataSets():
li = load_iris()
# 注意返回值的顺序
# 训练特征值x_train
# 测试特征值x_test
# 训练目标值y_train
# 测试目标值y_test
x_train, x_test, y_train, y_test = \
train_test_split(li.data, li.target, test_size=0.25)
print("训练集的特征值\r\n", x_train)
print("测试集的特征值\r\n", x_test)
print("训练集的目标值\r\n", y_train)
print("测试集的目标值\r\n", y_test)
# 获取分类新闻数据集
def getNewsDataSet():
news = fetch_20newsgroups(subset='all')
print("获取特征值")
print(news.data)
print("获取目标值")
print(news.target)
# 获取回归小数据集
def getRegressionDataSet():
lb = load_boston()
print("获取特征值")
print(lb.data)
print("获取目标值")
print(lb.target)
def knncls():
"""
k近邻分类计算最近居住位置
:return:
"""
# 读取数据
dt = pd.read_csv("./data/train.csv")
# print(dt.head(10))
# 处理数据
# 1.查询数据
dt = dt.query("x > 1.0 & x < 1.25 & y > 2.5 & y < 2.75")
# 2.处理时间
time_value = pd.to_datetime(dt['time'], unit='s')
# 3.构造特征值,把日期格式转化成day,hour
time_value = pd.DatetimeIndex(time_value)
dt.day = time_value.day
dt['weekday'] = time_value.weekday
dt['hour'] = time_value.hour
dt = dt.drop(['time'], axis=1)
# 删除少于指定阈值的place_id - 分组求和
place_count = dt.groupby("place_id").count()
tf = place_count[place_count.row_id > 3].reset_index()
dt = dt[dt['place_id'].isin(tf['place_id'])]
# 取出数据当中的特征值和目标值
x = dt.drop(['place_id', 'row_id'], axis=1) # 特征值
y = dt['place_id'] # 目标值
# 数据分割 - 切分训练数据x 和 测试数据y
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
# 特征工程 - 标准化
sd = StandardScaler()
x_train = sd.fit_transform(x_train)
x_test = sd.transform(x_test)
# print(x_train)
# fit predict score
knn = KNeighborsClassifier(n_neighbors=5, algorithm='kd_tree')
knn.fit(x_train, y_train)
y_pre = knn.predict(x_test)
print("预测目标签到的位置：", y_pre)
print("预测的准确率：", knn.score(x_test, y_test))
def knncls2():
# 获取数据
li = load_iris()
# 获取特征值和目标值
x = li.data
y = li.target
# 特征工程
# 首先判断哪些特征值有用，哪些没用
# 然后看看是否增加或者删除特征值。或者抽取额外的特征值
# 是否需要过滤
# 是否需要处理空值
# 是否需要降维
# 是否需要标准化和归一化
sd = StandardScaler()
x = sd.fit_transform(x)
# 进行数据切分
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
# 开始算法
# knn = MultinomialNB()
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(x_train, y_train)
pre = knn.predict(x_test)
sc = knn.score(x_test, y_test)
print("预测目标签到的位置：", pre)
print("预测的准确率：", sc)
def bayes():
# 加载数据
dt = fetch_20newsgroups(subset='all')
x = dt.data
y = dt.target
# 中文的话注意要切词。此处为英文，故不用切词
# con = jieba.cut(x)
# x = " ".join(con)
# 分割数据
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
# 特征抽取
td = TfidfVectorizer()
x_train = td.fit_transform(x_train)
x_test = td.transform(x_test)
print(td.get_feature_names())
print(x_train.toarray())
# 应用算法
# by = KNeighborsClassifier(n_neighbors=5, algorithm='auto')
by = MultinomialNB()
by.fit(x_train, y_train)
pre = by.predict(x_test)
sc = by.score(x_test, y_test)
print("预测目标签到的位置：", pre)
print("预测的准确率：", sc)
pp = classification_report(y_test, pre, target_names=dt.target_names)
print("计算精确率和召回率：", pp)
def decisionTree():
# 读取数据
dt = pd.read_csv("http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt")
# 得到目标值和特征值
# 分析： 取船票号pclass，性别sex 和 年龄age 作为特征值， 是否存活survived 作为目标值
x = dt[['pclass', 'sex', 'age']]
y = dt[['survived']]
# 缺失值填充
x = x.fillna(x['age'].mean(), inplace=False)
# 分割数据
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
# 处理数据 特征工程 - 字典特征抽取
train_dit = x_train.to_dict(orient='records')
test_dit = x_test.to_dict(orient='records')
dict = DictVectorizer()
x_train = dict.fit_transform(train_dit)
x_test = dict.transform(test_dit)
# 应用决策树算法
dtc = DecisionTreeClassifier()
dtc.fit(x_train, y_train)
sc = dtc.score(x_test, y_test)
# print("得分：", sc)
# 决策树的本地保存
export_graphviz(dtc, out_file='./data/tree.dot', feature_names=dict.get_feature_names())
def ramdomTree():
# 读取数据
dt = pd.read_csv("http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt")
# 得到目标值和特征值
# 分析： 取船票号pclass，性别sex 和 年龄age 作为特征值， 是否存活survived 作为目标值
x = dt[['pclass', 'sex', 'age']]
y = dt[['survived']]
# 缺失值填充
x = x.fillna(x['age'].mean(), inplace=False)
# 分割数据
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
# 处理数据 特征工程 - 字典特征抽取
train_dit = x_train.to_dict(orient='records')
test_dit = x_test.to_dict(orient='records')
dit = DictVectorizer()
x_train = dit.fit_transform(train_dit)
x_test = dit.transform(test_dit)
# 使用随机森林算法进行预测 - 超参数调优
rf = RandomForestClassifier()
# 网格搜索与交叉验证
param_dit = {'n_estimators': [120, 200, 300, 500, 800, 1200],
'max_depth': [5, 8, 15, 25, 30]}
gc = GridSearchCV(rf, param_grid=param_dit, cv=2)
gc.fit(x_train, y_train)
sc = gc.score(x_test, y_test)
print("预测结果准确率：", sc)
print("查看选择的参数模型：", gc.best_params_)
def kFold():
iris = load_iris()
knn = KNeighborsClassifier(n_neighbors=5)
scores = cross_val_score(knn, iris.data, iris.target, cv=5)
print(scores)
def kFold_1():
iris = load_iris()
knn = KNeighborsClassifier(n_neighbors=5)
predict = cross_val_predict(knn, iris.data, iris.target, cv=5)
print(predict)
print(metrics.accuracy_score(predict, iris.target))
if __name__ == '__main__':
kFold_1()
来源：CSDN
作者：葛红富
链接：https://blog.csdn.net/xcvbxv01/article/details/104117651