update week 15

Author: mhjensen

doc/pub/week15/html/week15-bs.html

@@ -1096,7 +1096,7 @@ <h2 id="computing-quantum-kernel-matrices">Computing Quantum Kernel Matrices </h
   </div>
 </div>
 
-<p>and compute kernel matrices.  For training:</p>
+<p>and compute kernel matrices.  For training (<b>note the codes will not run properly since the data are not defined</b>):</p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "perldoc" -->
 <div class="cell border-box-sizing code_cell rendered">
@@ -2215,7 +2215,6 @@ <h2 id="implementing-qnns-with-pennylane">Implementing QNNs with PennyLane </h2>
     variational_layer(params[<span style="color: #B452CD">4</span>:<span style="color: #B452CD">8</span>])
     <span style="color: #228B22"># measure expectation of Z on qubit 0</span>
     <span style="color: #8B008B; font-weight: bold">return</span> qml.expval(qml.PauliZ(wires=<span style="color: #B452CD">0</span>))
-In this code:
 </pre>
 </div>
       </div>
@@ -2231,8 +2230,8 @@ <h2 id="implementing-qnns-with-pennylane">Implementing QNNs with PennyLane </h2>
   </div>
 </div>
 
-<p>We instantiate a 2-qubit device dev.  feature$\_$map(x) encodes the
-2-dimensional input x using \( R_x \) rotations .
+<p>In this code we instantiate a two-qubit device dev.  feature$\_$map(x) encodes the
+two-dimensional input x using \( R_x \) rotations .
 variational$\_$layer(params) is a block of trainable gates (here two Rot
 gates and a CNOT).  The @qml.qnode(dev) decorator turns the Python
 function qclassifier into a quantum node that returns the expectation
@@ -2325,6 +2324,218 @@ <h2 id="additional-exercises">Additional exercises </h2>
 </ol>
 </section>
 
+<section>
+<h2 id="variational-quantum-neural-network-for-credit-classification">Variational Quantum Neural Network for credit classification </h2>
+
+<p>This self-contained PennyLane code demonstrates a simple hybrid
+quantum-classical binary classifier on synthetic financial data, like
+the one we discussed in connection with quantum support vector
+machines.
+</p>
+
+<p>We build a quantum neural network (QNN) &#8211; a parameterized
+(variational) quantum circuit &#8211; to classify synthetic credit data.
+Quantum neural networks are typically implemented as variational
+quantum circuits with trainable rotation angles.
+</p>
+
+<p>We first generate
+small synthetic data with features like income, debt ratio, and age,
+labeling each datapoint as &#8220;good&#8221; or &#8220;bad&#8221; credit. Classical features
+are encoded into qubit rotation angles using an angle embedding, and a
+layer of trainable entangling gates (PennyLane&#8217;s
+StronglyEntanglingLayers) forms the variational ansatz. During
+training, we optimize the circuit parameters via a classical optimizer
+to minimize binary cross-entropy loss . Finally, we measure one qubit
+to produce a probability for the positive class and evaluate the
+classifier with accuracy, precision, and recall . The following code
+implements all steps using PennyLane&#8217;s default.qubit simulator.
+</p>
+
+
+<!-- code=python (!bc pycod) typeset with pygments style "perldoc" -->
+<div class="cell border-box-sizing code_cell rendered">
+  <div class="input">
+    <div class="inner_cell">
+      <div class="input_area">
+        <div class="highlight" style="background: #eeeedd">
+  <pre style="font-size: 80%; line-height: 125%;"><span style="color: #8B008B; font-weight: bold">import</span> <span style="color: #008b45; text-decoration: underline">numpy</span> <span style="color: #8B008B; font-weight: bold">as</span> <span style="color: #008b45; text-decoration: underline">np</span>
+<span style="color: #8B008B; font-weight: bold">import</span> <span style="color: #008b45; text-decoration: underline">pennylane</span> <span style="color: #8B008B; font-weight: bold">as</span> <span style="color: #008b45; text-decoration: underline">qml</span>
+<span style="color: #8B008B; font-weight: bold">from</span> <span style="color: #008b45; text-decoration: underline">pennylane</span> <span style="color: #8B008B; font-weight: bold">import</span> numpy <span style="color: #8B008B; font-weight: bold">as</span> pnp
+<span style="color: #8B008B; font-weight: bold">from</span> <span style="color: #008b45; text-decoration: underline">sklearn.model_selection</span> <span style="color: #8B008B; font-weight: bold">import</span> train_test_split
+<span style="color: #8B008B; font-weight: bold">from</span> <span style="color: #008b45; text-decoration: underline">sklearn.metrics</span> <span style="color: #8B008B; font-weight: bold">import</span> accuracy_score, precision_score, recall_score
+
+<span style="color: #228B22"># Step 1: Generate synthetic credit data</span>
+np.random.seed(<span style="color: #B452CD">0</span>)
+N = <span style="color: #B452CD">100</span>
+<span style="color: #228B22"># Features: income (in thousands), debt_ratio (percent), age (years)</span>
+income = np.random.normal(<span style="color: #B452CD">50</span>, <span style="color: #B452CD">15</span>, N)         <span style="color: #228B22"># mean 50, std 15</span>
+debt_ratio = np.random.uniform(<span style="color: #B452CD">0</span>, <span style="color: #B452CD">100</span>, N)    <span style="color: #228B22"># between 0 and 100%</span>
+age = np.random.randint(<span style="color: #B452CD">18</span>, <span style="color: #B452CD">70</span>, N)           <span style="color: #228B22"># ages 18 to 69</span>
+X = np.column_stack((income, debt_ratio, age))
+
+<span style="color: #228B22"># Label: simple linear rule with noise =&gt; 1 = good credit, 0 = bad</span>
+score = <span style="color: #B452CD">0.3</span> * income - <span style="color: #B452CD">0.2</span> * debt_ratio + <span style="color: #B452CD">0.1</span> * age
+y = (score &gt; np.median(score)).astype(<span style="color: #658b00">int</span>)   <span style="color: #228B22"># threshold at median</span>
+
+<span style="color: #228B22"># Split into train/test (80/20 split)</span>
+X_train_np, X_test_np, y_train_np, y_test_np = train_test_split(X, y, test_size=<span style="color: #B452CD">0.2</span>, random_state=<span style="color: #B452CD">42</span>)
+
+<span style="color: #228B22"># Step 2: Feature scaling for angle embedding</span>
+<span style="color: #228B22"># Scale each feature to [0, pi] so they can serve as rotation angles</span>
+max_income = X[:, <span style="color: #B452CD">0</span>].max()
+max_debt = X[:, <span style="color: #B452CD">1</span>].max()
+min_age, max_age = X[:, <span style="color: #B452CD">2</span>].min(), X[:, <span style="color: #B452CD">2</span>].max()
+
+<span style="color: #228B22"># Scale training data</span>
+X_train_scaled = X_train_np.copy()
+X_train_scaled[:, <span style="color: #B452CD">0</span>] = X_train_scaled[:, <span style="color: #B452CD">0</span>] / max_income * np.pi
+X_train_scaled[:, <span style="color: #B452CD">1</span>] = X_train_scaled[:, <span style="color: #B452CD">1</span>] / max_debt * np.pi
+X_train_scaled[:, <span style="color: #B452CD">2</span>] = (X_train_scaled[:, <span style="color: #B452CD">2</span>] - min_age) / (max_age - min_age) * np.pi
+
+<span style="color: #228B22"># Scale test data</span>
+X_test_scaled = X_test_np.copy()
+X_test_scaled[:, <span style="color: #B452CD">0</span>] = X_test_scaled[:, <span style="color: #B452CD">0</span>] / max_income * np.pi
+X_test_scaled[:, <span style="color: #B452CD">1</span>] = X_test_scaled[:, <span style="color: #B452CD">1</span>] / max_debt * np.pi
+X_test_scaled[:, <span style="color: #B452CD">2</span>] = (X_test_scaled[:, <span style="color: #B452CD">2</span>] - min_age) / (max_age - min_age) * np.pi
+
+<span style="color: #228B22"># Convert data to PennyLane numpy arrays for differentiation</span>
+X_train = pnp.array(X_train_scaled)
+X_test  = pnp.array(X_test_scaled)
+y_train = pnp.array(y_train_np)
+y_test  = pnp.array(y_test_np)
+
+<span style="color: #228B22"># Step 3: Define the variational quantum circuit</span>
+n_qubits = <span style="color: #B452CD">3</span>
+dev = qml.device(<span style="color: #CD5555">&quot;default.qubit&quot;</span>, wires=n_qubits)
+
+<span style="color: #228B22"># Parameterized quantum neural network (variational circuit)</span>
+<span style="color: #707a7c">@qml</span>.qnode(dev)
+<span style="color: #8B008B; font-weight: bold">def</span> <span style="color: #008b45">circuit</span>(weights, x):
+    <span style="color: #228B22"># Feature map: encode features by rotation angles on each qubit</span>
+    <span style="color: #228B22"># Uses RY rotations (AngleEmbedding by default uses RX or can specify RY)</span>
+    qml.AngleEmbedding(features=x, wires=<span style="color: #658b00">range</span>(n_qubits), rotation=<span style="color: #CD5555">&#39;Y&#39;</span>)
+    <span style="color: #228B22"># Variational (trainable) layers: strong entangling rotations</span>
+    qml.templates.StronglyEntanglingLayers(weights, wires=<span style="color: #658b00">range</span>(n_qubits))
+    <span style="color: #228B22"># Measure expectation of Pauli-Z on the first qubit</span>
+    <span style="color: #8B008B; font-weight: bold">return</span> qml.expval(qml.PauliZ(<span style="color: #B452CD">0</span>))
+
+<span style="color: #228B22"># Initialize trainable weights for the variational layers</span>
+num_layers = <span style="color: #B452CD">1</span>
+<span style="color: #228B22"># Shape for StronglyEntanglingLayers: (num_layers, n_qubits, 3)</span>
+init_weights = <span style="color: #B452CD">0.01</span> * np.random.randn(num_layers, n_qubits, <span style="color: #B452CD">3</span>)
+weights = pnp.array(init_weights, requires_grad=<span style="color: #8B008B; font-weight: bold">True</span>)
+
+<span style="color: #228B22"># Step 4: Define cost (binary cross-entropy) and train the QNN</span>
+<span style="color: #8B008B; font-weight: bold">def</span> <span style="color: #008b45">cross_entropy_loss</span>(weights, X, y):
+    <span style="color: #228B22"># Run circuit on each sample to get expectation values</span>
+    expvals = [circuit(weights, x=x) <span style="color: #8B008B; font-weight: bold">for</span> x <span style="color: #8B008B">in</span> X]
+    expvals = pnp.stack(expvals)
+    <span style="color: #228B22"># Convert expectation ⟨Z⟩ to probability for label=1: P(1) = (1 - ⟨Z⟩)/2</span>
+    probs = (<span style="color: #B452CD">1</span> - expvals) / <span style="color: #B452CD">2</span>
+    <span style="color: #228B22"># Clip probabilities to avoid log(0)</span>
+    probs = pnp.clip(probs, <span style="color: #B452CD">1e-6</span>, <span style="color: #B452CD">1</span> - <span style="color: #B452CD">1e-6</span>)
+    <span style="color: #228B22"># Binary cross-entropy loss</span>
+    loss = -pnp.mean(y * pnp.log(probs) + (<span style="color: #B452CD">1</span> - y) * pnp.log(<span style="color: #B452CD">1</span> - probs))
+    <span style="color: #8B008B; font-weight: bold">return</span> loss
+
+<span style="color: #228B22"># Choose an optimizer (gradient descent)</span>
+opt = qml.GradientDescentOptimizer(stepsize=<span style="color: #B452CD">0.5</span>)
+
+<span style="color: #228B22"># Training loop</span>
+epochs = <span style="color: #B452CD">20</span>
+<span style="color: #8B008B; font-weight: bold">for</span> it <span style="color: #8B008B">in</span> <span style="color: #658b00">range</span>(epochs):
+    weights, cost_val = opt.step_and_cost(<span style="color: #8B008B; font-weight: bold">lambda</span> w: cross_entropy_loss(w, X_train, y_train), weights)
+    <span style="color: #8B008B; font-weight: bold">if</span> (it + <span style="color: #B452CD">1</span>) % <span style="color: #B452CD">5</span> == <span style="color: #B452CD">0</span>:
+        <span style="color: #658b00">print</span>(<span style="color: #CD5555">f&quot;Iteration {</span>it+<span style="color: #B452CD">1</span><span style="color: #CD5555">:&gt;2}: loss = {</span>cost_val<span style="color: #CD5555">:.4f}&quot;</span>)
+
+<span style="color: #228B22"># Step 5: Evaluate performance on training and test sets</span>
+<span style="color: #228B22"># Predict by evaluating circuit and thresholding at 0.5</span>
+<span style="color: #8B008B; font-weight: bold">def</span> <span style="color: #008b45">predict</span>(weights, X):
+    preds = []
+    <span style="color: #8B008B; font-weight: bold">for</span> x <span style="color: #8B008B">in</span> X:
+        z = circuit(weights, x=x)
+        prob = <span style="color: #658b00">float</span>((<span style="color: #B452CD">1</span> - z) / <span style="color: #B452CD">2</span>)  <span style="color: #228B22"># probability of class=1</span>
+        preds.append(<span style="color: #658b00">int</span>(prob &gt; <span style="color: #B452CD">0.5</span>))
+    <span style="color: #8B008B; font-weight: bold">return</span> np.array(preds)
+
+y_train_pred = predict(weights, X_train)
+y_test_pred  = predict(weights, X_test)
+
+<span style="color: #228B22"># Compute accuracy, precision, recall</span>
+train_acc = accuracy_score(y_train_np, y_train_pred)
+test_acc  = accuracy_score(y_test_np, y_test_pred)
+train_prec = precision_score(y_train_np, y_train_pred)
+test_prec  = precision_score(y_test_np, y_test_pred)
+train_rec  = recall_score(y_train_np, y_train_pred)
+test_rec   = recall_score(y_test_np, y_test_pred)
+
+<span style="color: #658b00">print</span>(<span style="color: #CD5555">f&quot;Train Accuracy:  {</span>train_acc<span style="color: #CD5555">:.2f}, Precision: {</span>train_prec<span style="color: #CD5555">:.2f}, Recall: {</span>train_rec<span style="color: #CD5555">:.2f}&quot;</span>)
+<span style="color: #658b00">print</span>(<span style="color: #CD5555">f&quot;Test  Accuracy:  {</span>test_acc<span style="color: #CD5555">:.2f}, Precision: {</span>test_prec<span style="color: #CD5555">:.2f}, Recall: {</span>test_rec<span style="color: #CD5555">:.2f}&quot;</span>)
+</pre>
+</div>
+      </div>
+    </div>
+  </div>
+  <div class="output_wrapper">
+    <div class="output">
+      <div class="output_area">
+        <div class="output_subarea output_stream output_stdout output_text">          
+        </div>
+      </div>
+    </div>
+  </div>
+</div>
+</section>
+
+<section>
+<h2 id="essential-steps-in-the-code">Essential steps in the code </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b>Data Encoding:</b>
+<p>
+<p>We map each feature vector to quantum states via angle embedding: each
+feature is used as the rotation angle of an RY gate on a qubit . This
+creates a <b>quantum feature map</b> of our classical data.
+</p>
+</div>
+
+<div class="alert alert-block alert-block alert-text-normal">
+<b>Variational Ansatz:</b>
+<p>
+<p>After embedding, we apply a layer of trainable rotations and
+entangling gates (StronglyEntanglingLayers), creating a parameterized
+circuit whose outputs depend on adjustable weights . Measuring the
+expectation &#10216;Z&#10217; of the first qubit yields a value in \( [&#8211;1,1] \), which we
+convert to a class probability via \( (1 &#8211; &#10216;Z&#10217;)/2 \).
+</p>
+</div>
+
+
+<div class="alert alert-block alert-block alert-text-normal">
+<b>Training:</b>
+<p>
+<p>We optimize the circuit parameters by minimizing the binary
+cross-entropy loss between the predicted probabilities and true
+labels. Binary cross-entropy (log-loss) is a standard choice for
+binary classification , adjusting weights to improve the match between
+predictions and targets. We use PennyLane&#8217;s GradientDescentOptimizer
+(or AdamOptimizer) to update parameters via backpropagated gradients.
+</p>
+</div>
+
+
+<div class="alert alert-block alert-block alert-text-normal">
+<b>Evaluation:</b>
+<p>
+<p>Finally, we compute accuracy, precision, and recall on the
+dataset. Accuracy is the fraction of correct predictions. Precision is
+the fraction of predicted &#8220;good&#8221; credits that are truly good, and
+recall is the fraction of actual good credits that are correctly
+identified. These metrics are standard in classification tasks .
+</p>
+</div>
+</section>
+
 <section>
 <h2 id="applications-and-examples">Applications and examples </h2>
 
@@ -2387,12 +2598,6 @@ <h2 id="more-on-applications">More on applications </h2>
 <p>Small-scale QML experiments have been run on IBM, Google, and IonQ devices. These serve as proof-of-concept for the hybrid model.</p>
 </div>
 
-<p>Each application comes with domain-specific twists, but all rely on
-the core ideas of Chapters 1&#8211;4: encoding data, parameterized circuits,
-measurement, and classical optimization.  As hardware improves, more
-complex QML tasks (e.g. image recognition, chemistry simulations,
-finance models) may become feasible.
-</p>
 
 <!-- A. Abbas et al., &#8220;The power of quantum neural networks,&#8221; Nature Comput. Sci. 1, 403&#8211;409 (2021) . -->
 <!-- E. Anschuetz and B. Kiani, &#8220;Quantum variational algorithms are swamped with traps,&#8221; Nat. Commun. 13, 7760 (2022) . -->