PyTorch Backend Yazmak
PyTorch'un SIDRA'yı native tanıması — model.to('sidra:0').
Önkoşul
Bu bölümde öğreneceklerin
- PyTorch'un custom backend mekanizmasını ve register_backend API'sini yaz
- Dispatch mekanizmasını (ATen op'lar SIDRA op'larına nasıl eşlenir) açıkla
- MVM, softmax, activation op'larının SIDRA implementasyonunu özetle
- Performance profiling ve benchmark stratejilerini söyle
- Diğer framework'lerle (TF, JAX) karşılaştır
Açılış: model.to('sidra:0')
PyTorch AI’nın %70+ piyasası. SIDRA için PyTorch destek zorunlu.
Hedef: model.to("sidra:0") → model otomatik SIDRA’da çalışır. CUDA backend gibi.
Bu bölüm PyTorch custom backend API’sini ve SIDRA’nın nasıl entegre edildiğini anlatır.
Sezgi: Dispatcher + Op Registration
PyTorch tensor işlemleri dispatcher üzerinden gider:
torch.matmul(a, b)
↓
ATen dispatcher
↓ (cihaz bazlı)
CPU: native C impl
CUDA: cuda_matmul
SIDRA: sidra_matmul ← yeni!Her op için cihaz-specific implementasyon. SIDRA MVM’i crossbar’a yönlendirir.
Formalizm: Custom Backend Register
PrivateUse1 backend (PyTorch 2.0+):
# SIDRA backend initialize
import torch
from sidra_pytorch import SidraDevice
# Register
torch.register_privateuse1_backend("sidra")
torch._register_device_module("sidra", SidraDevice())
# Kullan
device = torch.device("sidra:0")
tensor = torch.randn(10, 10, device=device) # SIDRA bellekteDispatch override:
# MVM için custom kernel
@torch.library.impl("aten::matmul", "PrivateUse1")
def sidra_matmul(a, b):
# SIDRA SDK ile crossbar MVM
return sidra.crossbar_mvm(a, b)PyTorch aten::matmul çağrısı geldiğinde SIDRA backend’iyse bu fonksiyon çalışır.
Desteklenen op’lar (öncelik sırası):
- matmul, linear, conv → SIDRA crossbar.
- relu, gelu, softmax → SIDRA compute engine.
- layernorm, batchnorm → compute engine.
- add, mul, reshape → genelde CPU veya fallback.
Tüm op’ları SIDRA’da yapmak şart değil. “Hotspot” op’lar yeter, geri kalan CPU’da.
Graph mode:
PyTorch 2.0 torch.compile model graph’ını optimize:
@torch.compile(backend="sidra")
def model_fn(x):
return model(x)Compile time:
- Model graph çıkar.
- SIDRA backend pass’leri uygula (operator fusion, quantization).
- Crossbar mapping.
- Optimized code emit.
Runtime: direk crossbar’da inference.
Quantization-aware:
# INT8 quantize
quantized_model = torch.quantization.quantize_dynamic(
model, {torch.nn.Linear}, dtype=torch.qint8
)
# SIDRA'ya yükle
quantized_model.to("sidra:0")SIDRA INT8 native. FP32 modeli INT8’e quantize etmek doğruluk kaybı %0.5.
Fallback:
Unsupported op (exotic) → CPU’ya fallback. Driver otomatik veri taşır.
# Hybrid execution
def forward(x):
x = layer1(x) # SIDRA
x = custom_op(x) # CPU fallback (auto)
x = layer2(x) # SIDRA
return xBenchmark:
import torch
import time
model = load_model("bert-base").to("sidra:0")
x = torch.randn(1, 512, 768).to("sidra:0")
# Warmup
for _ in range(10):
y = model(x)
torch.sidra.synchronize()
# Benchmark
t0 = time.time()
for _ in range(1000):
y = model(x)
torch.sidra.synchronize()
t1 = time.time()
print(f"Latency: {(t1-t0)/1000*1000:.2f} ms/inference")Typical: BERT-base Y1 ~5 ms/inference. H100 ~2 ms. SIDRA 2.5× yavaş ama 50× az enerji.
Profiler:
with torch.profiler.profile(
activities=[torch.profiler.ProfilerActivity.SIDRA]
) as prof:
y = model(x)
print(prof.key_averages().table())
# Output: matmul 2.1 ms, softmax 0.3 ms, ...Hotspot’ları bulmak için.
Eğitim (sınırlı Y1):
# Fine-tune son katman (Y1 hybrid)
for param in model.parameters():
param.requires_grad = False
model.classifier.requires_grad = True
optimizer = torch.optim.Adam(model.classifier.parameters())
for epoch in range(5):
for batch in loader:
y = model(batch.x.to("sidra:0"))
loss = criterion(y, batch.y)
loss.backward() # CPU'da gradient hesap
optimizer.step() # SIDRA son katmanı ISPP ile güncelleY1 sadece son katman eğitimi. Y10+ tam training.
TensorFlow + JAX:
- TensorFlow: XLA backend. SIDRA plugin. Sınırlı, geliştirme.
- JAX: XLA tabanlı. SIDRA JAX backend Y10+ hedef.
PyTorch öncelik çünkü %70 piyasa.
Deney: PyTorch → SIDRA 30 Saniyede
# 1. Import
import torch
import sidra_pytorch
# 2. Backend register
torch.register_privateuse1_backend("sidra")
# 3. Model yükle
from transformers import AutoModelForSequenceClassification
model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
# 4. SIDRA'ya geçir
model = model.to("sidra:0")
# 5. Inference
inputs = tokenizer("Hello SIDRA", return_tensors="pt").to("sidra:0")
outputs = model(**inputs)
print(outputs.logits)Standart HuggingFace kodu. SIDRA sadece .to("sidra:0") ekler. Transparent.
Kısa Sınav
Laboratuvar Görevi
Tipik workflow: HuggingFace transformer → SIDRA inference.
from transformers import pipeline
import sidra_pytorch
# Backend register (bir kere)
sidra.register_pytorch_backend()
# Pipeline'a sidra parametre geçir
translator = pipeline(
"translation_en_to_tr",
model="Helsinki-NLP/opus-mt-en-tr",
device="sidra:0"
)
result = translator("Hello, how are you?")
print(result) # [{'translation_text': 'Merhaba, nasılsın?'}]5 satırlık kod. Model indir, SIDRA’ya yükle, kullan. Arka planda: INT8 quantize, crossbar program, inference.
Süre: Model indirme 1 dakika. İlk inference 2 saniye. Sonraki her biri 10 ms.
Enerji: ~30 mJ/cümle (100 token). GPU 1 J (30× fazla).
Özet Kart
- PyTorch 2.0+ PrivateUse1 backend.
- Dispatch: ATen op’ları SIDRA kernel’e map.
- torch.compile: graph-level optimizasyon.
- Quantization: INT8 auto.
- Fallback: CPU unsupported op’lar için.
- Benchmark: Y1 BERT ~5 ms.
- Eğitim: Y1 son katman; tam Y10+.
Vizyon: SIDRA + PyTorch Ekosistemi
- Y1: PyTorch inference standart.
- Y3: HuggingFace ✓, Stable Diffusion ✓, Whisper ✓.
- Y10: Training + PyTorch Lightning.
- Y100: Native PyTorch primitive’leri (attention, transformer blocks).
- Y1000: PyTorch alternative — SIDRA-native framework.
Türkiye için: HuggingFace’de Türkçe modellere SIDRA backend = Türk NLP topluluğu doğal kullanıcı.
Daha İleri
- Bir sonraki bölüm: 6.7 — Derleyici: Model → Analog Mapping
- Önceki: 6.5 — SDK Katmanları
- PyTorch backend: pytorch.org PrivateUse1 guide.
- torch.compile: pytorch.org 2.0 release notes.
- HuggingFace: huggingface.co transformers.