Entrenamiento de modelo de clasificación con árbol de decisión
Curso de Decision Trees y Random Forest con Python y scikit-learn
Contenido del curso
FELIX DAVID CORDOVA GARCIA
Layla Scheli
Profesor
Nestor Ramirez
Sergio Andrés Majé Franco
Agustín Hernández Serpa
Jair Machuca
Germán Alejandro Niño
Layla Scheli
Profesor
Isabel Fernández
Layla Scheli
Profesor
LUIS GUILLERMO MONCADA RUIZ
Layla Scheli
Profesor
Carlos Mazzaroli
Layla Scheli
Profesor
Andrés Camilo Cala Gómez
Layla Scheli
Profesor
Anthony Ismael Manotoa Moreno
Antonio Demarco Bonino
Diego Mauricio Zuluaga Rodríguez
Diego Mauricio Zuluaga Rodríguez
Diego Mauricio Zuluaga Rodríguez
Sebastián Franco
Juan Acevedo
David Felipe Zabala Castañeda
Mario Alexander Vargas Celis
Ronald Andrey Beltran Parada
Diego Andrés Rojas Pinzón
Diego Andrés Rojas Pinzón
Alan Hugo Martinez Rodriguez
Abinadi Contreras
Usar el OrdinalEncoder de Scikit-learn para no instalar nada mas
Gracias Felix por tu aportacion :)
En casos donde tengas varias categorias ya este metodo pierde efectividad y es mejor utilizar el hot encoding, ya que los modelos toman la distancia en cada categoria. No es lo mismo si tus valores son categoricos con continuidad como pasa en la satisfaccion del cliente a si esta categorizando varias modelos de carros. Aqui puedes comparar la evaluacion de los modelos para ver como afecta esto a tu precision
['buying', 'maint', 'doors', 'persons', 'lug_boot', 'safety']
En general, para evitar escribir las columnas y pasarlas manualmente se puede escribir el código
X_train.columns
La salida de eso será la siguiente:
Index(['buying', 'maint', 'doors', 'persons', 'lug_boot', 'safety'], dtype='object')
De ahí, se copia el primer parámetro que aparece en el output.
Esto puede funcionar para evitar escribir los atributos cada vez que se hace el procedimiento sobre un dataset que pueda tener muchos más atributos.
si les presenta error para visualizar la gráfica se arregla con el siguiente codigo: sns.barplot(y=importances, x=columns, palette = 'bright', saturation = 2.0, edgecolor ='black', linewidth = 2)
espero les sirva.
Cual es la diferencia entre fit_transform y transform usando OrdinalEncoder?
Hola German! te paso info:
fit_transform y transform son dos métodos que se utilizan en el contexto de la transformación de datos en aprendizaje automático. En particular, cuando hablamos de OrdinalEncoder, estos métodos tienen funciones específicas:
fit_transform: Este método se utiliza para ajustar el codificador a los datos de entrada y transformarlos simultáneamente. Durante el ajuste (fit), el codificador aprende los diferentes valores únicos presentes en la característica y asigna a cada uno un número entero único. Luego, estos valores se utilizan para transformar los datos de entrada, es decir, cada valor único se reemplaza por su correspondiente número entero asignado.
transform: Este método se utiliza únicamente para transformar los datos de entrada utilizando las asignaciones aprendidas durante el ajuste (fit). Si intentas usar transform sin haber ajustado el codificador previamente (sin haber llamado fit), obtendrás un error.
Entonces, la diferencia principal radica en que fit_transform realiza tanto el ajuste como la transformación de los datos, mientras que transform solo realiza la transformación, utilizando los parámetros aprendidos durante el ajuste.
Este modelo queda estandar para usarlo en cualquier data que se requiera clasificación, o en qué puede variar el modelo?
Si :) tmb regresion. Es decir aplica a ambos! Gracias
Siempre he convertido datos que son Categoricos o Numericos con este codigo.
#Convertir las columnas a columnas Numericas #Cambia todas las columnas a categoricas, #dl es el dataframe a convertir. for col_name in dl.columns: if(dl[col_name].dtype == 'object'): dl[col_name]= dl[col_name].astype('category') dl[col_name] = dl[col_name].cat.codes #Cambia todas las columnas a categoricas dl
#Las variables categoricas se convierte en variables numericas, pero alguien me dice que uno todo lo tiene que convertir a dummy?, es verdad, es que si tienes 1000 categorias, te crea 1000 variables, pero si aca conviertes todo a numero es mas facil o no funciona?, todo debe ser dummy?
Hola Luis, hay muchas formas de crear una variable dummy, generalmente la necesitas asi, hay veces que podes utilizar el categorical encoders, tmb :) Son muy similares realmente, tu codigo va muy bien!
No entiendo porque primero hacen el split de datos antes que el encoder? no seria mejor hacer el encoder primero y después hacer el split?
Hola Carlos, es indistinto lo podes hacer antes o despues, generalmente se hace el split y luego lo otro, pero lo podes adaptar tmb sin problemas :) Un saludo!
Hola, no entiendo cual es la diferencia entre usar get_dummies para transformar las variables categoricas y category_encoders?
Hola Andres, las dos funciones muy similar o la finalidad es para lo mismo, sin embargo en funcion de las configuraciones que establezcas por ej, podes quitar o no la primera columna. No son exactamente iguales! :)
Te comparto link: get_dummies para transformar las variables categoricas y category_encoders
Me estoy imaginando como extrapolar este árbol a otras industrias y otros problemas a resolver. Me encanta.
¿Qué pasa si mis datos están desbalanceados?
Si tus datos están desbalanceados (por ejemplo, 90% de correos normales y 10% de spam), el árbol de decisión tenderá a favorecer a la clase mayoritaria. El modelo podría alcanzar una alta precisión simplemente prediciendo siempre "correo normal", pero fallará miserablemente en detectar el spam, que es tu objetivo real. Para solucionar esto durante el entrenamiento, puedes usar el parámetro class_weight="balanced" en tu modelo. Esto le indica al algoritmo que penalice más fuertemente los errores cometidos en la clase minoritaria, dándole matemáticamente más "importancia" a esos pocos ejemplos. Alternativamente, antes de entrenar, puedes aplicar técnicas de remuestreo en tu dataset, como SMOTE (para crear datos sintéticos de la clase minoritaria) o submuestreo (reduciendo la clase mayoritaria), asegurando que el árbol aprenda reglas justas para ambas categorías.
¿Cómo evito el sobreajuste al entrenar?
El sobreajuste (overfitting) ocurre cuando tu árbol memoriza los datos de entrenamiento en lugar de aprender patrones generales. Para evitarlo, la estrategia principal es "podar" el árbol. En bibliotecas como scikit-learn, puedes lograr esto configurando hiperparámetros clave durante la instanciación del modelo. Por ejemplo, max_depth limita cuántos niveles puede crecer el árbol, evitando que cree reglas demasiado específicas para cada fila de datos. Otro parámetro útil es min_samples_split, que exige un número mínimo de muestras antes de permitir que un nodo se divida nuevamente. Al restringir el crecimiento del árbol, fuerzas al modelo a enfocarse en las características más importantes y generales, logrando que prediga con mucha más precisión cuando se enfrente a datos nuevos que nunca ha visto.
¿Por qué es mejor limitar la profundidad?
Limitar la profundidad de un árbol de decisión es crucial porque un árbol sin restricciones crecerá hasta que cada hoja contenga una sola muestra. Esto crea un modelo excesivamente complejo, similar a un estudiante que memoriza las respuestas de un examen de práctica pero reprueba el examen real porque no entendió los conceptos. Al establecer un límite con el parámetro max_depth, obligas al algoritmo a detenerse antes de capturar el "ruido" o las anomalías de tus datos. Un árbol menos profundo no solo es más rápido de entrenar y evaluar, sino que también es mucho más fácil de interpretar visualmente. Si necesitas explicarle a tu equipo o a un cliente cómo el modelo está tomando decisiones, un árbol de 3 o 4 niveles es perfectamente comprensible, mientras que uno de 20 niveles es una caja negra inmanejable.
Para este problema se entrenará al árbol bajo un problema de clasificación, lo que significa que necesitará de una variable categórica objetivo
Ahora se convertiremos todas las variables en categorías, para eso se usa la librería category_encoders, luego entrenaremos el modelo en las etiquetas originales (sin categorizar)
\# Transform data import category\_encoders as ce encoder = ce.OrdinalEncoder(cols=list(X.columns)) \# fit data X\_train = encoder.fit\_transform(X\_train) X\_test = encoder.fit\_transform(X\_test) \# import tree libraries from sklearn.tree import DecisionTreeClassifier tree = DecisionTreeClassifier( max\_depth=2, random\_state=42, ) tree.fit(X\_train, Y\_train) y\_pred\_train\_tree = tree.predict(X\_train) y\_pred\_test\_tree = tree.predict(X\_test)
Como yo lo transformé
from sklearn.preprocessing import LabelEncoder X = df.drop('class', axis=1) y = df['class'] encoder = LabelEncoder() for col in X.columns: X[col] = encoder.fit_transform(X[col]) y = LabelEncoder().fit_transform(y)
Es importante tener en cuenta la distinción y el uso de fit y transform en los datos:
¿Qué pasaría si usaras fit_transform() en X_test? Si hicieras encoder.fit_transform(X_test), el encoder aprendería nuevas categorías (o medias/desviaciones) solo de los datos de prueba. Esto significaría que la transformación de X_test podría ser inconsistente con la transformación de X_train. Además, y más importante, estarías permitiendo que información de las estadísticas de X_test (como la existencia de ciertas categorías o el rango de valores) influya en cómo se manejan los datos, lo cual es información que tu modelo no debería "conocer" durante el entrenamiento. Esto sesgaría tu evaluación de rendimiento.
Aquí tienes un ejemplo completo y claro de entrenamiento de un modelo de clasificación con árbol de decisión, usando Python y scikit-learn.
✅ Ejemplo paso a paso: Clasificación con Árbol de Decisión
Usaremos el dataset Iris como ejemplo.
1. Importar librerías
from sklearn.datasets import load_iris from sklearn.tree import DecisionTreeClassifier from sklearn.model_selection import train_test_split from sklearn.metrics import classification_report, accuracy_score
2. Cargar datos
iris = load_iris() X = iris.data # variables predictoras y = iris.target # variable objetivo (0, 1, 2)
3. Dividir en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42 )
4. Entrenar el árbol de decisión
clf = DecisionTreeClassifier(criterion='gini', max_depth=3, random_state=42) clf.fit(X_train, y_train)
5. Predecir y evaluar
y_pred = clf.predict(X_test)
print("Accuracy:", accuracy_score(y_test, y_pred)) print("\nReporte de clasificación:\n", classification_report(y_test, y_pred))
6. (Opcional) Visualizar el árbol
import matplotlib.pyplot as plt from sklearn.tree import plot_tree
plt.figure(figsize=(12, 6)) plot_tree(clf, feature_names=iris.feature_names, class_names=iris.target_names, filled=True) plt.show()
🔍 ¿Qué puedes modificar?
max_depth, criterion, min_samples_split, etc. para ver cómo afecta al rendimiento.pd.read_csv(...)) y reemplaza X e y.Excelente docente
Hola estoy intentando hacer el proyecto final, y hay varias variables categóricas, vi en una de las respuestas a un compañero que dejaste el siguiente link: https://practicaldatascience.co.uk/machine-learning/how-to-encode-categorical-variables-for-machine-learning y estoy usándolo para el proyecto final, en una parte mencionan que usar el df.nunique() y que dependiendo de esto podemos tomar varios caminos, pero hay columnas donde hay 42, como lo es la columna native, y pienso usar el category enconders de esta clase, y cuando reviso como hace el cambio quedo mas perdido, por que segun entiendo ejemplo si lo aplico en sex deberia dar 1 y 0 sea cual sea el genero, pero pasa lo siguiente:
y si miramos el que dice tres puertas despues del category-encoder pasa a ser dos, esto siento que se presta para confusiones, no ? y me gustaria saber si hay alguna forma de corregirlo, como usando el replace:
df['diagnosis'].replace(to_replace='M', value=1, inplace=True) df['diagnosis'].replace(to_replace='B', value=0, inplace=True)
Hola, espero puedan ayudarme.
Entiendo la parte de .fit_transform y .transform en los datos de entrenamiento, que para este ejemplo, es X_train, X_test.
Aquí es donde me estoy perdiendo. Porque no se hace un .transform, a 'y_test' y 'y_train' ? Es decir porque usamos un tipo de dato 'Object', con un 'tipo numero' ?
O donde se hace ese transform al tipo de clase de carro?
Se necesita que Y sea una sola columna
En el primer proceso para X si hay una columna que tiene tres variaciones, el encoder crea tres columnas por cada categoria, entonces = categoria_uno = 0, categoria_dos = 1, categoria_tres = 0, en esa fila el 1 marca la categoria que aplica.
Para Y no podemos tener mas de una columna porque es el Target, se soluciona con ese otro procedimiento que lo que hace es, si en la columna target hay 5 categorias, entonces etiqueta del 1 al 5 cada categoria, tendras una columna con numeros que van marcando 2,3,4,1,5, donde cada numero es una categoria ya transfomada a numeros.
Yo lo hice con One Hot Encoding y LabelEncoder
from sklearn.preprocessing import OneHotEncoder, LabelEncoder encoder = OneHotEncoder(sparse_output=False) X_encoded = encoder.fit_transform(X_train) X_encoded_test = encoder.fit_transform(X_test) label_encoder = LabelEncoder() y_encoded = label_encoder.fit_transform(y_train) y_encoded_test = label_encoder.fit_transform(y_test) ```from sklearn.preprocessing import OneHotEncoder, LabelEncoder encoder = OneHotEncoder(sparse\_output=False) X\_encoded = encoder.fit\_transform(X\_train) X\_encoded\_test = encoder.fit\_transform(X\_test) label\_encoder = LabelEncoder() y\_encoded = label\_encoder.fit\_transform(y\_train) y\_encoded\_test = label\_encoder.fit\_transform(y\_test)