added examples

Author: mhjensen

doc/Programs/QuantumML/circuit.py

@@ -0,0 +1,55 @@
+import pennylane as qml
+import torch
+from torch.autograd import Variable
+import matplotlib.pyplot as plt
+
+
+dev = qml.device("default.qubit.torch", wires=1)
+
+@qml.qnode(dev, interface='torch')
+def circuit(phi, theta):
+    qml.RX(theta, wires=0)
+    qml.RZ(phi, wires=0)
+    return qml.expval(qml.PauliZ(0))
+
+def cost(phi, theta, step):
+    # Classical node
+    target = -(-1)**(step // 100)
+    return torch.abs(circuit(phi, theta) - target)**2
+
+phi = Variable(torch.tensor(1.), requires_grad=True)
+theta = Variable(torch.tensor(0.05), requires_grad=True)
+opt = torch.optim.Adam([phi, theta], lr=0.1)
+
+# Training Loop with Output Visualization:
+losses = []
+
+for i in range(1000):
+    opt.zero_grad()
+    loss = cost(phi, theta, i)
+    loss.backward()
+    opt.step()
+
+    losses.append(loss.item())
+
+# Print the final values of phi and theta
+print("Final phi:", phi.item())
+print("Final theta:", theta.item())
+
+# Calculate and print the final expectation value of Pauli-Z
+final_expectation = circuit(phi, theta).item()
+print("Final Expectation Value of Pauli-Z:", final_expectation)
+
+# Plot the loss curve
+plt.plot(range(1000), losses, label='Loss')
+plt.xlabel('Optimization Step')
+plt.ylabel('Loss')
+plt.legend()
+plt.show()
+
+# Plot the circuit output over optimization steps
+plt.plot(range(1000), outputs, label='Circuit Output')
+plt.xlabel('Optimization Step')
+plt.ylabel('Circuit Output')
+plt.legend()
+plt.show()

doc/Programs/QuantumML/sensor.py

@@ -0,0 +1,74 @@
+from qiskit import QuantumCircuit, Aer, transpile, assemble, execute
+import numpy as np
+import matplotlib.pyplot as plt
+
+def create_quantum_circuit(theta):
+    circuit = QuantumCircuit(1, 1)
+    circuit.h(0)  # Hadamard gate
+    circuit.ry(theta, 0)  # RY gate with parameter theta
+    circuit.measure(0, 0)
+    return circuit
+
+def simulate_quantum_circuit(circuit, shots=1024):
+    simulator = Aer.get_backend('qasm_simulator')
+    compiled_circuit = transpile(circuit, simulator)
+    result = execute(compiled_circuit, simulator, shots=shots).result()
+    counts = result.get_counts(compiled_circuit)
+    return counts
+
+def parameter_shift(theta, target, shots=1024, delta=0.001, learning_rate=0.01):
+    forward_circuit = create_quantum_circuit(theta + delta)
+    backward_circuit = create_quantum_circuit(theta - delta)
+
+    forward_counts = simulate_quantum_circuit(forward_circuit, shots)
+    backward_counts = simulate_quantum_circuit(backward_circuit, shots)
+
+    forward_expectation = forward_counts.get('0', 0) / shots
+    backward_expectation = backward_counts.get('0', 0) / shots
+
+    gradient = (forward_expectation - backward_expectation) / (2 * delta)
+
+    return theta - learning_rate * gradient
+
+def train_quantum_sensor(target, epochs=200, convergence_threshold=0.01):
+    theta = -1.0
+    # Lists to store data for final plot
+    epochs_list = []
+    cost_values = []
+
+    for epoch in range(epochs):
+        circuit = create_quantum_circuit(theta)
+        counts = simulate_quantum_circuit(circuit)
+
+        # Evaluate the cost function (simple example)
+        cost = np.abs(counts.get('0', 0) / 1024 - target)
+
+        # Update theta using the parameter-shift rule
+        theta = parameter_shift(theta, convergence_threshold)  # Pass convergence threshold here
+
+        # Append data for final plot
+        epochs_list.append(epoch + 1)
+        cost_values.append(cost)
+
+        # Print numbers
+        print(f"Epoch {epoch + 1}/{epochs}, Cost: {cost}, Theta: {theta}")
+
+        # Check for convergence
+        if cost < convergence_threshold:
+            print(f"Converged at epoch {epoch + 1} with cost {cost}")
+            break
+
+    # Final plot
+    plt.plot(epochs_list, cost_values, marker='o', linestyle='-', color='b')
+    plt.title('Cost Function Over Epochs')
+    plt.xlabel('Epochs')
+    plt.ylabel('Cost')
+    plt.grid(True)
+    plt.show()
+
+    return theta
+# Example usage
+target_value = 0.9  # Replace with your target value
+trained_theta = train_quantum_sensor(target_value, convergence_threshold=0.0005
+)
+print(f"Trained Theta: {trained_theta}")