Linux imprescindible para IA

Los modelos se entrenan y se sirven en Linux: conviene que te sientas como en casa.

Qué vas a aprender

• Moverte por el sistema de archivos de Linux y hacer las operaciones básicas con archivos desde la línea de comandos
• Gestionar permisos con chmod y chown para resolver los errores «Permission denied»
• Instalar paquetes del sistema con apt y preparar una máquina con GPU recién creada para trabajar en IA
• Conocer las diferencias entre macOS y Linux que más tropiezos causan al trabajar en máquinas remotas

Por qué importa

Desarrollas en macOS o Windows. Pero en cuanto entras por SSH en una GPU en la nube, alquilas una instancia en Lambda o levantas una máquina EC2, aterrizas en Ubuntu. La terminal es tu única interfaz: no hay Finder, ni Explorador, ni ventanas. Si no sabes moverte por el sistema de archivos, instalar paquetes y gestionar procesos desde la línea de comandos, estarás pagando horas de GPU parada mientras buscas en Google «cómo descomprimir un archivo en Linux».

Esto es una guía de supervivencia: exactamente lo que necesitas para trabajar en IA en una máquina Linux remota. Nada más.

El sistema de archivos

Linux organiza todo bajo una única raíz /. No hay C:\ ni /Volumes. Las carpetas que de verdad vas a tocar:

graph TD
    root["/"] --> home["home/tu-usuario/<br/>Tus archivos: clonar repos, entrenar"]
    root --> tmp["tmp/<br/>Archivos temporales, se borran al reiniciar"]
    root --> usr["usr/<br/>Programas y librerías del sistema"]
    root --> etc["etc/<br/>Archivos de configuración"]
    root --> varlog["var/log/<br/>Logs: míralos cuando algo falle"]
    root --> mnt["mnt/ o /media/<br/>Discos y volúmenes externos"]
    root --> proc["proc/ y /sys/<br/>Archivos virtuales: info del kernel y el hardware"]

Tu carpeta personal es ~ o /home/tu-usuario. Casi todo lo que hagas ocurrirá ahí.

Comandos esenciales

Estos 15 comandos cubren el 95 % de lo que harás en una máquina remota con GPU.

Moverte

pwd                         # ¿Dónde estoy?
ls                          # ¿Qué hay aquí?
ls -la                      # ¿Qué hay aquí, incluidos ocultos y con detalles?
cd /ruta/a/carpeta          # Ve ahí
cd ~                        # Ve a tu carpeta personal
cd ..                       # Sube un nivel

Archivos y carpetas

mkdir mi-proyecto           # Crea una carpeta
mkdir -p a/b/c              # Crea carpetas anidadas de una vez

cp file.txt backup.txt      # Copia un archivo
cp -r src/ src-backup/      # Copia una carpeta (recursivo)

mv old.txt new.txt          # Renombra un archivo
mv file.txt /tmp/           # Mueve un archivo

rm file.txt                 # Borra un archivo (no hay papelera: desaparece)
rm -rf my-dir/              # Borra una carpeta y todo su contenido

rm -rf es permanente. No hay deshacer. Revisa dos veces la ruta antes de pulsar Enter.

Leer archivos

cat file.txt                # Muestra el archivo entero
head -20 file.txt           # Las 20 primeras líneas
tail -20 file.txt           # Las 20 últimas líneas
tail -f log.txt             # Sigue un log en tiempo real (Ctrl+C para parar)
less file.txt               # Recorre un archivo con scroll (q para salir)

Buscar

grep "error" training.log           # Líneas que contienen "error"
grep -r "learning_rate" .           # Busca en todos los archivos de la carpeta actual
grep -i "cuda" config.yaml          # Búsqueda sin distinguir mayúsculas

find . -name "*.py"                 # Todos los archivos Python bajo la carpeta actual
find . -name "*.ckpt" -size +1G     # Checkpoints de más de 1 GB

Permisos

Cada archivo de Linux tiene un propietario y unos bits de permisos. Te los encontrarás cuando un script no se ejecute o no puedas escribir en una carpeta.

ls -l train.py
# -rwxr-xr-- 1 user group 2048 Mar 19 10:00 train.py
#  ^^^             permisos del propietario: lectura, escritura, ejecución
#     ^^^          permisos del grupo: lectura, ejecución
#        ^^        el resto: solo lectura

Los permisos también se escriben en octal: cada grupo de tres letras es un número, sumando r = 4, w = 2 y x = 1. Así, rwx = 7, r-x = 5 y r-- = 4: rwxr-xr-- es 754.

Arreglos habituales:

chmod +x train.sh           # Haz ejecutable un script
chmod 755 deploy.sh         # Propietario: todo; el resto: lectura + ejecución
chmod 644 config.yaml       # Propietario: lectura + escritura; el resto: solo lectura

chown user:group file.txt   # Cambia el propietario de un archivo (necesita sudo)

Cuando algo dice «Permission denied», casi siempre es un problema de permisos. chmod +x o sudo lo resuelven en la mayoría de los casos.

Claves SSH: si ssh se niega a usar tu clave privada con un aviso de permisos demasiado abiertos, ejecuta chmod 600 ~/.ssh/id_ed25519. Una clave privada solo debe poder leerla su dueño.

Gestión de paquetes (apt)

Ubuntu usa apt para instalar software del sistema.

sudo apt update             # Actualiza la lista de paquetes (hazlo siempre primero)
sudo apt install -y htop    # Instala un paquete (-y se salta la confirmación)
sudo apt install -y build-essential  # Compilador de C, make, etc. Lo necesitan muchos paquetes de Python
sudo apt install -y tmux    # Multiplexor de terminal (mantiene las sesiones vivas al desconectarte)

apt list --installed        # ¿Qué hay instalado?
sudo apt remove htop        # Desinstala

Los paquetes que instalarás en una máquina con GPU recién creada:

sudo apt update && sudo apt install -y \
    build-essential \
    git \
    curl \
    wget \
    tmux \
    htop \
    unzip \
    python3-venv

Usuarios y sudo

Normalmente entras como usuario normal. Algunas operaciones necesitan permisos de administrador (root).

whoami                      # ¿Qué usuario soy?
sudo comando                # Ejecuta un único comando como root
sudo su                     # Conviértete en root (exit para volver; úsalo poco)

En las GPUs en la nube sueles ser el único usuario y ya tienes sudo. No lo ejecutes todo como root: usa sudo solo cuando haga falta.

Procesos y systemd

Cuando tu entrenamiento se cuelga o necesitas ver qué se está ejecutando:

htop                        # Visor interactivo de procesos (q para salir)
ps aux | grep python        # Busca procesos de Python en ejecución
kill 12345                  # Detiene con suavidad el proceso con PID 12345
kill -9 12345               # Lo mata a la fuerza (cuando lo anterior no funciona)
nvidia-smi                  # Procesos y memoria de la GPU

systemd gestiona los servicios (procesos en segundo plano). Lo usarás si montas servidores de inferencia:

sudo systemctl start nginx          # Arranca un servicio
sudo systemctl stop nginx           # Lo detiene
sudo systemctl restart nginx        # Lo reinicia
sudo systemctl status nginx         # Comprueba si está en marcha
sudo systemctl enable nginx         # Lo arranca automáticamente al iniciar la máquina

Espacio en disco

Las máquinas con GPU suelen tener poco disco, y los modelos y datasets lo llenan rápido.

df -h                       # Uso de todos los discos montados
df -h /home                 # Uso de /home en concreto

du -sh *                    # Tamaño de cada elemento de la carpeta actual
du -sh ~/.cache             # Tamaño de tu caché (ahí acaban pip y los modelos de Hugging Face)
du -sh /data/checkpoints/   # Cuánto ocupan tus checkpoints

# Encuentra lo que más ocupa
du -h --max-depth=1 / 2>/dev/null | sort -hr | head -20

Formas habituales de liberar espacio:

# Vacía la caché de pip
pip cache purge

# Vacía la caché de apt
sudo apt clean

# Borra checkpoints antiguos que no necesitas
rm -rf checkpoints/epoch_01/ checkpoints/epoch_02/

Red

Descargarás modelos, transferirás archivos y llamarás a APIs desde la línea de comandos.

# Descargar archivos
wget https://example.com/model.bin                   # Descarga un archivo
curl -O https://example.com/data.tar.gz              # Lo mismo con curl
curl -s https://api.example.com/health | python3 -m json.tool  # Llama a una API y formatea el JSON

# Transferir archivos entre máquinas
scp model.bin user@remote:/data/                     # Copia un archivo a la máquina remota
scp user@remote:/data/results.csv .                  # Copia un archivo de la remota a la local
scp -r user@remote:/data/checkpoints/ ./local-dir/   # Copia una carpeta

# Sincroniza carpetas (más rápido que scp para transferencias grandes, y se reanuda si falla)
rsync -avz --progress ./data/ user@remote:/data/
rsync -avz --progress user@remote:/results/ ./results/

Usa rsync en lugar de scp para todo lo grande: solo transfiere lo que ha cambiado y aguanta las conexiones interrumpidas.

tmux: mantén vivas las sesiones

Cuando trabajas por SSH en una máquina remota, cerrar el portátil mata tu entrenamiento. tmux lo evita.

tmux new -s train           # Crea una sesión llamada "train"
# ... lanza el entrenamiento y luego:
# Ctrl+B, luego D           # Desconéctate (el entrenamiento sigue)

tmux ls                     # Lista las sesiones
tmux attach -t train        # Vuelve a la sesión

Lanza siempre los entrenamientos largos dentro de tmux. Siempre.

WSL2 para usuarios de Windows

Si usas Windows, WSL2 te da un Linux de verdad sin arranque dual.

# En PowerShell (como administrador)
wsl --install -d Ubuntu-24.04

# Tras reiniciar, abre Ubuntu desde el menú Inicio
sudo apt update && sudo apt upgrade -y

WSL2 ejecuta un kernel de Linux real: todo lo de esta lección funciona dentro. Tus archivos de Windows están en /mnt/c/Users/TuNombre/ desde WSL.

El acceso a la GPU funciona con los drivers de NVIDIA instalados en el lado de Windows. Instala el driver de NVIDIA para Windows (no el de Linux) y CUDA estará disponible dentro de WSL2.

Trampas: de macOS a Linux

Lo que te hará tropezar si vienes de macOS:

Chuleta

Moverte:        pwd, ls, cd, find
Archivos:       cp, mv, rm, mkdir, cat, head, tail, less
Buscar:         grep, find
Permisos:       chmod, chown, sudo
Paquetes:       apt update, apt install
Procesos:       htop, ps, kill, nvidia-smi
Servicios:      systemctl start/stop/restart/status
Disco:          df -h, du -sh
Red:            curl, wget, scp, rsync
Sesiones:       tmux new/attach/detach

Retos para tu ordenador

1. Entra por SSH en cualquier máquina Linux (o abre WSL2) y ve a tu carpeta personal. Crea una carpeta de proyecto, crea dentro tres archivos vacíos con touch y lístalos con ls -la.
2. Instala htop con apt, ejecútalo e identifica qué proceso usa más memoria.
3. Crea una sesión de tmux, ejecuta sleep 300 dentro, desconéctate, lista las sesiones y vuelve a conectarte.
4. Usa df -h para ver el espacio libre y du -sh ~/.cache/* para averiguar qué ocupa espacio en tu caché.
5. Transfiere un archivo de tu máquina a una remota con scp, repite la transferencia con rsync y compara la experiencia.