Linux pentru IA — lecție practică de AI Engineering

Majoritatea sistemelor de IA rulează pe Linux. Trebuie să cunoașteți suficient de bine acest sistem ca să nu rămâneți blocați.

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

Obiective de învățare

Navigarea prin sistemul de fișiere Linux și efectuarea operațiilor esențiale cu fișiere din linia de comandă
Gestionarea permisiunilor pentru fișiere cu chmod și chown, pentru a rezolva erorile „Permission denied”
Instalarea pachetelor de sistem cu apt și configurarea unui sistem nou cu GPU pentru lucrul cu IA
Identificarea diferențelor dintre macOS și Linux care le creează frecvent probleme dezvoltatorilor ce lucrează pe sisteme la distanță

Problema

Dezvoltați pe macOS sau Windows. Însă, de îndată ce vă conectați prin SSH la un sistem GPU din cloud, închiriați o instanță Lambda sau porniți o mașină EC2, ajungeți în Ubuntu. Terminalul este singura interfață disponibilă. Nu există Finder, Explorer sau interfață grafică. Dacă nu puteți naviga prin sistemul de fișiere, instala pachete și gestiona procese din linia de comandă, rămâneți blocați și plătiți pentru ore de GPU nefolosit, în timp ce căutați pe internet „how to unzip a file in Linux”.

Acesta este un ghid practic esențial. Acoperă exact ceea ce trebuie să știți pentru a lucra pe un sistem Linux la distanță în proiecte de IA. Nimic în plus.

Structura sistemului de fișiere

Linux organizează totul sub o singură rădăcină, /. Nu există C:\ sau /Volumes. Directoarele pe care le veți folosi efectiv sunt:

Диаграмма к уроку «Linux pentru IA»

Directorul personal este ~ sau /home/your-username. Aproape toate operațiile pe care le efectuați au loc aici.

Comenzi esențiale

Acestea sunt cele 15 comenzi care acoperă 95% dintre operațiile pe care le veți efectua pe un sistem GPU la distanță.

Navigarea

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

Fișiere și directoare

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

Efectul comenzii rm -rf este permanent. Nu există anulare. Verificați de două ori calea înainte de a apăsa Enter.

Citirea fișierelor

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)

Căutarea

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

Permisiuni

Fiecare fișier din Linux are un proprietar și biți de permisiune. Vă veți confrunta cu acest aspect atunci când scripturile nu pot fi executate sau nu puteți scrie într-un director.

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

Soluții uzuale:

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)

Când primiți mesajul „Permission denied”, cauza este aproape întotdeauna o problemă de permisiuni. chmod +x sau sudo rezolvă majoritatea cazurilor.

Gestionarea pachetelor (apt)

Ubuntu folosește apt. Cu acesta instalați software la nivel de sistem.

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

Pachete uzuale pe care le veți instala pe un sistem nou cu GPU:

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

Utilizatori și sudo

De obicei, sunteți conectați ca utilizatori obișnuiți. Unele operații necesită acces root (administrator).

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

Pe instanțele GPU din cloud, sunteți de regulă singurii utilizatori și aveți deja acces sudo. Nu rulați totul ca root. Folosiți sudo numai când este necesar.

Procese și systemd

Când antrenarea se blochează sau trebuie să verificați ce rulează:

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 gestionează serviciile (procese daemon care rulează în fundal). Îl veți folosi dacă rulați servere de inferență:

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

Spațiu pe disc

Sistemele cu GPU au adesea spațiu limitat pe disc. Modelele și seturile de date îl ocupă rapid.

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

Metode uzuale de eliberare a spațiului:

# 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/

Rețelistică

Veți descărca modele, veți transfera fișiere și veți apela API-uri din linia de comandă.

# 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/

Folosiți rsync în locul scp pentru orice transfer de dimensiuni mari. Transferă numai octeții modificați și poate relua transferurile întrerupte.

tmux: mențineți sesiunile active

Când vă conectați prin SSH la un sistem la distanță, închiderea laptopului oprește procesul de antrenare. tmux previne acest lucru.

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

Rulați întotdeauna activitățile de antrenare de lungă durată în tmux. Întotdeauna.

WSL2 pentru utilizatorii Windows

Dacă folosiți Windows, WSL2 vă oferă un mediu Linux real fără să configurați pornirea duală a sistemelor de operare.

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

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

WSL2 rulează un nucleu Linux real. Toate instrucțiunile din această lecție funcționează în acest mediu. Din WSL, fișierele Windows se află în /mnt/c/Users/YourName/.

Accesul la GPU din WSL2 funcționează dacă driverele NVIDIA sunt instalate în Windows. Instalați driverul NVIDIA pentru Windows (nu pe cel pentru Linux), iar CUDA va fi disponibil în WSL2.

Capcane la trecerea de la macOS la Linux

Aspecte care vă pot crea probleme dacă veniți de pe macOS:

macOS	Linux	Observații
`brew install`	`sudo apt install`	Uneori, pachetele au nume diferite. `brew install htop` și `sudo apt install htop` funcționează la fel, dar nu și `brew install readline` față de `sudo apt install libreadline-dev`.
`open file.txt`	`xdg-open file.txt`	Însă nu veți avea o interfață grafică pe un sistem la distanță. Folosiți `cat` sau `less`.
`pbcopy` / `pbpaste`	Indisponibile	Nu puteți trimite date către clipboard sau prelua date din acesta printr-un pipe într-o sesiune SSH.
`~/.zshrc`	`~/.bashrc`	macOS folosește implicit zsh. Majoritatea serverelor Linux folosesc bash.
`/opt/homebrew/`	`/usr/bin/`, `/usr/local/bin/`	Fișierele binare se află în locuri diferite.
`sed -i '' 's/a/b/' file`	`sed -i 's/a/b/' file`	În macOS, sed necesită un șir gol după `-i`. În Linux, acesta nu este necesar.
Sistem de fișiere care nu diferențiază literele mari de cele mici	Sistem de fișiere care diferențiază literele mari de cele mici	`Model.py` și `model.py` sunt două fișiere diferite în Linux.
Terminatori de linie `\n`	Terminatori de linie `\n`	La fel. Însă Windows folosește `\r\n`, ceea ce împiedică funcționarea scripturilor bash. Rulați `dos2unix` pentru remediere.

Fișă de referință rapidă

Navigare:       pwd, ls, cd, find
Fișiere:        cp, mv, rm, mkdir, cat, head, tail, less
Căutare:        grep, find
Permisiuni:     chmod, chown, sudo
Pachete:        apt update, apt install
Procese:        htop, ps, kill, nvidia-smi
Servicii:       systemctl start/stop/restart/status
Disc:           df -h, du -sh
Rețea:          curl, wget, scp, rsync
Sesiuni:        tmux new/attach/detach

Exerciții

Conectați-vă prin SSH la orice sistem Linux (sau deschideți WSL2) și navigați la directorul personal. Creați un folder de proiect și trei fișiere goale în acesta cu touch, apoi afișați-le cu ls -la.
Instalați htop cu apt, rulați-l și identificați procesul care folosește cea mai multă memorie.
Porniți o sesiune tmux, rulați sleep 300 în interiorul ei, detașați-vă, afișați lista sesiunilor și reconectați-vă la sesiune.
Folosiți df -h pentru a verifica spațiul disponibil pe disc, apoi utilizați du -sh ~/.cache/* pentru a afla ce ocupă spațiul din memoria cache.
Transferați un fișier de pe sistemul local pe unul aflat la distanță folosind scp, apoi efectuați același transfer cu rsync și comparați experiența.

Sursă: Linux for AI — original

Navigare: înapoi: 00.10 — Terminalul și shell-ul · Faza 0 — Configurare și instrumente · Catalog complet · înainte: 00.12 — Depanare și profilare.