Terminalul și shell-ul

Terminalul este mediul de lucru al inginerilor IA. Familiarizați-vă cu el.

Tip: Învățare Limbaje: – Cerințe preliminare: Faza 0, lecția 01 Durată: ~35 de minute

Obiective de învățare

• Utilizați operatorul pipe, redirecționările și grep pentru a filtra și prelucra jurnalele de antrenare din linia de comandă
• Creați sesiuni tmux persistente, cu mai multe panouri, pentru antrenare și monitorizarea simultană a GPU-ului
• Monitorizați resursele sistemului și ale GPU-ului cu htop, nvtop și nvidia-smi
• Transferați fișiere între calculatorul local și calculatoarele la distanță folosind SSH, scp și rsync

Problema

Veți petrece mai mult timp în terminal decât în orice editor. Rulări de antrenare, monitorizarea GPU-ului, urmărirea în timp real a jurnalelor, sesiuni SSH la distanță, gestionarea mediilor: fiecare flux de lucru din domeniul IA implică shell-ul. Dacă lucrați lent aici, veți lucra lent peste tot.

Această lecție prezintă abilitățile de lucru în terminal care contează pentru activitatea din domeniul IA. Fără o lecție de istorie Unix. Fără o incursiune aprofundată în scriptingul Bash. Doar ceea ce vă este necesar.

Conceptul

Trei activități rulează simultan într-un singur terminal. Puteți detașa sesiunea, puteți pleca acasă, apoi vă puteți conecta din nou prin SSH și o puteți reatașa. Antrenarea continuă să ruleze.

Punerea în practică

Pasul 1: Aflați ce shell utilizați

Verificați ce shell rulează:

echo $SHELL

Majoritatea sistemelor utilizează bash sau zsh. Ambele sunt potrivite. Comenzile din acest curs funcționează în oricare dintre ele.

Aspecte esențiale pe care trebuie să le cunoașteți:

# 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

Pasul 2: Operatorul pipe și redirecționările

Operatorul pipe conectează comenzile între ele. Astfel puteți prelucra jurnale, filtra ieșirea și înlănțui instrumente. Îl veți utiliza foarte des.

# 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

Cele trei redirecționări pe care trebuie să le cunoașteți:

Simbol	Ce face
>	Scrie ieșirea standard (stdout) într-un fișier, suprascriindu-l
>>	Adaugă ieșirea standard (stdout) la sfârșitul unui fișier
2>	Scrie ieșirea de eroare standard (stderr) într-un fișier
2>&1	Trimite stderr în același loc cu stdout
|	Trimite stdout al unei comenzi ca stdin pentru comanda următoare

Pasul 3: Procesele din fundal

Rulările de antrenare durează ore întregi. Nu este practic să țineți terminalul deschis în tot acest timp.

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

Diferența dintre &, nohup și screen/tmux:

Metodă	Continuă după închiderea terminalului?	Sesiunea poate fi reatașată?
command &	Nu	Nu
nohup command &	Da	Nu (consultați fișierul jurnal)
screen / tmux	Da	Da

Pentru orice operație care durează mai mult de câteva minute, utilizați tmux.

Pasul 4: tmux

tmux vă permite să creați sesiuni persistente de terminal, cu mai multe panouri. Este instrumentul cel mai util pentru gestionarea rulărilor de antrenare.

# 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

O sesiune tipică pentru un flux de lucru din domeniul 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

Pasul 5: Monitorizarea cu htop și 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

Combinațiile de taste din htop pe care le veți utiliza:

• F6 sau > pentru sortarea după coloană (sortați după memorie pentru a identifica pierderile de memorie)
• F5 pentru a comuta vizualizarea arborescentă (vedeți procesele-copil)
• F9 pentru a opri un proces
• / pentru a căuta numele unui proces

Pasul 6: SSH pentru sisteme GPU la distanță

Când închiriați un GPU în cloud (Lambda, RunPod, Vast.ai), vă conectați prin 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

Pasul 7: Aliasuri utile pentru activitatea din domeniul IA

Adăugați următoarele aliasuri în ~/.bashrc sau ~/.zshrc:

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

De asemenea, puteți copia numai aliasurile dorite. Cele mai importante sunt:

# 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ți code/shell_aliases.sh pentru setul complet.

Pasul 8: Tipare uzuale în terminal pentru activitatea din domeniul IA

Următoarele tipare apar frecvent în practică:

# 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

Utilizare

Iată când intervine fiecare instrument pe parcursul cursului:

Instrument	Când îl utilizați
tmux	La fiecare rulare de antrenare (începând cu faza 3)
tail -f + grep	Monitorizarea jurnalelor de antrenare
nohup / &	Sarcini rapide în fundal
htop / nvtop	Depanarea antrenării lente și a erorilor de memorie insuficientă (OOM)
SSH + rsync	Lucrul cu GPU-uri în cloud
Operatorul pipe + redirecționări	Prelucrarea rezultatelor experimentelor
Aliasuri	Economisirea timpului la comenzile repetitive

Exerciții

1. Instalați tmux, creați o sesiune cu trei panouri și rulați htop într-unul, watch -n1 date în altul și un script Python în al treilea. Detașați și reatașați sesiunea.
2. Adăugați aliasurile din code/shell_aliases.sh în configurația shell-ului și reîncărcați-o cu source ~/.zshrc (sau ~/.bashrc).
3. Creați un jurnal de antrenare fictiv cu for i in $(seq 1 100); do echo "epoch $i loss: $(echo "scale=4; 1/$i" | bc)"; sleep 0.1; done > fake_train.log, apoi utilizați grep, tail și awk pentru a extrage numai valorile pierderii.
4. Configurați o intrare SSH pentru un server la care aveți acces sau utilizați localhost pentru a exersa sintaxa.

Termeni-cheie

Termen	Formulare uzuală	Ce înseamnă de fapt
Shell	„Terminalul”	Programul care interpretează comenzile dumneavoastră (bash, zsh, fish)
tmux	„Multiplexor de terminal”	Un program care vă permite să rulați mai multe sesiuni de terminal într-o singură fereastră, să le detașați și să le reatașați
Pipe	„Bara verticală”	Operatorul |, care trimite ieșirea unei comenzi ca intrare pentru alta
PID	„Identificatorul procesului”	Un număr unic atribuit fiecărui proces în execuție, utilizat pentru monitorizarea sau oprirea acestuia
nohup	„Fără întrerupere la deconectare”	Rulează o comandă fără ca semnalul de deconectare să o afecteze, astfel încât închiderea terminalului nu o oprește
SSH	„Conectarea la server”	Secure Shell, un protocol criptat pentru rularea comenzilor pe un calculator la distanță

---

Sursă: Terminal & Shell — originalul Navigare: înapoi: 00.09 — Gestionarea datelor · Faza 0 — Configurare și instrumente · Catalog complet · înainte: 00.11 — Linux pentru IA.