Fake backend kullanımı — gerçek bir cihazın donmuş kopyasıyla geliştirme

FakeBackend, gerçek bir IBM cihazının belirli bir tarihteki sözleşmesini ve gürültü profilini, aynı BackendV2 arayüzünü uygulayan bir Python sınıfı olarak paketleyen yapıdır. Sınıfı çağırdığınızda ortaya çıkan nesne, gerçek bir cihazla aynı şekilde sorgulanır: backend.name, backend.num_qubits, backend.target, backend.coupling_map, backend.qubit_properties(q). Aradaki tek fark: tüm bu alanlar donmuş bir anın değerlerini taşır ve değişmez.

"Mock" değil, kayıt

FakeBackend bir mock değildir; eline geçen değerler yazılımcı tarafından uydurulmuş rakamlar değildir. Gerçek cihazda o tarihte ölçülmüş kalibrasyonun kaydıdır. Bu, "simüle ediyoruz ama gerçeğe yakın" cümlesinin somut karşılığıdır.

Ne değildir?

FakeBackend gerçek cihazın bugünkü hâli değildir. Aylık kalibrasyonlar yüzünden paketlenmiş anın gerçek cihaza göre farkı zaman içinde büyür. Aynı şekilde FakeBackend, aktif bir kuyruk, oturum, iş yöneticisi de değildir; arkasında ne queue (kuyruk) ne kalibrasyon sürüklenmesi vardır.

Fake backend katalogu, gerçek cihaz hattındaki farklı boyutları ve farklı topolojileri yansıtan sınıflardan oluşur: küçük 5-qubit cihazların donmuş örnekleri (örneğin FakeBelemV2, FakeManilaV2), daha büyük topolojilere ait V2 ekosistemi içindeki örnekler ve eski hat üzerinde kalan V1 sınıfları. Genel kural: yeni içerik için V2 sınıfları tercih edilir; V1'ler eski kodla uyumluluk için durur.

V1 vs V2 ayrımı

Eski (V1) sınıflarda kalibrasyon bilgisi backend.properties() üzerinden okunur; yeni (V2) sınıflarda aynı bilgi backend.target üzerinden gelir. Bu sayfada hep V2'yi kullanırız; V2 arayüzü, gerçek cihazlarla doğrudan örtüşür.

Hangi sınıfı seçmeli?

Seçim, "cihazın benzemesini istediğim taraf" üzerinden yapılır: 5-qubit doğrusal topoloji için bir tip, daha karmaşık çok-qubit topolojisi için başka bir tip. Sayıların kendisi (T1/T2/hata) hangi sınıfı seçtiğinize bağlıdır; bu yüzden iki farklı sınıfta yapılan deneyler birbiriyle kalitatif karşılaştırılır.

Bir V2 fake backend nesnesinin içinde üç paket bilgi vardır. Birincisi sözleşme — qubit sayısı, native kapı seti, coupling map; ikincisi kalibrasyon — qubit başına T1/T2/frekans ve (kapı, qargs) için duration/error; üçüncüsü çoğu fake'te aynı zamanda gürültü modeli — yani backend.run(...) çağrıldığında devre, depolanan kalibrasyona uygun olarak gürültülü simüle edilir. Bu üçlü, fake backend'i "okunabilir kayıt"tan "çalıştırılabilir model"e dönüştürür.

Çalıştırma davranışı

FakeBackendV2.run(circuit, shots=...) çağrısı, devreyi arka planda Aer çekirdeğinde simüle eder ama kalibrasyon-türevi bir gürültü modeli ile zenginleştirir. Bu sayede aynı devreyi gerçek cihaza göndermeden, "bu cihaz nasıl cevap verirdi?" sezgisini elde edersiniz. Sonuç gerçek değildir; gerçeğe tahmindir.

Runtime primitive uyumu

Aynı fake backend'i SamplerV2 / EstimatorV2 primitive'lerinin mode=... parametresine vererek yerel primitive akışını da kurgulayabilirsiniz. Aynı PUB yazımı, gerçek cihaza dönüldüğünde değişmez.

İkisini birbirinin yerine koymak yaygın bir karışıklıktır. AerSimulator bir genel amaçlı simülatördür: varsayılan olarak ideal (gürültüsüz) çalışır; topoloji kısıtı, native kapı kümesi yoktur, herhangi bir qubit çiftinde iki-qubit kapısı uygulanabilir. FakeBackend ise belirli bir cihazın topolojisini, kapı setini ve gürültü profilini taşıyan cihaza özgü simülatördür.

Karar tablosu

Algoritmanın doğrusunu görmek istiyorsanız (matematiksel olarak ne çıkar?) ideal AerSimulator işinizi görür. Algoritmanın donanımda nasıl davranacağına dair fikir istiyorsanız (kaç SWAP, kaç ölçüm hatası?) FakeBackend daha bilgilendiricidir. İdeal sonuç ile donanım sonucu arasındaki fark, "hata bütçesi"nin sezgisidir.

Hibrit kullanım

Pratikte her ikisi de aynı pipeline'da yer alır: ideal Aer ile algoritmanın doğru cevabı bulunur, ardından FakeBackend ile tahmini gerçek cevap üretilir; iki sayı arasındaki fark, gerçek donanıma çıkmadan önce somut bir kalite göstergesidir.

Fake backend, gerçek donanımın belirli bir anının kayıtlı yansımasıdır; gerçek donanım ise canlı, sürüklenen, başka deneylerin yan etkilerini de taşıyan bir sistemdir. Aralarındaki farklar üç başlık altında yığılır.

Zaman ekseni

FakeBackend'in T1/T2/hata değerleri "ön gönderi tarihi"ne aittir; gerçek cihaz bugün farklıdır. Yani fake üzerinde alınan kararlar (örneğin "bu qubit yolu daha iyi") genel formül olarak doğru, somut sayı olarak güncel değildir.

Operasyonel taraf

FakeBackend her zaman uygundur: kuyruk yok, oturum yok, hesap yok. Gerçek cihaz bakımda olabilir, kuyruk patlamış olabilir, sizin oturumunuz açılamayabilir. Bu yüzden fake üzerinde yazdığınız "çalıştır ve sonucu al" akışı, gerçeğe taşınınca "çalıştır + bekle + dön" akışına dönüşür.

Karşı korelasyonlar

Gerçek cihazda gözlenen bazı gürültüler (yan-bağlanmalar, ölçüm geri kazanım hataları, kapı çapraz-konuşması) fake'te basitleştirilmiştir. Yani fake "iyimser" bir model değil ama "basitleştirilmiş" bir modeldir.

FakeBackend'in üç tipik kullanım yeri vardır: yerel geliştirme (gerçek cihaza her seferinde çıkmadan kod yazma), otomatik test (CI'da hız ve tekrar üretilebilirlik), ve öğretim (gerçek mimariyle aynı API üzerinde, herkesin kolayca tekrar yapabileceği örnekler).

Geliştirme: ağa çıkmadan iterate

Algoritmanın kabasını yazarken her satır değişikliğinde gerçek cihaza çıkmak hem pahalı hem yavaştır. FakeBackend ile aynı arayüzde dakikada onlarca iterasyon yapılabilir; ancak son adımda gerçek donanıma çıkıldığında aynı kod çalışır.

Test: regresyonu sabitlemek

CI pipeline'ında "bu algoritma şu cihaz türünde şu davranışı göstermeli" şeklindeki testler, FakeBackend ile yazılabilir. Donmuş kalibrasyon, deterministik seed ile birlikte testin tekrar üretilebilirliğini garanti eder.

Öğretim: aynı kayık, aynı yön

Öğrencinin/okuyucunun cihaz hesabı, token sorunu, kuyruk beklemesi olmadan kavramı denemesi gerekir. FakeBackend bu zemini sağlar; örneklerin üretim davranışıyla aynı yapı taşlarını kullanmasını mümkün kılar.

FakeBackend ile geliştirilen bir kod, gerçek backend'e taşınırken "backend" nesnesini değiştirmek dışında ideal olarak başka bir değişiklik gerektirmez. Bu uyum, BackendV2'nin ve runtime primitive arayüzünün tasarlandığı gibi çalışmasıyla mümkün olur: transpile(qc, backend=...), SamplerV2(mode=backend), backend.target okumaları — hepsi aynı yöntem adlarıyla yer değiştirebilir.

Bağımlılık enjeksiyonu

Kodunuzu "backend"i dışarıdan alan fonksiyonlar olarak yazınca, geçiş tek satıra iner: "backend = FakeManilaV2()" yerine "backend = service.backend('ibm_...')". Bu desen, hem testte fake, hem üretimde gerçek kullanımı sıfır kod farkıyla sağlar.

Geçişte gözden geçirme

"Tek satır geçiş" idealdir; pratikte gerçek cihazın güncel kalibrasyonu nedeniyle ağırlıkları (örneğin backend seçimi'ndeki skor sözlüğünü) yeniden değerlendirmek, transpile seçeneklerini (örneğin optimization_level) tekrar gözden geçirmek iyi bir alışkanlıktır.

FakeBackend güçlüdür ama yanlış kullanıldığında iyimser bir yanılsama yaratır. "Bu algoritma fake üzerinde harika çalışıyor" cümlesi, gerçek cihazda da aynı sonucu garanti etmez. Bu yüzden raporlarda fake üzerinde alınan sonuçların üzeri çizilerek "FakeBackend kullanıldı, gerçek hesap değil" notu tutulmalıdır.

"Fake ile çalıştı, gerçekte de çalışacak" yanılgısı

Bu yanılgıyı engellemek için, üretim raporunda yalnızca gerçek cihaz sonuçları sunulur; fake sonuçlar geliştirme ve önbakış için "iç" malzeme kalır. Bu ayrım, çıktıların bilimsel saygınlığını korur.

Etiketlemeden çıktı yayınlamamak

Bir grafik ya da tablo üzerinde sayıların hangi cihaz, hangi tarihte, fake mi gerçek mi olduğunu açıkça yazmak gerekir. Bu, hem dürüstlüktür hem de gelecekteki okuyucunun yorumlama hatasını engeller.

Üç blok da yereldir. İlk blok bir fake backend nesnesini içe alır, üzerindeki temel sözleşme alanlarını dışarı yazar ve nesnenin tipini gösterir. İkinci blok aynı fake backend üzerinde uçtan uca bir akış kurar: transpile + backend.run + sayım histogramı. Üçüncü blok, geliştirme/test/üretim için "geçilebilir backend" deseninin nasıl yazıldığını gösterir; aynı fonksiyon hem fake hem gerçek backend'le çağrılabilir.

# from qiskit_ibm_runtime import QiskitRuntimeService
# service = QiskitRuntimeService()
# real_backend = service.backend("ibm_brisbane")
# # geliştirme: fake = FakeManilaV2()
# # üretim:    fake = real_backend
# # ortak kod: run(fake, qc) — tek satır geçiş

from qiskit_ibm_runtime.fake_provider import FakeManilaV2

backend = FakeManilaV2()

print(f"sınıf       : {type(backend).__name__}")
print(f"isim        : {backend.name}")
print(f"qubit       : {backend.num_qubits}")
print(f"native kapı : {sorted(backend.target.operation_names)}")
print(f"kenar sayısı: {len(list(backend.coupling_map.get_edges()))}")
print(f"dt          : {getattr(backend, 'dt', 'yok')}")

from qiskit import QuantumCircuit, transpile
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

backend = FakeManilaV2()

qc = QuantumCircuit(3)
qc.h(0); qc.cx(0, 1); qc.cx(1, 2)
qc.measure_all()

tqc    = transpile(qc, backend=backend, optimization_level=3, seed_transpiler=42)
result = backend.run(tqc, shots=2048, seed_simulator=7).result()
counts = result.get_counts()

print(f"derinlik={tqc.depth()}  2q kapı={sum(1 for d in tqc.data if d.operation.num_qubits == 2)}")
for bs, n in sorted(counts.items(), key=lambda x: -x[1])[:6]:
    print(f"  {bs}  {n:5d}  ({n/2048:.2%})")

from qiskit import QuantumCircuit, transpile
from qiskit_ibm_runtime.fake_provider import FakeManilaV2, FakeBelemV2

def run_bell(backend, shots=1024):
    """Verilen backend üzerinde küçük bir Bell devresi çalıştırır."""
    qc = QuantumCircuit(2)
    qc.h(0); qc.cx(0, 1); qc.measure_all()
    tqc = transpile(qc, backend=backend, optimization_level=3, seed_transpiler=1)
    res = backend.run(tqc, shots=shots, seed_simulator=1).result()
    return res.get_counts()

# Geliştirme/test: farklı fake backend'lerle aynı fonksiyon
for cls in (FakeManilaV2, FakeBelemV2):
    counts = run_bell(cls())
    total  = sum(counts.values())
    ok = sum(v for k, v in counts.items() if k in ("00 00", "00", "11 11", "11", "0011", "1100"))
    print(f"{cls.__name__:>14}  shots={total}  '00/11 ailesi'≈{ok/total:.2%}")

# Üretim: tek satır geçişle gerçek backend
# real = service.backend("ibm_brisbane")
# counts = run_bell(real)
# print(counts)

FakeBackend; gerçek cihazın donmuş anının paketlenmiş hâlidir. Aynı arayüzle geliştirme, test ve öğretim mümkün olur; üretime taşınırken kod ideal olarak tek satırda yer değiştirir. Sınırı bilmek (donmuş anlık olduğu, kuyruk/operasyonel taraf taşımadığı, basitleştirilmiş bir gürültü modeli olduğu) etik kullanımın şartıdır. Yayınlarda cihaz adı + tarih + kaynak (fake/gerçek) etiketi kuralı bilimsel zemini korur.

• Aer simülatörü — ideal / gürültülü ayrımının diğer ucu.
• Gürültü modelleme — fake'in arka planındaki kavramın derinleştirilmesi.
• Backend mimarisi — BackendV2 sözleşmesi.
• Backend özellikleri ve Kalibrasyon verileri — fake'in içindeki sayıların okunması.
• Coupling map — topoloji üzerine yerel pratik.
• Backend seçimi ve Runtime execution — fake'in kullanıldığı karar ve yürütme akışı.