adding codes

Author: mhjensen

doc/src/week16/programs/crbm.py

@@ -0,0 +1,70 @@
+import numpy as np
+
+class RBM:
+    def __init__(self, n_visible, n_hidden, learning_rate=0.1):
+        self.n_visible = n_visible
+        self.n_hidden = n_hidden
+        self.learning_rate = learning_rate
+
+        # Initialize weights and biases
+        self.weights = np.random.normal(0, 0.01, size=(n_visible, n_hidden))
+        self.visible_bias = np.zeros(n_visible)
+        self.hidden_bias = np.zeros(n_hidden)
+
+    def sigmoid(self, x):
+        return 1.0 / (1 + np.exp(-x))
+
+    def sample_prob(self, probs):
+        return (np.random.rand(*probs.shape) < probs).astype(np.float32)
+
+    def train(self, data, epochs=1000, batch_size=10):
+        n_samples = data.shape[0]
+
+        for epoch in range(epochs):
+            np.random.shuffle(data)
+            for i in range(0, n_samples, batch_size):
+                v0 = data[i:i + batch_size]
+                # Positive phase
+                h0_prob = self.sigmoid(np.dot(v0, self.weights) + self.hidden_bias)
+                h0_sample = self.sample_prob(h0_prob)
+
+                # Negative phase
+                v1_prob = self.sigmoid(np.dot(h0_sample, self.weights.T) + self.visible_bias)
+                h1_prob = self.sigmoid(np.dot(v1_prob, self.weights) + self.hidden_bias)
+
+                # Update weights and biases
+                self.weights += self.learning_rate * (
+                    np.dot(v0.T, h0_prob) - np.dot(v1_prob.T, h1_prob)
+                ) / batch_size
+                self.visible_bias += self.learning_rate * np.mean(v0 - v1_prob, axis=0)
+                self.hidden_bias += self.learning_rate * np.mean(h0_prob - h1_prob, axis=0)
+
+            if epoch % 100 == 0:
+                error = np.mean((v0 - v1_prob) ** 2)
+                print(f"Epoch {epoch}: Reconstruction error = {error:.4f}")
+
+    def transform(self, v):
+        """Compute hidden unit probabilities."""
+        return self.sigmoid(np.dot(v, self.weights) + self.hidden_bias)
+
+    def reconstruct(self, v):
+        """Reconstruct visible units from hidden layer."""
+        h = self.sigmoid(np.dot(v, self.weights) + self.hidden_bias)
+        v_recon = self.sigmoid(np.dot(h, self.weights.T) + self.visible_bias)
+        return v_recon
+
+# Generate synthetic binary data
+data = np.random.randint(0, 2, size=(100, 6))
+
+# Initialize and train RBM
+rbm = RBM(n_visible=6, n_hidden=2, learning_rate=0.1)
+rbm.train(data, epochs=500)
+
+# Transform and reconstruct
+sample = np.array([[1, 0, 1, 0, 1, 0]])
+hidden = rbm.transform(sample)
+reconstructed = rbm.reconstruct(sample)
+
+print("Original:", sample)
+print("Hidden:", hidden)
+print("Reconstructed:", reconstructed)

doc/src/week16/programs/qrbm6.py

@@ -0,0 +1,60 @@
+import pennylane as qml
+from pennylane import numpy as np
+
+# Define the device: two qubits for one visible and one hidden unit
+n_visible = 1
+n_hidden = 1
+dev = qml.device("default.qubit", wires=n_visible + n_hidden)
+
+# Weight and bias initialization
+weights = np.random.normal(0, 0.1, size=(n_visible, n_hidden), requires_grad=True)
+visible_bias = np.zeros(n_visible, requires_grad=True)
+hidden_bias = np.zeros(n_hidden, requires_grad=True)
+
+# Quantum circuit for the RQBM
+@qml.qnode(dev)
+def circuit(v, weights, visible_bias, hidden_bias):
+    # Encode visible state
+    for i in range(n_visible):
+        if v[i] == 1:
+            qml.PauliX(i)
+    
+    # Apply visible bias rotations
+    for i in range(n_visible):
+        qml.RZ(visible_bias[i], wires=i)
+    
+    # Apply hidden bias and interaction terms
+    for j in range(n_hidden):
+        qml.RZ(hidden_bias[j], wires[n_visible + j])
+        for i in range(n_visible):
+            qml.CNOT(wires=[i, n_visible + j])
+            qml.RZ(weights[i, j], wires=n_visible + j)
+            qml.CNOT(wires=[i, n_visible + j])
+
+    return qml.probs(wires=list(range(n_visible + n_hidden)))
+
+# Data: all possible visible unit configurations
+visible_data = np.array([[0], [1]])
+
+# Loss function: negative log-likelihood
+def rqbm_loss(weights, visible_bias, hidden_bias):
+    loss = 0
+    for v in visible_data:
+        probs = circuit(v, weights, visible_bias, hidden_bias)
+        prob = probs[0]  # Only the (v,h=0) state is considered
+        loss -= np.log(prob + 1e-6)
+    return loss / len(visible_data)
+
+# Optimization
+opt = qml.GradientDescentOptimizer(stepsize=0.1)
+steps = 100
+
+for step in range(steps):
+    weights, visible_bias, hidden_bias = opt.step(
+        rqbm_loss, weights, visible_bias, hidden_bias
+    )
+    if step % 10 == 0:
+        current_loss = rqbm_loss(weights, visible_bias, hidden_bias)
+        print(f"Step {step}: Loss = {current_loss:.4f}")
+
+B