repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/bawejagb/Quantum_Computing
|
bawejagb
|
#Import Libraries
from qiskit import QuantumCircuit, transpile, Aer, assemble
from qiskit.providers.aer import QasmSimulator
from qiskit.visualization import plot_bloch_multivector, plot_histogram
from qiskit.visualization import array_to_latex, plot_state_qsphere
#Input State: 01
qc_ha=QuantumCircuit(4,2)
qc_ha.x(0)
qc_ha.barrier()
qc_ha.cx(0,2)
qc_ha.cx(1,2)
qc_ha.ccx(0,1,3)
# Draw the circuit
qc_ha.draw(output='mpl')
# Let's get the result:
svsim=Aer.get_backend('aer_simulator')
qc_ha.save_statevector()
qobj = assemble(qc_ha)
result = svsim.run(qobj).result()
# Print the statevector neatly:
final_state = result.get_statevector()
array_to_latex(final_state, prefix="\\text{Statevector = }")
#Plot Sphere
plot_state_qsphere(final_state)
# Map the quantum measurement to the classical bits
qc_ha.measure(2,0)
qc_ha.measure(3,1)
# Draw the circuit
qc_ha.draw(output='mpl')
# compile the circuit down to low-level QASM instructions
simulator = QasmSimulator()
compiled_circuit = transpile(qc_ha, simulator)
# Execute the circuit on the qasm simulator
job = simulator.run(compiled_circuit, shots=1000)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(compiled_circuit)
print("\nTotal count for 00 and 11 are:",counts)
#Plot histogram of result
plot_histogram(counts)
|
https://github.com/bawejagb/Quantum_Computing
|
bawejagb
|
from qiskit import IBMQ
IBMQ.providers()
#https://quantum-computing.ibm.com/
#Craete account on IBM from above link and Paste 'YOUR-IBM-API-TOKEN'
IBMQ.save_account('YOUR-IBM-API-TOKEN',overwrite=True)
IBMQ.load_account()
from qiskit import(
QuantumCircuit,
execute,
Aer)
from qiskit.visualization import plot_histogram
# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(2, 2)
# Add a H gate on qubit 0
circuit.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circuit.cx(0, 1)
# Map the quantum measurement to the classical bits
circuit.measure([0,1], [0,1])
# Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)
# Draw the circuit
circuit.draw(output='mpl')
provider = IBMQ.get_provider('ibm-q')
provider.backends()
qcomp = provider.get_backend('ibmq_lima')
job = execute(circuit, backend=qcomp)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
result = job.result()
plot_histogram(result.get_counts(circuit))
|
https://github.com/brunorijsman/qiskit-cheat-sheet
|
brunorijsman
|
from qiskit import *
from qiskit.visualization import *
from math import *
# A simple example Quantum Circuit that is used in many code snippets below
example_qc = QuantumCircuit(2, 1)
example_qc.h(0)
example_qc.cx(0, 1)
example_qc.measure(1, 0)
None
# Specify number of qubits and classical bits
qc = QuantumCircuit(2, 1) # Quantum circuit with 2 qubits and 1 classical bit
# In any of these examples add qc.draw() at the end to see better what is happening:
# qc.draw()
# Specify only number of qubits
# Number of classical bits is zero by default
qc = QuantumCircuit(2) # Quantum circuit with 2 qubits, and 0 classical bits
# Quantum circuit with two quantum registers (a and b) and one classical register (c)
a = QuantumRegister(2, "a") # 2 qubits in register, name is "a"
b = QuantumRegister(3, "b") # 3 qubits in register, name is "b"
c = ClassicalRegister(1, "c") # 1 classical bit in register, name is "c"
qc = QuantumCircuit(a, b, c) # Quantum circuit with register a, b, and c
# Give a name to the quantum circuit (not shown in draw or print)
qc = QuantumCircuit(2, 2, name="my-quantum-circuit")
# Apply a global phase to the quantum circuit
# This is reported in draw() and print() and this is relevant when composing circuits
qc = QuantumCircuit(2, 2, global_phase=pi/4)
# Initialize to state provided as explicit vector
qc = QuantumCircuit(2)
qc.initialize([1, 0], 0) # Initialize qubit number 0 to [1, 0] = |0>
qc.initialize([0, 1], 1) # Initialize qubit number 1 to [0, 1] = |1>
# Many example end with "None" to avoid printing the return value of the last statement
# In this case, qc.intialize() returns an InstructionSet object
None
# Reset qubit
qc = QuantumCircuit(1)
qc.reset(0)
None
# Initalize to string label
# TODO: This is supposed to work, but it throws an exception
# qc = QuantumCircuit(2)
# qc.initialize('01', qc.qubits) # Initialize qubit 0 to |1> and qubit 1 to |0>
# qc.initialize('+-', qc.qubits) # Initialize qubit 0 to |+> and qubit 1 to |->
# qc.initialize('rl', qc.qubits) # Initialize qubit 0 to |r> = |i> and qubit 1 to |l> = |-i>
None
# Apply a gate to a single qubit
qc = QuantumCircuit(1)
qc.x(0) # Apply X = NOT gate to qubit number 0
None # qc.x function returns an InstructionSet which I don't want to be printed
# Apply a gate to two qubits
qc = QuantumCircuit(2)
qc.cx(0, 1) # Apply CX = controlled X = controlled NOT gate, qubit 0 is control, qubit 1 is target
None
# Apply a gate to three qubits
qc = QuantumCircuit(3)
qc.ccx(0, 1, 2) # Apply CCX = controlled controlled X = Toffoli gate, qubits 0 and 1 are control, qubit 2 is target
None
# Single qubit gates
qc = QuantumCircuit(1)
qc.x(0) # X gate = NOT gate = 180 degree rotation around X-axis
qc.y(0) # Y gate = 180 degree rotation around Y-axis
qc.z(0) # Z gate = 180 degree rotation around Z-axis
qc.s(0) # S gate = 90 degree positive rotation around Z-axis
qc.sdg(0) # S-dagger gate = 90 degree negative rotation around Z-axis
qc.t(0) # T gate = 45 degree positive rotation around Z-axis
qc.tdg(0) # T-dagger gate = 45 degree negative rotation around Z-axis
qc.h(0) # H gate = Hadamard gate
qc.i(0) # I gate = Identity gate (does nothing)
qc.id(0) # Identity gate (synonym for I gate)
# Parameterized gates
qc.p(pi/4, 0) # P gate = Phase gate: first argument is phase
qc.rx(pi/4, 0) # Rotate around X-axis by some angle
qc.ry(pi/4, 0) # Rotate around Y-axis by some angle
qc.rz(pi/4, 0) # Rotate around Z-axis by some angle
None
# Two qubit gates
qc = QuantumCircuit(2)
# "True" two qubit gates
qc.swap(0, 1) # Swap gate
qc.iswap(0, 1) # Iswap gate
# Controlled single qubit gates
# First argument is control qubit second argument is target qubit
qc.cx(0, 1) # Controlled-X = Controlled-NOT
qc.cnot(0, 1) # Controller-NOT = Controlled-X (synonym for cx)
qc.cy(0, 1) # Controlled-Y
qc.cz(0, 1) # Controlled-Z (Note control and target are symmetric due to phase kick-back)
qc.ch(0, 1) # Controlled-H = Controlled-Hadamard
# Controlled rotations around various axes / controlled phase
# First arg is phase, second is control qubit, third is target qubit
qc.crx(pi/8, 0, 1) # Controlled rotation around x-axis
qc.cry(pi/8, 0, 1) # Controlled rotation around y-axis
qc.crz(pi/8, 0, 1) # Controlled rotation around z-axis
qc.cp(pi/8, 0, 1) # Controlled-Phase
qc.csx(0, 1) # Controlled-SX gate = Controlled square-root-of-X gate
None
# Three qubit gates
# Double controlled single qubit gates
# First and second argument are control qubits, third argument is target qubit
qc = QuantumCircuit(3)
qc.ccx(0, 1, 2) # Controlled-controlled-X = controlled-controlled-NOT = Tofolli gate
# Controlled two qubit gates
# First argument is control qubit, second and third argument are target qubits
qc.cswap(0, 1, 2) # Controlled-swap
qc.fredkin(0, 1, 2) # Fredkin gate = synonym for controlled-swap
None
# TODO: more gates
# cu gate
# cu1 gate
# cu3 gate
# dcx gate
# ecr gate
# mcp gate
# mcrx gate
# mcry gate
# mcrz gate
# mct gate
# mcu1 gate
# mcx gate
# ms gate
# pauli gate
# r gate
# rccx gate
# rcccx gate
# rv gate
# rxx gate
# ryy gate
# rzz gate
# rzx gate
# sx gate
# sxdg gate
# u gate
# u1 gate
# u2 gate
# uc gate
# ucrx gate
# ucry gate
# ucrz gate
# Measure one qubit in existing classical bit
# Measure qubit number 0 into classical bit number 0
qc = QuantumCircuit(1, 1)
qc.measure(0, 0)
None
# Measure multiple qubits into multiple existing classical bits
# Measure qubit number 0 into classical bit number 0, and qubit number 1 into classical bit number 1
qc = QuantumCircuit(2, 2)
qc.measure([0, 1], [0, 1])
None
# Measure quantum register into existing classical register
quantum_register = QuantumRegister(2)
classical_register = ClassicalRegister(2)
qc = QuantumCircuit(quantum_register, classical_register)
qc.measure(quantum_register, classical_register)
None
# Create barrier and measure all qubits into newly created classical bits "meas"
qc = QuantumCircuit(2)
qc.measure_all()
None
# Create barrier and measure all qubits that have at least one gate into newly created classical bits "meas"
qc = QuantumCircuit(2)
qc.x(0)
qc.measure_active()
None
# Use Python control logic to procedurally generate a circuit
nr_qubits = 6
qc = QuantumCircuit(nr_qubits)
for i in range(nr_qubits-1):
qc.h(i)
qc.cx(i, nr_qubits-1)
# Draw a quantum circuit
example_qc.draw()
# Draw multiple quantum circuits
# Without the display calls, only the last draw is shown
display(example_qc.draw())
display(example_qc.draw())
# Draw a scaled quantum circuit
example_qc.draw(scale=0.5)
# Draw a quantum circuit as text
example_qc.draw(output="text")
# Print a quantum circuit (same as draw as text)
print(example_qc)
# Execute by invoking execute method, passing in quantum circuit and backend
backend = Aer.get_backend("qasm_simulator")
job = execute(example_qc, backend)
result = job.result()
# Execute by compiling to object code and then invoking backend run method, passing in object code
backend = Aer.get_backend("qasm_simulator")
qobj = assemble(example_qc)
job = backend.run(qobj)
result = job.result()
# Features of qasm_simulator backend:
# - Simulates a real (noisy) hardware device
# - No access to state vector, only to measurement results
# - TODO: more
backend = Aer.get_backend("qasm_simulator") # Note: synonymous with "aer_simulator" TODO: is that so?
result = execute(example_qc, backend).result()
# Features of statevector_simulator backend:
# - TODO
backend = Aer.get_backend("statevector_simulator") # Note: synonymous with "aer_simulator_statevector"
result = execute(example_qc, backend).result()
# Features of unitary_simulator backend:
# - TODO
backend = Aer.get_backend("unitary_simulator") # Note: synonymous with "aer_simulator_unitary"
result = execute(example_qc, backend).result()
# Plot histogram of measurement results
# Available with all backends
backend = Aer.get_backend("qasm_simulator")
job = execute(example_qc, backend)
result = job.result()
counts = result.get_counts()
plot_histogram(counts)
# Plot Bloch multivector for a quantum state
# Only available on backends where the internal statevector is available
backend = Aer.get_backend("statevector_simulator")
job = execute(example_qc, backend)
result = job.result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
# Plot a state city for a quantum state
# Only available on backends where the internal statevector is available
qc = QuantumCircuit(2)
qc.h(0)
qc.z(0)
qc.cx(0, 1)
backend = Aer.get_backend("statevector_simulator")
job = execute(qc, backend)
result = job.result()
statevector = result.get_statevector()
plot_state_city(statevector)
# Plot a hinton diagram for the density matrix of a quantum state
# Only available on backends where the internal statevector is available
qc = QuantumCircuit(2)
qc.h(0)
qc.z(0)
qc.cx(0, 1)
backend = Aer.get_backend("statevector_simulator")
job = execute(qc, backend)
result = job.result()
statevector = result.get_statevector()
plot_state_hinton(statevector)
# Plot the paulivec representation of a quantum state
# Only available on backends where the internal statevector is available
qc = QuantumCircuit(2)
qc.h(0)
qc.z(0)
qc.cx(0, 1)
backend = Aer.get_backend("statevector_simulator")
job = execute(qc, backend)
result = job.result()
statevector = result.get_statevector()
plot_state_paulivec(statevector)
# Plot the qsphere representation of a quantum state
# Only available on backends where the internal statevector is available
qc = QuantumCircuit(2)
qc.h(0)
qc.z(0)
qc.cx(0, 1)
backend = Aer.get_backend("statevector_simulator")
job = execute(qc, backend)
result = job.result()
statevector = result.get_statevector()
plot_state_qsphere(statevector)
# TODO: Schedule a jon on real hardware
# TODO: Monitor progress of a job
# TODO: Gate class, circuit to gate, ...
# TODO: classes Parameter, ParameterVector, ParameterExpression,
|
https://github.com/MadhavJivrajani/pyQSR
|
MadhavJivrajani
|
# -*- coding: utf-8 -*-
# pylint: disable=no-member
"""An IBM Qiskit implementation of quantum shift registers."""
__author__ = "Madhav Jivrajani"
from qiskit import QuantumCircuit, execute, Aer
from qiskit.circuit.exceptions import CircuitError
class QuantumLeftShift:
"""Circuit to implement a quantum shift register.
Two types of shift registers can be implemented:
1. Left shift register.
2. Circular left shift register.
Reference:
[1] Jae-weon Lee and Eok Kyun Lee and Jaewan Kim and Soonchil Lee, Quantum Shift Register, 2001.
https://arxiv.org/abs/quant-ph/0112107
"""
def __init__(self, data_qubits: int, seed: str, circular: bool = False) -> None:
"""Initializes a circuit for quantum shift register.
- Encodes qubits according to the initial seed.
To perform a shift operation on n data qubits, atleast n ancillary qubits are required
to store information. Therefore, a circuit will have a total of 2*n qubits. An extra
qubit apart from the 2*n qubits is required to store information about whether the circuit
should behave as a left shift register or a circular left shift register.
Args:
data_qubits : The number of data qubits to be alloted. Needs to be equal to
length of seed.
seed : Initial value the quantum shift register should start with.
circular : Flag to indicate if the shifts are circular in nature or not.
Raises:
CircuitError : If the number of data qubits is not equal to the length of the seed.
"""
self.seed_string = seed
#to follow qiskit's little endian encoding.
self.seed = list(map(int, list(seed)))[::-1]
self.num_data_qubits = data_qubits
if len(seed) != self.num_data_qubits:
raise CircuitError("Length of seed should be equal to number of data qubits.")
self.shift_circuit = QuantumCircuit(self.num_data_qubits + self.num_data_qubits + 1,
self.num_data_qubits)
self.shifts_done = 0
self.circular = circular
self.__prepare_circuit()
self.shift_gate = self.construct_shift_gate()
def __repr__(self):
return ("QuantumShiftLeft(data_qubits = %d, "
"seed = \"%s\", "
"circular = %s)") % (self.num_data_qubits, self.seed_string, str(self.circular))
def __str__(self):
print(self.shift_circuit)
return ("Data qubits: %d\n"
"Initial seed: %s\n"
"Shifts performed: %d\n"
"Circular: %s") % (self.num_data_qubits, self.seed_string,
self.shifts_done, str(self.circular))
def __prepare_circuit(self):
"""Encodes qubits according to initial seed and the flag: circular"""
for i in range(len(self.seed)):
if self.seed[i] == 1:
self.shift_circuit.x(i)
if self.circular:
self.shift_circuit.x(self.num_data_qubits + self.num_data_qubits)
self.shift_circuit.barrier(range(self.num_data_qubits + self.num_data_qubits + 1))
def construct_shift_gate(self):
"""Constructs a left/circular left shift circuit and
returns the circuit as a Gate object.
"""
if self.circular:
name = "Circular Left Shift"
else:
name = "Left Shift"
shift_circ = QuantumCircuit(self.num_data_qubits + self.num_data_qubits + 1, name=name)
for qubit in range(1, self.num_data_qubits + self.num_data_qubits)[::-1]:
shift_circ.swap(qubit, qubit - 1)
shift_circ.cx(0, self.num_data_qubits)
shift_circ.toffoli(self.num_data_qubits + self.num_data_qubits, self.num_data_qubits, 0)
shift_circ.cx(0, self.num_data_qubits)
shift_gate = shift_circ.to_gate()
return shift_gate
def shift(self):
"""Performs a single shift operation on the values of the data qubits."""
self.shifts_done += 1
self.shift_circuit.append(self.shift_gate,
range(self.num_data_qubits + self.num_data_qubits + 1))
def get_register_state(self):
"""Performs a measurement in the |0> basis on each of the data qubits
and returns the counts of the measurement.
"""
self.shift_circuit.barrier(range(self.num_data_qubits + self.num_data_qubits + 1))
self.shift_circuit.measure(range(self.num_data_qubits), range(self.num_data_qubits))
self.shift_circuit.barrier(range(self.num_data_qubits + self.num_data_qubits + 1))
backend = Aer.get_backend('statevector_simulator')
register_state = execute(self.shift_circuit, backend, shots=1024).result().get_counts()
return register_state
|
https://github.com/ericardomuten/qiskit-advocate-mentorship
|
ericardomuten
|
# Mount Google Drive
from google.colab import drive # import drive from google colab
ROOT = "/content/drive" # default location for the drive
print(ROOT) # print content of ROOT (Optional)
drive.mount(ROOT) # we mount the google drive at /content/drive
!pip install qiskit
from IPython.display import clear_output
clear_output()
import os
def restart_runtime():
os.kill(os.getpid(), 9)
restart_runtime()
# %matplotlib inline
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import make_axes_locatable
import numpy as np
import tensorflow as tf
from tensorflow.keras.utils import to_categorical
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train_flatten = x_train.reshape(x_train.shape[0], x_train.shape[1]*x_train.shape[2])/255.0
x_test_flatten = x_test.reshape(x_test.shape[0], x_test.shape[1]*x_test.shape[2])/255.0
# Sanity check
print(x_train_flatten.shape, y_train.shape)
print(x_test_flatten.shape, y_test.shape)
x_train_0 = x_train_flatten[y_train == 0]
x_train_1 = x_train_flatten[y_train == 1]
x_train_2 = x_train_flatten[y_train == 2]
x_train_3 = x_train_flatten[y_train == 3]
x_train_4 = x_train_flatten[y_train == 4]
x_train_5 = x_train_flatten[y_train == 5]
x_train_6 = x_train_flatten[y_train == 6]
x_train_7 = x_train_flatten[y_train == 7]
x_train_8 = x_train_flatten[y_train == 8]
x_train_9 = x_train_flatten[y_train == 9]
x_train_list = [x_train_0, x_train_1, x_train_2, x_train_3, x_train_4, x_train_5, x_train_6, x_train_7, x_train_8, x_train_9]
print(x_train_0.shape)
print(x_train_1.shape)
print(x_train_2.shape)
print(x_train_3.shape)
print(x_train_4.shape)
print(x_train_5.shape)
print(x_train_6.shape)
print(x_train_7.shape)
print(x_train_8.shape)
print(x_train_9.shape)
x_test_0 = x_test_flatten[y_test == 0]
x_test_1 = x_test_flatten[y_test == 1]
x_test_2 = x_test_flatten[y_test == 2]
x_test_3 = x_test_flatten[y_test == 3]
x_test_4 = x_test_flatten[y_test == 4]
x_test_5 = x_test_flatten[y_test == 5]
x_test_6 = x_test_flatten[y_test == 6]
x_test_7 = x_test_flatten[y_test == 7]
x_test_8 = x_test_flatten[y_test == 8]
x_test_9 = x_test_flatten[y_test == 9]
x_test_list = [x_test_0, x_test_1, x_test_2, x_test_3, x_test_4, x_test_5, x_test_6, x_test_7, x_test_8, x_test_9]
print(x_test_0.shape)
print(x_test_1.shape)
print(x_test_2.shape)
print(x_test_3.shape)
print(x_test_4.shape)
print(x_test_5.shape)
print(x_test_6.shape)
print(x_test_7.shape)
print(x_test_8.shape)
print(x_test_9.shape)
def binary_classification_data_generator(num_sample, mult_test, n_class, class_list):
X_train = x_train_list[class_list[0]][:num_sample, :]
X_test = x_test_list[class_list[0]][:int(mult_test*num_sample), :]
Y_train = np.zeros((n_class*X_train.shape[0],), dtype=int)
Y_test = np.zeros((n_class*X_test.shape[0],), dtype=int)
for i in range(n_class-1):
X_train = np.concatenate((X_train, x_train_list[class_list[i+1]][:num_sample, :]), axis=0)
Y_train[num_sample*(i+1):num_sample*(i+2)] = int(i+1)
X_test = np.concatenate((X_test, x_test_list[class_list[i+1]][:int(mult_test*num_sample), :]), axis=0)
Y_test[int(mult_test*num_sample*(i+1)):int(mult_test*num_sample*(i+2))] = int(i+1)
Y_train = to_categorical(Y_train)
Y_test = to_categorical(Y_test)
return X_train, Y_train, X_test, Y_test
num_sample = 200
n_class = 2
mult_test = 2.5
X_train01, Y_train01, X_test01, Y_test01 = binary_classification_data_generator(num_sample, mult_test, n_class, [0,1])
# Sanity check
print(X_train01.shape, Y_train01.shape)
print(X_test01.shape, Y_test01.shape)
plt.imshow
plt.imshow(np.concatenate((X_train01[0].reshape(28,28), X_train01[-1].reshape(28,28)), axis=1), cmap='gray')
X_train36, Y_train36, X_test36, Y_test36 = binary_classification_data_generator(num_sample, mult_test, n_class, [3,6])
# Sanity check
print(X_train36.shape, Y_train36.shape)
print(X_test36.shape, Y_test36.shape)
plt.imshow
plt.imshow(np.concatenate((X_train36[0].reshape(28,28), X_train36[-1].reshape(28,28)), axis=1), cmap='gray')
def normalize(X, use_params=False, params=None):
"""Normalize the given dataset X
Args:
X: ndarray, dataset
Returns:
(Xbar, mean, std): tuple of ndarray, Xbar is the normalized dataset
with mean 0 and standard deviation 1; mean and std are the
mean and standard deviation respectively.
Note:
You will encounter dimensions where the standard deviation is
zero, for those when you do normalization the normalized data
will be NaN. Handle this by setting using `std = 1` for those
dimensions when doing normalization.
"""
if use_params:
mu = params[0]
std_filled = [1]
else:
mu = np.mean(X, axis=0)
std = np.std(X, axis=0)
#std_filled = std.copy()
#std_filled[std==0] = 1.
Xbar = (X - mu)/(std + 1e-8)
return Xbar, mu, std
X_train01, mu_train01, std_train01 = normalize(X_train01)
X_test01 = (X_test01 - mu_train01)/(std_train01 + 1e-8)
# Sanity check
print(X_train01.shape, Y_train01.shape)
print(X_test01.shape, Y_test01.shape)
X_train36, mu_train36, std_train36 = normalize(X_train36)
X_test36 = (X_test36 - mu_train36)/(std_train36 + 1e-8)
# Sanity check
print(X_train36.shape, Y_train36.shape)
print(X_test36.shape, Y_test36.shape)
from sklearn.decomposition import PCA
from matplotlib import pyplot as plt
num_component = 6
pca01 = PCA(n_components=num_component, svd_solver='full')
pca36 = PCA(n_components=num_component, svd_solver='full')
pca01.fit(X_train01)
pca36.fit(X_train36)
print(np.cumsum(pca01.explained_variance_ratio_))
print(np.cumsum(pca36.explained_variance_ratio_))
X_train01 = pca01.transform(X_train01)
X_test01 = pca01.transform(X_test01)
# Sanity check
print(X_train01.shape, Y_train01.shape)
print(X_test01.shape, Y_test01.shape)
X_train36 = pca36.transform(X_train36)
X_test36 = pca36.transform(X_test36)
# Sanity check
print(X_train36.shape, Y_train36.shape)
print(X_test36.shape, Y_test36.shape)
X_train01 = (X_train01.T / np.sqrt(np.sum(X_train01 ** 2, -1))).T
X_test01 = (X_test01.T / np.sqrt(np.sum(X_test01 ** 2, -1))).T
plt.scatter(X_train01[:100, 0], X_train01[:100, 1])
plt.scatter(X_train01[100:200, 0], X_train01[100:200, 1])
plt.scatter(X_train01[200:300, 0], X_train01[200:300, 1])
X_train36 = (X_train36.T / np.sqrt(np.sum(X_train36 ** 2, -1))).T
X_test36 = (X_test36.T / np.sqrt(np.sum(X_test36 ** 2, -1))).T
plt.scatter(X_train36[:100, 0], X_train36[:100, 1])
plt.scatter(X_train36[100:200, 0], X_train36[100:200, 1])
plt.scatter(X_train36[200:300, 0], X_train36[200:300, 1])
from qiskit import *
import numpy as np
# Set a random seed
np.random.seed(42)
def drc_circuit(x_sample, parameters, num_features, layer=1):
q_reg = QuantumRegister(1)
c_reg = ClassicalRegister(1)
circuit = QuantumCircuit(q_reg, c_reg)
# Layer iteration
for i in range(layer):
# Gate iteration
for j in range(int(num_features/3)):
circuit.u(*(parameters[3*j:3*(j+1)] * x_sample[3*j:3*(j+1)] + parameters[3*j+num_features:3*(j+1)+num_features]), 0)
circuit.measure(0,0)
return circuit
num_features = 6
num_layer = 1
params = np.random.uniform(size=(2*num_features*num_layer + 2))
drc_circuit(X_train01[0], params, num_features).draw()
def weighted_fidelity_cost_function(params, X_train, Y_train, backend, L=1, num_features=6, shots=2000):
loss = 0
# Training sample iteration
for k in range(len(X_train)):
circuit = drc_circuit(X_train[k], params, num_features, layer=L)
t_circ = transpile(circuit, backend)
qobj = assemble(t_circ, shots=shots)
job = backend.run(qobj)
result = job.result().get_counts(circuit)
counts = np.array(list(result.values()))
# Pauli-Z eigenvalue
states = np.array([0, -1])
# Compute probabilities for each state
probabilities = counts / shots
# Get state expectation
z_expectation = np.sum(states * probabilities)
# Get weighted fidelity
fidel_0 = params[-2]*(1 + z_expectation)/2
fidel_1 = params[-1]*(1 - z_expectation)/2
# Calculate the loss from the sample
loss += ((fidel_0 - Y_train[k,0])**2 + (fidel_1 - Y_train[k,1])**2)/2
loss = loss/len(X_train)
return loss
def drc_pred(params, X, backend, L=1, num_features=6, shots=2000):
pred = []
# Sample iteration
for k in range(len(X)):
circuit = drc_circuit(X[k], params, num_features, layer=L)
t_circ = transpile(circuit, backend)
qobj = assemble(t_circ, shots=shots)
job = backend.run(qobj)
result = job.result().get_counts(circuit)
counts = np.array(list(result.values()))
# Pauli-Z eigenvalue
states = np.array([0, -1])
# Compute probabilities for each state
probabilities = counts / shots
# Get state expectation
z_expectation = np.sum(states * probabilities)
# Get weighted fidelity
fidel_0 = params[-2]*(1 + z_expectation)/2
fidel_1 = params[-1]*(1 - z_expectation)/2
pred += [[fidel_0, fidel_1]]
return np.array(pred)
shots=2000
backend = Aer.get_backend('qasm_simulator')
num_layer = 1
num_features = 6
params = np.random.uniform(size=(2*num_features*num_layer + 2))
from qiskit.aqua.components.optimizers import COBYLA
import scipy
opt_params_01 = scipy.optimize.minimize(fun=weighted_fidelity_cost_function, x0=params, method='COBYLA',
args=(X_train01, Y_train01, backend, num_layer, num_features, shots),
options={'maxiter':1000})
print(opt_params_01)
Y_pred_train = drc_pred(opt_params_01['x'], X_train01, backend, L=num_layer, num_features=num_features, shots=shots)
Y_pred_test = drc_pred(opt_params_01['x'], X_test01, backend, L=num_layer, num_features=num_features, shots=shots)
train_acc = (np.argmax(Y_pred_train, axis=1) == np.argmax(Y_train01, axis=1)).sum()/len(Y_train01)
test_acc = (np.argmax(Y_pred_test, axis=1) == np.argmax(Y_test01, axis=1)).sum()/len(Y_test01)
print("Train Accuracy:", train_acc)
print("Test Accuracy:", test_acc)
train_acc_list01 = []
test_acc_list01 = []
train_loss_list01 = []
test_loss_list01 = []
for i in range(5):
opt_params_01 = scipy.optimize.minimize(fun=weighted_fidelity_cost_function, x0=params, method='COBYLA',
args=(X_train01, Y_train01, backend, i+1, num_features, shots),
options={'maxiter':1000})
print("Number of layer: " + str(i+1) + ", status: finished.")
Y_pred_train = drc_pred(opt_params_01['x'], X_train01, backend, L=num_layer, num_features=num_features, shots=shots)
Y_pred_test = drc_pred(opt_params_01['x'], X_test01, backend, L=num_layer, num_features=num_features, shots=shots)
train_acc = (np.argmax(Y_pred_train, axis=1) == np.argmax(Y_train01, axis=1)).sum()/len(Y_train01)
test_acc = (np.argmax(Y_pred_test, axis=1) == np.argmax(Y_test01, axis=1)).sum()/len(Y_test01)
train_acc_list01 += [train_acc]
test_acc_list01 += [test_acc]
train_loss = weighted_fidelity_cost_function(opt_params_01['x'], X_train01, Y_train01, backend, L=num_layer, num_features=num_features, shots=shots)
test_loss = weighted_fidelity_cost_function(opt_params_01['x'], X_test01, Y_test01, backend, L=num_layer, num_features=num_features, shots=shots)
train_loss_list01 += [train_loss]
test_loss_list01 += [test_loss]
plt.plot(train_acc_list01, label='Train Acc')
plt.plot(test_acc_list01, label='Test Acc')
plt.xlabel('Number of Layer')
plt.ylabel('Classification Accuracy')
plt.legend()
plt.show()
plt.plot(train_loss_list01, label='Train Loss')
plt.plot(test_loss_list01, label='Test Loss')
plt.xlabel('Number of Layer')
plt.ylabel('Loss')
plt.legend()
plt.show()
import pandas as pd
d = {'Training Acc': [0.9875, 0.9175], 'Testing Acc': [0.992, 0.915]}
pd.DataFrame(data=d, index=["Qiskit (COBYLA, QASM Simulator)", "PennyLane (Adam, PennyLane's Statevector Simulator)"])
opt_params_36 = scipy.optimize.minimize(fun=weighted_fidelity_cost_function, x0=params, method='COBYLA',
args=(X_train36, Y_train36, backend, num_layer, num_features, shots),
options={'maxiter':1000})
print(opt_params_36)
Y_pred_train = drc_pred(opt_params_36['x'], X_train36, backend, L=num_layer, num_features=num_features, shots=shots)
Y_pred_test = drc_pred(opt_params_36['x'], X_test36, backend, L=num_layer, num_features=num_features, shots=shots)
train_acc = (np.argmax(Y_pred_train, axis=1) == np.argmax(Y_train36, axis=1)).sum()/len(Y_train36)
test_acc = (np.argmax(Y_pred_test, axis=1) == np.argmax(Y_test36, axis=1)).sum()/len(Y_test36)
print("Train Accuracy:", train_acc)
print("Test Accuracy:", test_acc)
|
https://github.com/ericardomuten/qiskit-advocate-mentorship
|
ericardomuten
|
# Mount Google Drive
from google.colab import drive # import drive from google colab
ROOT = "/content/drive" # default location for the drive
print(ROOT) # print content of ROOT (Optional)
drive.mount(ROOT) # we mount the google drive at /content/drive
!pip install pennylane
from IPython.display import clear_output
clear_output()
import os
def restart_runtime():
os.kill(os.getpid(), 9)
restart_runtime()
# %matplotlib inline
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import make_axes_locatable
import numpy as np
import tensorflow as tf
from tensorflow.keras.utils import to_categorical
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train_flatten = x_train.reshape(x_train.shape[0], x_train.shape[1]*x_train.shape[2])/255.0
x_test_flatten = x_test.reshape(x_test.shape[0], x_test.shape[1]*x_test.shape[2])/255.0
print(x_train_flatten.shape, y_train.shape)
print(x_test_flatten.shape, y_test.shape)
x_train_0 = x_train_flatten[y_train == 0]
x_train_1 = x_train_flatten[y_train == 1]
x_train_2 = x_train_flatten[y_train == 2]
x_train_3 = x_train_flatten[y_train == 3]
x_train_4 = x_train_flatten[y_train == 4]
x_train_5 = x_train_flatten[y_train == 5]
x_train_6 = x_train_flatten[y_train == 6]
x_train_7 = x_train_flatten[y_train == 7]
x_train_8 = x_train_flatten[y_train == 8]
x_train_9 = x_train_flatten[y_train == 9]
x_train_list = [x_train_0, x_train_1, x_train_2, x_train_3, x_train_4, x_train_5, x_train_6, x_train_7, x_train_8, x_train_9]
print(x_train_0.shape)
print(x_train_1.shape)
print(x_train_2.shape)
print(x_train_3.shape)
print(x_train_4.shape)
print(x_train_5.shape)
print(x_train_6.shape)
print(x_train_7.shape)
print(x_train_8.shape)
print(x_train_9.shape)
x_test_0 = x_test_flatten[y_test == 0]
x_test_1 = x_test_flatten[y_test == 1]
x_test_2 = x_test_flatten[y_test == 2]
x_test_3 = x_test_flatten[y_test == 3]
x_test_4 = x_test_flatten[y_test == 4]
x_test_5 = x_test_flatten[y_test == 5]
x_test_6 = x_test_flatten[y_test == 6]
x_test_7 = x_test_flatten[y_test == 7]
x_test_8 = x_test_flatten[y_test == 8]
x_test_9 = x_test_flatten[y_test == 9]
x_test_list = [x_test_0, x_test_1, x_test_2, x_test_3, x_test_4, x_test_5, x_test_6, x_test_7, x_test_8, x_test_9]
print(x_test_0.shape)
print(x_test_1.shape)
print(x_test_2.shape)
print(x_test_3.shape)
print(x_test_4.shape)
print(x_test_5.shape)
print(x_test_6.shape)
print(x_test_7.shape)
print(x_test_8.shape)
print(x_test_9.shape)
num_sample = 200
n_class = 2
mult_test = 2.5
X_train = x_train_list[0][:num_sample, :]
X_test = x_test_list[0][:int(mult_test*num_sample), :]
Y_train = np.zeros((n_class*X_train.shape[0],), dtype=int)
Y_test = np.zeros((n_class*X_test.shape[0],), dtype=int)
for i in range(n_class-1):
X_train = np.concatenate((X_train, x_train_list[i+1][:num_sample, :]), axis=0)
Y_train[num_sample*(i+1):num_sample*(i+2)] = int(i+1)
X_test = np.concatenate((X_test, x_test_list[i+1][:int(mult_test*num_sample), :]), axis=0)
Y_test[int(mult_test*num_sample*(i+1)):int(mult_test*num_sample*(i+2))] = int(i+1)
print(X_train.shape, Y_train.shape)
print(X_test.shape, Y_test.shape)
def normalize(X, use_params=False, params=None):
"""Normalize the given dataset X
Args:
X: ndarray, dataset
Returns:
(Xbar, mean, std): tuple of ndarray, Xbar is the normalized dataset
with mean 0 and standard deviation 1; mean and std are the
mean and standard deviation respectively.
Note:
You will encounter dimensions where the standard deviation is
zero, for those when you do normalization the normalized data
will be NaN. Handle this by setting using `std = 1` for those
dimensions when doing normalization.
"""
if use_params:
mu = params[0]
std_filled = [1]
else:
mu = np.mean(X, axis=0)
std = np.std(X, axis=0)
#std_filled = std.copy()
#std_filled[std==0] = 1.
Xbar = (X - mu)/(std + 1e-8)
return Xbar, mu, std
X_train, mu_train, std_train = normalize(X_train)
X_train.shape, Y_train.shape
X_test = (X_test - mu_train)/(std_train + 1e-8)
X_test.shape, Y_test.shape
from sklearn.decomposition import PCA
from matplotlib import pyplot as plt
num_component = 6
pca = PCA(n_components=num_component, svd_solver='full')
pca.fit(X_train)
np.cumsum(pca.explained_variance_ratio_)
X_train = pca.transform(X_train)
X_test = pca.transform(X_test)
print(X_train.shape, Y_train.shape)
print(X_test.shape, Y_test.shape)
X_train = (X_train.T / np.sqrt(np.sum(X_train ** 2, -1))).T
X_test = (X_test.T / np.sqrt(np.sum(X_test ** 2, -1))).T
plt.scatter(X_train[:100, 0], X_train[:100, 1])
plt.scatter(X_train[100:200, 0], X_train[100:200, 1])
plt.scatter(X_train[200:300, 0], X_train[200:300, 1])
import pennylane as qml
from pennylane import numpy as np
from pennylane.optimize import AdamOptimizer, GradientDescentOptimizer
qml.enable_tape()
# Set a random seed
np.random.seed(42)
# Define output labels as quantum state vectors
# def density_matrix(state):
# """Calculates the density matrix representation of a state.
# Args:
# state (array[complex]): array representing a quantum state vector
# Returns:
# dm: (array[complex]): array representing the density matrix
# """
# return state * np.conj(state).T
label_0 = [[1], [0]]
label_1 = [[0], [1]]
def density_matrix(state):
"""Calculates the density matrix representation of a state.
Args:
state (array[complex]): array representing a quantum state vector
Returns:
dm: (array[complex]): array representing the density matrix
"""
return np.outer(state, np.conj(state))
state_labels = [label_0, label_1]
#state_labels = np.loadtxt('./tetra_states.txt', dtype=np.complex_)
dm_labels = [density_matrix(state_labels[i]) for i in range(2)]
len(dm_labels)
dm_labels
n_qubits = 2 # number of class
dev_fc = qml.device("default.qubit", wires=n_qubits)
@qml.qnode(dev_fc)
def q_fc(params, inputs):
"""A variational quantum circuit representing the DRC.
Args:
params (array[float]): array of parameters
inputs = [x, y]
x (array[float]): 1-d input vector
y (array[float]): single output state density matrix
Returns:
float: fidelity between output state and input
"""
# layer iteration
for l in range(len(params[0])):
# qubit iteration
for q in range(n_qubits):
# gate iteration
for g in range(int(len(inputs)/3)):
qml.Rot(*(params[0][l][3*g:3*(g+1)] * inputs[3*g:3*(g+1)] + params[1][l][3*g:3*(g+1)]), wires=q)
return [qml.expval(qml.Hermitian(dm_labels[i], wires=[i])) for i in range(n_qubits)]
X_train[0].shape
a = np.random.uniform(size=(2, 1, 6))
q_fc(a, X_train[0])
tetra_class = np.loadtxt('./tetra_class_label.txt')
binary_class = np.array([[1, 0], [0, 1]])
class_labels = binary_class
n_class = 2
temp = np.zeros((len(Y_train), n_class))
for i in range(len(Y_train)):
temp[i, :] = class_labels[Y_train[i]]
Y_train = temp
temp = np.zeros((len(Y_test), n_class))
for i in range(len(Y_test)):
temp[i, :] = class_labels[Y_test[i]]
Y_test = temp
Y_train.shape, Y_test.shape
from keras import backend as K
# Alpha Custom Layer
class class_weights(tf.keras.layers.Layer):
def __init__(self):
super(class_weights, self).__init__()
w_init = tf.random_normal_initializer()
self.w = tf.Variable(
initial_value=w_init(shape=(1, 2), dtype="float32"),
trainable=True,
)
def call(self, inputs):
return (inputs * self.w)
n_component = 6
X = tf.keras.Input(shape=(n_component,), name='Input_Layer')
# Quantum FC Layer, trainable params = 18*L*n_class + 2, output size = 2
num_fc_layer = 3
q_fc_layer_0 = qml.qnn.KerasLayer(q_fc, {"params": (2, num_fc_layer, n_component)}, output_dim=2)(X)
# Alpha Layer
alpha_layer_0 = class_weights()(q_fc_layer_0)
model = tf.keras.Model(inputs=X, outputs=alpha_layer_0)
model(X_train[0:32])
opt = tf.keras.optimizers.Adam(learning_rate=0.1)
model.compile(opt, loss='mse', metrics=["accuracy"])
filepath = "./Model_2/2_PCA_QFC_saved-model-{epoch:02d}.hdf5"
checkpoint = tf.keras.callbacks.ModelCheckpoint(filepath, monitor='val_acc', verbose=1,
save_weights_only=True, save_best_only=False, mode='auto')
H = model.fit(X_train, Y_train, epochs=10, batch_size=32, initial_epoch=0,
validation_data=(X_test, Y_test), verbose=1,
callbacks=[checkpoint])
# another run to get 10 different set of weights
# 3 layer, 6 components
model.weights
# another run to get 10 different set of weights
# 3 layer, 6 components
H.history
# 3 layer, 3 components
H.history
# 2 layer, 3 components
H.history
# 1 layer, 3 components
H.history
# 3 layer, 6 components
H.history
# 2 layer, 6 components
H.history
# 1 layer, 6 components
H.history
model.summary()
# 3 layer, 6 components
model.weights
# random weights
model.weights
QFC_weights = np.array([[[-0.23825717, -0.6927138 , 1.9275627 , -0.6338903 ,
-1.5635191 , -0.54419893],
[-1.7943736 , 0.6555091 , 0.7756721 , -0.52433693,
0.33494785, 0.5896128 ],
[-1.93925 , 0.26347128, -1.0761861 , 0.1370001 ,
0.7956914 , 0.43674225]],
[[ 0.04991536, 0.4438185 , 0.28958392, 0.17212974,
-0.5826888 , 0.1689779 ],
[-0.05101966, -0.45951375, -0.7024131 , -0.51385176,
-1.2483467 , -0.46147949],
[-0.37164477, -0.980824 , -0.43812418, -0.7645581 ,
-0.8557718 , -0.01652514]]])
alpha_weights = np.array([[1.0457449, 1.0058646]])
random_weights = np.array([[[-0.01116788, -0.24572456, -0.34748596, 0.12041545,
-0.26595542, -0.18240207],
[ 0.3004377 , 0.5260234 , 0.35336393, 0.19536716,
0.01010054, -0.40111852],
[ 0.5502764 , -0.18851322, -0.25431797, -0.24531147,
0.07113147, -0.37417513]],
[[-0.44977266, 0.34296083, 0.51045287, -0.2749984 ,
0.41424918, -0.4837346 ],
[ 0.10718679, 0.507282 , 0.07516974, -0.4324274 ,
0.36671913, 0.3184935 ],
[ 0.49623525, 0.49480498, 0.4315616 , 0.46681094,
-0.12224993, -0.14642656]]])
QFC_weights.shape, alpha_weights.shape, random_weights.shape
# sanity check
pred = []
random_pred = []
for i in range(len(X_test)):
pred += [np.argmax(q_fc(QFC_weights, X_test[i]).numpy())]
random_pred += [np.argmax(q_fc(random_weights, X_test[i]).numpy())]
n_qubits = 1
dev_state = qml.device("default.qubit", wires=n_qubits)
@qml.qnode(dev_state)
def q_fc_state(params, inputs):
"""A variational quantum circuit representing the DRC.
Args:
params (array[float]): array of parameters
inputs = [x, y]
x (array[float]): 1-d input vector
y (array[float]): single output state density matrix
Returns:
float: fidelity between output state and input
"""
# layer iteration
for l in range(len(params[0])):
# qubit iteration
for q in range(n_qubits):
# gate iteration
for g in range(int(len(inputs)/3)):
qml.Rot(*(params[0][l][3*g:3*(g+1)] * inputs[3*g:3*(g+1)] + params[1][l][3*g:3*(g+1)]), wires=q)
return qml.expval(qml.Hermitian(dm_labels[0], wires=[0]))
q_fc_state(QFC_weights, X_test[0])
dev_state._state
train_state = np.zeros((len(X_train), 2), dtype=np.complex_)
test_state = np.zeros((len(X_test), 2), dtype=np.complex_)
for i in range(len(train_state)):
q_fc_state(QFC_weights, X_train[i])
temp = np.flip(dev_state._state)
train_state[i, :] = temp
for i in range(len(test_state)):
q_fc_state(QFC_weights, X_test[i])
temp = np.flip(dev_state._state)
test_state[i, :] = temp
np.conj(train_state[150]) @ dm_labels[0] @ train_state[150]
train_state[0] @ np.conj(train_state[0])
np.conj(test_state[0]) @ dm_labels[0] @ test_state[0]
np.savetxt('./2_PCA_QFC-State_Train.txt', train_state)
np.savetxt('./2_PCA_QFC-State_Test.txt', test_state)
train_state = np.zeros((len(X_train), 2), dtype=np.complex_)
test_state = np.zeros((len(X_test), 2), dtype=np.complex_)
for i in range(len(train_state)):
q_fc_state(random_weights, X_train[i])
temp = np.flip(dev_state._state)
train_state[i, :] = temp
for i in range(len(test_state)):
q_fc_state(random_weights, X_test[i])
temp = np.flip(dev_state._state)
test_state[i, :] = temp
np.conj(train_state[0]) @ dm_labels[0] @ train_state[0]
train_state[0] @ np.conj(train_state[0])
np.savetxt('./2_PCA_QFC-RandomState_Train.txt', train_state)
np.savetxt('./2_PCA_QFC-RandomState_Test.txt', test_state)
random_weights = np.array(model.get_weights()[0], dtype=float)
QFC_weights_list = [random_weights]
for i in range(10):
if i == 9:
model.load_weights('./Model_2/2_PCA_QFC_saved-model-' + str(i+1) + '.hdf5')
else:
model.load_weights('./Model_2/2_PCA_QFC_saved-model-0' + str(i+1) + '.hdf5')
QFC_weights_list += [np.array(model.get_weights()[0], dtype=float)]
len(QFC_weights_list)
n_qubits = 1
dev_state = qml.device("default.qubit", wires=n_qubits)
@qml.qnode(dev_state)
def q_fc_state(params, inputs):
"""A variational quantum circuit representing the DRC.
Args:
params (array[float]): array of parameters
inputs = [x, y]
x (array[float]): 1-d input vector
y (array[float]): single output state density matrix
Returns:
float: fidelity between output state and input
"""
# layer iteration
for l in range(len(params[0])):
# qubit iteration
for q in range(n_qubits):
# gate iteration
for g in range(int(len(inputs)/3)):
qml.Rot(*(params[0][l][3*g:3*(g+1)] * inputs[3*g:3*(g+1)] + params[1][l][3*g:3*(g+1)]), wires=q)
return qml.expval(qml.Hermitian(dm_labels[0], wires=[0]))
q_fc_state(QFC_weights_list[0], X_test[0])
for k in range(10+1):
train_state = np.zeros((len(X_train), 2), dtype=np.complex_)
test_state = np.zeros((len(X_test), 2), dtype=np.complex_)
for i in range(len(train_state)):
q_fc_state(QFC_weights_list[k], X_train[i])
temp = np.flip(dev_state._state)
train_state[i, :] = temp
for i in range(len(test_state)):
q_fc_state(QFC_weights_list[k], X_test[i])
temp = np.flip(dev_state._state)
test_state[i, :] = temp
print(train_state.shape, test_state.shape)
np.savetxt('./Model_2/2_PCA_QFC-State_Train_Epoch=' + str(k) + '.txt', train_state)
np.savetxt('./Model_2/2_PCA_QFC-State_Test_Epoch=' + str(k) + '.txt', test_state)
|
https://github.com/ericardomuten/qiskit-advocate-mentorship
|
ericardomuten
|
!pip install qiskit
!pip install pylatexenc--upgrade
!pip install retworkx
#!pip install numpy --upgrade
from IPython.display import clear_output
clear_output()
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, Aer, transpile
from qiskit.circuit.library import ZGate, XGate
from qiskit.extensions import UnitaryGate
from qiskit.aqua.algorithms import VQE, NumPyEigensolver
from qiskit.aqua.operators import WeightedPauliOperator, MatrixOperator, op_converter
from qiskit.aqua.components.optimizers import COBYLA, SPSA, SLSQP
#from qiskit.quantum_info.operators import Operator
import numpy as np
import scipy
import networkx as nx
from matplotlib import pyplot as plt
import copy
# Define the number of qubits
num_qubit = 4
qubits = range(num_qubit)
# Generating the graph
ising_graph = nx.star_graph(num_qubit-1)
print("Edges:", ising_graph.edges)
nx.draw(ising_graph)
# Set the random seed
rng = np.random.default_rng(seed=2021)
# Initialize the true weights and bias
true_weights = rng.random(size=len(ising_graph.edges)) - 0.5
true_bias = rng.random(size=num_qubit) - 0.5
print("True Weights:", true_weights)
print("True Bias", true_bias)
def create_hamiltonian_matrix(n_qubits, graph, weights, bias):
full_matrix = np.zeros((2 ** n_qubits, 2 ** n_qubits))
# Creates the interaction component of the Hamiltonian
for i, edge in enumerate(graph.edges):
interaction_term = 1
for qubit in range(0, n_qubits):
if qubit in edge:
interaction_term = np.kron(interaction_term, np.array(ZGate().to_matrix(), dtype=float))
else:
interaction_term = np.kron(interaction_term, np.identity(2))
full_matrix += weights[i] * interaction_term
# Creates the bias components of the matrix
for i in range(0, n_qubits):
z_term = x_term = 1
for j in range(0, n_qubits):
if j == i:
z_term = np.kron(z_term, np.array(ZGate().to_matrix(), dtype=float))
x_term = np.kron(x_term, np.array(XGate().to_matrix(), dtype=float))
else:
z_term = np.kron(z_term, np.identity(2))
x_term = np.kron(x_term, np.identity(2))
full_matrix += bias[i] * z_term + x_term
return full_matrix
# Prints a visual representation of the Hamiltonian matrix
H_matrix = create_hamiltonian_matrix(num_qubit, ising_graph, true_weights, true_bias)
print("Hamiltonian Matrix Visualization")
plt.matshow(H_matrix, cmap="cool")
plt.colorbar()
plt.show()
ground_state_energy = np.real_if_close(min(np.linalg.eig(H_matrix)[0]))
print("Ground State Energy:", ground_state_energy)
H_operator = op_converter.to_weighted_pauli_operator(MatrixOperator(H_matrix))
eig_vals = NumPyEigensolver(H_operator).run()
print("Minimum Eigenvalue:", np.real_if_close(min(eig_vals['eigenvalues'])))
opt = SLSQP(maxiter=5)
backend = Aer.get_backend("statevector_simulator")
vqe=VQE(operator=H_operator, optimizer=opt)
vqe_result=vqe.run(backend)
print("VQE Eigenvalue:", np.real_if_close(vqe_result['eigenvalue']))
#vqe.get_optimal_circuit().draw()
low_energy_state = vqe.get_optimal_vector()
print("Low Energy State:", low_energy_state)
# Sanity check, will be deleted in the final notebook
print(np.real_if_close(np.conj(vqe.get_optimal_vector())@H_matrix@vqe.get_optimal_vector()))
print(np.conj(vqe.get_optimal_vector())@vqe.get_optimal_vector())
import math
math.isclose(np.sum(np.absolute(np.kron(low_energy_state,low_energy_state)) ** 2), 1.0,
abs_tol=1e-11)
def state_evolve(circuit, hamiltonian, qubits, time):
U = scipy.linalg.expm(-1j * hamiltonian * time)
U_gate = UnitaryGate(U, label='evolved_unitary_'+str(time))
circuit.unitary(U_gate, qubits)
return circuit
def qgrnn_layer(circuit, weights, bias, qubits, graph, trotter_step):
# Applies a layer of RZZ gates (based on a graph)
for i, edge in enumerate(graph.edges):
circuit.rzz(2 * weights[i] * trotter_step, edge[0], edge[1])
# Applies a layer of RZ gates
for i, qubit in enumerate(qubits):
circuit.rz(2 * bias[i] * trotter_step, qubit)
# Applies a layer of RX gates
for qubit in qubits:
circuit.rx(2 * trotter_step, qubit)
return circuit
def swap_test(circuit, control, register1, register2):
circuit.h(control)
for reg1_qubit, reg2_qubit in zip(register1, register2):
circuit.cswap(control, reg1_qubit, reg2_qubit)
circuit.h(control)
return circuit
# Defines some fixed values
reg_data = tuple(range(num_qubit)) # First qubit register for quantum data
reg_qgrnn = tuple(range(num_qubit, 2 * num_qubit)) # Second qubit register for QGRNN
control = 2 * num_qubit # Index of control qubit
trotter_step = 0.01 # Trotter step size
# Defines the initial interaction graph
initial_ising_graph = nx.complete_graph(reg_qgrnn)
print("Edges:", initial_ising_graph.edges)
nx.draw(initial_ising_graph)
# Initialize random weights and bias
weights = rng.random(size=len(initial_ising_graph.edges)) - 0.5
bias = rng.random(size=num_qubit) - 0.5
trainable_params = np.concatenate((weights, bias))
initial_weights = copy.copy(weights)
initial_bias = copy.copy(bias)
print(trainable_params)
def qgrnn(param_weights, param_bias, time=None):
circuit = QuantumCircuit(2*num_qubit+1, 1)
# Prepares the low energy state in the two registers
circuit.initialize(np.kron(low_energy_state, low_energy_state), reg_data + reg_qgrnn)
# Evolves the first qubit register with the time-evolution circuit to
# prepare a piece of quantum data
circuit = state_evolve(circuit, H_matrix, reg_data, time)
# Applies the QGRNN layers to the second qubit register
depth = time / trotter_step # P = t/Delta
for _ in range(0, int(depth)):
circuit = qgrnn_layer(circuit, param_weights, param_bias, reg_qgrnn, initial_ising_graph, trotter_step)
# Applies the SWAP test between the registers
circuit = swap_test(circuit, control, reg_data, reg_qgrnn)
# Measure the circuit
circuit.measure([control], [0])
return circuit
qgrnn(initial_weights, initial_bias, time=0.02).draw()
def z_exp(circuit, shots=10000):
backend = Aer.get_backend('aer_simulator_statevector')
job = backend.run(circuit, shots=shots)
result = job.result()
counts = result.get_counts(0)
try:
exp_0 = counts['0']/shots
except:
exp_0 = 0
try:
exp_1 = counts['1']/shots
except:
exp_1 = 0
exp = exp_0 - exp_1
return exp
N = 15 # The number of pieces of quantum data that are used for each step
max_time = 0.1 # The maximum value of time that can be used for quantum data
def cost_function(params):
# Randomly samples times at which the QGRNN runs
times_sampled = rng.random(size=N) * max_time
# Cycles through each of the sampled times and calculates the cost
total_cost = 0
for dt in times_sampled:
result = z_exp(qgrnn(params[:len(initial_ising_graph.edges)], params[len(initial_ising_graph.edges):], time=dt))
total_cost += -1 * result
return total_cost / N
# Sanity check, will be deleted in the final notebook
backend = Aer.get_backend('aer_simulator_statevector')
job = backend.run(qgrnn(trainable_params[:len(initial_ising_graph.edges)], trainable_params[len(initial_ising_graph.edges):], time=0.09716818), shots=10000)
result = job.result()
counts = result.get_counts(0)
counts
# Sanity check
cost_function(trainable_params)
opt_params = scipy.optimize.minimize(fun=cost_function, x0=trainable_params, tol=1e-12,
method='L-BFGS-B',
#args=(),
options={'maxiter':5000, 'ftol':1e-12})
print(opt_params)
trained_weights = opt_params['x'][:len(initial_ising_graph.edges)]
trained_bias = opt_params['x'][len(initial_ising_graph.edges):]
weights.shape, bias.shape
H_matrix_trained = create_hamiltonian_matrix(
num_qubit, nx.complete_graph(num_qubit), trained_weights, trained_bias
)
H_matrix_initial = create_hamiltonian_matrix(
num_qubit, nx.complete_graph(num_qubit), initial_weights, initial_bias
)
fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(6, 6))
axes[0].matshow(H_matrix, vmin=-7, vmax=7, cmap="cool")
axes[0].set_title("Target", y=1.13)
axes[1].matshow(H_matrix_initial, vmin=-7, vmax=7, cmap="cool")
axes[1].set_title("Initial", y=1.13)
axes[2].matshow(H_matrix_trained, vmin=-7, vmax=7, cmap="cool")
axes[2].set_title("Learned", y=1.13)
plt.subplots_adjust(wspace=0.3, hspace=0.3)
plt.show()
|
https://github.com/ericardomuten/qiskit-advocate-mentorship
|
ericardomuten
|
# Mount Google Drive
from google.colab import drive # import drive from google colab
ROOT = "/content/drive" # default location for the drive
print(ROOT) # print content of ROOT (Optional)
drive.mount(ROOT) # we mount the google drive at /content/drive
!pip install pennylane
from IPython.display import clear_output
clear_output()
import os
def restart_runtime():
os.kill(os.getpid(), 9)
restart_runtime()
# %matplotlib inline
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import make_axes_locatable
import numpy as np
import tensorflow as tf
from tensorflow.keras.utils import to_categorical
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train_flatten = x_train.reshape(x_train.shape[0], x_train.shape[1]*x_train.shape[2])/255.0
x_test_flatten = x_test.reshape(x_test.shape[0], x_test.shape[1]*x_test.shape[2])/255.0
print(x_train_flatten.shape, y_train.shape)
print(x_test_flatten.shape, y_test.shape)
x_train_0 = x_train_flatten[y_train == 0]
x_train_1 = x_train_flatten[y_train == 1]
x_train_2 = x_train_flatten[y_train == 2]
x_train_3 = x_train_flatten[y_train == 3]
x_train_4 = x_train_flatten[y_train == 4]
x_train_5 = x_train_flatten[y_train == 5]
x_train_6 = x_train_flatten[y_train == 6]
x_train_7 = x_train_flatten[y_train == 7]
x_train_8 = x_train_flatten[y_train == 8]
x_train_9 = x_train_flatten[y_train == 9]
x_train_list = [x_train_0, x_train_1, x_train_2, x_train_3, x_train_4, x_train_5, x_train_6, x_train_7, x_train_8, x_train_9]
print(x_train_0.shape)
print(x_train_1.shape)
print(x_train_2.shape)
print(x_train_3.shape)
print(x_train_4.shape)
print(x_train_5.shape)
print(x_train_6.shape)
print(x_train_7.shape)
print(x_train_8.shape)
print(x_train_9.shape)
x_test_0 = x_test_flatten[y_test == 0]
x_test_1 = x_test_flatten[y_test == 1]
x_test_2 = x_test_flatten[y_test == 2]
x_test_3 = x_test_flatten[y_test == 3]
x_test_4 = x_test_flatten[y_test == 4]
x_test_5 = x_test_flatten[y_test == 5]
x_test_6 = x_test_flatten[y_test == 6]
x_test_7 = x_test_flatten[y_test == 7]
x_test_8 = x_test_flatten[y_test == 8]
x_test_9 = x_test_flatten[y_test == 9]
x_test_list = [x_test_0, x_test_1, x_test_2, x_test_3, x_test_4, x_test_5, x_test_6, x_test_7, x_test_8, x_test_9]
print(x_test_0.shape)
print(x_test_1.shape)
print(x_test_2.shape)
print(x_test_3.shape)
print(x_test_4.shape)
print(x_test_5.shape)
print(x_test_6.shape)
print(x_test_7.shape)
print(x_test_8.shape)
print(x_test_9.shape)
num_sample = 200
n_class = 2
mult_test = 2.5
X_train = x_train_list[0][:num_sample, :]
X_test = x_test_list[0][:int(mult_test*num_sample), :]
Y_train = np.zeros((n_class*X_train.shape[0],), dtype=int)
Y_test = np.zeros((n_class*X_test.shape[0],), dtype=int)
for i in range(n_class-1):
X_train = np.concatenate((X_train, x_train_list[i+1][:num_sample, :]), axis=0)
Y_train[num_sample*(i+1):num_sample*(i+2)] = int(i+1)
X_test = np.concatenate((X_test, x_test_list[i+1][:int(mult_test*num_sample), :]), axis=0)
Y_test[int(mult_test*num_sample*(i+1)):int(mult_test*num_sample*(i+2))] = int(i+1)
Y_train = to_categorical(Y_train)
Y_test = to_categorical(Y_test)
print(X_train.shape, Y_train.shape)
print(X_test.shape, Y_test.shape)
def normalize(X, use_params=False, params=None):
"""Normalize the given dataset X
Args:
X: ndarray, dataset
Returns:
(Xbar, mean, std): tuple of ndarray, Xbar is the normalized dataset
with mean 0 and standard deviation 1; mean and std are the
mean and standard deviation respectively.
Note:
You will encounter dimensions where the standard deviation is
zero, for those when you do normalization the normalized data
will be NaN. Handle this by setting using `std = 1` for those
dimensions when doing normalization.
"""
if use_params:
mu = params[0]
std_filled = [1]
else:
mu = np.mean(X, axis=0)
std = np.std(X, axis=0)
#std_filled = std.copy()
#std_filled[std==0] = 1.
Xbar = (X - mu)/(std + 1e-8)
return Xbar, mu, std
X_train, mu_train, std_train = normalize(X_train)
X_train.shape, Y_train.shape
X_test = (X_test - mu_train)/(std_train + 1e-8)
X_test.shape, Y_test.shape
from sklearn.decomposition import PCA
from matplotlib import pyplot as plt
num_component = 6
pca = PCA(n_components=num_component, svd_solver='full')
pca.fit(X_train)
np.cumsum(pca.explained_variance_ratio_)
X_train = pca.transform(X_train)
X_test = pca.transform(X_test)
print(X_train.shape, Y_train.shape)
print(X_test.shape, Y_test.shape)
X_train = (X_train.T / np.sqrt(np.sum(X_train ** 2, -1))).T
X_test = (X_test.T / np.sqrt(np.sum(X_test ** 2, -1))).T
plt.scatter(X_train[:100, 0], X_train[:100, 1])
plt.scatter(X_train[100:200, 0], X_train[100:200, 1])
plt.scatter(X_train[200:300, 0], X_train[200:300, 1])
from qiskit import *
import numpy as np
# Set a random seed
np.random.seed(42)
def drc_circuit(x_sample, parameters, num_features, layer=1):
q_reg = QuantumRegister(1)
c_reg = ClassicalRegister(1)
circuit = QuantumCircuit(q_reg, c_reg)
# Layer iteration
for i in range(layer):
# Gate iteration
for j in range(int(num_features/3)):
circuit.u(*x_sample[3*j:3*(j+1)], 0)
circuit.u(*parameters[3*j:3*(j+1)], 0)
circuit.measure(0,0)
return circuit
num_features = 6
params = np.random.uniform(size=(num_features + 2))
params
drc_circuit(X_train[0], params, num_features).draw('mpl')
shots=1000
backend = Aer.get_backend('qasm_simulator')
L = 1
num_features = 6
def weighted_fidelity_cost_function(params):
loss = 0
# Training sample iteration
for k in range(len(X_train)):
q_reg = QuantumRegister(1)
c_reg = ClassicalRegister(1)
circuit = QuantumCircuit(q_reg, c_reg)
# Layer iteration
for i in range(L):
# Gate iteration
for j in range(int(num_features/3)):
circuit.u(*X_train[k][3*j:3*(j+1)], 0)
circuit.u(*params[3*j:3*(j+1)], 0)
circuit.measure(0,0)
t_circ = transpile(circ, backend)
qobj = assemble(t_circ, shots=shots)
job = backend.run(qobj)
result = job.result().get_counts(circ)
counts = np.array(list(result.values()))
# Pauli-Z eigenvalue
states = np.array([0, -1])
# Compute probabilities for each state
probabilities = counts / shots
# Get state expectation
z_expectation = np.sum(states * probabilities)
# Get weighted fidelity
fidel_0 = params[-2]*(1 + z_expectation)/2
fidel_1 = params[-1]*(1 - z_expectation)/2
# Calculate the loss from the sample
loss += ((fidel_0-Y_train[0,0])**2 + (fidel_1-Y_train[0,1])**2)/2
loss = loss/len(X_train)
return loss
weighted_fidelity_cost_function(params)
from scipy.optimize import minimize
out = minimize(weighted_fidelity_cost_function, x0=params, method='L-BFGS-B', options={'maxiter':10000})
print(out)
params
from qiskit.aqua.components.optimizers import ADAM
from qiskit.aqua.components.optimizers import L_BFGS_B
opt_adam = ADAM(maxiter=100)
opt_lbfgsb = L_BFGS_B(maxiter=100, iprint=10)
out = opt_adam.optimize(num_vars=8, objective_function=weighted_fidelity_cost_function, initial_point=params)
out
out
out
params
weights = np.random.rand(num_features + 2)
weights = tf.Variable(weights, dtype=tf.float64, trainable=True)
weights.numpy()
shots=2000
backend = Aer.get_backend('qasm_simulator')
L = 1
def drc_pred(params):
params = params.numpy()
pred = np.zeros((len(X_train),2))
# Training sample iteration
for i in range(len(X_train)):
circ = drc_circuit(X_train[i], params, num_features, layer=L)
t_circ = transpile(circ, backend)
qobj = assemble(t_circ)
job = backend.run(qobj, shots=shots)
result = job.result().get_counts(circ)
counts = np.array(list(result.values()))
# Pauli-Z eigenvalue
states = np.array([0, -1])
# Compute probabilities for each state
probabilities = counts / shots
# Get state expectation
z_expectation = np.sum(states * probabilities)
# Get weighted fidelity
fidel_0 = params[-2]*(1 + z_expectation)/2
fidel_1 = params[-1]*(1 - z_expectation)/2
pred[i] = np.array([fidel_0, fidel_1])
return pred
optimizer = tf.keras.optimizers.Adam(lr=0.01)
def loss(params):
pred = drc_pred(params)
return tf.keras.losses.MeanSquaredError()(Y_train, pred)
loss(weights)
optimizer.minimize(lambda: loss(weights), [weights])
|
https://github.com/KMU-quantum-classroom/qiskit-classroom-converter
|
KMU-quantum-classroom
|
import numpy as np
from qiskit import(
QuantumCircuit,
execute,
Aer)
from qiskit.visualization import plot_histogram
# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(2, 2)
# Add a H gate on qubit 0
circuit.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circuit.cx(0, 1)
# Map the quantum measurement to the classical bits
circuit.measure([0,1], [0,1])
# Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(circuit)
print(counts)
# Draw the circuit
circuit.draw()
print(circuit)
|
https://github.com/KMU-quantum-classroom/qiskit-classroom-converter
|
KMU-quantum-classroom
|
import warnings
from loguru import logger
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit_class_converter import ConversionService, ConversionType, __FULL_VERSION__
warnings.filterwarnings('ignore')
__FULL_VERSION__
input_value = [
[1, 0, 0, 0],
[0, 0, 0, 1],
[0, 0, 1, 0],
[0, 1, 0, 0]
]
sample_converter = ConversionService(conversion_type="MATRIX_TO_QC", option={"label": "CX gate"})
result = sample_converter.convert(input_value=input_value)
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.x(0)
quantum_circuit.append(result, [0, 1])
quantum_circuit.measure(range(2), range(2))
backend = AerSimulator()
qc_compiled = transpile(quantum_circuit, backend)
logger.info("\n" + str(quantum_circuit))
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
sample_converter = ConversionService(conversion_type="QC_TO_MATRIX")
result = sample_converter.convert(input_value=quantum_circuit)
for gate in result["gate"]:
logger.info("\n" + str(gate.astype(int)))
logger.info("list: " + str(result["name"]))
result["result"].astype(int)
# quantum circuit to matrix (for print: raw option)
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
sample_converter = ConversionService(conversion_type="QC_TO_MATRIX", option={"print": "raw"})
result = sample_converter.convert(input_value=quantum_circuit)
for gate in result["gate"]:
logger.info(gate)
logger.info(result["result"])
from IPython.display import Latex
Latex(result["result"])
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.h(0)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
sample_converter = ConversionService(conversion_type="QC_TO_BRA_KET")
result = sample_converter.convert(input_value=quantum_circuit)
result
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.h(0)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
sample_converter = ConversionService(conversion_type="QC_TO_BRA_KET", option={"print": "raw"})
result = sample_converter.convert(input_value=quantum_circuit)
logger.info(result)
from IPython.display import Math
Math(result)
sample_converter = ConversionService(conversion_type="STR_TO_BRA_KET")
result = sample_converter.convert(input_value="sqrt(2)*|00>/2+sqrt(2)*|11>/2")
logger.info(result)
logger.info(type(result))
sample_converter = ConversionService(conversion_type="STR_TO_BRA_KET", option={"print": "raw"})
result = sample_converter.convert(input_value="sqrt(2)*|00>/2+sqrt(2)*|11>/2")
logger.info(result)
from IPython.display import Math
Math(result)
|
https://github.com/KMU-quantum-classroom/qiskit-classroom-converter
|
KMU-quantum-classroom
|
"""
Base Converter
"""
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
from abc import ABC, abstractmethod
import qiskit
import qiskit_aer
from loguru import logger
class BaseConverter(ABC):
"""
Converter class
"""
def __init__(self, option=None):
"""
BaseConverter init value
"""
if option is None:
option = {}
self.option = option
self.input_value = None
self.qiskit = qiskit
self.qiskit_aer = qiskit_aer
self.logger = logger
def convert(self, input_value):
"""
convert main process
:return:
"""
self.input_value = input_value
return self.actual_convert_action()
@abstractmethod
def actual_convert_action(self):
"""
actual action
:return:
"""
raise NotImplementedError
|
https://github.com/KMU-quantum-classroom/qiskit-classroom-converter
|
KMU-quantum-classroom
|
"""
QuantumCircuit to Bra-ket Notation Converter
"""
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
from typing import List
from loguru import logger
from qiskit import QuantumCircuit
from sympy import SympifyError, simplify, expand, latex
from sympy.parsing.latex import parse_latex
from qiskit_class_converter.converters.base import BaseConverter
class QuantumCircuitToBraketNotationConverter(BaseConverter):
"""
Converter class
"""
# pylint: disable-next = too-many-return-statements
def actual_convert_action(self):
self.logger.debug("quantum circuit to bra-ket notation")
self.input_value.save_statevector()
# type validate
if isinstance(self.input_value, (List, QuantumCircuit)):
result = self.qiskit_aer.AerSimulator().run(self.input_value).result()
else:
raise TypeError("QuantumCircuit is required.")
source = result.get_statevector().draw("latex_source")
try:
if (self.option.get("expression", False) == "simplify") and \
(self.option.get("print", False) == "raw"):
return latex(simplify(parse_latex(source)))
if self.option.get("expression", False) == "simplify":
return str(simplify(parse_latex(source)))
if (self.option.get("expression", False) == "expand") and \
(self.option.get("print", False) == "raw"):
return latex(expand(parse_latex(source)))
if self.option.get("expression", False) == "expand":
return str(expand(parse_latex(source)))
if self.option.get("print", False) == "raw":
return str(source)
return str(parse_latex(source))
except SympifyError:
# case : 01>
logger.warning("It caught a SympifyError, so it outputs source text.")
return source
|
https://github.com/KMU-quantum-classroom/qiskit-classroom-converter
|
KMU-quantum-classroom
|
"""
QuantumCircuit to Matrix Converter
"""
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
from typing import List
import numpy as np
from qiskit import QuantumCircuit
from qiskit.visualization import array_to_latex
from qiskit_class_converter.converters.base import BaseConverter
class QuantumCircuitToMatrixConverter(BaseConverter):
"""
Converter class
"""
def __init__(self, option=None):
super().__init__(option)
self.__programmable_variable_per_qubit = None
def insert_i_gate(self):
"""
Trace empty space in the layer to enter the Identity gate.
"""
arr = [f"I_{{q{i}}}" for i in range(self.__programmable_variable_per_qubit["total_qubits"])]
for i in self.__programmable_variable_per_qubit["gate_qubits"]:
for j in i["qubit"]:
arr[j] = i["name"]
arr = list(dict.fromkeys(arr))
arr.reverse()
return arr
def actual_convert_action(self):
self.logger.debug("quantum circuit to matrix")
matrix_list = {"gate": [], "name": []}
# type validate
if isinstance(self.input_value, (List, QuantumCircuit)):
self.input_value = self.input_value.remove_final_measurements(inplace=False)
dag = self.qiskit.converters.circuit_to_dag(self.input_value)
else:
raise TypeError("QuantumCircuit is required.")
layer_index = 0
for layer in dag.layers():
circuit = self.qiskit.converters.dag_to_circuit(layer['graph'])
matrix_list["gate"].append(self.qiskit.quantum_info.Operator(circuit).to_matrix())
self.__programmable_variable_per_qubit = {"total_qubits": circuit.num_qubits,
"gate_qubits": []}
for _inst in circuit.data:
_inst_upper_name = _inst[0].name.upper()
qubit_indices = [circuit.find_bit(qubit)[0] for qubit in _inst[1]]
gate_name = (_inst_upper_name +
"_{" + ", ".join(f"q{i}" for i in qubit_indices) + "}")
self.__programmable_variable_per_qubit["gate_qubits"].append(
{"name": gate_name, "qubit": qubit_indices}
)
matrix_list["name"].append((layer_index, self.insert_i_gate()))
layer_index += 1
matrix_list["result"] = self.qiskit.quantum_info.Operator(self.input_value).to_matrix()
if self.option.get("print", False) == "raw":
latex_source_list = {"gate": [], "name": matrix_list["name"]}
for each_matrix in matrix_list["gate"]:
latex_source_list["gate"].append(
array_to_latex(array=np.array(each_matrix), source=True))
latex_source_list["result"] = array_to_latex(
array=np.array(matrix_list["result"]), source=True)
return latex_source_list
return matrix_list
|
https://github.com/KMU-quantum-classroom/qiskit-classroom-converter
|
KMU-quantum-classroom
|
"""
converter service
"""
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import typing
from enum import Enum
import numpy as np
from qiskit import QuantumCircuit
from qiskit_class_converter.converters.matrix_to_quantum_circuit \
import MatrixToQuantumCircuitConverter
from qiskit_class_converter.converters.quantum_circuit_to_braket_notation \
import QuantumCircuitToBraketNotationConverter
from qiskit_class_converter.converters.quantum_circuit_to_matrix \
import QuantumCircuitToMatrixConverter
from qiskit_class_converter.converters.string_to_braket_notation \
import StringToBraketNotationConverter
class ConversionType(Enum):
"""
Conversion Type
"""
QC_TO_BRA_KET = QuantumCircuitToBraketNotationConverter
"""```python
from qiskit import QuantumCircuit
from qiskit_class_converter import ConversionService
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
sample_converter = ConversionService(conversion_type="QC_TO_BRA_KET")
result = sample_converter.convert(input_value=quantum_circuit)
```"""
QC_TO_MATRIX = QuantumCircuitToMatrixConverter
"""```python
from qiskit import QuantumCircuit
from qiskit_class_converter import ConversionService
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
sample_converter = ConversionService(conversion_type="QC_TO_MATRIX")
result = sample_converter.convert(input_value=quantum_circuit)
```"""
MATRIX_TO_QC = MatrixToQuantumCircuitConverter
"""```python
from qiskit import QuantumCircuit
from qiskit_class_converter import ConversionService
input_value = [
[1, 0, 0, 0],
[0, 0, 0, 1],
[0, 0, 1, 0],
[0, 1, 0, 0]
]
sample_converter = ConversionService(conversion_type="MATRIX_TO_QC")
result = sample_converter.convert(input_value=input_value)
# using user's QuantumCircuit object
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.append(result, [0, 1])
```"""
STR_TO_BRA_KET = StringToBraketNotationConverter
"""```python
from qiskit import QuantumCircuit
from qiskit_class_converter import ConversionService
sample_converter = ConversionService(conversion_type="STR_TO_BRA_KET")
sample_converter.convert(input_value="|01>")
```"""
class ConversionService: # pylint: disable=too-few-public-methods
"""
Conversion Service class
```python
from qiskit_class_converter import ConversionService
ConversionService(conversion_type="QC_TO_BRA_KET", option={"expression": "simplify"})
```
"""
def __init__(self, conversion_type: typing.Union[str, ConversionType], option=None):
"""
init function
:param conversion_type: QC_TO_BRA_KET, QC_TO_MATRIX, MATRIX_TO_QC, STR_TO_BRA_KET
:param option: See the Options table in this article.
"""
if option is None:
self.option = {}
self.option = option
if isinstance(conversion_type, str):
self.__conversion_object = ConversionType[conversion_type.upper()].value
elif isinstance(conversion_type, ConversionType):
self.__conversion_object = conversion_type.value
def convert(self, input_value: typing.Union[list, np.ndarray, QuantumCircuit, str]):
"""
convert functions
result = sample_converter.convert(input_value=quantum_circuit)
logger.info(result)
:param input_value: QuantumCircuit or MATRIX or BRA_KET String
:return: Converted result
"""
convert = self.__conversion_object(self.option).convert(input_value)
return convert
|
https://github.com/KMU-quantum-classroom/qiskit-classroom-converter
|
KMU-quantum-classroom
|
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# pylint: disable=duplicate-code
"""
converter service class
"""
import unittest
from qiskit import QuantumCircuit
from qiskit_class_converter import ConversionService, ConversionType
from qiskit_class_converter.converters.matrix_to_quantum_circuit \
import MatrixToQuantumCircuitConverter
class TestConverterServiceClass(unittest.TestCase):
"""Tests Service Impl class implementation."""
def test_str_to_bra_ket_service(self):
"""Tests run Service method implementation."""
input_value = "|1>"
system = ConversionService(conversion_type="STR_TO_BRA_KET")
result = system.convert(input_value=input_value)
self.assertIsNotNone(result)
def test_matrix_to_quantum_circuit_service(self):
"""Tests run Service method implementation."""
input_value = [
[1, 0, 0, 0],
[0, 0, 0, 1],
[0, 0, 1, 0],
[0, 1, 0, 0]
]
system = ConversionService(conversion_type="MATRIX_TO_QC")
result = system.convert(input_value=input_value)
self.assertIsNotNone(result)
def test_quantum_circuit_to_bra_ket_service(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.h(0)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
system = ConversionService(conversion_type="QC_TO_BRA_KET")
result = system.convert(input_value=quantum_circuit)
self.assertEqual(result, "(sqrt(2)/2)*|0> + (sqrt(2)/2)*|11>")
def test_quantum_circuit_to_raw_bra_ket_service(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.h(0)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
system = ConversionService(conversion_type="QC_TO_BRA_KET", option={"print": "raw"})
result = system.convert(input_value=quantum_circuit)
self.assertEqual(result, r"\frac{\sqrt{2}}{2} |00\rangle+\frac{\sqrt{2}}{2} |11\rangle")
def test_quantum_circuit_to_simplify_bra_ket_service(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.h(0)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
system = ConversionService(conversion_type="QC_TO_BRA_KET",
option={"expression": "simplify"})
result = system.convert(input_value=quantum_circuit)
self.assertEqual(result, "sqrt(2)*(|0> + |11>)/2")
def test_quantum_circuit_to_expand_bra_ket_service(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.h(0)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
system = ConversionService(conversion_type="QC_TO_BRA_KET",
option={"expression": "expand"})
result = system.convert(input_value=quantum_circuit)
self.assertEqual(result, "sqrt(2)*|0>/2 + sqrt(2)*|11>/2")
def test_quantum_circuit_to_simplify_raw_bra_ket_service(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.h(0)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
system = ConversionService(conversion_type="QC_TO_BRA_KET",
option={"expression": "simplify", "print": "raw"})
result = system.convert(input_value=quantum_circuit)
self.assertEqual(result, r"\frac{\sqrt{2} \left({\left|0\right\rangle } + "
r"{\left|11\right\rangle }\right)}{2}")
def test_quantum_circuit_to_expand_raw_bra_ket_service(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.h(0)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
system = ConversionService(conversion_type="QC_TO_BRA_KET",
option={"expression": "expand", "print": "raw"})
result = system.convert(input_value=quantum_circuit)
self.assertEqual(result, r"\frac{\sqrt{2} {\left|0\right\rangle }}{2} + "
r"\frac{\sqrt{2} {\left|11\right\rangle }}{2}")
def test_quantum_circuit_to_matrix_service(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(2)
quantum_circuit.cx(0, 1)
system = ConversionService(conversion_type="QC_TO_MATRIX")
result = system.convert(input_value=quantum_circuit)
self.assertIsNotNone(result)
def test_conversion_type(self):
"""Tests run Service Type implementation."""
self.assertEqual(ConversionType.MATRIX_TO_QC.value, MatrixToQuantumCircuitConverter)
|
https://github.com/KMU-quantum-classroom/qiskit-classroom-converter
|
KMU-quantum-classroom
|
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# pylint: disable=duplicate-code
"""
convert class
"""
import unittest
import warnings
from numpy import array
from qiskit import QuantumCircuit
from qiskit.circuit import Instruction
from sympy.physics.quantum.qubit import Qubit
from sympy import sqrt
from sympy.physics.quantum import represent
from qiskit_class_converter.converters.string_to_braket_notation \
import StringToBraketNotationConverter
from qiskit_class_converter.converters.matrix_to_quantum_circuit \
import MatrixToQuantumCircuitConverter
from qiskit_class_converter.converters.quantum_circuit_to_braket_notation \
import QuantumCircuitToBraketNotationConverter
from qiskit_class_converter.converters.quantum_circuit_to_matrix \
import QuantumCircuitToMatrixConverter
class TestConvertClass(unittest.TestCase):
"""Tests Impl class implementation."""
def test_str_to_bra_ket(self):
"""Tests run method implementation."""
main = StringToBraketNotationConverter()
symbol = 1/sqrt(2)*(Qubit('00')+Qubit('11'))
input_value = "sqrt(2)*|00>/2+sqrt(2)*|11>/2"
result = main.convert(input_value=input_value)
self.assertEqual(represent(result), represent(symbol))
def test_matrix_to_quantum_circuit(self):
"""Tests run method implementation."""
main = MatrixToQuantumCircuitConverter()
input_value = [
[1, 0, 0, 0],
[0, 0, 0, 1],
[0, 0, 1, 0],
[0, 1, 0, 0]
]
expect_value = Instruction(name='unitary', num_qubits=2, num_clbits=0,
params=[array([[1. + 0.j, 0. + 0.j, 0. + 0.j, 0. + 0.j],
[0. + 0.j, 0. + 0.j, 0. + 0.j, 1. + 0.j],
[0. + 0.j, 0. + 0.j, 1. + 0.j, 0. + 0.j],
[0. + 0.j, 1. + 0.j, 0. + 0.j, 0. + 0.j]])])
result = main.convert(input_value=input_value)
self.assertEqual(str(result), str(expect_value))
def test_quantum_circuit_to_bra_ket(self):
"""Tests run method implementation."""
main = QuantumCircuitToBraketNotationConverter()
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.h(0)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
result = main.convert(input_value=quantum_circuit)
self.assertEqual(result, "(sqrt(2)/2)*|0> + (sqrt(2)/2)*|11>")
def test_quantum_circuit_to_matrix(self):
"""Tests run method implementation."""
warnings.filterwarnings('ignore')
main = QuantumCircuitToMatrixConverter()
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.cx(0, 1)
result = main.convert(input_value=quantum_circuit)
expect_value = array([
[1, 0, 0, 0],
[0, 0, 0, 1],
[0, 0, 1, 0],
[0, 1, 0, 0]
])
self.assertTrue((result["result"].astype(int) & expect_value).any())
|
https://github.com/KMU-quantum-classroom/qiskit-classroom-converter
|
KMU-quantum-classroom
|
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# pylint: disable=duplicate-code
"""
converter service class
"""
import unittest
from numpy import array
from numpy.testing import assert_array_equal
from qiskit import QuantumCircuit
from qiskit_class_converter import ConversionService
class TestQcToMatrixClass(unittest.TestCase):
"""Tests Service Impl class implementation."""
def test_qc_to_matrix_gate(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
sample_converter = ConversionService(conversion_type="QC_TO_MATRIX")
result = sample_converter.convert(input_value=quantum_circuit)
assert_array_equal(result["gate"], [array([[0. + 0.j, 1. + 0.j, 0. + 0.j, 0. + 0.j],
[1. + 0.j, 0. + 0.j, 0. + 0.j, 0. + 0.j],
[0. + 0.j, 0. + 0.j, 0. + 0.j, 1. + 0.j],
[0. + 0.j, 0. + 0.j, 1. + 0.j, 0. + 0.j]]),
array([[1. + 0.j, 0. + 0.j, 0. + 0.j, 0. + 0.j],
[0. + 0.j, 0. + 0.j, 0. + 0.j, 1. + 0.j],
[0. + 0.j, 0. + 0.j, 1. + 0.j, 0. + 0.j],
[0. + 0.j, 1. + 0.j, 0. + 0.j, 0. + 0.j]])])
def test_qc_to_matrix_gate_raw(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
sample_converter = ConversionService(conversion_type="QC_TO_MATRIX",
option={"print": "raw"})
result = sample_converter.convert(input_value=quantum_circuit)
self.assertEqual(result["gate"], ['\n\n'
'\\begin{bmatrix}\n'
'0 & 1 & 0 & 0 \\\\\n'
' 1 & 0 & 0 & 0 \\\\\n'
' 0 & 0 & 0 & 1 \\\\\n'
' 0 & 0 & 1 & 0 \\\\\n'
' \\end{bmatrix}\n',
'\n'
'\n'
'\\begin{bmatrix}\n'
'1 & 0 & 0 & 0 \\\\\n'
' 0 & 0 & 0 & 1 \\\\\n'
' 0 & 0 & 1 & 0 \\\\\n'
' 0 & 1 & 0 & 0 \\\\\n'
' \\end{bmatrix}\n'])
def test_qc_to_matrix_result_raw(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
sample_converter = ConversionService(conversion_type="QC_TO_MATRIX",
option={"print": "raw"})
result = sample_converter.convert(input_value=quantum_circuit)
self.assertEqual(result["result"], '\n\n'
'\\begin{bmatrix}\n'
'0 & 1 & 0 & 0 \\\\\n'
' 0 & 0 & 1 & 0 \\\\\n'
' 0 & 0 & 0 & 1 \\\\\n'
' 1 & 0 & 0 & 0 \\\\\n'
' \\end{bmatrix}\n')
def test_qc_to_matrix_name(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
sample_converter = ConversionService(conversion_type="QC_TO_MATRIX")
result = sample_converter.convert(input_value=quantum_circuit)
self.assertEqual(result["name"], [(0, ['I_{q1}', 'X_{q0}']), (1, ['CX_{q0, q1}'])])
def test_qc_to_matrix_ccx(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(3, 3)
quantum_circuit.x(0)
quantum_circuit.ccx(0, 1, 2)
sample_converter = ConversionService(conversion_type="QC_TO_MATRIX")
result = sample_converter.convert(input_value=quantum_circuit)
self.assertEqual(result["name"],
[(0, ['I_{q2}', 'I_{q1}', 'X_{q0}']), (1, ['CCX_{q0, q1, q2}'])])
def test_qc_to_matrix_result(self):
"""Tests run Service method implementation."""
quantum_circuit = QuantumCircuit(2, 2)
quantum_circuit.x(0)
quantum_circuit.cx(0, 1)
sample_converter = ConversionService(conversion_type="QC_TO_MATRIX")
result = sample_converter.convert(input_value=quantum_circuit)
assert_array_equal(result["result"].astype(int), array([[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1],
[1, 0, 0, 0]]))
|
https://github.com/qiskit-community/qiskit-sat-synthesis
|
qiskit-community
|
%load_ext autoreload
%autoreload 2
# imports
from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import Clifford, Operator, StabilizerState, Statevector
from qiskit.transpiler import CouplingMap
from synthesis.sat_problem_clifford import SatProblemClifford
from synthesis.utils import line_coupling_map
from synthesis.synthesize import synthesize_optimal
from synthesis.synthesize_clifford import synthesize_clifford_depth2q
# naive preparation of the state of interest (does not adhere to LNN connectivity)
nq = 13 # number of qubits
k = 3 # number of consequtive ones (0: GHZ, 1: checkerboard, n/2: hartree-fock)
ones = [i for m in range(1, int(nq / k), 2) for i in range(m * k, (m + 1) * k)]
qc = QuantumCircuit(nq)
qc.h(nq - 1)
for target in ones:
qc.cx(nq - 1, target)
display(Statevector(qc).draw("latex"))
qc.draw("mpl")
# prepackaged clifford synthesis routine
cliff = Clifford(qc)
res = synthesize_clifford_depth2q(
cliff, coupling_map=line_coupling_map(cliff.num_qubits), state_preparation_mode=True
)
res.circuit.draw("mpl", fold=-1)
# Create a custom problem: we want to use a single H-gate in the first layer and only CX-gates after that
def create_problem_custom(cliff, depth):
nq = cliff.num_qubits
sat_problem = SatProblemClifford(nq, verbosity=1)
sat_problem.set_init_matrix_to_identity(nq)
sat_problem.set_final_clifford(cliff)
sat_problem.set_state_preparation_mode(True)
sat_problem.add_layer(gates=["H"], coupling_maps=[])
for _ in range(depth):
sat_problem.add_layer(gates=["CX"], coupling_maps=[line_coupling_map(nq)])
return sat_problem
def synthesize_clifford_custom(cliff):
res = synthesize_optimal(
target_obj=cliff, create_sat_problem_fn=create_problem_custom, verbosity=1
)
return res.circuit
cliff = Clifford(qc)
circuit = synthesize_clifford_custom(cliff)
circuit.draw("mpl", fold=-1)
# let's say we also want at most 2 unique layers
def create_problem_custom_u(cliff, depth):
nq = cliff.num_qubits
sat_problem = SatProblemClifford(nq, verbosity=1)
sat_problem.set_init_matrix_to_identity(nq)
sat_problem.set_final_clifford(cliff)
sat_problem.set_state_preparation_mode(True)
sat_problem.add_layer(gates=["H"], coupling_maps=[])
two_qubit_layers = []
for _ in range(depth):
layer = sat_problem.add_layer(
gates=["CX"], coupling_maps=[line_coupling_map(nq)]
)
two_qubit_layers.append(layer)
sat_problem.add_max_unique_layers_constraint(two_qubit_layers, 2)
return sat_problem
def synthesize_clifford_custom_u(cliff):
res = synthesize_optimal(
target_obj=cliff, create_sat_problem_fn=create_problem_custom_u, verbosity=1
)
return res.circuit
circuit = synthesize_clifford_custom_u(cliff)
circuit.draw("mpl", fold=-1)
|
https://github.com/qiskit-community/qiskit-sat-synthesis
|
qiskit-community
|
%load_ext autoreload
%autoreload 2
!pip install git+https://github.com/qiskit-community/qiskit-sat-synthesis
import numpy as np
# Qiskit includes
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import LinearFunction, PermutationGate
from qiskit.quantum_info import Clifford
from qiskit.transpiler import CouplingMap
from qiskit.compiler import transpile
from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig
from qiskit.transpiler.passes import HighLevelSynthesis
from qiskit.transpiler.passes.synthesis import high_level_synthesis_plugin_names
print(f'Clifford plugin names: {high_level_synthesis_plugin_names("clifford")}')
print(f'LinearFunction plugin names: {high_level_synthesis_plugin_names("linear_function")}')
print(f'PermutationGate plugin names: {high_level_synthesis_plugin_names("permutation")}')
mat = np.array(
[
[1, 1, 0, 1, 1],
[0, 1, 1, 1, 1],
[0, 0, 1, 1, 0],
[0, 0, 0, 1, 1],
[1, 0, 1, 1, 0],
]
)
mat
qc = QuantumCircuit(5)
qc.append(LinearFunction(mat), [0, 1, 2, 3, 4])
qc.draw("mpl")
# Transpile (default)
tqc = transpile(qc)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(linear_function=[("sat_count", {})])
tqc = transpile(qc, hls_config=hls_config)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(linear_function=[("sat_depth", {})])
tqc = transpile(qc, hls_config=hls_config)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(
linear_function=[("sat_depth", {"optimize_1q_gates": True, "verbosity": 1})]
)
tqc = transpile(qc, hls_config=hls_config)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(linear_function=[("sat_depth", {"allow_final_permutation": True})])
tqc = transpile(qc, hls_config=hls_config)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(linear_function=[("sat_depth", {"allow_layout_permutation": True})])
tqc = transpile(qc, hls_config=hls_config)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(linear_function=[("sat_depth", {})])
coupling_map = CouplingMap.from_line(5)
tqc = HighLevelSynthesis(hls_config=hls_config, coupling_map=coupling_map, use_qubit_indices=True)(qc)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
# This is cyclic shift: 1->0, 2->1, 0->2
pattern = [1, 2, 3, 4, 5, 6, 7, 0]
qc = QuantumCircuit(8)
qc.append(PermutationGate(pattern), [0, 1, 2, 3, 4, 5, 6, 7])
qc.draw(output='mpl')
hls_config = HLSConfig(permutation=[("sat_depth", {"optimize_2q_gates": True})])
coupling_map = CouplingMap.from_full(8)
tqc = HighLevelSynthesis(hls_config=hls_config, coupling_map=coupling_map, use_qubit_indices=True)(qc)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(permutation=[("sat_depth", {"optimize_2q_gates": True})])
coupling_map = CouplingMap.from_line(8)
tqc = HighLevelSynthesis(hls_config=hls_config, coupling_map=coupling_map, use_qubit_indices=True)(qc)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
print(mat)
from qiskit_sat_synthesis.synthesize_linear import synthesize_linear_depth, synthesize_linear_count
line5 = list(CouplingMap.from_line(5).get_edges()) # line connectivity
full5 = list(CouplingMap.from_full(5).get_edges()) # all-to-all connectivity
res = synthesize_linear_depth(mat, coupling_map=full5, verbosity=0, allow_final_permutation=True)
res.circuit.draw("mpl")
res.circuit_with_permutations.draw(output='mpl')
print(res.solutions[0].final_permutation)
LinearFunction(res.circuit_with_permutations) == LinearFunction(mat)
res = synthesize_linear_depth(mat, coupling_map=full5, verbosity=1, allow_final_permutation=True, print_solutions=False, max_solutions=5)
for i, solution in enumerate(res.solutions):
print(f"Solution {i+1}:")
print(solution.circuit)
from qiskit_sat_synthesis.synthesize_superposed import (
synthesize_superposed_count,
synthesize_superposed_depth,
)
coupling_map = [(0, 1), (1, 0), (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), (4, 3), (4, 5), (5, 4), (5, 6), (6, 5), (6, 7), (7, 6), (7, 8), (8, 7)] # line connectivity
result = synthesize_superposed_depth(
[1, 0, 1, 0, 1, 0, 1, 0, 1],
coupling_map=coupling_map,
optimize_2q_gates=True,
print_solutions=False,
verbosity=0,
max_depth2q=10,
)
result.circuit.draw('mpl')
hor9 = [[0, 1], [3, 4], [6, 7], [1, 0], [4, 3], [7, 6], [1, 2], [4, 5], [7, 8], [2, 1], [5, 4], [8, 7]]
ver9 = [[0, 3], [1, 4], [2, 5], [3, 0], [4, 1], [5, 2], [3, 6], [4, 7], [5, 8], [6, 3], [7, 4], [8, 5]]
all9 = hor9 + ver9
state = [1, 0, 0, 0, 0, 0, 0, 0, 1]
res = synthesize_superposed_depth(
state,
coupling_map=all9,
print_solutions=False,
check_solutions=True,
optimize_2q_gates=True,
verbosity=0,
)
res.circuit.draw(output='mpl')
res = synthesize_superposed_depth(
state,
coupling_map_list=[hor9, ver9],
print_solutions=False,
check_solutions=True,
optimize_2q_gates=True,
verbosity=0,
)
res.circuit.draw(output='mpl')
mat1 = np.array(
[
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[1, 1, 1, 1],
]
)
mat2 = np.array(
[
[1, 0, 0, 0],
[0, 1, 0, 0],
[1, 0, 1, 0],
[1, 1, 1, 1],
]
)
from qiskit_sat_synthesis.sat_problem_linear import SatProblemLinear
def create_custom_problem(k):
nq = 4
coupling_map = [[0, 1], [1, 0], [1, 2], [2, 1], [2, 3], [3, 2]]
sat_problem = SatProblemLinear(nq, verbosity=0)
sat_problem.set_init_matrix(mat1)
for _ in range(k):
sat_problem.add_layer(
gates=["CX"],
coupling_maps=[coupling_map],
)
sat_problem.set_final_matrix(mat2)
sat_problem.set_optimize_2q_gate(True)
return sat_problem
from qiskit_sat_synthesis.synthesize import SynthesisResult, synthesize_optimal
res = synthesize_optimal(create_sat_problem_fn=create_custom_problem, verbosity=1)
print(res.circuit)
def create_cx_swap_problem(k, mat):
nq = len(mat)
coupling_map = list(CouplingMap.from_line(nq).get_edges())
sat_problem = SatProblemLinear(nq, verbosity=0)
sat_problem.set_init_matrix_to_identity(nq)
for _ in range(k):
sat_problem.add_layer(
gates=["CX", "SWAP"],
coupling_maps=[coupling_map],
)
sat_problem.set_final_matrix(mat)
return sat_problem
mat = np.array(
[
[1, 1, 0, 1, 1],
[0, 1, 1, 1, 1],
[0, 0, 1, 1, 0],
[0, 0, 0, 1, 1],
[1, 0, 1, 1, 0],
]
)
from functools import partial
res = synthesize_optimal(
create_sat_problem_fn=partial(create_cx_swap_problem, mat=mat), verbosity=1
)
res.circuit.draw(output='mpl')
print(LinearFunction(res.circuit) == LinearFunction(mat))
def create_cx_swap_problem(k, mat):
nq = len(mat)
coupling_map = list(CouplingMap.from_line(nq).get_edges())
sat_problem = SatProblemLinear(nq, verbosity=0)
sat_problem.set_init_matrix_to_identity(nq)
for _ in range(k):
layer_id = sat_problem.add_layer(gates=["CX", "SWAP"], coupling_maps=[coupling_map])
sat_problem.add_nonempty_constraint(layer_id)
sat_problem.set_final_matrix(mat)
return sat_problem
res = synthesize_optimal(
create_sat_problem_fn=partial(create_cx_swap_problem, mat=mat), verbosity=1
)
res.circuit.draw(output='mpl')
|
https://github.com/smit14/Quantum-K-means-algorithm
|
smit14
|
from sklearn.datasets import make_blobs
import numpy as np
import matplotlib.pyplot as plt
import math
def get_data(n,k,std):
data = make_blobs(n_samples=n, n_features=2, centers=k, cluster_std=std, random_state=100)
points = data[0]
centers = data[1]
return points,centers
def draw_plot(points,centers,label=True):
if label==False:
plt.scatter(points[:,0], points[:,1])
else:
plt.scatter(points[:,0], points[:,1], c=centers, cmap='viridis')
plt.xlim(0,1)
plt.ylim(0,1)
plt.show()
def plot_centroids(centers):
plt.scatter(centers[:,0], centers[:,1])
plt.xlim(0,1)
plt.ylim(0,1)
plt.show()
def initialize_centers(points,k):
return points[np.random.randint(points.shape[0],size=k),:]
def get_distance(p1, p2):
return np.sqrt(np.sum((p1-p2)*(p1-p2)))
def find_nearest_neighbour(points,centroids):
n = len(points)
k = centroids.shape[0]
centers = np.zeros(n)
for i in range(n):
min_dis = 10000
ind = 0
for j in range(k):
temp_dis = get_distance(points[i,:],centroids[j,:])
if temp_dis < min_dis:
min_dis = temp_dis
ind = j
centers[i] = ind
return centers
def find_centroids(points,centers):
n = len(points)
k = int(np.max(centers))+1
print(k)
centroids = np.zeros([k,2])
for i in range(k):
#print(points[centers==i])
centroids[i,:] = np.average(points[centers==i])
return centroids
def preprocess(points):
n = len(points)
x = 30.0*np.sqrt(2)
for i in range(n):
points[i,:]+=15
points[i,:]/=x
return points
n = 100 # number of data points
k = 4 # Number of centers
std = 2 # std of datapoints
points,o_centers = get_data(n,k,std) #dataset
points = preprocess(points) # Normalize dataset
plt.figure()
draw_plot(points,o_centers,label=False)
centroids = initialize_centers(points,k) # Intialize centroids
# run k-means algorithm
for i in range(5):
centers = find_nearest_neighbour(points,centroids) # find nearest centers
plt.figure()
draw_plot(points,centers)
#plot_centroids(centroids)
centroids = find_centroids(points,centers) # find centroids
|
https://github.com/smit14/Quantum-K-means-algorithm
|
smit14
|
from sklearn.datasets import make_blobs
import numpy as np
import matplotlib.pyplot as plt
import math
# import math lib
from math import pi
# import Qiskit
from qiskit import Aer, IBMQ, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
# To use local qasm simulator
backend = Aer.get_backend('qasm_simulator')
def get_theta(d):
x = d[0]
y = d[1]
theta = 2*math.acos((x+y)/2.0)
return theta
def get_Distance(x,y):
theta_1 = get_theta(x)
theta_2 = get_theta(y)
# create Quantum Register called "qr" with 3 qubits
qr = QuantumRegister(3, name="qr")
# create Classical Register called "cr" with 5 bits
cr = ClassicalRegister(3, name="cr")
# Creating Quantum Circuit called "qc" involving your Quantum Register "qr"
# and your Classical Register "cr"
qc = QuantumCircuit(qr, cr, name="k_means")
qc.h(qr[0])
qc.h(qr[1])
qc.h(qr[2])
qc.u3(theta_1, pi, pi, qr[1])
qc.u3(theta_2, pi, pi, qr[2])
qc.cswap(qr[0], qr[1], qr[2])
qc.h(qr[0])
qc.measure(qr[0], cr[0])
qc.reset(qr)
#print('----before run----')
job = execute(qc,backend=backend, shots=1024)
#print('----after run----')
result = job.result()
data = result.get_data()['counts']
if len(data)==1:
return 0.0
else:
return data['001']/1024.0
def get_data(n,k,std):
data = make_blobs(n_samples=n, n_features=2, centers=k, cluster_std=std, random_state=100)
points = data[0]
centers = data[1]
return points,centers
def draw_plot(points,centers,label=True):
if label==False:
plt.scatter(points[:,0], points[:,1])
else:
plt.scatter(points[:,0], points[:,1], c=centers, cmap='viridis')
plt.xlim(0,1)
plt.ylim(0,1)
plt.show()
def plot_centroids(centers):
plt.scatter(centers[:,0], centers[:,1])
plt.xlim(0,1)
plt.ylim(0,1)
plt.show()
def initialize_centers(points,k):
return points[np.random.randint(points.shape[0],size=k),:]
def get_distance(p1, p2):
return np.sqrt(np.sum((p1-p2)*(p1-p2)))
def find_nearest_neighbour(points,centroids):
n = len(points)
k = centroids.shape[0]
centers = np.zeros(n)
for i in range(n):
min_dis = 10000
ind = 0
for j in range(k):
temp_dis = get_Distance(points[i,:],centroids[j,:])
if temp_dis < min_dis:
min_dis = temp_dis
ind = j
centers[i] = ind
return centers
def find_centroids(points,centers):
n = len(points)
k = int(np.max(centers))+1
centroids = np.zeros([k,2])
for i in range(k):
#print(points[centers==i])
centroids[i,:] = np.average(points[centers==i])
return centroids
def preprocess(points):
n = len(points)
x = 30.0*np.sqrt(2)
for i in range(n):
points[i,:]+=15
points[i,:]/=x
return points
n = 100 # number of data points
k = 4 # Number of centers
std = 2 # std of datapoints
points,o_centers = get_data(n,k,std) #dataset
points = preprocess(points) # Normalize dataset
plt.figure()
draw_plot(points,o_centers,label=False)
centroids = initialize_centers(points,k) # Intialize centroids
# run k-means algorithm
for i in range(5):
centers = find_nearest_neighbour(points,centroids) # find nearest centers
plt.figure()
draw_plot(points,centers)
#plot_centroids(centroids)
centroids = find_centroids(points,centers) # find centroids
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import numpy as np
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
import dimod
qp = QuadraticProgram("Example")
n = 3
for j in range(n):
qp.binary_var('x' + "_" + str(j))
linear_objective = np.array([-1,0,-1])
Q = np.array([[-2,0,1],
[0,2,-2],
[1,-2,0]]) / 2
quadratic_objective = {}
for i in range(n):
for j in range(i, n):
var_i = 'x' + "_" + str(i)
if i == j:
quadratic_objective[var_i, var_i] = Q[i, i]
else:
var_j = 'x' + "_" + str(j)
quadratic_objective[var_i, var_j] = Q[i, j] + Q[j, i]
qp.linear_constraint(linear=np.array([0,1,-1]), sense='==', rhs=0,
name='linear_cstr')
qp.minimize(linear=linear_objective, quadratic=quadratic_objective)
print(qp)
conv = QuadraticProgramToQubo()
qubo = conv.convert(qp)
print(f"Auto calculated {conv.penalty=}")
print(qubo)
bqm_binary = dimod.as_bqm(qubo.objective.linear.to_array(), qubo.objective.quadratic.to_array(), dimod.BINARY)
print(bqm_binary)
bqm_ising = bqm_binary.to_ising()
print("Ising Model form coefficients:")
print(bqm_ising)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import networkx as nx
import dwave_networkx as dnx
from dwave.system import DWaveCliqueSampler
sampler = DWaveCliqueSampler()
a = sampler.largest_clique_size
K_a = nx.complete_graph(a)
clique = dnx.maximum_clique(K_a, sampler = sampler)
for node in K_a.nodes :
if node not in clique:
print(f"Missing {node =}")
print(len(clique))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import networkx as nx
import dimod
import matplotlib.pyplot as plt
import dwave_networkx as dnx
from dwave.embedding import pegasus
import neal, dwave.system
# Define target Pegasus Graph
M = 16 # Defines number of qubits in Pegasus graph : 24M(M-1)
P_M = dnx.pegasus_graph(M, data = True) # allow the use of pegasus indizes
# Define source complete graph
a = 12*(M-1) # See section 3.1 in Next Generation Topologies White Paper
K_a = nx.complete_graph(a)
a
# Embedding K_a into P_M
embedding = pegasus.find_clique_embedding(K_a, target_graph=P_M)
"""
Alternative:
from minorminer import find_embedding
# Embedding K_a into P_M
timeout = 60
tries = 50
embedding = find_embedding(K_a, P_M, timeout = timeout, tries = tries)
"""
if embedding:
print("Found Embedding")
print(f"P_a has : Nodes {P_M.number_of_nodes()} Connections {P_M.number_of_edges()}")
from collections import Counter
degree_ct = Counter()
for node, degree in dict(P_M.degree()).items():
degree_ct[degree] += 1
degree_ct
chain_ct = Counter()
for node, chainlist in embedding.items():
chain_ct[len(chainlist)] += 1
print(f"The embedding has {len(embedding.keys())} nodes")
chain_ct
structured_sampler = dimod.StructureComposite(neal.SimulatedAnnealingSampler(), P_M.nodes, P_M.edges)
sampler = dwave.system.FixedEmbeddingComposite(structured_sampler, embedding = embedding)
num_reads = 500
max_clique_size_avg = 0
for i in range(num_reads):
max_clique_size_avg += dnx.clique_number(K_a, sampler=sampler)
max_clique_size_avg = max_clique_size_avg / num_reads
# to run this line 95 in clique.py (dwave-networkx - algorithms) must be commented out
# the decorator checks if sampler is properly implemented can be skipped...
print(f'Found {max_clique_size_avg = }. We wanted {a}. So {a - max_clique_size_avg :.4} are missing')
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import itertools
import matplotlib.pyplot as plt
import networkx as nx
from dwave.system import DWaveSampler, FixedEmbeddingComposite
import dwave_networkx as dnx
import dimod
from minorminer import find_embedding
from random_lp.lp_random_gen import RandomLP
var = 3
cstr = 3
multiple = 1
penalty = 1
lp_bin = RandomLP.create_random_binary_prog("test_" + str(0), cstr, var, multiple=multiple, penalty=penalty)
qp = lp_bin.qubo
lp_bin.complexity()
bqm = dimod.AdjVectorBQM(qp.objective.linear.to_array(),
qp.objective.quadratic.to_dict(),
qp.objective.constant,
vartype=dimod.BINARY)
G = bqm.to_networkx_graph()
labels = {}
variables, constraints = [], []
for key, value in qp.variables_index.items():
if 'slack' in key:
label = ''
constraints.append(value)
else:
label = key[1:]
variables.append(value)
labels[value] = label
var_edges, cstr_edges = G.subgraph(variables).edges, G.subgraph(constraints).edges
options = {"node_size": 600, "alpha": 0.9}
plt.figure(1, figsize=(12,12))
#pos = nx.circular_layout(G)
pos = nx.spring_layout(G, k=0.2, iterations=15, seed=1)
# k controls the distance between the nodes and varies between 0 and 1
# iterations is the number of times simulated annealing is run
# default k =0.1 and iterations=50
# draw each component individually ?
nx.draw_networkx_nodes(G, pos, nodelist=variables, node_color="r", **options)
nx.draw_networkx_nodes(G, pos, nodelist=constraints, node_color="b", **options)
nx.draw_networkx_edges(G, pos, width=1.0, alpha=0.5)
nx.draw_networkx_edges(
G,
pos,
edgelist=var_edges,
width=3,
alpha=0.5,
edge_color="r",
)
nx.draw_networkx_edges(
G,
pos,
edgelist=cstr_edges,
width=2,
alpha=0.5,
edge_color="b",
)
nx.draw_networkx_labels(G, pos, labels, font_size=10)
plt.axis("off")
plt.show()
P_16 = dnx.pegasus_graph(16)
embedding = find_embedding(G, P_16, timeout=60, tries=50)
P_16_sub = P_16.subgraph(list(itertools.chain(*embedding.values())))
P_16_labels = {}
P_16_constraints = []
P_16_variables = []
P_16_chains = []
for key, value in embedding.items():
for node in value:
if key in constraints:
P_16_constraints.append(node)
else:
P_16_variables.append(node)
P_16_labels[node] = labels[key]
if len(value) > 1:
P_16_chains.append(value)
P_16_var_edges, P_16_cstr_edges = P_16_sub.subgraph(P_16_variables).edges, P_16_sub.subgraph(P_16_constraints).edges
options = {"node_size": 300, "alpha": 0.9}
plt.figure(2, figsize=(12,12))
pos = dnx.pegasus_layout(P_16_sub)
nx.draw_networkx_nodes(P_16_sub, pos, nodelist=P_16_variables, node_color="r", **options)
nx.draw_networkx_nodes(P_16_sub, pos, nodelist=P_16_constraints, node_color="b", **options)
nx.draw_networkx_edges(P_16_sub, pos, width=1.0, alpha=0.5)
nx.draw_networkx_edges(
P_16_sub,
pos,
edgelist=P_16_var_edges,
width=3,
alpha=0.5,
edge_color="r",
)
nx.draw_networkx_edges(
P_16_sub,
pos,
edgelist=P_16_cstr_edges,
width=2,
alpha=0.5,
edge_color="b",
)
nx.draw_networkx_edges(
P_16_sub,
pos,
edgelist=P_16_chains,
width=4,
alpha=0.5,
edge_color="g",
)
nx.draw_networkx_labels(P_16_sub, pos, P_16_labels, font_size=10)
plt.axis("off")
plt.show()
structured_sampler = dimod.StructureComposite(DWaveSampler(), P_16.nodes, P_16.edges)
sampler = FixedEmbeddingComposite(structured_sampler, embedding=embedding)
res = sampler.sample(bqm, label="embedding_of_random_lp", num_reads=100)
res.to_pandas_dataframe()
solution = res.first.sample
solution
qp.get_feasibility_info(solution.values())
from qiskit.optimization.algorithms import CplexOptimizer
cplex = CplexOptimizer()
cplex.solve(qp)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import itertools
import matplotlib.pyplot as plt
import networkx as nx
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
from dwave.system import DWaveSampler, FixedEmbeddingComposite
import dimod
import dwave_networkx as dnx
from minorminer import find_embedding
import dwave.inspector
# select quadratic program to solve
qp = QuadraticProgram()
qp.read_from_lp_file("example.lp")
qubo = QuadraticProgramToQubo().convert(qp)
bqm_binary = dimod.as_bqm(qubo.objective.linear.to_array(), qubo.objective.quadratic.to_array(), dimod.BINARY)
print(qp)
print(bqm_binary)
bqm_ising = bqm_binary.to_ising()
print("Ising Model form coefficients:")
print(bqm_ising)
sampler_exact = dimod.ExactSolver()
sampleset = sampler_exact.sample(bqm_binary)
print(sampleset)
G = bqm_binary.to_networkx_graph()
P_16 = dnx.pegasus_graph(16)
embedding = find_embedding(G, P_16, timeout=60, tries=50)
P_16_sub = P_16.subgraph(list(itertools.chain(*embedding.values())))
plt.figure(figsize=(4,4))
dnx.draw_pegasus(P_16_sub, node_size=500, node_color='g')
structured_sampler = dimod.StructureComposite(DWaveSampler(), P_16.nodes, P_16.edges)
sampler = FixedEmbeddingComposite(structured_sampler, embedding=embedding)
res = sampler.sample(bqm_binary, label="example_qubo_3", num_reads=100)
res.to_pandas_dataframe()
dwave.inspector.show(res)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
from dwave.system import DWaveSampler, EmbeddingComposite
import dimod
import dwave.inspector
# select quadratic program to solve
qp = QuadraticProgram()
qp.read_from_lp_file("example.lp")
qubo = QuadraticProgramToQubo().convert(qp)
bqm_binary = dimod.as_bqm(qubo.objective.linear.to_array(), qubo.objective.quadratic.to_array(), dimod.BINARY)
print(qp)
print(bqm_binary)
bqm_ising = bqm_binary.to_ising()
print("Ising Model form coefficients:")
print(bqm_ising)
sampler = EmbeddingComposite(DWaveSampler())
res = sampler.sample(bqm_binary, label="example_qubo_3_1024", num_reads=1024)
res.to_pandas_dataframe()
dwave.inspector.show(res) # this is a good looking one
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from pyqubo import Binary
x_0, x_1, x_2 = (Binary('x_'+str(i)) for i in range(3))
linear_obj = - x_0 - x_2
quadratic_obj = - x_0 + x_0*x_2 + x_1 - 2*x_1*x_2
linear_cstr = 8*(x_1 - x_2)**2
qubo_bqm = (linear_obj + quadratic_obj + linear_cstr).compile().to_bqm()
print(qubo)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from collections import Counter
import matplotlib.pyplot as plt
import networkx as nx
import dwave_networkx as dnx
from dwave.embedding import pegasus
import dwave.system
pegasus_2 = dnx.pegasus_graph(2) # complete P_2
unit_cell_nodes = [8, 9, 10, 11, 36, 37, 38, 39]
odd_edges = [(node, node+1) for node in pegasus_2 if not node%2] # odd couplers
pegasus_k44 = dnx.pegasus_graph(2, node_list=unit_cell_nodes)
pegasus_k44_odd = dnx.pegasus_graph(2,node_list=unit_cell_nodes, edge_list=odd_edges)
pegasus_connections = dnx.pegasus_graph(2, edge_list=pegasus_2.edges(unit_cell_nodes))
pegasus_connections_odd = dnx.pegasus_graph(2, edge_list=odd_edges)
fig, ax = plt.subplots(1, 2, figsize=(16,8))
dnx.draw_pegasus(pegasus_k44, ax=ax[0], node_size=500, node_color='g', crosses=True)
dnx.draw_pegasus(pegasus_k44_odd, ax=ax[0], node_size=500, node_color='g', edge_color='r', width=3, crosses=True)
ax[0].set_title('Unit Cell', fontsize=18)
dnx.draw_pegasus(pegasus_2, ax=ax[1], node_size=150, node_color='b', crosses=True)
dnx.draw_pegasus(pegasus_connections_odd, ax=ax[1], node_size=150, node_color='b', edge_color='r', width=5, crosses=True)
dnx.draw_pegasus(pegasus_connections, ax=ax[1], node_size=100, node_color='cyan', edge_color='g',crosses=True)
dnx.draw_pegasus(pegasus_k44, ax=ax[1], node_size=150, node_color='g', crosses=True)
ax[1].set_title('Pegasus P2', fontsize=18)
plt.show()
# Define target Pegasus Graph
M = 16 # Defines number of qubits in Pegasus graph : 24M(M-1)
P_M = dnx.pegasus_graph(M, data = True) # allow the use of pegasus indizes
print(f"P 16: Nodes {P_M.number_of_nodes()} Connections {P_M.number_of_edges()}")
degree_ct = Counter()
for node, degree in dict(P_M.degree()).items():
degree_ct[degree] += 1
print("Degree to number of nodes: ", degree_ct)
# Embedding K_a into P_M
# Define source complete graph
a = 12*(M-1) # See section 3.1 in Next Generation Topologies White Paper
K_a = nx.complete_graph(a)
chain_ct = Counter()
print(f"complete graph of size {a=}")
embedding = pegasus.find_clique_embedding(K_a, target_graph=P_M) # heuristic search
if embedding:
print("Found Embedding")
for node, chainlist in embedding.items():
chain_ct[len(chainlist)] += 1
print(f"The embedding has {len(embedding.keys())} nodes")
print("Length of chains to number of logical qubits: ", chain_ct)
sampler = dwave.system.DWaveSampler()
print(f"Sampler with {sampler.properties['topology']['type']} topology and processor {sampler.properties['chip_id']}.")
print(f"Has default annealing time {sampler.properties['default_annealing_time']} "
+ f"and range {sampler.properties['annealing_time_range']} in microseconds")
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import dwavebinarycsp
import dimod
import neal
import numpy as np
from dwavebinarycsp.core.constraint import Constraint
from dwave.system import DWaveSampler, EmbeddingComposite
A = np.array([[1,1,1,1,1],
[2,2,2,2,2],
[0,1,2,3,4],
[2,1,4,1,0],
[0,1,0,1,0]])
b = np.array([2, 4, 3, 5, 1])
solution = {'x0':0, 'x1':1,'x2':1,'x3':0,'x4':0 }
no_solution = {'x0':0, 'x1':1,'x2':1,'x3':1,'x4':1 }
m, n = A.shape
vartype = dimod.Vartype.BINARY
csp = dwavebinarycsp.ConstraintSatisfactionProblem(vartype)
x = tuple(['x' + str(j) for j in range(n)])
def make_f(i): # avoid late binding of i in for loop
return lambda *z : (sum(A[i,j]*z[j] for j in range(n)) == b[i])
for v in x:
csp.add_variable(v)
for i in range(m):
constraint = Constraint.from_func(make_f(i),x,vartype)
csp.add_constraint(constraint)
def printAndGetTestResults(sampler, bqm):
sampleset = sampler.sample(bqm)
print("Sampling by ", sampler)
for sample, energy in sampleset.data(['sample', 'energy']):
isValid = csp.check(sample)
print(sample, isValid, energy)
if not isValid : return sampleset
bqm = dwavebinarycsp.stitch(csp)
samplers = {"BruteForce" : dimod.ExactSolver() , "Neal" : neal.SimulatedAnnealingSampler()}
samplesets = {s: printAndGetTestResults(samplers[s],bqm) for s in samplers.keys()}
sampler = EmbeddingComposite(DWaveSampler())
sampleset = sampler.sample(bqm,num_reads = 100)
sampleset.to_pandas_dataframe()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import dimod
import numpy as np
import dwave.system
A = np.array([[0,1,2,3,4,1],
[2,1,4,1,0,2],
[1,1,1,1,0,3],
[1,5,2,3,4,1]])
m, n = A.shape
vartype = dimod.Vartype.BINARY
c = np.array([1,2,1,3,1,4])
b = np.array([1, 3, 2, 6])
# Set up linear and quadratic coefficients
L = c.T - 2 * np.matmul(b.T,A)
Q = np.matmul(A.T,A)
offset = b.T.dot(b)
bqm = dimod.as_bqm(L, Q, offset, vartype)
sampler = dwave.system.DWaveCliqueSampler()
sampleset = sampler.sample(bqm,num_reads = 2000)
sampleset.to_pandas_dataframe()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import dimod
import neal
import numpy as np
from dwave.system import DWaveSampler, EmbeddingComposite
A = np.array([[0,1,2,3,4,1],
[2,1,4,1,0,2],
[1,1,1,1,0,3],
[1,5,2,3,4,1]])
m, n = A.shape
vartype = dimod.Vartype.BINARY
c = np.array([1,2,1,3,1,4])
b = np.array([1, 3, 2, 6])
# Set up linear and quadratic coefficients
L = c.T - 2 * np.matmul(b.T,A)
Q = np.matmul(A.T,A)
offset = b.T.dot(b)
bqm = dimod.as_bqm(L, Q, offset, vartype)
print(L)
print(bqm.linear)
print(Q + np.diag(L))
exactSolver = dimod.ExactSolver()
sim = neal.SimulatedAnnealingSampler()
num_reads = 500
exactSet = exactSolver.sample(bqm)
simSet = sim.sample(bqm, num_reads = num_reads)
print(exactSet.first)
print(simSet.to_pandas_dataframe()) # why is num_occurrences not counted up ?
sampler = EmbeddingComposite(DWaveSampler())
sampleset = sampler.sample(bqm,num_reads = num_reads)
sampleset.to_pandas_dataframe()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from qiskit.optimization import QuadraticProgram
from qiskit.optimization.algorithms import MinimumEigenOptimizer
from dwave.plugins.qiskit import DWaveMinimumEigensolver
import numpy as np
A = np.array([[0,1,2,3,4,1],
[2,1,4,1,0,2],
[1,1,1,1,0,3],
[1,5,2,3,4,1]])
m, n = A.shape
c = np.array([1,2,1,3,1,4])
b = np.array([1, 3, 2, 6])
model = QuadraticProgram("Binary Test")
# add variables
x = [model.binary_var('x'+str(j)) for j in range(n)]
# add linear constraints
for i in range(m):
model.linear_constraint(linear=A[i], sense='==', rhs=b[i], name='A'+str(i)+'eq'+'b'+str(i))
# add linear objective function
model.minimize(linear = c)
print(model.export_as_lp_string())
# Use D-Wave QPU as a minimum eigen solver
# See https://github.com/dwavesystems/dwave-qiskit-plugin
dwave_solver = DWaveMinimumEigensolver()
optimizer = MinimumEigenOptimizer(dwave_solver)
result = optimizer.solve(model)
print(result)
result.min_eigen_solver_result.sampleset.to_pandas_dataframe()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from qiskit.optimization import QuadraticProgram
from qiskit.optimization.algorithms import MinimumEigenOptimizer
from dwave.plugins.qiskit import DWaveMinimumEigensolver
from dwave.system import DWaveCliqueSampler, LeapHybridSampler
import numpy as np
A = np.array([[0,1,2,3,4,1],
[2,1,4,1,0,2],
[1,5,2,3,1,1],
[0,0,1,2,2,0]])
m, n = A.shape
c = np.array([-1,2,-2,2,1,1])
b = np.array([6,8,5,2])
solution = np.array([2,0,0,0,1,2])
print(all(A.dot(solution) == b))
model = QuadraticProgram("Integer Test")
lowerbound = 0
upperbound = 7
# add variables
x = [model.integer_var(lowerbound = lowerbound, upperbound = upperbound, name = 'x'+str(j)) for j in range(n)]
# add linear constraints
for i in range(m):
model.linear_constraint(linear=A[i], sense='==', rhs=b[i], name='A'+str(i)+'eq'+'b'+str(i))
# add linear objective function
model.minimize(linear = c)
print(model.export_as_lp_string())
# Use D-Wave QPU as a minimum eigen solver
# See https://github.com/dwavesystems/dwave-qiskit-plugin
num_reads = 1000
cliqueSampler = DWaveCliqueSampler()
dwave_solver_clique = DWaveMinimumEigensolver(sampler = cliqueSampler, num_reads = num_reads)
optimizer = MinimumEigenOptimizer(dwave_solver_clique)
result = optimizer.solve(model) # Problem ID : f684f451-2f9d-4ebd-ad84-983ac989838b
print(result)
result.min_eigen_solver_result.sampleset.to_pandas_dataframe()
dwave_solver_hybrid = DWaveMinimumEigensolver(sampler = LeapHybridSampler())
optimizer = MinimumEigenOptimizer(dwave_solver_hybrid)
result = optimizer.solve(model) # Problem ID : cef4cc6d-8686-4491-8eb7-3fdbba3b7ec2
print(result)
result.min_eigen_solver_result.sampleset.to_pandas_dataframe()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from qiskit.optimization import QuadraticProgram
from docplex.mp.advmodel import AdvModel
from docplex.mp.model_reader import ModelReader
from qiskit.optimization.algorithms import MinimumEigenOptimizer
from dwave.plugins.qiskit import DWaveMinimumEigensolver
from dwave.system import DWaveCliqueSampler, LeapHybridSampler
import numpy as np
model = ModelReader.read(filename='BURKARDT_DATA/BINARY/reid.lp',model_name = "Test_Bin_reid", model_class=AdvModel)
qp = QuadraticProgram()
qp.from_docplex(model)
dwave_solver_hybrid = DWaveMinimumEigensolver(sampler = LeapHybridSampler())
optimizer = MinimumEigenOptimizer(dwave_solver_hybrid)
result = optimizer.solve(qp) # Problem ID : 8f677f6a-7c23-481c-ad1e-e2887cc8758f
result
print(qp.export_as_lp_string())
# Use D-Wave QPU as a minimum eigen solver
# See https://github.com/dwavesystems/dwave-qiskit-plugin
num_reads = 1000
cliqueSampler = DWaveCliqueSampler()
dwave_solver_clique = DWaveMinimumEigensolver(sampler = cliqueSampler, num_reads = num_reads)
optimizer = MinimumEigenOptimizer(dwave_solver_clique)
result = optimizer.solve(qp) # Problem ID : 74108957-e013-40d5-a7ff-e88c9c552ab2
result
result.min_eigen_solver_result.sampleset.to_pandas_dataframe()
model = ModelReader.read(filename='BURKARDT_DATA/BINARY/two_by_four.lp',model_name = "Test_Bin_16", model_class=AdvModel)
qp = QuadraticProgram()
qp.from_docplex(model)
optimizer_hybrid = MinimumEigenOptimizer(dwave_solver_hybrid)
result = optimizer_hybrid.solve(qp) # Problem ID : 1270f318-2655-4417-a2de-5daf6c4e017a
result
result = optimizer.solve(qp) # Problem ID : 93df81b0-9ca4-450e-a921-edf22bd6b5ee
result
result.min_eigen_solver_result.sampleset.to_pandas_dataframe()
model.solve()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from qiskit.optimization import QuadraticProgram
from docplex.mp.advmodel import AdvModel
from docplex.mp.model_reader import ModelReader
from qiskit.optimization.algorithms import MinimumEigenOptimizer
from dwave.plugins.qiskit import DWaveMinimumEigensolver
from dwave.system import DWaveCliqueSampler, LeapHybridSampler
import numpy as np
model = ModelReader.read(filename='QPLIB_DATA/QPLIB_3834.lp',model_name = "Test_QPLIB_Small", model_class=AdvModel)
qp = QuadraticProgram()
qp.from_docplex(model)
dwave_solver_hybrid = DWaveMinimumEigensolver(sampler = LeapHybridSampler())
optimizer = MinimumEigenOptimizer(dwave_solver_hybrid)
result = optimizer.solve(qp) # Problem ID : 46e887a7-d787-4307-8443-c6d7c6b454a4
result
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from dwave.system import DWaveCliqueSampler, LeapHybridSampler
from helpers import *
qps = createModelsFromDir('BURKARDT_DATA/INT/')
for qp in qps.values():
print(qp.model.solve())
solvers = [createSolver(LeapHybridSampler()), createSolver(DWaveCliqueSampler(),1000)]
results = {}
for qp_name in qps.keys():
print(qp_name)
qp_name = "testprob"
results[qp_name] = [optimizer.solve(qps[qp_name]) for optimizer in solvers]
# problem ids :
# Leap db6c6b80-8882-4636-9879-a18c3b57c980
# Advantage system 0b80397c-22a2-41e1-9dce-2c6cffca3ff3
for res in results[qp_name]:
print(res)
qp_name = "three_vars_quadratic"
results[qp_name] = [optimizer.solve(qps[qp_name]) for optimizer in solvers]
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from collections import OrderedDict
import time
import os
import logging
from qiskit.optimization.algorithms import CplexOptimizer
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from dwave.system import DWaveCliqueSampler, LeapHybridSampler
from random_lp.lp_random_gen import create_models
from utilities.helpers import create_dwave_meo
TEST_DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/"
RES_DIR = 'RESULTS' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/"
os.makedirs(RES_DIR, exist_ok=True)
TEST_DIR
logger = logging.getLogger()
logger.setLevel(logging.INFO)
qps = create_models(TEST_DIR)
# init Optimizers
cplex = CplexOptimizer()
hybrid = create_dwave_meo(LeapHybridSampler())
clique = create_dwave_meo(DWaveCliqueSampler())
dwave_auto = create_dwave_meo()
results = OrderedDict()
for qp_name, qp in qps.items() :
print(qp_name)
print("number of qubits: ", qp.qubo.get_num_vars())
output_file_handler = logging.FileHandler(filename=RES_DIR + qp.name + ".log")
logger.addHandler(output_file_handler)
if qp.qubo.get_num_vars() > clique.min_eigen_solver.sampler.largest_clique_size:
dwave = dwave_auto
else:
dwave = clique
with open(RES_DIR + qp.name + '.res', 'w') as file:
file.write(str("Start " + qp.name + "\n " + str(qp.qubo.get_num_vars()) + " qubits needed"))
file.write("\n Leap: \n")
logger.info("\n Leap: \n ")
res_classic = cplex.solve(qp)
res_hybrid = hybrid.solve(qp)
logger.info(str(res_hybrid.min_eigen_solver_result.sampleset.info))
if res_hybrid.status != OptimizationResultStatus.SUCCESS:
file.write("No solution found with DWave Hybrid Sampler Leap.")
file.write("\n CPLEX:\n")
file.write(str(res_classic))
break
else:
print("Leap successful!")
if res_hybrid.fval == res_classic.fval:
file.write("\n Leap found optimal solution\n")
else:
print("\n optimal value Leap "+str(res_hybrid.fval) + " , cplex:"+ str(res_classic.fval))
file.write("\n Leap: \n")
file.write(str(res_hybrid))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
file.write("\n DWave Quantum: \n")
logger.info("\n DWave Quantum: \n ")
try:
res_quantum = dwave.solve(qp)
problem_id = str(res_quantum.min_eigen_solver_result.sampleset.info['problem_id'])
logger.info("\n problem id " + problem_id)
file.write("\n problem id: " + problem_id)
if res_quantum.status != OptimizationResultStatus.SUCCESS:
print("Dwave quantum solver found no solution.")
file.write("\n No solution found with DWave Quantum Solver \n")
else:
print("Dwave Quantum successful!")
if res_quantum.fval == res_classic.fval:
file.write("\n DWave quantum solver found optimal solution\n")
else:
print("\n optimal value Dwave quantum "+str(res_quantum.fval) + " , cplex:"+ str(res_classic.fval))
file.write("\n DWave quantum solver:\n")
file.write(str(res_quantum))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
except Exception as ex:
print(qp_name, " ", type(ex).__name__, " : ", ex)
file.write("\n DWave Solver produced an exception:\n")
file.write(str(ex))
logger.removeHandler(output_file_handler)
# see Class SubstituteVariables in https://qiskit.org/documentation/_modules/qiskit/optimization/problems/quadratic_program.html#QuadraticProgram
# for logger warning constraint A0_leb0 is infeasible due to substitution
# Afterwards a check for feasability of substituted solution is done to set OptimizationResultStatus
res_hybrid.min_eigen_solver_result.sampleset
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from collections import OrderedDict
import time
import os
import logging
from qiskit.optimization.algorithms import CplexOptimizer
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from dwave.system import LeapHybridSampler
from random_lp.lp_random_gen import create_models
from utilities.helpers import create_dwave_meo
TEST_DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/SPARSE/"
RES_DIR = 'RESULTS' + "/" + time.strftime("%d_%m_%Y") + "/SPARSE/"
os.makedirs(RES_DIR, exist_ok=True)
TEST_DIR
logger = logging.getLogger()
logger.setLevel(logging.INFO)
qps = create_models(TEST_DIR)
# init Optimizers
cplex = CplexOptimizer()
hybrid = create_dwave_meo(LeapHybridSampler())
dwave = create_dwave_meo(num_reads=1000)
results = OrderedDict()
count_fail_hybrid, count_fail_dwave = 0, 0
for qp_name, qp in qps.items() :
print(qp_name)
print("number of qubits: ", qp.qubo.get_num_vars())
output_file_handler = logging.FileHandler(filename=RES_DIR + qp.name + ".log")
logger.addHandler(output_file_handler)
with open(RES_DIR + qp.name + '.res', 'w') as file:
file.write(str("Start " + qp.name + "\n " + str(qp.qubo.get_num_vars()) + " qubits needed"))
file.write("\n Leap: \n")
logger.info("\n Leap: \n ")
res_classic = cplex.solve(qp)
res_hybrid = hybrid.solve(qp)
problem_id = str(res_hybrid.min_eigen_solver_result.sampleset.info['problem_id'])
logger.info("\n problem id " + problem_id)
file.write("\n problem id: " + problem_id)
if res_hybrid.status != OptimizationResultStatus.SUCCESS:
file.write("\n No solution found with DWave Hybrid Sampler Leap.\n")
file.write("\n CPLEX:\n")
file.write(str(res_classic))
count_fail_hybrid = count_fail_hybrid + 1
if count_fail_hybrid > 2 :
break
else:
print("Leap successful!")
count_fail_hybrid = 0
if res_hybrid.fval == res_classic.fval:
file.write("\n Leap found optimal solution\n")
else:
print("\n optimal value Leap "+str(res_hybrid.fval) + " , cplex:"+ str(res_classic.fval))
file.write("\n Leap: \n")
file.write(str(res_hybrid))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
if count_fail_dwave <= 2:
file.write("\n DWave Quantum: \n")
logger.info("\n DWave Quantum: \n ")
try:
res_quantum = dwave.solve(qp)
problem_id = str(res_quantum.min_eigen_solver_result.sampleset.info['problem_id'])
logger.info("\n problem id " + problem_id)
file.write("\n problem id: " + problem_id)
if res_quantum.status != OptimizationResultStatus.SUCCESS:
print("Dwave quantum solver found no solution.")
file.write("\n No solution found with DWave Quantum Solver \n")
count_fail_dwave = count_fail_dwave + 1
if count_fail_dwave == 3:
file.write("\n Stop testing DWave Quantum Solver \n")
else:
print("Dwave Quantum successful!")
count_fail_dwave = 0
if res_quantum.fval == res_classic.fval:
file.write("\n DWave quantum solver found optimal solution\n")
else:
print("\n optimal value Dwave quantum "+str(res_quantum.fval) + " , cplex:"+ str(res_classic.fval))
file.write("\n DWave quantum solver:\n")
file.write(str(res_quantum))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
except Exception as ex:
print(qp_name, " ", type(ex).__name__, " : ", ex)
file.write("\n DWave Solver produced an exception:\n")
file.write(str(ex))
logger.removeHandler(output_file_handler)
# see Class SubstituteVariables in https://qiskit.org/documentation/_modules/qiskit/optimization/problems/quadratic_program.html#QuadraticProgram
# for logger warning constraint A0_leb0 is infeasible due to substitution
# Afterwards a check for feasability of substituted solution is done to set OptimizationResultStatus
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time
from dwave.system import DWaveCliqueSampler, LeapHybridSampler
from qiskit.optimization.algorithms import CplexOptimizer
from random_lp.lp_random_gen import create_models
from utilities.helpers import create_dwave_meo
DIR = 'TEST_DATA' + "/" + "14_03_2021" + "/DENSE/"
# select linear program to solve
qps = create_models(DIR)
qp = qps['test_10']
# init Optimizers
cplex = CplexOptimizer()
leap = create_dwave_meo(LeapHybridSampler())
clique = create_dwave_meo(DWaveCliqueSampler())
# solve classically
cplex.solve(qp)
# solve hybrid
res_leap = leap.solve(qp)
res_leap
# solve quantum
res_clique = clique.solve(qp)
res_clique
qp.to_docplex().prettyprint()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time
from dwave.system import LeapHybridSampler
from qiskit.optimization.algorithms import CplexOptimizer
from random_lp.lp_random_gen import create_models
from utilities.helpers import create_dwave_meo
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/SPARSE/"
DIR
# select linear program to solve
qps = create_models(DIR)
qp = qps['test_38']
# init Optimizers
cplex = CplexOptimizer()
leap = create_dwave_meo(LeapHybridSampler())
dwave_auto = create_dwave_meo()
# solve classically
cplex.solve(qp)
# solve hybrid
leap.min_eigen_solver.sampler.set_label("leap_test_38")
res_leap = leap.solve(qp)
res_leap
# solve quantum
dwave_auto.min_eigen_solver.sampler.set_label("dwave_test_38")
res_dwave = dwave_auto.solve(qp)
res_dwave
qp.to_docplex().prettyprint()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import os
import shutil
import time
from random_lp.random_qp import RandomQP
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
def getPath(filename = "", directory = ""):
return DIR + "/" + directory + "/" + filename
DIR
shutil.rmtree(getPath(directory = "DENSE"), ignore_errors=True)
os.makedirs(getPath(directory = "DENSE"))
# create dense random binary quadratic Programs
# start with 10 variables and 5 constraints
max_qubits = 200
var = 10
while True:
cstr = int(var / 2)
qp_bin = RandomQP.create_random_binary_prog("test_dense_" + str(var), cstr, var)
qp_bin.write_to_lp_file(getPath(qp_bin.name, directory = "DENSE"))
if qp_bin.complexity() > max_qubits :
print(var)
break
if qp_bin.complexity() > 100 :
var = var + 10
else:
var = var + 5
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import os
import shutil
import time
from docplex.mp.error_handler import DOcplexException
from random_lp.random_qp import RandomQP
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
def getPath(filename = "", directory = ""):
return DIR + "/" + directory + "/" + filename
DIR
shutil.rmtree(getPath(directory = "SPARSE"), ignore_errors=True)
os.makedirs(getPath(directory = "SPARSE"))
# create sparse random binary quadratic Programs
# 3 variables with 2 constraints each
max_qubits = 290
var = 3
cstr = 2
multiple = 10
while True:
qp_bin = RandomQP.create_random_binary_prog("test_sparse_" + str(multiple), cstr, var, multiple=multiple)
try:
qp_bin.write_to_lp_file(getPath(qp_bin.name, directory = "SPARSE"))
if qp_bin.complexity() > max_qubits :
print(multiple)
break
if qp_bin.complexity() > 100 :
multiple = multiple + 6
else:
multiple = multiple + 3
except DOcplexException as ex:
print(ex)
print(qp_bin.complexity())
qp_bin.qubo.to_docplex().prettyprint()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from collections import OrderedDict
import time
import os
import logging, warnings
from qiskit.optimization.algorithms import CplexOptimizer
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from dwave.system import DWaveCliqueSampler, LeapHybridSampler
from random_lp.lp_random_gen import create_models
from utilities.helpers import create_dwave_meo
TEST_DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/"
RES_DIR = 'RESULTS' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/"
os.makedirs(RES_DIR, exist_ok=True)
TEST_DIR
logger = logging.getLogger()
logger.setLevel(logging.INFO)
warnings.filterwarnings("ignore", category=DeprecationWarning)
qps = create_models(TEST_DIR)
# init Optimizers
cplex = CplexOptimizer()
hybrid = create_dwave_meo(LeapHybridSampler())
clique = create_dwave_meo(DWaveCliqueSampler(), num_reads=4096)
dwave_auto = create_dwave_meo(num_reads=4096)
results = OrderedDict()
count_fail_hybrid, count_fail_dwave = 0, 0
for qp_name, qp in qps.items() :
print(qp_name)
print("number of qubits: ", qp.qubo.get_num_vars())
output_file_handler = logging.FileHandler(filename=RES_DIR + qp.name + ".log")
logger.addHandler(output_file_handler)
# set problem labels
for solver, label in zip([hybrid, clique, dwave_auto], ["hybrid_", "clique_", "auto_emb_"]):
solver.min_eigen_solver.sampler.set_label(label + qp_name + "_" + str(qp.complexity()))
if qp.qubo.get_num_vars() > clique.min_eigen_solver.sampler.child.largest_clique_size:
dwave = dwave_auto
else:
dwave = clique
with open(RES_DIR + qp.name + '.res', 'w') as file:
file.write(str("Start " + qp.name + "\n " + str(qp.qubo.get_num_vars()) + " qubits needed"))
file.write("\n Leap: \n")
logger.info("\n Leap: \n ")
res_classic = cplex.solve(qp)
res_hybrid = hybrid.solve(qp)
logger.info(str(res_hybrid.min_eigen_solver_result.sampleset.info))
if res_hybrid.status != OptimizationResultStatus.SUCCESS:
file.write("No solution found with DWave Hybrid Sampler Leap.")
file.write("\n CPLEX:\n")
file.write(str(res_classic))
count_fail_hybrid = count_fail_hybrid + 1
if count_fail_hybrid > 2 :
break
else:
print("Leap successful!")
count_fail_hybrid = 0
if res_hybrid.fval == res_classic.fval:
file.write("\n Leap found optimal solution\n")
else:
print("\n optimal value Leap "+str(res_hybrid.fval) + " , cplex:"+ str(res_classic.fval))
file.write("\n Leap: \n")
file.write(str(res_hybrid))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
if count_fail_dwave <= 2:
file.write("\n DWave Quantum: \n")
logger.info("\n DWave Quantum: \n ")
try:
res_quantum = dwave.solve(qp)
problem_id = str(res_quantum.min_eigen_solver_result.sampleset.info['problem_id'])
logger.info("\n problem id " + problem_id)
file.write("\n problem id: " + problem_id)
if res_quantum.status != OptimizationResultStatus.SUCCESS:
print("Dwave quantum solver found no solution.")
file.write("\n No solution found with DWave Quantum Solver \n")
count_fail_dwave = count_fail_dwave + 1
if count_fail_dwave == 3:
file.write("\n Stop testing DWave Quantum Solver \n")
else:
print("Dwave Quantum successful!")
count_fail_dwave = 0
if res_quantum.fval == res_classic.fval:
file.write("\n DWave quantum solver found optimal solution\n")
else:
print("\n optimal value Dwave quantum "+str(res_quantum.fval) + " , cplex:"+ str(res_classic.fval))
file.write("\n DWave quantum solver:\n")
file.write(str(res_quantum))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
except Exception as ex:
print(qp_name, " ", type(ex).__name__, " : ", ex)
file.write("\n DWave Solver produced an exception:\n")
file.write(str(ex))
logger.removeHandler(output_file_handler)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from collections import OrderedDict
import time
import os
import logging, warnings
from qiskit.optimization.algorithms import CplexOptimizer
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from dwave.system import LeapHybridSampler
from random_lp.lp_random_gen import create_models
from utilities.helpers import create_dwave_meo
TEST_DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/SPARSE/"
RES_DIR = 'RESULTS' + "/" + time.strftime("%d_%m_%Y") + "/SPARSE/"
os.makedirs(RES_DIR, exist_ok=True)
TEST_DIR
logger = logging.getLogger()
logger.setLevel(logging.INFO)
warnings.filterwarnings("ignore", category=DeprecationWarning)
qps = create_models(TEST_DIR)
# init Optimizers
cplex = CplexOptimizer()
hybrid = create_dwave_meo(LeapHybridSampler())
dwave = create_dwave_meo(num_reads=4096)
results = OrderedDict()
count_fail_hybrid, count_fail_dwave = 0, 0
for qp_name, qp in qps.items() :
print(qp_name)
print("number of qubits: ", qp.qubo.get_num_vars())
output_file_handler = logging.FileHandler(filename=RES_DIR + qp.name + ".log")
logger.addHandler(output_file_handler)
# set problem labels
for solver, label in zip([hybrid, dwave], ["hybrid_", "auto_emb_"]):
solver.min_eigen_solver.sampler.set_label(label + qp_name + "_" + str(qp.complexity()))
with open(RES_DIR + qp.name + '.res', 'w') as file:
file.write(str("Start " + qp.name + "\n " + str(qp.qubo.get_num_vars()) + " qubits needed"))
file.write("\n Leap: \n")
logger.info("\n Leap: \n ")
res_classic = cplex.solve(qp)
res_hybrid = hybrid.solve(qp)
problem_id = str(res_hybrid.min_eigen_solver_result.sampleset.info['problem_id'])
logger.info("\n problem id " + problem_id)
file.write("\n problem id: " + problem_id)
if res_hybrid.status != OptimizationResultStatus.SUCCESS:
file.write("\n No solution found with DWave Hybrid Sampler Leap.\n")
file.write("\n CPLEX:\n")
file.write(str(res_classic))
count_fail_hybrid = count_fail_hybrid + 1
if count_fail_hybrid > 2 :
break
else:
print("Leap successful!")
count_fail_hybrid = 0
if res_hybrid.fval == res_classic.fval:
file.write("\n Leap found optimal solution\n")
else:
print("\n optimal value Leap "+str(res_hybrid.fval) + " , cplex:"+ str(res_classic.fval))
file.write("\n Leap: \n")
file.write(str(res_hybrid))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
if count_fail_dwave <= 2:
file.write("\n DWave Quantum: \n")
logger.info("\n DWave Quantum: \n ")
try:
res_quantum = dwave.solve(qp)
problem_id = str(res_quantum.min_eigen_solver_result.sampleset.info['problem_id'])
logger.info("\n problem id " + problem_id)
file.write("\n problem id: " + problem_id)
if res_quantum.status != OptimizationResultStatus.SUCCESS:
print("Dwave quantum solver found no solution.")
file.write("\n No solution found with DWave Quantum Solver \n")
count_fail_dwave = count_fail_dwave + 1
if count_fail_dwave == 3:
file.write("\n Stop testing DWave Quantum Solver \n")
else:
print("Dwave Quantum successful!")
count_fail_dwave = 0
if res_quantum.fval == res_classic.fval:
file.write("\n DWave quantum solver found optimal solution\n")
else:
print("\n optimal value Dwave quantum "+str(res_quantum.fval) + " , cplex:"+ str(res_classic.fval))
file.write("\n DWave quantum solver:\n")
file.write(str(res_quantum))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
except Exception as ex:
print(qp_name, " ", type(ex).__name__, " : ", ex)
file.write("\n DWave Solver produced an exception:\n")
file.write(str(ex))
logger.removeHandler(output_file_handler)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import os
import shutil
import time
from random_lp.random_qp import RandomQP
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
def getPath(filename = "", directory = ""):
return DIR + "/" + directory + "/" + filename
DIR
shutil.rmtree(getPath(directory = "DENSE"), ignore_errors=True)
os.makedirs(getPath(directory = "DENSE"))
# create dense random binary quadratic Programs
# start with 10 variables and 5 constraints
max_qubits = 200
var = 10
while True:
cstr = int(var / 2)
qp_bin = RandomQP.create_random_binary_prog("test_dense_" + str(var), cstr, var)
qp_bin.write_to_lp_file(getPath(qp_bin.name, directory = "DENSE"))
if qp_bin.complexity() > max_qubits :
print(var)
break
if qp_bin.complexity() > 100 :
var = var + 10
else:
var = var + 5
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import os
import shutil
import time
from docplex.mp.error_handler import DOcplexException
from random_lp.random_qp import RandomQP
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
def getPath(filename = "", directory = ""):
return DIR + "/" + directory + "/" + filename
DIR
shutil.rmtree(getPath(directory = "SPARSE"), ignore_errors=True)
os.makedirs(getPath(directory = "SPARSE"))
# create sparse random binary quadratic Programs
# 3 variables with 2 constraints each
max_qubits = 290
var = 3
cstr = 2
multiple = 10
while True:
qp_bin = RandomQP.create_random_binary_prog("test_sparse_" + str(multiple), cstr, var, multiple=multiple)
try:
qp_bin.write_to_lp_file(getPath(qp_bin.name, directory = "SPARSE"))
if qp_bin.complexity() > max_qubits :
print(multiple)
break
if qp_bin.complexity() > 100 :
multiple = multiple + 6
else:
multiple = multiple + 3
except DOcplexException as ex:
print(ex)
print(qp_bin.complexity())
qp_bin.qubo.to_docplex().prettyprint()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import numpy as np
from linear_solver_float import LinearSolverFloat
# set floating point accuracy
R = 4
# first example
M = np.array([[1/2,3/2],
[3/2,1/2]])
Y_1 = np.array([1,0])
Y_2 = np.array([0,1])
M_inv = np.linalg.inv(M)
M_inv.dot(Y_1), M_inv.dot(Y_2)
num_reads = 1000
lsf = LinearSolverFloat(M,Y_1,R=R,num_reads=num_reads)
sampleset = lsf.sample()
sampleset.to_pandas_dataframe()
min_occurence = num_reads / 20
solutions = lsf.getSolutions(min_occurence)
list(solutions)
lsf.setY(Y_2)
lsf.sample() # 050d68cf-b1d7-4ba5-acdb-688140e88c15
list(lsf.getSolutions(min_occurence))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import numpy as np
from linear_solver_float import LinearSolverFloat
# set floating point accuracy
R = 3
# first example
M = np.array([[3,2],
[2,1]])
Y_1 = np.array([1,1])
Y_2 = np.array([-1/2,-1/2])
M_inv = np.linalg.inv(M)
M_inv.dot(Y_1), M_inv.dot(Y_2)
num_reads = 1000
lsf = LinearSolverFloat(M,Y_1,R=R,num_reads=num_reads)
sampleset = lsf.sample()
sampleset.to_pandas_dataframe()
min_occurence = num_reads / 20
solutions = lsf.getSolutions(min_occurence)
list(solutions)
lsf.setY(Y_2)
lsf.sample() #3cc3c704-57e3-4238-bf4a-3368e3f1a326
list(lsf.getSolutions(min_occurence))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import numpy as np
from linear_solver_float import LinearSolverFloat
# set floating point accuracy
R = 5
M = np.array([[-4,6,1],
[8,-11,-2],
[-3,4,1]]) # Test 2(f)
Y = np.array([0.75,-1.25,0.25])
M_inv = np.linalg.inv(M)
M_inv.dot(Y)
num_reads = 1000
min_occurrence = 2
lsf = LinearSolverFloat(M,Y,R=R,num_reads=num_reads, min_occurrence = min_occurrence)
sampleset = lsf.sample()
sampleset.to_pandas_dataframe()
solutions = lsf.getSolutions(10)
list(solutions)
M = np.array([[6.1795,11.8207,2.0583],
[15.673,-7.56717,-3.852],
[-5.6457,7.96872,15.9418]]) #Test 2(g)
Y = np.array([1.4114,0.9972,9.9643])
M_inv = np.linalg.inv(M)
M_inv.dot(Y)
M.dot(np.array([0,0.25,-0.75]))
lsf = LinearSolverFloat(M,Y,R=R,num_reads=num_reads, min_occurrence = min_occurrence)
sampleset = lsf.sample()
sampleset.to_pandas_dataframe()
list(lsf.getSolutions(10))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import dimod
import networkx as nx
import dwave_networkx as dnx
from dwave.embedding import pegasus
import neal, dwave.system
import numpy as np
A_int = np.array([[0,1,2,3,4,1],
[2,1,4,1,0,2],
[1,5,2,3,1,1]])
m, n = A_int.shape
vartype = dimod.Vartype.BINARY
c_int = np.array([1,2,1,-3,1,-1])
b = np.array([7,8,5])
print(A_int.dot(np.array([1,0,0,0,1,3])))
def get_binary_form(c,bits):
c_bin = []
for c_j in c:
c_bin += [c_j * 2**i for i in range(0,bits)]
return np.array(c_bin)
# represent each x_i as 3 bits to the power of 2
bits = 3
# Set Penalty for Constraints aprox solution
P = max(abs(c_int))*3
c = get_binary_form(c_int,bits)
print(c)
A = np.array([get_binary_form(A_int[i], bits) for i in range(0,m)])
print(A)
# Set up linear and quadratic coefficients
L = c.T - P * 2 * np.matmul(b.T,A)
Q = P * np.matmul(A.T,A)
offset = P * b.T.dot(b)
bqm = dimod.as_bqm(L, Q, offset, vartype)
def construct_x(sample, bits):
x=[]
for k in range(0,len(sample.keys()),bits):
x += [sum(sample[k+j]* 2**j for j in range(0,bits))]
return np.array(x)
def testSamples(sampleset, bits):
print("Minimum Energy Level found in:",sampleset.first)
X = []
for sample, energy, in sampleset.data(fields=['sample', 'energy']):
x = construct_x(sample,bits)
if all(A_int.dot(x)[i] == b[i] for i in range(0,m)) :
X += [(x,energy)]
return X
# Define target Pegasus Graph
M = 16 # Defines number of qubits in Pegasus graph : 24M(M-1)
P_M = dnx.pegasus_graph(M, data = True) # allow the use of pegasus indizes
# Define source complete graph
a = len(bqm.variables)
K_a = nx.complete_graph(a)
# Embedding K_a into P_M
embedding = pegasus.find_clique_embedding(K_a, target_graph=P_M)
sampler = dwave.system.FixedEmbeddingComposite(dwave.system.DWaveSampler(), embedding = embedding)
sampler.child.properties['num_qubits']
sampleset = sampler.sample(bqm,num_reads = 2000)
sampleset.to_pandas_dataframe()
solutions_real = testSamples(sampleset, bits)
solutions_unique = { str(x) : energy for x, energy in solutions_real}
for x in solutions_unique.keys() :
print("Found solution {} with Energy Level {}".format(x,solutions_unique[x]))
a = len(bqm.variables)
embedding = pegasus.find_clique_embedding(a,m = a)
sampler = dwave.system.FixedEmbeddingComposite(dwave.system.DWaveSampler(), embedding = embedding)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import dimod
import neal
import numpy as np
from dwave.system import DWaveSampler, EmbeddingComposite, DWaveCliqueSampler
A_int = np.array([[0,1,2,3,4,1],
[2,1,4,1,0,2],
[1,5,2,3,1,1]])
m, n = A_int.shape
vartype = dimod.Vartype.BINARY
c_int = np.array([1,2,1,-3,1,-1])
b = np.array([7,8,5])
print(A_int.dot(np.array([1,0,0,0,1,3])))
def get_binary_form(c,bits):
c_bin = []
for c_j in c:
c_bin += [c_j * 2**i for i in range(0,bits)]
return np.array(c_bin)
# represent each x_i as 3 bits to the power of 2
bits = 3
# Set Penalty for Constraints aprox solution
P = max(abs(c_int))*3
c = get_binary_form(c_int,bits)
print(c)
A = np.array([get_binary_form(A_int[i], bits) for i in range(0,m)])
print(A)
# Set up linear and quadratic coefficients
L = c.T - P * 2 * np.matmul(b.T,A)
Q = P * np.matmul(A.T,A)
offset = P * b.T.dot(b)
bqm = dimod.as_bqm(L, Q, offset, vartype)
exactSolver = dimod.ExactSolver()
sim = neal.SimulatedAnnealingSampler()
num_reads = 2500
exactSet = exactSolver.sample(bqm)
simSet = sim.sample(bqm, num_reads = num_reads)
def construct_x(sample, bits):
x=[]
for k in range(0,len(sample.keys()),bits):
x += [sum(sample[k+j]* 2**j for j in range(0,bits))]
return np.array(x)
def testSamples(sampleset, bits):
print("Minimum Energy Level found in:",sampleset.first)
X = []
for sample, energy, in sampleset.data(fields=['sample', 'energy']):
x = construct_x(sample,bits)
if all(A_int.dot(x)[i] == b[i] for i in range(0,m)) :
X += [(x,energy)]
return X
solutions_exact = testSamples(exactSet, bits)
for x, energy in solutions_exact :
print("Found solution {} with Energy Level {}".format(x,energy))
solutions_neal = testSamples(simSet, bits)
solutions_unique = { str(x) : energy for x, energy in solutions_neal}
solutions_count = {x:0 for x in solutions_unique.keys()}
for x,energy in solutions_neal:
solutions_count[str(x)]+=1
for x in solutions_unique.keys() :
print("Found solution {} {} times with Energy Level {}".format(x,solutions_count[x],solutions_unique[x]))
samplerComposite = EmbeddingComposite(DWaveSampler())
sampleset = samplerComposite.sample(bqm,num_reads = num_reads) # a7cb9757-6989-43d2-9e06-914c9e947727
sampleset.to_pandas_dataframe()
solutions_real = testSamples(sampleset, bits)
solutions_unique = { str(x) : energy for x, energy in solutions_real}
for x in solutions_unique.keys() :
print("Found solution {} with Energy Level {}".format(x,solutions_unique[x]))
samplerClique = DWaveCliqueSampler()
sampleset = samplerClique.sample(bqm,num_reads = num_reads) # ecebd686-0b4e-47c2-9087-b5e234d79d89
sampleset.to_pandas_dataframe()
solutions_real = testSamples(sampleset, bits)
solutions_unique = { str(x) : energy for x, energy in solutions_real}
for x in solutions_unique.keys() :
print("Found solution {} with Energy Level {}".format(x,solutions_unique[x]))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import dimod
import neal
import numpy as np
from dwave.system import DWaveSampler, EmbeddingComposite, DWaveCliqueSampler
A_int = np.array([[0,1,2,3,4,1],
[2,1,4,1,0,2],
[1,5,2,3,1,1],
[0,0,1,2,2,0]])
m, n = A_int.shape
vartype = dimod.Vartype.BINARY
c_int = np.array([-1,2,-2,2,1,1])
b = np.array([6,8,5,2])
print(A_int.dot(np.array([2,0,0,0,1,2])))
def get_binary_form(c,bits):
c_bin = []
for c_j in c:
c_bin += [c_j * 2**i for i in range(0,bits)]
return np.array(c_bin)
# represent each x_i as 2 bits to the power of 2
bits = 2
# Set Penalty for Constraints aprox solution
P = max(abs(c_int))*4
c = get_binary_form(c_int,bits)
print(c)
A = np.array([get_binary_form(A_int[i], bits) for i in range(0,m)])
print(A)
# Set up linear and quadratic coefficients
L = c.T - P * 2 * np.matmul(b.T,A)
Q = P * np.matmul(A.T,A)
offset = P * b.T.dot(b) -1
bqm = dimod.as_bqm(L, Q, offset, vartype)
exactSolver = dimod.ExactSolver()
sim = neal.SimulatedAnnealingSampler()
num_reads = 2500
exactSet = exactSolver.sample(bqm)
simSet = sim.sample(bqm, num_reads = num_reads)
def construct_x(sample, bits):
x=[]
for k in range(0,len(sample.keys()),bits):
x += [sum(sample[k+j]* 2**j for j in range(0,bits))]
return np.array(x)
def testSamples(sampleset, bits):
print("Minimum Energy Level found in:",sampleset.first)
X = []
for sample, energy, in sampleset.data(fields=['sample', 'energy']):
x = construct_x(sample,bits)
if all(A_int.dot(x)[i] == b[i] for i in range(0,m)) :
X += [(x,energy)]
return X
solutions_exact = testSamples(exactSet, bits)
for x, energy in solutions_exact :
print("Found solution {} with Energy Level {}".format(x,energy))
solutions_neal = testSamples(simSet, bits)
solutions_unique = { str(x) : energy for x, energy in solutions_neal}
solutions_count = {x:0 for x in solutions_unique.keys()}
for x,energy in solutions_neal:
solutions_count[str(x)]+=1
for x in solutions_unique.keys() :
print("Found solution {} {} times with Energy Level {}".format(x,solutions_count[x],solutions_unique[x]))
i=0
for sample, energy in exactSet.data(['sample','energy']):
print(sample,energy)
i+=1
if i==5: break
samplerComposite = EmbeddingComposite(DWaveSampler())
sampleset = samplerComposite.sample(bqm,num_reads = num_reads) # b2529319-cbc7-461c-a9c6-e4d2576b4a25
sampleset.to_pandas_dataframe()
solutions_real = testSamples(sampleset, bits)
solutions_unique = { str(x) : energy for x, energy in solutions_real}
for x in solutions_unique.keys() :
print("Found solution {} with Energy Level {}".format(x,solutions_unique[x]))
samplerClique = DWaveCliqueSampler()
sampleset = samplerClique.sample(bqm,num_reads = num_reads) # 9263c4dc-9701-462a-bfad-d990ca722c1f
sampleset.to_pandas_dataframe()
solutions_real = testSamples(sampleset, bits)
solutions_unique = { str(x) : energy for x, energy in solutions_real}
for x in solutions_unique.keys() :
print("Found solution {} with Energy Level {}".format(x,solutions_unique[x]))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from mip import Model, BINARY, xsum, OptimizationStatus # CONTINUOUS, INTEGER
import numpy as np
from itertools import permutations
A = np.array([[1,1,1,1,1],
[2,2,2,2,2],
[0,1,2,3,4],
[2,1,4,1,0],
[0,1,0,1,0]])
var_type = BINARY
max_gap = 0.05
max_seconds=10
def createModelAndCheck(A, b, var_type, max_gap, max_seconds):
n,m = A.shape
model = Model()
x = [model.add_var(var_type=var_type) for i in range(n)]
for i in range(m):
A_i = A[i]
b_i = b[i]
model += xsum(A_i[j]*x[j] for j in range(n)) == b_i
model.max_gap = max_gap
status = model.optimize(max_seconds=max_seconds)
if status != OptimizationStatus.INFEASIBLE:
print("Found b: ", b)
if status == OptimizationStatus.OPTIMAL:
print('optimal solution cost {} found'.format(model.objective_value))
elif status == OptimizationStatus.FEASIBLE:
print('sol.cost {} found, best possible: {}'.format(model.objective_value, model.objective_bound))
elif status == OptimizationStatus.NO_SOLUTION_FOUND:
print('no feasible solution found, lower bound is: {}'.format(model.objective_bound))
if status == OptimizationStatus.OPTIMAL or status == OptimizationStatus.FEASIBLE:
print('solution:')
for v in model.vars:
if abs(v.x) > 1e-6: # only printing non-zeros
print('{} : {}'.format(v.name, v.x))
brute_force_b = list(permutations([0,1,2,3,4,5,6,7,8],5))
for b in brute_force_b:
createModelAndCheck(A, np.array(b), var_type, max_gap, max_seconds)
A.dot(np.array([0,1,1,0,0]))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from mip import Model, INTEGER, xsum, OptimizationStatus, minimize
import numpy as np
from itertools import permutations
A = np.array([[0,1,2,3,4,1],
[2,1,4,1,0,2],
[1,5,2,3,1,1]])
var_type = INTEGER
max_gap = 0.05
max_seconds=10
c = np.array([1,2,1,-3,1,-1])
m, n = A.shape
def createModelAndCheck(A, b, var_type, max_gap, max_seconds):
m, n = A.shape
model = Model()
x = [model.add_var(var_type=var_type) for j in range(n)]
for i in range(m):
A_i = A[i]
b_i = b[i]
model += xsum(A_i[j]*x[j] for j in range(n)) == b_i
model.objective = minimize(xsum(c[j]*x[j] for j in range(n)))
model.max_gap = max_gap
status = model.optimize(max_seconds=max_seconds)
"""
if status != OptimizationStatus.INFEASIBLE:
print("Found b: ", b)
if status == OptimizationStatus.OPTIMAL:
print('optimal solution cost {} found'.format(model.objective_value))
elif status == OptimizationStatus.FEASIBLE:
print('sol.cost {} found, best possible: {}'.format(model.objective_value, model.objective_bound))
elif status == OptimizationStatus.NO_SOLUTION_FOUND:
print('no feasible solution found, lower bound is: {}'.format(model.objective_bound))
"""
if status == OptimizationStatus.OPTIMAL:# or status == OptimizationStatus.FEASIBLE:
print('solution:')
for v in model.vars:
if abs(v.x) > 1e-6: # only printing non-zeros
print('{} : {}'.format(v.name, v.x))
return model
else:
return None
brute_force_b = list(permutations([0,1,2,3,4,5,6,7,8],3))
goodB = []
for b in brute_force_b:
model = createModelAndCheck(A, np.array(b), var_type, max_gap, max_seconds)
if model is not None:
count = 0
good = False
for v in model.vars:
if abs(v.x) > 1e-6:
count += 1
if abs(v.x) > 1: good = True
if count > 2 and good:
goodB +=[b]
print(goodB)
for b in goodB :
createModelAndCheck(A, np.array(b), var_type, max_gap, max_seconds)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from mip import Model, INTEGER, xsum, OptimizationStatus, minimize
import numpy as np
from itertools import permutations
A = np.array([[0,1,2,3,4,1],
[2,1,4,1,0,2],
[1,5,2,3,1,1],
[0,0,1,2,2,0]])
var_type = INTEGER
max_gap = 0.05
max_seconds=10
c = np.array([-1,2,-2,2,1,1])
m, n = A.shape
def createModelAndCheck(A, b, var_type, max_gap, max_seconds):
m, n = A.shape
model = Model()
x = [model.add_var(var_type=var_type) for j in range(n)]
for i in range(m):
A_i = A[i]
b_i = b[i]
model += xsum(A_i[j]*x[j] for j in range(n)) == b_i
model.objective = minimize(xsum(c[j]*x[j] for j in range(n)))
model.max_gap = max_gap
status = model.optimize(max_seconds=max_seconds)
"""
if status != OptimizationStatus.INFEASIBLE:
print("Found b: ", b)
if status == OptimizationStatus.OPTIMAL:
print('optimal solution cost {} found'.format(model.objective_value))
elif status == OptimizationStatus.FEASIBLE:
print('sol.cost {} found, best possible: {}'.format(model.objective_value, model.objective_bound))
elif status == OptimizationStatus.NO_SOLUTION_FOUND:
print('no feasible solution found, lower bound is: {}'.format(model.objective_bound))
"""
if status == OptimizationStatus.OPTIMAL:# or status == OptimizationStatus.FEASIBLE:
print('solution:')
for v in model.vars:
if abs(v.x) > 1e-6: # only printing non-zeros
print('{} : {}'.format(v.name, v.x))
return model
else:
return None
brute_force_b = list(permutations([0,1,2,3,4,5,6,7,8],m))
goodB = []
for b in brute_force_b:
model = createModelAndCheck(A, np.array(b), var_type, max_gap, max_seconds)
if model is not None:
count = 0
good = 0
for v in model.vars:
if abs(v.x) > 1e-6:
count += 1
if abs(v.x) > 1: good += 1
if count > 2 and good > 1:
goodB +=[b]
print(goodB)
for b in goodB :
createModelAndCheck(A, np.array(b), var_type, max_gap, max_seconds)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time, os, logging, warnings
from qiskit_optimization.algorithms import CplexOptimizer
warnings.filterwarnings("ignore", category=DeprecationWarning)
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from dwave.system import DWaveCliqueSampler
from utilities.helpers import create_dwave_meo, create_quadratic_programs_from_paths
TEST_DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/"
RES_DIR = 'RESULTS' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/"
os.makedirs(RES_DIR, exist_ok=True)
TEST_DIR
# select linear programs to solve
qps = create_quadratic_programs_from_paths(TEST_DIR, True)
# init Optimizers
cplex = CplexOptimizer()
dwave = create_dwave_meo(DWaveCliqueSampler(), num_reads=4096)
prelabel = "clique_dense_"
logger = logging.getLogger()
logger.setLevel(logging.INFO)
warnings.filterwarnings("ignore", category=DeprecationWarning)
count_fail_dwave = 0
for qp_name, qp in qps.items() :
print(qp_name)
print("number of qubits: ", qp.get_num_vars())
output_file_handler = logging.FileHandler(filename=RES_DIR + qp.name + ".log")
logger.addHandler(output_file_handler)
# set problem label
dwave.min_eigen_solver.sampler.set_label(prelabel + qp_name + "_" + str(qp.get_num_vars()))
with open(RES_DIR + qp.name + '.res', 'w') as file:
file.write(str("Start " + qp.name + "\n " + str(qp.get_num_vars()) + " qubits needed"))
file.write("\n DWave Quantum: \n")
logger.info("\n DWave Quantum: \n ")
try:
res_classic = cplex.solve(qp)
res_quantum = dwave.solve(qp)
problem_id = str(res_quantum.min_eigen_solver_result.sampleset.info['problem_id'])
logger.info("\n problem id " + problem_id)
file.write("\n problem id: " + problem_id)
if res_quantum.status != OptimizationResultStatus.SUCCESS:
print("Dwave quantum solver found no solution.")
file.write("\n No solution found with DWave Quantum Solver \n")
count_fail_dwave = count_fail_dwave + 1
if count_fail_dwave == 3:
file.write("\n Stop testing DWave Quantum Solver \n")
break
else:
print("Dwave Quantum successful!")
count_fail_dwave = 0
if res_quantum.fval == res_classic.fval:
file.write("\n DWave quantum solver found optimal solution\n")
else:
print("\n optimal value Dwave quantum "+str(res_quantum.fval) \
+ " , cplex:"+ str(res_classic.fval))
file.write("\n DWave quantum solver:\n")
file.write(str(res_quantum))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
except Exception as ex:
print(qp_name, " ", type(ex).__name__, " : ", ex)
file.write("\n Cplex or DWave solver produced an exception:\n")
file.write(str(ex))
count_fail_dwave = count_fail_dwave + 1
if count_fail_dwave == 3:
file.write("\n Stop testing because of Exception! \n")
break
logger.removeHandler(output_file_handler)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time, os, logging, warnings
from qiskit_optimization.algorithms import CplexOptimizer
warnings.filterwarnings("ignore", category=DeprecationWarning)
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from utilities.helpers import create_dwave_meo, create_quadratic_programs_from_paths
TEST_DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/SPARSE/"
RES_DIR = 'RESULTS' + "/" + time.strftime("%d_%m_%Y") + "/SPARSE/"
os.makedirs(RES_DIR, exist_ok=True)
TEST_DIR
# select linear programs to solve
qps = create_quadratic_programs_from_paths(TEST_DIR, True)
# init Optimizers
cplex = CplexOptimizer()
dwave = create_dwave_meo(num_reads=4096)
prelabel = "auto_emb_sparse_5_"
logger = logging.getLogger()
logger.setLevel(logging.INFO)
warnings.filterwarnings("ignore", category=DeprecationWarning)
count_fail_dwave = 0
for qp_name, qp in qps.items() :
print(qp_name)
print("number of qubits: ", qp.get_num_vars())
output_file_handler = logging.FileHandler(filename=RES_DIR + qp.name + ".log")
logger.addHandler(output_file_handler)
# set problem label
dwave.min_eigen_solver.sampler.set_label(prelabel + qp_name + "_" + str(qp.get_num_vars()))
with open(RES_DIR + qp.name + '.res', 'w') as file:
file.write(str("Start " + qp.name + "\n " + str(qp.get_num_vars()) + " qubits needed"))
file.write("\n DWave Quantum: \n")
logger.info("\n DWave Quantum: \n ")
try:
res_classic = cplex.solve(qp)
res_quantum = dwave.solve(qp)
problem_id = str(res_quantum.min_eigen_solver_result.sampleset.info['problem_id'])
logger.info("\n problem id " + problem_id)
file.write("\n problem id: " + problem_id)
if res_quantum.status != OptimizationResultStatus.SUCCESS:
print("Dwave quantum solver found no solution.")
file.write("\n No solution found with DWave Quantum Solver \n")
count_fail_dwave = count_fail_dwave + 1
if count_fail_dwave == 3:
file.write("\n Stop testing DWave Quantum Solver \n")
break
else:
print("Dwave Quantum successful!")
count_fail_dwave = 0
if res_quantum.fval == res_classic.fval:
file.write("\n DWave quantum solver found optimal solution\n")
else:
print("\n optimal value Dwave quantum "+str(res_quantum.fval) \
+ " , cplex:"+ str(res_classic.fval))
file.write("\n DWave quantum solver:\n")
file.write(str(res_quantum))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
except Exception as ex:
print(qp_name, " ", type(ex).__name__, " : ", ex)
file.write("\n Cplex or DWave solver produced an exception:\n")
file.write(str(ex))
count_fail_dwave = count_fail_dwave + 1
if count_fail_dwave == 3:
file.write("\n Stop testing because of Exception! \n")
break
logger.removeHandler(output_file_handler)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time
from typing import Tuple
import dimod
from dwave.system import DWaveSampler, EmbeddingComposite, DWaveCliqueSampler
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import CplexOptimizer
from qiskit_optimization.converters import LinearEqualityToPenalty
from utilities.helpers import create_quadratic_programs_from_paths
DIR = 'TEST_DATA' + "/" + '27_04_2021'
# select linear programs to solve
qps = create_quadratic_programs_from_paths(DIR + "/DENSE/")
qp_dense = qps['test_70']
qps = create_quadratic_programs_from_paths(DIR + "/SPARSE/")
qp_sparse = qps['test_100']
# init solvers
cplex = CplexOptimizer()
dwave_dense = DWaveCliqueSampler()
dwave_sparse = EmbeddingComposite(DWaveSampler())
# solve classically
for qp in (qp_dense, qp_sparse):
print(cplex.solve(qp))
def qp_to_bqm(qp: QuadraticProgram) -> dimod.BQM:
conv = LinearEqualityToPenalty()
qubo = conv.convert(qp)
bqm = dimod.as_bqm(qubo.objective.linear.to_array(), qubo.objective.quadratic.to_array(), dimod.BINARY)
return bqm
solver_parameters = {'num_reads': 1024, 'annealing_time': 3}
def solve_bqm(sampler: dimod.Sampler, bqm: dimod.BQM):
sampleset = sampler.sample(bqm, **solver_parameters)
return sampleset
qubo_dense = qp_to_bqm(qp_dense)
sampleset_dense = solve_bqm(dwave_dense, qubo_dense)
# 44d0d592-9107-4661-a6df-3e65836c1bda
sampleset_dense.to_pandas_dataframe()
def eval_bqm_sampleset(qp: QuadraticProgram, sampleset) -> Tuple[bool, int, float]:
x = sampleset.record.sample[0]
feasible = qp.is_feasible(x)
num_occur = sampleset.record.num_occurrences[0]
energy = sampleset.record.energy[0]
return feasible, num_occur, energy
res = eval_bqm_sampleset(qp_dense, sampleset_dense)
res
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time
from dwave.system import DWaveCliqueSampler
from qiskit_optimization.algorithms import CplexOptimizer
from utilities.helpers import create_dwave_meo, create_quadratic_programs_from_paths
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
DIR
# select linear programs to solve
qps = create_quadratic_programs_from_paths(DIR + "/DENSE/", True)
qp_dense = qps['test_80']
qps = create_quadratic_programs_from_paths(DIR + "/SPARSE/", True)
qp_sparse = qps['test_100']
# init Optimizers
cplex = CplexOptimizer()
clique = create_dwave_meo(DWaveCliqueSampler())
clique.min_eigen_solver.sampler.set_label("clique_dense_80")
dwave_auto = create_dwave_meo()
dwave_auto.min_eigen_solver.sampler.set_label("dwave_sparse_100")
# solve classically
cplex.solve(qp_dense)
cplex.solve(qp_sparse)
# solve quantum clique embedding for dense problems
res_clique = clique.solve(qp_dense)
res_clique
# solve quantum: automatically searches for embedding
res_dwave = dwave_auto.solve(qp_sparse)
res_dwave
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import os, shutil, time
from random_qubo.random_qubo import RandomQubo
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
def getPath(filename = "", directory = ""):
return DIR + "/" + directory + "/" + filename
bounds = {"matrix_q_lb": -5, "matrix_q_ub": 5, "c_lb": -5, "c_ub": 5}
DIR
shutil.rmtree(DIR, ignore_errors=True)
os.makedirs(getPath(directory = "SPARSE"))
os.makedirs(getPath(directory = "DENSE"))
os.makedirs(getPath(directory = "MULTIPLE"))
os.makedirs(getPath(directory = "CPLEX"))
# create sparse random qubos
# 3 variables connected
# start with 3x1 qubits
qaoa_max_qubits = 27 # number of qubits in Falcon r5.1 processors
var = 3
multiple = 1
while True:
qp = RandomQubo.create_random_qubo("test_" + str(multiple), var, multiple=multiple, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "SPARSE"))
if qp.get_num_vars() > qaoa_max_qubits :
print(multiple)
break
multiple = multiple + 1
# create dense random qubos
# start with 3 variables
while True:
qp = RandomQubo.create_random_qubo("test_" + str(var), var, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "DENSE"))
if qp.get_num_vars() > qaoa_max_qubits :
print(var)
break
var = var + 3
# create more test data for pegasus
# instances with several times the last instance which Mumbai is able to solve
# 27 variables each
# start with 27x2 qubits
var = qaoa_max_qubits
multiples = [2, 5, 10, 20]
for multiple in multiples:
qp = RandomQubo.create_random_qubo("test_" + str(multiple), var, multiple=multiple, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "MULTIPLE"))
qp = RandomQubo.create_random_qubo("test_cplex", 100, **bounds) # used 10 for test data
qp.write_to_lp_file(getPath(qp.name, directory = "CPLEX"))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from qiskit import IBMQ
from qiskit.algorithms import QAOA
from qiskit.algorithms.optimizers import COBYLA
from qiskit.test.mock import FakeMumbai
from qiskit.utils import QuantumInstance
from qiskit.providers.aer.noise import NoiseModel
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import MinimumEigenOptimizer
def job_callback(job_id, job_status, queue_position, job):
# BUG ?
print(job_id)
print(job_status)
print(queue_position)
print(job)
problem = QuadraticProgram()
x = problem.continuous_var(name="x")
y = problem.continuous_var(name="y")
problem.maximize(linear=[2, 0], quadratic=[[-1, 2], [0, -2]])
# init IBM Q Experience Simulator
IBMQ.load_account()
backend = IBMQ.get_provider(hub="ibm-q").get_backend("simulator_statevector")
quantum_instance_kwargs = {"shots": 512, "job_callback": job_callback}
quantum_instance = QuantumInstance(backend, **quantum_instance_kwargs)
print("only quantum instance")
print(f"{quantum_instance._job_callback=}")
qaoa_mes = QAOA(quantum_instance=quantum_instance, optimizer=COBYLA(maxiter=2))
qaoa_ibmq_sim = MinimumEigenOptimizer(qaoa_mes)
print("QAOA meo no noise model")
print(f"{qaoa_ibmq_sim.min_eigen_solver.quantum_instance._job_callback=}")
device = FakeMumbai()
noise_model = NoiseModel.from_backend(device)
conf = device.configuration()
quantum_instance_kwargs_noise = {
"shots": 512,
"noise_model": noise_model,
"job_callback": job_callback,
"coupling_map": conf.coupling_map,
"basis_gates": conf.basis_gates,
}
quantum_instance_noise = QuantumInstance(backend, **quantum_instance_kwargs)
qaoa_mes_noise = QAOA(quantum_instance=quantum_instance_noise, optimizer=COBYLA(maxiter=2))
qaoa_ibmq_noise = MinimumEigenOptimizer(qaoa_mes_noise)
print("QAOA meo with noise model")
print(f"{qaoa_ibmq_noise.min_eigen_solver.quantum_instance._job_callback=}")
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from qiskit import IBMQ
import networkx as nx
from qiskit.providers.ibmq import least_busy
import matplotlib.pyplot as plt
IBMQ.load_account() # Load account from disk
IBMQ.providers() # List all available providers
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
backends = provider.backends(filters=lambda x: x.configuration().n_qubits >= 5
and not x.configuration().simulator
and x.status().operational==True)
print(f" Backend with only {least_busy(backends).status().pending_jobs} pending jobs is {least_busy(backends).name()}")
backend = provider.get_backend('ibmq_16_melbourne')
print(f" {backend.name()} currently has {backend.status().pending_jobs} pending jobs")
melbourne_conf = backend.configuration()
G = nx.Graph()
G.add_nodes_from(range(0,melbourne_conf.n_qubits))
G.add_edges_from(melbourne_conf.coupling_map)
pos = nx.kamada_kawai_layout(G)
nx.draw_networkx(G, pos, with_labels = True)
melbourne_props = backend.properties()
melbourne_props.qubits[1]
melbourne_conf.basis_gates
gates_on_qubit_1 = [gate.to_dict() for gate in melbourne_props.gates if 1 in gate.qubits]
len(gates_on_qubit_1)
for gate in gates_on_qubit_1 :
if gate['qubits'][0] == 1:
print("{} involves qubits:{} and has an error rate of {}".format(gate['gate'],gate['qubits'],melbourne_props.gate_error(gate['gate'], gate['qubits'])))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from numpy import pi
from qiskit import QuantumRegister, QuantumCircuit, execute, BasicAer
from qiskit.visualization import plot_histogram
qreg_q = QuantumRegister(3, 'q')
circuit = QuantumCircuit(qreg_q)
circuit.h(qreg_q[0])
circuit.cx(qreg_q[0], qreg_q[1])
circuit.cx(qreg_q[0], qreg_q[2])
circuit.measure_all()
circuit.draw(output='latex')
result_meas = execute(circuit, BasicAer.get_backend('qasm_simulator'))
counts = result_meas.result().get_counts()
plot_histogram(counts, figsize=(5,6), bar_labels=False, title="Probabilities")
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
import numpy as np
from qiskit.circuit.random import random_circuit
from qiskit.circuit import Parameter
from qiskit import IBMQ
from qiskit.compiler import transpile
from qiskit.converters import circuit_to_dag
from qiskit.tools.visualization import dag_drawer
IBMQ.load_account() # Load account from disk
provider = IBMQ.get_provider(hub='ibm-q')
n = 3 #number of qubits
def superpos(qc,qr):
for q in qr:
qc.h(q)
qreg_q = QuantumRegister(n, 'q')
creg_c = ClassicalRegister(n, 'c')
circuit = QuantumCircuit(qreg_q, creg_c)
paras = [Parameter('p'+str(i)) for i in range(n)]
superpos(circuit,qreg_q)
for p in paras:
circuit.rz(p,int(p.name[1:]))
algorithm = random_circuit(n,n)
circuit += algorithm
superpos(circuit,qreg_q)
circuit.measure(qreg_q,creg_c)
circuit.draw(output='mpl')
circuit_fixed = circuit.bind_parameters({p : np.pi * np.random.uniform(0, 2) for p in paras})
# note : compilation before binding has a better runtime
# transpile the circuit for backend chip
circuit_transpiled = transpile(circuit, backend=provider.get_backend('ibmq_16_melbourne'), optimization_level=3)
print('gates = ', circuit_transpiled.count_ops())
print('depth = ', circuit_transpiled.depth())
# use appropriate optimization level
for opt_lvl in range(4):
circuit_transpiled = transpile(circuit, backend=provider.get_backend('ibmq_santiago'), optimization_level=opt_lvl)
print("optimization level ",opt_lvl)
print('gates = ', circuit_transpiled.count_ops())
print('depth = ', circuit_transpiled.depth())
circuit_transpiled.draw(output = 'mpl')
dag = circuit_to_dag(circuit)
dag_drawer(dag)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from collections import Counter
import io, pydot
from PIL import Image
import networkx as nx
import retworkx as rx
from qiskit.test.mock import FakeMumbai, FakeManhattan
from qiskit.providers.aer.noise import NoiseModel
mumbai = FakeMumbai()
conf = mumbai.configuration()
props = mumbai.properties()
noise_model = NoiseModel.from_backend(mumbai)
graph = rx.PyGraph(multigraph=False)
coupling_map = [tuple(edge) for edge in conf.coupling_map]
graph.add_nodes_from([i for i in range(27)])
graph.add_edges_from_no_data(coupling_map)
circle_nodes = [12, 13, 14, 16, 19, 22, 25, 24, 23, 21, 18, 15]
neighbor_nodes = [10, 11, 20, 26, 17]
def node_attr(node):
kwargs = dict(style='filled', shape="circle", label="", fixedsize="true", width="0.3", height="0.3")
if node in circle_nodes:
kwargs.update(fillcolor='green')
elif node in neighbor_nodes:
kwargs.update(fillcolor='lightblue')
else:
kwargs.update(fillcolor='darkblue')
return kwargs
graph_attr = {"center": "true", "mode": "KK", "ratio": "0.5"}
dot_str = graph.to_dot(node_attr=node_attr, graph_attr=graph_attr)
dot = pydot.graph_from_dot_data(dot_str)[0]
png = dot.create_png(prog='neato')
Image.open(io.BytesIO(png))
print(f"Mumbai has the following gate set: {set(noise_model.basis_gates) - set(['reset'])}") # reset not physically implemented yet
num_qubits = conf.n_qubits
def calc_mean(T: callable) -> float:
""" return mean of T1 or T2 time in microseconds"""
s = sum(T(qubit) for qubit in range(num_qubits))
return s / num_qubits * 10**6
T1, T2 = map(calc_mean, (props.t1, props.t2))
print(f"Averages over all {num_qubits} qubits in µs: {T1=:.2f} {T2=:.2f}")
mean_readout = sum(props.readout_error(q) for q in range(num_qubits)) / num_qubits * 100
print(f"Average readout error is {mean_readout:.2f} %")
manhattan = FakeManhattan()
conf = manhattan.configuration()
G = nx.Graph()
G.add_nodes_from(range(0,conf.n_qubits))
G.add_edges_from(conf.coupling_map)
print(f"Manhattan Graph: Nodes {G.number_of_nodes()} Connections {G.number_of_edges()}")
degree_ct = Counter()
for node, degree in dict(G.degree()).items():
degree_ct[degree] += 1
print("Degree to number of nodes: ", degree_ct)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from qiskit import IBMQ, execute
from qiskit.providers.ibmq.managed import IBMQJobManager
from qiskit.providers.ibmq.job import job_monitor
from qiskit.circuit.random import random_circuit
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('simulator_statevector')
# list all jobs which have been executed from our provider in the past
for job in backend.jobs():
print(job.job_id())
job_monitor(job)
qc = random_circuit(num_qubits=5, depth=4, measure=True)
qc.draw(output='mpl')
job = execute(qc, backend, shots=4096, job_name="test_job_name", job_tags=["test", "job"])
job_monitor(job)
counts = job.result().get_counts(0)
counts
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import logging
from itertools import product
import networkx as nx
import matplotlib.pyplot as plt
from qiskit import IBMQ, QuantumCircuit, execute, transpile
from qiskit.test.mock import FakeMumbai as FakeDevice
from qiskit.providers.aer.noise import NoiseModel
from qiskit.visualization import plot_histogram
logging.getLogger().setLevel(logging.INFO)
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
device = FakeDevice()
noise_model = NoiseModel.from_backend(device)
conf = device.configuration()
print(conf.basis_gates)
G = nx.Graph()
G.add_nodes_from(range(0,conf.n_qubits))
G.add_edges_from(conf.coupling_map)
pos = nx.kamada_kawai_layout(G)
nx.draw_networkx(G, pos, with_labels = True)
simBackends = provider.backends(filters=lambda x: x.configuration().n_qubits >= conf.n_qubits
and x.configuration().simulator
and x.status().operational==True
and all(basis_gate in x.configuration().basis_gates
for basis_gate in conf.basis_gates if basis_gate!="reset"))
# we exclude reset because this is not physically implemented yet
simBackends
n_entangled = 4
n_pairs = 5
n_qubits = n_entangled * n_pairs
qc = QuantumCircuit(n_qubits, n_qubits)
qubits_in_superpos = [i for i in range(0,n_qubits, n_entangled)]
qubits_to_entangle = {i:[i + j for j in range(1, n_entangled)] for i in qubits_in_superpos}
for control in qubits_in_superpos:
qc.h(control)
for target in qubits_to_entangle[control]:
qc.cx(control, target)
qc.measure_all()
qc.draw(output='mpl')
circuit_transpiled = transpile(qc, backend=device, optimization_level=3)
circuit_transpiled.draw(output='mpl')
bell_states = [x * n_entangled for x in ["0", "1"]]
possible_states = ["".join(state) for state in product(bell_states, repeat=n_pairs)]
possible_states
backend = provider.get_backend('simulator_statevector')
shots = 4096
result = execute(qc, backend, shots=shots,
coupling_map=conf.coupling_map,
basis_gates=conf.basis_gates,
noise_model=noise_model).result() # took about 2 hours for problem with 26 qubits
counts = result.get_counts(0)
noise_ct = 0
for measurement, count in counts.items():
measurement = measurement[:n_qubits] # drop ancillary qubits
if measurement in possible_states:
print(f"{measurement=} : {count=}")
else:
noise_ct = noise_ct + count
print(f"{noise_ct=} valid states: {100 * (shots - noise_ct) / shots : 0.2f}%")
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.circuit.random import random_circuit
from qiskit.visualization import plot_state_qsphere
from qiskit.quantum_info.operators import Operator
def pretty_print(x):
with np.printoptions(precision=3, suppress=True):
print(x)
n = 3
circ = random_circuit(n,n)
circ.draw(output='mpl')
circ.draw(output='latex')
result_statevec_sim = execute(circ, Aer.get_backend('statevector_simulator')).result()
psi = result_statevec_sim.get_statevector(circ, decimals=3)
pretty_print(psi)
plot_state_qsphere(psi)
result_unitary_sim = execute(circ, Aer.get_backend('unitary_simulator')).result()
U = result_unitary_sim.get_unitary(circ, decimals=3)
pretty_print(U)
op = Operator(circ) # implicitly uses unitary simulator
op.dim
x = np.zeros(2**n)
x[0] = 1
pretty_print(op.data.dot(x))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import os
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.aqua.algorithms import QAOA
from qiskit.aqua.components.optimizers import COBYLA
from qiskit.optimization.algorithms import MinimumEigenOptimizer, CplexOptimizer
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from qiskit.optimization import QuadraticProgram
Q_SEED = 10598 # as used in most issues
aqua_globals.random_seed = Q_SEED
shots = 4096
# select linear program to solve
path = os.path.dirname(__file__) + "/test_8.lp"
qp = QuadraticProgram()
qp.read_from_lp_file(path)
# init classical Optimizers
optimizer = COBYLA()
cplex = CplexOptimizer()
# solve classically
print(cplex.solve(qp))
# solve qp with Minimum Eigen Optimizer QAOA
backend = BasicAer.get_backend("qasm_simulator")
quantum_instance = QuantumInstance(
backend, seed_simulator=Q_SEED, seed_transpiler=Q_SEED, shots=shots
)
# QAOA
qaoa_mes = QAOA(quantum_instance=quantum_instance, optimizer=optimizer)
qaoa = MinimumEigenOptimizer(qaoa_mes)
res = qaoa.solve(qp)
print(res)
print(qp.is_feasible(res.x))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import warnings
import numpy as np
from numpy import pi
from qiskit import IBMQ, QuantumRegister, ClassicalRegister, QuantumCircuit, execute, transpile, BasicAer
from qiskit_optimization.algorithms import CplexOptimizer
from qiskit_optimization import QuadraticProgram
from qiskit.visualization import plot_histogram
from qiskit.providers.ibmq.job import job_monitor
from qiskit.providers.ibmq import least_busy
from utilities.helpers import create_qaoa_meo
qp = QuadraticProgram()
qp.read_from_lp_file("example_5_qubits.lp")
# solve classically as reference
cplex = CplexOptimizer()
print(cplex.solve(qp))
print(qp)
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
shots = 4096
# solve qp with Minimum Eigen Optimizer QAOA and simulator
EVALUATIONS = 20
def qaoa_callback(eval_ct: int, opt_pars: np.ndarray, mean: float, stdev: float) -> None:
"""Print parameterset of last iteration."""
if eval_ct == EVALUATIONS:
print("Evaluation count reached ", eval_ct, "with pars:", opt_pars)
# Evaluation count reached 20 with pars: [-0.96598411 -0.26119604] original on ibmq_qasm_simulator
qaoa = create_qaoa_meo(max_iter=EVALUATIONS, qaoa_callback=qaoa_callback)
res = qaoa.solve(qp)
res
def create_qaoa_circuit() -> QuantumCircuit:
""" taken from IBMQ Experience Job ID 608e53f752b7af33fe34177f """
qreg_q = QuantumRegister(5, 'q')
circuit = QuantumCircuit(qreg_q)
circuit.h(qreg_q[0])
circuit.h(qreg_q[1])
circuit.cx(qreg_q[1], qreg_q[0])
circuit.rz(2.4149602828076864, qreg_q[0])
circuit.cx(qreg_q[1], qreg_q[0])
circuit.h(qreg_q[2])
circuit.cx(qreg_q[2], qreg_q[0])
circuit.rz(1.9319682262461493, qreg_q[0])
circuit.cx(qreg_q[2], qreg_q[0])
circuit.cx(qreg_q[2], qreg_q[1])
circuit.rz(-1.448976169684612, qreg_q[1])
circuit.cx(qreg_q[2], qreg_q[1])
circuit.h(qreg_q[3])
circuit.cx(qreg_q[3], qreg_q[0])
circuit.rz(1.9319682262461493, qreg_q[0])
circuit.cx(qreg_q[3], qreg_q[0])
circuit.cx(qreg_q[3], qreg_q[1])
circuit.rz(-2.4149602828076864, qreg_q[1])
circuit.cx(qreg_q[3], qreg_q[1])
circuit.cx(qreg_q[3], qreg_q[2])
circuit.rz(4.346928509053836, qreg_q[2])
circuit.cx(qreg_q[3], qreg_q[2])
circuit.h(qreg_q[4])
circuit.cx(qreg_q[4], qreg_q[0])
circuit.rz(1.448976169684612, qreg_q[0])
circuit.cx(qreg_q[4], qreg_q[0])
circuit.u3(0.5223920854580901, 1.5707963267948963, -3.4941874092818432, qreg_q[0])
circuit.cx(qreg_q[4], qreg_q[1])
circuit.rz(0.9659841131230746, qreg_q[1])
circuit.cx(qreg_q[4], qreg_q[1])
circuit.u3(0.5223920854580902, 1.5707963267948968, -0.12182015711028482, qreg_q[1])
circuit.cx(qreg_q[4], qreg_q[2])
circuit.rz(-0.9659841131230746, qreg_q[2])
circuit.cx(qreg_q[4], qreg_q[2])
circuit.u3(0.5223920854580902, 1.5707963267948966, 2.293140125697402, qreg_q[2])
circuit.cx(qreg_q[4], qreg_q[3])
circuit.rz(-0.4829920565615373, qreg_q[3])
circuit.cx(qreg_q[4], qreg_q[3])
circuit.u3(0.5223920854580901, 1.5707963267948968, 2.7847093260181426, qreg_q[3])
circuit.rx(-0.5223920854580901, qreg_q[4])
circuit.measure_all()
return circuit
warnings.filterwarnings("ignore", category=DeprecationWarning)
circuit = create_qaoa_circuit()
job = execute(circuit, BasicAer.get_backend('qasm_simulator'), shots=shots)
counts = job.result().get_counts()
plot_histogram(counts)
backend = provider.get_backend("ibmq_athens")
job = execute(circuit, backend, shots=shots, job_name="qaoa_5_real", job_tags=["qaoa", "athens"])
job_monitor(job)
counts = job.result().get_counts()
plot_histogram(counts)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import warnings
import numpy as np
from qiskit import IBMQ, execute, transpile, BasicAer
from qiskit_optimization.algorithms import CplexOptimizer
from qiskit_optimization import QuadraticProgram
from qiskit.visualization import plot_histogram
from qiskit.providers.ibmq.job import job_monitor
from utilities.helpers import create_qaoa_meo
# select linear program to solve
qp = QuadraticProgram()
qp.read_from_lp_file("example.lp")
# solve classically as reference
cplex = CplexOptimizer()
print(cplex.solve(qp))
print(qp)
# solve qp with Minimum Eigen Optimizer and QAOA
SHOTS = 1024
EVALUATIONS = 5
def qaoa_callback(eval_ct: int, opt_pars: np.ndarray, mean: float, stdev: float) -> None:
"""Print parameterset of last iteration."""
if eval_ct == EVALUATIONS:
print("Evaluation count reached ", eval_ct, "with pars:", opt_pars)
warnings.filterwarnings("ignore", category=DeprecationWarning)
qaoa = create_qaoa_meo(max_iter=EVALUATIONS, qaoa_callback=qaoa_callback, shots=SHOTS)
res = qaoa.solve(qp)
res
circuit = qaoa.min_eigen_solver.get_optimal_circuit()
circuit.measure_all()
result_meas = execute(circuit, BasicAer.get_backend('qasm_simulator'), shots=SHOTS)
counts = result_meas.result().get_counts()
plot_histogram(counts)
circuit.draw()
# to this later for belem!
for meas, count in sorted(counts.items(), key= lambda item: item[1], reverse=True):
print(meas[::-1]," : ",count) # x0, x1, x2 sorted by count
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3
and not x.configuration().simulator
and x.status().operational==True))
print(backend)
job = execute(circuit, backend, shots=shots, job_name="qaoa_3_real", job_tags=["qaoa", "least busy"])
job_monitor(job)
counts = job.result().get_counts()
plot_histogram(counts)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import warnings
import numpy as np
from numpy import pi
from matplotlib import MatplotlibDeprecationWarning
from qiskit import QuantumRegister, QuantumCircuit, execute, BasicAer
from qiskit_optimization import QuadraticProgram
from qiskit.visualization import plot_state_qsphere
from qiskit.quantum_info.operators import Operator
qreg_q = QuantumRegister(3, 'q')
qc_init = QuantumCircuit(qreg_q)
qc_init.h(qreg_q[0])
qc_init.h(qreg_q[1])
qc_init.h(qreg_q[2])
qc_init.barrier()
psi_0 = execute(qc_init, BasicAer.get_backend('statevector_simulator')).result().get_statevector(qc_init, \
decimals=3)
superpos_state = np.ones(8, dtype=complex) / np.sqrt(8)
print("Superposition state: ",np.allclose(psi_0, superpos_state, rtol=0.01))
warnings.filterwarnings("ignore", category=MatplotlibDeprecationWarning)
plot_state_qsphere(psi_0)
def pretty_print(x):
""" print with 1 decimal only """
with np.printoptions(precision=1, suppress=True):
print(x)
qc_evol = QuantumCircuit(qreg_q)
qc_evol.cx(qreg_q[1], qreg_q[0])
qc_evol.rz(-0.06942544294642758, qreg_q[0])
qc_evol.cx(qreg_q[1], qreg_q[0])
qc_evol.rz(-0.20827632883928274, qreg_q[0])
qc_evol.cx(qreg_q[2], qreg_q[1])
qc_evol.rz(1.2496579730356965, qreg_q[1])
qc_evol.cx(qreg_q[2], qreg_q[1])
qc_evol.rz(-0.20827632883928274, qreg_q[1])
qc_evol.barrier()
qc_evol.rx(0.7530122052855767, qreg_q[0])
qc_evol.rx(0.7530122052855767, qreg_q[1])
qc_evol.rx(0.7530122052855767, qreg_q[2])
U = execute(qc_evol, BasicAer.get_backend('unitary_simulator')).result().get_unitary(qc_evol, decimals=3)
pretty_print(U)
op = Operator(qc_evol) # to make it easy to multiply
psi_g = op.data.dot(psi_0)
pretty_print(psi_g)
warnings.filterwarnings("ignore", category=MatplotlibDeprecationWarning)
plot_state_qsphere(psi_g, figsize=(10,10))
qc_qaoa = qc_init.compose(qc_evol)
qc_qaoa.measure_all()
qc_qaoa.draw(output='latex') # ref to fig:circuit_ideal
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import io
import numpy as np
from numpy import pi
import pydot
from PIL import Image
import retworkx as rx
from qiskit import IBMQ, QuantumRegister, ClassicalRegister, QuantumCircuit, transpile
def create_qaoa_circuit() -> QuantumCircuit:
""" taken from IBMQ Experience """
qreg_q = QuantumRegister(3, 'q')
circuit = QuantumCircuit(qreg_q)
circuit.h(qreg_q[0])
circuit.h(qreg_q[1])
circuit.cx(qreg_q[1], qreg_q[0])
circuit.rz(-0.06942544294642758, qreg_q[0])
circuit.cx(qreg_q[1], qreg_q[0])
circuit.rz(-0.20827632883928274, qreg_q[0])
circuit.rx(0.7530122052855767, qreg_q[0])
circuit.h(qreg_q[2])
circuit.cx(qreg_q[2], qreg_q[1])
circuit.rz(1.2496579730356965, qreg_q[1])
circuit.cx(qreg_q[2], qreg_q[1])
circuit.rz(-0.20827632883928274, qreg_q[1])
circuit.rx(0.7530122052855767, qreg_q[1])
circuit.rx(0.7530122052855767, qreg_q[2])
return circuit
# transpile circuit for ibmq_belem
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
device = provider.get_backend("ibmq_belem")
conf = device.configuration()
print(conf.basis_gates)
qc = create_qaoa_circuit()
circuit_transpiled = transpile(qc, backend=device, optimization_level=3)
circuit_transpiled.draw(output='mpl')
graph = rx.PyGraph(multigraph=False)
coupling_map = [tuple(edge) for edge in conf.coupling_map]
graph.add_nodes_from([i for i in range(5)])
graph.add_edges_from_no_data(coupling_map)
circuit_nodes = [0, 1, 2]
neighbor_nodes = [3]
def node_attr(node):
kwargs = dict(style='filled', shape="circle", fontsize="14", fixedsize="true", width="0.4", height="0.4")
if node in circuit_nodes:
kwargs.update(fillcolor='green')
elif node in neighbor_nodes:
kwargs.update(fillcolor='lightblue', label="")
else:
kwargs.update(fillcolor='darkblue', label="")
return kwargs
dot_str = graph.to_dot(node_attr)
dot = pydot.graph_from_dot_data(dot_str)[0]
png = dot.create_png(prog='neato')
Image.open(io.BytesIO(png))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import io
import numpy as np
from numpy import pi
import pydot
from PIL import Image
import retworkx as rx
from qiskit import IBMQ, QuantumRegister, ClassicalRegister, QuantumCircuit, transpile
from qiskit.test.mock import FakeManhattan
def create_qaoa_circuit() -> QuantumCircuit:
""" taken from IBMQ Experience """
qreg_q = QuantumRegister(3, 'q')
circuit = QuantumCircuit(qreg_q)
circuit.h(qreg_q[0])
circuit.h(qreg_q[1])
circuit.cx(qreg_q[1], qreg_q[0])
circuit.rz(-0.06942544294642758, qreg_q[0])
circuit.cx(qreg_q[1], qreg_q[0])
circuit.rz(-0.20827632883928274, qreg_q[0])
circuit.rx(0.7530122052855767, qreg_q[0])
circuit.h(qreg_q[2])
circuit.cx(qreg_q[2], qreg_q[1])
circuit.rz(1.2496579730356965, qreg_q[1])
circuit.cx(qreg_q[2], qreg_q[1])
circuit.rz(-0.20827632883928274, qreg_q[1])
circuit.rx(0.7530122052855767, qreg_q[1])
circuit.rx(0.7530122052855767, qreg_q[2])
return circuit
# transpile circuit for ibmq_manhattan
device = FakeManhattan()
conf = device.configuration()
print(conf.basis_gates)
qc = create_qaoa_circuit()
circuit_transpiled = transpile(qc, backend=device, optimization_level=3)
circuit_transpiled.draw(output='mpl')
graph = rx.PyGraph(multigraph=False)
coupling_map = [tuple(edge) for edge in conf.coupling_map]
graph.add_nodes_from([i for i in range(65)])
graph.add_edges_from_no_data(coupling_map)
circuit_nodes = [19, 20, 21]
neighbor_nodes = [12, 18, 22, 25]
def node_attr(node):
kwargs = dict(style='filled', shape="circle", fontsize="14", fixedsize="true", width="0.4", height="0.4")
if node in circuit_nodes:
kwargs.update(fillcolor='green')
elif node in neighbor_nodes:
kwargs.update(fillcolor='lightblue', label="")
else:
kwargs.update(fillcolor='darkblue', label="")
return kwargs
dot_str = graph.to_dot(node_attr)
dot = pydot.graph_from_dot_data(dot_str)[0]
png = dot.create_png(prog='neato')
Image.open(io.BytesIO(png))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from collections import OrderedDict
import time
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.aqua.algorithms import QAOA
from qiskit.aqua.components.optimizers import COBYLA
from qiskit.optimization.algorithms import MinimumEigenOptimizer, CplexOptimizer
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from random_lp.lp_random_gen import create_models
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/" # 12.03.2021
Q_SEED = 10598 # as used in most issues
aqua_globals.random_seed = Q_SEED
shots = 4096
qps = create_models(DIR)
optimizer = COBYLA()
cplex = CplexOptimizer()
backend = BasicAer.get_backend('qasm_simulator')
max_qubits = backend.configuration().to_dict()['n_qubits']
quantum_instance = QuantumInstance(backend,
seed_simulator=Q_SEED,
seed_transpiler=Q_SEED,
shots=shots)
qaoa_mes = QAOA(quantum_instance=quantum_instance, optimizer=optimizer)
results = OrderedDict()
for qp_name, qp in qps.items() :
print(qp_name)
print("number of qubits: ", qp.qubo.get_num_vars())
if qp.qubo.get_num_vars() > max_qubits:
break
qaoa = MinimumEigenOptimizer(qaoa_mes)
res = qaoa.solve(qp)
results[qp_name] = res
if res.status == OptimizationResultStatus.SUCCESS:
print("success")
cres = cplex.solve(qp)
if res.fval != cres.fval:
print("\n optimal value QAOA "+str(res.fval) + " , cplex:"+ str(cres.fval))
# see Class SubstituteVariables in https://qiskit.org/documentation/_modules/qiskit/optimization/problems/quadratic_program.html#QuadraticProgram
# for logger warning constraint A0_leb0 is infeasible due to substitution
# Afterwards a check for feasability of substituted solution is done (line 227 in meo result class) to set OptimizationResultStatus
res_7 = results["test_7"]
print(res_7)
qps["test_7"].is_feasible(res_7.x)
qps["test_8"].is_feasible(results["test_8"].x)
qps["test_8"].to_docplex().prettyprint()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time
import numpy as np
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.aqua.algorithms import QAOA
from qiskit.aqua.components.optimizers import COBYLA
from qiskit.optimization.algorithms import MinimumEigenOptimizer, CplexOptimizer
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from random_lp.lp_random_gen import create_models
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/" # 23.04.2021
Q_SEED = 10598 # as used in most issues
aqua_globals.random_seed = Q_SEED
shots = 4096
# select linear program to solve
qps = create_models(DIR)
qp = qps['test_dense_3']
# init classical Optimizers
optimizer = COBYLA() # SLSQP is default in Class VQE
cplex = CplexOptimizer()
# solve qps with Minimum Eigen Optimizer QAOA
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend,
seed_simulator=Q_SEED,
seed_transpiler=Q_SEED,
shots=shots)
qaoa_mes = QAOA(quantum_instance=quantum_instance, optimizer=optimizer)
qaoa = MinimumEigenOptimizer(qaoa_mes)
cplex.solve(qp)
print("number of qubits: ",qp.get_num_vars())
res = qaoa.solve(qp)
res
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import os
import shutil
import time
from random_lp.lp_random_gen import RandomLP
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
def getPath(filename = "", directory = ""):
return DIR + "/" + directory + "/" + filename
DIR
shutil.rmtree(DIR, ignore_errors=True)
os.makedirs(getPath(directory = "DENSE"))
# create dense random binary Linear Programs
# we want up to 33 qubits since ibmq_qasm_simulator has 32
max_qubits = 32
var = 3
while True:
cstr = int(var / 2)
lp_bin = RandomLP.create_random_binary_prog("test_" + str(var), cstr, var)
lp_bin.write_to_lp_file(getPath(lp_bin.name, directory = "DENSE"))
if lp_bin.complexity() > max_qubits :
print(var)
break
var = var + 2
lp_bin.qubo.to_docplex().prettyprint()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time
import numpy as np
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.aqua.algorithms import QAOA
from qiskit.aqua.components.optimizers import COBYLA
from qiskit.optimization.algorithms import MinimumEigenOptimizer, CplexOptimizer
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from random_lp.lp_random_gen import create_models
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/" # 23.04.2021
Q_SEED = 10598 # as used in most issues
aqua_globals.random_seed = Q_SEED
shots = 4096
# select linear program to solve
qps = create_models(DIR)
qp = qps['test_dense_3']
# init classical Optimizers
optimizer = COBYLA() # SLSQP is default in Class VQE
cplex = CplexOptimizer()
# solve qps with Minimum Eigen Optimizer QAOA
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend,
seed_simulator=Q_SEED,
seed_transpiler=Q_SEED,
shots=shots)
qaoa_mes = QAOA(quantum_instance=quantum_instance, optimizer=optimizer)
qaoa = MinimumEigenOptimizer(qaoa_mes)
cplex.solve(qp)
print("number of qubits: ",qp.get_num_vars())
res = qaoa.solve(qp)
res
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from collections import OrderedDict
import time
import logging, warnings
from qiskit.optimization.algorithms import CplexOptimizer
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from random_lp.lp_random_gen import create_models
from utilities.helpers import create_qaoa_meo
logger = logging.getLogger()
logger.setLevel(logging.INFO)
warnings.filterwarnings("ignore", category=DeprecationWarning)
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
DIR
qps = create_models([DIR + "/DENSE/", DIR + "/SPARSE/"])
print(qps.keys())
cplex = CplexOptimizer()
qaoa = create_qaoa_meo()
max_qubits = qaoa.min_eigen_solver.quantum_instance.backend.configuration().to_dict()['n_qubits']
max_qubits
results = OrderedDict()
for qp_name, qp in qps.items() :
print(qp_name)
print("number of qubits: ", qp.qubo.get_num_vars())
if qp.qubo.get_num_vars() > max_qubits:
print("Too many qubits!")
break
res = qaoa.solve(qp)
results[qp_name] = res
if res.status == OptimizationResultStatus.SUCCESS:
print("success")
cres = cplex.solve(qp)
if res.fval != cres.fval:
print("\n optimal value QAOA "+str(res.fval) + " , cplex:"+ str(cres.fval))
else:
print(res.status)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import os, shutil, time
from random_qubo.random_qubo import RandomQubo
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
def getPath(filename = "", directory = ""):
return DIR + "/" + directory + "/" + filename
bounds = {"matrix_q_lb": -5, "matrix_q_ub": 5, "c_lb": -5, "c_ub": 5}
DIR
shutil.rmtree(DIR, ignore_errors=True)
os.makedirs(getPath(directory = "SPARSE"))
os.makedirs(getPath(directory = "DENSE"))
os.makedirs(getPath(directory = "MULTIPLE"))
os.makedirs(getPath(directory = "CPLEX"))
# create sparse random qubos
# 3 variables connected
# start with 3x1 qubits
qaoa_max_qubits = 27 # number of qubits in Falcon r5.1 processors
var = 3
multiple = 1
while True:
qp = RandomQubo.create_random_qubo("test_" + str(multiple), var, multiple=multiple, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "SPARSE"))
if qp.get_num_vars() > qaoa_max_qubits :
print(multiple)
break
multiple = multiple + 1
# create dense random qubos
# start with 3 variables
while True:
qp = RandomQubo.create_random_qubo("test_" + str(var), var, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "DENSE"))
if qp.get_num_vars() > qaoa_max_qubits :
print(var)
break
var = var + 3
# create more test data for pegasus
# instances with several times the last instance which Mumbai is able to solve
# 27 variables each
# start with 27x2 qubits
var = qaoa_max_qubits
multiples = [2, 5, 10, 20]
for multiple in multiples:
qp = RandomQubo.create_random_qubo("test_" + str(multiple), var, multiple=multiple, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "MULTIPLE"))
qp = RandomQubo.create_random_qubo("test_cplex", 100, **bounds) # used 10 for test data
qp.write_to_lp_file(getPath(qp.name, directory = "CPLEX"))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time, os, logging, warnings
import numpy as np
from qiskit import IBMQ
from qiskit.test.mock import FakeMumbai
from qiskit.providers.aer import AerSimulator
from qiskit.providers.aer.noise import NoiseModel
from qiskit_optimization.algorithms import CplexOptimizer
from qiskit_optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from utilities.helpers import create_qaoa_meo, create_quadratic_programs_from_paths
TEST_DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/"
RES_DIR = 'RESULTS' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/"
os.makedirs(RES_DIR, exist_ok=True)
TEST_DIR
logger = logging.getLogger()
max_iter = 5 # set maximum number of optimizer iterations in qaoa online simulation
def qaoa_callback(eval_ct: int, opt_pars: np.ndarray, mean: float, stdev: float) -> None:
"""Print number of iteration in QAOA and log."""
print("Evaluation count:", eval_ct)
logger.info(f"\n Evaluation count {eval_ct} with parameters {opt_pars} and mean {mean:.2f}")
if eval_ct == max_iter:
logger.info(" reached maximum number of evaluations \n")
# select linear programs to solve
qps = create_quadratic_programs_from_paths(TEST_DIR)
# init local backend simulator with noise model
device = FakeMumbai()
local = AerSimulator.from_backend(device)
noise_model = NoiseModel.from_backend(device)
conf = device.configuration()
# init IBM Q Experience Simulator
IBMQ.load_account()
ibmq = IBMQ.get_provider(hub='ibm-q').get_backend('simulator_statevector')
# init Optimizers
cplex = CplexOptimizer()
quantum_instance_kwargs = {"shots": 4096, "noise_model": noise_model, "optimization_level": 3}
qaoa_local_sim = create_qaoa_meo(backend=local, max_iter=max_iter, **quantum_instance_kwargs)
qaoa_ibmq_sim = create_qaoa_meo(backend=ibmq, coupling_map=conf.coupling_map, basis_gates=conf.basis_gates,
max_iter=max_iter, qaoa_callback=qaoa_callback, **quantum_instance_kwargs)
# set online job informations in IBM Q Experience
qaoa_ibmq_sim.min_eigen_solver.quantum_instance.backend_options["job_tags"] = ["qaoa", "dense", "mumbai"]
def set_job_name(qp):
qaoa_ibmq_sim.min_eigen_solver.quantum_instance.backend_options["job_name"] = "qaoa_dense_" \
+ qp.name + "_" + str(qp.get_num_vars())
warnings.filterwarnings("ignore", category=DeprecationWarning)
logger.setLevel(logging.INFO)
count_fail_qaoa = 0
for qp_name, qp in qps.items() :
print(qp_name)
print("number of qubits: ", qp.get_num_vars())
output_file_handler = logging.FileHandler(filename=RES_DIR + qp.name + ".log")
logger.addHandler(output_file_handler)
if qp.get_num_vars() >= 15:
set_job_name(qp)
qaoa = qaoa_ibmq_sim
logstring = "ibmq_simulator_statevector"
else:
qaoa = qaoa_local_sim
logstring = "local_qasm_simulator"
with open(RES_DIR + qp.name + '.res', 'w') as file:
file.write(str("Start " + qp.name + "\n " + str(qp.get_num_vars()) + " qubits needed"))
file.write("\n " + logstring + " \n")
logger.info("\n " + logstring + " \n")
print(logstring)
try:
res_classic = cplex.solve(qp)
res_quantum = qaoa.solve(qp)
if res_quantum.status != OptimizationResultStatus.SUCCESS:
print("QAOA minimum eigen solver found no solution.")
file.write("\n QAOA minimum eigen solver found no solution. \n")
count_fail_qaoa = count_fail_qaoa + 1
if count_fail_qaoa == 3:
file.write("\n Stop testing \n")
break
else:
print("QAOA minimum eigen solver successful!")
count_fail_qaoa = 0
if res_quantum.fval == res_classic.fval:
file.write("\n QAOA found optimal solution\n")
else:
print("\n optimal value QAOA "+str(res_quantum.fval) \
+ " , cplex:"+ str(res_classic.fval))
file.write("\n QAOA:\n")
file.write(str(res_quantum))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
except Exception as ex:
print(qp_name, " ", type(ex).__name__, " : ", ex)
file.write("\n Cplex or QAOA solver produced an exception:\n")
file.write(str(ex))
count_fail_qaoa = count_fail_qaoa + 1
if count_fail_qaoa == 3:
file.write("\n Stop testing because of Exception! \n")
break
logger.removeHandler(output_file_handler)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time, os, logging, warnings
import numpy as np
from qiskit import IBMQ
from qiskit.test.mock import FakeMumbai
from qiskit.providers.aer import AerSimulator
from qiskit.providers.aer.noise import NoiseModel
from qiskit_optimization.algorithms import CplexOptimizer
from qiskit_optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from utilities.helpers import create_qaoa_meo, create_quadratic_programs_from_paths
TEST_DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/SPARSE/"
RES_DIR = 'RESULTS' + "/" + time.strftime("%d_%m_%Y") + "/SPARSE/"
os.makedirs(RES_DIR, exist_ok=True)
TEST_DIR
logger = logging.getLogger()
max_iter = 5 # set maximum number of optimizer iterations
def qaoa_callback(eval_ct: int, opt_pars: np.ndarray, mean: float, stdev: float) -> None:
"""Print number of iteration in QAOA and log."""
print("Evaluation count:", eval_ct)
logger.info(f"\n Evaluation count {eval_ct} with parameters {opt_pars} and mean {mean:.2f}")
if eval_ct == max_iter:
logger.info(" reached maximum number of evaluations \n")
# select linear programs to solve
qps = create_quadratic_programs_from_paths(TEST_DIR)
# init local backend simulator with noise model
device = FakeMumbai()
local = AerSimulator.from_backend(device)
noise_model = NoiseModel.from_backend(device)
conf = device.configuration()
# init IBM Q Experience Simulator
IBMQ.load_account()
ibmq = IBMQ.get_provider(hub='ibm-q').get_backend('simulator_statevector')
# init Optimizers
cplex = CplexOptimizer()
quantum_instance_kwargs = {"shots": 4096, "noise_model": noise_model, "optimization_level": 3}
qaoa_local_sim = create_qaoa_meo(backend=local, max_iter=max_iter, **quantum_instance_kwargs)
qaoa_ibmq_sim = create_qaoa_meo(backend=ibmq, coupling_map=conf.coupling_map, basis_gates=conf.basis_gates,
max_iter=max_iter, qaoa_callback=qaoa_callback, **quantum_instance_kwargs)
# set online job informations in IBM Q Experience
qaoa_ibmq_sim.min_eigen_solver.quantum_instance.backend_options["job_tags"] = ["qaoa", "sparse", "mumbai"]
def set_job_name(qp):
qaoa_ibmq_sim.min_eigen_solver.quantum_instance.backend_options["job_name"] = "qaoa_sparse_5_" \
+ qp.name + "_" + str(qp.get_num_vars())
warnings.filterwarnings("ignore", category=DeprecationWarning)
logger.setLevel(logging.INFO)
count_fail_qaoa = 0
for qp_name, qp in qps.items() :
print(qp_name)
print("number of qubits: ", qp.get_num_vars())
output_file_handler = logging.FileHandler(filename=RES_DIR + qp.name + ".log")
logger.addHandler(output_file_handler)
if qp.get_num_vars() >= 15:
set_job_name(qp)
qaoa = qaoa_ibmq_sim
logstring = "ibmq_simulator_statevector"
else:
qaoa = qaoa_local_sim
logstring = "local_qasm_simulator"
with open(RES_DIR + qp.name + '.res', 'w') as file:
file.write(str("Start " + qp.name + "\n " + str(qp.get_num_vars()) + " qubits needed"))
file.write("\n " + logstring + " \n")
logger.info("\n " + logstring + " \n")
print(logstring)
try:
res_classic = cplex.solve(qp)
res_quantum = qaoa.solve(qp)
if res_quantum.status != OptimizationResultStatus.SUCCESS:
print("QAOA minimum eigen solver found no solution.")
file.write("\n QAOA minimum eigen solver found no solution. \n")
count_fail_qaoa = count_fail_qaoa + 1
if count_fail_qaoa == 3:
file.write("\n Stop testing \n")
break
else:
print("QAOA minimum eigen solver successful!")
count_fail_qaoa = 0
if res_quantum.fval == res_classic.fval:
file.write("\n QAOA found optimal solution\n")
else:
print("\n optimal value QAOA "+str(res_quantum.fval) \
+ " , cplex:"+ str(res_classic.fval))
file.write("\n QAOA:\n")
file.write(str(res_quantum))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
except Exception as ex:
print(qp_name, " ", type(ex).__name__, " : ", ex)
file.write("\n Cplex or QAOA solver produced an exception:\n")
file.write(str(ex))
count_fail_qaoa = count_fail_qaoa + 1
if count_fail_qaoa == 3:
file.write("\n Stop testing because of Exception! \n")
break
logger.removeHandler(output_file_handler)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time, warnings
import numpy as np
from qiskit import IBMQ
from qiskit.test.mock import FakeMumbai
from qiskit.providers.aer import AerSimulator
from qiskit.providers.aer.noise import NoiseModel
from qiskit_optimization.algorithms import CplexOptimizer
from utilities.helpers import create_qaoa_meo, create_quadratic_programs_from_paths
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
DIR
def job_callback(job_id, job_status, queue_position, job):
# BUG ? This is not called and not set in quantum instance (see info logging)
print(job_id)
print(job_status)
print(queue_position)
print(job)
def qaoa_callback(eval_ct: int, opt_pars: np.ndarray, mean: float, stdev: float) -> None:
"""Print number of iteration in QAOA."""
print("Evaluation count:", eval_ct)
# select linear programs to solve
qps_dense = create_quadratic_programs_from_paths(DIR + "/DENSE/")
qp_dense = qps_dense['test_3']
qps_sparse = create_quadratic_programs_from_paths(DIR + "/SPARSE/")
qp_sparse = qps_sparse['test_3']
# init local backend simulator with noise model
device = FakeMumbai()
local = AerSimulator.from_backend(device)
noise_model = NoiseModel.from_backend(device)
conf = device.configuration()
# init IBM Q Experience Simulator
IBMQ.load_account()
ibmq = IBMQ.get_provider(hub='ibm-q').get_backend('simulator_statevector')
# init Optimizers
cplex = CplexOptimizer()
quantum_instance_kwargs = {"shots": 4096, "noise_model": noise_model,
"job_callback": job_callback, "optimization_level": 3}
qaoa_local_sim = create_qaoa_meo(backend=local, **quantum_instance_kwargs)
qaoa_ibmq_sim = create_qaoa_meo(backend=ibmq, coupling_map=conf.coupling_map, basis_gates=conf.basis_gates,
max_iter=5, qaoa_callback=qaoa_callback, **quantum_instance_kwargs)
# solve classically
cplex.solve(qp_sparse)
# solve by using noise model with local qasm sim
qaoa_local_sim.solve(qp_sparse)
cplex.solve(qp_dense)
qaoa_local_sim.solve(qp_dense)
# solve by using noise model with IBM Q Experience simulator
qp_sparse = qps_sparse['test_7']
warnings.filterwarnings("ignore", category=DeprecationWarning)
qaoa_ibmq_sim.solve(qp_sparse)
cplex.solve(qp_sparse)
# solve by using noise model with IBM Q Experience simulator
qp_dense = qps_dense['test_15']
warnings.filterwarnings("ignore", category=DeprecationWarning)
qaoa_ibmq_sim.solve(qp_dense)
cplex.solve(qp_dense)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import os, shutil, time
from random_qubo.random_qubo import RandomQubo
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
def getPath(filename = "", directory = ""):
return DIR + "/" + directory + "/" + filename
bounds = {"matrix_q_lb": -5, "matrix_q_ub": 5, "c_lb": -5, "c_ub": 5}
DIR
shutil.rmtree(DIR, ignore_errors=True)
os.makedirs(getPath(directory = "SPARSE"))
os.makedirs(getPath(directory = "DENSE"))
os.makedirs(getPath(directory = "MULTIPLE"))
os.makedirs(getPath(directory = "CPLEX"))
# create sparse random qubos
# 3 variables connected
# start with 3x1 qubits
qaoa_max_qubits = 27 # number of qubits in Falcon r5.1 processors
var = 3
multiple = 1
while True:
qp = RandomQubo.create_random_qubo("test_" + str(multiple), var, multiple=multiple, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "SPARSE"))
if qp.get_num_vars() > qaoa_max_qubits :
print(multiple)
break
multiple = multiple + 1
# create dense random qubos
# start with 3 variables
while True:
qp = RandomQubo.create_random_qubo("test_" + str(var), var, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "DENSE"))
if qp.get_num_vars() > qaoa_max_qubits :
print(var)
break
var = var + 3
# create more test data for pegasus
# instances with several times the last instance which Mumbai is able to solve
# 27 variables each
# start with 27x2 qubits
var = qaoa_max_qubits
multiples = [2, 5, 10, 20]
for multiple in multiples:
qp = RandomQubo.create_random_qubo("test_" + str(multiple), var, multiple=multiple, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "MULTIPLE"))
qp = RandomQubo.create_random_qubo("test_cplex", 100, **bounds) # used 10 for test data
qp.write_to_lp_file(getPath(qp.name, directory = "CPLEX"))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time, warnings
from typing import Tuple
warnings.simplefilter("ignore")
import numpy as np
from qiskit import IBMQ
from qiskit.test.mock import FakeMumbai
from qiskit.test.mock.fake_qasm_backend import FakeQasmBackend
from qiskit.providers.aer import AerSimulator
from qiskit.providers.aer.noise import NoiseModel
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import MinimumEigenOptimizer as MEO
from qiskit_optimization.algorithms import MinimumEigenOptimizationResult as MEORes
from qiskit_optimization.algorithms import CplexOptimizer
import dimod
from dwave.system import DWaveSampler, EmbeddingComposite, DWaveCliqueSampler
from utilities.helpers import create_qaoa_meo, create_quadratic_programs_from_paths
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
DIR
# select QUBOs to solve
qps_dense = create_quadratic_programs_from_paths(DIR + "/DENSE/")
qp_dense = qps_dense['test_3']
qps_sparse = create_quadratic_programs_from_paths(DIR + "/SPARSE/")
qp_sparse = qps_sparse['test_3']
qps_multiple = create_quadratic_programs_from_paths(DIR + "/MULTIPLE/")
qp_mult = qps_multiple["test_20"]
qp_cplex = create_quadratic_programs_from_paths(DIR + "/CPLEX/")['test_cplex']
# set parameters and arguments
num_reads = 1024
classic_iters = 5
def qaoa_callback(eval_ct: int, opt_pars: np.ndarray, mean: float, stdev: float) -> None:
"""Print parameterset of last iteration."""
if eval_ct == classic_iters:
print("Evaluation count reached ", eval_ct, "with pars:", opt_pars)
device = FakeMumbai()
qaoa_kwargs = {"shots": num_reads, "noise_model": NoiseModel.from_backend(device),
"max_iter": classic_iters, "qaoa_callback": qaoa_callback, "optimization_level": 3}
dwave_parameters = {'num_reads': num_reads, 'annealing_time': 3}
def init_qaoa_optimizers(device: FakeQasmBackend) -> Tuple[MEO, MEO]:
# init local backend simulator with noise model
local = AerSimulator.from_backend(device)
qaoa_local = create_qaoa_meo(backend=local, **qaoa_kwargs)
# init IBM Q Experience Simulator
IBMQ.load_account()
ibmq = IBMQ.get_provider(hub='ibm-q').get_backend('simulator_statevector')
conf = device.configuration()
qaoa_ibmq_sim = create_qaoa_meo(backend=ibmq, coupling_map=conf.coupling_map, basis_gates=conf.basis_gates,
**qaoa_kwargs)
return qaoa_local, qaoa_ibmq_sim
# init Optimizers
cplex = CplexOptimizer()
qaoa_local_sim, qaoa_ibmq_sim = init_qaoa_optimizers(device)
dwave_dense = DWaveCliqueSampler()
dwave_sparse = EmbeddingComposite(DWaveSampler()) # TODO rename to dwave_auto
def dwave_solve_qp(sampler: dimod.Sampler, qubo: QuadraticProgram):
bqm = dimod.as_bqm(qubo.objective.linear.to_array(), qubo.objective.quadratic.to_array(), dimod.BINARY)
sampleset = sampler.sample(bqm, **dwave_parameters)
return sampleset
def eval_qaoa_result(res: MEORes) -> Tuple[float, float]:
prob = res.samples[0].probability
fval = res.samples[0].fval
return prob, fval
def eval_bqm_sampleset(sampleset) -> Tuple[float, float]:
prob = sampleset.record.num_occurrences[0] / num_reads
fval = sampleset.record.energy[0]
return prob, fval
# solve classically
for qp in (qp_dense, qp_sparse):
print(qp.name)
print(cplex.solve(qp))
# solve by using Mumbai noise model with local qasm sim
res_dense_qaoa = qaoa_local_sim.solve(qp_dense)
eval_qaoa_result(res_dense_qaoa)
# solve by using D-Wave Pegasus Advantage system
res_dense_dwave = dwave_solve_qp(dwave_dense, qp_dense)
eval_bqm_sampleset(res_dense_dwave)
qp_sparse = qps_sparse['test_8']
cplex.solve(qp_sparse)
# solve by using Mumbai noise model with IBM Q Experience simulator
warnings.filterwarnings("ignore", category=DeprecationWarning)
res_sparse_qaoa = qaoa_ibmq_sim.solve(qp_sparse)
eval_qaoa_result(res_sparse_qaoa)
cplex.solve(qp_mult) # takes just a few minutes
# solve by using D-Wave Pegasus Advantage system
res_mult_dwave = dwave_solve_qp(dwave_sparse, qp_mult)
eval_bqm_sampleset(res_mult_dwave)
start_time = time.perf_counter()
res_cplex = cplex.solve(qp_cplex)
cplex_runtime = time.perf_counter() - start_time
print(res_cplex)
cplex_runtime
start_time = time.perf_counter()
res_cplex_dwave = dwave_solve_qp(dwave_sparse, qp_cplex)
dwave_runtime = time.perf_counter() - start_time
print(eval_bqm_sampleset(res_cplex_dwave))
dwave_runtime
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import os, shutil, time
from random_qubo.random_qubo import RandomQubo
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
def getPath(filename = "", directory = ""):
return DIR + "/" + directory + "/" + filename
bounds = {"matrix_q_lb": -5, "matrix_q_ub": 5, "c_lb": -5, "c_ub": 5}
DIR
shutil.rmtree(DIR, ignore_errors=True)
os.makedirs(getPath(directory = "SPARSE"))
os.makedirs(getPath(directory = "DENSE"))
os.makedirs(getPath(directory = "MULTIPLE"))
os.makedirs(getPath(directory = "CPLEX"))
# create sparse random qubos
# 3 variables connected
# start with 3x1 qubits
qaoa_max_qubits = 27 # number of qubits in Falcon r5.1 processors
var = 3
multiple = 1
while True:
qp = RandomQubo.create_random_qubo("test_" + str(multiple), var, multiple=multiple, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "SPARSE"))
if qp.get_num_vars() > qaoa_max_qubits :
print(multiple)
break
multiple = multiple + 1
# create dense random qubos
# start with 3 variables
while True:
qp = RandomQubo.create_random_qubo("test_" + str(var), var, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "DENSE"))
if qp.get_num_vars() > qaoa_max_qubits :
print(var)
break
var = var + 3
# create more test data for pegasus
# instances with several times the last instance which Mumbai is able to solve
# 27 variables each
# start with 27x2 qubits
var = qaoa_max_qubits
multiples = [2, 5, 10, 20]
for multiple in multiples:
qp = RandomQubo.create_random_qubo("test_" + str(multiple), var, multiple=multiple, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "MULTIPLE"))
qp = RandomQubo.create_random_qubo("test_cplex", 100, **bounds) # used 10 for test data
qp.write_to_lp_file(getPath(qp.name, directory = "CPLEX"))
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from qiskit import *
from qiskit.providers.ibmq import least_busy
import numpy as np
from error_matrix import Minv, diags
from circuits import get_bin
def fix_to_full_hist(hist, ORACLE_SIZE=5):
for i in range(2**(ORACLE_SIZE-1)):
b_str = get_bin(i,ORACLE_SIZE-1)
# print(b_str)
if b_str not in hist:
hist[b_str] = 0
return hist
def correct_results(res, ORACLE_SIZE=5):
fixed_hist = fix_to_full_hist(res.get_counts())
# print(fixed_hist)
hist_vert = np.vstack(list(fixed_hist.values()))
# print(hist_vert)
error_corrected = np.matmul(Minv,hist_vert)
corrected_hist = {}
for i in range(len(error_corrected)):
cur_val = error_corrected[i]
cur_bin = get_bin(i,ORACLE_SIZE-1)
corrected_hist[cur_bin] = cur_val[0]
return fixed_hist, corrected_hist
def get_avg(accs):
return sum(accs) / len(accs)
def get_job_by_tag(TARGET_TAG, ibm_computer = ""):
if not account_loaded:
load_account()
provider = IBMQ.get_provider(hub = 'ibm-q')
# print(provider.backends())
small_devices = provider.backends(filters=lambda x: not x.configuration().simulator)
device = least_busy(small_devices)
if ibm_computer != "":
device = provider.get_backend(ibm_computer)
jobs = device.jobs(limit=100)
print(jobs)
for job in jobs:
# print(job.tags())
if len(job.tags()) > 0 and job.tags()[0] == TARGET_TAG:
return job
return None
|
https://github.com/BoxiLi/qiskit-CR-calibration
|
BoxiLi
|
import logging
from copy import deepcopy
import numpy as np
from numpy import pi
from qiskit.circuit import Gate
from qiskit import transpile
from qiskit.transpiler import InstructionProperties
from qiskit_utilities import (
save_job_data,
setup_logger,
retrieve_expdata,
get_cr_schedule,
iy_drag_calibration,
get_default_cr_params,
read_calibration_data,
iterative_cr_pulse_calibration,
create_echoed_cnot_schedule,
initilize_qiskit_dynamics_backend
)
session = None # qiskit runtime session
# Setup a logging system.
setup_logger(filename=None, level=logging.INFO, stdout=True)
logger = logging.getLogger("qiskit_utilities")
# Create a qiskit-dynamics backend with two Transmon, see fake_backend.py for detail.
# fidelity
f0 = 5.188339840468758e9
f1 = 5.079647268847252e9
# anharmonicity
a0 = -0.341931669003125e9
a1 = -0.343248404293835e9
backend = initilize_qiskit_dynamics_backend(f0, f1, a0, a1, J=0.003e9)
# Operating qubits
QUBIT_C, QUBIT_T = (0, 1)
# Compute the sampling time steps for the CR tomography experiments
if backend.name == 'DynamicsBackend':
amp = 2 * pi * 0.04
cr_times = np.arange(16*16, 1440*3, 32*4, dtype=int)
duration = 720 # Used for plotting only, not tomography.
else:
amp = get_default_cr_params(backend, QUBIT_C, QUBIT_T)[0]
duration = backend.defaults().instruction_schedule_map.get("cx", (QUBIT_C, QUBIT_T)).duration/16 * 4
cr_times = 16 * np.arange(16, duration + 16, duration//30, dtype=int)
## Use the default Gaussian shape with 28ns ramping.
gate_name = "CR-default" # This name will be used to identify the calibration
# CR drive
cr_params = {
"duration": int(duration), # only for plotting
"sigma": 64, # The ramping time is hard coded to be 2 * sigma
"amp": amp,
"angle": 0.,
}
# Target qubit compensation drive
ix_params = {
"duration": int(duration), # only for plotting
"sigma": 64,
"amp": 0.,
"angle": 0.,
}
initial_calibration_data = {
"cr_params": cr_params,
"ix_params": ix_params,
"frequency_offset": 0.,
}
get_cr_schedule((QUBIT_C, QUBIT_T), backend, cr_params=cr_params, ix_params=ix_params).draw()
iterative_cr_pulse_calibration(
(QUBIT_C, QUBIT_T),
backend,
initial_calibration_data=initial_calibration_data,
cr_times=cr_times,
session=session,
gate_name=gate_name,
verbose=True,
restart=True, # fresh start
threshold_MHz=0.015,
max_repeat=3,
shots=512,
mode="CR",
)
iy_drag_calibration((QUBIT_C, QUBIT_T), backend, gate_name, cr_times, session, verbose=True)
from qiskit_experiments.library import ProcessTomography
calibration_data = read_calibration_data(backend, "CR-default", (QUBIT_C, QUBIT_T))
custom_cnot_sched = create_echoed_cnot_schedule(backend, (QUBIT_C, QUBIT_T), calibration_data, reverse_direction=False)
# Show the custom CNOT schedule.
custom_cnot_sched.draw()
custom_cnot = Gate("custom_cnot", 2, [])
backend_tmp = deepcopy(backend)
backend_tmp.target.add_instruction(
custom_cnot,
{(QUBIT_C, QUBIT_T): InstructionProperties(calibration=custom_cnot_sched)},
name="custom_cnot",
)
qptexp = ProcessTomography(custom_cnot, physical_qubits=[QUBIT_C, QUBIT_T])
try:
basis_gates = backend.configuration().basis_gates
except AttributeError:
basis_gates = ["measure", "sx", "x", "rz"]
transpiled_circ_list = transpile(
qptexp._transpiled_circuits(),
backend=backend_tmp,
basis_gates = basis_gates + ["custom_cnot"],
optimization_level= 1, # Turn off optimization to keep the custom pulse
)
shots = 4096
if session is not None:
qpt_job = session.run(
"circuit-runner",
inputs={
"circuits": transpiled_circ_list,
"skip_transpilation": True,
"shots": shots,
},
)
else:
qpt_job = backend.run(transpiled_circ_list, shots=shots)
parameters = {
"backend": backend.name,
"qubits": (QUBIT_C, QUBIT_T),
"shots": shots,
}
logger.info(
"Quantum process tomography job: "+
str(qpt_job.job_id()) + "\n"
+ "\n".join([f"{key}: {val}" for key, val in parameters.items()])
+ "\n"
)
save_job_data(qpt_job, backend=backend, parameters=parameters)
import qutip
from qutip.core.gates import cnot
qptdata = retrieve_expdata(qpt_job, backend=backend, exp=qptexp)
state_result = qptdata.analysis_results("state")
choi_matrix = state_result.value.data
choi_qobj = qutip.Qobj(
choi_matrix, dims=[[[2, 2], [2, 2]], [[2, 2], [2, 2]]], superrep="choi"
)
choi_qobj = choi_qobj.permute([[1, 0], [3, 2]]) # Permute the two qubit
qutip.to_super(choi_qobj)
op_basis = [[qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]] * 2
chi = qutip.qpt(qutip.to_super(choi_qobj), op_basis)
qutip.qpt_plot_combined(
chi, lbls_list=[["i", "x", "y", "z"]] * 2, title="Process Matrix"
)
choi_qobj = qutip.to_choi(cnot())
qutip.to_super(choi_qobj)
op_basis = [[qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]]
lbls_list = [["i", "x", "y", "z"]]
if len(choi_qobj.dims[0][0]) == 2:
op_basis = op_basis * 2
lbls_list = lbls_list * 2
chi_qobj = qutip.qpt(qutip.to_super(choi_qobj), op_basis)
qutip.qpt_plot_combined(chi_qobj, lbls_list=lbls_list, title="Process Matrix")
|
https://github.com/BoxiLi/qiskit-CR-calibration
|
BoxiLi
|
import logging
from copy import deepcopy
import numpy as np
from numpy import pi
from qiskit.circuit import Gate
from qiskit import transpile
from qiskit.transpiler import InstructionProperties
from qiskit_utilities import (
save_job_data,
setup_logger,
retrieve_expdata,
get_cr_schedule,
iy_drag_calibration,
get_default_cr_params,
read_calibration_data,
iterative_cr_pulse_calibration,
create_echoed_cnot_schedule,
initilize_qiskit_dynamics_backend
)
session = None # qiskit runtime session
# Setup a logging system.
setup_logger(filename=None, level=logging.INFO, stdout=True)
logger = logging.getLogger("qiskit_utilities")
# Create a qiskit-dynamics backend with two Transmon, see fake_backend.py for detail.
# fidelity
f0 = 5.188339840468758e9
f1 = 5.079647268847252e9
# anharmonicity
a0 = -0.341931669003125e9
a1 = -0.343248404293835e9
backend = initilize_qiskit_dynamics_backend(f0, f1, a0, a1, J=0.003e9)
# Operating qubits
QUBIT_C, QUBIT_T = (0, 1)
# Compute the sampling time steps for the CR tomography experiments
if backend.name == 'DynamicsBackend':
amp = 2 * pi * 0.04
cr_times = np.arange(16*16, 1440*3, 32*4, dtype=int)
duration = 720 # Used for plotting only, not tomography.
else:
amp = get_default_cr_params(backend, QUBIT_C, QUBIT_T)[0]
duration = backend.defaults().instruction_schedule_map.get("cx", (QUBIT_C, QUBIT_T)).duration/16 * 4
cr_times = 16 * np.arange(16, duration + 16, duration//30, dtype=int)
## Custom shape
gate_name = "CR-Hann-tr10"
params = {
"order": "1", # order m for the initial pulse shape, order 1 is the Hann shape
"t_r": 10,
"drag_type" : False, # Givens rotation, use "sw" for perturbation
"duration": duration, # only for plotting
"amp": amp,
"angle": 0.0,
## If real device, use the following
# "Delta": (backend.properties().frequency(QUBIT_C) - backend.properties().frequency(QUBIT_T)) * 1.0e-9 * 2 * pi,
# "a1": 2 * pi * backend.properties().qubit_property(QUBIT_C)["anharmonicity"][0] * 1.0e-9,
## If Dynamicsbackend, use this
"Delta": 2 * pi * (f0 - f1) * 1.0e-9,
"a1": 2 * pi * a0 * 1.0e-9,
"drag_scale": [1., 1., 1.],
}
cr_params = params.copy()
ix_params = params.copy()
ix_params["amp"] = 0.0
ix_params["order"] = "2"
initial_calibration_data = {
"cr_params": cr_params,
"ix_params": ix_params,
"frequency_offset": 0.,
}
get_cr_schedule((QUBIT_C, QUBIT_T), backend, cr_params=cr_params, ix_params=ix_params).draw()
iterative_cr_pulse_calibration(
(QUBIT_C, QUBIT_T),
backend,
initial_calibration_data=initial_calibration_data,
cr_times=cr_times,
session=session,
gate_name=gate_name,
verbose=True,
restart=True, # fresh start
max_repeat=3,
shots=2048,
mode="CR",
)
from qiskit_experiments.library import ProcessTomography
calibration_data = read_calibration_data(backend, gate_name, (QUBIT_C, QUBIT_T))
custom_cnot_sched = create_echoed_cnot_schedule(backend, (QUBIT_C, QUBIT_T), calibration_data, reverse_direction=False)
# Show the custom CNOT schedule.
custom_cnot_sched.draw()
custom_cnot = Gate("custom_cnot", 2, [])
backend_tmp = deepcopy(backend)
backend_tmp.target.add_instruction(
custom_cnot,
{(QUBIT_C, QUBIT_T): InstructionProperties(calibration=custom_cnot_sched)},
name="custom_cnot",
)
qptexp = ProcessTomography(custom_cnot, physical_qubits=[QUBIT_C, QUBIT_T])
try:
basis_gates = backend.configuration().basis_gates
except AttributeError:
basis_gates = ["measure", "sx", "x", "rz"]
transpiled_circ_list = transpile(
qptexp._transpiled_circuits(),
backend=backend_tmp,
basis_gates = basis_gates + ["custom_cnot"],
optimization_level= 1, # Turn off optimization to keep the custom pulse
)
shots = 8096
if session is not None:
qpt_job = session.run(
"circuit-runner",
inputs={
"circuits": transpiled_circ_list,
"skip_transpilation": True,
"shots": shots,
},
)
else:
qpt_job = backend.run(transpiled_circ_list, shots=shots)
parameters = {
"backend": backend.name,
"qubits": (QUBIT_C, QUBIT_T),
"shots": shots,
}
logger.info(
"Quantum process tomography job: "+
str(qpt_job.job_id()) + "\n"
+ "\n".join([f"{key}: {val}" for key, val in parameters.items()])
+ "\n"
)
save_job_data(qpt_job, backend=backend, parameters=parameters)
import qutip
qptdata = retrieve_expdata(qpt_job, backend=backend, exp=qptexp)
state_result = qptdata.analysis_results("state")
choi_matrix = state_result.value.data
choi_qobj = qutip.Qobj(
choi_matrix, dims=[[[2, 2], [2, 2]], [[2, 2], [2, 2]]], superrep="choi"
)
choi_qobj = choi_qobj.permute([[1, 0], [3, 2]]) # Permute the two qubit
qutip.to_super(choi_qobj)
op_basis = [[qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]] * 2
chi_qobj = qutip.qpt(qutip.to_super(choi_qobj), op_basis)
qutip.qpt_plot_combined(
chi_qobj, lbls_list=[["i", "x", "y", "z"]] * 2, title="Process Matrix"
)
# Operating qubits
QUBIT_C, QUBIT_T = (0, 1)
# Compute the sampling time steps for the CR tomography experiments
if backend.name == 'DynamicsBackend':
amp = 2 * pi * 0.04
cr_times = np.arange(16*16, 1440*3, 32*4, dtype=int)
duration = 720 # Used for plotting only, not tomography.
else:
amp = get_default_cr_params(backend, QUBIT_C, QUBIT_T)[0]
duration = backend.defaults().instruction_schedule_map.get("cx", (QUBIT_C, QUBIT_T)).duration/16 * 4
cr_times = 16 * np.arange(16, duration + 16, duration//30, dtype=int)
## Custom shape
gate_name = "CR-recursive-tr10"
params = {
"order": "3", # order m for the initial pulse shape, order 1 is the Hann shape
"t_r": 10,
"drag_type" : "exact", # Givens rotation, use "sw" for perturbation
"duration": duration, # only for plotting
"amp": amp,
"angle": 0.0,
## If real device, use the following
# "Delta": (backend.properties().frequency(QUBIT_C) - backend.properties().frequency(QUBIT_T)) * 1.0e-9 * 2 * pi,
# "a1": 2 * pi * backend.properties().qubit_property(QUBIT_C)["anharmonicity"][0] * 1.0e-9,
## If Dynamicsbackend, use this
"Delta": 2 * pi * (f0 - f1) * 1.0e-9,
"a1": 2 * pi * a0 * 1.0e-9,
"drag_scale": [1., 1., 1.],
}
cr_params = params.copy()
ix_params = params.copy()
ix_params["amp"] = 0.0
ix_params["order"] = "2"
initial_calibration_data = {
"cr_params": cr_params,
"ix_params": ix_params,
"frequency_offset": 0.,
}
get_cr_schedule((QUBIT_C, QUBIT_T), backend, cr_params=cr_params, ix_params=ix_params).draw()
iterative_cr_pulse_calibration(
(QUBIT_C, QUBIT_T),
backend,
initial_calibration_data=initial_calibration_data,
cr_times=cr_times,
session=session,
gate_name=gate_name,
verbose=True,
restart=True, # fresh start
max_repeat=3,
shots=2048,
mode="CR",
)
from qiskit_experiments.library import ProcessTomography
calibration_data = read_calibration_data(backend, gate_name, (QUBIT_C, QUBIT_T))
custom_cnot_sched = create_echoed_cnot_schedule(backend, (QUBIT_C, QUBIT_T), calibration_data, reverse_direction=False)
# Show the custom CNOT schedule.
custom_cnot_sched.draw()
custom_cnot = Gate("custom_cnot", 2, [])
backend_tmp = deepcopy(backend)
backend_tmp.target.add_instruction(
custom_cnot,
{(QUBIT_C, QUBIT_T): InstructionProperties(calibration=custom_cnot_sched)},
name="custom_cnot",
)
qptexp = ProcessTomography(custom_cnot, physical_qubits=[QUBIT_C, QUBIT_T])
try:
basis_gates = backend.configuration().basis_gates
except AttributeError:
basis_gates = ["measure", "sx", "x", "rz"]
transpiled_circ_list = transpile(
qptexp._transpiled_circuits(),
backend=backend_tmp,
basis_gates = basis_gates + ["custom_cnot"],
optimization_level= 1, # Turn off optimization to keep the custom pulse
)
shots = 8096
if session is not None:
qpt_job = session.run(
"circuit-runner",
inputs={
"circuits": transpiled_circ_list,
"skip_transpilation": True,
"shots": shots,
},
)
else:
qpt_job = backend.run(transpiled_circ_list, shots=shots)
parameters = {
"backend": backend.name,
"qubits": (QUBIT_C, QUBIT_T),
"shots": shots,
}
logger.info(
"Quantum process tomography job: "+
str(qpt_job.job_id()) + "\n"
+ "\n".join([f"{key}: {val}" for key, val in parameters.items()])
+ "\n"
)
save_job_data(qpt_job, backend=backend, parameters=parameters)
import qutip
qptdata = retrieve_expdata(qpt_job, backend=backend, exp=qptexp)
state_result = qptdata.analysis_results("state")
choi_matrix = state_result.value.data
choi_qobj = qutip.Qobj(
choi_matrix, dims=[[[2, 2], [2, 2]], [[2, 2], [2, 2]]], superrep="choi"
)
choi_qobj = choi_qobj.permute([[1, 0], [3, 2]]) # Permute the two qubit
qutip.to_super(choi_qobj)
op_basis = [[qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]] * 2
chi_qobj = qutip.qpt(qutip.to_super(choi_qobj), op_basis)
qutip.qpt_plot_combined(
chi_qobj, lbls_list=[["i", "x", "y", "z"]] * 2, title="Process Matrix"
)
iy_drag_calibration((QUBIT_C, QUBIT_T), backend, gate_name, cr_times, session, verbose=True, delta_beta=10.)
calibration_data = read_calibration_data(backend, gate_name, (QUBIT_C, QUBIT_T))
custom_cnot_sched = create_echoed_cnot_schedule(backend, (QUBIT_C, QUBIT_T), calibration_data, reverse_direction=False)
# Show the custom CNOT schedule.
custom_cnot_sched.draw()
|
https://github.com/BoxiLi/qiskit-CR-calibration
|
BoxiLi
|
import logging
from copy import deepcopy
import warnings
import numpy as np
from numpy import pi
import matplotlib.pyplot as plt
from qiskit.circuit import Gate
from qiskit import transpile
from qiskit.transpiler import InstructionProperties
from qiskit_utilities import (
save_job_data,
setup_logger,
retrieve_expdata,
get_cr_schedule,
iy_drag_calibration,
get_default_cr_params,
read_calibration_data,
create_direct_cnot_schedule,
rough_rz0_correction_calibration,
fine_rz0_correction_calibration,
initilize_qiskit_dynamics_backend
)
session = None # qiskit runtime session
# Setup a logging system.
setup_logger(filename=None, level=logging.INFO, stdout=True)
logger = logging.getLogger("qiskit_utilities")
# Create a qiskit-dynamics backend with two Transmon, see fake_backend.py for detail.
# fidelity
f0 = 5.188339840468758e9
f1 = 5.079647268847252e9
# anharmonicity
a0 = -0.341931669003125e9
a1 = -0.343248404293835e9
backend = initilize_qiskit_dynamics_backend(f0, f1, a0, a1, J=0.0030e9)
# Operating qubits
QUBIT_C, QUBIT_T = (0, 1)
# Multiple the amplitude by a ratio factor.
ratio = 1
# Compute the sampling time steps for the CR tomography experiments
if backend.name == 'DynamicsBackend':
amp = 2 * pi * 0.06
cr_times = np.arange(16*16, 1440*3, 32*4, dtype=int)
duration = 720*2 # Used for plotting only, not tomography.
else:
amp = get_default_cr_params(backend, QUBIT_C, QUBIT_T)[0]
duration = backend.defaults().instruction_schedule_map.get("cx", (QUBIT_C, QUBIT_T)).duration/16 * 4 / ratio
cr_times = 16 * np.arange(16, duration + 16, duration//30, dtype=int)
# Custom shape
gate_name = "CR-recursive-tr10-direct"
params = {
"order": "3", # order m for the initial pulse shape
"t_r": 10,
"drag_type" : "exact", # Givens rotation, use "sw" for perturbation
"duration": duration, # only for plotting
"amp": amp,
"angle": 0.0,
## If real device, use the following
# "Delta": (backend.properties().frequency(QUBIT_C) - backend.properties().frequency(QUBIT_T)) * 1.0e-9 * 2 * pi,
# "a1": 2 * pi * backend.properties().qubit_property(QUBIT_C)["anharmonicity"][0] * 1.0e-9,
## If Dynamicsbackend, use this
"Delta": 2 * pi * (f0 - f1) * 1.0e-9,
"a1": 2 * pi * a0 * 1.0e-9,
"drag_scale": [1., 1., 1.],
}
cr_params = params.copy()
ix_params = params.copy()
ix_params["amp"] = 0.0
ix_params["order"] = "2"
ix_params["drag_type"] = "01" # single-derivative DRAG
initial_calibration_data = {
"cr_params": cr_params,
"ix_params": ix_params,
"frequency_offset": 0.,
}
get_cr_schedule((QUBIT_C, QUBIT_T), backend, cr_params=cr_params, ix_params=ix_params).draw()
from qiskit_utilities import iterative_cr_pulse_calibration
iterative_cr_pulse_calibration(
(QUBIT_C, QUBIT_T),
backend,
initial_calibration_data=initial_calibration_data,
cr_times=cr_times,
session=session,
gate_name=gate_name,
verbose=True,
restart=True,
max_repeat=3,
rerun_last_calibration=True,
shots=2048,
mode="CR",
)
iy_drag_calibration((QUBIT_C, QUBIT_T), backend, gate_name, cr_times, session, verbose=True, delta_beta=10.)
# Reduce cr_times by a half
if backend.name == 'DynamicsBackend':
cr_times = np.arange(16*16, 1440*4, 32*4, dtype=int)
else:
duration = backend.defaults().instruction_schedule_map.get("cx", (QUBIT_C, QUBIT_T)).duration/16 * 4 / ratio / 2
cr_times = 16 * np.arange(16, duration + 16, duration//30, dtype=int)
from qiskit_utilities import iterative_cr_pulse_calibration
iterative_cr_pulse_calibration(
(QUBIT_C, QUBIT_T),
backend,
cr_times,
session,
gate_name=gate_name,
initial_calibration_data=None,
verbose=True,
threshold_MHz=0.015,
restart=True,
rerun_last_calibration=False,
max_repeat=3,
shots=8096,
mode="IX-pi"
)
rough_rz0_correction_calibration(backend, (QUBIT_C, QUBIT_T), gate_name, session)
fine_rz0_correction_calibration(backend, (QUBIT_C, QUBIT_T), gate_name, session, num_repeat_cnot=6)
from qiskit_experiments.library import ProcessTomography
calibration_data = read_calibration_data(backend, gate_name, (QUBIT_C, QUBIT_T))
custom_cnot_sched = create_direct_cnot_schedule(backend, (QUBIT_C, QUBIT_T), calibration_data, reverse_direction=False)
# Show the custom CNOT schedule.
custom_cnot_sched.draw()
custom_cnot = Gate("custom_cnot", 2, [])
backend_tmp = deepcopy(backend)
backend_tmp.target.add_instruction(
custom_cnot,
{(QUBIT_C, QUBIT_T): InstructionProperties(calibration=custom_cnot_sched)},
name="custom_cnot",
)
qptexp = ProcessTomography(custom_cnot, physical_qubits=[QUBIT_C, QUBIT_T])
try:
basis_gates = backend.configuration().basis_gates
except AttributeError:
basis_gates = ["measure", "sx", "x", "rz"]
transpiled_circ_list = transpile(
qptexp._transpiled_circuits(),
backend=backend_tmp,
basis_gates = basis_gates + ["custom_cnot"],
optimization_level= 1, # Turn off optimization to keep the custom pulse
)
shots=8096
if session is not None:
qpt_job = session.run(
"circuit-runner",
inputs={
"circuits": transpiled_circ_list,
"skip_transpilation": True,
"shots": shots,
},
)
else:
qpt_job = backend.run(transpiled_circ_list, shots=shots)
parameters = {
"backend": backend.name,
"qubits": (QUBIT_C, QUBIT_T),
"shots": shots,
}
logger.info(
"Quantum process tomography job: "+
str(qpt_job.job_id()) + "\n"
+ "\n".join([f"{key}: {val}" for key, val in parameters.items()])
+ "\n"
)
save_job_data(qpt_job, backend=backend, parameters=parameters)
import qutip
qptdata = retrieve_expdata(qpt_job, backend=backend, exp=qptexp)
state_result = qptdata.analysis_results("state")
choi_matrix = state_result.value.data
choi_qobj = qutip.Qobj(
choi_matrix, dims=[[[2, 2], [2, 2]], [[2, 2], [2, 2]]], superrep="choi"
)
choi_qobj = choi_qobj.permute([[1, 0], [3, 2]]) # Permute the two qubit
qutip.to_super(choi_qobj)
op_basis = [[qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]] * 2
chi = qutip.qpt(qutip.to_super(choi_qobj), op_basis)
qutip.qpt_plot_combined(
chi, lbls_list=[["i", "x", "y", "z"]] * 2, title="Process Matrix"
)
from qiskit.circuit.library import CXGate
from qiskit_experiments.library import InterleavedRB
mode = "with_correction"
direct = True
if mode not in ("with_correction", "without_correction", "default"):
raise ValueError("Unknown mode.")
backend_tmp = deepcopy(backend)
rb_gate = CXGate()
calibration_data = read_calibration_data(backend, gate_name, (QUBIT_C, QUBIT_T))
if mode != "default":
modified_calibration_data = deepcopy(calibration_data)
if mode == "without_correction":
modified_calibration_data["ix_params"]["beta"] = 0.
modified_calibration_data["frequency_offset"] = 0.
modified_calibration_data["x_gate_frequency_offset"] = 0.
# Direct gate
custom_cnot_sched = create_direct_cnot_schedule(backend, (QUBIT_C, QUBIT_T), modified_calibration_data, with_separate_x=False)
backend_tmp.target["cx"][(QUBIT_C, QUBIT_T)] = InstructionProperties(calibration=custom_cnot_sched)
custom_cnot_sched = create_direct_cnot_schedule(backend, (QUBIT_C, QUBIT_T), modified_calibration_data, with_separate_x=False, reverse_direction=True)
backend_tmp.target["cx"][(QUBIT_T, QUBIT_C)] = InstructionProperties(calibration=custom_cnot_sched)
seed = np.random.randint(2**16)
num_sampling = 30
lengths = [1, 10, 20, 30, 40, 50, 60]
irb_exp = InterleavedRB(
interleaved_element=rb_gate, physical_qubits=[QUBIT_C, QUBIT_T], lengths=lengths, num_samples=num_sampling, backend=backend_tmp, seed=seed)
transpiled_circ_list = transpile(
# One must use _transpiled_circuits because it will include the calibration
irb_exp._transpiled_circuits(),
backend=backend_tmp,
basis_gates= ["x", "sx", "rz", "cx"], #+ ["custom_cnot"],
# initial_layout = [QUBIT_C, QUBIT_T], # Map the circuit to the target qubits
optimization_level= 1, # Turn off optimization to keep the custom pulse
)
shots = 4096
rb_job = backend_tmp.run(
transpiled_circ_list,
shots=shots,
)
parameters = {
"backend": backend.name,
"mode": mode,
"with_separate_x": False,
"direct": direct,
"qubits": [QUBIT_C, QUBIT_T],
"gate": rb_gate.name,
"shots": shots,
"lengths": lengths,
"num_sampling": num_sampling,
"seed": seed,
"calibration_data": calibration_data,
}
logger.info(
"Randomized benchmarking job: "+
str(rb_job.job_id()) + "\n"
+ "\n".join([f"{key}: {val}" for key, val in parameters.items()])
+ "\n"
)
save_job_data(rb_job, backend=backend, parameters=parameters)
from qiskit_utilities import load_job_data
parameters = load_job_data(rb_job)["parameters"]
exp_rb = InterleavedRB(
interleaved_element=CXGate(),
physical_qubits=[QUBIT_C, QUBIT_T],
lengths=parameters["lengths"],
num_samples=parameters["num_sampling"],
backend=backend,
seed=parameters["seed"])
exp_data = retrieve_expdata(rb_job, backend, exp=exp_rb)
exp_data.figure(0)
|
https://github.com/BoxiLi/qiskit-CR-calibration
|
BoxiLi
|
"""
Generation of echoed and direct CNOT gate based on calibrated CR pulse data.
"""
from copy import deepcopy
import numpy as np
from numpy import pi
from scipy.signal import find_peaks
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
import qiskit
from qiskit import pulse, circuit, schedule, transpile
from qiskit.circuit import Gate, QuantumCircuit
from qiskit.transpiler import InstructionProperties
from .job_util import (
load_job_data,
save_job_data,
read_calibration_data,
save_calibration_data,
omega_GHz_to_amp,
)
from .cr_pulse import (
process_zx_tomo_data,
get_cr_schedule,
_get_normalized_cr_tomography_data,
)
# Logger setup after importing logging
import logging
logger = logging.getLogger(__name__)
# %% Esitmate the gate time for a CNOT gate
def fit_function(
func,
xdata,
ydata,
init_params,
show_plot=False,
):
"""
Fit a given function using ``scipy.optimize.curve_fit``.
Args:
func (Callable): The function to fit the data. The first arguments is the input x data.
xdata (ArrayLike): X axis.
ydata (ArrayLike): Y axis.
init_params (ArrayLike): Initial parameter for x data
show_plot (bool, optional): If True, plot the fitted function and the given data. Defaults to False.
Returns:
list: The fitted parameters.
"""
xdata = np.array(xdata)
ydata = np.array(ydata)
if func is None:
func = lambda x, A, B, f, phi: (A * np.cos(2 * pi * f * x - phi) + B)
try:
fitparams, conv = curve_fit(
func,
xdata,
ydata,
p0=init_params,
)
except RuntimeError as e:
logger.warn("RuntimeError in the optimization")
fitparams = init_params
xline = np.linspace(xdata[0], xdata[-1], 100)
yline = func(xline, *fitparams)
diff = np.sum(np.abs(ydata - func(xdata, *fitparams))) / len(ydata)
if diff > 0.1:
logger.warning(
"The fitting error is too large. The calibrated value could be wrong. Please double check the calibration data."
)
if show_plot:
fig = plt.figure()
plt.plot(xdata, ydata, "x", c="k")
plt.plot(xline, yline)
plt.ylabel("Signal [a.u.]")
plt.ylim([-1.1, 1.1])
return fitparams
def _find_peak_index(ydata, xdata, height, positive=False):
"""Find the index of the first (close to time 0) peak in the given data.
Args:
ydata (np.ndarray): The y-values of the data.
xdata (np.ndarray): The x-values of the data.
height (float): The minimum height of peaks to be detected.
positive (bool, optional): If True, find positive peaks; otherwise, find negative peaks. Defaults to False.
Returns:
int: The index of the estimated peak.
Raises:
Warning: If no peaks are found in the data. It returns then the maximal index.
"""
extreme_indices = find_peaks(ydata, height=height)[0]
if positive:
# Positive maximum
extreme_indices = np.array([i for i in extreme_indices if xdata[i] > 0])
if extreme_indices.size > 0:
# Closest one to 0.
estimated_index = extreme_indices[
np.argmax(-np.abs(xdata[extreme_indices] - 0.0))
]
else:
logger.warning("Peak not found! Consider increase the drive strength.")
estimated_index = np.argmax(ydata)
return estimated_index
def _find_closest_extreme_point(f, phi, estimated_x_value):
"""Find the closest extreme point to the estimated maximum or minimum.
Args:
f (float): Frequency of the sinusoidal function.
phi (float): Phase of the sinusoidal function.
estimated_x_value (float): The estimated x-value of the maximum or minimum.
Returns:
float: The phase of the closest extreme point.
"""
extreme_points = (phi + np.array([-np.pi, 0.0, np.pi])) / f / 2 / pi
_diff_estimation = -np.abs(extreme_points - estimated_x_value)
return extreme_points[np.argmax(_diff_estimation)]
def estimate_cr_width(job_id, angle="90"):
"""
Estimate the duration of the CR pulse from the calibrated tomography experiment data.
This function takes the job ID of a tomography experiment for a calibrated CR pulse. It computes the duration of the CR pulse based on the observed signal. The function returns the estimated duration of the CR pulse as an integer that satisfies the qiskit-pulse requirement.
Args:
job_id (str): The ID of the calibrated tomography experiment job.
angle (str, optional): The angle of the CR gate, either "90" or "45". Defaults to "90".
Returns:
int: The estimated duration of the CR pulse.
Note:
Due to the truncation of the pulse time to a mulitple of 16, there is additional esitmation error introduced. This could be compensated for by adjusting the pulse amplitude. Here we omit this as the error is small.
"""
def _helper(cr_times, signal_z):
# Rough estimation of the first positive maximum
estimated_index = _find_peak_index(
-signal_z, cr_times, height=0.75, positive=True
)
# Curve fit
A, B, f, phi = fit_function(
lambda x, A, B, f, phi: (A * np.cos(2 * pi * f * x - phi) + B),
cr_times,
signal_z,
init_params=[-1, 0, 1 / 2 / (cr_times[estimated_index]), 0.0],
show_plot=False,
)
fitted_first_min = _find_closest_extreme_point(
f, phi, cr_times[estimated_index]
)
period = 1 / f
if angle == "90":
estimated_result = fitted_first_min - period / 4
elif angle == "45":
estimated_result = fitted_first_min - period / 8 * 3
else:
raise ValueError("Unknown angle")
return estimated_result
cr_times, splitted_data, dt = _get_normalized_cr_tomography_data(job_id)
signal_z0 = splitted_data[4]
signal_z1 = splitted_data[5]
est1 = _helper(cr_times, signal_z0)
est2 = _helper(cr_times, signal_z1)
if np.abs(est2 - est1) > 100:
logger.warning(
"The estimated CR pulse time is different for control qubit in state 0 and 1. This indicate that the ZX interaction strength is not well calibrated."
)
estimated_result = (est1 + est2) / 2
estimated_result = _helper(cr_times, signal_z1)
estimated_result = (estimated_result + 8) // 16 * 16
return int(estimated_result)
# %% ################# Calibrate a CNOT gate
def _get_ZX_sign(job_id):
coupling_strength = process_zx_tomo_data(job_id, show_plot=False)
return np.sign(coupling_strength["ZX"])
def create_cr45_pairs(
backend, qubits, cr_params, ix_params, ZX_sign, cr45_duration, frequency_offset=0.0
):
"""
Generate CR pulse schedule for a 45 degree ZX rotation.
Args:
backend (Backend): The quantum backend.
qubits (Tuple): Tuple of qubits (control, target).
cr_params (dict): Dictionary containing the base CR pulse parameters.
ix_params (dict): Dictionary containing the IX pulse parameters.
ZX_sign (int): Sign of the ZX interaction (1 or -1).
cr45_duration (int): Duration of the CR pulses for a 45 degree rotation.
frequency_offset (float, optional): Frequency offset. Defaults to 0.0.
Returns:
list: Pulse schedule for a CR45m and CR45p pulse schedule.
"""
cr_params = deepcopy(cr_params)
ix_params = deepcopy(ix_params)
cr_params["duration"] = cr45_duration
ix_params["duration"] = cr45_duration
cr_sched1 = get_cr_schedule(
qubits,
backend,
cr_params=cr_params,
ix_params=ix_params,
frequency_offset=frequency_offset,
)
cr_params["angle"] += pi
ix_params["angle"] += pi
cr_sched2 = get_cr_schedule(
qubits,
backend,
cr_params=cr_params,
ix_params=ix_params,
frequency_offset=frequency_offset,
)
if ZX_sign == 1:
return cr_sched2, cr_sched1
else:
return cr_sched1, cr_sched2
def create_echoed_cnot_schedule(
backend, qubits, calibration_data, reverse_direction=False
):
"""
Generate a schedule for a echod CNOT gate based on CR pulse.
Args:
backend (Backend): The quantum backend.
qubits (Tuple): Tuple of qubits (control, target).
cr_params (dict): Dictionary containing the base CR pulse parameters.
ix_params (dict): Dictionary containing the IX pulse parameters.
ZX_sign (int): Sign of the ZX interaction (1 or -1).
cr45_duration (int): Duration of the CR pulses for a 45 degree rotation.
cr90_duration (int): Duration of the CR pulses for a 90 degree rotation.
idle_duration (int): Duration of the idle time between the CR pulses.
frequency_offset (float, optional): Frequency offset. Defaults to 0.0.
Returns:
qsikit.pulse.Schedule: A pulse schedule for a CNOT gate with echo.
"""
cr_params = calibration_data["cr_params"]
ix_params = calibration_data["ix_params"]
calibrated_cr_tomo_id = calibration_data["calibration_job_id"]
duration = estimate_cr_width(calibrated_cr_tomo_id, angle="45")
frequency_offset = calibration_data["frequency_offset"]
ZX_sign = _get_ZX_sign(calibrated_cr_tomo_id)
cr45m_sched, cr45p_sched = create_cr45_pairs(
backend,
qubits,
cr_params,
ix_params,
ZX_sign,
duration,
frequency_offset=frequency_offset,
)
CR45p = Gate("CR45p", 2, [])
CR45m = Gate("CR45m", 2, [])
backend = deepcopy(backend)
backend.target.add_instruction(
CR45m,
{qubits: InstructionProperties(calibration=cr45m_sched)},
name="CR45m",
)
backend.target.add_instruction(
CR45p,
{qubits: InstructionProperties(calibration=cr45p_sched)},
name="CR45p",
)
circ = QuantumCircuit(2, 2)
if reverse_direction:
circ.h(0)
circ.h(1)
circ.sx(1)
circ.x(0)
circ.append(CR45p, [0, 1])
circ.x(0)
circ.append(CR45m, [0, 1])
circ.rz(np.pi / 2, 0)
if reverse_direction:
circ.h(0)
circ.h(1)
try:
basis_gates = backend.configuration().basis_gates
except AttributeError:
basis_gates = ["measure", "sx", "x", "rz"]
transpile_options = {
"basis_gates": basis_gates + ["CR45p", "CR45m"],
"initial_layout": qubits,
"optimization_level": 1,
}
transpiled_circ = transpile(circ, backend=backend, **transpile_options)
# Transfer Schedule to ScheduleBlock using pulse builder. Otherwise qiskit_ibm_provider rejects it.
cnot_sched = pulse.Schedule()
cnot_sched.append(schedule(transpiled_circ, backend=backend), inplace=True)
return cnot_sched
def create_cr90m(
backend,
qubits,
cr_params,
ix_params,
ZX_sign,
cr90_duration,
x_gate_ix_params,
frequency_offset=0.0,
):
"""
Generate CR pulse schedule for a 90 degree -ZX rotation.
Args:
backend (Backend): The quantum backend.
qubits (Tuple): Tuple of qubits (control, target).
cr_params (dict): Dictionary containing the base CR pulse parameters.
ix_params (dict): Dictionary containing the IX pulse parameters.
ZX_sign (int): Sign of the ZX interaction (1 or -1).
cr90_duration (int): Duration of the CR pulse for a 90 degree rotation.
frequency_offset (float, optional): Frequency offset. Defaults to 0.0.
Returns:
qiskit.pulse.Schedule: A pulse schedule for a CR90m pulse.
"""
cr_params = deepcopy(cr_params)
ix_params = deepcopy(ix_params)
if ZX_sign == 1:
cr_params["angle"] += pi
ix_params["angle"] += pi
cr_params["duration"] = cr90_duration
ix_params["duration"] = cr90_duration
if x_gate_ix_params is not None:
x_gate_ix_params["duration"] = cr90_duration
if ZX_sign == 1:
x_gate_ix_params["angle"] += pi
return get_cr_schedule(
qubits,
backend,
cr_params=cr_params,
ix_params=ix_params,
x_gate_ix_params=x_gate_ix_params,
frequency_offset=frequency_offset,
)
def create_direct_cnot_schedule(
backend, qubits, calibration_data, with_separate_x=False, reverse_direction=False
):
"""
Generate a schedule for a direct CNOT pulse.
Args:
backend (Backend): The quantum backend.
qubits (Tuple): Tuple of qubits (control, target).
calibration_data (dict): Dictionary containing calibration data.
with_separate_x (bool, optional): If True, includes a separate X gate before the CR90m. Defaults to False.
Returns:
qiskit.pulse.Schedule: A pulse schedule for a direct CNOT pulse.
"""
cr_params = calibration_data["cr_params"]
ix_params = calibration_data["ix_params"]
if with_separate_x:
x_gate_ix_params = None
else:
x_gate_ix_params = deepcopy(calibration_data["x_gate_ix_params"])
calibrated_cr_tomo_id = calibration_data["calibration_job_id"]
rz0_correction = calibration_data.get("rz0_correction", 0.0)
frequency_offset = calibration_data.get("x_gate_frequency_offset", 0.0)
ZX_sign = _get_ZX_sign(calibrated_cr_tomo_id)
duration = estimate_cr_width(calibrated_cr_tomo_id, angle="90")
cr90m_sched = create_cr90m(
backend,
qubits,
cr_params,
ix_params,
ZX_sign,
duration,
x_gate_ix_params=x_gate_ix_params,
frequency_offset=frequency_offset,
)
CR90m = Gate("CR90m", 2, [])
backend = deepcopy(backend)
backend.target.add_instruction(
CR90m,
{qubits: InstructionProperties(calibration=cr90m_sched)},
name="CR90m",
)
circ = QuantumCircuit(2)
if reverse_direction:
circ.h(0)
circ.h(1)
if with_separate_x:
circ.rx(pi / 2, 1)
circ.append(CR90m, [0, 1])
circ.rz(pi / 2, 0)
circ.rz(rz0_correction, 0)
if reverse_direction:
circ.h(0)
circ.h(1)
try:
basis_gates = backend.configuration().basis_gates
except AttributeError:
basis_gates = ["measure", "sx", "x", "rz"]
transpile_options = {
"basis_gates": basis_gates + ["CR90m"],
"initial_layout": qubits,
"optimization_level": 1,
}
transpiled_circ = transpile(circ, backend=backend, **transpile_options)
# Transfer Schedule to ScheduleBlock using pulse builder. Otherwise qiskit_ibm_provider rejects it.
cnot_sched = pulse.Schedule()
cnot_sched.append(schedule(transpiled_circ, backend=backend), inplace=True)
return cnot_sched
# %% Calibration of the RZ0 phase correction
def get_rz0_amplification_circuits(num_gates_list, phase_list):
"""
Generate a list of circuits for calibrating RZ0 phase correction by amplifying the effect.
Args:
num_gates_list (list): List of integers specifying the number of CNOT gates in each circuit.
phase_list (list): List of phase values for the RZ gate.
Returns:
list: List of circuits with varied numbers of CNOT gates and RZ phases.
"""
circ_list = []
phase = circuit.Parameter("phase")
custom_cnot = Gate("custom_cnot", 2, [])
for n in num_gates_list:
circ = QuantumCircuit(2, 2)
circ.h(0)
circ.barrier()
for _ in range(n):
circ.append(custom_cnot, [0, 1])
circ.rz(phase, 0)
circ.barrier()
circ.h(0)
circ.measure(0, 0)
circ.measure(1, 1)
circ_list += [circ.assign_parameters({phase: p}) for p in phase_list]
return circ_list
def get_rz0_pi_calibration_circuits(phase_list):
"""
Generate a list of circuits for calibrating RZ0 phase correction with pi rotations. One measures 00 if CX has correct ZI phase, if the phase is pi, one measures 11.
Args:
phase_list (list): List of phase values for the RZ gate.
Returns:
list: List of circuits for differnet phase.
"""
phase = circuit.Parameter("phase")
custom_cnot = Gate("custom_cnot", 2, [])
circ = QuantumCircuit(2, 2)
circ.h(0)
# CX with a phase need to be calibrated
circ.barrier()
circ.append(custom_cnot, [0, 1])
circ.rz(phase, 0)
circ.barrier()
circ.rx(pi / 2, 0)
# CX with a phase need to be calibrated
circ.barrier()
circ.append(custom_cnot, [0, 1])
circ.rz(phase, 0)
circ.barrier()
circ.rx(-pi / 2, 1)
circ.h(0)
circ.measure(0, 0)
circ.measure(1, 1)
return [circ.assign_parameters({phase: p}) for p in phase_list]
def send_rz0_calibration_job(backend, qubits, phase_list, circ_list, session):
"""
Send a job for calibrating RZ0 phase correction.
Args:
backend (Backend): The quantum backend.
qubits (Tuple): Tuple of qubits (control, target).
phase_list (list): List of phase values for the RZ gate.
circ_list (list): List of QuantumCircuit objects to be executed
session: A Qiskit runtime Session.
Returns:
str: Job ID of the calibration job.
"""
try:
basis_gates = backend.configuration().basis_gates
except AttributeError:
basis_gates = ["measure", "sx", "x", "rz"]
transpiled_circ_list = transpile(
circ_list,
backend=backend,
basis_gates=basis_gates + ["custom_cnot"],
initial_layout=qubits,
optimization_level=1,
)
shots = 1024
if session is not None:
job = session.run(
"circuit-runner",
inputs={
"circuits": transpiled_circ_list,
"skip_transpilation": True,
"shots": shots,
},
)
else:
job = backend.run(transpiled_circ_list, shots=shots)
parameters = {
"name": "rz0 calibration",
"backend": backend.name,
"qubits": qubits,
"phase_list": phase_list,
"shots": shots,
}
logger.info(
"ZI calibration ID: "
+ job.job_id()
+ "\n"
+ "\n".join([f"{key}: {val}" for key, val in parameters.items()])
+ "\n"
)
save_job_data(job, backend=backend, parameters=parameters)
return job.job_id()
def rough_rz0_correction_calibration(backend, qubits, gate_name, session):
"""
Perform a rough calibration of the RZ0 phase phase correction on the control qubit.
Args:
backend (Backend): The quantum backend.
qubits (Tuple): Tuple of qubits (control, target).
gate_name (str): Name of the gate for calibration.
session: A Qiskit runtime Session.
"""
logger.info("Rough calibration of the RZ0 phase correction.")
calibration_data = read_calibration_data(backend, gate_name, qubits)
calibration_data = deepcopy(calibration_data)
calibration_data["rz0_correction"] = 0.0
custom_cnot_schedule = create_direct_cnot_schedule(
backend, qubits, calibration_data, with_separate_x=False
)
phase_list = np.linspace(-pi, pi, 50)
max_num_gates = 8
num_gates_list = range(2, max_num_gates + 1, 2)
circ_list = get_rz0_amplification_circuits(
num_gates_list, phase_list
) + get_rz0_pi_calibration_circuits(phase_list)
backend = deepcopy(backend)
backend.target.add_instruction(
Gate("custom_cnot", 2, []),
{qubits: InstructionProperties(calibration=custom_cnot_schedule)},
name="custom_cnot",
)
job_id = send_rz0_calibration_job(backend, qubits, phase_list, circ_list, session)
logger.info("Job complete. Analyzing data...")
data = load_job_data(job_id)
result = data["result"]
shots = data["parameters"]["shots"]
prob_list = np.array(
[result.get_counts(i).get("00", 0) / shots for i in range(len(result.results))]
)
prob_list = prob_list.reshape(len(result.results) // 50, 50)
fig, ax = plt.subplots(1)
im = ax.imshow(prob_list, vmin=0, vmax=1, aspect=3, cmap="PuBu")
ax.set_xticklabels([0] + [round(p, 2) for p in phase_list[::10]])
ax.set_yticks([0, 1, 2, 3, 4], [2, 4, 6, 8, "parity"])
ax.set_ylabel("Number of CNOT")
cbar = fig.colorbar(im, spacing="proportional", shrink=0.4)
cbar.set_label(r"Probability of $|00\rangle$")
estimated_rz0_correction = phase_list[np.argmax(np.sum(prob_list, axis=0))]
calibration_data["rz0_correction"] = estimated_rz0_correction
logger.info(f"Estimated RZ0 correction: {estimated_rz0_correction}\n")
save_calibration_data(backend, gate_name, qubits, calibration_data)
def fine_rz0_correction_calibration(
backend, qubits, gate_name, session, num_repeat_cnot=2
):
"""
Perform a fine-tuning calibration of the phase correction on the control qubit.
Args:
backend (Backend): The quantum backend.
qubits (Tuple): Tuple of qubits (control, target).
gate_name (str): Name of the gate for calibration.
session: A Qiskit Quantum Session.
"""
logger.info("Fine calibration of the RZ0 phase correction.")
calibration_data = read_calibration_data(backend, gate_name, qubits)
rz0_correction = calibration_data["rz0_correction"]
calibration_data = deepcopy(calibration_data)
calibration_data["rz0_correction"] = 0.0
custom_cnot_schedule = create_direct_cnot_schedule(
backend, qubits, calibration_data, with_separate_x=False
)
narrow_phase_list = rz0_correction + np.linspace(-pi / 10, pi / 10, 50)
circ_list = get_rz0_amplification_circuits((num_repeat_cnot,), narrow_phase_list)
backend = deepcopy(backend)
backend.target.add_instruction(
Gate("custom_cnot", 2, []),
{qubits: InstructionProperties(calibration=custom_cnot_schedule)},
name="custom_cnot",
)
job_id = send_rz0_calibration_job(
backend, qubits, narrow_phase_list, circ_list, session
)
data = load_job_data(job_id)
result = data["result"]
shots = data["parameters"]["shots"]
def _find_closest_extreme_point(f, phi, estimated_x_value):
"""
Find the extreme point that is closed to the estimated maximum/minimum.
"""
extreme_points = (phi + np.linspace(-10 * pi, 10 * pi, 21)) / f / 2 / pi
_diff_estimation = -np.abs(extreme_points - estimated_x_value)
return extreme_points[np.argmax(_diff_estimation)]
prob_list = np.array(
[result.get_counts(i).get("00", 0) / shots for i in range(len(result.results))]
)
data_to_fit = -prob_list
rought_estimated_min_point = narrow_phase_list[np.argmin(data_to_fit)]
A, B, f, phi = fit_function(
lambda x, A, B, f, phi: (A * np.cos(2 * pi * f * x - phi) + B),
narrow_phase_list,
data_to_fit,
init_params=[-1.0, 0, 1.0, rought_estimated_min_point],
show_plot=True,
)
rz0_correction = _find_closest_extreme_point(f, phi, rought_estimated_min_point)
calibration_data["rz0_correction"] = rz0_correction
logger.info(f"Fine-tuning RZ0 correction: {rz0_correction}")
save_calibration_data(backend, gate_name, qubits, calibration_data)
# %% Fine-tuning the ZX and IX strength
def _CR_angle_error_amplification(backend, qubits, gate_name, session, max_num_gate):
custom_cnot = Gate("custom_cnot", 2, [])
circ_list = []
for initial_state in [0, 1]:
for num_gate in range(max_num_gate):
circ = QuantumCircuit(2, 1)
if initial_state == 1:
circ.x(0)
circ.rx(pi / 2, 1)
for _ in range(num_gate):
circ.barrier()
circ.append(custom_cnot, [0, 1], [])
circ.measure(1, 0)
circ_list.append(circ)
calibration_data = read_calibration_data(backend, gate_name, qubits)
modified_calibration_data = deepcopy(calibration_data)
custom_cnot_sched = create_direct_cnot_schedule(
backend, qubits, modified_calibration_data, with_separate_x=False
)
backend_tmp = deepcopy(backend)
backend_tmp.target.add_instruction(
custom_cnot,
{qubits: InstructionProperties(calibration=custom_cnot_sched)},
name="custom_cnot",
)
transpiled_circ_list = transpile(
circ_list,
backend=backend_tmp,
basis_gates=backend_tmp.configuration().basis_gates + ["custom_cnot"],
initial_layout=qubits,
optimization_level=1,
)
shots = 1024
job = session.run(
"circuit-runner",
inputs={
"circuits": transpiled_circ_list,
"skip_transpilation": True,
"shots": shots,
},
)
parameters = {
"name": "Fine CR amplitude calibration",
"backend": backend_tmp.name,
"qubits": qubits,
"gate_name": gate_name,
"phase_list": max_num_gate,
"shots": shots,
"calibration": calibration_data,
}
logger.info(
"ZI calibration ID: "
+ job.job_id()
+ "\n"
+ "\n".join([f"{key}: {val}" for key, val in parameters.items()])
+ "\n"
)
save_job_data(job, backend=backend_tmp, parameters=parameters)
logger.info("CR angle fine-tuning job complete.")
result = load_job_data(job)["result"]
return job.job_id()
def _analyize_CR_angle_data(
job_id,
):
data = load_job_data(job_id)
result = data["result"]
shots = data["parameters"]["shots"]
qubits = data["parameters"]["qubits"]
prob_list = np.array(
[result.get_counts(i).get("0", 0) / shots for i in range(len(result.results))]
)
plt.plot(prob_list[: len(prob_list) // 2], "o-", label="control 0")
plt.plot(prob_list[len(prob_list) // 2 :], "o-", label="control 1")
plt.legend()
control0_data = prob_list[: len(prob_list) // 2]
control1_data = prob_list[len(prob_list) // 2 :]
import warnings
def _func1(x, epsZX, epsIX, B):
with warnings.catch_warnings():
# Ignore the Runtime warning when x is not an integer.
# This happens because in `fit_function` we plot func as a function of x.
# It will gives nan, automatically ignore in the plot, so we just hide the warning here.
# One needs to plot the fitted points manually.
warnings.simplefilter("ignore")
result = (
1 * (-1) ** x * (np.cos(pi / 2 + pi / 4 * x * (-epsZX - epsIX))) + 0.5
)
return result
def _func0(x, epsZX, epsIX, B):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
result = 1 * (np.cos(pi / 2 + pi / 4 * x * (epsZX - epsIX))) + 0.5
return result
def _fun(x, epsZX, epsIX, B):
result1 = _func1(x, epsZX, epsIX, B)
result0 = _func0(x, epsZX, epsIX, B)
return np.concatenate([result0, result1])
data_to_fit = np.concatenate([control0_data, control1_data])
iteration_number = len(control0_data)
with warnings.catch_warnings():
# Ignore OptimizeWarning of SciPy because the Covariance cannot be calculated.
warnings.simplefilter("ignore")
params = fit_function(
_fun,
list(range(iteration_number)),
data_to_fit,
init_params=[
0.0,
0.0,
0,
],
show_plot=False,
)
xline = np.array(list(range(iteration_number)))
plt.plot(xline, _func0(xline, *params), "x")
plt.plot(xline, _func1(xline, *params), "x")
plt.show()
epsZX, epsIX, _ = params
logger.info(f"ZX error {round(epsZX*100, 2)}%, IX error {round(epsIX*100, 2)}%")
return epsZX, epsIX
def CR_angle_fine_tuning(backend, qubits, gate_name, session, max_num_gate=10):
job_id = _CR_angle_error_amplification(
backend, qubits, gate_name, max_num_gate=max_num_gate, session=session
)
epsZX, epsIX = _analyize_CR_angle_data(job_id)
if np.abs(epsZX) + np.abs(epsZX) <= 0.01:
logger.info("No need for amplitude calibration.\n")
return
old_calibration_data = read_calibration_data(backend, gate_name, qubits)
modified_calibration_data = deepcopy(old_calibration_data)
modified_calibration_data["cr_params"]["amp"] *= 1 + epsZX
# Divided by 2
IX_amp_correction = omega_GHz_to_amp(
backend,
qubits[1],
modified_calibration_data["x_gate_coeffs"]["IX"] / 2 * epsIX / 1000,
)
modified_calibration_data["x_gate_ix_params"]["amp"] += IX_amp_correction
save_calibration_data(backend, gate_name, qubits, modified_calibration_data)
job_id2 = _CR_angle_error_amplification(
backend, qubits, gate_name, max_num_gate=max_num_gate, session=session
)
epsZX_new, epsIX_new = _analyize_CR_angle_data(job_id2)
if (epsZX_new**2 + epsIX_new**2) < (epsZX**2 + epsZX**2):
save_calibration_data(backend, gate_name, qubits, modified_calibration_data)
logger.info("CR drive ampliutude updated.\n")
else:
save_calibration_data(backend, gate_name, qubits, old_calibration_data)
logger.info("Calibration brings no improvement.\n")
|
https://github.com/BoxiLi/qiskit-CR-calibration
|
BoxiLi
|
"""
Generation and calibration of CR pulse.
"""
import os
import warnings
import multiprocessing as mpl
from multiprocessing import Pool
from functools import partial
from copy import deepcopy
import numpy as np
from numpy import pi
try:
import jax
import jax.numpy as jnp
except:
warnings("JAX not install, multi-derivative pulse doesn't work.")
os.environ["XLA_PYTHON_CLIENT_PREALLOCATE"] = "false"
os.environ["JAX_PLATFORM_NAME"] = "cpu"
os.environ["OPENBLAS_NUM_THREADS"] = "1"
os.environ["MKL_NUM_THREADS"] = "1"
import scipy
from scipy.signal import find_peaks
from scipy.optimize import curve_fit
import symengine as sym
import matplotlib.pyplot as plt
from qiskit import pulse, circuit, schedule, transpile
from qiskit.circuit import QuantumCircuit
from qiskit.pulse.library import (
Gaussian,
GaussianSquare,
GaussianSquareDrag,
SymbolicPulse,
Waveform,
)
from qiskit.pulse import Play, ShiftPhase, DriveChannel, ScheduleBlock
from ._custom_jax import _value_and_jacfwd
from .job_util import (
amp_to_omega_GHz,
omega_GHz_to_amp,
load_job_data,
save_job_data,
async_execute,
read_calibration_data,
save_calibration_data,
)
# Logger setup after importing logging
import logging
logger = logging.getLogger(__name__)
# %% Compute the DRAG pulse shape using JAX
def _complex_square_root(x):
"""
Calculate the complex square root of a given complex number.
Parameters:
- x (complex): The input complex number.
Returns:
- complex: The complex square root of the input.
"""
a = jnp.real(x)
b = jnp.imag(x)
result = jnp.sign(a) * (
jnp.sqrt((jnp.abs(x) + a) / 2)
+ 1.0j * jnp.sign(b) * jnp.sqrt((jnp.abs(x) - a) / 2)
)
result = jnp.where(
jnp.abs(b / a) < 1.0e-3,
# Taylor expansion
jnp.sign(a)
* jnp.sqrt(jnp.abs(a))
* (1 + (1.0j * b / a) / 2 - (1.0j * b / a) ** 2 / 8),
result,
)
result = jnp.where(a == 0.0, 1.0j * b, result)
return result
def perturbative_pulse_transform_single_photon(pulse_fun, gap, scale=1.0):
"""
Add perturbative DRAG correction to a pulse based on the pulse function and energy gap.
Parameters:
- pulse_fun (callable): The original pulse function.
- gap (float): The gap parameter for the transformation.
- scale (float, optional): Scaling factor for the transformation. Default is 1.
Returns:
- callable: Transformed pulse function.
"""
def new_pulse_fun(t, params):
pulse, dt_pulse = _value_and_jacfwd(pulse_fun)(t, params)
return pulse - 1.0j * dt_pulse / gap * scale
return new_pulse_fun
def perturbative_pulse_transform_two_photon(pulse_fun, gap, gaps):
"""
Add perturbative DRAG correction to a two-photon transition based on the pulse function and energy gaps.
Parameters:
- pulse_fun (callable): The original pulse function.
- gap (float): The common gap parameter for the transformation.
- gaps (tuple): Tuple containing two gap parameters (gap01, gap12).
Returns:
- callable: Transformed pulse function.
"""
def new_pulse_fun(t, params):
pulse, dt_pulse = _value_and_jacfwd(pulse_fun)(t, params)
return _complex_square_root(pulse**2 - 2 * 1.0j * pulse * dt_pulse / gap)
return new_pulse_fun
def exact_pulse_transform_single_photon(pulse_fun, gap, ratio=1, scale=1.0):
"""
Apply an exact DRAG correction using Givens rotation to a pulse. It only works for single-photon transitions.
Parameters:
- pulse_fun (callable): The original pulse function.
- gap (float): The gap parameter for the transformation.
- ratio (float, optional): Ratio parameter. Default is 1.
- scale (float, optional): Scaling factor for the transformation. Default is 1.
Returns:
- callable: Transformed pulse function.
"""
def new_pulse_fun(t, params):
pulse = pulse_fun(t, params)
phase = jnp.where(pulse != 0.0, jnp.exp(1.0j * jnp.angle(pulse)), 0.0)
def renorm_pulse_fun(t, params):
pulse = pulse_fun(t, params)
angle = jnp.angle(pulse)
theta2 = jnp.arctan(
-ratio * (params["omega"] / 2) * jnp.abs(pulse) / (gap / 2)
)
return theta2, angle
(theta2, angle), (dt_theta2, dt_angle) = _value_and_jacfwd(renorm_pulse_fun)(
t, params
)
dt_angle = jnp.where(pulse != 0.0, dt_angle, 0.0)
angle = jnp.where(pulse != 0.0, angle, 0.0)
new_g = phase * (-(gap + dt_angle) * jnp.tan(theta2) + scale * 1.0j * dt_theta2)
return jnp.where(
params["omega"] == 0.0,
0.0,
new_g / (ratio * (params["omega"])),
)
return new_pulse_fun
def pulse_shape(t, params):
"""
Define a pulse shape function based on the specified parameters.
Parameters:
- t (float): Time parameter.
- params (dict): Dictionary containing pulse parameters.
Returns:
- float: Value of the pulse function at the given time.
"""
def pulse_fun(t, params):
order = params["order"]
if order == "2":
fun = (
lambda t, params: t / params["t_r"]
- (jnp.cos(t * pi / params["t_r"]) * jnp.sin(t * pi / params["t_r"]))
/ pi
)
elif order == "1":
fun = lambda t, params: jnp.sin(jnp.pi / 2 / params["t_r"] * t) ** 2
elif order == "3":
t_r = params["t_r"]
fun = (
lambda t, params: (jnp.cos(3 * pi * t / t_r)) / 16
- (9 / 16) * jnp.cos(pi * t / t_r)
+ 1 / 2
)
else:
raise ValueError("Pulse shape order not defined.")
if "t_r" in params:
t_r = params["t_r"]
t_tol = params["t_tol"]
max_value = fun(params["t_r"], params)
pulse = max_value
pulse = jnp.where(t < t_r, fun(t, params), pulse)
pulse = jnp.where(t > t_tol - t_r, fun(t_tol - t, params), pulse)
return pulse
else:
raise NotImplementedError
if "drag_scale" not in params or params["drag_scale"] is None:
drag_scale = jnp.ones(3)
else:
drag_scale = jnp.array(params["drag_scale"])
if "no_drag" in params:
return pulse_fun(t, params)
detuning = params["Delta"]
gap02 = 2 * detuning + params["a1"]
gap12 = detuning + params["a1"]
gap01 = detuning
if "01" in params:
# Only single-derivative DRAG with gap for level 0 and 1. Use beta from the input parameters as a scaling factor for the DRAG coefficient.
pulse_fun = perturbative_pulse_transform_single_photon(
pulse_fun, gap01, scale=params.get("beta", 0.0)
)
elif "01_scale" in params:
# Only single-derivative DRAG with gap for level 0 and 1.
pulse_fun = perturbative_pulse_transform_single_photon(
pulse_fun, gap01, scale=drag_scale[0]
)
elif "12" in params:
# Only single-derivative DRAG with gap for level 1 and 2.
pulse_fun = perturbative_pulse_transform_single_photon(pulse_fun, gap12)
elif "02" in params:
# Only single-derivative DRAG with gap for level 0 and 2.
pulse_fun = perturbative_pulse_transform_two_photon(
pulse_fun, gap02, (gap01, gap12)
)
elif "exact" in params:
# Full correction with Givens rotatino for the two single-photon transitions and the perturbative DRAG correction for the two-photon process.
pulse_fun = perturbative_pulse_transform_two_photon(
pulse_fun, gap02 / params["drag_scale"][2], (gap01, gap12)
)
pulse_fun = exact_pulse_transform_single_photon(
pulse_fun, gap01 / params["drag_scale"][0], ratio=1
)
pulse_fun = exact_pulse_transform_single_photon(
pulse_fun,
gap12 / params["drag_scale"][1],
ratio=jnp.sqrt(2),
# *(1 - gap12/gap01)
)
elif "sw" in params:
# Full correction for all the three transitions, only use perturabtive DRAG correction.
pulse_fun = perturbative_pulse_transform_two_photon(
pulse_fun, gap02 / drag_scale[2], (gap01, gap12)
)
pulse_fun = perturbative_pulse_transform_single_photon(
pulse_fun, gap01 / drag_scale[0]
)
pulse_fun = perturbative_pulse_transform_single_photon(
pulse_fun,
gap12 / drag_scale[1],
)
else:
raise ValueError("Unknown DRAG type.")
final_pulse = pulse_fun(t, params)
return final_pulse
# %% Build CR tomography circuit and send jobs
def get_default_cr_params(backend, qc, qt):
"""
Get the default parameters for the echoed CNOT gate from Qiskit.
Parameters:
- backend (qiskit.providers.backend.Backend): The Qiskit backend.
- qc (int): Control qubit index.
- qt (int): Target qubit index.
Returns:
Tuple[Dict, Dict]: Tuple containing dictionaries of parameters for the echoed CNOT gate for control and target qubits.
"""
inst_sched_map = backend.instruction_schedule_map
def _filter_fun(instruction, pulse="ZX"):
if pulse == "ZX" and "CR90p_u" in instruction[1].pulse.name:
return True
elif pulse == "ZX" and "CX_u" in instruction[1].pulse.name:
return True
elif pulse == "IX" and "CR90p_d" in instruction[1].pulse.name:
return True
elif pulse == "IX" and "CX_d" in instruction[1].pulse.name:
return True
return False
def get_cx_gate_schedule(qc, qt):
from qiskit.pulse import PulseError
try:
return inst_sched_map.get("ecr", (qc, qt))
except PulseError:
return inst_sched_map.get("cx", (qc, qt))
gate_schedule = get_cx_gate_schedule(qc, qt)
cr_sched_default = gate_schedule.filter(instruction_types=[Play]).filter(
_filter_fun
)
cr_instruction = cr_sched_default.instructions[0][1]
cr_pulse = cr_instruction.pulse
ix_sched_default = gate_schedule.filter(instruction_types=[Play]).filter(
partial(_filter_fun, pulse="IX")
)
ix_instruction = ix_sched_default.instructions[0][1]
ix_channel = ix_instruction.channel
ix_pulse = ix_instruction.pulse
return cr_pulse.parameters, ix_pulse.parameters
def _get_modulated_symbolic_pulse(pulse_class, backend, params, frequency_offset):
"""
Add a detuning to the pulse by pulse shape modulation with exp(2*pi*I*delta*t).
Parameters:
- pulse_class (type): The class of the pulse.
- backend (qiskit.providers.backend.Backend): The Qiskit backend.
- params (dict): Pulse parameters.
- frequency_offset (float): Frequency offset for detuning.
Returns:
SymbolicPulse: Modulated symbolic pulse.
"""
default_pulse = pulse_class(**params)
pulse_parameters = default_pulse.parameters
pulse_parameters["delta"] = frequency_offset * backend.dt
_t, _delta = sym.symbols("t, delta")
my_pulse = SymbolicPulse(
pulse_type="GaussianModulated",
duration=default_pulse.duration,
parameters=pulse_parameters,
envelope=default_pulse.envelope * sym.exp(2 * sym.pi * sym.I * _delta * _t),
name="modulated Gaussian",
)
return my_pulse
def _add_symbolic_gaussian_pulse(pulse1, pulse2):
"""
Add two symbolic GaussianSquare pulses.
It is used in the target drive for the direct CNOT gate calibration to separate the parameter from the echoed CNOT gate.
Parameters:
- pulse1 (SymbolicPulse): First symbolic GaussianSquare pulse.
- pulse2 (SymbolicPulse): Second symbolic GaussianSquare pulse.
Returns:
SymbolicPulse: Resulting pulse after adding the two pulses.
"""
edited_params2 = {key + "_": value for key, value in pulse2.parameters.items()}
edited_pulse2_envelop = pulse2.envelope
for p_str in pulse2.parameters.keys():
old_p = sym.symbols(p_str)
new_p = sym.symbols(p_str + "_")
edited_pulse2_envelop = edited_pulse2_envelop.xreplace(old_p, new_p)
pulse_parameters = pulse1.parameters.copy()
pulse_parameters.update(edited_params2)
if pulse1.duration != pulse2.duration:
raise RuntimeError("Pulse duration must be the same.")
my_pulse = SymbolicPulse(
pulse_type="SumGaussian",
duration=pulse1.duration,
parameters=pulse_parameters,
envelope=pulse1.envelope + edited_pulse2_envelop,
name="added_pulse",
)
return my_pulse
def _add_waveform(waveform1, waveform2):
"""Add two qiskit waveform samplings.
Parameters:
- waveform1 (Waveform): First qiskit waveform.
- waveform2 (Waveform): Second qiskit waveform.
Returns:
Waveform: Resulting waveform after adding the two waveforms.
"""
if len(waveform1.samples) != len(waveform2.samples):
raise ValueError("The two waveforms do not have the same length.")
return Waveform(
samples=waveform1.samples + waveform2.samples,
name=waveform1.name,
)
def get_custom_pulse_shape(params, backend, control_qubit, frequency_offset=0.0):
"""Compute the custom sine-shaped pulse with DRAG correction for the custom CR gate. It is only possible to get the array sampling of the waveform, no symbolic expressions.
Parameters:
- params (dict): Dictionary containing parameters for pulse shape computation.
- backend: Qiskit backend.
- control_qubit: Index of the control qubit.
- frequency_offset (float, optional): Frequency offset. Default is 0.0.
Returns:
Waveform: Computed pulse shape with DRAG correction.
"""
def regulate_array_length(array):
result_array = np.zeros((len(array) // 16 + 1) * 16)
result_array[: len(array)] = array
return result_array
params = params.copy()
# Computation of the DRAG pulse needs the final time in ns, transfer "duration" to the final time "t_tol".
if "duration" in params:
params["t_tol"] = params["duration"] * backend.dt * 1.0e9
elif "t_tol" in params:
pass
else:
ValueError(
"The total time of the CR pulse t_tol is not defined in the parameter dictionary."
)
# If amp is given, comute the the drive strength in 2*pi*GHz
params["omega"] = 2 * pi * amp_to_omega_GHz(backend, control_qubit, params["amp"])
# Choose the DRAG type
if "drag_type" in params and params["drag_type"]:
params[params["drag_type"]] = True
else:
params["no_drag"] = True
del params["drag_type"]
# Generate time array
tlist = np.arange(0, params["t_tol"], backend.dt * 1.0e9)
tlist = regulate_array_length(tlist)
# Compute pulse shape with DRAG correction using JAX
pulse_shape_sample = params["amp"] * jax.vmap(pulse_shape, (0, None))(
tlist,
params,
)
del params["amp"]
# Conjugate the pulse shape array (because of the qiskit convention) and apply frequency offset
pulse_shape_sample = np.array(pulse_shape_sample).conjugate()
pulse_shape_sample = pulse_shape_sample * np.exp(
2
* np.pi
* 1.0j
* frequency_offset
* backend.dt
* np.arange(len(pulse_shape_sample))
)
pulse_shape_sample = pulse_shape_sample * np.exp(1.0j * params["angle"])
# Return the computed waveform
return Waveform(
samples=pulse_shape_sample,
name="CR drive",
)
def get_cr_schedule(qubits, backend, **kwargs):
"""
Generate the qiskit Schedule for CR pulse, including both the CR drive and the target.
Args:
qubits (Tuple): Tuple of control and target qubits.
backend (Backend): Qiskit backend.
**kwargs: Additional keyword arguments:
- cr_params (dict): Parameters for the CR pulse.
- ix_params (dict): Parameters for the IX pulse.
- x_gate_ix_params (dict, optional): Additional parameters for the X-gate on the target IX pulse. Default is None.
- frequency_offset (float, optional): Frequency offset in . Default is 0.0.
Returns:
Schedule: Qiskit Schedule for the CR pulse.
"""
cr_params = kwargs["cr_params"].copy()
ix_params = kwargs["ix_params"].copy()
frequency_offset = kwargs.get("frequency_offset", 0.0)
x_gate_ix_params = kwargs.get("x_gate_ix_params", None)
cr_params["risefall_sigma_ratio"] = 2.0
ix_params["risefall_sigma_ratio"] = 2.0
if x_gate_ix_params is not None:
x_gate_ix_params["risefall_sigma_ratio"] = 2.0
if "width" in cr_params:
del cr_params["width"]
if "width" in ix_params:
del ix_params["width"]
qc, qt = qubits
cr_schedule = pulse.Schedule()
control_channel = pulse.ControlChannel(qc)
target_channel = pulse.DriveChannel(qt)
if "beta" not in ix_params:
ix_params["beta"] = 0.0
# Generate CR pulse waveform
if "drag_type" in cr_params:
cr_pulse = get_custom_pulse_shape(
cr_params, backend, qc, frequency_offset=frequency_offset
)
else:
cr_pulse = _get_modulated_symbolic_pulse(
GaussianSquare, backend, cr_params, frequency_offset
)
if "drag_type" in ix_params:
ix_pulse = get_custom_pulse_shape(
ix_params, backend, qc, frequency_offset=frequency_offset
)
if x_gate_ix_params is not None:
x_gate_pulse = get_custom_pulse_shape(
x_gate_ix_params, backend, qc, frequency_offset
)
ix_pulse = _add_waveform(ix_pulse, x_gate_pulse)
else:
ix_pulse = _get_modulated_symbolic_pulse(
GaussianSquareDrag, backend, ix_params, frequency_offset
)
if x_gate_ix_params is not None:
x_gate_pulse = _get_modulated_symbolic_pulse(
GaussianSquare, backend, x_gate_ix_params, frequency_offset
)
ix_pulse = _add_symbolic_gaussian_pulse(ix_pulse, x_gate_pulse)
# Check if CR and IX pulse durations are equal
if cr_pulse.duration != ix_pulse.duration:
raise RuntimeError(
f"CR and IX pulse duration are not equal {cr_pulse.duration} and {ix_pulse.duration}."
)
cr_schedule.append(pulse.Play(cr_pulse, control_channel), inplace=True)
cr_schedule.append(pulse.Play(ix_pulse, target_channel), inplace=True)
tmp_circ = QuantumCircuit(backend.num_qubits)
if backend.name == "DynamicsBackend":
# pass
tmp_circ.rz(
+2 * pi * frequency_offset * backend.dt * ix_pulse.duration,
qt,
)
else:
tmp_circ.rz(
-2 * pi * frequency_offset * backend.dt * ix_pulse.duration,
qt,
)
cr_schedule.append(schedule(tmp_circ, backend=backend), inplace=True)
return cr_schedule
def _generate_indiviual_circuit(
duration,
qubits,
backend,
cr_params,
ix_params,
x_gate_ix_params,
frequency_offset,
control_states,
):
"""
Generate tomography circuits for a given CR pulse duration.
Args:
duration (float): Duration of the CR pulse.
qubits (Tuple): Tuple of control and target qubits.
backend (Backend): Qiskit backend.
cr_params (dict): Parameters for the CR pulse.
ix_params (dict): Parameters for the IX pulse.
x_gate_ix_params (dict): Parameters for the X-gate on the IX pulse.
frequency_offset (float): Frequency offset.
control_states (Tuple): Control states for the tomography circuits.
Returns:
List[QuantumCircuit]: List of generated tomography circuits.
"""
cr_gate = circuit.Gate("cr", num_qubits=2, params=[])
(qc, qt) = qubits
circ_list = []
cr_params["duration"] = int(duration)
ix_params["duration"] = int(duration)
if x_gate_ix_params is not None:
x_gate_ix_params["duration"] = int(duration)
# Get CR pulse schedule
cr_sched = get_cr_schedule(
(qc, qt),
backend,
cr_params=cr_params,
ix_params=ix_params,
x_gate_ix_params=x_gate_ix_params,
frequency_offset=frequency_offset,
)
for basis in ["X", "Y", "Z"]:
for control in control_states:
tomo_circ = circuit.QuantumCircuit(
backend.num_qubits, 2
) # use all qubits to avoid error
if control in (1, "1"):
tomo_circ.x(qc) # flip control from |0> to |1>
tomo_circ.append(cr_gate, [qc, qt])
tomo_circ.barrier(qc, qt)
if basis == "X":
tomo_circ.h(qt)
elif basis == "Y":
tomo_circ.sdg(qt)
tomo_circ.h(qt)
tomo_circ.measure(qc, 0)
tomo_circ.measure(qt, 1)
tomo_circ.add_calibration(gate=cr_gate, qubits=[qc, qt], schedule=cr_sched)
circ_list.append(tomo_circ)
return circ_list
def get_cr_tomo_circuits(
qubits,
backend,
cr_times,
cr_params,
ix_params,
x_gate_ix_params=None,
frequency_offset=0.0,
control_states=(0, 1),
):
"""
Build an array of cross resonance schedules for the Hamiltonian tomography experiment.
Args:
qubits (Tuple): Tuple of control and target qubits.
backend (Backend): Qiskit backend.
cr_times (List[int]): List of CR pulse durations.
cr_params (dict): Parameters for the CR pulse
ix_params (dict): Parameters for the IX pulse.
x_gate_ix_params (dict, optional): Parameters for the X-gate on the IX pulse. Default is None.
frequency_offset (float, optional): Frequency offset. Default is 0.0.
control_states (Tuple, optional): Control states for the tomography circuits. Default is (0, 1).
Returns:
List[QuantumCircuit]: List of generated tomography circuits.
"""
tomo_circs = []
cr_params = cr_params.copy()
ix_params = ix_params.copy()
if x_gate_ix_params is not None:
x_gate_ix_params = x_gate_ix_params.copy()
tomo_circs = []
tmp_fun = partial(
_generate_indiviual_circuit,
qubits=qubits,
backend=backend,
cr_params=cr_params,
ix_params=ix_params,
x_gate_ix_params=x_gate_ix_params,
frequency_offset=frequency_offset,
control_states=control_states,
)
# with mpl.Pool(10) as p:
# tomo_circs = p.map(tmp_fun, cr_times)
tomo_circs = map(tmp_fun, cr_times)
tomo_circs = sum(tomo_circs, [])
logger.info("Tomography circuits have been generated.")
return tomo_circs
def _send_decoy_cicuit(backend, session):
"""
Send a very simple decoy circuit to the backend to prevent idling.
Parameters:
- backend (Backend): Qiskit backend.
- session (Session): Qiskit session.
"""
qc = QuantumCircuit(1)
qc.x(0)
qc = transpile(
qc,
backend,
scheduling_method="asap",
optimization_level=1,
)
job = session.run(
"circuit-runner",
inputs={
"circuits": qc,
"skip_transpilation": True,
"shots": 10,
},
)
return job.job_id()
def send_cr_tomography_job(
qubits,
backend,
cr_params,
ix_params,
cr_times,
x_gate_ix_params=None,
blocking=False,
frequency_offset=0.0,
session=None,
shots=1024,
control_states=(0, 1),
decoy=False,
):
"""
Send the tomography job for CR pulse.
Parameters:
- qubits (Tuple): Tuple of control and target qubits.
- backend (Backend): Qiskit backend.
- cr_params (dict): Parameters for the CR pulse.
- ix_params (dict): Parameters for the IX pulse.
- cr_times (List[float]): List of widths of the CR pulses.
- x_gate_ix_params (dict, optional): Parameters for the X-gate IX pulse. Default is None.
- blocking (bool, optional): If True, block until the job is completed. Default is False.
- frequency_offset (float, optional): Frequency offset. Default is 0.0.
- ZI_correction (float, optional): ZI interaction rate correction. Default is 0.0.
- session (Session, optional): Qiskit session. Default is None.
- shots (int, optional): Number of shots. Default is 1024.
- control_states (Tuple, optional): Tuple of control states. Default is (0, 1).
- decoy (bool, optional): If True, send a decoy circuit to prevent idling. Default is True.
Returns:
str: Job ID.
"""
# Create circuits
cr_tomo_circ_list = get_cr_tomo_circuits(
qubits,
backend,
cr_times,
cr_params=cr_params,
ix_params=ix_params,
x_gate_ix_params=x_gate_ix_params,
frequency_offset=frequency_offset,
control_states=control_states,
)
if decoy:
_send_decoy_cicuit(backend, session)
transpiled_tomo_circ_list = transpile(
cr_tomo_circ_list,
backend,
# scheduling_method="asap",
optimization_level=1,
)
# Send jobs
if session is not None:
job = session.run(
"circuit-runner",
inputs={
"circuits": transpiled_tomo_circ_list,
"skip_transpilation": True,
"shots": shots,
},
)
else:
job = backend.run(transpiled_tomo_circ_list, shots=shots)
tag = "CR tomography"
# job.update_tags([tag]) # qiskit-ibm-runtime does not support yet update_tags, will support soon.
parameters = {
"backend": backend.name,
"qubits": qubits,
"cr_times": cr_times,
"shots": shots,
"cr_params": cr_params,
"ix_params": ix_params,
"x_gate_ix_params": x_gate_ix_params,
"frequency_offset": frequency_offset,
"dt": backend.dt,
}
logger.info(
tag
+ ": "
+ job.job_id()
+ "\n"
+ "\n".join([f"{key}: {val}" for key, val in parameters.items()])
+ "\n"
)
if blocking:
save_job_data(job, backend=backend, parameters=parameters)
else:
async_execute(save_job_data, job, backend=backend, parameters=parameters)
return job.job_id()
def shifted_parameter_cr_job(
qubits,
backend,
cr_params,
ix_params,
cr_times,
prob_ix_strength,
x_gate_ix_params=None,
frequency_offset=0.0,
shots=1024,
blocking=False,
session=None,
control_states=(0, 1),
mode="CR",
):
"""
Send the tomography job for CR pulse with a shifted amplitude on the target drive.
Parameters:
- qubits (Tuple): Tuple of control and target qubits.
- backend (Backend): Qiskit backend.
- cr_params (dict): Parameters for the CR pulse.
- ix_params (dict): Parameters for the IX pulse.
- cr_times (List[float]): List of widths of the CR pulses.
- prob_ix_strength (float): Strength of the probability amplitude shift.
- x_gate_ix_params (dict, optional): Parameters for the X-gate IX pulse. Default is None.
- frequency_offset (float, optional): Frequency offset. Default is 0.0.
- shots (int, optional): Number of shots. Default is 1024.
- blocking (bool, optional): If True, block until the job is completed. Default is False.
- session (Session, optional): Qiskit session. Default is None.
- control_states (Tuple, optional): Tuple of control states. Default is (0, 1).
- mode (str, optional): Operation mode ("CR" or "IX"). Default is "CR".
Returns:
str: Job ID.
"""
if mode == "CR":
ix_params = ix_params.copy()
ix_params["amp"] += prob_ix_strength
else:
x_gate_ix_params = x_gate_ix_params.copy()
x_gate_ix_params["amp"] += prob_ix_strength
tomo_id = send_cr_tomography_job(
qubits,
backend,
cr_params,
ix_params,
cr_times,
x_gate_ix_params,
blocking=blocking,
session=session,
frequency_offset=frequency_offset,
shots=shots,
control_states=control_states,
)
return tomo_id
# %% Analyze CR tomography data
# Part of the following code is from https://github.com/Qiskit/textbook/blob/main/notebooks/quantum-hardware-pulses/hamiltonian-tomography.ipynb
def _get_omega(eDelta, eOmega_x, eOmega_y):
r"""Return \Omega from parameter arguments."""
eOmega = np.sqrt(eDelta**2 + eOmega_x**2 + eOmega_y**2)
return eOmega
def _avg_X(t, eDelta, eOmega_x, eOmega_y, eOmega, t0, normalize=True):
"""Return average X Pauli measurement vs time t"""
if normalize:
eOmega = _get_omega(eDelta, eOmega_x, eOmega_y)
eXt = (
-eDelta * eOmega_x
+ eDelta * eOmega_x * np.cos(eOmega * t + t0)
+ eOmega * eOmega_y * np.sin(eOmega * t + t0)
) / eOmega**2
return eXt
def _avg_Y(t, eDelta, eOmega_x, eOmega_y, eOmega, t0, normalize=True):
"""Return average Y Pauli measurement vs time t"""
if normalize:
eOmega = _get_omega(eDelta, eOmega_x, eOmega_y)
eYt = (
eDelta * eOmega_y
- eDelta * eOmega_y * np.cos(eOmega * t + t0)
- eOmega * eOmega_x * np.sin(eOmega * t + t0)
) / eOmega**2
return eYt
def _avg_Z(t, eDelta, eOmega_x, eOmega_y, eOmega, t0, normalize=True):
"""Return average Z Pauli measurement vs time t"""
if normalize:
eOmega = _get_omega(eDelta, eOmega_x, eOmega_y)
eZt = (
eDelta**2 + (eOmega_x**2 + eOmega_y**2) * np.cos(eOmega * t + t0)
) / eOmega**2
return eZt
def fit_evolution(tlist, eXt, eYt, eZt, p0, include, normalize):
"""
Use curve_fit to determine fit parameters of X,Y,Z Pauli measurements together.
Parameters:
- tlist (array-like): Time values for the measurements.
- eXt (array-like): X Pauli measurements.
- eYt (array-like): Y Pauli measurements.
- eZt (array-like): Z Pauli measurements.
- p0 (array-like): Initial guess for fit parameters.
- include (array-like): Boolean array specifying which Pauli measurements to include in the fit.
- normalize (bool): Whether to normalize the measurements.
Returns:
Tuple[array-like, array-like]: Fit parameters and covariance matrix.
"""
def fun(tlist, eDelta, eOmega_x, eOmega_y, eOmega, t0):
"""Stack average X,Y,Z Pauli measurements vertically."""
result = np.vstack(
[
_avg_X(
tlist, eDelta, eOmega_x, eOmega_y, eOmega, t0, normalize=normalize
),
_avg_Y(
tlist, eDelta, eOmega_x, eOmega_y, eOmega, t0, normalize=normalize
),
_avg_Z(
tlist, eDelta, eOmega_x, eOmega_y, eOmega, t0, normalize=normalize
),
]
)[include].flatten()
return result
data = np.asarray(
[
eXt,
eYt,
eZt,
]
)[include].flatten()
params, cov = curve_fit(fun, tlist, data, p0=p0, method="trf")
return params, cov
def fit_rt_evol(tlist, eXt, eYt, eZt, p0, include, normalize):
"""
Use curve_fit to determine fit parameters of X,Y,Z Pauli measurements together.
Parameters:
- tlist (array-like): Time values for the measurements.
- eXt (array-like): X Pauli measurements.
- eYt (array-like): Y Pauli measurements.
- eZt (array-like): Z Pauli measurements.
- p0 (array-like): Initial guess for fit parameters.
- include (array-like): Boolean array specifying which Pauli measurements to include in the fit.
- normalize (bool): Whether to normalize the measurements.
Returns:
Tuple[array-like, array-like]: Fit parameters and covariance matrix.
"""
def fun(tlist, eDelta, eOmega_x, eOmega_y, eOmega, t0):
"""
Stack average X,Y,Z Pauli measurements vertically.
"""
result = np.vstack(
[
_avg_X(
tlist, eDelta, eOmega_x, eOmega_y, eOmega, t0, normalize=normalize
),
_avg_Y(
tlist, eDelta, eOmega_x, eOmega_y, eOmega, t0, normalize=normalize
),
_avg_Z(
tlist, eDelta, eOmega_x, eOmega_y, eOmega, t0, normalize=normalize
),
]
)[include].flatten()
return result
data = np.asarray(
[
eXt,
eYt,
eZt,
]
)[include].flatten()
params, cov = curve_fit(fun, tlist, data, p0=p0, method="trf")
return params, cov
def recursive_fit(tlist, eXt, eYt, eZt, p0):
"""
Perform recursive fitting of X, Y, Z Pauli expectation values.
Parameters:
- tlist (array-like): Time values for the measurements.
- eXt (array-like): X Pauli expectation values.
- eYt (array-like): Y Pauli expectation values.
- eZt (array-like): Z Pauli expectation values.
- p0 (array-like): Initial guess for fit parameters.
Returns:
Tuple[array-like, array-like]: Fit parameters and covariance matrix.
"""
params = p0.copy()
# First fit with Z measurement only, no normalization
include = np.array([False, False, True])
params, cov = fit_evolution(tlist, eXt, eYt, eZt, params, include, normalize=False)
# Second fit with Z measurement only, normalization applied
include = np.array([False, False, True])
params, cov = fit_evolution(tlist, eXt, eYt, eZt, params, include, normalize=True)
# Third fit with Y and Z measurements, no normalization
include = np.array([False, True, True])
params, cov = fit_evolution(tlist, eXt, eYt, eZt, params, include, normalize=False)
# Fourth fit with X, Y, and Z measurements, no normalization
include = np.array([True, True, True])
params, cov = fit_evolution(tlist, eXt, eYt, eZt, params, include, normalize=False)
# Fifth fit with X, Y, and Z measurements, normalization applied
include = np.array([True, True, True])
params, cov = fit_evolution(tlist, eXt, eYt, eZt, params, include, normalize=True)
return params, cov
def get_interation_rates_MHz(ground_params, excited_params, ground_cov, excited_cov):
"""
Determine two-qubits interaction rates from fits to ground and excited control qubit data.
Parameters:
- ground_params (array-like): Fit parameters for the ground state.
- excited_params (array-like): Fit parameters for the excited state.
- ground_cov (array-like): Covariance matrix for the ground state fit.
- excited_cov (array-like): Covariance matrix for the excited state fit.
Returns:
Tuple[array-like, array-like]: Interaction rates and their standard deviations.
"""
Delta0, Omega0_x, Omega0_y = ground_params[:3]
Delta1, Omega1_x, Omega1_y = excited_params[:3]
Delta0_var, Omega0_x_var, Omega0_y_var = np.diag(ground_cov)[:3]
Delta1_var, Omega1_x_var, Omega1_y_var = np.diag(excited_cov)[:3]
# Interaction rates
IX = 0.5 * (Omega0_x + Omega1_x) / 2 / pi
IY = 0.5 * (Omega0_y + Omega1_y) / 2 / pi
IZ = 0.5 * (Delta0 + Delta1) / 2 / pi
ZX = 0.5 * (Omega0_x - Omega1_x) / 2 / pi
ZY = 0.5 * (Omega0_y - Omega1_y) / 2 / pi
ZZ = 0.5 * (Delta0 - Delta1) / 2 / pi
# Standard deviations
IX_std = 0.5 * (Omega0_x_var + Omega1_x_var) ** 0.5 / 2 / pi
IY_std = 0.5 * (Omega0_y_var + Omega1_y_var) ** 0.5 / 2 / pi
IZ_std = 0.5 * (Delta0_var + Delta1_var) ** 0.5 / 2 / pi
ZX_std = 0.5 * (Omega0_x_var + Omega1_x_var) ** 0.5 / 2 / pi
ZY_std = 0.5 * (Omega0_y_var + Omega1_y_var) ** 0.5 / 2 / pi
ZZ_std = 0.5 * (Delta0_var + Delta1_var) ** 0.5 / 2 / pi
return [[IX, IY, IZ], [ZX, ZY, ZZ]], [
[IX_std, IY_std, IZ_std],
[ZX_std, ZY_std, ZZ_std],
]
def _estimate_period(data, cr_times):
"""
Estimate the period of the oscillatory data using peak finding.
Parameters:
- data (array-like): Oscillatory data.
- cr_times (array-like): Corresponding time values.
Returns:
float: Estimated period of the oscillatory data.
"""
peaks_high, properties = scipy.signal.find_peaks(data, prominence=0.5)
peaks_low, properties = scipy.signal.find_peaks(-data, prominence=0.5)
peaks = sorted(np.concatenate([peaks_low, peaks_high]))
if len(peaks) <= 2:
return cr_times[-1] - cr_times[0]
return 2 * np.mean(np.diff(cr_times[peaks]))
def _get_normalized_cr_tomography_data(job_id):
"""Retrieve and normalize CR tomography data from a job. Renormalize the data to (-1, 1).
Args:
job_id (str): The ID of the job containing CR tomography data.
Returns:
Tuple[array-like, array-like]: A tuple containing the CR times and normalized tomography data.
"""
data = load_job_data(job_id)
result = data["result"]
dt = data["parameters"]["dt"]
cr_times = data["parameters"]["cr_times"]
shots = data["parameters"]["shots"]
# IBM classified data
# Trace out the control, notice that IBM uses reverse qubit indices labeling.
target_data = (
np.array(
[
(result.get_counts(i).get("00", 0) + result.get_counts(i).get("01", 0))
for i in range(len(result.results))
]
)
/ shots
)
if 6 * len(cr_times) == len(target_data):
# two-qubit tomography, with control on 0 and 1
splitted_data = target_data.reshape((len(cr_times), 6)).transpose()
elif 3 * len(cr_times) == len(target_data):
# single tomography
splitted_data = target_data.reshape((len(cr_times), 3)).transpose()
else:
ValueError(
"The number of data points does not match the number of tomography settings."
)
splitted_data = splitted_data * 2 - 1
scale = np.max(splitted_data) - np.min(splitted_data)
average = (np.max(splitted_data) + np.min(splitted_data)) / 2
splitted_data = 2 * (splitted_data - average) / scale
return cr_times, splitted_data, dt
def process_single_qubit_tomo_data(job_id, show_plot=False):
"""Process and analyze single qubit tomography data from a job.
Args:
job_id (str): The ID of the job containing single qubit tomography data.
show_plot (bool, optional): Whether to generate and display plots. Default is False.
Returns:
dict: Dictionary containing the processed results including <X>, <Y>, and <Z>.
Note:
Noticed that the measured value is not the IX, IY, IZ in the sense of CR, but the single qubit dynamics when the control qubit is in |0> or |1>.
"""
cr_times, splitted_data, dt = _get_normalized_cr_tomography_data(job_id)
signal_x, signal_y, signal_z = splitted_data
period = _estimate_period(signal_z, cr_times)
cutoff = -1
params, cov = recursive_fit(
cr_times[:cutoff] * dt * 1.0e6,
signal_x[:cutoff],
signal_y[:cutoff],
signal_z[:cutoff],
p0=np.array([1, 1, 1, 1 / (period * dt * 1.0e6) * 2 * pi, 0.0]),
)
if show_plot:
plot_cr_ham_tomo(
cr_times * dt * 1.0e6,
splitted_data,
ground_params=params,
ground_cov=cov,
)
plt.show()
return {
"IX": params[1] / 2 / pi,
"IY": params[2] / 2 / pi,
"IZ": params[0] / 2 / pi,
}
## TODO remove dt in the signiture.
def process_zx_tomo_data(job_id, show_plot=False):
"""Process and analyze ZX tomography data from a job.
Args:
job_id (str): The ID of the job containing ZX tomography data.
show_plot (bool, optional): Whether to generate and display plots. Default is False.
Returns:
dict: Dictionary containing the processed results including IX, IY, IZ, ZX, ZY, and ZZ.
Note:
The effective coupling strength is in the unit of MHz.
"""
cr_times, splitted_data, dt = _get_normalized_cr_tomography_data(job_id)
signal_x = splitted_data[:2]
signal_y = splitted_data[2:4]
signal_z = splitted_data[4:6]
period0 = _estimate_period(signal_z[0], cr_times)
period1 = _estimate_period(signal_z[1], cr_times)
cutoff = -1
_i = 0
while True:
try:
ground_params, ground_cov = recursive_fit(
cr_times[:cutoff] * dt * 1.0e6,
signal_x[0][:cutoff],
signal_y[0][:cutoff],
signal_z[0][:cutoff],
p0=np.array([1, 1, 1, 1 / (period0 * dt * 1.0e6) * 2 * pi, 0.0]),
)
break
except RuntimeError as e:
_i += 1
period0 *= 2
if _i > 16:
raise e
excited_params, excited_cov = recursive_fit(
cr_times[:cutoff] * dt * 1.0e6,
signal_x[1][:cutoff],
signal_y[1][:cutoff],
signal_z[1][:cutoff],
p0=np.array([1, 1, 1, 1 / (period1 * dt * 1.0e6) * 2 * pi, 0.0]),
)
# ground_params, ground_cov = excited_params, excited_cov
if show_plot:
plot_cr_ham_tomo(
cr_times * dt * 1.0e6,
splitted_data,
ground_params,
excited_params,
ground_cov,
excited_cov,
)
plt.show()
[[IX, IY, IZ], [ZX, ZY, ZZ]] = get_interation_rates_MHz(
ground_params, excited_params, ground_cov, excited_cov
)[0]
return {"IX": IX, "IY": IY, "IZ": IZ, "ZX": ZX, "ZY": ZY, "ZZ": ZZ}
def plot_cr_ham_tomo(
cr_times,
tomography_data,
ground_params,
excited_params=None,
ground_cov=None,
excited_cov=None,
):
"""Plot Hamiltonian tomography data and curve fits with interaction rates.
Args:
cr_times (np.ndarray): Array of CR times.
tomography_data (np.ndarray): Averaged tomography data.
ground_params (np.ndarray): Parameters of the ground fit.
excited_params (np.ndarray, optional): Parameters of the excited fit. Default is None.
ground_cov (np.ndarray, optional): Covariance matrix of the ground fit. Default is None.
excited_cov (np.ndarray, optional): Covariance matrix of the excited fit. Default is None.
"""
colors = ["tab:blue", "tab:red"]
fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(4, 4), sharey=True)
is_single_qubit_tomo = excited_params is None
if not is_single_qubit_tomo:
ground_avg = tomography_data[0::2, :]
excited_avg = tomography_data[1::2, :]
else:
ground_avg = tomography_data
# Scatter plot and curve for X(t)
ax1.scatter(
cr_times,
ground_avg[0, :],
lw=0.3,
color=colors[0],
label=r"control in $|0\rangle$" if not is_single_qubit_tomo else None,
)
ax1.plot(cr_times, _avg_X(cr_times, *ground_params), lw=2.0, color=colors[0])
ax1.set_ylabel(r"$\langle X(t) \rangle$", fontsize="small")
ax1.set_xticklabels([])
ax1.set_yticks([])
# Scatter plot and curve for Y(t)
ax2.scatter(
cr_times, ground_avg[1, :], lw=0.3, color=colors[0], label="control in |0>"
)
ax2.plot(cr_times, _avg_Y(cr_times, *ground_params), lw=2.0, color=colors[0])
ax2.set_ylabel(r"$\langle Y(t) \rangle$", fontsize="small")
ax2.set_xticklabels([])
# Scatter plot and curve for Z(t)
ax3.scatter(
cr_times,
ground_avg[2, :],
lw=0.3,
color=colors[0],
label=r"control in $|0\rangle$",
)
ax3.plot(cr_times, _avg_Z(cr_times, *ground_params), lw=2.0, color=colors[0])
ax3.set_ylabel(r"$\langle Z(t) \rangle$", fontsize="small")
ax3.set_yticklabels([])
ax3.set_xlabel(r"Time $(\mu s)$", fontsize="small")
if not is_single_qubit_tomo:
ax1.scatter(
cr_times,
excited_avg[0, :],
lw=0.3,
color=colors[1],
label=r"control in $|1\rangle$",
)
ax1.plot(cr_times, _avg_X(cr_times, *excited_params), lw=2.0, color=colors[1])
ax1.legend(loc=4, fontsize="x-small")
ax2.scatter(
cr_times,
excited_avg[1, :],
lw=0.3,
color=colors[1],
label=r"control in $|1\rangle$",
)
ax2.plot(cr_times, _avg_Y(cr_times, *excited_params), lw=2.0, color=colors[1])
ax3.scatter(
cr_times,
excited_avg[2, :],
lw=0.3,
color=colors[1],
label=r"control in $|1\rangle$",
)
ax3.plot(cr_times, _avg_Z(cr_times, *excited_params), lw=2.0, color=colors[1])
if not is_single_qubit_tomo:
coeffs, errors = get_interation_rates_MHz(
ground_params, excited_params, ground_cov, excited_cov
)
ax3.text(
cr_times[-1] / 2,
-2.55,
"ZX = %.3f (%2.f) MHz ZY = %.3f (%2.f) MHz ZZ = %.3f (%2.f) MHz"
% (
coeffs[1][0],
errors[1][0] * 1000,
coeffs[1][1],
errors[1][1] * 1000,
coeffs[1][2],
errors[1][2] * 1000,
),
fontsize="x-small",
horizontalalignment="center",
)
ax3.text(
cr_times[-1] / 2,
-2.9,
"IX = %.3f (%2.f) MHz IY = %.3f (%2.f) MHz IZ = %.3f (%2.f) MHz"
% (
coeffs[0][0],
errors[0][0] * 1000,
coeffs[0][1],
errors[0][1] * 1000,
coeffs[0][2],
errors[0][2] * 1000,
),
fontsize="x-small",
horizontalalignment="center",
)
else:
coeffs = ground_params / 2 / pi
errors = np.diagonal(ground_cov) ** 0.5 / 2 / pi
ax3.text(
cr_times[-1] / 2,
-2.55,
"X = %.3f (%2.f) MHz Y = %.3f (%2.f) MHz Z = %.3f (%2.f) MHz"
% (
coeffs[1],
errors[1] * 1000,
coeffs[2],
errors[2] * 1000,
coeffs[0],
errors[0] * 1000,
),
fontsize="x-small",
horizontalalignment="center",
)
# %% Iterative calibration
def _compute_drive_scale(
coeff_dict_1, coeff_dict_2, ix_params, prob_ix_strength, conjugate_pulse
):
vau1 = coeff_dict_1["IX"] + 1.0j * coeff_dict_1["IY"]
vau2 = coeff_dict_2["IX"] + 1.0j * coeff_dict_2["IY"]
A1 = ix_params["amp"] * np.exp(1.0j * ix_params["angle"])
A2 = (ix_params["amp"] + prob_ix_strength) * np.exp(1.0j * ix_params["angle"])
if conjugate_pulse:
return (vau2 - vau1) / np.conjugate(A2 - A1)
else:
return (vau2 - vau1) / (A2 - A1)
def _angle(c):
"""
User arctan to calculate the angle such that -1 won't be transfered to the angle parameters, in this way, a negative ZX will remains the same, not transfered to a positive ZX.
The output range is (-pi/2, pi/2)
"""
if c.real == 0.0:
return np.pi / 2
return np.arctan(c.imag / c.real)
def update_pulse_params(
coeff_dict_1,
coeff_dict_2,
cr_params,
ix_params,
prob_ix_strength,
target_IX_strength=None,
backend_name=None,
real_only=False,
):
"""
Update pulse parameters for CR and IX gates based on tomography results. Refer to arxiv 2303.01427 for the derivation.
Args:
coeff_dict_1 (dict): Coefficients from the first tomography job.
coeff_dict_2 (dict): Coefficients from the second tomography job.
cr_params (dict): Parameters for the CR gate pulse.
ix_params (dict): Parameters for the IX gate pulse.
prob_ix_strength (float): The strength of the IX gate pulse.
target_IX_strength (float, optional): Target angle for IX gate. Default is 0.
backend_name (str):
real_only: Update only the real part of the drive.
Returns:
tuple: Updated CR parameters, Updated IX parameters, None (for compatibility with CR-only calibration).
"""
cr_params = cr_params.copy()
ix_params = ix_params.copy()
if backend_name == "DynamicsBackend":
sign = -1 # dynamics end has a different convension
else:
sign = 1
if "ZX" in coeff_dict_1:
phi0 = _angle(coeff_dict_1["ZX"] + 1.0j * coeff_dict_1["ZY"])
else:
# No CR tomography, only single target qubit tomography.
phi0 = 0.0
cr_params["angle"] -= sign * phi0
drive_scale = _compute_drive_scale(
coeff_dict_1, coeff_dict_2, ix_params, prob_ix_strength, backend_name
)
logger.info(
"Estimated drive scale: \n"
f"{drive_scale/1000}" + "\n"
f"{drive_scale/np.exp(1.j*_angle(drive_scale))/1000}" + "\n"
f"{_angle(drive_scale)}"
)
# Update the IX drive strength and phase
vau1 = coeff_dict_1["IX"] + 1.0j * coeff_dict_1["IY"]
A1 = ix_params["amp"] * np.exp(sign * 1.0j * ix_params["angle"])
new_drive = (target_IX_strength - vau1) / drive_scale + A1
if real_only:
ix_params["amp"] = np.real(new_drive)
else:
new_angle = _angle(new_drive)
ix_params["amp"] = np.real(new_drive / np.exp(1.0j * new_angle))
ix_params["angle"] = sign * (new_angle - phi0)
if "ZX" in coeff_dict_1:
return (
cr_params,
ix_params,
None,
np.real(drive_scale / np.exp(1.0j * _angle(drive_scale)) / 1000),
)
else:
return (
cr_params,
None,
ix_params,
np.real(drive_scale / np.exp(1.0j * _angle(drive_scale)) / 1000),
)
def _update_frequency_offset(old_calibration_data, mode, backend_name):
"""
This should not be used separatly because applying more than once will lead to the wrong offset.
"""
new_calibration_data = deepcopy(old_calibration_data)
if mode == "CR":
coeffs_dict = old_calibration_data["coeffs"]
frequency_offset_key = "frequency_offset"
else:
coeffs_dict = old_calibration_data["x_gate_coeffs"]
frequency_offset_key = "x_gate_frequency_offset"
if backend_name == "DynamicsBackend":
correction = coeffs_dict["IZ"] * 1.0e6
else:
correction = -0.5 * coeffs_dict["IZ"] * 1.0e6
new_calibration_data[frequency_offset_key] = (
old_calibration_data.get(frequency_offset_key, 0.0) + correction
)
if np.abs(coeffs_dict["IZ"]) > 2.0:
logger.warning(
"Frequency offset larger than 2MHz, update is not applied. Please check if the fit is accurate."
)
return old_calibration_data
logger.info(
f"Frequency offset is updated to {new_calibration_data[frequency_offset_key]} Hz"
)
return new_calibration_data
def iterative_cr_pulse_calibration(
qubits,
backend,
cr_times,
session,
gate_name,
initial_calibration_data=None,
verbose=False,
threshold_MHz=0.015,
restart=False,
rerun_last_calibration=True,
max_repeat=4,
shots=None,
mode="CR",
IX_ZX_ratio=None,
save_result=True,
control_states=None,
):
"""
Iteratively calibrates CR pulses on the given qubits to remove the IX, ZY, IY terms. The result is saved in the carlibtaion data file and can be accessed via `read_calibration_data`.
Args:
qubits (list): Qubits involved in the calibration.
backend: Quantum backend.
cr_times (list): CR gate times for tomography.
session: Qiskit runtime session.
gate_name (str): Name of the CR gate. This will be used to identify the calibration data when retrieving the information.
initial_calibration_data (dict, optional): Initial parameters for calibration.
verbose (bool, optional): Whether to display detailed logging information. Default is False.
threshold_MHz (float, optional): Error threshold for calibration. Default is 0.015 GHz.
restart (bool, optional): Whether to restart calibration from scratch. Default is False.
rerun_last_calibration (bool, optional): Whether to rerun the last calibration. Default is True.
max_repeat (int, optional): Maximum number of calibration repetitions. Default is 4.
shots (int, optional): Number of shots for each tomography job. Default is 1024.
mode (str, optional): Calibration mode, "CR" or "IX-pi". Default is "CR". The CR mode is used to measure the ZX and ZZ strength. It only updates the phase of CR drive and the IX drive but not IY. The "IX-pi" mode updates the target drive for a CNOT gate.
"""
if control_states is None:
if mode == "CR":
control_states = (0, 1)
elif mode == "IX-pi":
control_states = (1,)
else:
ValueError("Mode must be either 'CR' or 'IX-pi/2'.")
if not restart:
try: # Load existing calibration
logger.info("Loading existing calibration data...")
qubit_calibration_data = read_calibration_data(backend, gate_name, (qubits))
qubit_calibration_data = deepcopy(qubit_calibration_data)
if mode == "IX-pi":
qubit_calibration_data["x_gate_ix_params"]
except KeyError: #
restart = True # we need to overwrite rerun_last_calibration=True
logger.warning(
f"Failed to find the calibration data for the gate{backend.name, gate_name, (qubits)}. Restarting from scratch."
)
if restart:
if not rerun_last_calibration:
logger.warning(
f"Last calibration job for {gate_name} not found or not used. Starting from scratch."
)
rerun_last_calibration = True
if mode == "CR":
if initial_calibration_data is None:
raise ValueError(
"Starting calibration from scratch, but initial parameters are not provided."
)
if (
"cr_params" not in initial_calibration_data
or "ix_params" not in initial_calibration_data
):
raise ValueError(
"The initial pulse parameters for the CR and target drive must be provided."
)
qubit_calibration_data = initial_calibration_data
else:
logger.info("Loading existing calibration data...")
qubit_calibration_data = read_calibration_data(backend, gate_name, (qubits))
qubit_calibration_data = deepcopy(qubit_calibration_data)
qubit_calibration_data["x_gate_ix_params"] = qubit_calibration_data[
"ix_params"
].copy()
qubit_calibration_data["x_gate_ix_params"]["amp"] = 0.0
qubit_calibration_data["x_gate_ix_params"]["angle"] = 0.0
if "beta" in qubit_calibration_data["x_gate_ix_params"]:
del qubit_calibration_data["x_gate_ix_params"]["beta"]
qubit_calibration_data["x_gate_frequency_offset"] = qubit_calibration_data[
"frequency_offset"
]
shots = 512 if shots is None else shots
if mode == "CR" and IX_ZX_ratio is None:
IX_ZX_ratio = 0.0
elif mode == "IX-pi" and IX_ZX_ratio is None:
IX_ZX_ratio = -2
try:
target_IX_strength = qubit_calibration_data["coeffs"]["ZX"] * IX_ZX_ratio
except:
target_IX_strength = 0.0
logger.info(f"Target IX / ZX ratio: {IX_ZX_ratio}")
def _get_error(coeff_dict, mode, target_IX):
if mode == "CR":
error = np.array(
(coeff_dict["IX"] - target_IX, coeff_dict["IY"], coeff_dict["ZY"])
)
elif mode == "IX-pi":
error = np.array((coeff_dict["IX"] - target_IX, coeff_dict["IY"]))
error = np.abs(error)
max_error = np.max(error)
return max_error
def _error_smaller_than(coeff_dict, threshold_MHz, mode, target_IX=None):
"""
Compare the measured coupling strength and check if the error terms are smaller than the threshold.
Args:
coeff_dict (dict): Coefficients from tomography job.
threshold_MHz (float): Error threshold for calibration.
mode (str): Calibration mode, "CR" or "IX-pi/2".
target_IX (float, optional): Target IX angle. Default is None.
Returns:
bool: True if error is smaller than threshold, False otherwise.
"""
if mode == "CR":
error = np.array(
(coeff_dict["IX"] - target_IX, coeff_dict["IY"], coeff_dict["ZY"])
)
elif mode == "IX-pi":
error = np.array((coeff_dict["IX"] - target_IX, coeff_dict["IY"]))
error = np.abs(error)
max_error = np.max(error)
error_type = ["IX", "IY", "ZY"][np.argmax(np.abs(error))]
logger.info(f"Remaining dominant error: {error_type}: {max_error} MHz" + "\n")
return max_error < threshold_MHz
def _step_cr(qubit_calibration_data, n):
"""
Submit two jobs, one with the given pulse parameter. If the calibration is not finished, submit another one with a shifted amplitude for the target drive. This will be used to calculate a new set of pulse parameters and returned.
Args:
qubit_calibration_data (dict): Calibration data.
prob_ix_strength (float): Strength of the IX gate pulse.
n (int): Calibration iteration number.
Returns:
tuple: Updated qubit_calibration_data, Calibration success flag.
"""
cr_params = qubit_calibration_data["cr_params"]
ix_params = qubit_calibration_data["ix_params"]
x_gate_ix_params = None
frequency_offset = qubit_calibration_data.get("frequency_offset", 0.0)
if not rerun_last_calibration and n == 1:
# If the last calibration was ran very recently, we can skip the first experiment that just rerun the tomography for the same pulse parameters.
tomo_id1 = qubit_calibration_data["calibration_job_id"]
else:
# Run tomography experiment for the given parameters.
tomo_id1 = send_cr_tomography_job(
(qubits),
backend,
cr_params,
ix_params,
cr_times,
x_gate_ix_params=x_gate_ix_params,
frequency_offset=frequency_offset,
blocking=True,
session=session,
shots=shots,
control_states=control_states,
)
coeff_dict_1 = process_zx_tomo_data(tomo_id1, show_plot=verbose)
target_IX_strength = (
IX_ZX_ratio
* np.sign(coeff_dict_1["ZX"])
* np.sqrt(coeff_dict_1["ZX"] ** 2 + coeff_dict_1["ZY"] ** 2)
)
if verbose:
logger.info("Tomography results:\n" + str(coeff_dict_1) + "\n")
qubit_calibration_data.update(
{
"calibration_job_id": tomo_id1,
"coeffs": coeff_dict_1,
}
)
# Interrupt the process if the calibration is successful or maximal repeat number is reached.
if np.abs(qubit_calibration_data["coeffs"]["IZ"]) > threshold_MHz:
if not (not rerun_last_calibration and n == 1):
qubit_calibration_data = _update_frequency_offset(
qubit_calibration_data, mode, backend.name
)
if _error_smaller_than(coeff_dict_1, threshold_MHz, mode, target_IX_strength):
logger.info("Successfully calibrated.")
return qubit_calibration_data, True
if n > max_repeat:
logger.info(
f"Maximum repeat number {max_repeat} reached, calibration terminates."
)
return qubit_calibration_data, True
# If not completed, send another job with shifted IX drive amplitude.
# Remark: There is a strange observation that the Omega_GHz_amp_ratio measured here is not the same as the one estimated from single-qubit gate duration. There is a
Omega_GHz_amp_ratio = qubit_calibration_data.get(
"_omega_amp_ratio", amp_to_omega_GHz(backend, qubits[1], 1)
)
logger.info(f"Omega[GHz]/amp: {Omega_GHz_amp_ratio}")
Omega_GHz_amp_ratio = np.real(Omega_GHz_amp_ratio)
prob_ix_strength_MHz = target_IX_strength - coeff_dict_1["IX"]
if np.abs(prob_ix_strength_MHz) > 0.1: # Minimum 0.1 MHz
prob_ix_strength = prob_ix_strength_MHz * 1.0e-3 / Omega_GHz_amp_ratio
logger.info(f"Probe amp shift [MHz]: {prob_ix_strength_MHz} MHz")
else:
prob_ix_strength = (
np.sign(prob_ix_strength_MHz) * 0.1e-3 / Omega_GHz_amp_ratio
)
logger.info("Probe amp shift [MHz]: 0.1 MHz")
logger.info(f"Probe amp shift (amp): {prob_ix_strength}")
tomo_id2 = shifted_parameter_cr_job(
qubits,
backend,
cr_params,
ix_params,
cr_times,
prob_ix_strength,
x_gate_ix_params=x_gate_ix_params,
frequency_offset=frequency_offset,
blocking=True,
session=session,
shots=shots,
control_states=control_states,
)
coeff_dict_2 = process_zx_tomo_data(tomo_id2, show_plot=verbose)
if verbose:
logger.info(coeff_dict_2)
# Compute the new parameters.
(
cr_params,
updated_ix_params,
updated_x_gate_ix_params,
omega_amp_ratio,
) = update_pulse_params(
coeff_dict_1,
coeff_dict_2,
cr_params,
ix_params,
prob_ix_strength,
target_IX_strength=target_IX_strength,
backend_name=backend.name,
# only update the real part, imaginary part can be
# unstable for small pulse ampliutude.
real_only=True,
)
# This should not be added before the second experiment because it should only have a different IX drive amplitude.
qubit_calibration_data.update(
{
"cr_params": cr_params,
"ix_params": updated_ix_params,
"_omega_amp_ratio": np.real(omega_amp_ratio),
}
)
return qubit_calibration_data, False
def _step_ix(qubit_calibration_data, n):
"""
Submit two jobs, one with the given pulse parameter. If the calibration is not finished, submit another one with a shifted amplitude for the target drive. This will be used to calculate a new set of pulse parameters and returned.
Args:
qubit_calibration_data (dict): Calibration data.
prob_ix_strength (float): Strength of the IX gate pulse.
n (int): Calibration iteration number.
Returns:
tuple: Updated qubit_calibration_data, Calibration success flag.
"""
if len(control_states) == 2:
process_data_fun = process_zx_tomo_data
else:
process_data_fun = process_single_qubit_tomo_data
cr_params = qubit_calibration_data["cr_params"]
ix_params = qubit_calibration_data["ix_params"]
x_gate_ix_params = qubit_calibration_data["x_gate_ix_params"]
frequency_offset = qubit_calibration_data.get("x_gate_frequency_offset", 0.0)
if not rerun_last_calibration and n == 1:
# If the last calibration was ran very recently, we can skip the first experiment that just rerun the tomography for the same pulse parameters.
tomo_id1 = qubit_calibration_data["x_gate_calibration_job_id"]
else:
# Run tomography experiment for the given parameters.
tomo_id1 = send_cr_tomography_job(
(qubits),
backend,
cr_params,
ix_params,
cr_times,
x_gate_ix_params=x_gate_ix_params,
frequency_offset=frequency_offset,
blocking=True,
session=session,
shots=shots,
control_states=control_states,
)
coeff_dict_1 = process_data_fun(tomo_id1, show_plot=verbose)
if verbose:
logger.info("Tomography results:\n" + str(coeff_dict_1) + "\n")
qubit_calibration_data.update(
{
"x_gate_calibration_job_id": tomo_id1,
"x_gate_coeffs": coeff_dict_1,
}
)
# Interrupt the process if the calibration is successful or maximal repeat number is reached.
if np.abs(qubit_calibration_data["coeffs"]["IZ"]) > threshold_MHz:
if not (not rerun_last_calibration and n == 1):
qubit_calibration_data = _update_frequency_offset(
qubit_calibration_data, mode, backend.name
)
if _error_smaller_than(coeff_dict_1, threshold_MHz, mode, target_IX_strength):
logger.info("Successfully calibrated.")
return qubit_calibration_data, True
if n > max_repeat:
logger.info(
f"Maximum repeat number {max_repeat} reached, calibration terminates."
)
return qubit_calibration_data, True
# If not completed, send another job with shifted IX drive amplitude.
Omega_GHz_amp_ratio = qubit_calibration_data.get(
"_omega_amp_ratio", amp_to_omega_GHz(backend, qubits[1], 1)
)
Omega_GHz_amp_ratio = np.real(Omega_GHz_amp_ratio)
logger.info(f"Omega[GHz]/amp: {Omega_GHz_amp_ratio}")
prob_ix_strength_MHz = target_IX_strength - coeff_dict_1["IX"]
if np.abs(prob_ix_strength_MHz) > 0.1: # Minimum 0.1 MHz
prob_ix_strength = prob_ix_strength_MHz * 1.0e-3 / Omega_GHz_amp_ratio
logger.info(f"Probe amp shift [MHz]: {prob_ix_strength_MHz} MHz")
else:
prob_ix_strength = (
np.sign(prob_ix_strength_MHz) * 0.1e-3 / Omega_GHz_amp_ratio
)
logger.info("Probe amp shift [MHz]: 0.1 MHz")
logger.info(f"Probe amp shift (amp): {prob_ix_strength}")
tomo_id2 = shifted_parameter_cr_job(
qubits,
backend,
cr_params,
ix_params,
cr_times,
prob_ix_strength,
x_gate_ix_params=x_gate_ix_params,
frequency_offset=frequency_offset,
blocking=True,
session=session,
shots=shots,
control_states=control_states,
mode=mode,
)
coeff_dict_2 = process_data_fun(tomo_id2, show_plot=verbose)
if verbose:
logger.info(coeff_dict_2)
# Compute the new parameters.
cr_params, _, updated_x_gate_ix_params, omega_amp_ratio = update_pulse_params(
coeff_dict_1,
coeff_dict_2,
cr_params,
x_gate_ix_params,
prob_ix_strength,
target_IX_strength=target_IX_strength,
backend_name=backend.name,
)
qubit_calibration_data.update(
{
"x_gate_ix_params": updated_x_gate_ix_params,
"_omega_amp_ratio": np.real(omega_amp_ratio),
}
)
return qubit_calibration_data, False
succeed = False
n = 1
error = np.inf
while (
not succeed and n <= max_repeat + 1
): # +1 because we need one last run for the calibration data.
logger.info(f"\n\nCR calibration round {n}: ")
if mode == "CR":
qubit_calibration_data, succeed = _step_cr(qubit_calibration_data, n)
else:
qubit_calibration_data, succeed = _step_ix(qubit_calibration_data, n)
target_IX_strength = qubit_calibration_data["coeffs"]["ZX"] * IX_ZX_ratio
new_error = _get_error(
qubit_calibration_data["coeffs"], mode, target_IX_strength
)
if save_result and new_error < error:
save_calibration_data(backend, gate_name, qubits, qubit_calibration_data)
logger.info("CR calibration data saved.")
n += 1
shots = 2 * shots if shots < 2048 else shots
if not succeed:
logger.warn(f"CR calibration failed after {n} round.")
def iy_drag_calibration(
qubits,
backend,
gate_name,
cr_times,
session,
verbose=False,
threshold_MHz=0.015,
delta_beta=None,
shots=1024,
):
"""Calibrate the IY-DRAG pulse for the qubits and a precalibrated CR pulse. It samples 3 "beta" value in the "ix_params" and perform an linear fit to obtain the correct IY-DRAG coefficient "beta" that zeros the ZZ interaction.
Args:
qubits (Tuple): Tuple containing the qubits involved in the gate.
backend: The quantum backend.
gate_name (str): Name of the gate for calibration. The pre calibrated CR pulse will be read from the database.
cr_times (List): List of control pulse durations for CR experiments.
session: Qiskit runtime session.
verbose (bool, optional): Whether to display additional information. Defaults to False.
threshold_MHz (float, optional): The error threshold for calibration in MHz. Defaults to 0.015.
delta_beta (float, optional): The step size for beta parameter calibration. Defaults to None.
"""
logger.info("\n" + f"Calibrating the IY-DRAG pulse for {qubits}-{gate_name}.")
qubit_calibration_data = read_calibration_data(backend, gate_name, qubits)
cr_params = qubit_calibration_data["cr_params"]
ix_params = qubit_calibration_data["ix_params"]
frequency_offset = qubit_calibration_data.get("frequency_offset", 0.0)
# Sample three different IY strength.
old_beta = ix_params.get("beta", 0.0)
if "drag_type" in ix_params:
ix_params["drag_type"] = "01"
default_delta_beta = 2.0
elif "drag_type" not in ix_params:
default_delta_beta = 100.0
else:
raise ValueError("Unknown drag type.")
delta_beta = (
old_beta
if (old_beta > default_delta_beta and delta_beta is None)
else delta_beta
)
delta_beta = default_delta_beta if delta_beta is None else delta_beta
beta_list = np.array([0.0, -delta_beta, delta_beta]) + old_beta
ZZ_coeff_list = []
for _, beta in enumerate(beta_list):
if np.abs(beta - old_beta) < 1.0e-6:
_shots = shots * 2
else:
_shots = shots
ix_params["beta"] = beta
job_id = send_cr_tomography_job(
qubits,
backend,
cr_params,
ix_params,
cr_times,
frequency_offset=frequency_offset,
blocking=True,
session=session,
shots=_shots,
)
coeff_dict = process_zx_tomo_data(job_id, show_plot=verbose)
ZZ_coeff_list.append(coeff_dict["ZZ"])
if abs(beta - old_beta) < 1.0e-5 and abs(coeff_dict["ZZ"]) < threshold_MHz:
logger.info(
f"ZZ error {round(coeff_dict['ZZ'], 3)} MHz, no need for further calibration."
)
qubit_calibration_data.update(
{
"calibration_job_id": job_id,
"coeffs": coeff_dict,
}
)
save_calibration_data(backend, gate_name, qubits, qubit_calibration_data)
if np.abs(qubit_calibration_data["coeffs"]["IZ"]) > threshold_MHz:
qubit_calibration_data = _update_frequency_offset(
qubit_calibration_data, "CR", backend.name
)
return
logger.info(f"ZZ sampling measurements complete : {ZZ_coeff_list}." + "\n")
# Fit a linear curve.
fun = lambda x, a, b: a * x + b
par, _ = curve_fit(fun, beta_list, ZZ_coeff_list)
calibrated_beta = -par[1] / par[0]
logger.info(f"Calibrated IY beta: {calibrated_beta}" + "\n")
if verbose:
fig, ax = plt.subplots(figsize=(4, 2), dpi=100)
plt.scatter(beta_list, ZZ_coeff_list)
x_line = np.linspace(min(beta_list), max(beta_list))
y_line = fun(x_line, *par)
plt.plot(x_line, y_line)
plt.xlabel("beta")
plt.ylabel("ZZ [MHz]")
plt.show()
# Perform a final tomography measurement.
ix_params["beta"] = calibrated_beta
job_id = send_cr_tomography_job(
qubits,
backend,
cr_params,
ix_params,
cr_times,
frequency_offset=frequency_offset,
blocking=True,
session=session,
shots=shots * 2,
)
# Compute the interaction strength and save the calibration data.
coeff_dict = process_zx_tomo_data(job_id, show_plot=verbose)
logger.info(f"Updated coupling strength: {coeff_dict}")
qubit_calibration_data.update(
{
"calibration_job_id": job_id,
"coeffs": coeff_dict,
"ix_params": ix_params,
}
)
if np.abs(qubit_calibration_data["coeffs"]["IZ"]) > threshold_MHz:
qubit_calibration_data = _update_frequency_offset(
qubit_calibration_data, "CR", backend.name
)
save_calibration_data(backend, gate_name, qubits, qubit_calibration_data)
logger.info(f"IY-DRAG calibration complete, new calibration data saved.")
|
https://github.com/BoxiLi/qiskit-CR-calibration
|
BoxiLi
|
import sys
import os
current_dir = os.getcwd()
sys.path.append(current_dir)
from quantum_circuit import QuantumCircuit
# import qiskit.providers.fake_provider
from qiskit.transpiler import CouplingMap
import qiskit_ibm_runtime.fake_provider
from Backend.backend import Backend
class FakeBackend(Backend):
def __init__(self, backend_name : str) -> None:
self.backend = FakeBackend.get_ibm_fake_backend(backend_name=backend_name)
@staticmethod
def get_ibm_fake_backend_name_list() -> list[str]:
ibm_dir = dir(qiskit_ibm_runtime.fake_provider)
return [val for val in ibm_dir if '__' not in val and 'Fake' in val]
@staticmethod
def get_ibm_fake_backend(backend_name : str):
try:
return getattr(qiskit_ibm_runtime.fake_provider, backend_name)()
except: pass
fake_backend_name = FakeBackend.get_ibm_fake_backend_name_list()
for backend in fake_backend_name:
backend = FakeBackend.get_ibm_fake_backend(backend)
if backend is not None:
try:
if backend.name == backend_name:
return backend
except: pass
return None
@staticmethod
def get_ibm_fake_backend_names_with_limit(min_qubit : int = 1, max_qubit: int = float('inf')) -> list[str]:
limited_backend = []
fake_backend_name = FakeBackend.get_ibm_fake_backend_name_list()
for backend in fake_backend_name:
backend = FakeBackend.get_ibm_fake_backend(backend)
if backend is not None:
try:
num_qubit = backend.num_qubits
if num_qubit >= min_qubit and num_qubit <= max_qubit:
limited_backend.append(backend.name)
except: pass
return limited_backend
if __name__ == "__main__":
print(FakeBackend.get_ibm_fake_backend_name_list())
backend = FakeBackend('fake_auckland')
qc = QuantumCircuit(2)
qc.x(0)
qc.h(1)
qc.measure_all()
print(qc.draw())
job = backend.run(qc)
print(job.result())
qc_transpile = backend.traspile_qiskit(qc)[0]
print(qc_transpile.draw())
job = backend.run(qc_transpile)
print(job.result())
|
https://github.com/devilkiller-ag/UnravelQuantum
|
devilkiller-ag
|
# ########## Import Initialization ############
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit.providers.basic_provider import BasicProvider
from qiskit.visualization import plot_histogram, circuit_drawer
from qiskit_ibm_provider.job import job_monitor
from qiskit_ibm_provider import IBMProvider
import streamlit as st
import matplotlib.pyplot as plt
from random import choice
# #############################################
# ########## Deustch Josza Algorithm ##########
def generate_bitstring(n):
return "".join(choice("01") for _ in range(n))
def ConstantFunctionOracle(n, output):
oracle = QuantumCircuit(n + 1) # n input qubits, 1 ancillia qubit for |->
if output == 0:
return oracle
elif output == 1:
# Performing X on all qubits except one qubit(k) is computationally same as performing X only on one qubit(k)
oracle.x(n)
return oracle
else:
return "Error: Invalid function output"
def BalancedFunctionOracle(n):
xGatesString = cxGatesString = generate_bitstring(n)
if len(xGatesString) != n:
return "Error: Invalid length of X Gate String"
if len(cxGatesString) != n:
return "Error: Invalid length of CX Gate String"
oracle = QuantumCircuit(n + 1) # n input qubits, 1 ancillia qubit for |->
# Place X-gates before implementing CX gates in the next loop
for i in range(n):
if xGatesString[i] == "1":
oracle.x(i)
# Place CX-gates to give phase at desired combinations
for m in range(n):
if cxGatesString[m] == "1":
oracle.cx(m, n)
# Place X-gates again to revert to original inputs on 0 to n-1 qubits
for k in range(n):
if xGatesString[k] == "1":
oracle.x(k)
return oracle
def DeustchJoszaAlgo(n, FunctionOracle):
dj_circuit = QuantumCircuit(n + 1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put ancillia qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
dj_circuit.barrier()
# Add Oracle
dj_circuit = dj_circuit.compose(FunctionOracle)
dj_circuit.barrier()
# Repeat H-Gates
for qubit in range(n):
dj_circuit.h(qubit)
dj_circuit.barrier()
# Measure
for i in range(n):
dj_circuit.measure(i, i)
return dj_circuit
def RunCircuit(circuit, provider, backend_name, shots=1024):
backend = provider.get_backend(backend_name)
job = transpile(circuit, backend=backend, shots=shots)
results = job.result()
counts = results.get_counts()
job_monitor(job)
job.status()
return counts
def run_on_simulator(circuit, provider, backend):
answer = RunCircuit(circuit, provider, backend, shots=1024)
st.subheader("Result Counts:")
st.write(answer) # Display result counts as text
st.subheader("Histogram:")
fig, ax = plt.subplots() # Create a Matplotlib figure and axes
plot_histogram(answer, ax=ax) # Pass the axes to the plot_histogram function
st.pyplot(fig) # Display the Matplotlib figure using st.pyplot
def run_on_real_backend(circuit, provider_api_key, backend):
IBMProvider.save_account(provider_api_key, overwrite=True)
provider = IBMProvider()
# backend = 'ibm_perth'
answer = RunCircuit(circuit, provider, backend, shots=1024)
st.subheader("Result Counts:")
st.write(answer) # Display result counts as text
st.subheader("Histogram:")
fig, ax = plt.subplots() # Create a Matplotlib figure and axes
plot_histogram(answer, ax=ax) # Pass the axes to the plot_histogram function
st.pyplot(fig) # Display the Matplotlib figure using st.pyplot
# ########## Use the DJ Algorithm ##########
# Page Config
st.set_page_config(page_title='Deustch Josza Algorithm - Unravel Quantum', page_icon="⚔️", layout='wide')
st.title("Deustch Josza Algorithm")
n = st.slider("Select the number of qubits (n)", 1, 10, 3)
st.write(f"Selected number of qubits: {n}")
f0allx = ConstantFunctionOracle(n, 0)
f1allx = ConstantFunctionOracle(n, 1)
f01half = BalancedFunctionOracle(n)
functions = {"Constant Function (f(x) = 0)": f0allx, "Constant Function (f(x) = 1)": f1allx, "Balanced Function": f01half}
selected_function = st.selectbox("Select the type of function", list(functions.keys()))
dj_circuit = DeustchJoszaAlgo(n, functions[selected_function])
st.write("**Circuit**")
fig, ax = plt.subplots()
circuit_drawer(dj_circuit, output='mpl', ax=ax) # Display the circuit using Matplotlib
st.pyplot(fig) # Show the Matplotlib figure in Streamlit
# providers = {"BasicAer": BasicProvider, "AerSimulator": AerSimulator}
providers = {"BasicAer": BasicProvider}
selected_provider = st.selectbox("Select Provider", list(providers.keys()))
backends = providers[selected_provider]().backends()
selected_backend = st.selectbox("Select Backend", list(backends))
if st.button("Run on Simulator") and selected_provider in providers:
run_on_simulator(dj_circuit, providers[selected_provider], str(selected_backend))
# provider_api_key = st.text_input("Enter your IBM Quantum Experience API Key (for real backend)")
# if st.button("Run on Real Backend") and provider_api_key:
# backends = IBMProvider.backends()
# selected_backend = st.selectbox("Select Backend", list(backends))
# run_on_real_backend(dj_circuit, provider_api_key, selected_backend)
# ################################### Show the Implementation #########################################
dj_algo_code = '''
# Importing libraries
from qiskit import QuantumCircuit, transpile
from qiskit.providers.basic_provider import BasicProvider
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram, circuit_drawer
from qiskit_ibm_provider.job import job_monitor
from qiskit_ibm_provider import IBMProvider
from random import choice
def ConstantFunctionOracle(n, output):
oracle = QuantumCircuit(n + 1) # n input qubits, 1 ancillia qubit for |->
if output == 0:
return oracle
elif output == 1:
# Performing X on all qubits except one qubit(k) is computationally same as performing X only on one qubit(k)
oracle.x(n)
return oracle
else:
return "Error: Invalid function output"
def BalancedFunctionOracle(n, xGatesString, cxGatesString):
if len(xGatesString) != n:
return "Error: Invalid length of X Gate String"
if len(cxGatesString) != n:
return "Error: Invalid length of CX Gate String"
oracle = QuantumCircuit(n + 1) # n input qubits, 1 ancillia qubit for |->
# Place X-gates before implementing CX gates in the next loop
for i in range(n):
if xGatesString[i] == "1":
oracle.x(i)
# Place CX-gates to give phase at desired combinations
for m in range(n):
if cxGatesString[m] == "1":
oracle.cx(m, n)
# Place X-gates again to revert to original inputs on 0 to n-1 qubits
for k in range(n):
if xGatesString[k] == "1":
oracle.x(k)
return oracle
def DeustchJoszaAlgo(n, FunctionOracle):
dj_circuit = QuantumCircuit(n + 1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put ancillia qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
dj_circuit.barrier()
# Add Oracle
dj_circuit = dj_circuit.compose(FunctionOracle)
dj_circuit.barrier()
# Repeat H-Gates
for qubit in range(n):
dj_circuit.h(qubit)
dj_circuit.barrier()
# Measure
for i in range(n):
dj_circuit.measure(i, i)
return dj_circuit
def RunCircuit(circuit, provider, backend_name, shots=1024):
backend = provider.get_backend(backend_name)
transpiled_circuit = transpile(circuit, backend=backend)
job = backend.run(transpiled_circuit, shots=shots)
results = job.result()
counts = results.get_counts()
job_monitor(job)
job.status()
return counts
def run_on_simulator(circuit, provider, backend, shots=1024):
answer = RunCircuit(circuit, provider, backend, shots)
plot_histogram(answer)
return answer
def run_on_real_backend(circuit, provider_api_key, backend, shots=1024):
IBMProvider.save_account(provider_api_key, overwrite=True)
provider = IBMProvider()
answer = RunCircuit(circuit, provider, backend, shots)
plot_histogram(answer)
return answer
# Create DJ Circuit
f0allx = ConstantFunctionOracle(n, 0)
f1allx = ConstantFunctionOracle(n, 1)
f01half = BalancedFunctionOracle(n, "101", "101")
dj_circuit = DeustchJoszaAlgo(n, f01half)
dj_circuit.draw('mpl')
# Run on the simulator
provider = BasicProvider
backend = 'qasm_simulator'
run_on_simulator(dj_circuit, provider, backend, shots=1024)
# Run on the real backend
# provider_api_key = # your provider api key
backend = 'ibm_perth'
# run_on_real_backend(dj_circuit, provider_api_key, backend, shots=1024)
'''
st.subheader("Implementation of Deustch Josza Algorithm")
st.write("""
Reference:
- [Deustch Josza Algorithm - Qiskit Textbook](https://learn.qiskit.org/course/ch-algorithms/deutsch-jozsa-algorithm)
- [Deustch Josza Algorithm - Classiq](https://www.classiq.io/insights/the-deutsch-jozsa-algorithm-explained)
""")
st.code(dj_algo_code, language='python')
# ################################### About the author #########################################
st.subheader("About the author: [Ashmit JaiSarita Gupta](https://jaisarita.vercel.app/)")
st.write("""
[Ashmit JaiSarita Gupta](https://jaisarita.vercel.app/) is an engineering physics undergraduate passionate about Quantum Computing, Machine Learning, UI/UX, and Web Development. I am a student driven by the community and who shares what he has learned. I love to work on real world projects about the topics I learn which can be used by others. To accomplish this I frequently attend hackathons and collaborate with companies to work on real-world projects related to my domains. Feel free to contact me if your company is interested in working on awesome projects in these fields with me. I’m currently building most frequently with: JavaScript/Typescript, C++, and Python.Some of the main frameworks and libraries I frequently use are: React.js,Express.js, Tailwind CSS, ShadCN UI, Qiskit,and Pytorch. Explore the below links to explore more about him, his previous projects, blogs, and experience at various organizations.
""")
# ############ Socials ############
c1, c2, c3 = st.columns(3)
with c1:
st.info('**Portfolio: [Ashmit JaiSarita Gupta](https://jaisarita.vercel.app/)**', icon="🔥")
with c2:
st.info('**GitHub: [@devilkiller-ag](https://github.com/devilkiller-ag)**', icon="😸")
with c3:
st.info('**GitLab: [@devilkiller-ag](https://gitlab.com/devilkiller-ag)**', icon="🚀")
c4, c5, c6 = st.columns(3)
with c4:
st.info('**LinkedIn: [jaisarita](https://www.linkedin.com/in/jaisarita/)**', icon="🌐")
with c5:
st.info('**Twitter: [@jaisarita](https://github.com/devilkiller-ag)**', icon="🐤")
with c6:
st.info('**Hashnode: [jaisarita](https://jaisarita.hashnode.dev/)**', icon="✍🏻")
|
https://github.com/devilkiller-ag/UnravelQuantum
|
devilkiller-ag
|
# ########## Import Initialization ############
from qiskit import QuantumCircuit, transpile
from qiskit.providers.basic_provider import BasicProvider
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram, circuit_drawer
from qiskit_ibm_provider.job import job_monitor
from qiskit_ibm_provider import IBMProvider
import streamlit as st
import matplotlib.pyplot as plt
from random import choice
# #############################################
# ########## Bernstien Vazirani Algorithm ##########
def generate_secret_bitstring(n):
return "".join(choice("01") for _ in range(n))
# Oracle to implement bitstring multiplication with input state
def BVOracle(n, s=""):
oracle = QuantumCircuit(n + 1)
s = s or generate_secret_bitstring(n) # the hidden binary string
# print(s)
index = n - 1
for q in s:
if q == "1":
oracle.cx(index, n)
index -= 1
return oracle
def BernsteinVaziraniAlgo(n, bv_oracle):
# We need a circuit with n qubits, plus one ancilla qubit
# Also we need n classical bits to write the output
bv_circuit = QuantumCircuit(n + 1, n)
# Apply Hadamard gates before querying the oracle
for i in range(n):
bv_circuit.h(i)
# Put Ancilla Qubit in state |->
bv_circuit.x(n)
bv_circuit.h(n)
# Apply barrier
bv_circuit.barrier()
bv_circuit = bv_circuit.compose(bv_oracle)
# Apply barrier
bv_circuit.barrier()
# Apply Hadamard gates before querying the oracle
for i in range(n):
bv_circuit.h(i)
# Apply Measurement
for i in range(n):
bv_circuit.measure(i, i)
return bv_circuit
def RunCircuit(circuit, provider, backend_name, shots=1024):
backend = provider.get_backend(backend_name)
transpiled_circuit = transpile(circuit, backend=backend)
job = backend.run(transpiled_circuit, shots=shots)
results = job.result()
counts = results.get_counts()
job_monitor(job)
job.status()
return counts
def run_on_simulator(circuit, provider, backend):
answer = RunCircuit(circuit, provider, backend, shots=1024)
st.subheader("Result Counts:")
st.write(answer) # Display result counts as text
st.subheader("Histogram:")
fig, ax = plt.subplots() # Create a Matplotlib figure and axes
plot_histogram(answer, ax=ax) # Pass the axes to the plot_histogram function
st.pyplot(fig) # Display the Matplotlib figure using st.pyplot
def run_on_real_backend(circuit, provider_api_key, backend):
IBMProvider.save_account(provider_api_key, overwrite=True)
provider = IBMProvider()
# backend = 'ibm_perth'
answer = RunCircuit(circuit, provider, backend, shots=1024)
st.subheader("Result Counts:")
st.write(answer) # Display result counts as text
st.subheader("Histogram:")
fig, ax = plt.subplots() # Create a Matplotlib figure and axes
plot_histogram(answer, ax=ax) # Pass the axes to the plot_histogram function
st.pyplot(fig) # Display the Matplotlib figure using st.pyplot
# ########## Use the DJ Algorithm ##########
# Page Config
st.set_page_config(
page_title="Bernstein Vazirani Algorithm - Unravel Quantum",
page_icon="⚔️",
layout="wide",
)
st.title("Bernstein Vazirani Algorithm")
# n = st.slider("Select the number of qubits (n)", 1, 10, 3)
s = "" # secret binary string
header = st.columns([1])
header[0].write("**Number of qubits**")
input = st.columns([1])
n = input[0].slider(
"Select the number of qubits (n)", 1, 10, 3, label_visibility="hidden"
)
st.write(f"Selected number of qubits: {n}")
header2 = st.columns([1])
header2[0].write("**Secret Bitstring**")
input2 = st.columns([1, 1])
radio_choice = input2[0].radio(
"Secret Bitstring",
["Generate Random Secret Bitstring", "Enter Your Own Secret Bitstring Here"],
label_visibility="hidden",
)
if radio_choice == "Enter Your Own Secret Bitstring Here":
s = input2[1].text_input(
label="Create Your Own Secret Bitstring",
placeholder="Enter Your Own Secret Bitstring Here",
label_visibility="hidden",
disabled=(radio_choice == "Generate Random Secret Bitstring"),
)
s = s or generate_secret_bitstring(n)
bv_oracle = BVOracle(n, s)
bv_circuit = BernsteinVaziraniAlgo(n, bv_oracle)
st.write("**Circuit**")
fig, ax = plt.subplots()
circuit_drawer(bv_circuit, output='mpl', ax=ax) # Display the circuit using Matplotlib
st.pyplot(fig) # Show the Matplotlib figure in Streamlit
# providers = {"BasicAer": BasicProvider, "AerSimulator": AerSimulator}
providers = {"BasicAer": BasicProvider}
selected_provider = st.selectbox("Select Provider", list(providers.keys()))
backends = providers[selected_provider]().backends()
selected_backend = st.selectbox("Select Backend", list(backends))
if st.button("Run on Simulator"):
st.write("Secret Bitstring: ", s)
if selected_provider in providers:
run_on_simulator(bv_circuit, providers[selected_provider], str(selected_backend))
# provider_api_key = st.text_input("Enter your IBM Quantum Experience API Key (for real backend)")
# if st.button("Run on Real Backend") and provider_api_key:
# backends = IBMProvider.backends()
# selected_backend = st.selectbox("Select Backend", list(backends))
# run_on_real_backend(bv_circuit, provider_api_key, selected_backend)
# ################################### Show the Implementation #########################################
bv_algo_code = """
# Importing libraries
from qiskit import QuantumCircuit, transpile
from qiskit.providers.basic_provider import BasicProvider
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram, circuit_drawer
from qiskit_ibm_provider.job import job_monitor
from qiskit_ibm_provider import IBMProvider
from random import choice
def generate_secret_bitstring(n):
return ''.join(choice('01') for _ in range(n))
# Oracle to implement bitstring multiplication with input state
def BVOracle(n, s=''):
oracle = QuantumCircuit(n+1)
s = s if s else generate_secret_bitstring(n) # the hidden binary string
# print(s)
index = n-1
for q in s:
if q == '1':
oracle.cx(index, n)
index-=1
return oracle
def BernsteinVaziraniAlgo(n, bv_oracle):
# We need a circuit with n qubits, plus one ancilla qubit
# Also we need n classical bits to write the output
bv_circuit = QuantumCircuit(n+1, n)
# Apply Hadamard gates before querying the oracle
for i in range(n):
bv_circuit.h(i)
# Put Ancilla Qubit in state |->
bv_circuit.x(n)
bv_circuit.h(n)
# Apply barrier
bv_circuit.barrier()
bv_circuit = bv_circuit.compose(bv_oracle)
# Apply barrier
bv_circuit.barrier()
# Apply Hadamard gates before querying the oracle
for i in range(n):
bv_circuit.h(i)
# Apply Measurement
for i in range(n):
bv_circuit.measure(i, i)
return bv_circuit
def RunCircuit(circuit, provider, backend_name, shots=1024):
backend = provider.get_backend(backend_name)
transpiled_circuit = transpile(circuit, backend=backend)
job = backend.run(transpiled_circuit, shots=shots)
results = job.result()
counts = results.get_counts()
job_monitor(job)
job.status()
return counts
def run_on_simulator(circuit, provider, backend, shots=1024):
answer = RunCircuit(circuit, provider, backend, shots)
plot_histogram(answer)
return answer
def run_on_real_backend(circuit, provider_api_key, backend, shots=1024):
IBMProvider.save_account(provider_api_key, overwrite=True)
provider = IBMProvider()
answer = RunCircuit(circuit, provider, backend, shots)
plot_histogram(answer)
return answer
n = 3 # number of qubits used to represent s
bv_oracle = BVOracle(n, s='110')
bv_circuit = BernsteinVaziraniAlgo(n, bv_oracle)
bv_circuit.draw('mpl')
# Run on the simulator
provider = BasicProvider
backend = 'qasm_simulator'
run_on_simulator(bv_circuit, provider, backend, shots=1024)
# Run on the real backend
# provider_api_key = # your provider api key
backend = 'ibm_perth'
# run_on_real_backend(bv_circuit, provider_api_key, backend, shots=1024)
"""
st.subheader("Implementation of Bernstein Vazirani Algorithm")
st.write(
"""
Reference:
- [Bernstein Vazirani Algorithm - Q-munity](https://www.qmunity.tech/tutorials/bernstein-vazirani-algorithm)
"""
)
st.code(bv_algo_code, language="python")
# ################################### About the author #########################################
st.subheader("About the author: [Ashmit JaiSarita Gupta](https://jaisarita.vercel.app/)")
st.write("""
[Ashmit JaiSarita Gupta](https://jaisarita.vercel.app/) is an engineering physics undergraduate passionate about Quantum Computing, Machine Learning, UI/UX, and Web Development. I am a student driven by the community and who shares what he has learned. I love to work on real world projects about the topics I learn which can be used by others. To accomplish this I frequently attend hackathons and collaborate with companies to work on real-world projects related to my domains. Feel free to contact me if your company is interested in working on awesome projects in these fields with me. I’m currently building most frequently with: JavaScript/Typescript, C++, and Python.Some of the main frameworks and libraries I frequently use are: React.js,Express.js, Tailwind CSS, ShadCN UI, Qiskit,and Pytorch. Explore the below links to explore more about him, his previous projects, blogs, and experience at various organizations.
""")
# ############ Socials ############
c1, c2, c3 = st.columns(3)
with c1:
st.info('**Portfolio: [Ashmit JaiSarita Gupta](https://jaisarita.vercel.app/)**', icon="🔥")
with c2:
st.info('**GitHub: [@devilkiller-ag](https://github.com/devilkiller-ag)**', icon="😸")
with c3:
st.info('**GitLab: [@devilkiller-ag](https://gitlab.com/devilkiller-ag)**', icon="🚀")
c4, c5, c6 = st.columns(3)
with c4:
st.info('**LinkedIn: [jaisarita](https://www.linkedin.com/in/jaisarita/)**', icon="🌐")
with c5:
st.info('**Twitter: [@jaisarita](https://github.com/devilkiller-ag)**', icon="🐤")
with c6:
st.info('**Hashnode: [jaisarita](https://jaisarita.hashnode.dev/)**', icon="✍🏻")
|
https://github.com/RQC-QApp/Seminars
|
RQC-QApp
|
import numpy as np
import matplotlib.pyplot as plt
outcome_0 = np.array([1.0, 0.0])
outcome_1 = np.array([0.0, 1.0])
a = 0.75
b = 0.25
assert a + b == 1
prob_bit = a * outcome_0 + b * outcome_1
X, Y = prob_bit
plt.figure(figsize=(5,5))
plt.plot([a, 0], [b, b], '--', color='orange')
plt.plot([a, a], [b, 0], '--', color='green')
ax = plt.gca()
ax.quiver(X, Y, angles='xy', scale_units='xy', scale=1)
ax.set_xlim([0,1])
ax.set_ylim([0,1])
ax.quiver(0, Y, angles='xy', scale_units='xy', scale=1, color='green',
label='Проекция на направление $\overrightarrow{1}$')
ax.quiver(X, 0, angles='xy', scale_units='xy', scale=1, color='orange',
label='Проекция на направление $\overrightarrow{0}$')
plt.xlabel('$\overrightarrow{0}$', fontsize=15)
plt.ylabel('$\overrightarrow{1}$', fontsize=15)
plt.title('$\overrightarrow{v} = {a}\cdot\overrightarrow{0} + {b}\cdot\overrightarrow{1}$'.format(0, 1, v='v',
a=a, b=b))
plt.legend()
plt.draw()
plt.show()
print("Получаем, что a={}".format(prob_bit.dot(outcome_0)))
print("Получаем, что b={}".format(prob_bit.dot(outcome_1)))
|
https://github.com/RQC-QApp/Seminars
|
RQC-QApp
|
# Подключаем необходимые методы/классы/etc.
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
# Указываем необходимое число квантовых регистров (кубитов)
# и классических регистров.
#
# В обоих случаях указано 2. Помимо количества им присваиваются идентификаторы
# в рамках программы `qp`: "qr" и "cr" соответственно.
qr = QuantumRegister(2, name="qr")
cr = ClassicalRegister(2, name="cr")
# Создаём квантовую цепь с квантовыми регистрами `qr`, классическими регистрами `cr` и называем её "Bell".
qc = QuantumCircuit(qr, cr, name="Bell")
# Начинаем добавлять различные гейты (операции над кубитами).
#
# Синтаксис следующий:
# "<квантовая_цепь>.<гейт>(<квантовый/классический регистр, параметры, etc. - в зависимости от гейта>)".
# Гейт Адамара на нулевой кубит.
qc.h(qr[0])
# Controlled NOT (CNOT) гейт, который использует `qr[0]` кубит как управляющий, а кубит `qr[1]` как таргет.
qc.cx(qr[0], qr[1])
# Измерить кубиты и записать измеренные значения в классические регистры.
qc.measure(qr, cr)
# Скомпилировать и запустить выполнение программы
# "Bell" на бэкэнде "local_qasm_simulator".
job_sim = execute(qc, "local_qasm_simulator")
result = job_sim.result()
# Посмотреть на результаты программы в виде "{'00': n1, '01': n2, ...}", где n1, n2, ... - число
# соответствующих исходов.
print(result.get_counts("Bell"))
from qiskit.tools.visualization import circuit_drawer
# Изобразим квантовую цепь, которая соответствует "Bell".
circuit_drawer(qc)
from qiskit.tools.visualization import plot_histogram
# Гистограмма распределения исходов.
plot_histogram(result.get_counts('Bell'))
# Посмотреть на программу в представлении OpenQASM - Open Quantum Assembly Language. Этот язык используется
# для описания инструкций к квантовой машине.
print(qc.qasm())
from qiskit import register
import Qconfig
# Указываем APItoken и ссылку на соответствующий API.
qx_config = {
"APItoken": Qconfig.APItoken,
"url": Qconfig.config['url']
}
print('Qconfig loaded from %s.' % Qconfig.__file__)
# Регистрируемся в системе IBM Q.
register(qx_config['APItoken'], qx_config['url'])
from qiskit import available_backends
# Список облачных устройств, которые подключены к сети.
available_backends({'local': False})
from qiskit import get_backend
# По названию устройства можно проверить его статус.
get_backend('ibmqx5').status
# Следующими строками можно найти доступный в настоящий момент времени квантовое устройство, которое имеет 16 кубит.
#
# Составляем список из всех облачных бэкэндов (симуляторы не рассматриваем, потому что у них нет параметра 'n_qubits').
backends = available_backends({'local': False})
real_device_backend = [backend for backend in backends if
get_backend(backend).configuration['n_qubits'] == 16 and
get_backend(backend).status['available'] == True]
real_device_backend
backend = real_device_backend[0]
# Список из квантовых схем, которые хочется запустить на квантовом устройстве. Здесь
# может быть перечислено несколько схем, это будет оптимальнее запускать на сервере
# в том плане, что на сервере есть очередь на запуск.
circuits = [qc]
# Количество "запусков" программы на бэкэнде. Максимальное число равно 8192.
shots = 1024
# Максимальное число кредитов, которые вы готовы потратить за запуск программы.
max_credits = 5
# Отпраляем программу в облако и ожидаем выполнения.
job = execute(circuits, backend=backend, shots=shots,
max_credits=max_credits)
result_real = job.result()
# Проверяем статус программы.
result_real.get_status()
%%time
# Гистограмма распределения исходов на настоящем квантовом устройстве.
plot_histogram(result_real.get_counts('Bell'))
qc_1 = qp.create_circuit('qc_1', [qr], [cr])
qc_1.measure(qr[0], cr[0])
# Теперь заметим, что квантовая цепь "qc_1" добавилась к остальным.
qp.get_circuit_names()
# Запустим на локальном симуляторе и построим гистограмму исходов.
result = qp.execute('qc_1')
plot_histogram(result.get_counts('qc_1'))
%%time
# Запустим ту же цепь на реальном устройстве.
result_real = qp.execute('qc_1', backend=backend,
shots=shots, max_credits=max_credits,
wait=wait_time, timeout=timeout)
plot_histogram(result_real.get_counts('qc_1'))
qc_2 = qp.create_circuit('qc_2', [qr], [cr])
# Добавляем NOT-гейт.
qc_2.x(qr[0])
qc_2.measure(qr[0], cr[0])
result = qp.execute('qc_2')
plot_histogram(result.get_counts('qc_2'))
qc_3 = qp.create_circuit('qc_3', [qr], [cr])
# Добавляем гейт Адамара.
qc_3.h(qr[0])
qc_3.measure(qr[0], cr[0])
result = qp.execute('qc_3')
plot_histogram(result.get_counts('qc_3'))
aux = qp.create_circuit('auxiliary', [qr], [cr])
aux.cx(qr[0], qr[1])
# Измерения.
aux.measure(qr[0], cr[0])
aux.measure(qr[1], cr[1])
utils.circuitImage(aux, utils.basis)
qc_4 = qp.create_circuit('qc_4_begin', [qr], [cr])
qc_4.x(qr[0])
qc_4.x(qr[1])
# Квантовые цепи можно "складывать" вместе, вернее, составлять.
qc_4 = qc_4 + aux
# Таким образом мы получаем четвертую квантовую цепь.
utils.circuitImage(qc_4, utils.basis)
# И записываем её в программу под соответствующим названием.
qp.add_circuit('qc_4', qc_4)
result = qp.execute('qc_4')
plot_histogram(result.get_counts('qc_4'))
qc_5 = qp.create_circuit('qc_5_begin', [qr], [cr])
qc_5.h(qr[0])
qc_5.x(qr[1])
qc_5 = qc_5 + aux
qp.add_circuit('qc_5', qc_5)
utils.circuitImage(qp.get_circuit('qc_5'), utils.basis)
result = qp.execute('qc_5')
plot_histogram(result.get_counts('qc_5'))
|
https://github.com/RQC-QApp/Seminars
|
RQC-QApp
|
from pyquil.quil import Program
from pyquil.gates import H, CNOT
from pyquil.api import QVMConnection
# Создаём объект для квантовой программы.
p = Program()
# "Мутирование" квантовой программы под действием оператора `H(0)` - гейт Адамара, который
# действует на нулевой кубит.
p.inst(H(0))
# Добавление CNOT гейта, который использует нулевой кубит как управляющий, а первый кубит как таргет.
p.inst(CNOT(0, 1))
# Объект "квантовой виртуальной машины" - создаёт соединение с облачным бэкэндом.
qvm = QVMConnection()
# Запускаем квантовую программу `p` на бэкэнде.
result = qvm.wavefunction(p)
# Посмотреть на результаты программы в виде "{'00': p1, '01': p2, ...}", где p1, p2, ... - вероятности
# соответствующих исходов.
print(result.get_outcome_probs())
# Построим гистограмму исходов.
result.plot()
# Ещё один способ представить состояние.
result.pretty_print()
import numpy as np
from pyquil.gates import I
quantum_simulator = QVMConnection()
# Создаём квантовую программу, которая использует один кубит и применяет к нему тождественное преобразование.
p = Program(I(0))
# После запуска программы на квантовом симуляторе вернётся состояние системы после применения к
# кубитам всех операторов из `p`.
wavefunction = quantum_simulator.wavefunction(p)
# `wavefunction` содержит в себе список амплитуд каждого из базисных состояний.
print(wavefunction.amplitudes)
alpha, beta = wavefunction
print("Соответственно наш кубит в состоянии: alpha={}, beta={}".format(alpha, beta))
print("Вероятность исхода 0: {}".format(abs(alpha)**2))
print("Вероятность исхода 1: {}".format(abs(beta)**2))
from pyquil.gates import X
# Пишем программу, которая состоит из одного оператора - NOT.
p = Program(X(0))
wavefunc = quantum_simulator.wavefunction(p)
alpha, beta = wavefunc
print("Волновая функция после применения X к |0>: {}".format(wavefunc))
# Посмотреть на вероятности исходов.
print(wavefunc.get_outcome_probs())
from pyquil.gates import CNOT
# Соответствует применению CNOT к состоянию |00>.
p = Program(CNOT(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("CNOT|00> =", wavefunction)
# Соответствует применению CNOT к состоянию |01>.
p = Program(X(0), CNOT(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("CNOT|01> =", wavefunction)
# Соответствует применению CNOT к состоянию |10>.
p = Program(X(1), CNOT(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("CNOT|10> =", wavefunction)
# Соответствует применению CNOT к состоянию |11>.
p = Program(X(0), X(1), CNOT(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("CNOT|11> =", wavefunction)
from pyquil.gates import SWAP
# Соответствует применению SWAP к состоянию |00>.
p = Program(SWAP(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("SWAP|00> = ", wavefunction)
# Соответствует применению SWAP к состоянию |01>.
p = Program(X(0), SWAP(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("SWAP|01> = ", wavefunction)
# Соответствует применению SWAP к состоянию |10>.
p = Program(X(1), SWAP(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("SWAP|10> = ", wavefunction)
# Соответствует применению SWAP к состоянию |11>.
p = Program(X(0), X(1), SWAP(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("SWAP|11> = ", wavefunction)
# Указываем индексы классических регистров для записи.
classical_reg_index_0 = 0
classical_reg_index_1 = 1
# Указываем индексы квантовых регистров для измерения.
quantum_reg_index_0 = 0
quantum_reg_index_1 = 1
# Создаём простую программу, результаты измерений записываем в соответствующие регистры.
p = Program(I(0), X(1))
p.measure(quantum_reg_index_0, classical_reg_index_0)
p.measure(quantum_reg_index_1, classical_reg_index_1)
# Указываем классические регистры, состояние которых нам интересно после завершения программы.
classical_regs = [0, 1]
# Запускаем программу на квантовом симуляторе.
print(quantum_simulator.run(p, classical_regs, trials=4))
from pyquil.gates import H
program = Program(H(0))
wavefunction = quantum_simulator.wavefunction(program)
print("H|0> = ", wavefunction)
print("Вероятности исходов:", wavefunction.get_outcome_probs())
# Запустим на симуляторе.
program = Program(H(0)).measure(0, 0)
result = quantum_simulator.run(program, [0], trials=10)
print(result)
print(program)
# DON'T HAVE ACCESS TO 19Q CHIP :(
# from pyquil.api import get_devices
# for device in get_devices():
# if device.is_online():
# print('Device {} is online'.format(device.name))
# DON'T HAVE ACCESS TO 19Q CHIP :(
# from pyquil.quil import Program
# import pyquil.api as api
# from pyquil.gates import *
# qpu = api.QPUConnection('19Q-Acorn')
# p = Program(H(0), CNOT(0, 1), MEASURE(0, 0), MEASURE(1, 1))
# qpu.run_and_measure(p, [0, 1], 1000)
# Первая цепь.
program = Program()
result = qvm.wavefunction(program)
result.plot()
program.measure(0, 0)
result = quantum_simulator.run(program, classical_addresses=[0], trials=10)
print(result)
# Вторая цепь.
program = Program(X(0))
result = qvm.wavefunction(program)
result.plot()
program.measure(0, 0)
result = quantum_simulator.run(program, classical_addresses=[0], trials=10)
print(result)
# Третья цепь.
program = Program(H(0))
result = qvm.wavefunction(program)
result.plot()
program.measure(0, 0)
result = quantum_simulator.run(program, classical_addresses=[0], trials=10)
print(result)
# Четвёртая цепь.
# управляющий------v v----таргет
program = Program(X(0), X(1), CNOT(0, 1))
result = qvm.wavefunction(program)
result.plot()
program.measure(0, 0).measure(1, 1)
result = quantum_simulator.run(program, classical_addresses=[0, 1], trials=10)
print(result)
# Пятая цепь.
# управляющий------v v----таргет
program = Program(H(0), X(1), CNOT(0, 1))
result = qvm.wavefunction(program)
result.plot()
program.measure(0, 0).measure(1, 1)
result = quantum_simulator.run(program, classical_addresses=[0, 1], trials=10)
print(result)
|
https://github.com/CodeJP97/QHT-2022-WoQ
|
CodeJP97
|
import networkx as nx
from qiskit import QuantumCircuit, Aer
from qiskit.circuit import Parameter
import numpy as np
import matplotlib.pyplot as plt
from IPython.display import Image
Image('./max_cut1.png')
Image('./max_cut2.png')
Image('./mac_cut3.png')
G = nx.Graph()
G.add_nodes_from([0, 1, 2, 3])
G.add_edges_from([(0, 1), (1, 2),(2, 3), (3, 0)])
pos=nx.spring_layout(G,seed = 1)
nx.draw(G, with_labels=True, alpha=0.8, node_size=500, pos = pos)
qaoa_circuit = QuantumCircuit(len(G.nodes()))
qc = QuantumCircuit (2)
gamma = Parameter ('gamma')
qc.rzz(2*gamma, 0, 1)
qc.decompose().draw()
def initial_state(circuit):
for i in range(circuit.num_qubits):
circuit.h(i)
return circuit
qaoa_circuit = initial_state(qaoa_circuit)
qaoa_circuit.draw()
def problem_unitary(graph,circuit,gamma):
for edge in list(G.edges()):
circuit.rzz(2*gamma,edge[0],edge[1])
return circuit
qaoa_circuit.barrier()
qaoa_circuit = problem_unitary(G, qaoa_circuit, gamma)
qaoa_circuit.decompose().draw()
beta = Parameter('beta')
def mix_unitary(circuit,beta):
for i in range(circuit.num_qubits):
circuit.rx(2*beta,i)
return circuit
qaoa_circuit.barrier()
qaoa_circuit = mix_unitary(qaoa_circuit, beta)
qaoa_circuit.draw()
def create_qaoa_circuit(graph, theta):
p = len(theta)//2
gamma = theta[p:]
beta = theta[:p]
qaoa_p = QuantumCircuit(len(graph.nodes()))
qaoa_p = initial_state(qaoa_p)
for i in range(p):
qaoa_p = problem_unitary(graph, qaoa_p, gamma[i])
qaoa_p = mix_unitary(qaoa_p, beta[i])
qaoa_p.measure_all()
return qaoa_p
def get_cost(graph, state):
cost = 0
for i,j in graph.edges():
if state[i] != state[j]:
cost -= 1
return cost
def expectation_value(graph, counts):
avg = 0
sum_count = 0
for state, count in counts.items():
cost = get_cost(graph, state)
avg += cost*count
sum_count += count
return avg/sum_count
def run_qpu(graph, shots=512):
backend = Aer.get_backend('aer_simulator')
backend.shots = shots
def run_circuit(theta):
qc = create_qaoa_circuit(graph, theta)
counts = backend.run(qc, seed_simulator = 5, nshots= shots).result().get_counts()
return expectation_value(graph,counts)
return run_circuit
from scipy.optimize import minimize
p=1
theta = [1.0 for i in range(2*p)]
exp_value = run_qpu(G)
res = minimize(exp_value, theta , method = 'COBYLA')
res
from qiskit.visualization import plot_histogram
backend = Aer.get_backend('aer_simulator')
backend.shots = 512
qc_res = create_qaoa_circuit(G, res.x)
counts = backend.run(qc_res, seed_simulator = 5).result().get_counts()
plot_histogram(counts)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.