El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Preparación del entorno de trabajo

Siguiente ►
►

Ya tienes la base conceptual del deep learning; ahora toca preparar el taller. En esta lección montarás el entorno donde ejecutarás todo el código del curso: veremos las dos opciones principales —Google Colab (recomendada para empezar, con GPU gratuita) y la instalación local con Python—, aprenderás lo básico de los Jupyter Notebooks, verificarás que la instalación y la GPU funcionan con un script concreto, y crearás la estructura de carpetas del proyecto TecnoMarket que usaremos en el resto del curso. Un entorno bien montado desde el principio te ahorrará horas de frustración: la mayoría de los problemas de los principiantes no son de redes neuronales, sino de instalación.

Contenido

  1. Las dos opciones: Colab vs instalación local
  2. Opción A: Google Colab, paso a paso
  3. Opción B: instalación local con Python
  4. Jupyter Notebooks: lo básico
  5. Script de verificación del entorno y la GPU
  6. Estructura de carpetas del proyecto TecnoMarket
  7. Buenas prácticas: entornos aislados y versiones

Las dos opciones: Colab vs instalación local

Para entrenar redes neuronales necesitas Python, unas cuantas bibliotecas y, a ser posible, una GPU (recuerda de la lección 01-02: las GPU fueron una de las claves del resurgimiento del deep learning; aceleran el entrenamiento de 10 a 50 veces). Hay dos formas de conseguirlo:

Aspecto Google Colab (nube) Instalación local
Coste inicial Gratis Gratis (pero una GPU NVIDIA cuesta dinero)
GPU Incluida gratis (con límites de uso) Solo si tu equipo la tiene
Instalación Ninguna: se abre en el navegador Python + bibliotecas + (drivers de GPU)
Requiere internet Sí, siempre No
Persistencia Las sesiones se reinician; hay que guardar en Google Drive Todo queda en tu disco
Privacidad de datos Los datos suben a Google Los datos no salen de tu máquina
Ideal para Aprender, prototipar, este curso Trabajo continuado, datos sensibles, proyectos serios

Recomendación para el curso: empieza con Google Colab. Cero instalación, GPU gratuita y todos los notebooks del curso funcionarán tal cual. Monta el entorno local además (no en lugar de) cuando quieras: es el escenario realista de un puesto de trabajo, y en TecnoMarket, con datos internos de clientes y pagos, el equipo trabajaría en local o en servidores propios precisamente por privacidad.

Opción A: Google Colab, paso a paso

Google Colab (colab.research.google.com) es un servicio gratuito que ejecuta notebooks de Python en servidores de Google.

  1. Entra en https://colab.research.google.com con una cuenta de Google.
  2. Crea un notebook: menú Archivo → Nuevo notebook. Ya puedes ejecutar Python: no hay que instalar nada, las bibliotecas principales (TensorFlow, PyTorch, NumPy, pandas, matplotlib) vienen preinstaladas.
  3. Activa la GPU: menú Entorno de ejecución → Cambiar tipo de entorno de ejecución → Acelerador por hardware: GPU → Guardar. Este paso es fácil de olvidar y es la causa nº1 de "mi entrenamiento va lentísimo" en Colab.
  4. Ejecuta tu primera celda: escribe el código y pulsa Shift+Enter.
# Primera celda en Colab: comprobar que hay Python y qué GPU nos ha tocado
import sys
print("Versión de Python:", sys.version)

# Comando del sistema (el signo ! ejecuta comandos de terminal desde el notebook)
!nvidia-smi

Si activaste la GPU, nvidia-smi mostrará una tabla con el modelo de tarjeta asignada (T4, por ejemplo) y su memoria. Si da error, revisa el paso 3.

Limitaciones a conocer: las sesiones gratuitas se desconectan tras un tiempo de inactividad (y tienen un máximo de horas), y el disco de la sesión se borra al desconectar. Guarda siempre tus notebooks (se guardan solos en Google Drive) y monta Drive para conservar datos y modelos:

# Montar Google Drive para guardar datos y modelos de forma persistente
from google.colab import drive
drive.mount('/content/drive')
# A partir de aquí, todo lo guardado en /content/drive/MyDrive/ sobrevive a la sesión

Opción B: instalación local con Python

Para trabajar en tu propia máquina necesitas cuatro pasos: Python, un entorno aislado, las bibliotecas y Jupyter.

Paso 1: instalar Python 3

Necesitas Python 3.10 o superior (comprueba la versión con python3 --version).

  • Linux: suele venir instalado. Si no: sudo apt install python3 python3-pip python3-venv (Debian/Ubuntu).
  • Windows: descarga el instalador de https://www.python.org/downloads/ y marca la casilla "Add Python to PATH" durante la instalación.
  • macOS: brew install python3 (con Homebrew) o el instalador de python.org.

Paso 2: crear un entorno aislado

Nunca instales bibliotecas directamente sobre el Python del sistema. Un entorno aislado es una carpeta con su propia copia de Python y sus propias bibliotecas; si algo se rompe, borras la carpeta y empiezas de nuevo sin afectar a nada más. Hay dos herramientas equivalentes; usa una u otra:

Con venv (incluido en Python):

# Crear la carpeta del proyecto y el entorno
mkdir tecnomarket-dl
cd tecnomarket-dl
python3 -m venv .venv

# Activar el entorno (hay que hacerlo en cada sesión de terminal)
source .venv/bin/activate        # Linux / macOS
# .venv\Scripts\activate         # Windows (PowerShell o CMD)

# Verás (.venv) al principio del prompt: el entorno está activo

Con conda (si prefieres la distribución Miniconda/Anaconda):

conda create -n tecnomarket-dl python=3.11
conda activate tecnomarket-dl

Paso 3: instalar las bibliotecas

Con el entorno activado:

# Actualizar pip (el gestor de paquetes de Python)
pip install --upgrade pip

# Frameworks de deep learning: instalamos los dos que usa el curso
pip install tensorflow torch torchvision

# Herramientas de acompañamiento
pip install numpy pandas matplotlib scikit-learn jupyter

Qué es cada cosa:

  • tensorflow: framework de deep learning de Google; lo usaremos desde su API Keras (módulo 6, lección 06-01).
  • torch / torchvision: PyTorch, el framework de Meta, y sus utilidades de visión (lección 06-02). Instalamos ambos frameworks porque el curso enseña los dos; la comparación en profundidad llegará en la lección 06-03.
  • numpy / pandas: cálculo numérico y manejo de tablas de datos.
  • matplotlib: gráficas (curvas de entrenamiento, visualización de imágenes).
  • scikit-learn: utilidades de ML clásico (divisiones train/test, métricas).
  • jupyter: los notebooks en local.

Nota sobre GPU en local: en Windows/Linux, PyTorch y TensorFlow solo aceleran con GPU NVIDIA (mediante CUDA); la instalación estándar de arriba funciona en CPU en cualquier máquina, que es suficiente para los ejemplos pequeños del curso. Si tienes GPU NVIDIA y quieres aprovecharla, sigue la guía oficial de instalación de cada framework para tu sistema (las combinaciones de drivers/CUDA cambian con frecuencia y conviene mirar la página oficial: pytorch.org/get-started y tensorflow.org/install). Si no tienes GPU, no te preocupes: para eso está Colab.

Paso 4: arrancar Jupyter

jupyter notebook
# Se abrirá el navegador en http://localhost:8888 mostrando tus carpetas

Jupyter Notebooks: lo básico

Tanto Colab como Jupyter local usan el mismo concepto: el notebook, un documento interactivo que mezcla celdas de código ejecutables con celdas de texto (Markdown). Es el formato estándar para experimentar en deep learning porque permite ejecutar el trabajo por pasos, ver resultados (tablas, gráficas) junto al código y documentar lo que haces.

Lo mínimo que debes saber:

Acción Cómo
Ejecutar una celda Shift+Enter (ejecuta y pasa a la siguiente)
Insertar celda debajo Tecla B (con la celda seleccionada, sin estar editándola)
Insertar celda encima Tecla A
Borrar celda D, D (dos veces)
Convertir celda a texto/Markdown Tecla M (y Y para volver a código)
Reiniciar el kernel Menú Kernel → Restart (borra todas las variables)

Dos conceptos importantes:

  • El kernel es el proceso de Python que ejecuta tus celdas. Las variables perviven entre celdas mientras el kernel viva.
  • El orden de ejecución importa: puedes ejecutar celdas en cualquier orden, y eso es fuente clásica de errores (usar una variable definida en una celda que aún no has ejecutado, o resultados "fantasma" de ejecuciones anteriores). Ante un comportamiento raro, el remedio universal es Kernel → Restart & Run All: reinicia y ejecuta todo de arriba abajo. Si así funciona, tu notebook es reproducible.

Script de verificación del entorno y la GPU

Crea un notebook (en Colab o local) llamado 00_verificacion.ipynb y ejecuta este script completo. Es el "chequeo médico" del entorno: comprueba versiones, frameworks y GPU.

# === Script de verificación del entorno TecnoMarket-DL ===
import sys
print(f"Python: {sys.version.split()[0]}")

# --- Bibliotecas de datos ---
import numpy as np
import pandas as pd
import matplotlib
print(f"NumPy: {np.__version__} | pandas: {pd.__version__} | matplotlib: {matplotlib.__version__}")

# --- TensorFlow ---
import tensorflow as tf
print(f"\nTensorFlow: {tf.__version__}")
gpus_tf = tf.config.list_physical_devices('GPU')
print(f"GPU visible para TensorFlow: {'SÍ -> ' + str(gpus_tf) if gpus_tf else 'NO (usará CPU)'}")

# --- PyTorch ---
import torch
print(f"\nPyTorch: {torch.__version__}")
if torch.cuda.is_available():
    print(f"GPU visible para PyTorch: SÍ -> {torch.cuda.get_device_name(0)}")
else:
    print("GPU visible para PyTorch: NO (usará CPU)")

# --- Mini-prueba de cálculo real ---
# Multiplicamos dos matrices grandes: si esto funciona, el entorno está operativo
a = torch.rand(1000, 1000)   # matriz 1000x1000 de números aleatorios
b = torch.rand(1000, 1000)
device = "cuda" if torch.cuda.is_available() else "cpu"
resultado = (a.to(device) @ b.to(device))   # @ = multiplicación de matrices
print(f"\nMultiplicación de matrices 1000x1000 en '{device}': OK, suma = {resultado.sum():.2f}")

print("\n=== Entorno verificado: listo para el curso ===")

Interpretación de la salida:

  • Deben aparecer las versiones de todas las bibliotecas sin ningún ImportError. Si alguna falla, revisa que el entorno esté activado y reinstálala con pip.
  • Las líneas de GPU dirán SÍ o NO. En Colab con GPU activada deben decir SÍ; en un portátil sin NVIDIA dirán NO, y es normal: el curso puede seguirse en CPU (los ejemplos están dimensionados para ello) y usar Colab para los entrenamientos pesados.
  • La mini-prueba ejecuta una operación real del tipo que hacen las redes neuronales (multiplicar matrices, exactamente el entradas × pesos de la lección 01-04, a lo grande). Si imprime OK, todo funciona de verdad, no solo se importa.

Estructura de carpetas del proyecto TecnoMarket

Durante el curso iremos generando notebooks, datos y modelos del proyecto TecnoMarket. Crear una estructura ordenada ahora evitará el caos después. Ejecuta en la terminal (o crea las carpetas a mano; en Colab, créalas dentro de MyDrive):

tecnomarket-dl/
├── .venv/                  # el entorno virtual (solo en local; no se toca)
├── datos/
│   ├── brutos/             # datos tal como llegan (fotos, CSV de reseñas...)
│   └── procesados/         # datos ya limpios y listos para entrenar
├── notebooks/              # un notebook por lección/experimento: 02-05-primera-red.ipynb...
├── modelos/                # modelos entrenados que guardemos (módulo 6)
├── figuras/                # gráficas exportadas (curvas de entrenamiento, etc.)
└── requirements.txt        # las versiones exactas de las bibliotecas (ver abajo)
# Comandos para crearla en local (Linux/macOS; en Windows, mkdir equivalentes)
cd tecnomarket-dl
mkdir -p datos/brutos datos/procesados notebooks modelos figuras

Reglas de uso que seguiremos todo el curso:

  • datos/brutos es de solo lectura: nunca modifiques los datos originales; toda transformación se guarda en datos/procesados. Así siempre puedes volver a empezar.
  • Un notebook por lección o experimento, con nombre numerado (03-02-cnn-cifar10.ipynb): el orden del curso será el orden de tus ficheros.
  • Los modelos entrenados van a modelos/ con nombre y fecha: aprenderemos a guardarlos y cargarlos en la lección 06-05.

Buenas prácticas: entornos aislados y versiones

Tres hábitos profesionales que te evitarán problemas serios:

  1. Un entorno aislado por proyecto. El proyecto TecnoMarket tiene su .venv; otro proyecto tendrá el suyo. Así, actualizar una biblioteca para un proyecto no rompe los demás. Jamás instales con pip fuera de un entorno.

  2. Congela las versiones. Las bibliotecas de deep learning cambian deprisa y el código que hoy funciona puede fallar con la versión del año que viene. Guarda las versiones exactas de tu entorno:

# Guardar el estado del entorno en requirements.txt
pip freeze > requirements.txt

# Recrear el entorno en otra máquina (o tras romperlo)
pip install -r requirements.txt

En el contexto de TecnoMarket esto es crítico: si el clasificador de fotos pasa a producción, el equipo debe poder reconstruir el entorno exacto donde se entrenó.

  1. Verifica antes de trabajar. Cuando algo falle a mitad del curso, vuelve al notebook 00_verificacion.ipynb y ejecútalo: distinguirás en segundos si el problema es del entorno o de tu código.

Más adelante, en la lección 06-04, veremos entornos y recursos más avanzados (IDE, gestión de experimentos, alternativas de nube); por ahora, con Colab o tu entorno local verificado tienes todo lo necesario.

Errores Comunes y Consejos

  • Error: entrenar en Colab sin activar la GPU. Colab arranca por defecto sin acelerador. Si un entrenamiento va sospechosamente lento, lo primero que debes mirar es Entorno de ejecución → Cambiar tipo de entorno de ejecución.
  • Error: instalar paquetes sin activar el entorno. Si pip install funciona pero luego import falla en el notebook, casi seguro instalaste en un Python distinto del que usa Jupyter. Activa el entorno antes de instalar y antes de arrancar Jupyter.
  • Error: perder el trabajo en Colab. El disco de la sesión es efímero. Datos y modelos que quieras conservar, siempre a Google Drive montado.
  • Error: usar python cuando el sistema tiene python3. En Linux/macOS el comando puede llamarse python3; dentro de un entorno activado, python ya apunta a la versión correcta.
  • Error: ejecutar las celdas del notebook en desorden. Si aparecen resultados incoherentes, Kernel → Restart & Run All y revisa de arriba abajo.
  • Consejo: no persigas la última versión de cada biblioteca; persigue un entorno estable y congelado en requirements.txt. La reproducibilidad vale más que la novedad.

Ejercicios

Ejercicio 1: Puesta en marcha en Colab

Crea un notebook en Google Colab llamado 00_verificacion, activa la GPU, ejecuta el script de verificación completo de esta lección y comprueba que ambos frameworks detectan la GPU. Después, desactiva la GPU (vuelve a CPU), reinicia el entorno y ejecútalo otra vez. Compara ambas salidas: ¿qué líneas cambian?

Ejercicio 2: Entorno local reproducible

En tu máquina: crea la carpeta tecnomarket-dl con la estructura de carpetas de la lección, crea y activa un entorno virtual, instala las bibliotecas del curso, genera el requirements.txt y ejecuta el script de verificación en un Jupyter local. Anota qué versión de Python, TensorFlow y PyTorch te ha quedado instalada.

Ejercicio 3: Diagnóstico de un fallo

Un compañero del equipo de datos de TecnoMarket te escribe: "He instalado torch con pip y me ha dicho que todo correcto, pero al hacer import torch en mi notebook me da ModuleNotFoundError". Enumera, por orden de probabilidad, las causas posibles y qué comando o comprobación harías para descartar cada una.

Soluciones

Solución 1:

Con GPU activada, nvidia-smi muestra la tarjeta asignada, y las líneas de verificación dicen GPU visible para TensorFlow: SÍ y GPU visible para PyTorch: SÍ -> Tesla T4 (u otro modelo); la mini-prueba indica device 'cuda'. Al volver a CPU, ambas líneas pasan a NO (usará CPU), la mini-prueba indica 'cpu' y nvidia-smi da error ("command not found" o similar, porque la máquina asignada no tiene GPU). Las versiones de Python y bibliotecas no cambian: solo cambia el hardware disponible, no el software.

Solución 2:

Secuencia esperada (Linux/macOS):

mkdir tecnomarket-dl && cd tecnomarket-dl
mkdir -p datos/brutos datos/procesados notebooks modelos figuras
python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install tensorflow torch torchvision numpy pandas matplotlib scikit-learn jupyter
pip freeze > requirements.txt
jupyter notebook

Las versiones concretas dependerán del momento de la instalación (por ejemplo, Python 3.11.x, TensorFlow 2.x, PyTorch 2.x); lo importante es que el script de verificación se ejecute sin errores de importación y que requirements.txt recoja las versiones exactas para poder reproducir el entorno.

Solución 3:

Por orden de probabilidad:

  1. Instaló en un Python distinto del que usa el notebook (el caso más común): instaló con el entorno desactivado, o Jupyter corre sobre otro entorno. Comprobación: en una celda, import sys; print(sys.executable) y comparar con la ruta donde instaló pip (which pip / pip -V en la terminal). Solución: activar el entorno correcto e instalar ahí, o arrancar Jupyter desde el entorno.
  2. El kernel del notebook no es el del entorno: en Jupyter puede haber varios kernels registrados. Comprobación: menú Kernel → Change kernel.
  3. No reinició el kernel tras instalar: si el notebook ya estaba abierto al instalar, a veces hace falta Kernel → Restart.
  4. La instalación falló en realidad (quedarse sin espacio, error de red que no vio). Comprobación: pip show torch en la terminal con el entorno activado.

Conclusión

Tu taller está montado: sabes trabajar con Google Colab y su GPU gratuita, tienes (o sabes crear) un entorno local aislado con TensorFlow y PyTorch, dominas los movimientos básicos de Jupyter, cuentas con un script de verificación para diagnosticar el entorno en cualquier momento, y la estructura de carpetas del proyecto TecnoMarket está lista para recibir los notebooks, datos y modelos de todo el curso. Recuerda las tres reglas de oro: entornos aislados, versiones congeladas y datos brutos intocables.

Con esto termina el módulo de introducción: sabes qué es el deep learning, de dónde viene, para qué sirve, de qué están hechas las redes y dónde vas a construirlas. En el módulo 2 empezamos la parte práctica de verdad: del perceptrón al perceptrón multicapa, funciones de activación, propagación y optimización... hasta entrenar tu primera red neuronal completa con datos reales.

◄ Anterior
◄
Siguiente ►
►

Curso de Deep Learning

Módulo 1: Introducción a Deep Learning

Módulo 2: Fundamentos de Redes Neuronales

Módulo 3: Redes Neuronales Convolucionales (CNN)

Módulo 4: Redes Neuronales Recurrentes (RNN)

Módulo 5: Técnicas Avanzadas en Deep Learning

Módulo 6: Herramientas y Frameworks

Módulo 7: Proyectos Prácticos

Módulo 8: Consideraciones Éticas y Futuro del Deep Learning

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2026. Todos los derechos reservados