Todo lo que aprendí clasificando flores con Python y Machine Learning

Objetivo: Aprender a clasificar tipos de flores usando modelos de clasificación multiclase (como Logistic Regression y Decision Tree).

---

📘 Temario del Curso

1. Introducción al problema

• ¿Qué es el dataset Iris?

• ¿Por qué es ideal para clasificación multiclase?

2. Carga y exploración de datos

• Cargar el dataset con sklearn.datasets

• Visualización básica con seaborn.pairplot o sns.heatmap

• Revisión de clases: setosa, versicolor, virginica

3. Preprocesamiento

• Separar features y etiquetas

• Dividir en train/test

• Escalado con StandardScaler

4. Entrenamiento de modelos

• Logistic Regression (multiclase)

• Decision Tree Classifier

• (Opcional) KNN Classifier

5. Evaluación

• Accuracy, Confusion Matrix

• Visualización de resultados

• ¿Qué modelo funcionó mejor?

6. Conclusiones

• ¿Qué aprendiste?

• ¿Qué errores cometiste y cómo los resolviste?

🪷 Curso 2: Clasificación Multiclase con el Dataset Iris

🔸 Paso 1: Introducción al problema

🎯 Objetivo:

Vamos a entrenar modelos de clasificación para predecir el tipo de flor basado en medidas como largo y ancho de los pétalos y sépalos.
Este es un clásico problema de clasificación multiclase, porque hay tres tipos de flores:

• setosa

• versicolor

• virginica

📂 Dataset: Iris

Este dataset viene incluido en sklearn.datasets, así que no necesitas descargarlo manualmente.

Cada fila representa una flor y contiene estas columnas:

🧠 ¿Por qué es un buen ejemplo?

• Tiene pocas columnas → fácil de visualizar

• Clases bien separadas → modelos funcionan bien

• Permite aplicar varios algoritmos de forma simple

📌 Tu misión para este paso:

1. Crea un nuevo notebook llamado iris-classification.ipynb.

2. Agrega una celda de texto donde expliques qué vas a hacer en este análisis (puedes usar parte de lo que viste arriba).

3. Prepara una celda de código donde importes las librerías:

import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

from sklearn.datasets import load_iris

🔸 Paso 2: Carga y exploración del dataset

📥 1. Cargar el dataset

El dataset Iris viene con sklearn.datasets, así que lo puedes cargar así:

from sklearn.datasets import load_iris

# Carga el dataset
iris = load_iris()

# Crea un DataFrame con los datos
df = pd.DataFrame(data=iris.data, columns=iris.feature_names)

# Agrega la columna de etiquetas (target)
df['target'] = iris.target

# Mapea los números a nombres de flores
df['target_name'] = df['target'].map(lambda i: iris.target_names[i])

🔍 2. Explora los datos

Te dejo algunas cosas que puedes hacer para entender bien el dataset:

📊 Revisa las primeras filas

df.head()

| |
sepal length (cm) | sepal width (cm) | petal length (cm) | petal width (cm) | target | target_name | | --- | --- | --- | --- | --- | --- | --- | | 0 | 5.1 | 3.5 | 1.4 | 0.2 | 0 | setosa | | 1 | 4.9 | 3.0 | 1.4 | 0.2 | 0 | setosa | | 2 | 4.7 | 3.2 | 1.3 | 0.2 | 0 | setosa | | 3 | 4.6 | 3.1 | 1.5 | 0.2 | 0 | setosa | | 4 | 5.0 | 3.6 | 1.4 | 0.2 | 0 | setosa |

🧠 Checa clases únicas

df['target_name'].value_counts()

target_name
setosa        50
versicolor    50
virginica     50
Name: count, dtype: int64

📈 Visualización rápida con pairplot

sns.pairplot(df, hue='target_name')
plt.show()

Esto te va a mostrar cómo se separan las clases según los pares de variables.

📌 Tu misión para este paso:

1. Carga el dataset como arriba.

2. Haz una mini exploración del DataFrame.

3. Genera un pairplot o un heatmap para empezar a ver patrones visuales.

4. Agrega en una celda Markdown tus observaciones: ¿ves clases separadas?, ¿qué columnas parecen más útiles?, etc.

🔸 Paso 3: Preprocesamiento

🎯 Objetivo:

Preparar los datos para entrenar los modelos. Vamos a:

1. Separar features y etiquetas

2. Dividir los datos en entrenamiento y prueba

3. Escalar las variables para que todos los modelos funcionen bien

---

✂️ 1. Separar features y etiquetas

# Variables independientes (features)
X = df[iris.feature_names]

# Variable dependiente (target numérico)
y = df['target']

---

🧪 2. Dividir en entrenamiento y prueba

Esto es importante para evaluar si el modelo generaliza bien.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

stratify=y asegura que haya la misma proporción de clases en train y test.

---

⚖️ 3. Escalar las variables

Aunque los datos ya tienen un rango razonable, muchos modelos se benefician del escalado.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

📌 Tu misión para este paso:

1. Separa X y y

2. Divide el dataset con train_test_split

3. Escala los datos con StandardScaler

4. (Opcional) Puedes imprimir la media y desviación estándar para comprobar:

print("Media:", X_train_scaled.mean(axis=0))
print("Desviación estándar:", X_train_scaled.std(axis=0))

Media: [-1.20829273e-15 -2.03679666e-15  4.99600361e-16  1.67458640e-15]
Desviación estándar: [1. 1. 1. 1.]

🔸 Paso 4: Entrenamiento de modelos 🤖

🎯 Objetivo:

Entrenar múltiples modelos de clasificación y compararlos.

Vamos a usar:

• LogisticRegression (regresión logística multiclase)

• DecisionTreeClassifier

• (Opcional) KNeighborsClassifier

---

🔁 1. Entrena modelos

from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier

# Logistic Regression
lr_model = LogisticRegression(max_iter=200)
lr_model.fit(X_train_scaled, y_train)

# Decision Tree
dt_model = DecisionTreeClassifier()
dt_model.fit(X_train, y_train)  # Este modelo no necesita escalado

# K-Nearest Neighbors (opcional)
knn_model = KNeighborsClassifier()
knn_model.fit(X_train_scaled, y_train)

Nota: algunos modelos como DecisionTree o RandomForest no necesitan escalado, pero otros como KNN o Logistic Regression sí.

📌 Tu misión para este paso:

1. Entrena mínimo 2 modelos (Logistic y Tree).

2. Puedes entrenar también KNN si quieres probar otro.

3. Guarda los modelos en variables para usarlos después.

🔸 Paso 5: Evaluación de modelos 🧪📊

🎯 Objetivo:

Comparar el rendimiento de los modelos y ver cuál clasifica mejor las flores.

---

✅ 1. Accuracy (precisión general)

from sklearn.metrics import accuracy_score

# Logistic Regression
y_pred_lr = lr_model.predict(X_test_scaled)
print("Logistic Regression Accuracy:", accuracy_score(y_test, y_pred_lr))

# Decision Tree
y_pred_dt = dt_model.predict(X_test)
print("Decision Tree Accuracy:", accuracy_score(y_test, y_pred_dt))

# KNN (si lo usaste)
y_pred_knn = knn_model.predict(X_test_scaled)
print("KNN Accuracy:", accuracy_score(y_test, y_pred_knn))

Logistic Regression Accuracy: 0.9333333333333333
Decision Tree Accuracy: 0.9666666666666667
KNN Accuracy: 0.9333333333333333

---

🔄 2. Matriz de confusión

Visualiza los errores de clasificación por clase.

from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

cm = confusion_matrix(y_test, y_pred_lr)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=iris.target_names,
            yticklabels=iris.target_names)
plt.title("Confusion Matrix - Logistic Regression")
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.show()

Haz lo mismo para los otros modelos si quieres compararlos.

📌 Tu misión para este paso:

1. Evalúa la accuracy de todos los modelos.

2. Muestra al menos una matriz de confusión.

3. Agrega una celda Markdown con tus observaciones:

   • ¿Qué modelo rindió mejor?

   • ¿Se equivocó mucho en alguna clase?

   • ¿Algún patrón interesante?

🌺 Conclusiones: ¿Qué aprendí clasificando flores?

Después de analizar el dataset Iris y entrenar varios modelos de clasificación multiclase, confirmé varias cosas:

• El dataset está muy bien estructurado: Las clases están bastante separadas y es fácil visualizarlas, lo que lo convierte en un clásico perfecto para aprender.

• Logistic Regression y Decision Tree funcionan muy bien, pero tienen fortalezas distintas. La regresión logística fue más estable, mientras que el árbol fue más interpretativo.

• Escalar los datos sí hace la diferencia, especialmente en modelos como KNN y regresión logística.

• Visualizar la matriz de confusión me ayudó a entender en qué tipo de flores se equivocaban los modelos y por qué.

Este proyecto me ayudó a afianzar los fundamentos de clasificación multiclase y a comprender mejor cómo se comportan distintos modelos frente a un problema sencillo pero ilustrativo. Es un gran paso después del Titanic, y me deja listo para enfrentar datasets más complejos.

---

👉 ¿Qué sigue? ¡Vamos por modelos de regresión!
En el próximo curso analizaré precios de casas y aplicaré regresión lineal para predecir valores continuos.
Si te gustó este análisis, sígueme para más notebooks y proyectos explicados desde cero.