Tarea: Implementación de un Perceptrón para Clasificación Binaria

🎯 Objetivo

El objetivo de esta tarea es diseñar e implementar un perceptrón multicapa (MLP) con al menos una capa oculta para resolver un problema de clasificación binaria. El ejercicio busca que el estudiante aplique los conceptos fundamentales de las redes neuronales artificiales: funciones de activación, propagación hacia adelante (forward propagation), retropropagación del error (backpropagation), ajuste de pesos y evaluación de desempeño.

Al finalizar, el estudiante será capaz de modelar un problema donde, a partir de múltiples variables numéricas, se predice una variable categórica dicotómica (benigno/maligno).

Instrucciones

• Utiliza el conjunto de datos Breast Cancer Wisconsin disponible en el siguiente enlace: https://raw.githubusercontent.com/marsgr6/rna-online/refs/heads/main/data/breast_cancer.csv
• Implementa un modelo de perceptrón con al menos una capa oculta.
• Entrena el modelo con un conjunto de entrenamiento y evalúalo en un conjunto de prueba.
• Visualiza la matriz de confusión y reporta las métricas de desempeño (precisión, recall, F1-score).
• Comenta brevemente los resultados obtenidos.

Tiempo estimado: 2 horas

Dataset

El dataset Breast Cancer Wisconsin, disponible en sklearn.datasets, contiene datos clínicos utilizados para diagnosticar tumores mamarios como malignos o benignos, a partir de características extraídas de imágenes digitales de células obtenidas por aspiración con aguja fina (FNA).

🔍 Descripción de las variables

El dataset tiene 30 variables numéricas (todas ya preprocesadas), agrupadas en 10 atributos básicos calculados para tres estadísticos: media, desviación estándar y valor peor ("worst" o máximo).

Aquí están los atributos y su agrupación (10 variables $\times$ 3 atributos - mean, se, worst):

Categoría	Variable base	Estadísticos disponibles
1. Tamaño del núcleo	radius	mean, se, worst
2. Textura	texture	mean, se, worst
3. Perímetro	perimeter	mean, se, worst
4. Área	area	mean, se, worst
5. Suavidad	smoothness	mean, se, worst
6. Compacidad	compactness	mean, se, worst
7. Concavidad	concavity	mean, se, worst
8. Puntos cóncavos	concave points	mean, se, worst
9. Simetría	symmetry	mean, se, worst
10. Dimensión fractal	fractal dimension	mean, se, worst

Estas variables permiten evaluar la forma, tamaño y consistencia del núcleo celular para predecir si un tumor es cancerígeno.

🧪 Variable objetivo

• target:

  • 0 → maligno (malignant)
  • 1 → benigno (benign)

📊 Tipo de problema

• Clasificación binaria: el objetivo es asignar cada muestra a una de dos clases mutuamente excluyentes.

• En este caso, se busca diagnosticar si un tumor es:

  • 0 → maligno (cáncer)
  • 1 → benigno (no cáncer)

⚙️ Clasificación binaria con un MLP

1) ¿Qué queremos predecir?

• Objetivo: decidir si cada caso es maligno (0) o benigno (1).
• Tipo de variable a modelar: categórica binaria (dos clases).

2) ¿Con qué información?

• Entradas (X): 30 medidas numéricas del tumor (radio, textura, área, etc.).
• Salida (y): etiqueta 0/1 (maligno/benigno).

3) Pasos del proceso (alto nivel)

1. Definir el problema

   • Es un problema de clasificación binaria.
   • La clase positiva será la que el modelo reporta como probabilidad (en este caso, benigno).

2. Preparar los datos

   • Verificar datos faltantes y tipos.
   • Separar características (X) y objetivo (y).
   • Dividir en entrenamiento y prueba manteniendo la proporción de clases.

3. Estandarizar características

   • Escalar las variables numéricas para que el MLP entrene de forma estable.
   • (Concepto: llevar todas las variables a una escala comparable.)

4. Configurar el MLP (conceptualmente)

   • Entrada: una unidad por cada variable de X.
   • Capas ocultas: 1–2 capas que aprenden patrones no lineales.
   • Salida: una unidad que devuelve una probabilidad de pertenecer a la clase 1 (benigno).

5. Entrenar

   • El modelo aprende ajustando pesos para minimizar el error entre predicciones y etiquetas.
   • (Concepto: retropropagación + actualización iterativa).

6. Predecir y decidir

   • El modelo entrega una probabilidad por muestra.
   • Regla simple: ≥ 0.5 → clase 1 (benigno), < 0.5 → clase 0 (maligno).
   • (Si el problema lo requiere, el umbral puede ajustarse según la métrica prioritaria.)

7. Evaluar

   • Matriz de confusión para ver aciertos/errores por clase.
   • Precisión (accuracy) como vista general.
   • Recall y Precision para entender falsos negativos/positivos.
   • F1-score como equilibrio entre precision y recall.
   • (Si las clases están desbalanceadas, considerar ROC-AUC o curva PR.)

8. Comentar resultados

   • ¿Dónde acierta más? ¿Dónde falla?
   • ¿Qué implican los errores para el problema clínico?
   • ¿Qué mejorarías (más datos, selección de variables, calibración de umbral, etc.)?

🧭 Mini–guía para estudiantes (checklist)

• [ ] Identifiqué X (30 variables) y y (0/1).
• [ ] Separé datos en train/test manteniendo la proporción de clases.
• [ ] Apliqué escalado a las características.
• [ ] Entrené un MLP con al menos una capa oculta.
• [ ] Obtuve probabilidades y clases (con umbral 0.5).
• [ ] Reporté matriz de confusión, accuracy, precision, recall, F1 (y ROC-AUC si procede).
• [ ] Analicé brevemente los errores y propuse mejoras.

🧠 Opción 1 - Low Code: Clasificación binaria con MLPClassifier

En esta tarea trabajarás con un conjunto de datos de cáncer de mama y aplicarás una red neuronal multicapa (MLP) para clasificar los diagnósticos como benignos o malignos. Solo necesitarás modificar algunas partes específicas del código indicadas con # 👈 CAMBIA AQUÍ.

📌 1. Cargar los datos y explorar la variable objetivo

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

# Leer el archivo CSV desde GitHub
df = pd.read_csv("https://raw.githubusercontent.com/marsgr6/rna-online/refs/heads/main/data/breast_cancer.csv")

# Visualizar frecuencias de la variable objetivo
plt.figure(figsize=(8, 6))
ax = sns.countplot(
    data=df,
    x="columna_a_modelar",   # 👈 CAMBIA AQUÍ, columna_a_modelar por el nombre de la columna a modelar
    hue="columna_a_modelar", # 👈 CAMBIA AQUÍ, columna_a_modelar por el nombre de la columna a modelar
    palette={'maligno': 'tomato', 'benigno': 'steelblue'}
)
for container in ax.containers:
    ax.bar_label(container, label_type='edge', padding=2)
plt.title("Distribución de la variable objetivo")
plt.xlabel("Clase")
plt.ylabel("Frecuencia")
plt.tight_layout()
`

🔍 2. Visualización por pares de algunas variables numéricas

# Seleccionar algunas variables numéricas (puedes cambiar)
features = ['mean radius', 'mean texture', 'mean perimeter', 'mean area', 'mean smoothness']  # 👈 CAMBIA AQUÍ si deseas otras variables

# Pairplot para explorar relaciones entre variables
sns.pairplot(data=df[features + ['target']], hue='target', palette={'maligno': 'tomato', 'benigno': 'steelblue'})
plt.suptitle("Visualización por pares de variables", y=1.02)

🧪 3. Separar conjunto de entrenamiento y prueba

from sklearn.model_selection import train_test_split

# Definir variables X e y
X = df.drop(columns=['target'])  
y = df['target'] 

# Separar datos (ej. 70% entrenamiento, 30% prueba)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, stratify=y, random_state=42  # 👈 CAMBIA AQUÍ el porcentaje si deseas
)

⚙️ 4. Escalar los datos

from sklearn.preprocessing import StandardScaler

# Normalizar características numéricas
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(datos_de_entrenamiento)  # 👈 CAMBIA AQUÍ datos_de_entrenamiento, usa X_train
X_test_scaled = scaler.transform(datos_de_prueba)  # 👈 CAMBIA AQUÍ datos_de_prueba, usa X_test

🤖 5. Entrenar el modelo MLP

from sklearn.neural_network import MLPClassifier

# Crear y entrenar el modelo
mlp = MLPClassifier(hidden_layer_sizes=(numero_de_nueronas,), max_iter=1000, random_state=42)  # 👈 CAMBIA AQUÍ numero_de_nueronas por un valor numérico entero 
mlp.fit(X_train_scaled, y_train)

📊 6. Evaluación del modelo

from sklearn.metrics import classification_report, ConfusionMatrixDisplay

# Realizar predicciones
y_pred = mlp.predict(test_data)  # 👈 CAMBIA AQUÍ test_data, usa X_test_scaled

# Reporte de clasificación
print("\nReporte de clasificación:\n", classification_report(y_test, y_pred))

# Matriz de confusión
ConfusionMatrixDisplay.from_predictions(
    y_test,
    y_pred,
    display_labels=['Benigno', 'Maligno'], 
    cmap='Blues',
    colorbar=False
)
plt.title("Matriz de confusión")
plt.grid(False)
plt.tight_layout()

✅ Recomendaciones finales

• Comenta cada bloque que modifiques.

• Puedes probar con diferentes:

  • Variables predictoras
  • Porcentajes de partición
  • Neuronas ocultas
  • Funciones de activación (MLPClassifier(..., activation='relu'))

Reflexión

Comente brevemente los resultados obtenidos: ¿el modelo clasificó correctamente la mayoría de los casos? ¿Qué métricas destacan? ¿Qué podría mejorar en una siguiente iteración?

📝 Opción 2- Informe Ejecutivo: Clasificación de Diagnóstico de Cáncer de Mama con MLPClassifier

Elabore un informe, de máximo 3 páginas, describiendo el proceso seguido para entrenar un modelo de red neuronal multicapa (MLP) utilizando datos clínicos de diagnóstico de cáncer de mama. El objetivo fue clasificar los tumores como benignos o malignos, a partir de medidas obtenidas de imágenes médicas. A continuación se detalla el proceso seguido, dividido en seis etapas clave. Analice cada sección utilizando las figuras y resultados proporcionados.

1. Frecuencia de la Variable Objetivo

Describa la distribución de las clases maligno y benigno en el conjunto de datos. Analice si existe desbalance y qué implicaciones podría tener.

2. Visualización de Variables Numéricas

Comente las relaciones visuales entre las variables numéricas seleccionadas. ¿Qué patrones o separaciones observas entre las clases?

3. División de Datos: Entrenamiento y Prueba

Explique cómo se dividió el conjunto de datos (porcentaje, estratificación) y justifique si es adecuado para este tipo de problema.

4. Escalamiento de Variables

Justifique el uso de StandardScaler. ¿Qué importancia tiene el escalamiento previo al entrenamiento de una red neuronal?

5. Modelado con MLPClassifier

Describa brevemente la arquitectura utilizada (número de capas, neuronas, iteraciones) y la función del modelo MLPClassifier.

6. Evaluación del Modelo

a) Matriz de Confusión

Analice el desempeño del modelo con base en los valores observados en la matriz de confusión.

b) Reporte de Clasificación

Comente los valores de precisión, recall y F1-score. ¿El modelo clasifica bien ambas clases?

Reporte de clasificación:
               precision    recall  f1-score   support

     benigno       0.98      0.99      0.99       107
     maligno       0.98      0.97      0.98        64

    accuracy                           0.98       171
   macro avg       0.98      0.98      0.98       171
weighted avg       0.98      0.98      0.98       171

✅ Conclusión

Redacte una conclusión ejecutiva sobre el desempeño general del modelo, su aplicabilidad al problema de diagnóstico médico, y posibles mejoras futuras.

🧠 Opción 3 – Libre elección de dataset y problema

En esta tarea, el estudiante podrá seleccionar el conjunto de datos con el que desea trabajar.

• Si no dispone de un dataset, se recomienda utilizar MNIST como referencia.
• Se sugiere escoger un problema de clasificación o regresión propio, siempre que no se repita alguno de los datasets ya empleados en el contenido y ejercicios del curso (ej.: Breast Cancer, Diabetes, Fashion-MNIST, Bike Sharing, Fraud Detection).
• El trabajo puede desarrollarse en Google Colab, asistido por Gemini AI, ya sea en modalidad high-code (escribir el código completo) o no-code (apoyarse más en Gemini para generar bloques de código automáticamente).

📌 1. Cargar y explorar los datos

• Subir el archivo CSV/Excel o importar el dataset desde una librería pública (sklearn.datasets, tensorflow.keras.datasets, openml, etc.).

⚙️ 2. Preparar el conjunto de datos

• Definir variables predictoras (X) y la variable objetivo (y).
• Dividir en entrenamiento y prueba (train_test_split).
• Normalizar características numéricas con StandardScaler u otra técnica adecuada.

🤖 3. Seleccionar y entrenar un modelo

• Para clasificación: MLPClassifier
• Para regresión: MLPRegressor
• Permitir variaciones en hiperparámetros: número de neuronas, capas ocultas, funciones de activación.

📊 4. Evaluación

• Clasificación: matriz de confusión, accuracy, precision, recall, F1-score.
• Regresión: métricas como MAE, RMSE y R².

• Visualizaciones adicionales:

  • Clasificación → gráficas de predicciones vs. reales.
  • Regresión → scatter plot de y_true vs. y_pred.

✅ Recomendaciones finales

• Comentar cada bloque de código generado o modificado.

• Documentar brevemente:

  • ¿Por qué se eligió ese dataset?
  • ¿Qué métricas destacan del modelo entrenado?
  • ¿Qué posibles mejoras se implementarían en una segunda iteración?

🧠 Opción 4 – Libre elección de dataset en KNIME

En esta tarea, el estudiante podrá seleccionar el dataset con el que desea trabajar en KNIME.

• Si no cuenta con un dataset propio, se recomienda utilizar MNIST (para clasificación) o un dataset público de regresión disponible en UCI Machine Learning Repository.
• La consigna es plantear un problema de clasificación o regresión, diferente de los datasets ya usados en el curso.

📌 1. Importación de datos

• Utilizar el nodo File Reader o Excel Reader para cargar el dataset.
• Verificar nombres de columnas y tipos de datos con Data Explorer.

⚙️ 2. Preprocesamiento

• Normalización con Normalizer (para X y, si aplica, también para y).
• División en entrenamiento y prueba con Partitioning.

🤖 3. Modelado

• Para clasificación:

  • MLP Learner.

• Para regresión:

  • MLP Learner (regresión).

Entrenar el modelo y conectar con el nodo Predictor.

📊 4. Evaluación

• Clasificación: usar Scorer para matriz de confusión, accuracy, precision y recall.
• Regresión: usar Numeric Scorer para MAE, RMSE y R².

✅ Recomendaciones finales

• Documentar el flujo KNIME con Annotation nodes para explicar cada bloque.
• Guardar capturas del flujo completo y de los resultados principales.