End-to-End Production Stack Lab

Step 1: Pick and download models.

from transformers import WhisperForConditionalGeneration, WhisperProcessor

model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny")
processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")

39M parameters. Uses 9% of SIDRA Y1.

Step 2: Fine-tune with Turkish (CPU/GPU).

import torch
from datasets import load_dataset

tr_dataset = load_dataset("mozilla-foundation/common_voice_13_0", "tr")

# Standard PyTorch training
optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)
for epoch in range(3):
    for batch in tr_dataset:
        loss = model(**batch).loss
        loss.backward()
        optimizer.step()

# Result: Turkish WER 15% (acceptable).

Step 3: QAT (Quantization-Aware Training).

from torch.quantization import prepare_qat, convert

model_qat = prepare_qat(model)
# 1 epoch QAT
for batch in tr_dataset:
    model_qat(**batch).loss.backward()
    optimizer.step()

model_int8 = convert(model_qat)

Result: INT8 model. Accuracy loss 0.5%.

Step 4: SIDRA compile.

import sidra

compiled = sidra.compile(
    model_int8,
    calib_data=tr_dataset[:100],
    target="y1",
    optimization_level=2
)
print(compiled.size_mb, compiled.crossbar_count)
# 78 MB, 600 crossbars

Step 5: Simulator validation.

sim = sidra.AccurateSimulator(compiled)
test_wer = sim.benchmark_wer(tr_test_set)
print(f"Sim WER: {test_wer:.1%}")  # 16.5%

Acceptance criterion: WER under 20%. Pass.

Step 6: FPGA test.

Run the same binary on the FPGA prototype. Accuracy confirmed.

fpga = sidra.FPGADevice("xilinx_u280")
fpga.deploy(compiled)
fpga_wer = fpga.benchmark_wer(tr_test_set)
# 16.7% (matches sim)

Step 7: Y1 deploy.

chip = sidra.Chip(0)  # real Y1
chip.deploy(compiled)

# Inference
audio = record_microphone(seconds=5)
text = chip.infer_whisper(audio)
print(text)  # "Merhaba, nasılsın?"

5 seconds of audio → 100 ms inference. 50 mJ energy.

Step 8: Add the translation model.

Marian NMT TR→EN follows a similar pipeline:

nmt = sidra.compile(marian_model, ...)
chip.deploy([whisper_compiled, nmt_compiled])  # two models in parallel

text = chip.infer_whisper(audio)        # TR
translation = chip.infer_marian(text)   # EN
print(translation)  # "Hello, how are you?"

Total pipeline: 200 ms audio → text → translation.

Step 9: CI/CD.

GitHub Actions workflow:

name: SIDRA Build & Test
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Install SIDRA SDK
      run: pip install sidra
    - name: Test on simulator
      run: python tests/test_whisper.py
    - name: Test on FPGA (self-hosted runner)
      run: python tests/test_fpga.py
      if: github.ref == 'refs/heads/main'

Auto-tests every commit. PR reviews show CI status.

Version management:

my-app v1.0.0
├── sidra-sdk 1.2.3
│   ├── sidra-driver 1.1.0
│   ├── sidra-firmware 1.0.5
│   └── sidra-compiler 1.2.0
├── pytorch 2.4.0
└── transformers 4.50.0

SemVer + lock file. Production stable, dev streets bleeding edge.

Production deploy:

Stages on the customer device:

1. SIDRA driver (kernel module, system install).
2. Firmware (Y1 boot ROM, once).
3. SDK runtime (ships with app).
4. Compiled model (inside the app).

OTA (Over-The-Air) updates: model + firmware update from the field.

Production scale:

The Local AI Assistant startup ships 100K devices/year. Each uses 1 SIDRA Y1 → 100K chips/year.

SIDRA workshop capacity: 100K/year (chapter 5.14). Match. Domestic production possible.

Y10 + scale:

Same product on Y10: GPT-4-class model. Phone-sized device. Volume 100K → 1M/year. Mini-fab needed (chapter 7.5).