Digital Twin / Simulator

Fast simulator:

class FastSimulator:
    def __init__(self, compiled_model):
        self.weights = compiled_model.weights  # INT8
        self.layers = compiled_model.layers
    
    def infer(self, x):
        for layer in self.layers:
            if layer.type == "MVM":
                w = self.weights[layer.idx]
                x = np.dot(w, x)  # basit numpy MVM
            elif layer.type == "ReLU":
                x = np.maximum(0, x)
            # ...
        return x

Hızlı prototipleme. Gürültü yok, IR drop yok. Ama fonksiyonel doğruluk garanti.

Accurate simulator:

class AccurateSimulator(FastSimulator):
    def infer(self, x):
        for layer in self.layers:
            if layer.type == "MVM":
                w = self.weights[layer.idx]
                # Gürültü ekle
                noise = np.random.normal(0, 0.05 * w.std(), w.shape)
                # IR drop simülasyon
                ir_drop = self.estimate_ir_drop(layer)
                x = np.dot(w + noise + ir_drop, x)
                # Kuantizasyon hatası
                x = self.quantize(x, bits=8)
            # ...

Gerçekçi doğruluk. Model validation için. Yüzlerce kez koşturulur (Monte Carlo).

Cycle-accurate simulator:

RTL (Register Transfer Level) Verilog/SystemC. Her saat çevrimi simüle edilir:

always @(posedge clk) begin
    if (mvm_start) begin
        // Tüm crossbar hücreler paralel
        for (int c = 0; c < 256; c++)
            current[c] = sum(weights[row][c] * voltage[row]);
        // ...
    end
end

Çok yavaş (1 sn simülasyon = gerçek 10 µs) ama %100 donanım doğrulama.

Verilator open-source alternatif (ticari: Synopsys VCS, Cadence Xcelium).

Monte Carlo analiz:

Gürültü rastgele → 100 inference koştur, doğruluk dağılımı bak:

accuracies = []
for _ in range(100):
    sim = AccurateSimulator(model, seed=random())
    acc = sim.benchmark(test_data)
    accuracies.append(acc)

print(f"Mean: {mean(accuracies):.2%}, Std: {std(accuracies):.2%}")
# Output: Mean: 97.5%, Std: 0.3%

Worst-case analiz:

Modelin hassas olduğu senaryolar (yüksek sıcaklık, max IR drop, eski cihaz) simüle et. SIDRA kabulü: worst-case %95 doğruluk.

FPGA prototyping:

Cycle-accurate simülatör yetersizse FPGA kullan. Xilinx/Intel FPGA’lara SIDRA RTL yüklenir, gerçek zamandan 10× yavaş ama gerçek davranış.

SIDRA Y1 FPGA prototipi 2025’te tamamlandı. Yazılım yığını bunun üstünde test edildi.

Digital twin ekosistemi:

PyTorch Model
    ↓
Compiler (6.7)
    ↓ compile
Compiled Binary
    ↓ deploy
[Fast Simulator]  OR  [Accurate Simulator]  OR  [FPGA]  OR  [Y1 Gerçek]

Geliştirici her durumda aynı binary’yi kullanır. Doğruluk arttıkça:

• Fast: prototipe uygun.
• Accurate: release öncesi.
• FPGA: production validation.
• Y1 gerçek: deployment.

QAT + simulator loop:

while not acceptable:
    model = train(model)
    model = quantize(model, method="qat")
    compiled = compile(model)
    acc = accurate_simulator.benchmark(compiled)
    if acc < target:
        # Noise injection training
        train_with_noise(model, noise_std=0.05)

Çoklu-Y1 simülasyon:

Multi-chip modeller için simulator bağımsız çipler simüle eder + PCIe gecikmesi modelleri.

Performance modeli:

Simulator performance da tahmin:

sim.estimate_latency(model)  # "5 ms / inference"
sim.estimate_energy(model)   # "20 mJ / inference"
sim.estimate_throughput()    # "3000 inference / saniye"

Müşteri için pre-sale spec.

Açık-kaynak:

SIDRA simulator (fast) MIT lisansı — herkesle paylaşılır. Araştırmacılar SIDRA donanımı olmadan geliştirebilir.

GitHub: sidra/sidra-sim. PyPI: pip install sidra-sim.

Türkiye akademik kullanım:

Simulator açık olduğu için TÜ öğrencileri SIDRA-temalı tezler yapabilir, donanım olmadan yayın üretebilir. Türkiye akademik ekosistemi katalizi.