Montar un pequeño laboratorio para aprender machine learning en Ubuntu
2026-10-24 · 5 min de lectura
Contenido
Llevo tiempo con ganas de meterle mano al machine learning con algo más que leer artículos, y lo primero que me ha pasado es lo de siempre: empiezas a instalar cosas con pip, el sistema se queja, acabas con tres versiones de la misma librería y a las dos semanas no sabes qué tienes ni cómo volver a dejarlo limpio.
Así que hoy vamos a montar un laboratorio pequeño, aislado y reproducible para aprender machine learning sobre Ubuntu. Nada de GPU, nada de conda y nada de contenedores: con lo que trae la distribución es más que suficiente para empezar, y cuando haga falta más potencia ya nos preocuparemos.
Esquema del laboratorio #
Como siempre, el primer paso es detallar con qué vamos a trabajar.
- Una máquina virtual con Ubuntu Server 26.04 LTS de 64 bits sobre KVM, aunque sirve igual una instalación de escritorio, un portátil viejo o cualquier otro virtualizador.
- 4 GB de RAM, 2 vCPU y 30 GB de disco. Con menos se puede, pero PyTorch y Jupyter se lo comen rápido.
- Sin tarjeta gráfica. Para scikit-learn no hace falta y para empezar con redes neuronales en PyTorch tampoco: los ejemplos de iniciación caben de sobra en una CPU.
- La estación de trabajo desde la que nos conectaremos por SSH, en mi caso una Debian.
Voy a suponer que sabéis instalar Ubuntu y acceder por SSH, así que esa parte me la salto.
Instalar lo básico del sistema #
Ubuntu 26.04 trae Python 3.14, pero no trae el módulo para crear entornos virtuales ni las herramientas de compilación que algunas librerías necesitan.
ignacio@mllab:~$ sudo apt update
ignacio@mllab:~$ sudo apt install -y python3 python3-venv python3-pip build-essential gitSi intentáis instalar algo directamente con pip en el sistema veréis un error del tipo externally-managed-environment. No es un fallo: desde Ubuntu 23.04 la distribución protege su Python para que no le rompamos los paquetes que ella misma usa. Precisamente por eso vamos a trabajar siempre dentro de un entorno virtual.
Crear el entorno virtual #
Creamos un directorio para el laboratorio y dentro el entorno virtual, que es simplemente una copia de Python con su propio pip y sus propias librerías.
ignacio@mllab:~$ mkdir -p ~/ml-lab
ignacio@mllab:~$ cd ~/ml-lab
ignacio@mllab:~/ml-lab$ python3 -m venv .venv
ignacio@mllab:~/ml-lab$ source .venv/bin/activate
(.venv) ignacio@mllab:~/ml-lab$ python -m pip install --upgrade pipFijaos en el (.venv) que aparece delante del prompt. Mientras esté ahí, todo lo que instalemos se queda dentro de ~/ml-lab/.venv y el sistema ni se entera. Para salir del entorno basta con deactivate, y para volver a entrar hay que repetir el source.
Instalar las librerías #
Primero lo clásico: NumPy, pandas, Matplotlib, scikit-learn y JupyterLab para trabajar con cuadernos.
(.venv) ignacio@mllab:~/ml-lab$ pip install numpy pandas matplotlib scikit-learn jupyterlabPyTorch va aparte. Si lo instaláis sin más, pip se baja la versión con soporte CUDA, que pesa varios gigas y no nos sirve de nada sin GPU. La versión para CPU se instala indicando el repositorio específico. Python 3.14 es relativamente reciente y PyTorch lo soporta desde la 2.10, así que si os aparece algún error de que no encuentra una versión compatible, comprobad que pip está actualizado y que no estáis fijando una versión antigua de torch.
(.venv) ignacio@mllab:~/ml-lab$ pip install torch torchvision --index-url https://download.pytorch.org/whl/cpuComprobar que funciona #
Antes de seguir, una prueba rápida para ver que todo carga y que PyTorch está usando la CPU como esperamos.
(.venv) ignacio@mllab:~/ml-lab$ python -c "import sklearn, torch; print(sklearn.__version__, torch.__version__, torch.cuda.is_available())"
1.8.0 2.14.0+cpu FalseEse False del final es correcto: no hay CUDA y no la queremos.
Arrancar JupyterLab #
Como la máquina virtual no tiene entorno gráfico, arrancamos Jupyter sin navegador y escuchando solo en localhost. No lo expongáis a toda la red aunque sea el laboratorio de casa.
(.venv) ignacio@mllab:~/ml-lab$ jupyter lab --no-browser --ip=127.0.0.1 --port=8888En la salida aparecerá una URL con un token. La copiamos y, desde la estación de trabajo, abrimos un túnel SSH para llegar al puerto 8888 de la máquina virtual.
ignacio@desktop:~$ ssh -L 8888:127.0.0.1:8888 ignacio@mllabCon el túnel abierto, pegamos en el navegador de la estación de trabajo la URL que nos dio Jupyter (la de http://127.0.0.1:8888/lab?token=...) y ya tenemos el cuaderno delante.
Si el laboratorio está en la misma máquina en la que trabajáis, podéis quitar el --no-browser y os abrirá el navegador directamente.
Un primer cuaderno de prueba #
Para comprobar que la cosa va, creamos un cuaderno nuevo y entrenamos el clasificador más manido del mundo: el del conjunto de datos iris que viene con scikit-learn.
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
modelo = KNeighborsClassifier(n_neighbors=3)
modelo.fit(X_train, y_train)
print(f"Precisión: {modelo.score(X_test, y_test):.2f}")Y en otra celda, dos líneas con PyTorch para ver que también responde.
import torch
x = torch.rand(3, 3)
print(x @ x.T)Si las dos celdas se ejecutan sin quejarse, el laboratorio está listo.
Dejarlo reproducible #
Lo que diferencia un laboratorio de un montón de paquetes instalados es poder volver a levantarlo igual en otra máquina. Guardamos la lista exacta de versiones:
(.venv) ignacio@mllab:~/ml-lab$ pip freeze > requirements.txtY para recrearlo en otro sitio:
ignacio@otro:~/ml-lab$ python3 -m venv .venv
ignacio@otro:~/ml-lab$ source .venv/bin/activate
(.venv) ignacio@otro:~/ml-lab$ pip install -r requirements.txtUn consejo: metedle un git init al directorio y un .gitignore con .venv/ y .ipynb_checkpoints/. Los cuadernos y el requirements.txt sí van al repositorio; el entorno virtual nunca, que se regenera en segundos.
Parar el laboratorio #
Para cerrar, Ctrl+C en la terminal de Jupyter, deactivate para salir del entorno y apagamos la máquina virtual. Al día siguiente, source .venv/bin/activate y jupyter lab otra vez, y seguimos donde lo dejamos.
Y con esto damos por finalizado este artículo. Cuando el laboratorio se nos quede corto ya veremos cómo añadirle una GPU. Y para decidir con qué aprender ahora que ya lo tienes montado, he reunido los recursos que sí merecen la pena.