Yürütüm akışı — kayıttan tensöre, eğitim döngüsüne kadar

PennyLane’de “yürütüm”, yalnızca kuantum devresinin donanımda koşması değildir; klasik girdilerin kuantum gövdeye girmesi, gövdenin kayda alınması, tape’in cihazda değerlendirilmesi, ölçüm sonuçlarının tensöre dönüşmesi ve (eğitimde) gradyanın geri akması — hepsinin tek bir iş akışı olarak planlanmasıdır.

Qiskit job döngüsünden fark

Qiskit tarafında tipik akış: devre oluştur → transpile → backend’e job gönder → sonuç bekle → counts ile post-process. PennyLane hibrit eğitimde akış: QNode çağrısı → iç tape → cihaz yürütümü → skalar/tensör maliyet → klasik loss.backward() → parametre güncelleme. Kuyruk, coupling map ve routing tabloları bu sayfanın konusu değildir; karşılaştırma yalnızca “ne zaman kuantum, ne zaman klasik?” sorusunu netleştirmek içindir.

result = qnode(x, weights) satırı çalıştığında, kabaca şu sıra izlenir — kullanıcı çoğu adımı görmez:

1. Girdi bağlama — aşağıda alt başlıklarla; kayıttan önce tamamlanır.
2. Kayıt (trace): kuantum gövde bir kez yürütülür; kapılar ve dönüş satırındaki ölçümler tape’e yazılır — devre kaydı bu aşamayı kullanıcı gözüyle anlatır.
3. Yürütüm planı: tape + cihaz + diff_method birleşir; gerekirse transform’lar devreye girer (özet: tape sistemi).
4. Cihaz değerlendirmesi: simülatör veya donanım, tape’i işler; shots açıksa istatistiksel örnekleme bu adımdadır.
5. Dönüş paketleme: expval, probs vb. çıktılar arayüz tensörüne dönüştürülür.

1 — Girdi bağlama: zaman çizelgesindeki ilk durak

qnode(x, weights) satırına girildiğinde PennyLane henüz tape üretmez; önce çağrı argümanları kuantum fonksiyonunun parametrelerine eşlenir ve seçilen arayüz tipine (Torch/JAX/NumPy) uygun hale getirilir. Bu adım, yürütüm akışında “klasik dünya → kuantum gövdeye girecek sayılar” köprüsüdür. İmza sözleşmesi ve çoklu dönüş biçimi QNode mimarisi sayfasında; burada yalnızca çağrı anında ne olur? sorusu vardır.

İmza eşlemesi: x ve weights nereye gider?

Konumsal ve anahtar kelime argümanları, dekoratörlü kuantum fonksiyonunun def circuit(x, weights): imzasıyla bire bir eşleşmelidir. Akış perspektifinden: veri (x) genelde gömme veya sabit açı kaynağıdır; eğitilebilir ağırlıklar (weights) varyasyonel kapılara gider. Yanlış sıra veya eksik argüman kayıt aşamasına gelmeden Python hatası verir — bu, “devre yanlış” değil “çağrı yanlış” sınıfındadır. Kablo sayısı ve gömme boyutu uyumu kayıt sırasında doğrulanır; kablo yönetimi ile hizalayın.

Sabit sayı, tensör ve bağlama zamanı

Aynı kapıya giden değer Python float ise, çoğu senaryoda kayıt anında sabit kabul edilir; tape’e “bu açı şu çağrıda şuydu” yazılır. Değer Torch/JAX tensörü ise, tape’de parametre yuvası bırakılır; sayı yürütüm adımında doldurulur. Yürütüm akışı açısından kritik ayrım budur: sabit girdi değişince tape şablonu değişebilir; tensör parametreleri değişince yalnızca yürütüm tekrarlanır. Bu ayrımın mimari karşılığı girdi hattı başlığında; burada zaman sırası vurgulanır — bağlama, trace’den önce biter.

Eğitilebilirlik: geri geçiş için ön hazırlık

requires_grad=True (veya JAX eşdeğeri) taşımayan ağırlıklar forward’da kullanılır ama backward kuantum tarafında o yuvaya gradyan yazmaz. Girdi bağlama adımında grafik düğümü oluşmazsa, sonraki loss.backward() sessizce “gradyan yok” bırakabilir. Pratik kontrol: bağlama sonrası, eğitmek istediğiniz tensörlerin arayüz grafiğine bağlı olduğundan emin olun — sorun çoğu zaman kayıt veya diff_method değil, bu erken adımdadır. Arayüz seçimi ve otograd birleşimi §4’te özetlenir.

Batch ve çoklu girdi: bağlama vs genişletme

Mini-batch boyutu (x’in ilk ekseni) bu adımda tensör şekline yansır; fakat tape’in fiziksel olarak çoğaltılması (genişletme) çoğu zaman kayıt veya yürütüm planında, bağlamadan sonra olur. Karıştırmayın: bağlama = “bu çağrıda hangi sayı dizileri var?”; genişletme = “aynı şablon bu dizilerin hepsi için nasıl koşturulur?” (ayrıntı tape sistemi §5). Epoch planlarken batch’i burada, throughput’u orada düşünün.

İlk çağrıda kayıt + derleme maliyeti yüksek olabilir; sonraki çağrılarda şablon sabitse önbellek/JIT devreye girebilir — ayrıntı tape sayfasının §6’sında. Yürütüm akışı perspektifinden önemli olan: hangi adımın epoch başına bir kez, hangisinin her mini-batch’te tekrarlandığı.

Kayıt ve yürütüm bilinçli olarak ayrılmıştır: kayıt “ne yapıldı?” sorusunu, yürütüm “bu program seçilen cihazda nasıl koşar?” sorusunu yanıtlar. Aynı tape iskeleti farklı parametre değerleriyle tekrar gönderilebilir; bu, varyasyonel eğitimin temel verimlilik argümanıdır.

execute ve cihaz sözleşmesi

Düşük seviyede qml.execute (veya eşdeğer iç yollar) tape listesini cihaza verir; cihaz ölçüm sonuçlarını döndürür. QNode dekoratörü bu çağrıyı sarmalar; kullanıcı doğrudan execute yazmak zorunda kalmaz. Cihaz değişince aynı kayıtlı gövde farklı gürültü profili veya farklı native kapı setiyle karşılaşabilir — cihaz seçimi yürütüm planının parçasıdır, transpiler detayı değil.

Kablo ve ölçüm sırası

Kayıt sırasında kablo envanteri sabitlenir; yürütüm sırasında ölçüm düğümleri tape sonunda değerlendirilir. Kablo–gömme uyumsuzluğu kayıtta, ölçüm şekli uyumsuzluğu dönüşte patlar — kablo yönetimi ve ölçüm süreci sayfalarına bakın; burada yalnızca sıra hatırlatılır: önce gövde kaydı, sonra cihazda ölçüm yürütümü.

QNode, Torch Tensor, JAX Array veya TensorFlow tensörleriyle konuşacak şekilde arayüzlenir. Yürütüm akışında kritik nokta: kuantum çıktısı klasik grafiğe bağlanabilir bir düğüm olarak dönmelidir; aksi halde loss.backward() kuantum parametrelerine ulaşamaz.

interface= ve çift yönlü köprü

@qml.qnode(dev, interface="torch") gibi seçimler, dönüş tensörünün hangi otograd ailesine ait olduğunu belirler. İleri geçişte QNode skalar üretir; geri geçişte PennyLane kuantum gradyanını hesaplar, arayüz bunu klasik parametre tensörlerine yazar. JAX ile JIT birleştiğinde tüm döngü tek XLA programı altında paketlenebilir — epoch süresinde belirgin fark yaratır.

QNode sınırı, argüman imzası ve çoklu dönüş biçimleri QNode mimarisi sayfasında; burada yalnızca “klasik kayıp ↔ kuantum QNode” bağlantısının akıştaki yeri vurgulanır.

Tek bir optimizasyon adımında akış iki fazlıdır: forward maliyeti hesaplar, backward gradyanları üretir. PennyLane’de kuantum forward, tape kaydı + cihaz yürütümüdür; kuantum backward, seçilen diff_method ile tape üzerinde tanımlı türev yoludur.

Forward

Klasik ön katman (ör. nn.Linear) veriyi hazırlar → QNode kuantum katmanı → maliyet skaları (ör. expval toplamı). Parameter-shift gibi yöntemlerde forward görünürde tek çağrı olsa bile içeride ek tape yürütümleri olabilir — epoch bütçesini planlarken bunu tape sistemi §4 ile birlikte sayın.

Backward

loss.backward() (veya JAX value_and_grad) çağrıldığında önce klasik grafik geri sarar; QNode düğümünde PennyLane devreye girer: transform + (gerekirse) ek yürütümler → ∂L/∂θ kuantum parametrelerine. Backprop uyumlu simülatörde kuantum backward, klasik otograd ile iç içe geçer; donanım veya shots rejiminde yol farklıdır.

Tipik hibrit QML epoch’u şu döngüyü tekrarlar: veri yükleyici → klasik ön işleme → QNode (kayıt + yürütüm) → kayıp → geri yayılım → optimizasyon adımı. Yürütüm akışı perspektifinden epoch maliyeti, QNode çağrı sayısı × çağrı başına iç yürütüm çarpanıdır.

Mini-batch ve çoklu QNode

Aynı ansatz farklı veri satırlarıyla batch halinde genişletilebilir; farklı maliyet terimleri için birden fazla QNode paralel veya sıralı çalıştırılabilir — sonuçlar klasik tarafta toplanır. Bu desen, kuantum kimyasında Hamiltonyen terim toplamlarında sık görülür; tape katmanı terimleri ayrı yürütür ( tape sistemi §5), eğitim döngüsü ise bunları epoch içinde tekrarlar.

Epoch planlama kontrol listesi

• Sabit şablon mu, dinamik kayıt mı? (dinamik → önbellek kırılır)
• Cihaz ve diff_method epoch boyunca sabit mi?
• Isınma epoch’ları benchmark’a dahil mi?
• Loss yalnızca türevlenebilir ölçümlerden mi oluşuyor?

Optimizasyon döngüsünün klasik iskeleti kuantum fonksiyonları sayfasında; burada kuantum yürütümünün epoch içindeki tekrar ritmi vurgulanır.

Sorun belirtisine göre hangi katmana bakacağınızı bilmek, yürütüm akışını öğrenmenin en pratik çıktısıdır. Aşağıdaki harita, §2’deki zaman çizelgesine göre yönlendirir — her maddede derinlik ilgili yan sayfada; burada hangi aşamada kırıldığı ve akış içinde neyi kontrol edeceğiniz vurgulanır.

Önce akışta nerede kırılıyor?

Hata ayıklamayı çoğu zaman şu sırayla yapın: (1) girdi bağlama — çağrı ve tensör şekli; (2) kayıt — gövde çalışıyor mu, tape oluşuyor mu; (3) yürütüm planı + cihaz — execute reddediyor mu; (4) dönüş — skalar/tensör beklediğiniz gibi mi; (5) yalnızca eğitimde sorun varsa geri geçiş. Forward doğru değilken backward’a geçmek zaman kaybıdır — §5’teki “önce forward, sonra gradyan” kuralı burada da geçerlidir.

• Kayıt · şekil · cihaz · gradiyan · performans · dinamik gövde — aşağıda alt başlıklar.

Kayıt hatası / beklenmeyen kapı (trace aşaması)

Belirti: QNode çağrısı tape oluşmadan patlar; “wire does not exist”, tanımsız operatör veya kayıt sırasında beklenmeyen kapı listesi. Akışta bu, adım 2 (kayıt) katmanıdır — cihaz henüz devreye girmemiş olabilir. Kontrol: kuantum fonksiyonu gövdesi, kablo isimleri/sayısı, dönüş satırındaki ölçümler. Python tarafında döngü veya koşul kayda nasıl yansıyor? Devre kaydı sayfasına geçin; burada yalnızca “hata kayıttan önce mi sonra mı?” sorusunu sorun.

Şekil uyumsuzluğu, yanlış probs boyutu (bağlama + kayıt)

Belirti: probs vektörü 2**n değil; batch ile loss boyutu uyuşmuyor; broadcasting hatası. Çoğu zaman sorun adım 1–2 arasında: girdi tensörünün eksenleri ile kablo gömme sözleşmesi kayıt anında farklı şeyler üretir. Akış kontrolü: tek örnek, tek kablo seti ile qnode(x) çıktısının .shape değerini yazdırın; batch’i sonra ekleyin. Kablo sırası ve vektör boyutu kablo yönetimi sayfasında; ölçümün döndürdüğü yapı ölçüm süreci sayfasında.

Cihaz reddi, shots, gürültü (yürütüm aşaması)

Belirti: cihaz exception, desteklenmeyen gözlemlenebilir, shots ile sonuçların aşırı oynaklığı. Akışta adım 3–4 (plan + cihaz değerlendirmesi). Kayıt başarılı ama execute başarısızsa sorun gövdede değil, cihaz + tape + ölçüm üçlüsündedir. Shots ve gürültünün gradyan gürültüsüne dönüşmesi eğitim davranışıdır — cihaz seçimi ve örnekleme bütçesi cihaz sistemi sayfasında; burada “kayıt geçti, yürütüm kırıldı” ayrımını not edin.

Gradyan sıfır / yanlış türev (geri geçiş aşaması)

Belirti: loss düşmüyor, weights.grad hep sıfır veya bariz yanlış; forward makul. Akışta sorun çoğu zaman adım 5’ten sonra (backward) veya aslında adım 1’de (bağlanmayan tensör). Sıra: forward çıktı doğru mu → eğitilebilir tensörler bağlı mı (§2) → diff_method cihazla uyumlu mu → ölçüm türü türevlenebilir mi → transform ek yürütümü beklenen mi? tape dönüşümleri ve ölçüm türü derinlik için; burada “forward OK, backward şüpheli” akış etiketi yeterlidir.

İlk epoch yavaş, sonra hızlı (planlama / önbellek)

Belirti: epoch 1 çok uzun, sonrakiler kısa — bu her zaman hata değildir. Akışta adım 2–3’te bir kerelik maliyet: kayıt, transform planı, JIT/önbellek kurulumu. Karşılaştırmalı benchmark yaparken ısınma epoch’larını süreye dahil etmeyin; aynı şablon, cihaz ve diff_method ile ölçün. Sabit şablonda bile parameter-shift iç çarpanı epoch başına yüksek kalabilir — “yavaşlık” önbellek değil, türev maliyeti de olabilir ( tape §6).

Python if ile farklı devre (dinamik akış)

Belirti: aynı kod bazen çalışıyor bazen farklı derinlik; epoch ortasında süre sıçraması; önbellek “soğuk” kalıyor. Akışta kayıt çağrı başına değişebilir — adım 2 her seferinde yeniden işler. Bu, sabit tape varsayımını kırar; JIT ve batch genişletme beklentileri bozulur. Kuantum betikleri sayfasına geçin; burada yalnızca “kontrol akışı kayıt aşamasını oynatıyor mu?” sorusunu sorun.

Qiskit job hatası vs PennyLane eğitim hatası

Qiskit’te “job failed” veya kuyruk zaman aşımı genelde backend / provider / transpile / job katmanındadır. PennyLane hibrit eğitimde çoğu belirti kayıt → tape → türev yolundadır; kullanıcı QNode çağrısı görür, arka planda job kuyruğu değil execute + transform işler. Donanım köprüsü kullanıyorsanız altta Qiskit yürütmesi olabilir; yine de önce PennyLane akış aşamalarını ayırın, sonra backend loguna inin. Kısa köprü: Qiskit backend mimarisi — farklı problem sınıfı.

Aşağıdaki örnekler, tek bir eğitim adımında forward + backward sırasını iskelet halinde gösterir. API sürümüne duyarlı olabilir; güncel arayüzler için PennyLane Torch arayüzü belgelerine bakın.

import pennylane as qml
import torch

dev = qml.device("default.qubit", wires=2)
weights = torch.tensor([0.1, 0.2], requires_grad=True)

@qml.qnode(dev, interface="torch", diff_method="backprop")
def layer(x):
    qml.RY(x, wires=0)
    qml.RY(weights[0], wires=1)
    qml.CNOT(wires=[0, 1])
    return qml.expval(qml.PauliZ(0))

# Forward: kayıt + yürütüm + tensör
pred = layer(torch.tensor(0.5))
loss = (pred - 0.3) ** 2

# Backward: klasik otograd + kuantum türev yolu
loss.backward()
# weights.grad artık dolu

import jax
import jax.numpy as jnp
import pennylane as qml

dev = qml.device("default.qubit", wires=1)

@qml.qnode(dev, interface="jax")
def model(w):
    qml.RY(w, wires=0)
    return qml.expval(qml.PauliZ(0))

def loss_fn(w):
    return (model(w) - 0.2) ** 2

loss, grad = jax.value_and_grad(loss_fn)(jnp.array(0.4))
# Tek çağrıda forward + gradyan (JAX tarafında paketlenir)

Yürütüm akışı, birimdeki parçaları birleştiren “harita” sayfasıdır. Derinleşmek için:

• QNode mimarisi — dekoratör, imza ve dönüş sözleşmesi.
• Devre kaydı — kayıt aşaması (trace).
• Tape sistemi — ara temsil, transform, batch, JIT.
• Ölçüm süreci — cihazdan klasik tensöre çıktı.
• Cihaz sistemi — yürütüm bağlamı ve shots.
• Kuantum betikleri — dinamik kontrol akışı ve önbellek kırılması.