ETAPA 01 EL MAPA DEL TP
Qué te están pidiendo, traducido
El TP tiene 6 puntos que parecen independientes pero en realidad cuentan una sola historia: entrenar un clasificador binario y demostrar que entendés qué pasó adentro. Esta tabla traduce cada punto y te dice en qué etapa de esta guía lo aprendés.
| Punto del TP | Qué significa en realidad | Etapa |
|---|---|---|
| 1. Estudiar Keras Sequential | Aprender la librería de Python con la que se arman redes apilando capas como bloques. | 05 |
| 2. Dataset binario en Hugging Face | Elegir datos donde cada fila pertenece a una de 2 clases posibles (spam/no spam, enfermo/sano...). | 06 |
| 3. Crear una red neuronal | Diseñar un MLP: cuántas capas, cuántas neuronas, qué activaciones. | 02–05 |
| 4. Simular un overfitting | Hacer que la red memorice a propósito, y mostrar las curvas que lo delatan. | 07 |
| 5. Variar ≥4 hiperparámetros | Cambiar las "perillas" del entrenamiento de a una, medir y explicar el efecto. | 08 |
| 6. Matriz de confusión + métrica | Mostrar en qué se equivoca el modelo y elegir el número correcto para juzgarlo. | 09 |
ETAPA 02 LA UNIDAD BÁSICA
La neurona: una cuenta muy simple
Olvidate de la biología. Una neurona artificial es una función matemática chiquita que hace tres cosas:
- Recibe números de entrada (
x₁, x₂, ...) — por ejemplo, las columnas de una fila de tu dataset. - Multiplica cada entrada por un peso (
w) y suma un sesgo (b, "bias"). - Pasa el resultado por una función de activación que decide "cuánto se prende" la neurona.
Los pesos y el bias son los parámetros: los números que la red va a ajustar sola durante el entrenamiento. Al principio son aleatorios; al final, codifican lo aprendido. Guardate esta palabra — parámetro — porque en la etapa 08 la vamos a contrastar con hiperparámetro.
Esta neurona tiene una sola entrada x. Movés el peso y el bias, y ves cómo cambia su salida σ(w·x + b). La salida siempre queda entre 0 y 1 — por eso sigmoid es la activación de salida en clasificación binaria: se lee como probabilidad de ser clase 1.
salida = σ() = → la red diría:
w = 0. La salida deja de depender de x: la neurona quedó "muerta", siempre dice lo mismo. Después poné w = 5: la curva se vuelve casi un escalón — la neurona se vuelve muy "decidida". El bias b corre la curva a izquierda/derecha: mueve el umbral de decisión.Una neurona sola apenas puede trazar una frontera recta entre dos clases. Para problemas reales necesitamos muchas trabajando en equipo. Eso es la red.
ETAPA 03 LA ARQUITECTURA
El MLP: neuronas en capas
MLP = Multi-Layer Perceptron, "perceptrón multicapa". Es lo que el título del TP te pide construir. La idea: apilar neuronas en capas, donde cada neurona de una capa recibe las salidas de todas las neuronas de la capa anterior (por eso en Keras estas capas se llaman Dense, densas: todas conectadas con todas).
Capa de entrada
No calcula nada: son tus datos. Tiene tantos valores como features (columnas) tenga tu dataset. Si tu dataset tiene 8 columnas predictoras, la entrada es de tamaño 8.
Capas ocultas
Acá ocurre la magia: cada capa transforma los datos y aprende patrones cada vez más abstractos. Cuántas capas y cuántas neuronas por capa lo decidís vos — son hiperparámetros.
Capa de salida
Para clasificación binaria: 1 sola neurona con sigmoid. Devuelve un número entre 0 y 1 = probabilidad de clase 1. Si ≥ 0.5 → predice 1; si no → 0.
¿Por qué capas ocultas?
Sin ellas (y sin activaciones no lineales), la red entera colapsa a una recta: solo separaría clases linealmente separables. Las capas ocultas + activaciones le dan poder para dibujar fronteras curvas y complejas.
Las funciones de activación
Si entre capa y capa solo hubiera sumas y multiplicaciones, apilar capas sería inútil (una composición de funciones lineales es otra función lineal). La activación mete la no linealidad que hace que apilar capas sirva. Las tres que tenés que conocer:
relu en las capas ocultas (rápida, funciona bien casi siempre), sigmoid en la capa de salida (porque tu problema es binario). No hace falta más sofisticación que eso.ETAPA 04 EL ENTRENAMIENTO
Cómo aprende: error, gradiente y repetición
Entrenar una red es un ciclo de cuatro pasos que se repite miles de veces:
- Predecir: la red recibe ejemplos y produce salidas con sus pesos actuales (al principio, basura aleatoria).
- Medir el error: una función de pérdida (loss) compara predicción vs. respuesta real y devuelve un número: cuanto más alto, peor. Para clasificación binaria se usa
binary_crossentropy, que castiga mucho a la red cuando está confiada y equivocada. - Calcular el gradiente (backpropagation): con derivadas, la red calcula para cada peso en qué dirección moverlo para que la loss baje. No necesitás saber derivar a mano: Keras lo hace solo. Lo que sí tenés que entender es la idea:
- Ajustar: cada peso se mueve un pasito en esa dirección. El tamaño del paso lo controla el learning rate.
La bolita busca el mínimo de la "loss". Elegí un learning rate y dale pasos. Mirá qué pasa con LR chico, razonable y demasiado grande.
pasos: 0 · loss actual: —
Epochs y batches: el vocabulario del fit()
| Término | Qué es |
|---|---|
epoch | Una pasada completa por todo el dataset de entrenamiento. Entrenar 50 epochs = la red vio cada ejemplo 50 veces. |
batch | La red no procesa todo el dataset de golpe: lo come en grupitos (ej. de 32 ejemplos) y ajusta pesos después de cada grupito. batch_size es el tamaño del grupito. |
optimizer | La estrategia para dar los pasos. adam es el estándar: adapta el learning rate solo y casi siempre anda bien. |
ETAPA 05 LA HERRAMIENTA
Keras Sequential: la red en 15 líneas
Keras es la API de alto nivel de TensorFlow para armar redes en Python. El modelo Sequential es su forma más simple: una pila de capas donde los datos fluyen de la primera a la última, sin desvíos. Para un MLP es exactamente lo que necesitás.
Tocá cada línea para ver qué hace y cómo se conecta con lo que ya viste:
Sequential) → configuración (compile) → entrenamiento (fit) → evaluación (predict). Todo TP de Keras tiene esa columna vertebral. Lo único que cambia entre proyectos son los números — y esos números son tus hiperparámetros.ETAPA 06 LOS DATOS
El dataset: elegí bien y te ahorrás la mitad del TP
Hugging Face (huggingface.co/datasets) es un repositorio público de datasets y modelos. El TP te pide elegir uno de clasificación binaria: cada fila tiene features (columnas con datos) y una etiqueta que vale 0 o 1.
Criterios para elegir (en serio, esto define tu TP)
- Tabular o texto corto, no imágenes. Un dataset tabular (números en columnas) entra directo a un MLP. Las imágenes piden otras arquitecturas (CNN) y te complican todo sin sumar nota.
- Tamaño manejable: entre ~1.000 y ~100.000 filas. Menos: no alcanza para aprender. Más: cada experimento tarda y tenés que correr muchos (etapa 08).
- Etiqueta claramente binaria: 0/1, yes/no, positive/negative.
- Mirá el balance de clases: ¿hay 50/50 de cada clase, o 95/5? No descartes uno desbalanceado — pero anotalo, porque define qué métrica vas a elegir en la etapa 09 (y eso te da material jugoso para el informe).
Ejemplos típicos que andan bien con MLP: predicción de churn de clientes, aprobación de créditos, diabetes/enfermedad cardíaca (Pima, heart-disease), spam, calidad de vino binarizada, Titanic.
El split: la regla más importante de todo el TP
Nunca evalúes la red con los mismos datos con los que entrenó — sería como tomarle un examen con las mismas preguntas de la guía resuelta. Los datos se parten en tres:
| Conjunto | Típico | Para qué sirve |
|---|---|---|
| Train | ~70% | La red aprende de acá: con estos ejemplos ajusta sus pesos. |
| Validación | ~15% | La red NO aprende de acá, solo se mide después de cada epoch. Comparar train vs. val es el detector de overfitting. |
| Test | ~15% | Se toca UNA sola vez, al final de todo. De acá sale la matriz de confusión y la métrica final que reportás. |
Preprocesamiento mínimo
- Normalizar las features numéricas (ej.
StandardScalerde scikit-learn: media 0, desvío 1). Si una columna va de 0 a 100.000 y otra de 0 a 1, la grande domina los gradientes y la red converge mal o no converge. - Codificar categorías como números (one-hot encoding): la red solo come números.
- Etiquetas como 0 y 1, no como strings.
ETAPA 07 EL VILLANO DEL TP
Overfitting: cuando la red memoriza en vez de aprender
Una red generaliza cuando aprende los patrones de fondo y acierta con datos que nunca vio. Hace overfitting cuando, en cambio, memoriza los ejemplos de entrenamiento — incluido su ruido — y rinde bárbaro en train pero mal en datos nuevos. Es el alumno que se aprendió de memoria la guía resuelta: 10 en la guía, 4 en el parcial.
¿Cómo se detecta? Comparando las curvas de loss de train y validación a lo largo de los epochs. Esta es la firma visual que tu informe tiene que mostrar:
Arrastrá el slider para avanzar el entrenamiento epoch a epoch y mirá las dos curvas.
La curva train baja siempre: la red memoriza cada vez mejor lo que ya vio. La curva validación baja al principio (está aprendiendo patrones reales) pero en un punto toca un mínimo y empieza a subir: a partir de ahí, lo que la red "aprende" es ruido del train que no sirve afuera. Ese codo es el momento óptimo para frenar.
Cómo simular el overfitting a propósito (punto 4 del TP)
El TP te pide provocarlo para demostrar que lo entendés. La receta — todo lo que aumenta capacidad de memorizar o reduce datos:
- Red sobredimensionada: muchas capas con muchas neuronas (ej. 3 capas de 256) para un problema chico.
- Muchísimos epochs (200–500), sin frenar nunca.
- Poco dato de entrenamiento: entrenar con una fracción chica del dataset exagera el efecto.
- Cero regularización: sin dropout, sin early stopping.
Después mostrás el contraste con un modelo "sano". Las armas contra el overfitting (nombralas en el informe aunque el punto pida solo simularlo — demuestra que entendés):
| Arma | Cómo funciona | En Keras |
|---|---|---|
| Dropout | En cada paso de entrenamiento "apaga" al azar un % de neuronas: obliga a la red a no depender de ninguna en particular, dificulta memorizar. | Dropout(0.3) entre capas |
| Early stopping | Frena el entrenamiento cuando la val_loss deja de mejorar — corta justo en el codo de la curva. | EarlyStopping(patience=10) |
| Red más chica | Menos parámetros = menos memoria para memorizar. | Menos capas / neuronas |
| Más datos | Más ejemplos hacen más difícil memorizarlos todos. | — |
ETAPA 08 LOS EXPERIMENTOS
Hiperparámetros: las perillas que controlás vos
La distinción que tenés que tener cristalina:
Parámetros
Los pesos y biases. Los aprende la red sola durante el entrenamiento, vía gradiente. Vos no los tocás nunca.
Hiperparámetros
Las decisiones de diseño que fijás vos, antes de entrenar: cuántas capas, qué learning rate, cuántos epochs. La red no puede aprenderlos; se eligen experimentando.
| Hiperparámetro | Qué controla | Si es muy bajo | Si es muy alto |
|---|---|---|---|
| Learning rate | Tamaño del paso del gradiente | Converge lentísimo o se estanca | Oscila o diverge (la loss explota) |
| Neuronas / capas | Capacidad del modelo | Underfitting: no le da ni para train | Overfitting: memoriza |
| Batch size | Ejemplos por ajuste de pesos | Entrenamiento ruidoso pero a veces generaliza mejor | Más estable y rápido por epoch, puede generalizar peor |
| Epochs | Cuántas veces ve los datos | Underfitting: frenó antes de aprender | Overfitting (sin early stopping) |
| Dropout | % de neuronas apagadas | No regulariza nada | Underfitting: le apagás demasiado cerebro |
| Activación | No linealidad de las capas ocultas | relu vs tanh vs sigmoid: cambia velocidad y calidad de convergencia | |
Metodología: cómo hacer los "al menos 4" experimentos del punto 5
- Definí un baseline: una configuración razonable (ej. 2 capas de 16/8, relu, adam lr=0.001, batch 32, 50 epochs) y medí su resultado.
- Variá un hiperparámetro en 2–3 valores manteniendo todo lo demás fijo. Registrá val_loss, accuracy y la métrica que elijas.
- Repetí para los otros 3+ hiperparámetros, siempre desde el baseline.
- Fijá la semilla aleatoria (
tf.random.set_seed(42), y la de numpy) para que los resultados sean reproducibles y comparables.
Una tabla así en tu informe vale oro:
| Exp | Cambio vs. baseline | val_accuracy | Observación esperable |
|---|---|---|---|
| E0 | baseline | 0.86 | referencia |
| E1 | lr 0.001 → 0.1 | 0.71 | loss oscila: paso demasiado grande |
| E2 | neuronas 16/8 → 256/256/128 | 0.83 | train sube, val baja: overfitting |
| E3 | batch 32 → 512 | 0.84 | converge más suave pero algo peor |
| E4 | + Dropout(0.3) | 0.88 | achica la brecha train/val |
(Números ilustrativos: los tuyos van a depender del dataset. Lo que importa es que puedas explicar la causa de cada cambio con el vocabulario de las etapas 04 y 07.)
ETAPA 09 LA EVALUACIÓN
Matriz de confusión: en qué se equivoca tu modelo
Cuando evaluás el modelo sobre el test set, cada predicción cae en una de cuatro casillas según qué predijo y qué era en realidad. Esa tabla 2×2 es la matriz de confusión — y de ella salen todas las métricas.
Editá las cuatro casillas y mirá cómo cambian las métricas. Arrancamos con un caso de detección de enfermedad sobre 1000 pacientes donde solo 50 están enfermos (clases desbalanceadas 95/5).
(enfermo)
(sano)
| Casilla | Significado |
|---|---|
| TP (true positive) | Era 1 y predijo 1. Acierto sobre la clase positiva. |
| TN (true negative) | Era 0 y predijo 0. Acierto sobre la clase negativa. |
| FP (false positive) | Era 0 pero predijo 1. Falsa alarma. |
| FN (false negative) | Era 1 pero predijo 0. Se le escapó un positivo. |
Las cuatro métricas y cuándo usar cada una
| Métrica | Fórmula | Responde a... | Usala cuando |
|---|---|---|---|
| Accuracy | (TP+TN)/total | ¿Qué % del total acerté? | Las clases están balanceadas y ambos errores pesan igual. |
| Precision | TP/(TP+FP) | De los que marqué como 1, ¿cuántos eran 1? | Las falsas alarmas (FP) son caras: marcar spam un mail importante. |
| Recall | TP/(TP+FN) | De los que eran 1, ¿cuántos encontré? | Que se escape un positivo (FN) es grave: no detectar una enfermedad. |
| F1 | 2·P·R/(P+R) | Promedio (armónico) de precision y recall | Clases desbalanceadas o cuando ambos errores importan. |
ETAPA 10 EL PLAN DE ATAQUE
Tu hoja de ruta, punto por punto
- Elegir el dataset en Hugging Face con los criterios de la etapa 06. Mirá el balance de clases antes de comprometerte. (~1 hora bien invertida)
- Preprocesar y splitear: codificar categorías, split 70/15/15, normalizar con estadísticas de train. Fijar seeds.
- Baseline: el MLP de la etapa 05 (2 capas ocultas relu + salida sigmoid, adam, binary_crossentropy). Verificá que la loss baja y la val_accuracy supera al azar y a "predecir siempre la clase mayoritaria".
- Simular overfitting: receta de la etapa 07 (red gigante + muchos epochs + poco dato). Graficá loss y val_loss por epoch — ese gráfico con las curvas separándose es tu evidencia. Opcional pero fuerte: mostrarlo al lado del modelo sano con dropout/early stopping.
- Experimentos: desde el baseline, variá de a UNO al menos 4 hiperparámetros (sugeridos: learning rate, tamaño de red, batch size, dropout o epochs). Tabla de resultados + explicación causal de cada efecto.
- Evaluación final: recién ahora tocás el test set. Matriz de confusión (scikit-learn:
confusion_matrix,classification_report) + métrica elegida y justificada según tu dataset. - El informe (máx. 5 páginas) lo escribís vos. Estructura natural: dataset y preprocesamiento → arquitectura → overfitting (gráfico) → tabla de experimentos → matriz + métrica → conclusión. Los gráficos y el código podés generarlos con IA; la redacción no.
Errores que hacen caer TPs como este
- Olvidar normalizar las features → la red no converge y perdés horas culpando a los hiperparámetros.
- Normalizar antes del split o ajustar hiperparámetros mirando el test → data leakage: tus números finales mienten.
- Cambiar varios hiperparámetros a la vez → experimentos que no explican nada.
- No fijar la seed → cada corrida da distinto y no podés comparar experimentos.
- Usar accuracy con clases desbalanceadas sin justificar → el punto 6 pide exactamente lo contrario.
- Capa de salida sin sigmoid, o loss que no sea binary_crossentropy → el modelo "entrena" pero está mal planteado.
- Elegir un dataset de imágenes enorme → semanas de cómputo para un TP de 2 semanas.
Autoevaluación: ¿estás listo?
Si acertás estas 8, podés sentarte a diseñar la arquitectura con criterio propio.