repo
stringclasses 885
values | file
stringclasses 741
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=invalid-name
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
from qtils.featuremap import FeatureMap
from qtils.qka import QKA
import os
import pandas as pd
def main(backend, user_messenger, **kwargs):
df = pd.read_csv(os.path.dirname(os.path.abspath(__file__)) + '/aux_file/dataset_graph7.csv',sep=',', header=None) # alterative problem: dataset_graph10.csv
data = df.values
# choose number of training and test samples per class:
num_train = 10
num_test = 10
# extract training and test sets and sort them by class label
train = data[:2*num_train, :]
test = data[2*num_train:2*(num_train+num_test), :]
ind=np.argsort(train[:,-1])
x_train = train[ind][:,:-1]
y_train = train[ind][:,-1]
ind=np.argsort(test[:,-1])
x_test = test[ind][:,:-1]
y_test = test[ind][:,-1]
C = 1
maxiters = 1
initial_point = [0.1]
initial_layout = [10, 11, 12, 13, 14, 15, 16] # see figure above for the 7-qubit graph
# initial_layout = [9, 8, 11, 14, 16, 19, 22, 25, 24, 23] # see figure above for the 10-qubit graph
d = np.shape(data)[1]-1 # feature dimension is twice the qubit number
em = [[0,2],[3,4],[2,5],[1,4],[2,3],[4,6]]
fm = FeatureMap(feature_dimension=d, entangler_map=em)
qka = QKA(
feature_map=fm,
backend=backend,
initial_layout=initial_layout,
user_messenger=user_messenger,
)
qka_results = qka.align_kernel(
data=x_train,
labels=y_train,
initial_kernel_parameters=initial_point,
maxiters=maxiters,
C=C,
)
user_messenger.publish(qka_results, final=True)
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
import pennylane as qml
from pennylane import numpy as np
import matplotlib.pyplot as plt
def coefficients_to_values(coefficients):
"""Returns the value representation of a polynomial
Args:
coefficients (array[complex]): a 1-D array of complex
coefficients of a polynomial with
index i representing the i-th degree coefficient
Returns:
array[complex]: the value representation of the
polynomial
"""
##################
# YOUR CODE HERE #
##################
# pass
return np.fft.fft(coefficients)
A = [4, 3, 2, 1]
print(coefficients_to_values(A))
def values_to_coefficients(values):
"""Returns the coefficient representation of a polynomial
Args:
values (array[complex]): a 1-D complex array with
the value representation of a polynomial
Returns:
array[complex]: a 1-D complex array of coefficients
"""
##################
# YOUR CODE HERE #
##################
return np.fft.ifft(values)
A = [10.+0.j, 2.-2.j, 2.+0.j, 2.+2.j]
print(values_to_coefficients(A))
def nearest_power_of_2(x):
"""Given an integer, return the nearest power of 2.
Args:
x (int): a positive integer
Returns:
int: the nearest power of 2 of x
"""
##################
# YOUR CODE HERE #
##################
# k = np.log2(x)
k = np.ceil(np.log2(x))
return (2**(int(k)))
nearest_power_of_2(7)
def fft_multiplication(poly_a, poly_b):
"""Returns the result of multiplying two polynomials
Args:
poly_a (array[complex]): 1-D array of coefficients
poly_b (array[complex]): 1-D array of coefficients
Returns:
array[complex]: complex coefficients of the product
of the polynomials
"""
##################
# YOUR CODE HERE #
##################
# len(poly_b) = b
# len(poly_a) = a
b = len(poly_b)
# print(b)
a = len(poly_a)
# print(a)
b = b-1
a= a-1
# Calculate the number of values required
nn = a + b + 1
# Figure out the nearest power of 2
n = nearest_power_of_2(nn)
# print(n)
# Pad zeros to the polynomial
# if a<n:
poly_a = np.pad(poly_a, (0,n-len(poly_a)))
# if b<n:
poly_b = np.pad(poly_b, (0,n-len(poly_b)))
# Convert the polynomials to value representation
aa = coefficients_to_values(poly_a)
bb = coefficients_to_values(poly_b)
# print(a)
# print(b)
# Multiply
m = aa*bb
# Convert back to coefficient representation
res = values_to_coefficients(m)
# final = np.zeros((a+b))
# final = []
# for i in range(a+b):
# final[i] = res[i]
return res
A = np.array([1,1])
B = np.array([1,-1])
fft_multiplication(A, B)
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def one_qubit_QFT(basis_id):
"""A circuit that computes the QFT on a single qubit.
Args:
basis_id (int): An integer value identifying
the basis state to construct.
Returns:
array[complex]: The state of the qubit after applying QFT.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0])
##################
# YOUR CODE HERE #
##################
qml.Hadamard(wires=0)
return qml.state()
n_bits = 2
dev = qml.device("default.qubit", wires=n_bits)
@qml.qnode(dev)
def two_qubit_QFT(basis_id):
"""A circuit that computes the QFT on two qubits using qml.QubitUnitary.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The state of the qubits after the QFT operation.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0, 1])
##################
# YOUR CODE HERE #
##################
U = 0.5*(np.array([[1,1,1,1], [1, complex(0,1), -1, complex(0,-1)], [1, -1, 1, -1], [1, complex(0,-1), -1, complex(0,1)]]))
qml.QubitUnitary(U, wires=[0,1])
return qml.state()
dev = qml.device("default.qubit", wires=2)
@qml.qnode(dev)
def decompose_two_qubit_QFT(basis_id):
"""A circuit that computes the QFT on two qubits using elementary gates.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The state of the qubits after the QFT operation.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0, 1])
##################
# YOUR CODE HERE #
##################
qml.Hadamard(wires=0)
qml.ctrl(qml.S, control=1)(wires=0)
qml.Hadamard(wires=1)
qml.SWAP(wires=[0,1])
# pass
return qml.state()
dev = qml.device("default.qubit", wires=3)
@qml.qnode(dev)
def three_qubit_QFT(basis_id):
"""A circuit that computes the QFT on three qubits.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The state of the qubits after the QFT operation.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0, 1, 2])
##################
# YOUR CODE HERE #
##################
for i in range(3):
# j=i+1
# print("test1")
qml.Hadamard(wires=i)
for jj in range(i+1,3,1):
# print("test2")
# k = (1/(2**(jj)))*(np.pi)*(complex(0,1))
# U = np.array([[1,0], [0, np.exp(k)]])
# qml.ctrl(qml.QubitUnitary(U, wires=i), control=jj)
# Below lines of code give the same result as the above one
k = (1/(2**(jj)))*(np.pi)
qml.ctrl(qml.PhaseShift(k, wires=i), control = jj)
qml.SWAP(wires=[0,2])
return qml.state()
print(qml.draw(three_qubit_QFT)(3))
dev = qml.device('default.qubit', wires=4)
def swap_bits(n_qubits):
"""A circuit that reverses the order of qubits, i.e.,
performs a SWAP such that [q1, q2, ..., qn] -> [qn, ... q2, q1].
Args:
n_qubits (int): An integer value identifying the number of qubits.
"""
##################
# YOUR CODE HERE #
##################
# if n%2==0:
# j =
for i in range(int(n_qubits/2)):
qml.SWAP(wires=[i,n_qubits-1-i])
# pass
@qml.qnode(dev)
def qft_node(basis_id, n_qubits):
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits, wires=range(n_qubits))
# qft_rotations(n_qubits)
swap_bits(n_qubits)
return qml.state()
dev = qml.device('default.qubit', wires=4)
# @qml.qnode(dev)
def qft_rotations(n_qubits):
"""A circuit performs the QFT rotations on the specified qubits.
Args:
n_qubits (int): An integer value identifying the number of qubits.
"""
##################
# YOUR CODE HERE #
##################
n = n_qubits
for i in range(n):
# j=i+1
# print("test1")
qml.Hadamard(wires=i)
for jj in range(i+1,n,1):
# print("test2")
qml.ControlledPhaseShift(np.pi/(2**(jj-i)), wires=[jj,i])
pass
@qml.qnode(dev)
def qft_node(basis_id, n_qubits):
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits, wires=range(n_qubits))
qft_rotations(n_qubits)
swap_bits(n_qubits)
return qml.state()
# print(qml.draw(qft_rotations)(3))
print(qml.draw(qft_node)(3,3))
dev = qml.device('default.qubit', wires=4)
def qft_recursive_rotations(n_qubits, wire=0):
"""A circuit that performs the QFT rotations on the specified qubits
recursively.
Args:
n_qubits (int): An integer value identifying the number of qubits.
wire (int): An integer identifying the wire
(or the qubit) to apply rotations on.
"""
##################
# YOUR CODE HERE #
##################
i = wire
if i == n_qubits-1:
qml.Hadamard(wires=i)
# for i in range(n_qubits):
# qml.Hadamard(wires=i)
# if n_qubits!=i:
else:
qml.Hadamard(wires=i)
for j in range(i+1, n_qubits, 1):
qml.ControlledPhaseShift(np.pi/(2**(j-i)), wires=[j,i])
qft_recursive_rotations(n_qubits, i+1)
pass
@qml.qnode(dev)
def qft_node(basis_id, n_qubits):
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits, wires=range(n_qubits))
qft_recursive_rotations(n_qubits)
swap_bits(n_qubits)
return qml.state()
print(qml.draw(qft_node)(3,3))
|
https://github.com/xin-0/QC-jupyter
|
xin-0
|
import numpy as np
from math import pi
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister, BasicAer, execute, IBMQ
from qiskit.visualization import plot_bloch_multivector, plot_histogram
def pe_circ_init(size:int):
#quantum register and single state for storing eigen-state
qr = QuantumRegister(size)
psi = QuantumRegister(1,name="psi")
#classical bits for readout
cr = ClassicalRegister(size)
qc = QuantumCircuit(qr,psi,cr)
# apply Hadamards and init the eigenstate as |1>
for i in range(size):
qc.h(i)
qc.x(size)
qc.barrier()
return qc
def C_U(circuit:QuantumCircuit, size:int, phi:float):
rep = 1
for counting_qubit in range(size):
for i in range(rep):
circuit.cu1(2*pi*phi, counting_qubit, size)
rep *= 2
circuit.barrier()
return
def qft_dagger(qc:QuantumCircuit,size:int):
for qubit in range(size//2):
qc.swap(qubit,size-qubit-1)
for j in range(size):
for m in range(j):
qc.cu1(-pi/float(2**(j-m)), m, j)
qc.h(j)
qc.barrier()
return
def readout(qc:QuantumCircuit,size:int):
for i in range(size):
qc.measure(i,i)
return
def phaseEstCircuit(size:int, phi:float):
qc = pe_circ_init(size)
C_U(qc, size, phi)
qft_dagger(qc, size)
readout(qc,size)
return qc
def counts_decode(counts):
decoded = {}
for key in counts:
decimal_key = 0.0
i = -1
for c in key:
b = int(c)
if b:
decimal_key += 2**i
i -= 1
decoded[decimal_key] = counts[key]
return decoded
def expectation(decode_counts):
res = 0.0
total = 0
for key in decode_counts:
total += decode_counts[key]
res += key*decode_counts[key]
return res/total
def choosemax(decode_counts):
counts = 0
result = 0.0
for key in decode_counts:
if decode_counts[key] > counts:
counts = decode_counts[key]
result = key
return result
def getEstPhi(PhaseEstQC:QuantumCircuit, back_end, shots, metric):
# get backend
result = execute(qc,backend=back_end,shots=shots).result()
counts = result.get_counts()
plot_histogram(counts)
dt = counts_decode(counts)
est_val = metric(dt)
return est_val
qubit = 4
nTrail = 20
back_end = BasicAer.get_backend("qasm_simulator")
shots = 4096
Phi = np.random.random((nTrail,))
Phi_est = []
for phi in Phi:
qc = phaseEstCircuit(qubit, phi)
single_run_res = getEstPhi(qc, back_end,shots,metric=choosemax)
Phi_est.append(single_run_res)
Phi_est = np.array(Phi_est)
error = np.abs(Phi_est-Phi)/Phi
print(Phi)
print(Phi_est)
print(error)
qubit = 5
nTrail = 20
back_end = BasicAer.get_backend("qasm_simulator")
shots = 4096
Phi_est = []
for phi in Phi:
qc = phaseEstCircuit(qubit, phi)
single_run_res = getEstPhi(qc, back_end,shots,metric=choosemax)
Phi_est.append(single_run_res)
Phi_est = np.array(Phi_est)
error = np.abs(Phi_est-Phi)/Phi
print(Phi)
print(Phi_est)
print(error)
qubit = 6
nTrail = 20
back_end = BasicAer.get_backend("qasm_simulator")
shots = 4096
Phi_est = []
for phi in Phi:
qc = phaseEstCircuit(qubit, phi)
single_run_res = getEstPhi(qc, back_end,shots,metric=choosemax)
Phi_est.append(single_run_res)
Phi_est = np.array(Phi_est)
error = np.abs(Phi_est-Phi)/Phi
print(Phi)
print(Phi_est)
print(error)
qubit = 7
nTrail = 20
back_end = BasicAer.get_backend("qasm_simulator")
shots = 4096
Phi_est = []
for phi in Phi:
qc = phaseEstCircuit(qubit, phi)
single_run_res = getEstPhi(qc, back_end,shots,metric=choosemax)
Phi_est.append(single_run_res)
Phi_est = np.array(Phi_est)
error = np.abs(Phi_est-Phi)/Phi
print(Phi)
print(Phi_est)
print(error)
qubit = 8
nTrail = 20
back_end = BasicAer.get_backend("qasm_simulator")
shots = 4096
Phi_est = []
for phi in Phi:
qc = phaseEstCircuit(qubit, phi)
single_run_res = getEstPhi(qc, back_end,shots,metric=choosemax)
Phi_est.append(single_run_res)
Phi_est = np.array(Phi_est)
error = np.abs(Phi_est-Phi)/Phi
print(Phi)
print(Phi_est)
print(error)
def get_error(size, Phi, back_end, shots, metric):
Phi_est = []
for phi in Phi:
qc = phaseEstCircuit(qubit, phi)
qc.draw()
single_run_res = getEstPhi(qc, back_end,shots,metric)
Phi_est.append(single_run_res)
Phi_est = np.array(Phi_est)
return np.abs(Phi_est-Phi)/Phi
error_4 = get_error(size=4, Phi=Phi, back_end=back_end,shots=2048,metric=choosemax)
error_5 = get_error(size=5, Phi=Phi, back_end=back_end,shots=2048,metric=choosemax)
error_6 = get_error(size=6, Phi=Phi, back_end=back_end,shots=2048,metric=choosemax)
import matplotlib.pyplot as plt
plt.plot(Phi,error_4,'rs',Phi,error_5,'bs',Phi,error_6,'gs')
error_4
error_5
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import QuantumCircuit
# Create a Quantum Circuit acting on a quantum register of three qubits
circ = QuantumCircuit(3)
# Add a H gate on qubit 0, putting this qubit in superposition.
circ.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
circ.cx(0, 1)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 2, putting
# the qubits in a GHZ state.
circ.cx(0, 2)
circ.draw('mpl')
from qiskit.quantum_info import Statevector
# Set the intial state of the simulator to the ground state using from_int
state = Statevector.from_int(0, 2**3)
# Evolve the state by the quantum circuit
state = state.evolve(circ)
#draw using latex
state.draw('latex')
from qiskit.visualization import array_to_latex
#Alternative way of representing in latex
array_to_latex(state)
state.draw('qsphere')
state.draw('hinton')
from qiskit.quantum_info import Operator
U = Operator(circ)
# Show the results
U.data
# Create a Quantum Circuit
meas = QuantumCircuit(3, 3)
meas.barrier(range(3))
# map the quantum measurement to the classical bits
meas.measure(range(3), range(3))
# The Qiskit circuit object supports composition.
# Here the meas has to be first and front=True (putting it before)
# as compose must put a smaller circuit into a larger one.
qc = meas.compose(circ, range(3), front=True)
#drawing the circuit
qc.draw('mpl')
# Adding the transpiler to reduce the circuit to QASM instructions
# supported by the backend
from qiskit import transpile
# Use AerSimulator
from qiskit_aer import AerSimulator
backend = AerSimulator()
# First we have to transpile the quantum circuit
# to the low-level QASM instructions used by the
# backend
qc_compiled = transpile(qc, backend)
# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit
# to be 1024, which is the default.
job_sim = backend.run(qc_compiled, shots=1024)
# Grab the results from the job.
result_sim = job_sim.result()
counts = result_sim.get_counts(qc_compiled)
print(counts)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2023
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=missing-docstring,invalid-name,no-member
# pylint: disable=attribute-defined-outside-init
# pylint: disable=unused-argument
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.compiler import transpile
from qiskit.quantum_info.random import random_unitary
class IsometryTranspileBench:
params = ([0, 1, 2, 3], [3, 4, 5, 6])
param_names = ["number of input qubits", "number of output qubits"]
def setup(self, m, n):
q = QuantumRegister(n)
qc = QuantumCircuit(q)
if not hasattr(qc, "iso"):
raise NotImplementedError
iso = random_unitary(2**n, seed=0).data[:, 0 : 2**m]
if len(iso.shape) == 1:
iso = iso.reshape((len(iso), 1))
qc.iso(iso, q[:m], q[m:])
self.circuit = qc
def track_cnot_counts_after_mapping_to_ibmq_16_melbourne(self, *unused):
coupling = [
[1, 0],
[1, 2],
[2, 3],
[4, 3],
[4, 10],
[5, 4],
[5, 6],
[5, 9],
[6, 8],
[7, 8],
[9, 8],
[9, 10],
[11, 3],
[11, 10],
[11, 12],
[12, 2],
[13, 1],
[13, 12],
]
circuit = transpile(
self.circuit,
basis_gates=["u1", "u3", "u2", "cx"],
coupling_map=coupling,
seed_transpiler=0,
)
counts = circuit.count_ops()
cnot_count = counts.get("cx", 0)
return cnot_count
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile, schedule
from qiskit.visualization.pulse_v2 import draw, IQXDebugging
from qiskit.providers.fake_provider import FakeBoeblingen
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
qc = transpile(qc, FakeBoeblingen(), layout_method='trivial')
sched = schedule(qc, FakeBoeblingen())
draw(sched, style=IQXDebugging(), backend=FakeBoeblingen())
|
https://github.com/Z-928/Bugs4Q
|
Z-928
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.wrapper import available_backends, get_backend
from qiskit.wrapper import execute as q_execute
q = QuantumRegister(2, name='q')
c = ClassicalRegister(2, name='c')
qc = QuantumCircuit(q,c)
qc.h(q[0])
qc.h(q[1])
qc.cx(q[0], q[1])
qc.measure(q, c)
z = 0.995004165 + 1j * 0.099833417
z = z / abs(z)
u_error = np.array([[1, 0], [0, z]])
noise_params = {'U':
{'gate_time': 1,
'p_depol': 0.001,
'p_pauli': [0, 0, 0.01],
'U_error': u_error
}
}
config = {"noise_params": noise_params}
ret = q_execute(qc, 'local_qasm_simulator_cpp', shots=1024, config=config)
ret = ret.result()
print(ret.get_counts())
|
https://github.com/AnikenC/JaxifiedQiskit
|
AnikenC
|
# All Imports
import numpy as np
import matplotlib.pyplot as plt
import sympy as sym
import qiskit
from qiskit import pulse
from qiskit_dynamics import Solver, DynamicsBackend
from qiskit_dynamics.pulse import InstructionToSignals
from qiskit_dynamics.array import Array
from qiskit.quantum_info import Statevector, DensityMatrix, Operator, SparsePauliOp
from qiskit.circuit.parameter import Parameter
import jax
import jax.numpy as jnp
from jax import jit, vmap, block_until_ready, config
import chex
from typing import Optional, Union
Array.set_default_backend('jax')
config.update('jax_enable_x64', True)
config.update('jax_platform_name', 'cpu')
# Constructing a Two Qutrit Hamiltonian
dim = 3
v0 = 4.86e9
anharm0 = -0.32e9
r0 = 0.22e9
v1 = 4.97e9
anharm1 = -0.32e9
r1 = 0.26e9
J = 0.002e9
a = np.diag(np.sqrt(np.arange(1, dim)), 1)
adag = np.diag(np.sqrt(np.arange(1, dim)), -1)
N = np.diag(np.arange(dim))
ident = np.eye(dim, dtype=complex)
full_ident = np.eye(dim**2, dtype=complex)
N0 = np.kron(ident, N)
N1 = np.kron(N, ident)
a0 = np.kron(ident, a)
a1 = np.kron(a, ident)
a0dag = np.kron(ident, adag)
a1dag = np.kron(adag, ident)
static_ham0 = 2 * np.pi * v0 * N0 + np.pi * anharm0 * N0 * (N0 - full_ident)
static_ham1 = 2 * np.pi * v1 * N1 + np.pi * anharm1 * N1 * (N1 - full_ident)
static_ham_full = static_ham0 + static_ham1 + 2 * np.pi * J * ((a0 + a0dag) @ (a1 + a1dag))
drive_op0 = 2 * np.pi * r0 * (a0 + a0dag)
drive_op1 = 2 * np.pi * r1 * (a1 + a1dag)
batchsize = 400
amp_vals = jnp.linspace(0.5, 0.99, batchsize, dtype=jnp.float64).reshape(-1, 1)
sigma_vals = jnp.linspace(20, 80, batchsize, dtype=jnp.int8).reshape(-1, 1)
freq_vals = jnp.linspace(-0.5, 0.5, batchsize, dtype=jnp.float64).reshape(-1, 1) * 1e6
batch_params = jnp.concatenate((amp_vals, sigma_vals, freq_vals), axis=-1)
batch_y0 = jnp.tile(np.ones(9), (batchsize, 1))
batch_obs = jnp.tile(N0, (batchsize, 1, 1))
print(f"Batched Params Shape: {batch_params.shape}")
# Constructing a custom function that takes as input a parameter vector and returns the simulated state
def standard_func(params):
amp, sigma, freq = params
# Here we use a Drag Pulse as defined in qiskit pulse as its already a Scalable Symbolic Pulse
special_pulse = pulse.Drag(
duration=320,
amp=amp,
sigma=sigma,
beta=0.1,
angle=0.1,
limit_amplitude=False
)
with pulse.build(default_alignment='sequential') as sched:
d0 = pulse.DriveChannel(0)
d1 = pulse.DriveChannel(1)
u0 = pulse.ControlChannel(0)
u1 = pulse.ControlChannel(1)
pulse.shift_frequency(freq, d0)
pulse.play(special_pulse, d0)
pulse.shift_frequency(freq, d1)
pulse.play(special_pulse, d1)
pulse.shift_frequency(freq, u0)
pulse.play(special_pulse, u0)
pulse.shift_frequency(freq, u1)
pulse.play(special_pulse, u1)
return sched
# Constructing the new solver
dt = 1/4.5e9
atol = 1e-2
rtol = 1e-4
t_linspace = np.linspace(0.0, 400e-9, 11)
t_span = np.array([t_linspace[0], t_linspace[-1]])
ham_ops = [drive_op0, drive_op1, drive_op0, drive_op1]
ham_chans = ["d0", "d1", "u0", "u1"]
chan_freqs = {"d0": v0, "d1": v1, "u0": v1, "u1": v0}
solver = Solver(
static_hamiltonian=static_ham_full,
hamiltonian_operators=ham_ops,
rotating_frame=static_ham_full,
hamiltonian_channels=ham_chans,
channel_carrier_freqs=chan_freqs,
dt=dt,
)
class JaxifiedSolver:
def __init__(
self,
schedule_func,
dt,
carrier_freqs,
ham_chans,
t_span,
rtol,
atol
):
super().__init__()
self.schedule_func = schedule_func
self.dt = dt
self.carrier_freqs = carrier_freqs
self.ham_chans = ham_chans
self.t_span = t_span
self.rtol = rtol
self.atol = atol
self.fast_batched_sim = jit(vmap(self.run_sim))
def run_sim(self, y0, obs, params):
sched = self.schedule_func(params)
converter = InstructionToSignals(self.dt, carriers=self.carrier_freqs, channels=self.ham_chans)
signals = converter.get_signals(sched)
results = solver.solve(
t_span=self.t_span,
y0=y0 / jnp.linalg.norm(y0),
t_eval=self.t_span,
signals=signals,
rtol=self.rtol,
atol=self.atol,
convert_results=False,
method='jax_odeint'
)
state_vec = results.y.data[-1]
state_vec = state_vec / jnp.linalg.norm(state_vec)
two_vec = state_vec[:4]
evolved_vec = jnp.dot(obs, two_vec)
new_vec = jnp.concatenate((evolved_vec, state_vec[4:]))
probs_vec = jnp.abs(new_vec)**2
probs_vec = jnp.clip(probs_vec, a_min=0.0, a_max=1.0)
# Shots instead of probabilities
return probs_vec
def estimate(self, batch_y0, batch_obs, batch_params):
ops_mat = [b.to_matrix() for b in batch_obs]
ops_arr = jnp.array(ops_mat)
return self.fast_batched_sim(batch_y0, ops_arr, batch_params)
j_solver = JaxifiedSolver(
schedule_func=standard_func,
dt=dt,
carrier_freqs=chan_freqs,
ham_chans=ham_chans,
t_span=t_span,
rtol=rtol,
atol=atol
)
ops_list = [SparsePauliOp(["IX"]), SparsePauliOp(["IY"]), SparsePauliOp(["YZ"]), SparsePauliOp(["ZX"])] * 100
batch_res = j_solver.estimate(
batch_y0,
ops_list,
batch_params
)
%timeit j_solver.estimate(batch_y0,ops_list,batch_params)
op_x = SparsePauliOp('IXXYI')
arr = op_x.to_matrix()
print(arr.shape)
print(op_x.to_matrix())
dim_size = 8
qudit = jnp.array([1.0, 0.0, 0.0, 0.0])
qubit_op = jnp.array([[0., 1.0], [1.0, 0.0]])
big_ident = jnp.identity(dim_size)
big_op = big_ident.at[:2,:2].set(qubit_op)
big_op
op_str = "XI"
num_qubits = len(op_str)
qudit_dim_size = 3
init_state = np.zeros(qudit_dim_size ** num_qubits, dtype=np.complex64)
init_state[1] = 1
base_gates_dict = {
"I": jnp.array([[1.0, 0.], [0., 1.]]),
"X": jnp.array([[0., 1.], [1., 0.]]),
"Y": jnp.array([[0., -1.0j], [1.0j, 0.]]),
"Z": jnp.array([[1., 0.], [0., -1.]])
}
def PauliToQuditMatrix(inp_str: str, qudit_dim_size: Optional[int] = 4):
word_list = list(inp_str)
qudit_op_list = []
for word in word_list:
qubit_op = base_gates_dict[word]
qud_op = np.identity(qudit_dim_size, dtype=np.complex64)
qud_op[:2,:2] = qubit_op
qudit_op_list.append(qud_op)
complete_op = qudit_op_list[0]
for i in range(1,len(qudit_op_list)):
complete_op = np.kron(complete_op, qudit_op_list[i])
return complete_op
def evolve_state(batch_state, batch_var_str):
return_state = []
for state, var_str in zip(batch_state, batch_var_str):
complete_op = PauliToQuditMatrix(var_str, qudit_dim_size)
return_state.append(complete_op @ state)
return return_state
b_size = 400
batch_state = [init_state] * b_size
batch_var_str = [op_str] * b_size
%timeit evolve_state(batch_state, batch_var_str)
class JaxedSolver:
def __init__(
self,
schedule_func,
dt,
carrier_freqs,
ham_chans,
t_span,
rtol,
atol
):
super().__init__()
self.schedule_func = schedule_func
self.dt = dt
self.carrier_freqs = carrier_freqs
self.ham_chans = ham_chans
self.t_span = t_span
self.rtol = rtol
self.atol = atol
self.fast_batched_sim = jit(vmap(self.run_sim))
def run_sim(self, y0, obs, params):
sched = self.schedule_func(params)
converter = InstructionToSignals(self.dt, carriers=self.carrier_freqs, channels=self.ham_chans)
signals = converter.get_signals(sched)
results = solver.solve(
t_span=self.t_span,
y0=y0 / jnp.linalg.norm(y0),
t_eval=self.t_span,
signals=signals,
rtol=self.rtol,
atol=self.atol,
convert_results=False,
method='jax_odeint'
)
state_vec = results.y.data[-1]
state_vec = state_vec / jnp.linalg.norm(state_vec)
new_vec = obs @ state_vec
probs_vec = jnp.abs(new_vec)**2
probs_vec = jnp.clip(probs_vec, a_min=0.0, a_max=1.0)
# Shots instead of probabilities
return probs_vec
def estimate2(self, batch_y0, batch_params, batch_obs_str):
batch_obs = jnp.zeros((batch_y0.shape[0], batch_y0.shape[1], batch_y0.shape[1]), dtype=jnp.complex64)
for i, b_str in enumerate(batch_obs_str):
batch_obs = batch_obs.at[i].set(PauliToQuditMatrix(b_str, dim))
return self.fast_batched_sim(batch_y0, batch_obs, batch_params)
j_solver_2 = JaxedSolver(
schedule_func=standard_func,
dt=dt,
carrier_freqs=chan_freqs,
ham_chans=ham_chans,
t_span=t_span,
rtol=rtol,
atol=atol
)
ops_str_list = ["IX", "XY", "ZX", "ZI"] * 100
batch_res = j_solver_2.estimate2(
batch_y0,
batch_params,
ops_str_list
)
%timeit j_solver_2.estimate2(batch_y0, batch_params, ops_str_list)
|
https://github.com/hephaex/Quantum-Computing-Awesome-List
|
hephaex
|
# Importing everything
from qiskit import *
from qiskit.visualization import plot_histogram
# For Jupyter Notebooks, change the settings to get nicer images
%config InlineBackend.figure_format = 'svg'
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a, b)
def encode_message(qc, qubit, message):
if message == "00":
pass
elif message == "01":
qc.z(qubit)
elif message == "10":
qc.x(qubit)
elif message == "11":
qc.z(qubit)
qz.x(qubit)
else:
print("Enter Valid message please")
def decode_message(qc, a, b):
qc.cx(a, b)
qc.h(a)
# Create the quantum circuit with 2 qubits
qc = QuantumCircuit(2)
# First, Eve creates the entangled pair between Alice and Bob
create_bell_pair(qc, 0, 1)
qc.barrier() # This adds a barrier to our circuit. A barrier
# separates the gates in our diagram and makes it
# clear which part of the circuit is which
# At this point, qubit 0 goes to Alice and qubit 1 goes to Bob
# Next, Alice encodes her message onto qubit 0. In this case,
# we want to send the message '10'. You can try changing this
# value and see how it affects the circuit
message = "10"
encode_message(qc, 0, message)
qc.barrier()
# Alice then sends her qubit to Bob.
# After recieving qubit 0, Bob applies the recovery protocol:
decode_message(qc, 0, 1)
# Finally, Bob measures his qubits to read Alice's message
qc.measure_all()
# Draw our output
qc.draw(output = "mpl")
backend = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend, shots=1024)
sim_result = job_sim.result()
measurement_result = sim_result.get_counts(qc)
print(measurement_result)
plot_histogram(measurement_result)
from qiskit import IBMQ
from qiskit.providers.ibmq import least_busy
shots = 256
# Load local account information
IBMQ.load_account()
# Get the least busy backend
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 2
and not x.configuration().simulator
and x.status().operational==True))
print("least busy backend: ", backend)
# Run our circuit
job = execute(qc, backend=backend, shots=shots)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
result = job.result()
plot_histogram(result.get_counts(qc))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, execute
from qiskit.providers.fake_provider import FakeVigoV2
from qiskit.visualization import plot_gate_map
backend = FakeVigoV2()
plot_gate_map(backend)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import pulse
with pulse.build(name='my_example') as my_program:
# Add instructions here
pass
my_program
from qiskit.pulse import DriveChannel
channel = DriveChannel(0)
from qiskit.providers.fake_provider import FakeValencia
backend = FakeValencia()
with pulse.build(backend=backend, name='backend_aware') as backend_aware_program:
channel = pulse.drive_channel(0)
print(pulse.num_qubits())
# Raises an error as backend only has 5 qubits
#pulse.drive_channel(100)
with pulse.build(backend) as delay_5dt:
pulse.delay(5, channel)
from qiskit.pulse import library
amp = 1
sigma = 10
num_samples = 128
gaus = pulse.library.Gaussian(num_samples, amp, sigma,
name="Parametric Gaus")
gaus.draw()
import numpy as np
times = np.arange(num_samples)
gaussian_samples = np.exp(-1/2 *((times - num_samples / 2) ** 2 / sigma**2))
gaus = library.Waveform(gaussian_samples, name="WF Gaus")
gaus.draw()
gaus = library.gaussian(duration=num_samples, amp=amp, sigma=sigma, name="Lib Gaus")
gaus.draw()
with pulse.build() as schedule:
pulse.play(gaus, channel)
schedule.draw()
with pulse.build() as schedule:
pulse.play([0.001*i for i in range(160)], channel)
schedule.draw()
with pulse.build(backend) as schedule:
pulse.set_frequency(4.5e9, channel)
with pulse.build(backend) as schedule:
pulse.shift_phase(np.pi, channel)
from qiskit.pulse import Acquire, AcquireChannel, MemorySlot
with pulse.build(backend) as schedule:
pulse.acquire(1200, pulse.acquire_channel(0), MemorySlot(0))
with pulse.build(backend, name='Left align example') as program:
with pulse.align_left():
gaussian_pulse = library.gaussian(100, 0.5, 20)
pulse.play(gaussian_pulse, pulse.drive_channel(0))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
program.draw()
with pulse.build(backend, name='Right align example') as program:
with pulse.align_right():
gaussian_pulse = library.gaussian(100, 0.5, 20)
pulse.play(gaussian_pulse, pulse.drive_channel(0))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
program.draw()
with pulse.build(backend, name='example') as program:
gaussian_pulse = library.gaussian(100, 0.5, 20)
with pulse.align_equispaced(2*gaussian_pulse.duration):
pulse.play(gaussian_pulse, pulse.drive_channel(0))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
program.draw()
with pulse.build(backend, name='example') as program:
with pulse.align_sequential():
gaussian_pulse = library.gaussian(100, 0.5, 20)
pulse.play(gaussian_pulse, pulse.drive_channel(0))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
program.draw()
with pulse.build(backend, name='Offset example') as program:
with pulse.phase_offset(3.14, pulse.drive_channel(0)):
pulse.play(gaussian_pulse, pulse.drive_channel(0))
with pulse.frequency_offset(10e6, pulse.drive_channel(0)):
pulse.play(gaussian_pulse, pulse.drive_channel(0))
program.draw()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
qc.h(q)
qc.measure(q, c)
qc.draw(output='mpl', style={'backgroundcolor': '#EEEEEE'})
|
https://github.com/acfilok96/Quantum-Computation
|
acfilok96
|
import qiskit
from qiskit import *
print(qiskit.__version__)
%matplotlib inline
from qiskit.tools.visualization import plot_histogram
from ibm_quantum_widgets import draw_circuit
# initialize two qubits in the zero state and
# two classical bits in the zero state in the quantum circuit
circuit = QuantumCircuit(3,3)
# C gate
# (2) => q2
circuit.x(2)
circuit.draw(output='mpl')
draw_circuit(circuit)
# Hadamard (H) gate
# (0) => (q0)
circuit.h(0)
circuit.draw(output='mpl')
draw_circuit(circuit)
# A controlled-NOT (CX NOT) gate, on control qubit 0
# and target qubit 1, putting the qubits in an entangled state.
# (2,1) = > q2(control bit)(quantum bit)(origin) --> q1(target bit)(quantum bit)(destination)
circuit.cx(2,1)
# (0,2) = > q0(control bit)(quantum bit)(origin) --> q2(target bit)(quantum bit)(destination)
circuit.cx(0,2)
circuit.draw(output='mpl')
draw_circuit(circuit)
# measurement between quantum state and classical state
# [1,1] => [q1,q1](quantum bit) and [2,0] => [c2,c0](classical bit)
circuit.measure([1,1],[2,0])
circuit.draw(output='mpl')
draw_circuit(circuit)
# The n qubit’s measurement result will be stored in the n classical bit
circuit.measure([1,1,2],[2,0,0])
circuit.draw(output='mpl')
draw_circuit(circuit)
simulator = Aer.get_backend("qasm_simulator")
job = execute(circuit, simulator, shots=2024)
result = job.result()
counts = result.get_counts(circuit)
print("Total count for 100 and 101 are: ", counts)
# 1.
plot_histogram(counts)
# 2.
from ibm_quantum_widgets import draw_circuit
draw_circuit(circuit)
|
https://github.com/danieljaffe/quantum-algorithms-qiskit
|
danieljaffe
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 19 19:13:26 2023
@author: abdullahalshihry
"""
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 18 19:15:12 2023
@author: abdullahalshihry
"""
import qiskit as qs
import qiskit.visualization as qv
import random
import qiskit.circuit as qf
def Deutsch_Jozsa(circuit):
qr = qs.QuantumRegister(5,'q')
cr = qs.ClassicalRegister(4,'c')
qc = qs.QuantumCircuit(qr,cr)
qc.x(qr[4])
qc.barrier(range(5))
qc.h(qr[0])
qc.h(qr[1])
qc.h(qr[2])
qc.h(qr[3])
qc.h(qr[4])
qc.barrier(range(5))
qc = qc.compose(circuit)
qc.barrier(range(5))
qc.h(qr[0])
qc.h(qr[1])
qc.h(qr[2])
qc.h(qr[3])
qc.barrier(range(5))
qc.measure(0,0)
qc.measure(1,1)
qc.measure(2,2)
qc.measure(3,3)
job1 = qs.execute(qc, qs.Aer.get_backend('aer_simulator'), shots = 1024)
output1 = job1.result().get_counts()
print(output1)
qc.draw('mpl')
def Oracle():
qr = qs.QuantumRegister(5,'q')
cr = qs.ClassicalRegister(4,'c')
qc = qs.QuantumCircuit(qr,cr)
qq = qs.QuantumCircuit(5,name='Uf')
v = random.randint(1, 2)
if v == 1:
qc.cx(0,4)
qc.cx(1,4)
qc.cx(2,4)
qc.cx(3,4)
print('Balanced (1)')
elif v == 2:
qq.i(qr[0])
qq.i(qr[1])
qq.i(qr[2])
qq.i(qr[3])
print('Constant (0)')
qq =qq.to_gate()
qc.append(qq,[0,1,2,3,4])
return qc
Deutsch_Jozsa(Oracle())
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
from pprint import pprint
# plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
import pickle
import time
import datetime
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, I, X, Y, Z
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile, Aer
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
from qiskit.transpiler.passes import RemoveBarriers
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
from qiskit.ignis.mitigation import expectation_value
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits
from qiskit.quantum_info import state_fidelity
import sys
import importlib
sys.path.append("./")
import circuit_utils, zne_utils, tomography_utils, sgs_algorithm
importlib.reload(circuit_utils)
importlib.reload(zne_utils)
importlib.reload(tomography_utils)
importlib.reload(sgs_algorithm)
from circuit_utils import *
from zne_utils import *
from tomography_utils import *
from sgs_algorithm import *
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
trot_gate = trotter_gate(dt)
# initial layout
initial_layout = [5,3,1]
# Number of trotter steps
num_steps = 100
print("trotter step: ", num_steps)
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(num_qubits, name="lq")
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
make_initial_state(qc, "110") # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
subspace_encoder_init110(qc, targets=[0, 1, 2]) # encode
trotterize(qc, trot_gate, num_steps, targets=[1, 2]) # Simulate time evolution under H_heis3 Hamiltonian
subspace_decoder(qc, targets=[0, 1, 2]) # decode
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time / num_steps})
print("created qc")
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(qc, [0, 1, 2][::-1]) #! state tomography requires === BIG ENDIAN ===
print("created st_qcs (length:", len(st_qcs), ")")
# remove barriers
st_qcs = [RemoveBarriers()(qc) for qc in st_qcs]
print("removed barriers from st_qcs")
# optimize circuit
t3_st_qcs = transpile(st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
print("created t3_st_qcs (length:", len(t3_st_qcs), ")")
# zne wrapping
zne_qcs = t3_st_qcs # CHANGED!!!!
print("created zne_qcs (length:", len(zne_qcs), ")")
t3_zne_qcs = transpile(zne_qcs, optimization_level=0, basis_gates=["sx", "cx", "rz"], initial_layout=initial_layout)
print("created t3_zne_qcs (length:", len(t3_zne_qcs), ")")
t3_zne_qcs[4].draw("mpl")
from qiskit.test.mock import FakeJakarta
# backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
IBMQ.load_account()
# provider = IBMQ.get_provider(hub='ibm-q-utokyo', group='internal', project='hirashi-jst')
provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
print("provider:", provider)
backend = provider.get_backend("ibmq_jakarta")
# QREM
shots = 1 << 13
qr = QuantumRegister(num_qubits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout = initial_layout)
print('Job ID', cal_job.job_id())
shots = 1 << 13
reps = 8 # unused
jobs = []
for _ in range(reps):
job = execute(t3_zne_qcs, backend, shots=shots, optimization_level=0) # 毎回チェック: ここちゃんと変えた？
print('Job ID', job.job_id())
jobs.append(job)
dt_now = datetime.datetime.now()
print(dt_now)
import pickle
with open("jobs_jakarta_100step_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump({"jobs": jobs, "cal_job": cal_job}, f)
with open("job_ids_jakarta_100step_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump({"job_ids": [job.job_id() for job in jobs], "cal_job_id": cal_job.job_id()}, f)
with open("properties_jakarta" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump(backend.properties(), f)
cal_results = cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
target_state = (One^One^Zero).to_matrix() # DO NOT CHANGE!!!
fids = []
for job in jobs:
mit_results = meas_fitter.filter.apply(job.result())
rho = State
fid = state_fidelity(rho, target_state)
fids.append(fid)
print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.problems import BaseProblem
dummy_hamiltonian = None
base_problem = BaseProblem(dummy_hamiltonian)
print(base_problem.properties)
from qiskit_nature.second_q.properties import AngularMomentum
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
print("Adding AngularMomentum to problem.properties...")
base_problem.properties.add(AngularMomentum(2))
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
print("Discarding AngularMomentum from problem.properties...")
base_problem.properties.discard(AngularMomentum)
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
from qiskit_nature.second_q.drivers import PySCFDriver
es_problem = PySCFDriver().run()
print(es_problem.properties.particle_number)
print(es_problem.properties.angular_momentum)
print(es_problem.properties.magnetization)
print(es_problem.properties.electronic_dipole_moment)
print(es_problem.properties.electronic_density)
from qiskit_nature.second_q.properties import ElectronicDensity
density = ElectronicDensity.from_orbital_occupation(
es_problem.orbital_occupations,
es_problem.orbital_occupations_b,
)
es_problem.properties.electronic_density = density
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/grossiM/Qiskit_workshop1019
|
grossiM
|
#initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
def phase_oracle(circuit, register):
circuit.cz(qr[2],qr[0])
circuit.cz(qr[2],qr[1])
def n_controlled_Z(circuit, controls, target):
"""Implement a Z gate with multiple controls"""
if (len(controls) > 2):
raise ValueError('The controlled Z with more than 2 controls is not implemented')
elif (len(controls) == 1):
circuit.h(target)
circuit.cx(controls[0], target)
circuit.h(target)
elif (len(controls) == 2):
circuit.h(target)
circuit.ccx(controls[0], controls[1], target)
circuit.h(target)
def inversion_about_average(circuit, register, n, barriers):
"""Apply inversion about the average step of Grover's algorithm."""
circuit.h(register)
circuit.x(register)
if barriers:
circuit.barrier()
n_controlled_Z(circuit, [register[j] for j in range(n-1)], register[n-1])
if barriers:
circuit.barrier()
circuit.x(register)
circuit.h(register)
barriers = True
qr = QuantumRegister(3)
cr = ClassicalRegister(3)
groverCircuit = QuantumCircuit(qr,cr)
groverCircuit.h(qr)
if barriers:
groverCircuit.barrier()
phase_oracle(groverCircuit, qr)
if barriers:
groverCircuit.barrier()
inversion_about_average(groverCircuit, qr, 3, barriers)
if barriers:
groverCircuit.barrier()
groverCircuit.measure(qr,cr)
groverCircuit.draw(output="mpl")
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(groverCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
# Load our saved IBMQ accounts and get the least busy backend device with less than or equal to 5 qubits
IBMQ.load_account()
IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits <= 5 and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
shots = 1024
job = execute(groverCircuit, backend=backend, shots=shots)
job_monitor(job, interval = 2)
# Get the results from the computation
results = job.result()
answer = results.get_counts(groverCircuit)
plot_histogram(answer)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/jdanielescanez/quantum-solver
|
jdanielescanez
|
"""Qiskit code for running Simon's algorithm on quantum hardware for 2 qubits and b = '11' """
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, execute
# import basic plot tools
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
#set b equal to '11'
b = '11'
#1) initialize qubits
n = 2
simon_circuit_2 = QuantumCircuit(n*2, n)
#2) Apply Hadamard gates before querying the oracle
simon_circuit_2.h(range(n))
#3) Query oracle
simon_circuit_2 += simon_oracle(b)
#5) Apply Hadamard gates to the input register
simon_circuit_2.h(range(n))
#3) and 6) Measure qubits
simon_circuit_2.measure(range(n), range(n))
# Load saved IBMQ accounts and get the least busy backend device
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= n and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
# Execute and monitor the job
from qiskit.tools.monitor import job_monitor
shots = 1024
job = execute(simon_circuit_2, backend=backend, shots=shots, optimization_level=3)
job_monitor(job, interval = 2)
# Get results and plot counts
device_counts = job.result().get_counts()
plot_histogram(device_counts)
#additionally, function for calculating dot product of results
def bdotz(b, z):
accum = 0
for i in range(len(b)):
accum += int(b[i]) * int(z[i])
return (accum % 2)
print('b = ' + b)
for z in device_counts:
print( '{}.{} = {} (mod 2) ({:.1f}%)'.format(b, z, bdotz(b,z), device_counts[z]*100/shots))
#the most significant results are those for which b dot z=0(mod 2).
'''b = 11
11.00 = 0 (mod 2) (45.0%)
11.01 = 1 (mod 2) (6.2%)
11.10 = 1 (mod 2) (6.4%)
11.11 = 0 (mod 2) (42.4%)'''
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
qc.h(q)
qc.measure(q, c)
qc.draw(output='mpl', style={'backgroundcolor': '#EEEEEE'})
|
https://github.com/vindem/quantumMD
|
vindem
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute, transpile
from VectorPreprocessor import VectorPreprocessor
import numpy as np
class CSWAPCircuit:
def __init__(self, aux, qr1n, qr2n, crn, backend, shots):
self._aux = aux
self._qr1n = qr1n
self._qr2n = qr2n
self._crn = crn
self._backend = backend
self._shots = shots
def _init_cswap_circuit(self, a, b, norm):
q1 = QuantumRegister(self._aux, name='control_0')
q2 = QuantumRegister(self._qr1n, name='qr_1')
q3 = QuantumRegister(self._qr2n, name='qr_2')
c = ClassicalRegister(self._crn, name='c')
qc = QuantumCircuit(q1,q2,q3,c)
qc.initialize(a, q2[0:self._qr1n])
qc.initialize(b, q3[0:self._qr2n])
qc.barrier()
qc.h(q1[0])
qc.cswap(q1[0], q2[0], q3[0])
qc.h(q1[0])
qc.barrier()
qc.measure(q1, c)
job = execute(qc, self._backend, shots=self._shots, optimization_level=1)
result = job.result()
countsqd = result.get_counts(qc)
qdsquared = abs((4 * norm ** 2 * ((countsqd['0'] / self._shots) - 0.5)))
qd = np.sqrt(qdsquared)
return qd
def execute_swap_test(self, A, B):
vector_preprocessor = VectorPreprocessor(A,B)
return [self._init_cswap_circuit(vector_preprocessor.phi_reg()[i],
vector_preprocessor.psi_reg()[i],
vector_preprocessor.norm_factor()[i]) for i in range(len(vector_preprocessor.psi_reg()))]
|
https://github.com/hugoecarl/TSP-Problem-Study
|
hugoecarl
|
import math
import matplotlib.pyplot as plt
%matplotlib inline
class TSP:
def __init__(self):
self.flat_mat = flat_mat
self.n = 0
self.melhor_dist = 1e11
self.pontos = []
self.melhores_pontos = []
def busca_exaustiva(self, flat_mat, n, ite):
if ite == n:
dist = 0
for j in range(1, n):
dist += flat_mat[self.pontos[j-1] * n + self.pontos[j]]
dist += flat_mat[self.pontos[n-1] * n + self.pontos[0]]
if dist < self.melhor_dist:
self.melhor_dist = dist
self.melhores_pontos = self.pontos[:]
return
for i in range(n):
if self.pontos[i] == -1:
self.pontos[i] = ite
self.busca_exaustiva(flat_mat, n, ite + 1)
self.pontos[i] = -1
def dist_mat(self):
x = []
y = []
flat_mat = [] #matriz 1 dimensao contendo todas as distancias possiveis entre os pontos para facilitar cálculo.
while True:
try:
temp = input("Digite a coordenada x y: ").split()
x.append(float(temp[0]))
y.append(float(temp[1]))
except:
break
for i in range(len(x)):
for j in range(len(y)):
flat_mat.append(math.sqrt((x[i] - x[j])**2 + (y[i] - y[j])**2))
return flat_mat, x, y
def get_results(self):
self.flat_mat, x, _ = self.dist_mat()
self.n = len(x)
self.pontos = [-1]*self.n
self.pontos[0] = 0
self.busca_exaustiva(self.flat_mat, self.n, 1)
return self.melhor_dist, self.melhores_pontos
Tsp = TSP()
distancia, pontos = Tsp.get_results()
print("Melhor distancia encontrada: ", distancia)
print("Melhor caminho encontrado: ", pontos)
#plota gráfico
def connectpoints(x,y,p1,p2):
x1, x2 = x[p1], x[p2]
y1, y2 = y[p1], y[p2]
plt.plot([x1,x2],[y1,y2],'ro-')
for i in range(1, len(pontos)):
connectpoints(x,y,pontos[i-1],pontos[i])
connectpoints(x,y,pontos[len(x)-1],pontos[0])
plt.title("Percurso")
plt.show()
%%time
%%cmd
python TSP.py < in-1.txt
type out-1.txt
python TSP.py < in-2.txt
type out-2.txt
python TSP.py < in-3.txt
type out-3.txt
python TSP.py < in-4.txt
type out-4.txt
from qiskit import IBMQ
import numpy as np
#IBMQ.save_account('seu-tokenIBMQ-para-rodar-localmente')
IBMQ.load_account()
from qiskit import Aer
from qiskit.tools.visualization import plot_histogram
from qiskit.circuit.library import TwoLocal
from qiskit.optimization.applications.ising import max_cut, tsp
from qiskit.aqua.algorithms import VQE, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import SPSA
from qiskit.aqua import aqua_globals
from qiskit.aqua import QuantumInstance
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.optimization.algorithms import MinimumEigenOptimizer
from qiskit.optimization.problems import QuadraticProgram
import logging
from qiskit.aqua import set_qiskit_aqua_logging
#Preparando os dados segundo os imputs do usuario para serem resolvidos pelo qiskit max 4 pontos por limitação de qubits
coord = []
flat_mat, x, y = TSP().dist_mat()
dist_mat = np.array(flat_mat).reshape(len(x),len(x))
for i, j in zip(x, y):
coord.append([i,j])
ins = tsp.TspData('TSP_Q', dim=len(x), coord=np.array(coord), w=dist_mat)
qubitOp, offset = tsp.get_operator(ins)
print('Offset:', offset)
print('Ising Hamiltonian:')
print(qubitOp.print_details())
#Usando o numpyMinimumEigensolver como o solver do problema para resolver de forma quantica
ee = NumPyMinimumEigensolver(qubitOp)
result = ee.run()
print('energy:', result.eigenvalue.real)
print('tsp objective:', result.eigenvalue.real + offset)
x_Q = sample_most_likely(result.eigenstate)
print('feasible:', tsp.tsp_feasible(x_Q))
z = tsp.get_tsp_solution(x_Q)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
for i in range(1, len(z)):
connectpoints(x,y,z[i-1],z[i])
connectpoints(x,y,z[len(x)-1],z[0])
plt.title("Percurso")
plt.show()
#instanciando o simulador ou o computador real importante lembrar que nao ira funcionar para mais de 4 pontos pelo numero de qubits disponibilizados pela IBM que sao apenas 16 para o simulador qasm e 15 para a maquina quantica
provider = IBMQ.get_provider(hub = 'ibm-q')
device = provider.get_backend('ibmq_16_melbourne')
aqua_globals.random_seed = np.random.default_rng(123)
seed = 10598
backend = Aer.get_backend('qasm_simulator')
#descomentar essa linha caso queira rodar na maquina real
#backend = device
quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed)
#rodando no simulador quantico
spsa = SPSA(maxiter=10)
ry = TwoLocal(qubitOp.num_qubits, 'ry', 'cz', reps=5, entanglement='linear')
vqe = VQE(qubitOp, ry, spsa, quantum_instance=quantum_instance)
result = vqe.run(quantum_instance)
print('energy:', result.eigenvalue.real)
print('time:', result.optimizer_time)
x = sample_most_likely(result.eigenstate)
print('feasible:', tsp.tsp_feasible(x_Q))
z = tsp.get_tsp_solution(x_Q)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
|
https://github.com/qiskit-community/qiskit-metriq
|
qiskit-community
|
import os
import pandas as pd
from pyzx import routing
from qiskit import QuantumCircuit, transpile
from qiskit.transpiler import CouplingMap, TranspilerError
from qiskit_versions import *
VERSION = get_installed_version()
PACKAGE_NAME = "qiskit" if VERSION == compare_versions(VERSION, "0.25.3") else "qiskit-terra"
SAMPLE_SIZE = 100
ARCHITECTURES = ["ibm_rochester", "rigetti_16q_aspen"]
OPTIMIZATION_LEVEL = 3
DATE = get_version_date(PACKAGE_NAME, VERSION)
METHOD = f"{PACKAGE_NAME} {VERSION} compilation"
def run_experiment(qasm_id: str):
print(f"\nRunning {METHOD} for circuit {qasm_id}\n")
qasm_file_path = os.path.abspath(os.path.join( os.path.dirname( __file__ ),"..", "benchmarking",f"{qasm_id}.qasm"))
circuit = QuantumCircuit.from_qasm_file(qasm_file_path)
# Transpile for each architecture using pyzx
for arch in ARCHITECTURES:
architecture = routing.create_architecture(arch)
coupling_map = CouplingMap(architecture.graph.edges())
df = pd.DataFrame(columns=["Qasm file","Method","Date","Opt level","Platform","Seed","Circuit depth","Gate count"])
for i in range(SAMPLE_SIZE):
result = None
while result is None:
try:
result = transpile(circuit, coupling_map=coupling_map, optimization_level=OPTIMIZATION_LEVEL,
seed_transpiler=i)
except TranspilerError:
i += SAMPLE_SIZE
results = [f"{qasm_id}.qasm", METHOD, DATE, OPTIMIZATION_LEVEL,arch,i,result.depth(),sum(result.count_ops().values())]
df.loc[len(df)] = results
output_path = os.path.abspath(os.path.join(os.path.dirname( __file__ ),"..","benchmarking","results",f"{qasm_id}-qiskit{VERSION}-{arch}.csv"))
df.to_csv(output_path, sep="|")
print(f"{arch}\n",
f"- Circuit depth - ave: {df['Circuit depth'].mean()} | stdev: {df['Circuit depth'].std()}\n",
f"- Gate count - ave: {df['Gate count'].mean()} | stdev: {df['Gate count'].std()}")
run_experiment("ex1_226")
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import cirq
import matplotlib.pyplot as plt
import numpy as np
def qft_dagger_cirq(qc, qubits, n):
for qubit in range(n//2):
qc.append(cirq.SWAP(qubits[qubit], qubits[n-qubit-1]))
for j in range(n):
for m in range(j):
qc.append((cirq.CZ**(-1/2**(j-m)))(qubits[m],qubits[j]))
qc.append(cirq.H(qubits[j]))
def generalised_qpe_cirq(amt_estimation_qubits, angle, shots = 4098):
# Create and set up circuit
qubits = cirq.LineQubit.range(amt_estimation_qubits+1)
circuit = cirq.Circuit()
# Apply H-Gates to counting qubits:
for qubit in range(amt_estimation_qubits):
circuit.append(cirq.H(qubits[qubit]))
# Prepare our eigenstate |psi>:
circuit.append(cirq.X(qubits[amt_estimation_qubits]))
repetitions = 1
for counting_qubit in range(amt_estimation_qubits):
for i in range(repetitions):
circuit.append((cirq.CZ**(angle))(qubits[counting_qubit],qubits[amt_estimation_qubits]));
repetitions *= 2
# Do the inverse QFT:
qft_dagger_cirq(circuit, qubits, amt_estimation_qubits)
# Measure of course!
circuit.append(cirq.measure(*qubits[:-1], key='m'))
simulator = cirq.Simulator()
results = simulator.run(circuit , repetitions = shots)
theta_estimates = np.sum(2 ** np.arange(amt_estimation_qubits) * results.measurements['m'], axis=1) / 2**amt_estimation_qubits
unique,pos = np.unique(theta_estimates,return_inverse=True)
counts = np.bincount(pos)
maxpos = counts.argmax()
generalised_qpe_cirq(8,(2*(1/3)))
%timeit -p 8 -r 1 -n 1 generalised_qpe_cirq(8,(2*(1/3)),10000)
%timeit -p 8 -r 1 -n 1 generalised_qpe_cirq(8,(2*(1/3)),10000)
%timeit -p 8 -r 1 -n 1 generalised_qpe_cirq(8,(2*(1/3)),10000)
%timeit -p 8 -r 1 -n 1 generalised_qpe_cirq(8,(2*(1/3)),10000)
%timeit -p 8 -r 1 -n 1 generalised_qpe_cirq(8,(2*(1/3)),10000)
%timeit -p 8 -r 1 -n 1 generalised_qpe_cirq(8,(2*(1/3)),10000)
%timeit -p 8 -r 1 -n 1 generalised_qpe_cirq(8,(2*(1/3)),10000)
%timeit -p 8 -r 1 -n 1 generalised_qpe_cirq(8,(2*(1/3)),10000)
%timeit -p 8 -r 1 -n 1 generalised_qpe_cirq(8,(2*(1/3)),10000)
%timeit -p 8 -r 1 -n 1 generalised_qpe_cirq(8,(2*(1/3)),10000)
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.units import DistanceUnit
from qiskit_nature.second_q.drivers import PySCFDriver
driver = PySCFDriver(
atom="H 0 0 0; H 0 0 0.735",
basis="sto3g",
charge=0,
spin=0,
unit=DistanceUnit.ANGSTROM,
)
es_problem = driver.run()
from qiskit_nature.second_q.mappers import JordanWignerMapper
mapper = JordanWignerMapper()
from qiskit.algorithms.eigensolvers import NumPyEigensolver
numpy_solver = NumPyEigensolver(filter_criterion=es_problem.get_default_filter_criterion())
from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.primitives import Estimator
from qiskit_nature.second_q.algorithms import GroundStateEigensolver, QEOM
from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD
ansatz = UCCSD(
es_problem.num_spatial_orbitals,
es_problem.num_particles,
mapper,
initial_state=HartreeFock(
es_problem.num_spatial_orbitals,
es_problem.num_particles,
mapper,
),
)
estimator = Estimator()
# This first part sets the ground state solver
# see more about this part in the ground state calculation tutorial
solver = VQE(estimator, ansatz, SLSQP())
solver.initial_point = [0.0] * ansatz.num_parameters
gse = GroundStateEigensolver(mapper, solver)
# The qEOM algorithm is simply instantiated with the chosen ground state solver and Estimator primitive
qeom_excited_states_solver = QEOM(gse, estimator, "sd")
from qiskit_nature.second_q.algorithms import ExcitedStatesEigensolver
numpy_excited_states_solver = ExcitedStatesEigensolver(mapper, numpy_solver)
numpy_results = numpy_excited_states_solver.solve(es_problem)
qeom_results = qeom_excited_states_solver.solve(es_problem)
print(numpy_results)
print("\n\n")
print(qeom_results)
import numpy as np
def filter_criterion(eigenstate, eigenvalue, aux_values):
return np.isclose(aux_values["ParticleNumber"][0], 2.0)
new_numpy_solver = NumPyEigensolver(filter_criterion=filter_criterion)
new_numpy_excited_states_solver = ExcitedStatesEigensolver(mapper, new_numpy_solver)
new_numpy_results = new_numpy_excited_states_solver.solve(es_problem)
print(new_numpy_results)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/sergiogh/qpirates-qiskit-notebooks
|
sergiogh
|
import networkx as nx
import numpy as np
from qiskit import Aer
from qiskit.aqua import aqua_globals, QuantumInstance
from qiskit.aqua.algorithms import QAOA, VQE, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import SPSA, COBYLA
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.optimization.applications.ising import tsp
from qiskit.optimization.converters import IsingToQuadraticProgram
from qiskit.optimization.problems import QuadraticProgram
from qiskit.optimization.algorithms import MinimumEigenOptimizer, RecursiveMinimumEigenOptimizer
from qiskit.circuit.library import TwoLocal
def get_graph(nodes):
G = nx.Graph()
G.add_nodes_from(np.arange(0, nodes, 1))
# Create random positions in the graph. Distance will be calculated from positions
# Note: Dwave and other solvers require a complete graph
for i in range(nodes):
G.nodes[i]['pos'] = (np.random.uniform(0, 10), np.random.uniform(0, 10))
elist = set()
for i in range(nodes):
for t in range(i + 1,nodes):
y1=G.nodes[i]['pos'][1]
x1=G.nodes[i]['pos'][0]
y2=G.nodes[t]['pos'][1]
x2=G.nodes[t]['pos'][0]
dist = np.sqrt(((x2-x1)**2)+((y2-y1)**2))
_tuple = (i, t, dist)
elist.add(_tuple)
# tuple is (i,j,weight) where (i,j) is the edge
G.add_weighted_edges_from(elist)
return G
def get_cost_matrix(G, nodes):
w = np.zeros([nodes,nodes])
for i in range(nodes):
for j in range(nodes):
temp = G.get_edge_data(i,j,default=0)
if temp != 0:
w[i,j] = temp['weight']
return w
def calculate_cost(cost_matrix, solution):
cost = 0
for i in range(len(solution)):
a = i % len(solution)
b = (i + 1) % len(solution)
cost += cost_matrix[solution[a]][solution[b]]
return cost
nodes = 3
starting_node = 0
####
G = get_graph(nodes)
cost_matrix = get_cost_matrix(G, nodes)
G.nodes[0]['pos']
coords = []
for node in G.nodes:
coords.append(G.nodes[node]['pos'])
print(G.nodes[node]['pos'])
tsp_instance = tsp.TspData(name = "TSP", dim = len(G.nodes), coord = coords, w = cost_matrix)
qubitOp, offset = tsp.get_operator(tsp_instance)
#print(qubitOp.print_details())
print("Qubits: ",qubitOp.num_qubits)
qp = QuadraticProgram()
qp.from_ising(qubitOp, offset, linear=True)
qp.to_docplex().prettyprint()
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend)
optimizer = SPSA(maxiter=400)
#optimizer = COBYLA(maxiter=100, rhobeg=2, tol=0.5, disp=True)
ry = TwoLocal(qubitOp.num_qubits, 'ry', 'cx', reps=3, entanglement='full')
vqe = VQE(operator=qubitOp, optimizer=optimizer, quantum_instance=quantum_instance)
result = vqe.run(quantum_instance)
print(result)
x = sample_most_likely(result.eigenstate)
print(x)
print(tsp.tsp_feasible(x))
if(tsp.tsp_feasible(x)):
z = tsp.get_tsp_solution(x)
print('solution with VQE:', z)
else:
print('No solution found with VQE and such parameters')
npes = NumPyMinimumEigensolver(qubitOp)
result_classical = npes.run()
x = sample_most_likely(result_classical.eigenstate)
print(x)
if(tsp.tsp_feasible(x)):
z = tsp.get_tsp_solution(x)
print('solution Numpy classical solver:', z)
else:
print('No solution found with Classical Eigensolver')
## Try now with the optimizer and the Recursive Optimizer
backend = quantum_instance = Aer.get_backend('qasm_simulator')
optimizer = COBYLA(maxiter=200, rhobeg=3, tol=1.5, disp=True)
# MinimumEigenSolvers
qaoa_mes = QAOA(quantum_instance = backend, optimizer=optimizer)
vqe_mes = VQE(quantum_instance=backend, optimizer=optimizer, operator=qubitOp)
exact_mes = NumPyMinimumEigensolver()
# Optimizers
qaoa = MinimumEigenOptimizer(qaoa_mes) # using QAOA
vqe = MinimumEigenOptimizer(vqe_mes) # using QAOA
exact = MinimumEigenOptimizer(exact_mes) # using the exact classical numpy minimum eigen solver
# We can try using VQE or QAOA for the minimum eigen optimizer and compare results
rqaoa = RecursiveMinimumEigenOptimizer(min_eigen_optimizer=vqe, min_num_vars=1, min_num_vars_optimizer=exact)
#rqaoa = RecursiveMinimumEigenOptimizer(min_eigen_optimizer=qaoa, min_num_vars=1, min_num_vars_optimizer=exact)
exact_result = exact.solve(qp)
print("Result Exact QP: ",exact_result.x)
if(tsp.tsp_feasible(exact_result.x)):
print(tsp.get_tsp_solution(exact_result.x))
qaoa_result = qaoa.solve(qp)
print("Result QAOA with QP: ",qaoa_result.x)
if(tsp.tsp_feasible(qaoa_result.x)):
print(tsp.get_tsp_solution(qaoa_result.x))
vqe_result = vqe.solve(qp)
print("Result VQE with QP: ",vqe_result.x)
if(tsp.tsp_feasible(vqe_result.x)):
print(tsp.get_tsp_solution(vqe_result.x))
rqaoa_result = rqaoa.solve(qp)
print("Result RQAOA (withVQE) QP: ",rqaoa_result.x)
if(tsp.tsp_feasible(rqaoa_result.x)):
print(tsp.get_tsp_solution(rqaoa_result.x))
# Compare with using VQE directly without optimizer. That is why we send qubit operator to the MES
result = vqe_mes.run(quantum_instance)
x = sample_most_likely(result_classical.eigenstate)
print("Result VQE with Operator: ",x)
if(tsp.tsp_feasible(x)):
print(tsp.get_tsp_solution(x))
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2022, 2023.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Compute-uncompute fidelity interface using primitives
"""
from __future__ import annotations
from collections.abc import Sequence
from copy import copy
from qiskit import QuantumCircuit
from qiskit.primitives import BaseSampler
from qiskit.providers import Options
from ..exceptions import AlgorithmError
from .base_state_fidelity import BaseStateFidelity
from .state_fidelity_result import StateFidelityResult
class ComputeUncompute(BaseStateFidelity):
r"""
This class leverages the sampler primitive to calculate the state
fidelity of two quantum circuits following the compute-uncompute
method (see [1] for further reference).
The fidelity can be defined as the state overlap.
.. math::
|\langle\psi(x)|\phi(y)\rangle|^2
where :math:`x` and :math:`y` are optional parametrizations of the
states :math:`\psi` and :math:`\phi` prepared by the circuits
``circuit_1`` and ``circuit_2``, respectively.
**Reference:**
[1] Havlíček, V., Córcoles, A. D., Temme, K., Harrow, A. W., Kandala,
A., Chow, J. M., & Gambetta, J. M. (2019). Supervised learning
with quantum-enhanced feature spaces. Nature, 567(7747), 209-212.
`arXiv:1804.11326v2 [quant-ph] <https://arxiv.org/pdf/1804.11326.pdf>`_
"""
def __init__(
self,
sampler: BaseSampler,
options: Options | None = None,
local: bool = False,
) -> None:
r"""
Args:
sampler: Sampler primitive instance.
options: Primitive backend runtime options used for circuit execution.
The order of priority is: options in ``run`` method > fidelity's
default options > primitive's default setting.
Higher priority setting overrides lower priority setting.
local: If set to ``True``, the fidelity is averaged over
single-qubit projectors
.. math::
\hat{O} = \frac{1}{N}\sum_{i=1}^N|0_i\rangle\langle 0_i|,
instead of the global projector :math:`|0\rangle\langle 0|^{\otimes n}`.
This coincides with the standard (global) fidelity in the limit of
the fidelity approaching 1. Might be used to increase the variance
to improve trainability in algorithms such as :class:`~.time_evolvers.PVQD`.
Raises:
ValueError: If the sampler is not an instance of ``BaseSampler``.
"""
if not isinstance(sampler, BaseSampler):
raise ValueError(
f"The sampler should be an instance of BaseSampler, " f"but got {type(sampler)}"
)
self._sampler: BaseSampler = sampler
self._local = local
self._default_options = Options()
if options is not None:
self._default_options.update_options(**options)
super().__init__()
def create_fidelity_circuit(
self, circuit_1: QuantumCircuit, circuit_2: QuantumCircuit
) -> QuantumCircuit:
"""
Combines ``circuit_1`` and ``circuit_2`` to create the
fidelity circuit following the compute-uncompute method.
Args:
circuit_1: (Parametrized) quantum circuit.
circuit_2: (Parametrized) quantum circuit.
Returns:
The fidelity quantum circuit corresponding to circuit_1 and circuit_2.
"""
if len(circuit_1.clbits) > 0:
circuit_1.remove_final_measurements()
if len(circuit_2.clbits) > 0:
circuit_2.remove_final_measurements()
circuit = circuit_1.compose(circuit_2.inverse())
circuit.measure_all()
return circuit
def _run(
self,
circuits_1: QuantumCircuit | Sequence[QuantumCircuit],
circuits_2: QuantumCircuit | Sequence[QuantumCircuit],
values_1: Sequence[float] | Sequence[Sequence[float]] | None = None,
values_2: Sequence[float] | Sequence[Sequence[float]] | None = None,
**options,
) -> StateFidelityResult:
r"""
Computes the state overlap (fidelity) calculation between two
(parametrized) circuits (first and second) for a specific set of parameter
values (first and second) following the compute-uncompute method.
Args:
circuits_1: (Parametrized) quantum circuits preparing :math:`|\psi\rangle`.
circuits_2: (Parametrized) quantum circuits preparing :math:`|\phi\rangle`.
values_1: Numerical parameters to be bound to the first circuits.
values_2: Numerical parameters to be bound to the second circuits.
options: Primitive backend runtime options used for circuit execution.
The order of priority is: options in ``run`` method > fidelity's
default options > primitive's default setting.
Higher priority setting overrides lower priority setting.
Returns:
The result of the fidelity calculation.
Raises:
ValueError: At least one pair of circuits must be defined.
AlgorithmError: If the sampler job is not completed successfully.
"""
circuits = self._construct_circuits(circuits_1, circuits_2)
if len(circuits) == 0:
raise ValueError(
"At least one pair of circuits must be defined to calculate the state overlap."
)
values = self._construct_value_list(circuits_1, circuits_2, values_1, values_2)
# The priority of run options is as follows:
# options in `evaluate` method > fidelity's default options >
# primitive's default options.
opts = copy(self._default_options)
opts.update_options(**options)
job = self._sampler.run(circuits=circuits, parameter_values=values, **opts.__dict__)
try:
result = job.result()
except Exception as exc:
raise AlgorithmError("Sampler job failed!") from exc
if self._local:
raw_fidelities = [
self._get_local_fidelity(prob_dist, circuit.num_qubits)
for prob_dist, circuit in zip(result.quasi_dists, circuits)
]
else:
raw_fidelities = [
self._get_global_fidelity(prob_dist) for prob_dist in result.quasi_dists
]
fidelities = self._truncate_fidelities(raw_fidelities)
return StateFidelityResult(
fidelities=fidelities,
raw_fidelities=raw_fidelities,
metadata=result.metadata,
options=self._get_local_options(opts.__dict__),
)
@property
def options(self) -> Options:
"""Return the union of estimator options setting and fidelity default options,
where, if the same field is set in both, the fidelity's default options override
the primitive's default setting.
Returns:
The fidelity default + estimator options.
"""
return self._get_local_options(self._default_options.__dict__)
def update_default_options(self, **options):
"""Update the fidelity's default options setting.
Args:
**options: The fields to update the default options.
"""
self._default_options.update_options(**options)
def _get_local_options(self, options: Options) -> Options:
"""Return the union of the primitive's default setting,
the fidelity default options, and the options in the ``run`` method.
The order of priority is: options in ``run`` method > fidelity's
default options > primitive's default setting.
Args:
options: The fields to update the options
Returns:
The fidelity default + estimator + run options.
"""
opts = copy(self._sampler.options)
opts.update_options(**options)
return opts
def _get_global_fidelity(self, probability_distribution: dict[int, float]) -> float:
"""Process the probability distribution of a measurement to determine the
global fidelity.
Args:
probability_distribution: Obtained from the measurement result
Returns:
The global fidelity.
"""
return probability_distribution.get(0, 0)
def _get_local_fidelity(
self, probability_distribution: dict[int, float], num_qubits: int
) -> float:
"""Process the probability distribution of a measurement to determine the
local fidelity by averaging over single-qubit projectors.
Args:
probability_distribution: Obtained from the measurement result
Returns:
The local fidelity.
"""
fidelity = 0.0
for qubit in range(num_qubits):
for bitstring, prob in probability_distribution.items():
# Check whether the bit representing the current qubit is 0
if not bitstring >> qubit & 1:
fidelity += prob / num_qubits
return fidelity
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
from IPython.display import HTML
HTML('''<script>
code_show=true;
function code_toggle() {
if (code_show){
$('div.input').hide();
} else {
$('div.input').show();
}
code_show = !code_show
}
$( document ).ready(code_toggle);
</script>
<form action="javascript:code_toggle()"><input type="submit" value="Click here to toggle on/off the raw code for QISKit exercises."></form>''')
from initialize import *
import random
#initialize quantum program
my_alg = initialize(circuit_name = 'bb84', qubit_number=1, bit_number=1, backend = 'local_qasm_simulator', shots = 1)
#add gates to the circuit
# Alice encodes the bit 1 into a qubit
my_alg.q_circuit.x(my_alg.q_reg[0])
# Alice randomly applies the Hadamard gate to go to the Hadamard basis
a = random.randint(0,1)
if a==1:
my_alg.q_circuit.h(my_alg.q_reg[0])
# Bob randomly applies the Hadamard gate to go to the Hadamard basis
b = random.randint(0,1)
if b==1:
my_alg.q_circuit.h(my_alg.q_reg[0])
my_alg.q_circuit.measure(my_alg.q_reg[0], my_alg.c_reg[0]) # measures first qubit
# print list of gates in the circuit
print('List of gates:')
for circuit in my_alg.q_circuit:
print(circuit.name)
#Execute the quantum algorithm
result = my_alg.Q_program.execute(my_alg.circ_name, backend=my_alg.backend, shots= my_alg.shots)
#Show the results obtained from the quantum algorithm
counts = result.get_counts(my_alg.circ_name)
print('\nThe measured outcomes of the circuits are:',counts)
if a == b:
print('Alice and Bob agree on the basis, thus they keep the bit')
else:
print("Alice and Bob don't agree the same basis, thus they discard the bit")
### <span style="color:blue"> QISKit: EPR protocol </span>
#### <span style="color:blue"> 3) Show the communication of one bit </span>
|
https://github.com/acfilok96/Quantum-Computation
|
acfilok96
|
from qiskit import *
from qiskit.tools.visualization import plot_bloch_multivector
circuit = QuantumCircuit(1,1)
circuit.x(0)
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuit, backend=simulator).result()
statevector = result.get_statevector()
print(statevector)
%matplotlib inline
circuit.draw(output='mpl')
# bloch sphere
plot_bloch_multivector(statevector)
# measurement
circuit.measure([0],[0])
backend = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend=backend, shots=1024).result()
counts = result.get_counts()
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
circuit = QuantumCircuit(1,1)
circuit.x(0)
simulator = Aer.get_backend('unitary_simulator')
result = execute(circuit, backend=simulator).result()
unitary = result.get_unitary()
print(unitary)
%matplotlib inline
circuit.draw(output='mpl')
# bloch sphere
plot_bloch_multivector(unitary)
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from datetime import datetime
backend = Aer.get_backend("qasm_simulator")
global n_reg # = QuantumRegister(6, 'n')
global scratch_a
global class_reg # = ClassicalRegister(6, 'y')
global qc # = QuantumCircuit(n_reg, m_reg, scratch_a, class_reg)
test_timestamp = datetime.now()
from ArithmaticFunctions import *
def setup_each_addition():
n_reg = QuantumRegister(6, 'n')
m_reg = QuantumRegister(6, 'm')
scratch_a = QuantumRegister(6, 'sca')
scratch_b = QuantumRegister(6, 'scb')
class_reg = ClassicalRegister(6, 'y')
qc = QuantumCircuit(n_reg, m_reg, scratch_a, scratch_b, class_reg)
return {'n_reg': n_reg, 'm_reg': m_reg, 'scratch_a': scratch_a, 'scratch_b': scratch_b, 'class_reg': class_reg, 'qc': qc }
# def get_results_of_last_test():
# # for bit in range(len(n_reg)):
# # qc.measure(n_reg[bit], class_reg[bit])
# simulate = execute(qc, backend=backend, shots=1024).result()
return simulate.get_counts()
def verify_results(expected):
if [expected] == list(results.keys()):
print("PASSING - ", test_timestamp)
else:
print("FAILING - ", test_timestamp)
print(f'Got - {results}')
tc = setup_each_addition()
qc = tc['qc']
qc.x(tc['m_reg'][0])
qc.x(tc['m_reg'][2])
qc.x(tc['n_reg'][3])
mod_reduce(circuit=qc, mod_reg=tc['m_reg'], base_reg=tc['n_reg'], scratch_carry=tc['scratch_a'], scratch_unadd=tc['scratch_b'] )
qc.measure(tc['n_reg'], tc['class_reg'])
simulate = execute(qc, backend=backend, shots=1024).result()
print(simulate.get_counts())
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1);
tensored = bottom.tensor(top)
tensored.draw('mpl')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import circuit_to_dag
from qiskit.visualization import dag_drawer
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.measure(q[0], c[0])
circ.rz(0.5, q[1]).c_if(c, 2)
dag = circuit_to_dag(circ)
dag_drawer(dag)
|
https://github.com/RQC-QApp/Seminars
|
RQC-QApp
|
import numpy as np
import matplotlib.pyplot as plt
outcome_0 = np.array([1.0, 0.0])
outcome_1 = np.array([0.0, 1.0])
a = 0.75
b = 0.25
assert a + b == 1
prob_bit = a * outcome_0 + b * outcome_1
X, Y = prob_bit
plt.figure(figsize=(5,5))
plt.plot([a, 0], [b, b], '--', color='orange')
plt.plot([a, a], [b, 0], '--', color='green')
ax = plt.gca()
ax.quiver(X, Y, angles='xy', scale_units='xy', scale=1)
ax.set_xlim([0,1])
ax.set_ylim([0,1])
ax.quiver(0, Y, angles='xy', scale_units='xy', scale=1, color='green',
label='Проекция на направление $\overrightarrow{1}$')
ax.quiver(X, 0, angles='xy', scale_units='xy', scale=1, color='orange',
label='Проекция на направление $\overrightarrow{0}$')
plt.xlabel('$\overrightarrow{0}$', fontsize=15)
plt.ylabel('$\overrightarrow{1}$', fontsize=15)
plt.title('$\overrightarrow{v} = {a}\cdot\overrightarrow{0} + {b}\cdot\overrightarrow{1}$'.format(0, 1, v='v',
a=a, b=b))
plt.legend()
plt.draw()
plt.show()
print("Получаем, что a={}".format(prob_bit.dot(outcome_0)))
print("Получаем, что b={}".format(prob_bit.dot(outcome_1)))
|
https://github.com/AllenGabrielMarchen/HHL_implementation
|
AllenGabrielMarchen
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer
from qiskit.quantum_info import Statevector
from qiskit.algorithms.linear_solvers.hhl import HHL
import numpy as np
def qiskit_HHL(A,b):
backend = Aer.get_backend('aer_simulator')
#qiskit HHL 코드를 불러옴
hhl = HHL(quantum_instance=backend)
#A, b에 대해서 HHL 회로를 구성
solution = hhl.solve(A, b)
#만들어진 회로를 그림으로 저장
solution.state.draw("mpl").savefig("./outputs/HHL_circuit_qiskit.png")
#연산된 상태를 상태 벡터의 형태로 결과를 얻음
naive_sv = Statevector(solution.state).data
#qubit수를 확인
num_qubit = solution.state.num_qubits
#상태 벡터에서 필요한 상태만을 골라서 저장함
naive_full_vector = np.array([naive_sv[2**(num_qubit-1)+i] for i in range(len(b))])
#실수 부분만 취함
naive_full_vector = np.real(naive_full_vector)
#얻어진 벡터를 normalize하여 반환
normalized_result = naive_full_vector/np.linalg.norm(naive_full_vector)
constant = b/(A @ normalized_result)
constant = (constant[0]+constant[1])/2
constant = np.mean(constant)
print('<Qiskit_HHL>')
print('Normalized Qiskit Answer : {0}'.format(normalized_result))
print('Un-normalized Qiskit Answer : {0}'.format(normalized_result * constant))
print('Normalize Constant: ' ,constant)
return [normalized_result,normalized_result * constant]
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# Import requisite modules
import math
import datetime
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# Import Qiskit packages
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver, QAOA, SamplingVQE
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit.library import TwoLocal
from qiskit_aer.primitives import Sampler
from qiskit_optimization.algorithms import MinimumEigenOptimizer
# The data providers of stock-market data
from qiskit_finance.data_providers import RandomDataProvider
from qiskit_finance.applications.optimization import PortfolioDiversification
# Generate a pairwise time-series similarity matrix
seed = 123
stocks = ["TICKER1", "TICKER2"]
n = len(stocks)
data = RandomDataProvider(
tickers=stocks,
start=datetime.datetime(2016, 1, 1),
end=datetime.datetime(2016, 1, 30),
seed=seed,
)
data.run()
rho = data.get_similarity_matrix()
q = 1 # q less or equal than n
class ClassicalOptimizer:
def __init__(self, rho, n, q):
self.rho = rho
self.n = n # number of inner variables
self.q = q # number of required selection
def compute_allowed_combinations(self):
f = math.factorial
return int(f(self.n) / f(self.q) / f(self.n - self.q))
def cplex_solution(self):
# refactoring
rho = self.rho
n = self.n
q = self.q
my_obj = list(rho.reshape(1, n**2)[0]) + [0.0 for x in range(0, n)]
my_ub = [1 for x in range(0, n**2 + n)]
my_lb = [0 for x in range(0, n**2 + n)]
my_ctype = "".join(["I" for x in range(0, n**2 + n)])
my_rhs = (
[q]
+ [1 for x in range(0, n)]
+ [0 for x in range(0, n)]
+ [0.1 for x in range(0, n**2)]
)
my_sense = (
"".join(["E" for x in range(0, 1 + n)])
+ "".join(["E" for x in range(0, n)])
+ "".join(["L" for x in range(0, n**2)])
)
try:
my_prob = cplex.Cplex()
self.populatebyrow(my_prob, my_obj, my_ub, my_lb, my_ctype, my_sense, my_rhs)
my_prob.solve()
except CplexError as exc:
print(exc)
return
x = my_prob.solution.get_values()
x = np.array(x)
cost = my_prob.solution.get_objective_value()
return x, cost
def populatebyrow(self, prob, my_obj, my_ub, my_lb, my_ctype, my_sense, my_rhs):
n = self.n
prob.objective.set_sense(prob.objective.sense.minimize)
prob.variables.add(obj=my_obj, lb=my_lb, ub=my_ub, types=my_ctype)
prob.set_log_stream(None)
prob.set_error_stream(None)
prob.set_warning_stream(None)
prob.set_results_stream(None)
rows = []
col = [x for x in range(n**2, n**2 + n)]
coef = [1 for x in range(0, n)]
rows.append([col, coef])
for ii in range(0, n):
col = [x for x in range(0 + n * ii, n + n * ii)]
coef = [1 for x in range(0, n)]
rows.append([col, coef])
for ii in range(0, n):
col = [ii * n + ii, n**2 + ii]
coef = [1, -1]
rows.append([col, coef])
for ii in range(0, n):
for jj in range(0, n):
col = [ii * n + jj, n**2 + jj]
coef = [1, -1]
rows.append([col, coef])
prob.linear_constraints.add(lin_expr=rows, senses=my_sense, rhs=my_rhs)
# Instantiate the classical optimizer class
classical_optimizer = ClassicalOptimizer(rho, n, q)
# Compute the number of feasible solutions:
print("Number of feasible combinations= " + str(classical_optimizer.compute_allowed_combinations()))
# Compute the total number of possible combinations (feasible + unfeasible)
print("Total number of combinations= " + str(2 ** (n * (n + 1))))
# Visualize the solution
def visualize_solution(xc, yc, x, C, n, K, title_str):
plt.figure()
plt.scatter(xc, yc, s=200)
for i in range(len(xc)):
plt.annotate(i, (xc[i] + 0.015, yc[i]), size=16, color="r")
plt.grid()
for ii in range(n**2, n**2 + n):
if x[ii] > 0:
plt.plot(xc[ii - n**2], yc[ii - n**2], "r*", ms=20)
for ii in range(0, n**2):
if x[ii] > 0:
iy = ii // n
ix = ii % n
plt.plot([xc[ix], xc[iy]], [yc[ix], yc[iy]], "C2")
plt.title(title_str + " cost = " + str(int(C * 100) / 100.0))
plt.show()
from qiskit.utils import algorithm_globals
class QuantumOptimizer:
def __init__(self, rho, n, q):
self.rho = rho
self.n = n
self.q = q
self.pdf = PortfolioDiversification(similarity_matrix=rho, num_assets=n, num_clusters=q)
self.qp = self.pdf.to_quadratic_program()
# Obtains the least eigenvalue of the Hamiltonian classically
def exact_solution(self):
exact_mes = NumPyMinimumEigensolver()
exact_eigensolver = MinimumEigenOptimizer(exact_mes)
result = exact_eigensolver.solve(self.qp)
return self.decode_result(result)
def vqe_solution(self):
algorithm_globals.random_seed = 100
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
ry = TwoLocal(n, "ry", "cz", reps=5, entanglement="full")
vqe_mes = SamplingVQE(sampler=Sampler(), ansatz=ry, optimizer=cobyla)
vqe = MinimumEigenOptimizer(vqe_mes)
result = vqe.solve(self.qp)
return self.decode_result(result)
def qaoa_solution(self):
algorithm_globals.random_seed = 1234
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
qaoa_mes = QAOA(sampler=Sampler(), optimizer=cobyla, reps=3)
qaoa = MinimumEigenOptimizer(qaoa_mes)
result = qaoa.solve(self.qp)
return self.decode_result(result)
def decode_result(self, result, offset=0):
quantum_solution = 1 - (result.x)
ground_level = self.qp.objective.evaluate(result.x)
return quantum_solution, ground_level
# Instantiate the quantum optimizer class with parameters:
quantum_optimizer = QuantumOptimizer(rho, n, q)
# Check if the binary representation is correct. This requires CPLEX
try:
import cplex
# warnings.filterwarnings('ignore')
quantum_solution, quantum_cost = quantum_optimizer.exact_solution()
print(quantum_solution, quantum_cost)
classical_solution, classical_cost = classical_optimizer.cplex_solution()
print(classical_solution, classical_cost)
if np.abs(quantum_cost - classical_cost) < 0.01:
print("Binary formulation is correct")
else:
print("Error in the formulation of the Hamiltonian")
except Exception as ex:
print(ex)
ground_state, ground_level = quantum_optimizer.exact_solution()
print(ground_state)
classical_cost = 1.000779571614484 # obtained from the CPLEX solution
try:
if np.abs(ground_level - classical_cost) < 0.01:
print("Ising Hamiltonian in Z basis is correct")
else:
print("Error in the Ising Hamiltonian formulation")
except Exception as ex:
print(ex)
vqe_state, vqe_level = quantum_optimizer.vqe_solution()
print(vqe_state, vqe_level)
try:
if np.linalg.norm(ground_state - vqe_state) < 0.01:
print("SamplingVQE produces the same solution as the exact eigensolver.")
else:
print(
"SamplingVQE does not produce the same solution as the exact eigensolver, but that is to be expected."
)
except Exception as ex:
print(ex)
xc, yc = data.get_coordinates()
visualize_solution(xc, yc, ground_state, ground_level, n, q, "Classical")
visualize_solution(xc, yc, vqe_state, vqe_level, n, q, "VQE")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/mmetcalf14/Hamiltonian_Downfolding_IBM
|
mmetcalf14
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
The Bernstein-Vazirani algorithm.
"""
import logging
import operator
import numpy as np
from qiskit import ClassicalRegister, QuantumCircuit
from qiskit.aqua import AquaError, Pluggable, PluggableType, get_pluggable_class
from qiskit.aqua.algorithms import QuantumAlgorithm
from qiskit.aqua.utils import get_subsystem_density_matrix
logger = logging.getLogger(__name__)
class BernsteinVazirani(QuantumAlgorithm):
"""The Bernstein-Vazirani algorithm."""
CONFIGURATION = {
'name': 'BernsteinVazirani',
'description': 'Bernstein Vazirani',
'input_schema': {
'$schema': 'http://json-schema.org/schema#',
'id': 'bv_schema',
'type': 'object',
'properties': {
},
'additionalProperties': False
},
'problems': ['hiddenstringfinding'],
'depends': [
{
'pluggable_type': 'oracle',
'default': {
'name': 'TruthTableOracle',
},
},
],
}
def __init__(self, oracle):
self.validate(locals())
super().__init__()
self._oracle = oracle
self._circuit = None
self._ret = {}
@classmethod
def init_params(cls, params, algo_input):
if algo_input is not None:
raise AquaError("Input instance not supported.")
oracle_params = params.get(Pluggable.SECTION_KEY_ORACLE)
oracle = get_pluggable_class(
PluggableType.ORACLE,
oracle_params['name']).init_params(params)
return cls(oracle)
def construct_circuit(self, measurement=False):
"""
Construct the quantum circuit
Args:
measurement (bool): Boolean flag to indicate if measurement should be included in the circuit.
Returns:
the QuantumCircuit object for the constructed circuit
"""
if self._circuit is not None:
return self._circuit
qc_preoracle = QuantumCircuit(
self._oracle.variable_register,
self._oracle.output_register,
)
qc_preoracle.h(self._oracle.variable_register)
qc_preoracle.x(self._oracle.output_register)
qc_preoracle.h(self._oracle.output_register)
qc_preoracle.barrier()
# oracle circuit
qc_oracle = self._oracle.circuit
qc_oracle.barrier()
# postoracle circuit
qc_postoracle = QuantumCircuit(
self._oracle.variable_register,
self._oracle.output_register,
)
qc_postoracle.h(self._oracle.variable_register)
self._circuit = qc_preoracle + qc_oracle + qc_postoracle
# measurement circuit
if measurement:
measurement_cr = ClassicalRegister(len(self._oracle.variable_register), name='m')
self._circuit.add_register(measurement_cr)
self._circuit.measure(self._oracle.variable_register, measurement_cr)
return self._circuit
def _run(self):
if self._quantum_instance.is_statevector:
qc = self.construct_circuit(measurement=False)
result = self._quantum_instance.execute(qc)
complete_state_vec = result.get_statevector(qc)
variable_register_density_matrix = get_subsystem_density_matrix(
complete_state_vec,
range(len(self._oracle.variable_register), qc.width())
)
variable_register_density_matrix_diag = np.diag(variable_register_density_matrix)
max_amplitude = max(
variable_register_density_matrix_diag.min(),
variable_register_density_matrix_diag.max(),
key=abs
)
max_amplitude_idx = np.where(variable_register_density_matrix_diag == max_amplitude)[0][0]
top_measurement = np.binary_repr(max_amplitude_idx, len(self._oracle.variable_register))
else:
qc = self.construct_circuit(measurement=True)
measurement = self._quantum_instance.execute(qc).get_counts(qc)
self._ret['measurement'] = measurement
top_measurement = max(measurement.items(), key=operator.itemgetter(1))[0]
self._ret['result'] = top_measurement
return self._ret
|
https://github.com/noamsgl/IBMAscolaChallenge
|
noamsgl
|
import qiskit
from qiskit import QuantumCircuit
from qiskit.circuit.library import RXGate
import numpy as np
basis_gates = ['u3']
circ = QuantumCircuit(1, 1)
RX = RXGate(0)
# circ.append(RX, [0])
circ.h(0)
circ.measure(0, 0)
print("Before Transpiling:")
print(circ)
new_circ = qiskit.compiler.transpile(circ, basis_gates=basis_gates, optimization_level=0)
print("After Transpiling:")
print(new_circ)
|
https://github.com/bernardomendonca/qiskit-fourier-check
|
bernardomendonca
|
import qiskit.quantum_info as qi
from qiskit.circuit.library import FourierChecking
from qiskit.visualization import plot_histogram
f=[1,-1,-1,-1]
g=[1,1,-1,-1]
circ = FourierChecking(f=f,g=g)
circ.draw()
zero = qi.Statevector.from_label('00')
sv = zero.evolve(circ)
probs = sv.probabilities_dict()
plot_histogram(probs)
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
from qiskit import QuantumCircuit
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
qasm_str = bell.qasm()
qc2 = QuantumCircuit().from_qasm_str(qasm_str)
qc2.draw()
qc3 = QuantumCircuit().from_qasm_file('qasm')
qc3.draw()
|
https://github.com/Z-928/Bugs4Q
|
Z-928
|
from qiskit import *
qc = QuantumCircuit(2)
qc.h(i)
qc.crz (PI/4, 0, 1)
|
https://github.com/quantum-tokyo/qiskit-handson
|
quantum-tokyo
|
import numpy as np
from scipy.fftpack import fft
import matplotlib.pyplot as plt
%matplotlib inline
# parameters
N = 2**20 # data number
dt = 0.0001 # data step [s]
f1, f2 = 5, 0 # frequency[Hz]
A1, A2 = 5, 0 # Amplitude
p1, p2 = 0, 0 # phase
t = np.arange(0, N*dt, dt) # time
freq = np.linspace(0, 1.0/dt, N) # frequency step
x = A1*np.sin(2*np.pi*f1*t + p1) + A2*np.sin(2*np.pi*f2*t + p2)
y = fft(x)/(N/2) # 離散フーリエ変換&規格化
plt.figure(2)
plt.subplot(211)
plt.plot(t, x)
plt.xlim(0, 1)
plt.xlabel("time")
plt.ylabel("amplitude")
plt.subplot(212)
plt.plot(freq, np.abs(y))
plt.xlim(0, 10)
#plt.ylim(0, 5)
plt.xlabel("frequency")
plt.ylabel("amplitude")
plt.tight_layout()
plt.savefig("01")
plt.show()
import numpy as np
from numpy import pi
# importing Qiskit
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram, plot_bloch_multivector
%config InlineBackend.figure_format = 'svg' # Makes the images look nice
qc = QuantumCircuit(3)
qc.h(2)
qc.cu1(pi/2, 1, 2) # CROT from qubit 1 to qubit 2
qc.cu1(pi/4, 0, 2) # CROT from qubit 2 to qubit 0
qc.h(1)
qc.cu1(pi/2, 0, 1) # CROT from qubit 0 to qubit 1
qc.h(0)
qc.swap(0,2)
qc.draw('mpl')
import numpy as np
from numpy import pi
# importing Qiskit
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram, plot_bloch_multivector
%config InlineBackend.figure_format = 'svg' # Makes the images look nice
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.cu1(pi/2**(n-qubit), qubit, n)
# At the end of our function, we call the same function again on
# the next qubits (we reduced n by one earlier in the function)
qft_rotations(circuit, n)
# Let's see how it looks:
qc = QuantumCircuit(4)
qft_rotations(qc,4)
qc.draw('mpl')
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
# Let's see how it looks:
qc = QuantumCircuit(4)
swap_registers(qc,4)
qc.draw('mpl')
def qft(circuit, n):
"""QFT on the first n qubits in circuit"""
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
# Let's see how it looks:
qc = QuantumCircuit(4)
qft(qc,4)
qc.draw('mpl')
bin(5)
# Create the circuit
qc = QuantumCircuit(3)
# Encode the state 5
qc.x(0)
qc.x(2)
%config InlineBackend.figure_format = 'svg' # Makes the images fit
qc.draw('mpl')
backend = Aer.get_backend("statevector_simulator")
statevector = execute(qc, backend=backend).result().get_statevector()
plot_bloch_multivector(statevector)
qft(qc,3)
qc.draw('mpl')
statevector = execute(qc, backend=backend).result().get_statevector()
plot_bloch_multivector(statevector)
def inverse_qft(circuit, n):
"""Does the inverse QFT on the first n qubits in circuit"""
# First we create a QFT circuit of the correct size:
qft_circ = qft(QuantumCircuit(n), n)
# Then we take the inverse of this circuit
invqft_circ = qft_circ.inverse()
# And add it to the first n qubits in our existing circuit
circuit.append(invqft_circ, circuit.qubits[:n])
return circuit.decompose() # .decompose() allows us to see the individual gates
nqubits = 3
number = 5
qc = QuantumCircuit(nqubits)
for qubit in range(nqubits):
qc.h(qubit)
qc.u1(number*pi/4,0)
qc.u1(number*pi/2,1)
qc.u1(number*pi,2)
qc.draw('mpl')
backend = Aer.get_backend("statevector_simulator")
statevector = execute(qc, backend=backend).result().get_statevector()
plot_bloch_multivector(statevector)
qc = inverse_qft(qc,nqubits)
qc.measure_all()
qc.draw('mpl')
# Load our saved IBMQ accounts and get the least busy backend device with less than or equal to nqubits
# IBMQ.save_account('Your_Token')
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= nqubits
and not x.configuration().simulator
and x.status().operational==True))
print("least busy backend: ", backend)
shots = 2048
job = execute(qc, backend=backend, shots=shots, optimization_level=3)
job_monitor(job)
counts = job.result().get_counts()
plot_histogram(counts)
|
https://github.com/samuraigab/Quantum-Basic-Algorithms
|
samuraigab
|
import numpy as np
from numpy import pi
# importing Qiskit
from qiskit import QuantumCircuit, transpile, assemble, Aer
from qiskit.visualization import plot_histogram, plot_bloch_multivector
qc = QuantumCircuit(3)
qc.h(2)
qc.cp(pi/2, 1, 2)
qc.cp(pi/4, 0, 2)
qc.h(1)
qc.cp(pi/2, 0, 1)
qc.h(0)
qc.swap(0, 2)
qc.draw()
def qft_rotations(circuit, n):
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, n)
qft_rotations(circuit, n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft(circuit, n):
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
qc = QuantumCircuit(4)
qft(qc,4)
qc.draw()
# Create the circuit
qc = QuantumCircuit(3)
# Encode the state 5 (101 in binary)
qc.x(0)
qc.x(2)
qc.draw()
sim = Aer.get_backend("aer_simulator")
qc_init = qc.copy()
qc_init.save_statevector()
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
qft(qc, 3)
qc.draw()
qc.save_statevector()
statevector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(statevector)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
qr = QuantumRegister(3, 'q')
anc = QuantumRegister(1, 'ancilla')
cr = ClassicalRegister(3, 'c')
qc = QuantumCircuit(qr, anc, cr)
qc.x(anc[0])
qc.h(anc[0])
qc.h(qr[0:3])
qc.cx(qr[0:3], anc[0])
qc.h(qr[0:3])
qc.barrier(qr)
qc.measure(qr, cr)
qc.draw('mpl')
|
https://github.com/aryashah2k/Quantum-Computing-Collection-Of-Resources
|
aryashah2k
|
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/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeAuckland
backend = FakeAuckland()
ghz = QuantumCircuit(15)
ghz.h(0)
ghz.cx(0, range(1, 15))
depths = []
for _ in range(100):
depths.append(
transpile(
ghz,
backend,
layout_method='trivial' # Fixed layout mapped in circuit order
).depth()
)
plt.figure(figsize=(8, 6))
plt.hist(depths, align='left', color='#AC557C')
plt.xlabel('Depth', fontsize=14)
plt.ylabel('Counts', fontsize=14);
|
https://github.com/kaelynj/Qiskit-HubbardModel
|
kaelynj
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ, BasicAer, QuantumRegister, ClassicalRegister
from qiskit.compiler import transpile, assemble
from qiskit.quantum_info import Operator
from qiskit.tools.monitor import job_monitor
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import random as rand
import scipy.linalg as la
provider = IBMQ.load_account()
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
from matplotlib import rcParams
rcParams['text.usetex'] = True
def reverse_list(s):
temp_list = list(s)
temp_list.reverse()
return ''.join(temp_list)
#Useful tool for converting an integer to a binary bit string
def get_bin(x, n=0):
"""
Get the binary representation of x.
Parameters: x (int), n (int, number of digits)"""
binry = format(x, 'b').zfill(n)
sup = list( reversed( binry[0:int(len(binry)/2)] ) )
sdn = list( reversed( binry[int(len(binry)/2):len(binry)] ) )
return format(x, 'b').zfill(n)
#return ''.join(sup)+''.join(sdn)
'''The task here is now to define a function which will either update a given circuit with a time-step
or return a single gate which contains all the necessary components of a time-step'''
#==========Set Parameters of the System=============#
dt = 0.2 #Delta t
t = 1.0 #Hopping parameter
U = 2. #On-Site repulsion
time_steps = 30
nsite = 3
trotter_slices = 5
#==========Needed Functions=============#
#Function to apply a full set of time evolution gates to a given circuit
def qc_evolve(qc, numsite, dt, t, U, num_steps):
#Compute angles for the onsite and hopping gates
# based on the model parameters t, U, and dt
theta = t*dt/(2*trotter_slices)
phi = U*dt/(trotter_slices)
numq = 2*numsite
y_hop = Operator([[np.cos(theta), 0, 0, -1j*np.sin(theta)],
[0, np.cos(theta), 1j*np.sin(theta), 0],
[0, 1j*np.sin(theta), np.cos(theta), 0],
[-1j*np.sin(theta), 0, 0, np.cos(theta)]])
x_hop = Operator([[np.cos(theta), 0, 0, 1j*np.sin(theta)],
[0, np.cos(theta), 1j*np.sin(theta), 0],
[0, 1j*np.sin(theta), np.cos(theta), 0],
[1j*np.sin(theta), 0, 0, np.cos(theta)]])
z_onsite = Operator([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, np.exp(1j*phi)]])
#Loop over each time step needed and apply onsite and hopping gates
for step in range(num_steps):
for trot in range(trotter_slices):
#Onsite Terms
for i in range(0, numsite):
qc.unitary(z_onsite, [i,i+numsite], label="Z_Onsite")
#Add barrier to separate onsite from hopping terms
qc.barrier()
#Hopping terms
for i in range(0,numsite-1):
#Spin-up chain
qc.unitary(y_hop, [i,i+1], label="YHop")
qc.unitary(x_hop, [i,i+1], label="Xhop")
#Spin-down chain
qc.unitary(y_hop, [i+numsite, i+1+numsite], label="Xhop")
qc.unitary(x_hop, [i+numsite, i+1+numsite], label="Xhop")
#Add barrier after finishing the time step
qc.barrier()
#Measure the circuit
for i in range(numq):
qc.measure(i, i)
#Function to run the circuit and store the counts for an evolution with
# num_steps number of time steps.
def sys_evolve(nsites, dt, t, U, num_steps):
numq = 2*nsites
data = np.zeros((2**numq, num_steps))
for t_step in range(0, num_steps):
#Create circuit with t_step number of steps
q = QuantumRegister(numq)
c = ClassicalRegister(numq)
qcirc = QuantumCircuit(q,c)
#Initialize circuit by setting the occupation to
# a spin up and down electron in the middle site
#=========I TURNED THIS OFF FOR A SPECIFIC CASE==============
#qcirc.x(int(nsites/2))
#qcirc.x(nsites+int(nsites/2))
# if nsites==3:
#Half-filling
# qcirc.x(1)
# qcirc.x(4)
# qcirc.x(0)
#1 electron
qcirc.x(1)
#=======USE THE REGION ABOVE TO SET YOUR INITIAL STATE=======
qcirc.barrier()
#Append circuit with Trotter steps needed
qc_evolve(qcirc, nsites, dt, t, U, t_step)
#Choose provider and backend
provider = IBMQ.get_provider()
#backend = Aer.get_backend('statevector_simulator')
backend = Aer.get_backend('qasm_simulator')
#backend = provider.get_backend('ibmq_qasm_simulator')
#backend = provider.get_backend('ibmqx4')
#backend = provider.get_backend('ibmqx2')
#backend = provider.get_backend('ibmq_16_melbourne')
shots = 8192
max_credits = 10 #Max number of credits to spend on execution
job_exp = execute(qcirc, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job_exp)
result = job_exp.result()
counts = result.get_counts(qcirc)
print(result.get_counts(qcirc))
print("Job: ",t_step+1, " of ", time_steps," complete.")
#Store results in data array and normalize them
for i in range(2**numq):
if counts.get(get_bin(i,numq)) is None:
dat = 0
else:
dat = counts.get(get_bin(i,numq))
data[i,t_step] = dat/shots
return data
#Run simulation
run_results = sys_evolve(nsite, dt, t, U, time_steps)
#Process and plot data
'''The procedure here is, for each fermionic mode, add the probability of every state containing
that mode (at a given time step), and renormalize the data based on the total occupation of each mode.
Afterwards, plot the data as a function of time step for each mode.'''
proc_data = np.zeros((2*nsite, time_steps))
timesq = np.arange(0.,time_steps*dt, dt)
#Sum over time steps
for t in range(time_steps):
#Sum over all possible states of computer
for i in range(2**(2*nsite)):
#num = get_bin(i, 2*nsite)
num = ''.join( list( reversed(get_bin(i,2*nsite)) ) )
#For each state, check which mode(s) it contains and add them
for mode in range(len(num)):
if num[mode]=='1':
proc_data[mode,t] += run_results[i,t]
#Renormalize these sums so that the total occupation of the modes is 1
norm = 0.0
for mode in range(len(num)):
norm += proc_data[mode,t]
proc_data[:,t] = proc_data[:,t] / norm
'''
At this point, proc_data is a 2d array containing the occupation
of each mode, for every time step
'''
#Create plots of the processed data
fig2, ax2 = plt.subplots(figsize=(20,10))
colors = list(mcolors.TABLEAU_COLORS.keys())
for i in range(nsite):
#Create string label
strup = "Site "+str(i+1)+r'$\uparrow$'
strdwn = "Site "+str(i+1)+r'$\downarrow$'
ax2.plot(timesq, proc_data[i,:], marker="^", color=str(colors[i]), label=strup)
ax2.plot(timesq, proc_data[i+nsite,:], marker="v", color=str(colors[i]), label=strdwn)
#ax2.set_ylim(0, 0.55)
ax2.set_xlim(0, time_steps*dt+dt/2.)
#ax2.set_xticks(np.arange(0,time_steps*dt+dt, 0.2))
#ax2.set_yticks(np.arange(0,0.55, 0.05))
ax2.tick_params(labelsize=16)
ax2.set_title('Time Evolution of 3 Site One Dimensional Chain', fontsize=22)
ax2.set_xlabel('Time', fontsize=24)
ax2.set_ylabel('Probability', fontsize=24)
ax2.legend(fontsize=20)
#Plot the raw data as a colormap
xticks = np.arange(2**(nsite*2))
xlabels=[]
print("Time Steps: ",time_steps, " Step Size: ",dt)
for i in range(2**(nsite*2)):
xlabels.append(get_bin(i,6))
fig, ax = plt.subplots(figsize=(10,20))
c = ax.pcolor(run_results, cmap='binary')
ax.set_title('Time Evolution of 3 Site One Dimensional Chain', fontsize=22)
plt.yticks(xticks, xlabels, size=18)
ax.set_xlabel('Time Step', fontsize=22)
ax.set_ylabel('State', fontsize=26)
plt.show()
#Try by constructing the matrix and finding the eigenvalues
N = 3
Nup = 2
Ndwn = N - Nup
t = 1.0
U = 2.
#Check if two states are different by a single hop
def hop(psii, psij):
#Check spin down
hopp = 0
if psii[0]==psij[0]:
#Create array of indices with nonzero values
indi = np.nonzero(psii[1])[0]
indj = np.nonzero(psij[1])[0]
for i in range(len(indi)):
if abs(indi[i]-indj[i])==1:
hopp = -t
return hopp
#Check spin up
if psii[1]==psij[1]:
indi = np.nonzero(psii[0])[0]
indj = np.nonzero(psij[0])[0]
for i in range(len(indi)):
if abs(indi[i]-indj[i])==1:
hopp = -t
return hopp
return hopp
#On-site terms
def repel(l,state):
if state[0][l]==1 and state[1][l]==1:
return state
else:
return []
#States for 3 electrons with net spin up
'''
states = [ [[1,1,0],[1,0,0]], [[1,1,0],[0,1,0]], [[1,1,0], [0,0,1]],
[[1,0,1],[1,0,0]], [[1,0,1],[0,1,0]], [[1,0,1], [0,0,1]],
[[0,1,1],[1,0,0]], [[0,1,1],[0,1,0]], [[0,1,1], [0,0,1]] ]
#States for 2 electrons in singlet state
'''
states = [ [[1,0,0],[1,0,0]], [[1,0,0],[0,1,0]], [[1,0,0],[0,0,1]],
[[0,1,0],[1,0,0]], [[0,1,0],[0,1,0]], [[0,1,0],[0,0,1]],
[[0,0,1],[1,0,0]], [[0,0,1],[0,1,0]], [[0,0,1],[0,0,1]] ]
#'''
#States for a single electron
#states = [ [[1,0,0],[0,0,0]], [[0,1,0],[0,0,0]], [[0,0,1],[0,0,0]] ]
#'''
H = np.zeros((len(states),len(states)) )
#Construct Hamiltonian matrix
for i in range(len(states)):
psi_i = states[i]
for j in range(len(states)):
psi_j = states[j]
if j==i:
for l in range(0,N):
if psi_i == repel(l,psi_j):
H[i,j] = U
break
else:
H[i,j] = hop(psi_i, psi_j)
print(H)
results = la.eig(H)
print()
for i in range(len(results[0])):
print('Eigenvalue: ',results[0][i])
print('Eigenvector: \n',results[1][i])
print()
dens_ops = []
eigs = []
for vec in results[1]:
dens_ops.append(np.outer(results[1][i],results[1][i]))
eigs.append(results[0][i])
print(dens_ops)
dt = 0.1
tsteps = 50
times = np.arange(0., tsteps*dt, dt)
t_op = la.expm(-1j*H*dt)
#print(np.subtract(np.identity(len(H)), dt*H*1j))
#print(t_op)
wfk = [0., 1., 0., 0., .0, 0., 0., 0., 0.] #Half-filling initial state
#wfk = [0., 0., 0., 0., 1.0, 0., 0., 0., 0.] #2 electron initial state
#wfk = [0., 1., 0.] #1 electron initial state
evolve = np.zeros([tsteps, len(wfk)])
mode_evolve = np.zeros([tsteps, 6])
evolve[0] = wfk
#Figure out how to generalize this later
#'''
mode_evolve[0][0] = (evolve[0][0]+evolve[0][1]+evolve[0][2]) /2.
mode_evolve[0][1] = (evolve[0][3]+evolve[0][4]+evolve[0][5]) /2.
mode_evolve[0][2] = (evolve[0][6]+evolve[0][7]+evolve[0][8]) /2.
mode_evolve[0][3] = (evolve[0][0]+evolve[0][3]+evolve[0][6]) /2.
mode_evolve[0][4] = (evolve[0][1]+evolve[0][4]+evolve[0][7]) /2.
mode_evolve[0][5] = (evolve[0][2]+evolve[0][5]+evolve[0][8]) /2.
'''
mode_evolve[0][0] = (evolve[0][0]+evolve[0][1]+evolve[0][2]+evolve[0][3]+evolve[0][4]+evolve[0][5]) /3.
mode_evolve[0][1] = (evolve[0][0]+evolve[0][1]+evolve[0][2]+evolve[0][6]+evolve[0][7]+evolve[0][8]) /3.
mode_evolve[0][2] = (evolve[0][3]+evolve[0][4]+evolve[0][5]+evolve[0][6]+evolve[0][7]+evolve[0][8]) /3.
mode_evolve[0][3] = (evolve[0][0]+evolve[0][3]+evolve[0][6]) /3.
mode_evolve[0][4] = (evolve[0][1]+evolve[0][4]+evolve[0][7]) /3.
mode_evolve[0][5] = (evolve[0][2]+evolve[0][5]+evolve[0][8]) /3.
'''
print(mode_evolve[0])
#Define density matrices
for t in range(1, tsteps):
#t_op = la.expm(-1j*H*t)
wfk = np.dot(t_op, wfk)
evolve[t] = np.multiply(np.conj(wfk), wfk)
norm = np.sum(evolve[t])
#print(evolve[t])
#Store data in modes rather than basis defined in 'states' variable
#''' #Procedure for two electrons
mode_evolve[t][0] = (evolve[t][0]+evolve[t][1]+evolve[t][2]) / (2)
mode_evolve[t][1] = (evolve[t][3]+evolve[t][4]+evolve[t][5]) / (2)
mode_evolve[t][2] = (evolve[t][6]+evolve[t][7]+evolve[t][8]) / (2)
mode_evolve[t][3] = (evolve[t][0]+evolve[t][3]+evolve[t][6]) / (2)
mode_evolve[t][4] = (evolve[t][1]+evolve[t][4]+evolve[t][7]) / (2)
mode_evolve[t][5] = (evolve[t][2]+evolve[t][5]+evolve[t][8]) / (2)
''' #Procedure for half-filling
mode_evolve[t][0] = (evolve[t][0]+evolve[t][1]+evolve[t][2]+evolve[t][3]+evolve[t][4]+evolve[t][5]) /3.
mode_evolve[t][1] = (evolve[t][0]+evolve[t][1]+evolve[t][2]+evolve[t][6]+evolve[t][7]+evolve[t][8]) /3.
mode_evolve[t][2] = (evolve[t][3]+evolve[t][4]+evolve[t][5]+evolve[t][6]+evolve[t][7]+evolve[t][8]) /3.
mode_evolve[t][3] = (evolve[t][0]+evolve[t][3]+evolve[t][6]) /3.
mode_evolve[t][4] = (evolve[t][1]+evolve[t][4]+evolve[t][7]) /3.
mode_evolve[t][5] = (evolve[t][2]+evolve[t][5]+evolve[t][8]) /3.
#'''
print(mode_evolve[t])
#print(np.linalg.norm(evolve[t]))
#print(len(evolve[:,0]) )
#print(len(times))
#print(evolve[:,0])
#print(min(evolve[:,0]))
#Create plots of the processed data
fig2, ax2 = plt.subplots(figsize=(20,10))
colors = list(mcolors.TABLEAU_COLORS.keys())
sit1 = "Exact Site "+str(1)+r'$\uparrow$'
sit2 = "Exact Site "+str(2)+r'$\uparrow$'
sit3 = "Exact Site "+str(3)+r'$\uparrow$'
#ax2.plot(times, evolve[:,0], linestyle='--', color=colors[0], linewidth=2.5, label=sit1)
#ax2.plot(times, evolve[:,1], linestyle='--', color=str(colors[1]), linewidth=2.5, label=sit2)
#ax2.plot(times, evolve[:,2], linestyle='--', color=str(colors[2]), linewidth=2., label=sit3)
#ax2.plot(times, np.zeros(len(times)))
for i in range(nsite):
#Create string label
strupq = "Quantum Site "+str(i+1)+r'$\uparrow$'
strdwnq = "Quantum Site "+str(i+1)+r'$\downarrow$'
strup = "Numerical Site "+str(i+1)+r'$\uparrow$'
strdwn = "Numerical Site "+str(i+1)+r'$\downarrow$'
#ax2.plot(timesq, proc_data[i,:], marker="*", color=str(colors[i]), markersize=5, label=strupq)
#ax2.plot(timesq, proc_data[i+nsite,:], marker="v", color=str(colors[i]), markersize=5, label=strdwnq)
ax2.plot(times, mode_evolve[:,i], linestyle='-', color=str(colors[i]), linewidth=2, label=strup)
ax2.plot(times, mode_evolve[:,i+3], linestyle='--', color=str(colors[i]), linewidth=2, label=strdwn)
#ax2.plot(times, evolve[:,i], linestyle='-', color=str(colors[i]), linewidth=2, label=strup)
#ax2.plot(times, evolve[:,i+3], linestyle='--', color=str(colors[i]), linewidth=2, label=strdwn)
ax2.set_ylim(0, .5)
ax2.set_xlim(0, tsteps*dt+dt/2.)
ax2.set_xticks(np.arange(0,tsteps*dt+dt, 2*dt))
ax2.set_yticks(np.arange(0,0.5, 0.05))
ax2.tick_params(labelsize=16)
ax2.set_title('Time Evolution of 2 Electrons in 3 Site Chain', fontsize=22)
ax2.set_xlabel('Time', fontsize=24)
ax2.set_ylabel('Probability', fontsize=24)
ax2.legend(fontsize=20)
|
https://github.com/kazawai/shor_qiskit
|
kazawai
|
from qiskit import (ClassicalRegister, QuantumCircuit, QuantumRegister,
transpile)
from qiskit_aer import AerSimulator
# Define the quantum circuit
qc = QuantumCircuit(QuantumRegister(1), ClassicalRegister(1))
# Append the X operator
qc.x(0)
# Measure the qubit
qc.measure(0, 0)
# Display the circuit
print(qc)
# Transpile the circuit for the AerSimulator
aer_sim = AerSimulator()
aer_sim_transpile = transpile(qc, aer_sim)
# Simulate the transpiled circuit 10 times
result = aer_sim.run(aer_sim_transpile, shots=10).result()
# Print the result
print(result.get_counts())
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import HGate
qr = QuantumRegister(3)
qc = QuantumCircuit(qr)
c3h_gate = HGate().control(2)
qc.append(c3h_gate, qr)
qc.draw('mpl')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.drivers import GaussianForcesDriver
# if you ran Gaussian elsewhere and already have the output file
driver = GaussianForcesDriver(logfile="aux_files/CO2_freq_B3LYP_631g.log")
# if you want to run the Gaussian job from Qiskit
# driver = GaussianForcesDriver(
# ['#p B3LYP/6-31g Freq=(Anharm) Int=Ultrafine SCF=VeryTight',
# '',
# 'CO2 geometry optimization B3LYP/6-31g',
# '',
# '0 1',
# 'C -0.848629 2.067624 0.160992',
# 'O 0.098816 2.655801 -0.159738',
# 'O -1.796073 1.479446 0.481721',
# '',
# ''
from qiskit_nature.second_q.problems import HarmonicBasis
basis = HarmonicBasis([2, 2, 2, 2])
from qiskit_nature.second_q.problems import VibrationalStructureProblem
from qiskit_nature.second_q.mappers import DirectMapper
vibrational_problem = driver.run(basis=basis)
vibrational_problem.hamiltonian.truncation_order = 2
main_op, aux_ops = vibrational_problem.second_q_ops()
print(main_op)
qubit_mapper = DirectMapper()
qubit_op = qubit_mapper.map(main_op)
print(qubit_op)
basis = HarmonicBasis([3, 3, 3, 3])
vibrational_problem = driver.run(basis=basis)
vibrational_problem.hamiltonian.truncation_order = 2
main_op, aux_ops = vibrational_problem.second_q_ops()
qubit_mapper = DirectMapper()
qubit_op = qubit_mapper.map(main_op)
print(qubit_op)
# for simplicity, we will use the smaller basis again
vibrational_problem = driver.run(basis=HarmonicBasis([2, 2, 2, 2]))
vibrational_problem.hamiltonian.truncation_order = 2
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit_nature.second_q.algorithms import GroundStateEigensolver
solver = GroundStateEigensolver(
qubit_mapper,
NumPyMinimumEigensolver(filter_criterion=vibrational_problem.get_default_filter_criterion()),
)
result = solver.solve(vibrational_problem)
print(result)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
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
# 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")
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)
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()
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)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-quantinuum-provider
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# Copyright 2019-2020 Quantinuum, Intl. (www.quantinuum.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Module for interfacing with a Quantinuum Backend."""
import logging
import warnings
from qiskit.circuit import QuantumCircuit
from qiskit.providers import BackendV1
from qiskit.providers.models import BackendStatus
from qiskit.providers import Options
from qiskit.utils import deprecate_arguments
from qiskit import qobj as qobj_mod
from qiskit import pulse
from qiskit_quantinuum.exceptions import QiskitError
from .quantinuumjob import QuantinuumJob
logger = logging.getLogger(__name__)
class QuantinuumBackend(BackendV1):
"""Backend class interfacing with a Quantinuum backend."""
def __init__(self, name, configuration, provider, api):
"""Initialize remote backend for Quantinuum Quantum Computer.
Args:
name (String): name of backend.
configuration (BackendConfiguration): backend configuration
provider (QuantinuumProvider): provider.
api (QuantinuumClient): API client instance to use for backend
communication
"""
super().__init__(configuration=configuration, provider=provider)
self._api = api
self._name = name
@classmethod
def _default_options(cls):
return Options(shots=1024, priority='normal')
@deprecate_arguments({'qobj': 'run_input'})
def run(self, run_input, **kwargs):
"""Run a circuit on the backend.
Args:
run_input (QuantumCircuit|list): A QuantumCircuit or a list of
QuantumCircuit objects to run on the backend
Returns:
HoneywelJob: a handle to the async execution of the circuit(s) on
the backend
Raises:
QiskitError: If a pulse schedule is passed in for ``run_input``
"""
if isinstance(run_input, qobj_mod.QasmQobj):
warnings.warn("Passing in a QASMQobj object to run() is "
"deprecated and will be removed in a future "
"release", DeprecationWarning)
job = QuantinuumJob(self, None, self._api, circuits=run_input)
elif isinstance(run_input, (qobj_mod.PulseQobj, pulse.Schedule)):
raise QiskitError("Pulse jobs are not accepted")
else:
if isinstance(run_input, QuantumCircuit):
run_input = [run_input]
job_config = {}
for kwarg in kwargs:
if not hasattr(self.options, kwarg):
warnings.warn(
"Option %s is not used by this backend" % kwarg,
UserWarning, stacklevel=2)
else:
job_config[kwarg] = kwargs[kwarg]
if 'shots' not in job_config:
job_config['shots'] = self.options.shots
job_config['priority'] = self.options.priority
job = QuantinuumJob(self, None, self._api, circuits=run_input,
job_config=job_config)
job.submit()
return job
def retrieve_job(self, job_id):
""" Returns the job associated with the given job_id """
job = QuantinuumJob(self, job_id, self._api)
return job
def retrieve_jobs(self, job_ids):
""" Returns a list of jobs associated with the given job_ids """
return [QuantinuumJob(self, job_id, self._api) for job_id in job_ids]
def status(self):
"""Return the online backend status.
Returns:
BackendStatus: The status of the backend.
Raises:
LookupError: If status for the backend can't be found.
QuantinuumBackendError: If the status can't be formatted properly.
"""
api_status = self._api.backend_status(self.name())
try:
return BackendStatus.from_dict(api_status)
except QiskitError as ex:
raise LookupError(
"Couldn't get backend status: {0}".format(ex)
)
def name(self):
return self._name
|
https://github.com/jdanielescanez/quantum-solver
|
jdanielescanez
|
#!/usr/bin/env python3
# Author: Daniel Escanez-Exposito
from qiskit import QuantumCircuit
from algorithms.qalgorithm import QAlgorithm
## A Quantum Algorithm to obtain random numbers for QuantumSolver
class QRand(QAlgorithm):
## Constructor
def __init__(self):
## The name of the algorithm
self.name = 'QRand'
## A short description
self.description = 'Gives a random number between 0 and 2 ^ n_qubits - 1'
## The required parameters for the algorithm
self.parameters = [
{
'type': 'int',
'description': 'A positive number of qubits to use',
'constraint': 'Can\'t be bigger than the number of qubits of the selected backend'
}
]
## How to parse the result of the circuit execution
self.parse_result = lambda counts: int(list(counts.keys())[0], 2)
## How to parse the input parameters
self.parse_parameters = lambda parameters: [int(parameters[0])]
## Verify that the parameter is the number of qubits to use
def check_parameters(self, parameters):
if len(parameters) == 1 and type(parameters[0]) == str:
try:
return int(parameters[0]) > 0
except:
return False
## Create the circuit
def circuit(self, n=1):
# Create a Quantum Circuit
circuit = QuantumCircuit(n, n)
n_range = list(range(n))
# Add a H gate on every qubit
circuit.h(n_range)
circuit.barrier()
# Map the quantum measurement to the classical bits
circuit.measure(n_range, n_range)
return circuit
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Tests for Kraus quantum channel representation class."""
import copy
import unittest
import numpy as np
from numpy.testing import assert_allclose
from qiskit import QiskitError
from qiskit.quantum_info.states import DensityMatrix
from qiskit.quantum_info import Kraus
from .channel_test_case import ChannelTestCase
class TestKraus(ChannelTestCase):
"""Tests for Kraus channel representation."""
def test_init(self):
"""Test initialization"""
# Initialize from unitary
chan = Kraus(self.UI)
assert_allclose(chan.data, [self.UI])
self.assertEqual(chan.dim, (2, 2))
self.assertEqual(chan.num_qubits, 1)
# Initialize from Kraus
chan = Kraus(self.depol_kraus(0.5))
assert_allclose(chan.data, self.depol_kraus(0.5))
self.assertEqual(chan.dim, (2, 2))
self.assertEqual(chan.num_qubits, 1)
# Initialize from Non-CPTP
kraus_l, kraus_r = [self.UI, self.UX], [self.UY, self.UZ]
chan = Kraus((kraus_l, kraus_r))
assert_allclose(chan.data, (kraus_l, kraus_r))
self.assertEqual(chan.dim, (2, 2))
self.assertEqual(chan.num_qubits, 1)
# Initialize with redundant second op
chan = Kraus((kraus_l, kraus_l))
assert_allclose(chan.data, kraus_l)
self.assertEqual(chan.dim, (2, 2))
self.assertEqual(chan.num_qubits, 1)
# Initialize from rectangular
kraus = [np.zeros((4, 2))]
chan = Kraus(kraus)
assert_allclose(chan.data, kraus)
self.assertEqual(chan.dim, (2, 4))
self.assertIsNone(chan.num_qubits)
# Wrong input or output dims should raise exception
self.assertRaises(QiskitError, Kraus, kraus, input_dims=4, output_dims=4)
def test_circuit_init(self):
"""Test initialization from a circuit."""
circuit, target = self.simple_circuit_no_measure()
op = Kraus(circuit)
target = Kraus(target)
self.assertEqual(op, target)
def test_circuit_init_except(self):
"""Test initialization from circuit with measure raises exception."""
circuit = self.simple_circuit_with_measure()
self.assertRaises(QiskitError, Kraus, circuit)
def test_equal(self):
"""Test __eq__ method"""
kraus = [self.rand_matrix(2, 2) for _ in range(2)]
self.assertEqual(Kraus(kraus), Kraus(kraus))
def test_copy(self):
"""Test copy method"""
mat = np.eye(2)
with self.subTest("Deep copy"):
orig = Kraus(mat)
cpy = orig.copy()
cpy._data[0][0][0, 0] = 0.0
self.assertFalse(cpy == orig)
with self.subTest("Shallow copy"):
orig = Kraus(mat)
clone = copy.copy(orig)
clone._data[0][0][0, 0] = 0.0
self.assertTrue(clone == orig)
def test_clone(self):
"""Test clone method"""
mat = np.eye(4)
orig = Kraus(mat)
clone = copy.copy(orig)
clone._data[0][0][0, 0] = 0.0
self.assertTrue(clone == orig)
def test_is_cptp(self):
"""Test is_cptp method."""
self.assertTrue(Kraus(self.depol_kraus(0.5)).is_cptp())
self.assertTrue(Kraus(self.UX).is_cptp())
# Non-CPTP should return false
self.assertFalse(Kraus(([self.UI], [self.UX])).is_cptp())
self.assertFalse(Kraus([self.UI, self.UX]).is_cptp())
def test_conjugate(self):
"""Test conjugate method."""
kraus_l, kraus_r = self.rand_kraus(2, 4, 4), self.rand_kraus(2, 4, 4)
# Single Kraus list
targ = Kraus([np.conjugate(k) for k in kraus_l])
chan1 = Kraus(kraus_l)
chan = chan1.conjugate()
self.assertEqual(chan, targ)
self.assertEqual(chan.dim, (2, 4))
# Double Kraus list
targ = Kraus(([np.conjugate(k) for k in kraus_l], [np.conjugate(k) for k in kraus_r]))
chan1 = Kraus((kraus_l, kraus_r))
chan = chan1.conjugate()
self.assertEqual(chan, targ)
self.assertEqual(chan.dim, (2, 4))
def test_transpose(self):
"""Test transpose method."""
kraus_l, kraus_r = self.rand_kraus(2, 4, 4), self.rand_kraus(2, 4, 4)
# Single Kraus list
targ = Kraus([np.transpose(k) for k in kraus_l])
chan1 = Kraus(kraus_l)
chan = chan1.transpose()
self.assertEqual(chan, targ)
self.assertEqual(chan.dim, (4, 2))
# Double Kraus list
targ = Kraus(([np.transpose(k) for k in kraus_l], [np.transpose(k) for k in kraus_r]))
chan1 = Kraus((kraus_l, kraus_r))
chan = chan1.transpose()
self.assertEqual(chan, targ)
self.assertEqual(chan.dim, (4, 2))
def test_adjoint(self):
"""Test adjoint method."""
kraus_l, kraus_r = self.rand_kraus(2, 4, 4), self.rand_kraus(2, 4, 4)
# Single Kraus list
targ = Kraus([np.transpose(k).conj() for k in kraus_l])
chan1 = Kraus(kraus_l)
chan = chan1.adjoint()
self.assertEqual(chan, targ)
self.assertEqual(chan.dim, (4, 2))
# Double Kraus list
targ = Kraus(
([np.transpose(k).conj() for k in kraus_l], [np.transpose(k).conj() for k in kraus_r])
)
chan1 = Kraus((kraus_l, kraus_r))
chan = chan1.adjoint()
self.assertEqual(chan, targ)
self.assertEqual(chan.dim, (4, 2))
def test_compose_except(self):
"""Test compose different dimension exception"""
self.assertRaises(QiskitError, Kraus(np.eye(2)).compose, Kraus(np.eye(4)))
self.assertRaises(QiskitError, Kraus(np.eye(2)).compose, 2)
def test_compose(self):
"""Test compose method."""
# Random input test state
rho = DensityMatrix(self.rand_rho(2))
# UnitaryChannel evolution
chan1 = Kraus(self.UX)
chan2 = Kraus(self.UY)
chan = chan1.compose(chan2)
targ = rho & Kraus(self.UZ)
self.assertEqual(rho & chan, targ)
# 50% depolarizing channel
chan1 = Kraus(self.depol_kraus(0.5))
chan = chan1.compose(chan1)
targ = rho & Kraus(self.depol_kraus(0.75))
self.assertEqual(rho & chan, targ)
# Compose different dimensions
kraus1, kraus2 = self.rand_kraus(2, 4, 4), self.rand_kraus(4, 2, 4)
chan1 = Kraus(kraus1)
chan2 = Kraus(kraus2)
targ = rho & chan1 & chan2
chan = chan1.compose(chan2)
self.assertEqual(chan.dim, (2, 2))
self.assertEqual(rho & chan, targ)
chan = chan1 & chan2
self.assertEqual(chan.dim, (2, 2))
self.assertEqual(rho & chan, targ)
def test_dot(self):
"""Test dot method."""
# Random input test state
rho = DensityMatrix(self.rand_rho(2))
# UnitaryChannel evolution
chan1 = Kraus(self.UX)
chan2 = Kraus(self.UY)
targ = rho.evolve(Kraus(self.UZ))
self.assertEqual(rho.evolve(chan1.dot(chan2)), targ)
self.assertEqual(rho.evolve(chan1 @ chan2), targ)
# 50% depolarizing channel
chan1 = Kraus(self.depol_kraus(0.5))
targ = rho & Kraus(self.depol_kraus(0.75))
self.assertEqual(rho.evolve(chan1.dot(chan1)), targ)
self.assertEqual(rho.evolve(chan1 @ chan1), targ)
# Compose different dimensions
kraus1, kraus2 = self.rand_kraus(2, 4, 4), self.rand_kraus(4, 2, 4)
chan1 = Kraus(kraus1)
chan2 = Kraus(kraus2)
targ = rho & chan1 & chan2
self.assertEqual(rho.evolve(chan2.dot(chan1)), targ)
self.assertEqual(rho.evolve(chan2 @ chan1), targ)
def test_compose_front(self):
"""Test deprecated front compose method."""
# Random input test state
rho = DensityMatrix(self.rand_rho(2))
# UnitaryChannel evolution
chan1 = Kraus(self.UX)
chan2 = Kraus(self.UY)
chan = chan1.compose(chan2, front=True)
targ = rho & Kraus(self.UZ)
self.assertEqual(rho & chan, targ)
# 50% depolarizing channel
chan1 = Kraus(self.depol_kraus(0.5))
chan = chan1.compose(chan1, front=True)
targ = rho & Kraus(self.depol_kraus(0.75))
self.assertEqual(rho & chan, targ)
# Compose different dimensions
kraus1, kraus2 = self.rand_kraus(2, 4, 4), self.rand_kraus(4, 2, 4)
chan1 = Kraus(kraus1)
chan2 = Kraus(kraus2)
targ = rho & chan1 & chan2
chan = chan2.compose(chan1, front=True)
self.assertEqual(chan.dim, (2, 2))
self.assertEqual(rho & chan, targ)
def test_expand(self):
"""Test expand method."""
rho0, rho1 = np.diag([1, 0]), np.diag([0, 1])
rho_init = DensityMatrix(np.kron(rho0, rho0))
chan1 = Kraus(self.UI)
chan2 = Kraus(self.UX)
# X \otimes I
chan = chan1.expand(chan2)
rho_targ = DensityMatrix(np.kron(rho1, rho0))
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init & chan, rho_targ)
# I \otimes X
chan = chan2.expand(chan1)
rho_targ = DensityMatrix(np.kron(rho0, rho1))
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init & chan, rho_targ)
# Completely depolarizing
chan_dep = Kraus(self.depol_kraus(1))
chan = chan_dep.expand(chan_dep)
rho_targ = DensityMatrix(np.diag([1, 1, 1, 1]) / 4)
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init & chan, rho_targ)
def test_tensor(self):
"""Test tensor method."""
rho0, rho1 = np.diag([1, 0]), np.diag([0, 1])
rho_init = DensityMatrix(np.kron(rho0, rho0))
chan1 = Kraus(self.UI)
chan2 = Kraus(self.UX)
# X \otimes I
chan = chan2.tensor(chan1)
rho_targ = DensityMatrix(np.kron(rho1, rho0))
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init & chan, rho_targ)
# I \otimes X
chan = chan1.tensor(chan2)
rho_targ = DensityMatrix(np.kron(rho0, rho1))
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init & chan, rho_targ)
# Completely depolarizing
chan_dep = Kraus(self.depol_kraus(1))
chan = chan_dep.tensor(chan_dep)
rho_targ = DensityMatrix(np.diag([1, 1, 1, 1]) / 4)
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init & chan, rho_targ)
def test_power(self):
"""Test power method."""
# 10% depolarizing channel
rho = DensityMatrix(np.diag([1, 0]))
p_id = 0.9
chan = Kraus(self.depol_kraus(1 - p_id))
# Compose 3 times
p_id3 = p_id**3
chan3 = chan.power(3)
targ3a = rho & chan & chan & chan
self.assertEqual(rho & chan3, targ3a)
targ3b = rho & Kraus(self.depol_kraus(1 - p_id3))
self.assertEqual(rho & chan3, targ3b)
def test_add(self):
"""Test add method."""
# Random input test state
rho = DensityMatrix(self.rand_rho(2))
kraus1, kraus2 = self.rand_kraus(2, 4, 4), self.rand_kraus(2, 4, 4)
# Random Single-Kraus maps
chan1 = Kraus(kraus1)
chan2 = Kraus(kraus2)
targ = (rho & chan1) + (rho & chan2)
chan = chan1._add(chan2)
self.assertEqual(rho & chan, targ)
chan = chan1 + chan2
self.assertEqual(rho & chan, targ)
# Random Single-Kraus maps
chan = Kraus((kraus1, kraus2))
targ = 2 * (rho & chan)
chan = chan._add(chan)
self.assertEqual(rho & chan, targ)
def test_add_qargs(self):
"""Test add method with qargs."""
rho = DensityMatrix(self.rand_rho(8))
kraus = self.rand_kraus(8, 8, 4)
kraus0 = self.rand_kraus(2, 2, 4)
op = Kraus(kraus)
op0 = Kraus(kraus0)
eye = Kraus(self.UI)
with self.subTest(msg="qargs=[0]"):
value = op + op0([0])
target = op + eye.tensor(eye).tensor(op0)
self.assertEqual(rho & value, rho & target)
with self.subTest(msg="qargs=[1]"):
value = op + op0([1])
target = op + eye.tensor(op0).tensor(eye)
self.assertEqual(rho & value, rho & target)
with self.subTest(msg="qargs=[2]"):
value = op + op0([2])
target = op + op0.tensor(eye).tensor(eye)
self.assertEqual(rho & value, rho & target)
def test_sub_qargs(self):
"""Test sub method with qargs."""
rho = DensityMatrix(self.rand_rho(8))
kraus = self.rand_kraus(8, 8, 4)
kraus0 = self.rand_kraus(2, 2, 4)
op = Kraus(kraus)
op0 = Kraus(kraus0)
eye = Kraus(self.UI)
with self.subTest(msg="qargs=[0]"):
value = op - op0([0])
target = op - eye.tensor(eye).tensor(op0)
self.assertEqual(rho & value, rho & target)
with self.subTest(msg="qargs=[1]"):
value = op - op0([1])
target = op - eye.tensor(op0).tensor(eye)
self.assertEqual(rho & value, rho & target)
with self.subTest(msg="qargs=[2]"):
value = op - op0([2])
target = op - op0.tensor(eye).tensor(eye)
self.assertEqual(rho & value, rho & target)
def test_subtract(self):
"""Test subtract method."""
# Random input test state
rho = DensityMatrix(self.rand_rho(2))
kraus1, kraus2 = self.rand_kraus(2, 4, 4), self.rand_kraus(2, 4, 4)
# Random Single-Kraus maps
chan1 = Kraus(kraus1)
chan2 = Kraus(kraus2)
targ = (rho & chan1) - (rho & chan2)
chan = chan1 - chan2
self.assertEqual(rho & chan, targ)
# Random Single-Kraus maps
chan = Kraus((kraus1, kraus2))
targ = 0 * (rho & chan)
chan = chan - chan
self.assertEqual(rho & chan, targ)
def test_multiply(self):
"""Test multiply method."""
# Random initial state and Kraus ops
rho = DensityMatrix(self.rand_rho(2))
val = 0.5
kraus1, kraus2 = self.rand_kraus(2, 4, 4), self.rand_kraus(2, 4, 4)
# Single Kraus set
chan1 = Kraus(kraus1)
targ = val * (rho & chan1)
chan = chan1._multiply(val)
self.assertEqual(rho & chan, targ)
chan = val * chan1
self.assertEqual(rho & chan, targ)
targ = (rho & chan1) * val
chan = chan1 * val
self.assertEqual(rho & chan, targ)
# Double Kraus set
chan2 = Kraus((kraus1, kraus2))
targ = val * (rho & chan2)
chan = chan2._multiply(val)
self.assertEqual(rho & chan, targ)
chan = val * chan2
self.assertEqual(rho & chan, targ)
def test_multiply_except(self):
"""Test multiply method raises exceptions."""
chan = Kraus(self.depol_kraus(1))
self.assertRaises(QiskitError, chan._multiply, "s")
self.assertRaises(QiskitError, chan.__rmul__, "s")
self.assertRaises(QiskitError, chan._multiply, chan)
self.assertRaises(QiskitError, chan.__rmul__, chan)
def test_negate(self):
"""Test negate method"""
rho = DensityMatrix(np.diag([1, 0]))
targ = DensityMatrix(np.diag([-0.5, -0.5]))
chan = -Kraus(self.depol_kraus(1))
self.assertEqual(rho & chan, targ)
if __name__ == "__main__":
unittest.main()
|
https://github.com/vm6502q/qiskit-qrack-provider
|
vm6502q
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Decorator for using with Qiskit unit tests."""
import functools
import os
import sys
import unittest
from .utils import Path
from .http_recorder import http_recorder
from .testing_options import get_test_options
def is_aer_provider_available():
"""Check if the C++ simulator can be instantiated.
Returns:
bool: True if simulator executable is available
"""
# TODO: HACK FROM THE DEPTHS OF DESPAIR AS AER DOES NOT WORK ON MAC
if sys.platform == 'darwin':
return False
try:
import qiskit.providers.aer # pylint: disable=unused-import
except ImportError:
return False
return True
def requires_aer_provider(test_item):
"""Decorator that skips test if qiskit aer provider is not available
Args:
test_item (callable): function or class to be decorated.
Returns:
callable: the decorated function.
"""
reason = 'Aer provider not found, skipping test'
return unittest.skipIf(not is_aer_provider_available(), reason)(test_item)
def slow_test(func):
"""Decorator that signals that the test takes minutes to run.
Args:
func (callable): test function to be decorated.
Returns:
callable: the decorated function.
"""
@functools.wraps(func)
def _wrapper(*args, **kwargs):
skip_slow = not TEST_OPTIONS['run_slow']
if skip_slow:
raise unittest.SkipTest('Skipping slow tests')
return func(*args, **kwargs)
return _wrapper
def _get_credentials(test_object, test_options):
"""Finds the credentials for a specific test and options.
Args:
test_object (QiskitTestCase): The test object asking for credentials
test_options (dict): Options after QISKIT_TESTS was parsed by
get_test_options.
Returns:
Credentials: set of credentials
Raises:
ImportError: if the
Exception: when the credential could not be set and they are needed
for that set of options
"""
try:
from qiskit.providers.ibmq.credentials import (Credentials,
discover_credentials)
except ImportError:
raise ImportError('qiskit-ibmq-provider could not be found, and is '
'required for mocking or executing online tests.')
dummy_credentials = Credentials(
'dummyapiusersloginWithTokenid01',
'https://quantumexperience.ng.bluemix.net/api')
if test_options['mock_online']:
return dummy_credentials
if os.getenv('USE_ALTERNATE_ENV_CREDENTIALS', ''):
# Special case: instead of using the standard credentials mechanism,
# load them from different environment variables. This assumes they
# will always be in place, as is used by the Travis setup.
return Credentials(os.getenv('IBMQ_TOKEN'), os.getenv('IBMQ_URL'))
else:
# Attempt to read the standard credentials.
discovered_credentials = discover_credentials()
if discovered_credentials:
# Decide which credentials to use for testing.
if len(discovered_credentials) > 1:
try:
# Attempt to use QE credentials.
return discovered_credentials[dummy_credentials.unique_id()]
except KeyError:
pass
# Use the first available credentials.
return list(discovered_credentials.values())[0]
# No user credentials were found.
if test_options['rec']:
raise Exception('Could not locate valid credentials. You need them for '
'recording tests against the remote API.')
test_object.log.warning('No user credentials were detected. '
'Running with mocked data.')
test_options['mock_online'] = True
return dummy_credentials
def requires_qe_access(func):
"""Decorator that signals that the test uses the online API:
It involves:
* determines if the test should be skipped by checking environment
variables.
* if the `USE_ALTERNATE_ENV_CREDENTIALS` environment variable is
set, it reads the credentials from an alternative set of environment
variables.
* if the test is not skipped, it reads `qe_token` and `qe_url` from
`Qconfig.py`, environment variables or qiskitrc.
* if the test is not skipped, it appends `qe_token` and `qe_url` as
arguments to the test function.
Args:
func (callable): test function to be decorated.
Returns:
callable: the decorated function.
"""
@functools.wraps(func)
def _wrapper(self, *args, **kwargs):
if TEST_OPTIONS['skip_online']:
raise unittest.SkipTest('Skipping online tests')
credentials = _get_credentials(self, TEST_OPTIONS)
self.using_ibmq_credentials = credentials.is_ibmq()
kwargs.update({'qe_token': credentials.token,
'qe_url': credentials.url})
decorated_func = func
if TEST_OPTIONS['rec'] or TEST_OPTIONS['mock_online']:
# For recording or for replaying existing cassettes, the test
# should be decorated with @use_cassette.
vcr_mode = 'new_episodes' if TEST_OPTIONS['rec'] else 'none'
decorated_func = http_recorder(
vcr_mode, Path.CASSETTES.value).use_cassette()(decorated_func)
return decorated_func(self, *args, **kwargs)
return _wrapper
TEST_OPTIONS = get_test_options()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.quantum_info import SparsePauliOp
H2_op = SparsePauliOp.from_list(
[
("II", -1.052373245772859),
("IZ", 0.39793742484318045),
("ZI", -0.39793742484318045),
("ZZ", -0.01128010425623538),
("XX", 0.18093119978423156),
]
)
from qiskit.circuit.library import TwoLocal
from qiskit.algorithms.optimizers import SLSQP
ansatz = TwoLocal(3, rotation_blocks=["ry", "rz"], entanglement_blocks="cz", reps=1)
optimizer = SLSQP()
ansatz.decompose().draw('mpl')
from qiskit.primitives import Sampler, Estimator
from qiskit.algorithms.state_fidelities import ComputeUncompute
estimator = Estimator()
sampler = Sampler()
fidelity = ComputeUncompute(sampler)
k = 3
betas = [33, 33, 33]
counts = []
values = []
steps = []
def callback(eval_count, params, value, meta, step):
counts.append(eval_count)
values.append(value)
steps.append(step)
from qiskit.algorithms.eigensolvers import VQD
vqd = VQD(estimator, fidelity, ansatz, optimizer, k=k, betas=betas, callback=callback)
result = vqd.compute_eigenvalues(operator = H2_op)
vqd_values = result.optimal_values
print(vqd_values)
import numpy as np
import pylab
pylab.rcParams["figure.figsize"] = (12, 8)
steps = np.asarray(steps)
counts = np.asarray(counts)
values = np.asarray(values)
for i in range(1,4):
_counts = counts[np.where(steps == i)]
_values = values[np.where(steps == i)]
pylab.plot(_counts, _values, label=f"State {i-1}")
pylab.xlabel("Eval count")
pylab.ylabel("Energy")
pylab.title("Energy convergence for each computed state")
pylab.legend(loc="upper right");
from qiskit.algorithms.eigensolvers import NumPyEigensolver
from qiskit.opflow import PauliSumOp
exact_solver = NumPyEigensolver(k=3)
exact_result = exact_solver.compute_eigenvalues(PauliSumOp(H2_op))
ref_values = exact_result.eigenvalues
print(f"Reference values: {ref_values}")
print(f"VQD values: {vqd_values}")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Tojarieh97/VQE
|
Tojarieh97
|
import nbimporter
from typing import Dict, Tuple, List
import numpy as np
from tqdm import tqdm
QUBITS_NUM = 4
N = 16
K = 4
NUM_SHOTS = 1024
NUM_ITERATIONS = 50
w = 0.5
approximated_energies = []
from qiskit import Aer
from qiskit.utils import QuantumInstance, algorithm_globals
seed = 50
algorithm_globals.random_seed = seed
simulator_backend = Aer.get_backend('qasm_simulator')
from scipy.optimize import minimize
from utiles import *
input_states = get_first_k_eigenvectors_from_n_computational_basis(K, N)
from ansatz_circuit_item2 import get_full_variational_quantum_circuit
init_circuit_params = {
"thetas": np.random.uniform(low=0, high=2*np.pi, size=8),
"phis": np.random.uniform(low=0, high=2*np.pi, size=4),
"D1": 2,
"D2": 6
}
def prepare_circuit_params(thetas) -> Dict:
return {
"thetas": thetas[4:],
"phis": thetas[:4],
"D1": 2,
"D2": 6
}
def get_ansatz_state(circuit_params, input_state):
circuit_params_with_input_state = {**circuit_params, "input_state": input_state}
return get_full_variational_quantum_circuit(**circuit_params_with_input_state)
def transfrom_hamiltonian_into_pauli_strings(hamiltonian) -> List:
pauli_operators = hamiltonian.to_pauli_op().settings['oplist']
pauli_coeffs = list(map(lambda pauli_operator: pauli_operator.coeff, pauli_operators))
pauli_strings = list(map(lambda pauli_operator: pauli_operator.primitive, pauli_operators))
return pauli_coeffs, pauli_strings
from qiskit.circuit.library.standard_gates import HGate, SGate
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
reducing_to_pauli_z_mapping = {
'I': 'I',
'Z': 'Z',
'X': 'Z',
'Y': 'Z'
}
def reduce_pauli_matrixes_into_sigma_z(pauli_string) -> str:
reduced_pauli_string = ""
for matrix_index in range(QUBITS_NUM):
pauli_matrix = str(pauli_string[matrix_index])
reduced_pauli_matrix = reducing_to_pauli_z_mapping[pauli_matrix]
reduced_pauli_string = reduced_pauli_matrix + reduced_pauli_string
return reduced_pauli_string
def add_layer_of_gates_for_reducing_paulis_to_sigma_z(pauli_string, quantum_circuit):
quantum_registers = QuantumRegister(QUBITS_NUM, name="qubit")
additional_circuit_layer = QuantumCircuit(quantum_registers)
for quantum_register_index, pauli_matrix in enumerate(pauli_string):
if pauli_matrix == "X":
additional_circuit_layer.append(HGate(), [quantum_registers[quantum_register_index]])
if pauli_string == "Y":
additional_circuit_layer.append(HGate(), [quantum_registers[quantum_register_index]])
additional_circuit_layer.append(SGate(), [quantum_registers[quantum_register_index]])
extended_quantum_circuit = quantum_circuit.compose(additional_circuit_layer)
return extended_quantum_circuit
def get_probability_distribution(counts: Dict) -> Dict:
proba_distribution = {state: (count / NUM_SHOTS) for state, count in counts.items()}
return proba_distribution
def calculate_probabilities_of_measurments_in_computational_basis(quantum_state_circuit) -> Dict:
quantum_state_circuit.measure_all()
transpiled_quantum_state_circuit = transpile(quantum_state_circuit, simulator_backend)
Qobj = assemble(transpiled_quantum_state_circuit)
result = simulator_backend.run(Qobj).result()
counts = result.get_counts(quantum_state_circuit)
return get_probability_distribution(counts)
def sort_probas_dict_by_qubits_string_keys(proba_distribution: Dict) -> Dict:
return dict(sorted(proba_distribution.items()))
def reset_power_of_minus_1(power_of_minus_1):
power_of_minus_1 = 0
return power_of_minus_1
def convert_pauli_string_into_str(pauli_string) -> str:
return str(pauli_string)
def calculate_expectation_value_of_pauli_string_by_measurments_probas(pauli_string, ansatz_circuit):
pauli_string_expectation_value = 0
power_of_minus_1 = 0
pauli_string_str = convert_pauli_string_into_str(pauli_string)
extended_ansatz_circuit = add_layer_of_gates_for_reducing_paulis_to_sigma_z(pauli_string_str, ansatz_circuit)
probas_distribution = calculate_probabilities_of_measurments_in_computational_basis(extended_ansatz_circuit)
reduced_pauli_string = reduce_pauli_matrixes_into_sigma_z(pauli_string)
sorted_probas_distribuition = sort_probas_dict_by_qubits_string_keys(probas_distribution)
for qubits_string, proba in sorted_probas_distribuition.items():
for string_index in range(QUBITS_NUM):
if(str(qubits_string[string_index])=="1" and str(pauli_string[string_index])=="Z"):
power_of_minus_1 += 1
pauli_string_expectation_value += pow(-1, power_of_minus_1)*proba
power_of_minus_1 = reset_power_of_minus_1(power_of_minus_1)
return pauli_string_expectation_value
def get_expectation_value(ansatz_circuit, pauli_coeffs, pauli_strings):
total_expection_value = 0
for pauli_coeff, pauli_string in zip(pauli_coeffs, pauli_strings):
total_expection_value += pauli_coeff*calculate_expectation_value_of_pauli_string_by_measurments_probas(
pauli_string, ansatz_circuit)
return total_expection_value
from qiskit import assemble, transpile
def cost_function(thetas, hamiltonian):
circuit_params = prepare_circuit_params(thetas)
computational_eigenvectors = get_first_k_eigenvectors_from_n_computational_basis(K, N)
pauli_coeffs, pauli_strings = transfrom_hamiltonian_into_pauli_strings(hamiltonian)
k_ansatz_state = get_ansatz_state(circuit_params, computational_eigenvectors[K-1])
approximated_energey = get_expectation_value(k_ansatz_state, pauli_coeffs, pauli_strings)
insert_approximated_energy_to_list_of_all_approximated_energies(approximated_energey)
L_w = w*approximated_energey
for j in range(K-1):
ansatz_state = get_ansatz_state(circuit_params, computational_eigenvectors[j])
L_w += get_expectation_value(ansatz_state, pauli_coeffs, pauli_strings)
return L_w
def get_optimal_thetas_of_ansatz_circuit_for_hamiltonian(hamiltonian):
initial_thetas = np.random.uniform(low=0, high=2*np.pi, size=12)
optimizer_result = minimize(cost_function,
x0=initial_thetas,
args=(hamiltonian),
method="COBYLA",
options={"disp": True, "maxiter":NUM_ITERATIONS})
optimal_thetas = prepare_circuit_params(optimizer_result.x)
return optimal_thetas
def get_approximated_eigenvalue_of_hamiltonian(hamiltonian):
optimal_thetas = get_optimal_thetas_of_ansatz_circuit_for_hamiltonian(hamiltonian)
print(optimal_thetas)
computational_eigenvectors = get_first_k_eigenvectors_from_n_computational_basis(K, N)
optimal_ansatz_state = get_ansatz_state(optimal_thetas, computational_eigenvectors[K-1])
pauli_coeffs, pauli_strings = transfrom_hamiltonian_into_pauli_strings(hamiltonian)
approximated_eigenvalue = get_expectation_value(optimal_ansatz_state, pauli_coeffs, pauli_strings)
return approximated_eigenvalue
from numpy import linalg as LA
def get_approximation_error(exact_eigenvalue, approximated_eigenvalue):
return abs(abs(exact_eigenvalue)-abs(approximated_eigenvalue))/abs(exact_eigenvalue)
def get_k_exact_eigenvalue_of_hamiltonian(hamiltonian, k):
eigen_values = LA.eig(hamiltonian.to_matrix())[0]
print(sorted(eigen_values, reverse=True))
return sorted(eigen_values,reverse=True)[k-1]
def compare_exact_and_approximated_eigenvalue(hamiltonian, approximated_eigenvalue):
exact_eigenvalue = get_k_exact_eigenvalue_of_hamiltonian(hamiltonian, K)
print("Exact Eigenvalue:")
print(exact_eigenvalue)
print("Approximated K Eigenvalues:")
print(approximated_eigenvalue)
print("Approximation Error")
print(get_approximation_error(exact_eigenvalue, approximated_eigenvalue))
def insert_approximated_energy_to_list_of_all_approximated_energies(energy):
approximated_energies.append(energy)
import matplotlib.pyplot as plt
def plot_convergence_of_optimization_process(approximated_energies, exact_eigenvalue, margin):
plt.title("convergence of optimization process to the exact eigenvalue")
plt.margins(0, margin)
plt.plot(approximated_energies)
plt.axhline(y = exact_eigenvalue, color = 'r', linestyle = '-')
plt.xlabel("# of iterations")
plt.ylabel("Energy")
def plot_fidelity():
plt.plot(LiH_approximated_energies)
plt.xlabel("# of iterations")
plt.ylabel("Energy")
from qiskit.opflow import X, Z, Y, I, H, S
LiH_molecule_4_qubits = -7.49894690201071*(I^I^I^I) + \
-0.0029329964409502266*(X^X^Y^Y) + \
0.0029329964409502266*(X^Y^Y^X) + \
0.01291078027311749*(X^Z^X^I) + \
-0.0013743761078958677*(X^Z^X^Z) + \
0.011536413200774975*(X^I^X^I) + \
0.0029329964409502266*(Y^X^X^Y) + \
-0.0029329964409502266*(Y^Y^X^X) + \
0.01291078027311749*(Y^Z^Y^I) + \
-0.0013743761078958677*(Y^Z^Y^Z) + \
0.011536413200774975*(Y^I^Y^I) + \
0.16199475388004184*(Z^I^I^I) + \
0.011536413200774975*(Z^X^Z^X) + \
0.011536413200774975*(Z^Y^Z^Y) + \
0.12444770133137588*(Z^Z^I^I) + \
0.054130445793298836*(Z^I^Z^I) + \
0.05706344223424907*(Z^I^I^Z) + \
0.012910780273117487*(I^X^Z^X) + \
-0.0013743761078958677*(I^X^I^X) + \
0.012910780273117487*(I^Y^Z^Y) + \
-0.0013743761078958677*(I^Y^I^Y) + \
0.16199475388004186*(I^Z^I^I) + \
0.05706344223424907*(I^Z^Z^I) + \
0.054130445793298836*(I^Z^I^Z) + \
-0.013243698330265966*(I^I^Z^I) + \
0.08479609543670981*(I^I^Z^Z) + \
-0.013243698330265952*(I^I^I^Z)
%%time
LiH_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(LiH_molecule_4_qubits)
compare_exact_and_approximated_eigenvalue(LiH_molecule_4_qubits, LiH_approximated_eigenvalue)
print(approximated_energies)
approximated_energies = []
LiH_approximated_energies = [-7.6274591415582105, -7.607576828257072, -7.632200935003245, -7.609855196623901, -7.6059250397280795, -7.854597415729809, -7.628956794318834, -7.6784378048763715, -7.640342773091634, -7.665298199108273, -7.4589086431520615, -7.64400728822478, -7.63919074876535, -7.5712982052834015, -7.644638404908841, -7.646954760531615, -7.755301596699023, -7.631831246253383, -7.631061799605215, -7.616310788526333, -7.611576222526171, -7.620105483420993, -7.6417862171136335, -7.589952292685995, -7.610418644012381, -7.674320046442037, -7.61956694546109, -7.627683802497983, -7.623678295984975, -7.617228428549745, -7.633104604686701, -7.629086274819348, -7.595694407363554, -7.617836676264696, -7.617389773769819, -7.634299221424122, -7.598467942904893, -7.630191480144404, -7.63698619980098, -7.623626950424333, -7.612007795510998, -7.6261074907011634, -7.6148982305668405, -7.623709634670492, -7.61204075447679, -7.6106110013026385, -7.620711346718306, -7.618187492707977, -7.612462844967995, -7.623640830688807]
plot_convergence_of_optimization_process(LiH_approximated_energies, exact_eigenvalue=-7.7140566916607005,margin=1)
H2_molecule_Hamiltonian_4_qubits = -0.8105479805373279 * (I^I^I^I) \
+ 0.1721839326191554 * (I^I^I^Z) \
- 0.22575349222402372 * (I^I^Z^I) \
+ 0.17218393261915543 * (I^Z^I^I) \
- 0.2257534922240237 * (Z^I^I^I) \
+ 0.12091263261776627 * (I^I^Z^Z) \
+ 0.16892753870087907 * (I^Z^I^Z) \
+ 0.045232799946057826 * (Y^Y^Y^Y) \
+ 0.045232799946057826 * (X^X^Y^Y) \
+ 0.045232799946057826 * (Y^Y^X^X) \
+ 0.045232799946057826 * (X^X^X^X) \
+ 0.1661454325638241 * (Z^I^I^Z) \
+ 0.1661454325638241 * (I^Z^Z^I) \
+ 0.17464343068300453 * (Z^I^Z^I) \
+ 0.12091263261776627 * (Z^Z^I^I)
%%time
H2_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(H2_molecule_Hamiltonian_4_qubits)
compare_exact_and_approximated_eigenvalue(H2_molecule_Hamiltonian_4_qubits, H2_approximated_eigenvalue)
print(approximated_energies)
approximated_energies = []
H2_approximated_energies = [-1.009976657006965, -0.9238284763706393, -0.9884320852467877, -0.9805917857984984, -1.0167176344158073, -0.803009921527331, -0.4598306468944341, -0.5114890962692614, -0.8589176393087158, -0.9346855734783651, -0.8412382644084648, -0.6224404303456501, -0.653317087612677, -0.7607656559263039, -0.7930275875404521, -0.4281158503125878, -0.5788815212789364, -0.7176165386431208, -0.8701142070097521, -0.8688095826524974, -0.9151572025822381, -0.6635735611840398, -0.6037067550586409, -0.9285839833437391, -0.5058550482270441, -0.9291800596309192, -0.49550483773798376, -0.7464398349372543, -0.9433354608506894, -0.8895971844704103, -0.9048816527272305, -0.8978302385287464, -0.6949574562429168, -0.8304208103551916, -0.4692230966986817, -0.8462497998117152, -0.7185585023635032, -0.8077110062007753, -0.5192275804166049, -0.5640061209546482, -0.8011222125790844, -0.9513753098344495, -0.8402620344123755, -0.6086751350074949, -0.7369530952207817, -0.7603612456563129, -0.7950958666448285, -0.7999579057635281, -0.7706575601258369, -0.7909119439657882]
plot_convergence_of_optimization_process(H2_approximated_energies, exact_eigenvalue=-1.2445845498133272, margin=5)
transverse_ising_4_qubits = 0.0 * (I^I^I^I) \
+ 0.8398088405253477 * (X^I^I^I) \
+ 0.7989496312070936 * (I^X^I^I) \
+ 0.38189710487113193 * (Z^Z^I^I) \
+ 0.057753122422666725 * (I^I^X^I) \
+ 0.5633292636970458 * (Z^I^Z^I) \
+ 0.3152740621483513 * (I^Z^Z^I) \
+ 0.07209487981989715 * (I^I^I^X) \
+ 0.17892334004292654 * (Z^I^I^Z) \
+ 0.2273896497668042 * (I^Z^I^Z) \
+ 0.09762902934216211 * (I^I^Z^Z)
%%time
TI_approximated_eigen_value = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_4_qubits)
compare_exact_and_approximated_eigenvalue(transverse_ising_4_qubits, TI_approximated_eigen_value)
print(approximated_energies)
approximated_energies = []
TI_approximated_energies = [1.0877911566875362, 1.3339897771771856, 1.1497195956414945, 1.3463775026022828, 1.1824868775928117, 1.6423958284840114, 1.5842407965410792, 1.6377219801098, 1.5250316270225506, 1.626129653972439, 1.3560460449434424, 1.6695319025733455, 1.6842571288891142, 1.5407570120203158, 1.5187677867233031, 1.4564666271629088, 1.7323725293893963, 1.792109013228278, 1.7481282811675565, 1.8139670143156743, 1.6629383661129478, 1.68337823955209, 1.4848944286809986, 1.4845001982657569, 1.6129182843066505, 1.6625400070359255, 1.6104761870181472, 1.7152744787413363, 1.6678413737920048, 1.6869395320619605, 1.6590487040095492, 1.6723344557176432, 1.627252139576561, 1.6998615622327233, 1.6227578573441954, 1.6709380388303952, 1.747587311276882, 1.7146592410359045, 1.7219455615683754, 1.6503664867345986, 1.7349602602365404, 1.767898541795154, 1.7803996165862503, 1.6955748077929296, 1.7174656756704858, 1.715728620581076, 1.7002352954018423, 1.7436412571902764, 1.6757447332820925, 1.7032804122037015]
plot_convergence_of_optimization_process(TI_approximated_energies, exact_eigenvalue=-1.7583827504312988, margin=3)
|
https://github.com/MonitSharma/Qiskit-Summer-School-and-Quantum-Challenges
|
MonitSharma
|
from qiskit import *
from qiskit.visualization import plot_histogram
import numpy as np
def NOT(inp):
"""An NOT gate.
Parameters:
inp (str): Input, encoded in qubit 0.
Returns:
QuantumCircuit: Output NOT circuit.
str: Output value measured from qubit 0.
"""
qc = QuantumCircuit(1, 1) # A quantum circuit with a single qubit and a single classical bit
qc.reset(0)
# We encode '0' as the qubit state |0⟩, and '1' as |1⟩
# Since the qubit is initially |0⟩, we don't need to do anything for an input of '0'
# For an input of '1', we do an x to rotate the |0⟩ to |1⟩
if inp=='1':
qc.x(0)
# barrier between input state and gate operation
qc.barrier()
# Now we've encoded the input, we can do a NOT on it using x
qc.x(0)
#barrier between gate operation and measurement
qc.barrier()
# Finally, we extract the |0⟩/|1⟩ output of the qubit and encode it in the bit c[0]
qc.measure(0,0)
qc.draw()
# We'll run the program on a simulator
backend = Aer.get_backend('qasm_simulator')
# Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc, shots=1, memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp in ['0', '1']:
qc, out = NOT(inp)
print('NOT with input',inp,'gives output',out)
display(qc.draw())
print('\n')
def XOR(inp1,inp2):
"""An XOR gate.
Parameters:
inpt1 (str): Input 1, encoded in qubit 0.
inpt2 (str): Input 2, encoded in qubit 1.
Returns:
QuantumCircuit: Output XOR circuit.
str: Output value measured from qubit 1.
"""
qc = QuantumCircuit(2, 1)
qc.reset(range(2))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
# barrier between input state and gate operation
qc.barrier()
# this is where your program for quantum XOR gate goes
qc.cx(0, 1)
# barrier between input state and gate operation
qc.barrier()
qc.measure(1,0) # output from qubit 1 is measured
#We'll run the program on a simulator
backend = Aer.get_backend('qasm_simulator')
#Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc, shots=1, memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp1 in ['0', '1']:
for inp2 in ['0', '1']:
qc, output = XOR(inp1, inp2)
print('XOR with inputs',inp1,inp2,'gives output',output)
display(qc.draw())
print('\n')
def AND(inp1,inp2):
"""An AND gate.
Parameters:
inpt1 (str): Input 1, encoded in qubit 0.
inpt2 (str): Input 2, encoded in qubit 1.
Returns:
QuantumCircuit: Output XOR circuit.
str: Output value measured from qubit 2.
"""
qc = QuantumCircuit(3, 1)
qc.reset(range(2))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
qc.barrier()
# this is where your program for quantum AND gate goes
qc.ccx(0,1,2)
qc.barrier()
qc.measure(2, 0) # output from qubit 2 is measured
# We'll run the program on a simulator
backend = Aer.get_backend('qasm_simulator')
# Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc, shots=1, memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp1 in ['0', '1']:
for inp2 in ['0', '1']:
qc, output = AND(inp1, inp2)
print('AND with inputs',inp1,inp2,'gives output',output)
display(qc.draw())
print('\n')
def NAND(inp1,inp2):
"""An NAND gate.
Parameters:
inpt1 (str): Input 1, encoded in qubit 0.
inpt2 (str): Input 2, encoded in qubit 1.
Returns:
QuantumCircuit: Output NAND circuit.
str: Output value measured from qubit 2.
"""
qc = QuantumCircuit(3, 1)
qc.reset(range(3))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
qc.barrier()
# this is where your program for quantum NAND gate goes
qc.ccx(0,1,2)
if inp=='1':
qc.x(2)
qc.barrier()
qc.measure(2, 0) # output from qubit 2 is measured
# We'll run the program on a simulator
backend = Aer.get_backend('aer_simulator')
# Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc,shots=1,memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp1 in ['0', '1']:
for inp2 in ['0', '1']:
qc, output = NAND(inp1, inp2)
print('NAND with inputs',inp1,inp2,'gives output',output)
display(qc.draw())
print('\n')
def OR(inp1,inp2):
"""An OR gate.
Parameters:
inpt1 (str): Input 1, encoded in qubit 0.
inpt2 (str): Input 2, encoded in qubit 1.
Returns:
QuantumCircuit: Output XOR circuit.
str: Output value measured from qubit 2.
"""
qc = QuantumCircuit(3, 1)
qc.reset(range(3))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
qc.barrier()
# this is where your program for quantum OR gate goes
qc.cx(0, 2)
qc.cx(1, 2)
qc.barrier()
qc.measure(2, 0) # output from qubit 2 is measured
# We'll run the program on a simulator
backend = Aer.get_backend('aer_simulator')
# Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc,shots=1,memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp1 in ['0', '1']:
for inp2 in ['0', '1']:
qc, output = OR(inp1, inp2)
print('OR with inputs',inp1,inp2,'gives output',output)
display(qc.draw())
print('\n')
from qiskit import IBMQ
#IBMQ.save_account("a68a35747d4eccd1d58f275e637909987c789ce5c0edd8a4f43014672bf0301b54b28b1b5f44ba8ff87500777429e1e4ceb79621a6ba248d6cca6bca0e233d23", overwrite=True)
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider('ibm-q')
provider.backends()
import qiskit.tools.jupyter
# run this cell
backend = provider.get_backend('ibmq_quito')
qc_and = QuantumCircuit(3)
qc_and.ccx(0,1,2)
print('AND gate')
display(qc_and.draw())
print('\n\nTranspiled AND gate with all the required connectivity')
qc_and.decompose().draw()
from qiskit.tools.monitor import job_monitor
# run the cell to define AND gate for real quantum system
def AND(inp1, inp2, backend, layout):
qc = QuantumCircuit(3, 1)
qc.reset(range(3))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
qc.barrier()
qc.ccx(0, 1, 2)
qc.barrier()
qc.measure(2, 0)
qc_trans = transpile(qc, backend, initial_layout=layout, optimization_level=3)
job = backend.run(qc_trans, shots=8192)
print(job.job_id())
job_monitor(job)
output = job.result().get_counts()
return qc_trans, output
backend
layout = [0, 1, 2]
output_all = []
qc_trans_all = []
prob_all = []
worst = 1
best = 0
for input1 in ['0','1']:
for input2 in ['0','1']:
qc_trans, output = AND(input1, input2, backend, layout)
output_all.append(output)
qc_trans_all.append(qc_trans)
prob = output[str(int( input1=='1' and input2=='1' ))]/8192
prob_all.append(prob)
print('\nProbability of correct answer for inputs',input1,input2)
print('{:.2f}'.format(prob) )
print('---------------------------------')
worst = min(worst,prob)
best = max(best, prob)
print('')
print('\nThe highest of these probabilities was {:.2f}'.format(best))
print('The lowest of these probabilities was {:.2f}'.format(worst))
print('Transpiled AND gate circuit for ibmq_vigo with input 0 0')
print('\nThe circuit depth : {}'.format (qc_trans_all[0].depth()))
print('# of nonlocal gates : {}'.format (qc_trans_all[0].num_nonlocal_gates()))
print('Probability of correct answer : {:.2f}'.format(prob_all[0]) )
qc_trans_all[0].draw()
print('Transpiled AND gate circuit for ibmq_vigo with input 0 1')
print('\nThe circuit depth : {}'.format (qc_trans_all[1].depth()))
print('# of nonlocal gates : {}'.format (qc_trans_all[1].num_nonlocal_gates()))
print('Probability of correct answer : {:.2f}'.format(prob_all[1]) )
qc_trans_all[1].draw()
print('Transpiled AND gate circuit for ibmq_vigo with input 1 0')
print('\nThe circuit depth : {}'.format (qc_trans_all[2].depth()))
print('# of nonlocal gates : {}'.format (qc_trans_all[2].num_nonlocal_gates()))
print('Probability of correct answer : {:.2f}'.format(prob_all[2]) )
qc_trans_all[2].draw()
print('Transpiled AND gate circuit for ibmq_vigo with input 1 1')
print('\nThe circuit depth : {}'.format (qc_trans_all[3].depth()))
print('# of nonlocal gates : {}'.format (qc_trans_all[3].num_nonlocal_gates()))
print('Probability of correct answer : {:.2f}'.format(prob_all[3]) )
qc_trans_all[3].draw()
|
https://github.com/qiskit-community/prototype-entanglement-forging
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
""" Weighted Pauli Operator """
import itertools
import json
import logging
import sys
from copy import deepcopy
from operator import add as op_add, sub as op_sub
from typing import List, Optional, Tuple, Union
import numpy as np
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
from qiskit.algorithms import AlgorithmError
from qiskit.quantum_info import Pauli
from qiskit.tools import parallel_map
from qiskit.tools.events import TextProgressBar
from qiskit.utils import algorithm_globals
from .base_operator import LegacyBaseOperator
from .common import (
measure_pauli_z,
covariance,
pauli_measurement,
suzuki_expansion_slice_pauli_list,
check_commutativity,
evolution_instruction,
)
logger = logging.getLogger(__name__)
# pylint: disable=invalid-name,too-many-lines,too-many-arguments,protected-access,no-else-return,too-many-locals
# pylint: disable=too-many-branches,too-many-public-methods
# pylint: disable=duplicate-code
class WeightedPauliOperator(LegacyBaseOperator):
"""Weighted Pauli Operator"""
def __init__(
self,
paulis: List[List[Union[complex, Pauli]]],
basis: Optional[List[Tuple[object, List[int]]]] = None,
z2_symmetries: "Z2Symmetries" = None,
atol: float = 1e-12,
name: Optional[str] = None,
) -> None:
"""
Args:
paulis: the list of weighted Paulis, where a weighted pauli is
composed of a length-2 list and the first item is the
weight and the second item is the Pauli object.
basis: the grouping basis, each element is a tuple composed of the basis
and the indices to paulis which belong to that group.
e.g., if tpb basis is used, the object will be a pauli.
By default, the group is equal to non-grouping, each pauli is its own basis.
z2_symmetries: recording the z2 symmetries info
atol: the threshold used in truncating paulis
name: the name of operator.
"""
super().__init__(basis, z2_symmetries, name)
# plain store the paulis, the group information is store in the basis
self._paulis_table = None
self._paulis = paulis
self._basis = (
[(pauli[1], [i]) for i, pauli in enumerate(paulis)]
if basis is None
else basis
)
# combine the paulis and remove those with zero weight
self.simplify()
self._atol = atol
@classmethod
def from_list(cls, paulis, weights=None, name=None):
"""
Create a WeightedPauliOperator via a pair of list.
Args:
paulis (list[Pauli]): the list of Paulis
weights (list[complex], optional): the list of weights,
if it is None, all weights are 1.
name (str, optional): name of the operator.
Returns:
WeightedPauliOperator: operator
Raises:
ValueError: The length of weights and paulis must be the same
"""
if weights is not None and len(weights) != len(paulis):
raise ValueError("The length of weights and paulis must be the same.")
if weights is None:
weights = [1.0] * len(paulis)
return cls(paulis=[[w, p] for w, p in zip(weights, paulis)], name=name)
# pylint: disable=arguments-differ
def to_opflow(self, reverse_endianness=False):
"""to op flow"""
# pylint: disable=import-outside-toplevel
from qiskit.opflow import PrimitiveOp
pauli_ops = []
for [w, p] in self.paulis:
pauli = Pauli(str(p)[::-1]) if reverse_endianness else p
# This weighted pauli operator has the coeff stored as a complex type
# irrespective of whether the value has any imaginary part or not.
# For many operators the coeff will be real. Hence below the coeff is made real,
# when creating the PrimitiveOp, since it can be stored then as a float, if its
# value is real, i.e. has no imaginary part. This avoids any potential issues around
# complex - but if there are complex coeffs then maybe that using the opflow
# later will fail if it happens to be used where complex is not supported.
# Now there are imaginary coefficients in UCCSD that would need to be handled
# when this is converted to opflow (evolution of hopping operators) where currently
# Terra does not handle complex.
# TODO fix these or add support for them in Terra # pylint: disable=fixme
coeff = np.real(w) if np.isreal(w) else w
pauli_ops += [PrimitiveOp(pauli, coeff=coeff)]
return sum(pauli_ops)
@property
def paulis(self):
"""get paulis"""
return self._paulis
@property
def atol(self):
"""get atol"""
return self._atol
@atol.setter
def atol(self, new_value):
"""set atol"""
self._atol = new_value
@property
def num_qubits(self):
"""
Number of qubits required for the operator.
Returns:
int: number of qubits
"""
if not self.is_empty():
res = self._paulis[0][1].num_qubits
else:
logger.warning("Operator is empty, Return 0.")
res = 0
return res
def __eq__(self, other):
"""Overload == operation"""
# need to clean up the zeros
self.simplify()
other.simplify()
if len(self._paulis) != len(other.paulis):
return False
for weight, pauli in self._paulis:
found_pauli = False
other_weight = 0.0
for weight2, pauli2 in other.paulis:
if pauli == pauli2:
found_pauli = True
other_weight = weight2
break
if (
not found_pauli and other_weight != 0.0
): # since we might have 0 weights of paulis.
return False
if weight != other_weight:
return False
return True
def _add_or_sub(self, other, operation, copy=True):
"""
Add two operators either extend (in-place) or combine (copy) them.
The addition performs optimized combination of two operators.
If `other` has identical basis, the coefficient are combined rather than
appended.
Args:
other (WeightedPauliOperator): to-be-combined operator
operation (callable or str): add or sub callable from operator
copy (bool): working on a copy or self
Returns:
WeightedPauliOperator: operator
Raises:
AlgorithmError: two operators have different number of qubits.
"""
if not self.is_empty() and not other.is_empty():
if self.num_qubits != other.num_qubits:
raise AlgorithmError(
"Can not add/sub two operators " "with different number of qubits."
)
ret_op = self.copy() if copy else self
for pauli in other.paulis:
pauli_label = pauli[1].to_label()
idx = ret_op._paulis_table.get(pauli_label, None)
if idx is not None:
ret_op._paulis[idx][0] = operation(ret_op._paulis[idx][0], pauli[0])
else:
new_pauli = deepcopy(pauli)
ret_op._paulis_table[pauli_label] = len(ret_op._paulis)
ret_op._basis.append((new_pauli[1], [len(ret_op._paulis)]))
new_pauli[0] = operation(0.0, pauli[0])
ret_op._paulis.append(new_pauli)
return ret_op
def add(self, other, copy=False):
"""
Perform self + other.
Args:
other (WeightedPauliOperator): to-be-combined operator
copy (bool): working on a copy or self, if False, the results are written back to self.
Returns:
WeightedPauliOperator: operator
"""
return self._add_or_sub(other, op_add, copy=copy)
def sub(self, other, copy=False):
"""
Perform self - other.
Args:
other (WeightedPauliOperator): to-be-combined operator
copy (bool): working on a copy or self, if False, the results are written back to self.
Returns:
WeightedPauliOperator: operator
"""
return self._add_or_sub(other, op_sub, copy=copy)
def __add__(self, other):
"""Overload + operator"""
return self.add(other, copy=True)
def __iadd__(self, other):
"""Overload += operator"""
return self.add(other, copy=False)
def __sub__(self, other):
"""Overload - operator"""
return self.sub(other, copy=True)
def __isub__(self, other):
"""Overload -= operator"""
return self.sub(other, copy=False)
def _scaling_weight(self, scaling_factor, copy=False):
"""
Constantly scaling all weights of paulis.
Args:
scaling_factor (complex): the scaling factor
copy (bool): return a copy or modify in-place
Returns:
WeightedPauliOperator: a copy of the scaled one.
Raises:
ValueError: the scaling factor is not a valid type.
"""
if not isinstance(scaling_factor, (int, float, complex)):
raise ValueError(
f"Type of scaling factor is a valid type. {scaling_factor.__class__} if given."
)
ret = self.copy() if copy else self
for idx in range(len(ret._paulis)): # pylint: disable=consider-using-enumerate
ret._paulis[idx] = [
ret._paulis[idx][0] * scaling_factor,
ret._paulis[idx][1],
]
return ret
def multiply(self, other):
"""
Perform self * other, and the phases are tracked.
Args:
other (WeightedPauliOperator): an operator
Returns:
WeightedPauliOperator: the multiplied operator
"""
ret_op = WeightedPauliOperator(paulis=[])
for existed_weight, existed_pauli in self.paulis:
for weight, pauli in other.paulis:
p = existed_pauli.dot(pauli)
new_pauli, sign = p[:], (-1j) ** p.phase
new_weight = existed_weight * weight * sign
pauli_term = [new_weight, new_pauli]
ret_op += WeightedPauliOperator(paulis=[pauli_term])
return ret_op
def __rmul__(self, other):
"""Overload other * self"""
if isinstance(other, (int, float, complex)):
return self._scaling_weight(other, copy=True)
else:
return other.multiply(self)
def __mul__(self, other):
"""Overload self * other"""
if isinstance(other, (int, float, complex)):
return self._scaling_weight(other, copy=True)
else:
return self.multiply(other)
def __neg__(self):
"""Overload unary -"""
return self._scaling_weight(-1.0, copy=True)
def __str__(self):
"""Overload str()"""
curr_repr = "paulis"
length = len(self._paulis)
name = "" if self._name == "" else f"{self._name}: "
ret = f"{name}Representation: {curr_repr}, qubits: {self.num_qubits}, size: {length}"
return ret
def print_details(self):
"""
Print out the operator in details.
Returns:
str: a formatted string describes the operator.
"""
if self.is_empty():
return "Operator is empty."
ret = ""
for weight, pauli in self._paulis:
ret = "".join([ret, f"{pauli.to_label()}\t{weight}\n"])
return ret
def copy(self):
"""Get a copy of self"""
return deepcopy(self)
def simplify(self, copy=False):
"""
Merge the paulis whose bases are identical and the pauli with zero coefficient
would be removed.
Note:
This behavior of this method is slightly changed,
it will remove the paulis whose weights are zero.
Args:
copy (bool): simplify on a copy or self
Returns:
WeightedPauliOperator: the simplified operator
"""
op = self.copy() if copy else self
new_paulis = []
new_paulis_table = {}
old_to_new_indices = {}
curr_idx = 0
for curr_weight, curr_pauli in op.paulis:
pauli_label = curr_pauli.to_label()
new_idx = new_paulis_table.get(pauli_label, None)
if new_idx is not None:
new_paulis[new_idx][0] += curr_weight
old_to_new_indices[curr_idx] = new_idx
else:
new_paulis_table[pauli_label] = len(new_paulis)
old_to_new_indices[curr_idx] = len(new_paulis)
new_paulis.append([curr_weight, curr_pauli])
curr_idx += 1
op._paulis = new_paulis
op._paulis_table = new_paulis_table
# update the grouping info, since this method only reduce the number
# of paulis, we can handle it here for both
# pauli and tpb grouped pauli
# should have a better way to rebuild the basis here.
new_basis = []
for basis, indices in op.basis:
new_indices = []
found = False
if new_basis:
for b, ind in new_basis:
if b == basis:
new_indices = ind
found = True
break
for idx in indices:
new_idx = old_to_new_indices[idx]
if new_idx is not None and new_idx not in new_indices:
new_indices.append(new_idx)
if new_indices and not found:
new_basis.append((basis, new_indices))
op._basis = new_basis
op.chop(0.0)
return op
def rounding(self, decimals, copy=False):
"""
Rounding the weight.
Args:
decimals (int): rounding the weight to the decimals.
copy (bool): chop on a copy or self
Returns:
WeightedPauliOperator: operator
"""
op = self.copy() if copy else self
op._paulis = [
[np.around(weight, decimals=decimals), pauli] for weight, pauli in op.paulis
]
return op
def chop(self, threshold=None, copy=False):
"""
Eliminate the real and imagine part of weight in each pauli by `threshold`.
If pauli's weight is less then `threshold` in both real and imaginary parts,
the pauli is removed.
Note:
If weight is real-only, the imaginary part is skipped.
Args:
threshold (float): the threshold is used to remove the paulis
copy (bool): chop on a copy or self
Returns:
WeightedPauliOperator: if copy is True, the original operator is unchanged; otherwise,
the operator is mutated.
"""
threshold = self._atol if threshold is None else threshold
def chop_real_imag(weight):
temp_real = weight.real if np.absolute(weight.real) >= threshold else 0.0
temp_imag = weight.imag if np.absolute(weight.imag) >= threshold else 0.0
if temp_real == 0.0 and temp_imag == 0.0:
return 0.0
else:
new_weight = temp_real + 1j * temp_imag
return new_weight
op = self.copy() if copy else self
if op.is_empty():
return op
paulis = []
old_to_new_indices = {}
curr_idx = 0
for idx, weighted_pauli in enumerate(op.paulis):
weight, pauli = weighted_pauli
new_weight = chop_real_imag(weight)
if new_weight != 0.0:
old_to_new_indices[idx] = curr_idx
curr_idx += 1
paulis.append([new_weight, pauli])
op._paulis = paulis
op._paulis_table = {
weighted_pauli[1].to_label(): i for i, weighted_pauli in enumerate(paulis)
}
# update the grouping info, since this method only remove pauli,
# we can handle it here for both
# pauli and tpb grouped pauli
new_basis = []
for basis, indices in op.basis:
new_indices = []
for idx in indices:
new_idx = old_to_new_indices.get(idx, None)
if new_idx is not None:
new_indices.append(new_idx)
if new_indices:
new_basis.append((basis, new_indices))
op._basis = new_basis
return op
def commute_with(self, other):
"""Commutes with"""
return check_commutativity(self, other)
def anticommute_with(self, other):
"""Anti commutes with"""
return check_commutativity(self, other, anti=True)
def is_empty(self):
"""
Check Operator is empty or not.
Returns:
bool: True if empty, False otherwise
"""
if not self._paulis:
return True
elif not self._paulis[0]:
return True
else:
return False
@classmethod
def from_file(cls, file_name, before_04=False):
"""
Load paulis in a file to construct an Operator.
Args:
file_name (str): path to the file, which contains a list of Paulis and coefficients.
before_04 (bool): support the format before Aqua 0.4.
Returns:
WeightedPauliOperator: the loaded operator.
"""
with open(file_name, "r", encoding="UTF-8") as file:
return cls.from_dict(json.load(file), before_04=before_04)
def to_file(self, file_name):
"""
Save operator to a file in pauli representation.
Args:
file_name (str): path to the file
"""
with open(file_name, "w", encoding="UTF-8") as file:
json.dump(self.to_dict(), file)
@classmethod
def from_dict(cls, dictionary, before_04=False):
"""
Load paulis from a dictionary to construct an Operator. The dictionary must
comprise the key 'paulis' having a value which is an array of pauli dicts.
Each dict in this array must be represented by label and coeff (real and imag)
such as in the following example:
.. code-block:: python
{'paulis':
[
{'label': 'IIII',
'coeff': {'real': -0.33562957575267038, 'imag': 0.0}},
{'label': 'ZIII',
'coeff': {'real': 0.28220597164664896, 'imag': 0.0}},
...
]
}
Args:
dictionary (dict): dictionary, which contains a list of Paulis and coefficients.
before_04 (bool): support the format before Aqua 0.4.
Returns:
WeightedPauliOperator: the operator created from the input dictionary.
Raises:
AlgorithmError: Invalid dictionary
"""
if "paulis" not in dictionary:
raise AlgorithmError('Dictionary missing "paulis" key')
paulis = []
for op in dictionary["paulis"]:
if "label" not in op:
raise AlgorithmError('Dictionary missing "label" key')
pauli_label = op["label"]
if "coeff" not in op:
raise AlgorithmError('Dictionary missing "coeff" key')
pauli_coeff = op["coeff"]
if "real" not in pauli_coeff:
raise AlgorithmError('Dictionary missing "real" key')
coeff = pauli_coeff["real"]
if "imag" in pauli_coeff:
coeff = complex(pauli_coeff["real"], pauli_coeff["imag"])
pauli_label = pauli_label[::-1] if before_04 else pauli_label
paulis.append([coeff, Pauli(pauli_label)])
return cls(paulis=paulis)
def to_dict(self):
"""
Save operator to a dict in pauli representation.
Returns:
dict: a dictionary contains an operator with pauli representation.
"""
ret_dict = {"paulis": []}
for coeff, pauli in self._paulis:
op = {"label": pauli.to_label()}
if isinstance(coeff, complex):
op["coeff"] = {"real": np.real(coeff), "imag": np.imag(coeff)}
else:
op["coeff"] = {"real": coeff}
ret_dict["paulis"].append(op)
return ret_dict
# pylint: disable=arguments-differ
def construct_evaluation_circuit(
self,
wave_function,
statevector_mode,
qr=None,
cr=None,
use_simulator_snapshot_mode=False,
circuit_name_prefix="",
):
r"""
Construct the circuits for evaluation, which calculating the expectation <psi\|H\|psi>.
At statevector mode: to simplify the computation, we do not build the whole
circuit for <psi|H|psi>, instead of
that we construct an individual circuit <psi\|, and a bundle circuit for H\|psi>
Args:
wave_function (QuantumCircuit): the quantum circuit.
statevector_mode (bool): indicate which type of simulator are going to use.
qr (QuantumRegister, optional): the quantum register associated with the input_circuit
cr (ClassicalRegister, optional): the classical register associated
with the input_circuit
use_simulator_snapshot_mode (bool, optional): if aer_provider is used, we can do faster
evaluation for pauli mode on
statevector simulation
circuit_name_prefix (str, optional): a prefix of circuit name
Returns:
list[QuantumCircuit]: a list of quantum circuits and each circuit with a unique name:
circuit_name_prefix + Pauli string
Raises:
AlgorithmError: if Operator is empty
AlgorithmError: if quantum register is not provided explicitly and
cannot find quantum register with `q` as the name
AlgorithmError: The provided qreg is not in the wave_function
"""
if self.is_empty():
raise AlgorithmError("Operator is empty, check the operator.")
# pylint: disable=import-outside-toplevel
from qiskit.utils.run_circuits import find_regs_by_name
if qr is None:
qr = find_regs_by_name(wave_function, "q")
if qr is None:
raise AlgorithmError(
"Either provide the quantum register "
"(qreg) explicitly or use `q` as the name "
"of the quantum register in the input circuit."
)
else:
if not wave_function.has_register(qr):
raise AlgorithmError(
"The provided QuantumRegister (qreg) is not in the circuit."
)
n_qubits = self.num_qubits
instructions = self.evaluation_instruction(
statevector_mode, use_simulator_snapshot_mode
)
circuits = []
if use_simulator_snapshot_mode:
circuit = wave_function.copy(name=circuit_name_prefix + "snapshot_mode")
# Add expectation value snapshot instruction
instr = instructions.get("expval_snapshot", None)
if instr is not None:
circuit.append(instr, qr)
circuits.append(circuit)
elif statevector_mode:
circuits.append(wave_function.copy(name=circuit_name_prefix + "psi"))
for _, pauli in self._paulis:
inst = instructions.get(pauli.to_label(), None)
if inst is not None:
circuit = wave_function.copy(
name=circuit_name_prefix + pauli.to_label()
)
circuit.append(inst, qr)
circuits.append(circuit)
else:
base_circuit = wave_function.copy()
if cr is not None:
if not base_circuit.has_register(cr):
base_circuit.add_register(cr)
else:
cr = find_regs_by_name(base_circuit, "c", qreg=False)
if cr is None:
cr = ClassicalRegister(n_qubits, name="c")
base_circuit.add_register(cr)
for basis, _ in self._basis:
circuit = base_circuit.copy(name=circuit_name_prefix + basis.to_label())
circuit.append(instructions[basis.to_label()], qargs=qr, cargs=cr)
circuits.append(circuit)
return circuits
def evaluation_instruction(
self, statevector_mode, use_simulator_snapshot_mode=False
):
"""
Args:
statevector_mode (bool): will it be run on statevector simulator or not
use_simulator_snapshot_mode (bool): will it use qiskit aer simulator operator mode
Returns:
dict: Pauli-instruction pair.
Raises:
AlgorithmError: if Operator is empty
MissingOptionalLibraryError: qiskit-aer not installed
"""
if self.is_empty():
raise AlgorithmError("Operator is empty, check the operator.")
instructions = {}
qr = QuantumRegister(self.num_qubits)
qc = QuantumCircuit(qr)
if statevector_mode:
for _, pauli in self._paulis:
tmp_qc = qc.copy(name="Pauli " + pauli.to_label())
if np.all(np.logical_not(pauli.z)) and np.all(
np.logical_not(pauli.x)
): # all I
continue
# This explicit barrier is needed for statevector simulator since Qiskit-terra
# will remove global phase at default compilation level but the results here
# rely on global phase.
tmp_qc.barrier(list(range(self.num_qubits)))
tmp_qc.append(pauli.to_instruction(), list(range(self.num_qubits)))
instructions[pauli.to_label()] = tmp_qc.to_instruction()
else:
cr = ClassicalRegister(self.num_qubits)
qc.add_register(cr)
for basis, _ in self._basis:
tmp_qc = qc.copy(name="Pauli " + basis.to_label())
tmp_qc = pauli_measurement(tmp_qc, basis, qr, cr, barrier=True)
instructions[basis.to_label()] = tmp_qc.to_instruction()
return instructions
# pylint: disable=arguments-differ
def evaluate_with_result(
self,
result,
statevector_mode,
use_simulator_snapshot_mode=False,
circuit_name_prefix="",
):
"""
This method can be only used with the circuits generated by the
:meth:`construct_evaluation_circuit` method with the same `circuit_name_prefix`
name since the circuit names are tied to some meanings.
Calculate the evaluated value with the measurement results.
Args:
result (qiskit.Result): the result from the backend.
statevector_mode (bool): indicate which type of simulator are used.
use_simulator_snapshot_mode (bool): if aer_provider is used, we can do faster
evaluation for pauli mode on
statevector simulation
circuit_name_prefix (str): a prefix of circuit name
Returns:
float: the mean value
float: the standard deviation
Raises:
AlgorithmError: if Operator is empty
"""
if self.is_empty():
raise AlgorithmError("Operator is empty, check the operator.")
avg, std_dev, variance = 0.0, 0.0, 0.0
if use_simulator_snapshot_mode:
snapshot_data = result.data(circuit_name_prefix + "snapshot_mode")[
"snapshots"
]
avg = snapshot_data["expectation_value"]["expval"][0]["value"]
if isinstance(avg, (list, tuple)):
# Aer versions before 0.4 use a list snapshot format
# which must be converted to a complex value.
avg = avg[0] + 1j * avg[1]
elif statevector_mode:
quantum_state = np.asarray(
result.get_statevector(circuit_name_prefix + "psi")
)
for weight, pauli in self._paulis:
# all I
if np.all(np.logical_not(pauli.z)) and np.all(np.logical_not(pauli.x)):
avg += weight
else:
quantum_state_i = result.get_statevector(
circuit_name_prefix + pauli.to_label()
)
avg += weight * (np.vdot(quantum_state, quantum_state_i))
else:
if logger.isEnabledFor(logging.DEBUG):
logger.debug("Computing the expectation from measurement results:")
TextProgressBar(sys.stderr)
# pick the first result to get the total number of shots
num_shots = sum(list(result.get_counts(0).values()))
results = parallel_map(
WeightedPauliOperator._routine_compute_mean_and_var,
[
(
[self._paulis[idx] for idx in indices],
result.get_counts(circuit_name_prefix + basis.to_label()),
)
for basis, indices in self._basis
],
num_processes=algorithm_globals.num_processes,
)
for res in results:
avg += res[0]
variance += res[1]
std_dev = np.sqrt(variance / num_shots)
return avg, std_dev
@staticmethod
def _routine_compute_mean_and_var(args):
paulis, measured_results = args
avg_paulis = []
avg = 0.0
variance = 0.0
for weight, pauli in paulis:
observable = measure_pauli_z(measured_results, pauli)
avg += weight * observable
avg_paulis.append(observable)
for idx_1, weighted_pauli_1 in enumerate(paulis):
weight_1, pauli_1 = weighted_pauli_1
for idx_2, weighted_pauli_2 in enumerate(paulis):
weight_2, pauli_2 = weighted_pauli_2
variance += (
weight_1
* weight_2
* covariance(
measured_results,
pauli_1,
pauli_2,
avg_paulis[idx_1],
avg_paulis[idx_2],
)
)
return avg, variance
def reorder_paulis(self) -> List[List[Union[complex, Pauli]]]:
"""
Reorder the paulis based on the basis and return the reordered paulis.
Returns:
the ordered paulis based on the basis.
"""
# if each pauli belongs to its group, no reordering it needed.
if len(self._basis) == len(self._paulis):
return self._paulis
paulis = []
new_basis = []
curr_count = 0
for basis, indices in self._basis:
sub_paulis = []
for idx in indices:
sub_paulis.append(self._paulis[idx])
new_basis.append((basis, range(curr_count, curr_count + len(sub_paulis))))
paulis.extend(sub_paulis)
curr_count += len(sub_paulis)
self._paulis = paulis
self._basis = new_basis
return self._paulis
# pylint: disable=arguments-differ
def evolve(
self,
state_in=None,
evo_time=0,
num_time_slices=1,
quantum_registers=None,
expansion_mode="trotter",
expansion_order=1,
):
"""
Carry out the eoh evolution for the operator under supplied specifications.
Args:
state_in (QuantumCircuit): a circuit describes the input state
evo_time (Union(complex, float, Parameter, ParameterExpression)): The evolution time
num_time_slices (int): The number of time slices for the expansion
quantum_registers (QuantumRegister): The QuantumRegister to build
the QuantumCircuit off of
expansion_mode (str): The mode under which the expansion is to be done.
Currently support 'trotter', which follows the expansion as discussed in
http://science.sciencemag.org/content/273/5278/1073,
and 'suzuki', which corresponds to the discussion in
https://arxiv.org/pdf/quant-ph/0508139.pdf
expansion_order (int): The order for suzuki expansion
Returns:
QuantumCircuit: The constructed circuit.
Raises:
AlgorithmError: quantum_registers must be in the provided state_in circuit
AlgorithmError: if operator is empty
"""
if self.is_empty():
raise AlgorithmError("Operator is empty, can not evolve.")
if state_in is not None and quantum_registers is not None:
if not state_in.has_register(quantum_registers):
raise AlgorithmError(
"quantum_registers must be in the provided state_in circuit."
)
elif state_in is None and quantum_registers is None:
quantum_registers = QuantumRegister(self.num_qubits)
qc = QuantumCircuit(quantum_registers)
elif state_in is not None and quantum_registers is None:
# assuming the first register is for evolve
quantum_registers = state_in.qregs[0]
qc = QuantumCircuit() + state_in
else:
qc = QuantumCircuit(quantum_registers)
instruction = self.evolve_instruction(
evo_time, num_time_slices, expansion_mode, expansion_order
)
qc.append(instruction, quantum_registers)
return qc
def evolve_instruction(
self, evo_time=0, num_time_slices=1, expansion_mode="trotter", expansion_order=1
):
"""
Carry out the eoh evolution for the operator under supplied specifications.
Args:
evo_time (Union(complex, float, Parameter, ParameterExpression)): The evolution time
num_time_slices (int): The number of time slices for the expansion
expansion_mode (str): The mode under which the expansion is to be done.
Currently support 'trotter', which follows the expansion as discussed in
http://science.sciencemag.org/content/273/5278/1073,
and 'suzuki', which corresponds to the discussion in
https://arxiv.org/pdf/quant-ph/0508139.pdf
expansion_order (int): The order for suzuki expansion
Returns:
QuantumCircuit: The constructed QuantumCircuit.
Raises:
ValueError: Number of time slices should be a non-negative integer
NotImplementedError: expansion mode not supported
AlgorithmError: if operator is empty
"""
if self.is_empty():
raise AlgorithmError("Operator is empty, can not build evolve instruction.")
# pylint: disable=no-member
if num_time_slices <= 0 or not isinstance(num_time_slices, int):
raise ValueError("Number of time slices should be a non-negative integer.")
if expansion_mode not in ["trotter", "suzuki"]:
raise NotImplementedError(f"Expansion mode {expansion_mode} not supported.")
pauli_list = self.reorder_paulis()
if len(pauli_list) == 1:
slice_pauli_list = pauli_list
else:
if expansion_mode == "trotter":
slice_pauli_list = pauli_list
# suzuki expansion
else:
slice_pauli_list = suzuki_expansion_slice_pauli_list(
pauli_list, 1, expansion_order
)
instruction = evolution_instruction(slice_pauli_list, evo_time, num_time_slices)
return instruction
class Z2Symmetries:
"""Z2 Symmetries"""
def __init__(self, symmetries, sq_paulis, sq_list, tapering_values=None):
"""
Args:
symmetries (list[Pauli]): the list of Pauli objects representing the Z_2 symmetries
sq_paulis (list[Pauli]): the list of single - qubit Pauli objects to construct the
Clifford operators
sq_list (list[int]): the list of support of the single-qubit Pauli objects used to build
the Clifford operators
tapering_values (list[int], optional): values determines the sector.
Raises:
AlgorithmError: Invalid paulis
"""
if len(symmetries) != len(sq_paulis):
raise AlgorithmError(
"Number of Z2 symmetries has to be the same as number "
"of single-qubit pauli x."
)
if len(sq_paulis) != len(sq_list):
raise AlgorithmError(
"Number of single-qubit pauli x has to be the same "
"as length of single-qubit list."
)
if tapering_values is not None:
if len(sq_list) != len(tapering_values):
raise AlgorithmError(
"The length of single-qubit list has "
"to be the same as length of tapering values."
)
self._symmetries = symmetries
self._sq_paulis = sq_paulis
self._sq_list = sq_list
self._tapering_values = tapering_values
@property
def symmetries(self):
"""return symmetries"""
return self._symmetries
@property
def sq_paulis(self):
"""returns sq paulis"""
return self._sq_paulis
@property
def cliffords(self):
"""
Get clifford operators, build based on symmetries and single-qubit X.
Returns:
list[WeightedPauliOperator]: a list of unitaries used to diagonalize the Hamiltonian.
"""
cliffords = [
WeightedPauliOperator(
paulis=[[1 / np.sqrt(2), pauli_symm], [1 / np.sqrt(2), sq_pauli]]
)
for pauli_symm, sq_pauli in zip(self._symmetries, self._sq_paulis)
]
return cliffords
@property
def sq_list(self):
"""returns sq list"""
return self._sq_list
@property
def tapering_values(self):
"""returns tapering values"""
return self._tapering_values
@tapering_values.setter
def tapering_values(self, new_value):
"""set tapering values"""
self._tapering_values = new_value
def __str__(self):
ret = ["Z2 symmetries:"]
ret.append("Symmetries:")
for symmetry in self._symmetries:
ret.append(symmetry.to_label())
ret.append("Single-Qubit Pauli X:")
for x in self._sq_paulis:
ret.append(x.to_label())
ret.append("Cliffords:")
for c in self.cliffords:
ret.append(c.print_details())
ret.append("Qubit index:")
ret.append(str(self._sq_list))
ret.append("Tapering values:")
if self._tapering_values is None:
possible_values = [
str(list(coeff))
for coeff in itertools.product([1, -1], repeat=len(self._sq_list))
]
possible_values = ", ".join(x for x in possible_values)
ret.append(" - Possible values: " + possible_values)
else:
ret.append(str(self._tapering_values))
ret = "\n".join(ret)
return ret
def copy(self) -> "Z2Symmetries":
"""
Get a copy of self.
Returns:
copy
"""
return deepcopy(self)
def is_empty(self):
"""
Check the z2_symmetries is empty or not.
Returns:
bool: empty
"""
if self._symmetries != [] and self._sq_paulis != [] and self._sq_list != []:
return False
else:
return True
def taper(self, operator, tapering_values=None):
"""
Taper an operator based on the z2_symmetries info and sector defined by `tapering_values`.
The `tapering_values` will be stored into the resulted operator for a record.
Args:
operator (WeightedPauliOperator): the to-be-tapered operator.
tapering_values (list[int], optional): if None, returns operators at each sector;
otherwise, returns
the operator located in that sector.
Returns:
list[WeightedPauliOperator] or WeightedPauliOperator: If
tapering_values is None: [:class`WeightedPauliOperator`];
otherwise, :class:`WeightedPauliOperator`
Raises:
AlgorithmError: Z2 symmetries, single qubit pauli and single qubit list cannot be empty
"""
if not self._symmetries or not self._sq_paulis or not self._sq_list:
raise AlgorithmError(
"Z2 symmetries, single qubit pauli and "
"single qubit list cannot be empty."
)
if operator.is_empty():
logger.warning("The operator is empty, return the empty operator directly.")
return operator
for clifford in self.cliffords:
operator = clifford * operator * clifford
tapering_values = (
tapering_values if tapering_values is not None else self._tapering_values
)
def _taper(op, curr_tapering_values):
z2_symmetries = self.copy()
z2_symmetries.tapering_values = curr_tapering_values
operator_out = WeightedPauliOperator(
paulis=[], z2_symmetries=z2_symmetries, name=operator.name
)
for pauli_term in op.paulis:
coeff_out = pauli_term[0]
for idx, qubit_idx in enumerate(self._sq_list):
if not (
not pauli_term[1].z[qubit_idx]
and not pauli_term[1].x[qubit_idx]
):
coeff_out = curr_tapering_values[idx] * coeff_out
z_temp = np.delete(pauli_term[1].z.copy(), np.asarray(self._sq_list))
x_temp = np.delete(pauli_term[1].x.copy(), np.asarray(self._sq_list))
pauli_term_out = WeightedPauliOperator(
paulis=[[coeff_out, Pauli((z_temp, x_temp))]]
)
operator_out += pauli_term_out
operator_out.chop(0.0)
return operator_out
if tapering_values is None:
tapered_ops = []
for coeff in itertools.product([1, -1], repeat=len(self._sq_list)):
tapered_ops.append(_taper(operator, list(coeff)))
else:
tapered_ops = _taper(operator, tapering_values)
return tapered_ops
@staticmethod
def two_qubit_reduction(operator, num_particles):
"""
Eliminates the central and last qubit in a list of Pauli that has
diagonal operators (Z,I) at those positions
Chemistry specific method:
It can be used to taper two qubits in parity and binary-tree mapped
fermionic Hamiltonians when the spin orbitals are ordered in two spin
sectors, (block spin order) according to the number of particles in the system.
Args:
operator (WeightedPauliOperator): the operator
num_particles (Union(list, int)): number of particles, if it is a list,
the first number is alpha
and the second number if beta.
Returns:
WeightedPauliOperator: a new operator whose qubit number is reduced by 2.
"""
if operator.is_empty():
logger.info(
"Operator is empty, can not do two qubit reduction. "
"Return the empty operator back."
)
return operator
if isinstance(num_particles, (tuple, list)):
num_alpha = num_particles[0]
num_beta = num_particles[1]
else:
num_alpha = num_particles // 2
num_beta = num_particles // 2
par_1 = 1 if (num_alpha + num_beta) % 2 == 0 else -1
par_2 = 1 if num_alpha % 2 == 0 else -1
tapering_values = [par_2, par_1]
num_qubits = operator.num_qubits
last_idx = num_qubits - 1
mid_idx = num_qubits // 2 - 1
sq_list = [mid_idx, last_idx]
# build symmetries, sq_paulis:
symmetries, sq_paulis = [], []
for idx in sq_list:
pauli_str = ["I"] * num_qubits
pauli_str[idx] = "Z"
z_sym = Pauli("".join(pauli_str)[::-1])
symmetries.append(z_sym)
pauli_str[idx] = "X"
sq_pauli = Pauli("".join(pauli_str)[::-1])
sq_paulis.append(sq_pauli)
z2_symmetries = Z2Symmetries(symmetries, sq_paulis, sq_list, tapering_values)
return z2_symmetries.taper(operator)
def consistent_tapering(self, operator):
"""
Tapering the `operator` with the same manner of how this tapered operator
is created. i.e., using the same Cliffords and tapering values.
Args:
operator (WeightedPauliOperator): the to-be-tapered operator
Returns:
TaperedWeightedPauliOperator: the tapered operator
Raises:
AlgorithmError: The given operator does not commute with the symmetry
"""
if operator.is_empty():
raise AlgorithmError("Can not taper an empty operator.")
for symmetry in self._symmetries:
if not operator.commute_with(symmetry):
raise AlgorithmError(
"The given operator does not commute with "
"the symmetry, can not taper it."
)
return self.taper(operator)
|
https://github.com/samihatashin/QC-Algorithms-with-Qiskit
|
samihatashin
|
my_list = [1,3,5,2,4,2,5,8,0,7,6]
#classical computation method
def oracle(my_input):
winner =7
if my_input is winner:
response = True
else:
response = False
return response
for index, trial_number in enumerate(my_list):
if oracle(trial_number) is True:
print("Winner is found at index %i" %index)
print("%i calls to the oracle used " %(index +1))
break
#quantum implemenation
from qiskit import *
import matplotlib.pyplot as plt
import numpy as np
from qiskit.tools import job_monitor
# oracle circuit
oracle = QuantumCircuit(2, name='oracle')
oracle.cz(0,1)
oracle.to_gate()
oracle.draw(output='mpl')
backend = Aer.get_backend('statevector_simulator')
grover_circuit = QuantumCircuit(2,2)
grover_circuit.h([0,1])
grover_circuit.append(oracle,[0,1])
grover_circuit.draw(output='mpl')
job= execute(grover_circuit, backend=backend)
result= job.result()
sv= result.get_statevector()
np.around(sv,2)
#amplitude amplification
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(output='mpl')
#testing circuit on simulator
simulator = Aer.get_backend('qasm_simulator')
grover_circuit = QuantumCircuit(2,2)
grover_circuit.h([0,1])
grover_circuit.append(oracle,[0,1])
grover_circuit.append(reflection, [0,1])
grover_circuit.barrier()
grover_circuit.measure([0,1],[0,1])
grover_circuit.draw(output='mpl')
job= execute(grover_circuit,backend=simulator,shots=1)
result=job.result()
result.get_counts()
#testing on real backend system
IBMQ.load_account()
provider= IBMQ.get_provider('ibm-q')
qcomp= provider.get_backend('ibmq_manila')
job = execute(grover_circuit,backend=qcomp)
job_monitor(job)
result=job.result()
counts=result.get_counts(grover_circuit)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
counts['11']
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import HGate
qr = QuantumRegister(3)
qc = QuantumCircuit(qr)
c3h_gate = HGate().control(2)
qc.append(c3h_gate, qr)
qc.draw('mpl')
|
https://github.com/Slope86/QiskitExtension
|
Slope86
|
import math
import random
from qiskit_extension.quantum_circuit2 import QuantumCircuit2 as qc2
from qiskit_extension.state_vector2 import StateVector2 as sv2
state_unknown = sv2.from_label((random.random(), "0"), (random.random(), "1"))
state_unknown.show_state()
# Create a 2bits quantum circuit
circ_init = qc2(2)
# Entangle two ground state qubits to an EPR pair
circ_init.h(0)
circ_init.cx(0,1)
# Put the ground state into the circuit to get the EPR pair
state_EPR = sv2(circ_init)
# Show state_EPR, confirm it is EPR pair
state_EPR.show_state()
# Combined state_unknown and state_EPR into a 3-qubit sv2 object
state_before_teleport = state_unknown.expand(state_EPR)
state_before_teleport.show_state()
# Create the circuit for Bell measurement
circ_bell = qc2(3)
circ_bell.cx(0,1)
circ_bell.h(0)
# Bell measurement on qubits(0,1), and store the four possible states as a list after measurement
# list[0b00]=state after measurement result is 00,
# list[0b01]=state after measurement result is 01,
# ...
list_state_after_measure = state_before_teleport.evolve(circ_bell).measure([0,1])
# Show the four possible states after the Bell measurement
# Display format: (|00> indicates the measured state, followed by a colon indicating [the remaining state after measurement result is 00])
# |00>: 1/2|0> + 1/2|1> ...
state_before_teleport.evolve(circ_bell).show_measure([0,1])
state_after_teleport = list_state_after_measure[0b00]
state_after_teleport.show_state(hide=[0,1])
# Correction circuit
circ_correction = qc2(3)
circ_correction.x(2)
# Applying the correction circuit
state_after_teleport = list_state_after_measure[0b01].evolve(circ_correction)
state_after_teleport.show_state(hide=[0,1])
# Correction circuit
circ_correction = qc2(3)
circ_correction.z(2)
# Applying the correction circuit
state_after_teleport = list_state_after_measure[0b10].evolve(circ_correction)
state_after_teleport.show_state(hide=[0,1])
# Correction circuit
circ_correction = qc2(3)
circ_correction.x(2)
circ_correction.z(2)
# Applying the correction circuit
state_after_teleport = list_state_after_measure[0b11].evolve(circ_correction)
state_after_teleport.show_state(hide=[0,1])
|
https://github.com/SaashaJoshi/IBM-Qiskit-Summer-School-2020
|
SaashaJoshi
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/DeboQubie/Options-Trading
|
DeboQubie
|
from qiskit import QuantumCircuit,QuantumRegister,ClassicalRegister
from qiskit_finance.circuit.library import LogNormalDistribution
import numpy as np
from qiskit.quantum_info import Statevector
# Implementing the log-normal-distribution
# number of qubits to represent the uncertainty
num_uncertainty_qubits = 3
# parameters for considered random distribution
S = 2.0 # initial spot price
vol = 0.4 # volatility of 40%
r = 0.05 # annual interest rate of 4%
T = 300 / 365 # 40 days to maturity
# resulting parameters for log-normal distribution
mu = ((r - 0.5 * vol**2) * T + np.log(S))
# sigma = vol * np.sqrt(T)
sigma=0.1 # sigma=10%
mean = np.exp(mu + sigma**2/2)
variance = (np.exp(sigma**2) - 1) * np.exp(2*mu + sigma**2)
stddev = np.sqrt(variance)
# lowest and highest value considered for the spot price; in between, an equidistant discretization is considered.
low = np.maximum(0, mean - 3*stddev)
high = mean + 3*stddev
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
uncertainty_model = LogNormalDistribution(num_uncertainty_qubits, mu=mu, sigma=sigma**2, bounds=(low, high))
uncertainty_model.draw('mpl')
# Defining some constants
num_of_qubits=3
q=QuantumRegister(num_of_qubits,name="q")
q_c=QuantumRegister(1,name="c")
q_a=QuantumRegister(1,name="a")
c=ClassicalRegister(1)
qc=QuantumCircuit(q,q_c,q_a,c)
qc.append(uncertainty_model,range(num_uncertainty_qubits))
qc.barrier()
qc.draw("mpl")
psi=Statevector(qc)
psi.draw("latex")
# To see the log normal distribution
# qc.measure(q,c)
# qc.draw('mpl')
# from qiskit import transpile
# from qiskit.providers.aer import QasmSimulator
# backend=QasmSimulator()
# qc_compiled=transpile(qc,backend)
# job = backend.run(qc_compiled,shot=1024)
# result=job.result()
# counts=result.get_counts()
# print(counts)
# from qiskit.visualization import plot_histogram
# plot_histogram(counts)
k=2 # Strike price
# Implementing the comparitor circuit for the given strike price
qc.cx(q[2],q_c[0])
qc.barrier()
qc.draw("mpl")
from math import pi
# constants
C=0.25 # scalling factor
i_max=(2**num_of_qubits)-1 #2^n-1
# f(i)=f0+f1*i
f0=-(2*C*k)/(i_max-k)
f1=(2*C)/(i_max-k)
g0=(pi/4)-C
# circuit
qc.ry(g0,q_a[0])
# making the Ry[g(i)] part
qc.ry(f0,q_a[0])
qc.cry(f1,q_c[0],q_a[0])
qc.cry(4*f1,q[2],q_a[0])
qc.cry(2*f1,q[1],q_a[0])
qc.cry(f1,q[0],q_a[0])
qc.barrier()
qc.draw('mpl')
psi=Statevector(qc)
psi.draw('latex')
qc.measure(q_a,c)
qc.draw('mpl')
from qiskit import transpile
from qiskit.providers.aer import QasmSimulator
backend=QasmSimulator()
qc_compiled=transpile(qc,backend)
job = backend.run(qc_compiled,shots=2)
result=job.result()
counts=result.get_counts()
print(counts)
from qiskit.visualization import plot_histogram
plot_histogram(counts,sort="value")
from qiskit import transpile
from qiskit.providers.aer import QasmSimulator
m=[3,5,7,9,11,13] #different no.of shots
a_l=[] # stores the expected payoff for different no.of shots
for i in m:
M=2**i
backend=QasmSimulator()
qc_compiled=transpile(qc,backend)
job = backend.run(qc_compiled,shots=M)
result=job.result()
counts=result.get_counts()
print(counts)
a_l+=[counts["1"]/(2**i)]
for i in range(len(a_l)):
print("expected payoff for m =",m[i]," is =",a_l[i])
import numpy as np
import scipy.stats as si
import sympy as sy
from sympy.stats import Normal, cdf
def euro_vanilla_call(S, K, T, r, sigma):
#S: spot price
#K: strike price
#T: time to maturity
#r: interest rate
#sigma: volatility of underlying asset
d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
d2 = (np.log(S / K) + (r - 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
call = (S * si.norm.cdf(d1, 0.0, 1.0) - K * np.exp(-r * T) * si.norm.cdf(d2, 0.0, 1.0))
return call
print(euro_vanilla_call(S, k, T, r, sigma))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_circuit_layout
from qiskit.providers.fake_provider import FakeVigo
backend = FakeVigo()
ghz = QuantumCircuit(3, 3)
ghz.h(0)
ghz.cx(0,range(1,3))
ghz.barrier()
ghz.measure(range(3), range(3))
# Virtual -> physical
# 0 -> 3
# 1 -> 4
# 2 -> 2
my_ghz = transpile(ghz, backend, initial_layout=[3, 4, 2])
plot_circuit_layout(my_ghz, backend)
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
import pickle
# plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
import time
import datetime
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, I, X, Y, Z
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile, Aer
from qiskit.providers.aer import QasmSimulator
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
# Suppress warnings
import warnings
warnings.filterwarnings('ignore')
def trotter_gate(dt, to_instruction = True):
qc = QuantumCircuit(2)
qc.rx(2*dt,0)
qc.rz(2*dt,1)
qc.h(1)
qc.cx(1,0)
qc.rz(-2*dt, 0)
qc.rx(-2*dt, 1)
qc.rz(2*dt, 1)
qc.cx(1,0)
qc.h(1)
qc.rz(2*dt, 0)
return qc.to_instruction() if to_instruction else qc
trotter_gate(np.pi / 6, to_instruction=False).draw("mpl")
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
Trot_gate = trotter_gate(dt)
# Number of trotter steps
trotter_steps = 15 ### CAN BE >= 4
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(7)
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
qc.x([5]) # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
# Simulate time evolution under H_heis3 Hamiltonian
for _ in range(trotter_steps):
qc.append(Trot_gate, [qr[3], qr[5]])
qc.cx(qr[3], qr[1])
qc.cx(qr[5], qr[3])
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time/trotter_steps})
t3_qc = transpile(qc, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t3_qc = transpile(t3_qc, optimization_level=3, basis_gates=["sx", "cx", "rz"])
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(t3_qc, [qr[1], qr[3], qr[5]])
# Display circuit for confirmation
# st_qcs[-1].decompose().draw() # view decomposition of trotter gates
st_qcs[-1].draw("mpl") # only view trotter gates
# from qiskit.test.mock import FakeJakarta
# backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
print("provider:", provider)
backend = provider.get_backend("ibmq_jakarta")
shots = 8192
reps = 8
jobs = []
for _ in range(reps):
# execute
job = execute(st_qcs, backend, shots=shots)
print('Job ID', job.job_id())
jobs.append(job)
# QREM
qr = QuantumRegister(num_qubits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout=[5,3,1])
print('Job ID', cal_job.job_id())
dt_now = datetime.datetime.now()
print(dt_now)
with open("jobs_jakarta_15step_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump({"jobs": jobs, "cal_job": cal_job}, f)
with open("job_ids_jakarta_15step_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump({"job_ids": [job.job_id() for job in jobs], "cal_job_id": cal_job.job_id()}, f)
with open("properties_jakarta" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump(backend.properties(), f)
filename = "job_ids_jakarta_15step_20220412_031437_.pkl" # change here
with open(filename, "rb") as f:
job_ids_dict = pickle.load(f)
job_ids = job_ids_dict["job_ids"]
cal_job_id = job_ids_dict["cal_job_id"]
retrieved_jobs = []
for job_id in job_ids:
retrieved_jobs.append(backend.retrieve_job(job_id))
retrieved_cal_job = backend.retrieve_job(cal_job_id)
cal_results = retrieved_cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
# set the target state
target_state = (One^One^Zero).to_matrix() # DO NOT CHANGE!!!
fids = []
for job in retrieved_jobs:
mit_results = meas_fitter.filter.apply(job.result()) # apply QREM
rho = StateTomographyFitter(mit_results, st_qcs).fit(method='lstsq')
fid = state_fidelity(rho, target_state)
fids.append(fid)
print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/junayed-hasan/Quantum-Machine-Learning-Qiskit-PyTorch
|
junayed-hasan
|
from qiskit import *
%matplotlib inline
import numpy as np
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.draw('mpl')
from qiskit.visualization import plot_state_hinton
sim = Aer.get_backend('statevector_simulator') # qasm_simulator, statevector_simulator, unitary_simulator
result = execute(qc, backend=sim).result()
state = result.get_statevector(qc)
plot_state_hinton(state)
from qiskit.visualization import *
from matplotlib import style
style.use('bmh')
style.use('dark_background')
plot_state_city(state)
plot_state_paulivec(result.get_statevector(qc))
from qiskit import IBMQ
IBMQ.load_account()
from qiskit.tools.monitor import job_monitor
provider = IBMQ.get_provider(hub='ibm-q', group='open')
backend = provider.get_backend('ibmq_santiago')
job = execute(qc, backend=backend, shots=8192)
job_monitor(job)
from qiskit.visualization import plot_histogram
result = job.result()
plot_histogram(result.get_counts(qc))
|
https://github.com/drnickallgood/simonqiskit
|
drnickallgood
|
import sys
import logging
import matplotlib.pyplot as plt
import numpy as np
import operator
import itertools
#from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute, IBMQ
from qiskit.providers.ibmq import least_busy
from collections import OrderedDict
# AER is for simulators
from qiskit import Aer
from qiskit import QuantumCircuit
from qiskit import ClassicalRegister
from qiskit import QuantumRegister
from qiskit import execute
from qiskit import IBMQ
#from qiskit.providers.ibmq.managed import IBMQJobManager
from qiskit.tools.monitor import job_monitor
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.visualization import circuit_drawer
from sympy import Matrix, pprint, MatrixSymbol, expand, mod_inverse
from qjob import QJob
unitary_sim = Aer.get_backend('unitary_simulator')
## function to get dot product of result string with the period string to verify, result should be 0
#check the wikipedia for simons formula
# DOT PRODUCT IS MOD 2 !!!!
# Result XOR ?? = 0 -- this is what we're looking for!
# We have to verify the period string with the ouptput using mod_2 addition aka XOR
# Simply xor the period string with the output string
# Simply xor the period string with the output string, result must be 0 or 0b0
def verify_string(ostr, pstr):
"""
Verify string with period string
Does dot product and then mod2 addition
"""
temp_list = list()
# loop through outstring, make into numpy array
for o in ostr:
temp_list.append(int(o))
ostr_arr = np.asarray(temp_list)
temp_list.clear()
# loop through period string, make into numpy array
for p in pstr:
temp_list.append(int(p))
pstr_arr = np.asarray(temp_list)
temp_list.clear()
# Per Simosn, we do the dot product of the np arrays and then do mod 2
results = np.dot(ostr_arr, pstr_arr)
if results % 2 == 0:
return True
return False
def blackbox(simonCircuit, uni_list, period_string):
#### Blackbox Function #####
# QP's don't care about this, we do#
#############################
#bbqr = QuantumRegister(2*n, 'q')
#bbcr = ClassicalRegister(n, 'c')
#bbcirc = QuantumCircuit(bbqr,bbcr)
flag = True
while flag:
bbqr = QuantumRegister(2*n, 'q')
bbcr = ClassicalRegister(n, 'c')
bbcirc = QuantumCircuit(bbqr,bbcr)
# Copy first register to second by using CNOT gates
for i in range(n):
#simonCircuit.cx(qr[i],qr[n+i])
#bbcirc.cx(qr[i],qr[n+i])
bbcirc.cx(bbqr[i],bbqr[n+i])
# get the small index j such it's "1"
j = -1
#reverse the string so that it takes
s = period_string[::-1]
for i, c in enumerate(s):
if c == "1":
j = i
break
# 1-1 and 2-1 mapping with jth qubit
# x is control to xor 2nd qubit with a
for i, c in enumerate(s):
if c == "1" and j >= 0:
#simonCircuit.x(qr[j])
bbcirc.cx(bbqr[j], bbqr[n+i]) #the i-th qubit is flipped if s_i is 1
#simonCircuit.x(qr[j])
# Added to expand function space so that we get enough random
# functions for statistical sampling
# Randomly add a CX gate
for i in range(n):
for j in range(i+1, n):
if np.random.random() > 0.5:
bbcirc.cx(bbqr[n+i],bbqr[n+j])
# Random peemutation
# This part is how we can get by with 1 query of the oracle and better
# simulates quantum behavior we'd expect
perm = list(np.random.permutation(n))
# init position
init = list(range(n))
i = 0
while i < n:
if init[i] != perm[i]:
k = perm.index(init[i])
bbcirc.swap(bbqr[n+i], bbqr[n+k]) #swap gate on qubits
init[i], init[k] = init[k], init[i] # mark the swapped qubits
else:
i += 1
# Randomly flip qubit
# Seed random numbers for predictability / benchmark
for i in range(n):
if np.random.random() > 0.5:
bbcirc.x(bbqr[n+i])
# Added for duplicate checking
# We get the unitary matrix of the blackbox generated circuit
bb_sim_result = execute(bbcirc, unitary_sim).result()
bb_uni = bb_sim_result.get_unitary(bbcirc, decimals=15)
# Duplicate flag
dup = False
# Handle empty list
if len(uni_list) == 0:
#uni_list.append(bb_uni)
# Set flag to false to break out of main loop
flag = False
dup = False
print("adding first generated")
else:
# Check for duplicates
# If duplicate oracle query, re-run oracle
#print(np.array_equal(bb_uni, uni_list[0]))
for i, uni in enumerate(uni_list):
if (bb_uni == uni).all():
#if np.array_equal(bb_uni, uni):
# Break out of for loop because we founhd a duplicate, re-run to get new blackbox circuit
print("Duplicates Found, restarting loop")
dup = True
break # breaks out of for loop to start over,
else:
dup = False
# If duplicate flag not set after we searched the list...
if not dup:
# No duplicate unitary matricies, we can add to list
# and break out
uni_list.append(bb_uni)
flag = False
print("No Duplicates - Added another to list")
### End While
# Combine input circuit with created blackbox circuit
simonCircuit = simonCircuit + bbcirc
simonCircuit.barrier()
print("Ending blackbox")
return simonCircuit
## easily create period strings
## We want to avoid using anything with all 0's as that gives us false results
## because anything mod2 00 will give results
def create_period_str(strlen):
str_list = list()
for i in itertools.product([0,1],repeat=strlen):
if "1" in ("".join(map(str,i))):
#print("".join(map(str,i)))
str_list.append("".join(map(str,i)))
return str_list
#### START ####
# hidden stringsn
period_strings_5qubit = list()
period_strings_5qubit = create_period_str(2)
period_strings_2bit = list()
period_strings_3bit = list()
period_strings_4bit = list()
period_strings_5bit = list()
period_strings_6bit = list()
period_strings_7bit = list()
# 2-bit strings
period_strings_2bit = create_period_str(2)
# 3-bit strings
period_strings_3bit = create_period_str(3)
# 4-bit strings
period_strings_4bit = create_period_str(4)
# 5-bit strings
period_strings_5bit = create_period_str(5)
# 6-bit strings
period_strings_6bit = create_period_str(6)
# 7-bit strings
period_strings_7bit = create_period_str(7)
# IBM Q stuff..
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
circuitList = list()
## DO NOT USE ITERATION FORMULA JUST HERE FOR REF
# Iterations = # of backends tested
# iteration formula = floor(log2(num_backends * num_shots)) = 14 here
# 2-bit period strings
ranJobs = list()
backname = "local_sim"
#2bit = 12 = 36 random functions
#3bit = 54 = 372+ random functions
#4bit
#5bit
#6bit
#7bit
#o Jobs total = # of strings * iterations
#total_jobs = iterations * len(period_strings_5bit)
#job_start_idx = 1
circs = list()
def find_duplicates(circs):
k = 0
dup_count = 0
while k < len(circs)-1:
if circs[k].count_ops() == circs[k+1].count_ops():
#print("\n=== Duplicates Found! ===")
#print("Index:" + str(k))
#print("Index:" + str(k+1))
dup_count = dup_count + 1
#print(circs[k].count_ops())
#print(circs[k+1].count_ops())
#print("=== End Duplcates ===")
k = k+2
else:
k = k+1
return dup_count
def generate_simon(simonCircuit, uni_list, period):
# Generate circuit
# Assumes global simoncircuit
# Hadamards prior to oracle
for i in range(n):
simonCircuit.h(qr[i])
simonCircuit.barrier()
# Oracle query
simonCircuit = blackbox(simonCircuit, uni_list, period)
# Apply hadamards again
for i in range(n):
simonCircuit.h(qr[i])
simonCircuit.barrier()
# Measure qubits, maybe change to just first qubit to measure
simonCircuit.measure(qr[0:n],cr)
return simonCircuit
i = 0
z = 0
not_done = True
np.random.seed(0)
n = len(period_strings_2bit[0])
qr = QuantumRegister(2*n, 'q')
cr = ClassicalRegister(n, 'c')
simonCircuit = QuantumCircuit(qr,cr)
uni_list = list()
outfile = open("sim-results/simulations-2bit-12iter.txt", "w")
iterations = 12 #2-bit
#iterations = 54 #3-bit
#iterations = 26 #4-bit
#iterations = 13 #5-bit
#iterations = 7 #6-bit
#iterations = 4 #7-bit
local_sim = Aer.get_backend('qasm_simulator')
while not_done:
while i < len(period_strings_2bit):
#print("Started main block..")
#print(str(period_strings_6bit[i]))
n = len(period_strings_2bit[i])
print("Period strings: " + str(i+1) + "/" + str(len(period_strings_2bit)))
while z < iterations:
qr = QuantumRegister(2*n, 'q')
cr = ClassicalRegister(n, 'c')
simonCircuit = QuantumCircuit(qr,cr)
# Duplicates are checked in blackbox function
simon = generate_simon(simonCircuit, uni_list, period_strings_2bit[i])
circs.append(simon)
z = z + 1
print("Iterations:" + str(z) + "/" + str(iterations))
i = i + 1
z = 0
not_done = False
dup_flag = False
print("\nDouble checking heuristically...\n")
# Double checking all items in list are not duplicate
for x in range(0,len(uni_list)-1):
for y in range(1,len(uni_list)):
# Handle condition when x and y overlap and are eachother
if x != y:
if np.array_equal(uni_list[x], uni_list[y]):
print("Duplicates found at indexes:" + str(x) + "," + str(y))
dup_flag = True
#print("\nDuplicates in set, not valid\n")
if dup_flag:
print("\nDuplicates Found, see above.\n")
else:
print("\nNo duplicates found in 2nd pass\n")
print("\nRunning final check of dot product between period string and observed strings...")
### Now to run on simulator ####
iter_cnt = 0
pstr_cnt = 0
ranJobs = list()
for circ in circs:
job = execute(circ, backend=local_sim, shots=1024, optimization_level=3, seed_transpiler=0)
# create Qjob, store info
qj = QJob(job, circ, "local_sim", period_strings_2bit[pstr_cnt])
ranJobs.append(qj)
result = job.result()
counts = result.get_counts()
# We advance to next period string when we iterate through all
# the circuits per period strings
if iter_cnt == iterations-1:
pstr_cnt += 1
iter_cnt = 0
else:
iter_cnt += 1
# outfile.write(str(counts) + "\n")
outfile.close()
# Go through and get correct vs incorrect in jobs
## This will verify all the strings we get back are correct from the non
# duplicate circuits
for qjob in ranJobs:
results = qjob.job.result()
counts = results.get_counts()
#equations = guass_elim(results)
# Get period string
pstr = qjob.getPeriod()
# Verify observed string vs peroid string by doing dot product
for ostr, count in counts.items():
if verify_string(ostr, pstr):
qjob.setCorrect(count)
else:
qjob.setIncorrect(count)
total_correct = 0
total_incorrect = 0
total_runs = (1024 * iterations) * len(period_strings_2bit)
for qjob in ranJobs:
total_correct += qjob.getCorrect()
total_incorrect += qjob.getIncorrect()
print("\nTotal Runs: " + str(total_runs))
print("Total Correct: " + str(total_correct))
print("Prob Correct: " + str(float(total_correct) / float(total_runs)))
print("Total Incorrect: " + str(total_incorrect))
print("Prob Incorrect: " + str(float(total_incorrect) / float(total_runs)))
print("")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.x(0)
qc.y(1)
qc.z(2)
print(qc)
qc.draw("mpl")
|
https://github.com/quantum-tokyo/qiskit-handson
|
quantum-tokyo
|
# Qiskitライブラリーを導入
from qiskit import *
from qiskit.visualization import *
# 描画のためのライブラリーを導入
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# Qiskitバージョンの確認
qiskit.__qiskit_version__
q = QuantumCircuit(1) # １量子ビット回路を用意
q.x(0) # Xゲートを0番目の量子ビットに操作します。
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(1) # １量子ビット回路を用意
q.h(0) # Hゲートを0番目の量子ビットに操作します。
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(1) # １量子ビット回路を用意
# Hゲートを0番目の量子ビットに操作します。
q.h(0)
# 次にZゲートを0番目の量子ビットに操作します。
q.z(0)
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(1) # １量子ビット回路を用意
q.h(0) # Hゲートを0番目の量子ビットに操作します。
q.s(0) # 次にSゲートを0番目の量子ビットに操作します。
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(1) # １量子ビット回路を用意
q.h(0) # Hゲートを0番目の量子ビットに操作します。
q.t(0) # 次にTゲートを0番目の量子ビットに操作します。
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(1) # １量子ビット回路を用意
q.h(0) # Hゲートを0番目の量子ビットに操作します。
q.u1(np.pi/8,0) # 次にU1ゲートを0番目の量子ビットに操作します。
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(2) # 2量子ビット回路を用意
q.h(0) # Hゲートを0番目の量子ビットに操作します。
q.h(1) # Hゲートを1番目の量子ビットに操作します。
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(2) # 2量子ビット回路を用意
# q0=|1>, q1=|+>の場合：
q.x(0)
q.h(1)
# CU1ゲートの制御ビットをq0、目標ビットをq1、角度をpi/2にセットします。
q.cu1(np.pi/2,0,1)
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
|
https://github.com/Rodri-rf/playing_with_quantum_computing
|
Rodri-rf
|
# Author: Khaled Alam(khaledalam.net@gmail.com)
'''
Guess binary string (secret) of length N in 1 shot only using quantum computing circuit!
~ by using clasical computers we need at least N shots to guess string (secret) of length N
~ by using quantum computer we need 1 shot to guess string (secret) of ANY length ( cool isn't it! ^^ )
'''
secret = '01000001' # `01000001` = `A`
from qiskit import *
n = len(secret)
qCircuit = QuantumCircuit(n+1, n) # n+1 qubits and n classical bits
qCircuit.x(n)
qCircuit.barrier()
qCircuit.h(range(n+1))
qCircuit.barrier()
for ii, OZ in enumerate(reversed(secret)):
if OZ == '1':
qCircuit.cx(ii, n)
qCircuit.barrier()
qCircuit.h(range(n+1))
qCircuit.barrier()
qCircuit.measure(range(n), range(n))
%matplotlib inline
qCircuit.draw(output='mpl')
# run on simulator
simulator = Aer.get_backend('qasm_simulator')
result = execute(qCircuit, backend=simulator, shots=1).result() # only 1 shot
from qiskit.visualization import plot_histogram
plot_histogram(
result.get_counts(qCircuit)
)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
%run 08_gellmann.ipynb
def coh_l1(rho):
d = rho.shape[0]; C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += np.abs(rho[j,k])
return 2*C
rho = np.array([[1,0],[0,0]]); rho, coh_l1(rho)
rho = np.array([[1,1],[1,1]])/2; rho, coh_l1(rho)
def mutual_info(da, db, rhoAB):
rhoA = pTraceR_num(da, db, rhoAB); Sa = von_neumann_num(rhoA)
rhoB = pTraceL_num(da, db, rhoAB); Sb = von_neumann_num(rhoB)
Sab = von_neumann_num(rhoAB)
return Sa + Sb - Sab
def shannon_num(pv):
d = pv.shape[0]; SE = 0.0; j = -1
while (j < d-1):
j = j + 1
if pv[j] > 10**-15 and pv[j] < (1.0-10**-15):
SE -= pv[j]*math.log(pv[j], 2)
return SE
import scipy.linalg.lapack as lapak
def von_neumann_num(rho):
d = rho.shape[0]; b = lapak.zheevd(rho)
return shannon_num(b[0])
def pTraceL_num(dl, dr, rhoLR):
rhoR = np.zeros((dr, dr), dtype=complex)
for j in range(0, dr):
for k in range(j, dr):
for l in range(0, dl):
rhoR[j,k] += rhoLR[l*dr+j,l*dr+k]
if j != k:
rhoR[k,j] = np.conj(rhoR[j,k])
return rhoR
def pTraceR_num(dl, dr, rhoLR):
rhoL = np.zeros((dl, dl), dtype=complex)
for j in range(0, dl):
for k in range(j, dl):
for l in range(0, dr):
rhoL[j,k] += rhoLR[j*dr+l,k*dr+l]
if j != k:
rhoL[k,j] = np.conj(rhoL[j,k])
return rhoL
rho = proj(tp(cb(2,0),cb(2,0))); rho, mutual_info(2, 2, rho)
rho = 0.5*proj(tp(cb(2,0),cb(2,0))) + 0.5*proj(tp(cb(2,1),cb(2,1))); rho, mutual_info(2, 2, rho)
psi = (1/math.sqrt(2))*(tp(cb(2,0),cb(2,0))+tp(cb(2,1),cb(2,1)))
rho = proj(psi); rho, mutual_info(2, 2, rho)
import scipy
def Dhellinger(da, db, rhoAB):
M = scipy.linalg.sqrtm(rhoAB)
A = pTraceR_num(da, db, M); bva = bloch_vector(A)/math.sqrt(2*db)
B = pTraceL_num(da, db, M); bvb = bloch_vector(B)/2
cm = corr_mat(da, db, M)/2; ev = lapak.zheevd(bva*bva.T + cm*cm.T)
D_he = 2 - 2*math.sqrt((np.trace(A)/math.sqrt(2*db))**2 + (scipy.linalg.norm(bvb))**2 + max(ev[0].real))
D_he = D_he/(2 - 2/math.sqrt(da))
return D_he
da = 2; db = 2
M = scipy.linalg.sqrtm(np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]])/4)
A = pTraceR_num(2, 2, M); bva = bloch_vector(A)/math.sqrt(2*2); bva
B = pTraceL_num(da, db, M); bvb = bloch_vector(B)/2; bvb
cm = corr_mat(da, db, M)/2; ev = lapak.zheevd(bva*bva.T + cm*cm.T); cm
D_he = 2 - 2*math.sqrt((np.trace(A)/math.sqrt(2*db))**2 + (scipy.linalg.norm(bvb))**2 + max(ev[0].real))
D_he = D_he/(2 - 2/math.sqrt(da)); D_he
# teste para a raiz quadrada de matriz calculada usando scipy
A = np.array([[1,0],[0,-1]]); Asr = scipy.linalg.sqrtm(A); Asr # raiz quadrada (testes)
#Asr*Asr
def Pauli(j):
if j == 0:
return np.array([[1,0],[0,1]])
elif j == 1:
return np.array([[0,1],[1,0]])
elif j == 2:
return np.array([[0,-1j],[1j,0]])
elif j == 3:
return np.array([[1,0],[0,-1]])
ev = lapak.zheevd(Pauli(1)); ev, ev[0], ev[0][0], ev[1][0], ev[1][0][0]
def Econcurrence(rho):
R = rho@tp(Pauli(2),Pauli(2))@np.matrix.conjugate(rho)@tp(Pauli(2),Pauli(2))
ev = lapak.zheevd(R)
evm = max(abs(ev[0][0]), abs(ev[0][1]), abs(ev[0][2]), abs(ev[0][3]))
Ec = 2*math.sqrt(abs(evm)) - math.sqrt(abs(ev[0][0])) - math.sqrt(abs(ev[0][1]))\
- math.sqrt(abs(ev[0][2])) - math.sqrt(abs(ev[0][3]))
if Ec < 0.0:
Ec = 0.0
return Ec
# Emaranhamento de formação
def Eof(rho):
Ec = Econcurrence(rho)
pv = np.zeros(2); pv[0] = (1+math.sqrt(1-Ec**2))/2; pv[1] = 1 - pv[0]
return shannon_num(pv)
pv=np.array([1,2]); pv.shape
x = np.arange(10**-3,1,0.01); p0 = (1 + np.sqrt(1-x**2))/2; p1 = 1 - p0
ef = np.zeros(x.shape[0]); ef = -p0*np.log2(p0) - p1*np.log2(p1)
plt.plot(x , ef); plt.xlabel(r'$E_{c}$'); plt.ylabel(r'$E_{f}$'); plt.show()
def rho_werner(w):
rho = np.zeros((4,4), dtype = complex)
rho =+ ((1-w)/4)*np.identity(4) + (w/2)*np.array([[1,0,0,1],[0,0,0,0],[0,0,0,0],[1,0,0,1]])
return rho
rho_werner(0)
w = np.arange(0, 1.05, 0.05); C = np.zeros(w.shape[0]); MI = np.zeros(w.shape[0]); D_he = np.zeros(w.shape[0])
Ec = np.zeros(w.shape[0]); Ef = np.zeros(w.shape[0])
for j in range(0, w.shape[0]):
rho = rho_werner(w[j]); C[j] = coh_l1(rho); MI[j] = mutual_info(2, 2, rho)/2
D_he[j] = Dhellinger(2, 2, rho); Ec[j] = Econcurrence(rho); Ef[j] = Eof(rho)
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(w, C, label = r'$C$'); plt.plot(w, MI, label = r'$I/2$');
plt.plot(w, D_he, label = r'$D_{A}^{he}$')
plt.plot(w, Ec, '*', label = r'$E_{c}$'); plt.plot(w, Ef, '-.', label = r'$E_{f}$')
plt.xlabel(r'$w$'); plt.legend(); plt.show()
|
https://github.com/JackHidary/quantumcomputingbook
|
JackHidary
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer
from qiskit.extensions import Initialize
from qiskit.quantum_info import random_statevector, Statevector,partial_trace
def trace01(out_vector):
return Statevector([sum([out_vector[i] for i in range(0,4)]), sum([out_vector[i] for i in range(4,8)])])
def teleportation():
# Create random 1-qubit state
psi = random_statevector(2)
print(psi)
init_gate = Initialize(psi)
init_gate.label = "init"
## SETUP
qr = QuantumRegister(3, name="q") # Protocol uses 3 qubits
crz = ClassicalRegister(1, name="crz") # and 2 classical registers
crx = ClassicalRegister(1, name="crx")
qc = QuantumCircuit(qr, crz, crx)
# Don't modify the code above
## Put your code below
# ----------------------------
qc.initialize(psi, qr[0])
qc.h(qr[1])
qc.cx(qr[1],qr[2])
qc.cx(qr[0],qr[1])
qc.h(qr[0])
qc.measure(qr[0],crz[0])
qc.measure(qr[1],crx[0])
qc.x(qr[2]).c_if(crx[0], 1)
qc.z(qr[2]).c_if(crz[0], 1)
# ----------------------------
# Don't modify the code below
sim = Aer.get_backend('aer_simulator')
qc.save_statevector()
out_vector = sim.run(qc).result().get_statevector()
result = trace01(out_vector)
return psi, result
# (psi,res) = teleportation()
# print(psi)
# print(res)
# if psi == res:
# print('1')
# else:
# print('0')
|
https://github.com/quantumyatra/quantum_computing
|
quantumyatra
|
# import dimod
# import numpy as np
# import pylab as plt
linear = {0: -1, 1: -1}
quadratic = {(0, 1): 2}
bqm = dimod.BinaryQuadraticModel(linear, quadratic, 0.0, dimod.BINARY) # 0.0 is the value for offset
bqm_ising = bqm.change_vartype(dimod.SPIN, inplace=False)
response = dimod.ExactSolver().sample(bqm)
for sample, energy in response.data(['sample', 'energy']):
print(sample, energy)
def Test_offset_values(offset):
linear = {0: -1, 1: -1}
quadratic = {(0, 1): 2}
bqm = dimod.BinaryQuadraticModel(linear, quadratic, offset, dimod.BINARY) # 0.0 is the value for offset
bqm_ising = bqm.change_vartype(dimod.SPIN, inplace=False)
response = dimod.ExactSolver().sample(bqm)
for sample, energy in response.data(['sample', 'energy']):
print(sample, energy)
for offset in [0., 1., 10]:
print ('offset=',offset)
Test_offset_values(offset)
Q = {('x1', 'x2'): 1, ('x1', 'z'): -2, ('x2', 'z'): -2, ('z', 'z'): 3}
from dwave.system import DWaveSampler, EmbeddingComposite
sampler = DWaveSampler()
#from dwave.system import DWaveSampler, EmbeddingComposite
#sampler = DWaveSampler()
#sampler_embedded = EmbeddingComposite(sampler)
linear = {1: 1, 2: 2, 3: 3, 4: 4} # linear term in the Ising hamiltonian h_i s_i terms
# And the quadratic terms s_i \dot s_j terms
quadratic = {(1, 2): 12, (1, 3): 13, (1, 4): 14,
(2, 3): 23, (2, 4): 24,
(3, 4): 34}
bqm_k4 = dimod.BinaryQuadraticModel(linear, quadratic, 0.5, dimod.SPIN)
#bqm_k4
bqm_k4.vartype
import dimod
>>> linear = {1: 1, 2: 2, 3: 3, 4: 4}
>>> quadratic = {(1, 2): 12, (1, 3): 13, (1, 4): 14,
... (2, 3): 23, (2, 4): 24,
... (3, 4): 34}
>>> bqm_k4 = dimod.BinaryQuadraticModel(linear, quadratic, 0.5, dimod.SPIN)
>>> bqm_k4.vartype
<Vartype.SPIN: frozenset([1, -1])>
>>> len(bqm_k4.linear)
4
>>> bqm_k4.contract_variables(2, 3)
>>> len(bqm_k4.linear)
3
>>> bqm_no3_qubo = bqm_k4.binary
|
https://github.com/fiasqo-io/quantumcircuit_gym
|
fiasqo-io
|
import gym
import gym_quantcircuit
import numpy as np
env = gym.make('quantcircuit-v0')
num_qubits = 3
test_goal_state = [0j] * (2**num_qubits - 1) + [1+0j]
env.var_init(num_qubits,
unitary=False,
gate_group='pauli',
connectivity='fully_connected',
goal_state=test_goal_state)
env.render()
env.plot_connectivity_graph()
action = env.sample()
env.gate_list[action]
env.step(action)
env.render()
for _ in range(5):
env.step(env.sample())
env.render()
env.reset()
env.render()
# Environment must be created before this step
custom_gate_group = [
env.qcircuit.x,
env.qcircuit.h,
env.qcircuit.t
]
env.set_gate_group('custom',custom_gate_group)
env.gate_list = env._create_gates()
env.gate_list
# Nearest neighbour
nnenv = gym.make('quantcircuit-v0')
nnenv.var_init(5,connectivity='nearest_neighbour')
nnenv.plot_connectivity_graph()
# Fully Connected
fc_env = gym.make('quantcircuit-v0')
fc_env.var_init(5,connectivity='fully_connected')
fc_env.plot_connectivity_graph()
# IBM - limited to 5, 14 or 20 qubits (these are the only current physical architectures)
ibm_env = gym.make('quantcircuit-v0')
ibm_env.var_init(5,connectivity='ibm')
ibm_env.plot_connectivity_graph()
# Custom
custom_conn = np.array([[1,1,1,0],[1,1,1,0],[1,1,1,1],[0,0,1,1]])
custom_env = gym.make('quantcircuit-v0')
custom_env.var_init(4,connectivity='custom',custom_connectivity=custom_conn)
custom_env.plot_connectivity_graph()
num_gates = 2
curriculum, tracker = env.make_curriculum(num_gates)
curriculum
tracker
|
https://github.com/hephaex/Quantum-Computing-Awesome-List
|
hephaex
|
# 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/usamisaori/Grover
|
usamisaori
|
import qiskit
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
import numpy as np
from qiskit import execute, Aer
simulator = Aer.get_backend('qasm_simulator')
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
from qiskit.quantum_info import DensityMatrix, Statevector, Operator
def getDensityMatrix(circuit):
return DensityMatrix(circuit).data
from functools import reduce
Dag = lambda matrix: matrix.conj().T
Kron = lambda *matrices: reduce(np.kron, matrices)
def pm(matrix):
for row in range(len(matrix)):
for col in range (len(matrix[row])):
print("{:.3f}".format(matrix[row][col]), end = " ")
print()
def initCircuit(n):
circuit = QuantumCircuit(n, n)
for i in range(n):
circuit.h(i)
circuit.barrier()
return circuit
inputCircuit_2q = initCircuit(2)
inputCircuit_2q.draw(output='mpl')
def createEvenOracle():
circuit = QuantumCircuit(2, 2)
circuit.x(0)
circuit.x(1)
circuit.cz(0, 1)
circuit.x(1)
circuit.cz(0, 1)
circuit.x(0)
circuit.barrier()
return circuit
evenOracle = createEvenOracle()
evenOracle.draw(output='mpl')
Operator(evenOracle).data # find 0 and 2
def createR_2q():
circuit = QuantumCircuit(2, 2)
circuit.z(0)
circuit.z(1)
circuit.cz(0, 1)
return circuit
def createDiffuser_2q():
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.h(1)
circuit = circuit.compose(createR_2q())
circuit.h(0)
circuit.h(1)
circuit.barrier()
return circuit
diffuserCircuit_2q = createDiffuser_2q()
diffuserCircuit_2q.draw(output='mpl')
grover_even = initCircuit(2).compose(createEvenOracle()).compose(createDiffuser_2q())
grover_even.draw(output='mpl')
grover_even.measure([0, 1], [0, 1])
job = execute(grover_even, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(grover_even)
print(counts)
plot_histogram(counts, figsize=(5, 5), color="#66CCCC", title="origin grover - find evens")
|
https://github.com/qclib/qclib
|
qclib
|
# Copyright 2021 qclib project.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
https://arxiv.org/abs/quant-ph/9807054
"""
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
from qclib.gates.initialize_sparse import InitializeSparse
# pylint: disable=maybe-no-member
class FnPointsInitialize(InitializeSparse):
"""
Initializing the Amplitude Distribution of a Quantum State
https://arxiv.org/abs/quant-ph/9807054
This class implements a state preparation gate.
"""
def __init__(self, params, label=None, opt_params=None):
"""State preparation using Ventura and Martinez algorithm quant-ph/9807054
Algorithm that requires a polynomial number of elementary operations for
initializing a quantum system to represent only the m known points of a
function f (m = len(state)).
The result is a quantum superposition with m nonzero coefficients -- the
creation of which is a nontrivial task compared to creating a superposition
of all basis states.
The amplitudes of modulus "1/sqrt(m)" will be "2 pi / N" radians apart from
each other on the complex plane.
Binary output function case:
f:z->s with z \\in {0,1}^n and s \\in {0, 1}
General case:
f:z->s with z \\in {0,1}^n and s \\in {0, 1, ..., N-1}
For instance, to initialize the state
1/sqrt(3)|01> + 1/sqrt(3)*e^(1*i*2pi/N)|10> + 1/sqrt(3)*e^(2*i*2pi/N)c|11>
$ state = {1: 0, 2: 1, 3: 2}
$ circuit = initialize(state, n=2, N=3)
Parameters
----------
params: dict of {int:float}
A unit vector representing a quantum state.
Keys are function binary input values and values are function output values.
opt_params: Dictionary
n_output_values: int
Number of possible output values N (Ex.: n_output_values=2 for a binary
function). Default value is the max value in ``params`` minus 1.
"""
self._name = "fn-points"
self._get_num_qubits(params)
default_n_output_values = max(params.values()) - 1
if opt_params is None:
self.n_output_values = default_n_output_values
else:
if opt_params.get("n_output_values") is None:
self.n_output_values = default_n_output_values
else:
self.n_output_values = opt_params.get("n_output_values")
self.n_output_values = max(self.n_output_values, default_n_output_values)
if label is None:
self._label = "FNSP"
super().__init__(self._name, self.num_qubits, params.items(), label)
def _define(self):
self.definition = self._define_initialize()
def _define_initialize(self):
reg_x = QuantumRegister(self.num_qubits, "x")
reg_g = QuantumRegister(self.num_qubits - 1, "g")
reg_c = QuantumRegister(2, "c")
circuit = QuantumCircuit(reg_x, reg_g, reg_c)
reg_x = reg_x[::-1] # qiskit reverse (qiskit little-endian)
bits_z0 = [int(k) for k in f"{0:0{self.num_qubits}b}"]
for idx_p, (input_z, output_s) in list(enumerate(self.params))[::-1]:
bits_z = [int(k) for k in input_z]
circuit.x(reg_c[1])
for j, k in enumerate(bits_z):
if bits_z0[j] != k:
circuit.cx(reg_c[1], reg_x[j])
bits_z0 = bits_z
circuit.cx(reg_c[1], reg_c[0])
circuit.x(reg_c[1])
self._apply_smatrix(
circuit, idx_p, output_s.real, reg_c
)
self._flipflop01(bits_z, circuit, reg_x)
circuit.ccx(reg_x[0], reg_x[1], reg_g[0])
self._flipflop01(bits_z, circuit, reg_x)
for k in range(2, self.num_qubits):
if bits_z[k] == 0:
circuit.x(reg_x[k])
circuit.ccx(reg_x[k], reg_g[k - 2], reg_g[k - 1])
if bits_z[k] == 0:
circuit.x(reg_x[k])
circuit.cx(reg_g[self.num_qubits - 2], reg_c[0])
for k in range(self.num_qubits - 1, 1, -1):
if bits_z[k] == 0:
circuit.x(reg_x[k])
circuit.ccx(reg_x[k], reg_g[k - 2], reg_g[k - 1])
if bits_z[k] == 0:
circuit.x(reg_x[k])
self._flipflop01(bits_z, circuit, reg_x)
circuit.ccx(reg_x[0], reg_x[1], reg_g[0])
self._flipflop01(bits_z, circuit, reg_x)
circuit.x(reg_c[1])
return circuit
def _apply_smatrix(self, circuit, idx_p, output_s, reg_c):
theta = -2 * np.arccos(np.sqrt(idx_p / (idx_p + 1)))
# This sign is here for the smaller values of "s" to be represented by
# negative amplitudes and the larger ones by positive amplitudes.
# In the paper this negative sign is missing. Without it the matrix S
# is not unitary.
lamb = -output_s * 2 * np.pi / self.n_output_values
phi = -lamb
circuit.cu(theta, phi, lamb, 0, reg_c[0], reg_c[1])
@staticmethod
def _flipflop01(bits_z, circuit, reg_x):
if bits_z[0] == 0:
circuit.x(reg_x[0])
if bits_z[1] == 0:
circuit.x(reg_x[1])
@staticmethod
def initialize(q_circuit, state, qubits=None, opt_params=None):
if qubits is None:
q_circuit.append(
FnPointsInitialize(state, opt_params=opt_params), q_circuit.qubits
)
else:
q_circuit.append(FnPointsInitialize(state, opt_params=opt_params), qubits)
|
https://github.com/kaelynj/Qiskit-HubbardModel
|
kaelynj
|
%matplotlib inline
import sys
sys.path.append('./src')
# Importing standard Qiskit libraries and configuring account
#from qiskit import QuantumCircuit, execute, Aer, IBMQ
#from qiskit.compiler import transpile, assemble
#from qiskit.tools.jupyter import *
#from qiskit.visualization import *
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
import ClassicalHubbardEvolutionChain as chc
import FullClassicalHubbardEvolutionChain as fhc
import random as rand
import scipy.linalg as la
numsites = 3
states_list = fhc.get_states(numsites)
hamil = fhc.get_hamiltonian(states_list, 1.0, 2.0)
print(hamil)
eigval, eigvec = la.eig(hamil)
#Attempt to get trotter error
def XX(theta):
theta2 = theta / 2
cos = np.cos(theta2)
isin = 1j * np.sin(theta2)
return np.array([[cos, 0, 0, -isin], [0, cos, -isin, 0], [0, -isin, cos, 0], [-isin, 0, 0, cos]])
def YY(theta):
cos = np.cos(theta / 2)
isin = 1j * np.sin(theta / 2)
return np.array([[cos, 0, 0, isin], [0, cos, -isin, 0], [0, -isin, cos, 0], [isin, 0, 0, cos]])
def ZZ(theta):
itheta2 = 1j * float(theta) / 2
return np.array(
[
[np.exp(-itheta2), 0, 0, 0],
[0, np.exp(itheta2), 0, 0],
[0, 0, np.exp(itheta2), 0],
[0, 0, 0, np.exp(-itheta2)],
])
def Z(theta):
itheta2 = 1j * float(theta)/2
return np.array([np.exp(-itheta2), 0], [0, np.exp(itehta2)])
t = 6.0
trotter_steps = np.arange(2,50,2)
U_over_t = 2.0
I = np.array([[1., 0.], [0., 1.]])
X = np.array([[0., 1.], [1., 0.]])
Y = np.array([[0., -1.j], [1.j, 0.]])
Z = np.array([[1., 0.],[0., -1.]])
for N in trotter_steps:
delta = t/N
H0_trot = np.tensordot(I, np.tensordot(ZZ(delta), I, axes=0), axes=0)
H1_trot = np.tensordot(XX(delta), np.tensordot(I, I, axes=0), axes=0)
H2_trot = np.tensordot(YY(delta), np.tensordot(I, I, axes=0), axes=0)
H3_trot = np.tensordot(I, np.tensordot(I, XX(delta), axes=0), axes=0)
H4_trot = np.tensordot(I, np.tensordot(I, YY(delta), axes=0), axes=0)
H_trot = np.matmul(H3_trot, H4_trot)
H_trot = np.matmul(H2_trot, H_trot)
H_trot = np.matmul(H1_trot, H_trot)
H_trot = np.matmul(H0_trot, H_trot)
for step in range(N):
H_trot = np.matmul(H_trot, H_trot)
H0 = np.tensordot(I, np.tensordot(Z, np.tensordot(Z, I, axes=0), axes=0), axes=0)
H1 = np.tensordot(X, np.tensordot(X, np.tensordot(I, I, axes=0), axes=0), axes=0)
H2 = np.tensordot(Y, np.tensordot(Y, np.tensordot(I, I, axes=0), axes=0), axes=0)
H3 = np.tensordot(I, np.tensordot(I, np.tensordot(X, X, axes=0), axes=0), axes=0)
H4 = np.tensordot(I, np.tensordot(I, np.tensordot(Y, Y, axes=0), axes=0), axes=0)
H = H0 + H1 + H2 + H3 + H4
true_unitary = np.expm(-1j*H*t)
diff = np.linalg.norm(true_unitary - H_trot)
print("Trotter Steps: ", N, " Error: ",diff)
print(eigval)
#System parameters
numsites = 3
t = 1.0
U = 2.
classical_time_step = 0.01
classical_total_time = 500*0.01
times = np.arange(0., classical_total_time, classical_time_step)
states_list = fhc.get_states(numsites)
#Create full Hamiltonian
wfk_full = np.zeros(len(states_list))
#wfk_full[18] = 1. #010010
wfk_full[21] = 1. #010101
#wfk_full[2] = 1. #000010
evolution2, engs2, wfks = fhc.sys_evolve(states_list, wfk_full, t, U, classical_total_time, classical_time_step)
print(wfks[10])
print(evolution2)
#print(engs2)
colors = list(mcolors.TABLEAU_COLORS.keys())
fig2, ax2 = plt.subplots(figsize=(20,10))
for i in range(3):
#Create string label
strup = "Site "+str(i+1)+r'$\uparrow$'
strdwn = "Site "+str(i+1)+r'$\downarrow$'
ax2.plot(times, evolution2[:,i], linestyle='-', color=str(colors[i]), linewidth=2, label=strup)
ax2.plot(times, evolution2[:,i+3], linestyle='--', color=str(colors[i]), linewidth=2, label=strdwn)
plt.legend()
def get_bin(x, n=0):
"""
Get the binary representation of x.
Parameters: x (int), n (int, number of digits)"""
binry = format(x, 'b').zfill(n)
sup = list( reversed( binry[0:int(len(binry)/2)] ) )
sdn = list( reversed( binry[int(len(binry)/2):len(binry)] ) )
return format(x, 'b').zfill(n)
#==== Create all Possible States for given system size ===#
states_list = []
nsite = 3
for state in range(0, 2**(2*nsite)):
state_bin = get_bin(state, 2*nsite)
state_list = [[],[]]
for mode in range(0,nsite):
state_list[0].append(int(state_bin[mode]))
state_list[1].append(int(state_bin[mode+nsite]))
#print(state_list)
states_list.append(state_list)
def repel(l,state):
if state[0][l]==1 and state[1][l]==1:
return state
else:
return []
#Check if two states are different by a single hop
def hop(psii, psij, hopping):
#Check spin down
hopp = 0
if psii[0]==psij[0]:
#Create array of indices with nonzero values
hops = []
for site in range(len(psii[0])):
if psii[1][site] != psij[1][site]:
hops.append(site)
if len(hops)==2 and np.sum(psii[1]) == np.sum(psij[1]):
if hops[1]-hops[0]==1:
hopp = -hopping
return hopp
#Check spin up
if psii[1]==psij[1]:
hops = []
for site in range(len(psii[1])):
if psii[0][site] != psij[0][site]:
hops.append(site)
if len(hops)==2 and np.sum(psii[0])==np.sum(psij[0]):
if hops[1]-hops[0]==1:
hopp = -hopping
return hopp
return hopp
def get_hamiltonian(states, t, U):
H = np.zeros((len(states),len(states)) )
#Construct Hamiltonian matrix
for i in range(len(states)):
psi_i = states[i]
for j in range(i, len(states)):
psi_j = states[j]
if j==i:
for l in range(0,len(states[0][0])):
if psi_i == repel(l,psi_j):
H[i,j] = U
break
else:
#print('psi_i: ',psi_i,' psi_j: ',psi_j)
H[i,j] = hop(psi_i, psi_j, t)
H[j,i] = H[i,j]
return H
def get_mapping(states):
num_sites = len(states[0][0])
mode_list = []
for i in range(0,2*num_sites):
index_list = []
for state_index in range(0,len(states)):
state = states[state_index]
#Check spin-up modes
if i < num_sites:
if state[0][i]==1:
index_list.append(state_index)
#Check spin-down modes
else:
if state[1][i-num_sites]==1:
index_list.append(state_index)
if index_list:
mode_list.append(index_list)
return mode_list
def wfk_energy(wfk, hamil):
eng = np.dot(np.conj(wfk), np.dot(hamil, wfk))
return eng
def get_variance(wfk, h):
h_squared = np.matmul(h, h)
eng_squared = np.vdot(wfk, np.dot(h_squared, wfk))
squared_eng = np.vdot(wfk, np.dot(h, wfk))
var = np.sqrt(eng_squared - squared_eng)
return var
def sys_evolve(states, init_wfk, hopping, repulsion, total_time, dt):
hamiltonian = get_hamiltonian(states, hopping, repulsion)
t_operator = la.expm(-1j*hamiltonian*dt)
wavefunctions = []
mapping = get_mapping(states)
#print(mapping)
#Initalize system
tsteps = int(total_time/dt)
evolve = np.zeros([tsteps, len(init_wfk)])
mode_evolve = np.zeros([tsteps, len(mapping)])
wfk = init_wfk
wavefunctions.append(np.ndarray.tolist(wfk))
energies = np.zeros(tsteps)
#Store first time step in mode_evolve
evolve[0] = np.multiply(np.conj(wfk), wfk)
for i in range(0, len(mapping)):
wfk_sum = 0.
norm = 0.
for j in mapping[i]:
wfk_sum += evolve[0][j]
norm += evolve[0][j]
if norm == 0.:
norm = 1.
mode_evolve[0][i] = wfk_sum #/ norm
#print('wfk_sum: ',wfk_sum,' norm: ',norm)
energies[0] = wfk_energy(wfk, hamiltonian)
#print('Variance: ',get_variance(wfk, hamiltonian) )
#Now do time evolution
print(mode_evolve[0])
times = np.arange(0., total_time, dt)
for t in range(1, tsteps):
wfk = np.dot(t_operator, wfk)
evolve[t] = np.multiply(np.conj(wfk), wfk)
wavefunctions.append(np.ndarray.tolist(wfk))
#print(evolve[t])
energies[t] = wfk_energy(wfk, hamiltonian )
for i in range(0, len(mapping)):
norm = 0.
wfk_sum = 0.
for j in mapping[i]:
wfk_sum += evolve[t][j]
norm += evolve[t][j]
#print('wfk_sum: ',wfk_sum,' norm: ',norm)
if norm == 0.:
norm = 1.
mode_evolve[t][i] = wfk_sum #/ norm
#print(mode_evolve[t])
#Return time evolution
return mode_evolve, energies, wavefunctions
#System parameters
t = 1.0
U = 2.
classical_time_step = 0.01
classical_total_time = 500*0.01
times = np.arange(0., classical_total_time, classical_time_step)
#Create full Hamiltonian
wfk_full = np.zeros(len(states_list))
#wfk_full[18] = 1. #010010
wfk_full[21] = 1. #010101
#wfk_full[2] = 1. #000010
evolution2, engs2, wfks = sys_evolve(states_list, wfk_full, t, U, classical_total_time, classical_time_step)
print(wfks[10])
print(evolution2)
#print(engs2)
colors = list(mcolors.TABLEAU_COLORS.keys())
fig2, ax2 = plt.subplots(figsize=(20,10))
for i in range(3):
#Create string label
strup = "Site "+str(i+1)+r'$\uparrow$'
strdwn = "Site "+str(i+1)+r'$\downarrow$'
ax2.plot(times, evolution2[:,i], linestyle='-', color=str(colors[i]), linewidth=2, label=strup)
ax2.plot(times, evolution2[:,i+3], linestyle='--', color=str(colors[i]), linewidth=2, label=strdwn)
plt.legend()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from math import pi
import numpy as np
import rustworkx as rx
from qiskit_nature.second_q.hamiltonians.lattices import (
BoundaryCondition,
HyperCubicLattice,
Lattice,
LatticeDrawStyle,
LineLattice,
SquareLattice,
TriangularLattice,
)
from qiskit_nature.second_q.hamiltonians import FermiHubbardModel
num_nodes = 11
boundary_condition = BoundaryCondition.OPEN
line_lattice = LineLattice(num_nodes=num_nodes, boundary_condition=boundary_condition)
line_lattice.draw()
num_nodes = 11
boundary_condition = BoundaryCondition.PERIODIC
line_lattice = LineLattice(num_nodes=num_nodes, boundary_condition=boundary_condition)
line_lattice.draw()
line_lattice.draw_without_boundary()
num_nodes = 11
boundary_condition = BoundaryCondition.PERIODIC
edge_parameter = 1.0 + 1.0j
onsite_parameter = 1.0
line_lattice = LineLattice(
num_nodes=num_nodes,
edge_parameter=edge_parameter,
onsite_parameter=onsite_parameter,
boundary_condition=boundary_condition,
)
set(line_lattice.graph.weighted_edge_list())
line_lattice.to_adjacency_matrix()
line_lattice.to_adjacency_matrix(weighted=True)
rows = 5
cols = 4
boundary_condition = BoundaryCondition.OPEN
square_lattice = SquareLattice(rows=rows, cols=cols, boundary_condition=boundary_condition)
square_lattice.draw()
rows = 5
cols = 4
boundary_condition = (
BoundaryCondition.OPEN,
BoundaryCondition.PERIODIC,
) # open in the x-direction, periodic in the y-direction
square_lattice = SquareLattice(rows=rows, cols=cols, boundary_condition=boundary_condition)
square_lattice.draw()
rows = 5
cols = 4
edge_parameter = (1.0, 1.0 + 1.0j)
boundary_condition = (
BoundaryCondition.OPEN,
BoundaryCondition.PERIODIC,
) # open in the x-direction, periodic in the y-direction
onsite_parameter = 1.0
square_lattice = SquareLattice(
rows=rows,
cols=cols,
edge_parameter=edge_parameter,
onsite_parameter=onsite_parameter,
boundary_condition=boundary_condition,
)
set(square_lattice.graph.weighted_edge_list())
size = (3, 4, 5)
boundary_condition = (
BoundaryCondition.OPEN,
BoundaryCondition.OPEN,
BoundaryCondition.OPEN,
)
cubic_lattice = HyperCubicLattice(size=size, boundary_condition=boundary_condition)
# function for setting the positions
def indextocoord_3d(index: int, size: tuple, angle) -> list:
z = index // (size[0] * size[1])
a = index % (size[0] * size[1])
y = a // size[0]
x = a % size[0]
vec_x = np.array([1, 0])
vec_y = np.array([np.cos(angle), np.sin(angle)])
vec_z = np.array([0, 1])
return_coord = x * vec_x + y * vec_y + z * vec_z
return return_coord.tolist()
pos = dict([(index, indextocoord_3d(index, size, angle=pi / 4)) for index in range(np.prod(size))])
cubic_lattice.draw(style=LatticeDrawStyle(pos=pos))
rows = 4
cols = 3
boundary_condition = BoundaryCondition.OPEN
triangular_lattice = TriangularLattice(rows=rows, cols=cols, boundary_condition=boundary_condition)
triangular_lattice.draw()
rows = 4
cols = 3
boundary_condition = BoundaryCondition.PERIODIC
triangular_lattice = TriangularLattice(rows=rows, cols=cols, boundary_condition=boundary_condition)
triangular_lattice.draw()
graph = rx.PyGraph(multigraph=False) # multigraph shoud be False
graph.add_nodes_from(range(6))
weighted_edge_list = [
(0, 1, 1.0 + 1.0j),
(0, 2, -1.0),
(2, 3, 2.0),
(4, 2, -1.0 + 2.0j),
(4, 4, 3.0),
(2, 5, -1.0),
]
graph.add_edges_from(weighted_edge_list)
# make a lattice
general_lattice = Lattice(graph)
set(general_lattice.graph.weighted_edge_list())
general_lattice.draw()
general_lattice.draw(self_loop=True)
general_lattice.draw(self_loop=True, style=LatticeDrawStyle(with_labels=True))
square_lattice = SquareLattice(rows=5, cols=4, boundary_condition=BoundaryCondition.PERIODIC)
t = -1.0 # the interaction parameter
v = 0.0 # the onsite potential
u = 5.0 # the interaction parameter U
fhm = FermiHubbardModel(
square_lattice.uniform_parameters(
uniform_interaction=t,
uniform_onsite_potential=v,
),
onsite_interaction=u,
)
ham = fhm.second_q_op().simplify()
print(ham)
graph = rx.PyGraph(multigraph=False) # multiigraph shoud be False
graph.add_nodes_from(range(6))
weighted_edge_list = [
(0, 1, 1.0 + 1.0j),
(0, 2, -1.0),
(2, 3, 2.0),
(4, 2, -1.0 + 2.0j),
(4, 4, 3.0),
(2, 5, -1.0),
]
graph.add_edges_from(weighted_edge_list)
general_lattice = Lattice(graph) # the lattice whose weights are seen as the interaction matrix.
u = 5.0 # the interaction parameter U
fhm = FermiHubbardModel(lattice=general_lattice, onsite_interaction=u)
ham = fhm.second_q_op().simplify()
print(ham)
from qiskit_nature.second_q.problems import LatticeModelProblem
num_nodes = 4
boundary_condition = BoundaryCondition.OPEN
line_lattice = LineLattice(num_nodes=num_nodes, boundary_condition=boundary_condition)
fhm = FermiHubbardModel(
line_lattice.uniform_parameters(
uniform_interaction=t,
uniform_onsite_potential=v,
),
onsite_interaction=u,
)
lmp = LatticeModelProblem(fhm)
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit_nature.second_q.algorithms import GroundStateEigensolver
from qiskit_nature.second_q.mappers import JordanWignerMapper
numpy_solver = NumPyMinimumEigensolver()
qubit_mapper = JordanWignerMapper()
calc = GroundStateEigensolver(qubit_mapper, numpy_solver)
res = calc.solve(lmp)
print(res)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/pedrotelez/QuantumHelloWorld
|
pedrotelez
|
# Importing Qiskit
from qiskit import *
# Init 2 qubits and 2 classical bits
number_of_qubits = 2 # qubits
number_of_classical_bits = 2 # classical bits
Qr = QuantumRegister(number_of_qubits) # quantum register
Cr = ClassicalRegister(number_of_classical_bits) # classical register
# Building the circuit
circuit = QuantumCircuit(Qr, Cr)
# Adding gates to the circuit
circuit.h(Qr[0]) # Hadamard gate on Qubit 0
circuit.cx(Qr[0], Qr[1]) # CNOT gate on control Qubit 0 and target Qubit 1
# Measure the qubits [0, 1] and store the result in classical bits [0, 1]
circuit.measure(Qr, Cr)
# Draw the circuit
circuit.draw(output='mpl')
# the hello world of quantum computing
# 2 qubits, 2 classical bits
# Hadamard gate on Qubit 0
# CNOT gate on control Qubit 0 and target Qubit 1
# Measure the qubits [0, 1] and store the result in classical bits [0, 1]
# Hadamard gate means that the qubit is in superposition, so it has a 50% chance of being 0 or 1
# CNOT gate means that the qubit 1 is entangled with qubit 0, so if qubit 0 is 0, qubit 1 is 0, and if qubit 0 is 1, qubit 1 is 1
# Simulating the circuit in the local simulator
simulator = Aer.get_backend('qasm_simulator') # simulator
result = execute(circuit, backend=simulator).result() # execute the circuit on the simulator
# Plot the result
from qiskit.visualization import plot_histogram
plot_histogram(result.get_counts(circuit)) # plot the result
|
https://github.com/Z-928/Bugs4Q
|
Z-928
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.wrapper import available_backends, get_backend
from qiskit.wrapper import execute as q_execute
q = QuantumRegister(2, name='q')
c = ClassicalRegister(2, name='c')
qc = QuantumCircuit(q,c)
qc.h(q[0])
qc.h(q[1])
qc.cx(q[0], q[1])
qc.measure(q, c)
z = 0.995004165 + 1j * 0.099833417
z = z / abs(z)
u_error = np.array([[1, 0], [0, z]])
noise_params = {'U':
{'gate_time': 1,
'p_depol': 0.001,
'p_pauli': [0, 0, 0.01],
'U_error': u_error
}
}
config = {"noise_params": noise_params}
ret = q_execute(qc, 'local_qasm_simulator_cpp', shots=1024, config=config)
ret = ret.result()
print(ret.get_counts())
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, execute, Aer
from qiskit.tools.jupyter import *
provider = IBMQ.load_account()
# import basic plot tools
from qiskit.visualization import plot_histogram
def initialize(circuit, n, m):
circuit.h(range(n)) # Hadamard transform on measurment register
circuit.x(n+m-1) # X gate on last qubit
def c_amod15(a, x):
if a not in [2,7,8,11,13]:
raise ValueError("'a' must be 2,7,8,11 or 13") # remember that a needs to be co-prime with N
unitary = QuantumCircuit(4)
for iteration in range(x):
# bitwise arithmetic to represent modular exponentiation function
if a in [2,13]:
unitary.swap(0,1)
unitary.swap(1,2)
unitary.swap(2,3)
if a in [7,8]:
unitary.swap(2,3)
unitary.swap(1,2)
unitary.swap(0,1)
if a == 11:
unitary.swap(1,3)
unitary.swap(0,2)
if a in [7,11,13]:
for q in range(4):
unitary.x(q)
unitary = unitary.to_gate()
unitary.name = "%i^%i mod 15" % (a, x)
# But we need to make it a controlled operation for phase kickback
c_unitary = unitary.control()
return c_unitary
def modular_exponentiation(circuit, n, m, a):
for exp in range(n):
exponent = 2**exp
circuit.append(a_x_mod15(a, exponent), [exp] + list(range(n, n+m)))
from qiskit.circuit.library import QFT
def apply_iqft(circuit, measurement_qubits):
circuit.append(QFT( len(measurement_qubits), do_swaps=False).inverse(), measurement_qubits)
def shor_algo(n, m, a):
# set up the circuit
circ = QuantumCircuit(n+m, n)
# initialize the registers
initialize(circ, n, m)
circ.barrier()
# map modular exponentiation problem onto qubits
modular_exponentiation(circ, n, m, a)
circ.barrier()
# apply inverse QFT -- expose period
apply_iqft(circ, range(n))
# measure the measurement register
circ.measure(range(n), range(n))
return circ
n = 4; m = 4; a = 11
mycircuit = shor_algo(n, m, a)
mycircuit.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
counts = execute(mycircuit, backend=simulator, shots=1024).result().get_counts(mycircuit)
plot_histogram(counts)
for measured_value in counts:
print(f"Measured {int(measured_value[::-1], 2)}")
from math import gcd
from math import sqrt
from itertools import count, islice
for measured_value in counts:
measured_value_decimal = int(measured_value[::-1], 2)
print(f"Measured {measured_value_decimal}")
if measured_value_decimal % 2 != 0:
print("Failed. Measured value is not an even number")
continue
x = int((a ** (measured_value_decimal/2)) % 15)
if (x + 1) % 15 == 0:
print("Failed. x + 1 = 0 (mod N) where x = a^(r/2) (mod N)")
continue
guesses = gcd(x + 1, 15), gcd(x - 1, 15)
print(guesses)
def is_prime(n):
return n > 1 and all(n % i for i in islice(count(2), int(sqrt(n)-1)))
if is_prime(guesses[0]) and is_prime(guesses[1]):
print(f"**The prime factors are {guesses[0]} and {guesses[1]}**")
|
https://github.com/MonitSharma/Learn-Quantum-Computing-with-Qiskit
|
MonitSharma
|
from qiskit import QuantumCircuit, assemble, Aer
from math import pi, sqrt, exp
from qiskit.visualization import plot_bloch_multivector, plot_histogram
sim = Aer.get_backend('aer_simulator')
qc = QuantumCircuit(1)
qc.x(0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
qc = QuantumCircuit(1)
qc.y(0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
qc = QuantumCircuit(1)
qc.z(0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
qc = QuantumCircuit(1)
qc.h(0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
qc = QuantumCircuit(1)
qc.p(pi/4, 0)
qc.draw()
qc = QuantumCircuit(1)
qc.s(0) # Apply S-gate to qubit 0
qc.sdg(0) # Apply Sdg-gate to qubit 0
qc.draw()
qc = QuantumCircuit(1)
qc.t(0) # Apply T-gate to qubit 0
qc.tdg(0) # Apply Tdg-gate to qubit 0
qc.draw()
qc = QuantumCircuit(1)
qc.u(pi/2, 0, pi, 0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
initial_state =[1/sqrt(2), -1/sqrt(2)] # Define state |q_0>
qc = QuantumCircuit(1) # Must redefine qc
qc.initialize(initial_state, 0) # Initialize the 0th qubit in the state `initial_state`
qc.save_statevector() # Save statevector
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector() # Execute the circuit
print(state) # Print the result
qobj = assemble(qc)
results = sim.run(qobj).result().get_counts()
plot_histogram(results)
initial_state =[1/sqrt(2), 1/sqrt(2)] # Define state |q_0>
qc = QuantumCircuit(1) # Must redefine qc
qc.initialize(initial_state, 0) # Initialize the 0th qubit in the state `initial_state`
qc.save_statevector() # Save statevector
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector() # Execute the circuit
print(state) # Print the result
qobj = assemble(qc)
results = sim.run(qobj).result().get_counts()
plot_histogram(results)
# Create the Y-measurement function:
def x_measurement(qc, qubit, cbit):
"""Measure 'qubit' in the X-basis, and store the result in 'cbit'"""
qc.s(qubit)
qc.h(qubit)
qc.measure(qubit, cbit)
return qc
initial_state = [1/sqrt(2), -complex(0,1)/sqrt(2)]
# Initialize our qubit and measure it
qc = QuantumCircuit(1,1)
qc.initialize(initial_state, 0)
x_measurement(qc, 0, 0) # measure qubit 0 to classical bit 0
qc.draw()
qobj = assemble(qc) # Assemble circuit into a Qobj that can be run
counts = sim.run(qobj).result().get_counts() # Do the simulation, returning the state vector
plot_histogram(counts) # Display the output on measurement of state vector
|
https://github.com/aryashah2k/Quantum-Computing-Collection-Of-Resources
|
aryashah2k
|
%matplotlib inline
from qiskit import *
from qiskit.visualization import *
from qiskit.tools.monitor import *
circ_bell = QuantumCircuit(2,2) # We need two qubits and two classical bits (for the measurements)
circ_bell.h(0) # We apply the H gate on the first qubit
circ_bell.cx(0,1) # We apply the CNOT gate with control on the first qubit and target on the second
circ_bell.measure(range(2),range(2)) # Measurement
circ_bell.draw(output='mpl')
backend = Aer.get_backend('qasm_simulator')
job = execute(circ_bell, backend, shots=1000)
counts = job.result().get_counts()
print(counts)
circ_bell2 = QuantumCircuit(2)
circ_bell2.h(0)
circ_bell2.cx(0,1)
backend = Aer.get_backend('statevector_simulator')
job = execute(circ_bell2, backend)
state = job.result().get_statevector()
for i in range(4):
s = format(i,"b") # Convert to binary
s = (2-len(s))*"0"+s # Prepend zeroes if needed
print("Amplitude of",s,"=",state[i])
print()
for i in range(4):
s = format(i,"b") # Convert to binary
s = (2-len(s))*"0"+s # Prepend zeroes if needed
print("Probability of",s,"=",abs(state[i])**2)
provider = IBMQ.load_account()
backend_overview()
backend_monitor(provider.get_backend("ibmq_ourense"))
from qiskit.providers.ibmq import least_busy
# We execute on the least busy device (among the actual quantum computers)
backend = least_busy(provider.backends(operational = True, simulator=False, status_msg='active',
filters=lambda x: x.configuration().n_qubits > 1))
print("We are executing on...",backend)
print("It has",backend.status().pending_jobs,"pending jobs")
job_exp = execute(circ_bell, backend=backend)
job_monitor(job_exp)
result_exp = job_exp.result()
counts_exp = result_exp.get_counts(circ_bell)
plot_histogram([counts_exp,counts], legend=['Device', 'Simulator'])
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import qiskit
qiskit.__version__
from qiskit.circuit.library import XGate, CZGate, RZGate
from qiskit.circuit import QuantumCircuit
XGate() is XGate() is XGate() is XGate() is XGate() is XGate() is XGate() is XGate() is XGate()
CZGate() is CZGate() is CZGate() is CZGate() is CZGate() is CZGate() is CZGate() is CZGate() is CZGate() is CZGate() is CZGate() is CZGate() is CZGate()
gate = XGate()
print(f"name: {gate.name}")
print(f"params: {gate.params}")
print(f"matrix:\n{gate.to_matrix()}")
print(f"definition:\n{gate.definition}")
gate = XGate()
print(f"name: {gate.name}")
print(f"params: {gate.params}")
print(f"matrix:\n{gate.to_matrix()}")
print(f"definition:\n{gate.definition}")
import math
RZGate(math.pi) is RZGate(math.pi / 2)
RZGate(math.pi) is RZGate(math.pi)
gate = XGate()
try:
gate.label = "My bespoke x gate that gives me perfect results"
except TypeError as e:
print(e)
gate = XGate().to_mutable()
gate.label = "My bespoke x gate that gives me perfect results"
labelled_gate = XGate(label="My bespoke x gate that gives me perfect results")
print(labelled_gate.mutable)
qc = QuantumCircuit(1)
qc.append(gate, [0])
qc.append(labelled_gate, [0])
print(qc)
from qiskit import passmanager
class ToyPassManager(passmanager.BasePassManager):
"""Synthetic example PassManager that takes input "programs" integers operates on them as strings and returns a final integer
The transpiler's passmanager defines ``_passmanager_frontend`` as QuantumCircuit -> DAGCircuit and ``_passmanager_backend``
as DAGCircuit -> QuantumCircuit
"""
def _passmanager_frontend(self, input_program: int, **kwargs) -> str:
"""Convert input int to str "IR"""
return str(input_program)
def _passmanager_backend(self, passmanager_ir: str, in_program: int, **kwargs) -> int:
"""Convert str "IR" to output int"""
return int(passmanager_ir)
class RemoveFive(passmanager.GenericPass):
"""Pass for ToyPassManager that removes the number 5 from a string "IR"""
def run(self, passmanager_ir: str):
return passmanager_ir.replace("5", "")
pm = ToyPassManager(RemoveFive())
pm.run([123456789, 12345, 555552])
from qiskit.providers.fake_provider import FakeNairobiV2
from qiskit import transpile
qc = QuantumCircuit(5)
qc.x(4)
qc.h(range(5))
qc.cx(4, range(4))
tqc = transpile(qc, FakeNairobiV2(), optimization_level=3)
tqc.draw('mpl', fold=-1)
tqc.layout.initial_virtual_layout(filter_ancillas=True)
tqc.layout.final_index_layout()
from qiskit.circuit.library import RealAmplitudes
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import BackendEstimator
from qiskit.compiler import transpile
psi = RealAmplitudes(num_qubits=2, reps=2)
H1 = SparsePauliOp.from_list([("II", 1), ("IZ", 2), ("XI", 3)])
backend = FakeNairobiV2()
estimator = BackendEstimator(backend=backend, skip_transpilation=True)
thetas = [0, 1, 1, 2, 3, 5]
transpiled_psi = transpile(psi, backend, optimization_level=3)
# New in 0.45.0 inflate and permute:
print(f"original operator:\n{H1}\n")
permuted_op = H1.apply_layout(transpiled_psi.layout)
print(f"final layout: {transpiled_psi.layout.final_index_layout()}\n")
print(f"operator with layout applied:\n{permuted_op}\n")
res = estimator.run(transpiled_psi, permuted_op, thetas, shots=int(1e5)).result()
print(res)
|
https://github.com/OscarCharlieST/QISKIT_lab
|
OscarCharlieST
|
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, Aer
from qiskit.tools.visualization import circuit_drawer
import numpy as np
import time
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
circuit = QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.measure(qr[0],cr[0])
backend = Aer.get_backend('qasm_simulator')
exponent = np.arange(2,20,1) # 2^25 iterations is as much as I can calulate in a reasonable amound of time.
expectation = []
for s in [2**n for n in exponent]:
job = execute(circuit, backend, shots=s)
result=job.result().get_counts(circuit)
expectation.append((result['0']-result['1'])/(result['0']+result['1']))
fig = plt.figure(figsize=(10,5))
ax = fig.add_subplot()
ax.scatter(exponent, expectation)
ax.plot(exponent, exponent*0, c=(0.7,.7,0.7))
ax.set_ylabel('<Z> expectation value')
ax.set_xlabel('log2(number of itterations)')
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, Aer
from qiskit.visualization import circuit_drawer
import numpy as np
import pandas as pd
import time
def measure_z(circuit, c_bit, shots=1024):
"""
Takes a circuit and a classical bit, and returns the expectation value of the Z operator.
"""
circuit.measure([0],c_bit)
job = execute(circuit, backend, shots=shots)
result = job.result().get_counts(circuit)
keys = list(result.keys())
if set(keys) == set(['0','1']):
return (result['0']-result['1'])/(result['0']+result['1'])
elif keys == ['0']:
return 1.0
elif keys == ['1']:
return -1.0
def measure_x(circuit, c_bit, shots=1024):
"""
Takes a circuit and a classical bit, and returns the expectation value of the X operator.
"""
circuit.h([0])
circuit.measure([0],c_bit)
job = execute(circuit, backend, shots=shots)
result = job.result().get_counts(circuit)
keys = list(result.keys())
if set(keys) == set(['0','1']):
return (result['0']-result['1'])/(result['0']+result['1'])
elif keys == ['0']:
return 1.0
elif keys == ['1']:
return -1.0
def measure_y(circuit, c_bit, shots=1024):
"""
Takes a circuit and a classical bit, and returns the expectation value of the Y operator.
"""
circuit.s([0])
circuit.s([0])
circuit.s([0]) # using S^-1 = S^3
circuit.h([0])
circuit.measure([0],c_bit)
job = execute(circuit, backend, shots=shots)
result = job.result().get_counts(circuit)
keys = list(result.keys())
if set(keys) == set(['0','1']):
return (result['0']-result['1'])/(result['0']+result['1'])
elif keys == ['0']:
return 1.0
elif keys == ['1']:
return -1.0
def measure_method_2(theta, circuit, cr, shots=1024):
"""
Takes a parameter for the matrix M, and an input state circuit with an attached a classical register, and returns <M>
via the standard VQE method.
"""
xcircuit = circuit.copy()
x = measure_x(xcircuit, cr[0], shots=shots)
ycircuit = circuit.copy()
circuit_drawer(ycircuit)
y = measure_y(ycircuit, cr[0], shots=shots)
M = np.cos(theta)*x + np.sin(theta)*y
return M
def measure_method_1(theta, circuit, cr, shots=1024):
"""
Takes a parameter for the matrix M, and an input state circuit with an attached a classical register, and returns <M>
via the unitary basis rotation method.
"""
zcircuit = circuit.copy()
zcircuit.p(-theta, [0])
zcircuit.h([0])
M = measure_z(zcircuit, cr[0], shots=shots)
return M
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
backend = Aer.get_backend('qasm_simulator')
shots = 2**0 # Number of shots to obtain expectation value
N = 2**9 # The number of iterations used to see statistics of method
# Method 1
zcircuit = QuantumCircuit(qr, cr)
M1_1 = []
start=time.time()
for i in range(N):
M1_1.append(measure_method_1(np.pi/4, zcircuit, cr, shots=shots))
t1_1 = time.time()-start
print(f'Method 1: \nTime elapsed for {N} iterations of {shots} shots: ', t1_1)
print('Mean:', np.mean(M1_1))
print('Std. dev.:', np.std(M1_1))
# Method 2
circuit = QuantumCircuit(qr, cr)
M2_1 = []
start=time.time()
for i in range(N):
M2_1.append(measure_method_2(np.pi/4, circuit, cr, shots=shots))
t2_1 = time.time()-start
print(f'Method 2: \nTime elapsed for {N} iterations of {shots} shots: ', t2_1)
print('Mean:', np.mean(M2_1))
print('Std. dev.:', np.std(M2_1))
fig1, ax1 = plt.subplots(figsize=(8,5))
bins=np.histogram(np.hstack((M1_1,M2_1)), bins=40)[1]
ax1.hist(M1_1, bins, color='b', alpha=0.5, label=f'method 1 ({round(t1/N*1000, 2)} ms/iter)')
ax1.hist(M2_1, bins, color='r', alpha=0.5, label=f'method 2 ({round(t2/N*1000, 2)} ms/iter)')
ax1.axvline(0.0, linestyle='-', c='g', label='True value')
ax1.set_xlabel(r'Estimate of $\langle M\rangle$')
ax1.set_ylabel('Frequency')
ax1.set_title(f'Results of {N} simulations of {shots} shots for '+r'$\theta=\pi/4, \phi=\pi/8$')
ax1.legend()
def init_circuit(phi, qr, cr):
circuit = QuantumCircuit(qr, cr)
circuit.h([0])
circuit.p(-2*phi, [0])
circuit.h([0]) # Ignoring global phase
return circuit
# Method 1
zcircuit = init_circuit(np.pi/4, qr, cr)
M1_2 = []
start=time.time()
for i in range(N):
M1_2.append(measure_method_1(np.pi/8, zcircuit, cr, shots=shots))
t1_2 = time.time()-start
print(f'Method 1: \nTime elapsed for {N} iterations of {shots} shots: ', t1_2)
print('Mean:', np.mean(M1_2))
print('Std. dev.:', np.std(M1_2))
# Method 2
circuit = init_circuit(np.pi/4, qr, cr)
M2_2 = []
start=time.time()
for i in range(N):
M2_2.append(measure_method_2(np.pi/8, circuit, cr, shots=shots))
t2_2 = time.time()-start
print(f'Method 2: \nTime elapsed for {N} iterations of {shots} shots: ', t2_2)
print('Mean:', np.mean(M2_2))
print('Std. dev.:', np.std(M2_2))
fig1, ax1 = plt.subplots(figsize=(8,5))
bins=np.histogram(np.hstack((M1_2,M2_2)), bins=40)[1]
ax1.hist(M1_2, bins, color='b', alpha=0.5, label=f'method 1 ({round(t1/N*1000, 2)} ms/iter)')
ax1.hist(M2_2, bins, color='r', alpha=0.5, label=f'method 2 ({round(t2/N*1000, 2)} ms/iter)')
ax1.axvline(0.3827, linestyle='-', c='g', label='True value')
ax1.set_xlabel(r'Estimate of $\langle M\rangle$')
ax1.set_ylabel('Frequency')
ax1.set_title(f'Results of {N} simulations of {shots} shots for '+r'$\theta=\pi/4, \phi=\pi/8$')
ax1.legend()
shots = np.arange(1000, 100000, 1000)
s_exps = np.linspace(7, 17, 200)
#shots = [(2**exp)//1 for exp in s_exps]
# Method 1
zcircuit = init_circuit(np.pi/4, qr, cr)
M1 = []
t1 = []
for s in shots:
start=time.time()
M1.append(measure_method_1(np.pi/8, zcircuit, cr, shots=s))
end=time.time()
t1.append(end-start)
# Method 2
circuit = init_circuit(np.pi/4, qr, cr)
M2 = []
t2 = []
for s in shots:
start=time.time()
M2.append(measure_method_2(np.pi/8, circuit, cr, shots=s))
end=time.time()
t2.append(end-start)
fig, axs = plt.subplots(1,2,figsize=(16,5))
axs[0].plot(shots,t1, label='method 1')
axs[0].plot(shots,t2, label='method 2')
axs[0].set_xlabel('Number of shots')
axs[0].set_ylabel('Time taken')
axs[0].legend()
axs[1].scatter(shots,M1, label='method 1')
axs[1].scatter(shots,M2, label='method 2')
axs[1].axhline(np.sin(np.pi/8), label='expected value', c=(.7,.7,.7))
#axs[1].set_xlabel(r'$log_2(shots)$')
axs[1].set_ylabel(r'$\langle M\rangle')
axs[1].legend()
tps_1 = np.mean(np.array(t1)/np.array(shots))
tps_2 = np.mean(np.array(t2)/np.array(shots))
print('Ratio of time taken (method 2:method 1) = ', round(tps_2/tps_1, 3))
#s_exps = np.linspace(7, 14, 10)
#shots = [(2**exp)//1 for exp in s_exps]
shots_std = np.linspace(500,2000,15)
N=50
# Method 1
zcircuit = init_circuit(np.pi/4, qr, cr)
std1 = []
for s in shots_std:
m = []
for i in range(N):
m.append(measure_method_1(np.pi/8, zcircuit, cr, shots=s))
std1.append(np.std(m))
# Method 2
circuit = init_circuit(np.pi/4, qr, cr)
std2=[]
for s in shots_std:
m=[]
for i in range(N):
m.append(measure_method_2(np.pi/8, circuit, cr, shots=s))
std2.append(np.std(m))
fig, axs = plt.subplots(1,2,figsize=(16,5))
axs[0].plot(shots,t1, label='method 1', c='r')
axs[0].plot(shots,t2, label='method 2', c='b')
axs[0].set_xlabel('Number of shots')
axs[0].set_ylabel('Time taken')
axs[0].legend()
rt_s = np.sqrt(1/np.array(shots_std))
axs[1].scatter(rt_s, std1, label='method 1', c='r')
axs[1].plot(rt_s, rt_s*np.polyfit(rt_s, std1,1)[0]+ np.polyfit(rt_s, std1,1)[1],
c='r', alpha=.5, label='m='+str(round(np.polyfit(rt_s, std1,1)[0],3)))
axs[1].scatter(rt_s, std2, label='method 2', c='b')
axs[1].plot(rt_s, rt_s*np.polyfit(rt_s, std2,1)[0]+ np.polyfit(rt_s, std2,1)[1],
c='b', alpha=.5, label='m='+str(round(np.polyfit(rt_s, std2,1)[0],3)))
axs[1].set_xlabel(r'shots$^{-1/2}$')
axs[1].set_ylabel(r'$\Delta\langle M\rangle$')
axs[1].legend()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/aryashah2k/Quantum-Computing-Collection-Of-Resources
|
aryashah2k
|
%run qlatvia.py
draw_qubit()
draw_quantum_state(3/5,4/5,"u")
draw_quantum_state(3/5,-4/5,"u'")
# import all necessary objects and methods for quantum circuits
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
# import randrange for random choices
from random import randrange
#
# your code is here
#
# import all necessary objects and methods for quantum circuits
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
# import randrange for random choices
from random import randrange
number_of_qubit = 5
# define a quantum register with 5 qubits
q = QuantumRegister(number_of_qubit)
# define a classical register with 5 bits
c = ClassicalRegister(number_of_qubit)
# define our quantum circuit
qc = QuantumCircuit(q,c)
# apply h-gate to all qubits
for i in range(number_of_qubit):
qc.h(q[i])
# apply z-gate to randomly picked qubits
for i in range(number_of_qubit):
if randrange(2) == 0: # the qubit with index i is picked to apply z-gate
qc.z(q[i])
# apply h-gate to all qubits
for i in range(number_of_qubit):
qc.h(q[i])
qc.barrier()
# measure all qubits
qc.measure(q,c)
# draw the circuit
qc.draw(output='mpl')
# execute the circuit 1000 times in the local simulator
job = execute(qc,Aer.get_backend('qasm_simulator'),shots=1000)
counts = job.result().get_counts(qc)
print(counts)
%run qlatvia.py
draw_qubit()
sqrttwo=2**0.5
draw_quantum_state(1,0,"")
draw_quantum_state(1/sqrttwo,1/sqrttwo,"|+>")
%run qlatvia.py
draw_qubit()
sqrttwo=2**0.5
draw_quantum_state(0,1,"")
draw_quantum_state(1/sqrttwo,-1/sqrttwo,"|->")
%run qlatvia.py
draw_qubit()
sqrttwo=2**0.5
draw_quantum_state(1,0,"")
draw_quantum_state(1/sqrttwo,1/sqrttwo,"|+>")
draw_quantum_state(0,1,"")
draw_quantum_state(1/sqrttwo,-1/sqrttwo,"|->")
# line of reflection for Hadamard
from matplotlib.pyplot import arrow
arrow(-1.109,-0.459,2.218,0.918,linestyle='dotted',color='red')
# drawing the angle with |0>-axis
from matplotlib.pyplot import gca, text
from matplotlib.patches import Arc
gca().add_patch( Arc((0,0),0.4,0.4,angle=0,theta1=0,theta2=22.5) )
text(0.09,0.015,'.',fontsize=30)
text(0.25,0.03,'\u03C0/8')
gca().add_patch( Arc((0,0),0.4,0.4,angle=0,theta1=22.5,theta2=45) )
text(0.075,0.065,'.',fontsize=30)
text(0.21,0.16,'\u03C0/8')
%run qlatvia.py
draw_qubit()
# line of reflection for Hadamard
from matplotlib.pyplot import arrow
arrow(-1.109,-0.459,2.218,0.918,linestyle='dotted',color='red')
#
# your code is here
#
# randomly create a 2-dimensional quantum state
from math import cos, sin, pi
from random import randrange
def random_quantum_state2():
angle_degree = randrange(360)
angle_radian = 2*pi*angle_degree/360
return [cos(angle_radian),sin(angle_radian)]
%run qlatvia.py
draw_qubit()
# line of reflection for Hadamard
from matplotlib.pyplot import arrow
arrow(-1.109,-0.459,2.218,0.918,linestyle='dotted',color='red')
[x1,y1] = random_quantum_state2()
print(x1,y1)
sqrttwo=2**0.5
oversqrttwo = 1/sqrttwo
[x2,y2] = [ oversqrttwo*x1 + oversqrttwo*y1 , oversqrttwo*x1 - oversqrttwo*y1 ]
print(x2,y2)
draw_quantum_state(x1,y1,"main")
draw_quantum_state(x2,y2,"ref")
%run qlatvia.py
draw_qubit()
# the line y=x
from matplotlib.pyplot import arrow
arrow(-1,-1,2,2,linestyle='dotted',color='red')
#
# your code is here
#
# draw_quantum_state(x,y,"name")
# randomly create a 2-dimensional quantum state
from math import cos, sin, pi
from random import randrange
def random_quantum_state2():
angle_degree = randrange(360)
angle_radian = 2*pi*angle_degree/360
return [cos(angle_radian),sin(angle_radian)]
%run qlatvia.py
draw_qubit()
# the line y=x
from matplotlib.pyplot import arrow
arrow(-1,-1,2,2,linestyle='dotted',color='red')
[x1,y1] = random_quantum_state2()
[x2,y2] = [y1,x1]
draw_quantum_state(x1,y1,"main")
draw_quantum_state(x2,y2,"ref")
%run qlatvia.py
draw_qubit()
#
# your code is here
#
# line of reflection
# from matplotlib.pyplot import arrow
# arrow(x,y,dx,dy,linestyle='dotted',color='red')
#
#
# draw_quantum_state(x,y,"name")
|
https://github.com/matteoacrossi/oqs-jupyterbook
|
matteoacrossi
|
# Imports
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime
import json
import copy
# Main qiskit imports
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, execute, Aer, IBMQ
# Error mitigation
from qiskit.ignis.mitigation.measurement import (complete_meas_cal,
CompleteMeasFitter,
MeasurementFilter)
# Utility functions
from qiskit.tools.jupyter import *
from qiskit.tools.monitor import job_monitor
from qiskit.providers.jobstatus import JobStatus
# We use ibmqx2
IBMQ.load_account()
backend = IBMQ.get_provider(hub='ibm-q', group='open', project='main').get_backend('ibmqx2')
# Local simulator
simulator = Aer.get_backend('qasm_simulator')
def zz_pump(q, c, p, system, ancilla):
"""Returns a QuantumCircuit implementing the ZZ pump channel on the system qubits
Args:
q (QuantumRegister): the register to use for the circuit
c (ClassicalRegister): the register to use for the measurement of the system qubits
p (float): the efficiency for the channel, between 0 and 1
system (list): list of indices for the system qubits
ancilla (int): index for the ancillary qubit
Returns:
A QuantumCircuit object
"""
zz = QuantumCircuit(q, c)
theta = 2 * np.arcsin(np.sqrt(p))
# Map information to ancilla
zz.cx(q[system[0]], q[system[1]])
zz.x(q[ancilla])
zz.cx(q[system][1], q[ancilla])
# Conditional rotation
zz.cu3(theta, 0.0, 0.0, q[ancilla], q[system[1]])
# Inverse mapping
zz.cx(q[system[1]], q[ancilla])
# Measurement
zz.h(q[system[0]])
zz.measure(q[system[0]], c[0])
zz.measure(q[system[1]], c[1])
return zz
def xx_pump(q, c, p, system, ancilla):
"""Returns a QuantumCircuit implementing the XX pump channel on the system qubits
Args:
q (QuantumRegister): the register to use for the circuit
c (ClassicalRegister): the register to use for the measurement of the system qubits
p (float): the efficiency for the channel, between 0 and 1
system (list): list of indices for the system qubits
ancilla (int): index for the ancillary qubit
Returns:
A QuantumCircuit object
"""
xx = QuantumCircuit(q, c)
theta = 2 * np.arcsin(np.sqrt(p))
# Map information to ancilla
xx.cx(q[system[0]], q[system[1]])
xx.h(q[system[0]])
xx.x(q[ancilla])
xx.cx(q[system[0]], q[ancilla])
# Conditional rotation
xx.cu3(theta, 0.0, 0.0, q[ancilla], q[system[0]])
# Inverse mapping
xx.cx(q[system[0]], q[ancilla])
# Measurement
xx.measure(q[system[0]], c[0])
xx.measure(q[system[1]], c[1])
return xx
def zz_xx_pump(q, c, p, system, ancillae):
"""Returns a QuantumCircuit implementing the composition channel on the system qubits
Args:
q (QuantumRegister): the register to use for the circuit
c (ClassicalRegister): the register to use for the measurement of the system qubits
p (float): the efficiency for both channels, between 0 and 1
system (list): list of indices for the system qubits
ancillae (list): list of indices for the ancillary qubits
Returns:
A QuantumCircuit object
"""
zx = QuantumCircuit(q, c)
theta = 2 * np.arcsin(np.sqrt(p))
# ZZ pump
## Map information to ancilla
zx.cx(q[system[0]], q[system[1]])
zx.x(q[ancillae[0]])
zx.cx(q[system[1]], q[ancillae[0]])
## Conditional rotation
zx.cu3(theta, 0.0, 0.0, q[ancillae[0]], q[system[1]])
## Inverse mapping
zx.cx(q[system[1]], q[ancillae[0]])
# XX pump
## Map information to ancilla
zx.h(q[system[0]])
zx.x(q[ancillae[1]])
zx.cx(q[system[0]], q[ancillae[1]])
## Conditional rotation
zx.cu3(theta, 0.0, 0.0, q[ancillae[1]], q[system[0]])
## Inverse mapping
zx.cx(q[system[0]], q[ancillae[1]])
# Measurement
zx.measure(q[system[0]], c[0])
zx.measure(q[system[1]], c[1])
return zx
def initial_conditions(q, system):
"""Returns a dictionary containing four QuantumCircuit objects which prepare the two-qubit system in different initial states
Args:
q (QuantumRegister): the register to use for the circuit
system (list): list of indices for the system qubits
Returns:
A dictionary with the initial state QuantumCircuit objects and a list of labels
"""
# State labels
state_labels = ['00', '01', '10', '11']
ic = {}
for ic_label in state_labels:
ic[ic_label] = QuantumCircuit(q)
# |01>
ic['01'].x(q[system[0]])
# |10>
ic['10'].x(q[system[1]])
# |11>
ic['11'].x(q[system[0]])
ic['11'].x(q[system[1]])
return ic, state_labels
SHOTS = 8192
# The values for p
p_values = np.linspace(0, 1, 10)
# We create the quantum circuits
q = QuantumRegister(5, name='q')
c = ClassicalRegister(2, name='c')
## Index of the system qubit
system = [2, 1]
## Indices of the ancillary qubits
a_zz = 0
a_xx = 4
## Prepare the qubits in four initial conditions
ic_circs, ic_state_labels = initial_conditions(q, system)
## Three different channels, each with
## four initial conditions and ten values of p
pumps = ['ZZ', 'XX', 'ZZ_XX']
circuits = {}
for pump in pumps:
circuits[pump] = {}
for ic in ic_state_labels:
circuits[pump][ic] = []
for ic in ic_state_labels:
for p in p_values:
circuits['ZZ'][ic].append(ic_circs[ic]+zz_pump(q, c, p, system, a_zz))
circuits['XX'][ic].append(ic_circs[ic]+xx_pump(q, c, p, system, a_xx))
circuits['ZZ_XX'][ic].append(ic_circs[ic]+zz_xx_pump(q, c, p, system, [a_zz, a_xx]))
circuits['ZZ_XX']['00'][1].draw(output='mpl')
# Execute the circuits on the local simulator
jobs_sim = {}
for pump in pumps:
jobs_sim[pump] = {}
for ic in ic_state_labels:
jobs_sim[pump][ic] = execute(circuits[pump][ic], backend = simulator, shots = SHOTS)
# Analyse the outcomes
overlaps_sim = {}
for pump in pumps:
overlaps_sim[pump] = {}
for ic in ic_state_labels:
overlaps_sim[pump][ic] = [0.0]*len(p_values)
for i in range(len(p_values)):
for ic in ic_state_labels:
counts = jobs_sim[pump][ic].result().get_counts(i)
for outcome in counts:
overlaps_sim[pump][outcome][i] += counts[outcome]/(4.0 * float(SHOTS))
# Plot the results
fig_idx = 131
plt.figure(figsize=(15,6))
bell_labels = {'00': r"$| \phi^{+} \rangle$", '01': r"$| \phi^{-} \rangle$", '10': r"$| \psi^{+} \rangle$", '11': r"$| \psi^{-} \rangle$"}
for pump in pumps:
plt.subplot(fig_idx)
for outcome in overlaps_sim[pump]:
plt.plot(p_values, overlaps_sim[pump][outcome], label = bell_labels[outcome])
plt.xlabel('p')
plt.ylabel('Overlap')
fig_idx += 1
plt.grid()
plt.legend();
# Calibration circuits
cal_circuits, state_labels = complete_meas_cal(system, q, c)
# Run the calibration job
calibration_job = execute(cal_circuits, backend, shots=SHOTS)
# Run the circuits and save the jobs
jobs = {}
jobs_data = []
for pump in pumps:
jobs[pump] = {}
for ic in ic_state_labels:
jobs[pump][ic] = execute(circuits[pump][ic], backend = backend, shots = SHOTS)
# Use the calibration job to implement the error mitigation
meas_fitter = CompleteMeasFitter(calibration_job.result(), ic_state_labels)
meas_filter = meas_fitter.filter
overlaps = {}
for pump in pumps:
overlaps[pump] = {}
for ic in ic_state_labels:
overlaps[pump][ic] = [0.0]*len(p_values)
for i in range(len(p_values)):
for ic in ic_state_labels:
counts = meas_filter.apply(jobs[pump][ic].result()).get_counts(i)
for outcome in counts:
overlaps[pump][outcome][i] += counts[outcome]/(4 * float(SHOTS))
# Plot the results
fig_idx = 131
plt.figure(figsize=(15,6))
bell_labels = {'00': r"$| \phi^{+} \rangle$", '01': r"$| \phi^{-} \rangle$", '10': r"$| \psi^{+} \rangle$", '11': r"$| \psi^{-} \rangle$"}
for pump in pumps:
plt.subplot(fig_idx)
for outcome in overlaps[pump]:
plt.plot(p_values, overlaps[pump][outcome], label = bell_labels[outcome])
plt.xlabel('p')
plt.ylabel('Overlap')
fig_idx += 1
plt.grid()
plt.legend();
|
https://github.com/ctuning/ck-qiskit
|
ctuning
|
#!/usr/bin/env python3
import qiskit.tools.apps.optimization
num_of_qubits = 2
circuit_depth = 6
num_params = 2 * num_of_qubits * circuit_depth # make sure you set this correctly to the number of parameters used by the ansatz
## Previously used for Hydrogen VQE in QISKit implementation
#
def universal_ansatz(current_params, entangler_map=None):
if entangler_map==None:
# Which qubits to use (0 to 1 best to avoid qiskit bugs)
entangler_map = {1: [0]}
return qiskit.tools.apps.optimization.trial_circuit_ryrz(num_of_qubits, circuit_depth, current_params, entangler_map, None, False)
|
https://github.com/DRA-chaos/Quantum-Classical-Hyrid-Neural-Network-for-binary-image-classification-using-PyTorch-Qiskit-pipeline
|
DRA-chaos
|
!pip install qiskit
# check if CUDA is available
import torch
train_on_gpu = torch.cuda.is_available()
if not train_on_gpu:
print('CUDA is not available. Training on CPU ...')
else:
print('CUDA is available! Training on GPU ...')
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 import transpile, assemble
from qiskit.visualization import *
import numpy as np
import torch
from torch.autograd import Function
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from torchvision import datasets, transforms
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister, execute
from qiskit.circuit import Parameter
from qiskit import Aer
from tqdm import tqdm
from matplotlib import pyplot as plt
%matplotlib inline
def to_numbers(tensor_list):
num_list = []
for tensor in tensor_list:
num_list += [tensor.item()]
return num_list
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):
t_qc = transpile(self._circuit,
self.backend)
qobj = assemble(t_qc,
shots=self.shots,
parameter_binds = [{self.theta: theta} for theta in thetas])
job = self.backend.run(qobj)
result = job.result().get_counts()
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])
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)
import torchvision
transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()]) # transform images to tensors/vectors
cifar_trainset = datasets.CIFAR10(root='./data1', train=True, download=True, transform=transform)
len(cifar_trainset)
from torch.utils.data import DataLoader, random_split
#cifar_trainset = datasets.CIFAR10(root='./data1', train=True, download=True, transform=transform)
labels = cifar_trainset.targets # get the labels for the data
labels = np.array(labels)
idx1 = np.where(labels == 0) # filter on aeroplanes
idx2 = np.where(labels == 1) # filter on automobiles
# Specify number of datapoints per class (i.e. there will be n pictures of automobiles and n pictures of aeroplanes in the training set)
n=100
# concatenate the data indices
idx = np.concatenate((idx1[0][0:n],idx2[0][0:n]))
# create the filtered dataset for our training set
cifar_trainset.targets = labels[idx]
cifar_trainset.data = cifar_trainset.data[idx]
cifar_trainset, valid = random_split(cifar_trainset,[150,50])
train_loader = torch.utils.data.DataLoader(cifar_trainset, batch_size=1, shuffle=True)
valid_loader = torch.utils.data.DataLoader(valid, batch_size=1, shuffle=True)
@torch.no_grad()
def get_all_preds(model, train_loader):
all_preds = torch.tensor([])
for batch in train_loader:
images, labels = batch
preds = model(images)
all_preds = torch.cat(
(all_preds, preds)
,dim=0
)
return all_preds
import numpy as np
import matplotlib.pyplot as plt
n_samples_show = 6
data_iter = iter(train_loader)
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 2))
while n_samples_show > 0:
images, targets = data_iter.__next__()
images=images.squeeze()
axes[n_samples_show - 1].imshow(images[0].numpy(), 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
import torchvision
transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()]) # transform images to tensors/vectors
cifar_testset = datasets.CIFAR10(root='./data1', train=False, download=True, transform=transform)
labels = cifar_testset.targets # get the labels for the data
labels = np.array(labels)
idx1 = np.where(labels == 0) # filter on aeroplanes
idx2 = np.where(labels == 1) # filter on automobiles
# Specify number of datapoints per class (i.e. there will be n pictures of automobiles and n pictures of aeroplanes in the training set)
n=100
# concatenate the data indices
idx = np.concatenate((idx1[0][0:n],idx2[0][0:n]))
# create the filtered dataset for our training set
cifar_testset.targets = labels[idx]
cifar_testset.data = cifar_testset.data[idx]
test_loader = torch.utils.data.DataLoader(cifar_testset, batch_size=1, shuffle=False)
len(cifar_testset)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.dropout = nn.Dropout2d()
self.fc1 = nn.Linear(500, 500)
self.fc2 = nn.Linear(500, 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)
%matplotlib inline
import matplotlib.pyplot as plt
model = Net()
valid_loss_min = np.Inf # track change in validation loss
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 5
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
if (validation_loss)<=(valid_loss_min):
print('Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...'.format(
valid_loss_min,
validation_loss))
torch.save(model.state_dict(), 'model_cifar.pt')
valid_loss_min = validation_loss
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
model.load_state_dict(torch.load('model_cifar.pt'))
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
%matplotlib inline
import matplotlib.pyplot as plt
model = Net()
valid_loss_min = np.Inf # track change in validation loss
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 3
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
if (validation_loss)<=(valid_loss_min):
print('Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...'.format(
valid_loss_min,
validation_loss))
torch.save(model.state_dict(), 'model_cifar.pt')
valid_loss_min = validation_loss
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
%matplotlib inline
import matplotlib.pyplot as plt
model = Net()
valid_loss_min = np.Inf # track change in validation loss
optimizer = optim.Adam(model.parameters(), lr=0.0008)
loss_func = nn.NLLLoss()
epochs = 15
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
if (validation_loss)<=(valid_loss_min):
print('Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...'.format(
valid_loss_min,
validation_loss))
torch.save(model.state_dict(), 'model_cifar.pt')
valid_loss_min = validation_loss
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
model.load_state_dict(torch.load('model_cifar.pt'))
total_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)
)
%matplotlib inline
import matplotlib.pyplot as plt
model = Net()
valid_loss_min = np.Inf # track change in validation loss
optimizer = optim.Adam(model.parameters(), lr=0.0008)
loss_func = nn.NLLLoss()
epochs = 25
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
if (validation_loss)<=(valid_loss_min):
print('Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...'.format(
valid_loss_min,
validation_loss))
torch.save(model.state_dict(), 'model_cifar.pt')
valid_loss_min = validation_loss
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
%matplotlib inline
import matplotlib.pyplot as plt
model = Net()
valid_loss_min = np.Inf # track change in validation loss
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 5
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
if (validation_loss)<=(valid_loss_min):
print('Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...'.format(
valid_loss_min,
validation_loss))
torch.save(model.state_dict(), 'model_cifar.pt')
valid_loss_min = validation_loss
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
%matplotlib inline
import matplotlib.pyplot as plt
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 5
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
%matplotlib inline
import matplotlib.pyplot as plt
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 5
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0005)
loss_func = nn.NLLLoss()
epochs = 5
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train 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)
data=data.squeeze()
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
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0005)
loss_func = nn.NLLLoss()
epochs = 10
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0005)
loss_func = nn.NLLLoss()
epochs = 7
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0005)
loss_func = nn.NLLLoss()
epochs = 8
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0005)
loss_func = nn.NLLLoss()
epochs = 9
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0005)
loss_func = nn.NLLLoss()
epochs = 6
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0004)
loss_func = nn.NLLLoss()
epochs = 6
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0003)
loss_func = nn.NLLLoss()
epochs = 5
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0008)
loss_func = nn.NLLLoss()
epochs = 7
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
model = Net()
optimizer = optim.SGD(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 10
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 15
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.01)
loss_func = nn.NLLLoss()
epochs = 15
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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 train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0005)
loss_func = nn.NLLLoss()
epochs = 15
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0005)
loss_func = nn.NLLLoss()
epochs = 10
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0005)
loss_func = nn.NLLLoss()
epochs = 3
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0005)
loss_func = nn.NLLLoss()
epochs = 7
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0008)
loss_func = nn.NLLLoss()
epochs = 10
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0008)
loss_func = nn.NLLLoss()
epochs = 15
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0008)
loss_func = nn.NLLLoss()
epochs = 5
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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)
)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.0008)
loss_func = nn.NLLLoss()
epochs = 3
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_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()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_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)
)
|
https://github.com/quantumyatra/quantum_computing
|
quantumyatra
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute, BasicAer
from qiskit.visualization import plot_bloch_multivector
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
qc = QuantumCircuit(3, 2)
print(qc.qregs)
print(qc.cregs)
##This is equivalent to the following.
qr = QuantumRegister(3, name='q')
cr = ClassicalRegister(2, name='c')
qc = QuantumCircuit(qr, cr)
# Checking the quantum and classical registers
print(qc.qregs)
print(qc.cregs)
bell = QuantumCircuit(2, 2)
bell.h(0)
bell.cx(0, 1)
#Syntax: QuantumCircuit.measure(qubit, cbit)
bell.measure([0,1], [0,1])
bell.draw(output='mpl')
qr1 = QuantumRegister(1, 'q1')
qr2 = QuantumRegister(1, 'q2')
cr = ClassicalRegister(2, 'c')
circuit = QuantumCircuit(qr2, qr1, cr)
print('Qubit ordering:', circuit.qubits) # quantum
print('Classical bit ordering:', circuit.clbits) # classical
circuit.h([1,0]) # hadamard gate on both 1 and 0 qubits
circuit.measure(1, [0,1]) # 1 qubit and 2 clbit
circuit.draw(output='mpl')
from qiskit.circuit import Gate
# Syntax Gate(name, num_qubits, params, label=None)
my_gate = Gate(name='my_gate', num_qubits=2, params=[])
print (my_gate.params)
circ = QuantumCircuit(qr)
circ.h(0)
circ.append(my_gate, [qr[0], qr[1]])
circ.append(my_gate, [qr[1], qr[2]])
circ.draw(output='mpl')
from qiskit.circuit import QuantumCircuit, Parameter
theta = Parameter('theta')
test_ckt = QuantumCircuit(3)
#Syntax crz(theta, control_qubit, target_qubit, *, ctl=None, tgt=None)
test_ckt.crz(theta,0,2)
test_ckt.crz(theta,1,2)
test_ckt.barrier(0)
test_ckt.barrier()
test_ckt.draw(output='mpl')
from qiskit.extensions import HGate
print (f"Matrix(HGate):\n {HGate().to_matrix() } \n")
qcN = QuantumCircuit(2, 2)
qcN.h(0)
#qcN.cx(0, 1)
qcN.measure([0, 1], [0, 1])
backend = BasicAer.get_backend('statevector_simulator')
res = execute(qcN, backend).result()
out_state = res.get_statevector(qcN, decimals=3)
print (out_state)
plot_bloch_multivector(out_state)
# Build a sub-circuit
sub_q = QuantumRegister(2)
sub_circ = QuantumCircuit(sub_q, name='sub_circ')
sub_circ.h(sub_q[0])
sub_circ.crz(1, sub_q[0], sub_q[1])
sub_circ.barrier()
sub_circ.i(sub_q[1])
sub_circ.u3(1, 2, -2, sub_q[0])
sub_circ.draw('mpl')
# Convert to a gate and stick it into an arbitrary place in the bigger ckt
sub_inst = sub_circ.to_instruction()
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
#circ.cx(qr[1], qr[2])
#circ.append(sub_inst, [q[1], q[2]])
#circ.append(sub_circ, [q[1], q[2]])
circ.draw('mpl')
decomposed_circ = circ.decompose() # Does not modify original circuit
decomposed_circ.draw(output='mpl')
from qiskit.circuit import Parameter
%matplotlib inline
n=5
theta = Parameter('theta')
qc = QuantumCircuit(n, 1)
qc.h(0)
for i in range(n-1):
qc.cx(i, i+1)
qc.barrier()
qc.rz(theta, range(n))
#qc.rz(theta, [0,4])
qc.barrier()
for i in reversed(range(n-1)):
qc.cx(i, i+1)
qc.h(0)
qc.measure(0, 0)
qc.draw(output='mpl')
theta_range = np.linspace(0, 2 * np.pi, 128)
circuits = [qc.bind_parameters({theta: theta_val})
for theta_val in theta_range]
print(circuits[-1].draw(fold=120))
print(circuits[-1].parameters)### Binding parameters to values
job = execute(qc,
backend=BasicAer.get_backend('qasm_simulator'),
parameter_binds=[{theta: theta_val} for theta_val in theta_range],
shots=2000)
counts = [job.result().get_counts(i) for i in range(len(job.result().results))]
plt.figure(figsize=(8,4))
plt.plot(theta_range, list(map(lambda c: c.get('0', 0), counts)), '-.', label='0', color='green')
plt.plot(theta_range, list(map(lambda c: c.get('1', 0), counts)), '-.', label='1', color='maroon')
labs = ['0', r'$\frac{\pi}{2}$', r'$\pi$', r'$\frac{3\pi}{2}$', r'$2\pi$']
plt.xticks([i * np.pi / 2 for i in range(5)], labs, fontsize=16)
plt.xlabel('$\\theta$', fontsize=16);
plt.legend();
import time
from itertools import combinations
from qiskit.compiler import transpile, assemble
from qiskit.test.mock import FakeTokyo
start = time.time()
qcs = []
theta_range = np.linspace(0, 2*np.pi, 16)
for n in theta_range:
qc = QuantumCircuit(5)
for k in range(8):
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qc.rz(n, range(5))
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qcs.append(qc)
compiled_circuits = transpile(qcs, backend=FakeTokyo())
qobj = assemble(compiled_circuits, backend=FakeTokyo())
end = time.time()
print('Time compiling over set of bound circuits: ', end-start)
start = time.time()
qc = QuantumCircuit(5)
theta = Parameter('theta')
for k in range(4):
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qc.rz(theta, range(5))
for i,j in combinations(range(5), 2):
qc.cx(i,j)
transpiled_qc = transpile(qc, backend=FakeTokyo())
qobj = assemble([transpiled_qc.bind_parameters({theta: n})
for n in theta_range], backend=FakeTokyo())
end = time.time()
print('Time compiling over parameterized circuit, then binding: ', end-start)
phi = Parameter('phi')
sub_circ1 = QuantumCircuit(2, name='sc_1')
sub_circ1.rz(phi, 0)
sub_circ1.rx(phi, 1)
sub_circ2 = QuantumCircuit(2, name='sc_2')
sub_circ2.rx(phi, 0)
sub_circ2.rz(phi, 1)
qc = QuantumCircuit(4)
qr = qc.qregs[0]
qc.append(sub_circ1.to_instruction(), [qr[0], qr[1]])
qc.append(sub_circ2.to_instruction(), [qr[0], qr[1]])
qc.append(sub_circ2.to_instruction(), [qr[2], qr[3]])
print(qc.draw())
# The following raises an error: "QiskitError: 'Name conflict on adding parameter: phi'"
# phi2 = Parameter('phi')
# qc.u3(0.1, phi2, 0.3, 0)
p = Parameter('p')
qc = QuantumCircuit(3, name='oracle')
qc.rz(p, 0)
qc.cx(0, 1)
qc.rz(p, 1)
qc.cx(1, 2)
qc.rz(p, 2)
theta = Parameter('theta')
phi = Parameter('phi')
gamma = Parameter('gamma')
qr = QuantumRegister(9)
larger_qc = QuantumCircuit(qr)
larger_qc.append(qc.to_instruction({p: theta}), qr[0:3])
larger_qc.append(qc.to_instruction({p: phi}), qr[3:6])
larger_qc.append(qc.to_instruction({p: gamma}), qr[6:9])
print(larger_qc.draw())
print(larger_qc.decompose().draw())
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import pulse
from qiskit.providers.fake_provider import FakeArmonk
backend = FakeArmonk()
with pulse.build(backend) as drive_sched:
d0 = pulse.drive_channel(0)
a0 = pulse.acquire_channel(0)
pulse.play(pulse.library.Constant(10, 1.0), d0)
pulse.delay(20, d0)
pulse.shift_phase(3.14/2, d0)
pulse.set_phase(3.14, d0)
pulse.shift_frequency(1e7, d0)
pulse.set_frequency(5e9, d0)
with pulse.build() as temp_sched:
pulse.play(pulse.library.Gaussian(20, 1.0, 3.0), d0)
pulse.play(pulse.library.Gaussian(20, -1.0, 3.0), d0)
pulse.call(temp_sched)
pulse.acquire(30, a0, pulse.MemorySlot(0))
drive_sched.draw()
|
https://github.com/UST-QuAntiL/qiskit-service
|
UST-QuAntiL
|
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit
qc = QuantumCircuit()
q = QuantumRegister(5, 'q')
c = ClassicalRegister(3, 'c')
qc.add_register(q)
qc.add_register(c)
qc.h(q[0])
qc.h(q[1])
qc.h(q[2])
qc.h(q[1])
qc.cx(q[2], q[3])
qc.cu1(0, q[1], q[0])
qc.cx(q[2], q[4])
qc.h(q[0])
qc.cu1(0, q[1], q[2])
qc.cu1(0, q[0], q[2])
qc.h(q[2])
qc.measure(q[0], c[0])
qc.measure(q[1], c[1])
qc.measure(q[2], c[2])
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import *
# Create a Quantum Circuit acting on a quantum register of three qubits
circ = QuantumCircuit(3)
# Add a H gate on qubit $q_{0}$, putting this qubit in superposition.
circ.h(0)
# Add a CX (CNOT) gate on control qubit $q_{0}$ and target qubit $q_{1}$, putting
# the qubits in a Bell state.
circ.cx(0, 1)
# Add a CX (CNOT) gate on control qubit $q_{0}$ and target qubit $q_{2}$, putting
# the qubits in a GHZ state.
circ.cx(0, 2)
circ.draw('mpl')
# Import Aer
from qiskit import Aer
# Run the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')
# Create a Quantum Program for execution
job = backend.run(circ)
result = job.result()
outputstate = result.get_statevector(circ, decimals=3)
print(outputstate)
from qiskit.visualization import plot_state_city
plot_state_city(outputstate)
# Run the quantum circuit on a unitary simulator backend
backend = Aer.get_backend('unitary_simulator')
job = backend.run(circ)
result = job.result()
# Show the results
print(result.get_unitary(circ, decimals=3))
# Create a Quantum Circuit
meas = QuantumCircuit(3, 3)
meas.barrier(range(3))
# map the quantum measurement to the classical bits
meas.measure(range(3), range(3))
# The Qiskit circuit object supports composition using
# the compose method.
circ.add_register(meas.cregs[0])
qc = circ.compose(meas)
#drawing the circuit
qc.draw()
# Use Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit
# to be 1024, which is the default.
job_sim = backend_sim.run(transpile(qc, backend_sim), shots=1024)
# Grab the results from the job.
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
print(counts)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Helper function for converting a dag to a circuit."""
import copy
from qiskit.circuit import QuantumCircuit, CircuitInstruction
def dag_to_circuit(dag, copy_operations=True):
"""Build a ``QuantumCircuit`` object from a ``DAGCircuit``.
Args:
dag (DAGCircuit): the input dag.
copy_operations (bool): Deep copy the operation objects
in the :class:`~.DAGCircuit` for the output :class:`~.QuantumCircuit`.
This should only be set to ``False`` if the input :class:`~.DAGCircuit`
will not be used anymore as the operations in the output
:class:`~.QuantumCircuit` will be shared instances and
modifications to operations in the :class:`~.DAGCircuit` will
be reflected in the :class:`~.QuantumCircuit` (and vice versa).
Return:
QuantumCircuit: the circuit representing the input dag.
Example:
.. plot::
:include-source:
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import circuit_to_dag
from qiskit.circuit.library.standard_gates import CHGate, U2Gate, CXGate
from qiskit.converters import dag_to_circuit
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.measure(q[0], c[0])
circ.rz(0.5, q[1]).c_if(c, 2)
dag = circuit_to_dag(circ)
circuit = dag_to_circuit(dag)
circuit.draw('mpl')
"""
name = dag.name or None
circuit = QuantumCircuit(
dag.qubits,
dag.clbits,
*dag.qregs.values(),
*dag.cregs.values(),
name=name,
global_phase=dag.global_phase,
)
circuit.metadata = dag.metadata
circuit.calibrations = dag.calibrations
for node in dag.topological_op_nodes():
op = node.op
if copy_operations:
op = copy.deepcopy(op)
circuit._append(CircuitInstruction(op, node.qargs, node.cargs))
circuit.duration = dag.duration
circuit.unit = dag.unit
return circuit
|
https://github.com/dkp-quantum/Tutorials
|
dkp-quantum
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import *
from qiskit.visualization import *
import numpy as np
# Create a quantum register with 2 qubits
q = QuantumRegister(2,'q')
# Form a quantum circuit
# Note that the circuit name is optional
qc = QuantumCircuit(q,name="first_qc")
# Display the quantum circuit
qc.draw()
# Add a Hadamard gate on qubit 0, putting this in superposition.
qc.h(0)
# Add a CX (CNOT) gate on control qubit 0
# and target qubit 1 to create an entangled state.
qc.cx(0, 1)
qc.draw()
# Create a classical register with 2 bits
c = ClassicalRegister(2,'c')
meas = QuantumCircuit(q,c,name="first_m")
meas.barrier(q)
meas.measure(q, c)
meas.draw()
# Quantum circuits can be added with + operations
# Add two pre-defined circuits
qc_all=qc+meas
qc_all.draw()
# Draw the quantum circuit in a different (slightly better) format
qc_all.draw(output='mpl')
# Create the quantum circuit with the measurement in one go.
qc_all = QuantumCircuit(q,c,name="2q_all")
qc_all.h(0)
qc_all.cx(0,1)
qc_all.barrier()
qc_all.measure(0,0)
qc_all.measure(1,1)
qc_all.draw(output='mpl')
# Use Aer's qasm_simulator
backend_q = Aer.get_backend('qasm_simulator')
# Execute the circuit on the qasm simulator.
job_sim1 = execute(qc_all, backend_q, shots=4096)
job_sim1.status()
# Grab the results from the job.
result_sim1 = job_sim1.result()
result_sim1
result_sim1.get_counts(qc_all)
plot_histogram(result_sim1.get_counts(qc_all))
# Use Aer's statevector_simulator
backend_sv = Aer.get_backend('statevector_simulator')
# Execute the circuit on the statevector simulator.
# It is important to note that the measurement has been excluded
job_sim2 = execute(qc, backend_sv)
# Grab the results from the job.
result_sim2 = job_sim2.result()
# Output the entire result
result_sim2
# See output state as a vector
outputstate = result_sim2.get_statevector(qc, decimals=5)
print(outputstate)
# Visualize density matrix
plot_state_city(outputstate)
# Create the quantum circuit with the measurement in one go.
qc_3 = QuantumCircuit(3,3,name="qc_bloch")
qc_3.x(1)
qc_3.h(2)
qc_3.barrier()
qc_3.draw(output='mpl')
# Execute the circuit on the statevector simulator.
# It is important to note that the measurement has been excluded
job_sim_bloch = execute(qc_3, backend_sv)
# Grab the results from the job.
result_sim_bloch = job_sim_bloch.result()
# See output state as a vector
output_bloch = result_sim_bloch.get_statevector(qc_3, decimals=5)
# Draw on the Bloch sphere
plot_bloch_multivector(output_bloch)
# Use Aer's unitary_simulator
backend_u = Aer.get_backend('unitary_simulator')
# Execute the circuit on the unitary simulator.
job_usim = execute(qc, backend_u)
# Grab the results from the job.
result_usim = job_usim.result()
result_usim
# Output the unitary matrix
unitary = result_usim.get_unitary(qc)
print('%s\n' % unitary)
# Create the quantum circuit with the measurement in one go.
qc_ex1 = QuantumCircuit(q,c,name="ex1")
# Put the first qubit in equal superposition
qc_ex1.h(0)
# Rest of the circuit
qc_ex1.x(1)
qc_ex1.cx(0,1)
qc_ex1.barrier()
qc_ex1.measure(0,0)
qc_ex1.measure(1,1)
qc_ex1.draw(output='mpl')
# Execute the circuit on the qasm simulator.
job_ex1 = execute(qc_ex1, backend_q, shots=4096)
job_ex1.status()
# Grab the results from the job.
result_ex1 = job_ex1.result()
result_ex1.get_counts(qc_ex1)
plot_histogram(result_ex1.get_counts(qc_ex1))
# Or get the histogram in one go
plot_histogram(job_ex1.result().get_counts(qc_ex1))
# Create a quantum register with 3 qubits
q3 = QuantumRegister(3,'q')
# Create a classical register with 3 qubits
c3 = ClassicalRegister(3,'c')
# Create the quantum circuit with the measurement in one go.
qc_ex2 = QuantumCircuit(q3,c3,name="ex1")
qc_ex2.ry(2*np.pi/3,0)
qc_ex2.cx(0,1)
qc_ex2.cx(1,2)
qc_ex2.barrier()
qc_ex2.measure(q3,c3)
qc_ex2.draw(output='mpl')
# Execute the circuit on the qasm simulator.
job_ex2 = execute(qc_ex2, backend_q, shots=4096)
# Grab the results from the job.
result_ex2 = job_ex2.result()
plot_histogram(result_ex2.get_counts(qc_ex2))
# Create a quantum register with 3 qubits
q3 = QuantumRegister(3,'q')
# Create a classical register with 3 qubits
c3 = ClassicalRegister(3,'c')
# Create the quantum circuit without a Toffoli gate
qc_toff = QuantumCircuit(q3,c3,name="ex1")
qc_toff.ry(2*np.pi/3,0)
qc_toff.h(1)
qc_toff.h(2)
qc_toff.barrier()
qc_toff.measure(q3,c3)
qc_toff.draw(output='mpl')
# Execute the circuit on the qasm simulator.
job_toff = execute(qc_toff, backend_q, shots=4096)
# Grab the results from the job.
result_toff = job_toff.result()
plot_histogram(result_toff.get_counts(qc_toff))
# Now, add a Toffoli gate
qc_toff = QuantumCircuit(q3,c3,name="ex1")
qc_toff.ry(2*np.pi/3,0)
qc_toff.h(1)
qc_toff.h(2)
qc_toff.ccx(1,2,0)
qc_toff.barrier()
qc_toff.measure(q3,c3)
qc_toff.draw(output='mpl')
# Execute the circuit on the qasm simulator.
job_toff = execute(qc_toff, backend_q, shots=4096)
# Grab the results from the job.
result_toff = job_toff.result()
plot_histogram(result_toff.get_counts(qc_toff))
IBMQ.disable_account()
provider = IBMQ.enable_account('IBM_TOKEN')
# provider = IBMQ.get_provider(hub='ibm-q-research')
provider.backends()
from qiskit.tools.monitor import backend_overview, backend_monitor, job_monitor
from qiskit.tools.visualization import plot_gate_map, plot_error_map
# Retrieve IBM Quantum device information
backend_overview()
# Let's get two quantum devices as an example
backend_qx2 = provider.get_backend('ibmqx2')
backend_vigo = provider.get_backend('ibmq_vigo')
backend_monitor(backend_qx2)
plot_error_map(backend_qx2)
backend_monitor(backend_vigo)
plot_error_map(backend_vigo)
#
# Create a 5-qubit GHZ state (i.e. (|00000> + |11111>)/sqrt(2))
q5 = QuantumRegister(5,'q')
c5 = ClassicalRegister(5,'c')
ghz5= QuantumCircuit(q5,c5)
ghz5.h(0)
for i in range(1,5):
ghz5.cx(0,i)
ghz5.barrier()
ghz5.measure(q5,c5)
ghz5.draw(output='mpl')
# Run the 5-qubit GHZ experiment on a 5-qubit device (try vigo)
job_exp1 = execute(ghz5, backend=backend_vigo, shots=4096)
job_monitor(job_exp1)
# Grab experimental results
result_vigo = job_exp1.result()
counts_vigo = result_vigo.get_counts(ghz5)
# Let's also try the same experiment on the 14-qubit device.
job_exp2 = execute(ghz5, backend=provider.get_backend('ibmq_16_melbourne'), shots=4096)
job_monitor(job_exp2)
# Grab experimental results
result_mel = job_exp2.result()
counts_mel = result_mel.get_counts(ghz5)
# Now, compare to theory by running it on qasm_simulator
job_qasm = execute(ghz5,backend=backend_q)
result_qasm = job_qasm.result()
counts_qasm = result_qasm.get_counts(ghz5)
# Plot both experimental and ideal results
plot_histogram([counts_qasm,counts_vigo,counts_mel],
color=['black','green','blue'],
legend=['QASM','Vigo','Melbourne'],figsize = [20,8])
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
# Importing standard Qiskit libraries and configuring account
from qiskit import *
from qiskit.visualization import *
from qiskit.circuit import Parameter
# Simple example
# Define two parameters, t1 and t2
theta1 = Parameter('t1')
theta2 = Parameter('t2')
# Build a 1-qubit circuit
qc = QuantumCircuit(1, 1)
# First parameter, t1, is used for a single qubit rotation of a controlled qubit
qc.ry(theta1,0)
qc.rz(theta2,0)
qc.barrier()
qc.measure(0, 0)
qc.draw(output='mpl')
theta1_range = np.linspace(0, 2 * np.pi, 20)
theta2_range = np.linspace(0, np.pi, 2)
circuits = [qc.bind_parameters({theta1: theta_val1, theta2: theta_val2})
for theta_val2 in theta2_range for theta_val1 in theta1_range ]
# Visualize several circuits to check that correct circuits are generated correctly.
display(circuits[0].draw(output='mpl'))
display(circuits[1].draw(output='mpl'))
display(circuits[20].draw(output='mpl'))
# Execute multiple circuits
job = execute(qc, backend=Aer.get_backend('qasm_simulator'), shots = 8192,
parameter_binds=[{theta1: theta_val1, theta2: theta_val2}
for theta_val2 in theta2_range for theta_val1 in theta1_range])
# Store all counts
counts = [job.result().get_counts(i) for i in range(len(job.result().results))]
# Plot to visualize the result
plt.figure(figsize=(12,6))
plt.plot(range(len(theta1_range)*len(theta2_range)),
list(map(lambda counts: (counts.get('0',0)-counts.get('1',1))/8192,counts)))
plt.show()
# IBMQ.disable_account()
provider = IBMQ.enable_account('TOKEN')
from qiskit.tools.monitor import backend_overview, backend_monitor, job_monitor
from qiskit.tools.visualization import plot_gate_map, plot_error_map
# Retrieve IBM Quantum device information
backend_overview()
# Execute multiple circuits
job_exp = execute(qc, backend=provider.get_backend('ibmq_essex'), shots = 8192,
parameter_binds=[{theta1: theta_val1, theta2: theta_val2}
for theta_val2 in theta2_range for theta_val1 in theta1_range])
# Monitor job status
job_monitor(job_exp)
# Store all counts
counts_exp = [job_exp.result().get_counts(i) for i in range(len(job_exp.result().results))]
# Plot to visualize the result
plt.figure(figsize=(12,6))
plt.rcParams.update({'font.size': 16})
plt.plot(range(len(theta1_range)*len(theta2_range)),
list(map(lambda counts: (counts.get('0',0)-counts.get('1',1))/8192,counts)),'r',label='Simulation')
plt.plot(range(len(theta1_range)*len(theta2_range)),
list(map(lambda counts_exp: (counts_exp.get('0',0)-counts_exp.get('1',1))/8192,counts_exp)),
'b',label='Experiment')
plt.legend(loc='best')
plt.show()
from qiskit.compiler import transpile
from qiskit.transpiler import PassManager, Layout
display(plot_error_map(provider.get_backend('ibmqx2')))
display(plot_error_map(provider.get_backend('ibmq_burlington')))
# Create a dummy circuit for default transpiler demonstration
qc = QuantumCircuit(4)
qc.h(0)
qc.swap(0,1)
qc.cx(1,0)
qc.s(3)
qc.x(3)
qc.h(3)
qc.h(0)
qc.cx(0,2)
qc.ccx(0,1,2)
qc.h(0)
print('Original circuit')
display(qc.draw(output='mpl'))
# Transpile the circuit to run on ibmqx2
qt_qx2 = transpile(qc,provider.get_backend('ibmqx2'))
print('Transpiled circuit for ibmqx2')
display(qt_qx2.draw(output='mpl'))
# Transpile the circuit to run on ibmq_burlington
qt_bu = transpile(qc,provider.get_backend('ibmq_burlington'))
print('Transpiled circuit for ibmqx_Burlington')
display(qt_bu.draw(output='mpl'))
# Print out some circuit properties
# Total nunmber of operations
print("Number of operations for ibmqx2 = %s" % qt_qx2.size())
print("Number of operations for ibmq_burlington = %s \n" % qt_bu.size())
# Circuit depth
print("Circuit depth for ibmqx2 = %s" % qt_qx2.depth())
print("Circuit depth for ibmq_burlington = %s \n" % qt_bu.depth())
# Number of qubits
print("Number of qubits for ibmqx2 = %s" % qt_qx2.width())
print("Number of qubits for ibmq_burlington = %s \n" % qt_bu.width())
# Breakdown of operations by type
print("Operations for ibmqx2: %s" % qt_qx2.count_ops())
print("Operations for ibmq_burlington: %s \n" % qt_bu.count_ops())
# Number of unentangled subcircuits in this circuit.
# In principle, each subcircuit can be executed on a different quantum device.
print("Number of unentangled subcircuits for ibmqx2 = %s" % qt_qx2.num_tensor_factors())
print("Number of unentangled subcircuits for ibmq_burlington = %s" % qt_bu.num_tensor_factors())
qr = QuantumRegister(4,'q')
cr = ClassicalRegister(4,'c')
qc_test = QuantumCircuit(qr,cr)
qc_test.h(0)
for i in range(3):
qc_test.cx(i,i+1)
qc_test.barrier()
qc_test.measure(qr,cr)
qc_test.draw(output='mpl')
qc_t = transpile(qc_test, backend = provider.get_backend('ibmq_london'))
# Display transpiled circuit
display(qc_t.draw(output='mpl'))
# Display the qubit layout
display(plot_error_map(provider.get_backend('ibmq_london')))
# Print out some circuit properties
# Total nunmber of operations
print("Number of operations = %s" % qc_t.size())
# Circuit depth
print("Circuit depth = %s" % qc_t.depth())
# Execute the circuit on the qasm simulator.
job_test = execute(qc_test, provider.get_backend('ibmq_london'), shots=8192)
job_monitor(job_test)
# Customize the layout
layout = Layout({qr[0]: 4, qr[1]: 3, qr[2]: 1, qr[3]:0})
# Map it onto 5 qubit backend ibmqx2
qc_test_new = transpile(qc_test, backend = provider.get_backend('ibmq_london'), initial_layout=layout, basis_gates=['u1','u2','u3','cx'])
display(qc_test_new.draw(output='mpl'))
# Print out some circuit properties
# Total nunmber of operations
print("Number of operations = %s" % qc_test_new.size())
# Circuit depth
print("Circuit depth = %s" % qc_test_new.depth())
# Execute the circuit on the qasm simulator.
job_test_new = execute(qc_test_new, provider.get_backend('ibmq_london'), shots=8192)
job_monitor(job_test_new)
# Now, compare the two
result_test = job_test.result()
result_test_new = job_test_new.result()
# Plot both experimental and ideal results
plot_histogram([result_test.get_counts(qc_test),result_test_new.get_counts(qc_test_new)],
color=['green','blue'],legend=['default','custom'],figsize = [20,8])
# Apply 4-qubit controlled x gate
qr = QuantumRegister(5,'q')
qc = QuantumCircuit(qr)
qc.h(0)
qc.h(1)
qc.h(3)
qc.ccx(0,1,2)
qc.ccx(2,3,4)
qc.ccx(0,1,2)
display(qc.draw(output='mpl'))
# Print out some circuit properties
# Total nunmber of operations
print("Number of operations = %s \n" % qc.size())
# Count different types of operations
print("Operation counts = %s \n" % qc.count_ops())
# Circuit depth
print("Circuit depth = %s" % qc.depth())
qc_t = transpile(qc, provider.get_backend('ibmq_valencia'))
display(qc_t.draw(output='mpl'))
# Print out some circuit properties
# Total nunmber of operations
print("Number of operations = %s" % qc_t.size())
# Circuit depth
print("Circuit depth = %s" % qc_t.depth())
# Transpile many times (20 times in this example) and pick the best one
trial = 20
# Use ibmq_valencia for example
backend_exp = provider.get_backend('ibmq_valencia')
tcircs0 = transpile([qc]*trial, backend_exp, optimization_level=0)
tcircs1 = transpile([qc]*trial, backend_exp, optimization_level=1)
tcircs2 = transpile([qc]*trial, backend_exp, optimization_level=2)
tcircs3 = transpile([qc]*trial, backend_exp, optimization_level=3)
import matplotlib.pyplot as plt
num_cx0 = [c.count_ops()['cx'] for c in tcircs0]
num_cx1 = [c.count_ops()['cx'] for c in tcircs1]
num_cx2 = [c.count_ops()['cx'] for c in tcircs2]
num_cx3 = [c.count_ops()['cx'] for c in tcircs3]
num_tot0 = [c.size() for c in tcircs0]
num_tot1 = [c.size() for c in tcircs1]
num_tot2 = [c.size() for c in tcircs2]
num_tot3 = [c.size() for c in tcircs3]
num_depth0 = [c.depth() for c in tcircs0]
num_depth1 = [c.depth() for c in tcircs1]
num_depth2 = [c.depth() for c in tcircs2]
num_depth3 = [c.depth() for c in tcircs3]
plt.rcParams.update({'font.size': 16})
# Plot the number of CNOT gates
plt.figure(figsize=(12,6))
plt.plot(range(len(num_cx0)),num_cx0,'r',label='level 0')
plt.plot(range(len(num_cx1)),num_cx1,'b',label='level 1')
plt.plot(range(len(num_cx2)),num_cx2,'g',label='level 2')
plt.plot(range(len(num_cx3)),num_cx3,'k',label='level 3')
plt.legend(loc='upper left')
plt.xlabel('Random trial')
plt.ylabel('# of cx gates')
plt.show()
# Plot total number of gates
plt.figure(figsize=(12,6))
plt.plot(range(len(num_tot0)),num_tot0,'r',label='level 0')
plt.plot(range(len(num_tot1)),num_tot1,'b',label='level 1')
plt.plot(range(len(num_tot2)),num_tot2,'g',label='level 2')
plt.plot(range(len(num_tot3)),num_tot3,'k',label='level 3')
plt.legend(loc='upper left')
plt.xlabel('Random trial')
plt.ylabel('# of total gates')
plt.show()
# Plot the number of CNOT gates
plt.figure(figsize=(12,6))
plt.plot(range(len(num_depth0)),num_depth0,'r',label='level 0')
plt.plot(range(len(num_depth1)),num_depth1,'b',label='level 1')
plt.plot(range(len(num_depth2)),num_depth2,'g',label='level 2')
plt.plot(range(len(num_depth3)),num_depth3,'k',label='level 3')
plt.legend(loc='upper left')
plt.xlabel('Random trial')
plt.ylabel('Circuit depth')
plt.show()
print('Opt0: Minimum # of cx gates = %s' % min(num_cx0))
print('Opt0: The best circuit is the circut %s \n' % num_cx0.index(min(num_cx0)))
print('Opt1: Minimum # of cx gates = %s' % min(num_cx1))
print('Opt1: The best circuit is the circut %s \n' % num_cx1.index(min(num_cx1)))
print('Opt2: Minimum # of cx gates = %s' % min(num_cx2))
print('Opt2: The best circuit is the circut %s \n' % num_cx2.index(min(num_cx2)))
print('Opt3: Minimum # of cx gates = %s' % min(num_cx3))
print('Opt3: The best circuit is the circut %s' % num_cx3.index(min(num_cx3)))
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Helper function for converting a circuit to an instruction."""
from qiskit.exceptions import QiskitError
from qiskit.circuit.instruction import Instruction
from qiskit.circuit.quantumregister import QuantumRegister
from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None, label=None):
"""Build an :class:`~.circuit.Instruction` object from a :class:`.QuantumCircuit`.
The instruction is anonymous (not tied to a named quantum register),
and so can be inserted into another circuit. The instruction will
have the same string name as the circuit.
Args:
circuit (QuantumCircuit): the input circuit.
parameter_map (dict): For parameterized circuits, a mapping from
parameters in the circuit to parameters to be used in the instruction.
If None, existing circuit parameters will also parameterize the
instruction.
equivalence_library (EquivalenceLibrary): Optional equivalence library
where the converted instruction will be registered.
label (str): Optional instruction label.
Raises:
QiskitError: if parameter_map is not compatible with circuit
Return:
qiskit.circuit.Instruction: an instruction equivalent to the action of the
input circuit. Upon decomposition, this instruction will
yield the components comprising the original circuit.
Example:
.. code-block::
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.converters import circuit_to_instruction
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.measure(q[0], c[0])
circ.rz(0.5, q[1]).c_if(c, 2)
circuit_to_instruction(circ)
"""
# pylint: disable=cyclic-import
from qiskit.circuit.quantumcircuit import QuantumCircuit
if parameter_map is None:
parameter_dict = {p: p for p in circuit.parameters}
else:
parameter_dict = circuit._unroll_param_dict(parameter_map)
if parameter_dict.keys() != circuit.parameters:
raise QiskitError(
(
"parameter_map should map all circuit parameters. "
"Circuit parameters: {}, parameter_map: {}"
).format(circuit.parameters, parameter_dict)
)
out_instruction = Instruction(
name=circuit.name,
num_qubits=circuit.num_qubits,
num_clbits=circuit.num_clbits,
params=[*parameter_dict.values()],
label=label,
)
out_instruction.condition = None
target = circuit.assign_parameters(parameter_dict, inplace=False)
if equivalence_library is not None:
equivalence_library.add_equivalence(out_instruction, target)
regs = []
if out_instruction.num_qubits > 0:
q = QuantumRegister(out_instruction.num_qubits, "q")
regs.append(q)
if out_instruction.num_clbits > 0:
c = ClassicalRegister(out_instruction.num_clbits, "c")
regs.append(c)
qubit_map = {bit: q[idx] for idx, bit in enumerate(circuit.qubits)}
clbit_map = {bit: c[idx] for idx, bit in enumerate(circuit.clbits)}
definition = [
instruction.replace(
qubits=[qubit_map[y] for y in instruction.qubits],
clbits=[clbit_map[y] for y in instruction.clbits],
)
for instruction in target.data
]
# fix condition
for rule in definition:
condition = getattr(rule.operation, "condition", None)
if condition:
reg, val = condition
if isinstance(reg, Clbit):
rule.operation.condition = (clbit_map[reg], val)
elif reg.size == c.size:
rule.operation.condition = (c, val)
else:
raise QiskitError(
"Cannot convert condition in circuit with "
"multiple classical registers to instruction"
)
qc = QuantumCircuit(*regs, name=out_instruction.name)
for instruction in definition:
qc._append(instruction)
if circuit.global_phase:
qc.global_phase = circuit.global_phase
out_instruction.definition = qc
return out_instruction
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# Copyright 2022-2023 Ohad Lev.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0,
# or in the root directory of this package("LICENSE.txt").
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
`SATInterface` class.
"""
import os
import json
from typing import List, Tuple, Union, Optional, Dict, Any
from sys import stdout
from datetime import datetime
from hashlib import sha256
from qiskit import transpile, QuantumCircuit, qpy
from qiskit.result.counts import Counts
from qiskit.visualization.circuit.text import TextDrawing
from qiskit.providers.backend import Backend
from qiskit.transpiler.passes import RemoveBarriers
from IPython import display
from matplotlib.figure import Figure
from sat_circuits_engine.util import timer_dec, timestamp, flatten_circuit
from sat_circuits_engine.util.settings import DATA_PATH, TRANSPILE_KWARGS
from sat_circuits_engine.circuit import GroverConstraintsOperator, SATCircuit
from sat_circuits_engine.constraints_parse import ParsedConstraints
from sat_circuits_engine.interface.circuit_decomposition import decompose_operator
from sat_circuits_engine.interface.counts_visualization import plot_histogram
from sat_circuits_engine.interface.translator import ConstraintsTranslator
from sat_circuits_engine.classical_processing import (
find_iterations_unknown,
calc_iterations,
ClassicalVerifier,
)
from sat_circuits_engine.interface.interactive_inputs import (
interactive_operator_inputs,
interactive_solutions_num_input,
interactive_run_input,
interactive_backend_input,
interactive_shots_input,
)
# Local globlas for visualization of charts and diagrams
IFRAME_WIDTH = "100%"
IFRAME_HEIGHT = "700"
class SATInterface:
"""
An interface for building, running and mining data from n-SAT problems quantum circuits.
There are 2 options to use this class:
(1) Using an interactive interface (intuitive but somewhat limited) - for this
just initiate a bare instance of this class: `SATInterface()`.
(2) Using the API defined by this class, that includes the following methods:
* The following descriptions are partial, for full annotations see the methods' docstrings.
- `__init__`: an instance of `SATInterface must be initiated with exactly 1 combination:
(a) (high_level_constraints_string + high_level_vars) - for constraints
in a high-level format.
(b) (num_input_qubits + constraints_string) - for constraints
in a low-level foramt.
* For formats annotations see `constriants_format.ipynb` in the main directory.
- `obtain_grover_operator`: obtains the suitable grover operator for the constraints.
- `save_display_grover_operator`: saves and displays data generated
by the `obtain_grover_operator` method.
- `obtain_overall_circuit`: obtains the suitable overall SAT circuit.
- `save_display_overall_circuit: saves and displays data generated
by the `obtain_overall_circuit` method.
- `run_overall_circuit`: executes the overall SAT circuit.
- `save_display_results`: saves and displays data generated
by the `run_overall_circuit` method.
It is very recommended to go through `demos.ipynb` that demonstrates the various optional uses
of this class, in addition to reading `constraints_format.ipynb`, which is a must for using
this package properly. Both notebooks are in ther main directory.
"""
def __init__(
self,
num_input_qubits: Optional[int] = None,
constraints_string: Optional[str] = None,
high_level_constraints_string: Optional[str] = None,
high_level_vars: Optional[Dict[str, int]] = None,
name: Optional[str] = None,
save_data: Optional[bool] = True,
) -> None:
"""
Accepts the combination of paramters:
(high_level_constraints_string + high_level_vars) or (num_input_qubits + constraints_string).
Exactly one combination is accepted.
In other cases either an iteractive user interface will be called to take user's inputs,
or an exception will be raised due to misuse of the API.
Args:
num_input_qubits (Optional[int] = None): number of input qubits.
constraints_string (Optional[str] = None): a string of constraints in a low-level format.
high_level_constraints_string (Optional[str] = None): a string of constraints in a
high-level format.
high_level_vars (Optional[Dict[str, int]] = None): a dictionary that configures
the high-level variables - keys are names and values are bits-lengths.
name (Optional[str] = None): a name for this object, if None than the
generic name "SAT" is given automatically.
save_data (Optional[bool] = True): if True, saves all data and metadata generated by this
class to a unique data folder (by using the `save_XXX` methods of this class).
Raises:
SyntaxError - if a forbidden combination of arguments has been provided.
"""
if name is None:
name = "SAT"
self.name = name
# Creating a directory for data to be saved
if save_data:
self.time_created = timestamp(datetime.now())
self.dir_path = f"{DATA_PATH}{self.time_created}_{self.name}/"
os.mkdir(self.dir_path)
print(f"Data will be saved into '{self.dir_path}'.")
# Initial metadata, more to be added by this class' `save_XXX` methods
self.metadata = {
"name": self.name,
"datetime": self.time_created,
"num_input_qubits": num_input_qubits,
"constraints_string": constraints_string,
"high_level_constraints_string": high_level_constraints_string,
"high_level_vars": high_level_vars,
}
self.update_metadata()
# Identifying user's platform, for visualization purposes
self.identify_platform()
# In the case of low-level constraints format, that is the default value
self.high_to_low_map = None
# Case A - interactive interface
if (num_input_qubits is None or constraints_string is None) and (
high_level_constraints_string is None or high_level_vars is None
):
self.interactive_interface()
# Case B - API
else:
self.high_level_constraints_string = high_level_constraints_string
self.high_level_vars = high_level_vars
# Case B.1 - high-level format constraints inputs
if num_input_qubits is None or constraints_string is None:
self.num_input_qubits = sum(self.high_level_vars.values())
self.high_to_low_map, self.constraints_string = ConstraintsTranslator(
self.high_level_constraints_string, self.high_level_vars
).translate()
# Case B.2 - low-level format constraints inputs
elif num_input_qubits is not None and constraints_string is not None:
self.num_input_qubits = num_input_qubits
self.constraints_string = constraints_string
# Misuse
else:
raise SyntaxError(
"SATInterface accepts the combination of paramters:"
"(high_level_constraints_string + high_level_vars) or "
"(num_input_qubits + constraints_string). "
"Exactly one combination is accepted, not both."
)
self.parsed_constraints = ParsedConstraints(
self.constraints_string, self.high_level_constraints_string
)
def update_metadata(self, update_metadata: Optional[Dict[str, Any]] = None) -> None:
"""
Updates the metadata file (in the unique data folder of a given `SATInterface` instance).
Args:
update_metadata (Optional[Dict[str, Any]] = None):
- If None - just dumps `self.metadata` into the metadata JSON file.
- If defined - updates the `self.metadata` attribute and then dumps it.
"""
if update_metadata is not None:
self.metadata.update(update_metadata)
with open(f"{self.dir_path}metadata.json", "w") as metadata_file:
json.dump(self.metadata, metadata_file, indent=4)
def identify_platform(self) -> None:
"""
Identifies user's platform.
Writes True to `self.jupyter` for Jupyter notebook, False for terminal.
"""
# If True then the platform is a terminal/command line/shell
if stdout.isatty():
self.jupyter = False
# If False, we assume the platform is a Jupyter notebook
else:
self.jupyter = True
def output_to_platform(
self,
*,
title: str,
output_terminal: Union[TextDrawing, str],
output_jupyter: Union[Figure, str],
display_both_on_jupyter: Optional[bool] = False,
) -> None:
"""
Displays output to user's platform.
Args:
title (str): a title for the output.
output_terminal (Union[TextDrawing, str]): text to print for a terminal platform.
output_jupyter: (Union[Figure, str]): objects to display for a Jupyter notebook platform.
can handle `Figure` matplotlib objects or strings of paths to IFrame displayable file,
e.g PDF files.
display_both_on_jupyter (Optional[bool] = False): if True, displays both
`output_terminal` and `output_jupyter` in a Jupyter notebook platform.
Raises:
TypeError - in the case of misusing the `output_jupyter` argument.
"""
print()
print(title)
if self.jupyter:
if isinstance(output_jupyter, str):
display.display(display.IFrame(output_jupyter, width=IFRAME_WIDTH, height=IFRAME_HEIGHT))
elif isinstance(output_jupyter, Figure):
display.display(output_jupyter)
else:
raise TypeError("output_jupyter must be an str (path to image file) or a Figure object.")
if display_both_on_jupyter:
print(output_terminal)
else:
print(output_terminal)
def interactive_interface(self) -> None:
"""
An interactive CLI that allows exploiting most (but not all) of the package's features.
Uses functions of the form `interactive_XXX_inputs` from the `interactive_inputs.py` module.
Divided into 3 main stages:
1. Obtaining Grover's operator for the SAT problem.
2. Obtaining the overall SAT cirucit.
3. Executing the circuit and parsing the results.
The interface is built in a modular manner such that a user can halt at any stage.
The defualt settings for the interactive user intreface are:
1. `name = "SAT"`.
2. `save_data = True`.
3. `display = True`.
4. `transpile_kwargs = {'basis_gates': ['u', 'cx'], 'optimization_level': 3}`.
5. Backends are limited to those defined in the global-constant-like function `BACKENDS`:
- Those are the local `aer_simulator` and the remote `ibmq_qasm_simulator` for now.
Due to these default settings the interactive CLI is somewhat restrictive,
for full flexibility a user should use the API and not the CLI.
"""
# Handling operator part
operator_inputs = interactive_operator_inputs()
self.num_input_qubits = operator_inputs["num_input_qubits"]
self.high_to_low_map = operator_inputs["high_to_low_map"]
self.constraints_string = operator_inputs["constraints_string"]
self.high_level_constraints_string = operator_inputs["high_level_constraints_string"]
self.high_level_vars = operator_inputs["high_level_vars"]
self.parsed_constraints = ParsedConstraints(
self.constraints_string, self.high_level_constraints_string
)
self.update_metadata(
{
"num_input_qubits": self.num_input_qubits,
"constraints_string": self.constraints_string,
"high_level_constraints_string": self.high_level_constraints_string,
"high_level_vars": self.high_level_vars,
}
)
obtain_grover_operator_output = self.obtain_grover_operator()
self.save_display_grover_operator(obtain_grover_operator_output)
# Handling overall circuit part
solutions_num = interactive_solutions_num_input()
if solutions_num is not None:
backend = None
if solutions_num == -1:
backend = interactive_backend_input()
overall_circuit_data = self.obtain_overall_sat_circuit(
obtain_grover_operator_output["operator"], solutions_num, backend
)
self.save_display_overall_circuit(overall_circuit_data)
# Handling circuit execution part
if interactive_run_input():
if backend is None:
backend = interactive_backend_input()
shots = interactive_shots_input()
counts_parsed = self.run_overall_sat_circuit(
overall_circuit_data["circuit"], backend, shots
)
self.save_display_results(counts_parsed)
print()
print(f"Done saving data into '{self.dir_path}'.")
def obtain_grover_operator(
self, transpile_kwargs: Optional[Dict[str, Any]] = None
) -> Dict[str, Union[GroverConstraintsOperator, QuantumCircuit]]:
"""
Obtains the suitable `GroverConstraintsOperator` object for the constraints,
decomposes it using the `circuit_decomposition.py` module and transpiles it
according to `transpile_kwargs`.
Args:
transpile_kwargs (Optional[Dict[str, Any]]): kwargs for Qiskit's transpile function.
The defualt is set to the global constant `TRANSPILE_KWARGS`.
Returns:
(Dict[str, Union[GroverConstraintsOperator, QuantumCircuit, Dict[str, List[int]]]]):
- 'operator' (GroverConstraintsOperator):the high-level blocks operator.
- 'decomposed_operator' (QuantumCircuit): decomposed to building-blocks operator.
* For annotations regarding the decomposition method see the
`circuit_decomposition` module.
- 'transpiled_operator' (QuantumCircuit): the transpiled operator.
*** The high-level operator and the decomposed operator are generated with barriers
between constraints as default for visualizations purposes. The barriers are stripped
off before transpiling so the the transpiled operator object contains no barriers. ***
- 'high_level_to_bit_indexes_map' (Optional[Dict[str, List[int]]] = None):
A map of high-level variables with their allocated bit-indexes in the input register.
"""
print()
print(
"The system synthesizes and transpiles a Grover's "
"operator for the given constraints. Please wait.."
)
if transpile_kwargs is None:
transpile_kwargs = TRANSPILE_KWARGS
self.transpile_kwargs = transpile_kwargs
operator = GroverConstraintsOperator(
self.parsed_constraints, self.num_input_qubits, insert_barriers=True
)
decomposed_operator = decompose_operator(operator)
no_baerriers_operator = RemoveBarriers()(operator)
transpiled_operator = transpile(no_baerriers_operator, **transpile_kwargs)
print("Done.")
return {
"operator": operator,
"decomposed_operator": decomposed_operator,
"transpiled_operator": transpiled_operator,
"high_level_to_bit_indexes_map": self.high_to_low_map,
}
def save_display_grover_operator(
self,
obtain_grover_operator_output: Dict[str, Union[GroverConstraintsOperator, QuantumCircuit]],
display: Optional[bool] = True,
) -> None:
"""
Handles saving and displaying data generated by the `self.obtain_grover_operator` method.
Args:
obtain_grover_operator_output(Dict[str, Union[GroverConstraintsOperator, QuantumCircuit]]):
the dictionary returned upon calling the `self.obtain_grover_operator` method.
display (Optional[bool] = True) - If true, displays objects to user's platform.
"""
# Creating a directory to save operator's data
operator_dir_path = f"{self.dir_path}grover_operator/"
os.mkdir(operator_dir_path)
# Titles for displaying objects, by order of `obtain_grover_operator_output`
titles = [
"The operator diagram - high level blocks:",
"The operator diagram - decomposed:",
f"The transpiled operator diagram saved into '{operator_dir_path}'.\n"
f"It's not presented here due to its complexity.\n"
f"Please note that barriers appear in the high-level diagrams above only for convenient\n"
f"visual separation between constraints.\n"
f"Before transpilation all barriers are removed to avoid redundant inefficiencies.",
]
for index, (op_name, op_obj) in enumerate(obtain_grover_operator_output.items()):
# Generic path and name for files to be saved
files_path = f"{operator_dir_path}{op_name}"
# Generating a circuit diagrams figure
figure_path = f"{files_path}.pdf"
op_obj.draw("mpl", filename=figure_path, fold=-1)
# Generating a QPY serialization file for the circuit object
qpy_file_path = f"{files_path}.qpy"
with open(qpy_file_path, "wb") as qpy_file:
qpy.dump(op_obj, qpy_file)
# Original high-level operator and decomposed operator
if index < 2 and display:
# Displaying to user
self.output_to_platform(
title=titles[index], output_terminal=op_obj.draw("text"), output_jupyter=figure_path
)
# Transpiled operator
elif index == 2:
# Output to user, not including the circuit diagram
print()
print(titles[index])
print()
print(f"The transpilation kwargs are: {self.transpile_kwargs}.")
transpiled_operator_depth = op_obj.depth()
transpiled_operator_gates_count = op_obj.count_ops()
print(f"Transpiled operator depth: {transpiled_operator_depth}.")
print(f"Transpiled operator gates count: {transpiled_operator_gates_count}.")
print(f"Total number of qubits: {op_obj.num_qubits}.")
# Generating QASM 2.0 file only for the (flattened = no registers) tranpsiled operator
qasm_file_path = f"{files_path}.qasm"
flatten_circuit(op_obj).qasm(filename=qasm_file_path)
# Index 3 is 'high_level_to_bit_indexes_map' so it's time to break from the loop
break
# Mapping from high-level variables to bit-indexes will be displayed as well
mapping = obtain_grover_operator_output["high_level_to_bit_indexes_map"]
if mapping:
print()
print(f"The high-level variables mapping to bit-indexes:\n{mapping}")
print()
print(
f"Saved into '{operator_dir_path}':\n",
" Circuit diagrams for all levels.\n",
" QPY serialization exports for all levels.\n",
" QASM 2.0 export only for the transpiled level.",
)
with open(f"{operator_dir_path}operator.qpy", "rb") as qpy_file:
operator_qpy_sha256 = sha256(qpy_file.read()).hexdigest()
self.update_metadata(
{
"high_level_to_bit_indexes_map": self.high_to_low_map,
"transpile_kwargs": self.transpile_kwargs,
"transpiled_operator_depth": transpiled_operator_depth,
"transpiled_operator_gates_count": transpiled_operator_gates_count,
"operator_qpy_sha256": operator_qpy_sha256,
}
)
def obtain_overall_sat_circuit(
self,
grover_operator: GroverConstraintsOperator,
solutions_num: int,
backend: Optional[Backend] = None,
) -> Dict[str, SATCircuit]:
"""
Obtains the suitable `SATCircuit` object (= the overall SAT circuit) for the SAT problem.
Args:
grover_operator (GroverConstraintsOperator): Grover's operator for the SAT problem.
solutions_num (int): number of solutions for the SAT problem. In the case the number
of solutions is unknown, specific negative values are accepted:
* '-1' - for launching a classical iterative stochastic process that finds an adequate
number of iterations - by calling the `find_iterations_unknown` function (see its
docstrings for more information).
* '-2' - for generating a dynamic circuit that iterates over Grover's iterator until
a solution is obtained, using weak measurements. TODO - this feature isn't ready yet.
backend (Optional[Backend] = None): in the case of a '-1' value given to `solutions_num`,
a backend object to execute the depicted iterative prcess upon should be provided.
Returns:
(Dict[str, SATCircuit]):
- 'circuit' key for the overall SAT circuit.
- 'concise_circuit' key for the overall SAT circuit, with only 1 iteration over Grover's
iterator (operator + diffuser). Useful for visualization purposes.
*** The concise circuit is generated with barriers between segments as default
for visualizations purposes. In the actual circuit there no barriers. ***
"""
# -1 = Unknown number of solutions - iterative stochastic process
print()
if solutions_num == -1:
assert backend is not None, "Need to specify a backend if `solutions_num == -1`."
print("Please wait while the system checks various solutions..")
circuit, iterations = find_iterations_unknown(
self.num_input_qubits,
grover_operator,
self.parsed_constraints,
precision=10,
backend=backend,
)
print()
print(f"An adequate number of iterations found = {iterations}.")
# -2 = Unknown number of solutions - implement a dynamic circuit
# TODO this feature isn't fully implemented yet
elif solutions_num == -2:
print("The system builds a dynamic circuit..")
circuit = SATCircuit(self.num_input_qubits, grover_operator, iterations=None)
circuit.add_input_reg_measurement()
iterations = None
# Known number of solutions
else:
print("The system builds the overall circuit..")
iterations = calc_iterations(self.num_input_qubits, solutions_num)
print(f"\nFor {solutions_num} solutions, {iterations} iterations needed.")
circuit = SATCircuit(
self.num_input_qubits, grover_operator, iterations, insert_barriers=False
)
circuit.add_input_reg_measurement()
self.iterations = iterations
# Obtaining a SATCircuit object with one iteration for concise representation
concise_circuit = SATCircuit(
self.num_input_qubits, grover_operator, iterations=1, insert_barriers=True
)
concise_circuit.add_input_reg_measurement()
return {"circuit": circuit, "concise_circuit": concise_circuit}
def save_display_overall_circuit(
self, obtain_overall_sat_circuit_output: Dict[str, SATCircuit], display: Optional[bool] = True
) -> None:
"""
Handles saving and displaying data generated by the `self.obtain_overall_sat_circuit` method.
Args:
obtain_overall_sat_circuit_output(Dict[str, SATCircuit]):
the dictionary returned upon calling the `self.obtain_overall_sat_circuit` method.
display (Optional[bool] = True) - If true, displays objects to user's platform.
"""
circuit = obtain_overall_sat_circuit_output["circuit"]
concise_circuit = obtain_overall_sat_circuit_output["concise_circuit"]
# Creating a directory to save overall circuit's data
overall_circuit_dir_path = f"{self.dir_path}overall_circuit/"
os.mkdir(overall_circuit_dir_path)
# Generating a figure of the overall SAT circuit with just 1 iteration (i.e "concise")
concise_circuit_fig_path = f"{overall_circuit_dir_path}overall_circuit_1_iteration.pdf"
concise_circuit.draw("mpl", filename=concise_circuit_fig_path, fold=-1)
# Displaying the concise circuit to user
if display:
if self.iterations:
self.output_to_platform(
title=(
f"The high level circuit contains {self.iterations}"
f" iterations of the following form:"
),
output_terminal=concise_circuit.draw("text"),
output_jupyter=concise_circuit_fig_path,
)
# Dynamic circuit case - TODO NOT FULLY IMPLEMENTED YET
else:
dynamic_circuit_fig_path = f"{overall_circuit_dir_path}overall_circuit_dynamic.pdf"
circuit.draw("mpl", filename=dynamic_circuit_fig_path, fold=-1)
self.output_to_platform(
title="The dynamic circuit diagram:",
output_terminal=circuit.draw("text"),
output_jupyter=dynamic_circuit_fig_path,
)
if self.iterations:
transpiled_overall_circuit = transpile(flatten_circuit(circuit), **self.transpile_kwargs)
print()
print(f"The transpilation kwargs are: {self.transpile_kwargs}.")
transpiled_overall_circuit_depth = transpiled_overall_circuit.depth()
transpiled_overall_circuit_gates_count = transpiled_overall_circuit.count_ops()
print(f"Transpiled overall-circuit depth: {transpiled_overall_circuit_depth}.")
print(f"Transpiled overall-circuit gates count: {transpiled_overall_circuit_gates_count}.")
print(f"Total number of qubits: {transpiled_overall_circuit.num_qubits}.")
print()
print("Exporting the full overall SAT circuit object..")
export_files_path = f"{overall_circuit_dir_path}overall_circuit"
with open(f"{export_files_path}.qpy", "wb") as qpy_file:
qpy.dump(circuit, qpy_file)
if self.iterations:
transpiled_overall_circuit.qasm(filename=f"{export_files_path}.qasm")
print()
print(
f"Saved into '{overall_circuit_dir_path}':\n",
" A concised (1 iteration) circuit diagram of the high-level overall SAT circuit.\n",
" QPY serialization export for the full overall SAT circuit object.",
)
if self.iterations:
print(" QASM 2.0 export for the transpiled full overall SAT circuit object.")
metadata_update = {
"num_total_qubits": circuit.num_qubits,
"num_iterations": circuit.iterations,
}
if self.iterations:
metadata_update["transpiled_overall_circuit_depth"] = (transpiled_overall_circuit_depth,)
metadata_update[
"transpiled_overall_circuit_gates_count"
] = transpiled_overall_circuit_gates_count
self.update_metadata(metadata_update)
@timer_dec("Circuit simulation execution time = ")
def run_overall_sat_circuit(
self, circuit: QuantumCircuit, backend: Backend, shots: int
) -> Dict[str, Union[Counts, List[Tuple[Union[str, int]]], List[str], List[Dict[str, int]]]]:
"""
Executes a `circuit` on `backend` transpiled w.r.t backend, `shots` times.
Args:
circuit (QuantumCircuit): `QuantumCircuit` object or child-object (a.k.a `SATCircuit`)
to execute.
backend (Backend): backend to execute `circuit` upon.
shots (int): number of execution shots.
Returns:
(Dict[str, Union[Counts, List[Tuple[Union[str, int]]], List[str], List[Dict[str, int]]]]):
dict object returned by `self.parse_counts` - see this method's docstrings for annotations.
"""
# Defines also instance attributes to use in other methods
self.backend = backend
self.shots = shots
print()
print(f"The system is running the circuit {shots} times on {backend}, please wait..")
print("This process might take a while.")
job = backend.run(transpile(circuit, backend), shots=shots)
counts = job.result().get_counts()
print("Done.")
parsed_counts = self.parse_counts(counts)
return parsed_counts
def parse_counts(
self, counts: Counts
) -> Dict[str, Union[Counts, List[Tuple[Union[str, int]]], List[str], List[Dict[str, int]]]]:
"""
Parses a `Counts` object into several desired datas (see 'Returns' section).
Args:
counts (Counts): the `Counts` object to parse.
Returns:
(Dict[str, Union[Counts, List[Tuple[Union[str, int]]], List[str], List[Dict[str, int]]]]):
'counts' (Counts) - the original `Counts` object.
'counts_sorted' (List[Tuple[Union[str, int]]]) - results sorted in a descending order.
'distilled_solutions' (List[str]): list of solutions (bitstrings).
'high_level_vars_values' (List[Dict[str, int]]): list of solutions (each solution is a
dictionary with variable-names as keys and their integer values as values).
"""
# Sorting results in an a descending order
counts_sorted = sorted(counts.items(), key=lambda x: x[1], reverse=True)
# Generating a set of distilled verified-only solutions
verifier = ClassicalVerifier(self.parsed_constraints)
distilled_solutions = set()
for count_item in counts_sorted:
if not verifier.verify(count_item[0]):
break
distilled_solutions.add(count_item[0])
# In the case of high-level format in use, translating `distilled_solutions` into integer values
high_level_vars_values = None
if self.high_level_constraints_string and self.high_level_vars:
# Container for dictionaries with variables integer values
high_level_vars_values = []
for solution in distilled_solutions:
# Keys are variable-names and values are their integer values
solution_vars = {}
for var, bits_bundle in self.high_to_low_map.items():
reversed_solution = solution[::-1]
var_bitstring = ""
for bit_index in bits_bundle:
var_bitstring += reversed_solution[bit_index]
# Translating to integer value
solution_vars[var] = int(var_bitstring, 2)
high_level_vars_values.append(solution_vars)
return {
"counts": counts,
"counts_sorted": counts_sorted,
"distilled_solutions": distilled_solutions,
"high_level_vars_values": high_level_vars_values,
}
def save_display_results(
self,
run_overall_sat_circuit_output: Dict[
str, Union[Counts, List[Tuple[Union[str, int]]], List[str], List[Dict[str, int]]]
],
display: Optional[bool] = True,
) -> None:
"""
Handles saving and displaying data generated by the `self.run_overall_sat_circuit` method.
Args:
run_overall_sat_circuit_output (Dict[str, Union[Counts, List[Tuple[Union[str, int]]],
List[str], List[Dict[str, int]]]]): the dictionary returned upon calling
the `self.run_overall_sat_circuit` method.
display (Optional[bool] = True) - If true, displays objects to user's platform.
"""
counts = run_overall_sat_circuit_output["counts"]
counts_sorted = run_overall_sat_circuit_output["counts_sorted"]
distilled_solutions = run_overall_sat_circuit_output["distilled_solutions"]
high_level_vars_values = run_overall_sat_circuit_output["high_level_vars_values"]
# Creating a directory to save results data
results_dir_path = f"{self.dir_path}results/"
os.mkdir(results_dir_path)
# Defining custom dimensions for the custom `plot_histogram` of this package
histogram_fig_width = max((len(counts) * self.num_input_qubits * (10 / 72)), 7)
histogram_fig_height = 5
histogram_figsize = (histogram_fig_width, histogram_fig_height)
histogram_path = f"{results_dir_path}histogram.pdf"
plot_histogram(counts, figsize=histogram_figsize, sort="value_desc", filename=histogram_path)
if display:
# Basic output text
output_text = (
f"All counts:\n{counts_sorted}\n"
f"\nDistilled solutions ({len(distilled_solutions)} total):\n"
f"{distilled_solutions}"
)
# Additional outputs for a high-level constraints format
if high_level_vars_values:
# Mapping from high-level variables to bit-indexes will be displayed as well
output_text += (
f"\n\nThe high-level variables mapping to bit-indexes:" f"\n{self.high_to_low_map}"
)
# Actual integer solutions will be displayed as well
additional_text = ""
for solution_index, solution in enumerate(high_level_vars_values):
additional_text += f"Solution {solution_index + 1}: "
for var_index, (var, value) in enumerate(solution.items()):
additional_text += f"{var} = {value}"
if var_index != len(solution) - 1:
additional_text += ", "
else:
additional_text += "\n"
output_text += f"\n\nHigh-level format solutions: \n{additional_text}"
self.output_to_platform(
title=f"The results for {self.shots} shots are:",
output_terminal=output_text,
output_jupyter=histogram_path,
display_both_on_jupyter=True,
)
results_dict = {
"high_level_to_bit_indexes_map": self.high_to_low_map,
"solutions": list(distilled_solutions),
"high_level_solutions": high_level_vars_values,
"counts": counts_sorted,
}
with open(f"{results_dir_path}results.json", "w") as results_file:
json.dump(results_dict, results_file, indent=4)
self.update_metadata(
{
"num_solutions": len(distilled_solutions),
"backend": str(self.backend),
"shots": self.shots,
}
)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# Import requisite modules
import math
import datetime
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# Import Qiskit packages
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver, QAOA, SamplingVQE
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit.library import TwoLocal
from qiskit_aer.primitives import Sampler
from qiskit_optimization.algorithms import MinimumEigenOptimizer
# The data providers of stock-market data
from qiskit_finance.data_providers import RandomDataProvider
from qiskit_finance.applications.optimization import PortfolioDiversification
# Generate a pairwise time-series similarity matrix
seed = 123
stocks = ["TICKER1", "TICKER2"]
n = len(stocks)
data = RandomDataProvider(
tickers=stocks,
start=datetime.datetime(2016, 1, 1),
end=datetime.datetime(2016, 1, 30),
seed=seed,
)
data.run()
rho = data.get_similarity_matrix()
q = 1 # q less or equal than n
class ClassicalOptimizer:
def __init__(self, rho, n, q):
self.rho = rho
self.n = n # number of inner variables
self.q = q # number of required selection
def compute_allowed_combinations(self):
f = math.factorial
return int(f(self.n) / f(self.q) / f(self.n - self.q))
def cplex_solution(self):
# refactoring
rho = self.rho
n = self.n
q = self.q
my_obj = list(rho.reshape(1, n**2)[0]) + [0.0 for x in range(0, n)]
my_ub = [1 for x in range(0, n**2 + n)]
my_lb = [0 for x in range(0, n**2 + n)]
my_ctype = "".join(["I" for x in range(0, n**2 + n)])
my_rhs = (
[q]
+ [1 for x in range(0, n)]
+ [0 for x in range(0, n)]
+ [0.1 for x in range(0, n**2)]
)
my_sense = (
"".join(["E" for x in range(0, 1 + n)])
+ "".join(["E" for x in range(0, n)])
+ "".join(["L" for x in range(0, n**2)])
)
try:
my_prob = cplex.Cplex()
self.populatebyrow(my_prob, my_obj, my_ub, my_lb, my_ctype, my_sense, my_rhs)
my_prob.solve()
except CplexError as exc:
print(exc)
return
x = my_prob.solution.get_values()
x = np.array(x)
cost = my_prob.solution.get_objective_value()
return x, cost
def populatebyrow(self, prob, my_obj, my_ub, my_lb, my_ctype, my_sense, my_rhs):
n = self.n
prob.objective.set_sense(prob.objective.sense.minimize)
prob.variables.add(obj=my_obj, lb=my_lb, ub=my_ub, types=my_ctype)
prob.set_log_stream(None)
prob.set_error_stream(None)
prob.set_warning_stream(None)
prob.set_results_stream(None)
rows = []
col = [x for x in range(n**2, n**2 + n)]
coef = [1 for x in range(0, n)]
rows.append([col, coef])
for ii in range(0, n):
col = [x for x in range(0 + n * ii, n + n * ii)]
coef = [1 for x in range(0, n)]
rows.append([col, coef])
for ii in range(0, n):
col = [ii * n + ii, n**2 + ii]
coef = [1, -1]
rows.append([col, coef])
for ii in range(0, n):
for jj in range(0, n):
col = [ii * n + jj, n**2 + jj]
coef = [1, -1]
rows.append([col, coef])
prob.linear_constraints.add(lin_expr=rows, senses=my_sense, rhs=my_rhs)
# Instantiate the classical optimizer class
classical_optimizer = ClassicalOptimizer(rho, n, q)
# Compute the number of feasible solutions:
print("Number of feasible combinations= " + str(classical_optimizer.compute_allowed_combinations()))
# Compute the total number of possible combinations (feasible + unfeasible)
print("Total number of combinations= " + str(2 ** (n * (n + 1))))
# Visualize the solution
def visualize_solution(xc, yc, x, C, n, K, title_str):
plt.figure()
plt.scatter(xc, yc, s=200)
for i in range(len(xc)):
plt.annotate(i, (xc[i] + 0.015, yc[i]), size=16, color="r")
plt.grid()
for ii in range(n**2, n**2 + n):
if x[ii] > 0:
plt.plot(xc[ii - n**2], yc[ii - n**2], "r*", ms=20)
for ii in range(0, n**2):
if x[ii] > 0:
iy = ii // n
ix = ii % n
plt.plot([xc[ix], xc[iy]], [yc[ix], yc[iy]], "C2")
plt.title(title_str + " cost = " + str(int(C * 100) / 100.0))
plt.show()
from qiskit.utils import algorithm_globals
class QuantumOptimizer:
def __init__(self, rho, n, q):
self.rho = rho
self.n = n
self.q = q
self.pdf = PortfolioDiversification(similarity_matrix=rho, num_assets=n, num_clusters=q)
self.qp = self.pdf.to_quadratic_program()
# Obtains the least eigenvalue of the Hamiltonian classically
def exact_solution(self):
exact_mes = NumPyMinimumEigensolver()
exact_eigensolver = MinimumEigenOptimizer(exact_mes)
result = exact_eigensolver.solve(self.qp)
return self.decode_result(result)
def vqe_solution(self):
algorithm_globals.random_seed = 100
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
ry = TwoLocal(n, "ry", "cz", reps=5, entanglement="full")
vqe_mes = SamplingVQE(sampler=Sampler(), ansatz=ry, optimizer=cobyla)
vqe = MinimumEigenOptimizer(vqe_mes)
result = vqe.solve(self.qp)
return self.decode_result(result)
def qaoa_solution(self):
algorithm_globals.random_seed = 1234
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
qaoa_mes = QAOA(sampler=Sampler(), optimizer=cobyla, reps=3)
qaoa = MinimumEigenOptimizer(qaoa_mes)
result = qaoa.solve(self.qp)
return self.decode_result(result)
def decode_result(self, result, offset=0):
quantum_solution = 1 - (result.x)
ground_level = self.qp.objective.evaluate(result.x)
return quantum_solution, ground_level
# Instantiate the quantum optimizer class with parameters:
quantum_optimizer = QuantumOptimizer(rho, n, q)
# Check if the binary representation is correct. This requires CPLEX
try:
import cplex
# warnings.filterwarnings('ignore')
quantum_solution, quantum_cost = quantum_optimizer.exact_solution()
print(quantum_solution, quantum_cost)
classical_solution, classical_cost = classical_optimizer.cplex_solution()
print(classical_solution, classical_cost)
if np.abs(quantum_cost - classical_cost) < 0.01:
print("Binary formulation is correct")
else:
print("Error in the formulation of the Hamiltonian")
except Exception as ex:
print(ex)
ground_state, ground_level = quantum_optimizer.exact_solution()
print(ground_state)
classical_cost = 1.000779571614484 # obtained from the CPLEX solution
try:
if np.abs(ground_level - classical_cost) < 0.01:
print("Ising Hamiltonian in Z basis is correct")
else:
print("Error in the Ising Hamiltonian formulation")
except Exception as ex:
print(ex)
vqe_state, vqe_level = quantum_optimizer.vqe_solution()
print(vqe_state, vqe_level)
try:
if np.linalg.norm(ground_state - vqe_state) < 0.01:
print("SamplingVQE produces the same solution as the exact eigensolver.")
else:
print(
"SamplingVQE does not produce the same solution as the exact eigensolver, but that is to be expected."
)
except Exception as ex:
print(ex)
xc, yc = data.get_coordinates()
visualize_solution(xc, yc, ground_state, ground_level, n, q, "Classical")
visualize_solution(xc, yc, vqe_state, vqe_level, n, q, "VQE")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.