repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/nikhil-kamath/quantum-crop-optimization
|
nikhil-kamath
|
import numpy as np
from qiskit import IBMQ, Aer
from qiskit.algorithms import QAOA, VQE, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import COBYLA
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.providers.aer.noise.noise_model import NoiseModel
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_optimization.converters import QuadraticProgramToQubo
import qiskit.test.mock as Fake
IBMQ.load_account()
IBMQ.providers()
algorithm_globals.massive = True
quadprog = QuadraticProgram("test")
quadprog.integer_var(name="x_1", lowerbound=0, upperbound=4)
quadprog.integer_var(name="x_2", lowerbound=-2, upperbound=2)
quadprog.integer_var(name="x_3", lowerbound=-2, upperbound=4)
quadprog.minimize(
linear={"x_3": -6},
quadratic={("x_1", "x_1"): 1, ("x_2", "x_2"): 1, ("x_1", "x_2"): -1}
)
quadprog.linear_constraint(linear={"x_1": 1, "x_2": 1}, sense="=", rhs=2)
quadprog.quadratic_constraint(quadratic={("x_2", "x_3"): 1}, sense=">=", rhs=1)
print(quadprog.export_as_lp_string())
def cropyield_quadratic_program(n=3):
cropyield = QuadraticProgram()
# initialize the crop types as integer variables
crops = ["Wheat", "Soybeans", "Maize", "PushPull"]
w = "Wheat"
s = "Soybeans"
m = "Maize"
p = "PushPull"
for crop in crops:
cropyield.integer_var(name=crop, lowerbound=0, upperbound=n)
l = {}
q = {}
# initialize the equation for total crop output.
# these represent how "good" each of the crop types are in terms of the final equation
# so wheat is 2x as good as soybeans and maize is 4x as good, and pushpull provides no direct benefit
l[w] = 2
l[s] = 1
l[m] = 4
# define the intercropping coefficients, aka how well certain crops will be when grown together
q[(w, s)] = 2.4
q[(w, m)] = 4
q[(w, p)] = 4
q[(s, m)] = 2
q[(s, p)] = 1
q[(m, p)] = 5
# we want to maximize the output
cropyield.maximize(linear=l, quadratic=q)
# but make sure that the sum of the number of squares is <= 3
cropyield.linear_constraint(linear={w:1, s:1, m:1, p:1}, sense="<=", rhs=n)
return cropyield
# convert the quadratic problem to a quantum problem
cropyield = cropyield_quadratic_program(n=3)
ising_operations, _ = (
QuadraticProgramToQubo()
.convert(
cropyield,
)
.to_ising()
)
print(f"Number of qubits required is {ising_operations.num_qubits}")
QuadraticProgramToQubo().convert(cropyield)
# use the Aer simulator
backend = Aer.get_backend("qasm_simulator")
algorithm_globals.random_seed = 271828
def get_classical_solution_for(quadprog: QuadraticProgram):
solver = NumPyMinimumEigensolver()
optimizer = MinimumEigenOptimizer(solver)
return optimizer.solve(quadprog)
def get_QAOA_solution_for(
quadprog: QuadraticProgram, quantumInstance: QuantumInstance, optimizer=None
):
_eval_count = 0
def callback(eval_count, parameters, mean, std):
nonlocal _eval_count
_eval_count = eval_count
solver = QAOA(
optimizer=optimizer, quantum_instance=quantumInstance, callback=callback
)
optimizer = MinimumEigenOptimizer(solver)
result = optimizer.solve(quadprog)
return result, _eval_count
def get_VQE_solution_for(
quadprog: QuadraticProgram, quantumInstance: QuantumInstance, optimizer=None,
):
_eval_count = 0
def callback(eval_count, parameters, mean, std):
nonlocal _eval_count
_eval_count = eval_count
# Create solver and optimizer
solver = VQE(
optimizer=optimizer, quantum_instance=quantumInstance, callback=callback
)
# Create optimizer for solver
optimizer = MinimumEigenOptimizer(solver)
# Get result from optimizer
result = optimizer.solve(quadprog)
return result, _eval_count
classical_result = get_classical_solution_for(cropyield)
print("Solution found using classical method:\n")
print(f"Maximum crop yield is {classical_result.fval} tons")
print("Crops used are: ")
_crops = [v.name for v in cropyield.variables]
for cropIndex, cropHectares in enumerate(classical_result.x):
print(f"\t{cropHectares} ha of {_crops[cropIndex]}")
simulator_instance = QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
qaoa_result, qaoa_eval_count = get_QAOA_solution_for(cropyield, simulator_instance)
print("Solution found using the QAOA method:\n")
print(f"Maximum crop-yield is {qaoa_result.fval} tons")
print(f"Crops used are: ")
for cropHectares, cropName in zip(qaoa_result.x, qaoa_result.variable_names):
print(f"\t{cropHectares} ha of {cropName}")
print(f"\nThe solution was found within {qaoa_eval_count} evaluations of QAOA.")
# Create a QuantumInstance
simulator_instance = QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
# Get VQE result
vqe_result, vqe_eval_count = get_VQE_solution_for(
cropyield, simulator_instance)
# Format and print result
print("Solution found using the VQE method:\n")
print(f"Maximum crop-yield is {vqe_result.fval} tons")
print(f"Crops used are: ")
for cropHectares, cropName in zip(vqe_result.x, vqe_result.variable_names):
print(f"\t{cropHectares} ha of {cropName}")
print(f"\nThe solution was found within {vqe_eval_count} evaluations of VQE")
problem = cropyield_quadratic_program(n=50)
for _backend in IBMQ.get_provider(hub='ibm-q', group='open', project='main').backends():
print(_backend.name())
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
backend_real = provider.get_backend('ibmq_qasm_simulator')
quantum_instance_real = QuantumInstance(backend_real, shots=2048)
optimizer = COBYLA(maxiter=1)
## Get result from real device with VQE
vqe_result_real, vqe_eval_count_real = get_VQE_solution_for(
problem, quantum_instance_real, optimizer=optimizer
)
# Format and print result
print("Solution found using the VQE method:\n")
print(f"Maximum crop-yield is {vqe_result_real.fval} tons")
print(f"Crops used are: ")
for cropHectares, cropName in zip(vqe_result_real.x, vqe_result_real.variable_names):
print(f"\t{cropHectares} ha of {cropName}")
print(
f"\nThe solution was found within {vqe_eval_count_real} evaluations of VQE")
|
https://github.com/AlbertoVari/QC-Grover
|
AlbertoVari
|
#initialization
import matplotlib.pyplot as plt
import numpy as np
import math
# importing Qiskit
from qiskit import Aer, transpile, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.providers.ibmq import least_busy
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler
from qiskit.primitives import Estimator
from qiskit.circuit import ParameterVector
from qiskit_ibm_provider import IBMProvider
from qiskit_ibm_provider import least_busy
import qiskit_ibm_provider
provider = qiskit_ibm_provider.IBMProvider()
# --> simulator backend = provider.get_backend('ibmq_qasm_simulator')
n = 2
grover_circuit = QuantumCircuit(n)
def initialize_s(qc, qubits):
"""Apply a H-gate to 'qubits' in qc"""
for q in qubits:
qc.h(q)
return qc
grover_circuit = initialize_s(grover_circuit, [0,1])
print(grover_circuit)
grover_circuit.cz(0,1) # Oracle
print("Oracle :",end='\n')
print(grover_circuit)
# Diffusion operator (U_s)
grover_circuit.h([0,1])
grover_circuit.z([0,1])
grover_circuit.cz(0,1)
grover_circuit.h([0,1])
print("Oracle + Diffusion :",end='\n')
print(grover_circuit)
sv_sim = Aer.get_backend('statevector_simulator')
result = sv_sim.run(grover_circuit).result()
statevec = result.get_statevector()
grover_circuit.measure_all()
# display current supported backends
print("IBMQ Q system ready with almost 5 qubits",end='\n')
print(provider.backends(min_num_qubits=5, simulator=False, operational=True))
small_devices = provider.backends(min_num_qubits=5, simulator=False, operational=True)
backend = least_busy(small_devices)
print("BACKEND : ",backend)
#running the job
job_exp = execute(grover_circuit, backend, shots=2048)
result_exp = job_exp.result()
# Show the results
print('Counts: ', result_exp.get_counts(grover_circuit))
|
https://github.com/electricalgorithm/QuantumFourierTransform
|
electricalgorithm
|
"""
This module contains the Quantum Fourier Transform class.
"""
from numpy import pi
from qiskit import QuantumCircuit, Aer, transpile, assemble
class QuantumFourierTransform:
"""Class for operations of the Quantum Fourier Transform."""
@staticmethod
def simulate(state: int) -> dict:
"""Simulate the QFT and iQFT.
Parameters
----------
state (int): The state to simulate.
Returns
-------
dict: The simulated state.
"""
# Get the number of qubits.
qubit_count = state.bit_length()
# Create the circuit.
circuit = QuantumCircuit(qubit_count, qubit_count)
# Apply the initial state.
for qubit in range(qubit_count):
if state & (1 << qubit):
circuit.x(qubit)
# Apply the QFT.
circuit = QuantumFourierTransform.qft(circuit)
# Apply the inverse QFT.
circuit = QuantumFourierTransform.iqft(circuit)
# Append the measurement.
circuit.measure(range(qubit_count), range(qubit_count))
# Run the simulation.
simulator = Aer.get_backend("aer_simulator")
circuit = transpile(circuit, simulator)
job = simulator.run(assemble(circuit))
result = job.result().get_counts()
answer_as_list = list(result.keys())
answer_int = int(answer_as_list[0], 2)
return {"result": answer_int}
@staticmethod
def qft(circuit: QuantumCircuit) -> QuantumCircuit:
"""Apply QFT to a circuit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the QFT to.
Returns
-------
QuantumCircuit: The circuit with the QFT applied.
"""
# Apply the QFT to the circuit.
circuit = QuantumFourierTransform._qft_append_circuit(
circuit, circuit.num_qubits - 1
)
# Apply the swaps to the circuit.
circuit = QuantumFourierTransform._qft_append_swaps(circuit)
return circuit
@staticmethod
def qft_circuit(qubit_count: int) -> QuantumCircuit:
"""Create a QFT circuit with given Qubit count.
Parameters
----------
qubit_count : int
The number of qubits to use in the circuit.
Returns
-------
QuantumCircuit
The QFT circuit.
"""
return QuantumFourierTransform.qft(QuantumCircuit(qubit_count))
@staticmethod
def iqft_circuit(qubit_count: int) -> QuantumCircuit:
"""Create a iQFT circuit with given Qubit count.
Parameters
----------
qubit_count : int
The number of qubits to use in the circuit.
Returns
-------
QuantumCircuit
The iQFT circuit.
"""
return QuantumFourierTransform.iqft(QuantumCircuit(qubit_count))
@staticmethod
def iqft(circuit: QuantumCircuit) -> QuantumCircuit:
"""Apply inverse QFT to a circuit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the IQFT to.
Returns
-------
QuantumCircuit: The circuit with the iQFT applied.
"""
# Apply the swaps to the circuit.
circuit = QuantumFourierTransform._qft_append_swaps(circuit, inverse=True)
circuit.barrier()
# Apply the QFT to the circuit.
circuit = QuantumFourierTransform._iqft_append_circuit(circuit, 0)
return circuit
@staticmethod
def _qft_append_circuit(circuit: QuantumCircuit, qubit: int) -> QuantumCircuit:
"""Apply a rotation to a qubit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the rotation to.
qubit (int): The qubit to apply the rotation to.
Returns
-------
QuantumCircuit: The circuit with the rotation applied.
"""
# Recursive stop condition.
if qubit < 0:
return circuit
# Construct the minimal QFT circuit.
circuit.h(qubit)
for qubit_line in reversed(range(qubit)):
circuit.cp(pi / 2 ** (qubit - qubit_line), qubit_line, qubit)
circuit.barrier()
# Recursively apply the QFT to the next qubit.
return QuantumFourierTransform._qft_append_circuit(circuit, qubit - 1)
@staticmethod
def _iqft_append_circuit(circuit: QuantumCircuit, qubit: int) -> QuantumCircuit:
"""Apply a rotation to a qubit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the rotation to.
qubit (int): The qubit to apply the rotation to.
Returns
-------
QuantumCircuit: The circuit with the rotation applied.
"""
# Recursive stop condition.
if qubit >= circuit.num_qubits:
return circuit
# Construct the minimal QFT circuit.
for qubit_line in range(qubit):
circuit.cp(-pi / 2 ** (qubit - qubit_line), qubit_line, qubit)
circuit.h(qubit)
circuit.barrier()
# Recursively apply the QFT to the next qubit.
return QuantumFourierTransform._iqft_append_circuit(circuit, qubit + 1)
@staticmethod
def _qft_append_swaps(
circuit: QuantumCircuit, inverse: bool = False
) -> QuantumCircuit:
"""Apply swaps to a circuit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the swaps to.
qubit (int): The qubit to apply the rotation to.
Returns
-------
QuantumCircuit: The circuit with the swaps applied.
"""
qubit_count = circuit.num_qubits
qubits_list = (
reversed(range(qubit_count // 2))
if not inverse
else range(qubit_count // 2)
)
for qubit in qubits_list:
circuit.swap(qubit, qubit_count - qubit - 1)
return circuit
if __name__ == "__main__":
print("===================================")
print("Quantum Fourier Transform Simulator")
print("===================================")
# Get the input state as integer decimal.
state_int = int(input("> Enter the state as decimal integer: "))
# Run the algorithm.
result = QuantumFourierTransform.simulate(state_int)
print(f"iQFT result: {result['result']}")
|
https://github.com/werefin/BIP-Poznan-QRW-Search-Algorithm
|
werefin
|
!pip install qiskit && pip install pylatexenc && pip install qiskit-aer && pip install qiskit-ibmq-provider
# Useful imports
import numpy as np
import warnings
# Qiskit components
from qiskit import IBMQ
from qiskit import Aer, ClassicalRegister, QuantumRegister, QuantumCircuit, execute
from qiskit.quantum_info.operators import Operator
from qiskit.quantum_info import random_unitary
from qiskit.tools.monitor import backend_overview, backend_monitor
# Visualization
from qiskit.visualization import plot_histogram, plot_state_city
import matplotlib.pyplot as plt
import matplotlib.patches as patch
from matplotlib.path import Path
from matplotlib.animation import FuncAnimation
from IPython.display import Image
# Filter all warnings from now on
warnings.filterwarnings("ignore")
# Define the states
states = ['|00>', '|01>', '|11>', '|10>']
# Define the coordinates of the square's vertices
x = [0, 1, 1, 0, 0]
y = [0, 0, 1, 1, 0]
# Create a plot and set axis limits
plt.figure(figsize=(5, 5))
plt.plot(x, y, 'k-')
plt.scatter(x, y, c='black', s=100)
# Add text labels with variable offset
label_offset = 0.05
for i, state in enumerate(states):
if i in [0, 1]:
plt.text(x[i], y[i] - (1.8 * label_offset), state, fontsize=12, ha='center')
elif i in [2, 3]:
plt.text(x[i], y[i] + label_offset, state, fontsize=12, ha='center')
# Set axis limits and labels
plt.xlim(-0.25, 1.25)
plt.ylim(-0.25, 1.25)
# Add a title
plt.title('QRW - 2D hypercube')
# Show the plot
plt.grid(False)
plt.show()
# 1 flip of the Grover coin
q = QuantumRegister(6, name='q') # 6 quantum bits, 2 for the coin, 4 for the hypercube
q_circ = QuantumCircuit(q)
for i in range(1):
q_circ.h([4, 5])
q_circ.z([4, 5])
q_circ.cz(4, 5)
q_circ.h([4, 5])
q_circ.draw('mpl')
# 1 step in the process - a Grover coin toss and a shift operation
q = QuantumRegister(6, name='q') # same setup as before
q_circ = QuantumCircuit(q)
for i in range(1): # we are simulating one shift operation
q_circ.h([4, 5])
q_circ.z([4, 5])
q_circ.cz(4, 5)
q_circ.h([4, 5])
for i in range(0, 4): # here starts the shift operator, switching one of the four bits according to the rules mentioned above
q_circ.x(4)
if i % 2 == 0:
q_circ.x(5)
q_circ.ccx(4, 5, i)
q_circ.draw('mpl')
# In this algorithm we have a dimension of n for the state space, then we have log_2(n) states in the coin space --> define the dimensions of the quantum circuit
class QRW_Reg:
"""
QRW_Reg initializes a Quantum Random Walk registry --> it inputs the variable dim which is the number of qubits in the state space
dim: number of qubits
c: the number of coin qubits
"""
def __init__(self, dim):
c = (np.log2(dim))
if c.is_integer() != 1:
raise TypeError("The number of qubits n have to satisfy the condition that log_2(n) is an integer!")
self.c = int(c)
self.dim = dim
n = int(dim + c)
self.n = n
q_r = QuantumRegister(n, 'q')
cl_r = ClassicalRegister(n, "c")
self.qr = q_r
self.cl = cl_r
q_circuit = QuantumCircuit(self.qr, self.cl)
self.circuit = q_circuit
# Define the QRW search algorithm as a subclass of the QRW registry
class QRW_Search(QRW_Reg):
"""
QRW_Search is an implementation of the quantum random walk search algorithm
based on the paper by N. Shenvi et alter (see References paragraph for more details).
This class ineherits the QRW_Reg class
dim: number of qubits in the state space
state_search: the state that the algorithm searches for
"""
def __init__(self, dim, state_search):
QRW_Reg.__init__(self, dim)
self.circuit = QRW_Reg(dim).circuit
quantum_reg = QRW_Reg(dim).qr
classical_reg = QRW_Reg(dim).cl
self.search = state_search
circ = self.circuit
# Hadamards on all of the states
circ.h(quantum_reg[0:self.n])
# Operating U_prime pi/2 sqrt(2) times
times = np.ceil(0.5 * np.pi * np.sqrt(2**(self.dim)))
for i in range(int(times)):
circ.unitary(self.U_prime(), quantum_reg, label="U'")
# Measure the registry onto the classical bits
circ.measure(quantum_reg, classical_reg)
# Define all of the operators for the QRW search: S, C, U, U'
def S(self, display_matrix=False):
coin = self.c
num_dir = int(2**coin)
state = self.dim
S = np.zeros((2**(coin + state), 2**(coin + state)))
for i in range(num_dir):
for j in range(2**state):
# Perform the bit flip using a XOR
j_bin = int(j)
e_i = int(i + 1)
xor = j_bin ^ e_i
row = xor + (i * (2**state))
S[row][j + (i * (2**state))] = 1
if display_matrix:
print('Matrix for the shift operator:')
print(S)
return Operator(S)
def C(self, display_matrix=False):
# Definition of the C operator as an outer product in the coin space --> tensor product with the identity in state space
coin = self.c
num_dir = int(2**coin)
state = self.dim
num_state = int(2**state)
# Define the operator in just the coin space
s_c = np.zeros((2**(coin), 2**(coin)))
I_c = np.zeros((2**(coin), 2**(coin)))
for i in range(num_dir):
I_c[i][i] = 1
for j in range(num_dir):
s_c[i][j] = num_dir**(-1)
s_c = 2 * s_c
s_c = Operator(s_c)
I_c = Operator(I_c)
G = s_c - I_c
# Define the identity in the state space
I_s = np.zeros((2**(state), 2**(state)))
for i in range(num_state):
I_s[i][i] = 1
I = Operator(I_s)
C = G.tensor(I)
if display_matrix:
print('Matrix for the quantum coin operator:')
print(np.real(C.data))
return C
def U(self, display_matrix=False):
S_= self.S()
C_ = self.C()
U = C_.compose(S_)
if display_matrix:
print('Matrix for U:')
print(np.real(U.data))
return U
def U_prime(self, display_matrix=False):
# state_search is the state we are searching for --> focus on the second term
# Note: the state search must be in decimal!
if self.search >= 2**self.dim:
raise TypeError("search_state parameter is outside of state space values.")
elif self.search < 0:
raise TypeError("search_state parameter is outside of state space values.")
else:
# Focus on the second term of U_prime
coin = self.c
num_dir = int(2**coin)
state = self.dim
num_state = int(2**state)
search_array = np.zeros((num_state, num_state))
search_array[self.search][self.search] = 1
search = Operator(search_array)
s_c = np.zeros((2**(coin), 2**(coin)))
for i in range(num_dir):
for j in range(num_dir):
s_c[i][j] = num_dir**(-1)
coin_ = Operator(s_c)
search_op = coin_.tensor(search)
S_ = self.S()
second_term = search_op.compose(S_)
U_ = self.U()
U_prime = U_ - (2 * second_term)
if display_matrix:
print("Matrix for U':")
print(np.real(U_prime.data))
return U_prime
# Visualization
def draw_circuit(self):
return self.circuit.draw(output='mpl')
# Plots by actually measuring the circuit
def plot_states_hist(self):
backend = Aer.get_backend('qasm_simulator')
shots = 1024 # number of times circuit is run (for sampling)
results = execute(self.circuit, backend=backend, shots=shots).result()
counts = results.get_counts()
return plot_histogram(counts, figsize=(5, 5), sort='value_desc')
# Define the QRW algorithm as a subclass of the QRW registry
class QRW(QRW_Reg):
"""
The QRW class is an arbitrary implementation of a QRW
dim: number of qubits in the state space
c_label: string that determines what coin operator to use on the coin space
- hadamard = Hadamard operator --> tensor product with the identity
- random = random unitary operator
step: number of 'steps' the QRW completes which corresponds to the number of times the operator U is called
"""
def __init__(self, dim, c_label, step):
QRW_Reg.__init__(self, dim)
self.circuit = QRW_Reg(dim).circuit
quantum_reg = QRW_Reg(dim).qr
classical_reg = QRW_Reg(dim).cl
circ = self.circuit
# Hadamards on all of the states
circ.h(quantum_reg[0:self.n])
for i in range(int(step)):
circ.unitary(self.U(c_label), quantum_reg, label="step")
# Measure the registry onto the classical bits
circ.measure(quantum_reg, classical_reg)
# Defining all of the operators for the QRW search: S, C, U
def S(self):
coin = self.c
num_dir = int(2**coin)
state = self.dim
S = np.zeros((2**(coin + state), 2**(coin + state)))
for i in range(num_dir):
for j in range(2**state):
# Perform the bit flip using a XOR
j_bin = int(j)
e_i = int(i + 1)
xor = j_bin ^ e_i
row = xor + (i * (2**state))
S[row][j + (i * (2**state))] = 1
return Operator(S)
def C(self, c_label):
coin = self.c
state = self.dim
# Create the identity in the S space
I = np.zeros((2**state, 2**state))
for i in range(2**state):
I[i][i] = 1
I = Operator(I)
if c_label == "hadamard":
result= np.zeros((2**coin, 2**coin))
for i in range(2**coin):
for j in range(2**coin):
if i >= 2 and j >= 2:
result[i][j] = (-1) * (-1)**(i * j) * (2**((-1) * (0.5 * coin)))
else:
result[i][j] = (-1)**(i * j) * (2**((-1) * (0.5 * coin)))
res_op = (Operator(result))
C_final = res_op.tensor(I)
return C_final
elif c_label == "random":
dim = []
for i in range(coin):
dim.append(2)
res_op = random_unitary(tuple(dim))
C_final = res_op.tensor(I)
return C_final
else:
raise TypeError("Label string for C is not a valid input!")
def U(self, c_label):
S_= self.S()
C_ = self.C(c_label)
U = C_.compose(S_)
return U
# Visualization
def draw_circuit(self):
return self.circuit.draw()
# Plot by actually measuring the circuit
def plot_states_hist(self):
backend = Aer.get_backend('qasm_simulator')
print(backend)
shots = 1024 # number of times circuit is run (for sampling)
results = execute(self.circuit, backend=backend, shots=shots).result()
counts = results.get_counts()
return plot_histogram(counts, figsize=(5, 5), sort='value_desc')
# Control the circuit
def execute(self):
backend = Aer.get_backend('qasm_simulator')
results = execute(self.circuit, backend=backend, shots=1).result()
answer = results.get_counts()
# One execution means that there will be one state in the answer dictionary
state = list(answer.keys())
return state[0]
# Define the QRW search circuit
search_circuit = QRW_Search(2, 2)
search_circuit.draw_circuit()
search_circuit.plot_states_hist()
n_steps = 1
q = QuantumRegister(3, name='q') # 3 qubits register
c = ClassicalRegister(3, name='c') # 3 bits classical register
q_circ = QuantumCircuit(q, c) # quantum circuit
for i in range(n_steps):
q_circ.h(0)
q_circ.ccx(0, 2, 1)
q_circ.ccx(1, 2, 0)
q_circ.x(0)
q_circ.ccx(0, 1, 2)
q_circ.x(0)
q_circ.x(2)
q_circ.ccx(1, 2, 0)
q_circ.ccx(0, 2, 1)
q_circ.x(1)
q_circ.ccx(1, 2, 0)
q_circ.x(1)
q_circ.x(2)
q_circ.ccx(1, 2, 0)
q_circ.x(0)
q_circ.ccx(0, 1, 2)
q_circ.x(0)
q_circ.x(2)
q_circ.ccx(1, 2, 0)
q_circ.x(2)
q_circ.ccx(0, 2, 1)
q_circ.ccx(1, 2, 0)
q_circ.x(0)
q_circ.ccx(0, 1, 2)
q_circ.x(0)
q_circ.x(1)
q_circ.ccx(1, 2, 0)
q_circ.x(1)
q_circ.ccx(0, 2, 1)
q_circ.ccx(1, 2, 0)
q_circ.barrier()
q_circ.measure([q[0], q[1], q[2]], [c[0], c[1], c[2]])
q_circ.draw('mpl')
backend = Aer.get_backend('qasm_simulator')
shots = 1024 # number of times circuit is run (for sampling)
results = execute(q_circ, backend=backend, shots=shots).result()
counts = results.get_counts()
# Normalize counts to obtain probabilities
total_counts = sum(counts.values())
probabilities = {state: count / total_counts for state, count in counts.items()}
plot_histogram(probabilities, figsize=(5, 5), sort='value_desc')
n_steps = 4
q = QuantumRegister(3, name='q') # 3 qubits register
c = ClassicalRegister(3, name='c') # 3 bits classical register
q_circ = QuantumCircuit(q, c) # quantum circuit
for i in range(n_steps):
q_circ.h(q[0]) # coin
q_circ.ccx(q[0], q[1], q[2]) # Toffoli
q_circ.cx (q[0], q[1]) # CNOT
q_circ.x(q[0])
q_circ.x(q[1])
q_circ.ccx(q[0], q[1], q[2])
q_circ.x(q[1])
q_circ.cx(q[0], q[1])
q_circ.barrier()
q_circ.measure([q[0], q[1], q[2]], [c[0], c[1], c[2]])
q_circ.draw('mpl')
backend = Aer.get_backend('qasm_simulator')
shots = 1024 # number of times circuit is run (for sampling)
results = execute(q_circ, backend=backend, shots=shots).result()
counts = results.get_counts()
# Normalize counts to obtain probabilities
total_counts = sum(counts.values())
probabilities = {state: count / total_counts for state, count in counts.items()}
plot_histogram(probabilities, figsize=(5, 5), sort='value_desc')
# IBMQ.save_account needs to be run only once
IBMQ.save_account(API_KEY, overwrite=True)
# Load the saved IBMQ account
provider = IBMQ.load_account()
# Get a list of available backends
backend_overview()
# Get a specific backend device by its name
backend_device = provider.get_backend('ibm_brisbane')
print("Running on: "+str(backend_device))
# Monitor the status of the selected backend device
backend_monitor(backend_device)
shots = 1024 # number of times circuit is run (for sampling)
# Execute the quantum circuit on the selected backend
results_r = execute(q_circ, backend_device, shots=shots).result()
counts_r = results_r.get_counts()
# Normalize counts to obtain probabilities
total_counts = sum(counts_r.values())
probabilities_r = {state: count_r / total_counts for state, count_r in counts_r.items()}
plot_histogram([probabilities_r, probabilities], legend=['ibm_brisbane', 'qasm_simulator'], color=['#061727', '#82cfff'], sort='value_desc')
# Animate the 2D 'mapping' for the QRW it inherits the QRW class
class QRW_Automata(QRW):
"""
QRW_Automata is a class that inherits the QRW class --> it animates multiple executions of the QRW algorithm into a cellular automata board
Note: this algorithm has only been defined for the cases of 2 and 4 state qubits!
dim: number of qubits in the state space
c_label: string that determines what coin operator to use on the coin space
- hadamard = Hadamard operator --> tensor product with the identity
- random = random unitary operator
steps: number of 'steps' the QRW completes which corresponds to the number of times the operator U is called
iters: number of times the circuit is executed (also determines the number of frames in the animation)
"""
def __init__(self, dim, c_label, steps, iters):
QRW.__init__(self, dim, c_label, steps)
self.n = QRW(dim, c_label, steps).n
self.c = QRW(dim, c_label, steps).c
self.circ = QRW(dim, c_label, steps).circuit
state = []
for i in range(iters):
state.append(QRW(dim, c_label, steps).execute())
self.state = state
print("State:")
print(state)
c_state = []
s_state = []
for i in state:
c_state.append(i[0:self.c])
s_state.append(i[self.c:])
self.c_state = c_state
self.s_state = s_state
if (dim/2).is_integer() != True:
raise ValueError("The half of the number of qubits in the state space has to be an integer!")
# Divide up the board according to number of bits
# n: number of rows and columns --> we are going to implement only the case for n=4!
if int(self.dim) != 4 and int(self.dim) != 2:
raise ValueError("Grid is implemented only for the cases where n=2 and n=4 in the state space!")
figure, axes = plt.subplots(nrows=2, ncols=1)
axes[0].set_facecolor((0, 0, 0))
axes[0].get_xaxis().set_ticks([])
axes[0].get_yaxis().set_ticks([])
axes[1].get_xaxis().set_ticks([])
axes[1].get_yaxis().set_ticks([])
self.fig = figure
self.ax = axes
self.circuit.draw('mpl', scale=0.9, ax=axes[1])
n_v = (2 * self.dim)
if self.c % 2 != 0:
n_h = self.dim
else:
n_h = n_v
v_lines = np.arange(0, 1, 1/n_v)
h_lines = np.arange(0, 1, 1/n_h)
# Draw the frames for the board
for i in v_lines:
axes[0].axvline(x=i, ymin=0, ymax=1, color='r')
for i in h_lines:
axes[0].axhline(y=i, xmin=0, xmax=1, color='r')
anim = FuncAnimation(self.fig, self.animate, frames=int(len(state)), interval=1300)
anim.save("QRW_{n}qubits_{op}_{st}steps.gif".format(n=self.dim, op=c_label, st=steps),)
def animate(self, i):
# Plot the state space
if self.dim == 2:
c_ = self.c_state[i]
s_ = self.s_state[i]
n_v = (2 * self.dim)
n_h = self.dim
verts = [
(0. + int(s_[-1]) * (1/n_v) + 0.5 * int(c_), 1. - int(s_[0]) * (1/n_h) - (1/n_h)), # left, bottom
(0. + int(s_[-1]) * (1/n_v)+ 0.5 * int(c_), 1. - int(s_[0]) * (1/n_h)), # left, top
((1/n_v) + int(s_[-1]) * (1/n_v) + 0.5 * int(c_), 1. - int(s_[0]) * (1/n_h)), # right, top
((1/n_v) + int(s_[-1]) * (1/n_v) + 0.5 * int(c_), 1. - int(s_[0]) * (1/n_h) - (1/n_h)), # right, bottom
(0. + int(s_[-1]) * (1/n_v) + 0.5 * int(c_), 1. - int(s_[0]) * (1/n_h) - (1/n_h)), # ignored
]
codes = [
Path.MOVETO,
Path.LINETO,
Path.LINETO,
Path.LINETO,
Path.CLOSEPOLY,
]
path = Path(verts, codes)
cell = patch.PathPatch(path, facecolor='w')
self.ax[0].set_xlabel("Measured state: {state_}".format(state_=self.state[i]))
self.ax[0].add_patch(cell)
return patch
elif self.dim == 4:
c_ = self.c_state[i]
s_ = self.s_state[i]
n_v = (2 * self.dim)
n_h = (2 * self.dim)
verts = [
(0. + int(s_[-1]) * (1/n_v) + int(s_[-2]) * (2/n_v) + 0.5 * int(c_[1]), 1. - int(s_[0])* 2 *(1/n_h) - int(s_[1]) * (1/n_h) - (1/n_h) - 0.5 * int(c_[0])), # left, bottom
(0. + int(s_[-1]) * (1/n_v) + int(s_[-2]) * (2/n_v) + 0.5 * int(c_[1]), 1. - int(s_[0])* 2 *(1/n_h) - int(s_[1]) * (1/n_h) - 0.5 * int(c_[0])), # left, top
((1/n_v) + int(s_[-1]) * (1/n_v) + int(s_[-2]) * (2/n_v) + 0.5 * int(c_[1]), 1. - int(s_[0])* 2 *(1/n_h) - int(s_[1]) * (1/n_h) - 0.5 * int(c_[0])), # right, top
((1/n_v) + int(s_[-1]) * (1/n_v) + int(s_[-2]) * (2/n_v) + 0.5 * int(c_[1]), 1. - int(s_[0])* 2 *(1/n_h) - int(s_[1]) * (1/n_h) - (1/n_h) - 0.5 * int(c_[0])), # right, bottom
(0. + int(s_[-1]) * (1/n_v) + int(s_[-2]) * (2/n_v) + 0.5 * int(c_[1]), 1. - int(s_[0])* 2 *(1/n_h) - int(s_[1]) * (1/n_h) - (1/n_h) - 0.5 * int(c_[0])), # ignored
]
codes = [
Path.MOVETO,
Path.LINETO,
Path.LINETO,
Path.LINETO,
Path.CLOSEPOLY,
]
path = Path(verts, codes)
cell = patch.PathPatch(path, facecolor='w')
self.ax[0].set_xlabel("Measured state: {state_}".format(state_=self.state[i]))
self.ax[0].add_patch(cell)
return patch
QRW_Automata(4, "hadamard", 4, 16)
QRW_Automata(4, "random", 4, 16)
display(Image(data=open('/content/QRW_4qubits_hadamard_4steps.gif','rb').read(), format='gif'))
display(Image(data=open('/content/QRW_4qubits_random_4steps.gif','rb').read(), format='gif'))
|
https://github.com/MahmoodSpewAfsh/4-Qubit-Teleportation
|
MahmoodSpewAfsh
|
from qiskit import *
Q4Teleportation01 = QuantumCircuit(4, 4)
%matplotlib inline
Q4Teleportation01.draw(output='mpl')
Q4Teleportation01.x(0)
Q4Teleportation01.barrier()
Q4Teleportation01.draw(output='mpl')
Q4Teleportation01.h(1)
Q4Teleportation01.cnot(1, 2)
Q4Teleportation01.cnot(1, 3)
Q4Teleportation01.barrier()
Q4Teleportation01.draw(output='mpl')
Q4Teleportation01.cnot(1, 2)
Q4Teleportation01.cnot(0, 1)
Q4Teleportation01.h(0)
Q4Teleportation01.barrier()
Q4Teleportation01.draw(output='mpl')
Q4Teleportation01.measure([0, 1, 2], [0, 1 , 2])
Q4Teleportation01.draw(output='mpl')
Q4Teleportation01.cx(1, 3)
Q4Teleportation01.cz(0, 3)
Q4Teleportation01.barrier()
Q4Teleportation01.draw(output='mpl')
|
https://github.com/andre-juan/dicke_states_preparation
|
andre-juan
|
import numpy as np
import matplotlib.pyplot as plt
import scipy
# main classes and functions
from qiskit import QuantumRegister, QuantumCircuit, Aer, execute
# gates
from qiskit.circuit.library import RYGate
# visualization stuff
from qiskit.visualization import plot_histogram
##################################################################
##################################################################
# auxiliary functions
##################################################################
##################################################################
def show_figure(fig):
'''
auxiliar function to display plot
even if it's not the last command of the cell
from: https://github.com/Qiskit/qiskit-terra/issues/1682
'''
new_fig = plt.figure()
new_mngr = new_fig.canvas.manager
new_mngr.canvas.figure = fig
fig.set_canvas(new_mngr.canvas)
plt.show(fig)
# ===============================================
def test_circuit_qasm(qc, figsize=(12, 4)):
'''
auxiliar function to simulate the execution of a quantum circuit
using the qasm simulator.
the quantum circuit to be simulates (qc) must
have no measurements or classical registers.
'''
# meausring
qc.measure_all()
#################################
backend = Aer.get_backend("qasm_simulator")
job = execute(qc, backend, shots=1e5, seed_simulator=42)
results = job.result()
counts = results.get_counts()
print(f"\nNumber of elements in result superposition: {len(counts)}\n")
return plot_histogram(counts, title="Results", figsize=figsize)
# ===============================================
def test_circuit_sv(qc, print_stuff=False, figsize=(12, 4)):
'''
auxiliar function to simulate the execution of a quantum circuit
using the state vector simulator.
optionally, prints the statevector components as well as the probabilities.
'''
backend = Aer.get_backend("statevector_simulator")
job = execute(qc, backend, seed_simulator=42)
results = job.result()
counts = results.get_counts()
if print_stuff:
sv = results.data(0)['statevector']
probs = sv**2
print(f"Statevector:\t{sv}\n")
print(f"Probabilities:\t{probs}")
print(f"\nNumber of elements in result superposition: {len(counts)}\n")
return plot_histogram(counts, title="Results", figsize=figsize)
##################################################################
##################################################################
# quantum circuit
##################################################################
##################################################################
def gate_i(n, draw=False):
'''
returns the 2-qubit gate (i), introduced in Sec. 2.2
this gate is simply a cR_y between 2 CNOTs, with
rotation angle given by 2*np.arccos(np.sqrt(1/n))
args:
- `n`: int, defining the rotation angle;
- `draw` : bool, determines if the circuit is drawn.
'''
qc_i = QuantumCircuit(2)
qc_i.cnot(0, 1)
theta = 2*np.arccos(np.sqrt(1/n))
cry = RYGate(theta).control(ctrl_state="1")
qc_i.append(cry, [1, 0])
qc_i.cnot(0, 1)
####################################
gate_i = qc_i.to_gate()
gate_i.name = "$(i)$"
####################################
if draw:
show_figure(qc_i.draw("mpl"))
return gate_i
# ===============================================
def gate_ii_l(l, n, draw=False):
'''
returns the 2-qubit gate (ii)_l, introduced in Sec. 2.2
this gate is simply a ccR_y between 2 CNOTs, with
rotation angle given by 2*np.arccos(np.sqrt(l/n))
args:
- `l`: int, defining the rotation angle;
- `n`: int, defining the rotation angle;
- `draw` : bool, determines if the circuit is drawn.
'''
qc_ii = QuantumCircuit(3)
qc_ii.cnot(0, 2)
theta = 2*np.arccos(np.sqrt(l/n))
ccry = RYGate(theta).control(num_ctrl_qubits = 2, ctrl_state="11")
qc_ii.append(ccry, [2, 1, 0])
qc_ii.cnot(0, 2)
####################################
gate_ii = qc_ii.to_gate()
gate_ii.name = f"$(ii)_{l}$"
####################################
if draw:
show_figure(qc_ii.draw("mpl"))
return gate_ii
# ===============================================
def gate_scs_nk(n, k, draw=False):
'''
returns the SCS_{n,k} gate, which is introduced in Definition 3 and
if built of one 2-qubits (i) gate and k+1 3-qubits gates (ii)_l
args:
- `n`: int, used as argument of `gate_i()` and `gate_ii_l()`;
- `k`: int, defines the size of the gate, as well as its topology;
- `draw` : bool, determines if the circuit is drawn.
'''
qc_scs = QuantumCircuit(k+1)
qc_scs.append(gate_i(n), [k-1, k])
for l in range(2, k+1):
qc_scs.append(gate_ii_l(l, n), [k-l, k-l+1, k])
####################################
gate_scs = qc_scs.to_gate()
gate_scs.name = "SCS$_{" + f"{n},{k}" + "}$"
####################################
if draw:
show_figure(qc_scs.decompose().draw("mpl"))
return gate_scs
# ===============================================
def first_block(n, k, l, draw=False):
'''
returns the first block of unitaries products in Lemma 2.
args:
- `n`: int, used to calculate indices and as argument of `gate_scs_nk()`;
- `k`: int, used to calculate indices and as argument of `gate_scs_nk()`;
- `l`: int, used to calculate indices and as argument of `gate_scs_nk()`;
- `draw` : bool, determines if the circuit is drawn.
'''
qr = QuantumRegister(n)
qc_first_block = QuantumCircuit(qr)
# indices of qubits to which we append identities.
n_first = l-k-1
n_last = n-l
# this will be a list with the qubits indices to which
# we append the SCS_{n,k} gate.
idxs_scs = list(range(n))
# only if ther is an identity to append to first registers
if n_first != 0:
# correcting the qubits indices to which we apply SCS_{n, k}
idxs_scs = idxs_scs[n_first:]
# applying identity to first qubits
qc_first_block.i(qr[:n_first])
if n_last !=0:
idxs_scs = idxs_scs[:-n_last]
# appending SCS_{n, k} to appropriate indices
qc_first_block.append(gate_scs_nk(l, k), idxs_scs)
# applying identity to last qubits
qc_first_block.i(qr[-n_last:])
else:
# appending SCS_{n, k} to appropriate indices
qc_first_block.append(gate_scs_nk(l, k), idxs_scs)
# string with the operator, to be used as gate label
str_operator = "$1^{\otimes " + f'{n_first}' + "} \otimes$ SCS$_{" + f"{l},{k}" + "} \otimes 1^{\otimes " + f"{n_last}" + "}$"
####################################
gate_first_block = qc_first_block.to_gate()
gate_first_block.name = str_operator
####################################
if draw:
show_figure(qc_first_block.decompose().draw("mpl"))
return gate_first_block
# ===============================================
def second_block(n, k, l, draw=False):
'''
returns the second block of unitaries products in Lemma 2.
args:
- `n`: int, used to calculate indices and as argument of `gate_scs_nk()`;
- `k`: int, used to calculate indices and as argument of `gate_scs_nk()`;
- `l`: int, used to calculate indices and as argument of `gate_scs_nk()`;
- `draw` : bool, determines if the circuit is drawn.
'''
qr = QuantumRegister(n)
qc_second_block = QuantumCircuit(qr)
# here we only have identities added to last registers, so it's a bit simpler
n_last = n-l
idxs_scs = list(range(n))
if n_last !=0:
idxs_scs = idxs_scs[:-n_last]
# appending SCS_{n, k} to appropriate indices
qc_second_block.append(gate_scs_nk(l, l-1), idxs_scs)
qc_second_block.i(qr[-n_last:])
else:
# appending SCS_{n, k} to appropriate indices
qc_second_block.append(gate_scs_nk(l, l-1), idxs_scs)
str_operator = "SCS$_{" + f"{l},{l-1}" + "} \otimes 1^{\otimes " + f"{n_last}" + "}$"
####################################
gate_second_block = qc_second_block.to_gate()
gate_second_block.name = str_operator
####################################
if draw:
show_figure(qc_second_block.decompose().draw("mpl"))
return gate_second_block
# ===============================================
def dicke_state(n, k, draw=False, barrier=False, only_decomposed=False):
'''
returns a quantum circuit with to prepare a Dicke state with arbitrary n, k
this function essentially calls previous functions, wrapping the products in Lemma 2
within the appropriate for loops for the construction of U_{n, k}, which is
applied to the initial state as prescribed.
args:
- `n`: int, number of qubits for the Dicke state;
- `k`: int, hamming weight of states to be included in the superposition;
- `draw` : bool, determines if the circuit is drawn;
- `barrier` : bool, determines if barriers are added to the circuit;
- `only_decomposed` : bool, determines if only the 3-fold decomposed circuit is drawn.
'''
qr = QuantumRegister(n)
qc = QuantumCircuit(qr)
########################################
# initial state
qc.x(qr[-k:])
if barrier:
qc.barrier()
########################################
# applying U_{n, k}
# I didn't create a function to generate a U_{n, k} gate
# because I wanted to keep the possibility of adding barriers,
# which are quite nice for visualizing the circuit and its elements.
# apply first term in Lemma 2
# notice how this range captures exactly the product bounds.
# also, it's very important to invert the range, for the gates
# to be applied in the correct order!!
for l in range(k+1, n+1)[::-1]:
qc.append(first_block(n, k, l), range(n))
if barrier:
qc.barrier()
# apply second term in Lemma 2
for l in range(2, k+1)[::-1]:
qc.append(second_block(n, k, l), range(n))
if barrier:
qc.barrier()
########################################
# drawing
if draw:
# draws only the 3-fold decomposed circuit.
# this opens up to (i) and (ii)_l into its components.
if only_decomposed:
show_figure(qc.decompose().decompose().decompose().draw("mpl"))
else:
show_figure(qc.draw("mpl"))
print()
show_figure(qc.decompose().draw("mpl"))
print()
show_figure(qc.decompose().decompose().draw("mpl"))
print()
show_figure(qc.decompose().decompose().decompose().draw("mpl"))
return qc
|
https://github.com/andre-juan/dicke_states_preparation
|
andre-juan
|
import numpy as np
import matplotlib.pyplot as plt
import scipy
# main classes and functions
from qiskit import QuantumRegister, QuantumCircuit, Aer, execute
# gates
from qiskit.circuit.library import RYGate
# visualization stuff
from qiskit.visualization import plot_histogram
def show_figure(fig):
'''
auxiliar function to display plot
even if it's not the last command of the cell
from: https://github.com/Qiskit/qiskit-terra/issues/1682
'''
new_fig = plt.figure()
new_mngr = new_fig.canvas.manager
new_mngr.canvas.figure = fig
fig.set_canvas(new_mngr.canvas)
plt.show(fig)
def test_circuit_qasm(qc, figsize=(12, 4)):
'''
auxiliar function to simulate the execution of a quantum circuit
using the qasm simulator.
the quantum circuit to be simulates (qc) must
have no measurements or classical registers.
'''
# meausring
qc.measure_all()
#################################
backend = Aer.get_backend("qasm_simulator")
job = execute(qc, backend, shots=1e5, seed_simulator=42)
results = job.result()
counts = results.get_counts()
print(f"\nNumber of elements in result superposition: {len(counts)}\n")
return plot_histogram(counts, title="Results", figsize=figsize)
def test_circuit_sv(qc, print_stuff=False, figsize=(12, 4)):
'''
auxiliar function to simulate the execution of a quantum circuit
using the state vector simulator.
optionally, prints the statevector components as well as the probabilities.
'''
backend = Aer.get_backend("statevector_simulator")
job = execute(qc, backend, seed_simulator=42)
results = job.result()
counts = results.get_counts()
if print_stuff:
sv = results.data(0)['statevector']
probs = sv**2
print(f"Statevector:\t{sv}\n")
print(f"Probabilities:\t{probs}")
print(f"\nNumber of elements in result superposition: {len(counts)}\n")
return plot_histogram(counts, title="Results", figsize=figsize)
def gate_i(n, draw=False):
'''
returns the 2-qubit gate (i), introduced in Sec. 2.2
this gate is simply a cR_y between 2 CNOTs, with
rotation angle given by 2*np.arccos(np.sqrt(1/n))
args:
- `n`: int, defining the rotation angle;
- `draw` : bool, determines if the circuit is drawn.
'''
qc_i = QuantumCircuit(2)
qc_i.cnot(0, 1)
theta = 2*np.arccos(np.sqrt(1/n))
cry = RYGate(theta).control(ctrl_state="1")
qc_i.append(cry, [1, 0])
qc_i.cnot(0, 1)
####################################
gate_i = qc_i.to_gate()
gate_i.name = "$(i)$"
####################################
if draw:
show_figure(qc_i.draw("mpl"))
return gate_i
def gate_ii_l(l, n, draw=False):
'''
returns the 2-qubit gate (ii)_l, introduced in Sec. 2.2
this gate is simply a ccR_y between 2 CNOTs, with
rotation angle given by 2*np.arccos(np.sqrt(l/n))
args:
- `l`: int, defining the rotation angle;
- `n`: int, defining the rotation angle;
- `draw` : bool, determines if the circuit is drawn.
'''
qc_ii = QuantumCircuit(3)
qc_ii.cnot(0, 2)
theta = 2*np.arccos(np.sqrt(l/n))
ccry = RYGate(theta).control(num_ctrl_qubits = 2, ctrl_state="11")
qc_ii.append(ccry, [2, 1, 0])
qc_ii.cnot(0, 2)
####################################
gate_ii = qc_ii.to_gate()
gate_ii.name = f"$(ii)_{l}$"
####################################
if draw:
show_figure(qc_ii.draw("mpl"))
return gate_ii
def gate_scs_nk(n, k, draw=False):
'''
returns the SCS_{n,k} gate, which is introduced in Definition 3 and
if built of one 2-qubits (i) gate and k+1 3-qubits gates (ii)_l
args:
- `n`: int, used as argument of `gate_i()` and `gate_ii_l()`;
- `k`: int, defines the size of the gate, as well as its topology;
- `draw` : bool, determines if the circuit is drawn.
'''
qc_scs = QuantumCircuit(k+1)
qc_scs.append(gate_i(n), [k-1, k])
for l in range(2, k+1):
qc_scs.append(gate_ii_l(l, n), [k-l, k-l+1, k])
####################################
gate_scs = qc_scs.to_gate()
gate_scs.name = "SCS$_{" + f"{n},{k}" + "}$"
####################################
if draw:
show_figure(qc_scs.decompose().draw("mpl"))
return gate_scs
def first_block(n, k, l, draw=False):
'''
returns the first block of unitaries products in Lemma 2.
args:
- `n`: int, used to calculate indices and as argument of `gate_scs_nk()`;
- `k`: int, used to calculate indices and as argument of `gate_scs_nk()`;
- `l`: int, used to calculate indices and as argument of `gate_scs_nk()`;
- `draw` : bool, determines if the circuit is drawn.
'''
qr = QuantumRegister(n)
qc_first_block = QuantumCircuit(qr)
# indices of qubits to which we append identities.
n_first = l-k-1
n_last = n-l
# this will be a list with the qubits indices to which
# we append the SCS_{n,k} gate.
idxs_scs = list(range(n))
# only if ther is an identity to append to first registers
if n_first != 0:
# correcting the qubits indices to which we apply SCS_{n, k}
idxs_scs = idxs_scs[n_first:]
# applying identity to first qubits
qc_first_block.i(qr[:n_first])
if n_last !=0:
idxs_scs = idxs_scs[:-n_last]
# appending SCS_{n, k} to appropriate indices
qc_first_block.append(gate_scs_nk(l, k), idxs_scs)
# applying identity to last qubits
qc_first_block.i(qr[-n_last:])
else:
# appending SCS_{n, k} to appropriate indices
qc_first_block.append(gate_scs_nk(l, k), idxs_scs)
# string with the operator, to be used as gate label
str_operator = "$1^{\otimes " + f'{n_first}' + "} \otimes$ SCS$_{" + f"{l},{k}" + "} \otimes 1^{\otimes " + f"{n_last}" + "}$"
####################################
gate_first_block = qc_first_block.to_gate()
gate_first_block.name = str_operator
####################################
if draw:
show_figure(qc_first_block.decompose().draw("mpl"))
return gate_first_block
def second_block(n, k, l, draw=False):
'''
returns the second block of unitaries products in Lemma 2.
args:
- `n`: int, used to calculate indices and as argument of `gate_scs_nk()`;
- `k`: int, used to calculate indices and as argument of `gate_scs_nk()`;
- `l`: int, used to calculate indices and as argument of `gate_scs_nk()`;
- `draw` : bool, determines if the circuit is drawn.
'''
qr = QuantumRegister(n)
qc_second_block = QuantumCircuit(qr)
# here we only have identities added to last registers, so it's a bit simpler
n_last = n-l
idxs_scs = list(range(n))
if n_last !=0:
idxs_scs = idxs_scs[:-n_last]
# appending SCS_{n, k} to appropriate indices
qc_second_block.append(gate_scs_nk(l, l-1), idxs_scs)
qc_second_block.i(qr[-n_last:])
else:
# appending SCS_{n, k} to appropriate indices
qc_second_block.append(gate_scs_nk(l, l-1), idxs_scs)
str_operator = "SCS$_{" + f"{l},{l-1}" + "} \otimes 1^{\otimes " + f"{n_last}" + "}$"
####################################
gate_second_block = qc_second_block.to_gate()
gate_second_block.name = str_operator
####################################
if draw:
show_figure(qc_second_block.decompose().draw("mpl"))
return gate_second_block
def dicke_state(n, k, draw=False, barrier=False, only_decomposed=False):
'''
returns a quantum circuit with to prepare a Dicke state with arbitrary n, k
this function essentially calls previous functions, wrapping the products in Lemma 2
within the appropriate for loops for the construction of U_{n, k}, which is
applied to the initial state as prescribed.
args:
- `n`: int, number of qubits for the Dicke state;
- `k`: int, hamming weight of states to be included in the superposition;
- `draw` : bool, determines if the circuit is drawn;
- `barrier` : bool, determines if barriers are added to the circuit;
- `only_decomposed` : bool, determines if only the 3-fold decomposed circuit is drawn.
'''
qr = QuantumRegister(n)
qc = QuantumCircuit(qr)
########################################
# initial state
qc.x(qr[-k:])
if barrier:
qc.barrier()
########################################
# applying U_{n, k}
# I didn't create a function to generate a U_{n, k} gate
# because I wanted to keep the possibility of adding barriers,
# which are quite nice for visualizing the circuit and its elements.
# apply first term in Lemma 2
# notice how this range captures exactly the product bounds.
# also, it's very important to invert the range, for the gates
# to be applied in the correct order!!
for l in range(k+1, n+1)[::-1]:
qc.append(first_block(n, k, l), range(n))
if barrier:
qc.barrier()
# apply second term in Lemma 2
for l in range(2, k+1)[::-1]:
qc.append(second_block(n, k, l), range(n))
if barrier:
qc.barrier()
########################################
# drawing
if draw:
# draws only the 3-fold decomposed circuit.
# this opens up to (i) and (ii)_l into its components.
if only_decomposed:
show_figure(qc.decompose().decompose().decompose().draw("mpl"))
else:
show_figure(qc.draw("mpl"))
print()
show_figure(qc.decompose().draw("mpl"))
print()
show_figure(qc.decompose().decompose().draw("mpl"))
print()
show_figure(qc.decompose().decompose().decompose().draw("mpl"))
return qc
n, k = 4, 2
qc = dicke_state(n, k, barrier=True, draw=True, only_decomposed=False)
print(f"\nExpected number of elements in superposition: {scipy.special.comb(n, k):.0f}\n")
test_circuit_sv(qc)
n, k = 5, 3
qc = dicke_state(n, k, barrier=True, draw=True, only_decomposed=False)
print(f"\nExpected number of elements in superposition: {scipy.special.comb(n, k):.0f}\n")
test_circuit_sv(qc)
n, k = 6, 4
qc = dicke_state(n, k, barrier=True, draw=True, only_decomposed=True)
print(f"\nExpected number of elements in superposition: {scipy.special.comb(n, k):.0f}\n")
test_circuit_sv(qc)
n, k = 6, 2
qc = dicke_state(n, k, barrier=True, draw=True, only_decomposed=True)
print(f"\nExpected number of elements in superposition: {scipy.special.comb(n, k):.0f}\n")
test_circuit_sv(qc)
n, k = 7, 4
qc = dicke_state(n, k, barrier=True, draw=True, only_decomposed=True)
print(f"\nExpected number of elements in superposition: {scipy.special.comb(n, k):.0f}\n")
test_circuit_sv(qc, figsize=(16, 4))
|
https://github.com/alexyev/Grover-s_Algorithm
|
alexyev
|
import matplotlib.pyplot as plt
import numpy as np
!pip install qiskit
from qiskit import IBMQ, Aer, assemble, transpile, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.providers.ibmq import least_busy
!pip install qiskit.visualization
from qiskit.visualization import *
from qiskit.tools.jupyter import *
!pip install ibm_quantum_widgets
from ibm_quantum_widgets import *
from qiskit.tools.monitor import job_monitor
provider = IBMQ.load_account()
num_qubits = 2
grover_circuit = QuantumCircuit(num_qubits, num_qubits)
def initialize_circ(qc, qubits):
for q in qubits:
qc.h(q)
return qc
grover_circuit = initialize_circ(grover_circuit, [0,1])
grover_circuit.barrier()
grover_circuit.draw()
grover_circuit.cz(0, 1)
grover_circuit.barrier()
grover_circuit.draw()
grover_circuit.h([0, 1])
grover_circuit.z([0, 1])
grover_circuit.cz(0, 1)
grover_circuit.h([0, 1])
grover_circuit.barrier()
grover_circuit.measure([0,1], [0, 1])
grover_circuit.draw()
backend = Aer.get_backend('qasm_simulator')
job = execute(grover_circuit, backend, shots = 1)
result = job.result()
counts = result.get_counts()
print(counts)
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print(device)
transpiled_grover_circuit = transpile(grover_circuit, device, optimization_level=3)
job = device.run(transpiled_grover_circuit)
job_monitor(job, interval=2)
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
|
https://github.com/alexyev/Grover-s_Algorithm
|
alexyev
|
import matplotlib.pyplot as plt
import numpy as np
!pip install qiskit
from qiskit import IBMQ, Aer, assemble, transpile, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.providers.ibmq import least_busy
!pip install qiskit.visualization
from qiskit.visualization import *
from qiskit.tools.jupyter import *
!pip install ibm_quantum_widgets
from ibm_quantum_widgets import *
from qiskit.tools.monitor import job_monitor
def initialize_circuit(qc, qubits):
for q in qubits:
qc.h(q)
return qc
qc = QuantumCircuit(3)
qc.cz(0, 2)
qc.cz(1, 2)
oracle_3 = qc.to_gate()
oracle_3.name = "Uω"
def diffuser(qubits):
qc = QuantumCircuit(qubits)
for qubit in range(qubits):
qc.h(qubit)
for qubit in range(qubits):
qc.x(qubit)
qc.h(qubits-1)
qc.mct(list(range(qubits-1)), qubits -1)
qc.h(qubits-1)
for qubit in range(qubits):
qc.x(qubit)
for qubit in range(qubits):
qc.h(qubit)
U_s = qc.to_gate()
U_s.name = "Us"
return U_s
n_qubits = 3
grover_circuit = QuantumCircuit(n_qubits)
grover_circuit = initialize_circuit(grover_circuit, [0, 1, 2])
grover_circuit.append(oracle_3, [0, 1, 2])
grover_circuit.append(diffuser(n_qubits), [0, 1, 2])
grover_circuit.measure_all()
grover_circuit.draw()
backend = Aer.get_backend('qasm_simulator')
transpiled_grover_circuit = transpile(grover_circuit, backend)
job = execute(transpiled_grover_circuit, backend)
result = job.result()
counts = result.get_counts()
plot_histogram(counts)
provider = IBMQ.load_account()
device_2 = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print(device_2)
transpiled_grover_circuit_2 = transpile(grover_circuit, backend_2, optimization_level=3)
job = device_2.run(transpiled_grover_circuit_2)
job_monitor(job, interval=2)
results_2 = job.result()
answer_2 = results_2.get_counts()
plot_histogram(answer_2)
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import numpy as np
import qiskit
from qiskit import QuantumCircuit
import matplotlib.pyplot as plt
from qiskit.circuit import QuantumCircuit, Parameter
import warnings
warnings.filterwarnings('ignore')
theta = Parameter("θ")
phi = Parameter("φ")
lamb = Parameter("λ")
def sampleCircuitA(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for i in range(qubits - 1):
circuit.cx(i, i + 1)
circuit.cx(qubits - 1, 0)
for i in range(qubits - 1):
circuit.cx(i, i + 1)
circuit.cx(qubits - 1, 0)
circuit.barrier()
for i in range(qubits):
circuit.u3(theta, phi, lamb, i)
return circuit
circuitA = sampleCircuitA(qubits=4)
circuitA.draw(output='mpl')
def sampleCircuitB1(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(qubits):
circuit.u1(theta, i)
for i in range(layer):
for j in range(qubits - 1):
circuit.cz(j, j + 1)
circuit.cz(qubits - 1, 0)
circuit.barrier()
for j in range(qubits):
circuit.u1(theta, j)
return circuit
def sampleCircuitB2(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(qubits):
circuit.u2(phi, lamb, i)
for i in range(layer):
for j in range(qubits - 1):
circuit.cz(j, j + 1)
circuit.cz(qubits - 1, 0)
circuit.barrier()
for j in range(qubits):
circuit.u2(phi, lamb, j)
return circuit
def sampleCircuitB3(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(qubits):
circuit.u3(theta, phi, lamb, i)
for i in range(layer):
for j in range(qubits - 1):
circuit.cz(j, j + 1)
circuit.cz(qubits - 1, 0)
circuit.barrier()
for j in range(qubits):
circuit.u3(theta, phi, lamb, j)
return circuit
circuitB1 = sampleCircuitB1(qubits=4)
circuitB1.draw(output='mpl')
circuitB2 = sampleCircuitB2(qubits=4)
circuitB2.draw(output='mpl')
circuitB3 = sampleCircuitB3(qubits=4)
circuitB3.draw(output='mpl')
def sampleCircuitC(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for j in range(qubits):
circuit.ry(theta, j)
circuit.crx(theta, qubits - 1, 0)
for j in range(qubits - 1, 0, -1):
circuit.crx(theta, j - 1, j)
circuit.barrier()
for j in range(qubits):
circuit.ry(theta, j)
circuit.crx(theta, 3, 2)
circuit.crx(theta, 0, 3)
circuit.crx(theta, 1, 0)
circuit.crx(theta, 2, 1)
return circuit
circuitC = sampleCircuitC(qubits=4)
circuitC.draw(output='mpl')
def sampleCircuitD(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
for j in range(qubits - 1, -1, -1):
for k in range(qubits - 1, -1, -1):
if j != k:
circuit.crx(theta, j, k)
circuit.barrier()
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
return circuit
circuitD = sampleCircuitD(qubits=4)
circuitD.draw(output='mpl')
def sampleCircuitE(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
for j in range(1, qubits, 2):
circuit.crx(theta, j, j - 1)
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
for j in range(2, qubits, 2):
circuit.crx(theta, j, j - 1)
return circuit
circuitE = sampleCircuitE(qubits=4)
circuitE.draw(output='mpl')
def sampleCircuitF(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
circuit.crx(theta, qubits - 1, 0)
for j in range(qubits - 1, 0, -1):
circuit.crx(theta, j - 1, j)
return circuit
circuitF = sampleCircuitF(qubits=4)
circuitF.draw(output='mpl')
def sampleEncoding(qubits):
circuit = QuantumCircuit(qubits)
for i in range(qubits):
circuit.h(i)
circuit.ry(theta, i)
return circuit
circuit = sampleEncoding(4)
circuit.draw(output='mpl')
# demo:
circuit = sampleEncoding(5).compose(sampleCircuitB3(layer=2, qubits=5))
circuit.draw(output='mpl')
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import sys
sys.path.append('../')
from circuits import sampleCircuitA, sampleCircuitB1, sampleCircuitB2,\
sampleCircuitB3, sampleCircuitC, sampleCircuitD, sampleCircuitE,\
sampleCircuitF
from entanglement import Ent
import warnings
warnings.filterwarnings('ignore')
labels = [
'Circuit A', 'Circuit B1', 'Circuit B2', 'Circuit B3',
'Circuit C', 'Circuit D', 'Circuit E', 'Circuit F'
]
samplers = [
sampleCircuitA,
sampleCircuitB1,
sampleCircuitB2,
sampleCircuitB3,
sampleCircuitC,
sampleCircuitD,
sampleCircuitE,
sampleCircuitF
]
q = 4
for layer in range(1, 4):
print(f'qubtis: {q}')
print('-' * 25)
for (label, sampler) in zip(labels, samplers):
expr = Ent(sampler, layer=layer, epoch=3000)
print(f'{label}(layer={layer}): {expr}')
print()
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import sys
sys.path.append('../')
from expressibility import expressibility
from entanglement import Ent
import numpy as np
import kaleidoscope.qiskit
from kaleidoscope import bloch_sphere
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix
def getDensityMatrix(circuit):
return DensityMatrix(circuit).data
import warnings
warnings.filterwarnings('ignore')
def sampleI(layer=1, qubits=1):
circuit = QuantumCircuit(1)
circuit.i(0)
return circuit
def sampleHU1(layer=1, qubits=1):
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.u1(np.random.uniform(0, np.pi * 2), 0)
return circuit
def sampleHU2(layer=1, qubits=1):
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.u2(np.random.uniform(0, np.pi * 2), np.random.uniform(0, np.pi * 2), 0)
return circuit
def sampleHU3(layer=1, qubits=1):
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.u3(np.random.uniform(0, np.pi * 2), np.random.uniform(0, np.pi * 2), np.random.uniform(0, np.pi * 2), 0)
return circuit
X = np.matrix([
[0, 1], [1, 0]
])
Y = np.matrix([
[0, -1j],
[1j, 0]
])
Z = np.matrix([
[1, 0],
[0, -1]
])
def point(sample):
rou = getDensityMatrix(sample())
return [
np.trace(rou @ X).real,
np.trace(rou @ Y).real,
np.trace(rou @ Z).real
]
color = "#FF9933"
bins = 100
sampleI().draw(output='mpl')
pointsI = [ point(sampleI) for i in range(100) ]
bloch_sphere(points=pointsI, points_color=color)
h_i, p_i = expressibility(1, sampleI, bins=bins, return_detail=True)
fig, ax = plt.subplots()
plt.bar([ i/100 for i in range(bins) ], h_i, color="#9999FF", label="Haar", width=0.01)
plt.bar([ i/100 for i in range(bins) ], p_i, color="#FF9933AA", label="VQC", width=0.01)
plt.ylabel("Probability", fontsize=15)
plt.xlabel("Fidelity", fontsize=15)
plt.title("Expr")
ax.legend(loc="upper center")
sampleHU1().draw(output='mpl')
pointsHU1 = [ point(sampleHU1) for i in range(2000) ]
bloch_sphere(points=pointsHU1, points_color=color)
h_hu1, p_hu1 = expressibility(1, sampleHU1, bins=bins, return_detail=True)
fig, ax = plt.subplots()
plt.bar([ i/100 for i in range(bins) ], h_hu1, color="#9999FF", label="Haar", width=0.01)
plt.bar([ i/100 for i in range(bins) ], p_hu1, color="#FF9933AA", label="VQC", width=0.01)
plt.ylabel("Probability", fontsize=15)
plt.xlabel("Fidelity", fontsize=15)
plt.title("Expr")
ax.legend(loc="upper center")
sampleHU2().draw(output='mpl')
pointsHU2 = [ point(sampleHU2) for i in range(2000) ]
bloch_sphere(points=pointsHU2, points_color=color)
h_hu2, p_hu2 = expressibility(1, sampleHU2, bins=bins, return_detail=True)
fig, ax = plt.subplots()
plt.bar([ i/100 for i in range(bins) ], h_hu2, color="#9999FF", label="Haar", width=0.01)
plt.bar([ i/100 for i in range(bins) ], p_hu2, color="#FF9933AA", label="VQC", width=0.01)
plt.ylabel("Probability", fontsize=15)
plt.xlabel("Fidelity", fontsize=15)
plt.title("Expr")
ax.legend(loc="upper center")
sampleHU3().draw(output='mpl')
pointsHU3 = [ point(sampleHU3) for i in range(2000) ]
bloch_sphere(points=pointsHU3, points_color=color)
h_hu3, p_hu3 = expressibility(1, sampleHU3, bins=bins, return_detail=True)
fig, ax = plt.subplots()
plt.bar([ i/100 for i in range(bins) ], h_hu3, color="#9999FF", label="Haar", width=0.01)
plt.bar([ i/100 for i in range(bins) ], p_hu3, color="#FF9933AA", label="VQC", width=0.01)
plt.ylabel("Probability", fontsize=15)
plt.xlabel("Fidelity", fontsize=15)
plt.title("Expr")
ax.legend(loc="upper center")
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.mlab as mlab
from mpl_toolkits.mplot3d import Axes3D
plt.rc('font',family='Microsoft YaHei')
plt.rcParams['axes.unicode_minus'] = False
palettes = [
"#999999",
"#FFEE00",
"#FF9900",
"#FF3636",
"#99CC33",
"#66CCCC",
"#3399CC",
"#9966CC"
]
plt.scatter(0.1, 0.1, color=palettes[0])
plt.scatter(0.2, 0.2, color=palettes[1])
plt.scatter(0.3, 0.3, color=palettes[2])
plt.scatter(0.4, 0.4, color=palettes[3])
plt.scatter(0.5, 0.5, color=palettes[4])
plt.scatter(0.6, 0.6, color=palettes[5])
plt.scatter(0.7, 0.7, color=palettes[6])
plt.scatter(0.8, 0.8, color=palettes[7])
# Expressibility Entanglement
plt.figure(figsize=(8, 5))
c1 = "#FF6666"
c2 = "#FF9900"
c3 = "#66CCFF"
# layer 1
# layer 1 qubit 3
plt.grid()
plt.xticks([1, 2, 3, 4, 5, 6])
plt.ylim(0.13, 0.7)
plt.title("角度编码方案与表达能力", fontsize=14)
plt.xlabel("Qubit数", fontsize=13)
plt.ylabel("Expr", fontsize=13)
plt.scatter(3, 0.1974, color=c1, label="Rx(θ)(·)")
plt.scatter(3, 0.1997, color=c2, label="Ry(θ)H(·)")
plt.scatter(3, 0.1918, color=c3, label="Rz(θ)H(·)")
plt.scatter(4, 0.1462, color=c1)
plt.scatter(4, 0.1442, color=c2)
plt.scatter(4, 0.1331, color=c3)
plt.scatter(5, 0.1711, color=c1)
plt.scatter(5, 0.1824, color=c2)
plt.scatter(5, 0.1741, color=c3)
plt.scatter(1, 0.6515, color=c1)
plt.scatter(1, 0.6613, color=c2)
plt.scatter(1, 0.6260, color=c3)
plt.scatter(2, 0.3435, color=c1)
plt.scatter(2, 0.3355, color=c2)
plt.scatter(2, 0.3304, color=c3)
plt.scatter(6, 0.2582, color=c1)
plt.scatter(6, 0.2748, color=c2)
plt.scatter(6, 0.2644, color=c3)
plt.legend(loc='upper center')
plt.figure(figsize=(15, 3.8))
# layer 1
# layer 1 qubit 3
ax = plt.subplot(1,3,1)
plt.grid()
plt.ylim(0.3, 0.8)
plt.xlim(0.4, 2.4)
plt.title("Quibts: 3, Layers: 1")
plt.xlabel("Expr", fontsize=13)
plt.ylabel("Ent", fontsize=13)
plt.scatter(1.189, 0.625, color=palettes[0], label="C1")
plt.scatter(0.704, 0.377, color=palettes[1], label="C2")
plt.scatter(2.175, 0.702, color=palettes[2], label="C3")
plt.scatter(2.352, 0.540, color=palettes[3], label="C4")
plt.scatter(1.799, 0.542, color=palettes[4], label="C5")
plt.scatter(2.287, 0.720, color=palettes[5], label="C6")
plt.scatter(1.546, 0.338, color=palettes[6], label="C7")
plt.scatter(1.905, 0.456, color=palettes[7], label="C8")
ax.legend(loc='upper left', ncol=3, bbox_to_anchor=(0, 1.01))
plt.axvline(2.352, linestyle="--", color="#FF363666")
plt.axvline(2.175, linestyle="--", color="#FF990066")
plt.axhline(0.540, linestyle="--", color="#FF363666")
plt.axhline(0.702, linestyle="--", color="#FF990066")
# # layer 1 qubit 4
plt.subplot(1,3,2)
plt.grid()
plt.ylim(0.3, 0.8)
plt.xlim(0.4, 2.4)
plt.title("Quibts: 4, Layers: 1")
plt.xlabel("Expr", fontsize=13)
plt.scatter(1.724, 0.625, color=palettes[0])
plt.scatter(0.503, 0.375, color=palettes[1])
plt.scatter(1.881, 0.704, color=palettes[2])
plt.scatter(1.982, 0.537, color=palettes[3])
plt.scatter(1.837, 0.545, color=palettes[4])
plt.scatter(2.115, 0.721, color=palettes[5])
plt.scatter(1.219, 0.337, color=palettes[6])
plt.scatter(1.390, 0.457, color=palettes[7])
plt.axvline(1.982, linestyle="--", color="#FF363666")
plt.axvline(1.881, linestyle="--", color="#FF990066")
plt.axhline(0.537, linestyle="--", color="#FF363666")
plt.axhline(0.704, linestyle="--", color="#FF990066")
# # layer 1 qubit 5
plt.subplot(1,3,3)
plt.grid()
plt.ylim(0.3, 0.8)
plt.xlim(0.4, 2.4)
plt.title("Quibts: 5, Layers: 1")
plt.xlabel("Expr", fontsize=13)
plt.scatter(1.376, 0.625, color=palettes[0])
plt.scatter(0.456, 0.377, color=palettes[1])
plt.scatter(1.465, 0.703, color=palettes[2])
plt.scatter(1.557, 0.536, color=palettes[3])
plt.scatter(1.424, 0.547, color=palettes[4])
plt.scatter(2.113, 0.722, color=palettes[5])
plt.scatter(0.942, 0.339, color=palettes[6])
plt.scatter(1.152, 0.456, color=palettes[7])
plt.axvline(1.557, linestyle="--", color="#FF363666")
plt.axvline(1.465, linestyle="--", color="#FF990066")
plt.axhline(0.536, linestyle="--", color="#FF363666")
plt.axhline(0.703, linestyle="--", color="#FF990066")
def depth(circuit_type, n, L):
if circuit_type == 1:
return (2 * n + 1) * L
elif circuit_type >= 2 and circuit_type <= 4:
return (n + 1) * L + 1
elif circuit_type == 5:
return (2 + n + n // np.gcd(n, 3)) * L
elif circuit_type == 6:
return (n ** 2 - n + 4) * L
elif circuit_type == 7:
return 6 * L
elif circuit_type == 8:
return (n + 2) * L
colors2 = ['#FFCC33', '#FF9900', '#FF9966', '#FF6666', '#CC3333']
colors = ['#99CCFF', '#66CCFF', '#0088CC', '#6666FF', '#0000FF']
types = ['o', '^', ',', 'p', 'X']
plt.grid()
plt.title("线路深度同量子比特数量关系")
plt.xlabel("线路类型", fontsize=13)
plt.ylabel("线路深度", fontsize=13)
for n in range(2, 7):
for ct in range(1, 9):
if ct == 1:
plt.scatter(ct, depth(ct, n, 1), color=colors[n - 2], marker=types[n - 2], label=f"n={n}, L=1")
else:
plt.scatter(ct, depth(ct, n, 1), color=colors[n - 2], marker=types[n - 2])
for n in range(2, 7):
for ct in range(1, 9):
if ct == 1:
plt.scatter(ct, depth(ct, n, 3), color=colors2[n - 2], marker=types[n - 2], label=f"n={n}, L=3")
else:
plt.scatter(ct, depth(ct, n, 3), color=colors2[n - 2], marker=types[n - 2])
plt.axhline(22, 0, 8, linestyle="--", color="#CC6666")
plt.legend()
plt.figure(figsize=(7, 5))
# layer 1
# layer 1 qubit 3
plt.grid()
plt.ylim(0.4, 0.6)
plt.xlim(1, 1.7)
plt.title("原始线路与丢弃处理后线路的可表达性与纠缠能力", fontsize=13)
plt.xlabel("Expr", fontsize=13)
plt.ylabel("Ent", fontsize=13)
plt.scatter(1.6105, 0.5622, color="#FF9966", label="原始线路")
plt.scatter(1.4415, 0.5158, color="#FF6666", label="纠缠丢弃")
plt.scatter(1.1185, 0.4283, color="#3399CC", label="旋转丢弃")
plt.legend(loc='upper left')
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import numpy as np
import qiskit
from qiskit import QuantumCircuit
import matplotlib.pyplot as plt
from qiskit.circuit import QuantumCircuit, Parameter
import warnings
warnings.filterwarnings('ignore')
theta = Parameter("θ")
phi = Parameter("φ")
lamb = Parameter("λ")
def sampleCircuitA(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for i in range(qubits - 1):
circuit.cx(i, i + 1)
circuit.cx(qubits - 1, 0)
for i in range(qubits - 1):
circuit.cx(i, i + 1)
circuit.cx(qubits - 1, 0)
circuit.barrier()
for i in range(qubits):
circuit.u3(theta, phi, lamb, i)
return circuit
circuitA = sampleCircuitA(qubits=4)
circuitA.draw(output='mpl')
def sampleCircuitB1(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(qubits):
circuit.u1(theta, i)
for i in range(layer):
for j in range(qubits - 1):
circuit.cz(j, j + 1)
circuit.cz(qubits - 1, 0)
circuit.barrier()
for j in range(qubits):
circuit.u1(theta, j)
return circuit
def sampleCircuitB2(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(qubits):
circuit.u2(phi, lamb, i)
for i in range(layer):
for j in range(qubits - 1):
circuit.cz(j, j + 1)
circuit.cz(qubits - 1, 0)
circuit.barrier()
for j in range(qubits):
circuit.u2(phi, lamb, j)
return circuit
def sampleCircuitB3(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(qubits):
circuit.u3(theta, phi, lamb, i)
for i in range(layer):
for j in range(qubits - 1):
circuit.cz(j, j + 1)
circuit.cz(qubits - 1, 0)
circuit.barrier()
for j in range(qubits):
circuit.u3(theta, phi, lamb, j)
return circuit
circuitB1 = sampleCircuitB1(qubits=4)
circuitB1.draw(output='mpl')
circuitB2 = sampleCircuitB2(qubits=4)
circuitB2.draw(output='mpl')
circuitB3 = sampleCircuitB3(qubits=4)
circuitB3.draw(output='mpl')
def sampleCircuitC(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for j in range(qubits):
circuit.ry(theta, j)
circuit.crx(theta, qubits - 1, 0)
for j in range(qubits - 1, 0, -1):
circuit.crx(theta, j - 1, j)
circuit.barrier()
for j in range(qubits):
circuit.ry(theta, j)
circuit.crx(theta, 3, 2)
circuit.crx(theta, 0, 3)
circuit.crx(theta, 1, 0)
circuit.crx(theta, 2, 1)
return circuit
circuitC = sampleCircuitC(qubits=4)
circuitC.draw(output='mpl')
def sampleCircuitD(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
for j in range(qubits - 1, -1, -1):
for k in range(qubits - 1, -1, -1):
if j != k:
circuit.crx(theta, j, k)
circuit.barrier()
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
return circuit
circuitD = sampleCircuitD(qubits=4)
circuitD.draw(output='mpl')
def sampleCircuitE(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
for j in range(1, qubits, 2):
circuit.crx(theta, j, j - 1)
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
for j in range(2, qubits, 2):
circuit.crx(theta, j, j - 1)
return circuit
circuitE = sampleCircuitE(qubits=4)
circuitE.draw(output='mpl')
def sampleCircuitF(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
circuit.crx(theta, qubits - 1, 0)
for j in range(qubits - 1, 0, -1):
circuit.crx(theta, j - 1, j)
return circuit
circuitF = sampleCircuitF(qubits=4)
circuitF.draw(output='mpl')
def sampleEncoding(qubits):
circuit = QuantumCircuit(qubits)
for i in range(qubits):
circuit.h(i)
circuit.ry(theta, i)
return circuit
circuit = sampleEncoding(4)
circuit.draw(output='mpl')
# demo:
circuit = sampleEncoding(5).compose(sampleCircuitB3(layer=2, qubits=5))
circuit.draw(output='mpl')
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
from qiskit import *
from oracle_generation import generate_oracle
get_bin = lambda x, n: format(x, 'b').zfill(n)
def gen_circuits(min,max,size):
circuits = []
secrets = []
ORACLE_SIZE = size
for i in range(min,max+1):
cur_str = get_bin(i,ORACLE_SIZE-1)
(circuit, secret) = generate_oracle(ORACLE_SIZE,False,3,cur_str)
circuits.append(circuit)
secrets.append(secret)
return (circuits, secrets)
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import numpy as np
import qiskit
from qiskit import QuantumCircuit
import matplotlib.pyplot as plt
from qiskit.circuit import QuantumCircuit, Parameter
import warnings
warnings.filterwarnings('ignore')
theta = Parameter("θ")
phi = Parameter("φ")
lamb = Parameter("λ")
def sampleCircuitA(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for i in range(qubits - 1):
circuit.cx(i, i + 1)
circuit.cx(qubits - 1, 0)
for i in range(qubits - 1):
circuit.cx(i, i + 1)
circuit.cx(qubits - 1, 0)
circuit.barrier()
for i in range(qubits):
circuit.u3(theta, phi, lamb, i)
return circuit
circuitA = sampleCircuitA(qubits=4)
circuitA.draw(output='mpl')
def sampleCircuitB1(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(qubits):
circuit.u1(theta, i)
for i in range(layer):
for j in range(qubits - 1):
circuit.cz(j, j + 1)
circuit.cz(qubits - 1, 0)
circuit.barrier()
for j in range(qubits):
circuit.u1(theta, j)
return circuit
def sampleCircuitB2(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(qubits):
circuit.u2(phi, lamb, i)
for i in range(layer):
for j in range(qubits - 1):
circuit.cz(j, j + 1)
circuit.cz(qubits - 1, 0)
circuit.barrier()
for j in range(qubits):
circuit.u2(phi, lamb, j)
return circuit
def sampleCircuitB3(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(qubits):
circuit.u3(theta, phi, lamb, i)
for i in range(layer):
for j in range(qubits - 1):
circuit.cz(j, j + 1)
circuit.cz(qubits - 1, 0)
circuit.barrier()
for j in range(qubits):
circuit.u3(theta, phi, lamb, j)
return circuit
circuitB1 = sampleCircuitB1(qubits=4)
circuitB1.draw(output='mpl')
circuitB2 = sampleCircuitB2(qubits=4)
circuitB2.draw(output='mpl')
circuitB3 = sampleCircuitB3(qubits=4)
circuitB3.draw(output='mpl')
def sampleCircuitC(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for j in range(qubits):
circuit.ry(theta, j)
circuit.crx(theta, qubits - 1, 0)
for j in range(qubits - 1, 0, -1):
circuit.crx(theta, j - 1, j)
circuit.barrier()
for j in range(qubits):
circuit.ry(theta, j)
circuit.crx(theta, 3, 2)
circuit.crx(theta, 0, 3)
circuit.crx(theta, 1, 0)
circuit.crx(theta, 2, 1)
return circuit
circuitC = sampleCircuitC(qubits=4)
circuitC.draw(output='mpl')
def sampleCircuitD(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
for j in range(qubits - 1, -1, -1):
for k in range(qubits - 1, -1, -1):
if j != k:
circuit.crx(theta, j, k)
circuit.barrier()
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
return circuit
circuitD = sampleCircuitD(qubits=4)
circuitD.draw(output='mpl')
def sampleCircuitE(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
for j in range(1, qubits, 2):
circuit.crx(theta, j, j - 1)
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
for j in range(2, qubits, 2):
circuit.crx(theta, j, j - 1)
return circuit
circuitE = sampleCircuitE(qubits=4)
circuitE.draw(output='mpl')
def sampleCircuitF(layer=1, qubits=4):
circuit = QuantumCircuit(qubits)
for i in range(layer):
for j in range(qubits):
circuit.rx(theta, j)
circuit.rz(theta, j)
circuit.crx(theta, qubits - 1, 0)
for j in range(qubits - 1, 0, -1):
circuit.crx(theta, j - 1, j)
return circuit
circuitF = sampleCircuitF(qubits=4)
circuitF.draw(output='mpl')
def sampleEncoding(qubits):
circuit = QuantumCircuit(qubits)
for i in range(qubits):
circuit.h(i)
circuit.ry(theta, i)
return circuit
circuit = sampleEncoding(4)
circuit.draw(output='mpl')
# demo:
circuit = sampleEncoding(5).compose(sampleCircuitB3(layer=2, qubits=5))
circuit.draw(output='mpl')
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import sys
sys.path.append('../')
from circuits import sampleCircuitA, sampleCircuitB1, sampleCircuitB2,\
sampleCircuitB3, sampleCircuitC, sampleCircuitD, sampleCircuitE,\
sampleCircuitF
from entanglement import Ent
import warnings
warnings.filterwarnings('ignore')
labels = [
'Circuit A', 'Circuit B1', 'Circuit B2', 'Circuit B3',
'Circuit C', 'Circuit D', 'Circuit E', 'Circuit F'
]
samplers = [
sampleCircuitA,
sampleCircuitB1,
sampleCircuitB2,
sampleCircuitB3,
sampleCircuitC,
sampleCircuitD,
sampleCircuitE,
sampleCircuitF
]
q = 4
for layer in range(1, 4):
print(f'qubtis: {q}')
print('-' * 25)
for (label, sampler) in zip(labels, samplers):
expr = Ent(sampler, layer=layer, epoch=3000)
print(f'{label}(layer={layer}): {expr}')
print()
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import sys
sys.path.append('../')
from circuits import sampleCircuitA, sampleCircuitB1, sampleCircuitB2,\
sampleCircuitB3, sampleCircuitC, sampleCircuitD, sampleCircuitE,\
sampleCircuitF
from entanglement import Ent
import warnings
warnings.filterwarnings('ignore')
labels = [
'Circuit A', 'Circuit B1', 'Circuit B2', 'Circuit B3',
'Circuit C', 'Circuit D', 'Circuit E', 'Circuit F'
]
samplers = [
sampleCircuitA,
sampleCircuitB1,
sampleCircuitB2,
sampleCircuitB3,
sampleCircuitC,
sampleCircuitD,
sampleCircuitE,
sampleCircuitF
]
q = 4
for layer in range(1, 4):
print(f'qubtis: {q}')
print('-' * 25)
for (label, sampler) in zip(labels, samplers):
expr = Ent(sampler, layer=layer, epoch=3000)
print(f'{label}(layer={layer}): {expr}')
print()
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import sys
sys.path.append('../')
from circuits import sampleCircuitA, sampleCircuitB1, sampleCircuitB2,\
sampleCircuitB3, sampleCircuitC, sampleCircuitD, sampleCircuitE,\
sampleCircuitF
from entanglement import Ent
import warnings
warnings.filterwarnings('ignore')
labels = [
'Circuit A', 'Circuit B1', 'Circuit B2', 'Circuit B3',
'Circuit C', 'Circuit D', 'Circuit E', 'Circuit F'
]
samplers = [
sampleCircuitA,
sampleCircuitB1,
sampleCircuitB2,
sampleCircuitB3,
sampleCircuitC,
sampleCircuitD,
sampleCircuitE,
sampleCircuitF
]
q = 4
for layer in range(1, 4):
print(f'qubtis: {q}')
print('-' * 25)
for (label, sampler) in zip(labels, samplers):
expr = Ent(sampler, layer=layer, epoch=3000)
print(f'{label}(layer={layer}): {expr}')
print()
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import numpy as np
from qiskit.quantum_info import state_fidelity, Statevector
def getStatevector(circuit):
return Statevector(circuit).data
import warnings
warnings.filterwarnings('ignore')
def P_haar(N, F):
if F == 1:
return 0
else:
return (N - 1) * ((1 - F) ** (N - 2))
def KL(P, Q):
epsilon = 1e-8
kl_divergence = 0.0
for p, q in zip(P, Q):
kl_divergence += p * np.log( (p + epsilon) / (q + epsilon) )
return abs(kl_divergence)
def expressibility(qubits, sampler, *, bins=100, epoch=3000, layer=1, encode=False, return_detail=False):
unit = 1 / bins
limits = []
probabilities = np.array([0] * bins)
for i in range(1, bins + 1):
limits.append(unit * i)
for i in range(epoch):
circuit_1 = sampler(layer=layer, qubits=qubits)
circuit_2 = sampler(layer=layer, qubits=qubits)
f = state_fidelity(
getStatevector(circuit_1),
getStatevector(circuit_2)
)
for j in range(bins):
if f <= limits[j]:
probabilities[j] += 1
break
pHaar_vqc = [ P_haar(2 ** qubits, f - (unit/2)) / bins for f in limits]
probabilities = [ p / epoch for p in probabilities ]
if return_detail:
return pHaar_vqc, probabilities
else:
return KL(probabilities, pHaar_vqc)
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import sys
sys.path.append('../')
from circuits import sampleCircuitA, sampleCircuitB1, sampleCircuitB2,\
sampleCircuitB3, sampleCircuitC, sampleCircuitD, sampleCircuitE,\
sampleCircuitF
from entanglement import Ent
import warnings
warnings.filterwarnings('ignore')
labels = [
'Circuit A', 'Circuit B1', 'Circuit B2', 'Circuit B3',
'Circuit C', 'Circuit D', 'Circuit E', 'Circuit F'
]
samplers = [
sampleCircuitA,
sampleCircuitB1,
sampleCircuitB2,
sampleCircuitB3,
sampleCircuitC,
sampleCircuitD,
sampleCircuitE,
sampleCircuitF
]
q = 4
for layer in range(1, 4):
print(f'qubtis: {q}')
print('-' * 25)
for (label, sampler) in zip(labels, samplers):
expr = Ent(sampler, layer=layer, epoch=3000)
print(f'{label}(layer={layer}): {expr}')
print()
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import numpy as np
from qiskit.quantum_info import state_fidelity, Statevector
def getStatevector(circuit):
return Statevector(circuit).data
import warnings
warnings.filterwarnings('ignore')
def P_haar(N, F):
if F == 1:
return 0
else:
return (N - 1) * ((1 - F) ** (N - 2))
def KL(P, Q):
epsilon = 1e-8
kl_divergence = 0.0
for p, q in zip(P, Q):
kl_divergence += p * np.log( (p + epsilon) / (q + epsilon) )
return abs(kl_divergence)
def expressibility(qubits, sampler, *, bins=100, epoch=3000, layer=1, encode=False, return_detail=False):
unit = 1 / bins
limits = []
probabilities = np.array([0] * bins)
for i in range(1, bins + 1):
limits.append(unit * i)
for i in range(epoch):
circuit_1 = sampler(layer=layer, qubits=qubits)
circuit_2 = sampler(layer=layer, qubits=qubits)
f = state_fidelity(
getStatevector(circuit_1),
getStatevector(circuit_2)
)
for j in range(bins):
if f <= limits[j]:
probabilities[j] += 1
break
pHaar_vqc = [ P_haar(2 ** qubits, f - (unit/2)) / bins for f in limits]
probabilities = [ p / epoch for p in probabilities ]
if return_detail:
return pHaar_vqc, probabilities
else:
return KL(probabilities, pHaar_vqc)
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import numpy as np
from qiskit.quantum_info import state_fidelity, Statevector
def getStatevector(circuit):
return Statevector(circuit).data
import warnings
warnings.filterwarnings('ignore')
def P_haar(N, F):
if F == 1:
return 0
else:
return (N - 1) * ((1 - F) ** (N - 2))
def KL(P, Q):
epsilon = 1e-8
kl_divergence = 0.0
for p, q in zip(P, Q):
kl_divergence += p * np.log( (p + epsilon) / (q + epsilon) )
return abs(kl_divergence)
def expressibility(qubits, sampler, *, bins=100, epoch=3000, layer=1, encode=False, return_detail=False):
unit = 1 / bins
limits = []
probabilities = np.array([0] * bins)
for i in range(1, bins + 1):
limits.append(unit * i)
for i in range(epoch):
circuit_1 = sampler(layer=layer, qubits=qubits)
circuit_2 = sampler(layer=layer, qubits=qubits)
f = state_fidelity(
getStatevector(circuit_1),
getStatevector(circuit_2)
)
for j in range(bins):
if f <= limits[j]:
probabilities[j] += 1
break
pHaar_vqc = [ P_haar(2 ** qubits, f - (unit/2)) / bins for f in limits]
probabilities = [ p / epoch for p in probabilities ]
if return_detail:
return pHaar_vqc, probabilities
else:
return KL(probabilities, pHaar_vqc)
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import numpy as np
from qiskit.quantum_info import state_fidelity, Statevector
def getStatevector(circuit):
return Statevector(circuit).data
import warnings
warnings.filterwarnings('ignore')
def P_haar(N, F):
if F == 1:
return 0
else:
return (N - 1) * ((1 - F) ** (N - 2))
def KL(P, Q):
epsilon = 1e-8
kl_divergence = 0.0
for p, q in zip(P, Q):
kl_divergence += p * np.log( (p + epsilon) / (q + epsilon) )
return abs(kl_divergence)
def expressibility(qubits, sampler, *, bins=100, epoch=3000, layer=1, encode=False, return_detail=False):
unit = 1 / bins
limits = []
probabilities = np.array([0] * bins)
for i in range(1, bins + 1):
limits.append(unit * i)
for i in range(epoch):
circuit_1 = sampler(layer=layer, qubits=qubits)
circuit_2 = sampler(layer=layer, qubits=qubits)
f = state_fidelity(
getStatevector(circuit_1),
getStatevector(circuit_2)
)
for j in range(bins):
if f <= limits[j]:
probabilities[j] += 1
break
pHaar_vqc = [ P_haar(2 ** qubits, f - (unit/2)) / bins for f in limits]
probabilities = [ p / epoch for p in probabilities ]
if return_detail:
return pHaar_vqc, probabilities
else:
return KL(probabilities, pHaar_vqc)
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import sys
sys.path.append('../')
from expressibility import expressibility
from entanglement import Ent
import numpy as np
import kaleidoscope.qiskit
from kaleidoscope import bloch_sphere
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix
def getDensityMatrix(circuit):
return DensityMatrix(circuit).data
import warnings
warnings.filterwarnings('ignore')
def sampleI(layer=1, qubits=1):
circuit = QuantumCircuit(1)
circuit.i(0)
return circuit
def sampleHU1(layer=1, qubits=1):
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.u1(np.random.uniform(0, np.pi * 2), 0)
return circuit
def sampleHU2(layer=1, qubits=1):
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.u2(np.random.uniform(0, np.pi * 2), np.random.uniform(0, np.pi * 2), 0)
return circuit
def sampleHU3(layer=1, qubits=1):
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.u3(np.random.uniform(0, np.pi * 2), np.random.uniform(0, np.pi * 2), np.random.uniform(0, np.pi * 2), 0)
return circuit
X = np.matrix([
[0, 1], [1, 0]
])
Y = np.matrix([
[0, -1j],
[1j, 0]
])
Z = np.matrix([
[1, 0],
[0, -1]
])
def point(sample):
rou = getDensityMatrix(sample())
return [
np.trace(rou @ X).real,
np.trace(rou @ Y).real,
np.trace(rou @ Z).real
]
color = "#FF9933"
bins = 100
sampleI().draw(output='mpl')
pointsI = [ point(sampleI) for i in range(100) ]
bloch_sphere(points=pointsI, points_color=color)
h_i, p_i = expressibility(1, sampleI, bins=bins, return_detail=True)
fig, ax = plt.subplots()
plt.bar([ i/100 for i in range(bins) ], h_i, color="#9999FF", label="Haar", width=0.01)
plt.bar([ i/100 for i in range(bins) ], p_i, color="#FF9933AA", label="VQC", width=0.01)
plt.ylabel("Probability", fontsize=15)
plt.xlabel("Fidelity", fontsize=15)
plt.title("Expr")
ax.legend(loc="upper center")
sampleHU1().draw(output='mpl')
pointsHU1 = [ point(sampleHU1) for i in range(2000) ]
bloch_sphere(points=pointsHU1, points_color=color)
h_hu1, p_hu1 = expressibility(1, sampleHU1, bins=bins, return_detail=True)
fig, ax = plt.subplots()
plt.bar([ i/100 for i in range(bins) ], h_hu1, color="#9999FF", label="Haar", width=0.01)
plt.bar([ i/100 for i in range(bins) ], p_hu1, color="#FF9933AA", label="VQC", width=0.01)
plt.ylabel("Probability", fontsize=15)
plt.xlabel("Fidelity", fontsize=15)
plt.title("Expr")
ax.legend(loc="upper center")
sampleHU2().draw(output='mpl')
pointsHU2 = [ point(sampleHU2) for i in range(2000) ]
bloch_sphere(points=pointsHU2, points_color=color)
h_hu2, p_hu2 = expressibility(1, sampleHU2, bins=bins, return_detail=True)
fig, ax = plt.subplots()
plt.bar([ i/100 for i in range(bins) ], h_hu2, color="#9999FF", label="Haar", width=0.01)
plt.bar([ i/100 for i in range(bins) ], p_hu2, color="#FF9933AA", label="VQC", width=0.01)
plt.ylabel("Probability", fontsize=15)
plt.xlabel("Fidelity", fontsize=15)
plt.title("Expr")
ax.legend(loc="upper center")
sampleHU3().draw(output='mpl')
pointsHU3 = [ point(sampleHU3) for i in range(2000) ]
bloch_sphere(points=pointsHU3, points_color=color)
h_hu3, p_hu3 = expressibility(1, sampleHU3, bins=bins, return_detail=True)
fig, ax = plt.subplots()
plt.bar([ i/100 for i in range(bins) ], h_hu3, color="#9999FF", label="Haar", width=0.01)
plt.bar([ i/100 for i in range(bins) ], p_hu3, color="#FF9933AA", label="VQC", width=0.01)
plt.ylabel("Probability", fontsize=15)
plt.xlabel("Fidelity", fontsize=15)
plt.title("Expr")
ax.legend(loc="upper center")
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.mlab as mlab
from mpl_toolkits.mplot3d import Axes3D
plt.rc('font',family='Microsoft YaHei')
plt.rcParams['axes.unicode_minus'] = False
palettes = [
"#999999",
"#FFEE00",
"#FF9900",
"#FF3636",
"#99CC33",
"#66CCCC",
"#3399CC",
"#9966CC"
]
plt.scatter(0.1, 0.1, color=palettes[0])
plt.scatter(0.2, 0.2, color=palettes[1])
plt.scatter(0.3, 0.3, color=palettes[2])
plt.scatter(0.4, 0.4, color=palettes[3])
plt.scatter(0.5, 0.5, color=palettes[4])
plt.scatter(0.6, 0.6, color=palettes[5])
plt.scatter(0.7, 0.7, color=palettes[6])
plt.scatter(0.8, 0.8, color=palettes[7])
# Expressibility Entanglement
plt.figure(figsize=(8, 5))
c1 = "#FF6666"
c2 = "#FF9900"
c3 = "#66CCFF"
# layer 1
# layer 1 qubit 3
plt.grid()
plt.xticks([1, 2, 3, 4, 5, 6])
plt.ylim(0.13, 0.7)
plt.title("角度编码方案与表达能力", fontsize=14)
plt.xlabel("Qubit数", fontsize=13)
plt.ylabel("Expr", fontsize=13)
plt.scatter(3, 0.1974, color=c1, label="Rx(θ)(·)")
plt.scatter(3, 0.1997, color=c2, label="Ry(θ)H(·)")
plt.scatter(3, 0.1918, color=c3, label="Rz(θ)H(·)")
plt.scatter(4, 0.1462, color=c1)
plt.scatter(4, 0.1442, color=c2)
plt.scatter(4, 0.1331, color=c3)
plt.scatter(5, 0.1711, color=c1)
plt.scatter(5, 0.1824, color=c2)
plt.scatter(5, 0.1741, color=c3)
plt.scatter(1, 0.6515, color=c1)
plt.scatter(1, 0.6613, color=c2)
plt.scatter(1, 0.6260, color=c3)
plt.scatter(2, 0.3435, color=c1)
plt.scatter(2, 0.3355, color=c2)
plt.scatter(2, 0.3304, color=c3)
plt.scatter(6, 0.2582, color=c1)
plt.scatter(6, 0.2748, color=c2)
plt.scatter(6, 0.2644, color=c3)
plt.legend(loc='upper center')
plt.figure(figsize=(15, 3.8))
# layer 1
# layer 1 qubit 3
ax = plt.subplot(1,3,1)
plt.grid()
plt.ylim(0.3, 0.8)
plt.xlim(0.4, 2.4)
plt.title("Quibts: 3, Layers: 1")
plt.xlabel("Expr", fontsize=13)
plt.ylabel("Ent", fontsize=13)
plt.scatter(1.189, 0.625, color=palettes[0], label="C1")
plt.scatter(0.704, 0.377, color=palettes[1], label="C2")
plt.scatter(2.175, 0.702, color=palettes[2], label="C3")
plt.scatter(2.352, 0.540, color=palettes[3], label="C4")
plt.scatter(1.799, 0.542, color=palettes[4], label="C5")
plt.scatter(2.287, 0.720, color=palettes[5], label="C6")
plt.scatter(1.546, 0.338, color=palettes[6], label="C7")
plt.scatter(1.905, 0.456, color=palettes[7], label="C8")
ax.legend(loc='upper left', ncol=3, bbox_to_anchor=(0, 1.01))
plt.axvline(2.352, linestyle="--", color="#FF363666")
plt.axvline(2.175, linestyle="--", color="#FF990066")
plt.axhline(0.540, linestyle="--", color="#FF363666")
plt.axhline(0.702, linestyle="--", color="#FF990066")
# # layer 1 qubit 4
plt.subplot(1,3,2)
plt.grid()
plt.ylim(0.3, 0.8)
plt.xlim(0.4, 2.4)
plt.title("Quibts: 4, Layers: 1")
plt.xlabel("Expr", fontsize=13)
plt.scatter(1.724, 0.625, color=palettes[0])
plt.scatter(0.503, 0.375, color=palettes[1])
plt.scatter(1.881, 0.704, color=palettes[2])
plt.scatter(1.982, 0.537, color=palettes[3])
plt.scatter(1.837, 0.545, color=palettes[4])
plt.scatter(2.115, 0.721, color=palettes[5])
plt.scatter(1.219, 0.337, color=palettes[6])
plt.scatter(1.390, 0.457, color=palettes[7])
plt.axvline(1.982, linestyle="--", color="#FF363666")
plt.axvline(1.881, linestyle="--", color="#FF990066")
plt.axhline(0.537, linestyle="--", color="#FF363666")
plt.axhline(0.704, linestyle="--", color="#FF990066")
# # layer 1 qubit 5
plt.subplot(1,3,3)
plt.grid()
plt.ylim(0.3, 0.8)
plt.xlim(0.4, 2.4)
plt.title("Quibts: 5, Layers: 1")
plt.xlabel("Expr", fontsize=13)
plt.scatter(1.376, 0.625, color=palettes[0])
plt.scatter(0.456, 0.377, color=palettes[1])
plt.scatter(1.465, 0.703, color=palettes[2])
plt.scatter(1.557, 0.536, color=palettes[3])
plt.scatter(1.424, 0.547, color=palettes[4])
plt.scatter(2.113, 0.722, color=palettes[5])
plt.scatter(0.942, 0.339, color=palettes[6])
plt.scatter(1.152, 0.456, color=palettes[7])
plt.axvline(1.557, linestyle="--", color="#FF363666")
plt.axvline(1.465, linestyle="--", color="#FF990066")
plt.axhline(0.536, linestyle="--", color="#FF363666")
plt.axhline(0.703, linestyle="--", color="#FF990066")
def depth(circuit_type, n, L):
if circuit_type == 1:
return (2 * n + 1) * L
elif circuit_type >= 2 and circuit_type <= 4:
return (n + 1) * L + 1
elif circuit_type == 5:
return (2 + n + n // np.gcd(n, 3)) * L
elif circuit_type == 6:
return (n ** 2 - n + 4) * L
elif circuit_type == 7:
return 6 * L
elif circuit_type == 8:
return (n + 2) * L
colors2 = ['#FFCC33', '#FF9900', '#FF9966', '#FF6666', '#CC3333']
colors = ['#99CCFF', '#66CCFF', '#0088CC', '#6666FF', '#0000FF']
types = ['o', '^', ',', 'p', 'X']
plt.grid()
plt.title("线路深度同量子比特数量关系")
plt.xlabel("线路类型", fontsize=13)
plt.ylabel("线路深度", fontsize=13)
for n in range(2, 7):
for ct in range(1, 9):
if ct == 1:
plt.scatter(ct, depth(ct, n, 1), color=colors[n - 2], marker=types[n - 2], label=f"n={n}, L=1")
else:
plt.scatter(ct, depth(ct, n, 1), color=colors[n - 2], marker=types[n - 2])
for n in range(2, 7):
for ct in range(1, 9):
if ct == 1:
plt.scatter(ct, depth(ct, n, 3), color=colors2[n - 2], marker=types[n - 2], label=f"n={n}, L=3")
else:
plt.scatter(ct, depth(ct, n, 3), color=colors2[n - 2], marker=types[n - 2])
plt.axhline(22, 0, 8, linestyle="--", color="#CC6666")
plt.legend()
plt.figure(figsize=(7, 5))
# layer 1
# layer 1 qubit 3
plt.grid()
plt.ylim(0.4, 0.6)
plt.xlim(1, 1.7)
plt.title("原始线路与丢弃处理后线路的可表达性与纠缠能力", fontsize=13)
plt.xlabel("Expr", fontsize=13)
plt.ylabel("Ent", fontsize=13)
plt.scatter(1.6105, 0.5622, color="#FF9966", label="原始线路")
plt.scatter(1.4415, 0.5158, color="#FF6666", label="纠缠丢弃")
plt.scatter(1.1185, 0.4283, color="#3399CC", label="旋转丢弃")
plt.legend(loc='upper left')
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import sys
sys.path.append('../')
from expressibility import expressibility
from entanglement import Ent
import numpy as np
import kaleidoscope.qiskit
from kaleidoscope import bloch_sphere
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix
def getDensityMatrix(circuit):
return DensityMatrix(circuit).data
import warnings
warnings.filterwarnings('ignore')
def sampleI(layer=1, qubits=1):
circuit = QuantumCircuit(1)
circuit.i(0)
return circuit
def sampleHU1(layer=1, qubits=1):
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.u1(np.random.uniform(0, np.pi * 2), 0)
return circuit
def sampleHU2(layer=1, qubits=1):
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.u2(np.random.uniform(0, np.pi * 2), np.random.uniform(0, np.pi * 2), 0)
return circuit
def sampleHU3(layer=1, qubits=1):
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.u3(np.random.uniform(0, np.pi * 2), np.random.uniform(0, np.pi * 2), np.random.uniform(0, np.pi * 2), 0)
return circuit
X = np.matrix([
[0, 1], [1, 0]
])
Y = np.matrix([
[0, -1j],
[1j, 0]
])
Z = np.matrix([
[1, 0],
[0, -1]
])
def point(sample):
rou = getDensityMatrix(sample())
return [
np.trace(rou @ X).real,
np.trace(rou @ Y).real,
np.trace(rou @ Z).real
]
color = "#FF9933"
bins = 100
sampleI().draw(output='mpl')
pointsI = [ point(sampleI) for i in range(100) ]
bloch_sphere(points=pointsI, points_color=color)
h_i, p_i = expressibility(1, sampleI, bins=bins, return_detail=True)
fig, ax = plt.subplots()
plt.bar([ i/100 for i in range(bins) ], h_i, color="#9999FF", label="Haar", width=0.01)
plt.bar([ i/100 for i in range(bins) ], p_i, color="#FF9933AA", label="VQC", width=0.01)
plt.ylabel("Probability", fontsize=15)
plt.xlabel("Fidelity", fontsize=15)
plt.title("Expr")
ax.legend(loc="upper center")
sampleHU1().draw(output='mpl')
pointsHU1 = [ point(sampleHU1) for i in range(2000) ]
bloch_sphere(points=pointsHU1, points_color=color)
h_hu1, p_hu1 = expressibility(1, sampleHU1, bins=bins, return_detail=True)
fig, ax = plt.subplots()
plt.bar([ i/100 for i in range(bins) ], h_hu1, color="#9999FF", label="Haar", width=0.01)
plt.bar([ i/100 for i in range(bins) ], p_hu1, color="#FF9933AA", label="VQC", width=0.01)
plt.ylabel("Probability", fontsize=15)
plt.xlabel("Fidelity", fontsize=15)
plt.title("Expr")
ax.legend(loc="upper center")
sampleHU2().draw(output='mpl')
pointsHU2 = [ point(sampleHU2) for i in range(2000) ]
bloch_sphere(points=pointsHU2, points_color=color)
h_hu2, p_hu2 = expressibility(1, sampleHU2, bins=bins, return_detail=True)
fig, ax = plt.subplots()
plt.bar([ i/100 for i in range(bins) ], h_hu2, color="#9999FF", label="Haar", width=0.01)
plt.bar([ i/100 for i in range(bins) ], p_hu2, color="#FF9933AA", label="VQC", width=0.01)
plt.ylabel("Probability", fontsize=15)
plt.xlabel("Fidelity", fontsize=15)
plt.title("Expr")
ax.legend(loc="upper center")
sampleHU3().draw(output='mpl')
pointsHU3 = [ point(sampleHU3) for i in range(2000) ]
bloch_sphere(points=pointsHU3, points_color=color)
h_hu3, p_hu3 = expressibility(1, sampleHU3, bins=bins, return_detail=True)
fig, ax = plt.subplots()
plt.bar([ i/100 for i in range(bins) ], h_hu3, color="#9999FF", label="Haar", width=0.01)
plt.bar([ i/100 for i in range(bins) ], p_hu3, color="#FF9933AA", label="VQC", width=0.01)
plt.ylabel("Probability", fontsize=15)
plt.xlabel("Fidelity", fontsize=15)
plt.title("Expr")
ax.legend(loc="upper center")
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.mlab as mlab
from mpl_toolkits.mplot3d import Axes3D
plt.rc('font',family='Microsoft YaHei')
plt.rcParams['axes.unicode_minus'] = False
palettes = [
"#999999",
"#FFEE00",
"#FF9900",
"#FF3636",
"#99CC33",
"#66CCCC",
"#3399CC",
"#9966CC"
]
plt.scatter(0.1, 0.1, color=palettes[0])
plt.scatter(0.2, 0.2, color=palettes[1])
plt.scatter(0.3, 0.3, color=palettes[2])
plt.scatter(0.4, 0.4, color=palettes[3])
plt.scatter(0.5, 0.5, color=palettes[4])
plt.scatter(0.6, 0.6, color=palettes[5])
plt.scatter(0.7, 0.7, color=palettes[6])
plt.scatter(0.8, 0.8, color=palettes[7])
# Expressibility Entanglement
plt.figure(figsize=(8, 5))
c1 = "#FF6666"
c2 = "#FF9900"
c3 = "#66CCFF"
# layer 1
# layer 1 qubit 3
plt.grid()
plt.xticks([1, 2, 3, 4, 5, 6])
plt.ylim(0.13, 0.7)
plt.title("角度编码方案与表达能力", fontsize=14)
plt.xlabel("Qubit数", fontsize=13)
plt.ylabel("Expr", fontsize=13)
plt.scatter(3, 0.1974, color=c1, label="Rx(θ)(·)")
plt.scatter(3, 0.1997, color=c2, label="Ry(θ)H(·)")
plt.scatter(3, 0.1918, color=c3, label="Rz(θ)H(·)")
plt.scatter(4, 0.1462, color=c1)
plt.scatter(4, 0.1442, color=c2)
plt.scatter(4, 0.1331, color=c3)
plt.scatter(5, 0.1711, color=c1)
plt.scatter(5, 0.1824, color=c2)
plt.scatter(5, 0.1741, color=c3)
plt.scatter(1, 0.6515, color=c1)
plt.scatter(1, 0.6613, color=c2)
plt.scatter(1, 0.6260, color=c3)
plt.scatter(2, 0.3435, color=c1)
plt.scatter(2, 0.3355, color=c2)
plt.scatter(2, 0.3304, color=c3)
plt.scatter(6, 0.2582, color=c1)
plt.scatter(6, 0.2748, color=c2)
plt.scatter(6, 0.2644, color=c3)
plt.legend(loc='upper center')
plt.figure(figsize=(15, 3.8))
# layer 1
# layer 1 qubit 3
ax = plt.subplot(1,3,1)
plt.grid()
plt.ylim(0.3, 0.8)
plt.xlim(0.4, 2.4)
plt.title("Quibts: 3, Layers: 1")
plt.xlabel("Expr", fontsize=13)
plt.ylabel("Ent", fontsize=13)
plt.scatter(1.189, 0.625, color=palettes[0], label="C1")
plt.scatter(0.704, 0.377, color=palettes[1], label="C2")
plt.scatter(2.175, 0.702, color=palettes[2], label="C3")
plt.scatter(2.352, 0.540, color=palettes[3], label="C4")
plt.scatter(1.799, 0.542, color=palettes[4], label="C5")
plt.scatter(2.287, 0.720, color=palettes[5], label="C6")
plt.scatter(1.546, 0.338, color=palettes[6], label="C7")
plt.scatter(1.905, 0.456, color=palettes[7], label="C8")
ax.legend(loc='upper left', ncol=3, bbox_to_anchor=(0, 1.01))
plt.axvline(2.352, linestyle="--", color="#FF363666")
plt.axvline(2.175, linestyle="--", color="#FF990066")
plt.axhline(0.540, linestyle="--", color="#FF363666")
plt.axhline(0.702, linestyle="--", color="#FF990066")
# # layer 1 qubit 4
plt.subplot(1,3,2)
plt.grid()
plt.ylim(0.3, 0.8)
plt.xlim(0.4, 2.4)
plt.title("Quibts: 4, Layers: 1")
plt.xlabel("Expr", fontsize=13)
plt.scatter(1.724, 0.625, color=palettes[0])
plt.scatter(0.503, 0.375, color=palettes[1])
plt.scatter(1.881, 0.704, color=palettes[2])
plt.scatter(1.982, 0.537, color=palettes[3])
plt.scatter(1.837, 0.545, color=palettes[4])
plt.scatter(2.115, 0.721, color=palettes[5])
plt.scatter(1.219, 0.337, color=palettes[6])
plt.scatter(1.390, 0.457, color=palettes[7])
plt.axvline(1.982, linestyle="--", color="#FF363666")
plt.axvline(1.881, linestyle="--", color="#FF990066")
plt.axhline(0.537, linestyle="--", color="#FF363666")
plt.axhline(0.704, linestyle="--", color="#FF990066")
# # layer 1 qubit 5
plt.subplot(1,3,3)
plt.grid()
plt.ylim(0.3, 0.8)
plt.xlim(0.4, 2.4)
plt.title("Quibts: 5, Layers: 1")
plt.xlabel("Expr", fontsize=13)
plt.scatter(1.376, 0.625, color=palettes[0])
plt.scatter(0.456, 0.377, color=palettes[1])
plt.scatter(1.465, 0.703, color=palettes[2])
plt.scatter(1.557, 0.536, color=palettes[3])
plt.scatter(1.424, 0.547, color=palettes[4])
plt.scatter(2.113, 0.722, color=palettes[5])
plt.scatter(0.942, 0.339, color=palettes[6])
plt.scatter(1.152, 0.456, color=palettes[7])
plt.axvline(1.557, linestyle="--", color="#FF363666")
plt.axvline(1.465, linestyle="--", color="#FF990066")
plt.axhline(0.536, linestyle="--", color="#FF363666")
plt.axhline(0.703, linestyle="--", color="#FF990066")
def depth(circuit_type, n, L):
if circuit_type == 1:
return (2 * n + 1) * L
elif circuit_type >= 2 and circuit_type <= 4:
return (n + 1) * L + 1
elif circuit_type == 5:
return (2 + n + n // np.gcd(n, 3)) * L
elif circuit_type == 6:
return (n ** 2 - n + 4) * L
elif circuit_type == 7:
return 6 * L
elif circuit_type == 8:
return (n + 2) * L
colors2 = ['#FFCC33', '#FF9900', '#FF9966', '#FF6666', '#CC3333']
colors = ['#99CCFF', '#66CCFF', '#0088CC', '#6666FF', '#0000FF']
types = ['o', '^', ',', 'p', 'X']
plt.grid()
plt.title("线路深度同量子比特数量关系")
plt.xlabel("线路类型", fontsize=13)
plt.ylabel("线路深度", fontsize=13)
for n in range(2, 7):
for ct in range(1, 9):
if ct == 1:
plt.scatter(ct, depth(ct, n, 1), color=colors[n - 2], marker=types[n - 2], label=f"n={n}, L=1")
else:
plt.scatter(ct, depth(ct, n, 1), color=colors[n - 2], marker=types[n - 2])
for n in range(2, 7):
for ct in range(1, 9):
if ct == 1:
plt.scatter(ct, depth(ct, n, 3), color=colors2[n - 2], marker=types[n - 2], label=f"n={n}, L=3")
else:
plt.scatter(ct, depth(ct, n, 3), color=colors2[n - 2], marker=types[n - 2])
plt.axhline(22, 0, 8, linestyle="--", color="#CC6666")
plt.legend()
plt.figure(figsize=(7, 5))
# layer 1
# layer 1 qubit 3
plt.grid()
plt.ylim(0.4, 0.6)
plt.xlim(1, 1.7)
plt.title("原始线路与丢弃处理后线路的可表达性与纠缠能力", fontsize=13)
plt.xlabel("Expr", fontsize=13)
plt.ylabel("Ent", fontsize=13)
plt.scatter(1.6105, 0.5622, color="#FF9966", label="原始线路")
plt.scatter(1.4415, 0.5158, color="#FF6666", label="纠缠丢弃")
plt.scatter(1.1185, 0.4283, color="#3399CC", label="旋转丢弃")
plt.legend(loc='upper left')
|
https://github.com/adiazcarral/QHarmony
|
adiazcarral
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Jan 27 11:07:17 2022
@author: angel
"""
# http://lampx.tugraz.at/~hadley/ss1/bzones/fcc.php
# https://aiida-tutorials.readthedocs.io/en/tutorial-2020-intro-week/source/sections/bands.html
from jarvis.db.figshare import get_wann_electron, get_wann_phonon, get_hk_tb
from jarvis.io.qiskit.inputs import HermitianSolver, get_bandstruct, get_dos
from jarvis.core.kpoints import generate_kgrid
import numpy as np
import qiskit
from qiskit import Aer
from jarvis.core.circuits import QuantumCircuitLibrary
import matplotlib.pyplot as plt
# JVASP-816 Al
# JVASP-1002 Si
# JVASP-35680 PbS
#########################
##### Download WTBH #####
wtbh, Ef, atoms = get_wann_electron(jid="JVASP-1002")
# wtbh, atoms = get_wann_phonon(jid="JVASP-1002", factor=34.3)
#########################
kpt = [0.5, 0., 0.5] #X-point jarvis
# kpt = [0., 0., 0.] #gamma-point
################################################
##### Transform WTBH into Hermitian matrix #####
# kpt = [0.5, 0., 0.5] #X-point jarvis
kpt = [0., 0., 0.] #gamma-point
##########
hk = get_hk_tb(w=wtbh, k=kpt)
HS = HermitianSolver(hk)
n_qubits = HS.n_qubits()
reps = 1
circ = QuantumCircuitLibrary(n_qubits=n_qubits, reps=reps).circuit6()
backend = Aer.get_backend("statevector_simulator")
###########
### VQE ###
en, vqe_result, vqe = HS.run_vqe(mode='min_val',var_form=circ,backend=backend)
vals, vecs = HS.run_numpy()
params = vqe.optimal_params
circuit = vqe.construct_circuit(params)
print('Classical, VQE (eV)', (vals[0] - Ef),(en - Ef))
print('Classical, VQE (eV)', (vals[0]),(en))
print(Ef)
###########
##### PbS X Plot Example #######
y = [-5.527449487783215, -8.057364907488996, -8.262343159928434, -8.247681114397821, -8.30798759954503, -8.310212504542353 ]
x = [1, 2, 3, 4, 5, 6]
plt.plot(x,y, color='black', marker = 'o')
plt.axhline(y=-8.310902072462328, color='b', linestyle='-.', linewidth=1)
plt.xlabel('Repetitions')
plt.ylabel('Energy (eV)')
plt.title('PbS X-point (Circuit 6)')
plt.xlim(0.5, 6.5)
plt.ylim(-10, -5)
plt.savefig('PbSX6.png', dpi=150, format=None, metadata=None,
bbox_inches='tight')
|
https://github.com/ayush-vatsal/Grovers_Search_Algorithm
|
ayush-vatsal
|
from qiskit import QuantumCircuit, Aer, assemble, ClassicalRegister, QuantumRegister, transpile
import numpy as np
from qiskit.visualization import plot_histogram, plot_bloch_multivector
#clause_list = [[0,1], [1,2], [2,3]]
address = QuantumRegister(2, name='add')
var = QuantumRegister(4, name='v')
clause_qubits = QuantumRegister(3, name='c')
output = QuantumRegister(1, name='out')
result = ClassicalRegister(3, name='cbit')
qc = QuantumCircuit(address, var, clause_qubits, output , result)
def qRAM(qc, address, var):
qc.x(address)
qc.mct(address, var[3])
qc.x(address)
qc.barrier(address, var)
qc.x(address[0])
qc.mct(address, var[1])
qc.mct(address, var[3])
qc.x(address[0])
qc.barrier(address, var)
qc.x(address[1])
qc.mct(address, var[1])
qc.mct(address, var[2])
qc.x(address[1])
qc.barrier(address, var)
qc.mct(address, var[0])
qc.mct(address, var[2])
qRAM(qc, address, var)
qc.draw()
def oracle(qc, var, clause_qubits):
qc.cx(var[0], clause_qubits[0])
qc.cx(var[1], clause_qubits[0])
qc.cx(var[1], clause_qubits[1])
qc.cx(var[2], clause_qubits[1])
qc.cx(var[2], clause_qubits[2])
qc.cx(var[3], clause_qubits[2])
qc.mct(clause_qubits, output)
qc.cx(var[0], clause_qubits[0])
qc.cx(var[1], clause_qubits[0])
qc.cx(var[1], clause_qubits[1])
qc.cx(var[2], clause_qubits[1])
qc.cx(var[2], clause_qubits[2])
qc.cx(var[3], clause_qubits[2])
oracle(qc, var, clause_qubits)
qc.draw(fold=-1)
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> (H-gates)
for qubit in range(nqubits):
qc.h(qubit)
# Apply transformation |00..0> -> |11..1> (X-gates)
for qubit in range(nqubits):
qc.x(qubit)
# Do multi-controlled-Z gate
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
# Apply transformation |11..1> -> |00..0>
for qubit in range(nqubits):
qc.x(qubit)
# Apply transformation |00..0> -> |s>
for qubit in range(nqubits):
qc.h(qubit)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "U$_s$"
return U_s
address = QuantumRegister(2, name='add')
var = QuantumRegister(4, name='v')
clause_qubits = QuantumRegister(3, name='c')
output = QuantumRegister(1, name='out')
result = ClassicalRegister(2, name='cbit')
results = ClassicalRegister(4, name='cbits')
qc = QuantumCircuit(address, var, clause_qubits, output , result, results)
qc.initialize([1, -1]/np.sqrt(2), output)
qc.h(address)
qc.barrier()
qRAM(qc, address, var)
qc.barrier()
#qc.h(var)#remove#
oracle(qc, var, clause_qubits)
qc.barrier()
qc.append(diffuser(2), [0,1])
qc.append(diffuser(4), [2,3,4,5])
#qc.measure(address, result[0:2])
qc.measure(var, results)
qc.draw(fold=-1)
aer_simulator = Aer.get_backend('aer_simulator')
transpiled_qc = transpile(qc, aer_simulator)
qobj = assemble(transpiled_qc)
result = aer_simulator.run(qobj).result()
plot_histogram(result.get_counts())
|
https://github.com/AmanSinghBhogal/NasaNEO_Classification
|
AmanSinghBhogal
|
import pandas as pd
from sklearn.model_selection import train_test_split
from qiskit import QuantumCircuit, execute, Aer
from qiskit import ClassicalRegister, QuantumRegister
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
from math import asin, sqrt, pi, log
from statistics import mean
import pandas as pd
from sklearn.metrics import confusion_matrix, precision_score, recall_score
# Loaded the Dataset
data = pd.read_csv('neo_v2.csv')
# Writing code for Pre-Procesing
cat_max_dia = []
cat_RV = []
cat_miss = []
max_dia_mean = mean(data['est_diameter_max'])
Rv_mean = mean(data['relative_velocity'])
# print("\n\nThe Mean Max Diameter is: ", max_dia_mean)
# print("The Mean Relative Velocity is: ", Rv_mean)
for i,j, z in zip(data['est_diameter_max'], data['relative_velocity'], data['miss_distance']):
if i>=max_dia_mean:
cat_max_dia.append("Large")
else :
cat_max_dia.append("Small")
if j>=Rv_mean:
cat_RV.append("Fast")
else:
cat_RV.append("Slow")
if z>=0 and z< 25000000:
cat_miss.append("Less")
elif z>= 25000000 and z<50000000:
cat_miss.append("Medium")
else:
cat_miss.append("More")
processed_data = pd.DataFrame(list(zip(data['est_diameter_max'], data['relative_velocity'],data['miss_distance'], cat_max_dia, cat_RV,cat_miss, data['hazardous'])),columns=['Max_Diameter','Relative_Velocity','Miss_Distance', 'Categorized_Diameter', 'Categorized_Relative_Vel','Categorised_Miss_Distance','Hazardous'])
# Saving the Processed Data to get a better view
processed_data.to_csv('processedData.csv')
# Splitted the Dataset into Training and Testing
train_input, test_input = train_test_split(processed_data, test_size=0.3, random_state=0)
# # Printing Number of records in training and testing
# print("There are {} Training Records and {} Testing Records".format(train_input.shape[0], test_input.shape[0]))
# # Printing the Number of True and False Records in Train and Test Dataset
# print("Train Dataset: No of True: {}, No. False: {}".format(len(train_input[train_input['Hazardous'] == True]), len(train_input[train_input['Hazardous'] == False])))
# print("Test Dataset: No of True: {}, No. False: {}".format(len(test_input[test_input['Hazardous'] == True]), len(test_input[test_input['Hazardous'] == False])))
# need to write preprocess function for calculating backward probability
# Function for Calculating Category Prob.
def prob_hazard_calc(df, category_name, category_val):
pop = df[df[category_name] == category_val]
hazard_pop = pop[pop['Hazardous'] == True]
p_pop = len(hazard_pop)/len(pop)
return p_pop, len(pop)
# For Max Diameter
# for small:
p_small, pop_small = prob_hazard_calc(train_input, "Categorized_Diameter", "Small")
# print(p_small, pop_small)
# for Large:
p_large, pop_large = prob_hazard_calc(train_input, "Categorized_Diameter", "Large")
# print(p_large, pop_large)
# print("\n\nPrinting Chances of Max Diameter Objects given they are hazardous:\n")
# print("{} Small Diameter objects had {} chances of being hazardous".format(pop_small, p_small))
# print("{} Large Diameter objects had {} chances of being hazardous".format(pop_large, p_large))
# For Relative Velocity:
# for Slow:
p_slow, pop_slow = prob_hazard_calc(train_input, "Categorized_Relative_Vel", "Slow")
# print(p_slow, pop_slow)
# for Fast:
p_fast, pop_fast = prob_hazard_calc(train_input, "Categorized_Relative_Vel", "Fast")
# print(p_fast, pop_fast)
# print("\n\nPrinting Chances of Relative Velocity Objects given they are hazardous:\n")
# print("{} Slow Relative Velocity objects had {} chances of being hazardous".format(pop_slow, p_slow))
# print("{} Fast Relative Velocity objects had {} chances of being hazardous".format(pop_fast, p_fast))
# For Miss Distance:
# For Less
p_less, pop_less = prob_hazard_calc(train_input, "Categorised_Miss_Distance", "Less")
# print(p_less, pop_less)
# For Medium
p_med, pop_med = prob_hazard_calc(train_input, "Categorised_Miss_Distance", "Medium")
# print(p_med, pop_med)
# For More:
p_more, pop_more = prob_hazard_calc(train_input, "Categorised_Miss_Distance", "More")
# print(p_more, pop_more)
# print("\n\nPrinting Chances of Miss Distance Objects given they are hazardous:\n")
# print("{} Less Miss Distance objects had {} chances of being hazardous".format(pop_less, p_less))
# print("{} Medium Miss Distance objects had {} chances of being hazardous".format(pop_med, p_med))
# print("{} More Miss Distance objects had {} chances of being hazardous".format(pop_more, p_more))
# Implementing Baysian Interference:
# Specifying the marginal probability
def prob_to_angle(prob):
"""
Converts a given P(psi) value into an equivalent theta value.
"""
return 2*asin(sqrt(prob))
# Baysian Interference
# Dataset with missing values
data = [
(1, 1), (1, 1), (0, 0), (0, 0), (0, 0), (0, None), (0, 1), (1, 0)
]
# The log‐likelihood function adapted for our data
def log_likelihood(data, prob_a_b, prob_a_nb, prob_na_b, prob_na_nb):
def get_prob(point):
if point[0] == 1 and point[1] == 1:
return log(prob_a_b)
elif point[0] == 1 and point[1] == 0:
return log(prob_a_nb)
elif point[0] == 0 and point[1] == 1:
return log(prob_na_b)
elif point[0] == 0 and point[1] == 0:
return log(prob_na_nb)
else:
return log(prob_na_b+prob_na_nb)
return sum(map(get_prob, data))
# The as‐pqc function
def as_pqc(cnt_quantum, with_qc, cnt_classical=1, shots=1, hist=False, measure=False):
# Prepare the circuit with qubits and a classical bit to hold the measurement
qr = QuantumRegister(cnt_quantum)
cr = ClassicalRegister(cnt_classical)
qc = QuantumCircuit(qr, cr) if measure else QuantumCircuit(qr)
with_qc(qc, qr=qr, cr=cr)
results = execute(
qc,
Aer.get_backend('statevector_simulator') if measure is False else Aer.get_backend('qasm_simulator'),
shots=shots
).result().get_counts()
return plot_histogram(results, figsize=(12,4)) if hist else results
# The quantum Bayesian network
def qbn(data, hist=True):
def circuit(qc, qr=None, cr=None):
list_a = list(filter(lambda item: item[0] == 1, data))
list_na = list(filter(lambda item: item[0] == 0, data))
# set the marginal probability of A
qc.ry(prob_to_angle(
len(list_a) / len(data)
), 0)
# set the conditional probability of NOT A and (B / not B)
qc.x(0)
qc.cry(prob_to_angle(
sum(list(map(lambda item: item[1], list_na))) / len(list_na)
),0,1)
qc.x(0)
# set the conditional probability of A and (B / not B)
qc.cry(prob_to_angle(
sum(list(map(lambda item: item[1], list_a))) / len(list_a)
),0,1)
return as_pqc(2, circuit, hist=hist)
# Ignoring the missing data
qbn(list(filter(lambda item: item[1] is not None ,data)))
# Calculate the log‐likelihood when ignoring the missing data
def eval_qbn(model, prepare_data, data):
results = model(prepare_data(data), hist=False)
return (
round(log_likelihood(data,
results['11'], # prob_a_b
results['01'], # prob_a_nb
results['10'], # prob_na_b
results['00'] # prob_na_nb
), 3),
results['10'] / (results['10'] + results['00'])
)
# print(eval_qbn(qbn, lambda dataset: list(filter(lambda item: item[1] is not None ,dataset)), data))
# # Calculate the log‐likelihood when filling in 0
# print(eval_qbn(qbn, lambda dataset: list(map(lambda item: item if item[1] is not None else (item[0], 0) ,dataset)), data))
# # Evaluating the guess
# print(eval_qbn(qbn, lambda dataset: list(map(lambda item: item if item[1] is not None else (item[0], 0.5) ,dataset)), data))
# # Refining the model
# print(eval_qbn(qbn, lambda dataset: list(map(lambda item: item if item[1] is not None else (item[0], 0.3) ,dataset)), data))
# # Further refining the model
# print(eval_qbn(qbn, lambda dataset: list(map(lambda item: item if item[1] is not None else (item[0], 0.252) ,dataset)), data))
# # Another iteration
# print(eval_qbn(qbn, lambda dataset: list(map(lambda item: item if item[1] is not None else (item[0], 0.252) ,dataset)), data))
# positions of the qubits
QPOS_dia = 0
QPOS_RV = 1
def apply_islarge_fast(qc):
# set the marginal probability of large Diameter
qc.ry(prob_to_angle(p_large), QPOS_dia)
# set the marginal probability of Fast Relative Velocity
qc.ry(prob_to_angle(p_fast), QPOS_RV)
# Defining the CCRY‐gate:
def ccry(qc, theta, control1, control2, controlled):
qc.cry(theta/2, control2, controlled)
qc.cx(control1, control2)
qc.cry(-theta/2, control2, controlled)
qc.cx(control1, control2)
qc.cry(theta/2, control1, controlled)
# Listing Represent the norm
# position of the qubit representing the norm
QPOS_NORM = 2
def apply_norm(qc, norm_params):
"""
norm_params = {
'p_norm_small_slow': 0.25,
'p_norm_small_fast': 0.35,
'p_norm_large_slow': 0.45,
'p_norm_large_fast': 0.55
}
"""
# set the conditional probability of Norm given small/slow
qc.x(QPOS_dia)
qc.x(QPOS_RV)
ccry(qc, prob_to_angle(
norm_params['p_norm_small_slow']
),QPOS_dia, QPOS_RV, QPOS_NORM)
qc.x(QPOS_dia)
qc.x(QPOS_RV)
# set the conditional probability of Norm given small/fast
qc.x(QPOS_dia)
ccry(qc, prob_to_angle(
norm_params['p_norm_small_fast']
),QPOS_dia, QPOS_RV, QPOS_NORM)
qc.x(QPOS_dia)
# set the conditional probability of Norm given large/slow
qc.x(QPOS_RV)
ccry(qc, prob_to_angle(
norm_params['p_norm_large_slow']
),QPOS_dia, QPOS_RV, QPOS_NORM)
qc.x(QPOS_RV)
# set the conditional probability of Norm given large/fast
ccry(qc, prob_to_angle(
norm_params['p_norm_large_fast']
),QPOS_dia, QPOS_RV, QPOS_NORM)
# Listing Calculate the probabilities related to the miss distance
pop_more = train_input[train_input.Categorised_Miss_Distance.eq("More")]
hazardous_more = round(len(pop_more[pop_more.Hazardous.eq(1)])/len(pop_more), 2)
p_more = round(len(pop_more)/len(train_input), 2)
pop_med = train_input[train_input.Categorised_Miss_Distance.eq("Medium")]
hazardous_med = round(len(pop_med[pop_med.Hazardous.eq(1)])/len(pop_med), 2)
p_med = round(len(pop_med)/len(train_input), 2)
pop_less = train_input[train_input.Categorised_Miss_Distance.eq("Less")]
hazardous_less = round(len(pop_less[pop_less.Hazardous.eq(1)])/len(pop_less), 2)
p_less = round(len(pop_less)/len(train_input), 2)
# print("More Miss Distance: {} of the Objects, hazardous: {}".format(p_more , hazardous_more))
# print("Medium Miss Distance: {} of the Objects, hazardous: {}".format(p_med,hazardous_med))
# print("Less Miss Distance: {} of the Objects, hazardous: {}".format(p_less,hazardous_less))
# Listing Represent the miss-distance
# positions of the qubits
QPOS_more = 3
QPOS_med = 4
QPOS_less = 5
def apply_class(qc):
# set the marginal probability of miss-distance=more
qc.ry(prob_to_angle(p_more), QPOS_more)
qc.x(QPOS_more)
# set the marginal probability of Pclass=2nd
qc.cry(prob_to_angle(p_med/(1-p_more)), QPOS_more, QPOS_med)
# set the marginal probability of Pclass=3rd
qc.x(QPOS_med)
ccry(qc, prob_to_angle(p_less/(1-p_more-p_med)), QPOS_more, QPOS_med, QPOS_less)
qc.x(QPOS_med)
qc.x(QPOS_more)
# Listing Represent hazardous
# position of the qubit
QPOS_hazardous = 6
def apply_hazardous(qc, hazardous_params):
"""
hazardous_params = {
'p_hazardous_favoured_more': 0.3,
'p_hazardous_favoured_med': 0.4,
'p_hazardous_favoured_less': 0.5,
'p_hazardous_unfavoured_more': 0.6,
'p_hazardous_unfavoured_med': 0.7,
'p_hazardous_unfavoured_less': 0.8
}
"""
# set the conditional probability of Survival given unfavored by norm
qc.x(QPOS_NORM)
ccry(qc, prob_to_angle(
hazardous_params['p_hazardous_unfavoured_more']
),QPOS_NORM, QPOS_more, QPOS_hazardous)
ccry(qc, prob_to_angle(
hazardous_params['p_hazardous_unfavoured_med']
),QPOS_NORM, QPOS_med, QPOS_hazardous)
ccry(qc, prob_to_angle(
hazardous_params['p_hazardous_unfavoured_less']
),QPOS_NORM, QPOS_less, QPOS_hazardous)
qc.x(QPOS_NORM)
# set the conditional probability of hazardous given favored by norm
ccry(qc, prob_to_angle(
hazardous_params['p_hazardous_favoured_more']
),QPOS_NORM, QPOS_more, QPOS_hazardous)
ccry(qc, prob_to_angle(
hazardous_params['p_hazardous_favoured_med']
),QPOS_NORM, QPOS_med, QPOS_hazardous)
ccry(qc, prob_to_angle(
hazardous_params['p_hazardous_favoured_less']
),QPOS_NORM, QPOS_less, QPOS_hazardous)
# Listing The quantum bayesian network
QUBITS = 7
def qbn_neo(norm_params, hazardous_params, hist=True, measure=False, shots=1):
def circuit(qc, qr=None, cr=None):
apply_islarge_fast(qc)
apply_norm(qc, norm_params)
apply_class(qc)
apply_hazardous(qc, hazardous_params)
return as_pqc(QUBITS, circuit, hist=hist, measure=measure, shots=shots)
# Listing Try the QBN
norm_params = {
'p_norm_small_slow': 0.25,
'p_norm_small_fast': 0.35,
'p_norm_large_slow': 0.45,
'p_norm_large_fast': 0.55
}
hazardous_params = {
'p_hazardous_favoured_more': 0.3,
'p_hazardous_favoured_med': 0.4,
'p_hazardous_favoured_less': 0.5,
'p_hazardous_unfavoured_more': 0.6,
'p_hazardous_unfavoured_med': 0.7,
'p_hazardous_unfavoured_less': 0.8
}
qbn_neo(norm_params, hazardous_params, hist=True)
# Listing Calculate the parameters of the norm
def calculate_norm_params(objects):
# the different diameteric objects in our data
pop_large = objects[objects.Categorized_Diameter.eq("Large")]
pop_small = objects[objects.Categorized_Diameter.eq("Small")]
# combinations of being a large object and Relative Velocity
pop_small_slow = pop_small[pop_small.Categorized_Relative_Vel.eq('Slow')]
pop_small_fast = pop_small[pop_small.Categorized_Relative_Vel.eq('Fast')]
pop_large_slow = pop_large[pop_large.Categorized_Relative_Vel.eq('Slow')]
pop_large_fast = pop_large[pop_large.Categorized_Relative_Vel.eq('Fast')]
norm_params = {
'p_norm_small_slow': pop_small_slow.Norm.sum() / len(pop_small_slow),
'p_norm_small_fast': pop_small_fast.Norm.sum() / len(pop_small_fast),
'p_norm_large_slow': pop_large_slow.Norm.sum() / len(pop_large_slow),
'p_norm_large_fast': pop_large_fast.Norm.sum() / len(pop_large_fast),
}
return norm_params
# Listing Calculate the parameters of hazardous
def calculate_hazardous_params(objects):
# all hazardous
hazardous = objects[objects.Hazardous.eq(1)]
# weight the object
def weight_object(norm, missDistance):
return lambda object: (object[0] if norm else 1-object[0]) * (1 if object[1] == missDistance else 0)
# calculate the probability of being hazardous
def calc_prob(norm, missDistance):
return sum(list(map(
weight_object(norm, missDistance),
list(zip(hazardous['Norm'], hazardous['Categorised_Miss_Distance']))
))) / sum(list(map(
weight_object(norm, missDistance),
list(zip(objects['Norm'], objects['Categorised_Miss_Distance']))
)))
hazardous_params = {
'p_hazardous_favoured_more': calc_prob(True, "More"),
'p_hazardous_favoured_med': calc_prob(True, "Medium"),
'p_hazardous_favoured_less': calc_prob(True, "Less"),
'p_hazardous_unfavoured_more': calc_prob(False, "More"),
'p_hazardous_unfavoured_med': calc_prob(False, "Medium"),
'p_hazardous_unfavoured_less': calc_prob(False, "Less")
}
return hazardous_params
# Listing Prepare the data
def prepare_data(objects, params):
"""
params = {
'p_norm_large_slow_hazardous': 0.45,
'p_norm_large_slow_nonhazardous': 0.46,
'p_norm_large_fast_hazardous': 0.47,
'p_norm_large_fast_nonhazardous': 0.48,
'p_norm_small_slow_hazardous': 0.49,
'p_norm_small_slow_nonhazardous': 0.51,
'p_norm_small_fast_hazardous': 0.52,
'p_norm_small_fast_nonhazardous': 0.53,
}
"""
# is the object large?
objects['IsLarge'] = objects['Categorized_Diameter'].map(lambda dia: 0 if dia == "Small" else 1)
# the probability of favored by norm given diameter, relative velocity, and hazardous
objects['Norm'] = list(map(
lambda item: params['p_norm_{}_{}_{}'.format(
'small' if item[0] == "Small" else 'large',
'slow' if item[1] == "Slow" else 'fast',
'nonhazardous' if item[2] == 0 else 'hazardous'
)],
list(zip(objects['IsLarge'], objects['Categorized_Relative_Vel'], objects['Hazardous']))
))
return objects
# Listing Initialize the parameters
# Step 0: Initialize the parameter values
params = {
'p_norm_large_slow_hazardous': 0.45,
'p_norm_large_slow_nonhazardous': 0.46,
'p_norm_large_fast_hazardous': 0.47,
'p_norm_large_fast_nonhazardous': 0.48,
'p_norm_small_slow_hazardous': 0.49,
'p_norm_small_slow_nonhazardous': 0.51,
'p_norm_small_fast_hazardous': 0.52,
'p_norm_small_fast_nonhazardous': 0.53,
}
# Listing Run the qbn
objects = prepare_data(train_input, params)
results = qbn_neo(calculate_norm_params(objects), calculate_hazardous_params(objects), hist=False)
# Listing Get a list of relevant states
def filter_states(states, position, value):
return list(filter(lambda item: item[0][QUBITS-1-position] == str(value), states))
# Listing The states with hazardous objects
filter_states(results.items(), QPOS_hazardous, '1')
# Listing Calculate the marginal probability to be hazardous
def sum_states(states):
return sum(map(lambda item: item[1], states))
sum_states(filter_states(results.items(), QPOS_hazardous, '1'))
# Listing The log‐likelihood function adapted for our data
def log_likelihood_neo(data, results):
states = results.items()
def calc_prob(norm_val, islarge_val, rv_val, hazardous_val):
return sum_states(
filter_states(
filter_states(
filter_states(
filter_states(states, QPOS_RV, rv_val),
QPOS_dia, islarge_val
), QPOS_hazardous, hazardous_val
), QPOS_NORM, norm_val))
probs = {
'p_favoured_large_slow_hazardous': calc_prob('1', '1', '0', '1'),
'p_favoured_large_slow_nonhazardous': calc_prob('1', '1', '0', '0'),
'p_favoured_large_fast_hazardous': calc_prob('1', '1', '1', '1'),
'p_favoured_large_fast_nonhazardous': calc_prob('1', '1', '1', '0'),
'p_favoured_small_slow_hazardous': calc_prob('1', '0', '0', '1'),
'p_favoured_small_slow_nonhazardous': calc_prob('1', '0', '0', '0'),
'p_favoured_small_fast_hazardous': calc_prob('1', '0', '1', '1'),
'p_favoured_small_fast_nonhazardous': calc_prob('1', '0', '1', '0'),
'p_unfavoured_large_slow_hazardous': calc_prob('0', '1', '0', '1'),
'p_unfavoured_large_slow_nonhazardous': calc_prob('0', '1', '0', '0'),
'p_unfavoured_large_fast_hazardous': calc_prob('0', '1', '1', '1'),
'p_unfavoured_large_fast_nonhazardous': calc_prob('0', '1', '1', '0'),
'p_unfavoured_small_slow_hazardous': calc_prob('0', '0', '0', '1'),
'p_unfavoured_small_slow_nonhazardous': calc_prob('0', '0', '0', '0'),
'p_unfavoured_small_fast_hazardous': calc_prob('0', '0', '1', '1'),
'p_unfavoured_small_fast_nonhazardous': calc_prob('0', '0', '1', '0'),
}
return round(sum(map(
lambda item: log(probs['p_{}_{}_{}_{}'.format(
'unfavoured',
'small' if item[1] == 0 else 'large',
'slow' if item[2] == "Slow" else 'fast',
'nonhazardous' if item[3] == 0 else 'hazardous'
)] + probs['p_{}_{}_{}_{}'.format(
'favoured',
'small' if item[1] == 0 else 'large',
'slow' if item[2] == "Slow" else 'fast',
'nonhazardous' if item[3] == 0 else 'hazardous'
)]
),
list(zip(data['Norm'], data['IsLarge'], data['Categorized_Relative_Vel'], data['Hazardous']))
)), 3)
# Listing Calculate the log‐likelihood
log_likelihood_neo(train_input, results)
# Listing Obtain new object values from the results
def to_params(results):
states = results.items()
def calc_norm(islarge_val, rv_val, hazardous_val):
pop = filter_states(filter_states(filter_states(states, QPOS_RV, rv_val), QPOS_dia, islarge_val), QPOS_hazardous, hazardous_val)
p_norm = sum(map(lambda item: item[1], filter_states(pop, QPOS_NORM, '1')))
p_total = sum(map(lambda item: item[1], pop))
return p_norm / p_total
return {
'p_norm_large_slow_hazardous': calc_norm('1', '0', '1'),
'p_norm_large_slow_nonhazardous': calc_norm('1', '0', '0'),
'p_norm_large_fast_hazardous': calc_norm('1', '1', '1'),
'p_norm_large_fast_nonhazardous': calc_norm('1', '1', '0'),
'p_norm_small_slow_hazardous': calc_norm('0', '0', '1'),
'p_norm_small_slow_nonhazardous': calc_norm('0', '0', '0'),
'p_norm_small_fast_hazardous': calc_norm('0', '1', '1'),
'p_norm_small_fast_nonhazardous': calc_norm('0', '1', '0'),
}
# Listing Calcualte new objects
to_params(results)
# Listing The recursive training automatism
def train_qbn_neo(objects, params, iterations):
if iterations > 0:
new_params = train_qbn_neo(objects, params, iterations - 1)
objects = prepare_data(objects, new_params)
results = qbn_neo(calculate_norm_params(objects), calculate_hazardous_params(objects), hist=False)
# print ('The log-likelihood after {} iteration(s) is {}'.format(iterations, log_likelihood_neo(objects, results)))
return to_params(results)
return params
# Listing Train the QBN
trained_params = train_qbn_neo(train_input, {
'p_norm_large_slow_hazardous': 0.45,
'p_norm_large_slow_nonhazardous': 0.46,
'p_norm_large_fast_hazardous': 0.47,
'p_norm_large_fast_nonhazardous': 0.48,
'p_norm_small_slow_hazardous': 0.49,
'p_norm_small_slow_nonhazardous': 0.51,
'p_norm_small_fast_hazardous': 0.52,
'p_norm_small_fast_nonhazardous': 0.53,
}, 25)
# Listing The parameters after training
trained_params
# Listing Pre‐processing
def pre_process(object):
return (object['IsLarge'] == 1, object['Categorized_Relative_Vel'] == 'Fast', object['Categorised_Miss_Distance'])
# Listing Apply the known data on the quantum circuit
def apply_known(qc, is_large, is_fast, missDistance):
if is_large:
qc.x(QPOS_dia)
if is_fast:
qc.x(QPOS_RV)
qc.x(QPOS_more if missDistance == "More" else (QPOS_med if missDistance == "Medium" else QPOS_less))
# Listing Get the trained QBN
def get_trained_qbn(objects, params):
prepared_objects = prepare_data(objects, params)
norm_params = calculate_norm_params(prepared_objects)
hazardous_params = calculate_hazardous_params(prepared_objects)
def trained_qbn_neo(object):
(is_large, is_fast, missDistance) = object
def circuit(qc, qr, cr):
apply_known(qc, is_large, is_fast, missDistance)
apply_norm(qc, norm_params)
apply_hazardous(qc, hazardous_params)
qc.measure(qr[QPOS_hazardous], cr[0])
return as_pqc(QUBITS, circuit, hist=False, measure=True, shots=100)
return trained_qbn_neo
# Listing Post‐processing
def post_process(counts):
"""
counts -- the result of the quantum circuit execution
returns the prediction
"""
#print (counts)
p_hazardous = counts['1'] if '1' in counts.keys() else 0
p_nonhazardous = counts['0'] if '0' in counts.keys() else 0
#return int(list(map(lambda item: item[0], counts.items()))[0])
return 1 if p_hazardous > p_nonhazardous else 0
# Preparing Report
def run(f_classify, x):
return list(map(f_classify, x))
def specificity(matrix):
return matrix[0][0]/(matrix[0][0]+matrix[0][1]) if (matrix[0][0]+matrix[0][1] > 0) else 0
def npv(matrix):
return matrix[0][0]/(matrix[0][0]+matrix[1][0]) if (matrix[0][0]+matrix[1][0] > 0) else 0
def classifier_report(name, run, classify, input, labels):
cr_predictions = run(classify, input)
cr_cm = confusion_matrix(labels, cr_predictions)
cr_precision = precision_score(labels, cr_predictions)
cr_recall = recall_score(labels, cr_predictions)
cr_specificity = specificity(cr_cm)
cr_npv = npv(cr_cm)
cr_level = 0.25*(cr_precision + cr_recall + cr_specificity + cr_npv)
print('The precision score of the {} classifier is {:.2f}'
.format(name, cr_precision))
print('The recall score of the {} classifier is {:.2f}'
.format(name, cr_recall))
print('The specificity score of the {} classifier is {:.2f}'
.format(name, cr_specificity))
print('The npv score of the {} classifier is {:.2f}'
.format(name, cr_npv))
print('The information level is: {:.2f}'
.format(cr_level))
# Listing Run the Quantum Naive Bayes Classifier
# redefine the run-function
def run(f_classify, data):
return [f_classify(data.iloc[i]) for i in range(0,len(data))]
# get the simple qbn
trained_qbn = get_trained_qbn(train_input, trained_params)
# evaluate the Quantum Bayesian Network
# classifier_report("QBN",
# run,
# lambda object: post_process(trained_qbn(pre_process(object))),
# objects,
# train_input['Hazardous'])
|
https://github.com/AmanSinghBhogal/NasaNEO_Classification
|
AmanSinghBhogal
|
# In this code we use Classical Computing Gaussian Naive Bayes Algorithm on Nasa Nearst Earth Object Data Set
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
import statistics as st
from sklearn.metrics import recall_score, precision_score, confusion_matrix
import math
import seaborn as samandar
# Loaded the Dataset
data = pd.read_csv('neo_v2.csv')
# Lets drop unwated attributes such as Orbiting Body and Name
data = data.drop("orbiting_body", axis = 1)
data = data.drop("name", axis = 1)
data = data.drop("sentry_object", axis = 1)
data = data.drop("id", axis = 1)
# Splitted the Dataset into Training and Testing
train_input, test_input = train_test_split(data, test_size=0.3, random_state=0)
# Printing the Number of True and False Records in Train and Test Dataset
print("Train Dataset: No of True: {}, No. False: {}".format(len(train_input[train_input['hazardous'] == True]), len(train_input[train_input['hazardous'] == False])))
print("Test Dataset: No of True: {}, No. False: {}".format(len(test_input[test_input['hazardous'] == True]), len(test_input[test_input['hazardous'] == False])))
# Printing Number of records in training and testing
print("There are {} Training Records and {} Testing Records".format(train_input.shape[0], test_input.shape[0]))
# Calculating Probability of Hazardious true And false
p_hazard_true = len(train_input[train_input['hazardous'] == True])/len(train_input)
p_hazard_false = len(train_input[train_input['hazardous'] == False])/len(train_input)
# Printing the target class probility
print("P[True]: {:.3f}".format(p_hazard_true))
print("P[False]: {:.3f}".format(p_hazard_false))
# Calculating probabilities for Hazardous = True
row1 = []
# Calculating Mean and variance for est_diameter_min for hazardous = true
row1.append(st.mean(train_input[train_input['hazardous'] == True]['est_diameter_min']))
row1.append(st.variance(train_input[train_input['hazardous'] == True]['est_diameter_min']))
row1.append(st.mean(train_input[train_input['hazardous'] == True]['est_diameter_max']))
row1.append(st.variance(train_input[train_input['hazardous'] == True]['est_diameter_max']))
row1.append(st.mean(train_input[train_input['hazardous'] == True]['relative_velocity']))
row1.append(st.variance(train_input[train_input['hazardous'] == True]['relative_velocity']))
row1.append(st.mean(train_input[train_input['hazardous'] == True]['miss_distance']))
row1.append(st.variance(train_input[train_input['hazardous'] == True]['miss_distance']))
row1.append(st.mean(train_input[train_input['hazardous'] == True]['absolute_magnitude']))
row1.append(st.variance(train_input[train_input['hazardous'] == True]['absolute_magnitude']))
# Calculating Probabilities for Hazardous = False
row2 = []
# Calculating Mean and variance for est_diameter_min for hazardous = false
row2.append(st.mean(train_input[train_input['hazardous'] == False]['est_diameter_min']))
row2.append(st.variance(train_input[train_input['hazardous'] == False]['est_diameter_min']))
row2.append(st.mean(train_input[train_input['hazardous'] == False]['est_diameter_max']))
row2.append(st.variance(train_input[train_input['hazardous'] == False]['est_diameter_max']))
row2.append(st.mean(train_input[train_input['hazardous'] == False]['relative_velocity']))
row2.append(st.variance(train_input[train_input['hazardous'] == False]['relative_velocity']))
row2.append(st.mean(train_input[train_input['hazardous'] == False]['miss_distance']))
row2.append(st.variance(train_input[train_input['hazardous'] == False]['miss_distance']))
row2.append(st.mean(train_input[train_input['hazardous'] == False]['absolute_magnitude']))
row2.append(st.variance(train_input[train_input['hazardous'] == False]['absolute_magnitude']))
calculated_fields = pd.DataFrame([row1,row2], columns= ['Mean_est_diameter_min','Var_est_diameter_min', 'Mean_est_diameter_max','Var_est_diameter_max', 'Mean_relative_velocity','Var_relative_velocity', 'Mean_miss_distance', 'Var_miss_distance', 'Mean_absolute_magnitude', 'Var_absolute_magnitude'])
# Saving the Calculated fields to get a better view
calculated_fields.to_csv('calculated_fields.csv')
# Calculating Posterior Probability Function F(x) = (1/2πσ2)e(-(x-x̄)/2σ2)
def post_prob(mean, var, input_x):
return ((1.0/math.sqrt(2.0*np.pi*var))*math.exp((-1.0*((input_x-mean)**2.0))/(2.0*var)))
# Writing the Estimation function:
def cnb(input):
# Post_T = (p_hazard_true*def()*)
Post_T = p_hazard_true
Post_F = p_hazard_false
# print("For Hazardous = True")
# Calculating Posterior Probability for Hazardous = True
for i in range(len(input)-1):
t1 = i*2
t2 = t1+1
val = post_prob(calculated_fields.iloc[0,t1],calculated_fields.iloc[0,t2], input[i])
# print(val)
# print("Post_T: {}".format(Post_T))
Post_T *= val
# print("For hazardous = False")
# Calculating Posterior Probability for Hazardous = False
for i in range(len(input)-1):
t1 = i*2
t2 = t1+1
val = post_prob(calculated_fields.iloc[1,t1],calculated_fields.iloc[1,t2], input[i])
# print(val)
# print("Post_F: {}".format(Post_F))
Post_F *= val
# print("Posterior Probability for Hazardous = True is: {}".format(Post_T))
# print("Posterior Probability for Hazardous = False is: {}".format(Post_F))
if Post_T > Post_F:
return True
else:
return False
# Specificity
def specificity(matrix):
return matrix[0][0]/(matrix[0][0]+ matrix[0][1]) if (matrix[0][0]+matrix[0][1]>0) else 0
# Negative Predictive Value(NPV)
def npv(matrix):
return matrix[0][0]/(matrix[0][1]+ matrix[1][0]) if (matrix[0][1]+ matrix[1][0] > 0) else 0
# Logic for testing the algorithm
actual_outputs = test_input['hazardous']
predicted_outputs = []
for i in range(len(test_input)):
predicted_outputs.append(cnb(test_input.iloc[i].values.flatten().tolist()))
# Creating Classifier Report function
def classifier_report():
name = 'Classical Guassian Naive Bayes Algorithm'
cr_prediction = predicted_outputs
labels = actual_outputs
cr_cm = confusion_matrix(labels, cr_prediction)
print("Confusion Matrix")
print(cr_cm)
cr_precision = precision_score(labels, cr_prediction)
cr_recall = recall_score(labels, cr_prediction)
cr_specificity = specificity(cr_cm)
cr_npv = npv(cr_cm)
cr_level = 0.25 * (cr_precision + cr_recall + cr_specificity + cr_npv)
print('The precision score of the {} classifier is {:.2f}'
.format(name, cr_precision))
print('The recall score of the {} classifier is {:.2f}'
.format(name, cr_recall))
print('The specificity score of the {} classifier is {:.2f}'
.format(name, cr_specificity))
print('The npv score of the {} classifier is {:.2f}'
.format(name, cr_npv))
print('The information level is: {:.2f}'
.format(cr_level))
classifier_report()
# Visualisation
correlation = train_input.corr()
# plot the heatmap
samandar.heatmap(correlation, xticklabels = correlation.columns, yticklabels = correlation.columns, annot=True)
# plot the clustermap
samandar.clustermap(correlation, xticklabels = correlation.columns, yticklabels = correlation.columns, annot=True)
|
https://github.com/AmanSinghBhogal/NasaNEO_Classification
|
AmanSinghBhogal
|
import numpy as np
import networkx as nx
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, assemble
from qiskit.quantum_info import Statevector
from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.extensions.snapshot_statevector import *
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
import matplotlib.pyplot as plt
LAMBDA = 10
SEED = 10
SHOTS = 10000
# returns the bit index for an alpha and j
def bit(i_city, l_time, num_cities):
return i_city * num_cities + l_time
# e^(cZZ)
def append_zz_term(qc, q_i, q_j, gamma, constant_term):
qc.cx(q_i, q_j)
qc.rz(2*gamma*constant_term,q_j)
qc.cx(q_i, q_j)
# e^(cZ)
def append_z_term(qc, q_i, gamma, constant_term):
qc.rz(2*gamma*constant_term, q_i)
# e^(cX)
def append_x_term(qc,qi,beta):
qc.rx(-2*beta, qi)
def get_not_edge_in(G):
N = G.number_of_nodes()
not_edge = []
for i in range(N):
for j in range(N):
if i != j:
buffer_tupla = (i,j)
in_edges = False
for edge_i, edge_j in G.edges():
if ( buffer_tupla == (edge_i, edge_j) or buffer_tupla == (edge_j, edge_i)):
in_edges = True
if in_edges == False:
not_edge.append((i, j))
return not_edge
def get_classical_simplified_z_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# z term #
z_classic_term = [0] * N**2
# first term
for l in range(N):
for i in range(N):
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += -1 * _lambda
# second term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_jl
z_jl_index = bit(j, l, N)
z_classic_term[z_jl_index] += _lambda / 2
# third term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_ij
z_ij_index = bit(i, j, N)
z_classic_term[z_ij_index] += _lambda / 2
# fourth term
not_edge = get_not_edge_in(G) # include order tuples ej = (1,0), (0,1)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 4
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
z_classic_term[z_jlplus_index] += _lambda / 4
# fifthy term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
z_classic_term[z_il_index] += weight_ij / 4
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
z_classic_term[z_il_index] += weight_ji / 4
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ji / 4
return z_classic_term
def tsp_obj_2(x, G,_lambda):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
not_edge = get_not_edge_in(G)
N = G.number_of_nodes()
tsp_cost=0
#Distancia
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# x_il
x_il_index = bit(edge_i, l, N)
# x_jlplus
l_plus = (l+1) % N
x_jlplus_index = bit(edge_j, l_plus, N)
tsp_cost+= int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ij
# add order term because G.edges() do not include order tuples #
# x_i'l
x_il_index = bit(edge_j, l, N)
# x_j'lplus
x_jlplus_index = bit(edge_i, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ji
#Constraint 1
for l in range(N):
penal1 = 1
for i in range(N):
x_il_index = bit(i, l, N)
penal1 -= int(x[x_il_index])
tsp_cost += _lambda * penal1**2
#Contstraint 2
for i in range(N):
penal2 = 1
for l in range(N):
x_il_index = bit(i, l, N)
penal2 -= int(x[x_il_index])
tsp_cost += _lambda*penal2**2
#Constraint 3
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# x_il
x_il_index = bit(i, l, N)
# x_j(l+1)
l_plus = (l+1) % N
x_jlplus_index = bit(j, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * _lambda
return tsp_cost
def get_classical_simplified_zz_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# zz term #
zz_classic_term = [[0] * N**2 for i in range(N**2) ]
# first term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
# z_jl
z_jl_index = bit(j, l, N)
zz_classic_term[z_il_index][z_jl_index] += _lambda / 2
# second term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
# z_ij
z_ij_index = bit(i, j, N)
zz_classic_term[z_il_index][z_ij_index] += _lambda / 2
# third term
not_edge = get_not_edge_in(G)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += _lambda / 4
# fourth term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ji / 4
return zz_classic_term
def get_classical_simplified_hamiltonian(G, _lambda):
# z term #
z_classic_term = get_classical_simplified_z_term(G, _lambda)
# zz term #
zz_classic_term = get_classical_simplified_zz_term(G, _lambda)
return z_classic_term, zz_classic_term
def get_cost_circuit(G, gamma, _lambda):
N = G.number_of_nodes()
N_square = N**2
qc = QuantumCircuit(N_square,N_square)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _lambda)
# z term
for i in range(N_square):
if z_classic_term[i] != 0:
append_z_term(qc, i, gamma, z_classic_term[i])
# zz term
for i in range(N_square):
for j in range(N_square):
if zz_classic_term[i][j] != 0:
append_zz_term(qc, i, j, gamma, zz_classic_term[i][j])
return qc
def get_mixer_operator(G,beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
for n in range(N**2):
append_x_term(qc, n, beta)
return qc
def get_QAOA_circuit(G, beta, gamma, _lambda):
assert(len(beta)==len(gamma))
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
# init min mix state
qc.h(range(N**2))
p = len(beta)
for i in range(p):
qc = qc.compose(get_cost_circuit(G, gamma[i], _lambda))
qc = qc.compose(get_mixer_operator(G, beta[i]))
qc.barrier(range(N**2))
qc.snapshot_statevector("final_state")
qc.measure(range(N**2),range(N**2))
return qc
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
# Sample expectation value
def compute_tsp_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj_2(meas, G, LAMBDA)
energy += obj_for_meas*meas_count
total_counts += meas_count
mean = energy/total_counts
return mean
def get_black_box_objective_2(G,p):
backend = Aer.get_backend('qasm_simulator')
sim = Aer.get_backend('aer_simulator')
# function f costo
def f(theta):
beta = theta[:p]
gamma = theta[p:]
# Anzats
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
result = execute(qc, backend, seed_simulator=SEED, shots= SHOTS).result()
final_state_vector = result.data()["snapshots"]["statevector"]["final_state"][0]
state_vector = Statevector(final_state_vector)
probabilities = state_vector.probabilities()
probabilities_states = invert_counts(state_vector.probabilities_dict())
expected_value = 0
for state,probability in probabilities_states.items():
cost = tsp_obj_2(state, G, LAMBDA)
expected_value += cost*probability
counts = result.get_counts()
mean = compute_tsp_energy_2(invert_counts(counts),G)
return mean
return f
def crear_grafo(cantidad_ciudades):
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
return G, mejor_costo, mejor_camino
def run_QAOA(p,ciudades, grafo):
if grafo == None:
G, mejor_costo, mejor_camino = crear_grafo(ciudades)
print("Mejor Costo")
print(mejor_costo)
print("Mejor Camino")
print(mejor_camino)
print("Bordes del grafo")
print(G.edges())
print("Nodos")
print(G.nodes())
print("Pesos")
labels = nx.get_edge_attributes(G,'weight')
print(labels)
else:
G = grafo
intial_random = []
# beta, mixer Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,np.pi))
# gamma, cost Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,2*np.pi))
init_point = np.array(intial_random)
obj = get_black_box_objective_2(G,p)
res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
print(res_sample)
if __name__ == '__main__':
# Run QAOA parametros: profundidad p, numero d ciudades,
run_QAOA(5, 3, None)
|
https://github.com/AmanSinghBhogal/NasaNEO_Classification
|
AmanSinghBhogal
|
import pandas as pd
from sklearn.model_selection import train_test_split
from qiskit import QuantumCircuit, execute, Aer
from qiskit import ClassicalRegister, QuantumRegister
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
from math import asin, sqrt, pi, log
from statistics import mean
import pandas as pd
from sklearn.metrics import confusion_matrix, precision_score, recall_score
# Loaded the Dataset
data = pd.read_csv('neo_v2.csv')
# Writing code for Pre-Procesing
cat_max_dia = []
cat_RV = []
cat_miss = []
max_dia_mean = mean(data['est_diameter_max'])
Rv_mean = mean(data['relative_velocity'])
miss_mean = mean(data['miss_distance'])
print("\n\nThe Mean Max Diameter is: ", max_dia_mean)
print("The Mean Relative Velocity is: ", Rv_mean)
print("The Mean Miss Distance is: ", miss_mean)
for i,j, z in zip(data['est_diameter_max'], data['relative_velocity'], data['miss_distance']):
if i>=max_dia_mean:
cat_max_dia.append("Large")
else :
cat_max_dia.append("Small")
if j>=Rv_mean:
cat_RV.append("Fast")
else:
cat_RV.append("Slow")
if z>=miss_mean:
cat_miss.append("More")
else:
cat_miss.append("Less")
processed_data = pd.DataFrame(list(zip(data['est_diameter_max'], data['relative_velocity'],data['miss_distance'], cat_max_dia, cat_RV,cat_miss, data['hazardous'])),columns=['Max_Diameter','Relative_Velocity','Miss_Distance', 'Categorized_Diameter', 'Categorized_Relative_Vel','Categorised_Miss_Distance','Hazardous'])
# Saving the Processed Data to get a better view
processed_data.to_csv('processedData.csv')
# Splitted the Dataset into Training and Testing
train_input, test_input = train_test_split(processed_data, test_size=0.3, random_state=0)
# Printing Number of records in training and testing
print("There are {} Training Records and {} Testing Records".format(train_input.shape[0], test_input.shape[0]))
# Printing the Number of True and False Records in Train and Test Dataset
print("Train Dataset: No of True: {}, No. False: {}".format(len(train_input[train_input['Hazardous'] == True]), len(train_input[train_input['Hazardous'] == False])))
print("Test Dataset: No of True: {}, No. False: {}".format(len(test_input[test_input['Hazardous'] == True]), len(test_input[test_input['Hazardous'] == False])))
# need to write preprocess function for calculating backward probability
# Function for Calculating Category Prob.
def prob_hazard_calc(df, category_name, category_val):
pop = df[df[category_name] == category_val]
hazard_pop = pop[pop['Hazardous'] == True]
p_pop = len(hazard_pop)/len(pop)
return p_pop, len(pop)
# For Max Diameter
# for small:
p_small, pop_small = prob_hazard_calc(train_input, "Categorized_Diameter", "Small")
# print(p_small, pop_small)
# for Large:
p_large, pop_large = prob_hazard_calc(train_input, "Categorized_Diameter", "Large")
# print(p_large, pop_large)
print("\n\nPrinting Chances of Max Diameter Objects given they are hazardous:\n")
print("{} Small Diameter objects had {} chances of being hazardous".format(pop_small, p_small))
print("{} Large Diameter objects had {} chances of being hazardous".format(pop_large, p_large))
# For Relative Velocity:
# for Slow:
p_slow, pop_slow = prob_hazard_calc(train_input, "Categorized_Relative_Vel", "Slow")
# print(p_slow, pop_slow)
# for Fast:
p_fast, pop_fast = prob_hazard_calc(train_input, "Categorized_Relative_Vel", "Fast")
# print(p_fast, pop_fast)
print("\n\nPrinting Chances of Relative Velocity Objects given they are hazardous:\n")
print("{} Slow Relative Velocity objects had {} chances of being hazardous".format(pop_slow, p_slow))
print("{} Fast Relative Velocity objects had {} chances of being hazardous".format(pop_fast, p_fast))
# For Miss Distance:
# For Less
p_less, pop_less = prob_hazard_calc(train_input, "Categorised_Miss_Distance", "Less")
# print(p_less, pop_less)
# For More:
p_more, pop_more = prob_hazard_calc(train_input, "Categorised_Miss_Distance", "More")
# print(p_more, pop_more)
print("\n\nPrinting Chances of Miss Distance Objects given they are hazardous:\n")
print("{} Less Miss Distance objects had {} chances of being hazardous".format(pop_less, p_less))
print("{} More Miss Distance objects had {} chances of being hazardous".format(pop_more, p_more))
# Implementing Quantum Naive Bayes Circuit:
# Specifying the marginal probability
def prob_to_angle(prob):
"""
Converts a given P(psi) value into an equivalent theta value.
"""
return 2*asin(sqrt(prob))
# Initialize the quantum circuit
qc = QuantumCircuit(3)
# Set qubit0 to p_small i.e for Max Diameter
qc.ry(prob_to_angle(p_large), 0)
# Set qubit1 to p_fast i.e for Relative Velocity
qc.ry(prob_to_angle(p_fast), 1)
# Defining the CCRY‐gate:
def ccry(qc, theta, control1, control2, controlled):
qc.cry(theta/2, control2, controlled)
qc.cx(control1, control2)
qc.cry(-theta/2, control2, controlled)
qc.cx(control1, control2)
qc.cry(theta/2, control1, controlled)
# Calculating the conditional probabilities
# fast Relative Velocity and large Diameter
population_fast=train_input[train_input.Categorized_Relative_Vel.eq("Fast")]
population_fast_large= population_fast[population_fast.Categorized_Diameter.eq("Large")]
hazardous_fast_large = population_fast_large[population_fast_large.Hazardous.eq(1)]
p_hazardous_fast_large=len(hazardous_fast_large)/len(population_fast_large)
# fast Relative Velocity and small Diameter
population_fast_small = population_fast[population_fast.Categorized_Diameter.eq("Small")]
hazardous_fast_small = population_fast_small[population_fast_small.Hazardous.eq(1)]
p_hazardous_fast_small=len(hazardous_fast_small)/len(population_fast_small)
# Slow Relative Velocity and Large Diameter
population_slow = train_input[train_input.Categorized_Relative_Vel.eq("Slow")]
population_slow_large = population_slow[population_slow.Categorized_Diameter.eq("Large")]
hazardous_slow_large=population_slow_large[population_slow_large.Hazardous.eq(1)]
p_hazardous_slow_large=len(hazardous_slow_large)/len(population_slow_large)
# Slow Relative Velocity and Small Diameter
population_slow_small = population_slow[population_slow.Categorized_Diameter.eq("Small")]
hazardous_slow_small = population_slow_small[population_slow_small.Hazardous.eq(1)]
p_hazardous_slow_small=len(hazardous_slow_small)/len(population_slow_small)
# Initializing the child node:
# set state |00> to conditional probability of slow RV and small Diameter
qc.x(0)
qc.x(1)
ccry(qc,prob_to_angle(p_hazardous_slow_small),0,1,2)
qc.x(0)
qc.x(1)
# set state |01> to conditional probability of slow RV and large Diameter
qc.x(0)
ccry(qc,prob_to_angle(p_hazardous_slow_large),0,1,2)
qc.x(0)
# set state |10> to conditional probability of fast RV and small Diameter
qc.x(1)
ccry(qc,prob_to_angle(p_hazardous_fast_small),0,1,2)
qc.x(1)
# set state |11> to conditional probability of fast RV and large Diameter
ccry(qc,prob_to_angle(p_hazardous_fast_large),0,1,2)
# Circuit execution
# execute the qc
results = execute(qc,Aer.get_backend('statevector_simulator')).result().get_counts()
plot_histogram(results)
# Quantum circuit with classical register
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr)
# Listing Run the circuit including a measurement
# -- INCLUDE ALL GATES HERE --
# Set qubit0 to p_small i.e for Max Diameter
qc.ry(prob_to_angle(p_large), 0)
# Set qubit1 to p_fast i.e for Relative Velocity
qc.ry(prob_to_angle(p_fast), 1)
# set state |00> to conditional probability of slow RV and small Diameter
qc.x(0)
qc.x(1)
ccry(qc,prob_to_angle(p_hazardous_slow_small),0,1,2)
qc.x(0)
qc.x(1)
# set state |01> to conditional probability of slow RV and large Diameter
qc.x(0)
ccry(qc,prob_to_angle(p_hazardous_slow_large),0,1,2)
qc.x(0)
# set state |10> to conditional probability of fast RV and small Diameter
qc.x(1)
ccry(qc,prob_to_angle(p_hazardous_fast_small),0,1,2)
qc.x(1)
# set state |11> to conditional probability of fast RV and large Diameter
ccry(qc,prob_to_angle(p_hazardous_fast_large),0,1,2)
qc.measure(qr[2], cr[0])
results = execute(qc,Aer.get_backend('qasm_simulator'), shots=1000).result().get_counts()
plot_histogram(results)
|
https://github.com/AmanSinghBhogal/NasaNEO_Classification
|
AmanSinghBhogal
|
# pip install qiskit
# pip install qiskit.Aer
import pandas as pd
from sklearn.model_selection import train_test_split
from qiskit import QuantumCircuit, execute, Aer
from qiskit import ClassicalRegister, QuantumRegister
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
from math import asin, sqrt, pi, log
from statistics import mean
import pandas as pd
from sklearn.metrics import confusion_matrix, precision_score, recall_score
# Loaded the Dataset
data = pd.read_csv('neo_v2.csv')
# Writing code for Pre-Procesing
cat_max_dia = []
cat_RV = []
cat_miss = []
max_dia_mean = mean(data['est_diameter_max'])
Rv_mean = mean(data['relative_velocity'])
print("\n\nThe Mean Max Diameter is: ", max_dia_mean)
print("The Mean Relative Velocity is: ", Rv_mean)
for i,j, z in zip(data['est_diameter_max'], data['relative_velocity'], data['miss_distance']):
if i>=max_dia_mean:
cat_max_dia.append("Large")
else :
cat_max_dia.append("Small")
if j>=Rv_mean:
cat_RV.append("Fast")
else:
cat_RV.append("Slow")
if z>=0 and z< 25000000:
cat_miss.append("Less")
elif z>= 25000000 and z<50000000:
cat_miss.append("Medium")
else:
cat_miss.append("More")
processed_data = pd.DataFrame(list(zip(data['est_diameter_max'], data['relative_velocity'],data['miss_distance'], cat_max_dia, cat_RV,cat_miss, data['hazardous'])),columns=['Max_Diameter','Relative_Velocity','Miss_Distance', 'Categorized_Diameter', 'Categorized_Relative_Vel','Categorised_Miss_Distance','Hazardous'])
# Saving the Processed Data to get a better view
processed_data.to_csv('processedData.csv')
# Splitted the Dataset into Training and Testing
train_input, test_input = train_test_split(processed_data, test_size=0.3, random_state=50)
# Printing Number of records in training and testing
print("There are {} Training Records and {} Testing Records".format(train_input.shape[0], test_input.shape[0]))
# Printing the Number of True and False Records in Train and Test Dataset
print("Train Dataset: No of True: {}, No. False: {}".format(len(train_input[train_input['Hazardous'] == True]), len(train_input[train_input['Hazardous'] == False])))
print("Test Dataset: No of True: {}, No. False: {}".format(len(test_input[test_input['Hazardous'] == True]), len(test_input[test_input['Hazardous'] == False])))
# Probability of Max Diameter:
def prob_hazard_calc(df, category_name, category_val):
pop = df[df[category_name] == category_val]
hazard_pop = pop[pop['Hazardous'] == True]
p_pop = len(hazard_pop)/len(pop)
return p_pop, len(pop)
# For Max Diameter:
# for small:
p_small, pop_small = prob_hazard_calc(train_input, "Categorized_Diameter", "Small")
print(p_small, pop_small)
# for Large:
p_large, pop_large = prob_hazard_calc(train_input, "Categorized_Diameter", "Large")
print(p_large, pop_large)
print("\n\nPrinting Chances of Max Diameter Objects given they are hazardous:\n")
print("{} Small Diameter objects had {} chances of being hazardous".format(pop_small, p_small))
print("{} Large Diameter objects had {} chances of being hazardous".format(pop_large, p_large))
# For Relative Velocity:
# for Slow:
p_slow, pop_slow = prob_hazard_calc(train_input, "Categorized_Relative_Vel", "Slow")
# print(p_slow)
# for Fast:
p_fast, pop_fast = prob_hazard_calc(train_input, "Categorized_Relative_Vel", "Fast")
# print(p_fast)
print("\n\nPrinting Chances of Relative Velocity Objects given they are hazardous:\n")
print("{} Slow Relative Velocity objects had {} chances of being hazardous".format(pop_slow, p_slow))
print("{} Fast Relative Velocity objects had {} chances of being hazardous".format(pop_fast, p_fast))
# For Miss Distance:
# For Less
p_less, pop_less = prob_hazard_calc(train_input, "Categorised_Miss_Distance", "Less")
# print(p_less, pop_less)
# For Medium
p_med, pop_med = prob_hazard_calc(train_input, "Categorised_Miss_Distance", "Medium")
# print(p_med, pop_med)
# For More:
p_more, pop_more = prob_hazard_calc(train_input, "Categorised_Miss_Distance", "More")
# print(p_more, pop_more)
print("\n\nPrinting Chances of Miss Distance Objects given they are hazardous:\n")
print("{} Less Miss Distance objects had {} chances of being hazardous".format(pop_less, p_less))
print("{} Medium Miss Distance objects had {} chances of being hazardous".format(pop_med, p_med))
print("{} More Miss Distance objects had {} chances of being hazardous".format(pop_more, p_more))
# Specifying the marginal probability
def prob_to_angle(prob):
"""
Converts a given P(psi) value into an equivalent theta value.
"""
return 2*asin(sqrt(prob))
# Initialize the quantum circuit
qc = QuantumCircuit(3)
# Set qubit0 to p_large i.e for Max Diameter
qc.ry(prob_to_angle(p_large), 0)
# Set qubit1 to p_fast i.e for Relative Velocity
qc.ry(prob_to_angle(p_fast), 1)
# Defining the CCRY‐gate:
def ccry(qc, theta, control1, control2, controlled):
qc.cry(theta/2, control2, controlled)
qc.cx(control1, control2)
qc.cry(-theta/2, control2, controlled)
qc.cx(control1, control2)
qc.cry(theta/2, control1, controlled)
# Calculating the conditional probabilities
# fast Relative Velocity and large Diameter
population_fast=train_input[train_input.Categorized_Relative_Vel.eq("Fast")]
population_fast_large= population_fast[population_fast.Categorized_Diameter.eq("Large")]
hazardous_fast_large = population_fast_large[population_fast_large.Hazardous.eq(1)]
p_hazardous_fast_large=len(hazardous_fast_large)/len(population_fast_large)
# print(p_hazardous_fast_large)
# fast Relative Velocity and small Diameter
population_fast_small = population_fast[population_fast.Categorized_Diameter.eq("Small")]
hazardous_fast_small = population_fast_small[population_fast_small.Hazardous.eq(1)]
p_hazardous_fast_small=len(hazardous_fast_small)/len(population_fast_small)
# Slow Relative Velocity and Large Diameter
population_slow = train_input[train_input.Categorized_Relative_Vel.eq("Slow")]
population_slow_large = population_slow[population_slow.Categorized_Diameter.eq("Large")]
hazardous_slow_large=population_slow_large[population_slow_large.Hazardous.eq(1)]
p_hazardous_slow_large=len(hazardous_slow_large)/len(population_slow_large)
# Slow Relative Velocity and Small Diameter
population_slow_small = population_slow[population_slow.Categorized_Diameter.eq("Small")]
hazardous_slow_small = population_slow_small[population_slow_small.Hazardous.eq(1)]
p_hazardous_slow_small=len(hazardous_slow_small)/len(population_slow_small)
# Initializing the child node:
# set state |00> to conditional probability of slow RV and small Diameter
qc.x(0)
qc.x(1)
ccry(qc,prob_to_angle(p_hazardous_slow_small),0,1,2)
qc.x(0)
qc.x(1)
# set state |01> to conditional probability of slow RV and large Diameter
qc.x(0)
ccry(qc,prob_to_angle(p_hazardous_slow_large),0,1,2)
qc.x(0)
# set state |10> to conditional probability of fast RV and small Diameter
qc.x(1)
ccry(qc,prob_to_angle(p_hazardous_fast_small),0,1,2)
qc.x(1)
# set state |11> to conditional probability of fast RV and large Diameter
ccry(qc,prob_to_angle(p_hazardous_fast_large),0,1,2)
# Circuit execution
# execute the qc
results = execute(qc,Aer.get_backend('statevector_simulator')).result().get_counts()
plot_histogram(results)
# Quantum circuit with classical register
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr)
# Listing Run the circuit including a measurement
# Set qubit0 to p_small i.e for Max Diameter
qc.ry(prob_to_angle(p_large), 0)
# Set qubit1 to p_fast i.e for Relative Velocity
qc.ry(prob_to_angle(p_fast), 1)
# set state |00> to conditional probability of slow RV and small Diameter
qc.x(0)
qc.x(1)
ccry(qc,prob_to_angle(p_hazardous_slow_small),0,1,2)
qc.x(0)
qc.x(1)
# set state |01> to conditional probability of slow RV and large Diameter
qc.x(0)
ccry(qc,prob_to_angle(p_hazardous_slow_large),0,1,2)
qc.x(0)
# set state |10> to conditional probability of fast RV and small Diameter
qc.x(1)
ccry(qc,prob_to_angle(p_hazardous_fast_small),0,1,2)
qc.x(1)
# set state |11> to conditional probability of fast RV and large Diameter
ccry(qc,prob_to_angle(p_hazardous_fast_large),0,1,2)
qc.measure(qr[2], cr[0])
results = execute(qc,Aer.get_backend('qasm_simulator'), shots=1000).result().get_counts()
plot_histogram(results)
# Dataset with missing values
data = [
(1, 1), (1, 1), (0, 0), (0, 0), (0, 0), (0, None), (0, 1), (1, 0)
]
# The log‐likelihood function adapted for our data
def log_likelihood(data, prob_a_b, prob_a_nb, prob_na_b, prob_na_nb):
def get_prob(point):
if point[0] == 1 and point[1] == 1:
return log(prob_a_b)
elif point[0] == 1 and point[1] == 0:
return log(prob_a_nb)
elif point[0] == 0 and point[1] == 1:
return log(prob_na_b)
elif point[0] == 0 and point[1] == 0:
return log(prob_na_nb)
else:
return log(prob_na_b+prob_na_nb)
return sum(map(get_prob, data))
# The as‐pqc function
def as_pqc(cnt_quantum, with_qc, cnt_classical=1, shots=1, hist=False, measure=False):
# Prepare the circuit with qubits and a classical bit to hold the measurement
qr = QuantumRegister(cnt_quantum)
cr = ClassicalRegister(cnt_classical)
qc = QuantumCircuit(qr, cr) if measure else QuantumCircuit(qr)
with_qc(qc, qr=qr, cr=cr)
results = execute(
qc,
Aer.get_backend('statevector_simulator') if measure is False else Aer.get_backend('qasm_simulator'),
shots=shots
).result().get_counts()
return plot_histogram(results, figsize=(12,4)) if hist else results
# The quantum Bayesian network
def qbn(data, hist=True):
def circuit(qc, qr=None, cr=None):
list_a = list(filter(lambda item: item[0] == 1, data))
list_na = list(filter(lambda item: item[0] == 0, data))
# set the marginal probability of A
qc.ry(prob_to_angle(
len(list_a) / len(data)
), 0)
# set the conditional probability of NOT A and (B / not B)
qc.x(0)
qc.cry(prob_to_angle(
sum(list(map(lambda item: item[1], list_na))) / len(list_na)
),0,1)
qc.x(0)
# set the conditional probability of A and (B / not B)
qc.cry(prob_to_angle(
sum(list(map(lambda item: item[1], list_a))) / len(list_a)
),0,1)
return as_pqc(2, circuit, hist=hist)
# Ignoring the missing data
qbn(list(filter(lambda item: item[1] is not None ,data)))
# Calculate the log‐likelihood when ignoring the missing data
def eval_qbn(model, prepare_data, data):
results = model(prepare_data(data), hist=False)
return (
round(log_likelihood(data,
results['11'], # prob_a_b
results['01'], # prob_a_nb
results['10'], # prob_na_b
results['00'] # prob_na_nb
), 3),
results['10'] / (results['10'] + results['00'])
)
print(eval_qbn(qbn, lambda dataset: list(filter(lambda item: item[1] is not None ,dataset)), data))
# Calculate the log‐likelihood when filling in 0
print(eval_qbn(qbn, lambda dataset: list(map(lambda item: item if item[1] is not None else (item[0], 0) ,dataset)), data))
# Evaluating the guess
print(eval_qbn(qbn, lambda dataset: list(map(lambda item: item if item[1] is not None else (item[0], 0.5) ,dataset)), data))
# Refining the model
print(eval_qbn(qbn, lambda dataset: list(map(lambda item: item if item[1] is not None else (item[0], 0.3) ,dataset)), data))
# Further refining the model
print(eval_qbn(qbn, lambda dataset: list(map(lambda item: item if item[1] is not None else (item[0], 0.252) ,dataset)), data))
# Another iteration
print(eval_qbn(qbn, lambda dataset: list(map(lambda item: item if item[1] is not None else (item[0], 0.252) ,dataset)), data))
# positions of the qubits
QPOS_dia = 0
QPOS_RV = 1
def apply_islarge_fast(qc):
# set the marginal probability of large Diameter
qc.ry(prob_to_angle(p_large), QPOS_dia)
# set the marginal probability of Fast Relative Velocity
qc.ry(prob_to_angle(p_fast), QPOS_RV)
# Defining the CCRY‐gate:
def ccry(qc, theta, control1, control2, controlled):
qc.cry(theta/2, control2, controlled)
qc.cx(control1, control2)
qc.cry(-theta/2, control2, controlled)
qc.cx(control1, control2)
qc.cry(theta/2, control1, controlled)
# Listing Represent the norm
# position of the qubit representing the norm
QPOS_NORM = 2
def apply_norm(qc, norm_params):
"""
norm_params = {
'p_norm_small_slow': 0.25,
'p_norm_small_fast': 0.35,
'p_norm_large_slow': 0.45,
'p_norm_large_fast': 0.55
}
"""
# set the conditional probability of Norm given small/slow
qc.x(QPOS_dia)
qc.x(QPOS_RV)
ccry(qc, prob_to_angle(
norm_params['p_norm_small_slow']
),QPOS_dia, QPOS_RV, QPOS_NORM)
qc.x(QPOS_dia)
qc.x(QPOS_RV)
# set the conditional probability of Norm given small/fast
qc.x(QPOS_dia)
ccry(qc, prob_to_angle(
norm_params['p_norm_small_fast']
),QPOS_dia, QPOS_RV, QPOS_NORM)
qc.x(QPOS_dia)
# set the conditional probability of Norm given large/slow
qc.x(QPOS_RV)
ccry(qc, prob_to_angle(
norm_params['p_norm_large_slow']
),QPOS_dia, QPOS_RV, QPOS_NORM)
qc.x(QPOS_RV)
# set the conditional probability of Norm given large/fast
ccry(qc, prob_to_angle(
norm_params['p_norm_large_fast']
),QPOS_dia, QPOS_RV, QPOS_NORM)
# Listing Calculate the probabilities related to the miss distance
pop_more = train_input[train_input.Categorised_Miss_Distance.eq("More")]
hazardous_more = round(len(pop_more[pop_more.Hazardous.eq(1)])/len(pop_more), 2)
p_more = round(len(pop_more)/len(train_input), 2)
pop_med = train_input[train_input.Categorised_Miss_Distance.eq("Medium")]
hazardous_med = round(len(pop_med[pop_med.Hazardous.eq(1)])/len(pop_med), 2)
p_med = round(len(pop_med)/len(train_input), 2)
pop_less = train_input[train_input.Categorised_Miss_Distance.eq("Less")]
hazardous_less = round(len(pop_less[pop_less.Hazardous.eq(1)])/len(pop_less), 2)
p_less = round(len(pop_less)/len(train_input), 2)
print("More Miss Distance: {} of the Objects, hazardous: {}".format(p_more , hazardous_more))
print("Medium Miss Distance: {} of the Objects, hazardous: {}".format(p_med,hazardous_med))
print("Less Miss Distance: {} of the Objects, hazardous: {}".format(p_less,hazardous_less))
# Listing Represent the miss-distance
# positions of the qubits
QPOS_more = 3
QPOS_med = 4
QPOS_less = 5
def apply_class(qc):
# set the marginal probability of miss-distance=more
qc.ry(prob_to_angle(p_more), QPOS_more)
qc.x(QPOS_more)
# set the marginal probability of Pclass=2nd
qc.cry(prob_to_angle(p_med/(1-p_more)), QPOS_more, QPOS_med)
# set the marginal probability of Pclass=3rd
qc.x(QPOS_med)
ccry(qc, prob_to_angle(p_less/(1-p_more-p_med)), QPOS_more, QPOS_med, QPOS_less)
qc.x(QPOS_med)
qc.x(QPOS_more)
# Listing Represent hazardous
# position of the qubit
QPOS_hazardous = 6
def apply_hazardous(qc, hazardous_params):
"""
hazardous_params = {
'p_hazardous_favoured_more': 0.3,
'p_hazardous_favoured_med': 0.4,
'p_hazardous_favoured_less': 0.5,
'p_hazardous_unfavoured_more': 0.6,
'p_hazardous_unfavoured_med': 0.7,
'p_hazardous_unfavoured_less': 0.8
}
"""
# set the conditional probability of Survival given unfavored by norm
qc.x(QPOS_NORM)
ccry(qc, prob_to_angle(
hazardous_params['p_hazardous_unfavoured_more']
),QPOS_NORM, QPOS_more, QPOS_hazardous)
ccry(qc, prob_to_angle(
hazardous_params['p_hazardous_unfavoured_med']
),QPOS_NORM, QPOS_med, QPOS_hazardous)
ccry(qc, prob_to_angle(
hazardous_params['p_hazardous_unfavoured_less']
),QPOS_NORM, QPOS_less, QPOS_hazardous)
qc.x(QPOS_NORM)
# set the conditional probability of hazardous given favored by norm
ccry(qc, prob_to_angle(
hazardous_params['p_hazardous_favoured_more']
),QPOS_NORM, QPOS_more, QPOS_hazardous)
ccry(qc, prob_to_angle(
hazardous_params['p_hazardous_favoured_med']
),QPOS_NORM, QPOS_med, QPOS_hazardous)
ccry(qc, prob_to_angle(
hazardous_params['p_hazardous_favoured_less']
),QPOS_NORM, QPOS_less, QPOS_hazardous)
# Listing The quantum bayesian network
QUBITS = 7
def qbn_neo(norm_params, hazardous_params, hist=True, measure=False, shots=1):
def circuit(qc, qr=None, cr=None):
apply_islarge_fast(qc)
apply_norm(qc, norm_params)
apply_class(qc)
apply_hazardous(qc, hazardous_params)
return as_pqc(QUBITS, circuit, hist=hist, measure=measure, shots=shots)
# Listing Try the QBN
norm_params = {
'p_norm_small_slow': 0.25,
'p_norm_small_fast': 0.35,
'p_norm_large_slow': 0.45,
'p_norm_large_fast': 0.55
}
hazardous_params = {
'p_hazardous_favoured_more': 0.3,
'p_hazardous_favoured_med': 0.4,
'p_hazardous_favoured_less': 0.5,
'p_hazardous_unfavoured_more': 0.6,
'p_hazardous_unfavoured_med': 0.7,
'p_hazardous_unfavoured_less': 0.8
}
qbn_neo(norm_params, hazardous_params, hist=True)
# Listing Calculate the parameters of the norm
def calculate_norm_params(objects):
# the different diameteric objects in our data
pop_large = objects[objects.Categorized_Diameter.eq("Large")]
pop_small = objects[objects.Categorized_Diameter.eq("Small")]
# combinations of being a large object and Relative Velocity
pop_small_slow = pop_small[pop_small.Categorized_Relative_Vel.eq('Slow')]
pop_small_fast = pop_small[pop_small.Categorized_Relative_Vel.eq('Fast')]
pop_large_slow = pop_large[pop_large.Categorized_Relative_Vel.eq('Slow')]
pop_large_fast = pop_large[pop_large.Categorized_Relative_Vel.eq('Fast')]
norm_params = {
'p_norm_small_slow': pop_small_slow.Norm.sum() / len(pop_small_slow),
'p_norm_small_fast': pop_small_fast.Norm.sum() / len(pop_small_fast),
'p_norm_large_slow': pop_large_slow.Norm.sum() / len(pop_large_slow),
'p_norm_large_fast': pop_large_fast.Norm.sum() / len(pop_large_fast),
}
return norm_params
# Listing Calculate the parameters of hazardous
def calculate_hazardous_params(objects):
# all hazardous
hazardous = objects[objects.Hazardous.eq(1)]
# weight the object
def weight_object(norm, missDistance):
return lambda object: (object[0] if norm else 1-object[0]) * (1 if object[1] == missDistance else 0)
# calculate the probability of being hazardous
def calc_prob(norm, missDistance):
return sum(list(map(
weight_object(norm, missDistance),
list(zip(hazardous['Norm'], hazardous['Categorised_Miss_Distance']))
))) / sum(list(map(
weight_object(norm, missDistance),
list(zip(objects['Norm'], objects['Categorised_Miss_Distance']))
)))
hazardous_params = {
'p_hazardous_favoured_more': calc_prob(True, "More"),
'p_hazardous_favoured_med': calc_prob(True, "Medium"),
'p_hazardous_favoured_less': calc_prob(True, "Less"),
'p_hazardous_unfavoured_more': calc_prob(False, "More"),
'p_hazardous_unfavoured_med': calc_prob(False, "Medium"),
'p_hazardous_unfavoured_less': calc_prob(False, "Less")
}
return hazardous_params
# Listing Prepare the data
def prepare_data(objects, params):
"""
params = {
'p_norm_large_slow_hazardous': 0.45,
'p_norm_large_slow_nonhazardous': 0.46,
'p_norm_large_fast_hazardous': 0.47,
'p_norm_large_fast_nonhazardous': 0.48,
'p_norm_small_slow_hazardous': 0.49,
'p_norm_small_slow_nonhazardous': 0.51,
'p_norm_small_fast_hazardous': 0.52,
'p_norm_small_fast_nonhazardous': 0.53,
}
"""
# is the object large?
objects['IsLarge'] = objects['Categorized_Diameter'].map(lambda dia: 0 if dia == "Small" else 1)
# the probability of favored by norm given diameter, relative velocity, and hazardous
objects['Norm'] = list(map(
lambda item: params['p_norm_{}_{}_{}'.format(
'small' if item[0] == "Small" else 'large',
'slow' if item[1] == "Slow" else 'fast',
'nonhazardous' if item[2] == 0 else 'hazardous'
)],
list(zip(objects['IsLarge'], objects['Categorized_Relative_Vel'], objects['Hazardous']))
))
return objects
# Listing Initialize the parameters
# Step 0: Initialize the parameter values
params = {
'p_norm_large_slow_hazardous': 0.45,
'p_norm_large_slow_nonhazardous': 0.46,
'p_norm_large_fast_hazardous': 0.47,
'p_norm_large_fast_nonhazardous': 0.48,
'p_norm_small_slow_hazardous': 0.49,
'p_norm_small_slow_nonhazardous': 0.51,
'p_norm_small_fast_hazardous': 0.52,
'p_norm_small_fast_nonhazardous': 0.53,
}
# Listing Run the qbn
objects = prepare_data(test_input, params)
results = qbn_neo(calculate_norm_params(objects), calculate_hazardous_params(objects), hist=False)
print(objects)
objects.to_csv('objects.csv')
# Listing Get a list of relevant states
def filter_states(states, position, value):
return list(filter(lambda item: item[0][QUBITS-1-position] == str(value), states))
# Listing The states with hazardous objects
filter_states(results.items(), QPOS_hazardous, '1')
# Listing Calculate the marginal probability to be hazardous
def sum_states(states):
return sum(map(lambda item: item[1], states))
sum_states(filter_states(results.items(), QPOS_hazardous, '1'))
# Listing The log‐likelihood function adapted for our data
def log_likelihood_neo(data, results):
states = results.items()
def calc_prob(norm_val, islarge_val, rv_val, hazardous_val):
return sum_states(
filter_states(
filter_states(
filter_states(
filter_states(states, QPOS_RV, rv_val),
QPOS_dia, islarge_val
), QPOS_hazardous, hazardous_val
), QPOS_NORM, norm_val))
probs = {
'p_favoured_large_slow_hazardous': calc_prob('1', '1', '0', '1'),
'p_favoured_large_slow_nonhazardous': calc_prob('1', '1', '0', '0'),
'p_favoured_large_fast_hazardous': calc_prob('1', '1', '1', '1'),
'p_favoured_large_fast_nonhazardous': calc_prob('1', '1', '1', '0'),
'p_favoured_small_slow_hazardous': calc_prob('1', '0', '0', '1'),
'p_favoured_small_slow_nonhazardous': calc_prob('1', '0', '0', '0'),
'p_favoured_small_fast_hazardous': calc_prob('1', '0', '1', '1'),
'p_favoured_small_fast_nonhazardous': calc_prob('1', '0', '1', '0'),
'p_unfavoured_large_slow_hazardous': calc_prob('0', '1', '0', '1'),
'p_unfavoured_large_slow_nonhazardous': calc_prob('0', '1', '0', '0'),
'p_unfavoured_large_fast_hazardous': calc_prob('0', '1', '1', '1'),
'p_unfavoured_large_fast_nonhazardous': calc_prob('0', '1', '1', '0'),
'p_unfavoured_small_slow_hazardous': calc_prob('0', '0', '0', '1'),
'p_unfavoured_small_slow_nonhazardous': calc_prob('0', '0', '0', '0'),
'p_unfavoured_small_fast_hazardous': calc_prob('0', '0', '1', '1'),
'p_unfavoured_small_fast_nonhazardous': calc_prob('0', '0', '1', '0'),
}
return round(sum(map(
lambda item: log(probs['p_{}_{}_{}_{}'.format(
'unfavoured',
'small' if item[1] == 0 else 'large',
'slow' if item[2] == "Slow" else 'fast',
'nonhazardous' if item[3] == 0 else 'hazardous'
)] + probs['p_{}_{}_{}_{}'.format(
'favoured',
'small' if item[1] == 0 else 'large',
'slow' if item[2] == "Slow" else 'fast',
'nonhazardous' if item[3] == 0 else 'hazardous'
)]
),
list(zip(data['Norm'], data['IsLarge'], data['Categorized_Relative_Vel'], data['Hazardous']))
)), 3)
# Listing Calculate the log‐likelihood
log_likelihood_neo(test_input, results)
# Listing Obtain new object values from the results
def to_params(results):
states = results.items()
def calc_norm(islarge_val, rv_val, hazardous_val):
pop = filter_states(filter_states(filter_states(states, QPOS_RV, rv_val), QPOS_dia, islarge_val), QPOS_hazardous, hazardous_val)
p_norm = sum(map(lambda item: item[1], filter_states(pop, QPOS_NORM, '1')))
p_total = sum(map(lambda item: item[1], pop))
return p_norm / p_total
return {
'p_norm_large_slow_hazardous': calc_norm('1', '0', '1'),
'p_norm_large_slow_nonhazardous': calc_norm('1', '0', '0'),
'p_norm_large_fast_hazardous': calc_norm('1', '1', '1'),
'p_norm_large_fast_nonhazardous': calc_norm('1', '1', '0'),
'p_norm_small_slow_hazardous': calc_norm('0', '0', '1'),
'p_norm_small_slow_nonhazardous': calc_norm('0', '0', '0'),
'p_norm_small_fast_hazardous': calc_norm('0', '1', '1'),
'p_norm_small_fast_nonhazardous': calc_norm('0', '1', '0'),
}
# Listing Calcualte new objects
to_params(results)
# Listing The recursive training automatism
def train_qbn_neo(objects, params, iterations):
if iterations > 0:
new_params = train_qbn_neo(objects, params, iterations - 1)
objects = prepare_data(objects, new_params)
results = qbn_neo(calculate_norm_params(objects), calculate_hazardous_params(objects), hist=False)
print ('The log-likelihood after {} iteration(s) is {}'.format(iterations, log_likelihood_neo(objects, results)))
return to_params(results)
return params
# Listing Train the QBN
test_params = train_qbn_neo(test_input, {
'p_norm_large_slow_hazardous': 0.45,
'p_norm_large_slow_nonhazardous': 0.46,
'p_norm_large_fast_hazardous': 0.47,
'p_norm_large_fast_nonhazardous': 0.48,
'p_norm_small_slow_hazardous': 0.49,
'p_norm_small_slow_nonhazardous': 0.51,
'p_norm_small_fast_hazardous': 0.52,
'p_norm_small_fast_nonhazardous': 0.53,
}, 25)
# Listing The parameters after training
test_params
# Listing Pre‐processing
def pre_process(object):
return (object['IsLarge'] == 1, object['Categorized_Relative_Vel'] == 'Fast', object['Categorised_Miss_Distance'])
# Listing Apply the known data on the quantum circuit
def apply_known(qc, is_large, is_fast, missDistance):
if is_large:
qc.x(QPOS_dia)
if is_fast:
qc.x(QPOS_RV)
qc.x(QPOS_more if missDistance == "More" else (QPOS_med if missDistance == "Medium" else QPOS_less))
# Listing Get the trained QBN
def get_trained_qbn(objects, params):
prepared_objects = prepare_data(objects, params)
norm_params = calculate_norm_params(prepared_objects)
hazardous_params = calculate_hazardous_params(prepared_objects)
def trained_qbn_neo(object):
(is_large, is_fast, missDistance) = object
def circuit(qc, qr, cr):
apply_known(qc, is_large, is_fast, missDistance)
apply_norm(qc, norm_params)
apply_hazardous(qc, hazardous_params)
qc.measure(qr[QPOS_hazardous], cr[0])
return as_pqc(QUBITS, circuit, hist=False, measure=True, shots=100)
return trained_qbn_neo
# Listing Post‐processing
def post_process(counts):
"""
counts -- the result of the quantum circuit execution
returns the prediction
"""
#print (counts)
p_hazardous = counts['1'] if '1' in counts.keys() else 0
p_nonhazardous = counts['0'] if '0' in counts.keys() else 0
#return int(list(map(lambda item: item[0], counts.items()))[0])
return 1 if p_hazardous > p_nonhazardous else 0
# Preparing Report
def run(f_classify, x):
return list(map(f_classify, x))
def specificity(matrix):
return matrix[0][0]/(matrix[0][0]+matrix[0][1]) if (matrix[0][0]+matrix[0][1] > 0) else 0
def npv(matrix):
return matrix[0][0]/(matrix[0][0]+matrix[1][0]) if (matrix[0][0]+matrix[1][0] > 0) else 0
def classifier_report(name, run, classify, input, labels):
cr_predictions = run(classify, input)
cr_cm = confusion_matrix(labels, cr_predictions)
output = pd.DataFrame(list(zip(labels, cr_predictions)), columns=['Labels', 'Predictions'])
output.to_csv('output.csv')
cr_precision = precision_score(labels, cr_predictions)
cr_recall = recall_score(labels, cr_predictions)
cr_specificity = specificity(cr_cm)
cr_npv = npv(cr_cm)
cr_level = 0.25*(cr_precision + cr_recall + cr_specificity + cr_npv)
print("Confusion Matrix is:")
print(cr_cm)
print('The precision score of the {} classifier is {}'
.format(name, cr_precision))
print('The recall score of the {} classifier is {}'
.format(name, cr_recall))
print('The specificity score of the {} classifier is {}'
.format(name, cr_specificity))
print('The npv score of the {} classifier is {}'
.format(name, cr_npv))
print('The information level is: {}'
.format(cr_level))
# Listing Run the Quantum Naive Bayes Classifier
# redefine the run-function
def run(f_classify, data):
return [f_classify(data.iloc[i]) for i in range(0,len(data))]
# get the simple qbn
trained_qbn = get_trained_qbn(test_input, test_params)
# evaluate the Quantum Bayesian Network
classifier_report("QBN",
run,
lambda object: post_process(trained_qbn(pre_process(object))),
objects,
test_input['Hazardous'])
|
https://github.com/TaiteHopkins/OracleCircuit
|
TaiteHopkins
|
#Dependency import
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
import math
from qiskit.visualization import array_to_latex
#Problem Statement:
#Creating an Oracle Circuit and Diffuser which inverts the phase for the state 110101
#Defining Unitary Display function for confirmation, implementing Aer Sim
def display_unitary(qc, prefix=""):
sim = Aer.get_backend('aer_simulator')
qc = qc.copy()
qc.save_unitary()
unitary = sim.run(qc).result().get_unitary()
display(array_to_latex(unitary, prefix=prefix))
#Using V-Oracle Model - Vemula et Al. 2022 arXiv:2205.00117v1 [quant-ph] 30 Apr 2022
def v_oracle(circuit):
circuit.toffoli(0,1,6)
circuit.toffoli(2,3,7)
circuit.toffoli(6,7,8)
circuit.toffoli(4,8,9)
circuit.cz(9,5)
circuit.toffoli(4,8,9)
circuit.toffoli(6,7,8)
circuit.toffoli(2,3,7)
circuit.toffoli(0,1,6)
#Defining Oracle Circuit
oracle = QuantumCircuit(10)
oracle.h([0,1,2,3,4,5])
v_oracle(oracle)
oracle.x([1,3])
oracle.x([1,3])
#Displaying Oracle phase table
display_unitary(oracle, "U_\\text{oracle}=")
#Displaying Quantum Circuit Diagram
oracle.draw()
#Diffuser Construction
diffCircuit = QuantumCircuit(10)
diffCircuit.h([0,1,2,3,4,5])
diffCircuit.x([0,1,2,3,4,5])
v_oracle(diffCircuit)
diffCircuit.x([0,1,2,3,4,5])
diffCircuit.h([0,1,2,3,4,5])
diffCircuit.draw()
grover = QuantumCircuit(10,6)
grover = grover.compose(oracle)
grover = grover.compose(diffCircuit)
grover = grover.compose(diffCircuit)
grover = grover.compose(diffCircuit)
grover = grover.compose(diffCircuit)
grover = grover.compose(diffCircuit)
grover = grover.compose(diffCircuit)
grover = grover.compose(diffCircuit)
grover = grover.compose(diffCircuit)
grover = grover.compose(diffCircuit)
grover = grover.compose(diffCircuit)
grover = grover.compose(diffCircuit)
grover.x([1,3])
grover.measure([0,1,2,3,4,5],[0,1,2,3,4,5])
grover.draw()
sim = Aer.get_backend('aer_simulator')
counts = sim.run(grover).result().get_counts()
plot_histogram(counts)
|
https://github.com/SambitPrabhu/Boolean-SAT-using-Grovers-algorithm
|
SambitPrabhu
|
# Allowed combinations for the party according to the following guidelines:
# 1.It is Alice and Bob's engagement party so they must be invited
# 2.Charles will come only if Dave comes without Eve (iff Dave comes and Eve doesn't)
# A B C D E
# 1 1 0 0 0
# 1 1 0 0 1
# 1 1 0 1 0
# 1 1 0 1 1
# 1 1 1 1 0
# Karnaugh map:
# CD
# 00 01 11 10
# E 0 1 1 1 0
# 1 1 1 0 0
# The minimized boolean expression turns out to be:
# A.B.(C'+ E'.D)
# or
# A^B^(~C U ~E^D)
# This can be converted into CNF form:
# A.B.(C'+D).(C'+E')
# Later on, I realised that another expression is more convenient to implement from scratch using quantum gates:
# A.B.~(C.E).~(C.~D)
# Grover's algorithm must search through all possible values of A,B,C,D and E and output the 5 valid combinations we have tabulated above.
# In this project I have shown both the library implementation of Grover's algorithm and the from-scratch quantum circuit implementation, both of which yield the same correct results :D
from qiskit import QuantumCircuit, assemble, Aer
from qiskit.visualization import plot_histogram
from qiskit_textbook.widgets import binary_widget
from qiskit.aqua.algorithms import Grover
from qiskit.aqua.components.oracles import LogicalExpressionOracle
from qiskit.circuit.library import PhaseOracle
from qiskit.circuit import QuantumRegister
from qiskit.circuit import ClassicalRegister
from qiskit.compiler import transpile
import numpy as np
bool_exp = '''
c examples
p cnf 5 4
5 0
4 0
-3 2 0
-3 -1 0
'''
algorithm = Grover(LogicalExpressionOracle(bool_exp))
backend = Aer.get_backend('aer_simulator')
result = algorithm.run(backend)
plot_histogram(result['measurement'],title='Combinations A B C D E')
#Functions to append hadamard gate and diffuser oracle
def hadamard(qc, qubits):
for q in qubits:
qc.h(q)
return qc
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
for qubit in range(nqubits):
qc.h(qubit)
for qubit in range(nqubits):
qc.x(qubit)
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1)
qc.h(nqubits-1)
for qubit in range(nqubits):
qc.x(qubit)
for qubit in range(nqubits):
qc.h(qubit)
U_s = qc.to_gate()
U_s.name = "U$_s$"
return U_s
n= 5
var_qubits = QuantumRegister(5, name='v')
clause_qubits = QuantumRegister(4, name='c')
output_qubit = QuantumRegister(1, name='out')
cbits = ClassicalRegister(5, name='cbits')
grover_circuit = QuantumCircuit(var_qubits, clause_qubits, output_qubit, cbits)
grover_circuit.initialize([1, -1]/np.sqrt(2), output_qubit)
grover_circuit.initialize([1, 0], clause_qubits[0])
grover_circuit.initialize([1, 0], clause_qubits[1])
grover_circuit.initialize([1, 0], clause_qubits[2])
grover_circuit.initialize([1, 0], clause_qubits[3])
grover_circuit = QuantumCircuit(var_qubits, clause_qubits, output_qubit, cbits)
grover_circuit = hadamard(grover_circuit, var_qubits)
grover_circuit.barrier()
#Implementing boolean exp A.B.~(C.E).~(~D.~E) using Toffoli, CNOT and Bit-flip gates
#individual clauses evaluated using CNOT and X gates
grover_circuit.cx(var_qubits[0],clause_qubits[0])
grover_circuit.cx(var_qubits[1],clause_qubits[1])
grover_circuit.ccx(var_qubits[2],var_qubits[4],clause_qubits[2])
grover_circuit.x(clause_qubits[2])
grover_circuit.x(var_qubits[3])
grover_circuit.ccx(var_qubits[2],var_qubits[3],clause_qubits[3])
grover_circuit.x(clause_qubits[3])
#all clauses are ANDed using Toffoli gate
grover_circuit.mct(clause_qubits, output_qubit)
grover_circuit.barrier()
#Uncomputing to revert clause bits to their original state
grover_circuit.cx(var_qubits[0],clause_qubits[0])
grover_circuit.cx(var_qubits[1],clause_qubits[1])
grover_circuit.x(clause_qubits[2])
grover_circuit.ccx(var_qubits[2],var_qubits[4],clause_qubits[2])
grover_circuit.x(clause_qubits[3])
grover_circuit.ccx(var_qubits[2],var_qubits[3],clause_qubits[3])
grover_circuit.x(var_qubits[3])
grover_circuit.barrier()
grover_circuit.append(diffuser(n), [0,1,2,3,4])
#Implementing boolean exp A.B.~(C.E).~(~D.~E) using Toffoli, CNOT and Bit-flip gates
#individual clauses evaluated using CNOT and X gates
grover_circuit.cx(var_qubits[0],clause_qubits[0])
grover_circuit.cx(var_qubits[1],clause_qubits[1])
grover_circuit.ccx(var_qubits[2],var_qubits[4],clause_qubits[2])
grover_circuit.x(clause_qubits[2])
grover_circuit.x(var_qubits[3])
grover_circuit.ccx(var_qubits[2],var_qubits[3],clause_qubits[3])
grover_circuit.x(clause_qubits[3])
#all clauses are ANDed using Toffoli gate
grover_circuit.mct(clause_qubits, output_qubit)
grover_circuit.barrier()
#Uncomputing to revert clause bits to their original state
grover_circuit.cx(var_qubits[0],clause_qubits[0])
grover_circuit.cx(var_qubits[1],clause_qubits[1])
grover_circuit.x(clause_qubits[2])
grover_circuit.ccx(var_qubits[2],var_qubits[4],clause_qubits[2])
grover_circuit.x(clause_qubits[3])
grover_circuit.ccx(var_qubits[2],var_qubits[3],clause_qubits[3])
grover_circuit.x(var_qubits[3])
grover_circuit.barrier()
grover_circuit.append(diffuser(n), [0,1,2,3,4])
grover_circuit.measure(var_qubits,cbits)
grover_circuit.draw('mpl')
grover_circuit=grover_circuit.reverse_bits()
backend = Aer.get_backend('aer_simulator')
transpiled_qc = transpile(grover_circuit, backend)
qobj = assemble(transpiled_qc)
result = backend.run(qobj).result()
plot_histogram(result.get_counts(),title='Combinations: A B C D E')
|
https://github.com/andre-juan/quantum_nearest_neighbors
|
andre-juan
|
import numpy as np
from scipy.linalg import expm
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, Aer, execute
from qiskit.circuit import AncillaQubit
from qiskit.visualization import plot_histogram
from qiskit.circuit.library.standard_gates import XGate, ZGate, HGate
from qiskit.circuit.add_control import add_control
from qiskit.extensions import UnitaryGate
import matplotlib.pyplot as plt
def show_figure(fig):
'''
auxiliar function to display plot
even if it's not the last command of the cell
from: https://github.com/Qiskit/qiskit-terra/issues/1682
'''
new_fig = plt.figure()
new_mngr = new_fig.canvas.manager
new_mngr.canvas.figure = fig
fig.set_canvas(new_mngr.canvas)
plt.show(fig)
def test_circuit(qc):
'''
auxiliar function, to test intermediate steps, looking at measurement results
this function allows the inspection of the amplitudes of states,
at any point of the circuit (call it with the desired circuit)
'''
cr = ClassicalRegister(qc.num_qubits, "creg_test")
qc_cr = QuantumCircuit(cr)
qc_test = qc + qc_cr
for i in range(qc.num_qubits):
qc_test.measure(i, i)
#################################
backend = Aer.get_backend("qasm_simulator")
job = execute(qc_test, backend, shots=1e5, seed_simulator=42)
results = job.result()
counts = results.get_counts()
return plot_histogram(counts, title="Results", figsize=(12, 4))
def construct_input_state(X_test):
'''
construct quantum state from bit string X_test
'''
# number of features
n = len(X_test)
# build the circuit
qr_input = QuantumRegister(n, "features_input")
qc_input = QuantumCircuit(qr_input)
for i in range(n):
if X_test[i] == "1":
qc_input.x(i)
return qc_input
def construct_training_set_state(X, y):
'''
construct quantum superposition of training dataset from:
- X: feature matrix
- y: target array
returns the circuit as well as the number of features, n
'''
# number of examples
N = X.shape[0]
# number of features
n = X.shape[1]
# full dataset, of the form [[X], [y]]
dataset = np.append(X, y.reshape((-1, 1)), axis=1)
# n+1 because the last register will encode the class!
amplitudes = np.zeros(2**(n+1))
# integer representation of binary strings in training dataset
# notice the [::-1], which is necessary to adjust the endianness!
data_points_X = [int("".join(str(i) for i in X[j])[::-1], 2) for j in range(dataset.shape[0])]
# integer representation considering also the class
# IMPORTANT: sum 2**n for elements in class 1
# this is necessary to encode also the class, in n+1 registers!
data_points = [x + 2**n if y[i] == 1 else x for i, x in enumerate(data_points_X)]
# set amplitudesof existing datapoints
amplitudes[data_points] = 1
# normalize amplitudes
amplitudes = amplitudes/np.sqrt(amplitudes.sum())
###################################################
# build the circuit
qr_features = QuantumRegister(n, "features_train")
qr_target = QuantumRegister(1, "target_train")
qc_training = QuantumCircuit(qr_features, qr_target)
qc_training.initialize(amplitudes, [qr_features, qr_target])
return qc_training, n
def construct_ancilla_state():
'''
construct ancilla register
'''
# build the circuit
qr_anc = QuantumRegister(1, "anc")
qc_anc = QuantumCircuit(qr_anc)
qc_anc.draw("mpl")
return qc_anc
def construct_initial_state(X, y, X_test, draw=False):
'''
conjugate elements of the initial state (input, training dataset and ancilla) in a
single quantum circuit
returns the circuit as well as the number of features, n
'''
qc_input = construct_input_state(X_test)
qc_training, n = construct_training_set_state(X, y)
qc_anc = construct_ancilla_state()
qc = qc_input + qc_training + qc_anc
qc.barrier()
if draw:
print("\nInitial state:")
show_figure(qc.draw("mpl"))
return qc, n
def step1(qc, draw=False):
qc.h(-1)
qc.barrier()
if draw:
print("\nStep 1:")
show_figure(qc.draw("mpl"))
return qc
def step2(qc, n, draw=False):
for i in range(n):
qc.cnot(i, n+i)
qc.barrier()
if draw:
print("\nStep 2:")
show_figure(qc.draw("mpl"))
return qc
def step3(qc, n, draw):
# matrices of 1 and \sigma_z to be exponentiated below
# source of the matrix exponential methods below:
# https://quantumcomputing.stackexchange.com/questions/10317/quantum-circuit-to-implement-matrix-exponential
idtt = np.eye(2)
sz = np.array([[1,0],
[0,-1]])
###################################################
# define the exponentiated unitaries
U_1_minus = expm(-1j * (np.pi/(2*4)) * ((idtt-sz)/2))
U_1_plus = expm(1j * (np.pi/(2*4)) * ((idtt-sz)/2))
# defining controlled gates
u1m = add_control(operation=UnitaryGate(U_1_minus, label="$U_1^-$"),
num_ctrl_qubits=1, ctrl_state=0, label="$CU_1^-$")
u1p = add_control(operation=UnitaryGate(U_1_plus, label="$U_1^+$"),
num_ctrl_qubits=1, ctrl_state=1, label="$CU_1^+$")
# getting the registers
registers = qc.qregs
# register labels
registers_labels = [qr.name for qr in qc.qregs]
qr_features = registers[registers_labels.index("features_train")]
qr_anc = registers[registers_labels.index("anc")]
# build a circuit to apply the unitary above
# this will be combined with the main circuit later on (notice: same registers!!).
qc_u = QuantumCircuit(qr_features, qr_anc)
for i in range(n):
# apply the unitaries
qc_u.append(u1p, [qr_anc[0], qr_features[i]])
qc_u.append(u1m, [qr_anc[0], qr_features[i]])
###################################################
# combine the U circuit above to the main circuit
qc = qc.combine(qc_u)
qc.barrier()
###################################################
if draw:
print("\nStep 3:")
show_figure(qc.draw("mpl"))
return qc
def step4(qc, draw):
qc.h(-1)
qc.barrier()
if draw:
print("\nStep 4:")
show_figure(qc.draw("mpl"))
return qc
def measurement(qc, draw_final):
'''
implements the measurement of the circuit
'''
# getting the registers
registers = qc.qregs
registers_labels = [qr.name for qr in qc.qregs]
qr_anc = registers[registers_labels.index("anc")]
qr_target = registers[registers_labels.index("target_train")]
###########################3
cr_anc = ClassicalRegister(1, "c_anc")
qc_cr_anc = QuantumCircuit(cr_anc)
cr_class = ClassicalRegister(1, "c_class")
qc_cr_class = QuantumCircuit(cr_class)
qc = qc + qc_cr_anc + qc_cr_class
qc.measure(qr_anc, cr_anc)
qc.measure(qr_target, cr_class)
if draw_final:
print("\nStep 5 (measurement):")
show_figure(qc.draw("mpl"))
return qc
def run(qc):
'''
runs the circuit, display results and return both
predicted class and probability distribution of prediction
'''
backend = Aer.get_backend("qasm_simulator")
n_shots = 1e4
job = execute(qc, backend, shots=n_shots, seed_simulator=42)
results = job.result()
counts = results.get_counts()
# filtering out measurements of ancila = |1> (last register)
keys = list(counts.keys()).copy()
for key in keys:
if key[-1] == "1":
counts.pop(key)
show_figure(plot_histogram(counts, title="Results", figsize=(12, 4)))
####################################
# final prediction
# dictionary of counts sorted by value (sbv), decreasing order...
counts_sbv = dict(sorted(counts.items(), key=lambda item: item[1], reverse=True))
# ...will have its first key (first [0]) corresponding to the class with highest count (thus, probability!)
# the key is of the form "class ancilla", thus, to get the actual class, get the first character (second [0])
y_pred = list(counts_sbv.keys())[0][0]
# also display probabilities (predict_proba)
n_norm = sum(list(counts.values()))
y_proba = {"p(c={})".format(classe[0]): count/n_norm for classe, count in counts_sbv.items()}
print("\nProbability of belonging to each class:\n")
for k, v in y_proba.items():
print("{} = {:.3f}".format(k, v))
print("\n")
print("*"*30)
print("="*30)
print("*"*30)
print("\n")
print("Final prediction:\n")
print("y({}) = {}".format(X_test, y_pred))
return y_pred, y_proba
def quantum_nearest_neighbors(qc, n, X_test, draw=False, draw_final=False):
qc = step1(qc, draw)
qc = step2(qc, n, draw)
qc = step3(qc, n, draw)
qc = step4(qc, draw)
qc = measurement(qc, draw_final)
y_pred, y_proba = run(qc)
return y_pred, y_proba
X = np.array([[0, 0, 0, 0],
[0, 0, 0, 1],
[1, 1, 1, 0],
[1, 1, 1, 1]])
# balanced
y = np.array([0, 0, 1, 1])
#############################################
X_test = "0010"
#############################################
qc, n = construct_initial_state(X, y, X_test)
quantum_nearest_neighbors(qc, n, X_test)
X = np.array([[0, 0, 0, 0, 0],
[0, 0, 0, 1, 0],
[0, 0, 0, 1, 1],
[1, 1, 1, 1, 0],
[1, 1, 1, 1, 1]])
# imbalanced
y = np.array([0, 0, 0, 1, 1])
#############################################
X_test = "10101"
#############################################
qc, n = construct_initial_state(X, y, X_test)
quantum_nearest_neighbors(qc, n, X_test)
X = np.array([[0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 1],
[0, 0, 0, 1, 1, 0],
[1, 1, 1, 1, 0, 1],
[1, 1, 1, 1, 1, 0]])
# imbalanced
y = np.array([0, 0, 0, 1, 1])
#############################################
X_test = "001111"
#############################################
qc, n = construct_initial_state(X, y, X_test)
quantum_nearest_neighbors(qc, n, X_test)
# modified dataset to cause ambiguity
# (notice how many examples have the central "11")
X = np.array([[0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 1],
[0, 0, 1, 1, 1, 0],
[1, 1, 1, 1, 0, 1],
[1, 1, 1, 1, 1, 0]])
# imbalanced
y = np.array([0, 0, 0, 1, 1])
#############################################
X_test = "001100"
#############################################
qc, n = construct_initial_state(X, y, X_test)
quantum_nearest_neighbors(qc, n, X_test)
# modified dataset to cause ambiguity
# (notice how many examples have the central "11")
X = np.array([[0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 1],
[0, 0, 1, 1, 1, 0],
[1, 1, 1, 1, 0, 1],
[1, 1, 1, 1, 1, 0],
[1, 1, 0, 0, 1, 1]])
# imbalanced
y = np.array([0, 0, 0, 1, 1, 1])
#############################################
X_test = "001100"
#############################################
qc, n = construct_initial_state(X, y, X_test)
quantum_nearest_neighbors(qc, n, X_test)
|
https://github.com/andre-juan/quantum_nearest_neighbors
|
andre-juan
|
import numpy as np
from scipy.linalg import expm
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, Aer, execute
from qiskit.circuit import AncillaQubit
from qiskit.visualization import plot_histogram
from qiskit.circuit.library.standard_gates import XGate, ZGate, HGate
from qiskit.circuit.add_control import add_control
from qiskit.extensions import UnitaryGate
def test_circuit(qc):
'''
auxiliar function, to test intermediate steps, looking at measurement results
this function allows the inspection of the amplitudes of states,
at any point of the circuit (call it with the desired circuit)
'''
cr = ClassicalRegister(qc.num_qubits, "m_cl")
qc_cr = QuantumCircuit(cr)
qc_test = qc + qc_cr
for i in range(qc.num_qubits):
qc_test.measure(i, i)
#################################
backend = Aer.get_backend("qasm_simulator")
job = execute(qc_test, backend, shots=1e5, seed_simulator=42)
results = job.result()
counts = results.get_counts()
return plot_histogram(counts, title="Results", figsize=(12, 4))
qr_input = QuantumRegister(4, "i")
qc_input = QuantumCircuit(qr_input)
x = "0010"
for i in range(len(x)):
if x[i] == "1":
qc_input.x(i)
qc_input.draw("mpl")
test_circuit(qc_input)
X = np.array([[0, 0, 0, 0],
[0, 0, 0, 1],
[1, 1, 1, 0],
[1, 1, 1, 1]])
# number of examples
N = X.shape[0]
# number of features
n = X.shape[1]
y = np.array([0, 0, 1, 1])
# full dataset, of the form [[X], [y]]
dataset = np.append(X, y.reshape((-1, 1)), axis=1)
# n+1 because the last register will encode the class!
amplitudes = np.zeros(2**(n+1))
amplitudes
# integer representation of binary strings in training dataset
# notice the [::-1], which is necessary to adjust the endianness!
data_points_X = [int("".join(str(i) for i in X[j])[::-1], 2) for j in range(dataset.shape[0])]
data_points_X
# integer representation considering also the class
# IMPORTANT: sum 2**n for elements in class 1
# this is necessary to encode also the class!
data_points = [x + 2**n if y[i] == 1 else x for i, x in enumerate(data_points_X)]
data_points
amplitudes[data_points] = 1
amplitudes = amplitudes/np.sqrt(amplitudes.sum())
amplitudes
qr_features = QuantumRegister(n, "f")
qr_class = QuantumRegister(1, "cl")
qc_training = QuantumCircuit(qr_features, qr_class)
qc_training.initialize(amplitudes, [qr_features, qr_class])
qc_training.draw("mpl")
test_circuit(qc_training)
dataset
qr_anc = QuantumRegister(1, "anc")
qc_anc = QuantumCircuit(qr_anc)
qc_anc.draw("mpl")
qc = qc_input + qc_training + qc_anc
qc.barrier()
qc.draw("mpl")
test_circuit(qc)
qc.h(-1)
qc.barrier()
qc.draw("mpl")
for i in range(4):
qc.cnot(i, 4+i)
qc.barrier()
qc.draw("mpl")
# matrices of 1 and \sigma_z to be exponentiated below
# source of the matrix exponential methods below:
# https://quantumcomputing.stackexchange.com/questions/10317/quantum-circuit-to-implement-matrix-exponential
idtt = np.eye(2)
sz = np.array([[1,0],
[0,-1]])
# define the exponentiated unitaries
U_1_minus = expm(-1j * (np.pi/(2*4)) * ((idtt-sz)/2))
U_1_plus = expm(1j * (np.pi/(2*4)) * ((idtt-sz)/2))
# defining controlled gates
u1m = add_control(operation=UnitaryGate(U_1_minus, label="$U_1^-$"),
num_ctrl_qubits=1, ctrl_state=0, label="$CU_1^-$")
u1p = add_control(operation=UnitaryGate(U_1_plus, label="$U_1^+$"),
num_ctrl_qubits=1, ctrl_state=1, label="$CU_1^+$")
# build a circuit to apply the unitary above
# this will be combined with the main circuit later on (notice: same registers!!).
qc_u = QuantumCircuit(qr_features, qr_anc)
for i in range(4):
# apply the unitaries
qc_u.append(u1p, [qr_anc[0], qr_features[i]])
qc_u.append(u1m, [qr_anc[0], qr_features[i]])
# # decompose this portion of the circuit
# # (this will be appended to the main circuit later on)
# qc_u = qc_u.decompose()
qc_u.draw("mpl")
qr_input = QuantumRegister(4, "i")
qr_features = QuantumRegister(4, "f")
qr_class = QuantumRegister(1, "cl")
qr_anc = QuantumRegister(1, "anc")
qc_prep = QuantumCircuit(qr_input, qr_features, qr_class, qr_anc)
# build the state |0010,0110,0 ;1⟩ + |0010,0110,0 ;0⟩
# input
qc_prep.x(qr_input[2])
# hamming ditance
# qc_prep.x(qr_features[1])
# qc_prep.x(qr_features[2])
qc_prep.x(qr_features[3])
# ancilla
qc_prep.h(qr_anc[0])
qc_prep.barrier()
##################################################
qc_test = qc_prep.combine(qc_u)
qc_test.barrier()
##################################################
qc_test.h(qr_anc[0])
qc_test.barrier()
##################################################
cr = ClassicalRegister(qc_test.num_qubits, "c")
qc_cr = QuantumCircuit(cr)
qc_test = qc_test + qc_cr
for i in range(qc_test.num_qubits):
qc_test.measure(i, i)
##################################################
qc_test.draw("mpl")
cr = ClassicalRegister(qc_test.num_qubits, "c")
qc_cr = QuantumCircuit(cr)
qc_prep = qc_prep + qc_cr
for i in range(qc_prep.num_qubits):
qc_prep.measure(i, i)
backend = Aer.get_backend("qasm_simulator")
job = execute(qc_prep, backend, shots=1e5, seed_simulator=42)
results = job.result()
counts = results.get_counts()
plot_histogram(counts, title="Results", figsize=(12, 4))
backend = Aer.get_backend("qasm_simulator")
job = execute(qc_test, backend, shots=1e5, seed_simulator=42)
results = job.result()
counts = results.get_counts()
plot_histogram(counts, title="Results", figsize=(12, 4))
print("Ancila 0")
(np.cos(np.pi/8))**2
print("Ancila 1")
(np.sin(np.pi/8))**2
qc = qc.combine(qc_u)
qc.barrier()
qc.draw("mpl")
qc.h(-1)
qc.barrier()
qc.draw("mpl", scale=0.75)
# copying the qc so far, before measurement
qc_bckp = qc.copy()
qc = qc_bckp.copy()
cr = ClassicalRegister(qc.num_qubits, "c")
qc_cr = QuantumCircuit(cr)
qc = qc + qc_cr
for i in range(qc.num_qubits):
qc.measure(i, i)
# qc.draw("mpl")
backend = Aer.get_backend("qasm_simulator")
job = execute(qc, backend, shots=1e5, seed_simulator=42)
results = job.result()
counts = results.get_counts()
plot_histogram(counts, title="Results", figsize=(12, 4))
# using the same endiannes of qiskit, i.e., |0010,0010,0;0> = 0001000100
{"0001000100" : round((0.25)*(np.cos(np.pi/8))**2, 3),
"1001000100" : round((0.25)*(np.sin(np.pi/8))**2, 3),
"0011000100" : round((0.25)*(np.cos(2*np.pi/8))**2, 3),
"1011000100" : round((0.25)*(np.sin(2*np.pi/8))**2, 3),
"0100110100" : round((0.25)*(np.cos(2*np.pi/8))**2, 3),
"1100110100" : round((0.25)*(np.sin(2*np.pi/8))**2, 3),
"0110110100" : round((0.25)*(np.cos(3*np.pi/8))**2, 3),
"1110110100" : round((0.25)*(np.sin(3*np.pi/8))**2, 3)}
qc = qc_bckp.copy()
# first, lets's measure the ancilla
cr_anc = ClassicalRegister(1, "c_anc")
qc_cr_anc = QuantumCircuit(cr_anc)
qc_cr_anc.draw("mpl")
qc = qc + qc_cr_anc
qc.measure(qr_anc, cr_anc[0])
# qc.draw("mpl", scale=0.7)
# theoretical probability of measuring ancilla in |0>
(0.25)*((np.cos(np.pi/8))**2 + 2*(np.cos(2*np.pi/8))**2 + (np.cos(3*np.pi/8))**2)
backend = Aer.get_backend("qasm_simulator")
job = execute(qc, backend, shots=1e4, seed_simulator=42)
results = job.result()
counts = results.get_counts()
plot_histogram(counts, title="Results", figsize=(12, 4))
qc = qc_bckp.copy()
cr_anc = ClassicalRegister(1, "c_anc")
qc_cr_anc = QuantumCircuit(cr_anc)
cr_class = ClassicalRegister(1, "c_class")
qc_cr_class = QuantumCircuit(cr_class)
qc = qc + qc_cr_anc + qc_cr_class
qc.measure(qr_anc, cr_anc)
qc.measure(qr_class, cr_class)
qc.draw("mpl")
backend = Aer.get_backend("qasm_simulator")
job = execute(qc, backend, shots=1e4, seed_simulator=42)
results = job.result()
counts = results.get_counts()
# filtering out measurements of ancila = |1> (last register)
keys = list(counts.keys()).copy()
for key in keys:
if key[-1] == "1":
counts.pop(key)
plot_histogram(counts, title="Results", figsize=(12, 4))
# theoretical probability of measuring class qubit in |0>, given ancilla was in |0>
(0.5)*((np.cos(np.pi/8))**2 + (np.cos(2*np.pi/8))**2)
# probability of measuring class qubit in |1>, given ancilla was in |0>
(0.5)*((np.cos(2*np.pi/8))**2 + (np.cos(3*np.pi/8))**2)
|
https://github.com/divyanshchoubisa/Quantum-Computing-Dynamic-Circuits
|
divyanshchoubisa
|
# Importing all the parts we need
from typing import List, Optional
from qiskit import transpile, QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.result import marginal_counts
import warnings
warnings.filterwarnings("ignore")
import math
pi = math.pi
# Preparing registers
quantum_register = QuantumRegister(127)
classical_register = ClassicalRegister(127)
# For simplicity we map the physical qubits to the logical qubits directly using the same number.
initial_layout = [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
53,
54,
55,
56,
57,
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
68,
69,
70,
71,
72,
73,
74,
75,
76,
77,
78,
79,
80,
81,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
92,
93,
94,
95,
96,
97,
98,
99,
100,
101,
102,
103,
104,
105,
106,
107,
108,
109,
110,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
121,
122,
123,
124,
125,
126,
]
# The "even"" qubits will be used for the 54 qubit GHZ-state
ghz_qubits = [
0,
2,
4,
6,
8,
10,
12,
18,
20,
22,
24,
26,
28,
30,
32,
37,
39,
41,
43,
45,
47,
49,
51,
56,
58,
60,
62,
64,
66,
68,
70,
75,
77,
79,
81,
83,
85,
87,
89,
94,
96,
98,
100,
102,
104,
106,
108,
114,
116,
118,
120,
122,
124,
126,
]
# The "odd" qubits will be used as the stabilizers
stabilizer_qubits = [
1,
3,
5,
7,
9,
11,
14,
15,
16,
17,
19,
21,
23,
25,
27,
29,
31,
33,
34,
35,
36,
38,
40,
42,
44,
46,
48,
50,
52,
53,
54,
55,
57,
59,
61,
63,
65,
67,
69,
71,
72,
73,
74,
76,
78,
80,
82,
84,
86,
88,
90,
91,
92,
93,
95,
97,
99,
101,
103,
105,
107,
109,
110,
111,
112,
115,
117,
119,
121,
123,
125,
]
def generate_ghz127():
qc = QuantumCircuit(quantum_register, classical_register)
####### your code goes here #######
qc.h(64)
qc.cx(64, 63)
qc.cx(63, 62)
qc.cx(64, 65)
qc.cx(62, 61)
qc.cx(64, 54)
qc.cx(65, 66)
qc.cx(61, 60)
qc.cx(62, 72)
qc.cx(54, 45)
qc.cx(66, 73)
qc.cx(60, 53)
qc.cx(72, 81)
qc.cx(45, 46)
qc.cx(66, 67)
qc.cx(73, 85)
qc.cx(53, 41)
qc.cx(60, 59)
qc.cx(81, 80)
qc.cx(46, 47)
qc.cx(45, 44)
qc.cx(67, 68)
qc.cx(85, 86)
qc.cx(41, 40)
qc.cx(59, 58)
qc.cx(44, 43)
qc.cx(47, 35)
qc.cx(68, 69)
qc.cx(80, 79)
qc.cx(81, 82)
qc.cx(85, 84)
qc.cx(86, 87)
qc.cx(43, 34)
qc.cx(40, 39)
qc.cx(41, 42)
qc.cx(58, 71)
qc.cx(79, 91)
qc.cx(82, 83)
qc.cx(35, 28)
qc.cx(47, 48)
qc.cx(68, 55)
qc.cx(69, 70)
qc.cx(87, 93)
qc.cx(39, 33)
qc.cx(34, 24)
qc.cx(28, 29)
qc.cx(48, 49)
qc.cx(58, 57)
qc.cx(71, 77)
qc.cx(79, 78)
qc.cx(91, 98)
qc.cx(83, 92)
qc.cx(93, 106)
qc.cx(87, 88)
qc.cx(70, 74)
qc.cx(33, 20)
qc.cx(24, 23)
qc.cx(28, 27)
qc.cx(29, 30)
qc.cx(39, 38)
qc.cx(49, 50)
qc.cx(57, 56)
qc.cx(77, 76)
qc.cx(88, 89)
qc.cx(98, 97)
qc.cx(92, 102)
qc.cx(106, 107)
qc.cx(20, 19)
qc.cx(23, 22)
qc.cx(27, 26)
qc.cx(30, 17)
qc.cx(38, 37)
qc.cx(50, 51)
qc.cx(56, 52)
qc.cx(76, 75)
qc.cx(97, 96)
qc.cx(102, 101)
qc.cx(106, 105)
qc.cx(107, 108)
qc.cx(17, 12)
qc.cx(19, 18)
qc.cx(20, 21)
qc.cx(24, 25)
qc.cx(22, 15)
qc.cx(26, 16)
qc.cx(30, 31)
qc.cx(51, 36)
qc.cx(75, 90)
qc.cx(96, 109)
qc.cx(98, 99)
qc.cx(101, 100)
qc.cx(102, 103)
qc.cx(105, 104)
qc.cx(108, 112)
qc.cx(12, 11)
qc.cx(15, 4)
qc.cx(16, 8)
qc.cx(18, 14)
qc.cx(31, 32)
qc.cx(90, 94)
qc.cx(96, 95)
qc.cx(100, 110)
qc.cx(104, 111)
qc.cx(109, 114)
qc.cx(112, 126)
qc.cx(4, 3)
qc.cx(8, 7)
qc.cx(11, 10)
qc.cx(12, 13)
qc.cx(14, 0)
qc.cx(110, 118)
qc.cx(111, 122)
qc.cx(114, 115)
qc.cx(126, 125)
qc.cx(0, 1)
qc.cx(3, 2)
qc.cx(4, 5)
qc.cx(7, 6)
qc.cx(10, 9)
qc.cx(114, 113)
qc.cx(115, 116)
qc.cx(118, 119)
qc.cx(122, 121)
qc.cx(125, 124)
qc.cx(116, 117)
qc.cx(119, 120)
qc.cx(122, 123)
#We can check if number of cx is equal to 124 and a single H gate and each one is targeted once only and only from a
#Qubit already in superposition
return qc
ghz_circuit = generate_ghz127()
print(ghz_circuit.depth())
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex5a
grade_ex5a(ghz_circuit)
def deentangle_qubits():
qc = QuantumCircuit(quantum_register, classical_register)
####### your code goes here #######
qc.cx(62, 63)
qc.cx(66, 65)
qc.cx(60, 61)
qc.cx(45, 54)
qc.cx(81, 72)
qc.cx(85, 73)
qc.cx(41, 53)
qc.cx(47, 46)
qc.cx(68, 67)
qc.cx(58, 59)
qc.cx(43, 44)
qc.cx(43, 42)
qc.cx(79, 80)
qc.cx(87, 86)
qc.cx(39, 40)
qc.cx(83, 82)
qc.cx(83, 84)
qc.cx(28, 35)
qc.cx(70, 69)
qc.cx(24, 34)
qc.cx(49, 48)
qc.cx(49, 55)
qc.cx(77, 71)
qc.cx(77, 78)
qc.cx(98, 91)
qc.cx(106, 93)
qc.cx(20, 33)
qc.cx(30, 29)
qc.cx(56, 57)
qc.cx(89, 88)
qc.cx(89, 74)
qc.cx(102, 92)
qc.cx(22, 23)
qc.cx(22, 21)
qc.cx(26, 27)
qc.cx(37, 38)
qc.cx(37, 52)
qc.cx(51, 50)
qc.cx(75, 76)
qc.cx(96, 97)
qc.cx(108, 107)
qc.cx(12, 17)
qc.cx(18, 19)
qc.cx(26, 25)
qc.cx(100, 101)
qc.cx(100, 99)
qc.cx(104, 105)
qc.cx(104, 103)
qc.cx(4, 15)
qc.cx(8, 16)
qc.cx(32, 31)
qc.cx(32, 36)
qc.cx(94, 90)
qc.cx(94, 95)
qc.cx(114, 109)
qc.cx(126, 112)
qc.cx(10, 11)
qc.cx(0, 14)
qc.cx(118, 110)
qc.cx(122, 111)
qc.cx(2, 3)
qc.cx(2, 1)
qc.cx(6, 7)
qc.cx(6, 5)
qc.cx(8, 9)
qc.cx(116, 115)
qc.cx(124, 125)
qc.cx(118, 117)
qc.cx(120, 119)
qc.cx(120, 121)
qc.cx(124, 123)
qc.cx(114, 113)
qc.cx(12, 13)
return qc
unentangle_circuit = deentangle_qubits()
print(unentangle_circuit.depth())
complete_circuit = ghz_circuit.compose(unentangle_circuit)
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex5b
grade_ex5b(complete_circuit)
# Measuring stabilizers this can also be used in post processing to see what went wrong.
def measure_stabilizers():
qc = QuantumCircuit(quantum_register, classical_register)
qc.measure(stabilizer_qubits, stabilizer_qubits)
return qc
stabilizer_circuit = measure_stabilizers()
# Measuring the GHZ qubits
def measure_ghz():
qc = QuantumCircuit(quantum_register, classical_register)
qc.measure(ghz_qubits, ghz_qubits)
return qc
measure_circuit = measure_ghz()
# Everything together
simple_ghz = (
ghz_circuit.compose(unentangle_circuit)
.compose(stabilizer_circuit)
.compose(measure_circuit)
)
# Importing provider and getting access to the system
from qiskit_ibm_provider import IBMProvider
from qiskit import transpile
provider = IBMProvider()
hub = "qc-spring-23-1"
group = "group-1"
project = "recIvcxUcc27LvvSh"
backend_name = "ibm_sherbrooke"
backend = provider.get_backend(backend_name, instance=f"{hub}/{group}/{project}")
number_of_shots: int = 1024
# First we transpile the GHZ-state for the actual device
qc_transpiled = transpile(simple_ghz, backend, initial_layout=initial_layout)
# Now we can run the job
# We add memory=true to be easier able to analyse how good the result were and the tags to make it easier to find it later.
job = backend.run(
qc_transpiled,
shots=number_of_shots,
memory=True,
job_tags=["ghz_state", "spring_challenge"],
)
job_id = job.job_id()
print(job_id)
# Change job id to the id of your previous submitted job something like "ch36cf1pleju56fajrqg"
# You only need to run this if you come back at a later time
job = provider.backend.retrieve_job(job_id)
job.status()
# Getting the data of the job for testing
data = job.result().get_memory()
# A function to test the quality of a GHZ-state. The lower the better
def test_ghz(data):
ghz_qubits = [
0,
2,
4,
6,
8,
10,
12,
18,
20,
22,
24,
26,
28,
30,
32,
37,
39,
41,
43,
45,
47,
49,
51,
56,
58,
60,
62,
64,
66,
68,
70,
75,
77,
79,
81,
83,
85,
81,
89,
94,
96,
98,
100,
102,
104,
106,
108,
114,
116,
118,
120,
122,
124,
126,
]
####### your code goes here #######
quality_list = []
average = 0
best = len(data)
worst = 0
for result in data:
count_zeroes = 0
count_ones = 0
bit_count = -1
for bit in result:
bit_count = bit_count + 1
if bit_count not in ghz_qubits:
continue
if bit == 0:
count_zeroes = count_zeroes + 1
else:
count_ones = count_ones + 1
if count_ones < count_zeroes:
count_zeroes = count_ones
quality_list.append(count_zeroes)
average = average + count_zeroes
if count_zeroes > worst:
worst = count_zeroes
if count_zeroes < best:
best = count_zeroes
average = average / len(data)
print(average)
print(worst)
print(best)
return average
test_ghz(data)
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex5c
# Since we test here a function, we do not need brackets after test_ghz, since the input is the function
grade_ex5c(test_ghz)
qc_transpiled.depth()
#qc_transpiled.draw()
# Simple idea for Example A find where the error happened and flip accordingly
def correct_ghz():
qc = QuantumCircuit(quantum_register, classical_register)
with qc.if_test((classical_register[9], 1)):
qc.x(quantum_register[9])
with qc.if_test((classical_register[8], 1)):
qc.x(quantum_register[8])
with qc.if_test((classical_register[8], 1)):
qc.x(quantum_register[9])
with qc.if_test((classical_register[7], 1)):
qc.x(quantum_register[9])
with qc.if_test((classical_register[7], 1)):
qc.x(quantum_register[8])
with qc.if_test((classical_register[7], 1)):
qc.x(quantum_register[7])
# ...
# qc.barrier()
return qc
correcting_circuit = correct_ghz()
# Everything together corrected
error_corrected_ghz = (
ghz_circuit.compose(unentangle_circuit)
.compose(stabilizer_circuit)
.compose(correcting_circuit)
.compose(measure_circuit)
)
from qiskit import qasm3, QuantumCircuit, transpile
# Creating a bell circuit
qc_bell = QuantumCircuit(2, 2)
qc_bell.h(0)
qc_bell.cx(0, 1)
qc_bell.measure(0, 0)
qc_bell.measure(0, 1)
# Transpiling it for our device (as above it does not have the H- and CX- Gates)
qc_bell = transpile(qc_bell, backend)
# Generate qasm3 code before we can print it
exporter = qasm3.Exporter(
includes=[], disable_constants=True, basis_gates=backend.configuration().basis_gates
)
print(qasm3_bell := exporter.dumps(qc_bell))
# Draw a circuit as comparison
qc_bell.draw(output="mpl", idle_wires=False)
# All the probabilities here only consider errors introduced by the CX gate and assumes they are bit flip errors.
# Probability for a single CX gate
p1 = 0.01
# Probability that there is an error after 2 CX gates (going through stabilizer)
p2 = p1 * (1 - p1) + (1 - p1) * p1
# Probability that the stabilizer shows something wrong even though it is correct
p3 = p1 * p1 + (1 - p1) * (1 - p1) * p1
print("Probability of a single cx having an error: {}".format(p1))
print("Probability of having an error after 2 cx: {:.4f}".format(p2))
print("Probability of the stabilizer showing a non existent error: {:.4f}".format(p3))
# First we transpile the GHZ-state for the actual device
qc_corrected_transpiled = transpile(
error_corrected_ghz, backend, initial_layout=initial_layout
)
# Now we can run the job
job_corrected = backend.run(
qc_corrected_transpiled,
dynamic=True,
shots=number_of_shots,
memory=True,
job_tags=["dynamic", "spring_challenge"],
)
job_id = job_corrected.job_id()
print(job_id)
job_corrected = provider.retrieve_job(job_id)
job_corrected.status()
# And get the results back
counts_corrected = job_corrected.result().get_counts()
|
https://github.com/divyanshchoubisa/Quantum-Computing-Dynamic-Circuits
|
divyanshchoubisa
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr)
####### your code goes here #######
qc.h(qr[0])
qc.measure(qr[0], cr[0])
qc.draw("mpl")
answer_0 = 2
#answer_0 = 500
print
##### Hint: Remember to run this cell after changing your value ###
# Grader Cell: Run this to submit your answer
from qc_grader.challenges.spring_2023 import grade_ex1a
grade_ex1a(answer_0)
from qiskit import QuantumCircuit
from qiskit.circuit import QuantumRegister, ClassicalRegister
qr = QuantumRegister(1)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr)
# unpack the qubit and classical bits from the registers
(q0,) = qr
b0, b1 = cr
# apply Hadamard
qc.h(q0)
# measure
qc.measure(q0, b0)
# begin if test block. the contents of the block are executed if b0 == 1
with qc.if_test((b0, 1)):
# if the condition is satisfied (b0 == 1), then flip the bit back to 0
qc.x(q0)
# finally, measure q0 again
qc.measure(q0, b1)
qc.draw(output="mpl", idle_wires=False)
from qiskit_aer import AerSimulator
# initialize the simulator
backend_sim = AerSimulator()
# run the circuit
reset_sim_job = backend_sim.run(qc)
# get the results
reset_sim_result = reset_sim_job.result()
# retrieve the bitstring counts
reset_sim_counts = reset_sim_result.get_counts()
print(f"Counts: {reset_sim_counts}")
from qiskit.visualization import *
# plot histogram
plot_histogram(reset_sim_counts)
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr)
q0, q1 = qr
b0, b1 = cr
qc.h(q0)
qc.measure(q0, b0)
####### your code goes here #######
with qc.if_test((b0, 0)) as else_:
qc.x(q1)
with else_:
qc.h(q1)
qc.measure(q1, b1)
qc.draw(output="mpl", idle_wires=False)
backend_sim = AerSimulator()
job_1 = backend_sim.run(qc)
result_1 = job_1.result()
counts_1 = result_1.get_counts()
print(f"Counts: {counts_1}")
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex1b
grade_ex1b(qc)
controls = QuantumRegister(2, name="control")
target = QuantumRegister(1, name="target")
mid_measure = ClassicalRegister(2, name="mid")
final_measure = ClassicalRegister(1, name="final")
base = QuantumCircuit(controls, target, mid_measure, final_measure)
def trial(
circuit: QuantumCircuit,
target: QuantumRegister,
controls: QuantumRegister,
measures: ClassicalRegister,
):
"""Probabilistically perform Rx(theta) on the target, where cos(theta) = 3/5."""
####### your code goes here #######
t = target
c0, c1 = controls
m0, m1 = measures
circuit.h(c0)
circuit.h(c1)
circuit.h(t)
circuit.ccx(c0, c1, t)
circuit.s(t)
circuit.ccx(c0, c1, t)
circuit.h(c0)
circuit.h(c1)
circuit.h(t)
circuit.measure(c0, m0)
circuit.measure(c1, m1)
qc = base.copy_empty_like()
trial(qc, target, controls, mid_measure)
qc.draw("mpl", cregbundle=False)
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex1c
grade_ex1c(qc)
def reset_controls(
circuit: QuantumCircuit, controls: QuantumRegister, measures: ClassicalRegister
):
"""Reset the control qubits if they are in |1>."""
c0, c1 = controls
m0, m1 = measures
####### your code goes here #######
with qc.if_test((m0, 1)):
circuit.x(c0)
with qc.if_test((m1, 1)):
circuit.x(c1)
qc = base.copy_empty_like()
trial(qc, target, controls, mid_measure)
reset_controls(qc, controls, mid_measure)
qc.measure(controls, mid_measure)
qc.draw("mpl", cregbundle=False)
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex1d
grade_ex1d(qc)
# Set the maximum number of trials
max_trials = 2
# Create a clean circuit with the same structure (bits, registers, etc)
# as the initial base we set up.
circuit = base.copy_empty_like()
qc = circuit
# The first trial does not need to reset its inputs, since the controls
# are guaranteed to start in the |0> state.
trial(qc, target, controls, mid_measure)
# Manually add the rest of the trials. In the future, we will be
# able to use a dynamic `while` loop to do this, but for now, we
# statically add each loop iteration with a manual condition check
# on each one. This involves more classical synchronizations than
# the while loop, but will suffice for now.
for _ in range(max_trials - 1):
reset_controls(qc, controls, mid_measure)
with qc.if_test((mid_measure, 0b00)) as else_:
# This is the success path, but Qiskit can't directly
# represent a negative condition yet, so we have an
# empty `true` block in order to use the `else` branch.
pass
with else_:
####### your code goes here #######
qc.x(target)
trial(qc, target, controls, mid_measure)
# We need to measure the control qubits again to ensure we
# get their final results; this is a hardware limitation.
qc.measure(controls, mid_measure)
# Finally, let's measure our target, to check that we're
# getting the rotation we desired.
qc.measure(target, final_measure)
qc.draw("mpl", cregbundle=False)
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex1e
grade_ex1e(circuit)
sim = AerSimulator()
job = sim.run(circuit, shots=1000)
result = job.result()
counts = result.get_counts()
plot_histogram(counts)
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
hub = "qc-spring-23-1"
group = "group-1"
project = "recIvcxUcc27LvvSh"
backend_name = "ibm_peekskill"
backend = provider.get_backend(backend_name, instance=f"{hub}/{group}/{project}")
from qiskit import transpile
qc_transpiled = transpile(circuit, backend)
job = backend.run(qc_transpiled, shots=1000, dynamic=True)
counts = job.result().get_counts()
plot_histogram(counts)
|
https://github.com/divyanshchoubisa/Quantum-Computing-Dynamic-Circuits
|
divyanshchoubisa
|
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np
def step_1_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# qr is a quantum register with 2 qubits
# cr is a classical register with 2 bits
qc = QuantumCircuit(qr, cr)
########## your code goes here #######
##1 Initialization
q0, q1 = qr
# apply Hadamard on the auxiliary qubit
qc.h(q0)
# put the system qubit into the |1> state
qc.x(q1)
##2 Apply control-U operator as many times as needed to get the least significant phase bit
# controlled-S is equivalent to CPhase with angle pi / 2
s_angle = np.pi / 2
# we want to apply controlled-S 2^k times
k = 1
# calculate the angle of CPhase corresponding to 2^k applications of controlled-S
cphase_angle = s_angle * 2**k
# apply the controlled phase gate
qc.cp(cphase_angle, q0, q1)
##3 Measure the auxiliary qubit in x-basis into the first classical bit
# apply Hadamard to change to the X basis
qc.h(q0)
# measure the auxiliary qubit into the first classical bit
c0, _ = cr
qc.measure(q0, c0)
return qc
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)
qc = step_1_circuit(qr, cr)
qc.draw("mpl")
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex3a
grade_ex3a(qc)
def step_2_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# qr is a quantum register with 2 qubits
# cr is a classical register with 2 bits
# begin with the circuit from Step 1
qc = step_1_circuit(qr, cr)
########## your code goes here #######
##1 Reset and re-initialize the auxiliary qubit
q0, q1 = qr
# reset the auxiliary qubit
qc.reset(q0)
# apply Hadamard on the auxiiliary qubit
qc.h(q0)
##2 Apply phase correction conditioned on the first classical bit
c0, c1 = cr
with qc.if_test((c0, 1)):
qc.p(-np.pi / 2, q0)
##3 Apply control-U operator as many times as needed to get the next phase bit
# controlled-S is equivalent to CPhase with angle pi / 2
s_angle = np.pi / 2
# we want to apply controlled-S 2^k times
k = 0
# calculate the angle of CPhase corresponding to 2^k applications of controlled-S
cphase_angle = s_angle * 2**k
# apply the controlled phase gate
qc.cp(cphase_angle, q0, q1)
##4 Measure the auxiliary qubit in x-basis into the second classical bit
# apply Hadamard to change to the X basis
qc.h(q0)
# measure the auxiliary qubit into the first classical bit
qc.measure(q0, c1)
return qc
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)
qc = step_2_circuit(qr, cr)
qc.draw("mpl")
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex3b
grade_ex3b(qc)
from qiskit_aer import AerSimulator
sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
counts
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np
def t_gate_ipe_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# qr is a quantum register with 2 qubits
# cr is a classical register with 3 bits
qc = QuantumCircuit(qr, cr)
########## your code goes here #######
# Initialization
q0, q1 = qr
qc.h(q0)
qc.x(q1)
# Apply control-U operator as many times as needed to get the least significant phase bit
t_angle = np.pi / 4
k = 2
cphase_angle = t_angle * 2**k
qc.cp(cphase_angle, q0, q1)
# Measure the auxiliary qubit in x-basis into the first classical bit
qc.h(q0)
c0, c1, c2 = cr
qc.measure(q0, c0)
# Reset and re-initialize the auxiliary qubit
qc.reset(q0)
qc.h(q0)
# Apply phase correction conditioned on the first classical bit
with qc.if_test((c0, 1)):
qc.p(-np.pi / 2, q0)
# Apply control-U operator as many times as needed to get the next phase bit
k = 1
cphase_angle = t_angle * 2**k
qc.cp(cphase_angle, q0, q1)
# Measure the auxiliary qubit in x-basis into the second classical bit
qc.h(q0)
qc.measure(q0, c1)
# Reset and re-initialize the auxiliary qubit
qc.reset(q0)
qc.h(q0)
# Apply phase correction conditioned on the first and second classical bits
with qc.if_test((c0, 1)):
qc.p(-np.pi / 4, q0)
with qc.if_test((c1, 1)):
qc.p(-np.pi / 2, q0)
# Apply control-U operator as many times as needed to get the next phase bit
k = 0
cphase_angle = t_angle * 2**k
qc.cp(cphase_angle, q0, q1)
# Measure the auxiliary qubit in x-basis into the third classical bit
qc.h(q0)
qc.measure(q0, c2)
return qc
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(3, "c")
qc = QuantumCircuit(qr, cr)
qc = t_gate_ipe_circuit(qr, cr)
qc.draw("mpl")
from qiskit_aer import AerSimulator
sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
counts
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex3c
grade_ex3c(qc)
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np
def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# qr is a quantum register with 2 qubits
# cr is a classical register with 2 bits
qc = QuantumCircuit(qr, cr)
# Initialization
q0, q1 = qr
qc.h(q0)
qc.x(q1)
# Apply control-U operator as many times as needed to get the least significant phase bit
u_angle = 2 * np.pi / 3
k = 1
cphase_angle = u_angle * 2**k
qc.cp(cphase_angle, q0, q1)
# Measure the auxiliary qubit in x-basis into the first classical bit
qc.h(q0)
c0, c1 = cr
qc.measure(q0, c0)
# Reset and re-initialize the auxiliary qubit
qc.reset(q0)
qc.h(q0)
# Apply phase correction conditioned on the first classical bit
with qc.if_test((c0, 1)):
qc.p(-np.pi / 2, q0)
# Apply control-U operator as many times as needed to get the next phase bit
k = 0
cphase_angle = u_angle * 2**k
qc.cp(cphase_angle, q0, q1)
# Measure the auxiliary qubit in x-basis into the second classical bit
qc.h(q0)
qc.measure(q0, c1)
return qc
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)
qc = u_circuit(qr, cr)
qc.draw("mpl")
from qiskit_aer import AerSimulator
sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
print(counts)
success_probability = counts["01"] / counts.shots()
print(f"Success probability: {success_probability}")
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np
def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# qr is a quantum register with 2 qubits
# cr is a classical register with 1 bits
qc = QuantumCircuit(qr, cr)
# Initialization
q0, q1 = qr
qc.h(q0)
qc.x(q1)
# Apply control-U operator as many times as needed to get the least significant phase bit
u_angle = 2 * np.pi / 3
k = 1
cphase_angle = u_angle * 2**k
qc.cp(cphase_angle, q0, q1)
# Measure the auxiliary qubit in x-basis
qc.h(q0)
(c0,) = cr
qc.measure(q0, c0)
return qc
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)
qc = u_circuit(qr, cr)
qc.draw("mpl")
job = sim.run(qc, shots=15)
result = job.result()
counts = result.get_counts()
print(counts)
step1_bit = 1
####### your code goes here #######
print(step1_bit)
# Submit your result
from qc_grader.challenges.spring_2023 import grade_ex3d
grade_ex3d(step1_bit)
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np
def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# qr is a quantum register with 2 qubits
# cr is a classical register with 2 bits
qc = QuantumCircuit(qr, cr)
########## your code goes here #######
# Initialization
q0, q1 = qr
if step1_bit:
qc.x(q0)
qc.x(q1)
# Measure the auxiliary qubit
c0, c1 = cr
qc.measure(q0, c0)
# Reset and re-initialize the auxiliary qubit
qc.reset(q0)
qc.h(q0)
# Apply phase correction conditioned on the first classical bit
with qc.if_test((c0, 1)):
qc.p(-np.pi / 2, q0)
# Apply control-U operator as many times as needed to get the next phase bit
u_angle = 2 * np.pi / 3
k = 0
cphase_angle = u_angle * 2**k
qc.cp(cphase_angle, q0, q1)
# Measure the auxiliary qubit in x-basis into the second classical bit
qc.h(q0)
qc.measure(q0, c1)
return qc
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)
qc = u_circuit(qr, cr)
qc.draw("mpl")
# Submit your result
from qc_grader.challenges.spring_2023 import grade_ex3e
grade_ex3e(qc)
from qiskit_aer import AerSimulator
sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
print(counts)
success_probability = counts["01"] / counts.shots()
print(f"Success probability: {success_probability}")
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
hub = "qc-spring-23-1"
group = "group-1"
project = "recIvcxUcc27LvvSh"
backend_name = "ibm_peekskill"
backend = provider.get_backend(backend_name, instance=f"{hub}/{group}/{project}")
from qiskit import transpile
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)
qc = step_2_circuit(qr, cr)
qc_transpiled = transpile(qc, backend)
job = backend.run(qc_transpiled, shots=1000, dynamic=True)
job_id = job.job_id()
print(job_id)
retrieve_job = provider.retrieve_job(job_id)
retrieve_job.status()
from qiskit.tools.visualization import plot_histogram
counts = retrieve_job.result().get_counts()
plot_histogram(counts)
|
https://github.com/divyanshchoubisa/Quantum-Computing-Dynamic-Circuits
|
divyanshchoubisa
|
# Importing all the parts we will need.
from typing import List, Optional
from qiskit import transpile, QuantumCircuit, QuantumRegister, ClassicalRegister, Aer
from qiskit.providers.fake_provider import FakeManilaV2
from qiskit.visualization import plot_histogram
import warnings
warnings.filterwarnings("ignore")
import math
pi = math.pi
# Probability for a 000 message to contain one error:
p1 = 0.10
# Calculating the probability of a message containing 2 or 3 errors:
p3 = 3 * p1 * p1 * (1 - p1) + p1 * p1 * p1
print("Percent chance the 000 message has one error: {}".format(p1 * 100))
print("Percent chance the 000 message has 2 or 3 errors: {:.4f}".format(p3 * 100))
# Creating a simple decoder for the classical case
def create_decoder(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# Expect a bit being encoded in the first 3 qubits and decode it into the 4th qubit
# Make sure values of the first 3 qubit stays the same
qc = QuantumCircuit(qr, cr)
q0, q1, q2, q3 = qr
(c0,) = cr
####### your code goes here #######
qc.ccx(q0, q1, q3)
qc.ccx(q1, q2, q3)
qc.ccx(q0, q2, q3)
return qc
# We expect a bit being encoded in the first 3 qubits and decode it into the 4th qubit
qr = QuantumRegister(4)
cr = ClassicalRegister(1)
q0, q1, q2, q3 = qr
# To encode a 1. Change them to test the other encodings.
encoder = QuantumCircuit(qr, cr)
encoder.x(q0)
encoder.x(q1)
encoder.x(q2)
decoder = create_decoder(qr, cr)
qc1 = encoder.compose(decoder)
qc1.draw("mpl")
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex4a
grade_ex4a(create_decoder(qr, cr))
# Setup a base quantum circuit for our experiments
encoding = QuantumRegister(3)
stabilizer = QuantumRegister(2)
encoding_q0, encoding_q1, encoding_q2 = encoding
stabilizer_q0, stabilizer_q1 = stabilizer
# Results of the encoding
results = ClassicalRegister(3)
result_b0, result_b1, result_b2 = results
# For measuring the stabilizer
syndrome = ClassicalRegister(2)
syndrome_b0, syndrome_b1 = syndrome
# The actual qubit which is encoded
state = encoding[0]
# The ancillas used for encoding the state
ancillas = encoding[1:]
# Initializing
def initialize_circuit() -> QuantumCircuit:
return QuantumCircuit(encoding, stabilizer, results, syndrome)
initial_state = initialize_circuit()
initial_state.x(encoding[0])
initial_state.draw(output="mpl")
# Encoding using bit flip code
def encode_bit_flip(qc, state, ancillas):
qc.barrier(state, *ancillas)
for ancilla in ancillas:
qc.cx(state, ancilla)
return qc
# The circuit encoding our qubit
encoding_circuit = encode_bit_flip(initialize_circuit(), state, ancillas)
# The circuit including all parts so far
complete_circuit = initial_state.compose(encoding_circuit)
complete_circuit.draw(output="mpl")
# Decoding (doing the reverse)
def decode_bit_flip(qc, state, ancillas):
qc.barrier(state, *ancillas)
for ancilla in ancillas:
qc.cx(state, ancilla)
return qc
decoding_circuit = decode_bit_flip(initialize_circuit(), state, ancillas)
decoding_circuit.draw(output="mpl")
# Add functions such that the classical bits can be used to see which qubit is flipped in the case a single qubit is flipped.
# Use 2 classical bits for it.
# 0 = 00 = no qubit flipped
# 1 = 01 = first qubit (qubit 0) flipped
# 2 = 10 second qubit (qubit 1) flipped
# 3 = 11 = third qubit (qubit 2) flipped
def measure_syndrome_bit(qc, encoding, stabilizer):
qc.barrier()
encoding_q0, encoding_q1, encoding_q2 = encoding
stabilizer_q0, stabilizer_q1 = stabilizer
####### your code goes here #######
qc.cx(encoding_q0, stabilizer_q0)
qc.cx(encoding_q1, stabilizer_q1)
qc.cx(encoding_q2, stabilizer_q0)
qc.cx(encoding_q2, stabilizer_q1)
####### don't edit the code below #######
qc.barrier()
qc.measure(stabilizer, syndrome)
with qc.if_test((syndrome_b0, 1)):
qc.x(stabilizer_q0)
with qc.if_test((syndrome_b1, 1)):
qc.x(stabilizer_q1)
return qc
syndrome_circuit = measure_syndrome_bit(initialize_circuit(), encoding, stabilizer)
complete_circuit = initial_state.compose(encoding_circuit).compose(syndrome_circuit)
complete_circuit.draw("mpl")
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex4b
grade_ex4b(complete_circuit)
# Correct the errors, remember how we encoded the errors above!
def apply_correction_bit(qc, encoding, syndrome):
qc.barrier()
encoding_q0, encoding_q1, encoding_q2 = encoding
####### your code goes here #######
#qc.x(encoding_q0).c_if(syndrome, 1)
#qc.x(encoding_q1).c_if(syndrome, 1)
#qc.x(encoding_q2).c_if(syndrome, 2)
with qc.if_test((syndrome, 0b11)): #3
qc.x(encoding_q2)
with qc.if_test((syndrome, 0b10)): #2
qc.x(encoding_q1)
with qc.if_test((syndrome, 0b01)): #1
qc.x(encoding_q0)
qc.barrier(encoding)
return qc
correction_circuit = apply_correction_bit(initialize_circuit(), encoding, syndrome)
complete_circuit = (
initial_state.compose(encoding_circuit)
.compose(syndrome_circuit)
.compose(correction_circuit)
)
complete_circuit.draw(output="mpl")
def apply_final_readout(qc, encoding, results):
qc.barrier(encoding)
qc.measure(encoding, results)
return qc
measuring_circuit = apply_final_readout(initialize_circuit(), encoding, results)
complete_circuit = (
initial_state.compose(encoding_circuit)
.compose(syndrome_circuit)
.compose(correction_circuit)
.compose(decoding_circuit)
.compose(measuring_circuit)
)
complete_circuit.draw(output="mpl")
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex4c
grade_ex4c(complete_circuit)
# We first choose a simulator as our backend without any noise
backend = Aer.get_backend("qasm_simulator")
# We run the simulation and get the counts
counts = backend.run(complete_circuit, shots=1000).result().get_counts()
# And now we plot a histogram to see the possible outcomes and corresponding probabilities
plot_histogram(counts)
# We choose a simulator for Manila a 5 qubit device, includes errors
backend = FakeManilaV2()
# We run the simulation and get the counts
counts = backend.run(complete_circuit, shots=1000).result().get_counts()
# We plot a histogram to see the possible outcomes and corresponding probabilities
plot_histogram(counts)
qc3 = (
initial_state.compose(encoding_circuit)
.compose(syndrome_circuit)
.compose(decoding_circuit)
.compose(measuring_circuit)
)
# We choose a again FakeManila
backend = FakeManilaV2()
# let the simulation run
counts = backend.run(qc3, shots=1000).result().get_counts()
# and plot our results
plot_histogram(counts)
# Add some errors as defined above (only add errors to the encoding qubits)
def make_some_noise(qc, encoding, syndrome, error_percentage):
encoding_q0, encoding_q1, encoding_q2 = encoding
syndrome_b0, syndrome_b1 = syndrome
error_angle = 2*math.asin(math.sqrt(error_percentage/100))
####### your code goes here #######
qc.rx(error_angle, encoding_q0)
qc.rx(error_angle, encoding_q1)
qc.rx(error_angle, encoding_q2)
return qc
# Constructing a circuit with 10% error rate (for each of the encoding qubit)
noise_circuit = make_some_noise(initialize_circuit(), encoding, syndrome, 10)
noise_circuit.draw(output="mpl")
# Submit your circuit
from qc_grader.challenges.spring_2023 import grade_ex4d
grade_ex4d(noise_circuit)
qc4 = (
initial_state.compose(encoding_circuit)
.compose(noise_circuit)
.compose(syndrome_circuit)
.compose(correction_circuit)
.compose(decoding_circuit)
.compose(measuring_circuit)
)
# We choose again FakeManila
backend = FakeManilaV2()
# let the simulation run
counts = backend.run(qc4, shots=1000).result().get_counts()
# and plot our results
plot_histogram(counts)
from qiskit.circuit import IfElseOp
# Fill in a better layout to test!!
initial_layout = [0, 1, 2, 3, 4]
# We use Manila as our potential backend, since it has the wanted layout
backend = FakeManilaV2()
# Temporary workaround for fake backends. For real backends this is not required.
backend.target.add_instruction(IfElseOp, name="if_else")
# And now we transpile the circuit for the backend.
qc_transpiled = transpile(complete_circuit, backend, initial_layout=initial_layout)
qc_transpiled.draw()
|
https://github.com/divyanshchoubisa/Quantum-Computing-Dynamic-Circuits
|
divyanshchoubisa
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, BasicAer, IBMQ
from qiskit.visualization import plot_histogram, plot_bloch_multivector
### Creating 3 qubit and 2 classical bits in each separate register
qr = QuantumRegister(3)
crz = ClassicalRegister(1)
crx = ClassicalRegister(1)
teleportation_circuit = QuantumCircuit(qr, crz, crx)
### A third party eve helps to create an entangled state
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a, b)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.draw()
def alice_gates(qc, a, b):
qc.cx(a, b)
qc.h(a)
teleportation_circuit.barrier()
alice_gates(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def measure_and_send(qc, a, b):
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
teleportation_circuit.barrier()
measure_and_send(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def bob_gates(qc, qubit, crz, crx):
qc.x(qubit).c_if(crx, 1)
qc.z(qubit).c_if(crz, 1)
teleportation_circuit.barrier()
bob_gates(teleportation_circuit, 2, crz, crx)
teleportation_circuit.draw()
from qiskit.extensions import Initialize
import math
qc = QuantumCircuit(1)
initial_state = [0,1]
init_gate = Initialize(initial_state)
# qc.append(initialize_qubit, [0])
qr = QuantumRegister(3) # Protocol uses 3 qubits
crz = ClassicalRegister(1) # and 2 classical registers
crx = ClassicalRegister(1)
qc = QuantumCircuit(qr, crz, crx)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
# Alice then sends her classical bits to Bob
measure_and_send(qc, 0, 1)
# Bob decodes qubits
bob_gates(qc, 2, crz, crx)
qc.draw()
backend = BasicAer.get_backend('statevector_simulator')
out_vector = execute(qc, backend).result().get_statevector()
plot_bloch_multivector(out_vector)
inverse_init_gate = init_gate.gates_to_uncompute()
qc.append(inverse_init_gate, [2])
qc.draw()
cr_result = ClassicalRegister(1)
qc.add_register(cr_result)
qc.measure(2,2)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
counts = execute(qc, backend, shots=1024).result().get_counts()
plot_histogram(counts)
def bob_gates(qc, a, b, c):
qc.cz(a, c)
qc.cx(b, c)
qc = QuantumCircuit(3,1)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
qc.barrier()
# Alice sends classical bits to Bob
bob_gates(qc, 0, 1, 2)
# We undo the initialisation process
qc.append(inverse_init_gate, [2])
# See the results, we only care about the state of qubit 2
qc.measure(2,0)
# View the results:
qc.draw()
from qiskit import IBMQ
IBMQ.save_account('### IMB TOKEN ')
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
from qiskit.providers.ibmq import least_busy
backend = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 3 and
not b.configuration().simulator and b.status().operational==True))
job_exp = execute(qc, backend=backend, shots=8192)
exp_result = job_exp.result()
exp_measurement_result = exp_result.get_counts(qc)
print(exp_measurement_result)
plot_histogram(exp_measurement_result)
error_rate_percent = sum([exp_measurement_result[result] for result in exp_measurement_result.keys() if result[0]=='1']) \
* 100./ sum(list(exp_measurement_result.values()))
print("The experimental error rate : ", error_rate_percent, "%")
|
https://github.com/electricalgorithm/BernsteinVaziraniAlgorithm
|
electricalgorithm
|
"""
This module implements the Bernstein-Vazirani Algorithm.
"""
from qiskit import Aer
from qiskit import QuantumCircuit, assemble, transpile
from qiskit.circuit.instruction import Instruction
class BVAlgorithm:
"""This class implements the Bernstein-Vazirani Algorithm."""
@staticmethod
def create_oracle_from_number(number: int) -> Instruction:
"""This method returns a Oracle block which will be used in
the Bernstein-Vazirani Algorithm.
Parameters
----------
number_str : str
The number in binary form as string.
Returns
-------
Instruction
Oracle block to be fed into the algorithm.
"""
# Convert the integer into binary string.
number_str = format(number, "b")
inputs_count = len(number_str)
# Create a quantum circuit with the number of input qubits + 1 output qubit.
oracle = QuantumCircuit(inputs_count + 1, inputs_count)
# Apply the CNOTs to the inputs as "1"s.
for index, qubit in enumerate(reversed(number_str)):
if qubit == "1":
oracle.cx(index, inputs_count)
inst = oracle.to_instruction()
inst.name = "SecretNumberOracle"
return inst
@staticmethod
def simulate(secret_number_oracle: Instruction) -> dict:
"""_summary_
Parameters
----------
secret_no_oracle : Instruction
The secret number to look for with the algoritm.
Returns
-------
dict
A dictionary with result attribute which is the found number.
"""
# Create the circuit.
circuit = BVAlgorithm._construct_the_circuit(secret_number_oracle)
# Run the simulation.
aer_sim = Aer.get_backend("aer_simulator")
transpiled_dj_circuit = transpile(circuit, aer_sim)
qobj = assemble(transpiled_dj_circuit)
results = aer_sim.run(qobj).result()
# Get the answer.
answer = results.get_counts()
answer_as_list = list(answer.keys())
answer_int = int(answer_as_list[0], 2)
return {"result": answer_int}
@staticmethod
def _construct_the_circuit(function_block: QuantumCircuit) -> QuantumCircuit:
"""It creates the circuit for the Bernstein-Vazirani Algorithm.
Parameters
----------
function_block : QuantumCircuit
The secret number block to check with the Bernstein-Vazirani Algorithm.
Returns
-------
QuantumCircuit
The circuit for the Bernstein-Vazirani Algorithm.
"""
# Get the number of input qubits.
input_length = function_block.num_qubits - 1
_circuit = QuantumCircuit(input_length + 1, input_length)
# Apply Hadamard gates to all input qubits.
for qubit in range(input_length):
_circuit.h(qubit)
# Convert the last qubit to |-) state.
_circuit.x(input_length)
_circuit.h(input_length)
_circuit.barrier()
# Apply the oracle block.
_circuit.append(
function_block,
range(function_block.num_qubits),
range(function_block.num_clbits),
)
_circuit.barrier()
# Apply Hadamard gates to all input qubits.
for qubit in range(input_length):
_circuit.h(qubit)
_circuit.barrier()
# Measure all input qubits and put them to classical bits.
for qubit in range(input_length):
_circuit.measure(qubit, qubit)
return _circuit
if __name__ == "__main__":
print("========================================")
print("Bernstein-Vazirani Algorithm Simulation")
print("========================================")
# Get the number of input qubits.
secret_number = int(input("> Enter the secret number to search for: "))
# Get the oracle block.
block_to_test = BVAlgorithm.create_oracle_from_number(secret_number)
# Run the algorithm.
result = BVAlgorithm.simulate(block_to_test)
print(f"Result: {result['result']}")
|
https://github.com/arnaucasau/Quantum-Computing-3SAT
|
arnaucasau
|
# imports
import math
# importing Qiskit
from qiskit import QuantumCircuit, Aer, assemble, transpile
from qiskit.visualization import plot_histogram
f = open("cnf_test1.txt")
info = f.readline().split(' ')
literals = int(info[0])
clausulas = int(info[1])
lines = [line.rstrip('\n') for line in f]
formula = []
for i in lines:
l = i.split(' ')
formula.append([int(l[0]),int(l[1]),int(l[2])])
n = literals + clausulas + 2 # Number of qubits in the circuit
def initialize_grover(qc, qubits):
# Superposition
for i in range(literals+1):
qc.h(qubits[i])
# State |-⟩
qc.x(n-1)
qc.h(n-1)
return qc
qc = QuantumCircuit(n)
# Creation of each clause.
contador = 0
for c in formula:
for i in range(3):
if c[i] > 0:
qc.x(abs(c[i])-1)
qc.mct(list([abs(c[0])-1,abs(c[1])-1,abs(c[2])-1]), literals+1+contador) # multi-controlled-toffoli
for i in range(3):
if c[2-i] > 0:
qc.x(abs(c[2-i])-1)
contador+=1
# Checking of each clause
qc.x(literals) # Augmented space
for q in range(literals+1,n-1):
qc.x(q)
qc.mct(list(list([literals, *range(literals+1,n-1)])), n-1)
for q in range(literals+1,n-1):
qc.x(q)
qc.x(literals) # Augmented space
# Creation of each clause (symmetry).
contador -= 1
for c in reversed(formula):
for i in range(3):
if c[i] > 0:
qc.x(abs(c[i])-1)
qc.mct(list([abs(c[0])-1,abs(c[1])-1,abs(c[2])-1]), literals+1+contador)
for i in range(3):
if c[2-i] > 0:
qc.x(abs(c[2-i])-1)
contador-=1
oracle = qc.to_gate()
oracle.name = "Oracle"
qc.draw()
qc = QuantumCircuit(n)
for qubit in range(literals+1):
qc.h(qubit)
for qubit in range(literals+1):
qc.x(qubit)
# Equivalent Diffuser. It gives us the opposite result in Quantum counting, therefore M will be the number of no solutions at the end.
qc.mct(list([i for i in range(literals+1)]), n-1)
########## Original Diffuser ##############################################################
#qc.mct(list([i for i in range(literals+1)]), literals+1)
#qc.x(literals+1)
#qc.cx(literals+1,n-1)
#qc.x(literals+1)
#qc.mct(list([i for i in range(literals+1)]), literals+1)
###########################################################################################
for qubit in range(literals+1):
qc.x(qubit)
for qubit in range(literals+1):
qc.h(qubit)
inversionMean = qc.to_gate()
inversionMean.name = "inversionMean"
qc.draw()
grover_iteration = QuantumCircuit(n)
grover_iteration.append(oracle, list(range(n)))
grover_iteration.append(inversionMean, list(range(n)))
gi = grover_iteration.to_gate()
gi.label = "GroverI"
cgi = gi.control()
def qft(n):
circuit = QuantumCircuit(n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft_rotations(circuit, n):
#Performs qft on the first n qubits in circuit (without swaps)
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(math.pi/2**(n-qubit), qubit, n)
qft_rotations(circuit, n)
qft_rotations(circuit, n)
swap_registers(circuit, n) # Comment this line if we use the 2 possible order of the QPE registers
return circuit
t = literals+1 # Number of counting qubits.
qft_dagger = qft(t).to_gate().inverse()
qft_dagger.label = "QFT†"
qpe = QuantumCircuit(n+t, t) # Circuit with n+t qubits and t classical bits
# Superposition
for qubit in range(t+literals+1):
qpe.h(qubit)
# State |-⟩
qpe.x(n+t-1)
qpe.h(n+t-1)
# Grover iterations
iterations = 1
for qubit in range(t):
for i in range(iterations):
qpe.append(cgi, [qubit] + [*range(t, n+t)]) # Using this line, uncomment the QFT swap.
#qpe.append(cgrit, [(t-1)-qubit] + [*range(t, n+t)]) # Using this line, comment the QFT swap.
iterations *= 2
# Application of QFT inverse to all counting qubits
qpe.append(qft_dagger, range(t))
# Measure the counting qubits
qpe.measure(range(t), range(t))
qpe.draw()
# Quantum counting sinulation
aer_sim = Aer.get_backend('aer_simulator')
transpiled_qpe = transpile(qpe, aer_sim)
qobj = assemble(transpiled_qpe)
job = aer_sim.run(qobj)
hist = job.result().get_counts()
plot_histogram(hist)
measured_str = max(hist, key=hist.get)
measured_int = int(measured_str,2)
print(measured_str)
print("Register Output = %i" % measured_int)
theta = (measured_int/(2**t))*math.pi*2
print("Theta = %.5f" % theta)
N = 2**(literals+1)
M = N * (math.sin(theta/2)**2)
M = N-M # Diffuser faster only
print(N,M)
print("No. of Solutions = %.1f" % M)
# Upper bound error for the number of solutions
m = t - 1
err = (math.sqrt(2*M*N) + N/(2**(m+1)))*(2**(-m))
print("Error < %.2f" % err)
rounds = math.pi/4.0*math.sqrt(N/M)
print("Result:",rounds)
print("Iterations R ≤",math.ceil(rounds))
if math.floor(rounds) == 0:
rounds = round(rounds)
else:
rounds = math.floor(rounds)
print("Iterations chosen:", rounds)
grover_circuit = QuantumCircuit(n,literals+1)
grover_circuit = initialize_grover(grover_circuit, list(range(n)))
for i in range(rounds):
grover_circuit.append(oracle, list(range(n)))
grover_circuit.append(inversionMean, list(range(n)))
for i in range(literals+1):
grover_circuit.measure([i],[i])
grover_circuit.draw()
# Grover's algorithm simulation
aer_sim = Aer.get_backend('aer_simulator')
transpiled_grover_circuit = transpile(grover_circuit, aer_sim)
qobj = assemble(transpiled_grover_circuit)
results = aer_sim.run(qobj, shots=1024).result()
counts = results.get_counts()
print("\nTotal count:",counts)
plot_histogram(counts,figsize=(12,5))
|
https://github.com/arnaucasau/Quantum-Computing-3SAT
|
arnaucasau
|
# imports
import math
# importing Qiskit
from qiskit import QuantumCircuit, Aer, assemble, transpile
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
f = open("cnf_test2.txt")
info = f.readline().split(' ')
n_var = int(info[0])
n_clause = int(info[1])
lines = [line.rstrip('\n') for line in f]
formula = []
for i in lines:
l = i.split(' ')
formula.append([int(l[0]),int(l[1]),int(l[2])])
n_qubits = n_var + 3*n_var*(2 + n_clause) + n_clause + 1
n_measures = 7*n_var
iters = 3*n_var
qc = QuantumCircuit(n_qubits)
for i in range(n_var):
qc.h(i)
ini = n_var+n_clause
theta = 2*math.acos(math.sqrt(2/3))
for i in range(iters):
qc.u(theta,0,0,ini)
qc.x(ini)
qc.ch(ini, ini+1)
qc.x(ini)
ini += 2+n_clause
qc.x(n_qubits-1)
qc.h(n_qubits-1)
initial = qc.to_gate()
initial.name = "Initialization"
qc.draw()
qc = QuantumCircuit(n_qubits)
for it in range(iters):
first_bit = n_var+(2+n_clause)*it+n_clause
first_clause = n_var+(2+n_clause)*it
nc = 0
for clause in formula:
control = list()
for lit in clause:
lit_aux = abs(lit)-1
if lit < 0:
qc.x(lit_aux)
control.append(lit_aux)
qc.mct(control,first_clause+nc)
for lit in clause:
if lit < 0:
lit_aux = abs(lit)-1
qc.x(lit_aux)
nc += 1
nc = 0
for clause in formula:
lit1 = abs(clause[0])-1
lit2 = abs(clause[1])-1
lit3 = abs(clause[2])-1
control = list()
control.append(first_bit)
control.append(first_bit+1)
control.append(first_clause+nc)
for n in range(nc):
control.append(first_clause+n)
qc.x(first_clause+n)
qc.x(first_bit)
qc.x(first_bit+1)
qc.mct(control,lit1)
qc.x(first_bit+1)
qc.x(first_bit)
qc.x(first_bit+1)
qc.mct(control,lit2)
qc.x(first_bit+1)
qc.x(first_bit)
qc.mct(control,lit3)
qc.x(first_bit)
for n in range(nc):
qc.x(first_clause+n)
nc += 1
nc = 0
for clause in formula:
control = list()
for lit in clause:
lit_aux = abs(lit)-1
if lit < 0:
qc.x(lit_aux)
control.append(lit_aux)
qc.mct(control,n_qubits-1-n_clause+nc)
for lit in clause:
if lit < 0:
lit_aux = abs(lit)-1
qc.x(lit_aux)
nc += 1
schoning_step = qc.to_gate()
schoning_step.name = "Schoning"
qc.draw(fold=10000)
qc = QuantumCircuit(n_qubits)
qc.append(schoning_step, list(range(n_qubits)))
control = list()
for nc in range(n_clause):
qc.x(n_qubits-1-n_clause+nc)
control.append(n_qubits-1-n_clause+nc)
qc.mct(control,n_qubits-1)
for nc in range(n_clause):
qc.x(n_qubits-1-n_clause+nc)
qc.append(schoning_step.inverse(), list(range(n_qubits)))
oracle = qc.to_gate()
oracle.name = "Oracle"
qc.draw()
qc = QuantumCircuit(n_qubits)
l = list()
aux = list()
ini = n_var
for i in range(iters):
for j in range(n_clause):
aux.append(ini+j)
ini += n_clause+2
for j in range(n_clause):
aux.append(ini+j)
for i in range(n_var):
qc.h(i)
qc.x(i)
l.append(i)
ini = n_var+n_clause
theta = 2*math.acos(math.sqrt(2/3))
for i in range(iters):
qc.x(ini)
qc.ch(ini, ini+1)
qc.x(ini)
qc.u(-theta,0,0,ini)
qc.x(ini)
qc.x(ini+1)
l.append(ini)
l.append(ini+1)
ini += 2+n_clause
#qc.mct(l,n_qubits-1)
original = l
total = len(l)
l2 = list()
i = 0
while total != 1:
for j in range(math.ceil(total/4)):
qc.mct(l[4*j:4*j+4],aux[i])
l2.append(aux[i])
i+=1
l = l2
total = len(l)
l2 = list()
diff_part1 = qc.to_gate()
diff_part1.name = "diff_part1"
qc.draw()
qc = QuantumCircuit(n_qubits)
qc.append(diff_part1, list(range(n_qubits)))
qc.mct(l,n_qubits-1)
qc.append(diff_part1.inverse(), list(range(n_qubits)))
diffuser = qc.to_gate()
diffuser.name = "Diffuser"
qc.draw()
rounds = math.pi/4.0*math.sqrt((4/3)**n_var)
print("Result:",rounds)
print("Iterations R ≤",math.ceil(rounds))
if math.floor(rounds) == 0:
rounds = round(rounds)
else:
rounds = math.floor(rounds)
print("Iterations chosen:", rounds)
qc = QuantumCircuit(n_qubits,n_measures)
qc.append(initial, list(range(n_qubits)))
for i in range(rounds):
qc.append(oracle, list(range(n_qubits)))
qc.append(diffuser, list(range(n_qubits)))
actual = 0
for i in range(n_var):
qc.measure([i],[i])
actual += 1
ini = n_var+n_clause
for i in range(iters):
qc.measure([ini],[actual])
qc.measure([ini+1],[actual+1])
ini += 2+n_clause
actual += 2
qc.draw()
# Select the AerSimulator from the Aer provider
simulator = AerSimulator(method='matrix_product_state')
#simulator = AerSimulator(method='statevector')
#simulator = AerSimulator(method='extended_stabilizer')
# Run and get counts, using the matrix_product_state method
tcirc = transpile(qc, simulator)
result = simulator.run(tcirc, shots=1).result()
print('This succeeded?: {}'.format(result.success))
counts = result.get_counts(0)
print(counts)
assig = list(next(iter(counts))[::-1][0:n_var])
steps = next(iter(counts))[::-1][n_var:]
print(assig)
print(steps)
def check_formula(formula, assig):
c = 0
for clause in formula:
lit1_pos = abs(clause[0])-1
lit2_pos = abs(clause[1])-1
lit3_pos = abs(clause[2])-1
total = 0
if (clause[0] < 0 and assig[lit1_pos] == '0') or (clause[0] > 0 and assig[lit1_pos] == '1'):
total += 1
if (clause[1] < 0 and assig[lit2_pos] == '0') or (clause[1] > 0 and assig[lit2_pos] == '1'):
total += 1
if (clause[2] < 0 and assig[lit3_pos] == '0') or (clause[2] > 0 and assig[lit3_pos] == '1'):
total += 1
if total == 0:
return (False,c)
c += 1
return (True,-1)
def schoning(formula,assig,steps,verbose=True):
n = len(assig)
if verbose:
print("initial guess","->",assig)
print("")
for i in range(3*n):
checking = check_formula(formula, assig)
if checking[0]:
return True
lit = int(steps[2*i])+2*int(steps[2*i+1])
var = abs(formula[checking[1]][lit])-1
if assig[var] == '0':
assig[var] = '1'
else:
assig[var] = '0'
if verbose:
print("iter",i+1,"->",assig)
return check_formula(formula, assig)[0]
schoning(formula,assig,steps)
simulator = AerSimulator(method='matrix_product_state')
tcirc = transpile(qc, simulator)
result = simulator.run(tcirc, shots=1024).result()
print('This succeeded?: {}'.format(result.success))
counts = result.get_counts(0)
total = 0
true = 0
for key in counts:
assig = list(key[::-1][0:n_var])
steps = key[::-1][n_var:]
r = schoning(formula,assig,steps,verbose=False)
if r:
true += counts[key]
total += counts[key]
print(true/total*100,"% of success")
|
https://github.com/sprynder/QuantumApproximationOptimizationAlgorithm
|
sprynder
|
#In case you don't have qiskit, install it now
%pip install qiskit --quiet
#Installing/upgrading pylatexenc seems to have fixed my mpl issue
#If you try this and it doesn't work, try also restarting the runtime/kernel
%pip install pylatexenc --quiet
!pip install -Uqq ipdb
!pip install qiskit_optimization
import networkx as nx
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import BasicAer
from qiskit.compiler import transpile
from qiskit.quantum_info.operators import Operator, Pauli
from qiskit.quantum_info import process_fidelity
from qiskit.extensions.hamiltonian_gate import HamiltonianGate
from qiskit.extensions import RXGate, XGate, CXGate
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, execute
import numpy as np
from qiskit.visualization import plot_histogram
import ipdb
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
#quadratic optimization
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
%pdb on
# def ApplyCost(qc, gamma):
# Ix = np.array([[1,0],[0,1]])
# Zx= np.array([[1,0],[0,-1]])
# Xx = np.array([[0,1],[1,0]])
# Temp = (Ix-Zx)/2
# T = Operator(Temp)
# I = Operator(Ix)
# Z = Operator(Zx)
# X = Operator(Xx)
# FinalOp=-2*(T^I^T)-(I^T^T)-(T^I^I)+2*(I^T^I)-3*(I^I^T)
# ham = HamiltonianGate(FinalOp,gamma)
# qc.append(ham,[0,1,2])
task = QuadraticProgram(name = 'QUBO on QC')
task.binary_var(name = 'x')
task.binary_var(name = 'y')
task.binary_var(name = 'z')
task.minimize(linear = {"x":-1,"y":2,"z":-3}, quadratic = {("x", "z"): -2, ("y", "z"): -1})
qubo = QuadraticProgramToQubo().convert(task) #convert to QUBO
operator, offset = qubo.to_ising()
print(operator)
# ham = HamiltonianGate(operator,0)
# print(ham)
Ix = np.array([[1,0],[0,1]])
Zx= np.array([[1,0],[0,-1]])
Xx = np.array([[0,1],[1,0]])
Temp = (Ix-Zx)/2
T = Operator(Temp)
I = Operator(Ix)
Z = Operator(Zx)
X = Operator(Xx)
FinalOp=-2*(T^I^T)-(I^T^T)-(T^I^I)+2*(I^T^I)-3*(I^I^T)
ham = HamiltonianGate(FinalOp,0)
print(ham)
#define PYBIND11_DETAILED_ERROR_MESSAGES
def compute_expectation(counts):
"""
Computes expectation value based on measurement results
Args:
counts: dict
key as bitstring, val as count
G: networkx graph
Returns:
avg: float
expectation value
"""
avg = 0
sum_count = 0
for bitstring, count in counts.items():
x = int(bitstring[2])
y = int(bitstring[1])
z = int(bitstring[0])
obj = -2*x*z-y*z-x+2*y-3*z
avg += obj * count
sum_count += count
return avg/sum_count
# We will also bring the different circuit components that
# build the qaoa circuit under a single function
def create_qaoa_circ(theta):
"""
Creates a parametrized qaoa circuit
Args:
G: networkx graph
theta: list
unitary parameters
Returns:
qc: qiskit circuit
"""
nqubits = 3
n,m=3,3
p = len(theta)//2 # number of alternating unitaries
qc = QuantumCircuit(nqubits,nqubits)
Ix = np.array([[1,0],[0,1]])
Zx= np.array([[1,0],[0,-1]])
Xx = np.array([[0,1],[1,0]])
Temp = (Ix-Zx)/2
T = Operator(Temp)
I = Operator(Ix)
Z = Operator(Zx)
X = Operator(Xx)
FinalOp=-2*(Z^I^Z)-(I^Z^Z)-(Z^I^I)+2*(I^Z^I)-3*(I^I^Z)
beta = theta[:p]
gamma = theta[p:]
# initial_state
for i in range(0, nqubits):
qc.h(i)
for irep in range(0, p):
#ipdb.set_trace(context=6)
# problem unitary
# for pair in list(G.edges()):
# qc.rzz(2 * gamma[irep], pair[0], pair[1])
#ApplyCost(qc,2*0)
ham = HamiltonianGate(operator,2 * gamma[irep])
qc.append(ham,[0,1,2])
# mixer unitary
for i in range(0, nqubits):
qc.rx(2 * beta[irep], i)
qc.measure(qc.qubits[:n],qc.clbits[:m])
return qc
# Finally we write a function that executes the circuit on the chosen backend
def get_expectation(shots=512):
"""
Runs parametrized circuit
Args:
G: networkx graph
p: int,
Number of repetitions of unitaries
"""
backend = Aer.get_backend('qasm_simulator')
backend.shots = shots
def execute_circ(theta):
qc = create_qaoa_circ(theta)
# ipdb.set_trace(context=6)
counts = {}
job = execute(qc, backend, shots=1024)
result = job.result()
counts=result.get_counts(qc)
return compute_expectation(counts)
return execute_circ
from scipy.optimize import minimize
expectation = get_expectation()
res = minimize(expectation, [1, 1], method='COBYLA')
expectation = get_expectation()
res = minimize(expectation, res.x, method='COBYLA')
res
from qiskit.visualization import plot_histogram
backend = Aer.get_backend('aer_simulator')
backend.shots = 512
qc_res = create_qaoa_circ(res.x)
backend = Aer.get_backend('qasm_simulator')
job = execute(qc_res, backend, shots=1024)
result = job.result()
counts=result.get_counts(qc_res)
plot_histogram(counts)
|
https://github.com/kosakhro/QAOA-for-exact-cover
|
kosakhro
|
from qiskit import *
from qiskit.visualization import plot_bloch_multivector
from qiskit.visualization import plot_histogram
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
IBMQ.load_account()
matplotlib inline
my_provider = IBMQ.get_provider()
my_provider.backends()
simulator = my_provider.get_backend('ibmq_5_yorktown')
# Making the quantum circuit
def circuitI(gamma, beta, J, h1, h2):
qc = QuantumCircuit(2, 2)
qc.h([0, 1])
qc.h(1)
qc.cz(0,1)
qc.rx(2*gamma*J, 1)
qc.cz(0,1)
qc.h(1)
qc.i(0)
qc.rz(2*gamma*h1, 0)
qc.rz(2*gamma*h2, 1)
qc.rx(2*beta, 0)
qc.rx(2*beta, 1)
qc.measure([0,1], [0,1])
return qc
# Initializing the variables for A.
J = 0.5
h1 = -0.5
h2 = 0
#Setting the dimesions of the pasephase. The amount of simulated points = n**2
n = 61
p = np.pi/(n-1)
res = np.zeros([n, n, 4])
# Running a simulation for each point
for i in range(n):
qc_list = []
gamma = i*p
for j in range(n):
beta = j*p
qc = circuitI(gamma, beta, J, h1, h2)
qc_list.append(qc)
transpiled_circs = transpile(qc_list, backend=simulator)
job = execute(transpiled_circs, backend = simulator, shots=1000 )
for circ_index in range(len(transpiled_circs)):
counts = job.result().get_counts(qc_list[circ_index])
res[i][circ_index][:] = np.array([int(counts.get('00', 0)), int(counts.get('01', 0)), int(counts.get('10', 0)),
int(counts.get('11', 0))])
print(res)
#Draw the current circuit
qc.draw(output='mpl')
transpiled_circs[0].draw(output='mpl')
# Making a heatmap plot
sns.heatmap(res[:, :, 2])
|
https://github.com/kosakhro/QAOA-for-exact-cover
|
kosakhro
|
from qiskit import *
from qiskit.visualization import plot_bloch_multivector
from qiskit.visualization import plot_histogram
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
IBMQ.load_account()
matplotlib inline
my_provider = IBMQ.get_provider()
my_provider.backends()
simulator = my_provider.get_backend('ibmq_5_yorktown')
# Making the quantum circuit
def circuitI(gamma, beta, J, h1, h2):
qc = QuantumCircuit(2, 2)
qc.h([0, 1])
qc.h(1)
qc.cz(0,1)
qc.rx(2*gamma*J, 1)
qc.cz(0,1)
qc.h(1)
qc.i(0)
qc.rz(2*gamma*h1, 0)
qc.rz(2*gamma*h2, 1)
qc.rx(2*beta, 0)
qc.rx(2*beta, 1)
qc.measure([0,1], [0,1])
return qc
# Initializing the variables for B.
J = 0
h1 = -1
h2 = 0
#Setting the dimesions of the pasephase. The amount of simulated points = n**2
n = 61
p = np.pi/(n-1)
res = np.zeros([n, n, 4])
# Running a simulation for each point
for i in range(n):
qc_list = []
gamma = i*p
for j in range(n):
beta = j*p
qc = circuitI(gamma, beta, J, h1, h2)
qc_list.append(qc)
transpiled_circs = transpile(qc_list, backend=simulator)
job = execute(transpiled_circs, backend = simulator, shots=1000 )
for circ_index in range(len(transpiled_circs)):
counts = job.result().get_counts(qc_list[circ_index])
res[i][circ_index][:] = np.array([int(counts.get('00', 0)), int(counts.get('01', 0)), int(counts.get('10', 0)),
int(counts.get('11', 0))])
print(res)
#Draw the current circuit
qc.draw(output='mpl')
transpiled_circs[0].draw(output='mpl')
# Making a heatmap plot
sns.heatmap(res[:, :, 1]+res[:, :, 3])
|
https://github.com/kosakhro/QAOA-for-exact-cover
|
kosakhro
|
from qiskit import *
from qiskit.visualization import plot_bloch_multivector
from qiskit.visualization import plot_histogram
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
IBMQ.load_account()
matplotlib inline
my_provider = IBMQ.get_provider()
my_provider.backends()
simulator = my_provider.get_backend('ibmq_5_yorktown')
# Making the quantum circuit
def circuitI(gamma, beta, J, h1, h2):
qc = QuantumCircuit(2, 2)
qc.h([0, 1])
qc.h(1)
qc.cz(0,1)
qc.rx(2*gamma*J, 1)
qc.cz(0,1)
qc.h(1)
qc.i(0)
qc.rz(2*gamma*h1, 0)
qc.rz(2*gamma*h2, 1)
qc.rx(2*beta, 0)
qc.rx(2*beta, 1)
qc.measure([0,1], [0,1])
return qc
# Initializing the variables for C.
J = 0
h1 = -0.5
h2 = -0.5
#Setting the dimesions of the pasephase. The amount of simulated points = n**2
n = 61
p = np.pi/(n-1)
res = np.zeros([n, n, 4])
# Running a simulation for each point
for i in range(n):
qc_list = []
gamma = i*p
for j in range(n):
beta = j*p
qc = circuitI(gamma, beta, J, h1, h2)
qc_list.append(qc)
transpiled_circs = transpile(qc_list, backend=simulator)
job = execute(transpiled_circs, backend = simulator, shots=1000 )
for circ_index in range(len(transpiled_circs)):
counts = job.result().get_counts(qc_list[circ_index])
res[i][circ_index][:] = np.array([int(counts.get('00', 0)), int(counts.get('01', 0)), int(counts.get('10', 0)),
int(counts.get('11', 0))])
print(res)
#Draw the current circuit
qc.draw(output='mpl')
transpiled_circs[0].draw(output='mpl')
# Making a heatmap plot
sns.heatmap(res[:, :, 3])
|
https://github.com/kosakhro/QAOA-for-exact-cover
|
kosakhro
|
from qiskit import *
from qiskit.visualization import plot_bloch_multivector
from qiskit.visualization import plot_histogram
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
IBMQ.load_account()
matplotlib inline
my_provider = IBMQ.get_provider()
my_provider.backends()
simulator = my_provider.get_backend('ibmq_5_yorktown')
# Making the quantum circuit
def circuitI(gamma, beta, J, h1, h2):
qc = QuantumCircuit(2, 2)
qc.h([0, 1])
qc.h(1)
qc.cz(0,1)
qc.rx(2*gamma*J, 1)
qc.cz(0,1)
qc.h(1)
qc.i(0)
qc.rz(2*gamma*h1, 0)
qc.rz(2*gamma*h2, 1)
qc.rx(2*beta, 0)
qc.rx(2*beta, 1)
qc.measure([0,1], [0,1])
return qc
# Initializing the variables for D.
J = 1
h1 = 0
h2 = 0
#Setting the dimesions of the pasephase. The amount of simulated points = n**2
n = 61
p = np.pi/(n-1)
res = np.zeros([n, n, 4])
# Running a simulation for each point
for i in range(n):
qc_list = []
gamma = i*p
for j in range(n):
beta = j*p
qc = circuitI(gamma, beta, J, h1, h2)
qc_list.append(qc)
transpiled_circs = transpile(qc_list, backend=simulator)
job = execute(transpiled_circs, backend = simulator, shots=1000 )
for circ_index in range(len(transpiled_circs)):
counts = job.result().get_counts(qc_list[circ_index])
res[i][circ_index][:] = np.array([int(counts.get('00', 0)), int(counts.get('01', 0)), int(counts.get('10', 0)),
int(counts.get('11', 0))])
print(res)
#Draw the current circuit
qc.draw(output='mpl')
transpiled_circs[0].draw(output='mpl')
# Making a heatmap plot
sns.heatmap(res[:, :, 1]+res[:, :, 2])
|
https://github.com/kosakhro/QAOA-for-exact-cover
|
kosakhro
| |
https://github.com/kosakhro/QAOA-for-exact-cover
|
kosakhro
|
# -*- coding: utf-8 -*-
"""
Created on Wed Dec 16 20:22:29 2020
@author: Arttu Huikuri
"""
from qiskit import *
from qiskit.visualization import plot_bloch_multivector
from qiskit.visualization import plot_histogram
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Making the quantum circuit
def circuitI(gamma, beta, J, h1, h2):
qc = QuantumCircuit(2, 2)
qc.h([0, 1])
qc.h(1)
qc.cz(0,1)
qc.rx(2*gamma*J, 1)
qc.cz(0,1)
qc.h(1)
qc.i(0)
qc.rz(2*gamma*h1, 0)
qc.rz(2*gamma*h2, 1)
qc.rx(2*beta, 0)
qc.rx(2*beta, 1)
qc.measure([0,1], [0,1])
return qc
simulator = Aer.get_backend('qasm_simulator')
# Initializing the variables
h1 = 0
h2 = 0
J = 1
#Setting the dimesions of the pasephase. The amount of simulated points = n**2
n = 61
p = np.pi/(n-1)
res = np.zeros([n, n, 4])
# Running a simulation for each point
for i in range(n):
gamma = i*p
for j in range(n):
beta = j*p
qc = circuitI(gamma, beta, J, h1, h2)
counts = execute(qc, backend = simulator, shots=1000).result().get_counts()
res[i][j][:] = np.array([int(counts.get('00', 0)), int(counts.get('01', 0)), int(counts.get('10', 0)),
int(counts.get('11', 0))])
# Making the heatmap plots
sns.heatmap(res[:, :, 0])
plt.xlabel('\u03B2, [0,\u03C0]')
plt.ylabel('\u03B3, [0,\u03C0]')
plt.title('00')
plt.figure(2)
sns.heatmap(res[:, :, 1])
plt.xlabel('\u03B2, [0,\u03C0]')
plt.ylabel('\u03B3, [0,\u03C0]')
plt.title('01')
plt.figure(3)
sns.heatmap(res[:, :, 2])
plt.xlabel('\u03B2, [0,\u03C0]')
plt.ylabel('\u03B3, [0,\u03C0]')
plt.title('10')
plt.figure(4)
sns.heatmap(res[:, :, 3])
plt.xlabel('\u03B2, [0,\u03C0]')
plt.ylabel('\u03B3, [0,\u03C0]')
plt.title('11')
plt.figure(5)
sns.heatmap(res[:, :, 2]+ res[:, :, 1])
plt.xlabel('\u03B2, [0,\u03C0]')
plt.ylabel('\u03B3, [0,\u03C0]')
plt.title('11 + 01')
|
https://github.com/kosakhro/QAOA-for-exact-cover
|
kosakhro
|
from qiskit import *
from qiskit.visualization import plot_bloch_multivector
from qiskit.visualization import plot_histogram
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
IBMQ.load_account()
matplotlib inline
simulator = Aer.get_backend('qasm_simulator')
# Making the quantum circuit
def circuitI(gamma, beta, J, h1, h2):
qc = QuantumCircuit(2, 2)
qc.h([0, 1])
qc.h(1)
qc.cz(0,1)
qc.rx(2*gamma*J, 1)
qc.cz(0,1)
qc.h(1)
qc.i(0)
qc.rz(2*gamma*h1, 0)
qc.rz(2*gamma*h2, 1)
qc.rx(2*beta, 0)
qc.rx(2*beta, 1)
qc.measure([0,1], [0,1])
return qc
# Initializing the variables for A.
J = 0.5
h1 = -0.5
h2 = 0
#Setting the dimesions of the pasephase. The amount of simulated points = n**2
n = 61
p = np.pi/(n-1)
resA = np.zeros([n, n, 4])
qc_list = []
# Running a simulation for each point
for i in range(n):
gamma = i*p
for j in range(n):
beta = j*p
qc = circuitI(gamma, beta, J, h1, h2)
counts = execute(qc, backend = simulator, shots=1000).result().get_counts()
resA[i][j][:] = np.array([int(counts.get('00', 0)), int(counts.get('01', 0)), int(counts.get('10', 0)),
int(counts.get('11', 0))])
#Draw the current circuit
qc.draw(output='mpl')
# Making a heatmap plot
sns.heatmap(resA[:, :, 0]*0 + resA[:, :, 1] + resA[:, :, 2]*0 + resA[:, :, 3]*0 )
# Initializing the variables for B.
J = 0
h1 = -1
h2 = 0
#Setting the dimesions of the pasephase. The amount of simulated points = n**2
n = 61
p = np.pi/(n-1)
resB = np.zeros([n, n, 4])
# Running a simulation for each point
for i in range(n):
gamma = i*p
for j in range(n):
beta = j*p
qc = circuitI(gamma, beta, J, h1, h2)
counts = execute(qc, backend = simulator, shots=1000).result().get_counts()
resB[i][j][:] = np.array([int(counts.get('00', 0)), int(counts.get('01', 0)), int(counts.get('10', 0)),
int(counts.get('11', 0))])
#Draw the current circuit
qc.draw(output='mpl')
# Making a heatmap plot
sns.heatmap(resB[:, :, 0]*0 + resB[:, :, 1] + resB[:, :, 2]*0 + resB[:, :, 3] )
# Initializing the variables for C.
J = 0
h1 = -0.5
h2 = -0.5
#Setting the dimesions of the pasephase. The amount of simulated points = n**2
n = 61
p = np.pi/(n-1)
resC = np.zeros([n, n, 4])
# Running a simulation for each point
for i in range(n):
gamma = i*p
for j in range(n):
beta = j*p
qc = circuitI(gamma, beta, J, h1, h2)
counts = execute(qc, backend = simulator, shots=1000).result().get_counts()
resC[i][j][:] = np.array([int(counts.get('00', 0)), int(counts.get('01', 0)), int(counts.get('10', 0)),
int(counts.get('11', 0))])
#Draw the current circuit
qc.draw(output='mpl')
# Making a heatmap plot
sns.heatmap(resC[:, :, 3])
# Initializing the variables for D.
J = 1
h1 = 0
h2 = 0
#Setting the dimesions of the pasephase. The amount of simulated points = n**2
n = 61
p = np.pi/(n-1)
resD = np.zeros([n, n, 4])
# Running a simulation for each point
for i in range(n):
gamma = i*p
for j in range(n):
beta = j*p
qc = circuitI(gamma, beta, J, h1, h2)
counts = execute(qc, backend = simulator, shots=1000).result().get_counts()
resD[i][j][:] = np.array([int(counts.get('00', 0)), int(counts.get('01', 0)), int(counts.get('10', 0)),
int(counts.get('11', 0))])
#Draw the current circuit
qc.draw(output='mpl')
# Making a heatmap plot
sns.heatmap(resD[:, :, 0]*0 + resD[:, :, 1] + resD[:, :, 2] + resD[:, :, 3] *0 )
|
https://github.com/albertnieto/mucomcu04
|
albertnieto
|
%%capture
%pip install qiskit
%pip install qiskit_ibm_provider
%pip install qiskit-aer
# Importing standard Qiskit libraries
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, QuantumCircuit, transpile, Aer
from qiskit_ibm_provider import IBMProvider
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.circuit.library import C3XGate
# Importing matplotlib
import matplotlib.pyplot as plt
# Importing Numpy, Cmath and math
import numpy as np
import os, math, cmath
from numpy import pi
# Other imports
from IPython.display import display, Math, Latex
# Specify the path to your env file
env_file_path = 'config.env'
# Load environment variables from the file
os.environ.update(line.strip().split('=', 1) for line in open(env_file_path) if '=' in line and not line.startswith('#'))
# Load IBM Provider API KEY
IBMP_API_KEY = os.environ.get('IBMP_API_KEY')
# Loading your IBM Quantum account(s)
IBMProvider.save_account(IBMP_API_KEY, overwrite=True)
# Run the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')
qc_b1 = QuantumCircuit(2, 2)
qc_b1.h(0)
qc_b1.cx(0, 1)
qc_b1.draw(output='mpl', style="iqp")
sv = backend.run(qc_b1).result().get_statevector()
sv.draw(output='latex', prefix = "|\Phi^+\\rangle = ")
qc_b2 = QuantumCircuit(2, 2)
qc_b2.x(0)
qc_b2.h(0)
qc_b2.cx(0, 1)
qc_b2.draw(output='mpl', style="iqp")
sv = backend.run(qc_b2).result().get_statevector()
sv.draw(output='latex', prefix = "|\Phi^-\\rangle = ")
qc_b2 = QuantumCircuit(2, 2)
qc_b2.h(0)
qc_b2.cx(0, 1)
qc_b2.z(0)
qc_b2.draw(output='mpl', style="iqp")
sv = backend.run(qc_b2).result().get_statevector()
sv.draw(output='latex', prefix = "|\Phi^-\\rangle = ")
qc_b3 = QuantumCircuit(2, 2)
qc_b3.x(1)
qc_b3.h(0)
qc_b3.cx(0, 1)
qc_b3.draw(output='mpl', style="iqp")
sv = backend.run(qc_b3).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^+\\rangle = ")
qc_b3 = QuantumCircuit(2, 2)
qc_b3.h(0)
qc_b3.cx(0, 1)
qc_b3.x(0)
qc_b3.draw(output='mpl', style="iqp")
sv = backend.run(qc_b3).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^+\\rangle = ")
qc_b4 = QuantumCircuit(2, 2)
qc_b4.x(0)
qc_b4.h(0)
qc_b4.x(1)
qc_b4.cx(0, 1)
qc_b4.draw(output='mpl', style="iqp")
sv = backend.run(qc_b4).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^-\\rangle = ")
qc_b4 = QuantumCircuit(2, 2)
qc_b4.h(0)
qc_b4.cx(0, 1)
qc_b4.x(0)
qc_b4.z(1)
qc_b4.draw(output='mpl', style="iqp")
sv = backend.run(qc_b4).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^-\\rangle = ")
def sv_latex_from_qc(qc, backend):
sv = backend.run(qc).result().get_statevector()
return sv.draw(output='latex')
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(1)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(1)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(1)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(3)
sv_latex_from_qc(qc_ej2, backend)
def circuit_adder (num):
if num<1 or num>8:
raise ValueError("Out of range") ## El enunciado limita el sumador a los valores entre 1 y 8. Quitar esta restricción sería directo.
# Definición del circuito base que vamos a construir
qreg_q = QuantumRegister(4, 'q')
creg_c = ClassicalRegister(1, 'c')
circuit = QuantumCircuit(qreg_q, creg_c)
qbit_position = 0
for element in reversed(np.binary_repr(num)):
if (element=='1'):
circuit.barrier()
match qbit_position:
case 0: # +1
circuit.append(C3XGate(), [qreg_q[0], qreg_q[1], qreg_q[2], qreg_q[3]])
circuit.ccx(qreg_q[0], qreg_q[1], qreg_q[2])
circuit.cx(qreg_q[0], qreg_q[1])
circuit.x(qreg_q[0])
case 1: # +2
circuit.ccx(qreg_q[1], qreg_q[2], qreg_q[3])
circuit.cx(qreg_q[1], qreg_q[2])
circuit.x(qreg_q[1])
case 2: # +4
circuit.cx(qreg_q[2], qreg_q[3])
circuit.x(qreg_q[2])
case 3: # +8
circuit.x(qreg_q[3])
qbit_position+=1
return circuit
add_3 = circuit_adder(3)
add_3.draw(output='mpl', style="iqp")
qc_test_2 = QuantumCircuit(4, 4)
qc_test_2.x(1)
qc_test_2_plus_3 = qc_test_2.compose(add_3)
qc_test_2_plus_3.draw(output='mpl', style="iqp")
sv_latex_from_qc(qc_test_2_plus_3, backend)
qc_test_7 = QuantumCircuit(4, 4)
qc_test_7.x(0)
qc_test_7.x(1)
qc_test_7.x(2)
qc_test_7_plus_8 = qc_test_7.compose(circuit_adder(8))
sv_latex_from_qc(qc_test_7_plus_8, backend)
#qc_test_7_plus_8.draw()
theta = 6.544985
phi = 2.338741
lmbda = 0
alice_1 = 0
alice_2 = 1
bob_1 = 2
qr_alice = QuantumRegister(2, 'Alice')
qr_bob = QuantumRegister(1, 'Bob')
cr = ClassicalRegister(3, 'c')
qc_ej3 = QuantumCircuit(qr_alice, qr_bob, cr)
qc_ej3.barrier(label='1')
qc_ej3.u(theta, phi, lmbda, alice_1);
qc_ej3.barrier(label='2')
qc_ej3.h(alice_2)
qc_ej3.cx(alice_2, bob_1);
qc_ej3.barrier(label='3')
qc_ej3.cx(alice_1, alice_2)
qc_ej3.h(alice_1);
qc_ej3.barrier(label='4')
qc_ej3.measure([alice_1, alice_2], [alice_1, alice_2]);
qc_ej3.barrier(label='5')
qc_ej3.x(bob_1).c_if(alice_2, 1)
qc_ej3.z(bob_1).c_if(alice_1, 1)
qc_ej3.measure(bob_1, bob_1);
qc_ej3.draw(output='mpl', style="iqp")
result = backend.run(qc_ej3, shots=1024).result()
counts = result.get_counts()
plot_histogram(counts)
sv_0 = np.array([1, 0])
sv_1 = np.array([0, 1])
def find_symbolic_representation(value, symbolic_constants={1/np.sqrt(2): '1/√2'}, tolerance=1e-10):
"""
Check if the given numerical value corresponds to a symbolic constant within a specified tolerance.
Parameters:
- value (float): The numerical value to check.
- symbolic_constants (dict): A dictionary mapping numerical values to their symbolic representations.
Defaults to {1/np.sqrt(2): '1/√2'}.
- tolerance (float): Tolerance for comparing values with symbolic constants. Defaults to 1e-10.
Returns:
str or float: If a match is found, returns the symbolic representation as a string
(prefixed with '-' if the value is negative); otherwise, returns the original value.
"""
for constant, symbol in symbolic_constants.items():
if np.isclose(abs(value), constant, atol=tolerance):
return symbol if value >= 0 else '-' + symbol
return value
def array_to_dirac_notation(array, tolerance=1e-10):
"""
Convert a complex-valued array representing a quantum state in superposition
to Dirac notation.
Parameters:
- array (numpy.ndarray): The complex-valued array representing
the quantum state in superposition.
- tolerance (float): Tolerance for considering amplitudes as negligible.
Returns:
str: The Dirac notation representation of the quantum state.
"""
# Ensure the statevector is normalized
array = array / np.linalg.norm(array)
# Get the number of qubits
num_qubits = int(np.log2(len(array)))
# Find indices where amplitude is not negligible
non_zero_indices = np.where(np.abs(array) > tolerance)[0]
# Generate Dirac notation terms
terms = [
(find_symbolic_representation(array[i]), format(i, f"0{num_qubits}b"))
for i in non_zero_indices
]
# Format Dirac notation
dirac_notation = " + ".join([f"{amplitude}|{binary_rep}⟩" for amplitude, binary_rep in terms])
return dirac_notation
def array_to_matrix_representation(array):
"""
Convert a one-dimensional array to a column matrix representation.
Parameters:
- array (numpy.ndarray): The one-dimensional array to be converted.
Returns:
numpy.ndarray: The column matrix representation of the input array.
"""
# Replace symbolic constants with their representations
matrix_representation = np.array([find_symbolic_representation(value) or value for value in array])
# Return the column matrix representation
return matrix_representation.reshape((len(matrix_representation), 1))
def array_to_dirac_and_matrix_latex(array):
"""
Generate LaTeX code for displaying both the matrix representation and Dirac notation
of a quantum state.
Parameters:
- array (numpy.ndarray): The complex-valued array representing the quantum state.
Returns:
Latex: A Latex object containing LaTeX code for displaying both representations.
"""
matrix_representation = array_to_matrix_representation(array)
latex = "Matrix representation\n\\begin{bmatrix}\n" + \
"\\\\\n".join(map(str, matrix_representation.flatten())) + \
"\n\\end{bmatrix}\n"
latex += f'Dirac Notation:\n{array_to_dirac_notation(array)}'
return Latex(latex)
sv_b1 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b1)
sv_b1 = (np.kron(sv_0, sv_0) + np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b1)
sv_b1 = (np.kron(sv_0, sv_0) + np.kron(sv_1, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b1)
sv_b2 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b2 = (np.kron(sv_0, sv_0) + np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b2 = (np.kron(sv_0, sv_0) + np.kron(sv_1, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b2 = (np.kron(sv_0, sv_0) - np.kron(sv_1, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b3 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = np.kron(sv_0, sv_1)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = (np.kron(sv_0, sv_0) - np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = (np.kron(sv_0, sv_1) - np.kron(sv_1, sv_0)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = (np.kron(sv_0, sv_1) + np.kron(sv_1, sv_0)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b4 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b4)
sv_b4 = np.kron(sv_0, sv_1)
array_to_dirac_and_matrix_latex(sv_b4)
sv_b4 = (np.kron(sv_0, sv_0) - np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b4)
sv_b4 = (np.kron(sv_0, sv_1) - np.kron(sv_1, sv_0)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b4)
|
https://github.com/sohrabganjian/Quantum-Information-Science
|
sohrabganjian
|
import random
from qiskit import QuantumCircuit, QuantumRegister, execute, Aer
from qiskit.extensions import UnitaryGate
import numpy as np
# Generate a random bit
random_bit = random.randint(0, 1)
# Print the random bit
print(random_bit)
# Charlie to Alice bit
CA = random.randint(0, 1)
# Charlie to Bob bit
CB = random.randint(0, 1)
print(CA,CB)
# Alice to Charlie bit
AC = 0
# Bob to Charlie bit
BC = 0
# Charlie checks
(CA and CB) == (AC or BC)
classical_wins = 0
number_of_rounds = 10000
for i in range(number_of_rounds):
CA = random.randint(0, 1)
CB = random.randint(0, 1)
AC, BC = 0, 0
if (CA and CB) == (AC or BC):
classical_wins += 1
print(classical_wins/number_of_rounds)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
# qc.measure(0,0)
# Measure both qubits and store the results in classical registers
qc.measure([0, 1], [0, 1])
# Execute the circuit on a simulator backend
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=10)
result = job.result()
# Get the counts of each measurement outcome
counts = result.get_counts(qc)
print(counts)
CA, CB = 0,0
# Create a quantum circuit with two qubits and two classical registers
qc = QuantumCircuit(2, 2)
# Prepare an entangled state of the two qubits
qc.h(0)
qc.cx(0,1)
# Apply Alice's measurement
if CA == 1:
qc.h(0)
Bob_0_unitary = np.array([[np.cos(np.pi/8), np.sin(np.pi/8)], [-np.sin(np.pi/8), np.cos(np.pi/8)]])
Bob_1_unitary = np.array(
[[np.cos(np.pi/8), -np.sin(np.pi/8)],[np.sin(np.pi/8), np.cos(np.pi/8)]]
)
if CB == 0:
qc.unitary(Bob_0_unitary, [1])
if CB == 1:
qc.unitary(Bob_1_unitary, [1])
# Measure both qubits in the computational basis
qc.measure([0, 1], [0, 1])
qc.draw('mpl')
def CHSH_strategy(CA, CB):
# Create a quantum circuit with two qubits and two classical registers
qc = QuantumCircuit(2, 2)
# Prepare an entangled state of the two qubits
qc.h(0)
qc.cx(0,1)
# Apply Alice's measurement
if CA == 1:
qc.h(0)
Bob_0_unitary = np.array([[np.cos(np.pi/8), np.sin(np.pi/8)], [-np.sin(np.pi/8), np.cos(np.pi/8)]])
Bob_1_unitary = np.array(
[[np.cos(np.pi/8), -np.sin(np.pi/8)],[np.sin(np.pi/8), np.cos(np.pi/8)]]
)
if CB == 0:
qc.unitary(Bob_0_unitary, [1])
if CB == 1:
qc.unitary(Bob_1_unitary, [1])
# Measure both qubits in the computational basis
qc.measure([0, 1], [0, 1])
drawing = qc.draw('mpl')
# Execute the circuit on a simulator backend
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1)
result = job.result()
# Get the counts of each measurement outcome
counts = result.get_counts(qc)
# Compute the XOR of the keys
xor_values = [int(k[0]) ^ int(k[1]) for k in counts.keys()]
return xor_values[0]
# Test the CHSH strategy
quantum_wins = 0
number_of_rounds = 100
for i in range(number_of_rounds):
CA = random.randint(0, 1)
CB = random.randint(0, 1)
output_bit = CHSH_strategy(CA,CB)
if (CA and CB) == output_bit:
quantum_wins += 1
print(quantum_wins/number_of_rounds)
|
https://github.com/sohrabganjian/Quantum-Information-Science
|
sohrabganjian
|
from qiskit import QuantumCircuit, QuantumRegister
# approach 1:
qr = QuantumRegister(1) # QuantumRegister(1) would output QuantumRegister(1, 'q0')
qr
QuantumCircuit(qr)
type(QuantumCircuit(qr))
QuantumCircuit(qr).draw() # better than nothing - but it looks empty for now as we are
# applying any gates to it
QuantumCircuit(1).draw() # this has the same effect
QuantumCircuit(1,1).draw()
# Create a quantum register with one qubit
qr = QuantumRegister(1)
# Create a quantum circuit with the quantum register
circuit = QuantumCircuit(qr)
# Apply the X gate to the first qubit
circuit.x(qr[0])
# Draw the circuit
circuit.draw('mpl') # what does mpl do?
# mpl: images with color rendered purely in Python using matplotlib.
qc = QuantumCircuit(1,0)
qc.x(0)
qc.draw('mpl')
qc = QuantumCircuit(1,1) # adding a classical bit
qc.x(0)
qc.draw('mpl')
qc = QuantumCircuit(1)
qc.y(0)
qc.draw('mpl')
qc = QuantumCircuit(1)
qc.z(0)
qc.draw('mpl')
qc = QuantumCircuit(2,0)
qc.draw()
qc.h(0)
qc.draw()
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
qc.draw('mpl')
from qiskit.visualization import plot_bloch_vector, visualize_transition
from math import sqrt, pi
coords = [1,pi/2,0] # [Radius, Theta, Phi]
plot_bloch_vector(coords, coord_type='spherical')
qc = QuantumCircuit(1)
qc.y(0)
qc.h(0)
qc.z(0)
qc.draw('mpl')
## Takes 30s # uncomment to run
# %%time ## takes a long time to run this cell, about 30 seconds!
# ## it creates a useful animation that shows the effect of quantum gates over time
# visualize_transition(qc)
|
https://github.com/ratansahu05/Quantum-Computing-and-Programming
|
ratansahu05
|
from qiskit import QuantumCircuit
from qiskit.tools.visualization import circuit_drawer
import numpy as np
from matplotlib import pyplot as plt
n=5
qc = QuantumCircuit(n)
qc.x(1)
qc.ccx(0, 1, 3)
qc.ccx(2, 3, 4)
qc.ccx(0, 1, 3)
qc.x(1)
qc.draw('mpl')
def phase_oracle(n, name = 'Uf'):
qc = QuantumCircuit(n, name = name)
qc.x(1)
qc.ccx(0, 1, 3)
qc.ccx(2, 3, 4)
qc.ccx(0, 1, 3)
qc.x(1)
return qc
n=5
qc = QuantumCircuit(n)
for i in range(n-2):
qc.x(i)
qc.ccx(0, 1, 3)
qc.ccx(2, 3, 4)
qc.ccx(0, 1, 3)
for i in range(n-2):
qc.x(i)
qc.draw('mpl')
def diffuser(n, name= 'V'):
qc = QuantumCircuit(n, name =name)
for qb in range(n-2): # First layer of Hadamards in diffuser
qc.h(qb)
for i in range(n-2):
qc.x(i)
qc.ccx(0, 1, 3)
qc.ccx(2, 3, 4)
qc.ccx(0, 1, 3)
for i in range(n-2):
qc.x(i)
for qb in range(n-2): # Second layer of Hadamards in diffuser
qc.h(qb)
return qc
n=5
gr = QuantumCircuit(n, n-2)
mu = 1 #number of solutions
r = int(np.floor(np.pi/4*np.sqrt(2**(n-2)/mu))) #determine r
print('r = ',r)
gr.h(range(n-2)) #step1: apply Hadamard gates on all working qubits
#put ancilla in state |->
gr.x(n-1)
gr.h(n-1)
#step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr.append(phase_oracle(n), range(n))
gr.append(diffuser(n), range(n))
gr.measure(range(n-2), range(n-2)) #step 3: measure all qubits
gr.draw('mpl')
from qiskit import BasicAer, Aer, execute, IBMQ
from qiskit.visualization import plot_histogram
simulator = Aer.get_backend('qasm_simulator')
result = execute(gr, backend = simulator, shots = 1024).result()
counts = result.get_counts()
plot_histogram(counts)
from qiskit import IBMQ
IBMQ.save_account('e19ab1a54fb68a1937a725b48b02eafb8af0db9189107e78762686e5bf12dff5642e1597470d966ea9d2e121cc86f4a0f08bea5d5e760de66c7be7be04fd2974')
IBMQ.load_account()
provider = IBMQ.get_provider(hub = 'ibm-q')
device = provider.get_backend('ibmq_qasm_simulator')
job = execute(gr, backend=device, shots=1024)
print(job.job_id())
from qiskit.tools.monitor import job_monitor
job_monitor(job)
device_result = job.result()
plot_histogram(device_result.get_counts(gr))
|
https://github.com/ratansahu05/Quantum-Computing-and-Programming
|
ratansahu05
|
import matplotlib.pyplot as plt
import numpy as np
from sklearn.svm import SVC
from sklearn.cluster import SpectralClustering
from sklearn.metrics import normalized_mutual_info_score
from qiskit import BasicAer
from qiskit.circuit.library import ZZFeatureMap
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit_machine_learning.algorithms import QSVC
from qiskit_machine_learning.kernels import QuantumKernel
from qiskit_machine_learning.datasets import ad_hoc_data
seed = 12345
algorithm_globals.random_seed = seed
adhoc_dimension = 2
train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(
training_size=20,
test_size=5,
n=adhoc_dimension,
gap=0.3,
plot_data=False,
one_hot=False,
include_sample_total=True,
)
plt.figure(figsize=(5, 5))
plt.ylim(0, 2 * np.pi)
plt.xlim(0, 2 * np.pi)
plt.imshow(
np.asmatrix(adhoc_total).T,
interpolation="nearest",
origin="lower",
cmap="RdBu",
extent=[0, 2 * np.pi, 0, 2 * np.pi],
)
plt.scatter(
train_features[np.where(train_labels[:] == 0), 0],
train_features[np.where(train_labels[:] == 0), 1],
marker="s",
facecolors="w",
edgecolors="b",
label="A train",
)
plt.scatter(
train_features[np.where(train_labels[:] == 1), 0],
train_features[np.where(train_labels[:] == 1), 1],
marker="o",
facecolors="w",
edgecolors="r",
label="B train",
)
plt.scatter(
test_features[np.where(test_labels[:] == 0), 0],
test_features[np.where(test_labels[:] == 0), 1],
marker="s",
facecolors="b",
edgecolors="w",
label="A test",
)
plt.scatter(
test_features[np.where(test_labels[:] == 1), 0],
test_features[np.where(test_labels[:] == 1), 1],
marker="o",
facecolors="r",
edgecolors="w",
label="B test",
)
plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
plt.title("Ad hoc dataset for classification")
plt.show()
adhoc_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement="linear")
adhoc_backend = QuantumInstance(
BasicAer.get_backend("qasm_simulator"), shots=1024, seed_simulator=seed, seed_transpiler=seed
)
adhoc_kernel = QuantumKernel(feature_map=adhoc_feature_map, quantum_instance=adhoc_backend)
adhoc_svc = SVC(kernel=adhoc_kernel.evaluate)
adhoc_svc.fit(train_features, train_labels)
adhoc_score = adhoc_svc.score(test_features, test_labels)
print(f"Callable kernel classification test score: {adhoc_score}")
adhoc_matrix_train = adhoc_kernel.evaluate(x_vec=train_features)
adhoc_matrix_test = adhoc_kernel.evaluate(x_vec=test_features, y_vec=train_features)
fig, axs = plt.subplots(1, 2, figsize=(10, 5))
axs[0].imshow(
np.asmatrix(adhoc_matrix_train), interpolation="nearest", origin="upper", cmap="Blues"
)
axs[0].set_title("Ad hoc training kernel matrix")
axs[1].imshow(np.asmatrix(adhoc_matrix_test), interpolation="nearest", origin="upper", cmap="Reds")
axs[1].set_title("Ad hoc testing kernel matrix")
plt.show()
adhoc_svc = SVC(kernel="precomputed")
adhoc_svc.fit(adhoc_matrix_train, train_labels)
adhoc_score = adhoc_svc.score(adhoc_matrix_test, test_labels)
print(f"Precomputed kernel classification test score: {adhoc_score}")
qsvc = QSVC(quantum_kernel=adhoc_kernel)
qsvc.fit(train_features, train_labels)
qsvc_score = qsvc.score(test_features, test_labels)
print(f"QSVC classification test score: {qsvc_score}")
|
https://github.com/ratansahu05/Quantum-Computing-and-Programming
|
ratansahu05
|
from qiskit import QuantumCircuit, execute, Aer, BasicAer
from qiskit.visualization import plot_histogram
import numpy as np
n=6
p=int(n/2)
bs='111'
so1 = QuantumCircuit(n)
for i in range(p):
so1.cx(i,i+p)
k=0
for i in range(p-1,-1,-1):
if bs[i]=='1':
m=p
for j in range(p-1,-1,-1):
print(j,i)
if bs[j]=='1':
so1.cx(k,m)
m+=1
break
k+=1
so1.draw('mpl')
n=6
p=int(n/2)
bs='001'
so2 = QuantumCircuit(n)
for i in range(p):
so2.cx(i,i+p)
k=0
for i in range(p-1,-1,-1):
if bs[i]=='1':
so2.x(k)
m=p
for j in range(p-1,-1,-1):
print(j,i)
if bs[j]=='1':
so2.cx(k,m)
m+=1
so2.x(k)
break
k+=1
so2.draw('mpl')
simon = QuantumCircuit(n,p)
# Apply H-gates
for qubit in range(p):
simon.h(qubit)
simon.barrier()
# Add oracle
simon=simon+so2
simon.barrier()
# Repeat H-gates
for qubit in range(p):
simon.h(qubit)
simon.barrier()
# Measure
for i in range(p):
simon.measure(i, i)
# Display circuit
simon.draw('mpl')
# use local simulator
simulator = BasicAer.get_backend('qasm_simulator')
shots = 5000
noisy_results = execute(simon, backend=simulator, shots=shots).result()
noisy_counts = noisy_results.get_counts()
plot_histogram(noisy_counts)
|
https://github.com/tanvipenumudy/Quantum-Computing-Mini-Projects
|
tanvipenumudy
|
pip install qiskit
from qiskit.aqua.algorithms import Shor
from qiskit.aqua import QuantumInstance
from qiskit import Aer
key = 21
base = 2
backend = Aer.get_backend('qasm_simulator')
qi = QuantumInstance(backend=backend, shots=18240)
shors = Shor(N=key, a=base, quantum_instance = qi)
results = shors.run()
print(results['factors'])
|
https://github.com/tanvipenumudy/Quantum-Computing-Mini-Projects
|
tanvipenumudy
|
pip install qiskit
import numpy as np
import matplotlib.pyplot as plt
import torch
from torch.autograd import Function
from torchvision import datasets, transforms
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
import qiskit
from qiskit.visualization import *
class QuantumCircuit:
"""
This class provides a simple interface for interaction
with the quantum circuit
"""
def __init__(self, n_qubits, backend, shots):
# --- Circuit definition ---
self._circuit = qiskit.QuantumCircuit(n_qubits)
all_qubits = [i for i in range(n_qubits)]
self.theta = qiskit.circuit.Parameter('theta')
self._circuit.h(all_qubits)
self._circuit.barrier()
self._circuit.ry(self.theta, all_qubits)
self._circuit.measure_all()
# ---------------------------
self.backend = backend
self.shots = shots
def run(self, thetas):
job = qiskit.execute(self._circuit,
self.backend,
shots = self.shots,
parameter_binds = [{self.theta: theta} for theta in thetas])
result = job.result().get_counts(self._circuit)
counts = np.array(list(result.values()))
states = np.array(list(result.keys())).astype(float)
# Compute probabilities for each state
probabilities = counts / self.shots
# Get state expectation
expectation = np.sum(states * probabilities)
return np.array([expectation])
simulator = qiskit.Aer.get_backend('qasm_simulator')
circuit = QuantumCircuit(1, simulator, 100)
print('Expected value for rotation pi {}'.format(circuit.run([np.pi])[0]))
circuit._circuit.draw()
class HybridFunction(Function):
""" Hybrid quantum - classical function definition """
@staticmethod
def forward(ctx, input, quantum_circuit, shift):
""" Forward pass computation """
ctx.shift = shift
ctx.quantum_circuit = quantum_circuit
expectation_z = ctx.quantum_circuit.run(input[0].tolist())
result = torch.tensor([expectation_z])
ctx.save_for_backward(input, result)
return result
@staticmethod
def backward(ctx, grad_output):
""" Backward pass computation """
input, expectation_z = ctx.saved_tensors
input_list = np.array(input.tolist())
shift_right = input_list + np.ones(input_list.shape) * ctx.shift
shift_left = input_list - np.ones(input_list.shape) * ctx.shift
gradients = []
for i in range(len(input_list)):
expectation_right = ctx.quantum_circuit.run(shift_right[i])
expectation_left = ctx.quantum_circuit.run(shift_left[i])
gradient = torch.tensor([expectation_right]) - torch.tensor([expectation_left])
gradients.append(gradient)
gradients = np.array([gradients]).T
return torch.tensor([gradients]).float() * grad_output.float(), None, None
class Hybrid(nn.Module):
""" Hybrid quantum - classical layer definition """
def __init__(self, backend, shots, shift):
super(Hybrid, self).__init__()
self.quantum_circuit = QuantumCircuit(1, backend, shots)
self.shift = shift
def forward(self, input):
return HybridFunction.apply(input, self.quantum_circuit, self.shift)
# Concentrating on the first 100 samples
n_samples = 100
X_train = datasets.MNIST(root='./data', train=True, download=True,
transform=transforms.Compose([transforms.ToTensor()]))
# Leaving only labels 0 and 1
idx = np.append(np.where(X_train.targets == 0)[0][:n_samples],
np.where(X_train.targets == 1)[0][:n_samples])
X_train.data = X_train.data[idx]
X_train.targets = X_train.targets[idx]
train_loader = torch.utils.data.DataLoader(X_train, batch_size=1, shuffle=True)
n_samples_show = 6
data_iter = iter(train_loader)
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 3))
while n_samples_show > 0:
images, targets = data_iter.__next__()
axes[n_samples_show - 1].imshow(images[0].numpy().squeeze(), cmap='gray')
axes[n_samples_show - 1].set_xticks([])
axes[n_samples_show - 1].set_yticks([])
axes[n_samples_show - 1].set_title("Labeled: {}".format(targets.item()))
n_samples_show -= 1
n_samples = 50
X_test = datasets.MNIST(root='./data', train=False, download=True,
transform=transforms.Compose([transforms.ToTensor()]))
idx = np.append(np.where(X_test.targets == 0)[0][:n_samples],
np.where(X_test.targets == 1)[0][:n_samples])
X_test.data = X_test.data[idx]
X_test.targets = X_test.targets[idx]
test_loader = torch.utils.data.DataLoader(X_test, batch_size=1, shuffle=True)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 6, kernel_size=5)
self.conv2 = nn.Conv2d(6, 16, kernel_size=5)
self.dropout = nn.Dropout2d()
self.fc1 = nn.Linear(256, 64)
self.fc2 = nn.Linear(64, 1)
self.hybrid = Hybrid(qiskit.Aer.get_backend('qasm_simulator'), 100, np.pi / 2)
def forward(self, x):
x = F.relu(self.conv1(x))
x = F.max_pool2d(x, 2)
x = F.relu(self.conv2(x))
x = F.max_pool2d(x, 2)
x = self.dropout(x)
x = x.view(1, -1)
x = F.relu(self.fc1(x))
x = self.fc2(x)
x = self.hybrid(x)
return torch.cat((x, 1 - x), -1)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 20
loss_list = []
model.train()
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
loss = loss_func(output, target)
# Backward pass
loss.backward()
# Optimize the weights
optimizer.step()
total_loss.append(loss.item())
loss_list.append(sum(total_loss)/len(total_loss))
print('Training [{:.0f}%]\tLoss: {:.4f}'.format(
100. * (epoch + 1) / epochs, loss_list[-1]))
plt.plot(loss_list)
plt.title('Hybrid NN Training Convergence')
plt.xlabel('Training Iterations')
plt.ylabel('Neg Log Likelihood Loss')
model.eval()
with torch.no_grad():
correct = 0
for batch_idx, (data, target) in enumerate(test_loader):
output = model(data)
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
loss = loss_func(output, target)
total_loss.append(loss.item())
print('Performance on test data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
n_samples_show = 6
count = 0
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 3))
model.eval()
with torch.no_grad():
for batch_idx, (data, target) in enumerate(test_loader):
if count == n_samples_show:
break
output = model(data)
pred = output.argmax(dim=1, keepdim=True)
axes[count].imshow(data[0].numpy().squeeze(), cmap='gray')
axes[count].set_xticks([])
axes[count].set_yticks([])
axes[count].set_title('Predicted {}'.format(pred.item()))
count += 1
|
https://github.com/JayRGopal/Quantum-Error-Correction
|
JayRGopal
|
from qiskit import *
from oracle_generation import generate_oracle
get_bin = lambda x, n: format(x, 'b').zfill(n)
def gen_circuits(min,max,size):
circuits = []
secrets = []
ORACLE_SIZE = size
for i in range(min,max+1):
cur_str = get_bin(i,ORACLE_SIZE-1)
(circuit, secret) = generate_oracle(ORACLE_SIZE,False,3,cur_str)
circuits.append(circuit)
secrets.append(secret)
return (circuits, secrets)
|
https://github.com/JayRGopal/Quantum-Error-Correction
|
JayRGopal
|
from qiskit import *
from qiskit.tools.monitor import job_monitor
from qiskit.providers.ibmq import least_busy
import random
from oracle_generation import validate_oracle
def run_on_simulator(circuit, expected):
simulator = Aer.get_backend('qasm_simulator')
COUNT = 1024
results = execute(circuit, backend = simulator, shots=COUNT).result()
validate_oracle(results,expected,COUNT)
return results
def run_on_QC(circuits, secrets, qubit_cnt, ibm_computer = ""):
COUNT = 10000
if not account_loaded:
load_account()
provider = IBMQ.get_provider(hub = 'ibm-q')
# print(provider.backends())
small_devices = provider.backends(filters=lambda x: x.configuration().n_qubits == qubit_cnt
and not x.configuration().simulator)
device = least_busy(small_devices)
if ibm_computer != "":
device = provider.get_backend(ibm_computer)
current_jobs = device.active_jobs()
job_cnt = len(current_jobs)
# print(job_cnt)
# print(device.remaining_jobs_count())
print("running %d jobs..."%(len(circuits)))
if (len(circuits) > device.remaining_jobs_count()):
print("Too many jobs to handle (limit of %d)... Getting status of older jobs"%(device.remaining_jobs_count()))
print("%d of the inputted circuits will not be run until older jobs are finished"%(len(circuits) - device.remaining_jobs_count()))
while len(circuits) > 0:
# load up to limit of jobs
if (device.remaining_jobs_count() == 0): break
circuit = circuits.pop(0)
secret_key = secrets.pop(0)
# print(secret_key)
cur_job = execute(circuit,backend = device,shots = COUNT)
cur_job.update_tags(replacement_tags=[secret_key])
job_cnt+=1
current_jobs = device.active_jobs()
current_jobs.reverse()
res = []
for i in range(job_cnt):
print("JOB %d"%(i))
cur_job = current_jobs[i]
job_monitor(cur_job)
results = cur_job
res.append(results)
if len(circuits) > 0:
circuit = circuits.pop(0)
secret_key = secrets.pop(0)
extra_job = execute(circuit,backend = device,shots = COUNT)
extra_job.update_tags(replacement_tags=[secret_key])
current_jobs.append(extra_job)
job_cnt+=1
return res
|
https://github.com/JayRGopal/Quantum-Error-Correction
|
JayRGopal
|
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/JayRGopal/Quantum-Error-Correction
|
JayRGopal
|
import numpy as np
import networkx as nx
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, assemble
from qiskit.quantum_info import Statevector
from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.extensions.snapshot_statevector import *
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
import matplotlib.pyplot as plt
LAMBDA = 10
SEED = 10
SHOTS = 10000
# returns the bit index for an alpha and j
def bit(i_city, l_time, num_cities):
return i_city * num_cities + l_time
# e^(cZZ)
def append_zz_term(qc, q_i, q_j, gamma, constant_term):
qc.cx(q_i, q_j)
qc.rz(2*gamma*constant_term,q_j)
qc.cx(q_i, q_j)
# e^(cZ)
def append_z_term(qc, q_i, gamma, constant_term):
qc.rz(2*gamma*constant_term, q_i)
# e^(cX)
def append_x_term(qc,qi,beta):
qc.rx(-2*beta, qi)
def get_not_edge_in(G):
N = G.number_of_nodes()
not_edge = []
for i in range(N):
for j in range(N):
if i != j:
buffer_tupla = (i,j)
in_edges = False
for edge_i, edge_j in G.edges():
if ( buffer_tupla == (edge_i, edge_j) or buffer_tupla == (edge_j, edge_i)):
in_edges = True
if in_edges == False:
not_edge.append((i, j))
return not_edge
def get_classical_simplified_z_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# z term #
z_classic_term = [0] * N**2
# first term
for l in range(N):
for i in range(N):
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += -1 * _lambda
# second term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_jl
z_jl_index = bit(j, l, N)
z_classic_term[z_jl_index] += _lambda / 2
# third term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_ij
z_ij_index = bit(i, j, N)
z_classic_term[z_ij_index] += _lambda / 2
# fourth term
not_edge = get_not_edge_in(G) # include order tuples ej = (1,0), (0,1)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 4
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
z_classic_term[z_jlplus_index] += _lambda / 4
# fifthy term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
z_classic_term[z_il_index] += weight_ij / 4
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
z_classic_term[z_il_index] += weight_ji / 4
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ji / 4
return z_classic_term
def tsp_obj_2(x, G,_lambda):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
not_edge = get_not_edge_in(G)
N = G.number_of_nodes()
tsp_cost=0
#Distancia
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# x_il
x_il_index = bit(edge_i, l, N)
# x_jlplus
l_plus = (l+1) % N
x_jlplus_index = bit(edge_j, l_plus, N)
tsp_cost+= int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ij
# add order term because G.edges() do not include order tuples #
# x_i'l
x_il_index = bit(edge_j, l, N)
# x_j'lplus
x_jlplus_index = bit(edge_i, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ji
#Constraint 1
for l in range(N):
penal1 = 1
for i in range(N):
x_il_index = bit(i, l, N)
penal1 -= int(x[x_il_index])
tsp_cost += _lambda * penal1**2
#Contstraint 2
for i in range(N):
penal2 = 1
for l in range(N):
x_il_index = bit(i, l, N)
penal2 -= int(x[x_il_index])
tsp_cost += _lambda*penal2**2
#Constraint 3
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# x_il
x_il_index = bit(i, l, N)
# x_j(l+1)
l_plus = (l+1) % N
x_jlplus_index = bit(j, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * _lambda
return tsp_cost
def get_classical_simplified_zz_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# zz term #
zz_classic_term = [[0] * N**2 for i in range(N**2) ]
# first term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
# z_jl
z_jl_index = bit(j, l, N)
zz_classic_term[z_il_index][z_jl_index] += _lambda / 2
# second term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
# z_ij
z_ij_index = bit(i, j, N)
zz_classic_term[z_il_index][z_ij_index] += _lambda / 2
# third term
not_edge = get_not_edge_in(G)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += _lambda / 4
# fourth term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ji / 4
return zz_classic_term
def get_classical_simplified_hamiltonian(G, _lambda):
# z term #
z_classic_term = get_classical_simplified_z_term(G, _lambda)
# zz term #
zz_classic_term = get_classical_simplified_zz_term(G, _lambda)
return z_classic_term, zz_classic_term
def get_cost_circuit(G, gamma, _lambda):
N = G.number_of_nodes()
N_square = N**2
qc = QuantumCircuit(N_square,N_square)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _lambda)
# z term
for i in range(N_square):
if z_classic_term[i] != 0:
append_z_term(qc, i, gamma, z_classic_term[i])
# zz term
for i in range(N_square):
for j in range(N_square):
if zz_classic_term[i][j] != 0:
append_zz_term(qc, i, j, gamma, zz_classic_term[i][j])
return qc
def get_mixer_operator(G,beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
for n in range(N**2):
append_x_term(qc, n, beta)
return qc
def get_QAOA_circuit(G, beta, gamma, _lambda):
assert(len(beta)==len(gamma))
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
# init min mix state
qc.h(range(N**2))
p = len(beta)
for i in range(p):
qc = qc.compose(get_cost_circuit(G, gamma[i], _lambda))
qc = qc.compose(get_mixer_operator(G, beta[i]))
qc.barrier(range(N**2))
qc.snapshot_statevector("final_state")
qc.measure(range(N**2),range(N**2))
return qc
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
# Sample expectation value
def compute_tsp_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj_2(meas, G, LAMBDA)
energy += obj_for_meas*meas_count
total_counts += meas_count
mean = energy/total_counts
return mean
def get_black_box_objective_2(G,p):
backend = Aer.get_backend('qasm_simulator')
sim = Aer.get_backend('aer_simulator')
# function f costo
def f(theta):
beta = theta[:p]
gamma = theta[p:]
# Anzats
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
result = execute(qc, backend, seed_simulator=SEED, shots= SHOTS).result()
final_state_vector = result.data()["snapshots"]["statevector"]["final_state"][0]
state_vector = Statevector(final_state_vector)
probabilities = state_vector.probabilities()
probabilities_states = invert_counts(state_vector.probabilities_dict())
expected_value = 0
for state,probability in probabilities_states.items():
cost = tsp_obj_2(state, G, LAMBDA)
expected_value += cost*probability
counts = result.get_counts()
mean = compute_tsp_energy_2(invert_counts(counts),G)
return mean
return f
def crear_grafo(cantidad_ciudades):
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
return G, mejor_costo, mejor_camino
def run_QAOA(p,ciudades, grafo):
if grafo == None:
G, mejor_costo, mejor_camino = crear_grafo(ciudades)
print("Mejor Costo")
print(mejor_costo)
print("Mejor Camino")
print(mejor_camino)
print("Bordes del grafo")
print(G.edges())
print("Nodos")
print(G.nodes())
print("Pesos")
labels = nx.get_edge_attributes(G,'weight')
print(labels)
else:
G = grafo
intial_random = []
# beta, mixer Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,np.pi))
# gamma, cost Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,2*np.pi))
init_point = np.array(intial_random)
obj = get_black_box_objective_2(G,p)
res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
print(res_sample)
if __name__ == '__main__':
# Run QAOA parametros: profundidad p, numero d ciudades,
run_QAOA(5, 3, None)
|
https://github.com/JayRGopal/Quantum-Error-Correction
|
JayRGopal
|
from qiskit import *
import random
def generate_oracle(oracle_length, random_cnot, cnot_count, fixed_string=""):
if random_cnot == True:
cnot_count = random.randint(0, oracle_length)
random_cnots = random.sample(range(0, oracle_length), cnot_count)
oracle = ""
for i in range(oracle_length):
if random_cnots.count(i) == 1:
oracle = oracle + "1"
else:
oracle = oracle + "0"
if fixed_string != "" and len(fixed_string) == oracle_length - 1:
oracle = fixed_string
circuit = QuantumCircuit(len(oracle)+1, len(oracle))
circuit.h(range(len(oracle)))
circuit.x(len(oracle))
circuit.h(len(oracle))
circuit.barrier()
for ii, yesno in enumerate(reversed(oracle)):
if yesno == '1':
circuit.cx(ii, len(oracle))
circuit.barrier()
circuit.h(range(len(oracle)))
circuit.barrier()
circuit.measure(range(len(oracle)), range(len(oracle)))
return [circuit, oracle]
def validate_oracle(results,expected,cnt):
print("ORACLE PASSES :)" if results.get_counts().most_frequent() == expected else "oracle failed... :(")
acc = (results.get_counts()[expected] / cnt) * 100
print("Correct with %d%% accurary"%(acc))
|
https://github.com/JayRGopal/Quantum-Error-Correction
|
JayRGopal
|
!pip install qiskit -q
from qiskit import *
%matplotlib inline
from qiskit.tools.visualization import plot_histogram
secretnumber = '0110110110101011110100101010101001'
circuit = QuantumCircuit(len(secretnumber)+1, len(secretnumber))
circuit.h(range(len(secretnumber)))
circuit.x(len(secretnumber))
circuit.h(len(secretnumber))
circuit.barrier()
for ii, yesno in enumerate(reversed(secretnumber)):
if yesno == '1':
circuit.cx(ii, len(secretnumber))
circuit.barrier()
circuit.h(range(len(secretnumber)))
circuit.barrier()
circuit.measure(range(len(secretnumber)), range(len(secretnumber)))
circuit.draw(output='text')
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = simulator, shots = 1).result()
counts = result.get_counts()
print(counts)
|
https://github.com/JayRGopal/Quantum-Error-Correction
|
JayRGopal
|
import numpy as np
import matplotlib.pyplot as plt
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ, execute
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
y_target = 3
def f(x):
return x # can be any function!
def oracle(x):
return f(x) == y_target # logic to determine this oracle can be anything ! This is just the simplest example ... but hopefully only ONE satisfying value or answers are inconsistent
N = 10
for i in range(N):
if oracle(i):
print("%i satisfies f(x)" % i)
oracle = QuantumCircuit(2,name='oracle')
oracle.cz(0,1)
oracle.to_gate()
oracle.draw()
grover = QuantumCircuit(2,2)
grover.h([0,1])
grover.append(oracle,[0,1])
grover.draw()
backend = Aer.get_backend('statevector_simulator')
job = execute(grover,backend)
result = job.result()
sv = result.get_statevector()
np.around(sv,2)
reflection = QuantumCircuit(2,name='reflection')
reflection.h([0,1])
reflection.z([0,1])
reflection.cz(0,1)
reflection.h([0,1])
reflection.to_gate()
reflection.draw()
backend = Aer.get_backend('qasm_simulator')
grover = QuantumCircuit(2,2)
grover.h([0,1])
grover.append(oracle,[0,1])
grover.append(reflection,[0,1]) # repeat sqrt(N) times...
grover.measure([0,1],[0,1])
grover.draw()
job = execute(grover,backend,shots=1)
job.result().get_counts()
|
https://github.com/JayRGopal/Quantum-Error-Correction
|
JayRGopal
|
!pip install qiskit -q
!pip install qiskit-machine-learning -q
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit.library import TwoLocal, ZZFeatureMap
from qiskit.utils import algorithm_globals
from qiskit_machine_learning.algorithms import VQC
from qiskit_machine_learning.datasets import ad_hoc_data
from matplotlib import pyplot as plt
import numpy as np
!pip install pylatexenc -q
import json
import matplotlib.pyplot as plt
import numpy as np
from IPython.display import clear_output
from qiskit import QuantumCircuit
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit import ParameterVector
from qiskit.circuit.library import ZFeatureMap
from qiskit.quantum_info import SparsePauliOp
from qiskit.utils import algorithm_globals
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier
from qiskit_machine_learning.neural_networks import EstimatorQNN
from sklearn.model_selection import train_test_split
algorithm_globals.random_seed = 12345
seed = 1376
algorithm_globals.random_seed = seed
# Use ad hoc data set for training and test data
feature_dim = 2 # dimension of each data point
training_size = 20
test_size = 10
# training features, training labels, test features, test labels as np.ndarray,
# one hot encoding for labels
training_features, training_labels, test_features, test_labels = ad_hoc_data(
training_size=training_size, test_size=test_size, n=feature_dim, gap=0.3
)
# Visualizing Ad Hoc Data
plt.scatter(np.array(training_features)[:, 0], np.array(training_features)[:, 1],
c=np.argmax(np.array(training_labels), axis=1), cmap='copper')
plt.title("2D Ad Hoc Data")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
# ZZFeatureMap creates a quantum circuit out of the classical data
feature_map = ZZFeatureMap(feature_dimension=feature_dim, reps=2, entanglement="linear")
print(feature_map.decompose().draw())
# TwoLocal circuit
'''
From Qiskit Documentation:
The two-local circuit is a parameterized circuit consisting of alternating rotation layers
and entanglement layers. The rotation layers are single qubit gates applied on all qubits.
The entanglement layer uses two-qubit gates to entangle the qubits according to a strategy
set using entanglement. Both the rotation and entanglement gates can be specified as string
(e.g. 'ry' or 'cx'), as gate-type (e.g. RYGate or CXGate) or as QuantumCircuit
(e.g. a 1-qubit circuit or 2-qubit circuit).
'''
# We assume that the solution takes the form of the 'ansatz'
ansatz = TwoLocal(feature_map.num_qubits, ["ry", "rz"], "cz", reps=3)
print(ansatz.decompose().draw())
# COBYLA = Constrained Optimization By Linear Approximation optimizer.
# COBYLA assumes the derivative of the objective function isn't known
# VQC = Variational Quantum Classifier
# 1 - Feature Map - Load data into quantum system
# 2 - Ansatz - Variational quantum circuit - a quantum circuit that needs certain parameters (trained via ML)
# 3 - Measure an n (classical) bit output, and convert to a label (e.g. binary)
# 4 - Optimization (may not always be gradient-based). In this case, COBYLA
vqc = VQC(
feature_map=feature_map,
ansatz=ansatz,
optimizer=COBYLA(maxiter=100),
)
vqc.fit(training_features, training_labels)
score = vqc.score(test_features, test_labels)
print(f"Testing accuracy: {score:0.2f}")
# Ad Hoc Data doesn't support feature dims > 3
feature_dim = 3 # dimension of each data point
training_size = 100
test_size = 50
# training features, training labels, test features, test labels as np.ndarray,
# one hot encoding for labels
training_features, training_labels, test_features, test_labels = ad_hoc_data(
training_size=training_size, test_size=test_size, n=feature_dim, gap=0.3
)
feature_map = ZZFeatureMap(feature_dimension=feature_dim, reps=2, entanglement="linear")
ansatz = TwoLocal(feature_map.num_qubits, ["ry", "rz"], "cz", reps=3)
vqc = VQC(
feature_map=feature_map,
ansatz=ansatz,
optimizer=COBYLA(maxiter=100),
)
vqc.fit(training_features, training_labels)
score = vqc.score(test_features, test_labels)
print(f"Testing accuracy: {score:0.2f}")
def generate_dataset(num_images):
images = []
labels = []
hor_array = np.zeros((6, 8))
ver_array = np.zeros((4, 8))
j = 0
for i in range(0, 7):
if i != 3:
hor_array[j][i] = np.pi / 2
hor_array[j][i + 1] = np.pi / 2
j += 1
j = 0
for i in range(0, 4):
ver_array[j][i] = np.pi / 2
ver_array[j][i + 4] = np.pi / 2
j += 1
for n in range(num_images):
rng = algorithm_globals.random.integers(0, 2)
if rng == 0:
labels.append(-1)
random_image = algorithm_globals.random.integers(0, 6)
images.append(np.array(hor_array[random_image]))
elif rng == 1:
labels.append(1)
random_image = algorithm_globals.random.integers(0, 4)
images.append(np.array(ver_array[random_image]))
# Create noise
for i in range(8):
if images[-1][i] == 0:
images[-1][i] = algorithm_globals.random.uniform(0, np.pi / 4)
return images, labels
images, labels = generate_dataset(50)
train_images, test_images, train_labels, test_labels = train_test_split(
images, labels, test_size=0.3
)
fig, ax = plt.subplots(2, 2, figsize=(10, 6), subplot_kw={"xticks": [], "yticks": []})
for i in range(4):
ax[i // 2, i % 2].imshow(
train_images[i].reshape(2, 4), # Change back to 2 by 4
aspect="equal",
)
plt.subplots_adjust(wspace=0.1, hspace=0.025)
# Steps
# 1 - Feature Map - Load data into quantum system
# 2 - Ansatz - Variational quantum circuit - a quantum circuit that needs certain parameters (trained via ML)
# 3 - Measure an n (classical) bit output, and convert to a label (e.g. binary)
# 4 - Optimization (may not always be gradient-based). In this case, COBYLA
# COBYLA = Constrained Optimization By Linear Approximation optimizer.
# COBYLA assumes the derivative of the objective function isn't known
# We now define a two qubit unitary as defined in [3]
def conv_circuit(params):
target = QuantumCircuit(2)
target.rz(-np.pi / 2, 1)
target.cx(1, 0)
target.rz(params[0], 0)
target.ry(params[1], 1)
target.cx(0, 1)
target.ry(params[2], 1)
target.cx(1, 0)
target.rz(np.pi / 2, 0)
return target
# Let's draw this circuit and see what it looks like
params = ParameterVector("θ", length=3)
circuit = conv_circuit(params)
circuit.draw("mpl")
def conv_layer(num_qubits, param_prefix):
qc = QuantumCircuit(num_qubits, name="Convolutional Layer")
qubits = list(range(num_qubits))
param_index = 0
params = ParameterVector(param_prefix, length=num_qubits * 3)
for q1, q2 in zip(qubits[0::2], qubits[1::2]):
qc = qc.compose(conv_circuit(params[param_index : (param_index + 3)]), [q1, q2])
qc.barrier()
param_index += 3
for q1, q2 in zip(qubits[1::2], qubits[2::2] + [0]):
qc = qc.compose(conv_circuit(params[param_index : (param_index + 3)]), [q1, q2])
qc.barrier()
param_index += 3
qc_inst = qc.to_instruction()
qc = QuantumCircuit(num_qubits)
qc.append(qc_inst, qubits)
return qc
circuit = conv_layer(4, "θ")
circuit.decompose().draw("mpl")
def pool_circuit(params):
target = QuantumCircuit(2)
target.rz(-np.pi / 2, 1)
target.cx(1, 0)
target.rz(params[0], 0)
target.ry(params[1], 1)
target.cx(0, 1)
target.ry(params[2], 1)
return target
params = ParameterVector("θ", length=3)
circuit = pool_circuit(params)
circuit.draw("mpl")
def pool_layer(sources, sinks, param_prefix):
num_qubits = len(sources) + len(sinks)
qc = QuantumCircuit(num_qubits, name="Pooling Layer")
param_index = 0
params = ParameterVector(param_prefix, length=num_qubits // 2 * 3)
for source, sink in zip(sources, sinks):
qc = qc.compose(pool_circuit(params[param_index : (param_index + 3)]), [source, sink])
qc.barrier()
param_index += 3
qc_inst = qc.to_instruction()
qc = QuantumCircuit(num_qubits)
qc.append(qc_inst, range(num_qubits))
return qc
sources = [0, 1]
sinks = [2, 3]
circuit = pool_layer(sources, sinks, "θ")
circuit.decompose().draw("mpl")
feature_map = ZFeatureMap(8)
feature_map.decompose().draw("mpl")
feature_map = ZFeatureMap(8)
ansatz = QuantumCircuit(8, name="Ansatz")
# First Convolutional Layer
ansatz.compose(conv_layer(8, "с1"), list(range(8)), inplace=True)
# First Pooling Layer
ansatz.compose(pool_layer([0, 1, 2, 3], [4, 5, 6, 7], "p1"), list(range(8)), inplace=True)
# Second Convolutional Layer
ansatz.compose(conv_layer(4, "c2"), list(range(4, 8)), inplace=True)
# Second Pooling Layer
ansatz.compose(pool_layer([0, 1], [2, 3], "p2"), list(range(4, 8)), inplace=True)
# Third Convolutional Layer
ansatz.compose(conv_layer(2, "c3"), list(range(6, 8)), inplace=True)
# Third Pooling Layer
ansatz.compose(pool_layer([0], [1], "p3"), list(range(6, 8)), inplace=True)
# Combining the feature map and ansatz
circuit = QuantumCircuit(8)
circuit.compose(feature_map, range(8), inplace=True)
circuit.compose(ansatz, range(8), inplace=True)
observable = SparsePauliOp.from_list([("Z" + "I" * 7, 1)])
# we decompose the circuit for the QNN to avoid additional data copying
qnn = EstimatorQNN(
circuit=circuit.decompose(),
observables=observable,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
)
circuit.draw("mpl")
def callback_graph(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
from google.colab import drive
drive.mount('/content/drive', force_remount=True)
!cp '/content/drive/MyDrive/Quantum Computing/11_qcnn_initial_point.json' ./
with open("11_qcnn_initial_point.json", "r") as f:
initial_point = json.load(f)
classifier = NeuralNetworkClassifier(
qnn,
optimizer=COBYLA(maxiter=200), # Set max iterations here
callback=callback_graph,
initial_point=initial_point,
)
x = np.asarray(train_images)
y = np.asarray(train_labels)
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
classifier.fit(x, y)
# score classifier
print(f"Accuracy from the train data : {np.round(100 * classifier.score(x, y), 2)}%")
y_predict = classifier.predict(test_images)
x = np.asarray(test_images)
y = np.asarray(test_labels)
print(f"Accuracy from the test data : {np.round(100 * classifier.score(x, y), 2)}%")
# Let's see some examples in our dataset
fig, ax = plt.subplots(2, 2, figsize=(10, 6), subplot_kw={"xticks": [], "yticks": []})
for i in range(0, 4):
ax[i // 2, i % 2].imshow(test_images[i].reshape(2, 4), aspect="equal")
if y_predict[i] == -1:
ax[i // 2, i % 2].set_title("The QCNN predicts this is a Horizontal Line")
if y_predict[i] == +1:
ax[i // 2, i % 2].set_title("The QCNN predicts this is a Vertical Line")
plt.subplots_adjust(wspace=0.1, hspace=0.5)
figure, axes = plt.subplots()
draw1 = plt.Circle((0.5, 0.5), 0.2, color='b')
draw2 = plt.Circle((0.5, 0.5), 0.1, color='r')
axes.set_aspect(1)
axes.add_artist(draw1)
axes.add_artist(draw2)
plt.title('2 Circles')
plt.show()
print('Can be mapped into a 1D space (x^2 + y^2) via a kernel for a simple decision boundary')
|
https://github.com/JayRGopal/Quantum-Error-Correction
|
JayRGopal
|
from qiskit import Aer, IBMQ, transpile
from qiskit.utils import QuantumInstance
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes.calibration import RZXCalibrationBuilderNoEcho
from qiskit_nature.drivers import UnitsType, Molecule
from qiskit_nature.drivers.second_quantization import ElectronicStructureDriverType, ElectronicStructureMoleculeDriver
from qiskit_nature.problems.second_quantization import ElectronicStructureProblem
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.transformers.second_quantization.electronic import FreezeCoreTransformer
from qiskit_nature.mappers.second_quantization import ParityMapper
from qiskit_nature.algorithms import GroundStateEigensolver
from qiskit_nature.runtime import VQEClient
from qiskit.algorithms import NumPyMinimumEigensolver, VQE
from qiskit.algorithms.optimizers import SPSA
from qiskit.circuit import QuantumCircuit, ParameterVector
from qiskit.utils import QuantumInstance
from qiskit.providers.aer import AerSimulator
import matplotlib.pyplot as plt
import numpy as np
backend = AerSimulator()
def HEA_naive(num_q, depth):
circuit = QuantumCircuit(num_q)
params = ParameterVector("theta", length=num_q * (3 * depth + 2))
counter = 0
for q in range(num_q):
circuit.rx(params[counter], q)
counter += 1
circuit.rz(params[counter], q)
counter += 1
for d in range(depth):
for q in range(num_q - 1):
circuit.cx(q, q + 1)
for q in range(num_q):
circuit.rz(params[counter], q)
counter += 1
circuit.rx(params[counter], q)
counter += 1
circuit.rz(params[counter], q)
counter += 1
return circuit, params
def HEA_aware(num_q, depth, hardware):
circuit = QuantumCircuit(num_q)
params = ParameterVector("theta", length=num_q * (3 * depth + 2))
counter = 0
for q in range(num_q):
circuit.rx(params[counter], q)
counter += 1
circuit.rz(params[counter], q)
counter += 1
for d in range(depth):
for q in range(num_q - 1):
gate = QuantumCircuit(num_q)
gate.rzx(np.pi/2, q, q + 1)
pass_ = RZXCalibrationBuilderNoEcho(hardware)
qc_cr = PassManager(pass_).run(gate)
circuit.compose(qc_cr, inplace=True)
for q in range(num_q):
circuit.rz(params[counter], q)
counter += 1
circuit.rx(params[counter], q)
counter += 1
circuit.rz(params[counter], q)
counter += 1
return circuit, params
depth = 2
qubits = 4
circuit, _ = HEA_naive(qubits, depth)
spsa = SPSA(100)
qi = QuantumInstance(Aer.get_backend('aer_simulator'))
vqe_circuit = VQE(ansatz=circuit, quantum_instance=qi, optimizer=spsa)
print(circuit)
|
https://github.com/matheusvtna/Grover-Algorithm
|
matheusvtna
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
from qiskit.circuit.library.standard_gates import XGate, HGate
from operator import *
n = 3
N = 8 #2**n
index_colour_table = {}
colour_hash_map = {}
index_colour_table = {'000':"yellow", '001':"red", '010':"blue", '011':"red", '100':"green", '101':"blue", '110':"orange", '111':"red"}
colour_hash_map = {"yellow":'100', "red":'011', "blue":'000', "green":'001', "orange":'010'}
def database_oracle(index_colour_table, colour_hash_map):
circ_database = QuantumCircuit(n + n)
for i in range(N):
circ_data = QuantumCircuit(n)
idx = bin(i)[2:].zfill(n) # removing the "0b" prefix appended by the bin() funtion
colour = index_colour_table[idx]
colour_hash = colour_hash_map[colour][::-1]
for j in range(n):
if colour_hash[j] == '1':
circ_data.x(j)
# qiskit maps the rightmost bit as the 0th qubit -> qn, ..., q0
# we therefore reverse the index string -> q0, ..., qn
data_gate = circ_data.to_gate(label=colour).control(num_ctrl_qubits=n, ctrl_state=idx, label="index-"+colour)
circ_database.append(data_gate, list(range(n+n)))
return circ_database
# drawing the database oracle circuit
print("Database Encoding")
database_oracle(index_colour_table, colour_hash_map).draw()
circ_data = QuantumCircuit(n)
m = 4
idx = bin(m)[2:].zfill(n) # removing the "0b" prefix appended by the bin() funtion
colour = index_colour_table[idx]
colour_hash = colour_hash_map[colour][::-1]
for j in range(n):
if colour_hash[j] == '1':
circ_data.x(j)
print("Internal colour encoding for the colour green (as an example)");
circ_data.draw()
def oracle_grover(database, data_entry):
circ_grover = QuantumCircuit(n + n + 1)
circ_grover.append(database, list(range(n+n)))
target_reflection_gate = XGate().control(num_ctrl_qubits=n, ctrl_state=colour_hash_map[data_entry], label="Reflection of " + "\"" + data_entry + "\" Target")
# control() missing 1 required positional argument: 'self' .... if only 'XGate' used instead of 'XGate()'
# The “missing 1 required positional argument: 'self'” error is raised when you do not instantiate an object of a class before calling a class method. This error is also raised when you incorrectly instantiate a class.
circ_grover.append(target_reflection_gate, list(range(n, n+n+1)))
circ_grover.append(database, list(range(n+n)))
return circ_grover
print("Grover Oracle (target example: orange)")
oracle_grover(database_oracle(index_colour_table, colour_hash_map).to_gate(label="Database Encoding"), "orange").decompose().draw()
def mcz_gate(num_qubits):
num_controls = num_qubits - 1
mcz_gate = QuantumCircuit(num_qubits)
target_mcz = QuantumCircuit(1)
target_mcz.z(0)
target_mcz = target_mcz.to_gate(label="Z_Gate").control(num_ctrl_qubits=num_controls, ctrl_state=None, label="MCZ")
mcz_gate.append(target_mcz, list(range(num_qubits)))
return mcz_gate.reverse_bits()
print("Multi-controlled Z (MCZ) Gate")
mcz_gate(n).decompose().draw()
def diffusion_operator(num_qubits):
circ_diffusion = QuantumCircuit(num_qubits)
qubits_list = list(range(num_qubits))
# Layer of H^n gates
circ_diffusion.h(qubits_list)
# Layer of X^n gates
circ_diffusion.x(qubits_list)
# Layer of Multi-controlled Z (MCZ) Gate
circ_diffusion = circ_diffusion.compose(mcz_gate(num_qubits), qubits_list)
# Layer of X^n gates
circ_diffusion.x(qubits_list)
# Layer of H^n gates
circ_diffusion.h(qubits_list)
return circ_diffusion
print("Diffusion Circuit")
diffusion_operator(n).draw()
# Putting it all together ... !!!
item = "green"
print("Searching for the index of the colour", item)
circuit = QuantumCircuit(n + n + 1, n)
circuit.x(n + n)
circuit.barrier()
circuit.h(list(range(n)))
circuit.h(n+n)
circuit.barrier()
unitary_oracle = oracle_grover(database_oracle(index_colour_table, colour_hash_map).to_gate(label="Database Encoding"), item).to_gate(label="Oracle Operator")
unitary_diffuser = diffusion_operator(n).to_gate(label="Diffusion Operator")
M = countOf(index_colour_table.values(), item)
Q = int(np.pi * np.sqrt(N/M) / 4)
for i in range(Q):
circuit.append(unitary_oracle, list(range(n + n + 1)))
circuit.append(unitary_diffuser, list(range(n)))
circuit.barrier()
circuit.measure(list(range(n)), list(range(n)))
circuit.draw()
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(circuit, backend_sim), shots=1024)
result_sim = job_sim.result()
counts = result_sim.get_counts(circuit)
if M==1:
print("Index of the colour", item, "is the index with most probable outcome")
else:
print("Indices of the colour", item, "are the indices the most probable outcomes")
from qiskit.visualization import plot_histogram
plot_histogram(counts)
|
https://github.com/MansourZarrin/A-Simple-Guide-to-Quantum-Approaches-for-Solving-Max-Cut
|
MansourZarrin
|
# Import libraries
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, Aer, execute
import warnings
# Step 1: Define the problem and setup
num_vertices = 20 # Number of vertices in the graph
edge_probability = 0.5 # Probability of creating an edge between any two vertices
shots = 1000 # Number of shots for quantum circuit execution
# Step 2: Generate a random graph using NetworkX
def generate_random_graph(num_vertices, edge_probability):
"""
Generate a random graph using NetworkX.
Parameters:
num_vertices (int): Number of vertices in the graph.
edge_probability (float): Probability of creating an edge between any two vertices.
Returns:
np.array: Adjacency matrix of the generated graph.
"""
with warnings.catch_warnings():
warnings.simplefilter("ignore")
graph = nx.erdos_renyi_graph(num_vertices, edge_probability)
return nx.adjacency_matrix(graph).toarray()
# Step 3: Implement quantum walk on graph
def quantum_walk(graph):
"""
Implement a quantum walk on a graph.
Parameters:
graph (np.array): Adjacency matrix representing the graph.
Returns:
dict: Dictionary containing counts of measurement outcomes.
"""
num_vertices = len(graph)
qc = QuantumCircuit(num_vertices)
for i in range(num_vertices):
qc.h(i)
for i in range(num_vertices):
for j in range(i+1, num_vertices):
if graph[i][j] == 1:
qc.cp(np.pi, i, j)
qc.measure_all()
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, simulator, shots=shots).result()
counts = result.get_counts(qc)
return counts
# Step 4: Quantum Approximation Algorithm (Max-Cut)
def max_cut_approximation(graph, counts):
"""
Implement the Quantum Approximation Algorithm (Max-Cut).
Parameters:
graph (np.array): Adjacency matrix representing the graph.
counts (dict): Dictionary containing counts of measurement outcomes.
Returns:
tuple: Tuple containing the max cut size and the partition string.
"""
max_cut = 0
partition = None
for partition_string in counts.keys():
cut = 0
for i in range(len(partition_string)):
for j in range(i+1, len(partition_string)):
if partition_string[i] != partition_string[j] and graph[i][j] == 1:
cut += 1
if cut > max_cut:
max_cut = cut
partition = partition_string
return max_cut, partition
# Step 5: Decode the partitioning and visualize the resulting graph with cut
def decode_partition(graph, partition):
"""
Decode the partitioning and visualize the resulting graph with the cut.
Parameters:
graph (np.array): Adjacency matrix representing the graph.
partition (str): String representing the partition of the vertices.
Returns:
None
"""
G = nx.from_numpy_array(graph)
colors = ['skyblue', 'salmon']
node_colors = [colors[int(partition[node])] for node in G.nodes()]
# Identify edges crossing the partition
cut_edges = [(u, v) for u, v in G.edges() if partition[u] != partition[v]]
# Draw graph with nodes colored based on partition and cut edges highlighted
pos = nx.spring_layout(G) # Positions for all nodes
nx.draw(G, pos, with_labels=True, node_color=node_colors, node_size=1000, font_size=12)
nx.draw_networkx_edges(G, pos, edgelist=cut_edges, width=2, alpha=0.5, edge_color='red') # Draw cut edges
plt.title("Resulted Partitioned Graph with Cut")
plt.show()
# Execute the steps
# Generate random graph
graph = generate_random_graph(num_vertices, edge_probability)
# Implement quantum walk
counts = quantum_walk(graph)
# Find max-cut approximation
max_cut, partition = max_cut_approximation(graph, counts)
print("Max-Cut:", max_cut)
print(f"The value {max_cut} indicates the maximum number of edges that can be cut by partitioning the vertices into two sets.")
print(f"In other words, if we divide the vertices into two groups according to the partition obtained, we can cut a maximum of {max_cut} edges between these two groups.")
print()
print("Partition:", partition)
print(f"The binary string {partition} represents the partitioning of vertices.")
print(f"Each digit in the string corresponds to a vertex in the graph.")
print(f"In this case, there are {num_vertices} vertices, so the binary string has {num_vertices} digits.")
print("The value '1' indicates that the corresponding vertex belongs to one set (Partition 1), and the value '0' indicates that the vertex belongs to the other set (Partition 0).")
# Decode partition and visualize resulting graph
decode_partition(graph, partition)
|
https://github.com/anikazaman24/Quantum_computer_data_collection_HHL_algorithm_circuit_with_NoiseAnalysis_Framework
|
anikazaman24
|
from qiskit_ibm_runtime import QiskitRuntimeService
# Save an IBM Quantum account and set it as your default account.
QiskitRuntimeService.save_account(channel="ibm_quantum", token='<YOUR_TOKEN>', overwrite=True,set_as_default=True)
# Load saved credentials
service = QiskitRuntimeService()
service.backend()
!pip install qiskit[visualization]
# Imports for Qiskit
from qiskit import QuantumCircuit, execute,IBMQ
from qiskit.compiler import transpile, assemble
from qiskit import QuantumCircuit, transpile, IBMQ, execute #i added to remove error
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit import *
from qiskit import IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.visualization import plot_histogram
from copy import deepcopy
from matplotlib import pyplot as plt
from qiskit import *
from qiskit.tools.visualization import *
from qiskit.visualization import plot_histogram, plot_bloch_vector
from math import sqrt, pi
from qiskit import QuantumCircuit, assemble
from math import pi, sqrt
from qiskit.visualization import plot_bloch_multivector, plot_histogram
#sim = Aer.get_backend('aer_simulator')
from IPython.display import clear_output
#Quantum Volume
from IPython.display import clear_output
#Import Qiskit classes
import qiskit
from qiskit import assemble, transpile
#from qiskit.providers.aer.noise import NoiseModel
#from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error
#Import the qv function
#import qiskit.ignis.verification.quantum_volume as qv
#Import qv measurement classes
#from qiskit_experiments.framework import BatchExperiment
#from qiskit_experiments.library import QuantumVolume
#from qiskit import Aer
#from qiskit.providers.aer import AerSimulator
from qiskit.circuit.random import random_circuit
from qiskit import QuantumCircuit
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.tools.monitor import job_monitor
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
#from ibm_quantum_widgets import *
#from qiskit.providers.aer import QasmSimulator
from qiskit import *
import numpy as np
# Register declaration
clock = QuantumRegister(2, name='clock')
input_ = QuantumRegister(1, name='b')
ancilla = QuantumRegister(1, name='ancilla')
circuit = QuantumCircuit(ancilla, clock, input_)
#---------------Psi 0--------------------------
circuit.barrier()
circuit.x(input_);
#---------------Psi 1--------------------------
circuit.barrier();
circuit.h(clock[0]);
circuit.h(clock[1]);
#--------------Psi 2---------------------------
circuit.barrier();
# e^{i*A*t}
circuit.cu(np.pi/2, -np.pi/2, np.pi/2, 3*np.pi/4, clock[0], input_, label='U');
# e^{i*A*t*2}
circuit.cu(np.pi, np.pi, 0, 0, clock[1], input_, label='U2');
#--------------Psi 3---------------------------
circuit.barrier();
circuit.h(clock[1]);
for j in reversed(range(2)):
for k in reversed(range(j+1,2)):
circuit.cp(-np.pi/float(2**(k-j)), clock[k], clock[j]); #cu1 changes to cp in the new version
circuit.h(clock[0]);
circuit.swap(clock[0], clock[1]);
#--------------Psi 4---------------------------
circuit.barrier();
circuit.cry(np.pi, clock[0], ancilla);
circuit.cry(np.pi/3, clock[1], ancilla);
#--------------Psi 5---------------------------
circuit.barrier();
circuit.swap(clock[0], clock[1]);
circuit.h(clock[0]);
for j in reversed(range(2)):
for k in reversed(range(j+1,2)):
circuit.cp(np.pi/float(2**(k-j)), clock[k], clock[j]);
circuit.h(clock[1])
#--------------Psi 6---------------------------
circuit.barrier();
circuit.cu(np.pi, np.pi, 0, 0, clock[1], input_, label='U2');
# e^{i*A*t}
circuit.cu(np.pi/2, np.pi/2, -np.pi/2, -3*np.pi/4, clock[0], input_, label='U');
#--------------Psi 7--------------------------
circuit.barrier();
circuit.h(clock[0]);
circuit.h(clock[1]);
#--------------Psi 8---------------------------
circuit.barrier();
circuit.draw(output='mpl', style = 'iqp')
# Register declaration
clock = QuantumRegister(2, name='clock')
input_ = QuantumRegister(1, name='b')
ancilla = QuantumRegister(1, name='ancilla')
circuit0 = QuantumCircuit(ancilla, clock, input_)
#---------------Psi 0--------------------------
circuit0.barrier()
circuit0.x(input_);
circuit0.measure_all()
circuit0.draw(output='mpl',idle_wires=False)
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
transpiled_ckt0 = transpile(circuit0, provider.get_backend('ibm_brisbane'), seed_transpiler = 13,optimization_level=0)
transpiled_ckt0.draw(output = 'mpl',idle_wires=False)
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Options
service = QiskitRuntimeService()
options = Options()
options.resilience_level = 0
options.optimization_level = 0
#backend = service.least_busy(operational=True, simulator=False)
example_circuit = transpiled_ckt0
service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")
sampler = Sampler(backend, options=options)
job = sampler.run(example_circuit)
print(f"job id: {job.job_id()}")
result = job.result()
print(result)
binary_prob = [quasi_dist.binary_probabilities() for quasi_dist in result.quasi_dists]
plot_histogram(binary_prob)
import csv
data = binary_prob
# Extract all possible combinations of 4-bit binary headings
all_combinations = [format(i, '04b') for i in range(16)]
# Iterate over the data and fill in missing values with zeros
filled_data = []
for d in data:
filled_row = {key: d.get(key, 0) for key in all_combinations}
filled_data.append(filled_row)
# Write the filled data to a CSV file
csv_file = "data.csv"
with open(csv_file, mode='w', newline='') as file:
writer = csv.DictWriter(file, fieldnames=all_combinations)
writer.writeheader()
for row in filled_data:
writer.writerow(row)
print(f"Data has been written to {csv_file}")
# Register declaration
clock = QuantumRegister(2, name='clock')
input_ = QuantumRegister(1, name='b')
ancilla = QuantumRegister(1, name='ancilla')
circuit1 = QuantumCircuit(ancilla, clock, input_)
#---------------Psi 0--------------------------
circuit1.barrier()
circuit1.x(input_);
#---------------Psi 1--------------------------
circuit1.barrier();
circuit1.h(clock[0]);
circuit1.h(clock[1]);
circuit1.measure_all()
circuit1.draw(output='mpl',idle_wires=False)
#--------------Psi 2---------------------------
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
transpiled_ckt1 = transpile(circuit1, provider.get_backend('ibm_brisbane'), seed_transpiler = 13,optimization_level=0)
transpiled_ckt1.draw(output = 'mpl',idle_wires=False)
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Options
service = QiskitRuntimeService()
options = Options()
options.resilience_level = 0
options.optimization_level = 0
#backend = service.least_busy(operational=True, simulator=False)
example_circuit = transpiled_ckt1
service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")
sampler = Sampler(backend, options=options)
job = sampler.run(example_circuit)
print(f"job id: {job.job_id()}")
result = job.result()
print(result)
binary_prob = [quasi_dist.binary_probabilities() for quasi_dist in result.quasi_dists]
plot_histogram(binary_prob)
import csv
data1 = binary_prob
# Fill in missing values in data1 with zeros
filled_data1 = []
for d in data1:
filled_row = {key: d.get(key, 0) for key in all_combinations}
filled_data1.append(filled_row)
# Append filled_data1 to filled_data
filled_data.extend(filled_data1)
# Write the updated filled_data to the same CSV file
csv_file = "data.csv"
with open(csv_file, mode='a', newline='') as file:
writer = csv.DictWriter(file, fieldnames=all_combinations)
for row in filled_data1:
writer.writerow(row)
print(f"Data1 has been added to {csv_file}")
# Register declaration
clock = QuantumRegister(2, name='clock')
input_ = QuantumRegister(1, name='b')
ancilla = QuantumRegister(1, name='ancilla')
circuit2 = QuantumCircuit(ancilla, clock, input_)
#---------------Psi 0--------------------------
circuit2.barrier()
circuit2.x(input_);
#---------------Psi 1--------------------------
circuit2.barrier();
circuit2.h(clock[0]);
circuit2.h(clock[1]);
#--------------Psi 2---------------------------
circuit2.barrier();
# e^{i*A*t}
circuit2.cu(np.pi/2, -np.pi/2, np.pi/2, 3*np.pi/4, clock[0], input_, label='U');
# e^{i*A*t*2}
circuit2.cu(np.pi, np.pi, 0, 0, clock[1], input_, label='U2');
circuit2.measure_all()
circuit2.draw(output='mpl',idle_wires=False)
#--------------Psi 3---------------------------
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
transpiled_ckt2 = transpile(circuit2, provider.get_backend('ibm_brisbane'), seed_transpiler = 13,optimization_level=0)
transpiled_ckt2.draw(output = 'mpl',idle_wires=False)
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Options
service = QiskitRuntimeService()
options = Options()
options.resilience_level = 0
options.optimization_level = 0
#backend = service.least_busy(operational=True, simulator=False)
example_circuit = transpiled_ckt2
service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")
sampler = Sampler(backend, options=options)
job = sampler.run(example_circuit)
print(f"job id: {job.job_id()}")
result = job.result()
print(result)
binary_prob = [quasi_dist.binary_probabilities() for quasi_dist in result.quasi_dists]
plot_histogram(binary_prob)
import csv
data1 = binary_prob
# Fill in missing values in data1 with zeros
filled_data1 = []
for d in data1:
filled_row = {key: d.get(key, 0) for key in all_combinations}
filled_data1.append(filled_row)
# Append filled_data1 to filled_data
filled_data.extend(filled_data1)
# Write the updated filled_data to the same CSV file
csv_file = "data.csv"
with open(csv_file, mode='a', newline='') as file:
writer = csv.DictWriter(file, fieldnames=all_combinations)
for row in filled_data1:
writer.writerow(row)
print(f"Data1 has been added to {csv_file}")
# Register declaration
clock = QuantumRegister(2, name='clock')
input_ = QuantumRegister(1, name='b')
ancilla = QuantumRegister(1, name='ancilla')
circuit3 = QuantumCircuit(ancilla, clock, input_)
#---------------Psi 0--------------------------
circuit3.barrier()
circuit3.x(input_);
#---------------Psi 1--------------------------
circuit3.barrier();
circuit3.h(clock[0]);
circuit3.h(clock[1]);
#--------------Psi 2---------------------------
circuit3.barrier();
# e^{i*A*t}
circuit3.cu(np.pi/2, -np.pi/2, np.pi/2, 3*np.pi/4, clock[0], input_, label='U');
# e^{i*A*t*2}
circuit3.cu(np.pi, np.pi, 0, 0, clock[1], input_, label='U2');
#--------------Psi 3---------------------------
circuit3.barrier();
circuit3.h(clock[1]);
for j in reversed(range(2)):
for k in reversed(range(j+1,2)):
circuit3.cp(-np.pi/float(2**(k-j)), clock[k], clock[j]); #cu1 changes to cp in the new version
circuit3.h(clock[0]);
circuit3.swap(clock[0], clock[1]);
circuit3.measure_all();
circuit3.draw(output='mpl',idle_wires=False)
#--------------Psi 4---------------------------
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
transpiled_ckt3 = transpile(circuit3, provider.get_backend('ibm_brisbane'), seed_transpiler = 13,optimization_level=0)
transpiled_ckt3.draw(output = 'mpl',idle_wires=False)
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Options
service = QiskitRuntimeService()
options = Options()
options.resilience_level = 0
options.optimization_level = 0
#backend = service.least_busy(operational=True, simulator=False)
example_circuit = transpiled_ckt3
service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")
sampler = Sampler(backend, options=options)
job = sampler.run(example_circuit)
print(f"job id: {job.job_id()}")
result = job.result()
print(result)
binary_prob = [quasi_dist.binary_probabilities() for quasi_dist in result.quasi_dists]
plot_histogram(binary_prob)
import csv
data1 = binary_prob
# Fill in missing values in data1 with zeros
filled_data1 = []
for d in data1:
filled_row = {key: d.get(key, 0) for key in all_combinations}
filled_data1.append(filled_row)
# Append filled_data1 to filled_data
filled_data.extend(filled_data1)
# Write the updated filled_data to the same CSV file
csv_file = "data.csv"
with open(csv_file, mode='a', newline='') as file:
writer = csv.DictWriter(file, fieldnames=all_combinations)
for row in filled_data1:
writer.writerow(row)
print(f"Data1 has been added to {csv_file}")
# Register declaration
clock = QuantumRegister(2, name='clock')
input_ = QuantumRegister(1, name='b')
ancilla = QuantumRegister(1, name='ancilla')
circuit4 = QuantumCircuit(ancilla, clock, input_)
#---------------Psi 0--------------------------
circuit4.barrier()
circuit4.x(input_);
#---------------Psi 1--------------------------
circuit4.barrier();
circuit4.h(clock[0]);
circuit4.h(clock[1]);
#--------------Psi 2---------------------------
circuit4.barrier();
# e^{i*A*t}
circuit4.cu(np.pi/2, -np.pi/2, np.pi/2, 3*np.pi/4, clock[0], input_, label='U');
# e^{i*A*t*2}
circuit4.cu(np.pi, np.pi, 0, 0, clock[1], input_, label='U2');
#--------------Psi 3---------------------------
circuit4.barrier();
circuit4.h(clock[1]);
for j in reversed(range(2)):
for k in reversed(range(j+1,2)):
circuit4.cp(-np.pi/float(2**(k-j)), clock[k], clock[j]); #cu1 changes to cp in the new version
circuit4.h(clock[0]);
circuit4.swap(clock[0], clock[1]);
#--------------Psi 4---------------------------
circuit4.barrier();
circuit4.cry(np.pi, clock[0], ancilla);
circuit4.cry(np.pi/3, clock[1], ancilla);
circuit4.measure_all()
circuit4.draw(output='mpl',idle_wires=False)
#--------------Psi 5---------------------------
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
transpiled_ckt4 = transpile(circuit4, provider.get_backend('ibm_brisbane'), seed_transpiler = 13,optimization_level=0)
transpiled_ckt4.draw(output = 'mpl',idle_wires=False)
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Options
service = QiskitRuntimeService()
options = Options()
options.resilience_level = 0
options.optimization_level = 0
#backend = service.least_busy(operational=True, simulator=False)
example_circuit = transpiled_ckt4
service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")
sampler = Sampler(backend, options=options)
job = sampler.run(example_circuit)
print(f"job id: {job.job_id()}")
result = job.result()
print(result)
binary_prob = [quasi_dist.binary_probabilities() for quasi_dist in result.quasi_dists]
plot_histogram(binary_prob)
import csv
data1 = binary_prob
# Fill in missing values in data1 with zeros
filled_data1 = []
for d in data1:
filled_row = {key: d.get(key, 0) for key in all_combinations}
filled_data1.append(filled_row)
# Append filled_data1 to filled_data
filled_data.extend(filled_data1)
# Write the updated filled_data to the same CSV file
csv_file = "data.csv"
with open(csv_file, mode='a', newline='') as file:
writer = csv.DictWriter(file, fieldnames=all_combinations)
for row in filled_data1:
writer.writerow(row)
print(f"Data1 has been added to {csv_file}")
# Register declaration
clock = QuantumRegister(2, name='clock')
input_ = QuantumRegister(1, name='b')
ancilla = QuantumRegister(1, name='ancilla')
circuit5 = QuantumCircuit(ancilla, clock, input_)
#---------------Psi 0--------------------------
circuit5.barrier()
circuit5.x(input_);
#---------------Psi 1--------------------------
circuit5.barrier();
circuit5.h(clock[0]);
circuit5.h(clock[1]);
#--------------Psi 2---------------------------
circuit5.barrier();
# e^{i*A*t}
circuit5.cu(np.pi/2, -np.pi/2, np.pi/2, 3*np.pi/4, clock[0], input_, label='U');
# e^{i*A*t*2}
circuit5.cu(np.pi, np.pi, 0, 0, clock[1], input_, label='U2');
#--------------Psi 3---------------------------
circuit5.barrier();
circuit5.h(clock[1]);
for j in reversed(range(2)):
for k in reversed(range(j+1,2)):
circuit5.cp(-np.pi/float(2**(k-j)), clock[k], clock[j]); #cu1 changes to cp in the new version
circuit5.h(clock[0]);
circuit5.swap(clock[0], clock[1]);
#--------------Psi 4---------------------------
circuit5.barrier();
circuit5.cry(np.pi, clock[0], ancilla);
circuit5.cry(np.pi/3, clock[1], ancilla);
#--------------Psi 5---------------------------
circuit5.barrier();
circuit5.swap(clock[0], clock[1]);
circuit5.h(clock[0]);
for j in reversed(range(2)):
for k in reversed(range(j+1,2)):
circuit5.cp(np.pi/float(2**(k-j)), clock[k], clock[j]);
circuit5.h(clock[1])
circuit5.measure_all()
circuit5.draw(output='mpl',idle_wires=False)
#--------------Psi 6---------------------------
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
transpiled_ckt5 = transpile(circuit5, provider.get_backend('ibm_brisbane'), seed_transpiler = 13,optimization_level=0)
transpiled_ckt5.draw(output = 'mpl',idle_wires=False)
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Options
service = QiskitRuntimeService()
options = Options()
options.resilience_level = 0
options.optimization_level = 0
#backend = service.least_busy(operational=True, simulator=False)
example_circuit = transpiled_ckt5
service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")
sampler = Sampler(backend, options=options)
job = sampler.run(example_circuit)
print(f"job id: {job.job_id()}")
result = job.result()
print(result)
binary_prob = [quasi_dist.binary_probabilities() for quasi_dist in result.quasi_dists]
plot_histogram(binary_prob)
import csv
data1 = binary_prob
# Fill in missing values in data1 with zeros
filled_data1 = []
for d in data1:
filled_row = {key: d.get(key, 0) for key in all_combinations}
filled_data1.append(filled_row)
# Append filled_data1 to filled_data
filled_data.extend(filled_data1)
# Write the updated filled_data to the same CSV file
csv_file = "data.csv"
with open(csv_file, mode='a', newline='') as file:
writer = csv.DictWriter(file, fieldnames=all_combinations)
for row in filled_data1:
writer.writerow(row)
print(f"Data1 has been added to {csv_file}")
# Register declaration
clock = QuantumRegister(2, name='clock')
input_ = QuantumRegister(1, name='b')
ancilla = QuantumRegister(1, name='ancilla')
circuit6 = QuantumCircuit(ancilla, clock, input_)
#---------------Psi 0--------------------------
circuit6.barrier()
circuit6.x(input_);
#---------------Psi 1--------------------------
circuit6.barrier();
circuit6.h(clock[0]);
circuit6.h(clock[1]);
#--------------Psi 2---------------------------
circuit6.barrier();
# e^{i*A*t}
circuit6.cu(np.pi/2, -np.pi/2, np.pi/2, 3*np.pi/4, clock[0], input_, label='U');
# e^{i*A*t*2}
circuit6.cu(np.pi, np.pi, 0, 0, clock[1], input_, label='U2');
#--------------Psi 3---------------------------
circuit6.barrier();
circuit6.h(clock[1]);
for j in reversed(range(2)):
for k in reversed(range(j+1,2)):
circuit6.cp(-np.pi/float(2**(k-j)), clock[k], clock[j]); #cu1 changes to cp in the new version
circuit6.h(clock[0]);
circuit6.swap(clock[0], clock[1]);
#--------------Psi 4---------------------------
circuit6.barrier();
circuit6.cry(np.pi, clock[0], ancilla);
circuit6.cry(np.pi/3, clock[1], ancilla);
#--------------Psi 5---------------------------
circuit6.barrier();
circuit6.swap(clock[0], clock[1]);
circuit6.h(clock[0]);
for j in reversed(range(2)):
for k in reversed(range(j+1,2)):
circuit6.cp(np.pi/float(2**(k-j)), clock[k], clock[j]);
circuit6.h(clock[1])
#--------------Psi 6---------------------------
circuit6.barrier();
circuit6.cu(np.pi, np.pi, 0, 0, clock[1], input_, label='U2');
# e^{i*A*t}
circuit6.cu(np.pi/2, np.pi/2, -np.pi/2, -3*np.pi/4, clock[0], input_, label='U');
circuit6.measure_all()
circuit6.draw(output='mpl',idle_wires=False)
#--------------Psi 7--------------------------
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
transpiled_ckt6 = transpile(circuit6, provider.get_backend('ibm_brisbane'), seed_transpiler = 13,optimization_level=0)
transpiled_ckt6.draw(output = 'mpl',idle_wires=False)
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Options
service = QiskitRuntimeService()
options = Options()
options.resilience_level = 0
options.optimization_level = 0
#backend = service.least_busy(operational=True, simulator=False)
example_circuit = transpiled_ckt6
service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")
sampler = Sampler(backend, options=options)
job = sampler.run(example_circuit)
print(f"job id: {job.job_id()}")
result = job.result()
print(result)
binary_prob = [quasi_dist.binary_probabilities() for quasi_dist in result.quasi_dists]
plot_histogram(binary_prob)
import csv
data1 = binary_prob
# Fill in missing values in data1 with zeros
filled_data1 = []
for d in data1:
filled_row = {key: d.get(key, 0) for key in all_combinations}
filled_data1.append(filled_row)
# Append filled_data1 to filled_data
filled_data.extend(filled_data1)
# Write the updated filled_data to the same CSV file
csv_file = "data.csv"
with open(csv_file, mode='a', newline='') as file:
writer = csv.DictWriter(file, fieldnames=all_combinations)
for row in filled_data1:
writer.writerow(row)
print(f"Data1 has been added to {csv_file}")
# Register declaration
clock = QuantumRegister(2, name='clock')
input_ = QuantumRegister(1, name='b')
ancilla = QuantumRegister(1, name='ancilla')
circuit7 = QuantumCircuit(ancilla, clock, input_)
#---------------Psi 0--------------------------
circuit7.barrier()
circuit7.x(input_);
#---------------Psi 1--------------------------
circuit7.barrier();
circuit7.h(clock[0]);
circuit7.h(clock[1]);
#--------------Psi 2---------------------------
circuit7.barrier();
# e^{i*A*t}
circuit7.cu(np.pi/2, -np.pi/2, np.pi/2, 3*np.pi/4, clock[0], input_, label='U');
# e^{i*A*t*2}
circuit7.cu(np.pi, np.pi, 0, 0, clock[1], input_, label='U2');
#--------------Psi 3---------------------------
circuit7.barrier();
circuit7.h(clock[1]);
for j in reversed(range(2)):
for k in reversed(range(j+1,2)):
circuit7.cp(-np.pi/float(2**(k-j)), clock[k], clock[j]); #cu1 changes to cp in the new version
circuit7.h(clock[0]);
circuit7.swap(clock[0], clock[1]);
#--------------Psi 4---------------------------
circuit7.barrier();
circuit7.cry(np.pi, clock[0], ancilla);
circuit7.cry(np.pi/3, clock[1], ancilla);
#--------------Psi 5---------------------------
circuit7.barrier();
circuit7.swap(clock[0], clock[1]);
circuit7.h(clock[0]);
for j in reversed(range(2)):
for k in reversed(range(j+1,2)):
circuit7.cp(np.pi/float(2**(k-j)), clock[k], clock[j]);
circuit7.h(clock[1])
#--------------Psi 6---------------------------
circuit7.barrier();
circuit7.cu(np.pi, np.pi, 0, 0, clock[1], input_, label='U2');
# e^{i*A*t}
circuit7.cu(np.pi/2, np.pi/2, -np.pi/2, -3*np.pi/4, clock[0], input_, label='U');
#--------------Psi 7--------------------------
circuit7.barrier();
circuit7.h(clock[0]);
circuit7.h(clock[1]);
#--------------Psi 8---------------------------
circuit7.measure_all();
circuit.draw(output='mpl', style = 'iqp')
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
transpiled_ckt7 = transpile(circuit7, provider.get_backend('ibm_brisbane'), seed_transpiler = 13,optimization_level=0)
transpiled_ckt7.draw(output = 'mpl',idle_wires=False)
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Options
service = QiskitRuntimeService()
options = Options()
options.resilience_level = 0
options.optimization_level = 0
#backend = service.least_busy(operational=True, simulator=False)
example_circuit = transpiled_ckt7
service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")
sampler = Sampler(backend, options=options)
job = sampler.run(example_circuit)
print(f"job id: {job.job_id()}")
result = job.result()
print(result)
binary_prob = [quasi_dist.binary_probabilities() for quasi_dist in result.quasi_dists]
plot_histogram(binary_prob)
import csv
data1 = binary_prob
# Fill in missing values in data1 with zeros
filled_data1 = []
for d in data1:
filled_row = {key: d.get(key, 0) for key in all_combinations}
filled_data1.append(filled_row)
# Append filled_data1 to filled_data
filled_data.extend(filled_data1)
# Write the updated filled_data to the same CSV file
csv_file = "data.csv"
with open(csv_file, mode='a', newline='') as file:
writer = csv.DictWriter(file, fieldnames=all_combinations)
for row in filled_data1:
writer.writerow(row)
print(f"Data1 has been added to {csv_file}")
|
https://github.com/robinsonvs/tcc-information-systems
|
robinsonvs
|
import math
import random
import matplotlib.pyplot as plt
def is_edge(graph, u, v):
return u in graph[v] or v in graph[u]
def generate_clauses(graph, k):
n = len(graph)
clauses = []
# Cláusulas para garantir que k vértices são selecionados
for i in range(1, k+1):
clauses.append([j + n * (i - 1) for j in range(1, n+1)])
# Cláusulas para garantir que não há dois vértices no mesmo slot
for i in range(1, k+1):
for u in range(1, n+1):
for v in range(u + 1, n+1):
clauses.append([-(u + n * (i - 1)), -(v + n * (i - 1))])
# Cláusulas para garantir que todos os pares de vértices no clique são adjacentes
for i in range(1, k):
for j in range(i+1, k+1):
for u in range(1, n+1):
for v in range(1, n+1):
if not is_edge(graph, u-1, v-1):
clauses.append([-(u + n * (i - 1)), -(v + n * (j - 1))])
return clauses
if __name__ == '__main__':
graph = {
0: [1, 2, 3, 4],
1: [0, 2, 3, 4],
2: [0, 1, 3, 4],
3: [0, 1, 2, 4],
4: [0, 1, 2, 3],
}
K = 5
cnf_clauses = generate_clauses(graph, K)
print(cnf_clauses)
print("***************")
expression = ''
for i, clause in enumerate(cnf_clauses):
if i > 0:
expression += ' & '
expression += '(' + ' | '.join(['x' + str(x) if x > 0 else '~x' + str(abs(x)) for x in clause]) + ')'
print(expression)
# Apply "optimized" Grover
from qiskit.circuit.library import PhaseOracle
from qiskit.primitives import Sampler
from qiskit.visualization import plot_histogram
from qiskit_algorithms import AmplificationProblem, Grover
from qiskit import *
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider(token='8f69cea4cf33304753bfe092aacdf58174e59f8e9813d9305e21c248e3bbb19b98b8508540e15ad4959f3a585675058da81276c3871dce532772da60b370566b')
backend = provider.get_backend('ibm_kyoto')
iteracoes = 3
oracle = PhaseOracle(expression)
problem = AmplificationProblem(oracle)
grover = Grover(sampler=Sampler(), iterations=iteracoes)
#results = grover.amplify(problem)
# Construir o circuito do Grover
qc = grover.construct_circuit(problem, iteracoes, True)
# Transpilar o circuito para o backend
transpiled_qc = transpile(qc, backend=backend)
print("Starting ........................")
# Executar o circuito no backend
job = backend.run(transpiled_qc, shots=1024)
result = job.result()
counts = result.get_counts()
# Análise dos resultados
top_measurement = max(counts, key=counts.get)
max_probability = counts[top_measurement] / 1024
oracle_evaluation = 'True' if max_probability > 0 else 'False'
print('É Satisfatível?', oracle_evaluation)
print('Estado amplificado', top_measurement)
print('Probabilidade estado amplificado', max_probability)
print('Iterações máximas', iteracoes)
print('Width', problem.grover_operator.decompose().width())
print('Depth', problem.grover_operator.decompose().depth())
# Gerar somente resultados relevantes
output = {}
for x in counts:
value = counts[x] / 1024
if value >= max_probability - max_probability * 0.05:
output[x] = value
print(f"estado_amplificado: {x} probabilidade {value}")
# Ordenar o output por probabilidade
sorted_output = dict(sorted(output.items(), key=lambda item: item[1], reverse=True))
# Plotar o histograma
plt.bar(sorted_output.keys(), sorted_output.values(), width=0.5)
plt.xticks(fontsize=8, rotation=45)
plt.xlabel('States')
plt.ylabel('Probability')
plt.title('Histogram of Amplified States')
plt.ylim(0, max(sorted_output.values()) * 1.1) # Ajustar o limite superior do eixo y
# Adicionar as probabilidades sobre as barras
for i, (state, probability) in enumerate(sorted_output.items()):
plt.text(i, probability, f'{probability:.2f}', ha='center', va='bottom', fontsize=8)
plt.show()
#input()
|
https://github.com/robinsonvs/tcc-information-systems
|
robinsonvs
|
import random
import pycosat
import numpy as np
from qiskit import QuantumCircuit, transpile, QuantumRegister
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
import networkx as nx
from qiskit import QuantumCircuit as qc
from qiskit import QuantumRegister as qr
from qiskit.result import Counts
from heapq import nlargest
from matplotlib.pyplot import show, subplots, xticks, yticks
from matplotlib.backend_bases import MouseEvent
N: int = 3 # Number of qubits
SEARCH_VALUES: set[int] = { 0,1,3 } # Set of m nonnegative integers to search for using Grover's algorithm (i.e. TARGETS in base 10)
SHOTS: int = 1024 # Amount of times the algorithm is simulated
FONTSIZE: int = 10 # Histogram's font size
TARGETS: set[str] = { f"{s:0{N}b}" for s in SEARCH_VALUES } # Set of m N-qubit binary strings representing target state(s) (i.e. SEARCH_VALUES in base 2)
QUBITS: qr = qr(N, "qubit")
def print_circuit(circuit: qc, name: str = ""):
print(f"\n{name}:" if name else "")
print(f"{circuit}")
def outcome(winners: list[str], counts: Counts):
print("WINNER(S):")
print(f"Binary = {winners}\nDecimal = {[ int(key, 2) for key in winners ]}\n")
print("TARGET(S):")
print(f"Binary = {TARGETS}\nDecimal = {SEARCH_VALUES}\n")
winners_frequency, total = 0, 0
for value, frequency in counts.items():
if value in winners:
winners_frequency += frequency
total += frequency
print(f"Target(s) found with {winners_frequency / total:.2%} accuracy!")
def display_results(results: Counts, combine_other_states: bool = True):
# State(s) with highest count and their frequencies
winners = { winner : results.get(winner) for winner in nlargest(len(TARGETS), results, key = results.get) }
# Print outcome
outcome(list(winners.keys()), results)
# X-axis and y-axis value(s) for winners, respectively
winners_x_axis = [ str(winner) for winner in [*winners] ]
winners_y_axis = [ *winners.values() ]
# All other states (i.e. non-winners) and their frequencies
others = {state : frequency for state, frequency in results.items() if state not in winners}
# X-axis and y-axis value(s) for all other states, respectively
other_states_x_axis = "Others" if combine_other_states else [*others]
other_states_y_axis = [ sum([*others.values()]) ] if combine_other_states else [ *others.values() ]
# Create histogram for simulation results
figure, axes = subplots(num = "Grover's Algorithm — Results", layout = "constrained")
axes.bar(winners_x_axis, winners_y_axis, color = "green", label = "Target")
axes.bar(other_states_x_axis, other_states_y_axis, color = "red", label = "Non-target")
axes.legend(fontsize = FONTSIZE)
axes.grid(axis = "y", ls = "dashed")
axes.set_axisbelow(True)
# Set histogram title, x-axis title, and y-axis title respectively
axes.set_title(f"Outcome of {SHOTS} Simulations", fontsize = int(FONTSIZE * 1.45))
axes.set_xlabel("States (Qubits)", fontsize = int(FONTSIZE * 1.3))
axes.set_ylabel("Frequency", fontsize = int(FONTSIZE * 1.3))
# Set font properties for x-axis and y-axis labels respectively
xticks(fontsize = FONTSIZE, family = "monospace", rotation = 0 if combine_other_states else 70)
yticks(fontsize = FONTSIZE, family = "monospace")
# Set properties for annotations displaying frequency above each bar
annotation = axes.annotate("",
xy = (0, 0),
xytext = (5, 5),
xycoords = "data",
textcoords = "offset pixels",
ha = "center",
va = "bottom",
family = "monospace",
weight = "bold",
fontsize = FONTSIZE,
bbox = dict(facecolor = "white", alpha = 0.4, edgecolor = "None", pad = 0)
)
def hover(event: MouseEvent):
visibility = annotation.get_visible()
if event.inaxes == axes:
for bars in axes.containers:
for bar in bars:
cont, _ = bar.contains(event)
if cont:
x, y = bar.get_x() + bar.get_width() / 2, bar.get_y() + bar.get_height()
annotation.xy = (x, y)
annotation.set_text(y)
annotation.set_visible(True)
figure.canvas.draw_idle()
return
if visibility:
annotation.set_visible(False)
figure.canvas.draw_idle()
# Display histogram
id = figure.canvas.mpl_connect("motion_notify_event", hover)
show()
figure.canvas.mpl_disconnect(id)
def generate_complete_graph(clique_size):
graph = [[1 if i != j else 0 for j in range(clique_size)] for i in range(clique_size)]
return remove_random_edges(graph, clique_size)
def remove_random_edges(graph, clique_size):
num_vertices = len(graph)
max_edges = clique_size * (clique_size - 1) // 2
edges_to_remove = random.sample(range(max_edges, num_vertices * (num_vertices - 1) // 2),
k=num_vertices * (num_vertices - 1) // 2 - max_edges)
for edge in edges_to_remove:
row = edge // num_vertices
col = edge % num_vertices
graph[row][col] = 0
graph[col][row] = 0
return graph
def clique_max_sat(graph):
num_vertices = len(graph)
cnf_clauses = []
# Constraint 1: There is an ith vertex
for i in range(num_vertices):
clique_clause = [j + 1 for j in range(num_vertices) if j != i]
cnf_clauses.append(clique_clause)
# Constraint 2: The ith and jth vertices are different
for i in range(num_vertices):
for j in range(i + 1, num_vertices):
if graph[i][j] == 0:
cnf_clauses.append([-1 * (i + 1), -1 * (j + 1)])
return cnf_clauses
def solve(number_of_vertices, cnf_clauses):
solution = pycosat.solve(cnf_clauses)
if solution != "UNSAT":
return [i for i in range(1, number_of_vertices + 1) if i in solution]
return None
def amplify(num_of_qubits, num_sub_states):
subsets = np.empty(num_sub_states, dtype=object)
N = 2 ** num_of_qubits
index = 0
sup_index = (N // num_sub_states)
if (N % num_sub_states != 0):
k = 0
for i in range(1, num_sub_states):
sup = [0.] * N
num_el = (N // num_sub_states) + 1
for j in range(index, sup_index + 1):
sup[j] = np.sqrt((N / num_el) / N)
subsets[k] = sup
index = index + (N // num_sub_states) + 1
sup_index = sup_index + (N // num_sub_states) + 1
k = k + 1
sup = [0.] * N
for j in range(len(sup)):
sup[j] = np.sqrt((N / num_el) / N)
subsets[num_sub_states - 1] = sup
else:
k = 0
for i in range(0, num_sub_states):
sup = [0.] * N
num_el = N / num_sub_states
for j in range(index, sup_index):
sup[j] = np.sqrt((N / num_el) / N)
subsets[k] = sup
index = index + (N // num_sub_states)
sup_index = sup_index + (N // num_sub_states)
k = k + 1
return subsets
def oracle_circuit(sat, num_qubits, subsets, targets: set[str] = TARGETS, name: str = "Oracle", display_oracle: bool = True):
# oracle = QuantumCircuit(num_qubits + 1, name=name)
# for target in targets:
# # Reverse target state since Qiskit uses little-endian for qubit ordering
# target = target[::-1]
# # Flip zero qubits in target
# for i in range(num_qubits):
# if target[i] == "0":
# oracle.x(i) # Pauli-X gate
# # Simulate (N - 1)-control Z gate
# oracle.h(num_qubits - 1) # Hadamard gate
# oracle.mcx(list(range(num_qubits - 1)), num_qubits - 1) # (N - 1)-control Toffoli gate
# oracle.h(num_qubits - 1) # Hadamard gate
# # Flip back to original state
# for i in range(num_qubits):
# if target[i] == "0":
# oracle.x(i)
# if display_oracle: print_circuit(oracle, "ORACLE")
# return oracle
for clause in sat:
oracle = QuantumCircuit(num_qubits+1)
for literal in clause:
if literal > 0:
#oracle.x(literal-1)
oracle.h(num_qubits - 1)
oracle.mcx(list(range(num_qubits - 1)), num_qubits - 1)
for literal in clause:
if literal > 0:
#oracle.x(literal-1)
oracle.h(num_qubits - 1)
#oracle.append(oracle.to_gate().control(num_qubits+1), list(range(num_qubits+1)))
if display_oracle: print_circuit(oracle, "ORACLE")
return oracle
#using subsets
# qc = QuantumCircuit(num_qubits + 1)
# for i, subset in enumerate(subsets):
# for j, amplitude in enumerate(subset):
# if j < num_qubits:
# #qc.ry(2 * amplitude, j)
# qc.h(num_qubits - 1)
# #qc.mcp(2 * np.pi, list(range(num_qubits)), num_qubits)
# qc.mcx(list(range(num_qubits - 1)), num_qubits - 1)
# for j, amplitude in enumerate(subset):
# if j < num_qubits:
# #qc.ry(-2 * amplitude, j)
# qc.h(num_qubits - 1)
# return qc
def diffusion_circuit(num_qubits, name: str = "Diffuser", display_diffuser: bool = True):
qc = QuantumCircuit(num_qubits, name = name)
for qubit in range(num_qubits):
qc.h(qubit)
for qubit in range(num_qubits):
qc.x(qubit)
qc.h(num_qubits - 1)
qc.mcp(np.pi, list(range(num_qubits - 1)), num_qubits - 1)
qc.h(num_qubits - 1)
for qubit in range(num_qubits):
qc.x(qubit)
for qubit in range(num_qubits):
qc.h(qubit)
if display_diffuser: print_circuit(qc, "DIFFUSER")
return qc
def grover_algorithm(oracle, diffusion, num_iterations, name: str = "Grover Circuit", display_grover: bool = True):
num_qubits = oracle.num_qubits - 1
qc = QuantumCircuit(num_qubits + 1, num_qubits, name = name)
for qubit in range(num_qubits):
qc.h(qubit)
qc.x(num_qubits)
qc.h(num_qubits)
for _ in range(num_iterations):
qc.append(oracle.to_gate(), range(num_qubits + 1))
qc.append(diffusion.to_gate(), range(num_qubits))
qc.measure(range(num_qubits), range(num_qubits))
if display_grover: print_circuit(qc, "GROVER CIRCUIT")
return qc
def map_solution(qubit_configurations, clique_size):
# Mapeia as configurações dos qubits de volta para as soluções do problema original (clique máximo)
solutions = []
for config in qubit_configurations:
solution = [i for i, bit in enumerate(config) if bit == '1']
if len(solution) == clique_size: # Apenas considera as soluções que têm o tamanho correto da clique
solutions.append(solution)
return solutions
if __name__ == '__main__':
k = N
graph = [
[0, 1, 0, 1],
[1, 0, 1, 1],
[0, 1, 0, 0],
[1, 1, 0, 0]
]
#print(graph)
#graph = generate_complete_graph(k)
#print(graph)
# Plotar o grafo gerado
G = nx.Graph()
for i in range(len(graph)):
for j in range(i + 1, len(graph)):
if graph[i][j] == 1:
G.add_edge(i, j)
plt.figure(figsize=(6, 6))
nx.draw(G, with_labels=True, font_weight='bold')
plt.title('Grafo Gerado')
plt.show()
cnf_clauses = clique_max_sat(graph)
print("Fórmula SAT gerada:")
for clause in cnf_clauses:
print(clause)
max_clique = solve(len(graph), cnf_clauses)
print("Clique máximo encontrado pelo solve:", max_clique)
if max_clique:
print("Maximal-Clique problem found:", [x - 1 for x in max_clique])
else:
print("It's not possible to find maximal-clique problem!")
num_qubits = N # Número de qubits necessário para representar a fórmula SAT
num_sub_states = 2 # Número de subestados para dividir o espaço SAT
subsets = amplify(num_qubits, num_sub_states) # Aplicar amplify para otimização da busca
oracle = oracle_circuit(cnf_clauses, num_qubits, subsets)
diffusion = diffusion_circuit(num_qubits)
grover_circuit = grover_algorithm(oracle, diffusion, SHOTS)
backend = AerSimulator()
new_circuit = transpile(grover_circuit, backend)
result = backend.run(new_circuit).result()
counts = result.get_counts(grover_circuit)
print("Counts:", counts)
solutions = map_solution(counts.keys(), len(max_clique))
print("Solutions found:", solutions)
plot_histogram(counts)
plt.show()
display_results(counts, False)
|
https://github.com/robinsonvs/tcc-information-systems
|
robinsonvs
|
import random
import pycosat
import numpy as np
from qiskit import QuantumCircuit, transpile, QuantumRegister
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
import networkx as nx
from qiskit import QuantumCircuit as qc
from qiskit import QuantumRegister as qr
from heapq import nlargest
from matplotlib.pyplot import show, subplots, xticks, yticks
from qiskit import ClassicalRegister
def generate_complete_graph(clique_size):
graph = [[1 if i != j else 0 for j in range(clique_size)] for i in range(clique_size)]
return remove_random_edges(graph, clique_size)
def remove_random_edges(graph, clique_size):
num_vertices = len(graph)
max_edges = clique_size * (clique_size - 1) // 2
edges_to_remove = random.sample(range(max_edges, num_vertices * (num_vertices - 1) // 2),
k=num_vertices * (num_vertices - 1) // 2 - max_edges)
for edge in edges_to_remove:
row = edge // num_vertices
col = edge % num_vertices
graph[row][col] = 0
graph[col][row] = 0
return graph
def clique_max_sat(graph):
num_vertices = len(graph)
cnf_clauses = []
# Constraint 1: There is an ith vertex
for i in range(num_vertices):
clique_clause = [j + 1 for j in range(num_vertices) if j != i]
cnf_clauses.append(clique_clause)
# Constraint 2: The ith and jth vertices are different
for i in range(num_vertices):
for j in range(i + 1, num_vertices):
if graph[i][j] == 0:
cnf_clauses.append([-1 * (i + 1), -1 * (j + 1)])
return cnf_clauses
def solve(number_of_vertices, cnf_clauses):
solution = pycosat.solve(cnf_clauses)
if solution != "UNSAT":
return [i for i in range(1, number_of_vertices + 1) if i in solution]
return None
def amplify(num_of_qubits, num_sub_states):
subsets = np.empty(num_sub_states, dtype=object)
N = 2 ** num_of_qubits
index = 0
sup_index = (N // num_sub_states)
if (N % num_sub_states != 0):
k = 0
for i in range(1, num_sub_states):
sup = [0.] * N
num_el = (N // num_sub_states) + 1
sub_state = QuantumCircuit(num_of_qubits)
for j in range(index, sup_index + 1):
sup[j] = np.sqrt((N / num_el) / N)
sub_state.initialize(sup, range(num_of_qubits))
subsets[k] = sub_state
index = index + (N // num_sub_states) + 1
sup_index = sup_index + (N // num_sub_states) + 1
k = k + 1
sub_state = QuantumCircuit(num_of_qubits)
sup = [0.] * N
for j in range(index-1, sup_index):
sup[j] = np.sqrt((N / num_el) / N)
sub_state.initialize(sup, range(num_of_qubits))
subsets[num_sub_states - 1] = sub_state
else:
k = 0
for i in range(0, num_sub_states):
sup = [0.] * N
num_el = N / num_sub_states
sub_state = QuantumCircuit(num_of_qubits)
for j in range(index, sup_index):
sup[j] = np.sqrt((N / num_el) / N)
sub_state.initialize(sup, range(num_of_qubits))
subsets[k] = sub_state
index = index + (N // num_sub_states)
sup_index = sup_index + (N // num_sub_states)
k = k + 1
return subsets
def n_controlled_Z(circuit, controls, target):
if len(controls) == 1:
circuit.h(target)
circuit.cx(controls[0], target)
circuit.h(target)
elif len(controls) > 1:
circuit.h(target)
circuit.mcx(controls, target)
circuit.h(target)
else:
raise ValueError("At least one control qubit is required for controlled-Z gate.")
def inversion_about_average(circuit, f_in, n):
for j in range(n):
circuit.h(f_in[j])
for j in range(n):
circuit.x(f_in[j])
n_controlled_Z(circuit, [f_in[j] for j in range(n-1)], f_in[n-1])
for j in range(n):
circuit.x(f_in[j])
for j in range(n):
circuit.h(f_in[j])
def input_state(circuit, f_in, f_out, n):
for j in range(n):
circuit.h(f_in[j])
circuit.x(f_out)
circuit.h(f_out)
def oracle(circuit, f_in, f_out, aux, cnf_sat):
num_clauses = len(cnf_sat)
for (k, clause) in enumerate(cnf_sat):
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
if num_clauses > 0:
circuit.mcx(aux[:-1], f_out[0])
for (k, clause) in enumerate(cnf_sat):
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
if __name__ == '__main__':
graph = generate_complete_graph(3)
G = nx.Graph()
for i in range(len(graph)):
for j in range(i + 1, len(graph)):
if graph[i][j] == 1:
G.add_edge(i, j)
plt.figure(figsize=(6, 6))
nx.draw(G, with_labels=True, font_weight='bold')
plt.title('Grafo Gerado')
plt.show()
cnf_clauses = clique_max_sat(graph)
for clause in cnf_clauses:
print(clause)
print(cnf_clauses)
max_clique = solve(len(graph), cnf_clauses)
print("Clique máximo :", max_clique)
num_qubits = 3
num_sub_states = 2
subsets = amplify(num_qubits, num_sub_states)
#cnf_clauses = [[1, 2, 3], [-1, -2, -3], [-1, -2, -3]]
#cnf_clauses = [[1, 2, -3], [-1, -2, -3], [-1, 2, 3]]
#cnf_clauses = [[1, -2, -3, -4], [-1, 2, -3, -4], [-1, -2, 3, -4], [-1, -2, -3, 4]]
#cnf_clauses = [[-1, -2, -3, -4], [-1, -2, -3, -4], [-1, -2, -3, -4], [-1, -2, -3, -4]]
f_in = QuantumRegister(num_qubits)
f_out = QuantumRegister(1)
aux = QuantumRegister(len(cnf_clauses) + 1)
ans = ClassicalRegister(num_qubits)
grover = QuantumCircuit()
grover.add_register(f_in)
grover.add_register(f_out)
grover.add_register(aux)
grover.add_register(ans)
#print(grover)
#substate_circuit = QuantumCircuit(num_qubits)
#substate_circuit.initialize(subsets[0], range(num_qubits))
#grover = grover.compose(substate_circuit)
input_state(grover, f_in, f_out, num_qubits)
grover = grover.compose(subsets[0])
#print(grover)
#input_state(grover, f_in, f_out, num_qubits)
#print(grover)
T = 2
for t in range(T):
oracle(grover, f_in, f_out, aux, cnf_clauses)
inversion_about_average(grover, f_in, num_qubits)
for j in range(num_qubits):
grover.measure(f_in[j], ans[j])
#print(grover)
backend = AerSimulator()
new_circuit = transpile(grover, backend)
result = backend.run(new_circuit).result()
counts = result.get_counts(grover)
print("Counts:", counts)
plot_histogram(counts)
plt.show()
|
https://github.com/robinsonvs/tcc-information-systems
|
robinsonvs
|
from qiskit import QuantumCircuit as qc
from qiskit import QuantumRegister as qr
from qiskit import transpile
from qiskit.providers import Backend
from qiskit.quantum_info import DensityMatrix as dm
from qiskit.result import Counts
from qiskit.visualization import plot_histogram
from qiskit_ibm_runtime import QiskitRuntimeService
from math import pi, sqrt
from heapq import nlargest
"""Number of qubits."""
N: int = 5
"""Set of m nonnegative integers to search for using Grover's algorithm (i.e. TARGETS in base 10)."""
SEARCH_VALUES: set[int] = { 11, 9, 0, 3 }
"""Amount of times to simulate the algorithm."""
SHOTS: int = 10000
"""Set of m N-qubit binary strings representing target state(s) (i.e. SEARCH_VALUES in base 2)."""
TARGETS: set[str] = { f"{s:0{N}b}" for s in SEARCH_VALUES }
"""N-qubit quantum register."""
QUBITS: qr = qr(N, "qubit")
"""Name of backend to run the algorithm on."""
BACKEND_NAME: str = "ibmq_qasm_simulator"
"""Backend to run the algorithm on."""
BACKEND: Backend = QiskitRuntimeService().backend(BACKEND_NAME)
def oracle(targets: set[str] = TARGETS, name: str = "Oracle") -> qc:
"""Mark target state(s) with negative phase.
Args:
targets (set[str]): N-qubit binary string(s) representing target state(s). Defaults to TARGETS.
name (str, optional): Quantum circuit's name. Defaults to "Oracle".
Returns:
qc: Quantum circuit representation of oracle.
"""
# Create N-qubit quantum circuit for oracle
oracle = qc(QUBITS, name = name)
for target in targets:
# Reverse target state since Qiskit uses little-endian for qubit ordering
target = target[::-1]
# Flip zero qubits in target
for i in range(N):
if target[i] == "0":
oracle.x(i) # Pauli-X gate
# Simulate (N - 1)-control Z gate
oracle.h(N - 1) # Hadamard gate
oracle.mcx(list(range(N - 1)), N - 1) # (N - 1)-control Toffoli gate
oracle.h(N - 1) # Hadamard gate
# Flip back to original state
for i in range(N):
if target[i] == "0":
oracle.x(i) # Pauli-X gate
return oracle
# Generate and display quantum circuit for oracle
grover_oracle = oracle()
grover_oracle.draw("mpl", style = "iqp")
def diffuser(name: str = "Diffuser") -> qc:
"""Amplify target state(s) amplitude, which decreases the amplitudes of other states
and increases the probability of getting the correct solution (i.e. target state(s)).
Args:
name (str, optional): Quantum circuit's name. Defaults to "Diffuser".
Returns:
qc: Quantum circuit representation of diffuser (i.e. Grover's diffusion operator).
"""
# Create N-qubit quantum circuit for diffuser
diffuser = qc(QUBITS, name = name)
diffuser.h(QUBITS) # Hadamard gate
diffuser.append(oracle({ "0" * N }), list(range(N))) # Oracle with all zero target state
diffuser.h(QUBITS) # Hadamard gate
return diffuser
# Generate and display quantum circuit for diffuser
grover_diffuser = diffuser()
grover_diffuser.draw("mpl", style = "iqp")
def grover(oracle: qc = oracle(), diffuser: qc = diffuser(), name: str = "Grover Circuit") -> tuple[qc, dm]:
"""Create quantum circuit representation of Grover's algorithm,
which consists of 4 parts: (1) state preparation/initialization,
(2) oracle, (3) diffuser, and (4) measurement of resulting state.
Steps 2-3 are repeated an optimal number of times (i.e. Grover's
iterate) in order to maximize probability of success of Grover's algorithm.
Args:
oracle (qc, optional): Quantum circuit representation of oracle. Defaults to oracle().
diffuser (qc, optional): Quantum circuit representation of diffuser. Defaults to diffuser().
name (str, optional): Quantum circuit's name. Defaults to "Grover Circuit".
Returns:
tuple[qc, dm]: Quantum circuit representation of Grover's algorithm and its density matrix.
"""
# Create N-qubit quantum circuit for Grover's algorithm
grover = qc(QUBITS, name = name)
# Intialize qubits with Hadamard gate (i.e. uniform superposition)
grover.h(QUBITS)
# Apply barrier to separate steps
grover.barrier()
# Apply oracle and diffuser (i.e. Grover operator) optimal number of times
for _ in range(int((pi / 4) * sqrt((2 ** N) / len(TARGETS)))):
grover.append(oracle, list(range(N)))
grover.append(diffuser, list(range(N)))
# Generate density matrix representation of Grover's algorithm
density_matrix = dm(grover)
# Measure all qubits once finished
grover.measure_all()
return grover, density_matrix
# Save density matrix and generate and display quantum circuit for Grover's algorithm
grover_circuit, density_matrix = grover(grover_oracle, grover_diffuser)
grover_circuit.draw("mpl", style = "iqp")
def outcome(winners: list[str], counts: Counts) -> None:
"""Print top measurement(s) (state(s) with highest frequency)
and target state(s) in binary and decimal form, determine
if top measurement(s) equals target state(s), then print result.
Args:
winners (list[str]): State(s) (N-qubit binary string(s))
with highest probability of being measured.
counts (Counts): Each state and its respective frequency.
"""
print("WINNER(S):")
print(f"Binary = {winners}\nDecimal = {[ int(key, 2) for key in winners ]}\n")
print("TARGET(S):")
print(f"Binary = {TARGETS}\nDecimal = {SEARCH_VALUES}\n")
if not all(key in TARGETS for key in winners): print ("Target(s) not found...")
else:
winners_frequency, total = 0, 0
for value, frequency in counts.items():
if value in winners:
winners_frequency += frequency
total += frequency
print(f"Target(s) found with {winners_frequency / total:.2%} accuracy!")
# Simulate Grover's algorithm with Qiskit backend and get results
with BACKEND.open_session() as session:
results = BACKEND.run(transpile(grover_circuit, BACKEND, optimization_level = 2), shots = SHOTS).result()
# Get each state's frequency
counts = results.get_counts()
# Find winner(s) (i.e. state(s) with highest count)
winners = nlargest(len(TARGETS), counts, key = counts.get)
# Print outcome
outcome(winners, counts)
# Display simulation results as histogram
plot_histogram(data = counts, number_to_keep = len(TARGETS))
# City plot of density_matrix
density_matrix.draw("city")
# Bloch sphere representation of density_matrix
# reverse_bits = True since Qiskit uses little-endian for qubit ordering
density_matrix.draw("bloch", reverse_bits = True)
# Hinton plot of density_matrix
density_matrix.draw("hinton")
# Qsphere representation of density_matrix
density_matrix.draw("qsphere")
|
https://github.com/robinsonvs/tcc-information-systems
|
robinsonvs
|
from qiskit import QuantumCircuit as qc
from qiskit import QuantumRegister as qr
from qiskit import transpile
from qiskit.providers import Backend
from qiskit.result import Counts
from qiskit_ibm_runtime import QiskitRuntimeService
from matplotlib.pyplot import show, subplots, xticks, yticks
from matplotlib.backend_bases import MouseEvent
from math import pi, sqrt
from heapq import nlargest
from qiskit_aer import AerSimulator
"""Feel free to modify the following constants."""
N: int = 5 # Number of qubits
SEARCH_VALUES: set[int] = { 11, 9, 0, 3 } # Set of m nonnegative integers to search for using Grover's algorithm (i.e. TARGETS in base 10)
SHOTS: int = 10000 # Amount of times the algorithm is simulated
FONTSIZE: int = 10 # Histogram's font size
"""Unless you know what you are doing, please do not modify the following constants, otherwise you risk breaking the program."""
TARGETS: set[str] = { f"{s:0{N}b}" for s in SEARCH_VALUES } # Set of m N-qubit binary strings representing target state(s) (i.e. SEARCH_VALUES in base 2)
QUBITS: qr = qr(N, "qubit") # N-qubit quantum register
#BACKEND_NAME: str = "ibmq_qasm_simulator" # Name of backend to run the algorithm on
#BACKEND: Backend = QiskitRuntimeService().backend(BACKEND_NAME) # Backend to run the algorithm on
BACKEND: Backend = AerSimulator()
def print_circuit(circuit: qc, name: str = "") -> None:
"""Print quantum circuit.
Args:
circuit (qc): Quantum circuit to print.
name (str, optional): Quantum circuit's name. Defaults to None.
"""
print(f"\n{name}:" if name else "")
print(f"{circuit}")
def oracle(targets: set[str] = TARGETS, name: str = "Oracle", display_oracle: bool = True) -> qc:
"""Mark target state(s) with negative phase.
Args:
targets (set[str]): N-qubit binary string(s) representing target state(s). Defaults to TARGETS.
name (str, optional): Quantum circuit's name. Defaults to "Oracle".
display_oracle (bool, optional): Whether or not to display oracle. Defaults to True.
Returns:
qc: Quantum circuit representation of oracle.
"""
# Create N-qubit quantum circuit for oracle
oracle = qc(QUBITS, name = name)
for target in targets:
# Reverse target state since Qiskit uses little-endian for qubit ordering
target = target[::-1]
# Flip zero qubits in target
for i in range(N):
if target[i] == "0":
oracle.x(i) # Pauli-X gate
# Simulate (N - 1)-control Z gate
oracle.h(N - 1) # Hadamard gate
oracle.mcx(list(range(N - 1)), N - 1) # (N - 1)-control Toffoli gate
oracle.h(N - 1) # Hadamard gate
# Flip back to original state
for i in range(N):
if target[i] == "0":
oracle.x(i) # Pauli-X gate
# Display oracle, if applicable
if display_oracle: print_circuit(oracle, "ORACLE")
return oracle
def diffuser(name: str = "Diffuser", display_diffuser: bool = True) -> qc:
"""Amplify target state(s) amplitude, which decreases the amplitudes of other states
and increases the probability of getting the correct solution (i.e. target state(s)).
Args:
name (str, optional): Quantum circuit's name. Defaults to "Diffuser".
display_diffuser (bool, optional): Whether or not to display diffuser. Defaults to True.
Returns:
qc: Quantum circuit representation of diffuser (i.e. Grover's diffusion operator).
"""
# Create N-qubit quantum circuit for diffuser
diffuser = qc(QUBITS, name = name)
diffuser.h(QUBITS) # Hadamard gate
diffuser.append(oracle({"0" * N}), list(range(N))) # Oracle with all zero target state
diffuser.h(QUBITS) # Hadamard gate
# Display diffuser, if applicable
if display_diffuser: print_circuit(diffuser, "DIFFUSER")
return diffuser
def grover(oracle: qc = oracle(), diffuser: qc = diffuser(), name: str = "Grover Circuit", display_grover: bool = True) -> qc:
"""Create quantum circuit representation of Grover's algorithm,
which consists of 4 parts: (1) state preparation/initialization,
(2) oracle, (3) diffuser, and (4) measurement of resulting state.
Steps 2-3 are repeated an optimal number of times (i.e. Grover's
iterate) in order to maximize probability of success of Grover's algorithm.
Args:
oracle (qc, optional): Quantum circuit representation of oracle. Defaults to oracle().
diffuser (qc, optional): Quantum circuit representation of diffuser. Defaults to diffuser().
name (str, optional): Quantum circuit's name. Defaults to "Grover Circuit".
display_grover (bool, optional): Whether or not to display grover circuit. Defaults to True.
Returns:
qc: Quantum circuit representation of Grover's algorithm.
"""
# Create N-qubit quantum circuit for Grover's algorithm
grover = qc(QUBITS, name = name)
# Intialize qubits with Hadamard gate (i.e. uniform superposition)
grover.h(QUBITS)
# # Apply barrier to separate steps
grover.barrier()
# Apply oracle and diffuser (i.e. Grover operator) optimal number of times
for _ in range(int((pi / 4) * sqrt((2 ** N) / len(TARGETS)))):
grover.append(oracle, list(range(N)))
grover.append(diffuser, list(range(N)))
# Measure all qubits once finished
grover.measure_all()
# Display grover circuit, if applicable
if display_grover: print_circuit(grover, "GROVER CIRCUIT")
return grover
def outcome(winners: list[str], counts: Counts) -> None:
"""Print top measurement(s) (state(s) with highest frequency)
and target state(s) in binary and decimal form, determine
if top measurement(s) equals target state(s), then print result.
Args:
winners (list[str]): State(s) (N-qubit binary string(s))
with highest probability of being measured.
counts (Counts): Each state and its respective frequency.
"""
print("WINNER(S):")
print(f"Binary = {winners}\nDecimal = {[ int(key, 2) for key in winners ]}\n")
print("TARGET(S):")
print(f"Binary = {TARGETS}\nDecimal = {SEARCH_VALUES}\n")
if not all(key in TARGETS for key in winners): print("Target(s) not found...")
else:
winners_frequency, total = 0, 0
for value, frequency in counts.items():
if value in winners:
winners_frequency += frequency
total += frequency
print(f"Target(s) found with {winners_frequency / total:.2%} accuracy!")
def display_results(results: Counts, combine_other_states: bool = True) -> None:
"""Print outcome and display histogram of simulation results.
Args:
results (Counts): Each state and its respective frequency.
combine_other_states (bool, optional): Whether to combine all non-winning states into 1 bar
labeled "Others" or not. Defaults to True.
"""
# State(s) with highest count and their frequencies
winners = { winner : results.get(winner) for winner in nlargest(len(TARGETS), results, key = results.get) }
# Print outcome
outcome(list(winners.keys()), results)
# X-axis and y-axis value(s) for winners, respectively
winners_x_axis = [ str(winner) for winner in [*winners] ]
winners_y_axis = [ *winners.values() ]
# All other states (i.e. non-winners) and their frequencies
others = {state : frequency for state, frequency in results.items() if state not in winners}
# X-axis and y-axis value(s) for all other states, respectively
other_states_x_axis = "Others" if combine_other_states else [*others]
other_states_y_axis = [ sum([*others.values()]) ] if combine_other_states else [ *others.values() ]
# Create histogram for simulation results
figure, axes = subplots(num = "Grover's Algorithm — Results", layout = "constrained")
axes.bar(winners_x_axis, winners_y_axis, color = "green", label = "Target")
axes.bar(other_states_x_axis, other_states_y_axis, color = "red", label = "Non-target")
axes.legend(fontsize = FONTSIZE)
axes.grid(axis = "y", ls = "dashed")
axes.set_axisbelow(True)
# Set histogram title, x-axis title, and y-axis title respectively
axes.set_title(f"Outcome of {SHOTS} Simulations", fontsize = int(FONTSIZE * 1.45))
axes.set_xlabel("States (Qubits)", fontsize = int(FONTSIZE * 1.3))
axes.set_ylabel("Frequency", fontsize = int(FONTSIZE * 1.3))
# Set font properties for x-axis and y-axis labels respectively
xticks(fontsize = FONTSIZE, family = "monospace", rotation = 0 if combine_other_states else 70)
yticks(fontsize = FONTSIZE, family = "monospace")
# Set properties for annotations displaying frequency above each bar
annotation = axes.annotate("",
xy = (0, 0),
xytext = (5, 5),
xycoords = "data",
textcoords = "offset pixels",
ha = "center",
va = "bottom",
family = "monospace",
weight = "bold",
fontsize = FONTSIZE,
bbox = dict(facecolor = "white", alpha = 0.4, edgecolor = "None", pad = 0)
)
def hover(event: MouseEvent) -> None:
"""Display frequency above each bar upon hovering over it.
Args:
event (MouseEvent): Matplotlib mouse event.
"""
visibility = annotation.get_visible()
if event.inaxes == axes:
for bars in axes.containers:
for bar in bars:
cont, _ = bar.contains(event)
if cont:
x, y = bar.get_x() + bar.get_width() / 2, bar.get_y() + bar.get_height()
annotation.xy = (x, y)
annotation.set_text(y)
annotation.set_visible(True)
figure.canvas.draw_idle()
return
if visibility:
annotation.set_visible(False)
figure.canvas.draw_idle()
# Display histogram
id = figure.canvas.mpl_connect("motion_notify_event", hover)
show()
figure.canvas.mpl_disconnect(id)
if __name__ == "__main__":
# Generate quantum circuit for Grover's algorithm
grover_circuit = grover()
# Simulate Grover's algorithm with a Qiskit backend and get results
#with BACKEND.open_session() as session:
# results = BACKEND.run(transpile(grover_circuit, BACKEND, optimization_level = 2), shots = SHOTS).result()
new_circuit = transpile(grover_circuit, BACKEND)
result = BACKEND.run(new_circuit).result()
results = result.get_counts(grover_circuit)
# Get each state's frequency and display simulation results
display_results(results, False)
|
https://github.com/FilipeChagasDev/register-by-constant-qft-adder
|
FilipeChagasDev
|
#By Filipe Chagas
#2022
import qiskit
from math import *
def qft(n: int) -> qiskit.circuit.Gate:
"""Returns a QFT gate for n qubits.
:param n: Number of target qubits.
:type n: int
:return: QFT gate.
:rtype: qiskit.circuit.Gate
"""
def rotations(my_circuit: qiskit.circuit.Gate, m: int):
if m == 0:
return my_circuit
else:
my_circuit.h(m-1) #Add a Haddamard gate to the most significant qubit
for i in range(m-1):
my_circuit.crz(pi/(2**(m-1-i)), i, m-1)
rotations(my_circuit, m-1)
my_circuit = qiskit.QuantumCircuit(n, name='QFT')
rotations(my_circuit, n)
for m in range(n//2):
my_circuit.swap(m, n-m-1)
return my_circuit.to_gate()
|
https://github.com/FilipeChagasDev/register-by-constant-qft-adder
|
FilipeChagasDev
|
#By Filipe Chagas
#2022
import qiskit
from math import *
from qiskit_quantum_fourier_transform import qft
from numeric_systems import *
def reg_by_const_fourier_basis_adder(n: int, c: int) -> qiskit.circuit.Gate:
"""
Register-by-constant addition gate in Fourier basis.
Get a gate to perform an addition of a constant $c$ to an integer register in Fourier basis.
No ancillary qubits needed.
[see https://doi.org/10.48550/arXiv.2207.05309]
:param n: Number of target qubits.
:type n: int
:param c: Constant to add.
:type c: int
:return: $U_{\phi(+)}(c)$ gate.
:rtype: qiskit.circuit.Gate
"""
assert n > 0
my_circuit = qiskit.QuantumCircuit(n, name=f'$U_{{\\phi(+)}}({c})$')
for i in range(n):
theta = c * (pi / (2**(n-i-1)))
my_circuit.rz(theta, i)
return my_circuit.to_gate()
def reg_by_const_qft_adder(n: int, c: int) -> qiskit.circuit.Gate:
"""
Register-by-constant QFT addition gate.
Get a gate to perform an addition of a constant $c$ to a integer register.
No ancillary qubits needed.
[see https://doi.org/10.48550/arXiv.2207.05309]
:param n: Number of target qubits.
:type n: int
:param c: Constant to add.
:type c: int
:return: $U_{+}(c)$ gate.
:rtype: qiskit.circuit.Gate
"""
assert n > 0
my_circuit = qiskit.QuantumCircuit(n, name=f'$U_{{+}}({c})$')
my_qft = qft(n)
my_circuit.append(my_qft, list(range(n)))
my_circuit.append(reg_by_const_fourier_basis_adder(n, c), list(range(n)))
my_circuit.append(my_qft.inverse(), list(range(n)))
return my_circuit.to_gate()
|
https://github.com/FilipeChagasDev/register-by-constant-qft-adder
|
FilipeChagasDev
|
import qiskit
from qiskit_reg_by_const_qft_adder import reg_by_const_qft_adder
from numeric_systems import *
from typing import *
from test_tools import *
for a in range(-4, 3):
for c in range(-4, 3):
#Create the quantum circuit
my_circuit = qiskit.QuantumCircuit(4)
#Initialize register with $a$
a_binary = integer_to_binary(a, 4)
for i in range(4):
if a_binary[i] == True:
my_circuit.x(i)
#Create gate
g = reg_by_const_qft_adder(4, c)
#Append gate to the circuit
my_circuit.append(g, list(range(4)))
#Append measurements
my_circuit.measure_all()
#Simulation
result_binary = one_shot_simulation(my_circuit)
result_integer = binary_to_integer(result_binary)
print(f'a={a}, c={c}, result={result_integer}')
|
https://github.com/FilipeChagasDev/register-by-constant-qft-adder
|
FilipeChagasDev
|
# By Filipe Chagas
# 2022
import qiskit
from numeric_systems import *
from typing import *
def result_string_to_list(result: str) -> List[bool]:
"""Convert a string result to a list of bits.
:param result: String result from Qiskit.
:type result: str
:return: List of bits. Most significant bit last.
:rtype: List[bool]
"""
return [(True if c == '1' else False) for c in result[::-1]]
def extract_register_from_result(result: List[bool], register: List[int]) -> List[bool]:
"""Extract a register from a list of bits.
:param result: List of bits from Qiskit result. Most significant bit last.
:type result: List[bool]
:param register: List of register's qubits indexes. Most significant bit last.
:type register: List[int]
:return: List of bits. Most significant bit last.
:rtype: List[bool]
"""
return [result[i] for i in register]
def one_shot_simulation(circuit: qiskit.QuantumCircuit) -> List[bool]:
"""Do a one-shot simulation with Qiskit and return it's result as a list of bits.
:param circuit: Qiskit quantum circuit.
:type circuit: qiskit.QuantumCircuit
:return: List of bits. Most significant bit last.
:rtype: List[bool]
"""
backend = qiskit.BasicAer.get_backend('qasm_simulator')
job = qiskit.execute(circuit, backend, shots=1)
counts = job.result().get_counts()
result_string = list(counts.keys())[0]
return result_string_to_list(result_string)
|
https://github.com/sahar-saoudi/Bernstein-Vazirani-Circuit
|
sahar-saoudi
|
from qiskit import QuantumCircuit
import matplotlib.pyplot as plt
from qiskit.circuit import Gate
from qiskit.visualization import plot_histogram
def oracle_function(qubits_number: int, secret_number: int) -> Gate:
"""
This function returns a gate corresponding to the question asked
to know the secret number
"""
assert 0 < secret_number < (2**qubits_number-1)
assert qubits_number>0
oracle_circuit = QuantumCircuit(qubits_number+ 1, name="oracle")
for qubit, bit in enumerate(reversed(f"{secret_number:0{qubits_number}b}")):
if bit == '1':
oracle_circuit.cx(qubit, qubits_number)
oracle=oracle_circuit.to_gate()
return oracle
def circuit_function(oracle: Gate) -> QuantumCircuit:
"""
This function returns the quantum circuit that represents
the algorithm of Bernstein Vazirani
"""
qubits_number = oracle.num_qubits
circuit = QuantumCircuit(qubits_number, qubits_number-1)
circuit.x(qubits_number-1)
circuit.h(range(qubits_number))
circuit.barrier()
circuit.append(oracle, range(qubits_number))
circuit.barrier()
circuit.h(range(qubits_number-1))
circuit.barrier()
circuit.measure(range(qubits_number-1), range(qubits_number-1))
circuit.barrier()
return circuit
#example:
oracle = oracle_function(6, 33)
circuit = circuit_function(oracle)
print(circuit)
circuit.draw(output="mpl", style="clifford")
plt.show()
|
https://github.com/ansh25saini/Grover_Algorithm_Project
|
ansh25saini
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
from qiskit.circuit.library.standard_gates import XGate, HGate
from operator import *
n = 3
N = 8 #2**n
index_colour_table = {}
colour_hash_map = {}
index_colour_table = {'000':"yellow", '001':"red", '010':"blue", '011':"red", '100':"green", '101':"blue", '110':"orange", '111':"red"}
colour_hash_map = {"yellow":'100', "red":'011', "blue":'000', "green":'001', "orange":'010'}
def database_oracle(index_colour_table, colour_hash_map):
circ_database = QuantumCircuit(n + n)
for i in range(N):
circ_data = QuantumCircuit(n)
idx = bin(i)[2:].zfill(n) # removing the "0b" prefix appended by the bin() funtion
colour = index_colour_table[idx]
colour_hash = colour_hash_map[colour][::-1]
for j in range(n):
if colour_hash[j] == '1':
circ_data.x(j)
# qiskit maps the rightmost bit as the 0th qubit -> qn, ..., q0
# we therefore reverse the index string -> q0, ..., qn
data_gate = circ_data.to_gate(label=colour).control(num_ctrl_qubits=n, ctrl_state=idx, label="index-"+colour)
circ_database.append(data_gate, list(range(n+n)))
return circ_database
# drawing the database oracle circuit
print("Database Encoding")
database_oracle(index_colour_table, colour_hash_map).draw()
circ_data = QuantumCircuit(n)
m = 4
idx = bin(m)[2:].zfill(n) # removing the "0b" prefix appended by the bin() funtion
colour = index_colour_table[idx]
colour_hash = colour_hash_map[colour][::-1]
for j in range(n):
if colour_hash[j] == '1':
circ_data.x(j)
print("Internal colour encoding for the colour green (as an example)");
circ_data.draw()
def oracle_grover(database, data_entry):
circ_grover = QuantumCircuit(n + n + 1)
circ_grover.append(database, list(range(n+n)))
target_reflection_gate = XGate().control(num_ctrl_qubits=n, ctrl_state=colour_hash_map[data_entry], label="Reflection of " + "\"" + data_entry + "\" Target")
# control() missing 1 required positional argument: 'self' .... if only 'XGate' used instead of 'XGate()'
# The “missing 1 required positional argument: 'self'” error is raised when you do not instantiate an object of a class before calling a class method. This error is also raised when you incorrectly instantiate a class.
circ_grover.append(target_reflection_gate, list(range(n, n+n+1)))
circ_grover.append(database, list(range(n+n)))
return circ_grover
print("Grover Oracle (target example: orange)")
oracle_grover(database_oracle(index_colour_table, colour_hash_map).to_gate(label="Database Encoding"), "orange").decompose().draw()
def mcz_gate(num_qubits):
num_controls = num_qubits - 1
mcz_gate = QuantumCircuit(num_qubits)
target_mcz = QuantumCircuit(1)
target_mcz.z(0)
target_mcz = target_mcz.to_gate(label="Z_Gate").control(num_ctrl_qubits=num_controls, ctrl_state=None, label="MCZ")
mcz_gate.append(target_mcz, list(range(num_qubits)))
return mcz_gate.reverse_bits()
print("Multi-controlled Z (MCZ) Gate")
mcz_gate(n).decompose().draw()
def diffusion_operator(num_qubits):
circ_diffusion = QuantumCircuit(num_qubits)
qubits_list = list(range(num_qubits))
# Layer of H^n gates
circ_diffusion.h(qubits_list)
# Layer of X^n gates
circ_diffusion.x(qubits_list)
# Layer of Multi-controlled Z (MCZ) Gate
circ_diffusion = circ_diffusion.compose(mcz_gate(num_qubits), qubits_list)
# Layer of X^n gates
circ_diffusion.x(qubits_list)
# Layer of H^n gates
circ_diffusion.h(qubits_list)
return circ_diffusion
print("Diffusion Circuit")
diffusion_operator(n).draw()
# Putting it all together ... !!!
item = "green"
print("Searching for the index of the colour", item)
circuit = QuantumCircuit(n + n + 1, n)
circuit.x(n + n)
circuit.barrier()
circuit.h(list(range(n)))
circuit.h(n+n)
circuit.barrier()
unitary_oracle = oracle_grover(database_oracle(index_colour_table, colour_hash_map).to_gate(label="Database Encoding"), item).to_gate(label="Oracle Operator")
unitary_diffuser = diffusion_operator(n).to_gate(label="Diffusion Operator")
M = countOf(index_colour_table.values(), item)
Q = int(np.pi * np.sqrt(N/M) / 4)
for i in range(Q):
circuit.append(unitary_oracle, list(range(n + n + 1)))
circuit.append(unitary_diffuser, list(range(n)))
circuit.barrier()
circuit.measure(list(range(n)), list(range(n)))
circuit.draw()
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(circuit, backend_sim), shots=1024)
result_sim = job_sim.result()
counts = result_sim.get_counts(circuit)
if M==1:
print("Index of the colour", item, "is the index with most probable outcome")
else:
print("Indices of the colour", item, "are the indices the most probable outcomes")
from qiskit.visualization import plot_histogram
plot_histogram(counts)
|
https://github.com/S-Ganesh980/Implementing-Grover-s-Algorithm
|
S-Ganesh980
|
from qiskit.quantum_info import Operator
from qiskit import QuantumCircuit
import numpy as np
def phase_oracle(n, indices_to_mark, name = 'Oracle'):
qc = QuantumCircuit(n, name=name)
# create the identity matrix on n qubits
oracle_matrix = np.identity(2**n)
# add the -1 phase to marked elements
for index_to_mark in indices_to_mark:
oracle_matrix[index_to_mark, index_to_mark] = -1
# convert your matrix (called oracle_matrix) into an operator, and add it to the quantum circuit
qc.unitary(Operator(oracle_matrix), range(n))
return qc
def diffuser(n):
# create a quantum circuit on n qubits
qc = QuantumCircuit(n, name='Diffuser')
# apply hadamard gates to all qubits
qc.h(range(n))
# call the phase oracle applied to the zero state
qc.append(phase_oracle(n, [0]), range(n))
# apply hadamard gates to all qubits
qc.h(range(n))
return qc
def Grover(n, indices_of_marked_elements):
# Create a quantum circuit on n qubits
qc = QuantumCircuit(n, n)
# Determine r
r = int(np.floor(np.pi/4*np.sqrt(2**n/len(indices_of_marked_elements))))
print(f'{n} qubits, basis states {indices_of_marked_elements} marked, {r} rounds')
# step 1: apply Hadamard gates on all qubits
qc.h(range(n))
# step 2: apply r rounds of the phase oracle and the diffuser
for _ in range(r):
qc.append(phase_oracle(n, indices_of_marked_elements), range(n))
qc.append(diffuser(n), range(n))
# step 3: measure all qubits
qc.measure(range(n), range(n))
return qc
mycircuit = Grover(6, [1, 42])
mycircuit.draw()
from qiskit import Aer, execute
simulator = Aer.get_backend('qasm_simulator')
counts = execute(mycircuit, backend=simulator, shots=1000).result().get_counts(mycircuit)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
|
https://github.com/LarianeMohceneMouad/Variation-Circuit-Based-Hybrid-Quantum-Classical-Binary-Algorithm
|
LarianeMohceneMouad
|
!pip install qiskit
!pip install pylatexenc
from sklearn import model_selection, datasets, svm
from qiskit import QuantumCircuit, Aer, IBMQ, QuantumRegister, ClassicalRegister
import numpy as np
import qiskit
import copy
import matplotlib.pyplot as plt
np.random.seed(42)
iris = datasets.load_iris()
X = iris.data[0:100]
Y = iris.target[0:100]
X_train, X_test, Y_train, Y_test = model_selection.train_test_split(X, Y, test_size=0.33, random_state=42)
N = 4
def feature_map(X, encoding_type):
q = QuantumRegister(N)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
if encoding_type == 'rx':
for i, x in enumerate(X):
qc.rx(x, i)
elif encoding_type == 'ry':
for i, x in enumerate(X):
qc.ry(x, i)
elif encoding_type == 'rz':
for i, x in enumerate(X):
qc.rz(x, i)
return qc, c
# feature map test
qc,c = feature_map(X[0], 'rx')
qc.draw('mpl')
def variational_circuit(qc, theta, rotation_type):
for i in range(N-1):
qc.cnot(i, i+1)
qc.cnot(N-1, 0)
if rotation_type == 'rx':
for i in range(N):
qc.rx(theta[i], i)
elif rotation_type == 'ry':
for i in range(N):
qc.ry(theta[i], i)
elif rotation_type == 'rz':
for i in range(N):
qc.rz(theta[i], i)
return qc
qc = variational_circuit(qc, np.ones(4), 'ry')
qc.draw('mpl')
def quantum_nn(X, theta, shots, encoding_type, rotation_type, simulator=True):
qc, c = feature_map(X, encoding_type)
qc = variational_circuit(qc, theta, rotation_type)
qc.measure(0, c)
backend = Aer.get_backend('qasm_simulator')
if simulator == False:
provider = IBMQ.load_account()
backend = provider.get_backend('ibm_oslo')
job = qiskit.execute(qc, backend, shots=shots)
result = job.result()
counts = result.get_counts(qc)
return counts['1']/shots
qc, c = feature_map(X[0], 'rz')
qc = variational_circuit(qc, np.ones(4), 'rz')
qc.measure(0, c)
backend = Aer.get_backend('qasm_simulator')
job = qiskit.execute(qc, backend, shots=5000)
result = job.result()
counts = result.get_counts(qc)
print(counts)
# quantum_nn test
quantum_nn(X[0], np.ones(4), 5000, 'rx', 'ry')
def loss(prediction, target):
return(prediction-target)**2
# loss test
loss(quantum_nn(X[0], [0.9, 0.9, 0.9, 0.9], 5000, 'rx', 'ry'), Y[0])
def gradient(X, Y, theta, delta, shots, encoding_type, rotation_type):
grad = []
for i in range(len(theta)):
dtheta = copy.copy(theta)
dtheta[i] += delta
prediction_1 = quantum_nn(X, dtheta, shots, encoding_type, rotation_type)
prediction_2 = quantum_nn(X, theta, shots, encoding_type, rotation_type)
grad.append((loss(prediction_1, Y) - loss(prediction_2, Y)) / delta)
return np.array(grad)
gradient(X[0], Y[0], np.ones(4), 0.01, 5000, 'rx', 'ry')
def accuracy(X, Y, theta, shots, encoding_type, rotation_type):
counter = 0
for X_i, Y_i, in zip(X, Y):
prediction = quantum_nn(X_i, theta, shots, encoding_type, rotation_type)
if prediction < 0.5 and Y_i == 0:
counter += 1
elif prediction >= 0.5 and Y_i == 1:
counter += 1
return counter/len(Y)
# Accuracy test
accuracy(X_test, Y_test, [-1.5, 1.2, 0.6, -0.2], 1000, 'rx', 'ry')
def get_best_weight(accuracies, weights):
return(weights[accuracies.index(max(accuracies))])
N = 4
def model(x_train, y_train, x_test, y_test, learning_rate, epochs, theta, shots, encoding_type, rotation_type, delta, optimizing_weights=False):
loss_list = []
acc_list = []
weights_list = []
print('Epoch \t Loss \t Training Accuracy \t theta')
for i in range(epochs):
loss_tmp = []
for X_i, Y_i in zip(x_train, y_train):
prediction = quantum_nn(X_i, theta, shots, encoding_type, rotation_type)
loss_tmp.append(loss(prediction, Y_i))
# update theta
new_theta = theta - learning_rate * gradient(X_i, Y_i, theta, delta, shots, encoding_type, rotation_type)
if loss(quantum_nn(X_i, new_theta, shots, encoding_type, rotation_type), Y_i) < loss(quantum_nn(X_i, theta, shots, encoding_type, rotation_type), Y_i):
theta = new_theta
loss_list.append(np.mean(loss_tmp))
acc_list.append(accuracy(X_train, Y_train, theta, shots, encoding_type, rotation_type))
weights_list.append(theta)
print(f'{i} \t {round(loss_list[-1], 3)} \t {round(acc_list[-1], 3)} \t {theta} \t {len(weights_list)}')
if optimizing_weights==True:
acc = accuracy(x_test, y_test, get_best_weight(acc_list, weights_list), shots, encoding_type=encoding_gate, rotation_type=rotation_gate)
return acc, get_best_weight(acc_list, weights_list), theta, loss_list, acc_list, weights_list
else:
acc = accuracy(x_test, y_test, theta, shots, encoding_type=encoding_gate, rotation_type=rotation_gate)
return acc, theta, loss_list, acc_list, weights_list
gates = ['rx', 'ry', 'rz']
results = {}
for encoding_gate in gates:
for rotation_gate in gates:
circuit_type = encoding_gate + '-' + rotation_gate
if circuit_type != 'rz-rz':
print(f'Circuit type : {circuit_type} -> encoding : {encoding_gate} rotation : {rotation_gate}')
acc, theta, loss_list, acc_list, weights_history = model(X_train, Y_train, X_test, Y_test, learning_rate=0.05, epochs=10, theta=np.ones(N), shots=5000, encoding_type=encoding_gate, rotation_type=rotation_gate, delta=0.01)
results.update({circuit_type: {'accuracy': acc, 'theta': theta, 'loss_list':loss_list, 'acc_list':acc_list, 'weights_history_list':weights_history}})
print(f" {circuit_type} accuracy : {results.get(circuit_type).get('accuracy')}")
gates = ['rx', 'ry', 'rz']
labels = []
accuracies = []
for encoding_gate in gates:
for rotation_gate in gates:
circuit_type = encoding_gate + '-' + rotation_gate
if circuit_type != 'rz-rz':
labels.append(circuit_type)
accuracies.append(results.get(circuit_type).get('accuracy'))
plt.bar(labels, accuracies)
plt.show()
gates = ['rx', 'ry', 'rz']
labels = []
accuracies = []
for encoding_gate in gates:
for rotation_gate in gates:
circuit_type = encoding_gate + '-' + rotation_gate
if circuit_type != 'rz-rz':
plt.plot([x for x in range(1, 11)], results.get(circuit_type).get('acc_list'), label=circuit_type)
plt.xticks([x for x in range(1, 11)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.title('Circuit Type accuracy effect')
plt.legend()
plt.show()
N = 4
def model_1(x_train, y_train, x_test, y_test, learning_rate, epochs, theta, shots, encoding_type, rotation_type, delta, optimizing_weights=False):
loss_list = []
acc_list = []
weights_list = []
loss_val = 1
i = 0
print('Epoch \t Loss \t Training Accuracy \t theta')
while loss_val > 0.17:
loss_tmp = []
for X_i, Y_i in zip(x_train, y_train):
prediction = quantum_nn(X_i, theta, shots, encoding_type, rotation_type)
loss_tmp.append(loss(prediction, Y_i))
# update theta
new_theta = theta - learning_rate * gradient(X_i, Y_i, theta, delta, shots, encoding_type, rotation_type)
if loss(quantum_nn(X_i, new_theta, shots, encoding_type, rotation_type), Y_i) < loss(quantum_nn(X_i, theta, shots, encoding_type, rotation_type), Y_i):
theta = new_theta
loss_val = np.mean(loss_tmp)
loss_list.append(np.mean(loss_tmp))
acc_list.append(accuracy(X_train, Y_train, theta, shots, encoding_type, rotation_type))
weights_list.append(theta)
print(f'{i} \t {round(loss_list[-1], 3)} \t {round(acc_list[-1], 3)} \t {theta} \t {len(weights_list)}')
i = i + 1
return theta, loss_list, acc_list, weights_list
theta_b, loss_list_b, acc_list_b, weights_history_b = model_1(X_train, Y_train, X_test, Y_test, learning_rate=0.05, epochs=20, theta=np.ones(N), shots=5000, encoding_type='ry', rotation_type='ry', delta=0.01)
N = 4
def model_2(x_train, y_train, x_test, y_test, learning_rate, epochs, theta, shots, encoding_type, rotation_type, delta, optimizing_weights=False):
loss_list = []
acc_list = []
weights_list = []
print('Epoch \t Loss \t Training Accuracy \t theta')
for i in range(epochs):
loss_tmp = []
for X_i, Y_i in zip(x_train, y_train):
prediction = quantum_nn(X_i, theta, shots, encoding_type, rotation_type)
loss_tmp.append(loss(prediction, Y_i))
# update theta
new_theta = theta - learning_rate * gradient(X_i, Y_i, theta, delta, shots, encoding_type, rotation_type)
if loss(quantum_nn(X_i, new_theta, shots, encoding_type, rotation_type), Y_i) < loss(quantum_nn(X_i, theta, shots, encoding_type, rotation_type), Y_i):
theta = new_theta
loss_list.append(np.mean(loss_tmp))
acc_list.append(accuracy(X_train, Y_train, theta, shots, encoding_type, rotation_type))
weights_list.append(theta)
print(f'{i} \t {round(loss_list[-1], 3)} \t {round(acc_list[-1], 3)} \t {theta} \t {len(weights_list)}')
return theta, loss_list, acc_list, weights_list
for learning_rate in [0.001, 0.01, 0.05, 0.1]:
theta, loss_list, acc_list, weights_history = model_2(X_train, Y_train, X_test, Y_test, learning_rate=learning_rate, epochs=20, theta=np.ones(N), shots=5000, encoding_type='ry', rotation_type='ry', delta=0.01)
acc = accuracy(X_test, Y_test, theta, 5000, encoding_type='ry', rotation_type='ry')
results.update({learning_rate: {'accuracy': acc, 'theta': theta, 'loss_list':loss_list, 'acc_list':acc_list, 'weights_history_list':weights_history}})
print(f" Learning rate : {learning_rate} accuracy : {results.get(learning_rate).get('accuracy')}")
for learning_rate in [0.001, 0.01, 0.05, 0.1]:
plt.plot([x for x in range(1, 21)], results.get(learning_rate).get('acc_list'), label=learning_rate)
plt.xticks([x for x in range(1, 21)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('eposhs')
plt.ylabel('Accuracy')
plt.title('learning rates - accuracy effect')
plt.legend()
plt.show()
n_shots_results = {}
for n_shots in [1000, 5000, 10000, 50000]:
theta, loss_list, acc_list, weights_history = model_2(X_train, Y_train, X_test, Y_test, learning_rate=0.05, epochs=20, theta=np.ones(N), shots=n_shots, encoding_type='ry', rotation_type='ry', delta=0.01)
acc = accuracy(X_test, Y_test, theta, n_shots, encoding_type='ry', rotation_type='ry')
n_shots_results.update({n_shots: {'accuracy': acc, 'theta': theta, 'loss_list':loss_list, 'acc_list':acc_list, 'weights_history_list':weights_history}})
print(f" Number of Shots : {n_shots} accuracy : {n_shots_results.get(n_shots).get('accuracy')}")
shots_list = [1000, 5000, 10000, 50000]
for n_shots in shots_list:
plt.plot([x for x in range(1, 21)], n_shots_results.get(n_shots).get('acc_list'), label=n_shots)
plt.xticks([x for x in range(1, 21)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('n_shots')
plt.ylabel('Accuracy')
plt.title('number of shots - accuracy effecta')
plt.legend()
plt.show()
delta_results = {}
for delta in [0.01, 0.05, 0.1, 1]:
theta, loss_list, acc_list, weights_history = model_2(X_train, Y_train, X_test, Y_test, learning_rate=0.1, epochs=20, theta=np.ones(N), shots=1000, encoding_type='ry', rotation_type='ry', delta=delta)
acc = accuracy(X_test, Y_test, theta, 1000, encoding_type='ry', rotation_type='ry')
delta_results.update({delta: {'accuracy': acc, 'theta': theta, 'loss_list':loss_list, 'acc_list':acc_list, 'weights_history_list':weights_history}})
print(f" Delta : {delta} accuracy : {delta_results.get(delta).get('accuracy')}")
for delta in [0.01, 0.05, 0.1, 1]:
plt.plot([x for x in range(1, 21)], delta_results.get(delta).get('acc_list'), label=delta)
plt.xticks([x for x in range(1, 21)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('eposhs')
plt.ylabel('Accuracy')
plt.title('Delta - accuracy effect')
plt.legend()
plt.show()
def feature_map_2(X, theta):
n = 4
qr = QuantumRegister(4)
c = ClassicalRegister(1)
qc = QuantumCircuit(qr,c )
for i, x in enumerate(X):
qc.ry(x, i)
for i in range(n-1):
qc.cx(i, i+1)
qc.barrier()
for i in range(4):
qc.rz(theta[i], i)
qc.barrier()
for i in reversed(range(n-1)):
qc.cx(i, i+1)
qc.h(0)
return qc, c
qc, c = feature_map_2(X[0], np.ones(4))
qc.draw('mpl')
def quantum_nn(X, theta, shots, encoding_type=None, rotation_type=None, simulator=True):
qc, c = feature_map_2(X, theta)
qc.measure(0, c)
backend = Aer.get_backend('qasm_simulator')
if simulator == False:
provider = IBMQ.load_account()
backend = provider.get_backend('ibm_oslo')
job = qiskit.execute(qc, backend, shots=shots)
result = job.result()
counts = result.get_counts(qc)
return counts['1']/shots
def accuracy(X, Y, theta, shots):
counter = 0
for X_i, Y_i, in zip(X, Y):
prediction = quantum_nn(X_i, theta, shots)
if prediction < 0.5 and Y_i == 0:
counter += 1
elif prediction >= 0.5 and Y_i == 1:
counter += 1
return counter/len(Y)
def gradient(X, Y, theta, delta, shots):
grad = []
for i in range(len(theta)):
dtheta = copy.copy(theta)
dtheta[i] += delta
prediction_1 = quantum_nn(X, dtheta, shots)
prediction_2 = quantum_nn(X, theta, shots)
grad.append((loss(prediction_1, Y) - loss(prediction_2, Y)) / delta)
return np.array(grad)
N = 4
def model_5(x_train, y_train, x_test, y_test, learning_rate, epochs, theta, shots, delta, optimizing_weights=False):
loss_list = []
acc_list = []
weights_list = []
print('Epoch \t Loss \t Training Accuracy \t theta')
for i in range(epochs):
loss_tmp = []
for X_i, Y_i in zip(x_train, y_train):
prediction = quantum_nn(X_i, theta, shots)
loss_tmp.append(loss(prediction, Y_i))
# update theta
new_theta = theta - learning_rate * gradient(X_i, Y_i, theta, delta, shots)
if loss(quantum_nn(X_i, new_theta, shots), Y_i) < loss(quantum_nn(X_i, theta, shots), Y_i):
theta = new_theta
loss_list.append(np.mean(loss_tmp))
acc_list.append(accuracy(X_train, Y_train, theta, shots))
weights_list.append(theta)
print(f'{i} \t {round(loss_list[-1], 3)} \t {round(acc_list[-1], 3)} \t {theta} \t {len(weights_list)}')
return theta, loss_list, acc_list, weights_list
theta, loss_list, acc_list, weights_list = model_5(X_train, Y_train, X_test, Y_test, 0.01, 100, [1, 1, 1, 1], 5000, 0.01)
accuracy(X_test, Y_test, theta, 5000)
plt.figure(figsize=(25, 8))
plt.plot([x for x in range(0, 100)], acc_list)
plt.xticks([x for x in range(0, 101, 10)])
plt.ylim([0.6, 1])
plt.xlabel('eposhs')
plt.ylabel('Accuracy')
plt.title('Accuracy')
plt.show()
from qiskit.circuit.library import ZZFeatureMap
num_features = X_train.shape[1]
feature_map = ZZFeatureMap(feature_dimension=num_features, reps=1)
feature_map.decompose().draw(output="mpl", fold=20)
from qiskit.circuit.library import RealAmplitudes
ansatz = RealAmplitudes(num_qubits=num_features, reps=3)
ansatz.decompose().draw(output="mpl", fold=20)
from qiskit.algorithms.optimizers import COBYLA
optimizer = COBYLA(maxiter=100)
from qiskit.primitives import Sampler
sampler = Sampler()
from matplotlib import pyplot as plt
from IPython.display import clear_output
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
def callback_graph(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
!pip install qiskit[machine-learning]
import time
from qiskit_machine_learning.algorithms.classifiers import VQC
vqc = VQC(
sampler=sampler,
feature_map=feature_map,
ansatz=ansatz,
optimizer=optimizer,
callback=callback_graph,
)
# clear objective value history
objective_func_vals = []
start = time.time()
vqc.fit(X_train, Y_train)
elapsed = time.time() - start
print(f"Training time: {round(elapsed)} seconds")
train_score_q4 = vqc.score(X_train, Y_train)
test_score_q4 = vqc.score(X_test, Y_test)
print(f"Quantum QNN on the training dataset: {accuracy(X_train, Y_train, theta, 5000):.2f}")
print(f"Quantum QNN on the test dataset: {accuracy(X_test, Y_test, theta, 5000):.2f}")
print(f"Quantum VQC on the training dataset: {train_score_q4:.2f}")
print(f"Quantum VQC on the test dataset: {test_score_q4:.2f}")
train_acc_results_1 = []
test_acc_results_1 = []
train_acc_results_2 = []
test_acc_results_2 = []
start = time.time()
for _ in range(10):
print(_)
X_train, X_test, Y_train, Y_test = model_selection.train_test_split(X, Y, test_size=0.33, random_state=42)
theta, loss_list, acc_list, weights_list = model_5(X_train, Y_train, X_test, Y_test, 0.01, 100, [1, 1, 1, 1], 5000, 0.01)
train_acc_results_1.append(accuracy(X_train, Y_train, theta, 5000))
test_acc_results_1.append(accuracy(X_test, Y_test, theta, 5000))
objective_func_vals = []
vqc.fit(X_train, Y_train)
train_acc_results_2.append(vqc.score(X_train, Y_train))
test_acc_results_2.append(vqc.score(X_test, Y_test))
print(_)
elapsed = time.time() - start
print(f"Training time: {round(elapsed)} seconds")
from numpy.lib.function_base import average
average(train_acc_results_1), average(test_acc_results_1), average(train_acc_results_2), average(test_acc_results_2)
|
https://github.com/LarianeMohceneMouad/Variation-Circuit-Based-Hybrid-Quantum-Classical-Binary-Algorithm
|
LarianeMohceneMouad
|
from sklearn import model_selection, datasets, svm
from qiskit import QuantumCircuit, Aer, IBMQ, QuantumRegister, ClassicalRegister
import numpy as np
import qiskit
import copy
import matplotlib.pyplot as plt
np.random.seed(42)
iris = datasets.load_iris()
X = iris.data[0:100]
Y = iris.target[0:100]
X_train, X_test, Y_train, Y_test = model_selection.train_test_split(X, Y, test_size=0.33, random_state=42)
N = 4
def feature_map(X, encoding_type):
q = QuantumRegister(N)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
if encoding_type == 'rx':
for i, x in enumerate(X):
qc.rx(x, i)
elif encoding_type == 'ry':
for i, x in enumerate(X):
qc.ry(x, i)
elif encoding_type == 'rz':
for i, x in enumerate(X):
qc.rz(x, i)
return qc, c
# feature map test
qc,c = feature_map(X[0], 'rx')
qc.draw('mpl')
def variational_circuit(qc, theta, rotation_type):
for i in range(N-1):
qc.cnot(i, i+1)
qc.cnot(N-1, 0)
if rotation_type == 'rx':
for i in range(N):
qc.rx(theta[i], i)
elif rotation_type == 'ry':
for i in range(N):
qc.ry(theta[i], i)
elif rotation_type == 'rz':
for i in range(N):
qc.rz(theta[i], i)
return qc
qc = variational_circuit(qc, np.ones(4), 'ry')
qc.draw('mpl')
def quantum_nn(X, theta, shots, encoding_type, rotation_type, simulator=True):
qc, c = feature_map(X, encoding_type)
qc = variational_circuit(qc, theta, rotation_type)
qc.measure(0, c)
backend = Aer.get_backend('qasm_simulator')
if simulator == False:
provider = IBMQ.load_account()
backend = provider.get_backend('ibm_oslo')
job = qiskit.execute(qc, backend, shots=shots)
result = job.result()
counts = result.get_counts(qc)
return counts['1']/shots
qc, c = feature_map(X[0], 'rz')
qc = variational_circuit(qc, np.ones(4), 'rz')
qc.measure(0, c)
backend = Aer.get_backend('qasm_simulator')
job = qiskit.execute(qc, backend, shots=5000)
result = job.result()
counts = result.get_counts(qc)
print(counts)
# quantum_nn test
quantum_nn(X[0], np.ones(4), 5000, 'rx', 'ry')
def loss(prediction, target):
return(prediction-target)**2
# loss test
loss(quantum_nn(X[0], [0.9, 0.9, 0.9, 0.9], 5000, 'rx', 'ry'), Y[0])
def gradient(X, Y, theta, delta, shots, encoding_type, rotation_type):
grad = []
for i in range(len(theta)):
dtheta = copy.copy(theta)
dtheta[i] += delta
prediction_1 = quantum_nn(X, dtheta, shots, encoding_type, rotation_type)
prediction_2 = quantum_nn(X, theta, shots, encoding_type, rotation_type)
grad.append((loss(prediction_1, Y) - loss(prediction_2, Y)) / delta)
return np.array(grad)
gradient(X[0], Y[0], np.ones(4), 0.01, 5000, 'rx', 'ry')
def accuracy(X, Y, theta, shots, encoding_type, rotation_type):
counter = 0
for X_i, Y_i, in zip(X, Y):
prediction = quantum_nn(X_i, theta, shots, encoding_type, rotation_type)
if prediction < 0.5 and Y_i == 0:
counter += 1
elif prediction >= 0.5 and Y_i == 1:
counter += 1
return counter/len(Y)
# Accuracy test
accuracy(X_test, Y_test, [-1.5, 1.2, 0.6, -0.2], 1000, 'rx', 'ry')
def get_best_weight(accuracies, weights):
return(weights[accuracies.index(max(accuracies))])
N = 4
def model(x_train, y_train, x_test, y_test, learning_rate, epochs, theta, shots, encoding_type, rotation_type, delta, optimizing_weights=False):
loss_list = []
acc_list = []
weights_list = []
print('Epoch \t Loss \t Training Accuracy \t theta')
for i in range(epochs):
loss_tmp = []
for X_i, Y_i in zip(x_train, y_train):
prediction = quantum_nn(X_i, theta, shots, encoding_type, rotation_type)
loss_tmp.append(loss(prediction, Y_i))
# update theta
new_theta = theta - learning_rate * gradient(X_i, Y_i, theta, delta, shots, encoding_type, rotation_type)
if loss(quantum_nn(X_i, new_theta, shots, encoding_type, rotation_type), Y_i) < loss(quantum_nn(X_i, theta, shots, encoding_type, rotation_type), Y_i):
theta = new_theta
loss_list.append(np.mean(loss_tmp))
acc_list.append(accuracy(X_train, Y_train, theta, shots, encoding_type, rotation_type))
weights_list.append(theta)
print(f'{i} \t {round(loss_list[-1], 3)} \t {round(acc_list[-1], 3)} \t {theta} \t {len(weights_list)}')
if optimizing_weights==True:
acc = accuracy(x_test, y_test, get_best_weight(acc_list, weights_list), shots, encoding_type=encoding_gate, rotation_type=rotation_gate)
return acc, get_best_weight(acc_list, weights_list), theta, loss_list, acc_list, weights_list
else:
acc = accuracy(x_test, y_test, theta, shots, encoding_type=encoding_gate, rotation_type=rotation_gate)
return acc, theta, loss_list, acc_list, weights_list
gates = ['rx', 'ry', 'rz']
results = {}
for encoding_gate in gates:
for rotation_gate in gates:
circuit_type = encoding_gate + '-' + rotation_gate
if circuit_type != 'rz-rz':
print(f'Circuit type : {circuit_type} -> encoding : {encoding_gate} rotation : {rotation_gate}')
acc, theta, loss_list, acc_list, weights_history = model(X_train, Y_train, X_test, Y_test, learning_rate=0.05, epochs=10, theta=np.ones(N), shots=5000, encoding_type=encoding_gate, rotation_type=rotation_gate, delta=0.01)
results.update({circuit_type: {'accuracy': acc, 'theta': theta, 'loss_list':loss_list, 'acc_list':acc_list, 'weights_history_list':weights_history}})
print(f" {circuit_type} accuracy : {results.get(circuit_type).get('accuracy')}")
gates = ['rx', 'ry', 'rz']
labels = []
accuracies = []
for encoding_gate in gates:
for rotation_gate in gates:
circuit_type = encoding_gate + '-' + rotation_gate
if circuit_type != 'rz-rz':
labels.append(circuit_type)
accuracies.append(results.get(circuit_type).get('accuracy'))
plt.bar(labels, accuracies)
plt.show()
gates = ['rx', 'ry', 'rz']
labels = []
accuracies = []
for encoding_gate in gates:
for rotation_gate in gates:
circuit_type = encoding_gate + '-' + rotation_gate
if circuit_type != 'rz-rz':
plt.plot([x for x in range(1, 11)], results.get(circuit_type).get('acc_list'), label=circuit_type)
plt.xticks([x for x in range(1, 11)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.title('Circuit Type accuracy effect')
plt.legend()
plt.show()
N = 4
def model_1(x_train, y_train, x_test, y_test, learning_rate, epochs, theta, shots, encoding_type, rotation_type, delta, optimizing_weights=False):
loss_list = []
acc_list = []
weights_list = []
loss_val = 1
i = 0
print('Epoch \t Loss \t Training Accuracy \t theta')
while loss_val > 0.17:
loss_tmp = []
for X_i, Y_i in zip(x_train, y_train):
prediction = quantum_nn(X_i, theta, shots, encoding_type, rotation_type)
loss_tmp.append(loss(prediction, Y_i))
# update theta
new_theta = theta - learning_rate * gradient(X_i, Y_i, theta, delta, shots, encoding_type, rotation_type)
if loss(quantum_nn(X_i, new_theta, shots, encoding_type, rotation_type), Y_i) < loss(quantum_nn(X_i, theta, shots, encoding_type, rotation_type), Y_i):
theta = new_theta
loss_val = np.mean(loss_tmp)
loss_list.append(np.mean(loss_tmp))
acc_list.append(accuracy(X_train, Y_train, theta, shots, encoding_type, rotation_type))
weights_list.append(theta)
print(f'{i} \t {round(loss_list[-1], 3)} \t {round(acc_list[-1], 3)} \t {theta} \t {len(weights_list)}')
i = i + 1
return theta, loss_list, acc_list, weights_list
theta_b, loss_list_b, acc_list_b, weights_history_b = model_1(X_train, Y_train, X_test, Y_test, learning_rate=0.05, epochs=20, theta=np.ones(N), shots=5000, encoding_type='ry', rotation_type='ry', delta=0.01)
N = 4
def model_2(x_train, y_train, x_test, y_test, learning_rate, epochs, theta, shots, encoding_type, rotation_type, delta, optimizing_weights=False):
loss_list = []
acc_list = []
weights_list = []
print('Epoch \t Loss \t Training Accuracy \t theta')
for i in range(epochs):
loss_tmp = []
for X_i, Y_i in zip(x_train, y_train):
prediction = quantum_nn(X_i, theta, shots, encoding_type, rotation_type)
loss_tmp.append(loss(prediction, Y_i))
# update theta
new_theta = theta - learning_rate * gradient(X_i, Y_i, theta, delta, shots, encoding_type, rotation_type)
if loss(quantum_nn(X_i, new_theta, shots, encoding_type, rotation_type), Y_i) < loss(quantum_nn(X_i, theta, shots, encoding_type, rotation_type), Y_i):
theta = new_theta
loss_list.append(np.mean(loss_tmp))
acc_list.append(accuracy(X_train, Y_train, theta, shots, encoding_type, rotation_type))
weights_list.append(theta)
print(f'{i} \t {round(loss_list[-1], 3)} \t {round(acc_list[-1], 3)} \t {theta} \t {len(weights_list)}')
return theta, loss_list, acc_list, weights_list
for learning_rate in [0.001, 0.01, 0.05, 0.1]:
theta, loss_list, acc_list, weights_history = model_2(X_train, Y_train, X_test, Y_test, learning_rate=learning_rate, epochs=20, theta=np.ones(N), shots=5000, encoding_type='ry', rotation_type='ry', delta=0.01)
acc = accuracy(X_test, Y_test, theta, 5000, encoding_type='ry', rotation_type='ry')
results.update({learning_rate: {'accuracy': acc, 'theta': theta, 'loss_list':loss_list, 'acc_list':acc_list, 'weights_history_list':weights_history}})
print(f" Learning rate : {learning_rate} accuracy : {results.get(learning_rate).get('accuracy')}")
for learning_rate in [0.001, 0.01, 0.05, 0.1]:
plt.plot([x for x in range(1, 21)], results.get(learning_rate).get('acc_list'), label=learning_rate)
plt.xticks([x for x in range(1, 21)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('eposhs')
plt.ylabel('Accuracy')
plt.title('learning rates - accuracy effect')
plt.legend()
plt.show()
n_shots_results = {}
for n_shots in [1000, 5000, 10000, 50000]:
theta, loss_list, acc_list, weights_history = model_2(X_train, Y_train, X_test, Y_test, learning_rate=0.05, epochs=20, theta=np.ones(N), shots=n_shots, encoding_type='ry', rotation_type='ry', delta=0.01)
acc = accuracy(X_test, Y_test, theta, n_shots, encoding_type='ry', rotation_type='ry')
n_shots_results.update({n_shots: {'accuracy': acc, 'theta': theta, 'loss_list':loss_list, 'acc_list':acc_list, 'weights_history_list':weights_history}})
print(f" Number of Shots : {n_shots} accuracy : {n_shots_results.get(n_shots).get('accuracy')}")
shots_list = [1000, 5000, 10000, 50000]
for n_shots in shots_list:
plt.plot([x for x in range(1, 21)], n_shots_results.get(n_shots).get('acc_list'), label=n_shots)
plt.xticks([x for x in range(1, 21)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('n_shots')
plt.ylabel('Accuracy')
plt.title('number of shots - accuracy effecta')
plt.legend()
plt.show()
delta_results = {}
for delta in [0.01, 0.05, 0.1, 1]:
theta, loss_list, acc_list, weights_history = model_2(X_train, Y_train, X_test, Y_test, learning_rate=0.1, epochs=20, theta=np.ones(N), shots=1000, encoding_type='ry', rotation_type='ry', delta=delta)
acc = accuracy(X_test, Y_test, theta, 1000, encoding_type='ry', rotation_type='ry')
delta_results.update({delta: {'accuracy': acc, 'theta': theta, 'loss_list':loss_list, 'acc_list':acc_list, 'weights_history_list':weights_history}})
print(f" Delta : {delta} accuracy : {delta_results.get(delta).get('accuracy')}")
for delta in [0.01, 0.05, 0.1, 1]:
plt.plot([x for x in range(1, 21)], delta_results.get(delta).get('acc_list'), label=delta)
plt.xticks([x for x in range(1, 21)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('eposhs')
plt.ylabel('Accuracy')
plt.title('Delta - accuracy effect')
plt.legend()
plt.show()
def feature_map_2(X, theta):
n = 4
qr = QuantumRegister(4)
c = ClassicalRegister(1)
qc = QuantumCircuit(qr,c )
for i, x in enumerate(X):
qc.ry(x, i)
for i in range(n-1):
qc.cx(i, i+1)
qc.barrier()
for i in range(4):
qc.rz(theta[i], i)
qc.barrier()
for i in reversed(range(n-1)):
qc.cx(i, i+1)
qc.h(0)
return qc, c
qc, c = feature_map_2(X[0], np.ones(4))
qc.draw('mpl')
def quantum_nn(X, theta, shots, encoding_type=None, rotation_type=None, simulator=True):
qc, c = feature_map_2(X, theta)
qc.measure(0, c)
backend = Aer.get_backend('qasm_simulator')
if simulator == False:
provider = IBMQ.load_account()
backend = provider.get_backend('ibm_oslo')
job = qiskit.execute(qc, backend, shots=shots)
result = job.result()
counts = result.get_counts(qc)
return counts['1']/shots
def accuracy(X, Y, theta, shots):
counter = 0
for X_i, Y_i, in zip(X, Y):
prediction = quantum_nn(X_i, theta, shots)
if prediction < 0.5 and Y_i == 0:
counter += 1
elif prediction >= 0.5 and Y_i == 1:
counter += 1
return counter/len(Y)
def gradient(X, Y, theta, delta, shots):
grad = []
for i in range(len(theta)):
dtheta = copy.copy(theta)
dtheta[i] += delta
prediction_1 = quantum_nn(X, dtheta, shots)
prediction_2 = quantum_nn(X, theta, shots)
grad.append((loss(prediction_1, Y) - loss(prediction_2, Y)) / delta)
return np.array(grad)
N = 4
def model_5(x_train, y_train, x_test, y_test, learning_rate, epochs, theta, shots, delta, optimizing_weights=False):
loss_list = []
acc_list = []
weights_list = []
print('Epoch \t Loss \t Training Accuracy \t theta')
for i in range(epochs):
loss_tmp = []
for X_i, Y_i in zip(x_train, y_train):
prediction = quantum_nn(X_i, theta, shots)
loss_tmp.append(loss(prediction, Y_i))
# update theta
new_theta = theta - learning_rate * gradient(X_i, Y_i, theta, delta, shots)
if loss(quantum_nn(X_i, new_theta, shots), Y_i) < loss(quantum_nn(X_i, theta, shots), Y_i):
theta = new_theta
loss_list.append(np.mean(loss_tmp))
acc_list.append(accuracy(X_train, Y_train, theta, shots))
weights_list.append(theta)
print(f'{i} \t {round(loss_list[-1], 3)} \t {round(acc_list[-1], 3)} \t {theta} \t {len(weights_list)}')
return theta, loss_list, acc_list, weights_list
theta, loss_list, acc_list, weights_list = model_5(X_train, Y_train, X_test, Y_test, 0.01, 30, [1, 1, 1, 1], 5000, 0.01)
accuracy(X_test, Y_test, theta, 5000)
plt.plot([x for x in range(1, 31)], acc_list)
plt.xticks([x for x in range(1, 31)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('eposhs')
plt.ylabel('Accuracy')
plt.title('Accuracy')
plt.legend()
plt.show()
from qiskit.circuit.library import ZZFeatureMap
num_features = X_train.shape[1]
feature_map = ZZFeatureMap(feature_dimension=num_features, reps=1)
feature_map.decompose().draw(output="mpl", fold=20)
from qiskit.circuit.library import RealAmplitudes
ansatz = RealAmplitudes(num_qubits=num_features, reps=3)
ansatz.decompose().draw(output="mpl", fold=20)
from qiskit.algorithms.optimizers import COBYLA
optimizer = COBYLA(maxiter=100)
from qiskit.primitives import Sampler
sampler = Sampler()
from matplotlib import pyplot as plt
from IPython.display import clear_output
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
def callback_graph(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
import time
from qiskit_machine_learning.algorithms.classifiers import VQC
vqc = VQC(
sampler=sampler,
feature_map=feature_map,
ansatz=ansatz,
optimizer=optimizer,
callback=callback_graph,
)
# clear objective value history
objective_func_vals = []
start = time.time()
vqc.fit(X_train, Y_train)
elapsed = time.time() - start
print(f"Training time: {round(elapsed)} seconds")
train_score_q4 = vqc.score(X_train, Y_train)
test_score_q4 = vqc.score(X_test, Y_test)
print(f"Quantum QNN on the training dataset: {accuracy(X_train, Y_train, theta, 5000):.2f}")
print(f"Quantum QNN on the test dataset: {accuracy(X_test, Y_test, theta, 5000):.2f}")
print(f"Quantum VQC on the training dataset: {train_score_q4:.2f}")
print(f"Quantum VQC on the test dataset: {test_score_q4:.2f}")
|
https://github.com/Dpbm/QPapersPlease
|
Dpbm
|
%matplotlib inline
from qiskit import QuantumCircuit, QuantumRegister, AncillaRegister, Aer, transpile, ClassicalRegister
from qiskit.visualization import plot_histogram
from qiskit.quantum_info import Statevector
import numpy as np
import os
shots = 1000
# run this cell if you'll want to run the circuit in an IBMQ quantum computer
from qiskit_ibm_provider import IBMProvider
from dotenv import load_dotenv
load_dotenv()
IBMProvider.save_account(token=os.getenv('IBM_API_TOKEN'), overwrite=True)
provider = IBMProvider()
ibm_backend = provider.get_backend('ibmq_lima')
qubits = ["all_documents", "false_info", "wanted", "bribe"]
percentages_of_true = [30, 40, 5, 10]
get_theta = lambda B: np.arcsin(B) * 2
for qubit, percentage in zip(qubits, percentages_of_true):
#a = cos(theta/2)
#B = e^(i phi) sin(theta/2)
B = np.sqrt(percentage)/10
theta = get_theta(B)
a = np.cos(theta/2)
print('-'*50)
print(qubit.upper())
print(f'theta: {theta}')
print(f'a --> {a}')
print(f'B --> {B}')
print(f'a+B prob --> {np.round(a**2+B**2)}')
class Inputs:
def __init__(self, *args, probabilities):
self.total_qubits = len(args)
assert len(probabilities) == self.total_qubits, "different sizes of probabilities and qubits"
self.probabilities = probabilities
self.circuit = QuantumCircuit(*args)
def prepare(self):
self.bind_probabilities()
def bind_probabilities(self):
for qubit, probability in enumerate(self.probabilities):
self.bin_theta_from_probability(qubit, probability)
def bin_theta_from_probability(self, qubit, probability):
beta = np.sqrt(probability)/10
theta = np.arcsin(beta)*2
self.circuit.ry(theta, qubit)
def show(self):
display(self.circuit.draw('mpl'))
def add_measurement(self):
self.circuit.measure_all()
def measure(self, backend=Aer.get_backend("aer_simulator"), shots=shots):
transpiled_circuit = transpile(self.circuit, backend)
results = backend.run(transpiled_circuit, shots=shots).result().get_counts()
display(plot_histogram(results))
return {'results':results, 'shots':shots}
def get_circuit(self):
return self.circuit
all_documents = QuantumRegister(1, name="documents")
false_info = QuantumRegister(1, name="falsification")
wanted = QuantumRegister(1, name="wanted")
bribe = QuantumRegister(1, name="bribe")
inputs = Inputs(all_documents, false_info, wanted, bribe, probabilities=[40, 30, 10, 5])
inputs.prepare()
inputs.add_measurement()
inputs.show()
results = inputs.measure()
#results = inputs.measure(backend=ibm_backend) #use this to run on IBMQ
get_percentage = lambda total, x: (x/total)*100
def evaluate_results(shots, qubits, results):
totals = { qubit:0 for qubit in qubits }
qubits = qubits[::-1]
for bit_string, total in list(results.items()):
for qubit, value in enumerate(bit_string):
if(value == '1'):
totals[qubits[qubit]] += total
for qubit, total in list(totals.items()):
print(f'{qubit} ~{np.round(get_percentage(shots, total))}%')
evaluate_results(shots, ['all_documents', 'false_info', 'wanted', 'bribe'], results['results'])
class Check:
def __init__(self, *args):
self.total_data_qubits = len(args)
self.total_qubits = self.total_data_qubits+1
self.phase_qubit = AncillaRegister(1, name="ancilla")
self.circuit = QuantumCircuit(self.phase_qubit, *args)
self.circuit_measurement = QuantumCircuit(self.total_qubits, self.total_data_qubits)
self.circuit_measurement.measure(range(1, self.total_qubits), range(self.total_data_qubits))
def add_input(self, bit_string):
assert len(bit_string) == self.total_data_qubits, "Different amount of registers"
bit_string = self.parse_bit_string(bit_string)
for qubit, bit in enumerate(bit_string):
if(bit == '1'):
self.circuit.x(qubit+1)
self.add_barrier()
def parse_bit_string(self, bit_string):
return bit_string[::-1]
def add_barrier(self):
self.circuit.barrier()
def prepare(self, bit_string, show_oracle=False, show_state_vector=False):
self.add_oracle(bit_string, show_oracle)
if(show_state_vector):
self.show_state_vector()
def add_oracle(self, bit_string, show_oracle):
assert len(bit_string) <= self.total_data_qubits, "Different amount of registers"
bit_string = self.parse_bit_string(bit_string)
qubits_iterator = range(self.total_qubits)
oracle = QuantumCircuit(self.total_qubits, name="Oracle")
oracle.x(0)
oracle.h(qubits_iterator)
for qubit, bit in enumerate(bit_string):
if(bit == '0'):
oracle.cx(qubit+1, 0)
oracle.h(qubits_iterator)
if(show_oracle):
display(oracle.draw('mpl'))
self.circuit.append(oracle, qubits_iterator)
def show_state_vector(self):
display(Statevector(self.circuit).draw('latex'))
def add_measurement(self):
self.circuit.compose(self.circuit_measurement, inplace=True)
def measure(self, backend=Aer.get_backend("aer_simulator"), shots=1000):
transpiled_circuit = transpile(self.circuit, backend)
results = backend.run(transpiled_circuit, shots=shots).result().get_counts()
display(plot_histogram(results))
return {'results':results, 'shots':shots}
def show(self):
display(self.circuit.draw("mpl"))
def get_circuit(self):
return self.circuit
data = [false_info, wanted, bribe, all_documents]
checker = Check(*data)
checker.add_input("1000") #set the query
checker.prepare(bit_string="1000", show_oracle=True)# set hidden_string
checker.add_measurement()
checker.show()
results = checker.measure()
#results = inputs.measure(backend=ibm_backend) #use this to run on IBMQ
def show_results(shots, result):
get_percentage = lambda total, x: (x/total)*100
ordered_result = dict(sorted(result.items(), key=lambda item: item[1], reverse=True))
if(not '0' in list(ordered_result.keys())[0]):
print('Recieved the correct result!!!')
else:
print('The result is Incorrect!!!')
print('-'*50)
print("string - total - percentage")
for bit_string, total in list(ordered_result.items()):
print(f'{bit_string} {total} {int(get_percentage(shots, total))}%')
total_shots = measurement_result['shots']
result = measurement_result['results']
show_results(total_shots, result)
class QPP:
def __init__(self, *args, generator, checker):
self.generator = generator
self.checker = checker
phase = AncillaRegister(1, name="ancilla")
self.output = ClassicalRegister(len(args), name="out")
self.data_qubits_indexes = list(range(1, len(args)+1))
self.circuit = QuantumCircuit(phase, *args, self.output)
self.circuit.compose(generator, inplace=True, qubits=self.data_qubits_indexes)
self.circuit.barrier()
self.circuit.compose(checker, inplace=True)
def add_measurement(self):
self.circuit.measure(self.data_qubits_indexes, self.output)
def measure(self, backend=Aer.get_backend("aer_simulator"), shots=1000):
transpiled_circuit = transpile(self.circuit, backend)
results = backend.run(transpiled_circuit, shots=shots).result().get_counts()
display(plot_histogram(results))
return {'results':results, 'shots':shots}
def show(self):
display(self.circuit.draw('mpl'))
qubits = [false_info, wanted, bribe, all_documents]
inputs = Inputs(*qubits, probabilities=[40, 5, 10, 30])
inputs.prepare()
checker = Check(*qubits)
checker.prepare(bit_string="1000")
algorithm = QPP(*qubits, generator=inputs.get_circuit(), checker=checker.get_circuit())
algorithm.add_measurement()
algorithm.show()
results = algorithm.measure()
#results = algorithm.measure(backend=ibm_backend) #use this to run on IBMQ
evaluate_results(shots, ['false_info', 'wanted', 'bribe', 'all_documents'], results['results'])
passport = QuantumRegister(1, name="passport")
false_info = QuantumRegister(1, name="falsification")
wanted = QuantumRegister(1, name="wanted")
bribe = QuantumRegister(1, name="bribe")
person_id = QuantumRegister(1, name="id")
foreigner = QuantumRegister(1, name="foreigner")
qubits = [false_info, wanted, bribe, passport, person_id, foreigner]
inputs = Inputs(*qubits, probabilities=[40, 5, 10, 100, 3, 10])
inputs.prepare()
checker = Check(*qubits)
checker.prepare(bit_string="011000")
algorithm = QPP(*qubits, generator=inputs.get_circuit(), checker=checker.get_circuit())
algorithm.add_measurement()
algorithm.show()
results = algorithm.measure()
evaluate_results(shots, ['false_info', 'wanted', 'bribe', 'passport', 'person_id', 'foreigner'], results['results'])
|
https://github.com/IdhamHabibie/grover_algorithm_2_qubits
|
IdhamHabibie
|
# Run this if you haven't install qiskit, pylatexenc, and truth-table-generator
!pip install qiskit
!pip install qiskit --upgrade
!pip3 install pylatexenc
!pip install truth-table-generator
#initialization
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
from qiskit.aqua.components import oracles
# import basic plot tools
from qiskit.visualization import plot_histogram
# Bold Color
class color:
PURPLE = '\033[95m'
CYAN = '\033[96m'
DARKCYAN = '\033[36m'
BLUE = '\033[94m'
GREEN = '\033[92m'
YELLOW = '\033[93m'
RED = '\033[91m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
END = '\033[0m'
# Apply the H Gate
def initialize_s(qc, qubits):
"""Apply a H-gate to 'qubits' in qc"""
for q in qubits:
qc.h(q)
return qc
# Quantum 2 qubits
def list_qubit(n):
list_measurement = []
for i in range(n):
list_measurement.append(i)
return(list_measurement)
# Build the Oracle Function
def oracle(n_qubits, reversed_qubit):
# Define the Quantum Circuit
grover_circuit = QuantumCircuit(3*n_qubits+1)
# List Reversed
list_reversed = list(range(n_qubits))
list_reversed.reverse()
print("Vous avez", n_qubits , "qubits")
grover_circuit = initialize_s(grover_circuit, list(range(n_qubits)))
# Build the Oracle
for i in range(n_qubits):
grover_circuit.cx(i,i+n_qubits)
# Cx Gate
for i in range(n_qubits):
grover_circuit.cx(i+n_qubits, i + (2*n_qubits))
# X Gate
list_new = []
for j in range(2):
for i in range(n_qubits+1):
if(i == n_qubits):
grover_circuit.h(i + (2*n_qubits))
else:
grover_circuit.x(i + (2*n_qubits))
if(j != 1):
for i in range((n_qubits)):
list_new.append((2*n_qubits)+i)
grover_circuit.mct(list_new,(3*n_qubits))
# CX Gate
for i in list_reversed:
grover_circuit.cx(i+n_qubits,i + (2*n_qubits))
# CX Gate
for i in list_reversed:
grover_circuit.cx(i, i + n_qubits)
# We will return the diffuser as a gate
U_s = grover_circuit.to_gate()
U_s.name = "Oracle"
return(U_s)
# Build the Diffuser Function
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> (H-gates)
for qubit in range(nqubits):
qc.h(qubit)
# Apply transformation |00..0> -> |11..1> (X-gates)
for qubit in range(nqubits):
qc.x(qubit)
# Do multi-controlled-Z gate
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
# Apply transformation |11..1> -> |00..0>
for qubit in range(nqubits):
qc.x(qubit)
# Apply transformation |00..0> -> |s>
for qubit in range(nqubits):
qc.h(qubit)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "Diffuser"
return(U_s)
# Build the Diffuser Function
def diffuser_un(nqubits):
# Quantum Circuit A little bit
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> (H-gates)
for qubit in range(nqubits):
qc.h(qubit)
# Apply transformation |00..0> -> |11..1> (X-gates)
for qubit in range(nqubits):
qc.x(qubit)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "Diffuser"
return U_s
# Build the Statevector
def state_vector(circuit):
sv_sim = Aer.get_backend('statevector_simulator')
job_sim = execute(grover_circuit, sv_sim)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
return vector2latex(statevec, pretext="|\\psi\\rangle =")
# Running the Program
def probabilities(grover_circuit):
backend = Aer.get_backend('qasm_simulator')
results = execute(grover_circuit, backend=backend, shots=1024).result()
answer = results.get_counts()
return(answer)
# Load IBM Q account and get the least busy backend device
def experiment_device(grover_circuit):
provider = IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
backend = provider.get_backend('ibmq_armonk')
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
job = execute(grover_circuit, backend=backend, shots=1024, optimization_level=3)
job_monitor(job, interval = 2)
# Get the results from the computation
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
# AND Gate
# Position Argument : It depends on the argument of where you put in the Truth Table (1st, 2nd, 3rd)
def and_gate(n_qubits):
# Define the Quantum Circuit
qc = QuantumCircuit(n_qubits + 1)
# Multi Controlled Toffoli Gate
qc.mcx([0,1], n_qubits)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "$AND Gate$"
return(U_s)
# NAND Gate
# Position Argument : It depends on the argument of where you put in the Truth Table (1st, 2nd, 3rd)
def nand_gate(n_qubits):
# Define the Quantum Circuit
qc = QuantumCircuit(n_qubits + 1)
# X-Gate NAND Gate
for i in range(n_qubits+1):
qc.x(i)
# Multi Controlled Toffoli Gate
qc.mcx([0,1], n_qubits)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "$NAND Gate$"
return(U_s)
# OR GATE
# Position Argument : It depends on the argument of where you put in the Truth Table (1st, 2nd, 3rd)
def or_gate(n_qubits):
# Define the Quantum Circuit
qc = QuantumCircuit(n_qubits + 1)
# Range n_qubits
for i in range(2):
qc.x(i)
# Besides of the Toffoli
qc.x(n_qubits)
# Multi Controlled Toffoli Gate
qc.mcx([0,1], n_qubits)
# We will return the OR as a gate
U_s = qc.to_gate()
U_s.name = "$OR GATE$"
return(U_s)
# XOR Gate
# Position Argument : It depends on the XOR Gate
def xor_gate(n_qubits):
# Define the Quantum Circuit
qc = QuantumCircuit(n_qubits)
# This is the CNOT Gate and X Gate
qc.cx(0,1)
# We will return the OR as a gate
U_s = qc.to_gate()
U_s.name = "$XOR GATE$"
return(U_s)
# XnOR Gate
# Position Argument : It depends on the XOR Gate
def xnor_gate(n_qubits):
# Define the Quantum Circuit
qc = QuantumCircuit(n_qubits)
# This is the CNOT Gate and X Gate
qc.x(n_qubits-1)
qc.cx(0,n_qubits-1)
# We will return the OR as a gate
U_s = qc.to_gate()
U_s.name = "$XNOR GATE$"
return(U_s)
# Implication Gate
def implies_gate(n_qubits):
# Define the Quantum Circuit
qc = QuantumCircuit(n_qubits+1)
# This is the CNOT Gate and Toffoli Gate.
# The existing implies in here.
qc.x(n_qubits)
qc.cx(0,1)
qc.x(0)
qc.mcx([0,1], n_qubits)
# We will return the OR as a gate
U_s = qc.to_gate()
U_s.name = "$Implies GATE$"
return(U_s)
# Special Gate
def special_gate(n_qubits):
# Define the Quantum Circuit
qc = QuantumCircuit(n_qubits+1)
# This is the CNOT Gate and Toffoli Gate.
# The existing implies in here.
qc.x([0,1])
qc.mcx([0,1], n_qubits)
qc.cx(0,1)
qc.cx(1,2)
qc.mcx([0,1], n_qubits)
# We will return the OR as a gate
U_s = qc.to_gate()
U_s.name = "$Special GATE$"
return(U_s)
import ttg
import pandas as pd
# For example 2 qubits
# ~q
# p xor q
statement = True
while(statement != False):
# Define Variable
list_calculation = []
list_input = []
iniput = ''
output = ''
# Defining how many qubits used for this gate
print("How many qubits that you are looking?" + color.BOLD + " Par Exemple : 1 for 1 qubit, 2 for qubits, 3 for qubits" + color.END)
print("----------------------------------------")
n_qubits = int(input())
print("----------------------------------------")
# Rules of the Truth Table
print(f"You have filled" + color.BOLD + f" {n_qubits} qubits," +color.END + " so you must filled" + color.BOLD + f" {n_qubits} argument" + color.END+ " as follows")
# The Calculation qubits
for i in range(n_qubits):
print(f"The {i+1}-th Argument")
print("----------------------")
# String output
string = input()
list_calculation.append(string)
# String input
inputan = chr(ord('p')+i)
list_input.append(inputan)
# Create the Table
table = ttg.Truths(list_input, list_calculation)
table_pd = table.as_pandas()
display(table_pd)
# Inputan and Output
for i in range(n_qubits):
iniput = iniput + " " + table_pd.iloc[:,i].astype(str)
output = output + table_pd.iloc[:,i+n_qubits].astype(str)
# Convert to the dataframe
dataframe = pd.DataFrame({"input":iniput,
"output":output})
# Check if there is any duplicates in the output (which is not correspond to what we want)
statement = dataframe.output.duplicated().any()
if(statement == True):
print(color.RED + "Sorry, there is a duplicate output!" + color.END)
# Successful
print("Well done you have " + color.BLUE + "filled it correctly" + color.END)
# Question remark of my qubits
print("--------------------------------------------------")
print("Quels qubits souhaitez-vous rechercher? " + color.BOLD + "Par Exemple : 0, 01, 101, 1100" + color.END)
qubit = input()
print("--------------------------------------------------")
# Argument
arg = 0
while arg !=1:
if(len(qubit)!= n_qubits):
print(color.RED + "Sorry, it's wrong!" + color.END + " Please put the same input with the " + color.BOLD + "total qubits before" + color.END)
# Question remark of my qubits
print("--------------------------------------------------")
print("Quels qubits souhaitez-vous rechercher? " + color.BOLD + "Par Exemple : 0, 01, 101, 1100" + color.END)
qubit = input()
print("--------------------------------------------------")
arg = 0
else:
print("Correct")
print("--------------------------------------------------")
arg = 1
# Analysis the input qubit
# Initialize to 1
# %config InlineBackend.figure_format = 'svg' # Makes the images fit
initial_state = [0,1]
analyse_iteration = []
# Reversing the Qubit Information
reversed_qubit = qubit[::-1]
# Initialize the Quantum Circuit
if(n_qubits != 1):
grover_circuit = QuantumCircuit((3*(n_qubits)) + 1, n_qubits)
else:
grover_circuit = QuantumCircuit((3*(n_qubits)) + 2, n_qubits)
# List Reversed
if(n_qubits !=1):
list_reversed = list(range(n_qubits))
list_reversed.reverse()
else:
list_reversed = list(range(n_qubits+2))
list_reversed.reverse()
# Define the classical bits
cbit = n_qubits
print("Vous Avez", n_qubits , "qubits")
# Initialize the Quantum Circuit (How much the total qubits + ancilla qubits needed)
grover_circuit = initialize_s(grover_circuit, list(range(n_qubits)))
# Iteration
print("How many interation do you want?")
iteration = int(input())
print("--------------------------------------------------")
# Desired Value ->(&)
for i,j in enumerate(reversed_qubit):
if(n_qubits != 1): # If n_qubits is not equal to 1
if(int(j) == 1):
grover_circuit.initialize(initial_state, int(i) + (3*(n_qubits))-2)
else: # If equal to 1
if(int(j) == 1):
grover_circuit.initialize(initial_state, int(i) + (3*(n_qubits))-1)
# All the Circuits
for i in range(iteration):
if(n_qubits != 1):
# Initialize the Hadamard on the last
grover_circuit.initialize(initial_state, (3*(n_qubits)))
grover_circuit.barrier()
# Build the Flip Gate for Truth Table. Tres IMPORTANT !!
for i in range(n_qubits):
grover_circuit.cx(i, i + n_qubits)
grover_circuit.barrier()
#### C'est un important -> Truth Table Gate
# # X Gate aja
grover_circuit.swap(2,3)
grover_circuit.x([2,3])
grover_circuit.cx(3,2)
# This is swapping gates (It should be on the above)
grover_circuit.barrier()
# CX Gate
for i in range(n_qubits):
grover_circuit.cx(i+n_qubits, i + (2*n_qubits))
grover_circuit.barrier()
# X Gate
list_new = []
for j in range(2):
for i in range(n_qubits+1):
if(i == n_qubits):
grover_circuit.h(i + (2*n_qubits))
else:
grover_circuit.x(i + (2*n_qubits))
if(j != 1):
for i in range((n_qubits)):
list_new.append((2*n_qubits)+i)
grover_circuit.mct(list_new,(3*n_qubits))
grover_circuit.barrier()
# CX Gate
for i in list_reversed:
grover_circuit.cx(i+n_qubits,i + (2*n_qubits))
grover_circuit.barrier()
# # # CNOT Gate
grover_circuit.cx(3,2)
grover_circuit.x([2,3])
grover_circuit.swap(2,3)
# Last Oracle
for i in list_reversed:
grover_circuit.cx(i, i + n_qubits)
grover_circuit.barrier()
# Diffusion
grover_circuit.append(diffuser(n_qubits), list(range(n_qubits)))
grover_circuit.barrier()
# # Result Oriented
# result_2 = probabilities(grover_circuit)
# analyse_iteration.append(result_2[qubit])
# If there is a Single Qubit over it
else:
# Initialize the Hazamard on the last
grover_circuit.initialize(initial_state, (3*(n_qubits))+1)
grover_circuit.barrier()
# Build the Oracle
for i in range(n_qubits+2):
grover_circuit.cx(i,i+n_qubits)
grover_circuit.barrier()
# X Gate
list_new = []
for j in range(2):
for i in range(n_qubits+2):
if(i == n_qubits+1):
grover_circuit.h(i + (2*n_qubits))
else:
grover_circuit.x(i + (2*n_qubits))
if(j != 1):
for i in range((n_qubits)+1):
list_new.append((2*n_qubits)+i)
grover_circuit.mct(list_new,(3*n_qubits)+1)
grover_circuit.barrier()
# Last Oracle
for i in list_reversed:
grover_circuit.cx(i, i + n_qubits)
grover_circuit.barrier()
# Grover Diffuser Un
grover_circuit.append(diffuser_un(n_qubits), list(range(n_qubits)))
# Measurement
grover_circuit.measure(list(range(n_qubits)),list(range(n_qubits)))
grover_circuit.draw(output = 'mpl')
# Explorez le Probabilities
%config InlineBackend.figure_format = 'svg' # Makes the images fit
result_2 = probabilities(grover_circuit)
print("Simulation Result")
plot_histogram(result_2)
|
https://github.com/usamisaori/qLipschitz
|
usamisaori
|
from sklearn import datasets
import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
X_train, Y_train = datasets.make_circles(n_samples=500, noise=0.09, factor=0.4)
X_test, Y_test = datasets.make_circles(n_samples=200, noise=0.09, factor=0.4)
print('Training Data:')
print(X_train[:10])
print('\nTraining Label:')
print(Y_train[:10])
plt.scatter(X_train[:, 0], X_train[:, 1], c=Y_train)
plt.show()
print(f'Total datas: {len(X_train)}')
print(f'labels: {list(set(Y_train))}')
print(f' - label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f' - label 1 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
Z_train = (X_train[:, 0] ** 2 + X_train[:, 1] ** 2) ** 0.5
temp = np.zeros((X_train.shape[0], len(X_train[0]) + 1))
temp[:, :-1] = X_train
temp[:, -1] = Z_train
X_train2 = temp
Z_test = (X_test[:, 0] ** 2 + X_test[:, 1] ** 2) ** 0.5
temp = np.zeros((X_test.shape[0], len(X_test[0]) + 1))
temp[:, :-1] = X_test
temp[:, -1] = Z_test
X_test2 = temp
print('Solved Training Data:')
print(X_train2[:10])
def plot3D(X, Y):
fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(
X[:, 0], X[:, 1], X[:, 2],
zdir='z', s=30, c=Y, depthshade=True
)
plt.show()
plot3D(X_train2, Y_train)
X, Y = datasets.load_iris(return_X_y=True)
X_train_0 = X[0:30]
X_train_1 = X[50:80]
X_train_iris = np.vstack((X_train_0, X_train_1))
Y_train_0 = Y[0:30]
Y_train_1 = Y[50:80]
Y_train_iris = np.vstack((Y_train_0, Y_train_1)).flatten()
X, Y = datasets.load_iris(return_X_y=True)
X_test_0 = X[30:50]
X_test_1 = X[80:100]
X_test_iris = np.vstack((X_test_0, X_test_1))
Y_test_0 = Y[30:50]
Y_test_1 = Y[80:100]
Y_test_iris = np.vstack((Y_test_0, Y_test_1)).flatten()
X_train_iris = (X_train_iris - X_train_iris.min(axis=0)) / (X_train_iris.max(axis=0) - X_train_iris.min(axis=0))
X_test_iris = (X_test_iris - X_test_iris.min(axis=0)) / (X_test_iris.max(axis=0) - X_test_iris.min(axis=0))
import qiskit
from qiskit import QuantumCircuit
from qiskit import Aer, execute
qasm_backend = Aer.get_backend('qasm_simulator')
params = [
[[-1.18991246e-01, -8.69694713e-01, 1.43722811e-03],
[ 3.47641545e+00, -4.73632073e-02, 1.97135609e+00],
[ 1.95775707e+00, -1.12139160e-02, -6.21796144e-03]],
[[ 2.02460380e-02, -2.25797547e+00, 5.14234265e-03],
[-1.71552299e-02, 2.46283604e-03, -1.03805722e-02],
[-2.37244982e-03, -3.35799404e-03, 6.10191152e-03]]
]
params_iris = [
[[-3.42142600e-02, -5.45047534e-03, 8.11905347e-01],
[-1.52484152e+00, 1.49884676e+00, -1.25408626e-02],
[-1.89515860e-03, 1.35760410e-02, 8.22999582e-03],
[ 1.39102114e+00, 4.19729865e-01, 1.60000380e-04]],
[[ 7.88431068e-01, -8.86177264e-01, 1.33830291e-02],
[-3.71228143e-03, -1.12994101e-02, -1.27897783e-02],
[ 9.45954683e-03, -3.34659883e-03, 1.17217829e-02],
[ 1.98256181e-02, -1.07358054e-02, 7.53621360e-03]]
]
def createInputCircuit(data):
qubits_num = len(data)
qcircuit = QuantumCircuit(qubits_num, qubits_num)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
return qcircuit
# Test 1: create input circuit
test1_circuit = createInputCircuit(X_train2[0])
test1_circuit.draw(output='mpl')
def createModelCircuit(params):
qubits_num = len(params[0])
qcircuit = QuantumCircuit(qubits_num, qubits_num)
qubits = qcircuit.qubits
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
for i in range(qubits_num - 1):
qcircuit.cz(qubits[i], qubits[i + 1])
qcircuit.cz(qubits[0], qubits[qubits_num - 1])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
return qcircuit
# Test 2: create model circuit
test2_circuit = createModelCircuit(params)
test2_circuit.draw(output='mpl')
def createCircuit(params, data):
input_circuit = createInputCircuit(data)
model_circuit = createModelCircuit(params)
full_circuit = input_circuit.compose(model_circuit)
return full_circuit
# Test 3-1: create full quantum circuit - circle
test3_circuit = createCircuit(params, X_train2[0])
test3_circuit.draw(output='mpl')
# Test 3-2: create full quantum circuit - iris
test3_circuit = createCircuit(params_iris, X_train_iris[1])
test3_circuit.draw(output='mpl')
def predict(model, data):
qubits_num = len(data)
input_circuit = createInputCircuit(data)
qcircuit = input_circuit.compose(model)
# the measurement
qcircuit.measure(list(range(qubits_num)), list(range(qubits_num)))
# job execution
shots = 1000
job_sim = execute(qcircuit, qasm_backend, shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qcircuit)
p1 = 0
for i in range(2 ** (qubits_num - 1)):
comb = str(bin(i + 2 ** (qubits_num - 1))[2:])
p1 += counts.get(comb, 0)
p1 /= shots
if p1 > 0.5:
return 1
else:
return 0
def accuracy(model, datas, labels):
predictions = [ predict(model, data) for data in datas ]
acc = 0
for i, p in enumerate(predictions):
if p == labels[i]:
acc += 1
return acc / len(predictions)
def evaluate(model, X_test, Y_test):
acc = accuracy(model, X_test, Y_test)
print("FINAL ACCURACY: {:0.2f}%".format(acc * 100))
# Test 4: evaluate noiseless model
test4_circuit = createModelCircuit(params_iris)
evaluate(test4_circuit, X_train_iris, Y_train_iris)
evaluate(test4_circuit, X_test_iris, Y_test_iris)
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.utils import insert_noise
from qiskit.providers.aer.noise import pauli_error, depolarizing_error
def createNoiseModel(p, errorType):
# QuantumError objects
if errorType == 'bit_flip':
error = pauli_error([('X', p), ('I', 1 - p)])
elif errorType == 'phase_flip':
error = pauli_error([('Z', p), ('I', 1 - p)])
elif errorType == 'depolarizing':
error = depolarizing_error(p, num_qubits=1)
## two-qubits quantumError objects
if errorType == 'depolarizing':
error_2qubits = depolarizing_error(p, num_qubits=2)
else:
error_2qubits = error.tensor(error)
# Add errors to noise model
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ['u3'])
noise_model.add_all_qubit_quantum_error(error_2qubits, ['cz'])
return noise_model
def createNoisyModelCircuit(params, p, errorType):
noise_model = createNoiseModel(p, errorType)
model_circuit = createModelCircuit(params)
return insert_noise(model_circuit, noise_model)
# Test 5-1: create noisy model circuit - circle
test5_p = 0.001
test5_circuit = createNoisyModelCircuit(params, test5_p, 'phase_flip')
test5_circuit.draw(output='mpl')
# Test 5-2: create noisy model circuit - iris
test5_p = 0.001
test5_circuit = createNoisyModelCircuit(params_iris, test5_p, 'bit_flip')
test5_circuit.draw(output='mpl')
# Test 6-1: evaluate noisy model - circle
test6_p = 0.001
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
test6_circuits = [
createModelCircuit(params),
createNoisyModelCircuit(params, test6_p, 'bit_flip'),
createNoisyModelCircuit(params, test6_p, 'phase_flip'),
createNoisyModelCircuit(params, test6_p, 'depolarizing')
]
for i, model_type in enumerate(models_type):
print(f'Evaluate <{model_type}>: ')
evaluate(test6_circuits[i], X_test2, Y_test)
print()
# Test 6-2: evaluate noisy model - iris
test6_p = 0.5
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
test6_circuits = [
createModelCircuit(params_iris),
createNoisyModelCircuit(params_iris, test6_p, 'bit_flip'),
createNoisyModelCircuit(params_iris, test6_p, 'phase_flip'),
createNoisyModelCircuit(params_iris, test6_p, 'depolarizing')
]
for i, model_type in enumerate(models_type):
print(f'Evaluate <{model_type}>: ')
evaluate(test6_circuits[i], X_test_iris, Y_test_iris)
print()
from functools import reduce
Dag = lambda matrix: matrix.conj().T
Kron = lambda *matrices: reduce(np.kron, matrices)
from qiskit.quantum_info import DensityMatrix, Statevector
def getDensityMatrix(circuit):
return DensityMatrix(circuit).data
def getStatevector(circuit):
return Statevector(circuit).data
psi_0 = np.array([1.0, 0.0])
psi_1 = np.array([0.0, 1.0])
I = np.eye(2)
M_0 = psi_0.reshape([2, 1]) @ psi_0.reshape([1, 2]).conj()
M_1 = psi_1.reshape([2, 1]) @ psi_1.reshape([1, 2]).conj()
def getMeasurements(qubits_num):
measurement_0 = [M_0]
measurement_1 = [M_1]
for i in range(qubits_num - 1):
measurement_0.append(I)
measurement_1.append(I)
return [
Kron(*measurement_0),
Kron(*measurement_1)
]
# Test 7: test measure
test7_M_0, test7_M_1 = getMeasurements(qubits_num=3)
# 2: |0> - X -
test7_1_circuit = QuantumCircuit(3, 3)
test7_1_circuit.x(test7_1_circuit.qubits[2])
test7_1_circuit.draw(output='mpl')
test7_1_density_matrix = getDensityMatrix(test7_1_circuit)
test7_1_p1 = np.trace( test7_M_1 @ test7_1_density_matrix @ Dag(test7_M_1) )
print(test7_1_p1) # should be 1
# 2: |0> - H -
test7_2_circuit = QuantumCircuit(3, 3)
test7_2_circuit.h(test7_2_circuit.qubits[2])
test7_2_circuit.draw(output='mpl')
test7_2_density_matrix = getDensityMatrix(test7_2_circuit)
test7_2_p1 = np.trace( test7_M_1 @ test7_2_density_matrix @ Dag(test7_M_1) )
print(test7_2_p1) # should be 0.5
test7_M_0, test7_M_1 = getMeasurements(qubits_num=4)
# 3: |0> - H -
test7_3_circuit = QuantumCircuit(4, 4)
test7_3_circuit.h(test7_3_circuit.qubits[3])
test7_3_circuit.draw(output='mpl')
test7_3_density_matrix = getDensityMatrix(test7_3_circuit)
test7_3_p1 = np.trace( test7_M_1 @ test7_3_density_matrix @ Dag(test7_M_1) )
print(test7_3_p1) # should be 0.5
def powerSets(items):
N = len(items)
combs = []
for i in range(2 ** N):
comb = []
for j in range(N):
if (i >> j) % 2:
comb.append(items[j])
combs.append(comb)
return combs
# Test 8: calculate power sets
print(powerSets([0, 1]))
class Algorithm:
def __init__(self, model_circuit, measurements, outputs):
# DensityMatrix of model
self.E = getDensityMatrix(model_circuit)
# Measurements
self.M = dict()
for index, output in enumerate(outputs):
self.M[output] = measurements[index]
# Outputs
self.O = outputs
self.O_ = powerSets(outputs)
# Test 9: algorithm objects
test9_circuit = createModelCircuit(params_iris)
test9_A = Algorithm(test9_circuit, getMeasurements(qubits_num=4), [0, 1])
print(test9_A.E.shape)
print(test9_A.O)
print(test9_A.O_)
from scipy.linalg import sqrtm
def D(rou, sigma):
A = rou - sigma
A_ = sqrtm( np.dot( A.conj().T, A ) )
return 0.5 * np.linalg.norm( np.trace(A_) )
# Test 10: trace distance example
from math import isclose
# example from: quantumnanophotonics.org/media/Module2Lecture8.pdf
test10_rou = np.array([[2.0, 0.0], [0.0, 1.0]]) / 3
test10_sigma = np.array([[3.0, 0.0], [0.0, 1.0]]) / 4
assert isclose(D(test10_rou, test10_sigma), 1/12)
# Test 11: calculate input states' distance
test11_rou = getDensityMatrix(createInputCircuit(X_train2[0]))
test11_sigma = getDensityMatrix(createInputCircuit(X_train2[1]))
print(D(test11_rou, test11_rou)) # should be 0
print(D(test11_rou, test11_sigma))
def d(A, rou, sigma):
distance = 0
for output in A.O:
trace = np.trace(
Dag(A.M[output]) @ A.M[output] @
(A.E @ (rou - sigma) @ Dag(A.E))
)
distance += np.linalg.norm(trace)
return distance / 2
# Test 12: calculate total variation distance
test12_circuit = createModelCircuit(params)
test12_A = Algorithm(test12_circuit, getMeasurements(qubits_num=3), [0, 1])
test12_rou = getDensityMatrix(createInputCircuit(X_train2[0]))
test12_sigma = getDensityMatrix(createInputCircuit(X_train2[1]))
print(d(test12_A, test12_rou, test12_rou))
print(d(test12_A, test12_rou, test12_sigma))
def Lipschitz(A):
E, M, O, O_ = A.E, A.M, A.O, A.O_
# Step 1: Calculate W_i
W = dict()
for i in O:
W[i] = Dag(E) @ Dag(M[i]) @ M[i] @ E
# Step 2: Calculate K_star
K_star = 0; vectors = [None, None]
M_star = np.zeros(E.shape)
for S in O_:
if len(S) == 0:
continue
# calculate M_S = Σ Wi
M_S = np.zeros(E.shape).astype('complex64')
for i in S:
M_S += W[i]
# calculate eigenvalues and eigenvectors of M_S
eigenvalues, eigenvectors = np.linalg.eigh(M_S)
min_index = np.where(eigenvalues == eigenvalues.min())
max_index = np.where(eigenvalues == eigenvalues.max())
# calculate K_S
K_S = np.linalg.norm(eigenvalues[max_index][0] - eigenvalues[min_index][0])
if K_S > K_star:
K_star = K_S
vectors[0] = eigenvectors.T[max_index][0]
vectors[1] = eigenvectors.T[min_index][0]
return K_star, np.array(vectors)
# Test 13: calculate lipschitz constant
print('Classifier for centric circle: ')
test13_1_circuit = createModelCircuit(params)
test13_1_A = Algorithm(test13_1_circuit, getMeasurements(qubits_num=3), [0, 1])
print(Lipschitz(test13_1_A))
print('\nClassifier for Iris: ')
test13_2_circuit = createModelCircuit(params_iris)
test13_2_A = Algorithm(test13_2_circuit, getMeasurements(qubits_num=4), [0, 1])
print(Lipschitz(test13_2_A))
# Test 14-1: calculate lipschitz constant in noisy model
test14_p = [0.0001, 0.001, 0.05, 0.1]
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
print('Classifier for centric circle: ')
for p in test14_p:
test14_1_circuits = [
createModelCircuit(params),
createNoisyModelCircuit(params, p, 'bit_flip'),
createNoisyModelCircuit(params, p, 'phase_flip'),
createNoisyModelCircuit(params, p, 'depolarizing')
]
print(f'p: {p}')
for i, model_type in enumerate(models_type):
test14_1_noisy_A = Algorithm(test14_1_circuits[i], getMeasurements(qubits_num=3), [0, 1])
print(f'{model_type} model: {Lipschitz(test14_1_noisy_A)[0]}')
print()
# Test 14-2: calculate lipschitz constant in noisy model
test14_p = [0.0001, 0.001, 0.05, 0.1]
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
print('Classifier for Iris: ')
for p in test14_p:
test14_2_circuits = [
createModelCircuit(params_iris),
createNoisyModelCircuit(params_iris, p, 'bit_flip'),
createNoisyModelCircuit(params_iris, p, 'phase_flip'),
createNoisyModelCircuit(params_iris, p, 'depolarizing')
]
print(f'p: {p}')
for i, model_type in enumerate(models_type):
test14_2_noisy_A = Algorithm(test14_2_circuits[i], getMeasurements(qubits_num=4), [0, 1])
print(f'{model_type} model: {Lipschitz(test14_2_noisy_A)[0]}')
print()
def FairVeriQ(A, epsilon, delta):
# epsilon <= 1 and delta > 0
K_star, kernel = Lipschitz(A)
if delta >= K_star * epsilon:
return True, None
else:
return False, kernel
# Test 15-1: find proper epsilon - circle
import random
# D(rou, sigma) <= epsilon
indices = []
while len(indices) < 50:
a = random.randint(0, len(X_train2) - 1)
b = random.randint(0, len(X_train2) - 1)
if a != b:
indices.append([a, b])
distances = []
for pair in indices:
rou = getDensityMatrix(createInputCircuit(X_train2[pair[0]]))
sigma = getDensityMatrix(createInputCircuit(X_train2[pair[1]]))
distances.append(D(rou, sigma))
print('find proper epsilon - centric circle')
print(f'Mean distance: {sum(distances) / len(distances)}')
print(f'Max distance: {max(distances)}')
print(f'Min distance: {min(distances)}')
# Test 15-2: find proper epsilon - iris
# D(rou, sigma) <= epsilon
indices = []
while len(indices) < 50:
a = random.randint(0, len(X_train_iris) - 1)
b = random.randint(0, len(X_train_iris) - 1)
if a != b:
indices.append([a, b])
distances = []
for pair in indices:
rou = getDensityMatrix(createInputCircuit(X_train_iris[pair[0]]))
sigma = getDensityMatrix(createInputCircuit(X_train_iris[pair[1]]))
distances.append(D(rou, sigma))
print('find proper epsilon - centric iris')
print(f'Mean distance: {sum(distances) / len(distances)}')
print(f'Max distance: {max(distances)}')
print(f'Min distance: {min(distances)}')
# Test 16-1: find proper delta - circle
test16_1_circuit = createModelCircuit(params)
test16_1_A = Algorithm(test16_1_circuit, getMeasurements(qubits_num=3), [0, 1])
# d(A(rou), A(sigma)) <= delta
indices = []
while len(indices) < 50:
a = random.randint(0, len(X_train2) - 1)
b = random.randint(0, len(X_train2) - 1)
if a != b:
indices.append([a, b])
distances = []
for pair in indices:
rou = getDensityMatrix(createInputCircuit(X_train2[pair[0]]))
sigma = getDensityMatrix(createInputCircuit(X_train2[pair[1]]))
distances.append(d(test16_1_A, rou, sigma))
print('find proper delta - circle')
print(f'Mean distance: {sum(distances) / len(distances)}')
print(f'Max distance: {max(distances)}')
print(f'Min distance: {min(distances)}')
# Test 16-2: find proper delta - iris
test16_2_circuit = createModelCircuit(params_iris)
test16_2_A = Algorithm(test16_2_circuit, getMeasurements(qubits_num=4), [0, 1])
# d(A(rou), A(sigma)) <= delta
indices = []
while len(indices) < 50:
a = random.randint(0, len(X_train_iris) - 1)
b = random.randint(0, len(X_train_iris) - 1)
if a != b:
indices.append([a, b])
distances = []
for pair in indices:
rou = getDensityMatrix(createInputCircuit(X_train_iris[pair[0]]))
sigma = getDensityMatrix(createInputCircuit(X_train_iris[pair[1]]))
distances.append(d(test16_2_A, rou, sigma))
print('find proper delta - iris')
print(f'Mean distance: {sum(distances) / len(distances)}')
print(f'Max distance: {max(distances)}')
print(f'Min distance: {min(distances)}')
# Test 17-1: fairness verifying - circle
test17_1_circuit = createNoisyModelCircuit(params, p=0.001, errorType='bit_flip')
test17_1_A = Algorithm(test17_1_circuit, getMeasurements(qubits_num=3), [0, 1])
print(f'Lipschitz constant: {Lipschitz(test17_1_A)[0]}\n')
test17_1_fairness_params = [
# epsilon, delta
[1, 1], [0.9, 0.89], [0.6, 0.58], [0.6, 0.59]
]
for epsilon, delta in test17_1_fairness_params:
flag, kernel = FairVeriQ(test17_1_A, epsilon, delta)
print(f'A is ({epsilon},{delta})-fair: <{flag}>')
if not flag:
print(f' - bias kernel pair is: {kernel}')
print()
# Test 17-2: fairness verifying - iris
test17_2_circuit = createNoisyModelCircuit(params_iris, p=0.001, errorType='phase_flip')
test17_2_A = Algorithm(test17_2_circuit, getMeasurements(qubits_num=4), [0, 1])
print(f'Lipschitz constant: {Lipschitz(test17_2_A)[0]}\n')
test17_2_fairness_params = [
# epsilon, delta
[1, 0.99], [0.8, 0.79], [0.5, 0.3]
]
for epsilon, delta in test17_2_fairness_params:
flag, kernel = FairVeriQ(test17_2_A, epsilon, delta)
print(f'A is ({epsilon},{delta})-fair: <{flag}>')
if not flag:
print(f' - bias kernel pair is: {kernel}')
print()
def generateBiasPair(sigma, kernel, epsilon):
psi, phi = kernel
size = len(psi)
psi = psi.reshape(size, 1) @ Dag(psi.reshape(size, 1))
phi = phi.reshape(size, 1) @ Dag(phi.reshape(size, 1))
rou_psi = epsilon * psi + (1 - epsilon) * sigma
rou_phi = epsilon * phi + (1 - epsilon) * sigma
return np.array([
rou_psi, rou_phi
])
# Test 18: generate bias pair
test18_circuit = createNoisyModelCircuit(params_iris, p=0.01, errorType='depolarizing')
test18_A = Algorithm(test18_circuit, getMeasurements(qubits_num=4), [0, 1])
print(f'Lipschitz constant: {Lipschitz(test17_2_A)[0]}\n')
flag, kernel = FairVeriQ(test18_A, epsilon=0.9, delta=0.3)
print(f'fairness: {flag}')
assert (not flag)
test18_sigma = getDensityMatrix(createInputCircuit(X_train_iris[11]))
test18_bias_pair = generateBiasPair(test18_sigma, kernel, epsilon=0.9)
test18_rou_psi, test18_rou_phi = test18_bias_pair
# print(test18_bias_pair)
print(f'epsilon=0.9, delta=0.3')
print('D: ', D(test18_rou_psi, test18_rou_phi))
print('d: ', d(test18_A, test18_rou_psi, test18_rou_phi))
|
https://github.com/usamisaori/qLipschitz
|
usamisaori
|
from sklearn import datasets
import numpy as np
import matplotlib.pyplot as plt
from qiskit.quantum_info import DensityMatrix
def getDensityMatrix(circuit):
return DensityMatrix(circuit).data
from qCircuit import createInputCircuit, createModelCircuit, createNoisyModelCircuit
from qLipschitz import QLipschitz
from qDistance import d, D
import warnings
warnings.filterwarnings('ignore')
X_train, Y_train = datasets.make_circles(n_samples=500, noise=0.09, factor=0.4)
X_test, Y_test = datasets.make_circles(n_samples=200, noise=0.09, factor=0.4)
print('Training Data:')
print(X_train[:10])
print('\nTraining Label:')
print(Y_train[:10])
plt.scatter(X_train[:, 0], X_train[:, 1], c=Y_train)
plt.show()
print(f'Total datas: {len(X_train)}')
print(f'labels: {list(set(Y_train))}')
print(f' - label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f' - label 1 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
Z_train = (X_train[:, 0] ** 2 + X_train[:, 1] ** 2) ** 0.5
temp = np.zeros((X_train.shape[0], len(X_train[0]) + 1))
temp[:, :-1] = X_train
temp[:, -1] = Z_train
X_train2 = temp
Z_test = (X_test[:, 0] ** 2 + X_test[:, 1] ** 2) ** 0.5
temp = np.zeros((X_test.shape[0], len(X_test[0]) + 1))
temp[:, :-1] = X_test
temp[:, -1] = Z_test
X_test2 = temp
print('Solved Training Data:')
print(X_train2[:10])
def plot3D(X, Y):
fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(
X[:, 0], X[:, 1], X[:, 2],
zdir='z', s=30, c=Y, depthshade=True
)
plt.show()
plot3D(X_train2, Y_train)
X, Y = datasets.load_iris(return_X_y=True)
X_train_0 = X[0:30]
X_train_1 = X[50:80]
X_train_iris = np.vstack((X_train_0, X_train_1))
Y_train_0 = Y[0:30]
Y_train_1 = Y[50:80]
Y_train_iris = np.vstack((Y_train_0, Y_train_1)).flatten()
X, Y = datasets.load_iris(return_X_y=True)
X_test_0 = X[30:50]
X_test_1 = X[80:100]
X_test_iris = np.vstack((X_test_0, X_test_1))
Y_test_0 = Y[30:50]
Y_test_1 = Y[80:100]
Y_test_iris = np.vstack((Y_test_0, Y_test_1)).flatten()
X_train_iris = (X_train_iris - X_train_iris.min(axis=0)) / (X_train_iris.max(axis=0) - X_train_iris.min(axis=0))
X_test_iris = (X_test_iris - X_test_iris.min(axis=0)) / (X_test_iris.max(axis=0) - X_test_iris.min(axis=0))
import qiskit
from qiskit import Aer, execute
qasm_backend = Aer.get_backend('qasm_simulator')
params = [
[[-1.18991246e-01, -8.69694713e-01, 1.43722811e-03],
[ 3.47641545e+00, -4.73632073e-02, 1.97135609e+00],
[ 1.95775707e+00, -1.12139160e-02, -6.21796144e-03]],
[[ 2.02460380e-02, -2.25797547e+00, 5.14234265e-03],
[-1.71552299e-02, 2.46283604e-03, -1.03805722e-02],
[-2.37244982e-03, -3.35799404e-03, 6.10191152e-03]]
]
params_iris = [
[[-3.42142600e-02, -5.45047534e-03, 8.11905347e-01],
[-1.52484152e+00, 1.49884676e+00, -1.25408626e-02],
[-1.89515860e-03, 1.35760410e-02, 8.22999582e-03],
[ 1.39102114e+00, 4.19729865e-01, 1.60000380e-04]],
[[ 7.88431068e-01, -8.86177264e-01, 1.33830291e-02],
[-3.71228143e-03, -1.12994101e-02, -1.27897783e-02],
[ 9.45954683e-03, -3.34659883e-03, 1.17217829e-02],
[ 1.98256181e-02, -1.07358054e-02, 7.53621360e-03]]
]
# Test 1: createModelCircuit
createModelCircuit(params).draw(output='mpl')
def predict(model, data):
qubits_num = len(data)
input_circuit = createInputCircuit(data)
qcircuit = input_circuit.compose(model)
# the measurement
qcircuit.measure(list(range(qubits_num)), list(range(qubits_num)))
# job execution
shots = 1000
job_sim = execute(qcircuit, qasm_backend, shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qcircuit)
p1 = 0
for i in range(2 ** (qubits_num - 1)):
comb = str(bin(i + 2 ** (qubits_num - 1))[2:])
p1 += counts.get(comb, 0)
p1 /= shots
if p1 > 0.5:
return 1
else:
return 0
def accuracy(model, datas, labels):
predictions = [ predict(model, data) for data in datas ]
acc = 0
for i, p in enumerate(predictions):
if p == labels[i]:
acc += 1
return acc / len(predictions)
def evaluate(model, X_test, Y_test):
acc = accuracy(model, X_test, Y_test)
print("FINAL ACCURACY: {:0.2f}%".format(acc * 100))
# Test 2: evaluate noiseless model
test2_circuit = createModelCircuit(params_iris)
evaluate(test2_circuit, X_train_iris, Y_train_iris)
evaluate(test2_circuit, X_test_iris, Y_test_iris)
# Test 3: create noisy model circuit - circle
test3_p = 0.001
test3_circuit = createNoisyModelCircuit(params, test3_p, 'phase_flip')
test3_circuit.draw(output='mpl')
# Test 4: evaluate noisy model - circle
test4_p = 0.001
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
test4_circuits = [
createModelCircuit(params),
createNoisyModelCircuit(params, test4_p, 'bit_flip'),
createNoisyModelCircuit(params, test4_p, 'phase_flip'),
createNoisyModelCircuit(params, test4_p, 'depolarizing')
]
for i, model_type in enumerate(models_type):
print(f'Evaluate <{model_type}>: ')
evaluate(test4_circuits[i], X_test2, Y_test)
print()
# Test 5: calculate lipschitz constant
print('Classifier for centric circle: ')
test5_1_circuit = createModelCircuit(params)
test5_1_qlipschitz = QLipschitz(test5_1_circuit, [0, 1])
print(test5_1_qlipschitz.constant)
print('\nClassifier for Iris: ')
test5_2_circuit = createModelCircuit(params_iris)
test5_2_qlipschitz = QLipschitz(test5_2_circuit, [0, 1])
print(test5_2_qlipschitz.constant)
# Test 6-1: calculate lipschitz constant in noisy model
test6_p = [0.0001, 0.001, 0.05, 0.1]
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
print('Classifier for centric circle: ')
for p in test6_p:
test6_1_circuits = [
createModelCircuit(params),
createNoisyModelCircuit(params, p, 'bit_flip'),
createNoisyModelCircuit(params, p, 'phase_flip'),
createNoisyModelCircuit(params, p, 'depolarizing')
]
print(f'p: {p}')
for i, model_type in enumerate(models_type):
test6_1_qlipschitz = QLipschitz(test6_1_circuits[i], [0, 1])
print(f'{model_type} model: {test6_1_qlipschitz.constant[0]}')
print()
# Test 6-2: calculate lipschitz constant in noisy model
test6_p = [0.0001, 0.001, 0.05, 0.1]
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
print('Classifier for Iris: ')
for p in test6_p:
test6_2_circuits = [
createModelCircuit(params_iris),
createNoisyModelCircuit(params_iris, p, 'bit_flip'),
createNoisyModelCircuit(params_iris, p, 'phase_flip'),
createNoisyModelCircuit(params_iris, p, 'depolarizing')
]
print(f'p: {p}')
for i, model_type in enumerate(models_type):
test6_2_qlipschitz = QLipschitz(test6_2_circuits[i], [0, 1])
print(f'{model_type} model: {test6_2_qlipschitz.constant[0]}')
print()
# Test 7-1: find proper epsilon - circle
import random
# D(rou, sigma) <= epsilon
indices = []
while len(indices) < 50:
a = random.randint(0, len(X_train2) - 1)
b = random.randint(0, len(X_train2) - 1)
if a != b:
indices.append([a, b])
distances = []
for pair in indices:
rou = getDensityMatrix(createInputCircuit(X_train2[pair[0]]))
sigma = getDensityMatrix(createInputCircuit(X_train2[pair[1]]))
distances.append(D(rou, sigma))
print('find proper epsilon - centric circle')
print(f'Mean distance: {sum(distances) / len(distances)}')
print(f'Max distance: {max(distances)}')
print(f'Min distance: {min(distances)}')
# Test 7-2: find proper epsilon - iris
# D(rou, sigma) <= epsilon
indices = []
while len(indices) < 50:
a = random.randint(0, len(X_train_iris) - 1)
b = random.randint(0, len(X_train_iris) - 1)
if a != b:
indices.append([a, b])
distances = []
for pair in indices:
rou = getDensityMatrix(createInputCircuit(X_train_iris[pair[0]]))
sigma = getDensityMatrix(createInputCircuit(X_train_iris[pair[1]]))
distances.append(D(rou, sigma))
print('find proper epsilon - centric iris')
print(f'Mean distance: {sum(distances) / len(distances)}')
print(f'Max distance: {max(distances)}')
print(f'Min distance: {min(distances)}')
# Test 8-1: find proper delta - circle
test8_1_circuit = createModelCircuit(params)
test8_1_qlipschitz = QLipschitz(test8_1_circuit, [0, 1])
test8_1_A = test8_1_qlipschitz.A
# d(A(rou), A(sigma)) <= delta
indices = []
while len(indices) < 50:
a = random.randint(0, len(X_train2) - 1)
b = random.randint(0, len(X_train2) - 1)
if a != b:
indices.append([a, b])
distances = []
for pair in indices:
rou = getDensityMatrix(createInputCircuit(X_train2[pair[0]]))
sigma = getDensityMatrix(createInputCircuit(X_train2[pair[1]]))
distances.append(d(test8_1_A, rou, sigma))
print('find proper delta - circle')
print(f'Mean distance: {sum(distances) / len(distances)}')
print(f'Max distance: {max(distances)}')
print(f'Min distance: {min(distances)}')
# Test 8-2: find proper delta - circle
test8_2_circuit = createModelCircuit(params_iris)
test8_2_qlipschitz = QLipschitz(test8_2_circuit, [0, 1])
test8_2_A = test8_2_qlipschitz.A
# d(A(rou), A(sigma)) <= delta
indices = []
while len(indices) < 50:
a = random.randint(0, len(X_train_iris) - 1)
b = random.randint(0, len(X_train_iris) - 1)
if a != b:
indices.append([a, b])
distances = []
for pair in indices:
rou = getDensityMatrix(createInputCircuit(X_train_iris[pair[0]]))
sigma = getDensityMatrix(createInputCircuit(X_train_iris[pair[1]]))
distances.append(d(test8_2_A, rou, sigma))
print('find proper delta - iris')
print(f'Mean distance: {sum(distances) / len(distances)}')
print(f'Max distance: {max(distances)}')
print(f'Min distance: {min(distances)}')
# Test 9-1: fairness verifying - circle
test9_1_circuit = createNoisyModelCircuit(params, p=0.001, errorType='bit_flip')
test9_1_qlipschitz = QLipschitz(test9_1_circuit, [0, 1])
print(f'Lipschitz constant: {test9_1_qlipschitz.constant[0]}\n')
test9_1_fairness_params = [
# epsilon, delta
[1, 1], [0.9, 0.89], [0.6, 0.58], [0.6, 0.59]
]
for epsilon, delta in test9_1_fairness_params:
flag, kernel = test9_1_qlipschitz.fairVeriQ(epsilon, delta)
print(f'A is ({epsilon},{delta})-fair: <{flag}>')
if not flag:
print(f' - bias kernel pair is: {kernel}')
print()
# Test 9-2: fairness verifying - iris
test9_2_circuit = createNoisyModelCircuit(params_iris, p=0.001, errorType='phase_flip')
test9_2_qlipschitz = QLipschitz(test9_2_circuit, [0, 1])
print(f'Lipschitz constant: {test9_2_qlipschitz.constant[0]}\n')
test9_2_fairness_params = [
# epsilon, delta
[1, 0.99], [0.8, 0.79], [0.5, 0.3]
]
for epsilon, delta in test9_2_fairness_params:
flag, kernel = test9_1_qlipschitz.fairVeriQ(epsilon, delta)
print(f'A is ({epsilon},{delta})-fair: <{flag}>')
if not flag:
print(f' - bias kernel pair is: {kernel}')
print()
# Test 10: generate bias pair
test10_circuit = createNoisyModelCircuit(params_iris, p=0.01, errorType='depolarizing')
test10_qlipschitz = QLipschitz(test10_circuit, [0, 1])
print(f'Lipschitz constant: {test10_qlipschitz.constant[0]}\n')
flag, kernel = test10_qlipschitz.fairVeriQ(epsilon=0.9, delta=0.3)
print(f'fairness: {flag}')
assert (not flag)
test10_sigma = getDensityMatrix(createInputCircuit(X_train_iris[11]))
test10_bias_pair = test10_qlipschitz.generateBiasPair(test10_sigma, kernel, epsilon=0.9)
test10_rou_psi, test10_rou_phi = test10_bias_pair
# print(test10_bias_pair)
print(f'epsilon=0.9, delta=0.3')
print('D: ', D(test10_rou_psi, test10_rou_phi))
print('d: ', d(test10_qlipschitz.A, test10_rou_psi, test10_rou_phi))
|
https://github.com/usamisaori/qLipschitz
|
usamisaori
|
from sklearn import datasets
import pennylane as qml
import numpy as np
from pennylane.optimize import AdamOptimizer
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
X_train, Y_train = datasets.make_circles(n_samples=200, noise=0.09, factor=0.4)
X_test, Y_test = datasets.make_circles(n_samples=50, noise=0.09, factor=0.4)
print('Training Data:')
print(X_train[:10])
print('\nTraining Label:')
print(Y_train[:10])
plt.scatter(X_train[:, 0], X_train[:, 1], c=Y_train)
plt.show()
print(f'Total datas: {len(X_train)}')
print(f'labels: {list(set(Y_train))}')
print(f'label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f'label 1 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
Z_train = (X_train[:, 0] ** 2 + X_train[:, 1] ** 2) ** 0.5
temp = np.zeros((X_train.shape[0], len(X_train[0]) + 1))
temp[:, :-1] = X_train
temp[:, -1] = Z_train
X_train2 = temp
Z_test = (X_test[:, 0] ** 2 + X_test[:, 1] ** 2) ** 0.5
temp = np.zeros((X_test.shape[0], len(X_test[0]) + 1))
temp[:, :-1] = X_test
temp[:, -1] = Z_test
X_test2 = temp
print('Solved Training Data:')
print(X_train2[:10])
def plot3D(X, Y):
fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(
X[:, 0], X[:, 1], X[:, 2],
zdir='z', s=30, c=Y, depthshade=True
)
plt.show()
plot3D(X_train2, Y_train)
print(f'Total datas: {len(X_train2)}')
print(f'labels: {list(set(Y_train))}')
print(f'label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f'label 1 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
qubits_num = 3
layers_num = 2
dev = qml.device("default.qubit", wires=qubits_num)
class VQC:
def __init__(self):
# 3 => U3(theta, phi, lambda)
self.params = (0.05 * np.random.randn(layers_num, qubits_num, 3))
self.bestparams = self.params
self.bestcost = 10
self.opt = AdamOptimizer(0.08)
self.weights = []
self.costs = []
self.accuracies = []
def fit(self, X_train, Y_train, epoch=300):
batch_size = 20
for turn in range(epoch):
# Update the weights by one optimizer step
batch_index = np.random.randint(0, len(X_train), (batch_size,))
X_train_batch = X_train[batch_index]
Y_train_batch = Y_train[batch_index]
self.params = self.opt.step(lambda v: cost(v, X_train_batch, Y_train_batch), self.params)
cost_now = cost(self.params, X_train, Y_train)
acc_now = accuracy(self.params, X_train, Y_train)
if cost_now < self.bestcost:
self.bestcost = cost_now
self.bestparams = self.params
self.weights.append(self.params)
self.costs.append(cost_now)
self.accuracies.append(acc_now)
print(
"Turn: {:5d} | Cost: {:0.7f} | Accuracy: {:0.2f}% ".format(
turn + 1, cost_now, acc_now * 100
))
def score(self, X_test, Y_test):
predictions = [ predict(self.bestparams, data) for data in X_test ]
acc = accuracy(self.bestparams, X_test, Y_test)
print("FINAL ACCURACY: {:0.2f}%".format(acc * 100))
@qml.qnode(dev)
def circuit(params, data):
angles = [ i * np.pi for i in data ]
for i in range(qubits_num):
qml.RX(angles[i], wires=i)
qml.Rot( *params[0, i], wires=i )
qml.CZ(wires=[1, 0])
qml.CZ(wires=[1, 2])
qml.CZ(wires=[0, 2])
for i in range(qubits_num):
qml.Rot( *params[1, i], wires=i )
# PauliZ measure => 1 -> |0> while -1 -> |1>
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)), qml.expval(qml.PauliZ(2))
import qiskit
import numpy as np
from qiskit import QuantumCircuit
from qiskit import Aer, execute
unitary_backend = Aer.get_backend('unitary_simulator')
qasm_backend = Aer.get_backend('qasm_simulator')
def predict(params, data):
qcircuit = QuantumCircuit(3, 3)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
qcircuit.cz(qubits[0], qubits[1])
qcircuit.cz(qubits[1], qubits[2])
qcircuit.cz(qubits[0], qubits[2])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
# the measurement
qcircuit.measure([0, 1, 2], [0, 1, 2])
# job execution
shots = 1000
job_sim = execute(qcircuit, qasm_backend, shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qcircuit)
p1 = (counts.get('100', 0) + counts.get('111', 0) + counts.get('101', 0) + counts.get('110', 0)) / shots
if p1 > 0.5:
return 1
else:
return 0
def cost(weights, datas, labels):
loss = 0
for i, data in enumerate(datas):
# like [-1, 1, 1]
measured = circuit(weights, data)
p = measured[0]
if labels[i] == 0:
loss += (1 - p) ** 2
else:
loss += (-1 - p) ** 2
return loss / len(datas)
def accuracy(weights, datas, labels):
predictions = [ predict(weights, data) for data in datas ]
acc = 0
for i, p in enumerate(predictions):
if p == labels[i]:
acc += 1
return acc / len(predictions)
vqc = VQC()
# vqc.params = np.array([[[-1.18991246e-01, -8.69694713e-01, 1.43722811e-03],
# [ 3.47641545e+00, -4.73632073e-02, 1.97135609e+00],
# [ 1.95775707e+00, -1.12139160e-02, -6.21796144e-03]],
# [[ 2.02460380e-02, -2.25797547e+00, 5.14234265e-03],
# [-1.71552299e-02, 2.46283604e-03, -1.03805722e-02],
# [-2.37244982e-03, -3.35799404e-03, 6.10191152e-03]]])
vqc.fit(X_train2, Y_train, epoch=10)
print(cost(vqc.bestparams, X_train2, Y_train))
print(cost(vqc.bestparams, X_test2, Y_test))
vqc.score(X_test2, Y_test)
def createCircuit(params, data):
qcircuit = QuantumCircuit(3, 3)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
qcircuit.cz(qubits[0], qubits[1])
qcircuit.cz(qubits[1], qubits[2])
qcircuit.cz(qubits[0], qubits[2])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
return qcircuit
qcircuit = createCircuit(vqc.bestparams, X_train2[0])
qcircuit.draw(output='mpl')
def measure(qcircuit, label):
# the measurement
qcircuit.measure([0, 1, 2], [0, 1, 2])
# job execution
shots = 1000
job_sim = execute(qcircuit, qasm_backend, shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qcircuit)
print(f'simulation results: \n{counts}')
p1 = (counts.get('100', 0) + counts.get('111', 0) + counts.get('101', 0) + counts.get('110',0)) / shots
print(f'p1: {p1}')
print(f'Expected label: {label}')
example = [3, 30, 35, 70]
for index in example:
qcircuit = createCircuit(vqc.bestparams, X_train2[index])
measure(qcircuit, Y_train[index])
print()
# origin data
plt.scatter(X_train2[:, 0], X_train2[:, 1], c=Y_train)
plt.show()
predictions = [ predict(vqc.bestparams, data) for data in X_test2 ]
Y_ = [ Y_test[i] if Y_test[i] == predictions[i] else 2 for i in range(len(Y_test)) ]
plt.scatter(X_test2[:, 0], X_test2[:, 1], c=Y_)
plt.show()
train_params(X_train2[10:50], Y_train[10:50])
|
https://github.com/usamisaori/qLipschitz
|
usamisaori
|
from sklearn import datasets
import pennylane as qml
import numpy as np
from pennylane.optimize import AdamOptimizer
import matplotlib.pyplot as plt
X_train, Y_train = datasets.make_circles(n_samples=200, noise=0.09, factor=0.4)
X_test, Y_test = datasets.make_circles(n_samples=50, noise=0.09, factor=0.4)
print('Training Data:')
print(X_train[:10])
print('\nTraining Label:')
print(Y_train[:10])
plt.scatter(X_train[:, 0], X_train[:, 1], c=Y_train)
plt.show()
print(f'Total datas: {len(X_train)}')
print(f'labels: {list(set(Y_train))}')
print(f'label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f'label 1 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
Z_train = (X_train[:, 0] ** 2 + X_train[:, 1] ** 2) ** 0.5
temp = np.zeros((X_train.shape[0], len(X_train[0]) + 1))
temp[:, :-1] = X_train
temp[:, -1] = Z_train
X_train2 = temp
Z_test = (X_test[:, 0] ** 2 + X_test[:, 1] ** 2) ** 0.5
temp = np.zeros((X_test.shape[0], len(X_test[0]) + 1))
temp[:, :-1] = X_test
temp[:, -1] = Z_test
X_test2 = temp
print('Solved Training Data:')
print(X_train2[:10])
def plot3D(X, Y):
fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(
X[:, 0], X[:, 1], X[:, 2],
zdir='z', s=30, c=Y, depthshade=True
)
plt.show()
plot3D(X_train2, Y_train)
print(f'Total datas: {len(X_train2)}')
print(f'labels: {list(set(Y_train))}')
print(f'label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f'label 1 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
qubits_num = 3
layers_num = 2
dev = qml.device("default.qubit", wires=qubits_num)
class VQC:
def __init__(self):
# 3 => U3(theta, phi, lambda)
self.params = (0.05 * np.random.randn(layers_num, qubits_num, 3))
params = [-1.18991246e-01, -8.69694713e-01, 1.43722811e-03]
self.params = [
[params, [ 3.47641545e+00, -4.73632073e-02, 1.97135609e+00], [ 1.95775707e+00, -1.12139160e-02, -6.21796144e-03]],
[params, [ 3.47641545e+00, -4.73632073e-02, 1.97135609e+00], [ 1.95775707e+00, -1.12139160e-02, -6.21796144e-03]],
]
self.params = [
[-0.09117728, -1.11137259, -1.33992893, -1.49234722, -1.64223525,
-1.63931865, -1.75914568, -1.78395664, -1.64893105],
(0.05 * np.random.randn(1, 9))[0]
]
self.bestparams = self.params
self.bestcost = 10
self.opt = AdamOptimizer(0.1)
self.weights = []
self.costs = []
self.accuracies = []
def fit(self, X_train, Y_train, epoch=300):
batch_size = 20
for turn in range(epoch):
# Update the weights by one optimizer step
batch_index = np.random.randint(0, len(X_train), (batch_size,))
X_train_batch = X_train[batch_index]
Y_train_batch = Y_train[batch_index]
self.params = self.opt.step(lambda v: cost(v, X_train_batch, Y_train_batch), self.params)
cost_now = cost(self.params, X_train, Y_train)
acc_now = accuracy(self.params, X_train, Y_train)
if cost_now < self.bestcost:
self.bestcost = cost_now
self.bestparams = self.params
self.weights.append(self.params)
self.costs.append(cost_now)
self.accuracies.append(acc_now)
print(
"Turn: {:5d} | Cost: {:0.7f} | Accuracy: {:0.2f}% ".format(
turn + 1, cost_now, acc_now * 100
))
def score(self, X_test, Y_test):
predictions = [ predict(self.bestparams, data) for data in X_test ]
acc = accuracy(self.bestparams, X_test, Y_test)
print("FINAL ACCURACY: {:0.2f}%".format(acc * 100))
@qml.qnode(dev)
def circuit(params, data):
angles = [ i * np.pi for i in data ]
for i in range(qubits_num):
qml.RX(angles[i], wires=i)
qml.Rot( *params[0, i], wires=i )
qml.CZ(wires=[1, 0])
qml.CZ(wires=[1, 2])
qml.CZ(wires=[0, 2])
for i in range(qubits_num):
qml.Rot( *params[1, i], wires=i )
# PauliZ measure => 1 -> |0> while -1 -> |1>
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)), qml.expval(qml.PauliZ(2))
import qiskit
import numpy as np
from qiskit import QuantumCircuit
from qiskit import Aer, execute
unitary_backend = Aer.get_backend('unitary_simulator')
qasm_backend = Aer.get_backend('qasm_simulator')
def predict(params, data):
qcircuit = QuantumCircuit(3, 3)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
qcircuit.cz(qubits[0], qubits[1])
qcircuit.cz(qubits[1], qubits[2])
qcircuit.cz(qubits[0], qubits[2])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
# the measurement
qcircuit.measure([0, 1, 2], [0, 1, 2])
# job execution
shots = 1000
job_sim = execute(qcircuit, qasm_backend, shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qcircuit)
p1 = (counts.get('100', 0) + counts.get('111', 0) + counts.get('101', 0) + counts.get('110',0)) / shots
if p1 > 0.5:
return 1
else:
return 0
def cost(weights, datas, labels):
loss = 0
for i, data in enumerate(datas):
# like [-1, 1, 1]
measured = circuit(weights, data)
p = measured[0]
if labels[i] == 0:
loss += (1 - p) ** 2
else:
loss += (-1 - p) ** 2
return loss / len(datas)
def accuracy(weights, datas, labels):
predictions = [ predict(weights, data) for data in datas ]
acc = 0
for i, p in enumerate(predictions):
if p == labels[i]:
acc += 1
return acc / len(predictions)
vqc = VQC()
vqc = VQC()
vqc.fit(X_train2, Y_train, epoch=50)
vqc.bestparams = [[[-1.18991246e-01, -8.69694713e-01, 1.43722811e-03],
[ 3.47641545e+00, -4.73632073e-02, 1.97135609e+00],
[ 1.95775707e+00, -1.12139160e-02, -6.21796144e-03]],
[[ 2.02460380e-02, -2.25797547e+00, 5.14234265e-03],
[-1.71552299e-02, 2.46283604e-03, -1.03805722e-02],
[-2.37244982e-03, -3.35799404e-03, 6.10191152e-03]]]
print(cost(vqc.bestparams, X_train2, Y_train))
print(cost(vqc.bestparams, X_test2, Y_test))
vqc.score(X_test2, Y_test)
def createCircuit(params, data):
qcircuit = QuantumCircuit(3, 3)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
qcircuit.cz(qubits[0], qubits[1])
qcircuit.cz(qubits[1], qubits[2])
qcircuit.cz(qubits[0], qubits[2])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
return qcircuit
qcircuit = createCircuit(vqc.bestparams, X_train2[0])
qcircuit.draw(output='mpl')
def measure(qcircuit, label):
# the measurement
qcircuit.measure([0, 1, 2], [0, 1, 2])
# job execution
shots = 1000
job_sim = execute(qcircuit, qasm_backend, shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qcircuit)
print(f'simulation results: \n{counts}')
p1 = (counts.get('100', 0) + counts.get('111', 0) + counts.get('101', 0) + counts.get('110',0)) / shots
print(f'p1: {p1}')
print(f'Expected label: {label}')
example = [0, 30, 35, 70]
for index in example:
qcircuit = createCircuit(vqc.bestparams, X_train2[index])
measure(qcircuit, Y_train[index])
print()
# origin data
plt.scatter(X_train2[:, 0], X_train2[:, 1], c=Y_train)
plt.show()
predictions = [ predict(vqc.bestparams, data) for data in X_test2 ]
Y_ = [ Y_test[i] if Y_test[i] == predictions[i] else 2 for i in range(len(Y_test)) ]
plt.scatter(X_test2[:, 0], X_test2[:, 1], c=Y_)
plt.show()
print(X_train2[9])
print(Y_train[9])
print(X_train2[7])
print(Y_train[7])
params = [[[-1.18991246e-01, -8.69694713e-01, 1.43722811e-03],
[ 3.47641545e+00, -4.73632073e-02, 1.97135609e+00],
[ 1.95775707e+00, -1.12139160e-02, -6.21796144e-03]],
[[ 2.02460380e-02, -2.25797547e+00, 5.14234265e-03],
[-1.71552299e-02, 2.46283604e-03, -1.03805722e-02],
[-2.37244982e-03, -3.35799404e-03, 6.10191152e-03]]]
params = [[
[1.571, 1.571, 1.571],[1.571, 1.571, 1.571],[1.571, 1.571, 1.571],
],[
[1.571, 1.571, 1.571],[1.571, 1.571, 1.571],[1.571, 1.571, 1.571],
]]
def getCircuits(a, b):
circuit0 = QuantumCircuit(3, 3)
qubits = circuit0.qubits
for i, d in enumerate(X_train2[a]):
circuit0.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
circuit0.u3(*params[0][i], qubits[i])
circuit1 = QuantumCircuit(3, 3)
qubits = circuit1.qubits
for i, d in enumerate(X_train2[b]):
circuit1.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
circuit1.u3(*params[0][i], qubits[i])
return circuit0, circuit1
circuit0, circuit1 = getCircuits(12, 60)
circuit0.draw(output='mpl')
circuit1.draw(output='mpl')
from scipy.linalg import sqrtm
def D(rou, sigma):
A = rou - sigma
A_ = sqrtm( np.dot( A.conj().T, A ) )
return 0.5 * np.linalg.norm( np.trace(A_) )
from qiskit.quantum_info import DensityMatrix, Statevector
def getDensityMatrix(circuit):
return DensityMatrix(circuit).data
def getStatevector(circuit):
return Statevector(circuit).data
print(X_train2[3])
print(Y_train[3])
print(X_train2[15])
print(Y_train[15])
circuit0, circuit1 = getCircuits(3,15)
matrix_0 = getDensityMatrix(circuit0)
matrix_1 = getDensityMatrix(circuit1)
print(D(matrix_0, matrix_1))
def params_loss(params, data1, data2, label1, label2):
circuit1 = QuantumCircuit(3, 3)
qubits = circuit1.qubits
for i, d in enumerate(data1):
circuit1.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
circuit1.u3(*params[i*3: (i+1)*3], qubits[i])
circuit2 = QuantumCircuit(3, 3)
qubits = circuit2.qubits
for i, d in enumerate(data1):
circuit1.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
circuit1.u3(*params[i*3: (i+1)*3], qubits[i])
matrix_1 = getDensityMatrix(circuit1)
matrix_2 = getDensityMatrix(circuit2)
d = D(matrix_1, matrix_2)
if label1 == label2:
return d ** 2
else:
return (1 - d) ** 2
print(Y_train[10:30])
def train_params(datas, labels):
params = (0.01 * np.random.randn(1, 9))[0]
length = len(params)
momentum, s = 0, 0
alpha = 0.1
belta1 = 0.9; belta2 = 0.999
e = 1e-8
for epoch in range(40):
loss_origin = 0
derivates = np.zeros(len(params))
for t in range(10):
a, b = t, t + 10
loss_origin += params_loss(params, datas[a], datas[b], labels[a], labels[b])
for i in range(len(params)):
params[i] += 0.01
loss = 0
for t in range(10):
a, b = t, t + 10
loss += params_loss(params, datas[a], datas[b], labels[a], labels[b])
derivates[i] = (loss - loss_origin) / 0.01
grad = derivates
# Adam Optimizer
momentum = belta1 * momentum + (1 - belta1) * grad
s = belta2 * s + (1 - belta2) * (grad ** 2)
m_ = momentum / (1 - belta1 ** t)
s_ = s / (1 - belta2 ** t)
# update parameters
params = params - alpha * (m_ / ( s_ ** 0.5 + e ))
return loss_origin, params
train_params(X_train2[10:50], Y_train[10:50])
|
https://github.com/usamisaori/qLipschitz
|
usamisaori
|
from sklearn import datasets
import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
X_train, Y_train = datasets.make_circles(n_samples=500, noise=0.09, factor=0.4)
X_test, Y_test = datasets.make_circles(n_samples=200, noise=0.09, factor=0.4)
print('Training Data:')
print(X_train[:10])
print('\nTraining Label:')
print(Y_train[:10])
plt.scatter(X_train[:, 0], X_train[:, 1], c=Y_train)
plt.show()
print(f'Total datas: {len(X_train)}')
print(f'labels: {list(set(Y_train))}')
print(f' - label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f' - label 1 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
Z_train = (X_train[:, 0] ** 2 + X_train[:, 1] ** 2) ** 0.5
temp = np.zeros((X_train.shape[0], len(X_train[0]) + 1))
temp[:, :-1] = X_train
temp[:, -1] = Z_train
X_train2 = temp
Z_test = (X_test[:, 0] ** 2 + X_test[:, 1] ** 2) ** 0.5
temp = np.zeros((X_test.shape[0], len(X_test[0]) + 1))
temp[:, :-1] = X_test
temp[:, -1] = Z_test
X_test2 = temp
print('Solved Training Data:')
print(X_train2[:10])
def plot3D(X, Y):
fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(
X[:, 0], X[:, 1], X[:, 2],
zdir='z', s=30, c=Y, depthshade=True
)
plt.show()
plot3D(X_train2, Y_train)
X, Y = datasets.load_iris(return_X_y=True)
X_train_0 = X[0:30]
X_train_1 = X[50:80]
X_train_iris = np.vstack((X_train_0, X_train_1))
Y_train_0 = Y[0:30]
Y_train_1 = Y[50:80]
Y_train_iris = np.vstack((Y_train_0, Y_train_1)).flatten()
X, Y = datasets.load_iris(return_X_y=True)
X_test_0 = X[30:50]
X_test_1 = X[80:100]
X_test_iris = np.vstack((X_test_0, X_test_1))
Y_test_0 = Y[30:50]
Y_test_1 = Y[80:100]
Y_test_iris = np.vstack((Y_test_0, Y_test_1)).flatten()
X_train_iris = (X_train_iris - X_train_iris.min(axis=0)) / (X_train_iris.max(axis=0) - X_train_iris.min(axis=0))
X_test_iris = (X_test_iris - X_test_iris.min(axis=0)) / (X_test_iris.max(axis=0) - X_test_iris.min(axis=0))
import qiskit
from qiskit import QuantumCircuit
from qiskit import Aer, execute
qasm_backend = Aer.get_backend('qasm_simulator')
params = [
[[-1.18991246e-01, -8.69694713e-01, 1.43722811e-03],
[ 3.47641545e+00, -4.73632073e-02, 1.97135609e+00],
[ 1.95775707e+00, -1.12139160e-02, -6.21796144e-03]],
[[ 2.02460380e-02, -2.25797547e+00, 5.14234265e-03],
[-1.71552299e-02, 2.46283604e-03, -1.03805722e-02],
[-2.37244982e-03, -3.35799404e-03, 6.10191152e-03]]
]
params_iris = [
[[-3.42142600e-02, -5.45047534e-03, 8.11905347e-01],
[-1.52484152e+00, 1.49884676e+00, -1.25408626e-02],
[-1.89515860e-03, 1.35760410e-02, 8.22999582e-03],
[ 1.39102114e+00, 4.19729865e-01, 1.60000380e-04]],
[[ 7.88431068e-01, -8.86177264e-01, 1.33830291e-02],
[-3.71228143e-03, -1.12994101e-02, -1.27897783e-02],
[ 9.45954683e-03, -3.34659883e-03, 1.17217829e-02],
[ 1.98256181e-02, -1.07358054e-02, 7.53621360e-03]]
]
def createInputCircuit(data):
qubits_num = len(data)
qcircuit = QuantumCircuit(qubits_num, qubits_num)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
return qcircuit
# Test 1: create input circuit
test1_circuit = createInputCircuit(X_train2[0])
test1_circuit.draw(output='mpl')
def createModelCircuit(params):
qubits_num = len(params[0])
qcircuit = QuantumCircuit(qubits_num, qubits_num)
qubits = qcircuit.qubits
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
for i in range(qubits_num - 1):
qcircuit.cz(qubits[i], qubits[i + 1])
qcircuit.cz(qubits[0], qubits[qubits_num - 1])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
return qcircuit
# Test 2: create model circuit
test2_circuit = createModelCircuit(params)
test2_circuit.draw(output='mpl')
def createCircuit(params, data):
input_circuit = createInputCircuit(data)
model_circuit = createModelCircuit(params)
full_circuit = input_circuit.compose(model_circuit)
return full_circuit
# Test 3-1: create full quantum circuit - circle
test3_circuit = createCircuit(params, X_train2[0])
test3_circuit.draw(output='mpl')
# Test 3-2: create full quantum circuit - iris
test3_circuit = createCircuit(params_iris, X_train_iris[1])
test3_circuit.draw(output='mpl')
def predict(model, data):
qubits_num = len(data)
input_circuit = createInputCircuit(data)
qcircuit = input_circuit.compose(model)
# the measurement
qcircuit.measure(list(range(qubits_num)), list(range(qubits_num)))
# job execution
shots = 1000
job_sim = execute(qcircuit, qasm_backend, shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qcircuit)
p1 = 0
for i in range(2 ** (qubits_num - 1)):
comb = str(bin(i + 2 ** (qubits_num - 1))[2:])
p1 += counts.get(comb, 0)
p1 /= shots
if p1 > 0.5:
return 1
else:
return 0
def accuracy(model, datas, labels):
predictions = [ predict(model, data) for data in datas ]
acc = 0
for i, p in enumerate(predictions):
if p == labels[i]:
acc += 1
return acc / len(predictions)
def evaluate(model, X_test, Y_test):
acc = accuracy(model, X_test, Y_test)
print("FINAL ACCURACY: {:0.2f}%".format(acc * 100))
# Test 4: evaluate noiseless model
test4_circuit = createModelCircuit(params_iris)
evaluate(test4_circuit, X_train_iris, Y_train_iris)
evaluate(test4_circuit, X_test_iris, Y_test_iris)
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.utils import insert_noise
from qiskit.providers.aer.noise import pauli_error, depolarizing_error
def createNoiseModel(p, errorType):
# QuantumError objects
if errorType == 'bit_flip':
error = pauli_error([('X', p), ('I', 1 - p)])
elif errorType == 'phase_flip':
error = pauli_error([('Z', p), ('I', 1 - p)])
elif errorType == 'depolarizing':
error = depolarizing_error(p, num_qubits=1)
## two-qubits quantumError objects
if errorType == 'depolarizing':
error_2qubits = depolarizing_error(p, num_qubits=2)
else:
error_2qubits = error.tensor(error)
# Add errors to noise model
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ['u3'])
noise_model.add_all_qubit_quantum_error(error_2qubits, ['cz'])
return noise_model
def createNoisyModelCircuit(params, p, errorType):
noise_model = createNoiseModel(p, errorType)
model_circuit = createModelCircuit(params)
return insert_noise(model_circuit, noise_model)
# Test 5-1: create noisy model circuit - circle
test5_p = 0.001
test5_circuit = createNoisyModelCircuit(params, test5_p, 'phase_flip')
test5_circuit.draw(output='mpl')
# Test 5-2: create noisy model circuit - iris
test5_p = 0.001
test5_circuit = createNoisyModelCircuit(params_iris, test5_p, 'bit_flip')
test5_circuit.draw(output='mpl')
# Test 6-1: evaluate noisy model - circle
test6_p = 0.001
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
test6_circuits = [
createModelCircuit(params),
createNoisyModelCircuit(params, test6_p, 'bit_flip'),
createNoisyModelCircuit(params, test6_p, 'phase_flip'),
createNoisyModelCircuit(params, test6_p, 'depolarizing')
]
for i, model_type in enumerate(models_type):
print(f'Evaluate <{model_type}>: ')
evaluate(test6_circuits[i], X_test2, Y_test)
print()
# Test 6-2: evaluate noisy model - iris
test6_p = 0.5
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
test6_circuits = [
createModelCircuit(params_iris),
createNoisyModelCircuit(params_iris, test6_p, 'bit_flip'),
createNoisyModelCircuit(params_iris, test6_p, 'phase_flip'),
createNoisyModelCircuit(params_iris, test6_p, 'depolarizing')
]
for i, model_type in enumerate(models_type):
print(f'Evaluate <{model_type}>: ')
evaluate(test6_circuits[i], X_test_iris, Y_test_iris)
print()
from functools import reduce
Dag = lambda matrix: matrix.conj().T
Kron = lambda *matrices: reduce(np.kron, matrices)
from qiskit.quantum_info import DensityMatrix, Statevector
def getDensityMatrix(circuit):
return DensityMatrix(circuit).data
def getStatevector(circuit):
return Statevector(circuit).data
psi_0 = np.array([1.0, 0.0])
psi_1 = np.array([0.0, 1.0])
I = np.eye(2)
M_0 = psi_0.reshape([2, 1]) @ psi_0.reshape([1, 2]).conj()
M_1 = psi_1.reshape([2, 1]) @ psi_1.reshape([1, 2]).conj()
def getMeasurements(qubits_num):
measurement_0 = [M_0]
measurement_1 = [M_1]
for i in range(qubits_num - 1):
measurement_0.append(I)
measurement_1.append(I)
return [
Kron(*measurement_0),
Kron(*measurement_1)
]
# Test 7: test measure
test7_M_0, test7_M_1 = getMeasurements(qubits_num=3)
# 2: |0> - X -
test7_1_circuit = QuantumCircuit(3, 3)
test7_1_circuit.x(test7_1_circuit.qubits[2])
test7_1_circuit.draw(output='mpl')
test7_1_density_matrix = getDensityMatrix(test7_1_circuit)
test7_1_p1 = np.trace( test7_M_1 @ test7_1_density_matrix @ Dag(test7_M_1) )
print(test7_1_p1) # should be 1
# 2: |0> - H -
test7_2_circuit = QuantumCircuit(3, 3)
test7_2_circuit.h(test7_2_circuit.qubits[2])
test7_2_circuit.draw(output='mpl')
test7_2_density_matrix = getDensityMatrix(test7_2_circuit)
test7_2_p1 = np.trace( test7_M_1 @ test7_2_density_matrix @ Dag(test7_M_1) )
print(test7_2_p1) # should be 0.5
test7_M_0, test7_M_1 = getMeasurements(qubits_num=4)
# 3: |0> - H -
test7_3_circuit = QuantumCircuit(4, 4)
test7_3_circuit.h(test7_3_circuit.qubits[3])
test7_3_circuit.draw(output='mpl')
test7_3_density_matrix = getDensityMatrix(test7_3_circuit)
test7_3_p1 = np.trace( test7_M_1 @ test7_3_density_matrix @ Dag(test7_M_1) )
print(test7_3_p1) # should be 0.5
def powerSets(items):
N = len(items)
combs = []
for i in range(2 ** N):
comb = []
for j in range(N):
if (i >> j) % 2:
comb.append(items[j])
combs.append(comb)
return combs
# Test 8: calculate power sets
print(powerSets([0, 1]))
class Algorithm:
def __init__(self, model_circuit, measurements, outputs):
# DensityMatrix of model
self.E = getDensityMatrix(model_circuit)
# Measurements
self.M = dict()
for index, output in enumerate(outputs):
self.M[output] = measurements[index]
# Outputs
self.O = outputs
self.O_ = powerSets(outputs)
# Test 9: algorithm objects
test9_circuit = createModelCircuit(params_iris)
test9_A = Algorithm(test9_circuit, getMeasurements(qubits_num=4), [0, 1])
print(test9_A.E.shape)
print(test9_A.O)
print(test9_A.O_)
from scipy.linalg import sqrtm
def D(rou, sigma):
A = rou - sigma
A_ = sqrtm( np.dot( A.conj().T, A ) )
return 0.5 * np.linalg.norm( np.trace(A_) )
# Test 10: trace distance example
from math import isclose
# example from: quantumnanophotonics.org/media/Module2Lecture8.pdf
test10_rou = np.array([[2.0, 0.0], [0.0, 1.0]]) / 3
test10_sigma = np.array([[3.0, 0.0], [0.0, 1.0]]) / 4
assert isclose(D(test10_rou, test10_sigma), 1/12)
# Test 11: calculate input states' distance
test11_rou = getDensityMatrix(createInputCircuit(X_train2[0]))
test11_sigma = getDensityMatrix(createInputCircuit(X_train2[1]))
print(D(test11_rou, test11_rou)) # should be 0
print(D(test11_rou, test11_sigma))
def d(A, rou, sigma):
distance = 0
for output in A.O:
trace = np.trace(
Dag(A.M[output]) @ A.M[output] @
(A.E @ (rou - sigma) @ Dag(A.E))
)
distance += np.linalg.norm(trace)
return distance / 2
# Test 12: calculate total variation distance
test12_circuit = createModelCircuit(params)
test12_A = Algorithm(test12_circuit, getMeasurements(qubits_num=3), [0, 1])
test12_rou = getDensityMatrix(createInputCircuit(X_train2[0]))
test12_sigma = getDensityMatrix(createInputCircuit(X_train2[1]))
print(d(test12_A, test12_rou, test12_rou))
print(d(test12_A, test12_rou, test12_sigma))
def Lipschitz(A):
E, M, O, O_ = A.E, A.M, A.O, A.O_
# Step 1: Calculate W_i
W = dict()
for i in O:
W[i] = Dag(E) @ Dag(M[i]) @ M[i] @ E
# Step 2: Calculate K_star
K_star = 0; vectors = [None, None]
M_star = np.zeros(E.shape)
for S in O_:
if len(S) == 0:
continue
# calculate M_S = Σ Wi
M_S = np.zeros(E.shape).astype('complex64')
for i in S:
M_S += W[i]
# calculate eigenvalues and eigenvectors of M_S
eigenvalues, eigenvectors = np.linalg.eigh(M_S)
min_index = np.where(eigenvalues == eigenvalues.min())
max_index = np.where(eigenvalues == eigenvalues.max())
# calculate K_S
K_S = np.linalg.norm(eigenvalues[max_index][0] - eigenvalues[min_index][0])
if K_S > K_star:
K_star = K_S
vectors[0] = eigenvectors.T[max_index][0]
vectors[1] = eigenvectors.T[min_index][0]
return K_star, np.array(vectors)
# Test 13: calculate lipschitz constant
print('Classifier for centric circle: ')
test13_1_circuit = createModelCircuit(params)
test13_1_A = Algorithm(test13_1_circuit, getMeasurements(qubits_num=3), [0, 1])
print(Lipschitz(test13_1_A))
print('\nClassifier for Iris: ')
test13_2_circuit = createModelCircuit(params_iris)
test13_2_A = Algorithm(test13_2_circuit, getMeasurements(qubits_num=4), [0, 1])
print(Lipschitz(test13_2_A))
# Test 14-1: calculate lipschitz constant in noisy model
test14_p = [0.0001, 0.001, 0.05, 0.1]
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
print('Classifier for centric circle: ')
for p in test14_p:
test14_1_circuits = [
createModelCircuit(params),
createNoisyModelCircuit(params, p, 'bit_flip'),
createNoisyModelCircuit(params, p, 'phase_flip'),
createNoisyModelCircuit(params, p, 'depolarizing')
]
print(f'p: {p}')
for i, model_type in enumerate(models_type):
test14_1_noisy_A = Algorithm(test14_1_circuits[i], getMeasurements(qubits_num=3), [0, 1])
print(f'{model_type} model: {Lipschitz(test14_1_noisy_A)[0]}')
print()
# Test 14-2: calculate lipschitz constant in noisy model
test14_p = [0.0001, 0.001, 0.05, 0.1]
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
print('Classifier for Iris: ')
for p in test14_p:
test14_2_circuits = [
createModelCircuit(params_iris),
createNoisyModelCircuit(params_iris, p, 'bit_flip'),
createNoisyModelCircuit(params_iris, p, 'phase_flip'),
createNoisyModelCircuit(params_iris, p, 'depolarizing')
]
print(f'p: {p}')
for i, model_type in enumerate(models_type):
test14_2_noisy_A = Algorithm(test14_2_circuits[i], getMeasurements(qubits_num=4), [0, 1])
print(f'{model_type} model: {Lipschitz(test14_2_noisy_A)[0]}')
print()
def FairVeriQ(A, epsilon, delta):
# epsilon <= 1 and delta > 0
K_star, kernel = Lipschitz(A)
if delta >= K_star * epsilon:
return True, None
else:
return False, kernel
# Test 15-1: find proper epsilon - circle
import random
# D(rou, sigma) <= epsilon
indices = []
while len(indices) < 50:
a = random.randint(0, len(X_train2) - 1)
b = random.randint(0, len(X_train2) - 1)
if a != b:
indices.append([a, b])
distances = []
for pair in indices:
rou = getDensityMatrix(createInputCircuit(X_train2[pair[0]]))
sigma = getDensityMatrix(createInputCircuit(X_train2[pair[1]]))
distances.append(D(rou, sigma))
print('find proper epsilon - centric circle')
print(f'Mean distance: {sum(distances) / len(distances)}')
print(f'Max distance: {max(distances)}')
print(f'Min distance: {min(distances)}')
# Test 15-2: find proper epsilon - iris
# D(rou, sigma) <= epsilon
indices = []
while len(indices) < 50:
a = random.randint(0, len(X_train_iris) - 1)
b = random.randint(0, len(X_train_iris) - 1)
if a != b:
indices.append([a, b])
distances = []
for pair in indices:
rou = getDensityMatrix(createInputCircuit(X_train_iris[pair[0]]))
sigma = getDensityMatrix(createInputCircuit(X_train_iris[pair[1]]))
distances.append(D(rou, sigma))
print('find proper epsilon - centric iris')
print(f'Mean distance: {sum(distances) / len(distances)}')
print(f'Max distance: {max(distances)}')
print(f'Min distance: {min(distances)}')
# Test 16-1: find proper delta - circle
test16_1_circuit = createModelCircuit(params)
test16_1_A = Algorithm(test16_1_circuit, getMeasurements(qubits_num=3), [0, 1])
# d(A(rou), A(sigma)) <= delta
indices = []
while len(indices) < 50:
a = random.randint(0, len(X_train2) - 1)
b = random.randint(0, len(X_train2) - 1)
if a != b:
indices.append([a, b])
distances = []
for pair in indices:
rou = getDensityMatrix(createInputCircuit(X_train2[pair[0]]))
sigma = getDensityMatrix(createInputCircuit(X_train2[pair[1]]))
distances.append(d(test16_1_A, rou, sigma))
print('find proper delta - circle')
print(f'Mean distance: {sum(distances) / len(distances)}')
print(f'Max distance: {max(distances)}')
print(f'Min distance: {min(distances)}')
# Test 16-2: find proper delta - iris
test16_2_circuit = createModelCircuit(params_iris)
test16_2_A = Algorithm(test16_2_circuit, getMeasurements(qubits_num=4), [0, 1])
# d(A(rou), A(sigma)) <= delta
indices = []
while len(indices) < 50:
a = random.randint(0, len(X_train_iris) - 1)
b = random.randint(0, len(X_train_iris) - 1)
if a != b:
indices.append([a, b])
distances = []
for pair in indices:
rou = getDensityMatrix(createInputCircuit(X_train_iris[pair[0]]))
sigma = getDensityMatrix(createInputCircuit(X_train_iris[pair[1]]))
distances.append(d(test16_2_A, rou, sigma))
print('find proper delta - iris')
print(f'Mean distance: {sum(distances) / len(distances)}')
print(f'Max distance: {max(distances)}')
print(f'Min distance: {min(distances)}')
# Test 17-1: fairness verifying - circle
test17_1_circuit = createNoisyModelCircuit(params, p=0.001, errorType='bit_flip')
test17_1_A = Algorithm(test17_1_circuit, getMeasurements(qubits_num=3), [0, 1])
print(f'Lipschitz constant: {Lipschitz(test17_1_A)[0]}\n')
test17_1_fairness_params = [
# epsilon, delta
[1, 1], [0.9, 0.89], [0.6, 0.58], [0.6, 0.59]
]
for epsilon, delta in test17_1_fairness_params:
flag, kernel = FairVeriQ(test17_1_A, epsilon, delta)
print(f'A is ({epsilon},{delta})-fair: <{flag}>')
if not flag:
print(f' - bias kernel pair is: {kernel}')
print()
# Test 17-2: fairness verifying - iris
test17_2_circuit = createNoisyModelCircuit(params_iris, p=0.001, errorType='phase_flip')
test17_2_A = Algorithm(test17_2_circuit, getMeasurements(qubits_num=4), [0, 1])
print(f'Lipschitz constant: {Lipschitz(test17_2_A)[0]}\n')
test17_2_fairness_params = [
# epsilon, delta
[1, 0.99], [0.8, 0.79], [0.5, 0.3]
]
for epsilon, delta in test17_2_fairness_params:
flag, kernel = FairVeriQ(test17_2_A, epsilon, delta)
print(f'A is ({epsilon},{delta})-fair: <{flag}>')
if not flag:
print(f' - bias kernel pair is: {kernel}')
print()
def generateBiasPair(sigma, kernel, epsilon):
psi, phi = kernel
size = len(psi)
psi = psi.reshape(size, 1) @ Dag(psi.reshape(size, 1))
phi = phi.reshape(size, 1) @ Dag(phi.reshape(size, 1))
rou_psi = epsilon * psi + (1 - epsilon) * sigma
rou_phi = epsilon * phi + (1 - epsilon) * sigma
return np.array([
rou_psi, rou_phi
])
# Test 18: generate bias pair
test18_circuit = createNoisyModelCircuit(params_iris, p=0.01, errorType='depolarizing')
test18_A = Algorithm(test18_circuit, getMeasurements(qubits_num=4), [0, 1])
print(f'Lipschitz constant: {Lipschitz(test17_2_A)[0]}\n')
flag, kernel = FairVeriQ(test18_A, epsilon=0.9, delta=0.3)
print(f'fairness: {flag}')
assert (not flag)
test18_sigma = getDensityMatrix(createInputCircuit(X_train_iris[11]))
test18_bias_pair = generateBiasPair(test18_sigma, kernel, epsilon=0.9)
test18_rou_psi, test18_rou_phi = test18_bias_pair
# print(test18_bias_pair)
print(f'epsilon=0.9, delta=0.3')
print('D: ', D(test18_rou_psi, test18_rou_phi))
print('d: ', d(test18_A, test18_rou_psi, test18_rou_phi))
|
https://github.com/usamisaori/qLipschitz
|
usamisaori
|
from sklearn import datasets
import pennylane as qml
import numpy as np
from pennylane.optimize import AdamOptimizer
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
X_train, Y_train = datasets.make_circles(n_samples=200, noise=0.06, factor=0.6)
X_test, Y_test = datasets.make_circles(n_samples=80, noise=0.06, factor=0.6)
print('Training Data:')
print(X_train[:10])
print('\nTraining Label:')
print(Y_train[:10])
plt.scatter(X_train[:, 0], X_train[:, 1], c=Y_train)
plt.show()
print(f'Total datas: {len(X_train)}')
print(f'labels: {list(set(Y_train))}')
print(f'label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f'label 1 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
Z_train = (X_train[:, 0] ** 2 + X_train[:, 1] ** 2) ** 0.5
temp = np.zeros((X_train.shape[0], len(X_train[0]) + 1))
temp[:, :-1] = X_train
temp[:, -1] = Z_train
X_train2 = temp
Z_test = (X_test[:, 0] ** 2 + X_test[:, 1] ** 2) ** 0.5
temp = np.zeros((X_test.shape[0], len(X_test[0]) + 1))
temp[:, :-1] = X_test
temp[:, -1] = Z_test
X_test2 = temp
print('Solved Training Data:')
print(X_train2[:10])
def plot3D(X, Y):
fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(
X[:, 0], X[:, 1], X[:, 2],
zdir='z', s=30, c=Y, depthshade=True
)
plt.show()
plot3D(X_train2, Y_train)
print(f'Total datas: {len(X_train2)}')
print(f'labels: {list(set(Y_train))}')
print(f'label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f'label 1 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
qubits_num = 3
layers_num = 2
dev = qml.device("default.qubit", wires=qubits_num)
@qml.qnode(dev)
def circuit(params, data):
angles = [ i * np.pi for i in data ]
for i in range(qubits_num):
qml.RX(angles[i], wires=i)
qml.Rot( *params[0, i], wires=i )
qml.CZ(wires=[1, 0])
qml.CZ(wires=[1, 2])
qml.CZ(wires=[0, 2])
for i in range(qubits_num):
qml.Rot( *params[1, i], wires=i )
# PauliZ measure => 1 -> |0> while -1 -> |1>
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)), qml.expval(qml.PauliZ(2))
import qiskit
from qiskit import QuantumCircuit
from qiskit import Aer, execute
unitary_backend = Aer.get_backend('unitary_simulator')
qasm_backend = Aer.get_backend('qasm_simulator')
def predict(params, data):
qcircuit = QuantumCircuit(3, 3)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
qcircuit.cz(qubits[0], qubits[1])
qcircuit.cz(qubits[1], qubits[2])
qcircuit.cz(qubits[0], qubits[2])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
# the measurement
qcircuit.measure([0, 1, 2], [0, 1, 2])
# job execution
shots = 1000
job_sim = execute(qcircuit, qasm_backend, shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qcircuit)
p1 = (counts.get('100', 0) + counts.get('111', 0) + counts.get('101', 0) + counts.get('110',0)) / shots
if p1 > 0.5:
return 1
else:
return 0
def cost(weights, datas, labels):
loss = 0
for i, data in enumerate(datas):
# like [-1, 1, 1]
measured = circuit(weights, data)
p = measured[0]
if labels[i] == 0:
loss += (1 - p) ** 2
else:
loss += (-1 - p) ** 2
return loss / len(datas)
def accuracy(weights, datas, labels):
predictions = [ predict(weights, data) for data in datas ]
acc = 0
for i, p in enumerate(predictions):
if p == labels[i]:
acc += 1
return acc / len(predictions)
class VQC:
def __init__(self):
# 3 => U3(theta, phi, lambda)
self.params = (0.01 * np.random.randn(layers_num, qubits_num, 3))
self.bestparams = self.params
self.bestcost = 10
self.weights = []
self.costs = []
self.accuracies = []
def fit(self, X_train, Y_train, *, epoch=300, stepsize=0.1):
self.opt = AdamOptimizer(stepsize)
batch_size = 30
for turn in range(epoch):
# Update the weights by one optimizer step
batch_index = np.random.randint(0, len(X_train), (batch_size,))
X_train_batch = X_train[batch_index]
Y_train_batch = Y_train[batch_index]
self.params = self.opt.step(lambda v: cost(v, X_train_batch, Y_train_batch), self.params)
cost_now = cost(self.params, X_train, Y_train)
acc_now = accuracy(self.params, X_train, Y_train)
if cost_now < self.bestcost:
self.bestcost = cost_now
self.bestparams = self.params
self.weights.append(self.params)
self.costs.append(cost_now)
self.accuracies.append(acc_now)
print(
"Turn: {:5d} | Cost: {:0.7f} | Accuracy: {:0.2f}% ".format(
turn + 1, cost_now, acc_now * 100
))
def score(self, X_test, Y_test):
predictions = [ predict(self.bestparams, data) for data in X_test ]
acc = accuracy(self.bestparams, X_test, Y_test)
print("FINAL ACCURACY: {:0.2f}%".format(acc * 100))
def train_params(datas, labels, *, epoch=30):
alpha_grid = [0.001, 0.05, 0.1, 0.125, 0.25, 0.35, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 2.25, 2.5, 2.75, 3]
# alpha_grid = [0.05, 0.15, 0.25, 0.5]
# alpha_grid = [0.05, 0.075, 0.1, 0.125, 0.25, 0.5, 0.75, 1]
alpha_best = None
loss_best = 1000
batch_size = 30
for alpha in alpha_grid:
print(f'alpha: {alpha}: ')
vqc = VQC()
vqc.fit(datas, labels, epoch=epoch, stepsize=alpha)
loss = vqc.bestcost
print(f' - finished. (loss {loss})\n')
if loss < loss_best:
loss_best = loss
alpha_best = alpha
return {
'alpha': alpha_best,
'loss': loss_best
}
train_params()
vqc = VQC()
vqc.fit(X_train2, Y_train, epoch=300, stepsize=)
|
https://github.com/usamisaori/qLipschitz
|
usamisaori
|
from sklearn import datasets
import pennylane as qml
import numpy as np
from pennylane.optimize import AdamOptimizer
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
X_train, Y_train = datasets.make_circles(n_samples=400, noise=0.06, factor=0.7)
X_test, Y_test = datasets.make_circles(n_samples=100, noise=0.06, factor=0.7)
print('Training Data:')
print(X_train[:10])
print('\nTraining Label:')
print(Y_train[:10])
plt.scatter(X_train[:, 0], X_train[:, 1], c=Y_train)
plt.show()
print(f'Total datas: {len(X_train)}')
print(f'labels: {list(set(Y_train))}')
print(f'label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f'label 1 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
Z_train = (X_train[:, 0] ** 2 + X_train[:, 1] ** 2) ** 0.5
temp = np.zeros((X_train.shape[0], len(X_train[0]) + 1))
temp[:, :-1] = X_train
temp[:, -1] = Z_train
X_train2 = temp
Z_test = (X_test[:, 0] ** 2 + X_test[:, 1] ** 2) ** 0.5
temp = np.zeros((X_test.shape[0], len(X_test[0]) + 1))
temp[:, :-1] = X_test
temp[:, -1] = Z_test
X_test2 = temp
print('Solved Training Data:')
print(X_train2[:10])
def plot3D(X, Y):
fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(
X[:, 0], X[:, 1], X[:, 2],
zdir='z', s=30, c=Y, depthshade=True
)
plt.show()
plot3D(X_train2, Y_train)
print(f'Total datas: {len(X_train2)}')
print(f'labels: {list(set(Y_train))}')
print(f'label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f'label 1 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
qubits_num = 3
layers_num = 2
dev = qml.device("default.qubit", wires=qubits_num)
@qml.qnode(dev)
def circuit(params, data):
angles = [ i * np.pi for i in data ]
for i in range(qubits_num):
qml.RX(angles[i], wires=i)
qml.Rot( *(params[0, i]), wires=i )
qml.CZ(wires=[1, 0])
qml.CZ(wires=[1, 2])
qml.CZ(wires=[0, 2])
for i in range(qubits_num):
qml.Rot( *(params[1, i]), wires=i )
# PauliZ measure => 1 -> |0> while -1 -> |1>
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)), qml.expval(qml.PauliZ(2))
@qml.qnode(dev)
def circuit2(params_fixed, params_training, data):
angles = [ i * np.pi for i in data ]
for i in range(qubits_num):
qml.RX(angles[i], wires=i)
qml.Rot( *(params_fixed[i]), wires=i )
qml.CZ(wires=[1, 0])
qml.CZ(wires=[1, 2])
qml.CZ(wires=[0, 2])
for i in range(qubits_num):
qml.Rot( *(params_training[i]), wires=i )
# PauliZ measure => 1 -> |0> while -1 -> |1>
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)), qml.expval(qml.PauliZ(2))
import qiskit
from qiskit import QuantumCircuit
from qiskit import Aer, execute
unitary_backend = Aer.get_backend('unitary_simulator')
qasm_backend = Aer.get_backend('qasm_simulator')
def predict(params, data):
qcircuit = QuantumCircuit(3, 3)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
qcircuit.u3(*(params[0][i]), qubits[i])
qcircuit.cz(qubits[0], qubits[1])
qcircuit.cz(qubits[1], qubits[2])
qcircuit.cz(qubits[0], qubits[2])
for i in range(qubits_num):
qcircuit.u3(*(params[1][i]), qubits[i])
# the measurement
qcircuit.measure([0, 1, 2], [0, 1, 2])
# job execution
shots = 1000
job_sim = execute(qcircuit, qasm_backend, shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qcircuit)
p1 = (counts.get('100', 0) + counts.get('111', 0) + counts.get('101', 0) + counts.get('110',0)) / shots
if p1 > 0.5:
return 1
else:
return 0
def cost(weights, datas, labels):
loss = 0
for i, data in enumerate(datas):
# like [-1, 1, 1]
measured = circuit(weights, data)
p = measured[0]
if labels[i] == 0:
loss += (1 - p) ** 2
else:
loss += (-1 - p) ** 2
return loss / len(datas)
def cost2(params_fixed, params_training, datas, labels):
loss = 0
for i, data in enumerate(datas):
# like [-1, 1, 1]
measured = circuit2(params_fixed, params_training, data)
p = measured[0]
if labels[i] == 0:
loss += (1 - p) ** 2
else:
loss += (-1 - p) ** 2
return loss / len(datas)
def accuracy(weights, datas, labels):
predictions = [ predict(weights, data) for data in datas ]
acc = 0
for i, p in enumerate(predictions):
if p == labels[i]:
acc += 1
return acc / len(predictions)
class VQC:
def __init__(self):
# 3 => U3(theta, phi, lambda)
# self.params = 0.01 * np.random.random(size=(layers_num, qubits_num, 3))
self.params = (0.01 * np.random.randn(layers_num, qubits_num, 3))
self.bestparams = self.params
self.bestcost = 10
self.bestaccuracy = 0
self.weights = []
self.costs = []
self.accuracies = []
def fit(self, X_train, Y_train, *, epoch=300, stepsize=0.125, batch_size=20, fixed=False):
self.opt = AdamOptimizer(stepsize)
for turn in range(epoch):
# Update the weights by one optimizer step
if batch_size != -1:
batch_index = np.random.randint(0, len(X_train), (batch_size,))
X_train_batch = X_train[batch_index]
Y_train_batch = Y_train[batch_index]
if fixed:
params_fixed = self.params[0]
params_training = self.params[1]
self.params[1] = self.opt.step(lambda v: cost2(params_fixed, v, X_train_batch, Y_train_batch), params_training)
else:
self.params = self.opt.step(lambda v: cost(v, X_train_batch, Y_train_batch), self.params)
else:
if fixed:
params_fixed = self.params[0]
params_training = self.params[1]
self.params[1] = self.opt.step(lambda v: cost2(params_fixed, v, X_train, Y_train), params_training)
else:
self.params = self.opt.step(lambda v: cost(v, X_train, Y_train), self.params)
cost_now = cost(self.params, X_train, Y_train)
acc_now = accuracy(self.params, X_train, Y_train)
if cost_now < self.bestcost:
self.bestcost = cost_now
self.bestparams = self.params
self.weights.append(self.params)
self.costs.append(cost_now)
self.accuracies.append(acc_now)
print(
"Turn: {:5d} | Cost: {:0.7f} | Accuracy: {:0.2f}% ".format(
turn + 1, cost_now, acc_now * 100
))
def score(self, X_test, Y_test):
predictions = [ predict(self.bestparams, data) for data in X_test ]
acc = accuracy(self.bestparams, X_test, Y_test)
print("FINAL ACCURACY: {:0.2f}%".format(acc * 100))
from qiskit.quantum_info import DensityMatrix
def getDensityMatrix(circuit):
return DensityMatrix(circuit).data
from scipy.linalg import sqrtm
def D(rou, sigma):
A = rou - sigma
A_ = sqrtm( np.dot( A.conj().T, A ) )
return 0.5 * np.linalg.norm( np.trace(A_) )
def params_loss_distance(params, data1, data2, label1, label2):
u3Circuits = []
for i in range(qubits_num):
circuit = QuantumCircuit(1, 1)
circuit.u3(*( params[i] ), 0)
u3Circuits.append(circuit)
circuit1 = QuantumCircuit(qubits_num, qubits_num)
for qubit in range(qubits_num):
circuit1.rx(data1[qubit] * np.pi, qubit)
circuit2 = QuantumCircuit(qubits_num, qubits_num)
for qubit in range(qubits_num):
circuit2.rx(data2[qubit] * np.pi, qubit)
matrix1 = getDensityMatrix(circuit1)
matrix2 = getDensityMatrix(circuit2)
d = D(matrix1, matrix2)
if label1 == label2:
loss = d ** 2
else:
loss = (1 - d) ** 2
return loss
def params_loss_gradient(params, datas, labels, *, loss_function, epsilon=0.001):
length = len(datas)
derivates = np.zeros(len(params))
loss_origin = 0
# calculate origin loss
for i in range(length // 2):
j = i + length // 2
loss_origin += loss_function(params, datas[i], datas[j], labels[i], labels[j])
loss_origin /= length // 2
for i in range(len(params)):
params[i] += epsilon
loss = 0
for j in range(length // 2):
k = j + length // 2
loss += loss_function(params, datas[j], datas[k], labels[j], labels[k])
loss /= length // 2
derivates[i] = (loss - loss_origin) / epsilon
params[i] -= epsilon
return loss_origin, derivates
import random
def sub_train_params(datas, labels, *, epoch, alpha, batch_size, loss_function):
# params = 0.01 * np.random.random(size=(1, qubits_num, 3))[0]
params = (0.01 * np.random.randn(1, qubits_num, 3))[0]
# params = params.reshape(qubits_num, 3)
print(f'Training at alpha: {alpha} ')
momentum, s = 0, 0
belta1 = 0.9; belta2 = 0.999
e = 1e-3 # 1e-8
lastloss = 100
for turn in range(epoch):
if turn % 10 == 9:
print(f' -- training: ({turn + 1}/{epoch})')
batch_index = random.sample(range(0, len(datas)), batch_size)
# batch_index = range(0, 300)
loss, grad = params_loss_gradient(params, datas[batch_index], labels[batch_index],
loss_function=loss_function)
if abs(loss - lastloss) < 1e-4:
break
lastloss = loss
# Adam Optimizer
momentum = belta1 * momentum + (1 - belta1) * grad
s = belta2 * s + (1 - belta2) * (grad ** 2)
m_ = momentum / (1 - belta1 ** (turn + 1))
s_ = s / (1 - belta2 ** (turn + 1))
# update parameters
params = params - alpha * (m_ / ( s_ ** 0.5 + e ))
return loss, params
def train_params(datas, labels, *, epoch=30, loss_function=params_loss_distance):
# alpha_grid = [0.05, 0.1, 0.125, 0.25, 0.35, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 2.25, 2.5, 2.75, 3]
# alpha_grid = [0.05, 0.15, 0.25, 0.5]
alpha_grid = [0.05, 0.075, 0.1, 0.125, 0.25, 0.5, 0.75, 1]
alpha_best = None; params_best = None; loss_best = 1000
batch_size = 30
for alpha in alpha_grid:
loss, params = sub_train_params(datas, labels,
alpha=alpha, batch_size=batch_size, epoch=epoch, loss_function=loss_function)
print(f' - finished. (loss {loss})\n')
if loss < loss_best:
loss_best = loss
alpha_best = alpha
params_best = params
return {
'alpha': alpha_best,
'params': params_best,
'loss': loss_best
}
result = train_params(X_train2, Y_train, epoch=300)
print(f'best alpha: {result["alpha"]}')
print(f'best loss: {result["loss"]}')
print(f'best params: {result["params"]}')
vqc = VQC()
stepsize = 0.001
vqc.fit(X_train2, Y_train, epoch=200, stepsize=stepsize)
params_origin = vqc.bestparams
params_origin
print(cost(params_origin, X_train2, Y_train))
print(cost(params_origin, X_test2, Y_test))
vqc.score(X_test2, Y_test)
vqc = VQC()
vqc.params[0] = result['params']
stepsize = result['alpha']
# stepsize = 0.125
vqc.fit(X_train2, Y_train, epoch=10, stepsize=stepsize, fixed=False)
params_init = vqc.bestparams
params_init
print(cost(params_init, X_train2, Y_train))
print(cost(params_init, X_test2, Y_test))
vqc.score(X_test2, Y_test)
params_test = vqc.bestparams
params_test
vqc = VQC()
print(f'training with alpha: {result["alpha"]}')
vqc.params[0] = result['params']
# vqc.params[1] = result['params']
stepsize = result['alpha'] / 100
# stepsize =
vqc.fit(X_train2, Y_train, epoch=15, stepsize=stepsize)
print(cost(params_test, X_train2, Y_train))
print(cost(params_test, X_test2, Y_test))
vqc.score(X_test2, Y_test)
params_u3 = vqc.bestparams
print(params_u3)
def createInputCircuit(data):
qubits_num = len(data)
qcircuit = QuantumCircuit(qubits_num, qubits_num)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
return qcircuit
def createModelCircuit(params):
qubits_num = len(params[0])
qcircuit = QuantumCircuit(qubits_num, qubits_num)
qubits = qcircuit.qubits
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
for i in range(qubits_num - 1):
qcircuit.cz(qubits[i], qubits[i + 1])
qcircuit.cz(qubits[0], qubits[qubits_num - 1])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
return qcircuit
def createCircuit(params, data):
input_circuit = createInputCircuit(data)
model_circuit = createModelCircuit(params)
full_circuit = input_circuit.compose(model_circuit)
return full_circuit
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.utils import insert_noise
from qiskit.providers.aer.noise import pauli_error, depolarizing_error, mixed_unitary_error
from qiskit.circuit.library import XGate, IGate, ZGate
from qiskit.quantum_info import DensityMatrix
def createNoiseModel(p, errorType):
# QuantumError objects
if errorType == 'bit_flip':
error = pauli_error([('X', p), ('I', 1 - p)])
elif errorType == 'phase_flip':
error = pauli_error([('Z', p), ('I', 1 - p)])
elif errorType == 'depolarizing':
error = depolarizing_error(p, num_qubits=1)
elif errorType == 'mixed':
error = mixed_unitary_error([(XGate(), p/2), (ZGate(), p/2), (IGate(), 1 - p)])
## two-qubits quantumError objects
if errorType == 'depolarizing':
error_2qubits = depolarizing_error(p, num_qubits=2)
else:
error_2qubits = error.tensor(error)
# Add errors to noise model
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ['u3'])
noise_model.add_all_qubit_quantum_error(error_2qubits, ['cz'])
return noise_model
def createNoisyModelCircuit(params, p, errorType, *, model_circuit=None):
noise_model = createNoiseModel(p, errorType)
if model_circuit == None:
model_circuit = createModelCircuit(params)
return insert_noise(model_circuit, noise_model)
from functools import reduce
Dag = lambda matrix: matrix.conj().T
Kron = lambda *matrices: reduce(np.kron, matrices)
psi_0 = np.array([1.0, 0.0])
psi_1 = np.array([0.0, 1.0])
I = np.eye(2)
M_0 = psi_0.reshape([2, 1]) @ psi_0.reshape([1, 2]).conj()
M_1 = psi_1.reshape([2, 1]) @ psi_1.reshape([1, 2]).conj()
def getMeasurements(qubits_num):
measurement_0 = [M_0]
measurement_1 = [M_1]
for i in range(qubits_num - 1):
measurement_0.append(I)
measurement_1.append(I)
return [
Kron(*measurement_0),
Kron(*measurement_1)
]
def powerSets(items):
N = len(items)
combs = []
for i in range(2 ** N):
comb = []
for j in range(N):
if (i >> j) % 2:
comb.append(items[j])
combs.append(comb)
return combs
class Algorithm:
def __init__(self, model_circuit, measurements, outputs):
# DensityMatrix of model
self.E = getDensityMatrix(model_circuit)
# Measurements
self.M = dict()
for index, output in enumerate(outputs):
self.M[output] = measurements[index]
# Outputs
self.O = outputs
self.O_ = powerSets(outputs)
def d(A, rou, sigma):
distance = 0
for output in A.O:
trace = np.trace(
Dag(A.M[output]) @ A.M[output] @
(A.E @ (rou - sigma) @ Dag(A.E))
)
distance += np.linalg.norm(trace)
return distance / 2
def Lipschitz(A):
E, M, O, O_ = A.E, A.M, A.O, A.O_
# Step 1: Calculate W_i
W = dict()
for i in O:
W[i] = Dag(E) @ Dag(M[i]) @ M[i] @ E
# Step 2: Calculate K_star
K_star = 0; vectors = [None, None]
M_star = np.zeros(E.shape)
for S in O_:
if len(S) == 0:
continue
# calculate M_S = Σ Wi
M_S = np.zeros(E.shape).astype('complex64')
for i in S:
M_S += W[i]
# calculate eigenvalues and eigenvectors of M_S
eigenvalues, eigenvectors = np.linalg.eigh(M_S)
min_index = np.where(eigenvalues == eigenvalues.min())
max_index = np.where(eigenvalues == eigenvalues.max())
# calculate K_S
K_S = np.linalg.norm(eigenvalues[max_index][0] - eigenvalues[min_index][0])
if K_S > K_star:
K_star = K_S
vectors[0] = eigenvectors.T[max_index][0]
vectors[1] = eigenvectors.T[min_index][0]
return K_star, np.array(vectors)
def FairVeriQ(A, epsilon, delta):
# epsilon <= 1 and delta > 0
K_star, kernel = Lipschitz(A)
if delta >= K_star * epsilon:
return True, None
else:
return False, kernel
def generateBiasPair(sigma, kernel, epsilon):
psi, phi = kernel
size = len(psi)
psi = psi.reshape(size, 1) @ Dag(psi.reshape(size, 1))
phi = phi.reshape(size, 1) @ Dag(phi.reshape(size, 1))
rou_psi = epsilon * psi + (1 - epsilon) * sigma
rou_phi = epsilon * phi + (1 - epsilon) * sigma
return np.array([
rou_psi, rou_phi
])
X_train2[0]
# params trained by noiesless environment
vqc.bestparams
# calculate lipschitz constant in noisy model
probabilities = [0.0001, 0.001, 0.05, 0.1]
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
print('Classifier for centric circle: ')
params = vqc.bestparams
for p in probabilities:
circuits = [
createModelCircuit(params),
createNoisyModelCircuit(params, p, 'bit_flip'),
createNoisyModelCircuit(params, p, 'phase_flip'),
createNoisyModelCircuit(params, p, 'depolarizing')
]
print(f'p: {p}')
for i, model_type in enumerate(models_type):
noisy_A = Algorithm(circuits[i], getMeasurements(qubits_num=3), [0, 1])
print(f'{model_type} model: {Lipschitz(noisy_A)[0]}')
print()
def createParamTrainingCircuit(params):
qubits_num = len(params) // 3
qcircuit = QuantumCircuit(qubits_num, qubits_num)
qubits = qcircuit.qubits
for i in range(qubits_num):
qcircuit.u3(*params[i*3: (i+1)*3], qubits[i])
return qcircuit
def params_loss_noisemodel_distance_factory(p, noiseType):
def params_loss_noisemodel_distance(params, data1, data2, label1, label2):
u3Circuit = QuantumCircuit(qubits_num, qubits_num)
qubits = u3Circuit.qubits
for i in range(qubits_num):
u3Circuit.u3(*params[i*3: (i+1)*3], qubits[i])
inputCircuit1 = QuantumCircuit(qubits_num, qubits_num)
qubits = inputCircuit1.qubits
for i, d in enumerate(data1):
inputCircuit1.rx(d * np.pi, qubits[i])
inputCircuit2 = QuantumCircuit(qubits_num, qubits_num)
qubits = inputCircuit2.qubits
for i, d in enumerate(data1):
inputCircuit2.rx(d * np.pi, qubits[i])
# calculate distance
matrix_1 = getDensityMatrix(circuit1)
matrix_2 = getDensityMatrix(circuit2)
d = D(matrix_1, matrix_2)
if label1 == label2:
return d ** 2
else:
return (1 - d) ** 2
return params_loss_noisemodel_distance
params_loss_noisemodel_distance = params_loss_noisemodel_distance_factory(0.001, 'bit_flip')
result_noise = train_params(X_train2, Y_train, epoch=200, loss_function=params_loss_noisemodel_distance)
print(f'best alpha: {result_noise["alpha"]}')
print(f'best loss: {result_noise["loss"]}')
print(f'best params: {result_noise["params"]}')
vqc = VQC()
vqc.params[0] = result_noise['params']
stepsize = result_noise['alpha'] / 10
vqc.fit(X_train2, Y_train, epoch=5, stepsize=stepsize)
print(cost(vqc.bestparams, X_train2, Y_train))
print(cost(vqc.bestparams, X_test2, Y_test))
vqc.score(X_test2, Y_test)
# calculate lipschitz constant in noisy model
probabilities = [0.0001, 0.001, 0.05, 0.1]
models_type = [
'noiseless', 'bit_flip', 'phase_flip', 'depolarizing'
]
print('Classifier for centric circle: ')
params = vqc.bestparams
for p in probabilities:
circuits = [
createModelCircuit(params),
createNoisyModelCircuit(params, p, 'bit_flip'),
createNoisyModelCircuit(params, p, 'phase_flip'),
createNoisyModelCircuit(params, p, 'depolarizing')
]
print(f'p: {p}')
for i, model_type in enumerate(models_type):
noisy_A = Algorithm(circuits[i], getMeasurements(qubits_num=3), [0, 1])
print(f'{model_type} model: {Lipschitz(noisy_A)[0]}')
print()
circuit_ = createNoisyModelCircuit(params, 0.01, 'mixed')
circuit_.draw(output='mpl')
|
https://github.com/usamisaori/qLipschitz
|
usamisaori
|
from sklearn.datasets import load_iris
import pennylane as qml
import numpy as np
from pennylane.optimize import AdamOptimizer
import matplotlib.pyplot as plt
X, Y = load_iris(return_X_y=True)
X_train_0 = X[0:30]
X_train_1 = X[50:80]
X_train = np.vstack((X_train_0, X_train_1))
Y_train_0 = Y[0:30]
Y_train_1 = Y[50:80]
Y_train = np.vstack((Y_train_0, Y_train_1)).flatten()
X, Y = load_iris(return_X_y=True)
X_test_0 = X[30:50]
X_test_1 = X[80:100]
X_test = np.vstack((X_test_0, X_test_1))
Y_test_0 = Y[30:50]
Y_test_1 = Y[80:100]
Y_test = np.vstack((Y_test_0, Y_test_1)).flatten()
X_train = (X_train - X_train.min(axis=0)) / (X_train.max(axis=0) - X_train.min(axis=0))
X_test = (X_test - X_test.min(axis=0)) / (X_test.max(axis=0) - X_test.min(axis=0))
qubits_num = 4
layers_num = 2
dev = qml.device("default.qubit",wires=qubits_num)
class VQC:
def __init__(self):
# 3 => U3(theta, phi, lambda)
self.params = (0.01 * np.random.randn(layers_num, qubits_num, 3))
params = [-0.61058476, -0.23619078, -0.67559108]
self.params = [
[params, params, params, params],
[params, params, params, params],
]
self.bestparams = self.params
self.bestcost = 10
self.opt = AdamOptimizer(0.125)
self.weights = []
self.costs = []
self.accuracies = []
def fit(self, X_train, Y_train, epoch=300):
batch_size = 20
for turn in range(epoch):
# Update the weights by one optimizer step
batch_index = np.random.randint(0, len(X_train), (batch_size,))
X_train_batch = X_train[batch_index]
Y_train_batch = Y_train[batch_index]
self.params = self.opt.step(lambda v: cost(v, X_train_batch, Y_train_batch), self.params)
cost_now = cost(self.params, X_train, Y_train)
acc_now = accuracy(self.params, X_train, Y_train)
if cost_now < self.bestcost:
self.bestcost = cost_now
self.bestparams = self.params
self.weights.append(self.params)
self.costs.append(cost_now)
self.accuracies.append(acc_now)
print(
"Turn: {:5d} | Cost: {:0.7f} | Accuracy: {:0.2f}% ".format(
turn, cost_now, acc_now * 100
))
def score(self, X_test, Y_test):
predictions = [ predict(self.bestparams, data) for data in X_test ]
acc = accuracy(self.bestparams, X_test, Y_test)
print("FINAL ACCURACY: {:0.2f}%".format(acc * 100))
@qml.qnode(dev)
def circuit(params, data):
angles = [ i * np.pi for i in data ]
for i in range(qubits_num):
qml.RX(angles[i], wires=i)
qml.Rot( *params[0, i], wires=i )
qml.CZ(wires=[1, 0])
qml.CZ(wires=[1, 2])
qml.CZ(wires=[2, 3])
qml.CZ(wires=[0, 3])
for i in range(qubits_num):
qml.Rot( *params[1, i], wires=i )
# PauliZ measure => 1 -> |0> while -1 -> |1>
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)), qml.expval(qml.PauliZ(2)), qml.expval(qml.PauliZ(3))
import qiskit
import numpy as np
from qiskit import QuantumCircuit
from qiskit import Aer, execute
unitary_backend = Aer.get_backend('unitary_simulator')
qasm_backend = Aer.get_backend('qasm_simulator')
def predict(params, data):
qcircuit = QuantumCircuit(4, 4)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
qcircuit.cz(qubits[0], qubits[1])
qcircuit.cz(qubits[1], qubits[2])
qcircuit.cz(qubits[2], qubits[3])
qcircuit.cz(qubits[0], qubits[3])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
# the measurement
qcircuit.measure([0, 1, 2, 3], [0, 1, 2, 3])
# job execution
shots = 1000
job_sim = execute(qcircuit, qasm_backend, shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qcircuit)
p1 = (counts.get('1000', 0) + counts.get('1001', 0) + counts.get('1010', 0) + counts.get('1011',0) + \
counts.get('1100',0) + counts.get('1101',0) + counts.get('1110',0) + counts.get('1111',0)) / shots
if p1 > 0.5:
return 1
else:
return 0
def cost(weights, datas, labels):
loss = 0
for i, data in enumerate(datas):
# like [-1, 1, 1]
measured = circuit(weights, data)
p = measured[0]
if labels[i] == 0:
loss += (1 - p) ** 2
else:
loss += (-1 - p) ** 2
return loss / len(datas)
def accuracy(weights, datas, labels):
predictions = [ predict(weights, data) for data in datas ]
acc = 0
for i, p in enumerate(predictions):
if p == labels[i]:
acc += 1
return acc / len(predictions)
vqc = VQC()
vqc.fit(X_train, Y_train, epoch=1)
print(vqc.weights[26])
vqc.bestparams = vqc.weights[26]
vqc.score(X_test, Y_test)
vqc.score(X_train, Y_train)
vqc.bestparams
def createCircuit(params, data):
qcircuit = QuantumCircuit(4, 4)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
qcircuit.cz(qubits[0], qubits[1])
qcircuit.cz(qubits[1], qubits[2])
qcircuit.cz(qubits[2], qubits[3])
qcircuit.cz(qubits[0], qubits[3])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
return qcircuit
vqc.bestparams
qcircuit = createCircuit(vqc.bestparams, X_train[0])
qcircuit.draw(output='mpl')
print(X_train[15])
print(Y_train[15])
print(X_train[35])
print(Y_train[35])
circuit = QuantumCircuit(1, 1)
qubits = circuit.qubits
|
https://github.com/usamisaori/qLipschitz
|
usamisaori
|
from sklearn.datasets import load_iris
import pennylane as qml
import numpy as np
from pennylane.optimize import AdamOptimizer
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
X, Y = load_iris(return_X_y=True)
X_train_0 = X[0:30]
X_train_1 = X[50:80]
X_train = np.vstack((X_train_0, X_train_1))
Y_train_0 = Y[0:30]
Y_train_1 = Y[50:80]
Y_train = np.vstack((Y_train_0, Y_train_1)).flatten()
X, Y = load_iris(return_X_y=True)
X_test_0 = X[30:50]
X_test_1 = X[80:100]
X_test = np.vstack((X_test_0, X_test_1))
Y_test_0 = Y[30:50]
Y_test_1 = Y[80:100]
Y_test = np.vstack((Y_test_0, Y_test_1)).flatten()
X_train = (X_train - X_train.min(axis=0)) / (X_train.max(axis=0) - X_train.min(axis=0))
X_test = (X_test - X_test.min(axis=0)) / (X_test.max(axis=0) - X_test.min(axis=0))
qubits_num = 4
layers_num = 2
dev = qml.device("default.qubit", wires=qubits_num)
class VQC:
def __init__(self):
# 3 => U3(theta, phi, lambda)
self.params = (0.1 * np.random.randn(layers_num, qubits_num, 3))
self.bestparams = self.params
self.bestcost = 10
self.opt = AdamOptimizer(0.125)
self.weights = []
self.costs = []
self.accuracies = []
def fit(self, X_train, Y_train, epoch=300):
batch_size = 20
for turn in range(epoch):
# Update the weights by one optimizer step
batch_index = np.random.randint(0, len(X_train), (batch_size,))
X_train_batch = X_train[batch_index]
Y_train_batch = Y_train[batch_index]
self.params = self.opt.step(lambda v: cost(v, X_train_batch, Y_train_batch), self.params)
cost_now = cost(self.params, X_train, Y_train)
acc_now = accuracy(self.params, X_train, Y_train)
if cost_now < self.bestcost:
self.bestcost = cost_now
self.bestparams = self.params
self.weights.append(self.params)
self.costs.append(cost_now)
self.accuracies.append(acc_now)
print(
"Turn: {:5d} | Cost: {:0.7f} | Accuracy: {:0.2f}% ".format(
turn, cost_now, acc_now * 100
))
def score(self, X_test, Y_test):
predictions = [ predict(self.bestparams, data) for data in X_test ]
acc = accuracy(self.bestparams, X_test, Y_test)
print("FINAL ACCURACY: {:0.2f}%".format(acc * 100))
@qml.qnode(dev)
def circuit(params, data):
angles = [ i * np.pi for i in data ]
for i in range(qubits_num):
qml.RX(angles[i], wires=i)
qml.Rot( *params[0, i], wires=i )
qml.CZ(wires=[1, 0])
qml.CZ(wires=[1, 2])
qml.CZ(wires=[2, 3])
qml.CZ(wires=[0, 3])
for i in range(qubits_num):
qml.Rot( *params[1, i], wires=i )
# PauliZ measure => 1 -> |0> while -1 -> |1>
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)), qml.expval(qml.PauliZ(2)), qml.expval(qml.PauliZ(3))
def cost(weights, datas, labels):
loss = 0
for i, data in enumerate(datas):
# like [-1, 1, 1]
measured = circuit(weights, data)
p = measured[0]
if labels[i] == 0:
loss += (1 - p) ** 2
else:
loss += (-1 - p) ** 2
return loss / len(datas)
import qiskit
import numpy as np
from qiskit import QuantumCircuit
from qiskit import Aer, execute
unitary_backend = Aer.get_backend('unitary_simulator')
qasm_backend = Aer.get_backend('qasm_simulator')
def predict(params, data):
qcircuit = QuantumCircuit(4, 4)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
qcircuit.cz(qubits[0], qubits[1])
qcircuit.cz(qubits[1], qubits[2])
qcircuit.cz(qubits[2], qubits[3])
qcircuit.cz(qubits[0], qubits[3])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
# the measurement
qcircuit.measure([0, 1, 2, 3], [0, 1, 2, 3])
# job execution
shots = 1000
job_sim = execute(qcircuit, qasm_backend, shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qcircuit)
p1 = (counts.get('1000', 0) + counts.get('1001', 0) + counts.get('1010', 0) + counts.get('1011',0) + \
counts.get('1100', 0) + counts.get('1101', 0) + counts.get('1110', 0) + counts.get('1111', 0)) / shots
if p1 > 0.5:
return 1
else:
return 0
def accuracy(weights, datas, labels):
predictions = [ predict(weights, data) for data in datas ]
acc = 0
for i, p in enumerate(predictions):
if p == labels[i]:
acc += 1
return acc / len(predictions)
vqc = VQC()
vqc.fit(X_train, Y_train, epoch=10)
vqc.score(X_test, Y_test)
vqc.bestparams
def createCircuit(params, data):
qcircuit = QuantumCircuit(4, 4)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
qcircuit.cz(qubits[0], qubits[1])
qcircuit.cz(qubits[1], qubits[2])
qcircuit.cz(qubits[2], qubits[3])
qcircuit.cz(qubits[0], qubits[3])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
return qcircuit
qcircuit = createCircuit(vqc.bestparams, X_train[0])
qcircuit.draw(output='mpl')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.