>  기사  >  기술 주변기기  >  머신러닝 랜덤 포레스트 알고리즘의 실제 분석

머신러닝 랜덤 포레스트 알고리즘의 실제 분석

WBOY
WBOY앞으로
2023-04-16 22:28:011359검색

번역가 | Zhu Xianzhong

리뷰어 | Sun Shujuan

고전적인 기계 학습에서 Random Forests 알고리즘은 "은총알" 유형의 알고리즘 모델로 설명될 수 있습니다.

이 모델은 여러 가지 이유로 훌륭합니다.

  • 다른 많은 알고리즘보다 데이터 사전 처리가 덜 필요하므로 이 알고리즘을 설정하기가 더 쉽습니다.
  • 분류 또는 회귀 모델로 기능할 수 있습니다.
  • 과적합이 쉽지 않습니다
  • 가능합니다 기능의 중요성을 쉽게 계산하려면

이 글에서는 랜덤 포레스트 알고리즘을 구성하는 다양한 구성 요소를 더 잘 분석하고 싶습니다. 이를 달성하기 위해 랜덤 포레스트 알고리즘을 가장 기본적인 구성 요소로 분해하고 각 구성 요소의 계산 작업을 설명하겠습니다. 기사가 끝날 때쯤이면 Random Forest 알고리즘이 어떻게 작동하는지, 그리고 이를 보다 직관적인 방식으로 사용하는 방법에 대해 더 깊이 이해할 수 있을 것입니다. 이 기사에서 사용할 예제는 분류 기능에 중점을 두지만 많은 원칙이 회귀 시나리오에도 동일하게 적용된다는 점에 유의해야 합니다.

Random Forest 알고리즘 실행

고전적인 Random Forest 패턴을 호출하는 것부터 시작해 보겠습니다. 이것은 가장 높은 수준이며 Python에서 Random Forest를 훈련할 때 많은 사람들이 사용하는 것입니다.

머신러닝 랜덤 포레스트 알고리즘의 실제 분석

시뮬레이트된 데이터

대상 열을 예측하기 위해 Random Forest 알고리즘을 실행하려면 다음을 수행하면 됩니다.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(df.drop('target', axis=1), df['target'], test_size=0.2, random_state=0)

# 训练随机森林算法并计算得分
simple_rf_model = RandomForestClassifier(n_estimators=100, random_state=0)
simple_rf_model.fit(X_train, y_train)
print(f"accuracy: {simple_rf_model.score(X_test, y_test)}")

# accuracy: 0.93

Random Forest 분류기를 실행하는 것은 매우 간단합니다. 위 코드에서 볼 수 있듯이 n_estimators 매개변수를 정의하고 random_state 매개변수를 0으로 설정했습니다. 개인적인 경험을 통해 많은 사람들이 0.93의 정확도를 보고 긴장을 풀지 않을 것이라고 말할 수 있습니다. 그들은 매우 만족한 듯 보였고, 정신없이 전개 작업을 시작했습니다. 하지만 오늘은 그렇게 하지 않겠습니다.

먼저 다음과 같은 "무해한" 코드 줄을 다시 살펴보겠습니다.

simple_rf_model = RandomForestClassifier(n_estimators=100, random_state=0)

무작위 상태는 다른 사람이 귀하의 작업을 복제할 수 있도록 보장하는 대부분의 데이터 과학 모델의 기능입니다. 그러므로 우리는 random_state 매개변수에 대해 너무 걱정하지 않을 것입니다.

하지만 n_estimators 매개변수를 자세히 살펴보겠습니다. scikit-learn에서 관련 문서를 보면 다음과 같은 간결한 정의를 찾을 수 있습니다:

"숲에 있는 나무의 수."

나무 수 연구

이제 Random Forest를 좀 더 구체적으로 정의해 보겠습니다. Random Forest는 많은 의사결정나무의 합의 내용을 담은 앙상블 모델입니다. 이 정의는 불완전할 수 있지만 나중에 다시 설명하겠습니다.

머신러닝 랜덤 포레스트 알고리즘의 실제 분석

많은 나무들이 서로 소통하고 합의에 도달합니다

이를 다음과 같이 분해하면 임의의 숲이 생길 수도 있다고 생각하게 될 수 있습니다.

#创建决策树
tree1 = DecisionTreeClassifier().fit(X_train, y_train)
tree2 = DecisionTreeClassifier().fit(X_train, y_train)
tree3 = DecisionTreeClassifier().fit(X_train, y_train)

# 预测X_test上的每一棵决策树
predictions_1 = tree1.predict(X_test)
predictions_2 = tree2.predict(X_test)
predictions_3 = tree3.predict(X_test)
print(predictions_1, predictions_2, predictions_3)

# 采取优先级策略
final_prediction = np.array([np.round((predictions_1[i] + predictions_2[i] + predictions_3[i])/3) for i in range(len(predictions_1))])
print(final_prediction)

위의 예에서 우리는 훈련했습니다. X_train에 3개의 의사결정 트리가 있습니다. 이는 n_estimators=3을 의미합니다. 3개의 나무를 훈련시킨 후 동일한 테스트 세트에서 각 나무를 예측한 다음 3개의 나무 중 2개가 선택되는 예측으로 끝났습니다.

말은 되는 것 같지만 전혀 옳지 않은 것 같습니다. 모든 의사결정 트리가 동일한 데이터로 훈련된다면 모두 동일한 결론에 도달하게 되어 전반적인 이점이 무효화되지 않을까요?

대체 샘플링에 대한 자세한 설명

이전 정의를 바탕으로 다음 문장을 추가해 보겠습니다. "랜덤 포레스트는 관련되지 않은 많은 의사결정 트리의 합의인 앙상블 모델입니다."

의사결정 트리는 두 가지 방법으로 전달될 수 있습니다. 관련 없음:

1. 각 의사결정 트리에 데이터의 고유한 부분을 샘플링할 만큼 데이터 세트 크기가 충분히 큽니다. 이 접근 방식은 일반적으로 많은 양의 데이터가 필요하기 때문에 널리 사용되지 않습니다.

2. 샘플링을 대체로 사용하는 기술을 사용할 수 있습니다. 대체 표본 추출은 모집단에서 추출한 표본을 다음 표본을 추출하기 전에 표본 모집단으로 되돌리는 경우입니다.

교체 샘플링을 설명하기 위해 3가지 색상의 구슬 5개가 있다고 가정하면 전체적인 모습은 다음과 같습니다.

blue, blue, red, green, red

구슬을 샘플링하려면 보통 그중 몇 개를 뽑아서 Got로 끝날 수도 있습니다. :

blue, red

빨간색을 한 번 집으면 원래 구슬 더미에 다시 넣지 않았기 때문입니다.

하지만 교체품으로 샘플링하면 실제로 어떤 구슬이라도 두 번 집어 들 수 있습니다. 빨간색이 내 더미에 다시 들어왔기 때문에 아직 다시 집을 수 있는 기회가 있습니다.

red, red

랜덤 포레스트 알고리즘에서 기본값은 원래 표본 모집단 크기의 약 2/3에 해당하는 표본을 구성하는 것입니다. 원래 훈련 데이터가 1000행이라면 트리에 입력하는 훈련 데이터 샘플은 아마도 약 670행일 것입니다. 즉, 랜덤 포레스트를 구축할 때 다양한 샘플링 속도를 시도하는 것이 좋은 매개 변수가 될 것입니다.

이전 코드와 달리 다음 코드는 매개변수 n_estimators=3인 Random Forest에 더 가깝습니다.

import numpy as np
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

# 对于每一棵树从X_train中采用3次放回抽样
df_sample1 = df.sample(frac=.67, replace=True)
df_sample2 = df.sample(frac=.67, replace=True)
df_sample3 = df.sample(frac=.67, replace=True)

X_train_sample1, X_test_sample1, y_train_sample1, y_test_sample1 = train_test_split(df_sample1.drop('target', axis=1), df_sample1['target'], test_size=0.2)
X_train_sample2, X_test_sample2, y_train_sample2, y_test_sample2 = train_test_split(df_sample2.drop('target', axis=1), df_sample2['target'], test_size=0.2)
X_train_sample3, X_test_sample3, y_train_sample3, y_test_sample3 = train_test_split(df_sample3.drop('target', axis=1), df_sample3['target'], test_size=0.2)

#生成决策树
tree1 = DecisionTreeClassifier().fit(X_train_sample1, y_train_sample1)
tree2 = DecisionTreeClassifier().fit(X_train_sample2, y_train_sample2)
tree3 = DecisionTreeClassifier().fit(X_train_sample3, y_train_sample3)

# 在X_test上预测每一棵决策树
predictions_1 = tree1.predict(X_test)
predictions_2 = tree2.predict(X_test)
predictions_3 = tree3.predict(X_test)
df = pd.DataFrame([predictions_1, predictions_2, predictions_3]).T
df.columns = ["tree1", "tree2", "tree3"]

# 采取优先级策略 
final_prediction = np.array([np.round((predictions_1[i] + predictions_2[i] + predictions_3[i])/3) for i in range(len(predictions_1))])
preds = pd.DataFrame([predictions_1, predictions_2, predictions_3, final_prediction, y_test]).T.head(20)
preds.columns = ["tree1", "tree2", "tree3", "final", "label"]
preds

머신러닝 랜덤 포레스트 알고리즘의 실제 분석

我们用放回抽样,把这些样本输送给树,产生结果,并达成共识。

袋装分类器(Bagging Classifier)

머신러닝 랜덤 포레스트 알고리즘의 실제 분석

早期的架构实际上就是一个装袋分类器

我们现在将引入一种新的算法,一种称为自助聚集(Bootstrap Aggregation,也称为“Bagging”)的有监督的学习算法。但请放心,这又会与随机森林算法联系起来。我们引入这个新概念的原因是,正如我们将要在文章后面的图中看到的,我们到目前为止所做的一切实际上都是装袋分类器所做的!

在下面的代码中,装袋分类器使用了一个名为bootstrap的参数,它实际上执行了我们刚才手动执行的放回抽样步骤。其实,sklearn库的随机森林算法实现也存在相同的参数。如果bootstrap参数的值是false,那么我们将为每个分类器使用整个总体。

import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier

# 集合中所使用的树的数量
n_estimators = 3

# 初始化装袋分类器
bag_clf = BaggingClassifier(
DecisionTreeClassifier(), n_estimators=n_estimators, bootstrap=True)

# 根据训练数据拟合装袋分类器
bag_clf.fit(X_train, y_train)

# 对测试数据进行预测
y_pred = bag_clf.predict(X_test)
pd.DataFrame([y_pred, y_test]).T

装袋分类器BaggingClassifier非常棒,因为您可以将它们与未命名为决策树的评估器一起使用!您可以插入许多算法,Bagging算法会将其转化为集成解决方案。随机森林算法实际上扩展了装袋算法(如果bootstrapping = true),因为它部分地利用Bagging算法来形成不相关的决策树。

然而,即使bootstrapping=false,随机森林算法也需要额外一步来确保树之间的不相关性——特征采样。

特征采样详解

特征采样(Feature sampling)意味着不仅对行进行采样,还对列进行采样。与行不同,随机森林的列在没有放回的情况下被采样,这意味着我们不会有重复的列来训练1棵树。

有许多方法可以对特征进行采样。您可以指定要采样的固定最大特征数量,获取特征总数的平方根,或者尝试使用日志数据。这些方法中的每一种都有各自的利弊,并将取决于您的数据和具体使用场景。

머신러닝 랜덤 포레스트 알고리즘의 실제 분석

通过特征采样扩展了Bagging算法

下面的代码片段使用sqrt技术对列进行采样,对行进行采样,训练3个决策树,并使用优先级规则进行预测。我们首先使用放回进行采样,他们对列进行采样,训练我们的单个树,让我们的树根据测试数据进行预测,然后采用优先级规则实现共识。

import numpy as np
import pandas as pd
import math
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
#对于每一棵树从X_train中取3个样本
df_sample1 = df.sample(frac=.67, replace=True)
df_sample2 = df.sample(frac=.67, replace=True)
df_sample3 = df.sample(frac=.67, replace=True)

# 分割训练集
X_train_sample1, y_train_sample1 = df_sample1.drop('target', axis=1), df_sample1['target']
X_train_sample2, y_train_sample2 = df_sample2.drop('target', axis=1), df_sample2['target']
X_train_sample3, y_train_sample3 = df_sample3.drop('target', axis=1), df_sample3['target']

# 使用sqrt获取训练和测试的采样特征,现在注意replace如何等于False的
num_features = len(X_train.columns)
X_train_sample1 = X_train_sample1.sample(n=int(math.sqrt(num_features)), replace=False, axis = 1)
X_train_sample2 = X_train_sample2.sample(n=int(math.sqrt(num_features)), replace=False, axis = 1)
X_train_sample3 = X_train_sample3.sample(n=int(math.sqrt(num_features)), replace=False, axis = 1)

# 创建决策树,这次我们对列进行采样
tree1 = DecisionTreeClassifier().fit(X_train_sample1, y_train_sample1)
tree2 = DecisionTreeClassifier().fit(X_train_sample2, y_train_sample2)
tree3 = DecisionTreeClassifier().fit(X_train_sample3, y_train_sample3)

# 预测X_test上的每个决策树
predictions_1 = tree1.predict(X_test[X_train_sample1.columns])
predictions_2 = tree2.predict(X_test[X_train_sample2.columns])
predictions_3 = tree3.predict(X_test[X_train_sample3.columns])
preds = pd.DataFrame([predictions_1, predictions_2, predictions_3]).T
preds.columns = ["tree1", "tree2", "tree3"]

# 使用优先级规则 
final_prediction = np.array([np.round((predictions_1[i] + predictions_2[i] + predictions_3[i])/3) for i in range(len(predictions_1))])
preds = pd.DataFrame([predictions_1, predictions_2, predictions_3, final_prediction, y_test]).T.head(20)
preds.columns = ["tree1", "tree2", "tree3", "final", "label"]

当我运行这段代码时,我发现我的决策树开始预测不同的事情,这表明我们已经删除了树之间的许多相关性。

머신러닝 랜덤 포레스트 알고리즘의 실제 분석

我的测试结果树之间不再总是彼此保持一致了

决策树基础

到目前为止,我们已经剖析了数据是如何被送入大量决策树的。在前面的代码示例中,我们使用DecisionTreeClassifier函数来训练决策树,但为了完全理解随机森林,我们需要先来解释一下什么是决策树。

一棵名副其实的决策树看起来像一棵倒挂的树。从一种高级别角度上看,该算法试图提出问题,并将数据分割成不同的节点。下图显示了决策树的形象示意。

머신러닝 랜덤 포레스트 알고리즘의 실제 분석

决策树示例

决策树根据前一个问题的答案提出一系列问题。对于它提出的每一个问题,可能都有多个答案,我们不妨可以将其想象为分割节点。上一个问题的答案将决定树将询问的下一个问题。在询问了一系列问题之后的某个时刻,你得到了答案。

但是你怎么知道你的答案是准确的,或者你询问了正确的问题呢?实际上,您可以用几种不同的方法来评估决策树,我们当然也会对这些方法加以解释。

熵与信息增益

介绍到现在,我们需要讨论一个叫做熵(entropy)的新术语。从一种高角度来看,熵是衡量节点中杂质或随机性水平的一种方法。顺便说一句,还有另一种流行的方法来测量节点的杂质,称为基尼系数(Gini impurity),但我们不会在本文中解析该方法,因为它与许多关于熵的概念重叠,尽管计算略有不同。一般的想法是,熵或基尼系数越高,节点中的方差越大,我们的目标是减少这种不确定性。

决策树试图通过将所询问的节点拆分为更小、更同质的节点来最小化熵。熵的实际公式是:

머신러닝 랜덤 포레스트 알고리즘의 실제 분석

为了进一步解释熵的概念,让我们回到那个弹珠的例子:

假设我有10个弹珠。其中5个是蓝色的,5个是绿色的。我的总体数据集的熵为1.0,那么计算熵的代码如下:

from collections import Counter
from math import log2

#我的预测分类为:0或者1。其中,0代表蓝色弹珠,1代表是绿色弹珠。
data = [0, 0, 0, 1, 1, 1, 1, 0, 1, 0]
# 获取标签的长度
len_labels = len(data)
def calculate_entropy(data, len_labels):
# 对每一种分类进行计数
counts = Counter(labels)
# 我们计算分数,这个例子的输出应该是[.5,.5]
probs = [count / num_labels for count in counts.values()]
# 实际熵计算
return - sum(p * log2(p) for p in probs)

calculate_entropy(labels, num_labels)

如果数据完全充满绿色弹珠,熵将为0,并且熵将随着我们接近50%的分割而增加。

每次减少熵,我们都会获得一些关于数据集的信息,因为我们减少了随机性。信息增益告诉我们哪个特征相对来说最能让我们最小化熵。计算信息增益的方法是:

entropy(parent) — [weighted_average_of_entropy(children)]

在这种情况下,父节点是原始节点,子节点是拆分节点的结果。

머신러닝 랜덤 포레스트 알고리즘의 실제 분석

拆分一个节点

为了计算信息增益,我们执行以下操作:

  • 计算父节点的熵
  • 将父节点拆分为子节点
  • 为每个子节点创建权重。这是通过number_of_samples_in_child_node/number_of_ssamples_in_parent_node测量的
  • 计算每个子节点的熵
  • 通过计算weight*entropy_of_child1+weight*entropy_of_child2创建[weighted_average_of_entropy(children)]
  • 从父节点的熵中减去此加权熵

下面的代码实现了将父节点拆分为两个子节点的简单信息增益:

def information_gain(left_labels, right_labels, parent_entropy):
"""计算拆分的信息增益"""
#计算左侧节点的权重
proportion_left_node = float(len(left_labels)) / (len(left_labels) + len(right_labels))
#计算右节点的权重
proportion_right_node = 1 - proportion_left_node
# 计算子节点的加权平均值
weighted_average_of_child_nodes = ((proportion_left_node * entropy(left_labels)) + (proportion_right_node * entropy(right_labels)))
#返回父节点熵——子节点的加权熵
return parent_entropy - weighted_average_of_child_nodes

决策树详解

考虑到上述这些概念,我们现在已经准备好实现一棵小型决策树了!

在没有任何指导的情况下,决策树将继续拆分节点,直到所有最终的叶节点都是纯的。控制树的复杂性的想法被称为修剪(pruning),我们可以在树完全建成后修剪它,也可以在生长阶段之前使用特定参数对树进行预修剪。预修剪树复杂度的一些方法是控制拆分的数量、限制最大深度(从根节点到叶节点的最长距离)或设置信息增益。

以下代码将所有这些概念联系在一起:

  • 从一个数据集开始,其中有一个要预测的目标变量
  • 计算原始数据集(根节点)的熵(或基尼系数)
  • 查看每个特征并计算信息增益
  • 选择具有最佳信息增益的最佳特征,这与导致熵降低最多的特征相同

保持增长,直到满足停止条件——在这种情况下,这是我们的最大深度限制,节点的熵为0。

import pandas as pd
import numpy as np
from math import log2

def entropy(data, target_col):
# calculate the entropy of the entire dataset
values, counts = np.unique(data[target_col], return_counts=True)
entropy = np.sum([-count/len(data) * log2(count/len(data)) for count in counts])
return entropy

def compute_information_gain(data, feature, target_col):
parent_entropy = entropy(data, target_col)
# 计算在给定特征上拆分的信息增益
split_values = np.unique(data[feature])
# initialize at 0
weighted_child_entropy = 0
# 计算加权熵,记住这与新节点中的点数有关
for value in split_values:
sub_data = data[data[feature] == value]
node_weight = len(sub_data)/len(data)
weighted_child_entropy += node_weight * entropy(sub_data, target_col)
#与之前相同的计算,我们只是从父节点熵中减去加权熵 
return parent_entropy - weighted_child_entropy

def grow_tree(data, features, target_col, depth=0, max_depth=3):
# 我们将最大深度设置为3以“预修剪”或限制树的复杂性
if depth >= max_depth or len(np.unique(data[target_col])) == 1:
# 如果达到最大深度或所有标签都相同,则停止生长树。所有标签相同意味着熵为0
return np.unique(data[target_col])[0]
# 我们根据信息增益计算最佳特征(或最佳问题)
node = {}
gains = [compute_information_gain(data, feature, target_col) for feature in features]
best_feature = features[np.argmax(gains)]

for value in np.unique(data[best_feature]):
sub_data = data[data[best_feature] == value]
node[value] = grow_tree(sub_data, features, target_col, depth+1, max_depth)

return node


# 模拟一些数据并制作一个数据帧,注意我们是如何建立一个目标的
data = {
'A': [1, 2, 1, 2, 1, 2, 1, 2],
'B': [3, 3, 4, 4, 3, 3, 4, 4],
'C': [5, 5, 5, 5, 6, 6, 6, 6],
'target': [0, 0, 0, 1, 1, 1, 1, 0]
}
df = pd.DataFrame(data)

# 定义我们的特征和标签
features = ["A", "B", "C"]
target_col = "target"

# 成长树
tree = grow_tree(df, features, target_col, max_depth=3)
print(tree)

预测这棵树意味着,用新数据遍历生长的树,直到它到达叶节点。最后一个叶节点是预测。

关于随机森林的一些有趣的事情

我们在上一节中讨论的所有内容都是有关单棵决策树如何做出决策。下图将这些概念与我们之前讨论的随机森林采样概念联系起来。

머신러닝 랜덤 포레스트 알고리즘의 실제 분석

具有解构决策树的随机森林架构

因为决策树实际上检查每个特征的信息增益,所以您可以计算随机森林中的特征重要性。特征重要性的计算通常被视为所有树中杂质的平均减少。随机森林不像Logistic回归模型那样可解释,因此特征重要性为我们提供了一点关于树如何生长的知识。

最后,有几种方法可以测试你训练过的随机森林。您可以始终使用经典的机器学习方法,并使用测试集来衡量模型对未知数据的概括程度。然而,这通常需要第二次计算。随机森林有一个独特的属性,称为袋外错误或OOB错误。还记得我们如何仅对数据集的一部分进行采样以构建每个树吗?

实际上,您可以在训练时使用其余的样本来进行验证,这实际上只有在算法存在集成特性的情况下才是可能的。这意味着,在一次试验中,我们就可以了解我们的模型如何很好地推广到未知数据。

总结

总结一下,我们在本文中所学到的内容:

  • 随机森林实际上是一组不相关的决策树,它们做出预测并达成共识。这种共识是回归问题的平均分数和分类问题的优先级规则。
  • 随机森林通过利用装袋算法和特征采样减轻相关性。通过利用这两种技术,单棵决策树可以查看我们集合的特定维度,并根据不同的因素进行预测。
  • 决策树是通过在产生最高信息增益的特征上分割数据来生长的。信息增益被测量为杂质的最高减少。杂质通常通过熵或基尼系统来测量。
  • 随机森林能够通过特征重要性实现有限程度的可解释性,这是特征的平均信息增益的度量。
  • 随机森林也有能力在训练时进行交叉验证,这是一种被称为OOB错误的独特技术。这是可能的,得益于算法对上游数据进行采样的方式。
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(df.drop('target', axis=1), df['target'], test_size=0.2, random_state=0)

# 训练和评分随机森林
simple_rf_model = RandomForestClassifier(n_estimators=100, random_state=0)
simple_rf_model.fit(X_train, y_train)
print(f"accuracy: {simple_rf_model.score(X_test, y_test)}")

# accuracy: 0.93

当查看训练随机森林的原始代码时,这几行代码中发生了多少不同的计算和评估,这让我感到惊讶。为了防止过度拟合,在树木和森林层面上进行评估,并实现一些基本的可解释性,需要考虑很多因素,此外,由于现有的所有框架,很容易进行设置。

我希望下次你训练随机森林模型时,你能够查看随机森林的​​scikit学习文档页面​​,并更好地了解你的所有选项。虽然有一些直观的默认设置,但应该清楚您可以进行多少不同的调整,以及这些技术中有多少可以扩展到其他模型。

我在写这篇文章时很开心,并且亲自了解了很多关于这个漂亮算法的工作原理。我希望你也能从中学习到一些东西!

译者介绍

朱先忠,51CTO社区编辑,51CTO专家博客、讲师,潍坊一所高校计算机教师,自由编程界老兵一枚。

原文标题:Demystifying the Random Forest,作者:Siddarth Ramesh

위 내용은 머신러닝 랜덤 포레스트 알고리즘의 실제 분석의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

성명:
이 기사는 51cto.com에서 복제됩니다. 침해가 있는 경우 admin@php.cn으로 문의하시기 바랍니다. 삭제