English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
서론
랜덤 포레스트를 통해 데이터의 주요 특성을 얻고자 하는 것입니다
1이론
랜덤 포레스트는 매우 유연한 기계 학습 방법으로, 광범위한 응용 전망을 가지고 있습니다. 마케팅에서 보건 보험에 이르기까지 다양하게 사용될 수 있습니다. 마케팅 시뮬레이션 모델링, 고객 원천 통계, 유지 및 이탈을 예측할 수 있습니다. 또한, 질병의 위험과 환자의 감염성을 예측할 수 있습니다;
개별 학습 기계의 생성 방식에 따라, 현재의 집합 학습 방법은 크게 두 가지로 나눌 수 있습니다. 즉, 개별 학습 기계 간에 강한 의존 관계가 있어 순차적으로 생성해야 하는 시리얼화 방법과, 개별 학습 기계 간에 강한 의존 관계가 없어 동시에 생성할 수 있는 병행화 방법입니다;
전자의 대표는 Boosting이고, 후자의 대표는 Bagging과 '랜덤 포레스트'(Random}
Forest)
랜덤 포레스트는 결정 나무를 기반으로 한 Bagging 통합을 구축한 후, 결정 나무의 훈련 과정에서 무작위 특성 선택(즉, 무작위 특성 선택을 도입했습니다).
간단히 말해서, 랜덤 포레스트는 결정 나무의 통합입니다. 하지만 두 가지 차이점이 있습니다:
(2) 특징 선택의 차이: 각 결정 나무의 n개 분류 특징은 모든 특징 중 무작위로 선택됩니다(n은 우리가 조정해야 하는 매개변수입니다).
랜덤 포레스트는 간단히 이해하면, 예를 들어 salary를 예측하면, decision tree를 여러 개 생성하여 job, age, house를 예측하고, 예측할 값을 각 특징(teacher,39，suburb) 각각은 해당 결정 나무의 목표 값 확률(salary<5000,salary>=5000)，그래서 예측량의 발생 확률을 결정합니다(예, P(salary<5000)=0.3)
랜덤 포레스트는 회귀와 분류를 할 수 있는 도구입니다.大数据를 처리할 수 있는 특성을 가지고 있으며, 추정이나 변수가 매우 중요한 기본 데이터 모델링에 유용합니다.
매개변수 설명:
가장 중요한 두 가지 매개변수는 n_estimators와 max_features입니다.
n_estimators: 포레스트에서 나무의 개수를 나타냅니다. 이론적으로는 더 많을수록 좋습니다. 하지만 그에 따라 계산 시간이 늘어납니다. 하지만 더 많이 하면 좋지 않습니다. 예측 성능이 가장 좋은 것은 적절한 나무 개수에서 나타납니다.
max_features: 특징 집합의 부분 집합을 무작위로 선택하여 노드를 분할합니다. 부분 집합의 개수가 적을수록, 변동성이 빠르게 줄어들지만, 동시에 편차가 빠르게 증가합니다. 좋은 경험에 따르면. 귀환 문제이면:
max_features=n_features, 분류 문제이면 max_features=sqrt(n_features).
좋은 결과를 얻기 위해, max_depth=None, 그리고 min_sample_split을 기억해야 합니다.1.
그리고 cross_validated(교차 검증)을 기억하면서, 랜덤 포레스트에서 bootstrap=True. 하지만 extra-trees에서 bootstrap=False.
2、랜덤 포레스트 파이썬 구현
2.1Demo1
랜덤 포레스트 기본 기능 구현
#정수나무
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
import numpy as np
from sklearn.datasets import load_iris
iris=load_iris()
#print iris#iris의 4개 속성은: 꽃잎 너비 꽃잎 길이 꽃잎 너비 꽃잎 길이 레이블은 꽃의 종류: setosa versicolour virginica
print(iris['target'].shape)
rf=RandomForestRegressor()# 여기서는 기본 파라미터 설정을 사용
rf.fit(iris.data[:150],iris.target[:150])# 모델 훈련을 위해 사용
# 랜덤으로 두 개의 예측이 다른 샘플을 선택
instance=iris.data[[100,109]
print(instance)
rf.predict(instance[[0]])
print('인스턴스 0 예측;',rf.predict(instance[[0]]))
print( '인스턴스 1 예측;',rf.predict(instance[[1]))
print(iris.target[100], iris.target[109)]
실행 결과
(150,)
[[ 6.3 3.3 6. 2.5]
[ 7.2 3.6 6.1 2.5]
인스턴스 0 예측; [ 2]
인스턴스 1 예측; [ 2]
2 2
2.2 Demo2
3이 방법의 비교
# random forest test from sklearn.model_selection import cross_val_score from sklearn.datasets import make_blobs from sklearn.ensemble import RandomForestClassifier from sklearn.ensemble import ExtraTreesClassifier from sklearn.tree import DecisionTreeClassifier X, y = make_blobs(n_samples=10000, n_features=10, centers=100, random_state=0) clf = DecisionTreeClassifier(max_depth=None, min_samples_split=2, random_state=0) scores = cross_val_score(clf, X, y) print(scores.mean()) clf = RandomForestClassifier(n_estimators=10, 최대 깊이=None, min_samples_split=2, random_state=0) scores = cross_val_score(clf, X, y) print(scores.mean()) clf = ExtraTreesClassifier(n_estimators=10, 최대 깊이=None, min_samples_split=2, random_state=0) scores = cross_val_score(clf, X, y) print(scores.mean())
실행 결과:
0.979408793821
0.999607843137
0.999898989899
2.3 Demo3-특성 선택 구현
#정수나무2
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
import numpy as np
from sklearn.datasets import load_iris
iris=load_iris()
from sklearn.model_selection import cross_val_score, ShuffleSplit
X = iris["data"]
Y = iris["target"]
names = iris["feature_names"]
rf = RandomForestRegressor()
scores = []
for i in range(X.shape[1]:
score = cross_val_score(rf, X[:, i:i+1], Y, scoring="r2",
cv=ShuffleSplit(len(X), 3, .3))
scores.append((round(np.mean(score), 3), names[i]))
print(sorted(scores, reverse=True))
실행 결과:
[(0.89300000000000002, 'petal 너비 (cm)'), (0.82099999999999995, 'petal 길이
(cm)'), (0.13, 'sepال 길이 (cm)'), (-0.79100000000000004, 'sepال عرض (cm)')]
2.4 demo4-정수나무
본래 이 코드를 사용하여 랜덤 포레스트 결정 트리를 구축하려 했지만, 문제는 프로그램이 계속 실행되고, 응답하지 않으며, 디버깅이 필요합니다.
#정수나무4
#coding:utf-8
import csv
from random import seed
from random import randrange
from math import sqrt
def loadCSV(filename):#데이터를 로드하고, 행별로 목록에 저장
dataSet = []
with open(filename, 'r') as file:
csvReader = csv.reader(file)
for line in csvReader:
dataSet.append(line)
return dataSet
# 레이블 열을 제외한 다른 열을 float 타입으로 변환합니다.
def column_to_float(dataSet):
featLen = len(dataSet[0]) - 1
for data in dataSet:
for column in range(featLen):
data[column] = float(data[column].strip())
# 데이터셋을 무작위로 N개의 블록으로 나누어, 교차��정을 용이하게 합니다. 하나는 테스트 셋이고, 나머지 네 개는 훈련 셋입니다.
def spiltDataSet(dataSet, n_folds):
fold_size = int(len(dataSet) / n_folds)
dataSet_copy = list(dataSet)
dataSet_spilt = []
for i in range(n_folds):
fold = []
while len(fold) < fold_size: # 여기서 if는 첫 번째 조건을 확인하는 데만 사용됩니다. while은 조건이 성립하지 않을 때까지 반복합니다.
index = randrange(len(dataSet_copy))
fold.append(dataSet_copy.pop(index)) # pop() 함수는 목록에서 하나의 요소를 제거하고 그 값을 반환합니다.
dataSet_spilt.append(fold)
return dataSet_spilt
# 데이터셋 서브샘플 생성
def get_subsample(dataSet, ratio):
subdataSet = []
lenSubdata = round(len(dataSet) * ratio)# float 값을 반환
while len(subdataSet) < lenSubdata:
index = randrange(len(dataSet) - 1)
subdataSet.append(dataSet[index])
# print len(subdataSet)
return subdataSet
# 데이터셋 분할
def data_spilt(dataSet, index, value):
left = []
right = []
for row in dataSet:
if row[index] < value:
left.append(row)
else:
right.append(row)
return left, right
# 计算分割代价
def spilt_loss(left, right, class_values):
loss = 0.0
for class_value in class_values:
left_size = len(left)
if left_size != 0: # 防止除数为零
prop = [row[-1] for row in left].count(class_value) / float(left_size)
loss += (prop * (1.0 - prop))
right_size = len(right)
if right_size != 0:
prop = [row[-1] for row in right].count(class_value) / float(right_size)
loss += (prop * (1.0 - prop))
return loss
# 选取任意的n个特征，在这n个特征中，选取分割时的最优特征
def get_best_spilt(dataSet, n_features):
features = []
class_values = list(set(row[-1] for row in dataSet))
b_index, b_value, b_loss, b_left, b_right = 999, 999, 999, None, None
while len(features) < n_features:
index = randrange(len(dataSet[0])) - 1)
if index not in features:
features.append(index)
# print 'features:', features
for index in features: # 找到列的最适合做节点的索引，（损失最小）
for row in dataSet:
left, right = data_spilt(dataSet, index, row[index]) # 以它为节点的，左右分支
loss = spilt_loss(left, right, class_values)
if loss < b_loss: # 寻找最小分割代价
b_index, b_value, b_loss, b_left, b_right = index, row[index], loss, left, right
# print b_loss
# print type(b_index)
return {'index': b_index, 'value': b_value, 'left': b_left, 'right': b_right}
# 출력 레이블 결정
def decide_label(data):
output = [row[-1] for row in data]
return max(set(output), key=output.count)
# 자식 분할, 지속적으로 단말 노드를 구축하는 과정
def sub_spilt(root, n_features, max_depth, min_size, depth):
left = root['left']
# print left
right = root['right']
del (root['left'])
del (root['right'])
# print depth
if not left or not right:
root['left'] = root['right'] = decide_label(left + right)
# print 'testing'
return
if depth > max_depth:
root['left'] = decide_label(left)
root['right'] = decide_label(right)
return
if len(left) < min_size:
root['left'] = decide_label(left)
else:
root['left'] = get_best_spilt(left, n_features)
# print 'testing_left'
sub_spilt(root['left'], n_features, max_depth, min_size, depth + 1)
if len(right) < min_size:
root['right'] = decide_label(right)
else:
root['right'] = get_best_spilt(right, n_features)
# print 'testing_right'
sub_spilt(root['right'], n_features, max_depth, min_size, depth + 1)
# 구조화 결정 트리
def build_tree(dataSet, n_features, max_depth, min_size):
root = get_best_spilt(dataSet, n_features)
sub_spilt(root, n_features, max_depth, min_size, 1)
return root
# 预测测试集结果
def predict(tree, row):
predictions = []
if row[tree['index']] < tree['value']:
if isinstance(tree['left'], dict):
return predict(tree['left'], row)
else:
return tree['left']
else:
if isinstance(tree['right'], dict):
return predict(tree['right'], row)
else:
return tree['right']
# predictions=set(predictions)
def bagging_predict(trees, row):
predictions = [predict(tree, row) for tree in trees]
return max(set(predictions), key=predictions.count)
# 创建随机森林
def random_forest(train, test, ratio, n_feature, max_depth, min_size, n_trees):
trees = []
for i in range(n_trees):
train = get_subsample(train, ratio)#从切割的数据集中选取子集
tree = build_tree(train, n_features, max_depth, min_size)
# print 'tree %d: '%i,tree
trees.append(tree)
# predict_values = [predict(trees,row) for row in test]
predict_values = [bagging_predict(trees, row) for row in test]
return predict_values
# 정확도 계산
def accuracy(predict_values, actual):
correct = 0
for i in range(len(actual)):
if actual[i] == predict_values[i]:
correct += 1
return correct / float(len(actual))
if __name__ == '__main__':
seed(1)
dataSet = loadCSV(r'G:\0석학생\tianchiCompetition\훈련 소样本2.csv')
column_to_float(dataSet)
n_folds = 5
max_depth = 15
min_size = 1
ratio = 1.0
# n_features=sqrt(len(dataSet)-1)
n_features = 15
n_trees = 10
folds = spiltDataSet(dataSet, n_folds)# 데이터셋을 먼저 분할
scores = []
for fold in folds:
train_set = folds[
:] # 여기서 train_set=folds를 간단히 사용할 수 없습니다. 이렇게 사용하면 train_set의 값이 변경되면 folds의 값도 변경됩니다. 따라서 복사 형식을 사용해야 합니다. (L[:])는 시리즈를 복사하고, D.copy()는 딕셔너리를 복사하고, list는 복사를 생성합니다.
train_set.remove(fold)# 훈련 데이터 선택
# print len(folds)
train_set = sum(train_set, []) # 여러 fold 리스트를 하나의 train_set 리스트로 결합
# print len(train_set)
test_set = []
for row in fold:
row_copy = list(row)
row_copy[-1] = None
test_set.append(row_copy)
# for row in test_set:
# print row[-1]
actual = [row[-1for row in fold]
predict_values = random_forest(train_set, test_set, ratio, n_features, max_depth, min_size, n_trees)
accur = accuracy(predict_values, actual)
scores.append(accur)
print('트리 수 %d' % n_trees)
print('점수:%s' % scores)
print('평균 점수:%s' % (sum(scores)) / float(len(scores)))
2.5 랜덤 포레스트 분류 sonic 데이터
# CART on the Bank Note dataset
from random import seed
from random import randrange
from csv import reader
# CSV 파일 로드
def load_csv(filename):
file = open(filename, "r")
lines = reader(file)
dataset = list(lines)
return dataset
# 문자열 열을 부호 float로 변환
def str_column_to_float(dataset, column):
for row in dataset:
row[column] = float(row[column].strip())
# 데이터 세트를 k개의 부분으로 분할합니다
def cross_validation_split(dataset, n_folds):
dataset_split = list()
dataset_copy = list(dataset)
fold_size = int(len(dataset) / n_folds)
for i in range(n_folds):
fold = list()
while len(fold) < fold_size:
index = randrange(len(dataset_copy))
fold.append(dataset_copy.pop(index))
dataset_split.append(fold)
return dataset_split
# 정확도 퍼센트 계산
def accuracy_metric(actual, predicted):
correct = 0
for i in range(len(actual)):
if actual[i] == predicted[i]:
correct += 1
return correct / float(len(actual)) * 100.0
# 결정 트리 알고리즘을 교차��분으로 평가합니다
def evaluate_algorithm(dataset, algorithm, n_folds, *args):
folds = cross_validation_split(dataset, n_folds)
scores = list()
for fold in folds:
train_set = list(folds)
train_set.remove(fold)
train_set = sum(train_set, [])
test_set = list()
for row in fold:
row_copy = list(row)
test_set.append(row_copy)
row_copy[-1] = None
predicted = algorithm(train_set, test_set, *args)
actual = [row[-1for row in fold]
accuracy = accuracy_metric(actual, predicted)
scores.append(accuracy)
return scores
# 데이터 세트를 특정 속성과 속성 값에 따라 분할합니다
def test_split(index, value, dataset):
left, right = list(), list()
for row in dataset:
if row[index] < value:
left.append(row)
else:
right.append(row)
return left, right
# Calculate the Gini index for a split dataset
def gini_index(groups, class_values):
gini = 0.0
for class_value in class_values:
for group in groups:
size = len(group)
if size == 0:
continue
proportion = [row[-1] for row in group].count(class_value) / float(size)
gini += (proportion * (1.0 - proportion))
return gini
# Select the best split point for a dataset
def get_split(dataset):
class_values = list(set(row[-1] for row in dataset))
b_index, b_value, b_score, b_groups = 999, 999, 999, None
for index in range(len(dataset[0]))-1)
for row in dataset:
groups = test_split(index, row[index], dataset)
gini = gini_index(groups, class_values)
if gini < b_score:
b_index, b_value, b_score, b_groups = index, row[index], gini, groups
print ({'index':b_index, 'value':b_value})
return {'index':b_index, 'value':b_value, 'groups':b_groups}
# Create a terminal node value
def to_terminal(group):
outcomes = [row[-1] for row in group]
return max(set(outcomes), key=outcomes.count)
# Create child splits for a node or make terminal
def split(node, max_depth, min_size, depth):
left, right = node['groups']
del(node['groups'])
# check for a no split
if not left or not right:
node['left'] = node['right'] = to_terminal(left + right)
return
# check for max depth
if depth >= max_depth:
node['left'], node['right'] = to_terminal(left), to_terminal(right)
return
# process left child
if len(left) <= min_size:
node['left'] = to_terminal(left)
else:
node['left'] = get_split(left)
split(node['left'], max_depth, min_size, depth)+1)
# process right child
if len(right) <= min_size:
node['right'] = to_terminal(right)
else:
node['right'] = get_split(right)
split(node['right'], max_depth, min_size, depth)+1)
# 결정 트리를 만듭니다
def build_tree(train, max_depth, min_size):
root = get_split(train)
split(root, max_depth, min_size, 1)
return root
# 결정 트리로 예측을 합니다
def predict(node, row):
if row[node['index']] < node['value']:
if isinstance(node['left'], dict):
return predict(node['left'], row)
else:
return node['left']
else:
if isinstance(node['right'], dict):
return predict(node['right'], row)
else:
return node['right']
# Classification and Regression Tree Algorithm
def decision_tree(train, test, max_depth, min_size):
tree = build_tree(train, max_depth, min_size)
predictions = list()
for row in test:
prediction = predict(tree, row)
predictions.append(prediction)
return(predictions)
# Test CART on Bank Note dataset
seed(1)
# load and prepare data
filename = r'G:\0pythonstudy\결정트리\sonar.all-data.csv'
dataset = load_csv(filename)
# 문자열 특성을 정수로 변환
for i in range(len(dataset[0]))-1)
str_column_to_float(dataset, i)
# evaluate algorithm
n_folds = 5
max_depth = 5
min_size = 10
scores = evaluate_algorithm(dataset, decision_tree, n_folds, max_depth, min_size)
print('점수: %s' % scores)
print('평균 정확도: %.3f%%' % (sum(scores)/float(len(scores)))
실행 결과:
{'index': 38, 'value': 0.0894}
{'index': 36, 'value': 0.8459}
{'index': 50, 'value': 0.0024}
{'index': 15, 'value': 0.0906}
{'index': 16, 'value': 0.9819}
{'index': 10, 'value': 0.0785}
{'index': 16, 'value': 0.0886}
{'index': 38, 'value': 0.0621}
{'index': 5, 'value': 0.0226}
{'index': 8, 'value': 0.0368}
{'index': 11, 'value': 0.0754}
{'index': 0, 'value': 0.0239}
{'index': 8, 'value': 0.0368}
{'index': 29, 'value': 0.1671}
{'index': 46, 'value': 0.0237}
{'index': 38, 'value': 0.0621}
{'index': 14, 'value': 0.0668}
{'index': 4, 'value': 0.0167}
{'index': 37, 'value': 0.0836}
{'index': 12, 'value': 0.0616}
{'index': 7, 'value': 0.0333}
{'index': 33, 'value': 0.8741}
{'index': 16, 'value': 0.0886}
{'index': 8, 'value': 0.0368}
{'index': 33, 'value': 0.0798}
{'index': 44, 'value': 0.0298}
점수: [48.78048780487805, 70.73170731707317, 58.536585365853654, 51.2195121951
2195, 39.02439024390244]
평균 정확도: 53.659%
어떤 키든 누르세요. . .
지식:
1.CSV 파일 로드
from csv import reader # CSV 파일 로드 def load_csv(filename): file = open(filename, "r") lines = reader(file) dataset = list(lines) return dataset filename = r'G:\0pythonstudy\결정트리\sonar.all-data.csv' dataset=load_csv(filename) print(dataset)
2.데이터를 float 형식으로 변환
# 문자열 열을 부호 float로 변환 def str_column_to_float(dataset, column): for row in dataset: row[column] = float(row[column].strip()) # print(row[column]) # 문자열 특성을 정수로 변환 for i in range(len(dataset[0]))-1) str_column_to_float(dataset, i)
3.마지막 열의 분류 문자열을 0,1integer
def str_column_to_int(dataset, column): class_values = [row[column] for row in dataset]#class 레이블의 리스트 생성 # print(class_values) unique = set(class_values)#set으로 다른 요소를 얻다 print(unique) lookup = dict()#정의하다 # print(enumerate(unique)) for i, value in enumerate(unique): lookup[value] = i # print(lookup) for row in dataset: row[column] = lookup[row[column]] print(lookup['M'])
4、데이터 세트를 K개로 분할합니다
# 데이터 세트를 k개의 부분으로 분할합니다 def cross_validation_split(dataset, n_folds): dataset_split = list()# 빈 리스트 생성 dataset_copy = list(dataset) print(len(dataset_copy)) print(len(dataset)) #print(dataset_copy) fold_size = int(len(dataset) / n_folds) for i in range(n_folds): fold = list() while len(fold) < fold_size: index = randrange(len(dataset_copy)) # print(index) fold.append(dataset_copy.pop(index))# .pop()를 사용하여 요소를 모두 제거합니다(이동하는 것과 같습니다)，이 k개의 요소가 모두 다릅니다 dataset_split.append(fold) return dataset_split n_folds=5 folds = cross_validation_split(dataset, n_folds)# k개의 요소가 모두 다른 훈련 세트로 분할됩니다
5. 정확률 계산
# 정확도 퍼센트 계산 def accuracy_metric(actual, predicted): correct = 0 for i in range(len(actual)): if actual[i] == predicted[i]: correct += 1 return correct / float(len(actual)) * 100.0# 이는 이분 분류 정확성의 표현식입니다
6. 이는 이분 분류의 각 열입니다
# 데이터 세트를 특정 속성과 속성 값에 따라 분할합니다 def test_split(index, value, dataset): left, right = list(), list()#초기화 두개의 비어 있는 리스트 for row in dataset: if row[index] < value: left.append(row) else: right.append(row) return left, right #두 개의 리스트를 반환하여 각 행(index)를 value로 구분하여 두분류로 나눔.
7.사용gini 계수를 최적 분할점을 얻기 위해
# Calculate the Gini index for a split dataset
def gini_index(groups, class_values):
gini = 0.0
for class_value in class_values:
for group in groups:
size = len(group)
if size == 0:
continue
proportion = [row[-1] for row in group].count(class_value) / float(size)
gini += (proportion * (1.0 - proportion))
return gini
# Select the best split point for a dataset
def get_split(dataset):
class_values = list(set(row[-1] for row in dataset))
b_index, b_value, b_score, b_groups = 999, 999, 999, None
for index in range(len(dataset[0]))-1)
for row in dataset:
groups = test_split(index, row[index], dataset)
gini = gini_index(groups, class_values)
if gini < b_score:
b_index, b_value, b_score, b_groups = index, row[index], gini, groups
# print(groups)
print ({'index':b_index, 'value':b_value,'score':gini})
return {'index':b_index, 'value':b_value, 'groups':b_groups}
이 코드는 gini 지수를 구하는 데 정의식을 직접 적용하여 이해하기 쉽습니다. 최적의 분할점을 이해하는 것은 어려울 수 있습니다. 여기서는 두 계층의 반복을 사용하며, 하나는 열에 대한 반복이고 다른 하나는 행에 대한 반복입니다. 그리고 각 반복마다 gini 계수를 갱신합니다.
8、결정树叶生成
# Create child splits for a node or make terminal def split(node, max_depth, min_size, depth): left, right = node['groups'] del(node['groups']) # check for a no split if not left or not right: node['left'] = node['right'] = to_terminal(left + right) return # check for max depth if depth >= max_depth: node['left'], node['right'] = to_terminal(left), to_terminal(right) return # process left child if len(left) <= min_size: node['left'] = to_terminal(left) else: node['left'] = get_split(left) split(node['left'], max_depth, min_size, depth)+1) # process right child if len(right) <= min_size: node['right'] = to_terminal(right) else: node['right'] = get_split(right) split(node['right'], max_depth, min_size, depth)+1)
여기서는 재귀 프로그래밍을 사용하여 지속적으로 좌 분할 트리와 우 분할 트리를 생성합니다
9.결정 트리 구축
# 결정 트리를 만듭니다 def build_tree(train, max_depth, min_size): root = get_split(train) split(root, max_depth, min_size, 1) return root tree=build_tree(train_set, max_depth, min_size) print(tree)
10、테스트 셋 예측
# 결정 트리를 만듭니다 def build_tree(train, max_depth, min_size): root = get_split(train)#최良 분할점, 인덱스 값, 그룹을 얻습니다 split(root, max_depth, min_size, 1) return root # tree=build_tree(train_set, max_depth, min_size) # print(tree) # 결정 트리로 예측을 합니다 def predict(node, row): print(row[node['index']]) print(node['value']) if row[node['index']] < node['value']:#테스트 셋을 사용하여 훈련된 최良 분할점을 대입, 분할점에 편차가 있을 때는 좌우 분할 트리를 통해 추가 비교 if isinstance(node['left'], dict):#如果是字典类型，执行操作 return predict(node['left'], row) else: return node['left'] else: if isinstance(node['right'], dict): return predict(node['right'], row) else: return node['right'] tree = build_tree(train_set, max_depth, min_size) predictions = list() for row in test_set: prediction = predict(tree, row) predictions.append(prediction)
11.결정 트리 평가
# 결정 트리 알고리즘을 교차��분으로 평가합니다 def evaluate_algorithm(dataset, algorithm, n_folds, *args): folds = cross_validation_split(dataset, n_folds) scores = list() for fold in folds: train_set = list(folds) train_set.remove(fold) train_set = sum(train_set, []) test_set = list() for row in fold: row_copy = list(row) test_set.append(row_copy) row_copy[-1] = None predicted = algorithm(train_set, test_set, *args) actual = [row[-1for row in fold] accuracy = accuracy_metric(actual, predicted) scores.append(accuracy) return scores
이것이 본 문서의 전체 내용입니다. 여러분의 학습에 도움이 되길 바라며, 많은 지원과 격려를 부탁드립니다.
선언: 본 내용은 인터넷에서 가져왔으며, 저작권자는 모두 소유합니다. 내용은 인터넷 사용자가 자발적으로 기여하고 업로드한 것이며, 이 사이트는 소유권을 가지지 않으며, 인공적인 편집을 하지 않았으며, 관련 법적 책임도 부담하지 않습니다. 저작권 침해가 의심되는 내용을 발견하면 notice#w로 이메일을 보내 주시기 바랍니다.3codebox.com（보고할 때는 #을 @으로 변경하십시오.）를 통해 신고하시고 관련 증거를 제공하시면, 실제로 확인되면 해당 사이트는 즉시 저작권 침해 내용을 삭제할 것입니다.