Workshop Setup: uv, PyTorch 2.5+, CUDA, WSL2, Mac MPS, Triton, FlashAttention, Nsight

# Linux / WSL2 / macOS
curl -LsSf https://astral.sh/uv/install.sh | sh
 
# Windows PowerShell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
 
# Sonra terminali yeniden başlat veya:
source $HOME/.cargo/env  # Linux/macOS
 
# Doğrulama
uv --version
# uv 0.5.x veya üstü görmen lazım

# Çalışma dizinini oluştur
mkdir -p ~/llm-muhendisligi && cd ~/llm-muhendisligi
 
# uv projesi başlat — Python 3.11 ile
uv init --python 3.11
# Bu komut: pyproject.toml + .python-version + örnek main.py + venv otomatik
 
# Sanal ortamı aktive et (otomatik oluşturuldu)
source .venv/bin/activate   # Linux/macOS/WSL
# .venv\Scripts\activate    # Windows PowerShell
 
# Doğrula
python --version
# Python 3.11.x görmelisin
which python
# .../llm-muhendisligi/.venv/bin/python görmelisin

# Aktif sanal ortamda:
uv pip install \
  transformers \
  datasets \
  accelerate \
  peft \
  trl \
  bitsandbytes \
  sentencepiece \
  tokenizers \
  einops \
  wandb \
  jupyter \
  ipykernel \
  matplotlib \
  pandas \
  numpy \
  scipy \
  scikit-learn \
  tqdm \
  rich \
  typer
 
# vLLM (Linux only, CUDA)
uv pip install vllm
 
# Triton (Linux + CUDA otomatik gelir; macOS sınırlı)
# Triton PyTorch ile birlikte gelir — ayrıca kurmaya gerek yok
 
# FlashAttention (Linux + Ampere/Hopper)
uv pip install flash-attn --no-build-isolation
 
# Doğrulama
python -c "import transformers, datasets, accelerate, peft, trl; print('Çekirdek kütüphaneler OK')"

# NVIDIA developer hesabı ile indir:
# https://developer.nvidia.com/nsight-systems
# Linux: .run veya .deb dosyası
 
# Ubuntu için:
sudo dpkg -i NsightSystems-linux-public-2024.5.1.113-3434142.deb
 
# Doğrulama
nsys --version
# NVIDIA Nsight Systems version 2024.5.1.113
 
# Kullanım:
nsys profile -o trace python my_script.py
# trace.nsys-rep dosyası oluşur — GUI ile aç
```

# sanity_test.py
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import time
 
# Cihaz seç
if torch.cuda.is_available():
    device = "cuda"
elif torch.backends.mps.is_available():
    device = "mps"
else:
    device = "cpu"
print(f"Cihaz: {device}")
print(f"PyTorch: {torch.__version__}")
 
# Veri
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
train_data = datasets.MNIST("./data", train=True, download=True, transform=transform)
test_data = datasets.MNIST("./data", train=False, transform=transform)
train_loader = DataLoader(train_data, batch_size=128, shuffle=True)
test_loader = DataLoader(test_data, batch_size=1000)
 
# Basit MLP
class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 256)
        self.fc2 = nn.Linear(256, 10)
    def forward(self, x):
        x = x.view(-1, 784)
        x = F.relu(self.fc1(x))
        return self.fc2(x)
 
model = Net().to(device)
opt = torch.optim.AdamW(model.parameters(), lr=1e-3)
 
# Eğit (1 epoch)
start = time.time()
model.train()
for x, y in train_loader:
    x, y = x.to(device), y.to(device)
    opt.zero_grad()
    loss = F.cross_entropy(model(x), y)
    loss.backward()
    opt.step()
elapsed = time.time() - start
 
# Değerlendir
model.eval()
correct = 0
with torch.no_grad():
    for x, y in test_loader:
        x, y = x.to(device), y.to(device)
        pred = model(x).argmax(dim=1)
        correct += (pred == y).sum().item()
acc = correct / len(test_data)
 
print(f"Eğitim süresi: {elapsed:.1f}s")
print(f"Test accuracy: {acc:.4f}")
assert acc > 0.9, "Bir şeyler yanlış — accuracy çok düşük"
print("✅ Sanity test başarılı!")

# Çalıştır
python sanity_test.py
 
# Beklenen çıktı:
# Cihaz: cuda  (veya mps, cpu)
# PyTorch: 2.5.1+cu124
# Eğitim süresi: 15-60s (GPU/CPU'ya göre)
# Test accuracy: 0.96 civarı
# ✅ Sanity test başarılı!

# Çalışan kurulumu requirements'a aktar
uv pip freeze > requirements.txt
 
# Veya uv.lock'u kullan (önerilen)
uv lock
 
# Yeni makinede tıpatıp kur
uv sync  # uv.lock'tan kurar

# full_sanity.py
import torch
import transformers
import datasets
import peft
 
print(f"PyTorch       : {torch.__version__}")
print(f"Transformers  : {transformers.__version__}")
print(f"Datasets      : {datasets.__version__}")
print(f"PEFT          : {peft.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}")
print(f"MPS available : {torch.backends.mps.is_available()}")
 
# Küçük bir transformer test
from transformers import AutoTokenizer, AutoModel
tok = AutoTokenizer.from_pretrained("bert-base-uncased")
ids = tok("Hello LLM Engineer", return_tensors="pt")
print(f"Tokenized: {ids.input_ids.shape}")
print("✅ Hepsi çalışıyor!")