Conceptos básicos del aprendizaje automático: "Algoritmo de clasificación (6) - Árbol de decisión"

News 2023-09-19 06:33:01 views: null

1. Árbol de decisión

1. Comprender los árboles de decisión.
El origen de la idea de los árboles de decisión es muy simple. La estructura de rama condicional en programación es la estructura if-else. El primer árbol de decisión es un método de aprendizaje de clasificación que utiliza este tipo de estructura para segmentar datos.

2. Un ejemplo de conversación

¡Piensa por qué esta chica pone la edad en el primer lugar de su juicio! ! !
¿Cómo tomar decisiones de manera eficiente? El orden de las características.

2. Explicación detallada de los principios de clasificación del árbol de decisión.

1. Usemos un ejemplo de un problema.

Se sabe que hay cuatro valores de características para predecir si se le debe prestar a una determinada persona
(1) primero mire la casa y luego mire el trabajo -> si se le presta (solo se miran dos características)
( 2) edad, situación crediticia, trabajo --> ver Se incluyen tres características.
El segundo método no es tan eficiente como el primero.
Espero encontrar un método matemático para determinar rápida y automáticamente qué característica se debe considerar primero.

2. Conceptos básicos de la teoría de la información
¡Es necesario introducir conocimientos de la teoría de la información, como la entropía de la información y la ganancia de información! ! !

(1) Información
Definición de Shannon: algo que elimina la incertidumbre aleatoria
La edad de Xiao Ming "Tengo 18 años este año"
Xiao Hua "Xiao Ming cumplirá 19 años el próximo año"

Después de que Xiao Ming lo dijo, lo que dijo Xiao Hua se convirtió en una tontería, no en información.

(2) Medición de información-cantidad de información-entropía de información

3. La definición de entropía de información.
El término profesional para H se llama entropía de información y su unidad es bit.

4. Tomando como ejemplo los datos de préstamos bancarios, calcule la entropía de la información.
Si se conoce la edad, el trabajo, la casa y la situación crediticia de alguien, ¿le prestará dinero a esta persona?
Es necesario medir el tamaño de la incertidumbre.
Aquí hay dos situaciones, una es un préstamo y la otra es un no préstamo.
La probabilidad de no préstamo es 6/15 y la probabilidad de préstamo es 9/15
H (total) = -(6/15 * registro 6/15 + 9/15 * registro 9/15) = 0,971

Cuando conocemos una determinada característica, la incertidumbre se reducirá,
por lo que si podemos descubrir el grado en que se reduce la incertidumbre después de conocer una determinada característica. Después de comparar nuevamente, después de saber qué característica, la incertidumbre se reduce más. ¿Podemos ver esta característica primero?

Después de conocer una determinada característica, ¿cuál es su entropía de información?
Introducción: obtención de información

5. Ganancia de información:
una de las bases para dividir los árboles de decisión: ganancia de información

(1) Definición y fórmula
La ganancia de información g(D,A) de la característica A en el conjunto de datos de entrenamiento D se define como la entropía de información H(D) del conjunto D y la entropía condicional de información H(D| La diferencia entre A)
g(D,A) = H(D) - entropía condicional La ganancia de información H(D|A)
mide el grado en que se reduce la incertidumbre de una determinada característica después de conocerla

Calcule la ganancia de información después de conocer la edad:
g(D,edad) = H(D) - H(D|edad)

Encuentre H(D|Edad):
H(Juventud) = -(2/5 * log 2/5 + 3/5 * log 3/5) = 
H(Mediana edad) = -(2/5 * log 2/ 5 + 3/5 * log 3/5) = 
H(vejez) = -(1/5 * log 1/5 + 4/5 * log 4/5) = 
H(D|edad) = 1/3 * H( Jóvenes) + 1/3 * H (mediana edad) + 1/3 * H (ancianos)

Usamos A1, A2, A3 y A4 para representar la edad, el trabajo, la casa propia y el estado del préstamo. Los resultados finales calculados son g(D, A1) = 0,313, g(D, A2) = 0,324, g(D, A3) = 0,420, g(D, A4) = 0,363. Entonces elegimos A3 como la primera característica de la división.

(2) Oficial

(3) Por supuesto, el principio del árbol de decisión no es solo la ganancia de información, sino también otros métodos
ID3:
  ganancia de información, el criterio más grande
C4.5:
  índice de ganancia de información, el criterio más grande
CART:
  árbol de clasificación: coeficiente de Gini, el más pequeño criterio, en sklearn, puede elegir el principio predeterminado
  ventaja de la división: la división es más detallada (comprenda el siguiente ejemplo)

3. API del árbol de decisiones

1. Clase API
sklearn.tree.DecisionTreeClassifier(criterion='gini', max_ Depth=None, random_state=None) Criterio del
analizador de árbol de decisión : el valor predeterminado es el coeficiente 'gini', también puede elegir la entropía de la ganancia de información 'entropía' max_profundidad: árbol La profundidad del árbol es demasiado profunda   , lo que provocará un sobreajuste.   El sobreajuste provocará una mala capacidad de generalización del modelo, es decir, es demasiado adecuado para el conjunto de muestras actual y carece de la capacidad de adaptarse (predecir ) nuevas muestras.random_state: semilla de número aleatorio




2. Clasificación del árbol de decisión de las flores de iris.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.tree import DecisionTreeClassifier

def KNN_iris():
    """
    用KNN算法对鸢尾花进行分类
    """
    # 1、获取数据
    iris = load_iris()
    print("iris.data：\n", iris.data)
    print("iris.target：\n", iris.target)
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 3、特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    # 用训练集的平均值和标准差对测试集的数据来标准化
    # 这里测试集和训练集要有一样的平均值和标准差，而fit的工作就是计算平均值和标准差，所以train的那一步用fit计算过了，到了test这就不需要再算一遍自己的了，直接用train的就可以
    x_test = transfer.transform(x_test)
    # 4、KNN算法预估器
    estimator = KNeighborsClassifier(n_neighbors=3)
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    return None
 
def KNN_iris_gscv():
    """
    用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证
    """
    # 1、获取数据
    iris = load_iris()
    print("iris.data：\n", iris.data)
    print("iris.target：\n", iris.target)
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 3、特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    # 用训练集的平均值和标准差对测试集的数据来标准化
    # 这里测试集和训练集要有一样的平均值和标准差，而fit的工作就是计算平均值和标准差，所以train的那一步用fit计算过了，到了test这就不需要再算一遍自己的了，直接用train的就可以
    x_test = transfer.transform(x_test)
    # 4、KNN算法预估器
    estimator = KNeighborsClassifier()
    # 加入网格搜索和交叉验证
    # 参数准备
    param_dict = {"n_neighbors": [1, 3, 5, 7, 9, 11]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10)
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    #最佳参数：best_params_
    print("最佳参数：\n", estimator.best_params_)
    #最佳结果：best_score_
    print("最佳结果：\n", estimator.best_score_)
    #最佳估计器：best_estimator_
    print("最佳估计器：\n", estimator.best_estimator_)
    #交叉验证结果：cv_results_
    print("交叉验证结果：\n", estimator.cv_results_)
    return None

def nb_news():
    """
    用朴素贝叶斯算法对新闻进行分类
    """
    # 1、获取数据
    news = fetch_20newsgroups(subset="all")
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(news.data, news.target)
    # 3、特征工程：文本特征抽取-tfidf
    transfer = TfidfVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 4、朴素贝叶斯算法预估器流程
    estimator = MultinomialNB()
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    return None

def decision_iris():
    """
    用决策树对鸢尾花数据进行分类
    """
    # 1、获取数据集
    iris = load_iris()
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 3、决策树预估器
    estimator = DecisionTreeClassifier(criterion='entropy')
    estimator.fit(x_train, y_train)
    # 4、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    return None

if __name__ == "__main__":
    # 代码1：用KNN算法对鸢尾花进行分类
    KNN_iris()
    # 代码2：用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证
    #KNN_iris_gscv()
    # 代码3：用朴素贝叶斯算法对新闻进行分类
    #nb_news()
    # 代码4：用决策树对鸢尾花数据进行分类
    decision_iris()

resultado de la operación:

y_predict：
 [0 2 0 0 2 1 1 0 2 1 2 1 2 2 1 1 2 1 1 0 0 2 0 0 1 1 1 2 0 1 0 1 0 0 1 2 1
 2]
直接比对真实值和预测值：
 [ True  True  True  True  True  True False  True  True  True  True  True
  True  True  True False  True  True  True  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True False  True
  True  True]
准确率为：
 0.9210526315789473
y_predict：
 [0 2 0 0 2 1 1 0 2 1 2 1 2 2 1 1 2 1 1 0 0 2 0 0 1 1 1 2 0 1 0 1 0 0 1 2 1
 2]
直接比对真实值和预测值：
 [ True  True  True  True  True  True False  True  True  True  True  True
  True  True  True False  True  True  True  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True False  True
  True  True]
准确率为：
 0.9210526315789473

KNN es un algoritmo perezoso. Durante el cálculo, calcula frenéticamente la distancia entre cada muestra en la memoria. El
escenario de aplicación del árbol de decisión es más adecuado para su uso en situaciones donde la cantidad de datos es relativamente grande.

4. Visualización de árboles de decisión.

1. Guarde la estructura de árbol en el archivo de puntos
sklearn.tree.export_graphviz().
Esta función puede exportar el formato DOT.

2. tree.export_graphviz(estimator, out_file='tree.dot', feature_names=['',''])
estimador: objeto del estimador
out_file: nombre exportado
feature_names: nombre de la característica

3. Modificar el código

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.tree import DecisionTreeClassifier, export_graphviz

def KNN_iris():
    """
    用KNN算法对鸢尾花进行分类
    """
    # 1、获取数据
    iris = load_iris()
    print("iris.data：\n", iris.data)
    print("iris.target：\n", iris.target)
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 3、特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    # 用训练集的平均值和标准差对测试集的数据来标准化
    # 这里测试集和训练集要有一样的平均值和标准差，而fit的工作就是计算平均值和标准差，所以train的那一步用fit计算过了，到了test这就不需要再算一遍自己的了，直接用train的就可以
    x_test = transfer.transform(x_test)
    # 4、KNN算法预估器
    estimator = KNeighborsClassifier(n_neighbors=3)
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    return None
 
def KNN_iris_gscv():
    """
    用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证
    """
    # 1、获取数据
    iris = load_iris()
    print("iris.data：\n", iris.data)
    print("iris.target：\n", iris.target)
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 3、特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    # 用训练集的平均值和标准差对测试集的数据来标准化
    # 这里测试集和训练集要有一样的平均值和标准差，而fit的工作就是计算平均值和标准差，所以train的那一步用fit计算过了，到了test这就不需要再算一遍自己的了，直接用train的就可以
    x_test = transfer.transform(x_test)
    # 4、KNN算法预估器
    estimator = KNeighborsClassifier()
    # 加入网格搜索和交叉验证
    # 参数准备
    param_dict = {"n_neighbors": [1, 3, 5, 7, 9, 11]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10)
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    #最佳参数：best_params_
    print("最佳参数：\n", estimator.best_params_)
    #最佳结果：best_score_
    print("最佳结果：\n", estimator.best_score_)
    #最佳估计器：best_estimator_
    print("最佳估计器：\n", estimator.best_estimator_)
    #交叉验证结果：cv_results_
    print("交叉验证结果：\n", estimator.cv_results_)
    return None

def nb_news():
    """
    用朴素贝叶斯算法对新闻进行分类
    """
    # 1、获取数据
    news = fetch_20newsgroups(subset="all")
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(news.data, news.target)
    # 3、特征工程：文本特征抽取-tfidf
    transfer = TfidfVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 4、朴素贝叶斯算法预估器流程
    estimator = MultinomialNB()
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    return None

def decision_iris():
    """
    用决策树对鸢尾花数据进行分类
    """
    # 1、获取数据集
    iris = load_iris()
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 3、决策树预估器
    estimator = DecisionTreeClassifier(criterion='entropy')
    estimator.fit(x_train, y_train)
    # 4、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    # 可视化决策树
    export_graphviz(estimator, out_file='iris_tree.dot', feature_names=iris.feature_names)
    return None

if __name__ == "__main__":
    # 代码1：用KNN算法对鸢尾花进行分类
    #KNN_iris()
    # 代码2：用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证
    #KNN_iris_gscv()
    # 代码3：用朴素贝叶斯算法对新闻进行分类
    #nb_news()
    # 代码4：用决策树对鸢尾花数据进行分类
    decision_iris()

El archivo iris_tree.dot se genera después de ejecutar:

digraph Tree {
node [shape=box] ;
0 [label="petal width (cm) <= 0.8\nentropy = 1.584\nsamples = 112\nvalue = [38, 38, 36]"] ;
1 [label="entropy = 0.0\nsamples = 38\nvalue = [38, 0, 0]"] ;
0 -> 1 [labeldistance=2.5, labelangle=45, headlabel="True"] ;
2 [label="petal width (cm) <= 1.65\nentropy = 0.999\nsamples = 74\nvalue = [0, 38, 36]"] ;
0 -> 2 [labeldistance=2.5, labelangle=-45, headlabel="False"] ;
3 [label="sepal length (cm) <= 7.1\nentropy = 0.179\nsamples = 37\nvalue = [0, 36, 1]"] ;
2 -> 3 ;
4 [label="entropy = 0.0\nsamples = 36\nvalue = [0, 36, 0]"] ;
3 -> 4 ;
5 [label="entropy = 0.0\nsamples = 1\nvalue = [0, 0, 1]"] ;
3 -> 5 ;
6 [label="petal length (cm) <= 5.05\nentropy = 0.303\nsamples = 37\nvalue = [0, 2, 35]"] ;
2 -> 6 ;
7 [label="sepal width (cm) <= 2.9\nentropy = 0.863\nsamples = 7\nvalue = [0, 2, 5]"] ;
6 -> 7 ;
8 [label="entropy = 0.0\nsamples = 4\nvalue = [0, 0, 4]"] ;
7 -> 8 ;
9 [label="petal width (cm) <= 1.75\nentropy = 0.918\nsamples = 3\nvalue = [0, 2, 1]"] ;
7 -> 9 ;
10 [label="entropy = 0.0\nsamples = 1\nvalue = [0, 1, 0]"] ;
9 -> 10 ;
11 [label="sepal width (cm) <= 3.1\nentropy = 1.0\nsamples = 2\nvalue = [0, 1, 1]"] ;
9 -> 11 ;
12 [label="entropy = 0.0\nsamples = 1\nvalue = [0, 0, 1]"] ;
11 -> 12 ;
13 [label="entropy = 0.0\nsamples = 1\nvalue = [0, 1, 0]"] ;
11 -> 13 ;
14 [label="entropy = 0.0\nsamples = 30\nvalue = [0, 0, 30]"] ;
6 -> 14 ;
}

4. La imagen generada
http://webgraphviz.com
siempre muestra cargando...

Más tarde, encontré uno generado en línea.
Visite http://www.tasksteper.com:8099/flow/home/; inicie sesión con nombre de usuario/contraseña: testuser1/testuser1; ingrese al proyecto "Herramientas integradas"; haga clic en "Crear entrada "

5. Proceso de juicio
(1) Primero mire el ancho de los pétalos, si el ancho es menor o igual a 0,8
(2) Si no está satisfecho, continúe dividiendo
(3) entropía: calcule la ganancia de información
(4) muestras: el número de muestras

5. Ventajas y desventajas de los árboles de decisión

1. Algo
simple y fácil de entender, y se puede visualizar
Visualización: fuerte interpretabilidad

2. Desventajas:
el árbol es demasiado complejo y propenso a sobreajustarse.


3. Algoritmo de carrito de reducción de ramas mejorado , se ha implementado
un bosque aleatorio en la API del árbol de decisión
 

Supongo que te gusta

Origin blog.csdn.net/csj50/article/details/132732152
Recomendado
Clasificación
Diario
Más
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)
2024-05-03(8)

Code World

© 2018 codetd.com