Phase 00 - Lesson 11

Linux para IA

La mayor parte de la IA se ejecuta en Linux. Necesitas saber lo suficiente para no quedarte atascado.

Tipo: Aprender Lenguajes: -- Requisitos previos: Fase 0, Lección 01 Tiempo: ~30 minutos

Objetivos de Aprendizaje

• Navegar por el sistema de archivos de Linux y realizar operaciones esenciales de archivos desde la línea de comandos
• Gestionar permisos de archivos con chmod y chown para resolver errores de "Permission denied"
• Instalar paquetes del sistema con apt y configurar una máquina de GPU nueva para trabajo con IA
• Identificar diferencias entre macOS y Linux que suelen confundir a los desarrolladores que trabajan en máquinas remotas

El Problema

Tu desarrollas en macOS o Windows. Pero en el momento en que te conectas por SSH a una máquina de GPU en la nube, rentas una instancia Lambda o levantas una máquina EC2, aterrizas en Ubuntu. La terminal es tu única interfaz. No hay Finder, no hay Explorer, no hay GUI. Si no puedes navegar por el sistema de archivos, instalar paquetes y gestionar procesos desde la línea de comandos, te quedas atascado pagando horas de GPU inactivas mientras buscas en Google "como descomprimir un archivo en Linux".

Esta es una guía de supervivencia. Cubre exactamente lo que necesitas para operar en una máquina Linux remota para trabajo con IA. Nada más.

Estructura del Sistema de Archivos

Linux organiza todo bajo una única raíz /. No hay C:\ ni /Volumes. Los directorios que realmente vas a tocar:

graph TD
    root["/"] --> home["home/your-username/<br/>Your files — clone repos, run training"]
    root --> tmp["tmp/<br/>Temporary files, cleared on reboot"]
    root --> usr["usr/<br/>System programs and libraries"]
    root --> etc["etc/<br/>Config files"]
    root --> varlog["var/log/<br/>Logs — check when something breaks"]
    root --> mnt["mnt/ or /media/<br/>External drives and volumes"]
    root --> proc["proc/ and /sys/<br/>Virtual files — kernel and hardware info"]

Tu directorio home es ~ o /home/your-username. Casi todo lo que haces ocurre aquí.

Comandos Esenciales

Estos son los 15 comandos que cubren el 95% de lo que haras en una máquina de GPU remota.

Moverse

pwd                         # Where am I?
ls                          # What's here?
ls -la                      # What's here, including hidden files with details?
cd /path/to/dir             # Go there
cd ~                        # Go home
cd ..                       # Go up one level

Archivos y Directorios

mkdir my-project            # Create a directory
mkdir -p a/b/c              # Create nested directories in one shot

cp file.txt backup.txt      # Copy a file
cp -r src/ src-backup/      # Copy a directory (recursive)

mv old.txt new.txt          # Rename a file
mv file.txt /tmp/           # Move a file

rm file.txt                 # Delete a file (no trash, it's gone)
rm -rf my-dir/              # Delete a directory and everything inside

rm -rf es permanente. No hay deshacer. Verifica la ruta dos veces antes de presionar enter.

Leer Archivos

cat file.txt                # Print entire file
head -20 file.txt           # First 20 lines
tail -20 file.txt           # Last 20 lines
tail -f log.txt             # Follow a log file in real time (Ctrl+C to stop)
less file.txt               # Scroll through a file (q to quit)

Buscar

grep "error" training.log           # Find lines containing "error"
grep -r "learning_rate" .           # Search all files in current directory
grep -i "cuda" config.yaml          # Case-insensitive search

find . -name "*.py"                 # Find all Python files under current dir
find . -name "*.ckpt" -size +1G     # Find checkpoint files larger than 1GB

Permisos

Cada archivo en Linux tiene un propietario y bits de permiso. Te toparás con esto cuando los scripts no se ejecuten o no puedas escribir en un directorio.

ls -l train.py
# -rwxr-xr-- 1 user group 2048 Mar 19 10:00 train.py
#  ^^^             owner permissions: read, write, execute
#     ^^^          group permissions: read, execute
#        ^^        everyone else: read only

Soluciones comunes:

chmod +x train.sh           # Make a script executable
chmod 755 deploy.sh         # Owner: full, others: read+execute
chmod 644 config.yaml       # Owner: read+write, others: read only

chown user:group file.txt   # Change who owns a file (needs sudo)

Cuando algo dice "Permission denied", casi siempre es un problema de permisos. chmod +x o sudo arregla la mayoría de los casos.

Gestión de Paquetes (apt)

Ubuntu usa apt. Así es como instalas software de nivel de sistema.

sudo apt update             # Refresh the package list (always do this first)
sudo apt install -y htop    # Install a package (-y skips confirmation)
sudo apt install -y build-essential  # C compiler, make, etc. Needed by many Python packages
sudo apt install -y tmux    # Terminal multiplexer (keep sessions alive after disconnect)

apt list --installed        # What's installed?
sudo apt remove htop        # Uninstall

Paquetes comunes que instalarás en una máquina de GPU nueva:

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

Usuarios y sudo

Normalmente inicias sesión como un usuario común. Algunas operaciones necesitan acceso root (administrador).

whoami                      # What user am I?
sudo command                # Run a single command as root
sudo su                     # Become root (exit to go back, use sparingly)

En instancias de GPU en la nube, normalmente eres el único usuario y ya tienes acceso sudo. No ejecutes todo como root. Usa sudo solo cuando sea necesario.

Procesos y systemd

Cuando tu entrenamiento se cuelga, o necesitas verificar que se está ejecutando:

htop                        # Interactive process viewer (q to quit)
ps aux | grep python        # Find running Python processes
kill 12345                  # Gracefully stop process with PID 12345
kill -9 12345               # Force kill (use when graceful doesn't work)
nvidia-smi                  # GPU processes and memory usage

systemd gestiona servicios (daemons en segundo plano). Lo usaras si ejecutas servidores de inferencia:

sudo systemctl start nginx          # Start a service
sudo systemctl stop nginx           # Stop it
sudo systemctl restart nginx        # Restart it
sudo systemctl status nginx         # Check if it's running
sudo systemctl enable nginx         # Start automatically on boot

Espacio en Disco

Las máquinas de GPU suelen tener espacio en disco limitado. Los modelos y los conjuntos de datos lo llenan rápido.

df -h                       # Disk usage for all mounted drives
df -h /home                 # Disk usage for /home specifically

du -sh *                    # Size of each item in current directory
du -sh ~/.cache             # Size of your cache (pip, huggingface models land here)
du -sh /data/checkpoints/   # Check how big your checkpoints are

# Find the biggest space hogs
du -h --max-depth=1 / 2>/dev/null | sort -hr | head -20

Ahorradores de espacio comunes:

# Clear pip cache
pip cache purge

# Clear apt cache
sudo apt clean

# Remove old checkpoints you don't need
rm -rf checkpoints/epoch_01/ checkpoints/epoch_02/

Redes

Vas a descargar modelos, transferir archivos y consultar APIs desde la línea de comandos.

# Download files
wget https://example.com/model.bin                   # Download a file
curl -O https://example.com/data.tar.gz              # Same thing with curl
curl -s https://api.example.com/health | python3 -m json.tool  # Hit an API, pretty-print JSON

# Transfer files between machines
scp model.bin user@remote:/data/                     # Copy file to remote machine
scp user@remote:/data/results.csv .                  # Copy file from remote to local
scp -r user@remote:/data/checkpoints/ ./local-dir/   # Copy directory

# Sync directories (faster than scp for large transfers, resumes on failure)
rsync -avz --progress ./data/ user@remote:/data/
rsync -avz --progress user@remote:/results/ ./results/

Usa rsync en lugar de scp para cualquier cosa grande. Solo transfiere los bytes que cambiaron y maneja las conexiones interrumpidas.

tmux: Mantén las Sesiones Vivas

Cuando te conectas por SSH a una máquina remota, cerrar tu laptop termina tu ejecución de entrenamiento. tmux lo evita.

tmux new -s train           # Start a new session named "train"
# ... start your training, then:
# Ctrl+B, then D            # Detach (training keeps running)

tmux ls                     # List sessions
tmux attach -t train        # Reattach to session

# Inside tmux:
# Ctrl+B, then %            # Split pane vertically
# Ctrl+B, then "            # Split pane horizontally
# Ctrl+B, then arrow keys   # Switch between panes

Siempre ejecuta los trabajos de entrenamiento de larga duración dentro de tmux. Siempre.

WSL2 para Usuarios de Windows

Si estas en Windows, WSL2 te da un entorno Linux real sin arranque dual.

# In PowerShell (admin)
wsl --install -d Ubuntu-24.04

# After restart, open Ubuntu from Start menu
sudo apt update && sudo apt upgrade -y

WSL2 ejecuta un kernel Linux real. Todo en esta lección funciona dentro de el. Tus archivos de Windows están en /mnt/c/Users/YourName/ desde dentro de WSL.

El passthrough de GPU funciona con los controladores NVIDIA instalados en el lado de Windows. Instala el controlador NVIDIA de Windows (no el de Linux), y CUDA estara disponible dentro de WSL2.

Trampas: de macOS a Linux

Cosas que te confundirán si vienes de macOS:

Tarjeta de Referencia Rápida

Navigation:     pwd, ls, cd, find
Files:          cp, mv, rm, mkdir, cat, head, tail, less
Search:         grep, find
Permissions:    chmod, chown, sudo
Packages:       apt update, apt install
Processes:      htop, ps, kill, nvidia-smi
Services:       systemctl start/stop/restart/status
Disk:           df -h, du -sh
Network:        curl, wget, scp, rsync
Sessions:       tmux new/attach/detach

Ejercicios

1. Conéctate por SSH a cualquier máquina Linux (o abre WSL2) y navega a tu directorio home. Crea una carpeta de proyecto, crea tres archivos vacíos dentro de ella con touch y luego lístalos con ls -la.
2. Instala htop con apt, ejecútalo e identifica qué proceso está usando más memoria.
3. Inicia una sesión tmux, ejecuta sleep 300 dentro de ella, desconéctate, lista las sesiones y reconéctate.
4. Usa df -h para verificar el espacio en disco disponible, luego usa du -sh ~/.cache/* para encontrar qué está ocupando espacio en tu cache.
5. Transfiere un archivo desde tu máquina local a una remota usando scp, luego haz la misma transferencia con rsync y compara la experiencia.