Entrenamiento de modelo de clasificación con árbol de decisión

Cursos Empresas Blog Live Conf Precios

Contenido del curso

Introducción a árboles de decisión

Proyecto práctico: árboles de decisión

Introducción a random forest

Proyecto práctico: random forest

20
Entrenamiento de modelo de clasificación de carros con random forest
04:28 min
21
Evaluación de resultados del modelo de clasificación con random forest
11:34 min

Conclusión

Tomar examen

Entrenamiento de modelo de clasificación con árbol de decisión

Comentarios

FELIX DAVID CORDOVA GARCIA

student

Usar el OrdinalEncoder de Scikit-learn para no instalar nada mas

Luego ese X se pasa en el train_test_split, tambien se podría haber hecho con el X_train y el X_test por separado pero toma mas tiempo XD

Layla Scheli

teacher

Gracias Felix por tu aportacion :)

Nestor Ramirez

student

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

Sergio Andrés Majé Franco

student

['buying', 'maint', 'doors', 'persons', 'lug_boot', 'safety']

Agustín Hernández Serpa

student

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.

Jair Machuca

student

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.

Germán Alejandro Niño

student

Cual es la diferencia entre fit_transform y transform usando OrdinalEncoder?

Layla Scheli

teacher

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.

Isabel Fernández

student

Este modelo queda estandar para usarlo en cualquier data que se requiera clasificación, o en qué puede variar el modelo?

Layla Scheli

teacher

Si :) tmb regresion. Es decir aplica a ambos! Gracias

LUIS GUILLERMO MONCADA RUIZ

student

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?

Layla Scheli

teacher

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!

Carlos Mazzaroli

student

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?

Layla Scheli

teacher

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!

Andrés Camilo Cala Gómez

student

Hola, no entiendo cual es la diferencia entre usar get_dummies para transformar las variables categoricas y category_encoders?

Layla Scheli

teacher

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

https://practicaldatascience.co.uk/machine-learning/how-to-encode-categorical-variables-for-machine-learning

Anthony Ismael Manotoa Moreno

student

Usa get_dummies cuando tengas pocas categorías
Usa OrdinalEnconder cuando tengas varias categorías y especialmente si son ordinales

Antonio Demarco Bonino

student

Me estoy imaginando como extrapolar este árbol a otras industrias y otros problemas a resolver. Me encanta.

Sebastián Franco

student

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)

Juan Acevedo

student

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)

David Felipe Zabala Castañeda

student

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.

Mario Alexander Vargas Celis

student

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?

Cambia max_depth, criterion, min_samples_split, etc. para ver cómo afecta al rendimiento.
Usa tus propios datos (pd.read_csv(...)) y reemplaza X e y.

Ronald Andrey Beltran Parada

student

Excelente docente

Diego Andrés Rojas Pinzón

student

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:

entiendo que de pronto el category enconders habra puesto el 1 para los carros de 5more, pero como hago para saber cual es cual. y asi poder entender un poco mas, gracias.

Diego Andrés Rojas Pinzón

student

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)

Alan Hugo Martinez Rodriguez

student

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?

Abinadi Contreras

student

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)

Daniel Andres Rojas Paredes

student

Thanks! Here's your corrected message first:

First, encode all variables and apply the scaler — correct? How should I pick the depth of my decision tree based on the quantity of training data? Are there other factors I should take into account to decide this hyperparameter?

✅ Confidence: High

You're asking two important things related to preprocessing and model tuning. Let's break it down:

1. First encoding and scaling — is that correct?

✅ Yes, but with a nuance depending on the model:

For Decision Trees (and Random Forests, etc.):
- Encoding categorical variables is required.
- Scaling is not necessary — these models are scale-invariant.
For linear models, KNN, SVM, and most neural networks:
- Encoding is required.
- Scaling is also required, especially with distance-based or gradient-based models.

2. How to pick the depth of your Decision Tree based on training data size?

There's no fixed rule, but here’s how to approach it:

✅ Basic heuristics (data-dependent):

A deeper tree can model more complex patterns, but also increases risk of overfitting, especially with small datasets.
A shallow tree might underfit if your data has many features or complex structure.

🧠 Rule of thumb:

Start with:max_depth ≈ log2(n_samples) Example: 1000 training samples → log2(1000) ≈ 10

📊 Better approach: Cross-validation tuning

Use GridSearchCV or RandomizedSearchCV from sklearn to find the best depth by validating performance across folds:

from sklearn.model_selection import GridSearchCV from sklearn.tree import DecisionTreeClassifier

params = {'max_depth': list(range(2, 20))} grid = GridSearchCV(DecisionTreeClassifier(), params, cv=5) grid.fit(X_train, y_train)

print("Best max_depth:", grid.best_params_['max_depth'])

3. Other factors to consider when choosing max_depth:

Number of features: More features might justify deeper trees.
Noise in the data: Noisy datasets benefit from shallower trees to generalize better.
Imbalanced classes: Deep trees can overfit to dominant classes.
Model interpretation: Shallower trees are easier to interpret (good for explainability).

Let me know if you're doing this for classification or regression — I can tailor the guidance more specifically.

Julián Cárdenas

student

El código de la clase: #Importante: todos nuestros tipos de datos son object, realizamos una transformacion !pip install category-encoders import category_encoders as ce **

cols = ['buying', 'maint', 'doors', 'persons','lug_bot', 'safety']
encoder = ce.OrdinalEncoder(cols = ['buying', 'maint', 'doors', 'persons','lug_bot', 'safety'])

X_train = encoder.fit_transform(X_train)

X_test = encoder.transform(X_test)

#Verificamos la transformacion
X_train.head ()

#Importar árbol de decisión
from sklearn.tree import DecisionTreeClassifier
#Creacion del modelo
tree = DecisionTreeClassifier(max_depth=2 , random_state= 0)

#Entrenamiento
tree.fit(X_train, Y_train)

#Calculo de las predicciones en Train y Test
Y_train_pred_tree = tree.predict(X_train)
Y_test_pred_tree = tree.predict(X_test)

#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

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

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)

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)

cols = ['buying', 'maint', 'doors', 'persons','lug_bot', 'safety']
encoder = ce.OrdinalEncoder(cols = ['buying', 'maint', 'doors', 'persons','lug_bot', 'safety'])

X_train = encoder.fit_transform(X_train)

X_test = encoder.transform(X_test)

Introducción a árboles de decisión

¿Qué son los árboles de decisión?

Tu primer árbol de decisión con scikit-learn

Análisis de datos para tu primer árbol de decisión

Entrenamiento y evaluación de árbol de decisión con scikit-learn

¿Cómo funcionan los árboles de decisión?

¿Cuándo usar árboles de decisión?

Proyecto práctico: árboles de decisión

Conociendo problema a resolver y dataset de clasificación

Análisis exploratorio de datos para árbol de decisión

Procesamiento de datos para el entrenamiento de árbol de decisión