17. 机器学习 - 随机森林

这篇具有很好参考价值的文章主要介绍了17. 机器学习 - 随机森林。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

17. 机器学习 - 随机森林,茶桁的AI秘籍 - 核心基础,机器学习,随机森林,人工智能

Hi,你好。我是茶桁。

我们之前那一节课讲了决策树,说了决策树的优点,也说了其缺点。

决策树实现起来比较简单,解释解释性也比较强。但是它唯一的问题就是不能拟合比较复杂的关系。

后来人们为了解决这个问题,让其能够拟合更加复杂的情况,提出来了一种模型,这种模型就叫做随机森林。

随机森林

随机森林之所以叫随机森林,是因为它是由多棵树组成。它结合了决策树和随机性的概念,用于解决分类和回归问题,随机森林由多个决策树组成,每棵树都是随机构建的。

随机森林其核心组成部分是决策树,为了提高模型的性能和泛化能力,所以引入了两种主要形式的随机性。

第一种就是随机选择样本,对于每棵决策树的构建,随机森林从训练数据中随机抽取一部分样本(有放回地抽样), 这称为自助采样(Bootstrap Sampling)。这就使得每棵树都在不同的样本子集上进行训练,增加了模型的多样性。

17. 机器学习 - 随机森林,茶桁的AI秘籍 - 核心基础,机器学习,随机森林,人工智能

第二种是随机选择特征,在每个节点上,随机森林只考虑特征的一个子集来进行分割决策,而不是考虑所有特征。这确保了每棵树的分裂过程是不同的,增加了多样性。

对于分类问题,随机森林中的每棵决策树都会对输入数据进行分类,那对于回归问题,就会变成是每棵决策树都会对输入数据进行预测了。最后的预测结果是通过对所有树的投票或平均值来获得的。这种集成方法可以减小过拟合奉先,提高模型的稳定性和泛化能力。

17. 机器学习 - 随机森林,茶桁的AI秘籍 - 核心基础,机器学习,随机森林,人工智能

  1. 使用随机森林来预测。
  2. 在预测之前呢,我们使用 Out-Of-Bagging 样本来评估我们的模型。这个bagging就是袋子,就是我们从袋子里随机取东西去衡量。
  3. 使用评估结果,我们可以选择合适的变量数。

随机森林的原理其实很简单,是一个非常简单但是非常好用的一个方法。基本上,除了深度学习之外,也是企业用的最多的方法之一。咱们在这里就来演示一下随机森林的作用以及效果:

from sklearn.datasets import load_iris
iris = load_iris()

x = iris.data
y = iris.target
print(x, y)

17. 机器学习 - 随机森林,茶桁的AI秘籍 - 核心基础,机器学习,随机森林,人工智能

这个是我们用sklearn里面鸢尾花分类的数据做个简单例子,快速的展现一下它的效果。我们将数据拿到以后,x是鸢尾花的四个维度,四个维度对应了它的一个类别。

from sklearn.tree import DecisionTreeClassifier

tree_clf = DecisionTreeClassifier()
tree_clf.fit(x, y)

tree_clf.feature_importances_

---
array([0.02666667, 0.        , 0.05072262, 0.92261071])

我们fit完之后就可以看到,这四个feature中,最终要的是第四个feature。然后是第三个,第二个根本就没用。

from sklearn.model_selection import train_test_split

train_x, test_x,train_y, test_y = train_test_split(x, y, test_size=0.3, random_state=0)

tree_clf = DecisionTreeClassifier()
tree_clf.fit(train_x, train_y)

print(tree_clf.score(train_x, train_y))
print(tree_clf.score(test_x, test_y))

---
1.0
0.9777777777777777

看结果我们其实可以看到,这个拟合度有点太高了。我们换个数据再来看, 还是之前的课程中我们用到的Boston房价的数据,不过因为这个是一个回归问题,所以我们需要用回归预测的方法:

from sklearn.tree import DecisionTreeRegressor
from sklearn.datasets import fetch_openml
dataset = fetch_openml(name='boston', version=1, as_frame=True, return_X_y=False, parser='pandas')

data = dataset['data']
target = dataset['target']

x_train, x_test, y_train, y_test = train_test_split(data, target, test_size=0.2)

tree_reg = DecisionTreeRegressor()
tree_reg.fit(x_train, y_train)

print('whole dataset train acc: {}'.format(tree_reg.score(x_train, y_train)))
print('whole dataset test acc: {}'.format(tree_reg.score(x_test, y_test)))

---
whole dataset train acc: 1.0
whole dataset test acc: 0.6606392933985246

现在我们来看,它的train上的score准确度是1.0,在test上是0.81,这个是全数据量测试的情况。

然后我们来定义一个函数:

def random_forest(x_train, y_train, x_test, y_test, drop_n=4):
    
    features_random = np.random.choice(list(x_train.columns), size=len(x_train.columns)-drop_n)

    x_sample = x_train[features_random]
    y_sample = y_train

    reg = DecisionTreeRegressor()
    reg.fit(x_sample, y_sample)

    score_train = reg.score(x_sample, y_sample)
    score_test = reg.score(x_test[features_random], y_test)

    print('sub sample :: train score: {}, test score: {}'.format(score_train, score_test))

    y_predicated = reg.predict(x_test[features_random])

    return y_predicated

咱们随机的从data里面取一些数据,之后我们来看一下单个树的结果:

with_feature_names = pd.DataFrame(data)
with_feature_names.columns = dataset['feature_names']

x_train, x_test, y_train, y_test = train_test_split(with_feature_names, target, test_size=0.3, random_state=0)

random_forest(x_train, y_train, x_test, y_test, 4)

---
sub sample :: train score: 1.0, test score: 0.5171643497313849

单个的结果显然是要比整个的数据量要差。那么咱们现在看一下最终的结果,把它变成一个森林:

tree_num = 4
predicates = []
for _ in range(tree_num):
    predicated, score = random_forest(x_train, y_train, x_test, y_test)
    predicates.append((predicated))

print('the mean result is: {}'.format(np.mean(predicates), axis=0))
print('the score of forest is: {}'.format(r2_score(y_test, np.mean(predicates, axis=0))))

---
the mean result is: 21.614144736842107
the score of forest is: 0.7194989474162439

从一开始到现在完整的打印结果为:

whole dataset train acc: 1.0
whole dataset test acc: 0.6606392933985246

ssub sample :: train score: 1.0, test score: 0.5885292814825753
sub sample :: train score: 1.0, test score: 0.559086368163823
sub sample :: train score: 1.0, test score: 0.6119989116140754
sub sample :: train score: 1.0, test score: 0.21831688326567122

the mean result is: 21.614144736842107
the score of forest is: 0.7194989474162439

这是个很典型的例子,使用全量的数据集,它的结果最终的在test集上是0.66,然后基本上每个的结都比它要差一些。但当我们用了森林的值做了平均之后,这个值就变得更好了。

当然其实这个值并不是每次都是如此,在我们进行计算的时候,因为数据什么的都是随机的,偶尔也会出现取均值之后变的更差的情况。不过大部分时候,都会更好一些。

我们现在再将结果稍微改一改:

def random_forest(x_train, y_train, x_test, y_test, drop_n=4):
    ...

    return y_predicated, score_test

tree_num = 4
predicates = []
for _ in range(tree_num):
    predicated, score = random_forest(x_train, y_train, x_test, y_test)
    predicates.append((predicated, score))

predicates_value = [v for v, s in predicates]
forest_scores = [s for v, s in predicates]

print('the score of forest is: {}'.format(r2_score(y_test, np.mean(predicates_value, axis=0))))

weights = np.array(forest_scores) / np.sum(forest_scores)
score_weights = np.zeros_like(np.mean(predicates_value, axis=0))

for i, v in enumerate(predicates_value):
    score_weights += v * weights[i]

print('the score of weighted forest is: {}'.format(r2_score(y_test, score_weights)))

---
the score of forest is: 0.7049603534192553
the score of weighted forest is: 0.7204901503020483

后面这段代码呢,其实就是人们发现用了随机森林之后,效果明显要好了,那一些人就想如果在知道每一次的test_score之后,能不能给test_score比较高的值加一个比较大的权重。

也就是说,当我知道test_score比较好,那在最后做决策的时候给它加的权重大一些。

最后我们打印了常规状态下森林的结果和加权之后的结果。加权之后的结果又变得好了一些。

Adaboost

然后人们沿着这个思路,就做了一件事情,就是Adaboost(Adaptive Boosting):

17. 机器学习 - 随机森林,茶桁的AI秘籍 - 核心基础,机器学习,随机森林,人工智能

Adaboost就是在随机森林的权重思路上做了一个优化,它的示意图也是有多个weak classifier, 然后最后有一个Weighted Voter, 这是一个权重的投票,这个就和我们上面加权的那部分代码非常的类似。只不过它在这里做了个细化:

17. 机器学习 - 随机森林,茶桁的AI秘籍 - 核心基础,机器学习,随机森林,人工智能

我们来注意看最后一个公式:

H ( x ) = s i g n ( ∑ t = 1 T α t h t ( x ) ) H(x) = sign(\sum_{t=1}^T\alpha_th_t(x)) H(x)=sign(t=1Tαtht(x))

公式里的 α t \alpha_t αt就是它的权重,最终的H(x)就是很多 α t ⋅ h t ( x ) \alpha_t \cdot h_t(x) αtht(x)加在一起的结果。这里的这个 α t \alpha_t αt就是每一次小的数的权重:v * weights[i]。这个权重就不是像咱们刚才代码里那样根据score的大小简单的做个加权。

我们看上图中间又一个 α t \alpha_t αt的公式:

α t = 1 2 l n ( 1 − ε t ε t ) \begin{align*} \alpha_t = \frac{1}{2}ln(\frac{1-\varepsilon_t}{\varepsilon_t}) \end{align*} αt=21ln(εt1εt)

然后我们再往上倒腾, ε t \varepsilon_t εt是当你预测出来这个值和实际值错的越多, 越趋近于1。如果完全没有错,一个错都没有的情况下,那么 ε t = 0 \varepsilon_t=0 εt=0

ε t = P r i ∼ D t [ h t ( x i ) ≠ y i ] \begin{align*} \varepsilon_t = Pr_{i\sim D_t}[h_t(x_i)\ne y_i] \end{align*} εt=PriDt[ht(xi)=yi]

如果 ε t = 1 \varepsilon_t = 1 εt=1的话, 那就是 1 − ε t ε t \frac{1-\varepsilon_t}{\varepsilon_t} εt1εt就是:1-1/1=0。ln0等于什么呢?它等于负的无穷大,那么 α t \alpha_t αt等于就没有。如果 ε t = 0 \varepsilon_t = 0 εt=0 l n ( 1 − ε t ε t ) ln(\frac{1-\varepsilon_t}{\varepsilon_t}) ln(εt1εt)就是无穷大。

也就是说,随着 ε t \varepsilon_t εt越大, 那 α t \alpha_t αt会越大,随着 ε t \varepsilon_t εt越小, α t \alpha_t αt也会越小。而且在这个地方是呈指数变化的,就是误差会对 α t \alpha_t αt的变化影响的很大。

除了用指数的东西来做,它还有一个很重要的特性, 这个特性才在我们整个Adaboost里非常重要:

D t + 1 ( i ) = D t ( i ) e x p ( − α t y i h t ( x i ) ) Z t D_{t+1}(i) = \frac{D_t(i)exp(-\alpha_ty_ih_t(x_i))}{Z_t} Dt+1(i)=ZtDt(i)exp(αtyiht(xi))

我们先来看 y i h t ( x i ) y_ih_t(x_i) yiht(xi)这部分,假设ht(xi)=1, yi预测对了等于1, yi预测错了等于-1。那如果预测错了,这整个部分都等于-1,如果预测对了,这里就是1。

前面有一个负号: − α t y i h t ( x i ) -\alpha_ty_ih_t(x_i) αtyiht(xi),那肯定是要变号的。也就是说,如果预测错了,那么这一串东西应该是正的,如果预测对了这一串东西应该是负的。

前面是什么,是 D t + 1 ( i ) D_{t+1}(i) Dt+1(i), 这里其实就是第i个训练元素在 D t + 1 D_{t+1} Dt+1被取到的概率。那么我们最前面有表示 D 1 ( i ) = 1 m D_1(i) = \frac{1}{m} D1(i)=m1, 也就是说,所有元素被取到的概率都是一样的,是平均的。那第二次的概率就是: D 1 ( i ) ⋅ e x p ( . . . ) D_1(i)\cdot exp(...) D1(i)exp(...), exp就是e的多少次方。

那我们现在知道,如果预测对了,这里是-1, 预测错了这里是1, 都要再乘以 α t \alpha_t αt。那么如果预测对了,这里是 − α t -\alpha_t αt, 那exp这里就是小于1的。那如果预测错了呢,exp就是大于1的。

如果exp大于1,那么 D t + 1 ( i ) D_{t+1}(i) Dt+1(i)概率就会被 D t ( i ) D_t(i) Dt(i)的概率要更大,反之就会更小。

这个就是我们Ada的含义,Ada就是Adaptive, 就是动态调整的意思。也就是通过这种方法实现的。

如果此时此刻 x i x_i xi算对了,那下一次就更不容易被取到,如果算错了,那下一次训练就会更有可能被取到。

觉得绕的小伙伴去理解这样一个例子:如果你是个学生去做卷子,那么你作对的题还会反复去做吗?肯定是不会的题才会反复刷,刷到自己会为止。

Gradient Boosting

除了Adaboost之外,后来人们又提出来了一个新的方法: Gradient Boosting。

17. 机器学习 - 随机森林,茶桁的AI秘籍 - 核心基础,机器学习,随机森林,人工智能

Gradient Boosting和Adaboost的核心原理很像:

l o s s ( p , q ) = − ∑ i ∈ o u t p u t c l a s s e s p ( x ) l o g q ( x ) loss(p, q) = -\sum_{i\in output classes}p(x)logq(x) loss(p,q)=ioutputclassesp(x)logq(x)

Gradient Boosting主要用于解决回归和分类问题。它基于决策树(通常是浅层决策树)构建模型,通过迭代改进预测的准确性。

其最核心的就是梯度提升,是一种集成学习方法。将多个弱预测模型,也就是决策树组合在一起,以提高整体性能。每个决策树在不同的数据子集上训练,然后进行组合以生成最终的预测。其核心原理就是通过迭代优化损失函数来构建模型。

在每一步中,模型的更新方向就是损失函数的负梯度。假设我们有一个损失函数L(y, f(x)), 其中y是真实标签, f(x)是当前模型的预测,梯度提升的目标是找到一个新的模型h(x), 使得损失函数L(y, f(x) + h(x))最小化。

梯度提升使用负梯度方向的决策树h(x)来拟合当前模型的残差,因此可以通过以下方式迭代更新模型:

f ( x ) = f ( x ) + l e a r n i n g _ r a t e ⋅ h ( x ) f(x) = f(x) + learning\_rate \cdot h(x) \\ f(x)=f(x)+learning_rateh(x)

也就是说,它其实要变成这样一个式子:

B o o s t e d E n s e m b l e = F i r s t T r e e + η ⋅ S e c o n d T r e e l o s s ( B o o s t e d E n s e m b l e ) < l o s s ( F i r s t T r e e ) Boosted Ensemble = First Tree + \eta \cdot Second Tree \\ loss(Boosted Ensemble) < loss(First Tree) BoostedEnsemble=FirstTree+ηSecondTreeloss(BoostedEnsemble)<loss(FirstTree)

也就是说,我们第二波的h_t(x),也就是h_2(x),前面乘以一个 η \eta η,这个 η \eta η是等于Learning Rate的,然后h_2(x)加上h_1(x)最后得到的结果,要比h_1(x)的loss值更小。

17. 机器学习 - 随机森林,茶桁的AI秘籍 - 核心基础,机器学习,随机森林,人工智能

那么我们现在要做的就是改变 η \eta η的权重,这个东西的权重就是和之前我们在随机森林里调整权重不同。

一开始,梯度提升初始化一个简单的模型,通常是一个常数,用来拟合目标变量的平均值。

对于每一个训练样本,计算模型的梯度。这表示模型对于每个样本的预测误差。

使用新的决策树来拟合梯度的负梯度,也就是模型的残差。这意味着构建一个决策树,其目标是减小之前模型的误差。

将新构建的决策树与之前的模型相加,以形成一个新的模型。这个过程重复进行多次,每次都会减小误差。

重复2到4步,直到满足某个停止条件,理入达到最大迭代次数或误差足够小。

最终模型是所有决策树的组合,可以用来进行预测。

那我们之前谈到的 η \eta η,也就是learning_rate,其实就是学习率,用于控制每次更新的幅度。

数学上,梯度提升通过迭代不断减小损失函数来逼近最优模型,这是一种梯度下降的优化方法,因此它的核心原理与梯度下降算法是密切相关的。

Grading Boost和AdaBoost的整个区别不大,它们都是属于Ensemble Learning,中文翻译是合唱团。

这个Ensemble Learning我们可以取很多个分类、回归,然后我们把它做好之后给它求一个平均值。

17. 机器学习 - 随机森林,茶桁的AI秘籍 - 核心基础,机器学习,随机森林,人工智能

比如这样,

from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC

log_clf = LogisticRegression()
rnd_clf = RandomForestClassifier()
svm_clf = SVC()

voting_clf = VotingClassifier(
    estimators = [('lr', log_clf),('rf', rnd_clf),('svc', svm_clf)], voting='hard')

voting_clf.fit(x_train, y_train)
...

在sklearn的ensemble中本身就有一个VotingClassifier,也有RandomForestClassifier,我们可以直接用几个分类器可以实现。

AdaBoost和Gradient Boost也是属于一个典型的ensemble Learning。

那还有两个比较重要的东西,一个叫做Xgboost,一个叫做LightBGM,这两个是Grading Boost的升级版。它们被广泛的使用于机器挖掘,推荐系统等等。

当然这两块内容就不放在「核心基础」里讲了,将会在后面讲到BI专业课的时候专门的去讲,这两个是很重要的点。

那本节课讲完之后呢,咱们核心基础的部分,关于机器学习就跨过一个小阶段了。下一节课开始,我们要讲「深度学习」了。属于向前要跨一大步。

好,那咱们经典机器学习模型到今天就讲完了。各位看文章的小伙伴,自己去把这个课程再好好巩固一下,咱们下节课开始,就进入深度学习了。文章来源地址https://www.toymoban.com/news/detail-743937.html

到了这里,关于17. 机器学习 - 随机森林的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【机器学习】python实现随机森林

    目录 一、模型介绍 1. 集成学习 2. bagging 3. 随机森林算法 二、随机森林算法优缺点 三、代码实现 四、疑问 五、总结 本文使用mnist数据集,进行随机森林算法。 集成学习通过训练学习出多个估计器,当需要预测时通过结合器将多个估计器的结果整合起来当作最后的结果输出。

    2024年02月05日
    浏览(46)
  • R语言机器学习篇——随机森林

    参考书籍:陈强.机器学习及R应用.北京:高等教育出版社,2020 随机森林属于集成学习的方法,也称为组台学习,本章介绍随机森林与它的特例方法,装袋法,并分别以例子的形式讨论回归问题与分类问题的随机森林方法。 对于回归问题,调用MASS包数据框Boston作为数据集,分析

    2024年02月05日
    浏览(45)
  • 机器学习框架sklearn之随机森林

    集成学习通过建立几个模型组合来解决单一预测问题。它的工作原理是生成多个分类器/模型,各自独立的学习和作出预测。这些预测最后结合成组合预测,因此优于任何一个单分类的做出预测。 在机器学习中,随机森林是一个包含多个决策树的分类器,并且其输出的类别是

    2023年04月22日
    浏览(41)
  • 机器学习(十八):Bagging和随机森林

    全文共10000余字,预计阅读时间约30~40分钟 | 满满干货(附数据及代码),建议收藏! 本文目标:理解什么是集成学习,明确Bagging算法的过程,熟悉随机森林算法的原理及其在Sklearn中的各参数定义和使用方法 代码及数据集下载点这里 在机器学习的众多算法中,随机森林无疑是

    2024年02月13日
    浏览(51)
  • 机器学习——决策树与随机森林

    机器学习——决策树与随机森林 决策树和随机森林都是常见的机器学习算法,用于分类和回归任务,本文将对这两种算法进行介绍。 决策树算法是一种基于树结构的分类和回归算法。它通过对数据集进行 递归地二分 ,选择最佳的特征进行划分,直到达到终止条件。 决策树

    2024年02月09日
    浏览(36)
  • 机器学习十大算法之七——随机森林

    集成学习(ensemble learning)是时下非常流行的机器学习算法,它本身不是一个单独的机器学习算法,而是通过在数据上构建多个横型,集成所有模型的建模结果,基本上所有的机器学习领域都可以看到集成学习的身影,在现实中集成学习也有相当大的作用,它可以用来做市场

    2024年02月11日
    浏览(39)
  • 【机器学习】随机森林 – Random forest

    随机森林是一种由 决策树 构成的 集成算法 ,他在很多情况下都能有不错的表现。 要深入理解上面这句话,请阅读我的另外两篇文章: 【机器学习】决策树 – Decision Tree 【机器学习】集成学习 - Ensemble Learning 随机森林属于 集成学习 中的 Bagging (Bootstrap AGgregation 的简称)

    2024年02月16日
    浏览(44)
  • sklearn机器学习库(二)sklearn中的随机森林

    集成算法会考虑多个评估器的建模结果,汇总之后得到一个综合的结果, 以此来获取比单个模型更好的回归或分类表现 。 多个模型集成成为的模型叫做集成评估器(ensemble estimator),组成集成评估器的每个模型都叫做基评估器(base estimator)。通常来说,有三类集成算法:

    2024年02月12日
    浏览(45)
  • 机器学习5—分类算法之随机森林(Random Forest)

    随机森林(Random Forest) 是Bagging(一种并行式的集成学习方法)的一个拓展体,它的基学习器固定为决策树,多棵树也就组成了森林,而“随机”则在于选择划分属性的随机,随机森林在训练基学习器时,也采用有放回采样的方式添加样本扰动,同时它还引入了一种属性扰动

    2024年02月03日
    浏览(40)
  • 机器学习实验——使用决策树和随机森林对数据分类

    使用决策树算法和随机森林算法对income_classification.csv的收入水平进行分类。训练集和测试集的比例是7:3,选取适当的特征列,使得针对测试样本的分类准确率在80%以上,比较2种分类方法的准确率。 数据说明: 特征列: 分类标签列:income 1、读入数据并显示数据的维度和前

    2024年02月04日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包