Phase 00 - Lesson 10

Terminal e Shell

O terminal é onde os engenheiros de IA vivem. Fique à vontade aqui.

Tipo: Aprender Linguagens: -- Pré-requisitos: Fase 0, Lição 01 Tempo: ~35 minutos

Objetivos de Aprendizagem

• Usar pipes, redirecionamentos e grep para filtrar e processar logs de treinamento pela linha de comando
• Criar sessões persistentes do tmux com vários painéis para treinamento e monitoramento de GPU simultâneos
• Monitorar recursos do sistema e da GPU com htop, nvtop e nvidia-smi
• Transferir arquivos entre máquinas locais e remotas usando SSH, scp e rsync

O Problema

Você vai passar mais tempo no terminal do que em qualquer editor. Execuções de treinamento, monitoramento de GPU, acompanhamento de logs, sessões SSH remotas, gerenciamento de ambientes. Todo fluxo de trabalho de IA passa pelo shell. Se você é lento aqui, é lento em todo lugar.

Esta lição cobre as habilidades de terminal que importam para o trabalho com IA. Sem história do Unix. Sem mergulho profundo em scripting Bash. Apenas o que você precisa.

O Conceito

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

Três coisas rodando ao mesmo tempo. Um único terminal. Você pode desanexar, ir para casa, conectar via SSH de novo e reanexar. O treinamento continua rodando.

Construa

Passo 1: Conheça seu shell

Verifique qual shell você está usando:

echo $SHELL

A maioria dos sistemas usa bash ou zsh. Os dois funcionam bem. Os comandos deste curso funcionam em qualquer um.

Coisas importantes para 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

Passo 2: Pipes e redirecionamentos

Pipes conectam comandos entre si. É assim que você processa logs, filtra saídas e encadeia ferramentas. Você vai usar isso o tempo todo.

# 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

Os três redirecionamentos que você precisa:

Passo 3: Processos em segundo plano

Execuções de treinamento levam horas. Você não quer manter o terminal aberto o tempo todo.

# 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")

A diferença entre &, nohup e screen/tmux:

Para qualquer coisa mais longa que alguns minutos, use o tmux.

Passo 4: tmux

O tmux permite criar sessões de terminal persistentes com vários painéis. Esta é a única ferramenta mais útil para gerenciar execuções de treinamento.

# 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

Uma sessão típica de fluxo de trabalho 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

Passo 5: Monitoramento com htop e 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

Atalhos do htop que você vai usar:

• F6 ou > para ordenar por coluna (ordene por memória para encontrar vazamentos de memória)
• F5 para alternar a visualização em árvore (ver processos filhos)
• F9 para encerrar um processo
• / para buscar pelo nome de um processo

Passo 6: SSH para máquinas remotas de GPU

Quando você aluga uma GPU na nuvem (Lambda, RunPod, Vast.ai), você se conecta via 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

Passo 7: Aliases úteis para trabalho com IA

Adicione estes ao seu ~/.bashrc ou ~/.zshrc:

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

Ou copie os que você quiser. Os principais aliases:

# 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"'

Veja code/shell_aliases.sh para o conjunto completo.

Passo 8: Padrões comuns de terminal em IA

Estes aparecem repetidamente na prática:

# 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

Use na Prática

Veja quando cada ferramenta entra em ação durante este curso:

Exercícios

1. Instale o tmux, crie uma sessão com três painéis e execute htop em um, watch -n1 date em outro e um script Python no terceiro. Desanexe e reanexe.
2. Adicione os aliases de code/shell_aliases.sh à configuração do seu shell e recarregue com source ~/.zshrc (ou ~/.bashrc).
3. Crie um log de treinamento falso com for i in $(seq 1 100); do echo "epoch $i loss: $(echo "scale=4; 1/$i" | bc)"; sleep 0.1; done > fake_train.log e depois use grep, tail e awk para extrair apenas os valores de loss.
4. Configure uma entrada de configuração SSH para um servidor ao qual você tem acesso (ou use localhost para praticar a sintaxe).

Termos-Chave