Phase 00 - Lesson 10

Terminal y Shell

La terminal es donde viven los ingenieros de IA. Ponte cómodo aquí.

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

Objetivos de Aprendizaje

• Usar tuberías (pipes), redirecciones y grep para filtrar y procesar registros de entrenamiento desde la línea de comandos
• Crear sesiones persistentes de tmux con varios paneles para entrenamiento y monitoreo de GPU simultaneos
• Monitorear recursos del sistema y de la GPU con htop, nvtop y nvidia-smi
• Transferir archivos entre máquinas locales y remotas usando SSH, scp y rsync

El Problema

Vas a pasar más tiempo en la terminal que en cualquier editor. Ejecuciones de entrenamiento, monitoreo de GPU, seguimiento de registros, sesiones SSH remotas, gestión de entornos. Todo flujo de trabajo de IA pasa por el shell. Si eres lento aquí, eres lento en todas partes.

Esta lección cubre las habilidades de terminal que importan para el trabajo con IA. Sin historia de Unix. Sin profundizar en scripting de Bash. Solo lo que necesitas.

El Concepto

graph TD
    subgraph tmux["tmux session: training"]
        subgraph top["Top row"]
            P1["Pane 1: Training run<br/>python train.py<br/>Epoch 12/100 ..."]
            P2["Pane 2: GPU monitor<br/>watch -n1 nvidia-smi<br/>GPU: 78% | Mem: 14/24G"]
        end
        P3["Pane 3: Logs + experiments<br/>tail -f logs/train.log | grep loss"]
    end

Tres cosas ejecutándose a la vez. Una sola terminal. Puedes desconectarte, irte a casa, conectarte de nuevo por SSH y reconectarte. El entrenamiento sigue ejecutándose.

Constrúyelo

Paso 1: Conoce tu shell

Verifica que shell estas usando:

echo $SHELL

La mayoría de los sistemas usan bash o zsh. Ambos funcionan bien. Los comandos de este curso funcionan en cualquiera de los dos.

Cosas clave que debes saber:

# Move around
cd ~/projects/ai-engineering-from-scratch
pwd
ls -la

# History search (most useful shortcut you'll learn)
# Ctrl+R then type part of a previous command
# Press Ctrl+R again to cycle through matches

# Clear terminal
clear   # or Ctrl+L

# Cancel a running command
# Ctrl+C

# Suspend a running command (resume with fg)
# Ctrl+Z

Paso 2: Tuberías y redirecciones

Las tuberías conectan comandos entre si. Así es como procesas registros, filtras salidas y encadenas herramientas. Las vas a usar constantemente.

# Count how many times "loss" appears in a log
cat train.log | grep "loss" | wc -l

# Extract just the loss values from training output
grep "loss:" train.log | awk '{print $NF}' > losses.txt

# Watch a log file update in real time, filtering for errors
tail -f train.log | grep --line-buffered "ERROR"

# Sort experiments by final accuracy
grep "final_accuracy" results/*.log | sort -t= -k2 -n -r

# Redirect stdout and stderr to separate files
python train.py > output.log 2> errors.log

# Redirect both to the same file
python train.py > train_full.log 2>&1

Las tres redirecciones que necesitas:

Paso 3: Procesos en segundo plano

Las ejecuciones de entrenamiento toman horas. No quieres mantener la terminal abierta todo el tiempo.

# Run in background (output still goes to terminal)
python train.py &

# Run in background, immune to hangup (closing terminal won't kill it)
nohup python train.py > train.log 2>&1 &

# Check what's running in background
jobs
ps aux | grep train.py

# Bring a background job to foreground
fg %1

# Kill a background process
kill %1
# or find its PID and kill that
kill $(pgrep -f "train.py")

La diferencia entre &, nohup y screen/tmux:

Para cualquier cosa que dure más de unos minutos, usa tmux.

Paso 4: tmux

tmux te permite crear sesiones de terminal persistentes con varios paneles. Esta es la herramienta más útil para gestionar ejecuciones de entrenamiento.

# Install
# macOS
brew install tmux
# Ubuntu
sudo apt install tmux

# Start a named session
tmux new -s training

# Split horizontally
# Ctrl+B then "

# Split vertically
# Ctrl+B then %

# Navigate between panes
# Ctrl+B then arrow keys

# Detach (session keeps running)
# Ctrl+B then d

# Reattach
tmux attach -t training

# List sessions
tmux ls

# Kill a session
tmux kill-session -t training

Una sesión típica de flujo de trabajo de IA:

tmux new -s train

# Pane 1: start training
python train.py --epochs 100 --lr 1e-4

# Ctrl+B, " to split, then run GPU monitor
watch -n1 nvidia-smi

# Ctrl+B, % to split vertically, tail the logs
tail -f logs/experiment.log

# Now detach with Ctrl+B, d
# SSH out, go get coffee, come back
# tmux attach -t train

Paso 5: Monitoreo con htop y nvtop

# System processes (better than top)
htop

# GPU processes (if you have NVIDIA GPU)
# Install: sudo apt install nvtop (Ubuntu) or brew install nvtop (macOS)
nvtop

# Quick GPU check without nvtop
nvidia-smi

# Watch GPU usage update every second
watch -n1 nvidia-smi

# See which processes are using the GPU
nvidia-smi --query-compute-apps=pid,name,used_memory --format=csv

Atajos de teclado de htop que usaras:

• F6 o > para ordenar por columna (ordena por memoria para encontrar fugas de memoria)
• F5 para alternar la vista de árbol (ver procesos hijos)
• F9 para terminar un proceso
• / para buscar por el nombre de un proceso

Paso 6: SSH para máquinas remotas de GPU

Cuando rentas una GPU en la nube (Lambda, RunPod, Vast.ai), te conectas por SSH.

# Basic connection
ssh user@gpu-box-ip

# With a specific key
ssh -i ~/.ssh/my_gpu_key user@gpu-box-ip

# Copy files to remote
scp model.pt user@gpu-box-ip:~/models/

# Copy files from remote
scp user@gpu-box-ip:~/results/metrics.json ./

# Sync a whole directory (faster for many files)
rsync -avz ./data/ user@gpu-box-ip:~/data/

# Port forward (access remote Jupyter/TensorBoard locally)
ssh -L 8888:localhost:8888 user@gpu-box-ip
# Now open localhost:8888 in your browser

# SSH config for convenience
# Add to ~/.ssh/config:
# Host gpu
#     HostName 192.168.1.100
#     User ubuntu
#     IdentityFile ~/.ssh/gpu_key
#
# Then just:
# ssh gpu

Paso 7: Aliases útiles para el trabajo con IA

Agrega estos a tu ~/.bashrc o ~/.zshrc:

source phases/00-setup-and-tooling/10-terminal-and-shell/code/shell_aliases.sh

O copia los que quieras. Los aliases clave:

# GPU status at a glance
alias gpu='nvidia-smi --query-gpu=index,name,utilization.gpu,memory.used,memory.total,temperature.gpu --format=csv,noheader'

# Kill all Python training processes
alias killtraining='pkill -f "python.*train"'

# Quick virtual environment activate
alias ae='source .venv/bin/activate'

# Watch training loss
alias watchloss='tail -f logs/*.log | grep --line-buffered "loss"'

Consulta code/shell_aliases.sh para el conjunto completo.

Paso 8: Patrones comunes de terminal en IA

Estos aparecen repetidamente en la práctica:

# Run training, log everything, notify when done
python train.py 2>&1 | tee train.log; echo "DONE" | mail -s "Training complete" you@email.com

# Compare two experiment logs side by side
diff <(grep "accuracy" exp1.log) <(grep "accuracy" exp2.log)

# Find the largest model files (clean up disk space)
find . -name "*.pt" -o -name "*.safetensors" | xargs du -h | sort -rh | head -20

# Download a model from Hugging Face
wget https://huggingface.co/model/resolve/main/model.safetensors

# Untar a dataset
tar xzf dataset.tar.gz -C ./data/

# Count lines in all Python files (see how big your project is)
find . -name "*.py" | xargs wc -l | tail -1

# Check disk space (training data fills disks fast)
df -h
du -sh ./data/*

# Environment variable check before training
env | grep -i cuda
env | grep -i torch

Usalo

Aquí esta cuando entra en juego cada herramienta durante este curso:

Ejercicios

1. Instala tmux, crea una sesión con tres paneles y ejecuta htop en uno, watch -n1 date en otro y un script de Python en el tercero. Desconéctate y reconéctate.
2. Agrega los aliases de code/shell_aliases.sh a la configuración de tu shell y recarga con source ~/.zshrc (o ~/.bashrc).
3. Crea un registro de entrenamiento falso con for i in $(seq 1 100); do echo "epoch $i loss: $(echo "scale=4; 1/$i" | bc)"; sleep 0.1; done > fake_train.log y luego usa grep, tail y awk para extraer solo los valores de loss.
4. Configura una entrada de configuración SSH para un servidor al que tengas acceso (o usa localhost para practicar la sintaxis).

Términos Clave