【机器学习】集成模型 集成学习：多个模型相结合实现更好的预测_模型集成(1)

为了做好运维面试路上的助攻手，特整理了上百道 【运维技术栈面试题集锦】 ，让你面试不慌心不跳，高薪offer怀里抱！

这次整理的面试题，小到shell、MySQL，大到K8s等云原生技术栈，不仅适合运维新人入行面试需要，还适用于想提升进阶跳槽加薪的运维朋友。

本份面试集锦涵盖了

• 174 道运维工程师面试题
• 128道k8s面试题
• 108道shell脚本面试题
• 200道Linux面试题
• 51道docker面试题
• 35道Jenkis面试题
• 78道MongoDB面试题
• 17道ansible面试题
• 60道dubbo面试题
• 53道kafka面试
• 18道mysql面试题
• 40道nginx面试题
• 77道redis面试题
• 28道zookeeper

总计 1000+ 道面试题， 内容 又全含金量又高

• 174道运维工程师面试题

1、什么是运维?

2、在工作中，运维人员经常需要跟运营人员打交道，请问运营人员是做什么工作的?

3、现在给你三百台服务器，你怎么对他们进行管理?

4、简述raid0 raid1raid5二种工作模式的工作原理及特点

5、LVS、Nginx、HAproxy有什么区别?工作中你怎么选择?

6、Squid、Varinsh和Nginx有什么区别，工作中你怎么选择?

7、Tomcat和Resin有什么区别，工作中你怎么选择?

8、什么是中间件?什么是jdk?

9、讲述一下Tomcat8005、8009、8080三个端口的含义？

10、什么叫CDN?

11、什么叫网站灰度发布?

12、简述DNS进行域名解析的过程?

13、RabbitMQ是什么东西?

14、讲一下Keepalived的工作原理?

15、讲述一下LVS三种模式的工作过程?

16、mysql的innodb如何定位锁问题，mysql如何减少主从复制延迟?

17、如何重置mysql root密码?

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以点击这里获取！

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

1

⌋

)

\left ( \left \lfloor log_{2}\left | F \right | + 1 \right \rfloor \right )

(⌊log2​∣F∣+1⌋)。因为随机森林中的每棵树使用的特征越多，其与森林中其他树的特征重合度就可能越高，导致产生的随机数相似度越大。

可解释性：单个实例预测背后的逻辑可以通过多棵随机树共同决定。

随机森林的特点：

• 随机森林非常强大，可以高效地进行构建。
• 可以并行的进行。
• 对过拟合有很强的鲁棒性。
• 可解释性被牺牲了一部分，因为每个树的特征都是特征集合中随机选取的一部分。

5.3 演进法 Boosting（算法操作）

演进法的思想源于调整基础分类器，使其专注于难以分类的实例的直觉判断。

具体方法：

迭代地改变训练实例的分布和权重，以反映分类器在前一次迭代中的表现。

• 从初始训练集训练出一个基学习器；这时候每个样本的权重都为。
• 每个都会根据上一轮预测结果调整训练集样本的权重。
• 基于调整后的训练集训练一个新的基学习器。
• 重复进行，直到基学习器数量达到开始设置的值。
• 将个基学习器通过加权的投票方法（weighted voting）进行结合。

例子：

对于boosting方法，有两个问题需要解决：

• 每一轮学习应该如何改变数据的概率分布
• 如何将各个基分类器组合起来

Boosting集成方法的特点：

• 他的基分类器是决策树或者 OneR 方法。
• 数学过程复杂，但是计算的开销较小；整个过程建立在迭代的采样过程和加权的投票（voting）上。
• 通过迭代的方式不断的拟合残差信息，最终保证模型的精度。
• 比bagging方法的计算开销要大一些。
• 在实际的应用中，boosting的方法略有过拟合的倾向（但是不严重）。
• 可能是最佳的词分类器（gradient boosting）。

5.3.1 演进法实例：AdaBoost

Adaptive Boosting（自适应增强算法）：是一种顺序的集成方法（随机森林和 Bagging 都属于并行的集成算法）。

具体方法：
有T个基分类器:

C

1

,

C

2

,

.

.

.

,

C

i

,

.

.

,

C

T

C_{1},C_{2},…,C_{i},…,C_{T}

C1​,C2​,…,Ci​,…,CT​。
训练集表示为

{

x

i

,

y

j

∣

j

=

1

,

2

,

.

.

.

,

N

}

\left { x_{i},y_{j}|j=1,2,…,N \right }

{xi​,yj​∣j=1,2,…,N}。
初始化每个样本的权重都为

1

N

\frac{1}{N}

N1​，即：

{

w

j

(

1

)

=

1

N

∣

j

=

1

,

2

,

.

.

.

,

N

}

\left { w_{j}^{(1)=\frac{1}{N}}|j=1,2,…,N \right }

{wj(1)=N1​​∣j=1,2,…,N}。

在每个iteration i 中，都按照下面的步骤进行：

计算错误率 error rate

ξ

i

=

∑

j

=

1

N

w

j

(

i

)

δ

(

C

j

(

x

j

)

≠

y

j

)

\xi _{i}=\sum _{j=1}^{N} w_{j}^{(i)}\delta (C_{j}(x_{j})\neq y_{j})

ξi​=∑j=1N​wj(i)​δ(Cj​(xj​)=yj​)

δ

(

)

\delta \left ( \right)

δ()是一个indicator函数，当函数的条件满足的时候函数值为1；即，当弱分类器

C

i

C_{i}

Ci​对样本

x

j

x_{j}

xj​进行分类的时候如果分错了就会累积

w

j

w_{j}

wj​。

使用

ξ

i

\xi _{i}

ξi​来计算每个基分类器

C

i

C_{i}

Ci​的重要程度（给这个基分类器分配权重

α

i

\alpha _{i}

αi​）

α

i

=

1

2

l

n

1

−

ε

i

ε

i

\alpha _{i}=\frac{1}{2}ln\frac{1-\varepsilon _{i}}{\varepsilon _{i}}

αi​=21​lnεi​1−εi​​

从这个公式也能看出来，当

C

i

C_{i}

Ci​ 判断错的样本量越多，得到的

ξ

i

\xi _{i}

ξi​就越大，相应的

α

i

\alpha _{i}

αi​就越小（越接近0）

根据

α

i

\alpha _{i}

αi​来更新每一个样本的权重参数，为了第i+1个iteration做准备：

w

j

(

i

1

)

=

w

j

(

i

)

Z

(

i

)

×

{

e

−

α

i

i

f

C

i

(

x

j

)

=

y

j

e

α

i

i

f

C

i

(

x

j

)

≠

y

j

w_{j}^{{(i+1)}=\frac{w_{j}}{(i)}}{Z^{(i)}}\times \left{\begin{matrix} e^{-\alpha _{i}} &ifC_{i}(x_{j})=y_{j} \ e^{\alpha _{i}} & ifC_{i}(x_{j})\neq y_{j} \end{matrix}\right.

wj(i+1)​=Z(i)wj(i)​​×{e−αi​eαi​​ifCi​(xj​)=yj​ifCi​(xj​)=yj​​

样本j的权重由

w

j

(

i

)

w_{j}^{(i)}

wj(i)​变成

w

j

(

i

1

)

w_{j}^{(i+1)}

wj(i+1)​这个过程中发生的事情是：如果这个样本在第i个iteration中被判断正确了，他的权重就会在原本KaTeX parse error: Expected ‘}’, got ‘EOF’ at end of input: w_{j}^{(i)}的基础上乘以

e

−

α

i

e^{-\alpha _{i}}

e−αi​；根据上面的知识

α

i

0

\alpha _{i} > 0

αi​>0因此

−

α

i

<

0

-\alpha _{i} < 0

−αi​<0所以根据公式我们可以知道，那些被分类器预测错误的样本会有一个大的权重；而预测正确的样本则会有更小的权重。

Z

(

i

)

Z^{(i)}

Z(i)是一个normalization项，为了保证所有的权重相加之和为1。

最终将所有的

C

i

C_{i}

Ci​按照权重进行集成

持续完成从i=2,…,T的迭代过程，但是当

ε

i

0.5

\varepsilon_{i} > 0.5

εi​>0.5的时候需要重新初始化样本的权重最终采用的集成模型进行分类的公式：

C

∗

(

x

)

=

a

r

g

m

a

x

y

∑

i

=

1

T

α

i

δ

(

C

i

(

x

)

=

y

)

C^{*}(x)=argmax_{y}\sum _{i=1}^{T}\alpha _{i}\delta (C_{i}(x)=y)

C∗(x)=argmaxy​∑i=1T​αi​δ(Ci​(x)=y)

这个公式的意思大概是：例如我们现在已经得到了3个基分类器，他们的权重分别是0.3, 0.2, 0.1所以整个集成分类器可以表示为：

C

(

x

)

=

∑

i

=

1

T

α

i

C

i

(

x

)

=

0.3

C

1

(

x

)

0.2

C

2

(

x

)

0.1

C

3

(

x

)

C(x)=\sum _{i=1}^{T}\alpha _{i}C_{i}(x)=0.3C_{1}(x)+0.2C_{2}(x)+0.1C_{3}(x)

C(x)=∑i=1T​αi​Ci​(x)=0.3C1​(x)+0.2C2​(x)+0.1C3​(x)

如果类别标签一共只有0, 1那就最终的C(x)对于0的值大还是对于1的值大了。

只要每一个基分类器都比随机预测的效果好，那么最终的集成模型就会收敛到一个强很多的模型。

5.3.2 装袋法/随机森林和演进法对比

装袋法和演进法的对比：

装袋法/随机森林 以及演进法对比

5.4 堆叠法 Stacking

堆叠法的思想源于在不同偏置的算法范围内平滑误差的直觉。

方法：采用多种算法，这些算法拥有不同的偏置

在基分类器（level-0 model) 的输出上训练一个元分类器（meta-classifier）也叫level-1 model

了解哪些分类器是可靠的，并组合基分类器的输出 使用交叉验证来减少偏置

Level-0：基分类器

给定一个数据集 ( X , y ) 可以是SVM, Naive Bayes, DT等

Level-1：集成分类器

在Level-0分类器的基础上构建新的attributes
每个Level-0分类器的预测输出都会加入作为新的attributes；如果有M个Level-0分离器最终就会加入M个attributes
删除或者保持原本的数据X 考虑其他可用的数据（NB概率分数，SVM权重） 训练meta-classifier来做最终的预测

可视化这个stacking过程：

stacking方法的特点：

• 结合多种不同的分类器
• 数学表达简单，但是实际操作耗费计算资源
• 通常与基分类器相比，stacking的结果一般好于最好的基分类器

PS：读到这里你大概已经了解集成学习了，如果你想更深入了解的话可以继续读下去

6. 深入介绍集成技术

6.1 集成学习介绍

我们通过一个例子来理解集成学习的概念。假设你是一名电影导演，你依据一个非常重要且有趣的话题创作了一部短片。现在，你想在公开发布前获得影片的初步反馈（评级）。有哪些可行的方法呢？

A：可以请一位朋友为电影打分。

于是完全有可能出现这种结果：你所选择的人由于非常爱你，并且不希望给你这部糟糕的影片打1星评级来伤害你脆弱的小心脏。

B：另一种方法是让你的5位同事评价这部电影。

这个办法应该更好，可能会为电影提供更客观诚实的评分。但问题依然存在。这5个人可能不是电影主题方面的“专家”。当然，他们可能懂电影摄制，镜头或音效，但他们可能并不是黑色幽默的最佳评判者。

C：让50个人评价这部电影呢？

其中一些可以是你的朋友，可以是你的同事，甚至是完完全全的陌生人。

在这种情况下，回应将更加普遍化和多样化，因为他们拥有不同的技能。事实证明，与我们之前看到的情况相比，这是获得诚实评级的更好方法。

通过这些例子，你可以推断，与个人相比，不同群体的人可能会做出更好的决策。与单一模型相比，各种不同模型也是这个道理。机器学习中的多样化是通过称为集成学习（Ensemble learning）的技术实现的。

现在你已经掌握了集成学习的要旨，接下来让我们看看集成学习中的各种技术及其实现。

6.2 简单集成技术

这一节中，我们会看一些简单但是强大的技术，比如：

• 最大投票法
• 平均法
• 加权平均法

6.2.1 最大投票法

最大投票方法通常用于分类问题。这种技术中使用多个模型来预测每个数据点。每个模型的预测都被视为一次“投票”。大多数模型得到的预测被用作最终预测结果。

例如，当你让5位同事评价你的电影时（最高5分）; 我们假设其中三位将它评为4，而另外两位给它一个5。由于多数人评分为4，所以最终评分为4。你可以将此视为采用了所有预测的众数（mode）。

最大投票的结果有点像这样：

示例代码：

这里x_train由训练数据中的自变量组成，y_train是训练数据的目标变量。验证集是x_test（自变量）和y_test（目标变量）。

model1 = tree.DecisionTreeClassifier()

model2 = KNeighborsClassifier()

model3= LogisticRegression()

model1.fit(x_train,y_train)

model2.fit(x_train,y_train)

model3.fit(x_train,y_train)

pred1=model1.predict(x_test)

pred2=model2.predict(x_test)

pred3=model3.predict(x_test)

final_pred = np.array([])

for i in range(0,len(x_test)):

final_pred =np.append(final_pred, mode([pred1[i], pred2[i], pred3[i]]))

或者，你也可以在sklearn中使用“VotingClassifier”模块，如下所示：

from sklearn.ensemble import VotingClassifier

model1 = LogisticRegression(random_state=1)

model2 = tree.DecisionTreeClassifier(random_state=1)

model = VotingClassifier(estimators=[(‘lr’, model1), (‘dt’, model2)], voting=‘hard’)

model.fit(x_train,y_train)

model.score(x_test,y_test)

6.2.2 平均法

类似于最大投票技术，这里对每个数据点的多次预测进行平均。在这种方法中，我们从所有模型中取平均值作为最终预测。平均法可用于在回归问题中进行预测或在计算分类问题的概率时使用。

例如，在下面的情况中，平均法将取所有值的平均值。

即（5 + 4 + 5 + 4 + 4）/ 5 = 4.4

示例代码：

model1 = tree.DecisionTreeClassifier()

model2 = KNeighborsClassifier()

model3= LogisticRegression()

model1.fit(x_train,y_train)

model2.fit(x_train,y_train)

model3.fit(x_train,y_train)

pred1=model1.predict_proba(x_test)

pred2=model2.predict_proba(x_test)

pred3=model3.predict_proba(x_test)

finalpred=(pred1+pred2+pred3)/3

2.3 加权平均法

这是平均法的扩展。为所有模型分配不同的权重，定义每个模型的预测重要性。例如，如果你的两个同事是评论员，而其他人在这方面没有任何经验，那么与其他人相比，这两个朋友的答案就更加重要。

计算结果为[（5 * 0.23）+（4 * 0.23）+（5 * 0.18）+（4 * 0.18）+（4 * 0.18）] = 4.41。

示例代码：

model1 = tree.DecisionTreeClassifier()

model2 = KNeighborsClassifier()

model3= LogisticRegression()

model1.fit(x_train,y_train)

model2.fit(x_train,y_train)

model3.fit(x_train,y_train)

pred1=model1.predict_proba(x_test)

pred2=model2.predict_proba(x_test)

pred3=model3.predict_proba(x_test)

finalpred=(pred1
0.3+pred20.3+pred3*0.4)

6.3 高级集成技术

我们已经介绍了基础的集成技术，让我们继续了解高级的技术。

6.3.1 堆叠（Stacking）

堆叠是一种集成学习技术，它使用多个模型（例如决策树，knn或svm）的预测来构建新模型。该新模型用于对测试集进行预测。以下是简单堆叠集成法的逐步解释：

**第一步：**把训练集分成10份

**第二步：**基础模型（假设是决策树）在其中9份上拟合，并对第10份进行预测。

**第三步：**对训练集上的每一份如此做一遍。

**第四步：**然后将基础模型（此处是决策树）拟合到整个训练集上。

**第五步：**使用此模型，在测试集上进行预测。

**第六步：**对另一个基本模型（比如knn）重复步骤2到4，产生对训练集和测试集的另一组预测。

**第七步：**训练集预测被用作构建新模型的特征。

**第八步：**该新模型用于对测试预测集（test prediction set，上图的右下角）进行最终预测。

示例代码：

我们首先定义一个函数来对n折的训练集和测试集进行预测。此函数返回每个模型对训练集和测试集的预测。

def Stacking(model,train,y,test,n_fold):

folds=StratifiedKFold(n_splits=n_fold,random_state=1)

test_pred=np.empty((test.shape[0],1),float)

train_pred=np.empty((0,1),float)

for train_indices,val_indices in folds.split(train,y.values):

x_train,x_val=train.iloc[train_indices],train.iloc[val_indices]

y_train,y_val=y.iloc[train_indices],y.iloc[val_indices]

model.fit(X=x_train,y=y_train)

train_pred=np.append(train_pred,model.predict(x_val))

test_pred=np.append(test_pred,model.predict(test))

return test_pred.reshape(-1,1),train_pred

现在我们将创建两个基本模型：决策树和knn。

model1 = tree.DecisionTreeClassifier(random_state=1)

test_pred1 ,train_pred1=Stacking(model=model1,n_fold=10, train=x_train,test=x_test,y=y_train)

train_pred1=pd.DataFrame(train_pred1)

test_pred1=pd.DataFrame(test_pred1)

model2 = KNeighborsClassifier()

test_pred2 ,train_pred2=Stacking(model=model2,n_fold=10,train=x_train,test=x_test,y=y_train)

train_pred2=pd.DataFrame(train_pred2)

test_pred2=pd.DataFrame(test_pred2)

创建第三个模型，逻辑回归，在决策树和knn模型的预测之上。

df = pd.concat([train_pred1, train_pred2], axis=1)

df_test = pd.concat([test_pred1, test_pred2], axis=1)

model = LogisticRegression(random_state=1)

model.fit(df,y_train)

model.score(df_test, y_test)

为了简化上面的解释，我们创建的堆叠模型只有两层。决策树和knn模型建立在零级，而逻辑回归模型建立在第一级。其实可以随意的在堆叠模型中创建多个层次。

6.3.2 混合（Stacking）

混合遵循与堆叠相同的方法，但仅使用来自训练集的一个留出(holdout)/验证集来进行预测。换句话说，与堆叠不同，预测仅在留出集上进行。留出集和预测用于构建在测试集上运行的模型。以下是混合过程的详细说明：

**第一步：**原始训练数据被分为训练集合验证集。

**第二步：**在训练集上拟合模型。

**第三步：**在验证集和测试集上进行预测。

**第四步：**验证集及其预测用作构建新模型的特征。

**第五步：**该新模型用于对测试集和元特征(meta-features)进行最终预测。

示例代码：

我们将在训练集上建立两个模型，决策树和knn，以便对验证集进行预测。

model1 = tree.DecisionTreeClassifier()

model1.fit(x_train, y_train)

val_pred1=model1.predict(x_val)

test_pred1=model1.predict(x_test)

val_pred1=pd.DataFrame(val_pred1)

test_pred1=pd.DataFrame(test_pred1)

model2 = KNeighborsClassifier()

model2.fit(x_train,y_train)

val_pred2=model2.predict(x_val)

test_pred2=model2.predict(x_test)

val_pred2=pd.DataFrame(val_pred2)

test_pred2=pd.DataFrame(test_pred2)

结合元特征和验证集，构建逻辑回归模型以对测试集进行预测。

df_val=pd.concat([x_val, val_pred1,val_pred2],axis=1)

df_test=pd.concat([x_test, test_pred1,test_pred2],axis=1)

model = LogisticRegression()

model.fit(df_val,y_val)

model.score(df_test,y_test)

6.3.3 Bagging

Bagging背后的想法是结合多个模型的结果（例如，所有决策树）来获得泛化的结果。这有一个问题：如果在同样一组数据上创建所有模型并将其组合起来，它会有用吗？这些模型极大可能会得到相同的结果，因为它们获得的输入相同。那我们该如何解决这个问题呢？其中一种技术是自举(bootstrapping)。

Bootstrapping是一种采样技术，我们有放回的从原始数据集上创建观察子集，子集的大小与原始集的大小相同。

Bagging（或Bootstrap Aggregating）技术使用这些子集（包）来获得分布的完整概念（完备集）。为bagging创建的子集的大小也可能小于原始集。

**第一步：**从原始数据集有放回的选择观测值来创建多个子集。

**第二步：**在每一个子集上创建一个基础模型（弱模型）。

**第三步：**这些模型同时运行，彼此独立。

**第四步：**通过组合所有模型的预测来确定最终预测。

6.3.4 Boosting

在我们进一步讨论之前，这里有另一个问题：如果第一个模型错误地预测了某一个数据点，然后接下来的模型（可能是所有模型），将预测组合起来会提供更好的结果吗？Boosting就是来处理这种情况的。

Boosting是一个顺序过程，每个后续模型都会尝试纠正先前模型的错误。后续的模型依赖于之前的模型。接下来一起看看boosting的工作方式：

**第一步：**从原始数据集创建一个子集。

**第二步：**最初，所有数据点都具有相同的权重。

**第三步：**在此子集上创建基础模型。

**第四步：**该模型用于对整个数据集进行预测。

**第五步：**使用实际值和预测值计算误差。

**第六步：**预测错误的点获得更高的权重。（这里，三个错误分类的蓝色加号点将被赋予更高的权重）

**第七步：**创建另一个模型并对数据集进行预测（此模型尝试更正先前模型中的错误）。

**第八步：**类似地，创建多个模型，每个模型校正先前模型的错误。

**第九步：**最终模型（强学习器）是所有模型（弱学习器）的加权平均值。

因此，boosting算法结合了许多弱学习器来形成一个强学习器。单个模型在整个数据集上表现不佳，但它们在数据集的某些部分上表现很好。因此，每个模型实际上提升了集成的整体性能。

6.4基于Bagging和Boosting的算法

Bagging和Boosting是机器学习中最常用的两种技术。在本节中，我们将详细介绍它们。以下是我们将关注的算法：

Bagging 算法:

• Bagging meta-estimator
• 随机森林

Boosting算法：

• AdaBoost
• GBM
• XGBM
• Light GBM
• CatBoost

对于本节中讨论的所有算法，我们将遵循以下顺序：

• 算法介绍
• 示例代码
• 参数

本文中，我使用了贷款预测问题。你可以从此处下载数据集。请注意，对于每种算法，某些代码（读取数据，划分训练测试集等）将是相同的。为了避免重复，我在下面编写了相同的代码，并且只对算法相关的代码进行进一步讨论。

#importing important packages

import pandas as pd

import numpy as np

#reading the dataset

df=pd.read_csv(“/home/user/Desktop/train.csv”)

#filling missing values

df[‘Gender’].fillna(‘Male’, inplace=True)

同理，对所有列进行值填充。本文只考虑所讨论的主题，已跳过EDA，缺失值和异常值处理等步骤。要了解这些主题，可以阅读此文：Ultimate guide for Data Explorationin Python using NumPy, Matplotlib and Pandas.

#split dataset into train and test

from sklearn.model_selection import train_test_split

train, test = train_test_split(df, test_size=0.3, random_state=0)

x_train=train.drop(‘Loan_Status’,axis=1)

y_train=train[‘Loan_Status’]

x_test=test.drop(‘Loan_Status’,axis=1)

y_test=test[‘Loan_Status’]

#create dummies

x_train=pd.get_dummies(x_train)

x_test=pd.get_dummies(x_test)

让我们来探索bagging和boosting算法。

6.4.1 Bagging meta-estimator

Bagging meta-estimator是一种集成算法，可用于分类(BaggingClassifier)和回归(BaggingRegressor)问题。它采用典型的bagging技术进行预测。以下是Bagging meta-estimator算法的步骤：

**第一步：**从原始数据集（Bootstrapping）创建随机子集。

**第二步：**数据集的子集包括所有特征。

第三步用户指定的基础估计器在这些较小的集合上拟合。

**第四步：**将每个模型的预测结合起来得到最终结果。

示例代码：

from sklearn.ensemble import BaggingClassifier

from sklearn import tree

model = BaggingClassifier(tree.DecisionTreeClassifier(random_state=1))

model.fit(x_train, y_train)

model.score(x_test,y_test)

0.75135135135135134

回归问题示例代码：

from sklearn.ensemble import BaggingRegressor

model = BaggingRegressor(tree.DecisionTreeRegressor(random_state=1))

model.fit(x_train, y_train)

model.score(x_test,y_test)

算法中用到的参数：

• base_estimator
• • 定义了在随机子集上拟合所用的基础估计器
    • 没有指明时，默认使用决策树
• n_estimators
• • 创建的基础估计器数量
    • 要小心微调这个参数，因为数字越大运行时间越长，相反太小的数字可能无法提供最优结果
• max_samples
• • 该参数控制子集的大小
    • 它是训练每个基础估计器的最大样本数量
• max_features
• • 控制从数据集中提取多少个特征
    • 它是训练每个基础估计器的最大特征数量
• n_jobs
• • 同时运行的job数量
    • 将这个值设为你系统的CPU核数
    • 如果设为-1，这个值会被设为你系统的CPU核数
• random_state
• • 定义了随机分割的方法。当两个模型的random_state值一样时，它们的随机选择也一样
    • 如果你想对比不同的模型，这个参数很有用

6.4.2 随机森林

随机森林是另一种遵循bagging技术的集成机器学习算法。它是bagging-estimator算法的扩展。随机森林中的基础估计器是决策树。与bagging meta-estimator不同，随机森林随机选择一组特征，这些特征用于决定决策树的每个节点处的最佳分割。

随机森林的具体步骤如下:

**第一步：**从原始数据集（Bootstrapping）创建随机子集。

**第二步：**在决策树中的每个节点处，仅考虑一组随机特征来决定最佳分割。

**第三步：**在每个子集上拟合决策树模型。

**第四步：**通过对所有决策树的预测求平均来计算最终预测。

**注意：**随机林中的决策树可以构建在数据和特征的子集上。特别地，sklearn中的随机森林使用所有特征作为候选，并且候选特征的随机子集用于在每个节点处分裂。

总而言之，随机森林随机选择数据点和特征，并构建多个树（森林）。

示例代码：

from sklearn.ensemble import RandomForestClassifier

model= RandomForestClassifier(random_state=1)

model.fit(x_train, y_train)

model.score(x_test,y_test)

0.77297297297297296

你可以通过在随机林中使用model.feature_importances_来查看特征重要性。

for i, j in sorted(zip(x_train.columns, model.feature_importances_)):

print(i, j)

结果如下：

ApplicantIncome 0.180924483743

CoapplicantIncome 0.135979758733

Credit_History 0.186436670523

.

.

.

Property_Area_Urban 0.0167025290557

Self_Employed_No 0.0165385567137

Self_Employed_Yes 0.0134763695267

回归问题示例代码：

from sklearn.ensemble import RandomForestRegressor

model= RandomForestRegressor()

model.fit(x_train, y_train)

model.score(x_test,y_test)

参数：

• n_estimators
• • 定义随机森林中要创建的决策树数量
    • 通常，越高的值会让预测更强大更稳定，但是过高的值会让训练时间很长
• criterion
• • 定义了分割用的函数
    • 该函数用来衡量使用每个特征分割的质量从而选择最佳分割
• max_features
• • 定义了每个决策树中可用于分割的最大特征数量
    • 增加最大特征数通常可以改善性能，但是一个非常高的值会减少各个树之间的差异性
• max_depth
• • 随机森林有多个决策树，此参数定义树的最大深度
• min_samples_split
• • 用于在尝试拆分之前定义叶节点中所需的最小样本数
    • 如果样本数小于所需数量，则不分割节点
• min_samples_leaf
• • 定义了叶子节点所需的最小样本数
    • 较小的叶片尺寸使得模型更容易捕获训练数据中的噪声
• max_leaf_nodes
• • 此参数指定每个树的最大叶子节点数
    • 当叶节点的数量变得等于最大叶节点时，树停止分裂
• n_jobs
• • 这表示并行运行的作业数
    • 如果要在系统中的所有核心上运行，请将值设置为-1
• random_state
• • 此参数用于定义随机选择
    • 它用于各种模型之间的比较

6.4.3 AdaBoost

自适应增强或AdaBoost是最简单的boosting算法之一。通常用决策树来建模。创建多个顺序模型，每个模型都校正上一个模型的错误。AdaBoost为错误预测的观测值分配权重，后续模型来正确预测这些值。

以下是执行AdaBoost算法的步骤：

**第一步：**最初，数据集中的所有观察值都具有相同的权重。

**第二步：**在数据子集上建立一个模型。

**第三步：**使用此模型，可以对整个数据集进行预测。

**第四步：**通过比较预测值和实际值来计算误差。

**第五步：**在创建下一个模型时，会给预测错误的数据点赋予更高的权重。

**第六步：**可以使用误差值确定权重。例如，误差越大，分配给观察值的权重越大。

**第七步：**重复该过程直到误差函数没有改变，或达到估计器数量的最大限制。

示例代码：

from sklearn.ensemble import AdaBoostClassifier

model = AdaBoostClassifier(random_state=1)

model.fit(x_train, y_train)

model.score(x_test,y_test)

0.81081081081081086

回归问题示例代码：

from sklearn.ensemble import AdaBoostRegressor

model = AdaBoostRegressor()

model.fit(x_train, y_train)

model.score(x_test,y_test)

参数：

• base_estimators
• • 它用于指定基础估计器的类型，即用作基础学习器的机器学习算法
• n_estimators
• • 它定义了基础估计器的数量
    • 默认值为10，但可以设为较高的值以获得更好的性能
• learning_rate

最全的Linux教程，Linux从入门到精通

======================

1. linux从入门到精通(第2版)

2. Linux系统移植

3. Linux驱动开发入门与实战

4. LINUX 系统移植 第2版

5. Linux开源网络全栈详解 从DPDK到OpenFlow

第一份《Linux从入门到精通》466页

====================

内容简介

====

本书是获得了很多读者好评的Linux经典畅销书**《Linux从入门到精通》的第2版**。本书第1版出版后曾经多次印刷，并被51CTO读书频道评为“最受读者喜爱的原创IT技术图书奖”。本书第﹖版以最新的Ubuntu 12.04为版本，循序渐进地向读者介绍了Linux 的基础应用、系统管理、网络应用、娱乐和办公、程序开发、服务器配置、系统安全等。本书附带1张光盘，内容为本书配套多媒体教学视频。另外,本书还为读者提供了大量的Linux学习资料和Ubuntu安装镜像文件，供读者免费下载。

本书适合广大Linux初中级用户、开源软件爱好者和大专院校的学生阅读，同时也非常适合准备从事Linux平台开发的各类人员。

需要《Linux入门到精通》、《linux系统移植》、《Linux驱动开发入门实战》、《Linux开源网络全栈》电子书籍及教程的工程师朋友们劳烦您转发+评论

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以点击这里获取！

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

train, y_train)

model.score(x_test,y_test)

参数：

• n_estimators
• • 定义随机森林中要创建的决策树数量
    • 通常，越高的值会让预测更强大更稳定，但是过高的值会让训练时间很长
• criterion
• • 定义了分割用的函数
    • 该函数用来衡量使用每个特征分割的质量从而选择最佳分割
• max_features
• • 定义了每个决策树中可用于分割的最大特征数量
    • 增加最大特征数通常可以改善性能，但是一个非常高的值会减少各个树之间的差异性
• max_depth
• • 随机森林有多个决策树，此参数定义树的最大深度
• min_samples_split
• • 用于在尝试拆分之前定义叶节点中所需的最小样本数
    • 如果样本数小于所需数量，则不分割节点
• min_samples_leaf
• • 定义了叶子节点所需的最小样本数
    • 较小的叶片尺寸使得模型更容易捕获训练数据中的噪声
• max_leaf_nodes
• • 此参数指定每个树的最大叶子节点数
    • 当叶节点的数量变得等于最大叶节点时，树停止分裂
• n_jobs
• • 这表示并行运行的作业数
    • 如果要在系统中的所有核心上运行，请将值设置为-1
• random_state
• • 此参数用于定义随机选择
    • 它用于各种模型之间的比较

6.4.3 AdaBoost

自适应增强或AdaBoost是最简单的boosting算法之一。通常用决策树来建模。创建多个顺序模型，每个模型都校正上一个模型的错误。AdaBoost为错误预测的观测值分配权重，后续模型来正确预测这些值。

以下是执行AdaBoost算法的步骤：

**第一步：**最初，数据集中的所有观察值都具有相同的权重。

**第二步：**在数据子集上建立一个模型。

**第三步：**使用此模型，可以对整个数据集进行预测。

**第四步：**通过比较预测值和实际值来计算误差。

**第五步：**在创建下一个模型时，会给预测错误的数据点赋予更高的权重。

**第六步：**可以使用误差值确定权重。例如，误差越大，分配给观察值的权重越大。

**第七步：**重复该过程直到误差函数没有改变，或达到估计器数量的最大限制。

示例代码：

from sklearn.ensemble import AdaBoostClassifier

model = AdaBoostClassifier(random_state=1)

model.fit(x_train, y_train)

model.score(x_test,y_test)

0.81081081081081086

回归问题示例代码：

from sklearn.ensemble import AdaBoostRegressor

model = AdaBoostRegressor()

model.fit(x_train, y_train)

model.score(x_test,y_test)

参数：

• base_estimators
• • 它用于指定基础估计器的类型，即用作基础学习器的机器学习算法
• n_estimators
• • 它定义了基础估计器的数量
    • 默认值为10，但可以设为较高的值以获得更好的性能
• learning_rate

最全的Linux教程，Linux从入门到精通

======================

1. linux从入门到精通(第2版)

2. Linux系统移植

3. Linux驱动开发入门与实战

4. LINUX 系统移植 第2版

5. Linux开源网络全栈详解 从DPDK到OpenFlow

第一份《Linux从入门到精通》466页

====================

内容简介

====

本书是获得了很多读者好评的Linux经典畅销书**《Linux从入门到精通》的第2版**。本书第1版出版后曾经多次印刷，并被51CTO读书频道评为“最受读者喜爱的原创IT技术图书奖”。本书第﹖版以最新的Ubuntu 12.04为版本，循序渐进地向读者介绍了Linux 的基础应用、系统管理、网络应用、娱乐和办公、程序开发、服务器配置、系统安全等。本书附带1张光盘，内容为本书配套多媒体教学视频。另外,本书还为读者提供了大量的Linux学习资料和Ubuntu安装镜像文件，供读者免费下载。

本书适合广大Linux初中级用户、开源软件爱好者和大专院校的学生阅读，同时也非常适合准备从事Linux平台开发的各类人员。

需要《Linux入门到精通》、《linux系统移植》、《Linux驱动开发入门实战》、《Linux开源网络全栈》电子书籍及教程的工程师朋友们劳烦您转发+评论

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以点击这里获取！

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！