Principio y método de implementación de Random Forest en Python

Introducción

Quiero obtener las características principales de los datos a través del bosque aleatorio

1Teoría

El bosque aleatorio es un método de aprendizaje de máquina altamente flexible, con un amplio campo de aplicación, desde el marketing hasta el seguro de salud. Puede utilizarse tanto para la modelización de simulación de marketing, como para la estadística de la fuente de clientes, la retención y la pérdida. También se puede utilizar para predecir el riesgo de enfermedades y la susceptibilidad de los pacientes enfermos.

De acuerdo con la forma de generación del aprendiz individual, los métodos de aprendizaje en conjunto actuales se pueden dividir大致 en dos grandes categorías, es decir, los métodos serializados que deben generarse en serie debido a la dependencia fuerte entre los aprendices individuales, y los métodos paralelizados que no tienen dependencia fuerte entre los aprendices individuales y pueden generarse simultáneamente;

前者的代表是Boosting，后者的代表是Bagging和“随机森林”（Random
Forest）

随机森林在以决策树为基学习器构建Bagging集成的基础上，进一步在决策树的训练过程中引入了随机属性选择（即引入随机特征选择）。

简单来说，随机森林就是对决策树的集成，但有两点不同：

（2）特征选取的差异性：每个决策树的n个分类特征是在所有特征中随机选择的（n是一个需要我们自己调整的参数）
随机森林，简单理解， 比如预测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

实现随机森林基本功能

#Árbol de decisión de bosque aleatorio
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()#aquí se utilizan los parámetros de configuración predeterminados 
rf.fit(iris.data[:150],iris.target[:150])#entrenar el modelo 
#seleccionar dos instancias con predicciones diferentes 
instance=iris.data[[100,109] 
print(instance)
rf.predict(instance[[0]])
print('instancia 0 predicción;',rf.predict(instance[[0]]))
print('instancia 1 predicción; ',rf.predict(instance[[1]))
print(iris.target[100], iris.target[109)] 

resultados de ejecución

(150,)
[[ 6.3　 3.3　 6.　　 2.5]
　[ 7.2　 3.6　 6.1　 2.5]
instancia 0 predicción; [ 2]
instancia 1 predicción; [ 2]
2 2

2.2 Demo2

3comparación de métodos

#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())

运行结果：

0.979408793821
0.999607843137
0.999898989899

2.3 Demo3-Implementar la selección de características

#Árbol de decisión de bosque aleatorio2
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, 'ancho del pétalo (cm)'), (0.82099999999999995, 'longitud del pétalo')]
(cm)'), (0.13, 'longitud del sépalo (cm)'), (-0.79100000000000004, 'ancho del sépalo (cm)')]

2.4 demo4-Árbol de decisión de bosque aleatorio

Quería utilizar el siguiente código para construir un bosque aleatorio de árboles de decisión, pero, el problema es que el programa está ejecutándose y no responde, necesitando ser depurado.

#Árbol de decisión de bosque aleatorio4
#coding:utf-8 
import csv 
from random import semilla 
from random import randrange 
from math import sqrt 
def loadCSV(filename):#Carga de datos, almacenando una línea por vez en una lista 
 dataSet = [] 
 with open(filename, 'r') as file: 
 csvReader = csv.reader(file) 
 for line in csvReader: 
  dataSet.append(line) 
 return dataSet 
# Convertir todas las columnas excepto la columna de etiquetas en tipo 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()) 
# Dividir el conjunto de datos aleatoriamente en N secciones, lo que facilita la validación cruzada, una sección es el conjunto de prueba y las otras cuatro secciones son conjuntos de entrenamiento 
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: # Aquí no se puede usar if, if solo tiene efecto en la primera vez, while ejecuta el bucle hasta que la condición no se cumpla 
  index = randrange(len(dataSet_copy)) 
  fold.append(dataSet_copy.pop(index)) # pop() función se utiliza para eliminar un elemento de una lista (por defecto el último elemento), y devuelve el valor del elemento. 
 dataSet_spilt.append(fold) 
 return dataSet_spilt 
# Construir el subconjunto de datos 
def get_subsample(dataSet, ratio): 
 subdataSet = [] 
 lenSubdata = round(len(dataSet) * ratio)# Devuelve un número de punto flotante 
 while len(subdataSet) < lenSubdata: 
 index = randrange(len(dataSet) - 1) 
 subdataSet.append(dataSet[index]) 
 # print len(subdataSet) 
 return subdataSet 
# Separar el conjunto de datos 
def data_spilt(dataSet, index, value): 
 left = [] 
 right = [] 
 for row in dataSet: 
 if row[index] < value: 
  left.append(row) 
 else: 
  right.append(row) 
 devolver(izquierda, derecha) 
# Calcular el costo de división 
def spilt_loss(left, right, class_values): 
 loss = 0.0 
 for class_value in class_values: 
 left_size = len(left) 
 if left_size != 0: # Prevenir la división por cero 
  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 
# Seleccionar n características aleatorias, entre estas características seleccionar la mejor característica para la división 
def get_best_spilt(dataSet, n_features): 
 features = [] 
 class_values = list(set(row[-1for 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: # Encontrar el índice más adecuado para el nodo (menor pérdida) 
 for row in dataSet: 
  left, right = data_spilt(dataSet, index, row[index]) # Ramas izquierda y derecha del nodo 
  loss = spilt_loss(left, right, class_values) 
  if loss < b_loss: # Buscar el costo de división más pequeño 
  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} 
# Determinar la etiqueta de salida 
def decide_label(data): 
 output = [row[-1] for row in data] 
 return max(set(output), key=output.count) 
# Subdividir, el proceso continuo de construcción de nodos hoja 
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) 
 # Construir el árbol de decisión 
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 
# Calcular precisión 
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__': 
 semilla(1) 
 dataSet = loadCSV(r'G:\0Estudiante\tianchiCompetition\miniSample2.csv') 
 column_to_float(dataSet) 
 n_folds = 5 
 profundidad_max = 15 
 tamano_min = 1 
 ratio = 1.0 
 # n_features=sqrt(len(dataSet)-1) 
 n_features = 15 
 n_trees = 10 
 folds = spiltDataSet(dataSet, n_folds)# Primero cortar el conjunto de datos 
 scores = [] 
 para división en divisiones: 
 train_set = folds[ 
   :] # Aquí no se puede usar simplemente train_set=folds, ya que esto sería una referencia, por lo que cuando cambia el valor de train_set, también cambia el valor de folds. Por lo tanto, se debe usar una copia de forma.(L[:]).copy() puede copiar una secuencia, D.copy() puede copiar un diccionario, list puede generar una copia list(L) 
 train_set.remove(fold)# Seleccionar el conjunto de entrenamiento 
 # print len(folds) 
 train_set = sum(train_set, []) # Combinar múltiples listas de folds en una lista de train_set 
 # print len(train_set) 
 test_set = [] 
 para fila en división: 
  row_copy = lista(row) 
  row_copy[-1] = None 
  conjunto_de_pruebas.append(row_copy) 
  # for row in test_set: 
  # print row[-1] 
 actual = [fila[-1] para fila en división] 
 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 ('Árboles es %d' % n_trees) 
 print ('puntuaciones:%s' % scores) 
 print ('puntuación media:%s' % (sum(scores)) / float(len(puntuaciones))) 

2.5 Clasificación de bosque aleatorio de datos de sonido

# CART en el conjunto de datos de notas bancarias
from random import semilla
from random import randrange
from csv import reader
# Load a CSV file
def load_csv(filename):
 file = open(filename, "r")
 lines = reader(file)
 dataset = list(lines)
 return dataset
# Convert string column to float
def str_column_to_float(dataset, column):
 for row in dataset:
 row[column] = float(row[column].strip())
# Dividir un conjunto de datos en k pliegues
def cross_validation_split(dataset, n_folds):
 dataset_dividido = lista()
 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(copia_dataset.pop(indice))
 dataset_split.append(fold)
 return dataset_split
# Calcular el porcentaje de precisión
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
# Evaluar un algoritmo utilizando una división de validación cruzada
def evaluar_algoritmo(dataset, algoritmo, n_divisiones, *args):
 divisiones = división_cruzada_split(dataset, n_divisiones)
 puntuaciones = lista()
 para división en divisiones:
 conjunto_de_entrenamiento = lista(divisiones)
 conjunto_de_entrenamiento.remove(división)
 conjunto_de_entrenamiento = suma(conjunto_de_entrenamiento, [])
 conjunto_de_pruebas = lista()
 para fila en división:
  row_copy = lista(row)
  conjunto_de_pruebas.append(row_copy)
  row_copy[-1] = None
 predicted = algoritmo(conjunto_de_entrenamiento, conjunto_de_pruebas, *args)
 actual = [fila[-1] para fila en división]
 accuracy = accuracy_metric(actual, predicted)
 puntuaciones.append(accuracy)
 devolver puntuaciones
# Dividir un conjunto de datos basado en un atributo y un valor de atributo
def test_split(index, value, dataset):
 izquierda, derecha = lista(), lista()
 for row in dataset:
 if row[index] < value:
  left.append(row)
 else:
  right.append(row)
 devolver(izquierda, derecha)
# 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 ({'indice':b_index, 'valor':b_value})
 return {'index':b_index, 'value':b_value, 'groups':b_groups}
# Crear un nodo terminal de valor
def a_terminal(grupo):
 resultados = [fila[-1] para fila en grupo]
 devolver(max(set(resultados), clave=lambda x: resultados.count(x)))
# 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)
# Construir un árbol de decisiones
def build_tree(train, max_depth, min_size):
 root = get_split(train)
 split(root, max_depth, min_size, 1)
 return root
# Hacer una predicción con un árbol de decisiones
def predict(node, row):
 si fila[node['indice']] < node['valor']:
 si isinstance(node['izquierda'], 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 de Árbol de Clasificación y Regresión
def arbol_decision(entrenamiento, prueba, profundidad_max, tamano_min):
 arbol = construir_arbol(entrenamiento, profundidad_max, tamano_min)
 predictions = list()
 para fila en prueba:
 prediction = predict(tree, row)
 predictions.append(prediction)
 devolver(predicciones)
# Test CART en el conjunto de datos de notas bancarias
semilla(1)
# cargar y preparar datos
filename = r'G:\0pythonstudy\决策树\sonar.all-data.csv'
dataset = cargar_csv(nom_archivo)
# convert string attributes to integers
for i in range(len(dataset[0]))-1)
 str_column_to_float(dataset, i)
# evaluar algoritmo
n_folds = 5
profundidad_max = 5
tamano_min = 10
puntuaciones = evaluar_algoritmo(dataset, arbol_decision, n_folds, profundidad_max, tamano_min)
print('Puntuaciones: %s' % puntuaciones)
print('Precisión Media: %.3f%%' % (sum(puntuaciones)/float(len(puntuaciones)))

运行结果：

{'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}
Scores: [48.78048780487805, 70.73170731707317, 58.536585365853654, 51.2195121951
2195, 39.02439024390244]
Mean Accuracy: 53.659%
请按任意键继续. . .

知识点：

1.load CSV file

from csv import reader
# Load a CSV file
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格式

# Convert string column to float
def str_column_to_float(dataset, column):
 for row in dataset:
 row[column] = float(row[column].strip())
 # print(row[column])
# convert string attributes to integers
for i in range(len(dataset[0]))-1)
 str_column_to_float(dataset, i)

3.把最后一列的分类字符串转化成0、1整数

def str_column_to_int(dataset, column):
 class_values = [row[column] for row in dataset]#生成一个class label的list
 # print(class_values)
 unique = set(class_values)#set 获得list的不同元素
 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、Dividir el conjunto de datos en K partes

# Dividir un conjunto de datos en k pliegues
def cross_validation_split(dataset, n_folds):
 dataset_split = list()# Generar lista vacía
 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))# Utilizar .pop() para eliminar todos los elementos dentro (equivalente a transferir), estos k elementos son diferentes.
 dataset_split.append(fold)
 return dataset_split
n_folds=5 
folds = cross_validation_split(dataset, n_folds)#k elementos de entrenamiento diferentes en cada conjunto

5. Calcular la tasa de precisión

# Calcular el porcentaje de precisión
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# Esta es la expresión de precisión de clasificación binaria

6. Cada columna en la clasificación bicausada

# Dividir un conjunto de datos basado en un atributo y un valor de atributo
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 of which performs binary classification of specified rows (index) based on 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}

Este código, al calcular el índice de gini, aplica directamente la fórmula definida, lo que es fácil de entender. Obtener el mejor punto de división puede ser difícil de entender, aquí se utiliza dos capas de iteración, una para las diferentes columnas y otra para las diferentes filas. Y en cada iteración, se actualiza el coeficiente de 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)

Aquí se utiliza programación recursiva, generando continuamente el árbol izquierdo y el derecho.

9.Construir el árbol de decisiones

# Construir un árbol de decisiones
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、predecir el conjunto de prueba

# Construir un árbol de decisiones
def build_tree(train, max_depth, min_size):
 root = get_split(train)# Obtener el mejor punto de división, valor de índice, grupos
 split(root, max_depth, min_size, 1)
 return root 
# tree=build_tree(train_set, max_depth, min_size)
# print(tree) 
# Hacer una predicción con un árbol de decisiones
def predict(node, row):
 print(row[node['index']])
 print(node['value'])
 if row[node['index']] < node['value']:# Usar el conjunto de prueba para reemplazar el mejor punto de división entrenado, cuando hay desviación en el punto de división, comparar adicionalmente mediante la búsqueda en los árboles izquierdo y derecho.
 if isinstance(node['left'], dict):# Si es del tipo diccionario, ejecutar la operación
  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.Evaluar el árbol de decisiones

# Evaluar un algoritmo utilizando una división de validación cruzada
def evaluar_algoritmo(dataset, algoritmo, n_divisiones, *args):
 divisiones = división_cruzada_split(dataset, n_divisiones)
 puntuaciones = lista()
 para división en divisiones:
 conjunto_de_entrenamiento = lista(divisiones)
 conjunto_de_entrenamiento.remove(división)
 conjunto_de_entrenamiento = suma(conjunto_de_entrenamiento, [])
 conjunto_de_pruebas = lista()
 para fila en división:
  row_copy = lista(row)
  conjunto_de_pruebas.append(row_copy)
  row_copy[-1] = None
 predicted = algoritmo(conjunto_de_entrenamiento, conjunto_de_pruebas, *args)
 actual = [fila[-1] para fila en división]
 accuracy = accuracy_metric(actual, predicted)
 puntuaciones.append(accuracy)
 devolver puntuaciones 

Esto es todo el contenido del artículo, espero que sea útil para su aprendizaje y que todos los demás lo apoyen en el tutorial de clamor.

Declaración: El contenido de este artículo se obtiene de la red, el copyright pertenece al autor original, el contenido se contribuye y carga de manera autónoma por los usuarios de Internet, este sitio web no posee derechos de propiedad, no se ha realizado tratamiento editorial humano y no asume responsabilidades legales relacionadas. Si encuentra contenido sospechoso de copyright, por favor envíe un correo electrónico a: notice#w3Declaración: El contenido de este artículo se obtiene de la red, el copyright pertenece al autor original, el contenido se contribuye y carga de manera autónoma por los usuarios de Internet, este sitio web no posee derechos de propiedad, no se ha realizado tratamiento editorial humano y no asume responsabilidades legales relacionadas. Si encuentra contenido sospechoso de copyright, por favor envíe un correo electrónico a: notice#w