Create qrbm3.py

Author: mhjensen

doc/src/week16/programs/qrbm3.py

@@ -0,0 +1,103 @@
+# Code example for a Quantum Boltzmann Machine (QBM) applied to a binary classification problem using PennyLane. This example uses a simplified dataset (XOR problem) and trains a parameterized quantum circuit to model the joint distribution of features and labels.
+
+import pennylane as qml
+from pennylane import numpy as np
+
+# Define the target probabilities for the XOR dataset
+target_probs = np.zeros(8)
+target_indices = [0, 3, 5, 6]  # Binary: 000, 011, 101, 110
+for idx in target_indices:
+   target_probs[idx] = 0.25
+
+# Quantum circuit configuration
+num_qubits = 3  # 2 features + 1 label
+dev = qml.device("default.qubit", wires=num_qubits)
+
+@qml.qnode(dev)
+def circuit(params):
+   # First rotation layer
+   for i in range(num_qubits):
+       qml.RX(params[0][i], wires=i)
+       qml.RY(params[1][i], wires=i)
+
+   # Entangling gates
+   qml.CNOT(wires=[0, 1])
+   qml.CNOT(wires=[1, 2])
+   qml.CNOT(wires=[0, 2])
+
+   # Second rotation layer
+   for i in range(num_qubits):
+       qml.RX(params[2][i], wires=i)
+       qml.RY(params[3][i], wires=i)
+
+   return qml.probs(wires=range(num_qubits))
+
+# Initialize parameters
+params = [
+   np.random.uniform(0, 2*np.pi, size=num_qubits, requires_grad=True),
+   np.random.uniform(0, 2*np.pi, size=num_qubits, requires_grad=True),
+   np.random.uniform(0, 2*np.pi, size=num_qubits, requires_grad=True),
+   np.random.uniform(0, 2*np.pi, size=num_qubits, requires_grad=True)
+]
+
+# Cost function (KL divergence)
+def cost(params):
+   model_probs = circuit(params)
+   cost = 0.0
+   for idx in target_indices:
+       q = model_probs[idx]
+       cost += 0.25 * (np.log(0.25) - np.log(q + 1e-10))  # Add small epsilon to avoid log(0)
+   return cost
+
+# Optimization
+opt = qml.AdamOptimizer(stepsize=0.1)
+max_iterations = 100
+
+for i in range(max_iterations):
+   params, current_cost = opt.step_and_cost(cost, params)
+   if i % 10 == 0:
+       print(f"Iteration {i+1}: Cost = {current_cost}")
+
+# Prediction function
+def predict(features):
+   # Calculate probabilities for both possible labels
+   all_probs = circuit(params)
+   feature_mask = (int(f"{features[0]}{features[1]}", 2) << 1)
+   p0 = all_probs[feature_mask]
+   p1 = all_probs[feature_mask | 1]
+   total = p0 + p1
+   return p0/total if total != 0 else 0.5, p1/total if total != 0 else 0.5
+
+# Test the model
+test_cases = [(0,0), (0,1), (1,0), (1,1)]
+print("\nPredictions:")
+for features in test_cases:
+   prob_0, prob_1 = predict(features)
+   print(f"Features {features}: P(0)={prob_0:.2f}, P(1)={prob_1:.2f}")
+
+"""
+**Key components explained:**
+
+1. **Dataset**: Uses XOR problem with binary features and labels encoded in 3 qubits (2 features, 1 label).
+
+2. **Quantum Circuit**:
+  - Uses rotation gates (RX, RY) and entangling gates (CNOT)
+  - Parameters are optimized to match the target distribution
+  - Outputs probabilities for all possible 8 states
+
+3. **Training**:
+  - Minimizes KL divergence between model and target probabilities
+  - Uses Adam optimizer for better convergence
+
+4. **Prediction**:
+  - Calculates conditional probabilities p(label|features) by marginalizing the joint distribution
+  - Normalizes probabilities for classification
+
+**Note:** This is a simplified example. For real-world applications, you would need to:
+1. Handle continuous features (e.g., using amplitude encoding)
+2. Use more sophisticated ansatz architectures
+3. Implement proper batching for larger datasets
+4. Add regularization to prevent overfitting
+
+The output should show decreasing cost during training and high probabilities for correct labels in predictions. Actual results may vary due to random initialization and optimization challenges.
+"""