Última lección del curso. Ya tienes los libros, los cursos y las comunidades; falta la pieza más tangible: el entorno de trabajo. Un practicante de machine learning es tan productivo como su taller: dónde escribe código, cómo gestiona entornos y experimentos, de dónde saca datos para practicar y qué hace cuando su portátil se queda corto. En esta lección organizamos ese taller con herramientas reales y consolidadas — muchas ya las has tocado durante el curso — y, al final, haremos lo que corresponde a una última lección: mirar atrás, recorrer el camino completo desde el primer módulo hasta aquí, y despedirnos.

1. Notebooks: Jupyter, JupyterLab y Google Colab
2. El editor: VS Code con Python y Jupyter
3. Entornos y versiones: venv/conda, Git, DVC y MLflow
4. Experimentación: Optuna y Weights & Biases
5. AutoML: qué es y qué esperar de él
6. Datasets públicos para practicar
7. Hardware: cuándo hace falta GPU y alternativas en la nube
8. Tabla-resumen: herramienta, uso y coste
9. El viaje completo: recapitulación del curso
10. Conclusión y despedida

El notebook es el cuaderno de laboratorio del ML, y lo has usado durante todo el curso:

• Jupyter Notebook / JupyterLab (jupyter.org): la herramienta local de referencia. JupyterLab es la evolución del Notebook clásico: misma idea (celdas de código, texto y gráficos) con interfaz de entorno completo — pestañas, explorador de ficheros, terminales. Coste: gratuito y open source. Idioma: interfaz en inglés.
• Google Colab (colab.research.google.com): notebooks de Jupyter en el navegador, sin instalar nada, con las librerías del curso preinstaladas y — su gran baza — GPU gratuita (con límites de tiempo y disponibilidad; los planes de pago amplían recursos). Coste: gratuito en su nivel base. Idioma: interfaz disponible en español.

¿Cuándo usar cada uno?

El notebook es ideal para explorar, pero cuando el código madura — funciones reutilizables, tests, la API de FastAPI del módulo 8 — necesitas un editor de verdad:

• Visual Studio Code (code.visualstudio.com): gratuito, multiplataforma y el editor más usado en el ecosistema Python. Con dos extensiones oficiales es un entorno de datos completo: la extensión Python (autocompletado, depurador, selección de intérprete/entorno) y la extensión Jupyter, que permite abrir y ejecutar notebooks dentro del propio editor: lo mejor de ambos mundos.
• El flujo profesional que ya esbozamos en el módulo 8: explorar en notebook, consolidar en ficheros .py, versionar en Git. VS Code cubre las tres fases sin cambiar de ventana.
• Alternativa digna de mención: PyCharm (JetBrains), con edición Community gratuita, preferido por quienes quieren un IDE más pesado y completo desde el inicio.

Recapitulación y ampliación de lo que montamos en el módulo 8:

• Entornos virtuales (venv / conda): como vimos en 08-01, cada proyecto debe tener su entorno aislado con sus versiones exactas de librerías. venv + pip (estándar de Python) cubre la mayoría de casos; conda añade gestión de paquetes no-Python y es popular en ciencia de datos. Elige uno y sé consistente; el requirements.txt (o environment.yml) va siempre al repositorio.
• Git y GitHub: el control de versiones del código no es opcional. Todo proyecto tuyo — incluidos los del módulo 9 — debería vivir en un repositorio con commits pequeños y descriptivos. Además de historial, GitHub es tu portfolio (lección anterior).
• DVC (dvc.org): Git versiona código, pero los datasets y modelos grandes no caben en Git. DVC (Data Version Control), que mencionamos en 08-03, extiende el flujo de Git a datos y modelos: versiona qué datos produjeron qué modelo. Gratuito y open source. Apúntalo para cuando un proyecto tuyo sufra el problema "¿con qué versión del CSV entrené esto?".
• MLflow (mlflow.org): registro de experimentos, modelos y su ciclo de vida, también mencionado en el módulo 8. Gratuito y open source. Su caso de uso mínimo — apuntar parámetros y métricas de cada experimento en lugar de en una hoja de cálculo — ya justifica aprenderlo.

• Optuna (optuna.org): lo usaste en 07-05 para la búsqueda de hiperparámetros. Merece quedarse en tu caja de herramientas permanente: su búsqueda bayesiana con pruning de ensayos malos ahorra horas frente a un grid search a ciegas, y se integra con scikit-learn, XGBoost, LightGBM y Keras. Gratuito y open source.
• Weights & Biases (wandb.ai): plataforma de seguimiento de experimentos muy extendida en deep learning: registra métricas, gráficos y modelos de cada ejecución y los presenta en paneles web compartibles. Tiene plan gratuito para uso personal. Es la alternativa "servicio gestionado" al MLflow autogestionado; conocer una de las dos es suficiente al principio.

El AutoML automatiza partes del flujo que has aprendido: probar algoritmos, preprocesados e hiperparámetros y quedarse con la mejor combinación. auto-sklearn es el ejemplo académico de referencia sobre nuestro stack: le das los datos y un presupuesto de tiempo y explora configuraciones de scikit-learn por ti.

Perspectiva honesta:

• Lo que hace bien: establecer rápidamente un listón fuerte ("¿qué rendimiento es alcanzable aquí?") y ahorrar búsqueda mecánica.
• Lo que no hace: entender el problema de negocio, detectar fugas de datos (módulo 6), diseñar variables con conocimiento del dominio (el RFM de MercaFresh del módulo 3) ni responder por las implicaciones éticas (08-04). Justo las partes donde tú aportas valor.
• Conclusión: el AutoML no te sustituye; automatiza lo que este curso te enseñó a hacer a mano — y precisamente por haberlo hecho a mano puedes usarlo con criterio y desconfiar cuando toca.

Todo lo anterior necesita materia prima. Fuentes consolidadas de datos para tus proyectos:

• Kaggle Datasets (kaggle.com/datasets): miles de datasets de todos los dominios, con notebooks de otros usuarios como punto de partida. Idioma: inglés.
• UCI Machine Learning Repository (archive.ics.uci.edu): el repositorio académico clásico — muchos datasets históricos del ML (Iris, Wine, Adult...) viven aquí. Idioma: inglés.
• Datos abiertos de administraciones españolas: el portal nacional datos.gob.es agrega datos públicos de administraciones (transporte, padrón, presupuestos...), y ayuntamientos como Madrid y Barcelona tienen portales propios de open data. Idioma: español. Ventaja doble: practicas con datos de tu contexto real y los proyectos resultantes son más originales que otro Titanic en tu portfolio.
• También los generadores de sklearn.datasets (que usamos en varias lecciones) siguen siendo útiles para experimentos controlados.

Pregunta frecuente al acabar un curso como este: "¿me compro una GPU?". Respuesta corta: probablemente todavía no.

• No necesitas GPU para: todo el ML clásico del curso (scikit-learn no usa GPU), XGBoost/LightGBM sobre datasets tabulares medianos, y en general los módulos 1 a 8. Un portátil moderno con 16 GB de RAM va sobrado.
• Sí ayuda (o hace falta) GPU para: deep learning en serio — entrenar CNNs sobre muchas imágenes (09-02), modelos de NLP grandes, fine-tuning de modelos preentrenados.
• Alternativas antes de comprar: Google Colab (GPU gratuita con límites; de pago para más), Kaggle Notebooks (también ofrece GPU gratuita con cuota semanal) y, para necesidades mayores, instancias con GPU de los proveedores cloud (AWS, Google Cloud, Azure) pagando por hora. La regla económica: alquila hasta que el gasto recurrente justifique comprar.

Merece la pena, antes de despedirnos, mirar el camino recorrido con MercaFresh, nuestro supermercado online, como compañero de viaje:

• Módulo 1: partimos de cero: qué es el machine learning, sus tipos (supervisado, no supervisado, por refuerzo) y el flujo de trabajo que luego repetiríamos una y otra vez.
• Módulo 2: construimos la base estadística — distribuciones, correlación, probabilidad — para poder razonar sobre datos y no solo ejecutar código.
• Módulo 3: aprendimos que los datos reales llegan sucios: limpieza, codificación, escalado, las variables RFM de los clientes de MercaFresh y los pipelines que lo hacen reproducible.
• Módulo 4: el aprendizaje supervisado: de la regresión lineal a las redes neuronales, pasando por regresión logística, árboles, SVM, K-NN y Naive Bayes, prediciendo desde ventas hasta abandono de clientes.
• Módulo 5: el no supervisado: K-means y clustering jerárquico para segmentar clientes, PCA para reducir dimensiones, DBSCAN y t-SNE/UMAP para ver lo que no se ve.
• Módulo 6: el módulo que separa al aficionado del profesional: evaluar con honestidad — división de datos, métricas, validación cruzada, ROC/AUC y la lucha contra el overfitting.
• Módulo 7: subimos el nivel: regularización, ensembles, gradient boosting con XGBoost y LightGBM, deep learning con Keras y el ajuste sistemático de hiperparámetros con Optuna.
• Módulo 8: sacamos los modelos del notebook: serialización con joblib, APIs con FastAPI, contenedores Docker, monitoreo de deriva y las obligaciones éticas y legales (RGPD) de poner un modelo ante personas reales.
• Módulo 9: cinco proyectos completos de principio a fin — precios de viviendas, imágenes con CNN, sentimientos con NLP, fraude con clases desbalanceadas y segmentación de clientes — donde todo lo anterior se encontró con la realidad.
• Módulo 10: y este mapa final: libros, cursos, comunidades y herramientas para que el aprendizaje no se detenga aquí.

Si el primer día te hubieran enseñado la última celda de código del proyecto de fraude, te habría parecido otro idioma. Hoy la lees con naturalidad. Ese es el viaje.

• Error: perseguir herramientas en lugar de proyectos. Instalar MLflow, DVC, W&B y tres editores la misma semana es procrastinación con apariencia de productividad. Adopta cada herramienta cuando un proyecto real te duela sin ella: DVC cuando pierdas la pista de un dataset, MLflow cuando tus experimentos no quepan en tu memoria.
• Error: comprar hardware antes de necesitarlo. Meses de Colab y Kaggle gratuitos separan tu situación actual de la primera GPU justificada.
• Error: quedarse en el notebook para siempre. Si un código va a reutilizarse o desplegarse, migra a .py con Git, como practicaste en el módulo 8. El notebook eterno de 200 celdas es deuda técnica.
• Consejo: automatiza tu entorno de arranque. Ten una plantilla de proyecto (estructura de carpetas, requirements.txt base, .gitignore para datos) y clónala en cada proyecto nuevo: empezarás en minutos y con buenas prácticas de serie.
• Consejo: revisa tu taller una vez al año, no cada semana. Las herramientas de esta lección son estables; las modas semanales de nuevas herramientas rara vez sobreviven. Tu criterio, no la novedad, decide qué entra en tu flujo.

Configura desde cero un entorno profesional para un proyecto nuevo: crea una carpeta con entorno virtual (venv o conda), instala scikit-learn, pandas y jupyterlab, genera el requirements.txt, inicializa un repositorio Git con un .gitignore que excluya datos y el entorno, y verifica que puedes abrir JupyterLab y VS Code sobre ese mismo entorno.

Abre Google Colab, crea un notebook, activa el entorno de ejecución con GPU y comprueba desde código que está disponible (por ejemplo, con tf.config.list_physical_devices('GPU') de TensorFlow). Después, sube o carga un dataset pequeño y entrena cualquier modelo de scikit-learn para verificar el flujo completo en la nube.

Explora datos.gob.es (o el portal de datos abiertos de tu ciudad) y elige un dataset que te interese. Define en un párrafo un proyecto de ML completo sobre él: pregunta de negocio, tipo de problema (¿supervisado?, ¿clustering?), métrica de evaluación adecuada y qué herramientas de esta lección usarías en cada fase. Es tu plan para la primera semana después de este curso.

Ejercicio 1 (orientativa): la secuencia mínima en Linux/macOS: python -m venv .venv, source .venv/bin/activate, pip install scikit-learn pandas jupyterlab, pip freeze > requirements.txt, git init y un .gitignore con al menos .venv/, data/ y .ipynb_checkpoints/. En VS Code, selecciona el intérprete de .venv (paleta de comandos, "Python: Select Interpreter"). Si JupyterLab arranca y VS Code ejecuta un notebook contra el mismo entorno, el taller está operativo: guarda esta receta como tu plantilla.

Ejercicio 2 (orientativa): en Colab: menú Entorno de ejecución → Cambiar tipo de entorno de ejecución → GPU. La comprobación debería listar al menos un dispositivo GPU. El modelo de scikit-learn no usará la GPU (y está bien: es la demostración práctica de la sección de hardware — el ML clásico no la necesita); la GPU cobrará sentido cuando repitas allí la CNN del proyecto 09-02 y compares tiempos de entrenamiento con tu CPU.

Ejercicio 3 (orientativa): un ejemplo bien planteado: con datos de accidentes de tráfico de un ayuntamiento, "predecir la gravedad de un accidente a partir de hora, meteorología y tipo de vía" — clasificación supervisada, probablemente con clases desbalanceadas (recuerda 09-04: mejor F1 o AUC-PR que accuracy), explorada en JupyterLab, versionada en Git, con hiperparámetros vía Optuna y, si el resultado merece la pena, publicada en GitHub como pieza de portfolio. Cualquier dataset vale si la pregunta es concreta y la métrica está justificada.

Y con esto, el curso termina. Empezaste sin saber qué distingue el aprendizaje supervisado del no supervisado y llegas hasta aquí habiendo limpiado datos reales, entrenado y evaluado decenas de modelos, desplegado uno en una API dentro de un contenedor y completado cinco proyectos de principio a fin. MercaFresh se queda aquí, pero el flujo de trabajo que practicaste con sus clientes, sus frutas y sus fraudes es exactamente el que aplicarás a cualquier problema real que te espere.

Este último módulo te deja el mapa: libros para profundizar, cursos para ampliar, comunidades para no caminar solo y un taller de herramientas para trabajar como un profesional. El machine learning es un campo que se mueve rápido, y eso, lejos de ser una amenaza, es la garantía de que nunca te aburrirás: siempre habrá un modelo mejor que entrenar, un dataset nuevo que entender, una técnica más que aprender.

Solo queda lo más importante: practicar. Elige un dataset esta semana — no el mes que viene — y recorre el flujo completo una vez más, ya sin nadie que te guíe. Ese es el momento exacto en que dejas de ser estudiante de machine learning y pasas a ser practicante. Ha sido un placer acompañarte hasta aquí. El resto del camino es tuyo: disfrútalo.