English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Introduzione
Vuoi ottenere le caratteristiche principali dei dati attraverso il bosco casuale
1, Teoria
Il bosco casuale è un metodo di machine learning altamente flessibile con un ampio potenziale di applicazione, dalla marketing al settore della salute. Può essere utilizzato per modellare simulazioni di marketing, statistica delle fonti dei clienti, conservazione e perdita. Può anche essere utilizzato per prevedere il rischio di malattie e la suscettibilità dei pazienti.
Secondo il modo di generazione degli apprenditori individuali, i metodi di integrazione attuali possono essere大致divisi in due grandi categorie, ovvero i metodi serializzati in cui gli apprenditori individuali hanno una forte dipendenza l'uno dall'altro e devono essere generati in serie, e i metodi paralleli in cui gli apprenditori individuali non hanno una forte dipendenza l'uno dall'altro e possono essere generati contemporaneamente;
Il rappresentante del primo è Boosting, il rappresentante del secondo è Bagging e "bosco casuale" (Random
Forest)
Il bosco casuale, costruito sull'integrazione Bagging basata sugli alberi decisionali come base apprendente, introduce ulteriormente la selezione casuale delle caratteristiche degli alberi decisionali durante il processo di addestramento degli alberi decisionali (cioè introduce la selezione casuale delle caratteristiche).
In parole semplici, il bosco casuale è l'integrazione degli alberi decisionali, ma ci sono due differenze:
(2) La differenza nella selezione delle caratteristiche: ogni albero decisionale seleziona casualmente n caratteristiche tra tutte le caratteristiche (n è un parametro che dobbiamo regolare noi stessi)
随机森林，简单理解， 比如预测salary，就是构建多个决策树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（交叉验证），除此之外记得在random forest中，bootstrap=True。但在extra-trees中，bootstrap=False。
2、随机森林python实现
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的４个属性是：萼片宽度 萼片长度 花瓣宽度 花瓣长度 标签是花的种类：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('instance 0 prediction；',rf.predict(instance[[0]]))
print('instance 1 prediction；',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]]
instance 0 prediction； [ 2.]
instance 1 prediction； [ 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, max_depth=None,min_samples_split=2, random_state=0) scores = cross_val_score(clf, X, y) print(scores.mean()) clf = ExtraTreesClassifier(n_estimators=10, max_depth=None,min_samples_split=2, random_state=0) scores = cross_val_score(clf, X, y) print(scores.mean())
Risultato di esecuzione:
0.979408793821
0.999607843137
0.999898989899
2.3 Demo3-Esecuzione della selezione delle caratteristiche
#Random Forest 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))
Risultato di esecuzione:
[(0.89300000000000002, 'larghezza petalo (cm)'), (0.82099999999999995, 'lunghezza petalo')]
[(0.13, 'lunghezza sepalo (cm)'), (-0.79100000000000004, 'larghezza sepalo (cm)')]
2.4 demo4-Random Forest
Volevo utilizzare il seguente codice per costruire un albero decisionale di Random Forest, ma ho incontrato il problema che il programma continua a eseguire senza rispondere e ha bisogno di essere debuggato.
#Random Forest 4
#coding:utf-8
import csv
from random import seed
from random import randrange
from math import sqrt
def loadCSV(filename):#Carica i dati, inserisce ogni riga in una lista
dataSet = []
with open(filename, 'r') as file:
csvReader = csv.reader(file)
per line in csvReader:
dataSet.append(line)
return dataSet
# convertire tutte le colonne tranne la colonna dei tag in tipo float
def column_to_float(dataSet):
featLen = len(dataSet[0]) - 1
per data in dataSet:
per column in range(featLen):
data[column] = float(data[column].strip())
# dividere il set di dati casualmente in N parti, per facilitare la validazione incrociata, una parte è il set di test, le altre quattro sono set di addestramento
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: # qui non può essere utilizzato if, sebbene if funzioni solo nel primo controllo, while esegue un ciclo fino a che la condizione non è più vera
index = randrange(len(dataSet_copy))
fold.append(dataSet_copy.pop(index)) # la funzione pop() viene utilizzata per rimuovere un elemento dalla lista (di default l'ultimo elemento) e restituire il valore dell'elemento.
dataSet_spilt.append(fold)
return dataSet_spilt
# costruire l'insieme dei dati sottinsieme
def get_subsample(dataSet, ratio):
subdataSet = []
lenSubdata = round(len(dataSet) * ratio)# restituisce un numero floating point
while len(subdataSet) < lenSubdata:
index = randrange(len(dataSet) - 1)
subdataSet.append(dataSet[index])
# stampa la lunghezza di 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)
# stampare 'testing_right'
sub_spilt(root['right'], n_features, max_depth, min_size, depth + 1)
# costruire albero decisionale
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
# prevedere i risultati del set di test
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)
# creare bosco casuale
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)# da selezionare subset dei dati di taglio
tree = build_tree(train, n_features, max_depth, min_size)
# stampare '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
# calcolare l'accuratezza
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_folgi = 5
max_depth = 15
min_size = 1
ratio = 1.0
# n_features=sqrt(len(dataSet)-1)
n_features = 15
n_trees = 10
folds = splitDataSet(dataSet, n_folds)# prima di dividere il set di dati
scores = []
for fold in folds:
train_set = folds[
:] # non può essere utilizzato semplicemente train_set=folds, in questo modo si tratta di una riferimento, quindi quando il valore di train_set cambia, il valore di folds cambia anche, quindi deve essere utilizzato una copia的形式。（L[:]）può copiare la sequenza，D.copy() può copiare il dizionario，list può generare copie list(L)
train_set.remove(fold)# selezionare il set di addestramento
# stampa la lunghezza di folds
train_set = sum(train_set, []) # combinare più liste fold in una lista train_set
# stampa la lunghezza di train_set
test_set = []
for row in fold:
row_copy = list(row)
row_copy[-1] = None
test_set.append(row_copy)
# per riga in test_set:
# stampa l'ultimo elemento della riga
actual = [row[-1] for 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 ('Alberi è %d' % n_trees)
print ('punteggi:%s' % scores)
print ('media del punteggio:%s' % (sum(scores) / float(len(scores))))
2.5 classificazione con foresta randomica dei dati sonic
# CART sul dataset Bank Note
from random import seed
from random import randrange
from csv import reader
# Carica un file CSV
def load_csv(filename):
file = open(filename, "r")
lines = reader(file)
dataset = list(lines)
return dataset
# Converti colonna stringa in float
def str_column_to_float(dataset, column):
for row in dataset:
row[column] = float(row[column].strip())
# Dividere un set di dati in k fogli
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
# Calcolare la percentuale di accuratezza
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
# Valutare un algoritmo utilizzando una divisione di cross-validation
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[-1] for row in fold]
accuracy = accuracy_metric(actual, predicted)
scores.append(accuracy)
return scores
# Dividere un set di dati in base a un attributo e un valore di attributo
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}
# Creare un nodo terminale di valore
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)
# Costruire un albero di decisione
def build_tree(train, max_depth, min_size):
root = get_split(train)
split(root, max_depth, min_size, 1)
return root
# Effettuare una previsione con un albero di decisione
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']
# Algoritmo di albero decisionale di classificazione e regressione
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 sul dataset Bank Note
seed(1)
# caricare e preparare i dati
filename = r'G:\0pythonstudy\albero_di决策\sonar.all-data.csv'
set_di_dati = caricare_csv(nomefile)
# converti attributi stringa in interi
for i in range(len(dataset[0])-1):
str_column_to_float(dataset, i)
# Valutare l'algoritmo
n_folgi = 5
profondita_massima = 5
dimensione_minima = 10
punteggi = valutare_algoritmo(set_di_dati, albero_diDecisione, n_folgi, profondita_massima, dimensione_minima)
print('Punteggi: %s' % punteggi)
print('Media di Accuratezza: %.3f%%' % (somma(punteggi)/float(len(punteggi))))
Risultato di esecuzione:
{'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}
Punteggi: [48.78048780487805, 70.73170731707317, 58.536585365853654, 51.2195121951]
2195, 39.02439024390244]
Precisione media: 53.659%
Premi qualsiasi tasto per continuare. . .
Conoscenza:
1. Carica il file CSV
from csv import reader # Carica un file CSV def load_csv(filename): file = open(filename, "r") lines = reader(file) dataset = list(lines) return dataset filename = r'G:\0pythonstudy\albero_di决策\sonar.all-data.csv' dataset=load_csv(filename) print(dataset)
2. Converti i dati in formato float
# Converti colonna stringa in float def str_column_to_float(dataset, column): for row in dataset: row[column] = float(row[column].strip()) # print(row[column]) # converti attributi stringa in interi for i in range(len(dataset[0])-1): str_column_to_float(dataset, i)
3. Converti la stringa dell'ultima colonna in interi 0, 1
def str_column_to_int(dataset, column): class_values = [row[column] for row in dataset]# genera una lista di etichette di classe # print(class_values) unique = set(class_values)# set ottiene gli elementi diversi della lista print(unique) lookup = dict()# definisci un dizionario # stampa(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. Dividere il set di dati in K parti
# Dividere un set di dati in k fogli def cross_validation_split(dataset, n_folds): dataset_split = list()# Creare una lista vuota 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))# Utilizzare .pop() per rimuovere tutti gli elementi all'interno (equivalente a un trasferimento), in modo che questi k elementi siano diversi dataset_split.append(fold) return dataset_split n_folds=5 folds = cross_validation_split(dataset, n_folds)# Set di addestramento di k elementi diversi
5. Calcolare l'accuratezza
# Calcolare la percentuale di accuratezza 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# Questa è l'espressione di accuratezza della classificazione binaria
6. Colonne di classificazione binaria
# Dividere un set di dati in base a un attributo e un valore di attributo def test_split(index, value, dataset): left, right = list(), list()# Initialize two empty lists for row in dataset: if row[index] < value: left.append(row) else: right.append(row) return left, right # Return two lists, each classifying the specified rows (index) based on the value.
7. Use the Gini coefficient to obtain the best split point
# 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}
This code directly applies the definition to calculate the gini index, which is easy to understand. Understanding the best split point may be more difficult, as it uses two levels of iteration, one for different columns and one for different rows. And, during each iteration, the gini coefficient is updated.
8、Decision Tree Generation
# 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)
Ecco che è stato utilizzato programmazione ricorsiva, che genera continuamente albero a sinistra e a destra.
9. Costruzione dell'albero di decisione
# Costruire un albero di decisione 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. Previsione del set di test
# Costruire un albero di decisione def build_tree(train, max_depth, min_size): root = get_split(train)# Ottenere il miglior punto di taglio, valore dell'indice, gruppi split(root, max_depth, min_size, 1) return root # tree=build_tree(train_set, max_depth, min_size) # print(tree) # Effettuare una previsione con un albero di decisione def predict(node, row): print(row[node['index']]) print(node['value']) if row[node['index']] < node['value']:# Utilizzare il set di test per sostituire il miglior punto di taglio addestrato, quando il punto di taglio ha una deviazione, confronta ulteriormente attraverso la ricerca degli alberi a destra e a sinistra. if isinstance(node['left'], dict):# Se è un tipo dizionario, esegui l'operazione 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. Valutazione dell'albero di decisione
# Valutare un algoritmo utilizzando una divisione di cross-validation 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[-1] for row in fold] accuracy = accuracy_metric(actual, predicted) scores.append(accuracy) return scores
Questo è tutto il contenuto dell'articolo, speriamo che sia utile per la tua apprendimento e speriamo che tu sostenga fortemente il tutorial urla.
Dichiarazione: il contenuto di questo articolo è stato prelevato da Internet, il copyright è di proprietà del rispettivo proprietario, il contenuto è stato contribuito autonomamente dagli utenti di Internet e caricato autonomamente, il sito web non detiene il diritto di proprietà, non è stato elaborato manualmente e non assume alcuna responsabilità legale correlata. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a: notice#oldtoolbag.com (al momento dell'invio dell'e-mail, sostituisci # con @) per segnalare il problema e fornire prove pertinenti. Una volta verificata, il sito web rimuoverà immediatamente il contenuto sospetto di violazione del copyright.