repo
stringclasses 885
values | file
stringclasses 741
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.visualization.timeline import draw as timeline_draw
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeBoeblingen
backend = FakeBoeblingen()
ghz = QuantumCircuit(5)
ghz.h(0)
ghz.cx(0,range(1,5))
circ = transpile(ghz, backend, scheduling_method="asap")
timeline_draw(circ)
|
https://github.com/Interlin-q/diskit
|
Interlin-q
|
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/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2021, 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.
"""An algorithm to implement a Trotterization real time-evolution."""
from __future__ import annotations
from qiskit import QuantumCircuit
from qiskit_algorithms.time_evolvers.time_evolution_problem import TimeEvolutionProblem
from qiskit_algorithms.time_evolvers.time_evolution_result import TimeEvolutionResult
from qiskit_algorithms.time_evolvers.real_time_evolver import RealTimeEvolver
from qiskit_algorithms.observables_evaluator import estimate_observables
from qiskit.opflow import PauliSumOp
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.circuit.parametertable import ParameterView
from qiskit.primitives import BaseEstimator
from qiskit.quantum_info import Pauli, SparsePauliOp
from qiskit.synthesis import ProductFormula, LieTrotter
class TrotterQRTE(RealTimeEvolver):
"""Quantum Real Time Evolution using Trotterization.
Type of Trotterization is defined by a ``ProductFormula`` provided.
Examples:
.. code-block:: python
from qiskit.opflow import PauliSumOp
from qiskit.quantum_info import Pauli, SparsePauliOp
from qiskit import QuantumCircuit
from qiskit_algorithms import TimeEvolutionProblem
from qiskit_algorithms.time_evolvers import TrotterQRTE
from qiskit.primitives import Estimator
operator = PauliSumOp(SparsePauliOp([Pauli("X"), Pauli("Z")]))
initial_state = QuantumCircuit(1)
time = 1
evolution_problem = TimeEvolutionProblem(operator, time, initial_state)
# LieTrotter with 1 rep
estimator = Estimator()
trotter_qrte = TrotterQRTE(estimator=estimator)
evolved_state = trotter_qrte.evolve(evolution_problem).evolved_state
"""
def __init__(
self,
product_formula: ProductFormula | None = None,
estimator: BaseEstimator | None = None,
num_timesteps: int = 1,
) -> None:
"""
Args:
product_formula: A Lie-Trotter-Suzuki product formula. If ``None`` provided, the
Lie-Trotter first order product formula with a single repetition is used. ``reps``
should be 1 to obtain a number of time-steps equal to ``num_timesteps`` and an
evaluation of :attr:`.TimeEvolutionProblem.aux_operators` at every time-step. If ``reps``
is larger than 1, the true number of time-steps will be ``num_timesteps * reps``.
num_timesteps: The number of time-steps the full evolution time is devided into
(repetitions of ``product_formula``)
estimator: An estimator primitive used for calculating expectation values of
``TimeEvolutionProblem.aux_operators``.
"""
self.product_formula = product_formula
self.num_timesteps = num_timesteps
self.estimator = estimator
@property
def product_formula(self) -> ProductFormula:
"""Returns a product formula."""
return self._product_formula
@product_formula.setter
def product_formula(self, product_formula: ProductFormula | None):
"""Sets a product formula. If ``None`` provided, sets the Lie-Trotter first order product
formula with a single repetition."""
if product_formula is None:
product_formula = LieTrotter()
self._product_formula = product_formula
@property
def estimator(self) -> BaseEstimator | None:
"""
Returns an estimator.
"""
return self._estimator
@estimator.setter
def estimator(self, estimator: BaseEstimator) -> None:
"""
Sets an estimator.
"""
self._estimator = estimator
@property
def num_timesteps(self) -> int:
"""Returns the number of timesteps."""
return self._num_timesteps
@num_timesteps.setter
def num_timesteps(self, num_timesteps: int) -> None:
"""
Sets the number of time-steps.
Raises:
ValueError: If num_timesteps is not positive.
"""
if num_timesteps <= 0:
raise ValueError(
f"Number of time steps must be positive integer, {num_timesteps} provided"
)
self._num_timesteps = num_timesteps
@classmethod
def supports_aux_operators(cls) -> bool:
"""
Whether computing the expectation value of auxiliary operators is supported.
Returns:
``True`` if ``aux_operators`` expectations in the ``TimeEvolutionProblem`` can be
evaluated, ``False`` otherwise.
"""
return True
def evolve(self, evolution_problem: TimeEvolutionProblem) -> TimeEvolutionResult:
"""
Evolves a quantum state for a given time using the Trotterization method
based on a product formula provided. The result is provided in the form of a quantum
circuit. If auxiliary operators are included in the ``evolution_problem``, they are
evaluated on the ``init_state`` and on the evolved state at every step (``num_timesteps``
times) using an estimator primitive provided.
Args:
evolution_problem: Instance defining evolution problem. For the included Hamiltonian,
``Pauli`` or ``PauliSumOp`` are supported by TrotterQRTE.
Returns:
Evolution result that includes an evolved state as a quantum circuit and, optionally,
auxiliary operators evaluated for a resulting state on an estimator primitive.
Raises:
ValueError: If ``t_param`` is not set to ``None`` in the ``TimeEvolutionProblem``
(feature not currently supported).
ValueError: If ``aux_operators`` provided in the time evolution problem but no estimator
provided to the algorithm.
ValueError: If the ``initial_state`` is not provided in the ``TimeEvolutionProblem``.
ValueError: If an unsupported Hamiltonian type is provided.
"""
evolution_problem.validate_params()
if evolution_problem.aux_operators is not None and self.estimator is None:
raise ValueError(
"The time evolution problem contained ``aux_operators`` but no estimator was "
"provided. The algorithm continues without calculating these quantities. "
)
# ensure the hamiltonian is a sparse pauli op
hamiltonian = evolution_problem.hamiltonian
if not isinstance(hamiltonian, (Pauli, PauliSumOp, SparsePauliOp)):
raise ValueError(
f"TrotterQRTE only accepts Pauli | PauliSumOp | SparsePauliOp, {type(hamiltonian)} "
"provided."
)
if isinstance(hamiltonian, PauliSumOp):
hamiltonian = hamiltonian.primitive * hamiltonian.coeff
elif isinstance(hamiltonian, Pauli):
hamiltonian = SparsePauliOp(hamiltonian)
t_param = evolution_problem.t_param
free_parameters = hamiltonian.parameters
if t_param is not None and free_parameters != ParameterView([t_param]):
raise ValueError(
f"Hamiltonian time parameters ({free_parameters}) do not match "
f"evolution_problem.t_param ({t_param})."
)
# make sure PauliEvolutionGate does not implement more than one Trotter step
dt = evolution_problem.time / self.num_timesteps
if evolution_problem.initial_state is not None:
initial_state = evolution_problem.initial_state
else:
raise ValueError("``initial_state`` must be provided in the ``TimeEvolutionProblem``.")
evolved_state = QuantumCircuit(initial_state.num_qubits)
evolved_state.append(initial_state, evolved_state.qubits)
if evolution_problem.aux_operators is not None:
observables = []
observables.append(
estimate_observables(
self.estimator,
evolved_state,
evolution_problem.aux_operators,
None,
evolution_problem.truncation_threshold,
)
)
else:
observables = None
if t_param is None:
# the evolution gate
single_step_evolution_gate = PauliEvolutionGate(
hamiltonian, dt, synthesis=self.product_formula
)
for n in range(self.num_timesteps):
# if hamiltonian is time-dependent, bind new time-value at every step to construct
# evolution for next step
if t_param is not None:
time_value = (n + 1) * dt
bound_hamiltonian = hamiltonian.assign_parameters([time_value])
single_step_evolution_gate = PauliEvolutionGate(
bound_hamiltonian,
dt,
synthesis=self.product_formula,
)
evolved_state.append(single_step_evolution_gate, evolved_state.qubits)
if evolution_problem.aux_operators is not None:
observables.append(
estimate_observables(
self.estimator,
evolved_state,
evolution_problem.aux_operators,
None,
evolution_problem.truncation_threshold,
)
)
evaluated_aux_ops = None
if evolution_problem.aux_operators is not None:
evaluated_aux_ops = observables[-1]
return TimeEvolutionResult(evolved_state, evaluated_aux_ops, observables)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# 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.
# pylint: disable=missing-docstring
import math
from qiskit.circuit.library import (
RZGate,
SXGate,
XGate,
CXGate,
RYGate,
RXGate,
RXXGate,
RGate,
IGate,
ECRGate,
UGate,
CCXGate,
RZXGate,
CZGate,
)
from qiskit.circuit import IfElseOp, ForLoopOp, WhileLoopOp, SwitchCaseOp
from qiskit.circuit.measure import Measure
from qiskit.circuit.parameter import Parameter
from qiskit import pulse
from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap
from qiskit.pulse.calibration_entries import CalibrationPublisher, ScheduleDef
from qiskit.transpiler.coupling import CouplingMap
from qiskit.transpiler.instruction_durations import InstructionDurations
from qiskit.transpiler.timing_constraints import TimingConstraints
from qiskit.transpiler.exceptions import TranspilerError
from qiskit.transpiler import Target
from qiskit.transpiler import InstructionProperties
from qiskit.test import QiskitTestCase
from qiskit.providers.fake_provider import (
FakeBackendV2,
FakeMumbaiFractionalCX,
FakeVigo,
FakeNairobi,
FakeGeneva,
)
class TestTarget(QiskitTestCase):
def setUp(self):
super().setUp()
self.fake_backend = FakeBackendV2()
self.fake_backend_target = self.fake_backend.target
self.theta = Parameter("theta")
self.phi = Parameter("phi")
self.ibm_target = Target()
i_props = {
(0,): InstructionProperties(duration=35.5e-9, error=0.000413),
(1,): InstructionProperties(duration=35.5e-9, error=0.000502),
(2,): InstructionProperties(duration=35.5e-9, error=0.0004003),
(3,): InstructionProperties(duration=35.5e-9, error=0.000614),
(4,): InstructionProperties(duration=35.5e-9, error=0.006149),
}
self.ibm_target.add_instruction(IGate(), i_props)
rz_props = {
(0,): InstructionProperties(duration=0, error=0),
(1,): InstructionProperties(duration=0, error=0),
(2,): InstructionProperties(duration=0, error=0),
(3,): InstructionProperties(duration=0, error=0),
(4,): InstructionProperties(duration=0, error=0),
}
self.ibm_target.add_instruction(RZGate(self.theta), rz_props)
sx_props = {
(0,): InstructionProperties(duration=35.5e-9, error=0.000413),
(1,): InstructionProperties(duration=35.5e-9, error=0.000502),
(2,): InstructionProperties(duration=35.5e-9, error=0.0004003),
(3,): InstructionProperties(duration=35.5e-9, error=0.000614),
(4,): InstructionProperties(duration=35.5e-9, error=0.006149),
}
self.ibm_target.add_instruction(SXGate(), sx_props)
x_props = {
(0,): InstructionProperties(duration=35.5e-9, error=0.000413),
(1,): InstructionProperties(duration=35.5e-9, error=0.000502),
(2,): InstructionProperties(duration=35.5e-9, error=0.0004003),
(3,): InstructionProperties(duration=35.5e-9, error=0.000614),
(4,): InstructionProperties(duration=35.5e-9, error=0.006149),
}
self.ibm_target.add_instruction(XGate(), x_props)
cx_props = {
(3, 4): InstructionProperties(duration=270.22e-9, error=0.00713),
(4, 3): InstructionProperties(duration=305.77e-9, error=0.00713),
(3, 1): InstructionProperties(duration=462.22e-9, error=0.00929),
(1, 3): InstructionProperties(duration=497.77e-9, error=0.00929),
(1, 2): InstructionProperties(duration=227.55e-9, error=0.00659),
(2, 1): InstructionProperties(duration=263.11e-9, error=0.00659),
(0, 1): InstructionProperties(duration=519.11e-9, error=0.01201),
(1, 0): InstructionProperties(duration=554.66e-9, error=0.01201),
}
self.ibm_target.add_instruction(CXGate(), cx_props)
measure_props = {
(0,): InstructionProperties(duration=5.813e-6, error=0.0751),
(1,): InstructionProperties(duration=5.813e-6, error=0.0225),
(2,): InstructionProperties(duration=5.813e-6, error=0.0146),
(3,): InstructionProperties(duration=5.813e-6, error=0.0215),
(4,): InstructionProperties(duration=5.813e-6, error=0.0333),
}
self.ibm_target.add_instruction(Measure(), measure_props)
self.aqt_target = Target(description="AQT Target")
rx_props = {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
}
self.aqt_target.add_instruction(RXGate(self.theta), rx_props)
ry_props = {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
}
self.aqt_target.add_instruction(RYGate(self.theta), ry_props)
rz_props = {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
}
self.aqt_target.add_instruction(RZGate(self.theta), rz_props)
r_props = {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
}
self.aqt_target.add_instruction(RGate(self.theta, self.phi), r_props)
rxx_props = {
(0, 1): None,
(0, 2): None,
(0, 3): None,
(0, 4): None,
(1, 0): None,
(2, 0): None,
(3, 0): None,
(4, 0): None,
(1, 2): None,
(1, 3): None,
(1, 4): None,
(2, 1): None,
(3, 1): None,
(4, 1): None,
(2, 3): None,
(2, 4): None,
(3, 2): None,
(4, 2): None,
(3, 4): None,
(4, 3): None,
}
self.aqt_target.add_instruction(RXXGate(self.theta), rxx_props)
measure_props = {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
}
self.aqt_target.add_instruction(Measure(), measure_props)
self.empty_target = Target()
self.ideal_sim_target = Target(num_qubits=3, description="Ideal Simulator")
self.lam = Parameter("lam")
for inst in [
UGate(self.theta, self.phi, self.lam),
RXGate(self.theta),
RYGate(self.theta),
RZGate(self.theta),
CXGate(),
ECRGate(),
CCXGate(),
Measure(),
]:
self.ideal_sim_target.add_instruction(inst, {None: None})
def test_qargs(self):
self.assertEqual(set(), self.empty_target.qargs)
expected_ibm = {
(0,),
(1,),
(2,),
(3,),
(4,),
(3, 4),
(4, 3),
(3, 1),
(1, 3),
(1, 2),
(2, 1),
(0, 1),
(1, 0),
}
self.assertEqual(expected_ibm, self.ibm_target.qargs)
expected_aqt = {
(0,),
(1,),
(2,),
(3,),
(4,),
(0, 1),
(0, 2),
(0, 3),
(0, 4),
(1, 0),
(2, 0),
(3, 0),
(4, 0),
(1, 2),
(1, 3),
(1, 4),
(2, 1),
(3, 1),
(4, 1),
(2, 3),
(2, 4),
(3, 2),
(4, 2),
(3, 4),
(4, 3),
}
self.assertEqual(expected_aqt, self.aqt_target.qargs)
expected_fake = {
(0,),
(1,),
(0, 1),
(1, 0),
}
self.assertEqual(expected_fake, self.fake_backend_target.qargs)
self.assertEqual(None, self.ideal_sim_target.qargs)
def test_qargs_for_operation_name(self):
with self.assertRaises(KeyError):
self.empty_target.qargs_for_operation_name("rz")
self.assertEqual(
self.ibm_target.qargs_for_operation_name("rz"), {(0,), (1,), (2,), (3,), (4,)}
)
self.assertEqual(
self.aqt_target.qargs_for_operation_name("rz"), {(0,), (1,), (2,), (3,), (4,)}
)
self.assertEqual(self.fake_backend_target.qargs_for_operation_name("cx"), {(0, 1)})
self.assertEqual(
self.fake_backend_target.qargs_for_operation_name("ecr"),
{
(1, 0),
},
)
self.assertEqual(self.ideal_sim_target.qargs_for_operation_name("cx"), None)
def test_instruction_names(self):
self.assertEqual(self.empty_target.operation_names, set())
self.assertEqual(self.ibm_target.operation_names, {"rz", "id", "sx", "x", "cx", "measure"})
self.assertEqual(self.aqt_target.operation_names, {"rz", "ry", "rx", "rxx", "r", "measure"})
self.assertEqual(
self.fake_backend_target.operation_names, {"u", "cx", "measure", "ecr", "rx_30", "rx"}
)
self.assertEqual(
self.ideal_sim_target.operation_names,
{"u", "rz", "ry", "rx", "cx", "ecr", "ccx", "measure"},
)
def test_operations(self):
self.assertEqual(self.empty_target.operations, [])
ibm_expected = [RZGate(self.theta), IGate(), SXGate(), XGate(), CXGate(), Measure()]
for gate in ibm_expected:
self.assertIn(gate, self.ibm_target.operations)
aqt_expected = [
RZGate(self.theta),
RXGate(self.theta),
RYGate(self.theta),
RGate(self.theta, self.phi),
RXXGate(self.theta),
]
for gate in aqt_expected:
self.assertIn(gate, self.aqt_target.operations)
fake_expected = [
UGate(self.fake_backend._theta, self.fake_backend._phi, self.fake_backend._lam),
CXGate(),
Measure(),
ECRGate(),
RXGate(math.pi / 6),
RXGate(self.fake_backend._theta),
]
for gate in fake_expected:
self.assertIn(gate, self.fake_backend_target.operations)
ideal_sim_expected = [
UGate(self.theta, self.phi, self.lam),
RXGate(self.theta),
RYGate(self.theta),
RZGate(self.theta),
CXGate(),
ECRGate(),
CCXGate(),
Measure(),
]
for gate in ideal_sim_expected:
self.assertIn(gate, self.ideal_sim_target.operations)
def test_instructions(self):
self.assertEqual(self.empty_target.instructions, [])
ibm_expected = [
(IGate(), (0,)),
(IGate(), (1,)),
(IGate(), (2,)),
(IGate(), (3,)),
(IGate(), (4,)),
(RZGate(self.theta), (0,)),
(RZGate(self.theta), (1,)),
(RZGate(self.theta), (2,)),
(RZGate(self.theta), (3,)),
(RZGate(self.theta), (4,)),
(SXGate(), (0,)),
(SXGate(), (1,)),
(SXGate(), (2,)),
(SXGate(), (3,)),
(SXGate(), (4,)),
(XGate(), (0,)),
(XGate(), (1,)),
(XGate(), (2,)),
(XGate(), (3,)),
(XGate(), (4,)),
(CXGate(), (3, 4)),
(CXGate(), (4, 3)),
(CXGate(), (3, 1)),
(CXGate(), (1, 3)),
(CXGate(), (1, 2)),
(CXGate(), (2, 1)),
(CXGate(), (0, 1)),
(CXGate(), (1, 0)),
(Measure(), (0,)),
(Measure(), (1,)),
(Measure(), (2,)),
(Measure(), (3,)),
(Measure(), (4,)),
]
self.assertEqual(ibm_expected, self.ibm_target.instructions)
ideal_sim_expected = [
(UGate(self.theta, self.phi, self.lam), None),
(RXGate(self.theta), None),
(RYGate(self.theta), None),
(RZGate(self.theta), None),
(CXGate(), None),
(ECRGate(), None),
(CCXGate(), None),
(Measure(), None),
]
self.assertEqual(ideal_sim_expected, self.ideal_sim_target.instructions)
def test_instruction_properties(self):
i_gate_2 = self.ibm_target.instruction_properties(2)
self.assertEqual(i_gate_2.error, 0.0004003)
self.assertIsNone(self.ideal_sim_target.instruction_properties(4))
def test_get_instruction_from_name(self):
with self.assertRaises(KeyError):
self.empty_target.operation_from_name("measure")
self.assertEqual(self.ibm_target.operation_from_name("measure"), Measure())
self.assertEqual(self.fake_backend_target.operation_from_name("rx_30"), RXGate(math.pi / 6))
self.assertEqual(
self.fake_backend_target.operation_from_name("rx"),
RXGate(self.fake_backend._theta),
)
self.assertEqual(self.ideal_sim_target.operation_from_name("ccx"), CCXGate())
def test_get_instructions_for_qargs(self):
with self.assertRaises(KeyError):
self.empty_target.operations_for_qargs((0,))
expected = [RZGate(self.theta), IGate(), SXGate(), XGate(), Measure()]
res = self.ibm_target.operations_for_qargs((0,))
for gate in expected:
self.assertIn(gate, res)
expected = [ECRGate()]
res = self.fake_backend_target.operations_for_qargs((1, 0))
for gate in expected:
self.assertIn(gate, res)
expected = [CXGate()]
res = self.fake_backend_target.operations_for_qargs((0, 1))
self.assertEqual(expected, res)
ideal_sim_expected = [
UGate(self.theta, self.phi, self.lam),
RXGate(self.theta),
RYGate(self.theta),
RZGate(self.theta),
CXGate(),
ECRGate(),
CCXGate(),
Measure(),
]
for gate in ideal_sim_expected:
self.assertIn(gate, self.ideal_sim_target.operations_for_qargs(None))
def test_get_operation_for_qargs_global(self):
expected = [
RXGate(self.theta),
RYGate(self.theta),
RZGate(self.theta),
RGate(self.theta, self.phi),
Measure(),
]
res = self.aqt_target.operations_for_qargs((0,))
self.assertEqual(len(expected), len(res))
for x in expected:
self.assertIn(x, res)
expected = [RXXGate(self.theta)]
res = self.aqt_target.operations_for_qargs((0, 1))
self.assertEqual(len(expected), len(res))
for x in expected:
self.assertIn(x, res)
def test_get_invalid_operations_for_qargs(self):
with self.assertRaises(KeyError):
self.ibm_target.operations_for_qargs((0, 102))
with self.assertRaises(KeyError):
self.ibm_target.operations_for_qargs(None)
def test_get_operation_names_for_qargs(self):
with self.assertRaises(KeyError):
self.empty_target.operation_names_for_qargs((0,))
expected = {"rz", "id", "sx", "x", "measure"}
res = self.ibm_target.operation_names_for_qargs((0,))
for gate in expected:
self.assertIn(gate, res)
expected = {"ecr"}
res = self.fake_backend_target.operation_names_for_qargs((1, 0))
for gate in expected:
self.assertIn(gate, res)
expected = {"cx"}
res = self.fake_backend_target.operation_names_for_qargs((0, 1))
self.assertEqual(expected, res)
ideal_sim_expected = ["u", "rx", "ry", "rz", "cx", "ecr", "ccx", "measure"]
for gate in ideal_sim_expected:
self.assertIn(gate, self.ideal_sim_target.operation_names_for_qargs(None))
def test_get_operation_names_for_qargs_invalid_qargs(self):
with self.assertRaises(KeyError):
self.ibm_target.operation_names_for_qargs((0, 102))
with self.assertRaises(KeyError):
self.ibm_target.operation_names_for_qargs(None)
def test_get_operation_names_for_qargs_global_insts(self):
expected = {"r", "rx", "rz", "ry", "measure"}
self.assertEqual(self.aqt_target.operation_names_for_qargs((0,)), expected)
expected = {
"rxx",
}
self.assertEqual(self.aqt_target.operation_names_for_qargs((0, 1)), expected)
def test_coupling_map(self):
self.assertEqual(
CouplingMap().get_edges(), self.empty_target.build_coupling_map().get_edges()
)
self.assertEqual(
set(CouplingMap.from_full(5).get_edges()),
set(self.aqt_target.build_coupling_map().get_edges()),
)
self.assertEqual(
{(0, 1), (1, 0)}, set(self.fake_backend_target.build_coupling_map().get_edges())
)
self.assertEqual(
{
(3, 4),
(4, 3),
(3, 1),
(1, 3),
(1, 2),
(2, 1),
(0, 1),
(1, 0),
},
set(self.ibm_target.build_coupling_map().get_edges()),
)
self.assertEqual(None, self.ideal_sim_target.build_coupling_map())
def test_coupling_map_mutations_do_not_propagate(self):
cm = CouplingMap.from_line(5, bidirectional=False)
cx_props = {
edge: InstructionProperties(duration=270.22e-9, error=0.00713)
for edge in cm.get_edges()
}
target = Target()
target.add_instruction(CXGate(), cx_props)
self.assertEqual(cm, target.build_coupling_map())
symmetric = target.build_coupling_map()
symmetric.make_symmetric()
self.assertNotEqual(cm, symmetric) # sanity check for the test.
# Verify that mutating the output of `build_coupling_map` doesn't affect the target.
self.assertNotEqual(target.build_coupling_map(), symmetric)
def test_coupling_map_filtered_mutations_do_not_propagate(self):
cm = CouplingMap.from_line(5, bidirectional=False)
cx_props = {
edge: InstructionProperties(duration=270.22e-9, error=0.00713)
for edge in cm.get_edges()
if 2 not in edge
}
target = Target()
target.add_instruction(CXGate(), cx_props)
symmetric = target.build_coupling_map(filter_idle_qubits=True)
symmetric.make_symmetric()
self.assertNotEqual(cm, symmetric) # sanity check for the test.
# Verify that mutating the output of `build_coupling_map` doesn't affect the target.
self.assertNotEqual(target.build_coupling_map(filter_idle_qubits=True), symmetric)
def test_coupling_map_no_filter_mutations_do_not_propagate(self):
cm = CouplingMap.from_line(5, bidirectional=False)
cx_props = {
edge: InstructionProperties(duration=270.22e-9, error=0.00713)
for edge in cm.get_edges()
}
target = Target()
target.add_instruction(CXGate(), cx_props)
# The filter here does not actually do anything, because there's no idle qubits. This is
# just a test that this path is also not cached.
self.assertEqual(cm, target.build_coupling_map(filter_idle_qubits=True))
symmetric = target.build_coupling_map(filter_idle_qubits=True)
symmetric.make_symmetric()
self.assertNotEqual(cm, symmetric) # sanity check for the test.
# Verify that mutating the output of `build_coupling_map` doesn't affect the target.
self.assertNotEqual(target.build_coupling_map(filter_idle_qubits=True), symmetric)
def test_coupling_map_2q_gate(self):
cmap = self.fake_backend_target.build_coupling_map("ecr")
self.assertEqual(
[
(1, 0),
],
cmap.get_edges(),
)
def test_coupling_map_3q_gate(self):
fake_target = Target()
ccx_props = {
(0, 1, 2): None,
(1, 0, 2): None,
(2, 1, 0): None,
}
fake_target.add_instruction(CCXGate(), ccx_props)
with self.assertLogs("qiskit.transpiler.target", level="WARN") as log:
cmap = fake_target.build_coupling_map()
self.assertEqual(
log.output,
[
"WARNING:qiskit.transpiler.target:"
"This Target object contains multiqubit gates that "
"operate on > 2 qubits. This will not be reflected in "
"the output coupling map."
],
)
self.assertEqual([], cmap.get_edges())
with self.assertRaises(ValueError):
fake_target.build_coupling_map("ccx")
def test_coupling_map_mixed_ideal_global_1q_and_2q_gates(self):
n_qubits = 3
target = Target()
target.add_instruction(CXGate(), {(i, i + 1): None for i in range(n_qubits - 1)})
target.add_instruction(RXGate(Parameter("theta")), {None: None})
cmap = target.build_coupling_map()
self.assertEqual([(0, 1), (1, 2)], cmap.get_edges())
def test_coupling_map_mixed_global_1q_and_2q_gates(self):
n_qubits = 3
target = Target()
target.add_instruction(CXGate(), {(i, i + 1): None for i in range(n_qubits - 1)})
target.add_instruction(RXGate(Parameter("theta")))
cmap = target.build_coupling_map()
self.assertEqual([(0, 1), (1, 2)], cmap.get_edges())
def test_coupling_map_mixed_ideal_global_2q_and_real_2q_gates(self):
n_qubits = 3
target = Target()
target.add_instruction(CXGate(), {(i, i + 1): None for i in range(n_qubits - 1)})
target.add_instruction(ECRGate())
cmap = target.build_coupling_map()
self.assertIsNone(cmap)
def test_physical_qubits(self):
self.assertEqual([], self.empty_target.physical_qubits)
self.assertEqual(list(range(5)), self.ibm_target.physical_qubits)
self.assertEqual(list(range(5)), self.aqt_target.physical_qubits)
self.assertEqual(list(range(2)), self.fake_backend_target.physical_qubits)
self.assertEqual(list(range(3)), self.ideal_sim_target.physical_qubits)
def test_duplicate_instruction_add_instruction(self):
target = Target()
target.add_instruction(XGate(), {(0,): None})
with self.assertRaises(AttributeError):
target.add_instruction(XGate(), {(1,): None})
def test_durations(self):
empty_durations = self.empty_target.durations()
self.assertEqual(
empty_durations.duration_by_name_qubits, InstructionDurations().duration_by_name_qubits
)
aqt_durations = self.aqt_target.durations()
self.assertEqual(aqt_durations.duration_by_name_qubits, {})
ibm_durations = self.ibm_target.durations()
expected = {
("cx", (0, 1)): (5.1911e-07, "s"),
("cx", (1, 0)): (5.5466e-07, "s"),
("cx", (1, 2)): (2.2755e-07, "s"),
("cx", (1, 3)): (4.9777e-07, "s"),
("cx", (2, 1)): (2.6311e-07, "s"),
("cx", (3, 1)): (4.6222e-07, "s"),
("cx", (3, 4)): (2.7022e-07, "s"),
("cx", (4, 3)): (3.0577e-07, "s"),
("id", (0,)): (3.55e-08, "s"),
("id", (1,)): (3.55e-08, "s"),
("id", (2,)): (3.55e-08, "s"),
("id", (3,)): (3.55e-08, "s"),
("id", (4,)): (3.55e-08, "s"),
("measure", (0,)): (5.813e-06, "s"),
("measure", (1,)): (5.813e-06, "s"),
("measure", (2,)): (5.813e-06, "s"),
("measure", (3,)): (5.813e-06, "s"),
("measure", (4,)): (5.813e-06, "s"),
("rz", (0,)): (0, "s"),
("rz", (1,)): (0, "s"),
("rz", (2,)): (0, "s"),
("rz", (3,)): (0, "s"),
("rz", (4,)): (0, "s"),
("sx", (0,)): (3.55e-08, "s"),
("sx", (1,)): (3.55e-08, "s"),
("sx", (2,)): (3.55e-08, "s"),
("sx", (3,)): (3.55e-08, "s"),
("sx", (4,)): (3.55e-08, "s"),
("x", (0,)): (3.55e-08, "s"),
("x", (1,)): (3.55e-08, "s"),
("x", (2,)): (3.55e-08, "s"),
("x", (3,)): (3.55e-08, "s"),
("x", (4,)): (3.55e-08, "s"),
}
self.assertEqual(ibm_durations.duration_by_name_qubits, expected)
def test_mapping(self):
with self.assertRaises(KeyError):
_res = self.empty_target["cx"]
expected = {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
}
self.assertEqual(self.aqt_target["r"], expected)
self.assertEqual(["rx", "ry", "rz", "r", "rxx", "measure"], list(self.aqt_target))
expected_values = [
{
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
},
{
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
},
{
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
},
{
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
},
{
(0, 1): None,
(0, 2): None,
(0, 3): None,
(0, 4): None,
(1, 0): None,
(2, 0): None,
(3, 0): None,
(4, 0): None,
(1, 2): None,
(1, 3): None,
(1, 4): None,
(2, 1): None,
(3, 1): None,
(4, 1): None,
(2, 3): None,
(2, 4): None,
(3, 2): None,
(4, 2): None,
(3, 4): None,
(4, 3): None,
},
{
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
},
]
self.assertEqual(expected_values, list(self.aqt_target.values()))
expected_items = {
"rx": {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
},
"ry": {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
},
"rz": {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
},
"r": {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
},
"rxx": {
(0, 1): None,
(0, 2): None,
(0, 3): None,
(0, 4): None,
(1, 0): None,
(2, 0): None,
(3, 0): None,
(4, 0): None,
(1, 2): None,
(1, 3): None,
(1, 4): None,
(2, 1): None,
(3, 1): None,
(4, 1): None,
(2, 3): None,
(2, 4): None,
(3, 2): None,
(4, 2): None,
(3, 4): None,
(4, 3): None,
},
"measure": {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
},
}
self.assertEqual(expected_items, dict(self.aqt_target.items()))
self.assertIn("cx", self.ibm_target)
self.assertNotIn("ecr", self.ibm_target)
self.assertEqual(len(self.ibm_target), 6)
def test_update_instruction_properties(self):
self.aqt_target.update_instruction_properties(
"rxx",
(0, 1),
InstructionProperties(duration=1e-6, error=1e-5),
)
self.assertEqual(self.aqt_target["rxx"][(0, 1)].duration, 1e-6)
self.assertEqual(self.aqt_target["rxx"][(0, 1)].error, 1e-5)
def test_update_instruction_properties_invalid_instruction(self):
with self.assertRaises(KeyError):
self.ibm_target.update_instruction_properties("rxx", (0, 1), None)
def test_update_instruction_properties_invalid_qarg(self):
with self.assertRaises(KeyError):
self.fake_backend_target.update_instruction_properties("ecr", (0, 1), None)
def test_str(self):
expected = """Target
Number of qubits: 5
Instructions:
id
(0,):
Duration: 3.55e-08 sec.
Error Rate: 0.000413
(1,):
Duration: 3.55e-08 sec.
Error Rate: 0.000502
(2,):
Duration: 3.55e-08 sec.
Error Rate: 0.0004003
(3,):
Duration: 3.55e-08 sec.
Error Rate: 0.000614
(4,):
Duration: 3.55e-08 sec.
Error Rate: 0.006149
rz
(0,):
Duration: 0 sec.
Error Rate: 0
(1,):
Duration: 0 sec.
Error Rate: 0
(2,):
Duration: 0 sec.
Error Rate: 0
(3,):
Duration: 0 sec.
Error Rate: 0
(4,):
Duration: 0 sec.
Error Rate: 0
sx
(0,):
Duration: 3.55e-08 sec.
Error Rate: 0.000413
(1,):
Duration: 3.55e-08 sec.
Error Rate: 0.000502
(2,):
Duration: 3.55e-08 sec.
Error Rate: 0.0004003
(3,):
Duration: 3.55e-08 sec.
Error Rate: 0.000614
(4,):
Duration: 3.55e-08 sec.
Error Rate: 0.006149
x
(0,):
Duration: 3.55e-08 sec.
Error Rate: 0.000413
(1,):
Duration: 3.55e-08 sec.
Error Rate: 0.000502
(2,):
Duration: 3.55e-08 sec.
Error Rate: 0.0004003
(3,):
Duration: 3.55e-08 sec.
Error Rate: 0.000614
(4,):
Duration: 3.55e-08 sec.
Error Rate: 0.006149
cx
(3, 4):
Duration: 2.7022e-07 sec.
Error Rate: 0.00713
(4, 3):
Duration: 3.0577e-07 sec.
Error Rate: 0.00713
(3, 1):
Duration: 4.6222e-07 sec.
Error Rate: 0.00929
(1, 3):
Duration: 4.9777e-07 sec.
Error Rate: 0.00929
(1, 2):
Duration: 2.2755e-07 sec.
Error Rate: 0.00659
(2, 1):
Duration: 2.6311e-07 sec.
Error Rate: 0.00659
(0, 1):
Duration: 5.1911e-07 sec.
Error Rate: 0.01201
(1, 0):
Duration: 5.5466e-07 sec.
Error Rate: 0.01201
measure
(0,):
Duration: 5.813e-06 sec.
Error Rate: 0.0751
(1,):
Duration: 5.813e-06 sec.
Error Rate: 0.0225
(2,):
Duration: 5.813e-06 sec.
Error Rate: 0.0146
(3,):
Duration: 5.813e-06 sec.
Error Rate: 0.0215
(4,):
Duration: 5.813e-06 sec.
Error Rate: 0.0333
"""
self.assertEqual(expected, str(self.ibm_target))
aqt_expected = """Target: AQT Target
Number of qubits: 5
Instructions:
rx
(0,)
(1,)
(2,)
(3,)
(4,)
ry
(0,)
(1,)
(2,)
(3,)
(4,)
rz
(0,)
(1,)
(2,)
(3,)
(4,)
r
(0,)
(1,)
(2,)
(3,)
(4,)
rxx
(0, 1)
(0, 2)
(0, 3)
(0, 4)
(1, 0)
(2, 0)
(3, 0)
(4, 0)
(1, 2)
(1, 3)
(1, 4)
(2, 1)
(3, 1)
(4, 1)
(2, 3)
(2, 4)
(3, 2)
(4, 2)
(3, 4)
(4, 3)
measure
(0,)
(1,)
(2,)
(3,)
(4,)
"""
self.assertEqual(aqt_expected, str(self.aqt_target))
sim_expected = """Target: Ideal Simulator
Number of qubits: 3
Instructions:
u
rx
ry
rz
cx
ecr
ccx
measure
"""
self.assertEqual(sim_expected, str(self.ideal_sim_target))
def test_extra_props_str(self):
target = Target(description="Extra Properties")
class ExtraProperties(InstructionProperties):
"""An example properties subclass."""
def __init__(
self,
duration=None,
error=None,
calibration=None,
tuned=None,
diamond_norm_error=None,
):
super().__init__(duration=duration, error=error, calibration=calibration)
self.tuned = tuned
self.diamond_norm_error = diamond_norm_error
cx_props = {
(3, 4): ExtraProperties(
duration=270.22e-9, error=0.00713, tuned=False, diamond_norm_error=2.12e-6
),
}
target.add_instruction(CXGate(), cx_props)
expected = """Target: Extra Properties
Number of qubits: 5
Instructions:
cx
(3, 4):
Duration: 2.7022e-07 sec.
Error Rate: 0.00713
"""
self.assertEqual(expected, str(target))
def test_timing_constraints(self):
generated_constraints = self.aqt_target.timing_constraints()
expected_constraints = TimingConstraints()
for i in ["granularity", "min_length", "pulse_alignment", "acquire_alignment"]:
self.assertEqual(
getattr(generated_constraints, i),
getattr(expected_constraints, i),
f"Generated constraints differs from expected for attribute {i}"
f"{getattr(generated_constraints, i)}!={getattr(expected_constraints, i)}",
)
def test_get_non_global_operation_name_ideal_backend(self):
self.assertEqual(self.aqt_target.get_non_global_operation_names(), [])
self.assertEqual(self.ideal_sim_target.get_non_global_operation_names(), [])
self.assertEqual(self.ibm_target.get_non_global_operation_names(), [])
self.assertEqual(self.fake_backend_target.get_non_global_operation_names(), [])
def test_get_non_global_operation_name_ideal_backend_strict_direction(self):
self.assertEqual(self.aqt_target.get_non_global_operation_names(True), [])
self.assertEqual(self.ideal_sim_target.get_non_global_operation_names(True), [])
self.assertEqual(self.ibm_target.get_non_global_operation_names(True), [])
self.assertEqual(
self.fake_backend_target.get_non_global_operation_names(True), ["cx", "ecr"]
)
def test_instruction_supported(self):
self.assertTrue(self.aqt_target.instruction_supported("r", (0,)))
self.assertFalse(self.aqt_target.instruction_supported("cx", (0, 1)))
self.assertTrue(self.ideal_sim_target.instruction_supported("cx", (0, 1)))
self.assertFalse(self.ideal_sim_target.instruction_supported("cx", (0, 524)))
self.assertTrue(self.fake_backend_target.instruction_supported("cx", (0, 1)))
self.assertFalse(self.fake_backend_target.instruction_supported("cx", (1, 0)))
self.assertFalse(self.ideal_sim_target.instruction_supported("cx", (0, 1, 2)))
def test_instruction_supported_parameters(self):
mumbai = FakeMumbaiFractionalCX()
self.assertTrue(
mumbai.target.instruction_supported(
qargs=(0, 1), operation_class=RZXGate, parameters=[math.pi / 4]
)
)
self.assertTrue(mumbai.target.instruction_supported(qargs=(0, 1), operation_class=RZXGate))
self.assertTrue(
mumbai.target.instruction_supported(operation_class=RZXGate, parameters=[math.pi / 4])
)
self.assertFalse(mumbai.target.instruction_supported("rzx", parameters=[math.pi / 4]))
self.assertTrue(mumbai.target.instruction_supported("rz", parameters=[Parameter("angle")]))
self.assertTrue(
mumbai.target.instruction_supported("rzx_45", qargs=(0, 1), parameters=[math.pi / 4])
)
self.assertTrue(mumbai.target.instruction_supported("rzx_45", qargs=(0, 1)))
self.assertTrue(mumbai.target.instruction_supported("rzx_45", parameters=[math.pi / 4]))
self.assertFalse(mumbai.target.instruction_supported("rzx_45", parameters=[math.pi / 6]))
self.assertFalse(
mumbai.target.instruction_supported("rzx_45", parameters=[Parameter("angle")])
)
self.assertTrue(
self.ideal_sim_target.instruction_supported(
qargs=(0,), operation_class=RXGate, parameters=[Parameter("angle")]
)
)
self.assertTrue(
self.ideal_sim_target.instruction_supported(
qargs=(0,), operation_class=RXGate, parameters=[math.pi]
)
)
self.assertTrue(
self.ideal_sim_target.instruction_supported(
operation_class=RXGate, parameters=[math.pi]
)
)
self.assertTrue(
self.ideal_sim_target.instruction_supported(
operation_class=RXGate, parameters=[Parameter("angle")]
)
)
self.assertTrue(
self.ideal_sim_target.instruction_supported(
"rx", qargs=(0,), parameters=[Parameter("angle")]
)
)
self.assertTrue(
self.ideal_sim_target.instruction_supported("rx", qargs=(0,), parameters=[math.pi])
)
self.assertTrue(self.ideal_sim_target.instruction_supported("rx", parameters=[math.pi]))
self.assertTrue(
self.ideal_sim_target.instruction_supported("rx", parameters=[Parameter("angle")])
)
def test_instruction_supported_multiple_parameters(self):
target = Target(1)
target.add_instruction(
UGate(self.theta, self.phi, self.lam),
{(0,): InstructionProperties(duration=270.22e-9, error=0.00713)},
)
self.assertFalse(target.instruction_supported("u", parameters=[math.pi]))
self.assertTrue(target.instruction_supported("u", parameters=[math.pi, math.pi, math.pi]))
self.assertTrue(
target.instruction_supported(
operation_class=UGate, parameters=[math.pi, math.pi, math.pi]
)
)
self.assertFalse(
target.instruction_supported(operation_class=UGate, parameters=[Parameter("x")])
)
def test_instruction_supported_arg_len_mismatch(self):
self.assertFalse(
self.ideal_sim_target.instruction_supported(operation_class=UGate, parameters=[math.pi])
)
self.assertFalse(self.ideal_sim_target.instruction_supported("u", parameters=[math.pi]))
def test_instruction_supported_class_not_in_target(self):
self.assertFalse(
self.ibm_target.instruction_supported(operation_class=CZGate, parameters=[math.pi])
)
def test_instruction_supported_no_args(self):
self.assertFalse(self.ibm_target.instruction_supported())
def test_instruction_supported_no_operation(self):
self.assertFalse(self.ibm_target.instruction_supported(qargs=(0,), parameters=[math.pi]))
class TestPulseTarget(QiskitTestCase):
def setUp(self):
super().setUp()
self.pulse_target = Target(
dt=3e-7, granularity=2, min_length=4, pulse_alignment=8, acquire_alignment=8
)
with pulse.build(name="sx_q0") as self.custom_sx_q0:
pulse.play(pulse.Constant(100, 0.1), pulse.DriveChannel(0))
with pulse.build(name="sx_q1") as self.custom_sx_q1:
pulse.play(pulse.Constant(100, 0.2), pulse.DriveChannel(1))
sx_props = {
(0,): InstructionProperties(
duration=35.5e-9, error=0.000413, calibration=self.custom_sx_q0
),
(1,): InstructionProperties(
duration=35.5e-9, error=0.000502, calibration=self.custom_sx_q1
),
}
self.pulse_target.add_instruction(SXGate(), sx_props)
def test_instruction_schedule_map(self):
inst_map = self.pulse_target.instruction_schedule_map()
self.assertIn("sx", inst_map.instructions)
self.assertEqual(inst_map.qubits_with_instruction("sx"), [0, 1])
self.assertTrue("sx" in inst_map.qubit_instructions(0))
def test_instruction_schedule_map_ideal_sim_backend(self):
ideal_sim_target = Target(num_qubits=3)
theta = Parameter("theta")
phi = Parameter("phi")
lam = Parameter("lambda")
for inst in [
UGate(theta, phi, lam),
RXGate(theta),
RYGate(theta),
RZGate(theta),
CXGate(),
ECRGate(),
CCXGate(),
Measure(),
]:
ideal_sim_target.add_instruction(inst, {None: None})
inst_map = ideal_sim_target.instruction_schedule_map()
self.assertEqual(InstructionScheduleMap(), inst_map)
def test_str(self):
expected = """Target
Number of qubits: 2
Instructions:
sx
(0,):
Duration: 3.55e-08 sec.
Error Rate: 0.000413
With pulse schedule calibration
(1,):
Duration: 3.55e-08 sec.
Error Rate: 0.000502
With pulse schedule calibration
"""
self.assertEqual(expected, str(self.pulse_target))
def test_update_from_instruction_schedule_map_add_instruction(self):
target = Target()
inst_map = InstructionScheduleMap()
inst_map.add("sx", 0, self.custom_sx_q0)
inst_map.add("sx", 1, self.custom_sx_q1)
target.update_from_instruction_schedule_map(inst_map, {"sx": SXGate()})
self.assertEqual(inst_map, target.instruction_schedule_map())
def test_update_from_instruction_schedule_map_with_schedule_parameter(self):
self.pulse_target.dt = None
inst_map = InstructionScheduleMap()
duration = Parameter("duration")
with pulse.build(name="sx_q0") as custom_sx:
pulse.play(pulse.Constant(duration, 0.2), pulse.DriveChannel(0))
inst_map.add("sx", 0, custom_sx, ["duration"])
target = Target(dt=3e-7)
target.update_from_instruction_schedule_map(inst_map, {"sx": SXGate()})
self.assertEqual(inst_map, target.instruction_schedule_map())
def test_update_from_instruction_schedule_map_update_schedule(self):
self.pulse_target.dt = None
inst_map = InstructionScheduleMap()
with pulse.build(name="sx_q1") as custom_sx:
pulse.play(pulse.Constant(1000, 0.2), pulse.DriveChannel(1))
inst_map.add("sx", 0, self.custom_sx_q0)
inst_map.add("sx", 1, custom_sx)
self.pulse_target.update_from_instruction_schedule_map(inst_map, {"sx": SXGate()})
self.assertEqual(inst_map, self.pulse_target.instruction_schedule_map())
# Calibration doesn't change for q0
self.assertEqual(self.pulse_target["sx"][(0,)].duration, 35.5e-9)
self.assertEqual(self.pulse_target["sx"][(0,)].error, 0.000413)
# Calibration is updated for q1 without error dict and gate time
self.assertIsNone(self.pulse_target["sx"][(1,)].duration)
self.assertIsNone(self.pulse_target["sx"][(1,)].error)
def test_update_from_instruction_schedule_map_new_instruction_no_name_map(self):
target = Target()
inst_map = InstructionScheduleMap()
inst_map.add("sx", 0, self.custom_sx_q0)
inst_map.add("sx", 1, self.custom_sx_q1)
target.update_from_instruction_schedule_map(inst_map)
self.assertEqual(target["sx"][(0,)].calibration, self.custom_sx_q0)
self.assertEqual(target["sx"][(1,)].calibration, self.custom_sx_q1)
def test_update_from_instruction_schedule_map_new_qarg_raises(self):
inst_map = InstructionScheduleMap()
inst_map.add("sx", 0, self.custom_sx_q0)
inst_map.add("sx", 1, self.custom_sx_q1)
inst_map.add("sx", 2, self.custom_sx_q1)
self.pulse_target.update_from_instruction_schedule_map(inst_map)
self.assertFalse(self.pulse_target.instruction_supported("sx", (2,)))
def test_update_from_instruction_schedule_map_with_dt_set(self):
inst_map = InstructionScheduleMap()
with pulse.build(name="sx_q1") as custom_sx:
pulse.play(pulse.Constant(1000, 0.2), pulse.DriveChannel(1))
inst_map.add("sx", 0, self.custom_sx_q0)
inst_map.add("sx", 1, custom_sx)
self.pulse_target.dt = 1.0
self.pulse_target.update_from_instruction_schedule_map(inst_map, {"sx": SXGate()})
self.assertEqual(inst_map, self.pulse_target.instruction_schedule_map())
self.assertEqual(self.pulse_target["sx"][(1,)].duration, 1000.0)
self.assertIsNone(self.pulse_target["sx"][(1,)].error)
# This is an edge case.
# System dt is read-only property and changing it will break all underlying calibrations.
# duration of sx0 returns previous value since calibration doesn't change.
self.assertEqual(self.pulse_target["sx"][(0,)].duration, 35.5e-9)
self.assertEqual(self.pulse_target["sx"][(0,)].error, 0.000413)
def test_update_from_instruction_schedule_map_with_error_dict(self):
inst_map = InstructionScheduleMap()
with pulse.build(name="sx_q1") as custom_sx:
pulse.play(pulse.Constant(1000, 0.2), pulse.DriveChannel(1))
inst_map.add("sx", 0, self.custom_sx_q0)
inst_map.add("sx", 1, custom_sx)
self.pulse_target.dt = 1.0
error_dict = {"sx": {(1,): 1.0}}
self.pulse_target.update_from_instruction_schedule_map(
inst_map, {"sx": SXGate()}, error_dict=error_dict
)
self.assertEqual(self.pulse_target["sx"][(1,)].error, 1.0)
self.assertEqual(self.pulse_target["sx"][(0,)].error, 0.000413)
def test_timing_constraints(self):
generated_constraints = self.pulse_target.timing_constraints()
expected_constraints = TimingConstraints(2, 4, 8, 8)
for i in ["granularity", "min_length", "pulse_alignment", "acquire_alignment"]:
self.assertEqual(
getattr(generated_constraints, i),
getattr(expected_constraints, i),
f"Generated constraints differs from expected for attribute {i}"
f"{getattr(generated_constraints, i)}!={getattr(expected_constraints, i)}",
)
def test_default_instmap_has_no_custom_gate(self):
backend = FakeGeneva()
target = backend.target
# This copies .calibraiton of InstructionProperties of each instruction
# This must not convert PulseQobj to Schedule during this.
# See qiskit-terra/#9595
inst_map = target.instruction_schedule_map()
self.assertFalse(inst_map.has_custom_gate())
# Get pulse schedule. This generates Schedule provided by backend.
sched = inst_map.get("sx", (0,))
self.assertEqual(sched.metadata["publisher"], CalibrationPublisher.BACKEND_PROVIDER)
self.assertFalse(inst_map.has_custom_gate())
# Update target with custom instruction. This is user provided schedule.
new_prop = InstructionProperties(
duration=self.custom_sx_q0.duration,
error=None,
calibration=self.custom_sx_q0,
)
target.update_instruction_properties(instruction="sx", qargs=(0,), properties=new_prop)
inst_map = target.instruction_schedule_map()
self.assertTrue(inst_map.has_custom_gate())
empty = InstructionProperties()
target.update_instruction_properties(instruction="sx", qargs=(0,), properties=empty)
inst_map = target.instruction_schedule_map()
self.assertFalse(inst_map.has_custom_gate())
def test_get_empty_target_calibration(self):
target = Target()
properties = {(0,): InstructionProperties(duration=100, error=0.1)}
target.add_instruction(XGate(), properties)
self.assertIsNone(target["x"][(0,)].calibration)
def test_loading_legacy_ugate_instmap(self):
# This is typical IBM backend situation.
# IBM provider used to have u1, u2, u3 in the basis gates and
# these have been replaced with sx and rz.
# However, IBM provider still provides calibration of these u gates,
# and the inst map loads them as backend calibrations.
# Target is implicitly updated with inst map when it is set in transpile.
# If u gates are not excluded, they may appear in the transpiled circuit.
# These gates are no longer supported by hardware.
entry = ScheduleDef()
entry.define(pulse.Schedule(name="fake_u3"), user_provided=False) # backend provided
instmap = InstructionScheduleMap()
instmap._add("u3", (0,), entry)
# Today's standard IBM backend target with sx, rz basis
target = Target()
target.add_instruction(SXGate(), {(0,): InstructionProperties()})
target.add_instruction(RZGate(Parameter("θ")), {(0,): InstructionProperties()})
target.add_instruction(Measure(), {(0,): InstructionProperties()})
names_before = set(target.operation_names)
target.update_from_instruction_schedule_map(instmap)
names_after = set(target.operation_names)
# Otherwise u3 and sx-rz basis conflict in 1q decomposition.
self.assertSetEqual(names_before, names_after)
class TestGlobalVariableWidthOperations(QiskitTestCase):
def setUp(self):
super().setUp()
self.theta = Parameter("theta")
self.phi = Parameter("phi")
self.lam = Parameter("lambda")
self.target_global_gates_only = Target(num_qubits=5)
self.target_global_gates_only.add_instruction(CXGate())
self.target_global_gates_only.add_instruction(UGate(self.theta, self.phi, self.lam))
self.target_global_gates_only.add_instruction(Measure())
self.target_global_gates_only.add_instruction(IfElseOp, name="if_else")
self.target_global_gates_only.add_instruction(ForLoopOp, name="for_loop")
self.target_global_gates_only.add_instruction(WhileLoopOp, name="while_loop")
self.target_global_gates_only.add_instruction(SwitchCaseOp, name="switch_case")
self.ibm_target = Target()
i_props = {
(0,): InstructionProperties(duration=35.5e-9, error=0.000413),
(1,): InstructionProperties(duration=35.5e-9, error=0.000502),
(2,): InstructionProperties(duration=35.5e-9, error=0.0004003),
(3,): InstructionProperties(duration=35.5e-9, error=0.000614),
(4,): InstructionProperties(duration=35.5e-9, error=0.006149),
}
self.ibm_target.add_instruction(IGate(), i_props)
rz_props = {
(0,): InstructionProperties(duration=0, error=0),
(1,): InstructionProperties(duration=0, error=0),
(2,): InstructionProperties(duration=0, error=0),
(3,): InstructionProperties(duration=0, error=0),
(4,): InstructionProperties(duration=0, error=0),
}
self.ibm_target.add_instruction(RZGate(self.theta), rz_props)
sx_props = {
(0,): InstructionProperties(duration=35.5e-9, error=0.000413),
(1,): InstructionProperties(duration=35.5e-9, error=0.000502),
(2,): InstructionProperties(duration=35.5e-9, error=0.0004003),
(3,): InstructionProperties(duration=35.5e-9, error=0.000614),
(4,): InstructionProperties(duration=35.5e-9, error=0.006149),
}
self.ibm_target.add_instruction(SXGate(), sx_props)
x_props = {
(0,): InstructionProperties(duration=35.5e-9, error=0.000413),
(1,): InstructionProperties(duration=35.5e-9, error=0.000502),
(2,): InstructionProperties(duration=35.5e-9, error=0.0004003),
(3,): InstructionProperties(duration=35.5e-9, error=0.000614),
(4,): InstructionProperties(duration=35.5e-9, error=0.006149),
}
self.ibm_target.add_instruction(XGate(), x_props)
cx_props = {
(3, 4): InstructionProperties(duration=270.22e-9, error=0.00713),
(4, 3): InstructionProperties(duration=305.77e-9, error=0.00713),
(3, 1): InstructionProperties(duration=462.22e-9, error=0.00929),
(1, 3): InstructionProperties(duration=497.77e-9, error=0.00929),
(1, 2): InstructionProperties(duration=227.55e-9, error=0.00659),
(2, 1): InstructionProperties(duration=263.11e-9, error=0.00659),
(0, 1): InstructionProperties(duration=519.11e-9, error=0.01201),
(1, 0): InstructionProperties(duration=554.66e-9, error=0.01201),
}
self.ibm_target.add_instruction(CXGate(), cx_props)
measure_props = {
(0,): InstructionProperties(duration=5.813e-6, error=0.0751),
(1,): InstructionProperties(duration=5.813e-6, error=0.0225),
(2,): InstructionProperties(duration=5.813e-6, error=0.0146),
(3,): InstructionProperties(duration=5.813e-6, error=0.0215),
(4,): InstructionProperties(duration=5.813e-6, error=0.0333),
}
self.ibm_target.add_instruction(Measure(), measure_props)
self.ibm_target.add_instruction(IfElseOp, name="if_else")
self.ibm_target.add_instruction(ForLoopOp, name="for_loop")
self.ibm_target.add_instruction(WhileLoopOp, name="while_loop")
self.ibm_target.add_instruction(SwitchCaseOp, name="switch_case")
self.aqt_target = Target(description="AQT Target")
rx_props = {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
}
self.aqt_target.add_instruction(RXGate(self.theta), rx_props)
ry_props = {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
}
self.aqt_target.add_instruction(RYGate(self.theta), ry_props)
rz_props = {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
}
self.aqt_target.add_instruction(RZGate(self.theta), rz_props)
r_props = {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
}
self.aqt_target.add_instruction(RGate(self.theta, self.phi), r_props)
rxx_props = {
(0, 1): None,
(0, 2): None,
(0, 3): None,
(0, 4): None,
(1, 0): None,
(2, 0): None,
(3, 0): None,
(4, 0): None,
(1, 2): None,
(1, 3): None,
(1, 4): None,
(2, 1): None,
(3, 1): None,
(4, 1): None,
(2, 3): None,
(2, 4): None,
(3, 2): None,
(4, 2): None,
(3, 4): None,
(4, 3): None,
}
self.aqt_target.add_instruction(RXXGate(self.theta), rxx_props)
measure_props = {
(0,): None,
(1,): None,
(2,): None,
(3,): None,
(4,): None,
}
self.aqt_target.add_instruction(Measure(), measure_props)
self.aqt_target.add_instruction(IfElseOp, name="if_else")
self.aqt_target.add_instruction(ForLoopOp, name="for_loop")
self.aqt_target.add_instruction(WhileLoopOp, name="while_loop")
self.aqt_target.add_instruction(SwitchCaseOp, name="switch_case")
def test_qargs(self):
expected_ibm = {
(0,),
(1,),
(2,),
(3,),
(4,),
(3, 4),
(4, 3),
(3, 1),
(1, 3),
(1, 2),
(2, 1),
(0, 1),
(1, 0),
}
self.assertEqual(expected_ibm, self.ibm_target.qargs)
expected_aqt = {
(0,),
(1,),
(2,),
(3,),
(4,),
(0, 1),
(0, 2),
(0, 3),
(0, 4),
(1, 0),
(2, 0),
(3, 0),
(4, 0),
(1, 2),
(1, 3),
(1, 4),
(2, 1),
(3, 1),
(4, 1),
(2, 3),
(2, 4),
(3, 2),
(4, 2),
(3, 4),
(4, 3),
}
self.assertEqual(expected_aqt, self.aqt_target.qargs)
self.assertEqual(None, self.target_global_gates_only.qargs)
def test_qargs_single_qarg(self):
target = Target()
target.add_instruction(XGate(), {(0,): None})
self.assertEqual(
{
(0,),
},
target.qargs,
)
def test_qargs_for_operation_name(self):
self.assertEqual(
self.ibm_target.qargs_for_operation_name("rz"), {(0,), (1,), (2,), (3,), (4,)}
)
self.assertEqual(
self.aqt_target.qargs_for_operation_name("rz"), {(0,), (1,), (2,), (3,), (4,)}
)
self.assertIsNone(self.target_global_gates_only.qargs_for_operation_name("cx"))
self.assertIsNone(self.ibm_target.qargs_for_operation_name("if_else"))
self.assertIsNone(self.aqt_target.qargs_for_operation_name("while_loop"))
self.assertIsNone(self.aqt_target.qargs_for_operation_name("switch_case"))
def test_instruction_names(self):
self.assertEqual(
self.ibm_target.operation_names,
{
"rz",
"id",
"sx",
"x",
"cx",
"measure",
"if_else",
"while_loop",
"for_loop",
"switch_case",
},
)
self.assertEqual(
self.aqt_target.operation_names,
{
"rz",
"ry",
"rx",
"rxx",
"r",
"measure",
"if_else",
"while_loop",
"for_loop",
"switch_case",
},
)
self.assertEqual(
self.target_global_gates_only.operation_names,
{"u", "cx", "measure", "if_else", "while_loop", "for_loop", "switch_case"},
)
def test_operations_for_qargs(self):
expected = [
IGate(),
RZGate(self.theta),
SXGate(),
XGate(),
Measure(),
IfElseOp,
ForLoopOp,
WhileLoopOp,
SwitchCaseOp,
]
res = self.ibm_target.operations_for_qargs((0,))
self.assertEqual(len(expected), len(res))
for x in expected:
self.assertIn(x, res)
expected = [
CXGate(),
IfElseOp,
ForLoopOp,
WhileLoopOp,
SwitchCaseOp,
]
res = self.ibm_target.operations_for_qargs((0, 1))
self.assertEqual(len(expected), len(res))
for x in expected:
self.assertIn(x, res)
expected = [
RXGate(self.theta),
RYGate(self.theta),
RZGate(self.theta),
RGate(self.theta, self.phi),
Measure(),
IfElseOp,
ForLoopOp,
WhileLoopOp,
SwitchCaseOp,
]
res = self.aqt_target.operations_for_qargs((0,))
self.assertEqual(len(expected), len(res))
for x in expected:
self.assertIn(x, res)
expected = [RXXGate(self.theta), IfElseOp, ForLoopOp, WhileLoopOp, SwitchCaseOp]
res = self.aqt_target.operations_for_qargs((0, 1))
self.assertEqual(len(expected), len(res))
for x in expected:
self.assertIn(x, res)
def test_operation_names_for_qargs(self):
expected = {
"id",
"rz",
"sx",
"x",
"measure",
"if_else",
"for_loop",
"while_loop",
"switch_case",
}
self.assertEqual(expected, self.ibm_target.operation_names_for_qargs((0,)))
expected = {
"cx",
"if_else",
"for_loop",
"while_loop",
"switch_case",
}
self.assertEqual(expected, self.ibm_target.operation_names_for_qargs((0, 1)))
expected = {
"rx",
"ry",
"rz",
"r",
"measure",
"if_else",
"for_loop",
"while_loop",
"switch_case",
}
self.assertEqual(self.aqt_target.operation_names_for_qargs((0,)), expected)
expected = {"rxx", "if_else", "for_loop", "while_loop", "switch_case"}
self.assertEqual(self.aqt_target.operation_names_for_qargs((0, 1)), expected)
def test_operations(self):
ibm_expected = [
RZGate(self.theta),
IGate(),
SXGate(),
XGate(),
CXGate(),
Measure(),
WhileLoopOp,
IfElseOp,
ForLoopOp,
SwitchCaseOp,
]
for gate in ibm_expected:
self.assertIn(gate, self.ibm_target.operations)
aqt_expected = [
RZGate(self.theta),
RXGate(self.theta),
RYGate(self.theta),
RGate(self.theta, self.phi),
RXXGate(self.theta),
ForLoopOp,
IfElseOp,
WhileLoopOp,
SwitchCaseOp,
]
for gate in aqt_expected:
self.assertIn(gate, self.aqt_target.operations)
fake_expected = [
UGate(self.theta, self.phi, self.lam),
CXGate(),
Measure(),
ForLoopOp,
WhileLoopOp,
IfElseOp,
SwitchCaseOp,
]
for gate in fake_expected:
self.assertIn(gate, self.target_global_gates_only.operations)
def test_add_invalid_instruction(self):
inst_props = {(0, 1, 2, 3): None}
target = Target()
with self.assertRaises(TranspilerError):
target.add_instruction(CXGate(), inst_props)
def test_instructions(self):
ibm_expected = [
(IGate(), (0,)),
(IGate(), (1,)),
(IGate(), (2,)),
(IGate(), (3,)),
(IGate(), (4,)),
(RZGate(self.theta), (0,)),
(RZGate(self.theta), (1,)),
(RZGate(self.theta), (2,)),
(RZGate(self.theta), (3,)),
(RZGate(self.theta), (4,)),
(SXGate(), (0,)),
(SXGate(), (1,)),
(SXGate(), (2,)),
(SXGate(), (3,)),
(SXGate(), (4,)),
(XGate(), (0,)),
(XGate(), (1,)),
(XGate(), (2,)),
(XGate(), (3,)),
(XGate(), (4,)),
(CXGate(), (3, 4)),
(CXGate(), (4, 3)),
(CXGate(), (3, 1)),
(CXGate(), (1, 3)),
(CXGate(), (1, 2)),
(CXGate(), (2, 1)),
(CXGate(), (0, 1)),
(CXGate(), (1, 0)),
(Measure(), (0,)),
(Measure(), (1,)),
(Measure(), (2,)),
(Measure(), (3,)),
(Measure(), (4,)),
(IfElseOp, None),
(ForLoopOp, None),
(WhileLoopOp, None),
(SwitchCaseOp, None),
]
self.assertEqual(ibm_expected, self.ibm_target.instructions)
ideal_sim_expected = [
(CXGate(), None),
(UGate(self.theta, self.phi, self.lam), None),
(Measure(), None),
(IfElseOp, None),
(ForLoopOp, None),
(WhileLoopOp, None),
(SwitchCaseOp, None),
]
self.assertEqual(ideal_sim_expected, self.target_global_gates_only.instructions)
def test_instruction_supported(self):
self.assertTrue(self.aqt_target.instruction_supported("r", (0,)))
self.assertFalse(self.aqt_target.instruction_supported("cx", (0, 1)))
self.assertTrue(self.target_global_gates_only.instruction_supported("cx", (0, 1)))
self.assertFalse(self.target_global_gates_only.instruction_supported("cx", (0, 524)))
self.assertFalse(self.target_global_gates_only.instruction_supported("cx", (0, 1, 2)))
self.assertTrue(self.aqt_target.instruction_supported("while_loop", (0, 1, 2, 3)))
self.assertTrue(
self.aqt_target.instruction_supported(operation_class=WhileLoopOp, qargs=(0, 1, 2, 3))
)
self.assertTrue(
self.aqt_target.instruction_supported(operation_class=SwitchCaseOp, qargs=(0, 1, 2, 3))
)
self.assertFalse(
self.ibm_target.instruction_supported(
operation_class=IfElseOp, qargs=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
)
)
self.assertFalse(
self.ibm_target.instruction_supported(operation_class=IfElseOp, qargs=(0, 425))
)
self.assertFalse(self.ibm_target.instruction_supported("for_loop", qargs=(0, 425)))
def test_coupling_map(self):
self.assertIsNone(self.target_global_gates_only.build_coupling_map())
self.assertEqual(
set(CouplingMap.from_full(5).get_edges()),
set(self.aqt_target.build_coupling_map().get_edges()),
)
self.assertEqual(
{
(3, 4),
(4, 3),
(3, 1),
(1, 3),
(1, 2),
(2, 1),
(0, 1),
(1, 0),
},
set(self.ibm_target.build_coupling_map().get_edges()),
)
class TestInstructionProperties(QiskitTestCase):
def test_empty_repr(self):
properties = InstructionProperties()
self.assertEqual(
repr(properties),
"InstructionProperties(duration=None, error=None, calibration=None)",
)
class TestTargetFromConfiguration(QiskitTestCase):
"""Test the from_configuration() constructor."""
def test_basis_gates_qubits_only(self):
"""Test construction with only basis gates."""
target = Target.from_configuration(["u", "cx"], 3)
self.assertEqual(target.operation_names, {"u", "cx"})
def test_basis_gates_no_qubits(self):
target = Target.from_configuration(["u", "cx"])
self.assertEqual(target.operation_names, {"u", "cx"})
def test_basis_gates_coupling_map(self):
"""Test construction with only basis gates."""
target = Target.from_configuration(
["u", "cx"], 3, CouplingMap.from_ring(3, bidirectional=False)
)
self.assertEqual(target.operation_names, {"u", "cx"})
self.assertEqual({(0,), (1,), (2,)}, target["u"].keys())
self.assertEqual({(0, 1), (1, 2), (2, 0)}, target["cx"].keys())
def test_properties(self):
fake_backend = FakeVigo()
config = fake_backend.configuration()
properties = fake_backend.properties()
target = Target.from_configuration(
basis_gates=config.basis_gates,
num_qubits=config.num_qubits,
coupling_map=CouplingMap(config.coupling_map),
backend_properties=properties,
)
self.assertEqual(0, target["rz"][(0,)].error)
self.assertEqual(0, target["rz"][(0,)].duration)
def test_properties_with_durations(self):
fake_backend = FakeVigo()
config = fake_backend.configuration()
properties = fake_backend.properties()
durations = InstructionDurations([("rz", 0, 0.5)], dt=1.0)
target = Target.from_configuration(
basis_gates=config.basis_gates,
num_qubits=config.num_qubits,
coupling_map=CouplingMap(config.coupling_map),
backend_properties=properties,
instruction_durations=durations,
dt=config.dt,
)
self.assertEqual(0.5, target["rz"][(0,)].duration)
def test_inst_map(self):
fake_backend = FakeNairobi()
config = fake_backend.configuration()
properties = fake_backend.properties()
defaults = fake_backend.defaults()
constraints = TimingConstraints(**config.timing_constraints)
target = Target.from_configuration(
basis_gates=config.basis_gates,
num_qubits=config.num_qubits,
coupling_map=CouplingMap(config.coupling_map),
backend_properties=properties,
dt=config.dt,
inst_map=defaults.instruction_schedule_map,
timing_constraints=constraints,
)
self.assertIsNotNone(target["sx"][(0,)].calibration)
self.assertEqual(target.granularity, constraints.granularity)
self.assertEqual(target.min_length, constraints.min_length)
self.assertEqual(target.pulse_alignment, constraints.pulse_alignment)
self.assertEqual(target.acquire_alignment, constraints.acquire_alignment)
def test_concurrent_measurements(self):
fake_backend = FakeVigo()
config = fake_backend.configuration()
target = Target.from_configuration(
basis_gates=config.basis_gates,
concurrent_measurements=config.meas_map,
)
self.assertEqual(target.concurrent_measurements, config.meas_map)
def test_custom_basis_gates(self):
basis_gates = ["my_x", "cx"]
custom_name_mapping = {"my_x": XGate()}
target = Target.from_configuration(
basis_gates=basis_gates, num_qubits=2, custom_name_mapping=custom_name_mapping
)
self.assertEqual(target.operation_names, {"my_x", "cx"})
def test_missing_custom_basis_no_coupling(self):
basis_gates = ["my_X", "cx"]
with self.assertRaisesRegex(KeyError, "is not present in the standard gate names"):
Target.from_configuration(basis_gates, num_qubits=4)
def test_missing_custom_basis_with_coupling(self):
basis_gates = ["my_X", "cx"]
cmap = CouplingMap.from_line(3)
with self.assertRaisesRegex(KeyError, "is not present in the standard gate names"):
Target.from_configuration(basis_gates, 3, cmap)
def test_over_two_qubit_gate_without_coupling(self):
basis_gates = ["ccx", "cx", "swap", "u"]
target = Target.from_configuration(basis_gates, 15)
self.assertEqual(target.operation_names, {"ccx", "cx", "swap", "u"})
def test_over_two_qubits_with_coupling(self):
basis_gates = ["ccx", "cx", "swap", "u"]
cmap = CouplingMap.from_line(15)
with self.assertRaisesRegex(TranspilerError, "This constructor method only supports"):
Target.from_configuration(basis_gates, 15, cmap)
|
https://github.com/sebasmos/QuantumVE
|
sebasmos
|
# Define the model name
model_name = "efficientnet_b3" #EfficientNet_B7_Weights.IMAGENET1K_V1
feat_space = 8
!pwd
%cd qubico
!pwd
import torchvision.models as models
import torch
MODEL_CONSTRUCTORS = {
'alexnet': models.alexnet,
'convnext_base': models.convnext_base,
'convnext_large': models.convnext_large,
'convnext_small': models.convnext_small,
'convnext_tiny': models.convnext_tiny,
'densenet121': models.densenet121,
'densenet161': models.densenet161,
'densenet169': models.densenet169,
'densenet201': models.densenet201,
'efficientnet_b0': models.efficientnet_b0,
'efficientnet_b1': models.efficientnet_b1,
'efficientnet_b2': models.efficientnet_b2,
'efficientnet_b3': models.efficientnet_b3,
'efficientnet_b4': models.efficientnet_b4,
'efficientnet_b5': models.efficientnet_b5,
'efficientnet_b6': models.efficientnet_b6,
'efficientnet_b7': models.efficientnet_b7,
'efficientnet_v2_l': models.efficientnet_v2_l,
'efficientnet_v2_m': models.efficientnet_v2_m,
'efficientnet_v2_s': models.efficientnet_v2_s,
'googlenet': models.googlenet,
'inception_v3': models.inception_v3,
'maxvit_t': models.maxvit_t,
'mnasnet0_5': models.mnasnet0_5,
'mnasnet0_75': models.mnasnet0_75,
'mnasnet1_0': models.mnasnet1_0,
'mnasnet1_3': models.mnasnet1_3,
'mobilenet_v2': models.mobilenet_v2,
'mobilenet_v3_large': models.mobilenet_v3_large,
'mobilenet_v3_small': models.mobilenet_v3_small,
'regnet_x_16gf': models.regnet_x_16gf,
'regnet_x_1_6gf': models.regnet_x_1_6gf,
'regnet_x_32gf': models.regnet_x_32gf,
'regnet_x_3_2gf': models.regnet_x_3_2gf,
'regnet_x_400mf': models.regnet_x_400mf,
'regnet_x_800mf': models.regnet_x_800mf,
'regnet_x_8gf': models.regnet_x_8gf,
'regnet_y_128gf': models.regnet_y_128gf,# check this regnet_y_128gf: no weigthts avaialble
'regnet_y_16gf': models.regnet_y_16gf,
'regnet_y_1_6gf': models.regnet_y_1_6gf,
'regnet_y_32gf': models.regnet_y_32gf,
'regnet_y_3_2gf': models.regnet_y_3_2gf,
'regnet_y_400mf': models.regnet_y_400mf,
'regnet_y_800mf': models.regnet_y_800mf,
'regnet_y_8gf': models.regnet_y_8gf,
'resnet101': models.resnet101,
'resnet152': models.resnet152,
'resnet18': models.resnet18,
'resnet34': models.resnet34,
'resnet50': models.resnet50,
'resnext101_32x8d': models.resnext101_32x8d,
'resnext101_64x4d': models.resnext101_64x4d,
'resnext50_32x4d': models.resnext50_32x4d,
'shufflenet_v2_x0_5': models.shufflenet_v2_x0_5,
'shufflenet_v2_x1_0': models.shufflenet_v2_x1_0,
'shufflenet_v2_x1_5': models.shufflenet_v2_x1_5,
'shufflenet_v2_x2_0': models.shufflenet_v2_x2_0,
'squeezenet1_0': models.squeezenet1_0,
'squeezenet1_1': models.squeezenet1_1,
'swin_b': models.swin_b,
'swin_s': models.swin_s,
'swin_t': models.swin_t,
'swin_v2_b': models.swin_v2_b,
'swin_v2_s': models.swin_v2_s,
'swin_v2_t': models.swin_v2_t,
'vgg11': models.vgg11,
'vgg11_bn': models.vgg11_bn,
'vgg13': models.vgg13,
'vgg13_bn': models.vgg13_bn,
'vgg16': models.vgg16,
'vgg16_bn': models.vgg16_bn,
'vgg19': models.vgg19,
'vgg19_bn': models.vgg19_bn,
'vit_b_16': models.vit_b_16,
'vit_b_32': models.vit_b_32,
'vit_h_14': models.vit_h_14,# and this..no weigthts avaialble
'vit_l_16': models.vit_l_16,
'vit_l_32': models.vit_l_32,
'wide_resnet101_2': models.wide_resnet101_2,
'wide_resnet50_2': models.wide_resnet50_2
}
# Create experiment directory
EXPERIMENT_NAME = f"{model_name}_embeddings"
import os
os.makedirs(EXPERIMENT_NAME, exist_ok=True)
train_path = f"{EXPERIMENT_NAME}/train"
val_path = f"{EXPERIMENT_NAME}/val"
os.makedirs(train_path, exist_ok=True)
os.makedirs(val_path, exist_ok=True)
import sys
sys.path.insert(0,'../')
from __future__ import print_function
import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.optim.lr_scheduler import StepLR
from torch.utils.data import random_split
from torch.utils.data import Subset, DataLoader, random_split
from torchvision import datasets, transforms
import torch.optim as optim
from torch.optim.lr_scheduler import StepLR
import matplotlib.pyplot as plt
import numpy as np
from sklearn.metrics import confusion_matrix, classification_report
import pandas as pd
# from MAE code
from util.datasets import build_dataset
import argparse
import util.misc as misc
import argparse
import datetime
import json
import numpy as np
import os
import time
from pathlib import Path
import torch
import torch.backends.cudnn as cudnn
from torch.utils.tensorboard import SummaryWriter
import timm
assert timm.__version__ == "0.3.2" # version check
from timm.models.layers import trunc_normal_
from timm.data.mixup import Mixup
from timm.loss import LabelSmoothingCrossEntropy, SoftTargetCrossEntropy
import util.lr_decay as lrd
import util.misc as misc
from util.datasets import build_dataset
from util.pos_embed import interpolate_pos_embed
from util.misc import NativeScalerWithGradNormCount as NativeScaler
import models_vit
import sys
import os
import torch
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
import models_mae
import torch; print(f'numpy version: {np.__version__}\nCUDA version: {torch.version.cuda} - Torch versteion: {torch.__version__} - device count: {torch.cuda.device_count()}')
from engine_finetune import train_one_epoch, evaluate
from timm.data import Mixup
from timm.utils import accuracy
from sklearn.metrics import confusion_matrix, classification_report
import seaborn as sns
from sklearn.preprocessing import LabelBinarizer
from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt
from itertools import cycle
import numpy as np
from sklearn.metrics import precision_score, recall_score, f1_score
import torch.optim as optim
import torchvision.models as models
import torch.nn as nn
import torch
import pandas as pd
import torch
import numpy as np
import pandas as pd
from tqdm import tqdm
import os
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, fbeta_score
from sklearn.metrics import precision_score, recall_score, f1_score, fbeta_score
import numpy as np
imagenet_mean = np.array([0.485, 0.456, 0.406])
imagenet_std = np.array([0.229, 0.224, 0.225])
def show_image(image, title=''):
# image is [H, W, 3]
assert image.shape[2] == 3
plt.imshow(torch.clip((image * imagenet_std + imagenet_mean) * 255, 0, 255).int())
plt.title(title, fontsize=16)
plt.axis('off')
return
def prepare_model(chkpt_dir, arch='mae_vit_large_patch16'):
# build model
model = getattr(models_mae, arch)()
# load model
checkpoint = torch.load(chkpt_dir, map_location='cpu')
msg = model.load_state_dict(checkpoint['model'], strict=False)
print(msg)
return model
def plot_multiclass_roc_curve(all_labels, all_predictions, EXPERIMENT_NAME="."):
# Step 1: Label Binarization
label_binarizer = LabelBinarizer()
y_onehot = label_binarizer.fit_transform(all_labels)
all_predictions_hot = label_binarizer.transform(all_predictions)
# Step 2: Calculate ROC curves
fpr = dict()
tpr = dict()
roc_auc = dict()
unique_classes = range(y_onehot.shape[1])
for i in unique_classes:
fpr[i], tpr[i], _ = roc_curve(y_onehot[:, i], all_predictions_hot[:, i])
roc_auc[i] = auc(fpr[i], tpr[i])
# Step 3: Plot ROC curves
fig, ax = plt.subplots(figsize=(8, 8))
# Micro-average ROC curve
fpr_micro, tpr_micro, _ = roc_curve(y_onehot.ravel(), all_predictions_hot.ravel())
roc_auc_micro = auc(fpr_micro, tpr_micro)
plt.plot(
fpr_micro,
tpr_micro,
label=f"micro-average ROC curve (AUC = {roc_auc_micro:.2f})",
color="deeppink",
linestyle=":",
linewidth=4,
)
# Macro-average ROC curve
all_fpr = np.unique(np.concatenate([fpr[i] for i in unique_classes]))
mean_tpr = np.zeros_like(all_fpr)
for i in unique_classes:
mean_tpr += np.interp(all_fpr, fpr[i], tpr[i])
mean_tpr /= len(unique_classes)
fpr_macro = all_fpr
tpr_macro = mean_tpr
roc_auc_macro = auc(fpr_macro, tpr_macro)
plt.plot(
fpr_macro,
tpr_macro,
label=f"macro-average ROC curve (AUC = {roc_auc_macro:.2f})",
color="navy",
linestyle=":",
linewidth=4,
)
# Individual class ROC curves with unique colors
colors = plt.cm.rainbow(np.linspace(0, 1, len(unique_classes)))
for class_id, color in zip(unique_classes, colors):
plt.plot(
fpr[class_id],
tpr[class_id],
color=color,
label=f"ROC curve for Class {class_id} (AUC = {roc_auc[class_id]:.2f})",
linewidth=2,
)
plt.plot([0, 1], [0, 1], color='gray', linestyle='--', linewidth=2) # Add diagonal line for reference
plt.axis("equal")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("Extension of Receiver Operating Characteristic\n to One-vs-Rest multiclass")
plt.legend()
plt.savefig(f'{EXPERIMENT_NAME}/roc_curve.png')
plt.show()
# Set the seed for PyTorch
torch.manual_seed(42)
parser = argparse.ArgumentParser('MAE fine-tuning for image classification', add_help=False)
parser.add_argument('--batch_size', default=64, type=int,
help='Batch size per GPU (effective batch size is batch_size * accum_iter * # gpus')
parser.add_argument('--epochs', default=50, type=int)
parser.add_argument('--accum_iter', default=4, type=int,
help='Accumulate gradient iterations (for increasing the effective batch size under memory constraints)')
# Model parameters
parser.add_argument('--model', default='mobilenet_v3', type=str, metavar='MODEL',
help='Name of model to train')
parser.add_argument('--input_size', default=224, type=int,
help='images input size')
parser.add_argument('--drop_path', type=float, default=0.1, metavar='PCT',
help='Drop path rate (default: 0.1)')
# Optimizer parameters
parser.add_argument('--clip_grad', type=float, default=None, metavar='NORM',
help='Clip gradient norm (default: None, no clipping)')
parser.add_argument('--weight_decay', type=float, default=0.05,
help='weight decay (default: 0.05)')
parser.add_argument('--lr', type=float, default=None, metavar='LR',
help='learning rate (absolute lr)')
parser.add_argument('--blr', type=float, default=5e-4, metavar='LR',
help='base learning rate: absolute_lr = base_lr * total_batch_size / 256')
parser.add_argument('--layer_decay', type=float, default=0.65,
help='layer-wise lr decay from ELECTRA/BEiT')
parser.add_argument('--min_lr', type=float, default=1e-6, metavar='LR',
help='lower lr bound for cyclic schedulers that hit 0')
parser.add_argument('--warmup_epochs', type=int, default=5, metavar='N',
help='epochs to warmup LR')
# Augmentation parameters
parser.add_argument('--color_jitter', type=float, default=None, metavar='PCT',
help='Color jitter factor (enabled only when not using Auto/RandAug)')
parser.add_argument('--aa', type=str, default='rand-m9-mstd0.5-inc1', metavar='NAME',
help='Use AutoAugment policy. "v0" or "original". " + "(default: rand-m9-mstd0.5-inc1)'),
parser.add_argument('--smoothing', type=float, default=0.1,
help='Label smoothing (default: 0.1)')
# * Random Erase params
parser.add_argument('--reprob', type=float, default=0.25, metavar='PCT',
help='Random erase prob (default: 0.25)')
parser.add_argument('--remode', type=str, default='pixel',
help='Random erase mode (default: "pixel")')
parser.add_argument('--recount', type=int, default=1,
help='Random erase count (default: 1)')
parser.add_argument('--resplit', action='store_true', default=False,
help='Do not random erase first (clean) augmentation split')
# * Mixup params
parser.add_argument('--mixup', type=float, default=0.8,
help='mixup alpha, mixup enabled if > 0.')
parser.add_argument('--cutmix', type=float, default=1.0,
help='cutmix alpha, cutmix enabled if > 0.')
parser.add_argument('--cutmix_minmax', type=float, nargs='+', default=None,
help='cutmix min/max ratio, overrides alpha and enables cutmix if set (default: None)')
parser.add_argument('--mixup_prob', type=float, default=1.0,
help='Probability of performing mixup or cutmix when either/both is enabled')
parser.add_argument('--mixup_switch_prob', type=float, default=0.5,
help='Probability of switching to cutmix when both mixup and cutmix enabled')
parser.add_argument('--mixup_mode', type=str, default='batch',
help='How to apply mixup/cutmix params. Per "batch", "pair", or "elem"')
# * Finetuning params
parser.add_argument('--finetune', default='mae_pretrain_vit_base.pth',
help='finetune from checkpoint')
parser.add_argument('--global_pool', action='store_true')
parser.set_defaults(global_pool=True)
parser.add_argument('--cls_token', action='store_false', dest='global_pool',
help='Use class token instead of global pool for classification')
# Dataset parameters
parser.add_argument('--data_path', default='/media/enc/vera1/sebastian/data/ABGQI_mel_spectrograms', type=str,
help='dataset path')
parser.add_argument('--nb_classes', default=5, type=int,
help='number of the classification types')
parser.add_argument('--output_dir', default='quinn_5_classes',
help='path where to save, empty for no saving')
parser.add_argument('--log_dir', default='/media/enc/vera1/sebastian/codes/classifiers/mae/MobileNet/output_dir',
help='path where to tensorboard log')
parser.add_argument('--device', default='cuda',
help='device to use for training / testing')
parser.add_argument('--seed', default=0, type=int)
parser.add_argument('--resume', default="/media/enc/vera1/sebastian/codes/classifiers/mae/MobileNet/quinn_5_classes/checkpoint-49.pth",
help='resume from checkpoint')
parser.add_argument('--start_epoch', default=0, type=int, metavar='N',
help='start epoch')
parser.add_argument('--eval',default=True, action='store_true',
help='Perform evaluation only')
parser.add_argument('--dist_eval', action='store_true', default=False,
help='Enabling distributed evaluation (recommended during training for faster monitor')
parser.add_argument('--num_workers', default=10, type=int)
parser.add_argument('--pin_mem', action='store_true',
help='Pin CPU memory in DataLoader for more efficient (sometimes) transfer to GPU.')
parser.add_argument('--no_pin_mem', action='store_false', dest='pin_mem')
parser.set_defaults(pin_mem=True)
# distributed training parameters
parser.add_argument('--world_size', default=1, type=int,
help='number of distributed processes')
parser.add_argument('--local_rank', default=-1, type=int)
parser.add_argument('--dist_on_itp', action='store_true')
parser.add_argument('--dist_url', default='env://',
help='url used to set up distributed training')
args, unknown = parser.parse_known_args()
misc.init_distributed_mode(args)
print("{}".format(args).replace(', ', ',\n'))
os.makedirs(args.output_dir, exist_ok=True)
device = torch.device(args.device)
misc.init_distributed_mode(args)
print("{}".format(args).replace(', ', ',\n'))
device = torch.device(args.device)
seed = args.seed + misc.get_rank()
torch.manual_seed(seed)
np.random.seed(seed)
cudnn.benchmark = True
dataset_train = build_dataset(is_train=True, args=args)
dataset_val = build_dataset(is_train=False, args=args)
if True: # args.distributed:
num_tasks = misc.get_world_size()
global_rank = misc.get_rank()
sampler_train = torch.utils.data.DistributedSampler(
dataset_train, num_replicas=num_tasks, rank=global_rank, shuffle=True
)
print("Sampler_train = %s" % str(sampler_train))
if args.dist_eval:
if len(dataset_val) % num_tasks != 0:
print('Warning: Enabling distributed evaluation with an eval dataset not divisible by process number. '
'This will slightly alter validation results as extra duplicate entries are added to achieve '
'equal num of samples per-process.')
sampler_val = torch.utils.data.DistributedSampler(
dataset_val, num_replicas=num_tasks, rank=global_rank, shuffle=True) # shuffle=True to reduce monitor bias
else:
sampler_val = torch.utils.data.SequentialSampler(dataset_val)
else:
sampler_train = torch.utils.data.RandomSampler(dataset_train)
sampler_val = torch.utils.data.SequentialSampler(dataset_val)
if global_rank == 0 and args.log_dir is not None and not args.eval:
os.makedirs(args.log_dir, exist_ok=True)
log_writer = SummaryWriter(log_dir=args.log_dir)
else:
log_writer = None
data_loader_train = torch.utils.data.DataLoader(
dataset_train, sampler=sampler_train,
batch_size=args.batch_size,
num_workers=args.num_workers,
pin_memory=args.pin_mem,
drop_last=True,
)
data_loader_val = torch.utils.data.DataLoader(
dataset_val, sampler=sampler_val,
batch_size=args.batch_size,
num_workers=args.num_workers,
pin_memory=args.pin_mem,
drop_last=False
)
def count_parameters(model, message=""):
trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
total_params = sum(p.numel() for p in model.parameters())
print(f"{message} Trainable params: {trainable_params} of {total_params}")
def extract_embeddings(model, data_loader, save_path, device, preprocess=None):
embeddings_list = []
targets_list = []
total_batches = len(data_loader)
with torch.no_grad(), tqdm(total=total_batches) as pbar:
model.eval() # Set the model to evaluation mode
for images, targets in data_loader:
if preprocess:
print("required processing")
images = preprocess(images).squeeze()
images = images.to(device)
# print("image shape is: ", images.shape)
embeddings = model(images)
embeddings_list.append(embeddings.cpu().detach().numpy()) # Move to CPU and convert to NumPy
targets_list.append(targets.numpy()) # Convert targets to NumPy
pbar.update(1)
# Concatenate embeddings and targets from all batches
embeddings = np.concatenate(embeddings_list).squeeze()
targets = np.concatenate(targets_list)
num_embeddings = embeddings.shape[1]
column_names = [f"feat_{i}" for i in range(num_embeddings)]
column_names.append("label")
embeddings_with_targets = np.hstack((embeddings, np.expand_dims(targets, axis=1)))
# Create a DataFrame with column names
df = pd.DataFrame(embeddings_with_targets, columns=column_names)
df.to_csv(save_path, index=False)
model_names = sorted(name for name in models.__dict__
if name.islower()
and not name.startswith("__") and not name.startswith('get_') and not name.startswith('list_')
and callable(models.__dict__[name]))
model_names
# Load the model
if model_name in MODEL_CONSTRUCTORS:
model_constructor = MODEL_CONSTRUCTORS[model_name]
if model_name == "vit_h_14":
from torchvision.io import read_image
from torchvision.models import vit_h_14, ViT_H_14_Weights
# Step 1: Initialize model with the best available weights
weights = ViT_H_14_Weights.IMAGENET1K_SWAG_E2E_V1.DEFAULT
model = vit_h_14(weights=weights)
model = torch.nn.Sequential(*(list(model.children())[:-1]))
# Step 2: Initialize the inference transforms
preprocess = weights.transforms()
if model_name =="regnet_y_128gf":
from torchvision.io import read_image
from torchvision.models import regnet_y_128gf, RegNet_Y_128GF_Weights
# Step 1: Initialize model with the best available weights
weights = RegNet_Y_128GF_Weights.IMAGENET1K_SWAG_E2E_V1
model = regnet_y_128gf(weights=weights)
model = torch.nn.Sequential(*(list(model.children())[:-1]))
# Step 2: Initialize the inference transforms
preprocess = weights.transforms()
if model_name =="mobilenet_v3_large":
from torchvision.io import read_image
from torchvision.models import mobilenet_v3_large, MobileNet_V3_Large_Weights
# Step 1: Initialize model with the best available weights
weights = MobileNet_V3_Large_Weights.IMAGENET1K_V2
model = mobilenet_v3_large(weights=weights)
model = torch.nn.Sequential(*(list(model.children())[:-1]))
# Step 2: Initialize the inference transforms
preprocess = weights.transforms()
else:
model = model_constructor(pretrained=True, progress=True)
model.classifier[1].in_features = model.classifier[1].in_features
model.classifier[1] = nn.Linear(model.classifier[1].in_features, out_features=feat_space)
preprocess=None
else:
raise ValueError("Invalid model type specified.")
model
model.eval()
model.to(device)
# Extract embeddings for training data
extract_embeddings(model, data_loader_train, f'{train_path}/train_embeddings.csv', device, preprocess)
# Extract embeddings for validation data
extract_embeddings(model, data_loader_val, f'{val_path}/val_embeddings.csv', device, preprocess)
|
https://github.com/jdanielescanez/quantum-solver
|
jdanielescanez
|
#!/usr/bin/env python3
# Author: Daniel Escanez-Exposito
from abc import ABC, abstractmethod
from qiskit import QuantumCircuit
from qiskit.circuit.library import YGate, ZGate
from qiskit.circuit.gate import Gate
import qiskit.quantum_info as qi
from numpy.random import randint
import numpy as np
from math import ceil
## An abstract class of a participant entity in the Six-State implementation
## @see https://qiskit.org/textbook/ch-algorithms/quantum-key-distribution.html
class Participant(ABC):
## Constructor
@abstractmethod
def __init__(self, name='', original_bits_size=0):
## The name of the participant
self.name = name
## The original size of the message
self.original_bits_size = original_bits_size
## The values of the participant
self.values = None
## The axes of the participant
self.axes = None
## The key of the participant
self.key = None
## If the key is determined safe
self.is_safe_key = False
## The otp of the participant
self.otp = None
## The gate measuring z and y axes
self.set_hy()
## Values setter
def set_values(self, values=None):
if values == None:
self.values = list(randint(2, size=self.original_bits_size))
else:
self.values = values
## Axes setter
def set_axes(self, axes=None):
if axes == None:
self.axes = list(randint(3, size=self.original_bits_size))
else:
self.axes = axes
## Print values
def show_values(self):
print('\n' + self.name, 'Values:')
print(self.values)
## Print axes
def show_axes(self):
print('\n' + self.name, 'Axes:')
print(self.axes)
## Print key
def show_key(self):
print('\n' + self.name, 'Key:')
print(self.key)
## Print otp
def show_otp(self):
print('\n' + self.name, 'OTP:')
print(self.otp)
## Remove the values of the qubits that were measured on the wrong axis
def remove_garbage(self, another_axes):
self.key = []
for i in range(self.original_bits_size):
if self.axes[i] == another_axes[i]:
self.key.append(self.values[i])
## Check if the shared key is equal to the current key
def check_key(self, shared_key):
return shared_key == self.key[:len(shared_key)]
## Use the rest of the key and validate it
def confirm_key(self, shared_size):
self.key = self.key[shared_size:]
self.is_safe_key = True
## Generate an One-Time Pad
def generate_otp(self, n_bits):
self.otp = []
for i in range(ceil(len(self.key) / n_bits)):
bits_string = ''.join(map(str, self.key[i * n_bits: (i + 1) * n_bits]))
self.otp.append(int(bits_string, 2))
## Performs an XOR operation between the message and the One-Time Pad
def xor_otp_message(self, message):
final_message = ''
CHR_LIMIT = 1114112
if len(self.otp) > 0:
for i, char in enumerate(message):
final_message += chr((ord(char) ^ self.otp[i % len(self.otp)]) % CHR_LIMIT)
return final_message
## New gate setter
def set_hy(self):
hy_op = qi.Operator(1/np.sqrt(2)*(YGate().to_matrix() + ZGate().to_matrix()))
hy_gate = QuantumCircuit(1)
hy_gate.unitary(hy_op, [0], label='h_y')
self.hy = hy_gate.to_gate()
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
#!/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/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
# Build a quantum circuit
circuit = QuantumCircuit(3, 3)
circuit.x(1)
circuit.h(range(3))
circuit.cx(0, 1)
circuit.measure(range(3), range(3));
print(circuit)
circuit.draw()
# Matplotlib Drawing
circuit.draw(output='mpl')
# Draw a new circuit with barriers and more registers
q_a = QuantumRegister(3, name='qa')
q_b = QuantumRegister(5, name='qb')
c_a = ClassicalRegister(3)
c_b = ClassicalRegister(5)
circuit = QuantumCircuit(q_a, q_b, c_a, c_b)
circuit.x(q_a[1])
circuit.x(q_b[1])
circuit.x(q_b[2])
circuit.x(q_b[4])
circuit.barrier()
circuit.h(q_a)
circuit.barrier(q_a)
circuit.h(q_b)
circuit.cswap(q_b[0], q_b[1], q_b[2])
circuit.cswap(q_b[2], q_b[3], q_b[4])
circuit.cswap(q_b[3], q_b[4], q_b[0])
circuit.barrier(q_b)
circuit.measure(q_a, c_a)
circuit.measure(q_b, c_b);
# Draw the circuit
circuit.draw(output='mpl')
# Draw the circuit with reversed bit order
circuit.draw(output='mpl', reverse_bits=True)
# Draw the circuit without barriers
circuit.draw(output='mpl', plot_barriers=False)
# Draw the circuit without barriers and reverse bit order
circuit.draw(output='mpl', plot_barriers=False, reverse_bits=True)
# Set line length to 80 for above circuit
circuit.draw(output='text')
# Change the background color in mpl
style = {'backgroundcolor': 'lightgreen'}
circuit.draw(output='mpl', style=style)
# Scale the mpl output to 1/2 the normal size
circuit.draw(output='mpl', scale=0.5)
from qiskit.tools.visualization import circuit_drawer
circuit_drawer(circuit, output='mpl', plot_barriers=False)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/community.qiskit.org
|
qiskit-community
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram
import numpy as np
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
error = {}
for n in range(1,11):
# Create a blank circuit
qc = QuantumCircuit(qr,cr)
# Implement an approximate Hadamard
theta = np.pi/np.sqrt(2) # here we correctly choose theta=pi/sqrt(2)
for j in range(n):
qc.rx(theta/n,qr[0])
qc.rz(theta/n,qr[0])
# We need to measure how good the above approximation is. Here's a simple way to do this.
# Step 1: Use a real hadamard to cancel the above approximation.
# For a good approximatuon, the qubit will return to state 0. For a bad one, it will end up as some superposition.
qc.h(qr[0])
# Step 2: Run the circuit, and see how many times we get the outcome 1.
# Since it should return 0 with certainty, the fraction of 1s is a measure of the error.
qc.measure(qr,cr)
shots = 20000
job = execute(qc, Aer.get_backend('qasm_simulator'),shots=shots)
try:
error[n] = (job.result().get_counts()['1']/shots)
except:
pass
plot_histogram(error)
# The linear nature of error^(-1/2) shows that the error has a quadratic decay.
inverse_square_of_error = {}
for n in error:
inverse_square_of_error[n] = (error[n])**(-1/2)
plot_histogram(inverse_square_of_error)
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
error = {}
for n in range(1,11):
# Create a blank circuit
qc = QuantumCircuit(qr,cr)
# Implement an approximate Hadamard
theta = np.pi/np.sqrt(2) # here we correctly use theta=pi/sqrt(2)
for j in range(n):
qc.rz(theta/(2*n),qr[0])
qc.rx(theta/n,qr[0])
qc.rz(theta/(2*n),qr[0])
# We need to measure how good the above approximation is. Here's a simple way to do this.
# Step 1: Use a real hadamard to cancel the above approximation.
# For a good approximatuon, the qubit will return to state 0. For a bad one, it will end up as some superposition.
qc.h(qr[0])
# Step 2: Run the circuit, and see how many times we get the outcome 1.
# Since it should return 0 with certainty, the fraction of 1s is a measure of the error.
qc.measure(qr,cr)
shots = 100000
job = execute(qc, Aer.get_backend('qasm_simulator'),shots=shots)
try:
error[n] = (job.result().get_counts()['1']/shots)
except:
pass
plot_histogram(error)
# The linear nature of error^(-1/3) shows that the error has a cubic decay.
# Note: this needs loads of shots to get a good result.
inverse_cube_of_error = {}
for n in error:
error[n]
inverse_cube_of_error[n] = (error[n])**(-1/3)
plot_histogram(inverse_cube_of_error)
|
https://github.com/zeynepCankara/Introduction-Quantum-Programming
|
zeynepCankara
|
u = [-2,-1,0,1]
v = [1,2,3]
uv = []
vu = []
for i in range(len(u)): # one element of u is picked
for j in range(len(v)): # now we iteratively select every element of v
uv.append(u[i]*v[j]) # this one element of u is iteratively multiplied with every element of v
print("u-tensor-v is",uv)
for i in range(len(v)): # one element of v is picked
for j in range(len(u)): # now we iteratively select every element of u
vu.append(v[i]*u[j]) # this one element of v is iteratively multiplied with every element of u
print("v-tensor-u is",vu)
A = [
[-1,0,1],
[-2,-1,2]
]
B = [
[0,2],
[3,-1],
[-1,1]
]
print("A =")
for i in range(len(A)):
print(A[i])
print() # print a line
print("B =")
for i in range(len(B)):
print(B[i])
# let's define A-tensor-B as a (6x6)-dimensional zero matrix
AB = []
for i in range(6):
AB.append([])
for j in range(6):
AB[i].append(0)
# let's find A-tensor-B
for i in range(2):
for j in range(3):
# for each A(i,j) we execute the following codes
a = A[i][j]
# we access each element of B
for m in range(3):
for n in range(2):
b = B[m][n]
# now we put (a*b) in the appropriate index of AB
AB[3*i+m][2*j+n] = a * b
print() # print a line
print("A-tensor-B =")
print() # print a line
for i in range(6):
print(AB[i])
A = [
[-1,0,1],
[-2,-1,2]
]
B = [
[0,2],
[3,-1],
[-1,1]
]
print() # print a line
print("B =")
for i in range(len(B)):
print(B[i])
print("A =")
for i in range(len(A)):
print(A[i])
# let's define B-tensor-A as a (6x6)-dimensional zero matrix
BA = []
for i in range(6):
BA.append([])
for j in range(6):
BA[i].append(0)
# let's find B-tensor-A
for i in range(3):
for j in range(2):
# for each B(i,j) we execute the following codes
b = B[i][j]
# we access each element of A
for m in range(2):
for n in range(3):
a = A[m][n]
# now we put (a*b) in the appropriate index of AB
BA[2*i+m][3*j+n] = b * a
print() # print a line
print("B-tensor-A =")
print() # print a line
for i in range(6):
print(BA[i])
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import time
import numpy as np
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.aqua.algorithms import QAOA
from qiskit.aqua.components.optimizers import COBYLA
from qiskit.optimization.algorithms import MinimumEigenOptimizer, CplexOptimizer
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from random_lp.lp_random_gen import create_models
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/" # 23.04.2021
Q_SEED = 10598 # as used in most issues
aqua_globals.random_seed = Q_SEED
shots = 4096
# select linear program to solve
qps = create_models(DIR)
qp = qps['test_dense_3']
# init classical Optimizers
optimizer = COBYLA() # SLSQP is default in Class VQE
cplex = CplexOptimizer()
# solve qps with Minimum Eigen Optimizer QAOA
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend,
seed_simulator=Q_SEED,
seed_transpiler=Q_SEED,
shots=shots)
qaoa_mes = QAOA(quantum_instance=quantum_instance, optimizer=optimizer)
qaoa = MinimumEigenOptimizer(qaoa_mes)
cplex.solve(qp)
print("number of qubits: ",qp.get_num_vars())
res = qaoa.solve(qp)
res
|
https://github.com/hkhetawat/QArithmetic
|
hkhetawat
|
# Import the Qiskit SDK
from numpy.lib.function_base import copy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, Aer
from qiskit.providers.aer import QasmSimulator
from QArithmetic import full_qr, power
from copy import copy
from qiskit.tools.visualization import circuit_drawer
# Input N
N = 2
X = 2 # qc will take exponentially longer to compile with each increase
a = QuantumRegister(N)
b = QuantumRegister(X)
m = QuantumRegister(N*(pow(2,X)-1))
ca = ClassicalRegister(N)
cm = ClassicalRegister(N*(pow(2,X)-1))
qc = QuantumCircuit(a, b, m, cm, ca)
# Input
# a = 11 = 3
qc.x(a[0])
qc.x(a[1])
# b= 11 = 3
qc.x(b[0])
qc.x(b[1])
power(qc, a, b, m)
qc.measure(m, cm)
qc.measure(a, ca)
backend_sim = Aer.get_backend('qasm_simulator')
print("started job")
job_sim = execute(qc, backend_sim, shots=1)
result_sim = job_sim.result()
print(result_sim.get_counts(qc))
|
https://github.com/Z-928/Bugs4Q
|
Z-928
|
# https://github.com/Qiskit/qiskit-terra/issues/5839
from qiskit import QuantumCircuit,QuantumRegister, Aer, execute
from qiskit.compiler import transpile
from qiskit.quantum_info.states.measures import state_fidelity
from IPython.core.display import display
# Create circuit
circ = QuantumCircuit(3)
circ.x(0)
circ.cnot(0,1)
circ.snapshot('snap1', snapshot_type='statevector')
circ.snapshot('snap1', snapshot_type='density_matrix')
circ.cnot(0,2)
circ.snapshot('snap2', snapshot_type='statevector')
circ.snapshot('snap2', snapshot_type='density_matrix')
circ.cnot(1,2)
circ.snapshot('snap3', snapshot_type='statevector')
circ.snapshot('snap3', snapshot_type='density_matrix')
circ.measure_all()
transpiled_circ = transpile(circ, coupling_map=[[0,1],[1,0],[1,2],[2,1]],optimization_level=2)
display(circ.draw())
display(transpiled_circ.draw())
results = execute(circ,Aer.get_backend('qasm_simulator')).result()
statevector1 = results.data()['snapshots']['statevector']['snap1'][0]
statevector2 = results.data()['snapshots']['statevector']['snap2'][0]
statevector3 = results.data()['snapshots']['statevector']['snap2'][0]
density_matrix1 = results.data()['snapshots']['density_matrix']['snap1'][0]['value']
density_matrix2 = results.data()['snapshots']['density_matrix']['snap2'][0]['value']
density_matrix3 = results.data()['snapshots']['density_matrix']['snap3'][0]['value']
results = execute(transpiled_circ,Aer.get_backend('qasm_simulator')).result()
statevector_transpiled1 = results.data()['snapshots']['statevector']['snap1'][0]
statevector_transpiled2 = results.data()['snapshots']['statevector']['snap2'][0]
statevector_transpiled3 = results.data()['snapshots']['statevector']['snap3'][0]
density_matrix_transpiled1 = results.data()['snapshots']['density_matrix']['snap1'][0]['value']
density_matrix_transpiled2 = results.data()['snapshots']['density_matrix']['snap2'][0]['value']
density_matrix_transpiled3 = results.data()['snapshots']['density_matrix']['snap3'][0]['value']
print('Fidelity between transpiled and normal statevector snapshots')
print('snap 1',state_fidelity(statevector_transpiled1,statevector1))
print('snap 2',state_fidelity(statevector_transpiled2,statevector2))
print('snap 3',state_fidelity(statevector_transpiled3,statevector3))
print('\nFidelity between transpiled and normal density matrix snapshots')
print('snap 1',state_fidelity(density_matrix_transpiled1,density_matrix1))
print('snap 2',state_fidelity(density_matrix_transpiled2,density_matrix2))
print('snap 3',state_fidelity(density_matrix_transpiled3,density_matrix3))
print('Counts normal: ',results.get_counts(circ))
print('Counts transpiled: ',results.get_counts(transpiled_circ))
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
import numpy as np
import matplotlib as plt
%matplotlib inline
input_param=[1, 0.5, -0.765, 0.1, 0, -0.654]
exp_output=[0, 0, 0, 0, -0.4553474723, 0]
from qiskit.circuit import QuantumCircuit, ParameterVector
n = 3
qc = QuantumCircuit(n)
param_list = ParameterVector('Parameter', 2*n)
for i in range(len(param_list)//n):
qc.rx(param_list[3*i], 0)
qc.ry(param_list[3*i+1], 1)
qc.rz(param_list[3*i+2], 2)
qc.cnot(0, 1)
qc.cnot(1, 2)
qc.cnot(2, 0)
qc.draw(output='mpl')
from qiskit.opflow import I, X, Y, Z
hamiltonian = Z ^ I ^ Y
from qiskit.opflow import StateFn, AerPauliExpectation
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(qc)
pauli_basis = AerPauliExpectation().convert(expectation)
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.opflow import CircuitSampler
quantum_instance = QuantumInstance(Aer.get_backend('qasm_simulator'),
# we'll set a seed for reproducibility
shots = 32768, seed_simulator = 2718,
seed_transpiler = 2718)
sampler = CircuitSampler(quantum_instance)
def evaluate_expectation(params):
value_dict = dict(zip(qc.parameters, params))
result = sampler.convert(pauli_basis, params=value_dict).eval()
return np.real(result)
def calc_gradient(params):
gradient = np.zeros_like(params)
for i in range(len(params)):
shifted = params.copy()
shifted[i] += np.pi/2
forward = evaluate_expectation(shifted)
shifted[i] -= np.pi
backward = evaluate_expectation(shifted)
gradient[i] = 0.5 * (forward - backward)
return np.round(gradient, 10)
calc_gradient(input_param)
from qiskit.opflow import Gradient
def calc_gradient_with_framework(params):
state_grad = Gradient(grad_method="param_shift").convert(operator=expectation)
value_dict = dict(zip(qc.parameters, params))
result = state_grad.assign_parameters(value_dict).eval()
return np.round(np.array(result).real, 10)
calc_gradient_with_framework(input_param)
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/adlrocha/cryptoq
|
adlrocha
|
#8ec67edd7b4c8e358b08222c23234d995de520b29686a14582cf2d797ac399124c799747364b30c8b86f34b5facbcc8d72734d652645bfad82ea6a4f4a46b7b1
from qiskit import IBMQ
IBMQ.load_accounts()
|
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))
ghz.draw(output='mpl')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
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, L_BFGS_B
from qiskit.circuit import Parameter
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit.utils import algorithm_globals
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier, VQC
from qiskit_machine_learning.algorithms.regressors import NeuralNetworkRegressor, VQR
from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN
algorithm_globals.random_seed = 42
num_inputs = 2
num_samples = 20
X = 2 * algorithm_globals.random.random([num_samples, num_inputs]) - 1
y01 = 1 * (np.sum(X, axis=1) >= 0) # in { 0, 1}
y = 2 * y01 - 1 # in {-1, +1}
y_one_hot = np.zeros((num_samples, 2))
for i in range(num_samples):
y_one_hot[i, y01[i]] = 1
for x, y_target in zip(X, y):
if y_target == 1:
plt.plot(x[0], x[1], "bo")
else:
plt.plot(x[0], x[1], "go")
plt.plot([-1, 1], [1, -1], "--", color="black")
plt.show()
# construct QNN
qc = QuantumCircuit(2)
feature_map = ZZFeatureMap(2)
ansatz = RealAmplitudes(2)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)
qc.draw(output="mpl")
estimator_qnn = EstimatorQNN(
circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
)
# QNN maps inputs to [-1, +1]
estimator_qnn.forward(X[0, :], algorithm_globals.random.random(estimator_qnn.num_weights))
# callback function that draws a live plot when the .fit() method is called
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()
# construct neural network classifier
estimator_classifier = NeuralNetworkClassifier(
estimator_qnn, optimizer=COBYLA(maxiter=60), callback=callback_graph
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
estimator_classifier.fit(X, y)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
estimator_classifier.score(X, y)
# evaluate data points
y_predict = estimator_classifier.predict(X)
# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y, y_predict):
if y_target == 1:
plt.plot(x[0], x[1], "bo")
else:
plt.plot(x[0], x[1], "go")
if y_target != y_p:
plt.scatter(x[0], x[1], s=200, facecolors="none", edgecolors="r", linewidths=2)
plt.plot([-1, 1], [1, -1], "--", color="black")
plt.show()
estimator_classifier.weights
# construct feature map
feature_map = ZZFeatureMap(num_inputs)
# construct ansatz
ansatz = RealAmplitudes(num_inputs, reps=1)
# construct quantum circuit
qc = QuantumCircuit(num_inputs)
qc.append(feature_map, range(num_inputs))
qc.append(ansatz, range(num_inputs))
qc.decompose().draw(output="mpl")
# parity maps bitstrings to 0 or 1
def parity(x):
return "{:b}".format(x).count("1") % 2
output_shape = 2 # corresponds to the number of classes, possible outcomes of the (parity) mapping.
# construct QNN
sampler_qnn = SamplerQNN(
circuit=qc,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=output_shape,
)
# construct classifier
sampler_classifier = NeuralNetworkClassifier(
neural_network=sampler_qnn, optimizer=COBYLA(maxiter=30), callback=callback_graph
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
sampler_classifier.fit(X, y01)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
sampler_classifier.score(X, y01)
# evaluate data points
y_predict = sampler_classifier.predict(X)
# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y01, y_predict):
if y_target == 1:
plt.plot(x[0], x[1], "bo")
else:
plt.plot(x[0], x[1], "go")
if y_target != y_p:
plt.scatter(x[0], x[1], s=200, facecolors="none", edgecolors="r", linewidths=2)
plt.plot([-1, 1], [1, -1], "--", color="black")
plt.show()
sampler_classifier.weights
# construct feature map, ansatz, and optimizer
feature_map = ZZFeatureMap(num_inputs)
ansatz = RealAmplitudes(num_inputs, reps=1)
# construct variational quantum classifier
vqc = VQC(
feature_map=feature_map,
ansatz=ansatz,
loss="cross_entropy",
optimizer=COBYLA(maxiter=30),
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
vqc.fit(X, y_one_hot)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
vqc.score(X, y_one_hot)
# evaluate data points
y_predict = vqc.predict(X)
# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y_one_hot, y_predict):
if y_target[0] == 1:
plt.plot(x[0], x[1], "bo")
else:
plt.plot(x[0], x[1], "go")
if not np.all(y_target == y_p):
plt.scatter(x[0], x[1], s=200, facecolors="none", edgecolors="r", linewidths=2)
plt.plot([-1, 1], [1, -1], "--", color="black")
plt.show()
from sklearn.datasets import make_classification
from sklearn.preprocessing import MinMaxScaler
X, y = make_classification(
n_samples=10,
n_features=2,
n_classes=3,
n_redundant=0,
n_clusters_per_class=1,
class_sep=2.0,
random_state=algorithm_globals.random_seed,
)
X = MinMaxScaler().fit_transform(X)
plt.scatter(X[:, 0], X[:, 1], c=y)
y_cat = np.empty(y.shape, dtype=str)
y_cat[y == 0] = "A"
y_cat[y == 1] = "B"
y_cat[y == 2] = "C"
print(y_cat)
vqc = VQC(
num_qubits=2,
optimizer=COBYLA(maxiter=30),
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
vqc.fit(X, y_cat)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
vqc.score(X, y_cat)
predict = vqc.predict(X)
print(f"Predicted labels: {predict}")
print(f"Ground truth: {y_cat}")
num_samples = 20
eps = 0.2
lb, ub = -np.pi, np.pi
X_ = np.linspace(lb, ub, num=50).reshape(50, 1)
f = lambda x: np.sin(x)
X = (ub - lb) * algorithm_globals.random.random([num_samples, 1]) + lb
y = f(X[:, 0]) + eps * (2 * algorithm_globals.random.random(num_samples) - 1)
plt.plot(X_, f(X_), "r--")
plt.plot(X, y, "bo")
plt.show()
# construct simple feature map
param_x = Parameter("x")
feature_map = QuantumCircuit(1, name="fm")
feature_map.ry(param_x, 0)
# construct simple ansatz
param_y = Parameter("y")
ansatz = QuantumCircuit(1, name="vf")
ansatz.ry(param_y, 0)
# construct a circuit
qc = QuantumCircuit(1)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)
# construct QNN
regression_estimator_qnn = EstimatorQNN(
circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
)
# construct the regressor from the neural network
regressor = NeuralNetworkRegressor(
neural_network=regression_estimator_qnn,
loss="squared_error",
optimizer=L_BFGS_B(maxiter=5),
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit to data
regressor.fit(X, y)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score the result
regressor.score(X, y)
# plot target function
plt.plot(X_, f(X_), "r--")
# plot data
plt.plot(X, y, "bo")
# plot fitted line
y_ = regressor.predict(X_)
plt.plot(X_, y_, "g-")
plt.show()
regressor.weights
vqr = VQR(
feature_map=feature_map,
ansatz=ansatz,
optimizer=L_BFGS_B(maxiter=5),
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit regressor
vqr.fit(X, y)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score result
vqr.score(X, y)
# plot target function
plt.plot(X_, f(X_), "r--")
# plot data
plt.plot(X, y, "bo")
# plot fitted line
y_ = vqr.predict(X_)
plt.plot(X_, y_, "g-")
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# -*- coding: utf-8 -*-
# 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.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
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.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')
|
https://github.com/indian-institute-of-science-qc/qiskit-aakash
|
indian-institute-of-science-qc
|
# -*- coding: utf-8 -*-
# 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.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# -*- 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.
"""
This module contains the definition of a base class for quantum fourier transforms.
"""
from abc import abstractmethod
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.aqua import Pluggable, AquaError
class QFT(Pluggable):
"""Base class for QFT.
This method should initialize the module and its configuration, and
use an exception if a component of the module is
available.
Args:
configuration (dict): configuration dictionary
"""
@abstractmethod
def __init__(self, *args, **kwargs):
super().__init__()
@classmethod
def init_params(cls, params):
qft_params = params.get(Pluggable.SECTION_KEY_QFT)
kwargs = {k: v for k, v in qft_params.items() if k != 'name'}
return cls(**kwargs)
@abstractmethod
def _build_matrix(self):
raise NotImplementedError
@abstractmethod
def _build_circuit(self, qubits=None, circuit=None, do_swaps=True):
raise NotImplementedError
def construct_circuit(self, mode='circuit', qubits=None, circuit=None, do_swaps=True):
"""Construct the circuit.
Args:
mode (str): 'matrix' or 'circuit'
qubits (QuantumRegister or qubits): register or qubits to build the circuit on.
circuit (QuantumCircuit): circuit for construction.
do_swaps (bool): include the swaps.
Returns:
The matrix or circuit depending on the specified mode.
"""
if mode == 'circuit':
return self._build_circuit(qubits=qubits, circuit=circuit, do_swaps=do_swaps)
elif mode == 'matrix':
return self._build_matrix()
else:
raise AquaError('Unrecognized mode: {}.'.format(mode))
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
from qiskit import QuantumCircuit
from QiskitPBT.property import Property
from QiskitPBT.input_generators import Integer
import random
class FrequencyProperty(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
# The assumption of our code is that we need at least one input generator, if we do not include it,
# the code breaks in the test runner - also its a fine assumption to include, property based testing requires inputs
return [Integer(0, 255), Integer(0, 3)]
# specify the preconditions for the test
def preconditions(self, state, padding):
return True
# specify the operations to be performed on the input
def operations(self, state, padding):
padding = 2
binary = bin(state)[2:]
binary = '0' * padding + binary
qc = QuantumCircuit(len(binary), len(binary))
binary_to_mark(qc, binary)
print(qc)
self.statistical_analysis.assert_most_frequent(self, list(range(qc.num_qubits)), qc, [binary], basis=["z"])
class UncertainFrequencyProperty(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
# The assumption of our code is that we need at least one input generator, if we do not include it,
# the code breaks in the test runner - also its a fine assumption to include, property based testing requires inputs
return [Integer(0, 255), Integer(0, 3)]
# specify the preconditions for the test
def preconditions(self, state, padding):
return True
# specify the operations to be performed on the input
def operations(self, state, padding):
padding = 2
binary = bin(state)[2:]
binary = '0' * padding + binary
qc = QuantumCircuit(len(binary), len(binary))
binary_to_mark(qc, binary)
# insert a random hadamard at a random position
index = random.randint(0, len(binary) - 1)
qc.h(index)
# list with two possible outcomes after hadamard
states = [binary[:index] + "0" + binary[index + 1:], binary[:index] + "1" + binary[index + 1:]]
self.statistical_analysis.assert_most_frequent(self, list(range(qc.num_qubits)), qc, states, basis=["z"])
def binary_to_mark(qc: QuantumCircuit, binary_string: str):
"""
Construct a circuit to mark a binary string.
"""
for idx, bit in enumerate(binary_string):
if bit == "1":
qc.x(qc.qubits[idx])
|
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.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')
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019, 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.
"""Measurement error mitigation"""
import copy
from typing import List, Optional, Tuple, Dict, Callable
from qiskit import compiler
from qiskit.providers import Backend
from qiskit.circuit import QuantumCircuit
from qiskit.qobj import QasmQobj
from qiskit.assembler.run_config import RunConfig
from qiskit.exceptions import QiskitError
from qiskit.utils.mitigation import (
complete_meas_cal,
tensored_meas_cal,
CompleteMeasFitter,
TensoredMeasFitter,
)
from qiskit.utils.deprecation import deprecate_func
@deprecate_func(
since="0.24.0",
additional_msg="For code migration guidelines, visit https://qisk.it/qi_migration.",
)
def get_measured_qubits(
transpiled_circuits: List[QuantumCircuit],
) -> Tuple[List[int], Dict[str, List[int]]]:
"""
Deprecated: Retrieve the measured qubits from transpiled circuits.
Args:
transpiled_circuits: a list of transpiled circuits
Returns:
The used and sorted qubit index
Key is qubit index str connected by '_',
value is the experiment index. {str: list[int]}
Raises:
QiskitError: invalid qubit mapping
"""
qubit_index = None
qubit_mappings = {}
for idx, qc in enumerate(transpiled_circuits):
measured_qubits = []
for instruction in qc.data:
if instruction.operation.name != "measure":
continue
for qreg in qc.qregs:
if instruction.qubits[0] in qreg:
index = qreg[:].index(instruction.qubits[0])
measured_qubits.append(index)
break
measured_qubits_str = "_".join([str(x) for x in measured_qubits])
if measured_qubits_str not in qubit_mappings:
qubit_mappings[measured_qubits_str] = []
qubit_mappings[measured_qubits_str].append(idx)
if qubit_index is None:
qubit_index = measured_qubits
elif set(qubit_index) != set(measured_qubits):
raise QiskitError(
"The used qubit index are different. ({}) vs ({}).\nCurrently, "
"we only support all circuits using the same set of qubits "
"regardless qubit order.".format(qubit_index, measured_qubits)
)
return sorted(qubit_index), qubit_mappings
@deprecate_func(
since="0.24.0",
additional_msg="For code migration guidelines, visit https://qisk.it/qi_migration.",
)
def get_measured_qubits_from_qobj(qobj: QasmQobj) -> Tuple[List[int], Dict[str, List[int]]]:
"""
Deprecated: Retrieve the measured qubits from transpiled circuits.
Args:
qobj: qobj
Returns:
the used and sorted qubit index
key is qubit index str connected by '_',
value is the experiment index. {str: list[int]}
Raises:
QiskitError: invalid qubit mapping
"""
qubit_index = None
qubit_mappings = {}
for idx, exp in enumerate(qobj.experiments):
measured_qubits = []
for instr in exp.instructions:
if instr.name != "measure":
continue
measured_qubits.append(instr.qubits[0])
measured_qubits_str = "_".join([str(x) for x in measured_qubits])
if measured_qubits_str not in qubit_mappings:
qubit_mappings[measured_qubits_str] = []
qubit_mappings[measured_qubits_str].append(idx)
if qubit_index is None:
qubit_index = measured_qubits
else:
if set(qubit_index) != set(measured_qubits):
raise QiskitError(
"The used qubit index are different. ({}) vs ({}).\nCurrently, "
"we only support all circuits using the same set of qubits "
"regardless qubit order.".format(qubit_index, measured_qubits)
)
return sorted(qubit_index), qubit_mappings
@deprecate_func(
since="0.24.0",
additional_msg="For code migration guidelines, visit https://qisk.it/qi_migration.",
)
def build_measurement_error_mitigation_circuits(
qubit_list: List[int],
fitter_cls: Callable,
backend: Backend,
backend_config: Optional[Dict] = None,
compile_config: Optional[Dict] = None,
mit_pattern: Optional[List[List[int]]] = None,
) -> Tuple[QuantumCircuit, List[str], List[str]]:
"""Deprecated: Build measurement error mitigation circuits
Args:
qubit_list: list of ordered qubits used in the algorithm
fitter_cls: CompleteMeasFitter or TensoredMeasFitter
backend: backend instance
backend_config: configuration for backend
compile_config: configuration for compilation
mit_pattern: Qubits on which to perform the
measurement correction, divided to groups according to tensors.
If `None` and `qr` is given then assumed to be performed over the entire
`qr` as one group (default `None`).
Returns:
the circuit
the state labels for build MeasFitter
the labels of the calibration circuits
Raises:
QiskitError: when the fitter_cls is not recognizable.
"""
circlabel = "mcal"
if not qubit_list:
raise QiskitError("The measured qubit list can not be [].")
run = False
if fitter_cls == CompleteMeasFitter:
meas_calibs_circuits, state_labels = complete_meas_cal(
qubit_list=range(len(qubit_list)), circlabel=circlabel
)
run = True
elif fitter_cls == TensoredMeasFitter:
meas_calibs_circuits, state_labels = tensored_meas_cal(
mit_pattern=mit_pattern, circlabel=circlabel
)
run = True
if not run:
try:
from qiskit.ignis.mitigation.measurement import (
CompleteMeasFitter as CompleteMeasFitter_IG,
TensoredMeasFitter as TensoredMeasFitter_IG,
)
except ImportError as ex:
# If ignis can't be imported we don't have a valid fitter
# class so just fail here with an appropriate error message
raise QiskitError(f"Unknown fitter {fitter_cls}") from ex
if fitter_cls == CompleteMeasFitter_IG:
meas_calibs_circuits, state_labels = complete_meas_cal(
qubit_list=range(len(qubit_list)), circlabel=circlabel
)
elif fitter_cls == TensoredMeasFitter_IG:
meas_calibs_circuits, state_labels = tensored_meas_cal(
mit_pattern=mit_pattern, circlabel=circlabel
)
else:
raise QiskitError(f"Unknown fitter {fitter_cls}")
# the provided `qubit_list` would be used as the initial layout to
# assure the consistent qubit mapping used in the main circuits.
tmp_compile_config = copy.deepcopy(compile_config)
tmp_compile_config["initial_layout"] = qubit_list
t_meas_calibs_circuits = compiler.transpile(
meas_calibs_circuits, backend, **backend_config, **tmp_compile_config
)
return t_meas_calibs_circuits, state_labels, circlabel
@deprecate_func(
since="0.24.0",
additional_msg="For code migration guidelines, visit https://qisk.it/qi_migration.",
)
def build_measurement_error_mitigation_qobj(
qubit_list: List[int],
fitter_cls: Callable,
backend: Backend,
backend_config: Optional[Dict] = None,
compile_config: Optional[Dict] = None,
run_config: Optional[RunConfig] = None,
mit_pattern: Optional[List[List[int]]] = None,
) -> Tuple[QasmQobj, List[str], List[str]]:
"""
Args:
qubit_list: list of ordered qubits used in the algorithm
fitter_cls: CompleteMeasFitter or TensoredMeasFitter
backend: backend instance
backend_config: configuration for backend
compile_config: configuration for compilation
run_config: configuration for running a circuit
mit_pattern: Qubits on which to perform the
measurement correction, divided to groups according to tensors.
If `None` and `qr` is given then assumed to be performed over the entire
`qr` as one group (default `None`).
Returns:
the Qobj with calibration circuits at the beginning
the state labels for build MeasFitter
the labels of the calibration circuits
Raises:
QiskitError: when the fitter_cls is not recognizable.
MissingOptionalLibraryError: Qiskit-Ignis not installed
"""
circlabel = "mcal"
if not qubit_list:
raise QiskitError("The measured qubit list can not be [].")
if fitter_cls == CompleteMeasFitter:
meas_calibs_circuits, state_labels = complete_meas_cal(
qubit_list=range(len(qubit_list)), circlabel=circlabel
)
elif fitter_cls == TensoredMeasFitter:
meas_calibs_circuits, state_labels = tensored_meas_cal(
mit_pattern=mit_pattern, circlabel=circlabel
)
else:
raise QiskitError(f"Unknown fitter {fitter_cls}")
# the provided `qubit_list` would be used as the initial layout to
# assure the consistent qubit mapping used in the main circuits.
tmp_compile_config = copy.deepcopy(compile_config)
tmp_compile_config["initial_layout"] = qubit_list
t_meas_calibs_circuits = compiler.transpile(
meas_calibs_circuits, backend, **backend_config, **tmp_compile_config
)
cals_qobj = compiler.assemble(t_meas_calibs_circuits, backend, **run_config.to_dict())
if hasattr(cals_qobj.config, "parameterizations"):
del cals_qobj.config.parameterizations
return cals_qobj, state_labels, circlabel
|
https://github.com/acfilok96/Quantum-Computation
|
acfilok96
|
import qiskit
print(qiskit.__version__)
from qiskit_machine_learning.datasets import ad_hoc_data
adhoc_dimension = 2
train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(training_size = 20, test_size = 5,
n = adhoc_dimension, gap=0.3,
plot_data =False, one_hot=False,
include_sample_total=True)
import numpy
print(numpy.array(adhoc_total).shape)
print("train data shape: ", train_features.shape,"\ttrain labels shape: ", train_labels.shape)
print("test data shape: ", test_features.shape,"\ttest labels shape: ", test_labels.shape)
print('train data:\n',train_features[:5])
print('\ntrain label:\n',train_labels[:5])
# plot_adhoc_dataset(train_features, train_labels, test_features, test_labels, adhoc_total)
from qiskit import Aer
from qiskit.utils import QuantumInstance
seed=20
quantum_instance = QuantumInstance(Aer.get_backend("qasm_simulator"), shots=1024,
seed_simulator=seed, seed_transpiler=seed)
from qiskit.circuit.library import ZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
z_feature_map = ZFeatureMap(feature_dimension=adhoc_dimension, reps=2)
z_kernel = QuantumKernel(feature_map = z_feature_map, quantum_instance=quantum_instance)
# z_feature_map.draw(output='mpl', scale=2)
z_feature_map.decompose().draw(output='mpl', scale=2)
from sklearn.svm import SVC
svc = SVC(kernel=z_kernel.evaluate)
svc.fit(train_features, train_labels)
score = svc.score(test_features, test_labels)
print('Callable kernel with ZFeatureMap classification test score: ', score)
prediction = svc.predict(test_features)
print(prediction)
from qiskit.circuit.library import ZZFeatureMap
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
from sklearn.svm import SVC
svc = SVC(kernel=zz_kernel.evaluate)
svc.fit(train_features, train_labels)
score = svc.score(test_features, test_labels)
print('Callable kernel with ZZFeatureMap classification test score: ', score)
prediction = svc.predict(test_features)
print(prediction)
from qiskit_machine_learning.algorithms import QSVC
qsvc = QSVC()
qsvc.quantum_kernel.quantum_instance = quantum_instance
qsvc.fit(train_features, train_labels)
score = qsvc.score(test_features, test_labels)
print('QSVC classification test score: ', score)
prediction = qsvc.predict(test_features)
print(prediction)
from qiskit.circuit.library import ZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
# here feature_dimension = 2 and reps = 1
adhoc_dimension = 2
z_feature_map = ZFeatureMap(feature_dimension=adhoc_dimension, reps=1)
z_kernel = QuantumKernel(feature_map = z_feature_map, quantum_instance=quantum_instance)
z_feature_map.decompose().draw(output='mpl', scale=2)
from qiskit.circuit.library import ZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
# here feature_dimension = 2 and reps = 2
adhoc_dimension = 2
z_feature_map = ZFeatureMap(feature_dimension=adhoc_dimension, reps=2)
z_kernel = QuantumKernel(feature_map = z_feature_map, quantum_instance=quantum_instance)
z_feature_map.decompose().draw(output='mpl', scale=2)
from qiskit.circuit.library import ZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
# here feature_dimension = 3 and reps = 4
adhoc_dimension = 3
z_feature_map = ZFeatureMap(feature_dimension=adhoc_dimension, reps=4)
z_kernel = QuantumKernel(feature_map = z_feature_map, quantum_instance=quantum_instance)
z_feature_map.decompose().draw(output='mpl', scale=2)
# same happens for ZZFeatureMap
from qiskit.circuit.library import ZZFeatureMap
adhoc_dimension=2
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=1, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
# same happens for ZZFeatureMap
from qiskit.circuit.library import ZZFeatureMap
adhoc_dimension=2
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
# same happens for ZZFeatureMap
from qiskit.circuit.library import ZZFeatureMap
adhoc_dimension=3
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=1, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
# same happens for ZZFeatureMap
from qiskit.circuit.library import ZZFeatureMap
adhoc_dimension=3
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# You can set a color for all the bars.
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_paulivec
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
state = Statevector(qc)
plot_state_paulivec(state, color='midnightblue', title="New PauliVec plot")
|
https://github.com/GIRISHBELANI/QC_Benchmarks_using_dm-simulator
|
GIRISHBELANI
|
import math
number = 3
int(math.ceil(math.log(number, 2)))
import math
import sys
import time
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
sys.path[1:1] = ["_common", "_common/qsim", "shors/_common", "quantum-fourier-transform/qsim"]
sys.path[1:1] = ["../../_common", "../../_common/qsim", "../../shors/_common", "../../quantum-fourier-transform/qsim"]
from qiskit import *
from shors_utils import getAngles, getAngle, modinv, generate_base
n=2
num_qubits = 2*n + 3
qr_counting = QuantumRegister(1)
qr_mult = QuantumRegister(n) # Register for multiplications
qr_aux = QuantumRegister(n+2) # Register for addition and multiplication
cr_data = ClassicalRegister(2*n) # Register for measured values of QFT
cr_aux = ClassicalRegister(1)
print(qr_counting)
print(qr_mult,qr_aux,cr_data,cr_aux)
qc = QuantumCircuit(qr_counting, qr_mult, qr_aux, cr_data, cr_aux, name="main")
print(qc)
qc.x(qr_mult[0])
print(qc)
num_gates = 0
depth = 0
############### QFT Circuit
def qft_gate(input_size):
global QFT_, num_gates, depth
qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="qft")
# Generate multiple groups of diminishing angle CRZs and H gate
for i_qubit in range(0, input_size):
# start laying out gates from highest order qubit (the hidx)
hidx = input_size - i_qubit - 1
# if not the highest order qubit, add multiple controlled RZs of decreasing angle
if hidx < input_size - 1:
num_crzs = i_qubit
for j in range(0, num_crzs):
divisor = 2 ** (num_crzs - j)
qc.crz( math.pi / divisor , qr[hidx], qr[input_size - j - 1])
num_gates += 1
depth += 1
# followed by an H gate (applied to all qubits)
qc.h(qr[hidx])
num_gates += 1
depth += 1
qc.barrier()
if QFT_ == None or input_size <= 5:
if input_size < 9: QFT_ = qc
return qc
############### Inverse QFT Circuit
def inv_qft_gate(input_size):
global QFTI_, num_gates, depth
qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="inv_qft")
# Generate multiple groups of diminishing angle CRZs and H gate
for i_qubit in reversed(range(0, input_size)):
# start laying out gates from highest order qubit (the hidx)
hidx = input_size - i_qubit - 1
# precede with an H gate (applied to all qubits)
qc.h(qr[hidx])
num_gates += 1
depth += 1
# if not the highest order qubit, add multiple controlled RZs of decreasing angle
if hidx < input_size - 1:
num_crzs = i_qubit
for j in reversed(range(0, num_crzs)):
divisor = 2 ** (num_crzs - j)
qc.crz( -math.pi / divisor , qr[hidx], qr[input_size - j - 1])
num_gates += 1
depth += 1
qc.barrier()
if QFTI_ == None or input_size <= 5:
if input_size < 9: QFTI_= qc
return qc
base=2
QC_ = None
PHIADD_ = None
CCPHIADDMODN_ = None
CMULTAMODN_ = None
CUA_ = None
QFT_ = None
QFTI_ = None
def phiADD(num_qubits, a):
qc = QuantumCircuit(num_qubits, name = "\u03C6ADD")
angle = getAngles(a, num_qubits)
for i in range(0, num_qubits):
# addition
qc.p(angle[i], i)
global PHIADD_
if PHIADD_ == None or num_qubits <= 3:
if num_qubits < 4: PHIADD_ = qc
return qc
#Single controlled version of the phiADD circuit
def cphiADD(num_qubits, a):
phiadd_gate = phiADD(num_qubits,a).to_gate()
cphiadd_gate = phiadd_gate.control(1)
return cphiadd_gate
#Doubly controlled version of the phiADD circuit
def ccphiADD(num_qubits, a):
phiadd_gate = phiADD(num_qubits,a).to_gate()
ccphiadd_gate = phiadd_gate.control(2)
return ccphiadd_gate
# Circuit that implements doubly controlled modular addition by a (num qubits should be bit count for number N)
def ccphiADDmodN(num_qubits, a, N):
qr_ctl = QuantumRegister(2)
qr_main = QuantumRegister(num_qubits+1)
qr_ancilla = QuantumRegister(1)
qc = QuantumCircuit(qr_ctl, qr_main,qr_ancilla, name = "cc\u03C6ADDmodN")
# Generate relevant gates for circuit
ccphiadda_gate = ccphiADD(num_qubits+1, a)
ccphiadda_inv_gate = ccphiADD(num_qubits+1, a).inverse()
phiaddN_inv_gate = phiADD(num_qubits+1, N).inverse(); phiaddN_inv_gate.name = "inv_\u03C6ADD"
cphiaddN_gate = cphiADD(num_qubits+1, N)
# Create relevant temporary qubit lists
ctl_main_qubits = [i for i in qr_ctl]; ctl_main_qubits.extend([i for i in qr_main])
anc_main_qubits = [qr_ancilla[0]]; anc_main_qubits.extend([i for i in qr_main])
#Create circuit
qc.append(ccphiadda_gate, ctl_main_qubits)
qc.append(phiaddN_inv_gate, qr_main)
qc.append(inv_qft_gate(num_qubits+1), qr_main)
qc.cx(qr_main[-1], qr_ancilla[0])
qc.append(qft_gate(num_qubits+1), qr_main)
qc.append(cphiaddN_gate, anc_main_qubits)
qc.append(ccphiadda_inv_gate, ctl_main_qubits)
qc.append(inv_qft_gate(num_qubits+1), qr_main)
qc.x(qr_main[-1])
qc.cx(qr_main[-1], qr_ancilla[0])
qc.x(qr_main[-1])
qc.append(qft_gate(num_qubits+1), qr_main)
qc.append(ccphiadda_gate, ctl_main_qubits)
global CCPHIADDMODN_
if CCPHIADDMODN_ == None or num_qubits <= 2:
if num_qubits < 3: CCPHIADDMODN_ = qc
return qc
def ccphiADDmodN_inv(num_qubits, a, N):
cchpiAddmodN_circ = ccphiADDmodN(num_qubits, a, N)
cchpiAddmodN_inv_circ = cchpiAddmodN_circ.inverse()
cchpiAddmodN_inv_circ.name = "inv_cchpiAddmodN"
return cchpiAddmodN_inv_circ
# Creates circuit that implements single controlled modular multiplication by a. n represents the number of bits
# needed to represent the integer number N
def cMULTamodN(n, a, N):
qr_ctl = QuantumRegister(1)
qr_x = QuantumRegister(n)
qr_main = QuantumRegister(n+1)
qr_ancilla = QuantumRegister(1)
qc = QuantumCircuit(qr_ctl, qr_x, qr_main,qr_ancilla, name = "cMULTamodN")
# quantum Fourier transform only on auxillary qubits
qc.append(qft_gate(n+1), qr_main)
for i in range(n):
ccphiADDmodN_gate = ccphiADDmodN(n, (2**i)*a % N, N)
# Create relevant temporary qubit list
qubits = [qr_ctl[0]]; qubits.extend([qr_x[i]])
qubits.extend([i for i in qr_main]); qubits.extend([qr_ancilla[0]])
qc.append(ccphiADDmodN_gate, qubits)
# inverse quantum Fourier transform only on auxillary qubits
qc.append(inv_qft_gate(n+1), qr_main)
global CMULTAMODN_
if CMULTAMODN_ == None or n <= 2:
if n < 3: CMULTAMODN_ = qc
return qc
def controlled_Ua(n,a,exponent,N):
qr_ctl = QuantumRegister(1)
qr_x = QuantumRegister(n)
qr_main = QuantumRegister(n)
qr_ancilla = QuantumRegister(2)
qc = QuantumCircuit(qr_ctl, qr_x, qr_main,qr_ancilla, name = f"C-U^{a**exponent}")
# Generate Gates
a_inv = modinv(a**exponent,N)
cMULTamodN_gate = cMULTamodN(n, a**exponent, N)
cMULTamodN_inv_gate = cMULTamodN(n, a_inv, N).inverse(); cMULTamodN_inv_gate.name = "inv_cMULTamodN"
# Create relevant temporary qubit list
qubits = [i for i in qr_ctl]; qubits.extend([i for i in qr_x]); qubits.extend([i for i in qr_main])
qubits.extend([i for i in qr_ancilla])
qc.append(cMULTamodN_gate, qubits)
for i in range(n):
qc.cswap(qr_ctl, qr_x[i], qr_main[i])
qc.append(cMULTamodN_inv_gate, qubits)
global CUA_
if CUA_ == None or n <= 2:
if n < 3: CUA_ = qc
return qc
# perform modular exponentiation 2*n times
for k in range(2*n):
qc.barrier()
# Reset the counting qubit to 0 if the previous measurement was 1
qc.x(qr_counting).c_if(cr_aux,1)
qc.h(qr_counting)
cUa_gate = controlled_Ua(n, base,2**(2*n-1-k), number)
# Create relevant temporary qubit list
qubits = [qr_counting[0]]; qubits.extend([i for i in qr_mult]);qubits.extend([i for i in qr_aux])
qc.append(cUa_gate, qubits)
# perform inverse QFT --> Rotations conditioned on previous outcomes
for i in range(2**k):
qc.p(getAngle(i, k), qr_counting[0]).c_if(cr_data, i)
qc.h(qr_counting)
qc.measure(qr_counting[0], cr_data[k])
qc.measure(qr_counting[0], cr_aux[0])
print(qc)
num_shots=100
backend = BasicAer.get_backend('dm_simulator')
options={}
job = execute(qc, backend, shots=num_shots, **options)
result = job.result()
print(result)
qc= qc.decompose()#.decompose().decompose().decompose()
print(qc)
num_shots=100
backend = BasicAer.get_backend('dm_simulator')
options={}
job = execute(qc, backend, shots=num_shots, **options)
result = job.result()
print(result)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit_sbf_2023
|
jonasmaziero
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(1,1)
qc.x(0)
qc.measure(0,0)
qc.draw('mpl')
from qiskit import Aer, execute
simulator = Aer.get_backend('qasm_simulator')
nshots = 2**13
job = execute(qc, backend=simulator,shots=nshots)
counts = job.result().get_counts()
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
from qiskit import QuantumCircuit
def qc_df(): # divisor de feixes 50:50
qc = QuantumCircuit(1, name='DF')
qc.s(0)
qc.h(0)
qc.s(0)
return qc
qcdf = qc_df(); qcdf.draw('mpl')
def qc_espelhos():
qc = QuantumCircuit(1, name='E')
qc.z(0)
qc.y(0)
return qc
qce = qc_espelhos(); qce.draw('mpl')
def qc_bomba():
qc = QuantumCircuit(2, name='B')
qc.cx(0,1)
return qc
qcb = qc_bomba(); qcb.draw('mpl')
def qc_detector_de_bomba():
qc = QuantumCircuit(2, name='DB')
qcdf = qc_df(); qc.append(qcdf,[0])
qce = qc_espelhos(); qc.append(qce,[0])
qcb = qc_bomba(); qc.append(qcb,[0,1])
qcdf = qc_df(); qc.append(qcdf,[0])
return qc
qcdb = qc_detector_de_bomba(); qcdb.draw('mpl')
qc = QuantumCircuit(2,2)
qcdb = qc_detector_de_bomba(); qc.append(qcdb,[0,1])
qc.measure([0,1],[0,1])
qc.draw('mpl')
# Simulação clássica
from qiskit import Aer, execute
simulator = Aer.get_backend('qasm_simulator')
nshots = 2**13
job = execute(qc, backend=simulator,shots=nshots)
counts = job.result().get_counts()
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
import qiskit
qiskit.IBMQ.save_account('18d1a392e10ffca595cb87ad064ca04fb8f407e702274610ba421f54ac39fbef8e14b664d350f3e48cc9762e4b63aad22ecb2135f16468825ae37b14a85c1762', overwrite = True)
qiskit.IBMQ.load_account()
#provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
provider = qiskit.IBMQ.get_provider(hub='ibm-q-research-2', group='federal-uni-sant-1', project='main')
device = provider.get_backend('ibm_nairobi')
nshots = 2**13
# Experimento (simulação quântica)
job = execute(qc, backend=device, shots=nshots)
print(job.job_id())
job = device.retrieve_job('cmpt4asb9x9g0088t2c0')
from qiskit.tools.visualization import plot_histogram
plot_histogram(job.result().get_counts())
|
https://github.com/anpaschool/QC-School-Fall2020
|
anpaschool
|
#!pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src
import numpy as np
from qiskit_textbook.tools import array_to_latex
Y=np.array([[0,complex(0,-1)],[complex(0,1),0]])
#print ('Y:',Y)
print (array_to_latex(Y,pretext="\\text{Y = } "))
Y_dag= Y.conj().transpose()
print (array_to_latex(Y_dag, pretext="\\text{Y_dag = } "))
A=np.dot(Y,Y_dag)
#print ('A:',A)
print (array_to_latex(A,pretext="\\text{A = } "))
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit import Aer
from qiskit.tools.visualization import circuit_drawer
# Calling a simulator to see what happened after applying the gate
backend_statevector = Aer.get_backend('statevector_simulator')
# create a quantum register and a classical register
q = QuantumRegister(1)
c = ClassicalRegister(1) #used to measure the result
circuit = QuantumCircuit(q, c) # Now we created a circuit
circuit.x(q[0]) # Applied a Pauli X-gate to q0
job = execute(circuit, backend_statevector)
print(array_to_latex(job.result().get_statevector(circuit),pretext="\\text{Psi after X-gate is applied = } "))
circuit.x(q[0]) # Apllied another Pauli X-gate to q
print(circuit.draw(style='mpl'))
job1 = execute(circuit, backend_statevector) # ran the job
#print("Psi after X-gate applied again:",job1.result().get_statevector(circuit))
print(array_to_latex(job1.result().get_statevector(circuit),pretext="\\text{Psi after X-gate is applied again = } "))
np.eye(4) # Creates an identity matrix of 4 X 4
def mixed_state(pure_state, visibility):
density_matrix = pure_state @ pure_state.T.conj()
maximally_mixed_state = np.eye(4)/2**2
return visibility*density_matrix + (1-visibility)*maximally_mixed_state
ϕ = np.array([[1],[0],[0],[1]])/np.sqrt(2)
#####################
print(array_to_latex(ϕ,pretext="\\text{ϕ = } "))
d_m= ϕ @ ϕ.T.conj()
print ('Density_matrix')
print (d_m)
###############################
print("Maximum visibility is a pure state:")
print(mixed_state(ϕ, 1.0))
#############################
print("The state is still entangled with visibility 0.8:")
print(mixed_state(ϕ, 0.8))
################################
print("Entanglement is lost by 0.6:")
print(mixed_state(ϕ, 0.6))
############################
print("Barely any coherence remains by 0.2:")
print(mixed_state(ϕ, 0.2))
import matplotlib.pyplot as plt
temperatures = [.5, 5, 200]
energies = np.linspace(0, 20, 100) # Creating uniform energy levels
fig, ax = plt.subplots()
for i, T in enumerate(temperatures):
probabilities = np.exp(-energies/T)
Z = probabilities.sum()
probabilities /= Z
ax.plot(energies, probabilities, linewidth=3, label = "$T_" + str(i+1)+"$="+str(T))
ax.set_xlim(0, 20)
ax.set_ylim(0, 1.2*probabilities.max())
#ax.set_xticks([])
#ax.set_yticks([])
ax.set_xlabel('Energy')
ax.set_ylabel('Probability')
ax.legend()
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise.errors import pauli_error, depolarizing_error
def get_noise(p_meas,p_gate):
error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])
error_gate1 = depolarizing_error(p_gate, 1)
error_gate2 = error_gate1.tensor(error_gate1)
noise_model = NoiseModel()
# measurement error is applied to measurements
noise_model.add_all_qubit_quantum_error(error_meas, "measure")
# single qubit gate error is applied to x gates
noise_model.add_all_qubit_quantum_error(error_gate1, ["x"])
# two qubit gate error is applied to cx gates
noise_model.add_all_qubit_quantum_error(error_gate2, ["cx"])
return noise_model
#Create noise_model with a probability of 1% for each type of error
noise_model=get_noise(0.01,0.01)
# initialize circuit with three qubits in the 0 state
qc0 = QuantumCircuit(3,3,name='0')
# measure the qubits
qc0.measure(qc0.qregs[0],qc0.cregs[0])
print(qc0.draw(style='mpl'))
# run the circuit with th noise model and extract the counts
counts_noise = execute( qc0, Aer.get_backend('qasm_simulator'),noise_model=noise_model).result().get_counts()
counts = execute( qc0, Aer.get_backend('qasm_simulator')).result().get_counts()
print(' No noise:',counts,'\n','Noise:',counts_noise)
n =1024 # number of shots
#Running same with '111' this time!
qc1 = QuantumCircuit(3, 3, name='0')
qc1.x(qc1.qregs[0]) # flip each 0 to 1
qc1.measure(qc1.qregs[0],qc1.cregs[0]) # measure the qubits
print(qc1.draw(style='mpl'))
# run the circuit with th noise model and extract the counts
counts_noise = execute( qc1, Aer.get_backend('qasm_simulator'),noise_model=noise_model,shots=n).result().get_counts()
counts = execute( qc1, Aer.get_backend('qasm_simulator'),shots=n).result().get_counts()
print(' No noise:',counts,'\n','Noise:',counts_noise)
#Increase measurement_noise probability
noise_model = get_noise(0.5,0.0)
counts = execute(qc1, Aer.get_backend('qasm_simulator'),noise_model=noise_model).result().get_counts()
print(counts)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import execute, pulse
d0 = pulse.DriveChannel(0)
with pulse.build() as pulse_prog:
pulse.play(pulse.Constant(100, 1.0), d0)
pulse_prog.draw()
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
import os
import shutil
import numpy as np
import pandas as pd
import random
import matplotlib.pyplot as plt
import seaborn as sns
from string import ascii_lowercase
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, transpile
from qiskit.quantum_info import Statevector
from qiskit.visualization import array_to_latex, plot_distribution, plot_histogram, plot_bloch_multivector
from qiskit_algorithms import AmplificationProblem, Grover
from qiskit.circuit.library import CPhaseGate
from qiskit.primitives import Sampler
from qiskit_aer import AerSimulator
from utils import get_image_path
def random_file_name(size=5):
return ''.join(random.sample(list(ascii_lowercase), size))
def create_test_folder(folder):
if(os.path.exists(folder)):
print("Path already exists")
print(f"Removing {folder}")
shutil.rmtree(folder, ignore_errors=True)
print(f"Creating: {folder}")
os.mkdir(folder)
def create_test_files(folder, n=5):
create_test_folder(folder)
for _ in range(n):
file = random_file_name()+".txt"
try:
print(f"creating file: {file}")
file_path = os.path.join(folder, file)
file = open(file_path, "a")
file.close()
except Exception as error:
print(f"Failed creating {file}")
test_folder = os.path.join('.', 'files-test')
create_test_files(test_folder)
files = os.listdir(test_folder)
files
selected_file = files[random.randint(0,len(files))]
selected_file
def classical_method_1(files, target):
#in this example, we are ignoring the extension
#just for this case, in real life a good idea is to use the entire name, or a hash of it
#unsing no type of lookup table, or sorting, the algorithm takes O(n)
total_tests = 0
for file in files:
total_tests += 1
print(f"total tests: {total_tests}")
if(file == target):
print("found file")
break
classical_method_1(files, selected_file)
def classical_method_2(files, target):
# this should be done after adding a file into the filesystem
# it takes O(1) for adding a new file, O(n) for adding n files and O(1) for searching
lut = {}
for file in files:
file_hash = hash(file)
lut[file_hash] = file
target_hash = hash(target)
if lut.get(target_hash):
print("File found")
else:
print("File doesnt exists in the filesystem")
classical_method_2(files, selected_file)
n_qubits = int(np.ceil(np.log2(len(files))))
def encoding_files_to_oracle(n_qubits, files):
oracle = QuantumCircuit(n_qubits, name="LUT")
encoded_bin = [bin(i)[2:].zfill(n_qubits)[::-1] for i in range(len(files))]
for encoded in encoded_bin:
x_positions = [i for i,char in enumerate(encoded) if char == '0']
oracle.x(x_positions)
oracle.mcp(np.pi, list(range(1,n_qubits)), 0)
oracle.x(x_positions)
return encoded_bin,oracle
binary,oracle = encoding_files_to_oracle(n_qubits,files)
oracle.draw('mpl', filename=get_image_path("look-up-table.png"))
def get_oracle_overload(files, targets):
oracle = QuantumCircuit(n_qubits, name="$LUT^{-1}$")
encode = lambda x,n: bin(x)[2:].zfill(n)[::-1]
encoded_bin = [encode(i,n_qubits) for i, file in enumerate(files) if file not in targets]
for encoded in encoded_bin:
x_positions = [i for i,char in enumerate(encoded) if char == '0']
oracle.x(x_positions)
oracle.mcp(np.pi, list(range(1,n_qubits)), 0)
oracle.x(x_positions)
return encoded_bin,oracle
lut_binary,oracle = encoding_files_to_oracle(n_qubits,files)
unvalid_states,oracle_inv = get_oracle_overload(files, [selected_file])
good_state = list(set(lut_binary) - set(unvalid_states))
n_qubits = len(oracle.qubits)
qc = QuantumCircuit(n_qubits)
qc.append(oracle, range(n_qubits))
qc.barrier(label="LUT")
qc.append(oracle_inv, range(n_qubits))
qc.draw('mpl', filename=get_image_path("sets-difference-look-up-table-oracle.png"))
qc.decompose().draw('mpl')
Statevector(qc).draw('latex')
qc_copy = qc.copy()
qc_copy.save_unitary()
sim = AerSimulator()
unitary = sim.run(transpile(qc_copy, sim)).result().get_unitary()
array_to_latex(unitary, max_size=10000)
problem = AmplificationProblem(qc, is_good_state=good_state)
problem.grover_operator.decompose().draw(output='mpl', filename=get_image_path("classical_grover_file_search.png"))
grover = Grover(sampler=Sampler())
result = grover.amplify(problem)
result.top_measurement
qc = QuantumCircuit(3)
qc.h(range(3))
qc.compose(problem.grover_operator.decompose(), range(3), inplace=True)
qc.draw('mpl', filename=get_image_path("file_explorer.png"))
sim = AerSimulator()
qc_copy = qc.copy()
qc_copy.measure_all()
aer_result = sim.run(transpile(qc_copy, sim), shots=1000).result().get_counts()
plot_histogram(aer_result, filename=get_image_path('AER_file_explorer_result.png'))
def create_new_grover(file):
n_qubits = int(np.ceil(np.log2(len(files))))
lut_binary, oracle = encoding_files_to_oracle(n_qubits,files)
unvalid_states,oracle_inv = get_oracle_overload(files, [file])
good_state = list(set(lut_binary) - set(unvalid_states))
print('good state: ', good_state)
t_qubits = len(oracle.qubits)
final_oracle = QuantumCircuit(t_qubits)
final_oracle.append(oracle, range(t_qubits))
final_oracle.barrier(label="LUT")
final_oracle.append(oracle_inv, range(t_qubits))
total_zeros = good_state[0].count('0')
"""
angles from the grover tests
000 1.013620
001 1.385071
010 1.479508
011 1.680972
100 1.397662
101 1.712451
110 1.699860
111 2.058719
"""
angles = {
"000":1.013620,
"001":1.385071,
"010":1.479508,
"011":1.680972,
"100":1.397662,
"101":1.712451,
"110":1.699860,
"111":2.058719
}
problem = AmplificationProblem(final_oracle, is_good_state=good_state)
qc = QuantumCircuit(t_qubits)
qc.ry(angles[good_state[0]], range(t_qubits))
qc.compose(problem.grover_operator.decompose(), range(t_qubits), inplace=True)
return qc
new_qc = create_new_grover(selected_file)
new_qc.draw('mpl', filename=get_image_path("improved_file_explorer.png"))
sim = AerSimulator()
qc_copy = new_qc.copy()
qc_copy.measure_all()
aer_result = sim.run(transpile(qc_copy, sim), shots=1000).result().get_counts()
hist = plot_histogram(aer_result)
plt.savefig(get_image_path("AER-file-explorer-hist-new-grover-mapped-rotations.png"))
display(hist)
x = np.array(list(range(0, 60)), dtype=np.int64)
classical_find = lambda x: x
classical_lut = lambda x: 1
quantum = lambda x: np.sqrt(x)
vec_cf = np.vectorize(classical_find)
vec_cl = np.vectorize(classical_lut)
vec_q = np.vectorize(quantum)
y_classical_f = vec_cf(x)
y_classical_l = vec_cl(x)
y_quantum = vec_q(x)
df = pd.DataFrame({"x":x, "cf":y_classical_f, "cl":y_classical_l, "q":y_quantum})
df.head()
plot = sns.lineplot(data=pd.melt(df, ["x"]), x="x", y="value", hue="variable", palette="flare")
legend = plot.axes.get_legend()
legend.set_title("O(x) comparation")
for old, new in zip(legend.texts, ["classical find = O(n)", "classical LUT = O(1)", "quantum = O(√N)"]):
old.set_text(new)
plt.savefig(get_image_path("algorithms-finding-comparation.png"))
plt.show(plot)
def get_result(qc, sim=AerSimulator()):
g_copy = qc.copy()
g_copy.measure_all()
sim = AerSimulator()
return sim.run(transpile(g_copy, sim), shots=1000).result().get_counts()
def new_g(superposition, oracle):
qc = QuantumCircuit(3)
qc.append(superposition, range(3))
qc.append(oracle, range(3))
qc.h(range(3))
qc.x(range(3))
qc.h(-1)
qc.ccx(0, 1,2)
qc.h(-1)
qc.x(range(3))
qc.h(range(3))
return qc
oracle = QuantumCircuit(3, name="oracle")
oracle.ccz(0, 1,2)
oracle.draw('mpl')
s = QuantumCircuit(3, name="s")
s.ry(np.pi/3, range(3))
display(s.draw('mpl'))
plot_bloch_multivector(s)
qc = new_g(s, oracle)
qc.draw('mpl')
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.x(range(3))
oracle.ccz(0, 1,2)
oracle.x(range(3))
oracle.draw('mpl')
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.x(range(3))
oracle.ccz(0, 1,2)
oracle.x(range(3))
oracle.ccz(0,1,2)
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
oracle.draw('mpl')
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
oracle.x(range(3))
oracle.ccz(0, 1,2)
oracle.x(range(3))
oracle.ccz(0,1,2)
oracle.draw('mpl')
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
oracle.draw('mpl')
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
sim = AerSimulator()
def find_best_angle(encoded_bit_string, oracle):
max_ = 0
best_angle = 0
for angle in np.linspace(0, np.pi, num=120):
s = QuantumCircuit(3)
s.ry(angle, range(3))
qc = new_g(s, oracle)
qc.measure_all()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
if(not result.get(encoded_bit_string)):
continue
result = result[encoded_bit_string]
if(result > max_):
max_ = result
best_angle = angle
print(angle, result)
return best_angle, max_
oracle = QuantumCircuit(3)
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
best_angle, max_ = find_best_angle('110', oracle)
best_angle, max_
np.degrees(best_angle)
np.pi/4
(np.pi*11)/20
np.pi - ((np.pi*10)/18) - (np.pi/4)
qc = QuantumCircuit(1)
qc.ry(best_angle, 0)
plot_bloch_multivector(qc)
s = QuantumCircuit(3, name="S")
s.ry(best_angle, range(3))
oracle = QuantumCircuit(3, name="oracle")
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
qc = new_g(s, oracle)
qc.draw('mpl')
plot_histogram(get_result(qc))
s = QuantumCircuit(3, name="S")
s.ry(best_angle, range(3))
oracle = QuantumCircuit(3, name="oracle")
oracle.ccz(0,1,2)
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
s = QuantumCircuit(3, name="S")
s.ry(best_angle, range(3))
oracle = QuantumCircuit(3, name="oracle")
#oracle.ccz(0,1,2)
oracle.x(range(3))
oracle.ccz(0,1,2)
oracle.x(range(3))
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.ccz(0,1,2)
oracle.x(range(3))
oracle.ccz(0,1,2)
oracle.x(range(3))
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
oracle.x(0)
oracle.x(1)
oracle.ccz(0,1,2)
oracle.x(0)
oracle.x(1)
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.ccz(0,1,2)
oracle.x(range(3))
oracle.ccz(0,1,2)
oracle.x(range(3))
oracle.draw('mpl')
problem = AmplificationProblem(oracle, is_good_state=['000', '111'])
problem.grover_operator.decompose().draw(output='mpl')
grover = Grover(sampler=Sampler())
result = grover.amplify(problem)
result.circuit_results, result.iterations
qc = QuantumCircuit(3)
qc.h(range(3))
qc.compose(problem.grover_operator.decompose(), inplace=True)
qc.draw('mpl')
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
problem = AmplificationProblem(oracle, is_good_state=['110'])
problem.grover_operator.decompose().draw(output='mpl')
grover = Grover(sampler=Sampler())
result = grover.amplify(problem)
result.circuit_results, result.iterations
def p_oracle(bit_string):
bit_string = bit_string[::-1]
zeros = [i for i, v in enumerate(bit_string) if v == '0']
qc = QuantumCircuit(3)
if(zeros):qc.x(zeros)
qc.ccz(0,1,2)
if(zeros):qc.x(zeros)
return qc
p_oracle('001').draw('mpl')
best_angle
def compare(best_angle):
for b in ['000', '001', '010', '011', '100', '101', '110', '111']:
oracle = p_oracle(b)
s = QuantumCircuit(3, name="S")
s.ry(best_angle, range(3))
new = new_g(s, oracle)
old_problem = AmplificationProblem(oracle, is_good_state=[b])
old = QuantumCircuit(3)
old.h(range(3))
old.compose(old_problem.grover_operator.decompose(), inplace=True)
new_r = get_result(new)
if(not new_r.get(b)):
new_r = 0
else:
new_r = new_r[b]
old_r = get_result(old)
if(not old_r.get(b)):
old_r = 0
else:
old_r = old_r[b]
print(b, ' - ', old_r,new_r)
compare(best_angle)
best_angle, _ = find_best_angle('000', p_oracle('000'))
best_angle
compare(best_angle)
qc = QuantumCircuit(1)
qc.ry(best_angle, 0)
plot_bloch_multivector(qc)
best_angle, _ = find_best_angle('010', p_oracle('010'))
best_angle
compare(best_angle)
qc = QuantumCircuit(1)
qc.ry(best_angle, 0)
plot_bloch_multivector(qc)
old = {}
new = {}
bit_strings = ['000', '001', '010', '011', '100', '101', '110', '111']
for b in bit_strings:
oracle = p_oracle(b)
best_angle, _ = find_best_angle(b, oracle)
s = QuantumCircuit(3, name="S")
s.ry(best_angle, range(3))
new_ = new_g(s, oracle)
old_problem = AmplificationProblem(oracle, is_good_state=[b])
old_ = QuantumCircuit(3)
old_.h(range(3))
old_.compose(old_problem.grover_operator.decompose(), inplace=True)
new_r = get_result(new_)
if(not new_r.get(b)):
new_r = 0
else:
new_r = new_r[b]
old_r = get_result(old_)
if(not old_r.get(b)):
old_r = 0
else:
old_r = old_r[b]
old[b] = old_r
new[b] = new_r
old, new
data = {"new": new, "old":old}
df = pd.DataFrame(data, columns=["new", "old"], index=bit_strings)
df
plt.plot(df.index.tolist(),df['new'], label="new")
plt.plot(df.index.tolist(),df['old'], label="old")
plt.title('old vs new Grover improvement (range [0, $\pi$])')
plt.xlabel("bit string")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.savefig(get_image_path("superposition-improvement-grover-algorithm.png"))
plt.show()
def find_best_angle_d_range(encoded_bit_string, oracle):
max_ = 0
best_angle = 0
for angle in np.linspace(0, 2*np.pi, num=240):
s = QuantumCircuit(3)
s.ry(angle, range(3))
qc = new_g(s, oracle)
qc.measure_all()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
if(not result.get(encoded_bit_string)):
continue
result = result[encoded_bit_string]
if(result > max_):
max_ = result
best_angle = angle
print(angle, result)
return best_angle, max_
old = {}
new = {}
bit_strings = ['000', '001', '010', '011', '100', '101', '110', '111']
for b in bit_strings:
oracle = p_oracle(b)
best_angle, _ = find_best_angle_d_range(b, oracle)
s = QuantumCircuit(3, name="S")
s.ry(best_angle, range(3))
new_ = new_g(s, oracle)
old_problem = AmplificationProblem(oracle, is_good_state=[b])
old_ = QuantumCircuit(3)
old_.h(range(3))
old_.compose(old_problem.grover_operator.decompose(), inplace=True)
new_r = get_result(new_)
if(not new_r.get(b)):
new_r = 0
else:
new_r = new_r[b]
old_r = get_result(old_)
if(not old_r.get(b)):
old_r = 0
else:
old_r = old_r[b]
old[b] = old_r
new[b] = new_r
data = {"new": new, "old":old}
df = pd.DataFrame(data, columns=["new", "old"], index=bit_strings)
df
plt.plot(df.index.tolist(),df['new'], label="new")
plt.plot(df.index.tolist(),df['old'], label="old")
plt.title('old vs new Grover improvement (range [0, $2\pi$])')
plt.xlabel("bit string")
plt.ylabel("counts")
plt.legend(loc="upper right")
#plt.savefig(get_image_path("superposition-improvement-grover-algorithm.png"))
plt.show()
s = QuantumCircuit(3)
s.ry(np.pi/3, 0)
s.ry(np.pi/5, 1)
s.ry(np.pi/9, 2)
s.draw('mpl')
plot_bloch_multivector(s)
oracle = p_oracle('000')
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
oracle = p_oracle('010')
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
CCP = CPhaseGate(-np.pi/8).control(1)
oracle = QuantumCircuit(3)
oracle.append(CCP, [0, 1, 2])
oracle.draw('mpl')
qc_copy = oracle.copy()
qc_copy.save_unitary()
sim = AerSimulator()
unitary = sim.run(transpile(qc_copy, sim)).result().get_unitary()
array_to_latex(unitary, max_size=10000)
s = QuantumCircuit(3)
s.ry(1.7423959255203896, range(3))
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
sim = AerSimulator()
def find_best_angle_rx(encoded_bit_string, oracle):
max_ = 0
best_angle = 0
for angle in np.linspace(0, np.pi, num=120):
s = QuantumCircuit(3)
s.rx(angle, range(3))
qc = new_g(s, oracle)
qc.measure_all()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
if(not result.get(encoded_bit_string)):
continue
result = result[encoded_bit_string]
if(result > max_):
max_ = result
best_angle = angle
#transpiled = transpile(qc, sim)
#display(transpiled.draw('mpl'))
#print(angle, result)
return best_angle, max_
def find_best_angle_rz(encoded_bit_string, oracle):
max_ = 0
best_angle = 0
for angle in np.linspace(0, np.pi, num=120):
s = QuantumCircuit(3)
s.rz(angle, range(3))
qc = new_g(s, oracle)
qc.measure_all()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
if(not result.get(encoded_bit_string)):
continue
result = result[encoded_bit_string]
if(result > max_):
max_ = result
best_angle = angle
#transpiled = transpile(qc, sim)
#display(transpiled.draw('mpl'))
#print(angle, result)
return best_angle, max_
def find_best_angle_ry(encoded_bit_string, oracle):
max_ = 0
best_angle = 0
for angle in np.linspace(0, np.pi, num=120):
s = QuantumCircuit(3)
s.ry(angle, range(3))
qc = new_g(s, oracle)
qc.measure_all()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
if(not result.get(encoded_bit_string)):
continue
result = result[encoded_bit_string]
if(result > max_):
max_ = result
best_angle = angle
#transpiled = transpile(qc, sim)
#display(transpiled.draw('mpl'))
#print(angle, result)
return best_angle, max_
rx = {}
rz = {}
ry = {}
bit_strings = ['000', '001', '010', '011', '100', '101', '110', '111']
for s in bit_strings:
oracle = p_oracle(s)
angle_rx, max_rx = find_best_angle_rx(s, oracle)
angle_rz, max_rz = find_best_angle_rz(s, oracle)
angle_ry, max_ry = find_best_angle_ry(s, oracle)
print(s, angle_rx, max_rx, angle_rz, max_rz, angle_ry, max_ry)
rx[s] = max_rx
rz[s] = max_rz
ry[s] = max_ry
data = {"ry": ry, "rx": rx, "rz": rz}
df = pd.DataFrame(data, columns=("ry", "rx", "rz"), index=bit_strings)
plt.plot(df.index.tolist(),df['ry'], label="ry")
plt.plot(df.index.tolist(),df['rx'], label="rx")
plt.plot(df.index.tolist(),df['rz'], label="rz")
plt.title('test rotations')
plt.xlabel("bit string")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.savefig(get_image_path("rotations-test-grover-algorithm.png"))
plt.show()
test = QuantumCircuit(1)
test.ry(3*np.pi/2, 0)
display(test.draw('mpl'))
plot_bloch_multivector(test)
def find_best_angle_2(encoded_bit_string, oracle, values_range, sim=AerSimulator()):
max_ = 0
best_angle = 0
for angle in values_range:
s = QuantumCircuit(3)
s.ry(angle, range(3))
qc = new_g(s, oracle)
qc.measure_all()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
if(not result.get(encoded_bit_string)):
continue
result = result[encoded_bit_string]
if(result > max_):
max_ = result
best_angle = angle
#print(angle, result)
return best_angle, max_
def new_compare(values_range, bit_strings=['000', '001', '010', '011', '100', '101', '110', '111']):
old = {}
new = {}
total_qubits = len(bit_strings[0])
for b in bit_strings:
oracle = p_oracle(b)
best_angle, _ = find_best_angle_2(b, oracle, values_range=values_range)
s = QuantumCircuit(total_qubits, name="S")
s.ry(best_angle, range(total_qubits))
new_ = QuantumCircuit(total_qubits)
new_.append(s, range(total_qubits))
new_.append(oracle, range(total_qubits))
new_.h(range(total_qubits))
new_.x(range(total_qubits))
new_.h(-1)
new_.mcmt(list(range(tota_qubits-1)),-1)
new_.h(-1)
new_.x(range(total_qubits))
new_.h(range(total_qubits))
old_problem = AmplificationProblem(oracle, is_good_state=[b])
old_ = QuantumCircuit(total_qubits)
old_.h(range(total_qubits))
old_.compose(old_problem.grover_operator.decompose(), inplace=True)
new_r = get_result(new_)
if(not new_r.get(b)):
new_r = 0
else:
new_r = new_r[b]
old_r = get_result(old_)
if(not old_r.get(b)):
old_r = 0
else:
old_r = old_r[b]
old[b] = old_r
new[b] = new_r
data = {"old": old, "new": new}
df = pd.DataFrame(data, columns=("old", "new"), index=bit_strings)
return df
df_0_to_pi = new_compare(np.linspace(0, np.pi, num=240))
df_0_to_pi
plt.plot(df_0_to_pi.index.tolist(),df_0_to_pi['old'], label="old")
plt.plot(df_0_to_pi.index.tolist(),df_0_to_pi['new'], label="new")
plt.xlabel("bit string")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.show()
df_0_to_2pi = new_compare(np.linspace(0, 2*np.pi, num=240))
df_0_to_2pi
plt.plot(df_0_to_2pi.index.tolist(),df_0_to_2pi['old'], label="old")
plt.plot(df_0_to_2pi.index.tolist(),df_0_to_2pi['new'], label="new")
plt.xlabel("bit string")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.show()
df_0_to_pi = new_compare(np.linspace(0, np.pi, num=240), bit_strings=['00', '01', '10', '11'])
df_0_to_pi
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile, schedule
from qiskit.visualization.timeline import draw
from qiskit.providers.fake_provider import FakeBoeblingen
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc = transpile(qc, FakeBoeblingen(), scheduling_method='alap', layout_method='trivial')
draw(qc)
|
https://github.com/zeynepCankara/Introduction-Quantum-Programming
|
zeynepCankara
|
#
# your solution is here
#
from random import randrange
def experiment(n):
num_tails = 0
num_heads = 0
for i in range(n):
if(randrange(2) == 0): # 0 is the head
num_heads += 1
else:
num_tails += 1
return num_heads, num_tails
num_heads1000, num_tails1000 = experiment(1000)
print("Experiment with 1000 flips | heads: " + str(num_heads1000) + " tails: " + str(num_tails1000))
print("Probability | heads: " + str(num_heads1000/1000) + " tails: " + str(num_tails1000/1000))
num_heads10000, num_tails10000 = experiment(10000)
print("Experiment with 10,000 flips | heads: " + str(num_heads10000) + " tails: " + str(num_tails10000))
print("Probability | heads: " + str(num_heads10000/10000) + " tails: " + str(num_tails10000/10000))
num_heads100000, num_tails100000 = experiment(100000)
print("Experiment with 100,000 flips | heads: " + str(num_heads100000) + " tails: " + str(num_tails100000))
print("Probability | heads: " + str(num_heads100000/1000000) + " tails: " + str(num_tails100000/1000000))
#
# your solution is here
#
def experiment(n):
num_tails = 0
num_heads = 0
for i in range(n):
if(randrange(5) < 2): # < 0.4 prob for tail
num_tails += 1
else:
num_heads += 1
return num_heads, num_tails
num_heads1000, num_tails1000 = experiment(1000)
print("Experiment with 1000 flips | heads: " + str(num_heads1000) + " tails: " + str(num_tails1000))
print("Probability | heads: " + str(num_heads1000/1000) + " tails: " + str(num_tails1000/1000))
num_heads10000, num_tails10000 = experiment(10000)
print("Experiment with 10,000 flips | heads: " + str(num_heads10000) + " tails: " + str(num_tails10000))
print("Probability | heads: " + str(num_heads10000/10000) + " tails: " + str(num_tails10000/10000))
num_heads100000, num_tails100000 = experiment(100000)
print("Experiment with 100,000 flips | heads: " + str(num_heads100000) + " tails: " + str(num_tails100000))
print("Probability | heads: " + str(num_heads100000/1000000) + " tails: " + str(num_tails100000/1000000))
# proportion of heads and tails
print(str((num_heads100000)/(num_tails100000)))
|
https://github.com/jwalaQ/my-qiskit-textbook-solutions
|
jwalaQ
|
from qiskit import *
from math import pi
import numpy as np
from qiskit.visualization import plot_bloch_multivector,plot_histogram
from qiskit_textbook.tools import array_to_latex
backend_s = Aer.get_backend('statevector_simulator')
backend_u = Aer.get_backend('unitary_simulator')
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
# Add Controlled-T
qc.cp(pi/4, 0, 1) # alternatively: qc.cu1(pi/4,0,1)
display(qc.draw('mpl'))
# See Results:
final_state = execute(qc,backend_s).result().get_statevector()
plot_bloch_multivector(final_state)
qc = QuantumCircuit(2)
qc.h(0)
# Add Controlled-T
qc.cp(pi/4, 0, 1) # Alternatively qc.cu1(pi/4,0,1)
display(qc.draw('mpl'))
# See Results:
final_state = execute(qc,backend_s).result().get_statevector()
plot_bloch_multivector(final_state)
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
# Add Controlled-T
qc.cp(-pi/2, 0, 1) #Alternatively qc.cu1(-pi/2,0,1)
display(qc.draw('mpl'))
# See Results:
final_state = execute(qc,backend_s).result().get_statevector()
plot_bloch_multivector(final_state)
qc = QuantumCircuit(2)
qc.x(0)
qc.x(1)
# Add Controlled-T
qc.cp(pi/4, 0, 1) # Alternatively, qc.cu1(pi/4,0,1)
display(qc.draw('mpl'))
# See Results:
final_state = execute(qc,backend_s).result().get_statevector()
plot_bloch_multivector(final_state)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/dv-gorasiya/quantum-machine-learning
|
dv-gorasiya
|
import numpy as np
from matplotlib import pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from matplotlib.colors import ListedColormap
seed = 12345
def plot_dataset(X, y, ax, axes=[-1, 1, -1, 1], marker='o', size=50, alpha=1.0, stepsize=0.5, grid=False, cmap=ListedColormap(['#FF0000', '#0000FF'])):
"""Simple routine to visualize a 2D dataset"""
ax.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap, edgecolors='k', marker=marker, s=size, alpha=alpha)
ax.axis(axes)
ax.grid(grid, which='both')
ax.set_xlabel(r"$x_1$", fontsize=24)
ax.set_ylabel(r"$x_2$", fontsize=24, rotation=0)
ax.xaxis.set_ticks(np.arange(axes[0], axes[1]+0.01, stepsize))
ax.yaxis.set_ticks(np.arange(axes[2], axes[3]+0.01, stepsize))
def visualize_dataset():
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 6))
ax1.set_title("Total", fontsize=24)
plot_dataset(X, y, ax1)
ax1.grid()
ax2.set_title("Train", fontsize=24)
plot_dataset(X_train, y_train, ax2, marker='s', size=80)
ax2.grid()
ax3.set_title("Test", fontsize=22)
plot_dataset(X_test, y_test, ax3, marker='^', size=100)
ax3.grid()
plt.rcParams['font.size'] = 15
plt.tight_layout()
plt.show()
from sklearn.datasets import load_iris
iris = load_iris()
pair = [0, 2]
X = iris.data[:, pair]
y = iris.target
# Data rescaling
xmin = -1; xmax = 1
X = MinMaxScaler(feature_range=(xmin, xmax), copy=False).fit_transform(X)
# Train/Test subdivision
train_size = 20; test_size = 20
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size, test_size=test_size,
stratify=y,
random_state=seed
)
def iris_visualize_dataset(X, y, ax, marker='o'):
n_classes = 3
plot_colors = ['#FF0000', '#0000FF', '#00FF00']
cmap = ListedColormap(plot_colors)
for i, color in zip(range(n_classes), plot_colors):
idx = np.where(y == i)
ax.scatter(
X[idx, 0],
X[idx, 1],
c=color,
label=iris.target_names[i],
edgecolor="black",
s=50,
marker=marker
)
fig, axs = plt.subplots(1, 3, figsize=(18, 6))
iris_visualize_dataset(X, y, axs[0])
iris_visualize_dataset(X_train, y_train, axs[1], marker='s')
iris_visualize_dataset(X_test, y_test, axs[2], marker='^')
for ax in axs:
ax.set_xlim(xmin, xmax)
ax.set_ylim(xmin, xmax)
ax.set_xlabel(iris.feature_names[pair[0]])
ax.set_ylabel(iris.feature_names[pair[1]])
plt.rcParams['font.size'] = 20
plt.suptitle("Iris dataset")
plt.legend(loc="lower right")
plt.tight_layout()
plt.show()
from sklearn.datasets import make_blobs
from sklearn.preprocessing import MinMaxScaler
n_samples = 400
X, y = make_blobs(n_samples=n_samples, n_features=2, centers=2, random_state=110, shuffle=True, cluster_std=1.2)
y[y%2 == 0] = -1
y[y > 0] = 1
xmin = -1; xmax = 1
X = MinMaxScaler(feature_range=(xmin, xmax)).fit_transform(X)
train_size = 20
test_size = 20
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size, test_size=test_size,
random_state=seed
)
visualize_dataset()
from sklearn.datasets import make_circles
n_samples = 200
X, y = make_circles(n_samples, noise=0.1, factor=0.4, random_state=0)
y[y%2 == 0] = -1
y[y > 0] = 1
xmin = -1; xmax = 1
X = MinMaxScaler(feature_range=(xmin, xmax)).fit_transform(X)
train_size = 20
test_size = 20
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size, test_size=test_size,
random_state=seed
)
visualize_dataset()
from sklearn.datasets import make_gaussian_quantiles
n_samples = 200
X, y = make_gaussian_quantiles(n_samples=n_samples, n_features=2, n_classes=2, shuffle=True, random_state=10)
y = 2*y-1
# Data rescaling
xmin = -1; xmax = 1
X = MinMaxScaler(feature_range=(xmin, xmax), copy=False).fit_transform(X)
train_size = 20
test_size = 20
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size,
test_size=test_size,
stratify=y,
random_state=seed
)
visualize_dataset()
from sklearn.datasets import make_moons
n_samples = 100
X, y = make_moons(n_samples=n_samples, noise=0.2, random_state=32345)
y = 2*y-1
# Data rescaling
xmin = -1; xmax = 1
X = MinMaxScaler(feature_range=(xmin, xmax), copy=False).fit_transform(X)
train_size = 20
test_size = 20
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size,
test_size=test_size,
stratify=y,
random_state=seed
)
visualize_dataset()
|
https://github.com/PabloMartinezAngerosa/QAOA-uniform-convergence
|
PabloMartinezAngerosa
|
from tsp_qaoa import test_solution
from qiskit.visualization import plot_histogram
import networkx as nx
import numpy as np
import json
import csv
# Array of JSON Objects
header = ['p', 'state', 'probability', 'mean']
length_p = 10
with open('qaoa_multiple_p.csv', 'w', encoding='UTF8') as f:
writer = csv.writer(f)
# write the header
writer.writerow(header)
first_p = False
for p in range(length_p):
p = p+1
if first_p == False:
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution(p=p)
first_p = True
else:
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution(grafo=G, p=p)
# Sort the JSON data based on the value of the brand key
UNIFORM_CONVERGENCE_SAMPLE.sort(key=lambda x: x["mean"])
mean = UNIFORM_CONVERGENCE_SAMPLE[0]["mean"]
print(mean)
state = 0
for probability in UNIFORM_CONVERGENCE_SAMPLE[0]["probabilities"]:
state += 1
writer.writerow([p,state, probability,mean])
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_optimization import QuadraticProgram
qp = QuadraticProgram()
qp.binary_var("x")
qp.binary_var("y")
qp.integer_var(lowerbound=0, upperbound=7, name="z")
qp.maximize(linear={"x": 2, "y": 1, "z": 1})
qp.linear_constraint(linear={"x": 1, "y": 1, "z": 1}, sense="LE", rhs=5.5, name="xyz_leq")
qp.linear_constraint(linear={"x": 1, "y": 1, "z": 1}, sense="GE", rhs=2.5, name="xyz_geq")
print(qp.prettyprint())
from qiskit_optimization.converters import InequalityToEquality
ineq2eq = InequalityToEquality()
qp_eq = ineq2eq.convert(qp)
print(qp_eq.prettyprint())
print(qp_eq.prettyprint())
from qiskit_optimization.converters import IntegerToBinary
int2bin = IntegerToBinary()
qp_eq_bin = int2bin.convert(qp_eq)
print(qp_eq_bin.prettyprint())
print(qp_eq_bin.prettyprint())
from qiskit_optimization.converters import LinearEqualityToPenalty
lineq2penalty = LinearEqualityToPenalty()
qubo = lineq2penalty.convert(qp_eq_bin)
print(qubo.prettyprint())
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/jdanielescanez/quantum-solver
|
jdanielescanez
|
import sys, os
sys.path.append(os.path.dirname(os.path.realpath(__file__)) + '/../../')
from composer.qs_circuit import QSCircuit
import string
from qiskit import execute, BasicAer
import math
ALPHABET = list(string.ascii_uppercase) + [' ', '-', '_', '.', ',', '@']
SIZE_REG = int(math.log2(len(ALPHABET)))
CIRCUIT_SIZE = SIZE_REG * 2
msg_indexes = list(range(0, SIZE_REG))
key_indexes = list(range(SIZE_REG, 2 * SIZE_REG))
key_slice = slice(SIZE_REG, 2 * SIZE_REG)
def vigenere_qcypher(msg, key):
qc = QSCircuit(CIRCUIT_SIZE)
qc.set_reg(msg, msg_indexes)
qc.set_reg(key, key_indexes)
qc.xor2(msg_indexes, key_indexes)
qc.measure(key_indexes, key_indexes)
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1)
counts = job.result().get_counts(qc)
result_bin = ''.join(list(list(counts.keys())[0][::-1][key_slice][::-1]))
result_char = ALPHABET[int(result_bin, 2) % len(ALPHABET)]
return result_char
msg = input('Insert message: ').upper()
key = input('Insert key: ').upper()
assert all(list(map(lambda c: c in ALPHABET, msg)))
assert all(list(map(lambda c: c in ALPHABET, key)))
cypher = ''
for i, msg_char in enumerate(msg):
key_char = key[i % len(key)]
a = format(ALPHABET.index(msg_char), f'0{SIZE_REG}b')[::-1]
b = format(ALPHABET.index(key_char), f'0{SIZE_REG}b')[::-1]
result_char = vigenere_qcypher(a, b)
cypher += result_char
print(f'\nMessage: {msg}')
print(f'Key: {key}')
print(f'Cypher text: {cypher}')
|
https://github.com/qiskit-community/prototype-quantum-kernel-training
|
qiskit-community
|
# pylint: disable=import-error, wrong-import-position, pointless-statement
import os
import sys
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit import ParameterVector
from qiskit_machine_learning.kernels import TrainableFidelityQuantumKernel
NUM_QUBITS = 3
fm = QuantumCircuit(NUM_QUBITS)
input_params = ip = ParameterVector("x", NUM_QUBITS)
training_params = tp = ParameterVector("θ", NUM_QUBITS)
for i in range(NUM_QUBITS):
fm.h(i)
fm.ry(tp[i], i)
for i in range(NUM_QUBITS):
fm.crx(ip[i], (i) % NUM_QUBITS, (i + 1) % NUM_QUBITS)
# Define a Quantum Kernel using our trainable feature map
qk = TrainableFidelityQuantumKernel(
feature_map=fm, training_parameters=training_params[:NUM_QUBITS]
)
print("input_params:", input_params)
print("training_params:", training_params)
qk.feature_map.draw()
# Bind parameters to numeric values
param_binds = {tp[0]: np.pi / 2, tp[1]: np.pi / 3, tp[2]: np.pi / 4}
qk.assign_training_parameters(param_binds)
qk.parameter_values
# Create incomplete training param bindings
param_binds = {tp[0]: np.pi / 6, tp[1]: np.pi / 5}
qk.assign_training_parameters(param_binds)
qk.parameter_values
# Create incomplete user param bindings
param_binds = {tp[0]: tp[0], tp[1]: tp[0] + tp[2], tp[2]: tp[2]}
qk.assign_training_parameters(param_binds)
qk.parameter_values
qk = TrainableFidelityQuantumKernel(feature_map=fm, training_parameters=training_params)
qk.feature_map.draw()
param_values = [np.pi / 7, tp[1], np.pi / 9]
qk.assign_training_parameters(param_values)
qk.parameter_values
param_values = [np.pi / 7, np.pi / 6, np.pi / 9]
qk.assign_training_parameters(param_values)
qk.parameter_values
param_values = [tp[0], tp[1], tp[2]]
qk.assign_training_parameters(param_values)
qk.parameter_values
#import qiskit.tools.jupyter
#
#%qiskit_version_table
#%qiskit_copyright
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
import sys
import os
current_dir = os.getcwd()
sys.path.append(current_dir)
from quantum_circuit import QuantumCircuit
# import qiskit.providers.fake_provider
from qiskit.transpiler import CouplingMap
import qiskit_ibm_runtime.fake_provider
from Backend.backend import Backend
class FakeBackend(Backend):
def __init__(self, backend_name : str) -> None:
self.backend = FakeBackend.get_ibm_fake_backend(backend_name=backend_name)
@staticmethod
def get_ibm_fake_backend_name_list() -> list[str]:
ibm_dir = dir(qiskit_ibm_runtime.fake_provider)
return [val for val in ibm_dir if '__' not in val and 'Fake' in val]
@staticmethod
def get_ibm_fake_backend(backend_name : str):
try:
return getattr(qiskit_ibm_runtime.fake_provider, backend_name)()
except: pass
fake_backend_name = FakeBackend.get_ibm_fake_backend_name_list()
for backend in fake_backend_name:
backend = FakeBackend.get_ibm_fake_backend(backend)
if backend is not None:
try:
if backend.name == backend_name:
return backend
except: pass
return None
@staticmethod
def get_ibm_fake_backend_names_with_limit(min_qubit : int = 1, max_qubit: int = float('inf')) -> list[str]:
limited_backend = []
fake_backend_name = FakeBackend.get_ibm_fake_backend_name_list()
for backend in fake_backend_name:
backend = FakeBackend.get_ibm_fake_backend(backend)
if backend is not None:
try:
num_qubit = backend.num_qubits
if num_qubit >= min_qubit and num_qubit <= max_qubit:
limited_backend.append(backend.name)
except: pass
return limited_backend
if __name__ == "__main__":
print(FakeBackend.get_ibm_fake_backend_name_list())
backend = FakeBackend('fake_auckland')
qc = QuantumCircuit(2)
qc.x(0)
qc.h(1)
qc.measure_all()
print(qc.draw())
job = backend.run(qc)
print(job.result())
qc_transpile = backend.traspile_qiskit(qc)[0]
print(qc_transpile.draw())
job = backend.run(qc_transpile)
print(job.result())
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# Create circuit to test transpiler on
from qiskit import QuantumCircuit
from qiskit.circuit.library import GroverOperator, Diagonal
oracle = Diagonal([1]*7 + [-1])
qc = QuantumCircuit(3)
qc.h([0,1,2])
qc = qc.compose(GroverOperator(oracle))
# Use Statevector object to calculate the ideal output
from qiskit.quantum_info import Statevector
ideal_distribution = Statevector.from_instruction(qc).probabilities_dict()
from qiskit.visualization import plot_histogram
plot_histogram(ideal_distribution)
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
backend = service.backend('ibm_algiers')
# Need to add measurements to the circuit
qc.measure_all()
from qiskit import transpile
circuits = []
for optimization_level in [0, 3]:
t_qc = transpile(qc,
backend,
optimization_level=optimization_level,
seed_transpiler=0)
print(f'CNOTs (optimization_level={optimization_level}): ',
t_qc.count_ops()['cx'])
circuits.append(t_qc)
from qiskit.transpiler import PassManager, InstructionDurations
from qiskit.transpiler.passes import ASAPSchedule, DynamicalDecoupling
from qiskit.circuit.library import XGate
# Get gate durations so the transpiler knows how long each operation takes
durations = InstructionDurations.from_backend(backend)
# This is the sequence we'll apply to idling qubits
dd_sequence = [XGate(), XGate()]
# Run scheduling and dynamic decoupling passes on circuit
pm = PassManager([ASAPSchedule(durations),
DynamicalDecoupling(durations, dd_sequence)]
)
circ_dd = pm.run(circuits[1])
# Add this new circuit to our list
circuits.append(circ_dd)
from qiskit_ibm_runtime import Sampler, Session
with Session(service=service, backend=backend):
sampler = Sampler()
job = sampler.run(
circuits=circuits, # sample all three circuits
skip_transpilation=True,
shots=8000)
result = job.result()
from qiskit.visualization import plot_histogram
binary_prob = [quasi_dist.binary_probabilities() for quasi_dist in result.quasi_dists]
plot_histogram(binary_prob+[ideal_distribution],
bar_labels=False,
legend=['optimization_level=0',
'optimization_level=3',
'optimization_level=3 + dd',
'ideal distribution'])
from qiskit.quantum_info import hellinger_fidelity
for counts in result.quasi_dists:
print(
f"{hellinger_fidelity(counts.binary_probabilities(), ideal_distribution):.3f}"
)
import qiskit_ibm_runtime
qiskit_ibm_runtime.version.get_version_info()
from qiskit.tools.jupyter import *
%qiskit_version_table
%qiskit_copyright
|
https://github.com/quantum-tokyo/qiskit-handson
|
quantum-tokyo
|
# Qiskitライブラリーを導入
from qiskit import *
# 描画のためのライブラリーを導入
import matplotlib.pyplot as plt
%matplotlib inline
qiskit.__qiskit_version__
grover11=QuantumCircuit(2,2)
grover11.draw(output='mpl')
# 問題-1 上の回路図を作ってください。
grover11.draw(output='mpl')
# 問題-2 上の回路図（問題-1に赤枠部分を追加したもの）を作ってください。
grover11.draw(output='mpl')
#問題-3 上の回路図（問題-2に赤枠部分を追加したもの）を作ってください。
grover11.i(0) # 回路の見栄えを整えるために、恒等ゲートを差し込む。無くても動くが、表示の見栄えが崩れるのを防止するために、残しておく。
grover11.draw(output='mpl')
grover11.measure(0,0)
grover11.measure(1,1)
grover11.draw(output='mpl')
backend = Aer.get_backend('statevector_simulator') # 実行環境の定義
job = execute(grover11, backend) # 処理の実行
result = job.result() # 実行結果
counts = result.get_counts(grover11) # 実行結果の詳細を取り出し
print(counts)
from qiskit.visualization import *
plot_histogram(counts) # ヒストグラムで表示
|
https://github.com/Quantum-Ducks/QuBayes
|
Quantum-Ducks
|
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from qubayes_tools import *
from network_setup import *
def get_probabilities(node):
############################################
# USE THIS FUNCTION TO FIND THE PROBABILITIES FOR AN INDIVIDUAL NODE IN THE NETWORK
### INPUT ###
# node: Node Node object in network
### OUTPUT ###
# probs: dict probabilities
############################################
data= node.data
states = node.states
name = node.name
num_total = len(data) #total number of data points with which to calculate probabilities
probs = {}
prob_sum = 0
for state in states.keys(): #loop through different state strings
prob = np.shape(np.where(data == states[state]))[1]/num_total
prob_sum += prob
probs.update({name + "_" + state : prob})
assert round(prob_sum, 3) == 1.
return probs
def get_conditional_probability(child, *ps):
############################################
### THIS FUNCTION CALCULATES CONDITIONAL PROBABILITIES FOR CHILD NODE
### THAT HAS s_m STATES AND m PARENT NODES EACH WITH s_i STATES WHERE i = 0, ..., m-1
### INPUTS ###
# child Node
# *ps Node(s) or a single list of Nodes
### OUTPUT ###
# a dictionary of conditional probabilities
############################################
#we might want to add some assert statements checking that all inputs have the same shape
#also use assert to check that for all p in ps, ps.name is in child.parents, and vice versa
if type(ps[0]) == list:
ps = ps[0]
if type(ps[0]) != Node:
print("ERROR: This input is not right!")
keys = generate_cond_keys(child, ps)
cond_probs = {key: 0 for key in keys} #initialize a dictionary for conditional probabilities
for key in keys:
numer, tot = 0, 0
n = len(child.data)
for i in range(n):
all_ps = True
for j in range(len(ps)):
p = ps[j]
if p.data[i] != int(p.states[key.split("|")[1].split(",")[j].split("_")[1]]):
all_ps = False
break
if all_ps:
tot += 1
if child.data[i] == int(child.states[key.split("|")[0].split("_")[1]]):
numer += 1
cond_probs.update({key : numer/tot})
return cond_probs
Cases, Tests, StayHome = get_lesser_model_nodes()
get_conditional_probability(Cases, StayHome, Tests)
get_conditional_probability(Cases, Tests, StayHome)
Cases, Test, Mask, Work, Rec, Death, Age = get_mallard_model_nodes()
get_conditional_probability(Cases, Test, Mask , Work, Rec)
Cases, Test, Mask, Work, Rec, Death, Age, Race, Poverty, Health = get_alabio_model_nodes()
get_conditional_probability(Cases, Test, Mask, Work, Rec, Poverty, Race)
# example: results from running simple model on simulator:
# {'000': 2783, '001': 1240, '100': 603, '111': 815, '110': 294, '010': 1712, '101': 485, '011': 260}
def get_marginal_0probabilities(state_counts):
#state_counts: dict, counts for each state from network result (should have 2^n entries)
#marg_probs: array of length n, marginal probabilities that each qubit is 0,
#from most significant to least significant qubit
n = len(list(state_counts.keys())[0]) #number of qubits
prob = np.zeros(n)
total = sum(state_counts.values())
for i in range(n):
for key in state_counts:
if int(key[i]) == 0:
prob[i] += state_counts[key]
prob[i] = prob[i]/total
return prob
# get marginal probabilities for simulation results - lesser model
results = {'000': 2783, '001': 1240, '100': 603, '111': 815, '110': 294, '010': 1712, '101': 485, '011': 260}
#margProb = marginal_probabilities(results)
#margCompare = marginal_probabilities_general(results)
#print(margProb)
#print(margCompare)
def func(**counts):
return counts["c001"]
func(c000=4928, c001=82743, c100=48937, c111=9288842)
C,B,A = get_lesser_model_nodes()
print(C.name)
get_conditional_probability(C, B, A)
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
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
class QKA:
def __init__(self, feature_map, backend, initial_layout=None, user_messenger=None):
self.feature_map = feature_map
self.feature_map_circuit = self.feature_map.construct_circuit
self.backend = backend
self.initial_layout = initial_layout
self.num_parameters = self.feature_map._num_parameters
self._user_messenger = user_messenger
self.result = {}
self.kernel_matrix = KernelMatrix(
feature_map=self.feature_map, backend=self.backend, initial_layout=self.initial_layout
)
def spsa_parameters(self):
spsa_params = np.zeros((5))
spsa_params[0] = 0.05 # a
spsa_params[1] = 0.1 # c
spsa_params[2] = 0.602 # alpha
spsa_params[3] = 0.101 # gamma
spsa_params[4] = 0 # A
return spsa_params
def cvxopt_solver(self, K, y, C, max_iters=10000, show_progress=False):
if y.ndim == 1:
y = y[:, np.newaxis]
H = np.outer(y, y) * K
f = -np.ones(y.shape)
n = K.shape[1] # number of training points
y = y.astype("float")
P = matrix(H)
q = matrix(f)
G = matrix(np.vstack((-np.eye((n)), np.eye((n)))))
h = matrix(np.vstack((np.zeros((n, 1)), np.ones((n, 1)) * C)))
A = matrix(y, y.T.shape)
b = matrix(np.zeros(1), (1, 1))
solvers.options["maxiters"] = max_iters
solvers.options["show_progress"] = show_progress
ret = solvers.qp(P, q, G, h, A, b, kktsolver="ldl")
return ret
def spsa_step_one(self, lambdas, spsa_params, count):
prng = RandomState(count)
c_spsa = float(spsa_params[1]) / np.power(count + 1, spsa_params[3])
delta = 2 * prng.randint(0, 2, size=np.shape(lambdas)[0]) - 1
lambda_plus = lambdas + c_spsa * delta
lambda_minus = lambdas - c_spsa * delta
return lambda_plus, lambda_minus, delta
def spsa_step_two(self, cost_plus, cost_minus, lambdas, spsa_params, delta, count):
a_spsa = float(spsa_params[0]) / np.power(count + 1 + spsa_params[4], spsa_params[2])
c_spsa = float(spsa_params[1]) / np.power(count + 1, spsa_params[3])
g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)
lambdas_new = lambdas - a_spsa * g_spsa
lambdas_new = lambdas_new.flatten()
cost_final = (cost_plus + cost_minus) / 2
return cost_final, lambdas_new
def align_kernel(self, data, labels, initial_kernel_parameters=None, maxiters=1, C=1):
if initial_kernel_parameters is not None:
lambdas = initial_kernel_parameters
else:
lambdas = np.random.uniform(-1.0, 1.0, size=(self.num_parameters))
spsa_params = self.spsa_parameters()
lambda_save = []
cost_final_save = []
for count in range(maxiters):
lambda_plus, lambda_minus, delta = self.spsa_step_one(
lambdas=lambdas, spsa_params=spsa_params, count=count
)
kernel_plus = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambda_plus
)
kernel_minus = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambda_minus
)
ret_plus = self.cvxopt_solver(K=kernel_plus, y=labels, C=C)
cost_plus = -1 * ret_plus["primal objective"]
ret_minus = self.cvxopt_solver(K=kernel_minus, y=labels, C=C)
cost_minus = -1 * ret_minus["primal objective"]
cost_final, lambda_best = self.spsa_step_two(
cost_plus=cost_plus,
cost_minus=cost_minus,
lambdas=lambdas,
spsa_params=spsa_params,
delta=delta,
count=count,
)
lambdas = lambda_best
interim_result = {"cost": cost_final, "kernel_parameters": lambdas}
print(interim_result)
self._user_messenger.publish(interim_result)
lambda_save.append(lambdas)
cost_final_save.append(cost_final)
# Evaluate aligned kernel matrix with optimized set of
# parameters averaged over last 10% of SPSA steps:
num_last_lambdas = int(len(lambda_save) * 0.10)
if num_last_lambdas > 0:
last_lambdas = np.array(lambda_save)[-num_last_lambdas:, :]
lambdas = np.sum(last_lambdas, axis=0) / num_last_lambdas
else:
lambdas = np.array(lambda_save)[-1, :]
kernel_best = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambdas
)
self.result["aligned_kernel_parameters"] = lambdas
self.result["aligned_kernel_matrix"] = kernel_best
return self.result
class KernelMatrix:
def __init__(self, feature_map, backend, initial_layout=None):
self._feature_map = feature_map
self._feature_map_circuit = self._feature_map.construct_circuit
self._backend = backend
self._initial_layout = initial_layout
self.results = {}
def construct_kernel_matrix(self, x1_vec, x2_vec, parameters=None):
is_identical = False
if np.array_equal(x1_vec, x2_vec):
is_identical = True
experiments = []
measurement_basis = "0" * self._feature_map._num_qubits
if is_identical:
my_product_list = list(
itertools.combinations(range(len(x1_vec)), 2)
) # all pairwise combos of datapoint indices
for index_1, index_2 in my_product_list:
circuit_1 = self._feature_map_circuit(
x=x1_vec[index_1], parameters=parameters, name="{}_{}".format(index_1, index_2)
)
circuit_2 = self._feature_map_circuit(
x=x1_vec[index_2], parameters=parameters, inverse=True
)
circuit = circuit_1.compose(circuit_2)
circuit.measure_all()
experiments.append(circuit)
experiments = transpile(
experiments, backend=self._backend, initial_layout=self._initial_layout
)
program_data = self._backend.run(experiments, shots=8192).result()
self.results["program_data"] = program_data
mat = np.eye(
len(x1_vec), len(x1_vec)
) # kernel matrix element on the diagonal is always 1
for experiment, [index_1, index_2] in enumerate(my_product_list):
counts = program_data.get_counts(experiment=experiment)
shots = sum(counts.values())
mat[index_1][index_2] = (
counts.get(measurement_basis, 0) / shots
) # kernel matrix element is the probability of measuring all 0s
mat[index_2][index_1] = mat[index_1][index_2] # kernel matrix is symmetric
return mat
else:
for index_1, point_1 in enumerate(x1_vec):
for index_2, point_2 in enumerate(x2_vec):
circuit_1 = self._feature_map_circuit(
x=point_1, parameters=parameters, name="{}_{}".format(index_1, index_2)
)
circuit_2 = self._feature_map_circuit(
x=point_2, parameters=parameters, inverse=True
)
circuit = circuit_1.compose(circuit_2)
circuit.measure_all()
experiments.append(circuit)
experiments = transpile(
experiments, backend=self._backend, initial_layout=self._initial_layout
)
program_data = self._backend.run(experiments, shots=8192).result()
self.results["program_data"] = program_data
mat = np.zeros((len(x1_vec), len(x2_vec)))
i = 0
for index_1, _ in enumerate(x1_vec):
for index_2, _ in enumerate(x2_vec):
counts = program_data.get_counts(experiment=i)
shots = sum(counts.values())
mat[index_1][index_2] = counts.get(measurement_basis, 0) / shots
i += 1
return mat
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile, schedule
from qiskit.visualization.pulse_v2 import draw, IQXSimple
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=IQXSimple(), backend=FakeBoeblingen())
|
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
|
import numpy as np
from qiskit import *
from qiskit.circuit import Gate
my_gate = Gate(name='my_gate', num_qubits=2, params=[])
qr = QuantumRegister(3, 'q')
circ = QuantumCircuit(qr)
circ.append(my_gate, [qr[0], qr[1]])
circ.append(my_gate, [qr[1], qr[2]])
circ.draw()
# 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.id(sub_q[1])
sub_circ.u(1, 2, -2, sub_q[0])
# Convert to a gate and stick it into an arbitrary place in the bigger circuit
sub_inst = sub_circ.to_instruction()
qr = QuantumRegister(3, 'q')
circ = QuantumCircuit(qr)
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.cx(qr[1], qr[2])
circ.append(sub_inst, [qr[1], qr[2]])
circ.draw()
decomposed_circ = circ.decompose() # Does not modify original circuit
decomposed_circ.draw()
from qiskit.circuit import Parameter
theta = Parameter('θ')
n = 5
qc = QuantumCircuit(5, 1)
qc.h(0)
for i in range(n-1):
qc.cx(i, i+1)
qc.barrier()
qc.rz(theta, range(5))
qc.barrier()
for i in reversed(range(n-1)):
qc.cx(i, i+1)
qc.h(0)
qc.measure(0, 0)
qc.draw('mpl')
print(qc.parameters)
import numpy as np
theta_range = np.linspace(0, 2 * np.pi, 128)
circuits = [qc.bind_parameters({theta: theta_val})
for theta_val in theta_range]
circuits[-1].draw()
backend = BasicAer.get_backend('qasm_simulator')
job = backend.run(transpile(circuits, backend))
counts = job.result().get_counts()
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(8,6))
ax = fig.add_subplot(111)
ax.plot(theta_range, list(map(lambda c: c.get('0', 0), counts)), '.-', label='0')
ax.plot(theta_range, list(map(lambda c: c.get('1', 0), counts)), '.-', label='1')
ax.set_xticks([i * np.pi / 2 for i in range(5)])
ax.set_xticklabels(['0', r'$\frac{\pi}{2}$', r'$\pi$', r'$\frac{3\pi}{2}$', r'$2\pi$'], fontsize=14)
ax.set_xlabel('θ', fontsize=14)
ax.set_ylabel('Counts', fontsize=14)
ax.legend(fontsize=14)
import time
from itertools import combinations
from qiskit.compiler import assemble
from qiskit.test.mock import FakeVigo
start = time.time()
qcs = []
theta_range = np.linspace(0, 2*np.pi, 32)
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=FakeVigo())
qobj = assemble(compiled_circuits, backend=FakeVigo())
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(8):
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=FakeVigo())
qobj = assemble([transpiled_qc.bind_parameters({theta: n})
for n in theta_range], backend=FakeVigo())
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())
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/mmetcalf14/Hamiltonian_Downfolding_IBM
|
mmetcalf14
|
from __future__ import print_function
from imp import reload
import matplotlib
reload(matplotlib)
matplotlib.use('nbagg')
import matplotlib.backends.backend_nbagg
reload(matplotlib.backends.backend_nbagg)
import matplotlib.backends.backend_webagg_core
reload(matplotlib.backends.backend_webagg_core)
import matplotlib.pyplot as plt
plt.interactive(False)
fig1 = plt.figure()
plt.plot(range(10))
plt.show()
plt.plot([3, 2, 1])
plt.show()
print(matplotlib.backends.backend_nbagg.connection_info())
plt.close(fig1)
plt.plot(range(10))
print(matplotlib.backends.backend_nbagg.connection_info())
plt.show()
plt.figure()
plt.plot(range(5))
plt.show()
plt.interactive(True)
plt.figure()
plt.plot([3, 2, 1])
plt.plot(range(3))
print(matplotlib.backends.backend_nbagg.connection_info())
plt.interactive(False)
plt.gcf().canvas.manager.reshow()
fig = plt.figure()
plt.axes()
plt.show()
plt.plot([1, 2, 3])
plt.show()
from matplotlib.backends.backend_nbagg import new_figure_manager,show
manager = new_figure_manager(1000)
fig = manager.canvas.figure
ax = fig.add_subplot(1,1,1)
ax.plot([1,2,3])
fig.show()
import matplotlib.animation as animation
import numpy as np
fig, ax = plt.subplots()
x = np.arange(0, 2*np.pi, 0.01) # x-array
line, = ax.plot(x, np.sin(x))
def animate(i):
line.set_ydata(np.sin(x+i/10.0)) # update the data
return line,
#Init only required for blitting to give a clean slate.
def init():
line.set_ydata(np.ma.array(x, mask=True))
return line,
ani = animation.FuncAnimation(fig, animate, np.arange(1, 200), init_func=init,
interval=32., blit=True)
plt.show()
import matplotlib
matplotlib.rcParams.update({'figure.facecolor': 'red',
'savefig.facecolor': 'yellow'})
plt.figure()
plt.plot([3, 2, 1])
plt.show()
import itertools
fig, ax = plt.subplots()
x = np.linspace(0,10,10000)
y = np.sin(x)
ln, = ax.plot(x,y)
evt = []
colors = iter(itertools.cycle(['r', 'g', 'b', 'k', 'c']))
def on_event(event):
if event.name.startswith('key'):
fig.suptitle('%s: %s' % (event.name, event.key))
elif event.name == 'scroll_event':
fig.suptitle('%s: %s' % (event.name, event.step))
else:
fig.suptitle('%s: %s' % (event.name, event.button))
evt.append(event)
ln.set_color(next(colors))
fig.canvas.draw()
fig.canvas.draw_idle()
fig.canvas.mpl_connect('button_press_event', on_event)
fig.canvas.mpl_connect('button_release_event', on_event)
fig.canvas.mpl_connect('scroll_event', on_event)
fig.canvas.mpl_connect('key_press_event', on_event)
fig.canvas.mpl_connect('key_release_event', on_event)
plt.show()
import time
fig, ax = plt.subplots()
text = ax.text(0.5, 0.5, '', ha='center')
def update(text):
text.set(text=time.ctime())
text.axes.figure.canvas.draw()
timer = fig.canvas.new_timer(500, [(update, [text], {})])
timer.start()
plt.show()
fig, ax = plt.subplots()
text = ax.text(0.5, 0.5, '', ha='center')
timer = fig.canvas.new_timer(500, [(update, [text], {})])
timer.single_shot = True
timer.start()
plt.show()
fig, ax = plt.subplots()
text = ax.text(0.5, 0.5, '', ha='center')
timer = fig.canvas.new_timer(500, [(update, [text], {})])
timer.start()
timer.stop()
plt.show()
fig, ax = plt.subplots()
text = ax.text(0.5, 0.5, '', ha='center')
timer = fig.canvas.new_timer(500, [(update, [text], {})])
timer.single_shot = True
timer.start()
timer.stop()
plt.show()
fig, ax = plt.subplots()
ax.plot(range(5))
plt.show()
fig.canvas.manager.reshow()
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
import numpy as np
from qiskit import BasicAer
from qiskit.transpiler import PassManager
from qiskit.aqua import QuantumInstance
from qiskit.aqua.operators import MatrixOperator, op_converter
from qiskit.aqua.algorithms import EOH
from qiskit.aqua.components.initial_states import Custom
num_qubits = 2
temp = np.random.random((2 ** num_qubits, 2 ** num_qubits))
qubit_op = op_converter.to_weighted_pauli_operator(MatrixOperator(matrix=temp + temp.T))
temp = np.random.random((2 ** num_qubits, 2 ** num_qubits))
evo_op = op_converter.to_weighted_pauli_operator(MatrixOperator(matrix=temp + temp.T))
evo_time = 1
num_time_slices = 1
state_in = Custom(qubit_op.num_qubits, state='uniform')
eoh = EOH(qubit_op, state_in, evo_op, evo_time=evo_time, num_time_slices=num_time_slices)
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend)
ret = eoh.run(quantum_instance)
print('The result is\n{}'.format(ret))
|
https://github.com/Qottmann/Quantum-anomaly-detection
|
Qottmann
|
import time
import itertools
import numpy as np
from scipy.optimize import minimize, basinhopping
from qiskit import *
from qiskit.quantum_info import Statevector
from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B, SPSA
from qiskit.opflow.state_fns import StateFn, CircuitStateFn
from qiskit.providers.aer import StatevectorSimulator, AerSimulator
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
from matplotlib.colors import BoundaryNorm
from modules.utils import *
%matplotlib inline
cmap = plt.get_cmap("plasma") #'viridis'
import qiskit
#%matplotlib inline
print(qiskit.__version__)
#reset random seed
np.random.seed(123)
from qiskit.utils import algorithm_globals
algorithm_globals.random_seed = 123
### Preliminaries
L = 5
num_trash = 2
logspace_size=50
name = f'VQE_Ising_L5_anti_-1_50x50' # _1e-3 # name of the data produced by this notebook
filename = "data/params_" + name # name of the data file that is used
L = 5
anti = -1.
VQE_params = np.load(filename + ".npz", allow_pickle=True)
gx_list = VQE_params['gx_list']
gz_list = VQE_params['gz_list']
opt_params = VQE_params['opt_params']
gx_vals = np.unique(gx_list)
gz_vals = np.unique(gz_list)
mag = QMag(L,anti) #magnetization operator (Qiskit)
Smag = Mag(L,anti) #magnetization operator (numpy)
# the ~ is the adjoint, but also it turns the is_measurement attribute to True
~StateFn(mag)
# state is technically a circuit, that prepares the ground state via VQE circuit
#state.draw() # uncomment to see, but is very long
Qen=np.zeros(len(opt_params)); Sen=np.zeros(len(opt_params)) #energies
Qmags=np.zeros(len(opt_params)); Smags=np.zeros(len(opt_params)) #magnetizations
load = True
if load:
temp = np.load(filename + "_mags-Es.npz",allow_pickle=True)
Qmags = temp["Qmags"]
Qen = temp["Qen"]
Sen = temp["Sen"]
Smags = temp["Smags"]
if not load:
for j in range(len(opt_params)):
gx = gx_list[j]
gz = gz_list[j]
H = QHIsing(L, anti, np.float32(gx), np.float32(gz)) # build Hamiltonian Op
state = init_vqe(opt_params[j], L=L)
meas_outcome = ~StateFn(mag) @ StateFn(state)
Qmags[j] = meas_outcome.eval()
e_outcome = ~StateFn(H) @ StateFn(state)
Qen[j] = e_outcome.eval()
init_state, E, ham = ising_groundstate(L, anti, np.float(gx), np.float(gz))
Sen[j] = E
Smags[j] = init_state.T.conj()@Smag@init_state #Magnetization with Numpy results
np.savez(filename + "_mags-Es",Qmags=Qmags, Qen=Qen, Sen=Sen, Smags=Smags) # for large parameter space takes quite a while because of the exact diagonalization
fig,ax = plt.subplots(figsize=(8,5))
cmap = plt.get_cmap("plasma") #'viridis'
im = ax.pcolormesh(gz_vals, gx_vals, abs(Smags).reshape(len(gz_vals),len(gx_vals)), cmap=cmap)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
plt.xscale("log")
plt.yscale("log")
ax.set_title("Magnetization ED L %.0f anti %.0f" %(L, anti),fontsize=20)
ax.set_xlabel(r"$g_z$",fontsize=24)
ax.set_ylabel(r"$g_x$",fontsize=24)
ax.tick_params(labelsize=20)
fig,ax = plt.subplots(figsize=(8,5))
cmap = plt.get_cmap("plasma") #'viridis'
im = ax.pcolormesh(gz_vals, gx_vals, abs(Qmags).reshape(len(gz_vals),len(gx_vals)), cmap=cmap)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
plt.xscale("log")
plt.yscale("log")
ax.set_title("Magnetization VQE L %.0f anti %.0f" %(L, anti),fontsize=20)
ax.set_xlabel(r"$g_z$",fontsize=24)
ax.set_ylabel(r"$g_x$",fontsize=24)
ax.tick_params(labelsize=20)
fig,ax = plt.subplots(figsize=(8,5))
cmap = plt.get_cmap("plasma") #'viridis'
im = ax.pcolormesh(gz_vals, gx_vals, Sen.reshape(len(gz_vals),len(gx_vals)) - Qen.reshape(len(gz_vals),len(gx_vals)), cmap=cmap)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
plt.xscale("log")
plt.yscale("log")
ax.set_title("Difference in energy L %.0f anti %.0f" %(L, anti),fontsize=20)
ax.set_xlabel(r"$g_z$",fontsize=24)
ax.set_ylabel(r"$g_x$",fontsize=24)
ax.tick_params(labelsize=20)
##############################################################################
### II - Training ###########################################################
##############################################################################
# Use Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
thetas = np.random.uniform(0, 2*np.pi, 2*L+2) # initial parameters without feature encoding
# thetas = np.random.uniform(0, 2*np.pi, (2*L+2, 2)) # initial parameters with feature encoding
# linear entangler (as in scales linearly with trash qubits)
def get_entangler_map(L, num_trash, i_permut=1):
result = []
nums = list(range(L)) # here was the problem, it doesnt like when list elements are taken from numpy
nums_compressed = nums.copy()[:L-num_trash]
nums_trash = nums.copy()[-num_trash:]
#print(nums, nums_compressed, nums_trash)
# combine all trash qubits with themselves
for trash_q in nums_trash[:-1]:
result.append((trash_q+1,trash_q))
# combine each of the trash qubits with every n-th
repeated = list(nums_trash) * (L-num_trash) # repeat the list of trash indices cyclicly
for i in range(L-num_trash):
result.append((repeated[i_permut + i], nums_compressed[i]))
return result
def QAE_Ansatz(thetas, L, num_trash, insert_barriers=False, parametrized_gate = "ry", entangling_gate = "cz"):
entanglement = [get_entangler_map(L,num_trash,i_permut) for i_permut in range(num_trash)]
circ = qiskit.circuit.library.TwoLocal(L,
parametrized_gate,
entangling_gate,
entanglement,
reps=num_trash,
insert_barriers=insert_barriers,
skip_final_rotation_layer=True
).assign_parameters(thetas[:-num_trash])
if insert_barriers: circ.barrier()
for i in range(num_trash):
circ.ry(thetas[L-i-1], L-i-1)
#circ.ry(circuit.Parameter(f'θ{i}'), L-i-1)
return circ
def prepare_circuit(thetas, L=6, num_trash=2, init_state=None, measurement=True, vqe=True):
qreg = QuantumRegister(L, 'q')
creg = ClassicalRegister(num_trash, 'c')
circ = QuantumCircuit(qreg, creg)
circ += QAE_Ansatz(thetas, L, num_trash, insert_barriers=True)#.assign_parameters(thetas) # difference to bind?
if measurement:
for i in range(num_trash):
circ.measure(qreg[L-i-1], creg[i])
if init_state is not None:
if vqe:
circ = init_vqe(init_state,L=L) + circ
else:
circ.initialize(init_state, qreg)
return circ
def feature_encoding(thetas, x):
""" thetas: parameters to be optimized, x: Ising model parameter (eg. field) """
new_thetas = []
thetas = thetas.reshape((-1,2))
for theta in thetas:
new_thetas.append(theta[0] * x + theta[1])
return new_thetas
idx = 30
num_trash = 2
J, gx, gz = -1., gx_list[idx], gz_list[idx] # Ising parameters for which ground state should be compressed
phi = opt_params[idx] # train on smallest lambda ;; this may grammatically be confusing, init_state = dictionary with unsorted parameters
def run_circuit(thetas, L, num_trash, init_state, vqe=True, shots=100):
circ = prepare_circuit(thetas, L, num_trash, init_state, vqe=vqe)
# Execute the circuit on the qasm simulator.
job_sim = execute(circ, backend_sim, shots=shots, seed_simulator=123, seed_transpiler=234) # fix seed to make it reproducible
# Grab the results from the job.
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
# print(counts)
# mems = result_sim.get_memory(circ)
# print(mems)
return counts
run_circuit(thetas, L, num_trash, phi)['11']
# translate to Rikes naming
phis = opt_params
gxs = gx_list
gzs = gz_list
def cost_function_single(thetas, L, num_trash, p, shots=1000, vqe=True, param_encoding=False, x=0):
""" Optimizes circuit """
if vqe:
init_state = phis[p]
else:
J, gx, gz = p
init_state, _ = ising_groundstate(L, J, gx, gz)
if param_encoding: thetas = feature_encoding(thetas, x)
out = run_circuit(thetas, L, num_trash, init_state, vqe=vqe, shots=shots)
cost = out.get('11', 0)*2 + out.get('01', 0) + out.get('10', 0)
return cost/shots
def cost_function(thetas, L, num_trash, ising_params, shots=1000, vqe=True, param_encoding=False, x=0):
""" Optimizes circuit """
cost = 0.
n_samples = len(ising_params)
for i, p in enumerate(ising_params):
if param_encoding:
cost += cost_function_single(thetas, L, num_trash, p, shots, vqe, param_encoding, x[i])
else:
cost += cost_function_single(thetas, L, num_trash, p, shots, vqe, param_encoding)
return cost/n_samples
def optimize(ising_params, L=6, num_trash=2, thetas=None, shots=1000, max_iter=400, vqe=True, param_encoding=False, x=0, pick_optimizer = None):
if thetas is None:
n_params = (2*L+2)*2 if param_encoding else (2*L+2)
thetas = np.random.uniform(0, 2*np.pi, n_params) # initial parameters without feature encoding
print("Initial cost: {:.3f}".format(cost_function(thetas, L, num_trash, ising_params, shots, vqe, param_encoding, x)))
counts, values, accepted = [], [], []
def store_intermediate_result(eval_count, parameters, mean, std, ac):
# counts.append(eval_count)
values.append(mean)
accepted.append(ac)
# Initialize optimizer
if pick_optimizer == "cobyla":
optimizer = COBYLA(maxiter=max_iter, tol=0.0001)
if pick_optimizer == "adam" or pick_optimizer == "ADAM":
optimizer = qiskit.algorithms.optimizers.ADAM(maxiter=max_iter)
# optimizer = L_BFGS_B(maxfun=300, maxiter=max_iter)#, factr=10, iprint=- 1, epsilon=1e-08)
if pick_optimizer == "spsa" or pick_optimizer == None:
optimizer = SPSA(maxiter=max_iter,
#blocking=True,
callback=store_intermediate_result,
#learning_rate=1e-1,
#perturbation=0.4
) # recommended from qiskit (first iteraction takes quite long)
# to reduce time figure out optimal learning rate and perturbation in advance
start_time = time.time()
ret = optimizer.optimize(
num_vars=len(thetas),
objective_function=(lambda thetas: cost_function(thetas, L, num_trash, ising_params, shots, vqe, param_encoding, x)),
initial_point=thetas
)
print("Time: {:.5f} sec".format(time.time()-start_time))
print(ret)
return ret[0], values, accepted
x,y = np.meshgrid(gx_vals, gz_vals)
def run_inference(thetas, shots=1000, L=5):
points = 50
J = -1.0
x,y = np.meshgrid(gx_vals, gz_vals)
cost = np.zeros((len(gx_vals) * len(gz_vals)))
Smags = np.zeros((len(gx_vals) * len(gz_vals)))
shots = 1000
for i,p in enumerate(list(zip(gxs, gzs))):
cost[i] = cost_function_single(thetas, L, num_trash, i, shots=shots)
cost = cost.reshape((len(gx_vals), len(gz_vals)))
return cost
cmap = plt.get_cmap("plasma")
def plot_result(cost):
fig,axs = plt.subplots(ncols=2,figsize=(15,5))
nbins=100
ax = axs[0]
im = ax.pcolormesh(x, y, cost, cmap=cmap, shading="auto")
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
ax.set_xscale("log")
ax.set_yscale("log")
ax.set_title(f"Loss",fontsize=20)
ax.set_xlabel(r"$g_z$",fontsize=24)
ax.set_ylabel(r"$g_x$",fontsize=24)
ax.tick_params(labelsize=20)
for p in params:
gz = gz_list[p]
gx = gx_list[p]
ax.plot(gz,gx,"o",label="training",color="cyan")
ax = axs[1]
im = ax.pcolormesh(gz_vals, gx_vals, abs(Qmags).reshape(len(gz_vals),len(gx_vals)), cmap=cmap, shading="auto")
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
ax.set_xscale("log")
ax.set_yscale("log")
ax.set_title("Magnetization VQE L %.0f anti %.0f" %(L, anti),fontsize=20)
ax.set_xlabel(r"$g_z$",fontsize=24)
ax.set_ylabel(r"$g_x$",fontsize=24)
ax.tick_params(labelsize=20)
paramss =[
[0], # train on bottom left point
np.intersect1d(np.where(gx_list > 99),np.where(gz_list == 1e-2)), # top left
np.intersect1d(np.where(gz_list > 99),np.where(gx_list == 1e-2)), # bottom right
[2450, 49] # both paramagnetic phases
]
for i,params in enumerate(paramss):
print(f"{i} / {len(paramss)} - params (gz, gx) in {[(gzs[p], gxs[p]) for p in params]}")
thetass = [None] * len(paramss)
losss = [None] * len(paramss)
costs = [None] * len(paramss)
for i,params in enumerate(paramss):
print(f"{i+1} / {len(paramss)} - params (gz, gx) in {[(gzs[p], gxs[p]) for p in params]}")
thetas, loss, accepted = optimize(params, max_iter=100, L=5) #, pick_optimizer="adam")
thetass[i], losss[i] = thetas, loss
plt.plot(loss)
cost = run_inference(thetas)
costs[i] = cost
np.savez("data/" + name + "_thetas-loss-cost", losss = losss, costs = costs, thetass = thetass)
for i,params in enumerate(paramss):
print(f"{i+1} / {len(paramss)} - params (gz, gx) in {[(gzs[p], gxs[p]) for p in params]}")
plot_result(np.load("data/" + name + "_thetas-loss-cost.npz",allow_pickle=True)["costs"][i])
plt.show()
fig, axs = plt.subplots(ncols=2,figsize=(10,5))
ax = axs[0]
ax.imshow(np.load("data/" + name + "_thetas-loss-cost.npz",allow_pickle=True)["costs"][0])
ax = axs[1]
ax.imshow(np.load("data/" + name + "_thetas-loss-cost2.npz",allow_pickle=True)["costs"][0])
algorithm_globals.random_seed = 321
for i,params in enumerate(paramss):
print(f"{i+1} / {len(paramss)} - params (gz, gx) in {[(gzs[p], gxs[p]) for p in params]}")
thetas, loss, accepted = optimize(params, max_iter=100, L=5) #, pick_optimizer="adam")
thetass[i], losss[i] = thetas, loss
plt.plot(loss)
cost = run_inference(thetas)
costs[i] = cost
np.savez("data/" + name + "_thetas-loss-cost2", losss = losss, costs = costs, thetass = thetass)
for i,params in enumerate(paramss):
print(f"{i+1} / {len(paramss)} - params (gz, gx) in {[(gzs[p], gxs[p]) for p in params]}")
plot_result(np.load("data/" + name + "_thetas-loss-cost2.npz",allow_pickle=True)["costs"][i])
plt.show()
for i,params in enumerate(paramss):
print(f"{i+1} / {len(paramss)} - params (gz, gx) in {[(gzs[p], gxs[p]) for p in params]}")
thetas, loss, accepted = optimize(params, max_iter=100, L=5, pick_optimizer="cobyla")
thetass[i], losss[i] = thetas, loss
plt.plot(loss)
cost = run_inference(thetas)
costs[i] = cost
np.savez("data/" + name + "_thetas-loss-cost_cobyla", losss = losss, costs = costs, thetass = thetass)
for i,params in enumerate(paramss):
print(f"{i+1} / {len(paramss)} - params (gz, gx) in {[(gzs[p], gxs[p]) for p in params]}")
plot_result(np.load("data/" + name + "_thetas-loss-cost_cobyla.npz",allow_pickle=True)["costs"][i])
plt.show()
|
https://github.com/ElePT/qiskit-algorithms-test
|
ElePT
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2022.
#
# 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.
"""
Base state fidelity interface
"""
from __future__ import annotations
from abc import ABC, abstractmethod
from collections.abc import Sequence, Mapping
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit import ParameterVector
from ..algorithm_job import AlgorithmJob
from .state_fidelity_result import StateFidelityResult
class BaseStateFidelity(ABC):
r"""
An interface to calculate state fidelities (state overlaps) for pairs of
(parametrized) quantum circuits. The calculation depends on the particular
fidelity method implementation, but can be always 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.
"""
def __init__(self) -> None:
# use cache for preventing unnecessary circuit compositions
self._circuit_cache: Mapping[tuple[int, int], QuantumCircuit] = {}
@staticmethod
def _preprocess_values(
circuits: QuantumCircuit | Sequence[QuantumCircuit],
values: Sequence[float] | Sequence[Sequence[float]] | None = None,
) -> Sequence[Sequence[float]]:
"""
Checks whether the passed values match the shape of the parameters
of the corresponding circuits and formats values to 2D list.
Args:
circuits: List of circuits to be checked.
values: Parameter values corresponding to the circuits to be checked.
Returns:
A 2D value list if the values match the circuits, or an empty 2D list
if values is None.
Raises:
ValueError: if the number of parameter values doesn't match the number of
circuit parameters
TypeError: if the input values are not a sequence.
"""
if isinstance(circuits, QuantumCircuit):
circuits = [circuits]
if values is None:
for circuit in circuits:
if circuit.num_parameters != 0:
raise ValueError(
f"`values` cannot be `None` because circuit <{circuit.name}> has "
f"{circuit.num_parameters} free parameters."
)
return [[]]
else:
# Support ndarray
if isinstance(values, np.ndarray):
values = values.tolist()
if len(values) > 0 and isinstance(values[0], np.ndarray):
values = [v.tolist() for v in values]
if not isinstance(values, Sequence):
raise TypeError(
f"Expected a sequence of numerical parameter values, "
f"but got input type {type(values)} instead."
)
# ensure 2d
if len(values) > 0 and not isinstance(values[0], Sequence) or len(values) == 0:
values = [values]
return values
def _check_qubits_match(self, circuit_1: QuantumCircuit, circuit_2: QuantumCircuit) -> None:
"""
Checks that the number of qubits of 2 circuits matches.
Args:
circuit_1: (Parametrized) quantum circuit.
circuit_2: (Parametrized) quantum circuit.
Raises:
ValueError: when ``circuit_1`` and ``circuit_2`` don't have the
same number of qubits.
"""
if circuit_1.num_qubits != circuit_2.num_qubits:
raise ValueError(
f"The number of qubits for the first circuit ({circuit_1.num_qubits}) "
f"and second circuit ({circuit_2.num_qubits}) are not the same."
)
@abstractmethod
def create_fidelity_circuit(
self, circuit_1: QuantumCircuit, circuit_2: QuantumCircuit
) -> QuantumCircuit:
"""
Implementation-dependent method to create a fidelity circuit
from 2 circuit inputs.
Args:
circuit_1: (Parametrized) quantum circuit.
circuit_2: (Parametrized) quantum circuit.
Returns:
The fidelity quantum circuit corresponding to ``circuit_1`` and ``circuit_2``.
"""
raise NotImplementedError
def _construct_circuits(
self,
circuits_1: QuantumCircuit | Sequence[QuantumCircuit],
circuits_2: QuantumCircuit | Sequence[QuantumCircuit],
) -> Sequence[QuantumCircuit]:
"""
Constructs the list of fidelity circuits to be evaluated.
These circuits represent the state overlap between pairs of input circuits,
and their construction depends on the fidelity method implementations.
Args:
circuits_1: (Parametrized) quantum circuits.
circuits_2: (Parametrized) quantum circuits.
Returns:
List of constructed fidelity circuits.
Raises:
ValueError: if the length of the input circuit lists doesn't match.
"""
if isinstance(circuits_1, QuantumCircuit):
circuits_1 = [circuits_1]
if isinstance(circuits_2, QuantumCircuit):
circuits_2 = [circuits_2]
if len(circuits_1) != len(circuits_2):
raise ValueError(
f"The length of the first circuit list({len(circuits_1)}) "
f"and second circuit list ({len(circuits_2)}) is not the same."
)
circuits = []
for (circuit_1, circuit_2) in zip(circuits_1, circuits_2):
# TODO: improve caching, what if the circuit is modified without changing the id?
circuit = self._circuit_cache.get((id(circuit_1), id(circuit_2)))
if circuit is not None:
circuits.append(circuit)
else:
self._check_qubits_match(circuit_1, circuit_2)
# re-parametrize input circuits
# TODO: make smarter checks to avoid unnecesary reparametrizations
parameters_1 = ParameterVector("x", circuit_1.num_parameters)
parametrized_circuit_1 = circuit_1.assign_parameters(parameters_1)
parameters_2 = ParameterVector("y", circuit_2.num_parameters)
parametrized_circuit_2 = circuit_2.assign_parameters(parameters_2)
circuit = self.create_fidelity_circuit(
parametrized_circuit_1, parametrized_circuit_2
)
circuits.append(circuit)
# update cache
self._circuit_cache[id(circuit_1), id(circuit_2)] = circuit
return circuits
def _construct_value_list(
self,
circuits_1: Sequence[QuantumCircuit],
circuits_2: Sequence[QuantumCircuit],
values_1: Sequence[float] | Sequence[Sequence[float]] | None = None,
values_2: Sequence[float] | Sequence[Sequence[float]] | None = None,
) -> list[float]:
"""
Preprocesses input parameter values to match the fidelity
circuit parametrization, and return in list format.
Args:
circuits_1: (Parametrized) quantum circuits preparing the
first list of quantum states.
circuits_2: (Parametrized) quantum circuits preparing the
second list of quantum states.
values_1: Numerical parameters to be bound to the first circuits.
values_2: Numerical parameters to be bound to the second circuits.
Returns:
List of parameter values for fidelity circuit.
"""
values_1 = self._preprocess_values(circuits_1, values_1)
values_2 = self._preprocess_values(circuits_2, values_2)
values = []
if len(values_2[0]) == 0:
values = list(values_1)
elif len(values_1[0]) == 0:
values = list(values_2)
else:
for (val_1, val_2) in zip(values_1, values_2):
values.append(val_1 + val_2)
return values
@abstractmethod
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).
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 set of circuits
values_2: Numerical parameters to be bound to the second set of 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.
"""
raise NotImplementedError
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,
) -> AlgorithmJob:
r"""
Runs asynchronously the state overlap (fidelity) calculation between two
(parametrized) circuits (first and second) for a specific set of parameter
values (first and second). This calculation depends on the particular
fidelity method implementation.
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 set of circuits.
values_2: Numerical parameters to be bound to the second set of 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:
Primitive job for the fidelity calculation.
The job's result is an instance of ``StateFidelityResult``.
"""
job = AlgorithmJob(self._run, circuits_1, circuits_2, values_1, values_2, **options)
job.submit()
return job
def _truncate_fidelities(self, fidelities: Sequence[float]) -> Sequence[float]:
"""
Ensures fidelity result in [0,1].
Args:
fidelities: Sequence of raw fidelity results.
Returns:
List of truncated fidelities.
"""
return np.clip(fidelities, 0, 1).tolist()
|
https://github.com/tanvipenumudy/Quantum-Computing-Mini-Projects
|
tanvipenumudy
|
pip install qiskit
import numpy as np
import matplotlib.pyplot as plt
import torch
from torch.autograd import Function
from torchvision import datasets, transforms
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
import qiskit
from qiskit.visualization import *
class QuantumCircuit:
"""
This class provides a simple interface for interaction
with the quantum circuit
"""
def __init__(self, n_qubits, backend, shots):
# --- Circuit definition ---
self._circuit = qiskit.QuantumCircuit(n_qubits)
all_qubits = [i for i in range(n_qubits)]
self.theta = qiskit.circuit.Parameter('theta')
self._circuit.h(all_qubits)
self._circuit.barrier()
self._circuit.ry(self.theta, all_qubits)
self._circuit.measure_all()
# ---------------------------
self.backend = backend
self.shots = shots
def run(self, thetas):
job = qiskit.execute(self._circuit,
self.backend,
shots = self.shots,
parameter_binds = [{self.theta: theta} for theta in thetas])
result = job.result().get_counts(self._circuit)
counts = np.array(list(result.values()))
states = np.array(list(result.keys())).astype(float)
# Compute probabilities for each state
probabilities = counts / self.shots
# Get state expectation
expectation = np.sum(states * probabilities)
return np.array([expectation])
simulator = qiskit.Aer.get_backend('qasm_simulator')
circuit = QuantumCircuit(1, simulator, 100)
print('Expected value for rotation pi {}'.format(circuit.run([np.pi])[0]))
circuit._circuit.draw()
class HybridFunction(Function):
""" Hybrid quantum - classical function definition """
@staticmethod
def forward(ctx, input, quantum_circuit, shift):
""" Forward pass computation """
ctx.shift = shift
ctx.quantum_circuit = quantum_circuit
expectation_z = ctx.quantum_circuit.run(input[0].tolist())
result = torch.tensor([expectation_z])
ctx.save_for_backward(input, result)
return result
@staticmethod
def backward(ctx, grad_output):
""" Backward pass computation """
input, expectation_z = ctx.saved_tensors
input_list = np.array(input.tolist())
shift_right = input_list + np.ones(input_list.shape) * ctx.shift
shift_left = input_list - np.ones(input_list.shape) * ctx.shift
gradients = []
for i in range(len(input_list)):
expectation_right = ctx.quantum_circuit.run(shift_right[i])
expectation_left = ctx.quantum_circuit.run(shift_left[i])
gradient = torch.tensor([expectation_right]) - torch.tensor([expectation_left])
gradients.append(gradient)
gradients = np.array([gradients]).T
return torch.tensor([gradients]).float() * grad_output.float(), None, None
class Hybrid(nn.Module):
""" Hybrid quantum - classical layer definition """
def __init__(self, backend, shots, shift):
super(Hybrid, self).__init__()
self.quantum_circuit = QuantumCircuit(1, backend, shots)
self.shift = shift
def forward(self, input):
return HybridFunction.apply(input, self.quantum_circuit, self.shift)
# Concentrating on the first 100 samples
n_samples = 100
X_train = datasets.MNIST(root='./data', train=True, download=True,
transform=transforms.Compose([transforms.ToTensor()]))
# Leaving only labels 0 and 1
idx = np.append(np.where(X_train.targets == 0)[0][:n_samples],
np.where(X_train.targets == 1)[0][:n_samples])
X_train.data = X_train.data[idx]
X_train.targets = X_train.targets[idx]
train_loader = torch.utils.data.DataLoader(X_train, batch_size=1, shuffle=True)
n_samples_show = 6
data_iter = iter(train_loader)
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 3))
while n_samples_show > 0:
images, targets = data_iter.__next__()
axes[n_samples_show - 1].imshow(images[0].numpy().squeeze(), cmap='gray')
axes[n_samples_show - 1].set_xticks([])
axes[n_samples_show - 1].set_yticks([])
axes[n_samples_show - 1].set_title("Labeled: {}".format(targets.item()))
n_samples_show -= 1
n_samples = 50
X_test = datasets.MNIST(root='./data', train=False, download=True,
transform=transforms.Compose([transforms.ToTensor()]))
idx = np.append(np.where(X_test.targets == 0)[0][:n_samples],
np.where(X_test.targets == 1)[0][:n_samples])
X_test.data = X_test.data[idx]
X_test.targets = X_test.targets[idx]
test_loader = torch.utils.data.DataLoader(X_test, batch_size=1, shuffle=True)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 6, kernel_size=5)
self.conv2 = nn.Conv2d(6, 16, kernel_size=5)
self.dropout = nn.Dropout2d()
self.fc1 = nn.Linear(256, 64)
self.fc2 = nn.Linear(64, 1)
self.hybrid = Hybrid(qiskit.Aer.get_backend('qasm_simulator'), 100, np.pi / 2)
def forward(self, x):
x = F.relu(self.conv1(x))
x = F.max_pool2d(x, 2)
x = F.relu(self.conv2(x))
x = F.max_pool2d(x, 2)
x = self.dropout(x)
x = x.view(1, -1)
x = F.relu(self.fc1(x))
x = self.fc2(x)
x = self.hybrid(x)
return torch.cat((x, 1 - x), -1)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 20
loss_list = []
model.train()
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
loss = loss_func(output, target)
# Backward pass
loss.backward()
# Optimize the weights
optimizer.step()
total_loss.append(loss.item())
loss_list.append(sum(total_loss)/len(total_loss))
print('Training [{:.0f}%]\tLoss: {:.4f}'.format(
100. * (epoch + 1) / epochs, loss_list[-1]))
plt.plot(loss_list)
plt.title('Hybrid NN Training Convergence')
plt.xlabel('Training Iterations')
plt.ylabel('Neg Log Likelihood Loss')
model.eval()
with torch.no_grad():
correct = 0
for batch_idx, (data, target) in enumerate(test_loader):
output = model(data)
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
loss = loss_func(output, target)
total_loss.append(loss.item())
print('Performance on test data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
n_samples_show = 6
count = 0
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 3))
model.eval()
with torch.no_grad():
for batch_idx, (data, target) in enumerate(test_loader):
if count == n_samples_show:
break
output = model(data)
pred = output.argmax(dim=1, keepdim=True)
axes[count].imshow(data[0].numpy().squeeze(), cmap='gray')
axes[count].set_xticks([])
axes[count].set_yticks([])
axes[count].set_title('Predicted {}'.format(pred.item()))
count += 1
|
https://github.com/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, test_loader):
all_preds = torch.tensor([])
for batch in test_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)
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 = 20
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+1, loss_list[epoch], 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 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.001)
loss_func = nn.NLLLoss()
epochs = 30
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+1, loss_list[epoch], 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 test data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
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(20, 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.max_pool2d(x, 2) #Added layer
x = F.relu(self.conv2(x))
x = self.dropout(x) #Added layer
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+1, loss_list[epoch], 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 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.001)
loss_func = nn.NLLLoss()
epochs = 20
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+1, loss_list[epoch], 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 test data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
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(20, 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.max_pool2d(x, 2)
x = F.relu(self.conv2(x))
x = self.dropout(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1) #Added layer
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+1, loss_list[epoch], 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)
)
%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 = 20
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+1, loss_list[epoch], 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 test data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
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(20, 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.max_pool2d(x, 2)
x = F.relu(self.conv2(x))
x = self.dropout(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1) #Added layer
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+1, loss_list[epoch], 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 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.001)
loss_func = nn.NLLLoss()
epochs = 20
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+1, loss_list[epoch], 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 test data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
|
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/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!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/Tojarieh97/VQE
|
Tojarieh97
|
import numpy as np
def get_first_k_eigenvectors_from_n_computational_basis(k, n):
n_computational_basis = np.identity(n)
return n_computational_basis[:k]
|
https://github.com/GIRISHBELANI/QC_Benchmarks_using_dm-simulator
|
GIRISHBELANI
|
"""
Quantum Fourier Transform Benchmark Program - QSim
"""
import math
import sys
import time
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
sys.path[1:1] = [ "_common", "_common/qsim" ]
sys.path[1:1] = [ "../../_common", "../../_common/qsim" ]
import execute as ex
import metrics as metrics
from qiskit.circuit.library import QFT
from execute import BenchmarkResult
# Benchmark Name
benchmark_name = "Quantum Fourier Transform"
np.random.seed(0)
verbose = False
# saved circuits for display
num_gates = 0
depth = 0
QC_ = None
QFT_ = None
QFTI_ = None
############### Circuit Definition
def QuantumFourierTransform (num_qubits, secret_int, method=1):
global num_gates, depth
# Size of input is one less than available qubits
input_size = num_qubits
num_gates = 0
depth = 0
# allocate qubits
qr = QuantumRegister(num_qubits); cr = ClassicalRegister(num_qubits);
qc = QuantumCircuit(qr, cr, name=f"qft({method})-{num_qubits}-{secret_int}")
if method==1:
# Perform X on each qubit that matches a bit in secret string
s = ('{0:0'+str(input_size)+'b}').format(secret_int)
for i_qubit in range(input_size):
if s[input_size-1-i_qubit]=='1':
qc.x(qr[i_qubit])
num_gates += 1
depth += 1
qc.barrier()
# perform QFT on the input
qc.append(qft_gate(input_size).to_instruction(), qr)
# End with Hadamard on all qubits (to measure the z rotations)
''' don't do this unless NOT doing the inverse afterwards
for i_qubit in range(input_size):
qc.h(qr[i_qubit])
qc.barrier()
'''
qc.barrier()
# some compilers recognize the QFT and IQFT in series and collapse them to identity;
# perform a set of rotations to add one to the secret_int to avoid this collapse
for i_q in range(0, num_qubits):
divisor = 2 ** (i_q)
qc.rz( 1 * math.pi / divisor , qr[i_q])
num_gates+=1
qc.barrier()
# to revert back to initial state, apply inverse QFT
qc.append(inv_qft_gate(input_size).to_instruction(), qr)
qc.barrier()
elif method == 2:
for i_q in range(0, num_qubits):
qc.h(qr[i_q])
num_gates += 1
for i_q in range(0, num_qubits):
divisor = 2 ** (i_q)
qc.rz(secret_int * math.pi / divisor, qr[i_q])
num_gates += 1
depth += 1
qc.append(inv_qft_gate(input_size).to_instruction(), qr)
# This method is a work in progress
elif method==3:
for i_q in range(0, secret_int):
qc.h(qr[i_q])
num_gates+=1
for i_q in range(secret_int, num_qubits):
qc.x(qr[i_q])
num_gates+=1
depth += 1
qc.append(inv_qft_gate(input_size).to_instruction(), qr)
else:
exit("Invalid QFT method")
# measure all qubits
qc.measure(qr, cr)
num_gates += num_qubits
depth += 1
# save smaller circuit example for display
global QC_
if QC_ == None or num_qubits <= 5:
if num_qubits < 9: QC_ = qc
# return a handle on the circuit
return qc
############### QFT Circuit
def qft_gate(input_size):
global QFT_, num_gates, depth
qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="qft")
# Generate multiple groups of diminishing angle CRZs and H gate
for i_qubit in range(0, input_size):
# start laying out gates from highest order qubit (the hidx)
hidx = input_size - i_qubit - 1
# if not the highest order qubit, add multiple controlled RZs of decreasing angle
if hidx < input_size - 1:
num_crzs = i_qubit
for j in range(0, num_crzs):
divisor = 2 ** (num_crzs - j)
qc.crz( math.pi / divisor , qr[hidx], qr[input_size - j - 1])
num_gates += 1
depth += 1
# followed by an H gate (applied to all qubits)
qc.h(qr[hidx])
num_gates += 1
depth += 1
qc.barrier()
if QFT_ == None or input_size <= 5:
if input_size < 9: QFT_ = qc
return qc
############### Inverse QFT Circuit
def inv_qft_gate(input_size):
global QFTI_, num_gates, depth
qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="inv_qft")
# Generate multiple groups of diminishing angle CRZs and H gate
for i_qubit in reversed(range(0, input_size)):
# start laying out gates from highest order qubit (the hidx)
hidx = input_size - i_qubit - 1
# precede with an H gate (applied to all qubits)
qc.h(qr[hidx])
num_gates += 1
depth += 1
# if not the highest order qubit, add multiple controlled RZs of decreasing angle
if hidx < input_size - 1:
num_crzs = i_qubit
for j in reversed(range(0, num_crzs)):
divisor = 2 ** (num_crzs - j)
qc.crz( -math.pi / divisor , qr[hidx], qr[input_size - j - 1])
num_gates += 1
depth += 1
qc.barrier()
if QFTI_ == None or input_size <= 5:
if input_size < 9: QFTI_= qc
return qc
# Define expected distribution calculated from applying the iqft to the prepared secret_int state
def expected_dist(num_qubits, secret_int, probs):
dist = {}
s = num_qubits - secret_int
for key in probs.keys():
if key[(num_qubits-secret_int):] == ''.zfill(secret_int):
dist[key] = 1/(2**s)
return dist
############### Result Data Analysis
# Analyze and print measured results
def analyze_and_print_result (qc, result, num_qubits, secret_int, num_shots, method):
# obtain probs from the result object
if result.backend_name == 'dm_simulator':
benchmark_result = BenchmarkResult(result, num_shots)
probs = benchmark_result.get_probs(num_shots) # get results as measured probability
else:
probs = result.get_counts(qc) # get results as measured counts
# For method 1, expected result is always the secret_int
if method==1:
# add one to the secret_int to compensate for the extra rotations done between QFT and IQFT
secret_int_plus_one = (secret_int + 1) % (2 ** num_qubits)
# create the key that is expected to have all the measurements (for this circuit)
key = format(secret_int_plus_one, f"0{num_qubits}b")
# correct distribution is measuring the key 100% of the time
correct_dist = {key: 1.0}
# For method 2, expected result is always the secret_int
elif method==2:
# create the key that is expected to have all the measurements (for this circuit)
key = format(secret_int, f"0{num_qubits}b")
# correct distribution is measuring the key 100% of the time
correct_dist = {key: 1.0}
# For method 3, correct_dist is a distribution with more than one value
elif method==3:
# correct_dist is from the expected dist
correct_dist = expected_dist(num_qubits, secret_int, probs)
# use our polarization fidelity rescaling
fidelity = metrics.polarization_fidelity(probs, correct_dist)
if verbose: print(f"For secret int {secret_int} measured: {probs} fidelity: {fidelity}")
return probs, fidelity
################ Benchmark Loop
# Execute program with default parameters
def run (min_qubits = 2, max_qubits = 8, max_circuits = 3, skip_qubits=1, num_shots = 100,
method=1,
backend_id='dm_simulator', provider_backend=None,
#hub="ibm-q", group="open", project="main",
exec_options=None,
context=None):
print(f"{benchmark_name} ({method}) Benchmark Program - QSim")
# validate parameters (smallest circuit is 2 qubits)
max_qubits = max(2, max_qubits)
min_qubits = min(max(2, min_qubits), max_qubits)
skip_qubits = max(1, skip_qubits)
#print(f"min, max qubits = {min_qubits} {max_qubits}")
# create context identifier
if context is None: context = f"{benchmark_name} ({method}) Benchmark"
##########
# Initialize metrics module
metrics.init_metrics()
# Define custom result handler
def execution_handler (qc, result, input_size, s_int, num_shots):
# determine fidelity of result set
num_qubits = int(input_size)
probs, fidelity = analyze_and_print_result(qc, result, num_qubits, int(s_int), num_shots, method)
metrics.store_metric(input_size, s_int, 'fidelity', fidelity)
# Initialize execution module using the execution result handler above and specified backend_id
ex.init_execution(execution_handler)
ex.set_execution_target(backend_id, provider_backend=provider_backend,
#hub=hub, group=group, project=project,
exec_options=exec_options,
context=context)
##########
# Execute Benchmark Program N times for multiple circuit sizes
# Accumulate metrics asynchronously as circuits complete
for input_size in range(min_qubits, max_qubits + 1, skip_qubits):
# reset random seed
np.random.seed(0)
num_qubits = input_size
# determine number of circuits to execute for this group
# and determine range of secret strings to loop over
if method == 1 or method == 2:
num_circuits = min(2 ** (input_size), max_circuits)
if 2**(input_size) <= max_circuits:
s_range = list(range(num_circuits))
else:
s_range = np.random.choice(2**(input_size), num_circuits, False)
elif method == 3:
num_circuits = min(input_size, max_circuits)
if input_size <= max_circuits:
s_range = list(range(num_circuits))
else:
s_range = np.random.choice(range(input_size), num_circuits, False)
else:
sys.exit("Invalid QFT method")
print(f"************\nExecuting [{num_circuits}] circuits with num_qubits = {num_qubits}")
# loop over limited # of secret strings for this
for s_int in s_range:
# create the circuit for given qubit size and secret string, store time metric
ts = time.time()
qc = QuantumFourierTransform(num_qubits, s_int, method=method).reverse_bits()
metrics.store_metric(input_size, s_int, 'create_time', time.time()-ts)
# collapse the sub-circuits used in this benchmark (for qiskit)
qc2 = qc.decompose()
# submit circuit for execution on target (simulator, cloud simulator, or hardware)
ex.submit_circuit(qc2, input_size, s_int, num_shots)
print(f"... number of gates, depth = {num_gates}, {depth}")
# Wait for some active circuits to complete; report metrics when groups complete
ex.throttle_execution(metrics.finalize_group)
# Wait for all active circuits to complete; report metrics when groups complete
ex.finalize_execution(metrics.finalize_group)
##########
# print a sample circuit created (if not too large)
print("Sample Circuit:"); print(QC_ if QC_ != None else " ... too large!")
if method==1:
print("\nQFT Circuit ="); print(QFT_)
print("\nInverse QFT Circuit ="); print(QFTI_)
# Plot metrics for all circuit sizes
metrics.plot_metrics(f"Benchmark Results - {benchmark_name} ({method}) - QSim")
# if main, execute method 1
if __name__ == '__main__':
ex.local_args() # calling local_args() needed while taking noise parameters through command line arguments (for individual benchmarks)
run()
|
https://github.com/wyqian1027/Qiskit-Fall-Fest-USC-2022
|
wyqian1027
|
import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_bloch_multivector, array_to_latex
##### DO NOT CHANGE THIS CODE #######
# This is used to help you check if your exercises are correct and allow you to keep track
# of your progress. Modifying this can make the system fail.
ex_correct_dict = {'ex1': False, 'ex2': False, 'ex3': False, 'ex4': False, 'ex5': False,
'ex6': False, 'ex7': False}
def language(x):
global ESP
ESP = x
def correction_announcer(x):
if ESP:
if x:
print('¡La respuesta es correcta! :) \n¡Te llevas un MAPI!')
else:
print('La respuesta es incorrecta :(')
else:
if x:
print('Your answer is correct! :)')
else:
print('Your answer is incorrect :(')
def ex1_grader(qc):
from qiskit.quantum_info import Statevector
state_vector_solution = Statevector(qc)
state_vector_real = Statevector((1./np.sqrt(2))*np.array([1., 0., 0., -1.]))
if state_vector_solution==state_vector_real or state_vector_solution==-state_vector_real:
ex_correct_dict['ex1'] = True
correction_announcer(True)
else:
correction_announcer(False)
def ex2_grader(qc):
from qiskit.quantum_info import Statevector
state_vector_solution = Statevector(qc)
state_vector_real = Statevector((1./np.sqrt(2))*np.array([0., 1., 1., 0.]))
if state_vector_solution==state_vector_real or state_vector_solution==-state_vector_real:
ex_correct_dict['ex2'] = True
correction_announcer(True)
else:
correction_announcer(False)
def ex3_grader(qc):
from qiskit.quantum_info import Statevector
state_vector_solution = Statevector(qc)
state_vector_real = Statevector((1./np.sqrt(2))*np.array([0., 1., -1., 0.]))
if state_vector_solution==state_vector_real or state_vector_solution==-state_vector_real:
ex_correct_dict['ex3'] = True
correction_announcer(True)
else:
correction_announcer(False)
def ex4_grader(qc):
from qiskit.quantum_info import Statevector
state_vector_solution = Statevector(qc)
state_vector_real = Statevector((1./np.sqrt(2))*np.array([1., 0., 0., 0., 0., 0., 0., 1.]))
if state_vector_solution==state_vector_real or state_vector_solution==-state_vector_real:
ex_correct_dict['ex4'] = True
correction_announcer(True)
else:
correction_announcer(False)
def ex5_grader(qc):
from qiskit.quantum_info import Statevector
state_vector_solution = Statevector(qc)
state_vector_real = Statevector((1./2.)*np.array([1., 0., 0., 1., 0., 1., 1., 0.]))
if state_vector_solution==state_vector_real or state_vector_solution==-state_vector_real:
ex_correct_dict['ex5'] = True
correction_announcer(True)
else:
correction_announcer(False)
def ex6_grader(qc):
from qiskit.quantum_info import Statevector
state_vector_solution = Statevector(qc)
state_vector_real = Statevector((1./2.)*np.array([0., 1., 1., 0., 1., 0., 0., 1.]))
if state_vector_solution==state_vector_real or state_vector_solution==-state_vector_real:
ex_correct_dict['ex6'] = True
correction_announcer(True)
else:
correction_announcer(False)
def ex7_grader(fun):
from qiskit.quantum_info import Statevector
qc = QuantumCircuit(1, 1)
qc.h(0)
fun(qc, 0, 0)
backend_shots = Aer.get_backend('qasm_simulator', shots = 1024)
result = execute(qc, backend_shots).result().get_counts()
if result['0'] == 1024:
qc = QuantumCircuit(1, 1)
qc.x(0)
qc.h(0)
fun(qc, 0, 0)
result = execute(qc, backend_shots).result().get_counts()
if result['1'] == 1024:
ex_correct_dict['ex7'] = True
correction_announcer(True)
else:
correction_announcer(False)
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
!pip install tabulate
%matplotlib inline
# 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 *
from tabulate import tabulate
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
#Get the library to check the answers
%pip install -I git+https://github.com/mnp-club/MnP_QC_Workshop.git
from mnp_qc_workshop_2020.discrete_logarithm import qft_dagger, oracle, check_answer
n_qubits = 3 #Number of qubits for the registers of |x1> and |x2>
#For figuring out you would just need 2*n_qubits classical bits
qc_disc_log = QuantumCircuit(4+n_qubits+n_qubits, n_qubits+n_qubits)
for i in range(2*n_qubits):
qc_disc_log.h(i)
qc_disc_log.x(9)
qc_disc_log.append(oracle(), range(10))
qc_disc_log.append(qft_dagger(3), range(3))
qc_disc_log.append(qft_dagger(3) ,[3,4,5])
qc_disc_log.measure(range(2*n_qubits), range(2*n_qubits))
qc_disc_log.draw('text')
backend = Aer.get_backend('qasm_simulator')
results = execute(qc_disc_log, backend, shots=8192).result()
counts = results.get_counts()
plot_histogram(counts)
rows_x_1, eigenvalues_x_1 = [], []
for output in counts:
decimal = int(output, 2)//8
eigenvalue = decimal/(2**3)
eigenvalues_x_1.append(eigenvalue)
rows_x_1.append(["%s(bin) = %i(dec)" % (output[0:3], decimal), "%i/%i = %.2f" % (decimal, 2**3, eigenvalue)])
print(tabulate(rows_x_1, headers=["Register Output", "Phase"]))
rows_x_2, eigenvalues_x_2 = [], []
for output in counts:
decimal = int(output, 2) - ((int(output, 2)//8)*8)
eigenvalue = decimal/(2**3)
eigenvalues_x_2.append(eigenvalue)
rows_x_2.append(["%s(bin) = %i(dec)" % (output[3:6], decimal), "%i/%i = %.2f" % (decimal, 2**3, eigenvalue)])
print(tabulate(rows_x_2, headers=["Register Output", "Phase"]))
#Store your value for s here
s = 3
#Do analysis of oracle here
qc = QuantumCircuit(10, 4)
qc.x(0)
qc.x(9)
qc.append(oracle(), range(10))
qc.measure([6,7,8,9], range(4))
backend = Aer.get_backend('qasm_simulator')
results = execute(qc, backend, shots=8192).result()
counts = results.get_counts()
plot_histogram(counts)
# On x1=1, ans = 2 and on x2=1, ans = 8
#Store values of a and b here
a, b = 2, 8
check_answer(s,a,b)
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
import numpy as np
from mitiq import cdr, Observable, PauliString, Executor
import cirq
from cirq.contrib.qasm_import import circuit_from_qasm
from cirq.circuits.qasm_output import QasmUGate
from qiskit import *
from qiskit import transpile, assemble, IBMQ
from qiskit.visualization import *
from qiskit import Aer, QuantumCircuit
from qiskit.circuit import ParameterVector
pi = np.pi
feature_dim = 2
reps = 2
duplicates = 1
feature_map_circuit = QuantumCircuit(feature_dim, name='feature_map_circuit')
# x = ParameterVector('x', feature_dim * reps)
x = [0.1, 0.2]
for i in range(reps):
for i in range(feature_dim):
feature_map_circuit.h(i)
feature_map_circuit.rz(2.0*x[0], 0)
feature_map_circuit.rz(2.0*x[1], 1)
feature_map_circuit.cnot(0, 1)
feature_map_circuit.rz(2.0*(pi - x[0])*(pi - x[1]), 1)
feature_map_circuit.cnot(0, 1)
feature_map_circuit.draw()
qasm_feature_map = feature_map_circuit.qasm(filename='feature_map.qasm')
print(qasm_feature_map)
cirq_feature_map = circuit_from_qasm(qasm_feature_map)
cirq_3_feature_map = cirq_feature_map * 3
print(cirq_3_feature_map)
from mitiq.interface.mitiq_cirq import compute_density_matrix
compute_density_matrix(cirq_feature_map).round(3)
obs = Observable(PauliString("ZZ"))
print(obs)
def simulate(circuit: cirq.Circuit) -> np.ndarray:
return compute_density_matrix(circuit, noise_level=(0.0,))
simulate(cirq_feature_map).round(3)
ideal_measurement = obs.expectation(cirq_feature_map, simulate).real
print("ideal_measurement = ",ideal_measurement)
unmitigated_measurement = obs.expectation(cirq_feature_map, compute_density_matrix).real
print("unmitigated_measurement = ", unmitigated_measurement)
mitigated_measurement = cdr.execute_with_cdr(
cirq_feature_map,
compute_density_matrix,
observable=obs,
simulator=simulate,
seed=0,
).real
print("mitigated_measurement = ", mitigated_measurement)
from mitiq.zne import scaling
vncdr = cdr.execute_with_cdr(
cirq_feature_map,
compute_density_matrix,
observable=obs,
simulator=simulate,
seed=0,
scale_factors=(1.0, 3.0),
).real
print("vncdr = ", vncdr)
error_unmitigated = abs(unmitigated_measurement-ideal_measurement)
error_mitigated = abs(mitigated_measurement-ideal_measurement)
error_vn_mitigated = abs(vncdr-ideal_measurement)
print("Error (unmitigated):", error_unmitigated)
print("Error (mitigated with CDR):", error_mitigated)
print("Error (mitigated with VNCDR):", error_vn_mitigated)
print("Relative error (unmitigated):", (error_unmitigated/ideal_measurement))
print("Relative error (mitigated with CDR):",
error_mitigated/ideal_measurement)
print("Relative error (mitigated with VNCDR):",
error_vn_mitigated/ideal_measurement)
print(
f"Error reduction with CDR: {(error_unmitigated-error_mitigated)/error_unmitigated :.1%}.")
print(
f"Error reduction with VNCDR: {(error_unmitigated-error_vn_mitigated)/error_unmitigated :.1%}.")
num_qubits = 2
ansatz_circuit = QuantumCircuit(num_qubits, name='ansatz_circuit')
reps = 1
# params = ParameterVector('θ', num_qubits + num_qubits * reps)
params = [0.7, 0.3, 0.5, 1.2]
counter = 0
for i in range(num_qubits):
ansatz_circuit.ry(params[counter], i)
counter += 1
for j in range(reps):
for k in range(num_qubits-1):
ansatz_circuit.cnot(k, k+1)
for m in range(num_qubits):
ansatz_circuit.ry(params[counter], m)
counter += 1
ansatz_circuit.draw()
qasm_ansatz = ansatz_circuit.qasm(filename='ansatz.qasm')
print(qasm_ansatz)
cirq_ansatz = circuit_from_qasm(qasm_ansatz) * 1
print(cirq_ansatz)
compute_density_matrix(cirq_ansatz).round(3)
simulate(cirq_ansatz).round(3)
ideal_measurement = obs.expectation(cirq_ansatz, simulate).real
print("ideal_measurement = ",ideal_measurement)
unmitigated_measurement = obs.expectation(cirq_ansatz, compute_density_matrix).real
print("unmitigated_measurement = ", unmitigated_measurement)
mitigated_measurement = cdr.execute_with_cdr(
cirq_ansatz,
compute_density_matrix,
observable=obs,
simulator=simulate,
seed=0,
).real
print("mitigated_measurement = ", mitigated_measurement)
from mitiq.zne import scaling
vncdr = cdr.execute_with_cdr(
cirq_ansatz,
compute_density_matrix,
observable=obs,
simulator=simulate,
seed=0,
scale_factors=(1.0, 3.0),
).real
print("vncdr = ", vncdr)
error_unmitigated = abs(unmitigated_measurement-ideal_measurement)
error_mitigated = abs(mitigated_measurement-ideal_measurement)
error_vn_mitigated = abs(vncdr-ideal_measurement)
print("Error (unmitigated):", error_unmitigated)
print("Error (mitigated with CDR):", error_mitigated)
print("Error (mitigated with VNCDR):", error_vn_mitigated)
print("Relative error (unmitigated):", (error_unmitigated/ideal_measurement))
print("Relative error (mitigated with CDR):",
error_mitigated/ideal_measurement)
print("Relative error (mitigated with VNCDR):",
error_vn_mitigated/ideal_measurement)
print(
f"Error reduction with CDR: {(error_unmitigated-error_mitigated)/error_unmitigated :.1%}.")
print(
f"Error reduction with VNCDR: {(error_unmitigated-error_vn_mitigated)/error_unmitigated :.1%}.")
|
https://github.com/qiskit-community/qopt-best-practices
|
qiskit-community
|
from networkx import barabasi_albert_graph, draw
graph = barabasi_albert_graph(n=10, m=6, seed=42)
draw(graph, with_labels=True)
from qopt_best_practices.utils import build_max_cut_paulis
from qiskit.quantum_info import SparsePauliOp
local_correlators = build_max_cut_paulis(graph)
cost_operator = SparsePauliOp.from_list(local_correlators)
print(cost_operator)
# import json
# graph_file = "data/graph_2layers_0seed.json"
# data = json.load(open(graph_file, "r"))
# local_correlators = data["paulis"]
# print(local_correlators)
# cost_operator = SparsePauliOp.from_list(local_correlators)
num_qubits = cost_operator.num_qubits
print(num_qubits)
qaoa_layers = 3
from qiskit.providers.fake_provider import GenericBackendV2
from qiskit.transpiler import CouplingMap
cmap = CouplingMap.from_heavy_hex(distance=3)
print(cmap.size())
backend = GenericBackendV2(num_qubits = 19, coupling_map = cmap, basis_gates = ["x", "sx", "cz", "id", "rz"], seed=0)
from qiskit import QuantumCircuit
from qiskit.circuit.library import QAOAAnsatz
from qiskit.circuit import ParameterVector
# Initial state = equal superposition
initial_state = QuantumCircuit(num_qubits)
initial_state.h(range(num_qubits))
# Mixer operator = rx rotations
betas = ParameterVector("β", qaoa_layers)
mixer_operator = QuantumCircuit(num_qubits)
mixer_operator.rx(-2*betas[0], range(num_qubits))
# Use off-the-shelf qiskit QAOAAnsatz
qaoa_ansatz = QAOAAnsatz(
cost_operator,
initial_state = initial_state,
mixer_operator = mixer_operator,
reps = qaoa_layers,
)
qaoa_ansatz.measure_all()
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
naive_pm = generate_preset_pass_manager(backend=backend, optimization_level=3)
print(naive_pm.expanded_stages)
# naive_pm.draw()
print("init")
for task in naive_pm.init._tasks:
print(task)
print("----")
print("layout")
for task in naive_pm.layout._tasks:
print(task)
print("----")
print("routing")
for task in naive_pm.routing._tasks:
print(task)
print("----")
print("translation")
for task in naive_pm.translation._tasks:
print(task)
print("----")
print("optimization")
for task in naive_pm.optimization._tasks:
print(task)
print("----")
print("scheduling")
for task in naive_pm.scheduling._tasks:
print(task)
def callback_func(**kwargs):
pass_ = kwargs['pass_']
print(pass_)
import time
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
naive_pm = generate_preset_pass_manager(backend=backend, optimization_level=3)
t0 = time.time()
naively_transpiled_qaoa = naive_pm.run(qaoa_ansatz)
t1 = time.time()
print(f"transpilation time: {t1 - t0} (s)")
naively_transpiled_qaoa.count_ops()
naively_transpiled_qaoa.depth()
# We are taking advantage of the QAOAAnsatz class to build the cost layer,
# note that we are giving it dummy initial state and mixer circuits.
dummy_initial_state = QuantumCircuit(num_qubits) # the real initial state is defined later
dummy_mixer_operator = QuantumCircuit(num_qubits) # the real mixer is defined later
cost_layer = QAOAAnsatz(
cost_operator,
reps=1,
initial_state=dummy_initial_state,
mixer_operator=dummy_mixer_operator,
name="QAOA cost block",
)
cost_layer.draw("mpl", fold=-1)
cost_layer.decompose(reps=2).draw("mpl", fold=-1)
from qopt_best_practices.qubit_selection import BackendEvaluator
# The backend evaluator finds the line of qubits with the best fidelity to map the circuit to
path_finder = BackendEvaluator(backend)
path, fidelity, num_subsets = path_finder.evaluate(num_qubits)
print(path, fidelity)
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import (
BasisTranslator,
UnrollCustomDefinitions,
CommutativeCancellation,
Decompose,
CXCancellation,
HighLevelSynthesis,
InverseCancellation
)
from qiskit.transpiler.passes.routing.commuting_2q_gate_routing import (
SwapStrategy,
FindCommutingPauliEvolutions,
Commuting2qGateRouter,
)
from qiskit.circuit.library.standard_gates.equivalence_library import _sel
from qiskit.circuit.library import CXGate
# 1. choose swap strategy (in this case -> line)
swap_strategy = SwapStrategy.from_line([i for i in range(num_qubits)])
edge_coloring = {(idx, idx + 1): (idx + 1) % 2 for idx in range(num_qubits)}
# 2. define pass manager for cost layer
pre_init = PassManager(
[HighLevelSynthesis(basis_gates=['PauliEvolution']),
FindCommutingPauliEvolutions(),
Commuting2qGateRouter(
swap_strategy,
edge_coloring,
),
HighLevelSynthesis(basis_gates=["x", "cx", "sx", "rz", "id"]),
InverseCancellation(gates_to_cancel=[CXGate()]),
]
)
# Before:
print(cost_layer.decompose(reps=4).count_ops())
cost_layer.decompose(reps=4).draw("mpl", fold=-1)
tmp = pre_init.run(cost_layer)
# After:
print(tmp.count_ops())
tmp.draw('mpl', fold=-1)
from qiskit.transpiler.basepasses import TransformationPass
from qiskit.converters import circuit_to_dag, dag_to_circuit
class QAOAPass(TransformationPass):
def __init__(self, num_layers, num_qubits, init_state = None, mixer_layer = None):
super().__init__()
self.num_layers = num_layers
self.num_qubits = num_qubits
if init_state is None:
# Add default initial state -> equal superposition
self.init_state = QuantumCircuit(num_qubits)
self.init_state.h(range(num_qubits))
else:
self.init_state = init_state
if mixer_layer is None:
# Define default mixer layer
self.mixer_layer = QuantumCircuit(num_qubits)
self.mixer_layer.rx(-2*betas[0], range(num_qubits))
else:
self.mixer_layer = mixer_layer
def run(self, cost_layer_dag):
cost_layer = dag_to_circuit(cost_layer_dag)
qaoa_circuit = QuantumCircuit(self.num_qubits, self.num_qubits)
# Re-parametrize the circuit
gammas = ParameterVector("γ", self.num_layers)
betas = ParameterVector("β", self.num_layers)
# Add initial state
qaoa_circuit.compose(self.init_state, inplace = True)
# iterate over number of qaoa layers
# and alternate cost/reversed cost and mixer
for layer in range(self.num_layers):
bind_dict = {cost_layer.parameters[0]: gammas[layer]}
bound_cost_layer = cost_layer.assign_parameters(bind_dict)
bind_dict = {self.mixer_layer.parameters[0]: betas[layer]}
bound_mixer_layer = self.mixer_layer.assign_parameters(bind_dict)
if layer % 2 == 0:
# even layer -> append cost
qaoa_circuit.compose(bound_cost_layer, range(self.num_qubits), inplace=True)
else:
# odd layer -> append reversed cost
qaoa_circuit.compose(bound_cost_layer.reverse_ops(), range(self.num_qubits), inplace=True)
# the mixer layer is not reversed
qaoa_circuit.compose(bound_mixer_layer, range(self.num_qubits), inplace=True)
if self.num_layers % 2 == 1:
# iterate over layout permutations to recover measurements
if self.property_set["virtual_permutation_layout"]:
for cidx, qidx in self.property_set["virtual_permutation_layout"].get_physical_bits().items():
qaoa_circuit.measure(qidx, cidx)
else:
print("layout not found, assigining trivial layout")
for idx in range(self.num_qubits):
qaoa_circuit.measure(idx, idx)
else:
for idx in range(self.num_qubits):
qaoa_circuit.measure(idx, idx)
return circuit_to_dag(qaoa_circuit)
init = PassManager([QAOAPass(num_layers=3, num_qubits=10)])
tmp_out = init.run(tmp)
tmp_out.count_ops()
tmp_out.draw('mpl', fold=-1)
from qiskit.transpiler import Layout
# We use the obtained path to define the initial layout
initial_layout = Layout.from_intlist(path, cost_layer.qregs[0])
# The post init step unrolls the gates in the ansatz to the backend basis gates
post_init = PassManager(
[
UnrollCustomDefinitions(_sel, basis_gates=backend.operation_names, min_qubits=3),
BasisTranslator(_sel, target_basis=backend.operation_names, min_qubits=3),
]
)
staged_pm = generate_preset_pass_manager(3, backend, initial_layout=initial_layout)
staged_pm.pre_init = pre_init
staged_pm.init = init
staged_pm.post_init = post_init
# staged_pm.routing = None
print("pre_init")
for task in staged_pm.pre_init._tasks:
print(task)
print("----")
print("init")
for task in staged_pm.init._tasks:
print(task)
print("----")
print("post_init")
for task in staged_pm.post_init._tasks:
print(task)
print("----")
print("layout")
for task in staged_pm.layout._tasks:
print(task)
print("----")
print("optimization")
for task in staged_pm.optimization._tasks:
print(task)
print("----")
print("routing")
for task in staged_pm.routing._tasks:
print(task)
t0_opt = time.time()
optimally_transpiled_qaoa = staged_pm.run(cost_layer)
t1_opt = time.time()
naive_count = naively_transpiled_qaoa.count_ops().get("cz", 0)
optimal_count = optimally_transpiled_qaoa.count_ops().get("cz", 0)
print(f"2q gate count for naive circuit = {naive_count}")
print(f"2q gate count for optimal circuit = {optimal_count}")
naive_2q_depth = naively_transpiled_qaoa.depth(filter_function=lambda x: x.operation.name == "cz")
optimal_2q_depth = optimally_transpiled_qaoa.depth(filter_function=lambda x: x.operation.name == "cz")
print(f"2q depth for naive circuit = {naive_2q_depth}")
print(f"2q depth for optimal circuit = {optimal_2q_depth}")
naive_depth = naively_transpiled_qaoa.depth()
optimal_depth = optimally_transpiled_qaoa.depth()
print(f"total depth for naive circuit = {naive_depth}")
print(f"total depth for optimal circuit = {optimal_depth}")
time_naive = t1 - t0
time_optimal = (t1_opt - t0_opt)
print(f"total time for naive transpilation = {time_naive} (s)")
print(f"total time for optimal transpilation = {time_optimal} (s)")
# optimally_transpiled_qaoa.draw(fold=-1)
# naively_transpiled_qaoa.draw(fold=-1)
from qiskit.transpiler.passes import (
FullAncillaAllocation,
EnlargeWithAncilla,
ApplyLayout,
SetLayout,
)
# The post init step unrolls the gates in the ansatz to the backend basis gates
post_init = PassManager(
[
UnrollCustomDefinitions(_sel, basis_gates=backend.operation_names),
BasisTranslator(_sel, target_basis=backend.operation_names),
]
)
# The layout step applies the previously computed layout and enlarges the circuit
# with ancilla qubits to have the same number of physical qubits as the target
layout = PassManager(
[
SetLayout(initial_layout),
FullAncillaAllocation(backend.target),
EnlargeWithAncilla(),
ApplyLayout(),
]
)
# The optimization step performs additional gate cancellations
optimization = PassManager(
[
CommutativeCancellation(target=backend.target)
]
)
from qiskit.transpiler import StagedPassManager
other_staged_pm = StagedPassManager(stages=["init", "layout", 'optimization'], pre_init=pre_init, init=init, post_init=post_init, layout=layout, optimization=optimization)
t0_opt = time.time()
optimally_transpiled_qaoa = other_staged_pm.run(cost_layer)
t1_opt = time.time()
naive_count = naively_transpiled_qaoa.count_ops().get("cz", 0)
optimal_count = optimally_transpiled_qaoa.count_ops().get("cz", 0)
print(f"2q gate count for naive circuit = {naive_count}")
print(f"2q gate count for optimal circuit = {optimal_count}")
naive_2q_depth = naively_transpiled_qaoa.depth(filter_function=lambda x: x.operation.name == "cz")
optimal_2q_depth = optimally_transpiled_qaoa.depth(filter_function=lambda x: x.operation.name == "cz")
print(f"2q depth for naive circuit = {naive_2q_depth}")
print(f"2q depth for optimal circuit = {optimal_2q_depth}")
naive_depth = naively_transpiled_qaoa.depth()
optimal_depth = optimally_transpiled_qaoa.depth()
print(f"total depth for naive circuit = {naive_depth}")
print(f"total depth for optimal circuit = {optimal_depth}")
time_naive = t1 - t0
time_optimal = (t1_opt - t0_opt)
print(f"total time for naive transpilation = {time_naive} (s)")
print(f"total time for optimal transpilation = {time_optimal} (s)")
|
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/DaisukeIto-ynu/KosakaQ
|
DaisukeIto-ynu
|
# 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.
"""
Simulator command to snapshot internal simulator representation.
"""
from warnings import warn
from qiskit import QuantumCircuit
from .snapshot import Snapshot
class SnapshotStabilizer(Snapshot):
"""Snapshot instruction for stabilizer method of Qasm simulator."""
def __init__(self, label, num_qubits=0):
"""Create a stabilizer state snapshot instruction.
Args:
label (str): the snapshot label.
num_qubits (int): the instruction barrier size [Default: 0].
Raises:
ExtensionError: if snapshot is invalid.
Additional Information:
This snapshot is always performed on all qubits in a circuit.
The number of qubits parameter specifies the size of the
instruction as a barrier and should be set to the number of
qubits in the circuit.
.. deprecated:: 0.9.0
This instruction has been deprecated and will be removed no earlier
than 3 months from the 0.9.0 release date. It has been superseded by the
:class:`qiskit.providers.aer.library.SaveStabilizer` instruction.
"""
warn('The `SnapshotStabilizer` instruction will be deprecated in the'
' future. It has been superseded by the `save_stabilizer`'
' instructions.', DeprecationWarning, stacklevel=2)
super().__init__(label, snapshot_type='stabilizer', num_qubits=num_qubits)
def snapshot_stabilizer(self, label):
"""Take a stabilizer snapshot of the simulator state.
Args:
label (str): a snapshot label to report the result.
Returns:
QuantumCircuit: with attached instruction.
Raises:
ExtensionError: if snapshot is invalid.
Additional Information:
This snapshot is always performed on all qubits in a circuit.
The number of qubits parameter specifies the size of the
instruction as a barrier and should be set to the number of
qubits in the circuit.
.. deprecated:: 0.9.0
This instruction has been deprecated and will be removed no earlier
than 3 months from the 0.9.0 release date. It has been superseded by the
:func:`qiskit.providers.aer.library.save_stabilizer` circuit
method.
"""
warn('The `snapshot_stabilizer` circuit method has been deprecated as of'
' qiskit-aer 0.9 and will be removed in a future release.'
' It has been superseded by the `save_stabilizer`'
' circuit method.', DeprecationWarning, stacklevel=2)
snapshot_register = Snapshot.define_snapshot_register(self)
return self.append(
SnapshotStabilizer(label, num_qubits=len(snapshot_register)),
snapshot_register)
QuantumCircuit.snapshot_stabilizer = snapshot_stabilizer
|
https://github.com/matheusmtta/Quantum-Computing
|
matheusmtta
|
import numpy as np
from scipy.linalg import expm, sinm, cosm
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
import math
from scipy import stats
%matplotlib inline
from IPython.display import Image, display, Math, Latex
sns.set(color_codes=True)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import HGate
qc1 = QuantumCircuit(2)
qc1.x(0)
qc1.h(1)
custom = qc1.to_gate().control(2)
qc2 = QuantumCircuit(4)
qc2.append(custom, [0, 3, 1, 2])
qc2.draw('mpl')
|
https://github.com/SamperQuinto/QisKit
|
SamperQuinto
|
import os
from qiskit import *
import qiskit.tools.visualization as qt
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.quantum_info import DensityMatrix
from qiskit.visualization import plot_state_city
from numpy import pi
import matplotlib.pyplot as plt
%matplotlib inline
qreg_q = QuantumRegister(2, 'q')
creg_c = ClassicalRegister(2, 'c')
circuits = []
for i in range(0, 4):
circuits.append(QuantumCircuit(qreg_q, creg_c))
def entlanging(circuit, qreg_q):
circuit.barrier()
circuit.h(qreg_q[0])
circuit.cnot(qreg_q[0], qreg_q[1])
circuit.barrier()
# 00 state
circuits[0].reset(qreg_q[0])
circuits[0].reset(qreg_q[1])
entlanging(circuits[0], qreg_q)
# 01 state
circuits[1].reset(qreg_q[0])
circuits[1].x(qreg_q[1])
entlanging(circuits[1], qreg_q)
# 10 state
circuits[2].x(qreg_q[0])
circuits[2].reset(qreg_q[1])
entlanging(circuits[2], qreg_q)
# 11 state
circuits[3].x(qreg_q[0])
circuits[3].x(qreg_q[1])
entlanging(circuits[3], qreg_q)
simulator = Aer.get_backend('qasm_simulator')
circuits[0].measure(qreg_q[0], creg_c[0])
circuits[0].measure(qreg_q[1], creg_c[1])
result0 = execute(circuits[0], backend=simulator, shots=1024).result()
counts0 = result0.get_counts()
qt.plot_histogram(counts0, color="#5C9DFF", title="Entangled qubits values for input |00>")
circuits[0].draw(output='mpl')
circuits[1].measure(qreg_q[0], creg_c[0])
circuits[1].measure(qreg_q[1], creg_c[1])
result1 = execute(circuits[1], backend=simulator, shots=1024).result()
counts1 = result1.get_counts()
qt.plot_histogram(counts1, color="#5C9DFF", title="Entangled qubits values for input |01>")
circuits[1].draw(output='mpl')
circuits[2].measure(qreg_q[0], creg_c[0])
circuits[2].measure(qreg_q[1], creg_c[1])
result2 = execute(circuits[2], backend=simulator, shots=1024).result()
counts2 = result2.get_counts()
qt.plot_histogram(counts2, color="#5C9DFF", title="Entangled qubits values for input |10>")
circuits[2].draw(output='mpl')
circuits[3].measure(qreg_q[0], creg_c[0])
circuits[3].measure(qreg_q[1], creg_c[1])
result3 = execute(circuits[3], backend=simulator, shots=1024).result()
counts3 = result3.get_counts()
qt.plot_histogram(counts3, color="#5C9DFF", title="Entangled qubits values for input |11>")
circuits[3].draw(output='mpl')
|
https://github.com/agaviniv/qaoa-maxcut-qiskit
|
agaviniv
|
from math import sqrt, pi
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
import oracle_simple
import composed_gates
def get_circuit(n, oracles):
"""
Build the circuit composed by the oracle black box and the other quantum gates.
:param n: The number of qubits (not including the ancillas)
:param oracles: A list of black box (quantum) oracles; each of them selects a specific state
:returns: The proper quantum circuit
:rtype: qiskit.QuantumCircuit
"""
cr = ClassicalRegister(n)
## Testing
if n > 3:
#anc = QuantumRegister(n - 1, 'anc')
# n qubits for the real number
# n - 1 qubits for the ancillas
qr = QuantumRegister(n + n - 1)
qc = QuantumCircuit(qr, cr)
else:
# We don't need ancillas
qr = QuantumRegister(n)
qc = QuantumCircuit(qr, cr)
## /Testing
print("Number of qubits is {0}".format(len(qr)))
print(qr)
# Initial superposition
for j in range(n):
qc.h(qr[j])
# The length of the oracles list, or, in other words, how many roots of the function do we have
m = len(oracles)
# Grover's algorithm is a repetition of an oracle box and a diffusion box.
# The number of repetitions is given by the following formula.
print("n is ", n)
r = int(round((pi / 2 * sqrt((2**n) / m) - 1) / 2))
print("Repetition of ORACLE+DIFFUSION boxes required: {0}".format(r))
oracle_t1 = oracle_simple.OracleSimple(n, 5)
oracle_t2 = oracle_simple.OracleSimple(n, 0)
for j in range(r):
for i in range(len(oracles)):
oracles[i].get_circuit(qr, qc)
diffusion(n, qr, qc)
for j in range(n):
qc.measure(qr[j], cr[j])
return qc, len(qr)
def diffusion(n, qr, qc):
"""
The Grover diffusion operator.
Given the arry of qiskit QuantumRegister qr and the qiskit QuantumCircuit qc, it adds the diffusion operator to the appropriate qubits in the circuit.
"""
for j in range(n):
qc.h(qr[j])
# D matrix, flips state |000> only (instead of flipping all the others)
for j in range(n):
qc.x(qr[j])
# 0..n-2 control bits, n-1 target, n..
if n > 3:
composed_gates.n_controlled_Z_circuit(
qc, [qr[j] for j in range(n - 1)], qr[n - 1],
[qr[j] for j in range(n, n + n - 1)])
else:
composed_gates.n_controlled_Z_circuit(
qc, [qr[j] for j in range(n - 1)], qr[n - 1], None)
for j in range(n):
qc.x(qr[j])
for j in range(n):
qc.h(qr[j])
|
https://github.com/jakelishman/qiskit-qasm2
|
jakelishman
|
import contextlib
import pathlib
import uuid
import sys
from typing import Iterable
import pytest
from qiskit.circuit import QuantumCircuit, Parameter
import qiskit_qasm2.parse
if sys.version_info >= (3, 8):
def _unlink(path: pathlib.Path):
path.unlink(missing_ok=True)
else:
def _unlink(path: pathlib.Path):
try:
path.unlink()
except FileNotFoundError:
pass
def gate_builder(name: str, parameters: Iterable[Parameter], definition: QuantumCircuit):
"""Get a builder for a custom gate. Ideally we would just use an eagerly defined `Gate`
instance here, but limitations in how `QuantumCircuit.__eq__` and `Instruction.__eq__` work mean
that we have to ensure we're using the same class as the parser for equality checks to work."""
# Ideally we wouldn't have this at all, but hiding it away in one function is likely the safest
# and easiest to update if the Python component of the library changes.
# pylint: disable=protected-access
def definer(*arguments):
# We can supply empty lists for the gates and the bytecode, because we're going to override
# the definition manually ourselves.
gate = qiskit_qasm2.parse._DefinedGate(name, definition.num_qubits, arguments, (), ())
gate._definition = definition.assign_parameters(dict(zip(parameters, arguments)))
return gate
return definer
class _TemporaryFilePathFactory:
def __init__(self, basedir):
self._basedir = basedir
@contextlib.contextmanager
def __call__(self):
path = self._basedir / str(uuid.uuid4())
path.touch()
try:
yield path
finally:
_unlink(path)
@pytest.fixture(scope="session")
def tmp_file_path_factory(tmp_path_factory):
"""Get a path to a unique read/writeable temporary file that already exists on disk (with no
content), has a valid file name, and can be opened for both reading and writing in any mode. The
file will cleaned up after the function, if it still exists."""
return _TemporaryFilePathFactory(tmp_path_factory.getbasetemp())
|
https://github.com/IlliaOvcharenko/quantum-search
|
IlliaOvcharenko
|
import sys, os
sys.path.append(os.getcwd())
import matplotlib
matplotlib.use('Agg')
import math
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.primitives.sampler import Sampler
from fire import Fire
def main(
array_len: int | None = None,
n_grover_iterations: int | None = None,
save_circuit_plot: bool = False,
save_state_dist_plot: bool = False,
plot_prefix: str = "",
):
np.random.seed(42)
plot_prefix = plot_prefix + "-" if plot_prefix != "" else plot_prefix
if array_len is None:
array = [4, 7, 2, 1, 3, 0, 5, 6]
# item = 5 # answer should be 6
# item = 4 # answer should be 0
item = 0 # answer should be 5
else:
array = np.arange(array_len)
np.random.shuffle(array)
item = np.random.choice(array)
array = array.tolist()
print(f"Input array: {array}")
print(f"Item to search: {item}")
print(f"Correct answer should be: {array.index(item)}")
n_index_qbits = math.ceil(math.log(len(array), 2))
n_value_qbits = math.ceil(math.log(max(array), 2))
to_bits = lambda i: bin(i)[2:][::-1]
to_int = lambda b: int(b[::-1], 2)
index_qbits = [i for i in range(n_index_qbits)]
value_qbits = [i + n_index_qbits for i in range(n_value_qbits)]
phase_qbit = n_index_qbits + n_value_qbits
print(f"N qubits for index: {n_index_qbits}")
print(f"N qubits for value: {n_value_qbits}")
if n_grover_iterations is None:
n_grover_iterations = math.floor(math.sqrt(len(array)))
print(f"Num of grover iterations: {n_grover_iterations}")
qc = QuantumCircuit(
QuantumRegister(n_index_qbits, "index"),
QuantumRegister(n_value_qbits, "value"),
QuantumRegister(1, "phase"),
icr := ClassicalRegister(n_index_qbits, "meas-index"),
)
qc.h(index_qbits)
# qc.x(index_qbits[0])
# qc.x(index_qbits[1])
qc.x(phase_qbit)
qc.h(phase_qbit)
def add_oracle(global_qc):
qc = QuantumCircuit(
QuantumRegister(n_index_qbits, "index"),
QuantumRegister(n_value_qbits, "value"),
QuantumRegister(1, "phase"),
)
for array_idx in range(len(array)):
qc.barrier()
array_idx_bit = to_bits(array_idx)[:n_index_qbits]
array_idx_bit += "0" * (n_index_qbits - len(array_idx_bit))
array_item = array[array_idx]
array_item_bit = to_bits(array_item)[:n_value_qbits]
array_item_bit += "0" * (n_value_qbits - len(array_item_bit))
zeros = [index_qbits[i] for i, b in enumerate(array_idx_bit) if b == "0"]
ones = [value_qbits[i] for i, b in enumerate(array_item_bit) if b == "1"]
for value_idx in ones:
if zeros:
qc.x(zeros)
qc.mcx(index_qbits, value_idx)
if zeros:
qc.x(zeros)
global_qc = global_qc.compose(qc)
item_bit = to_bits(item)
item_bit += "0" * (n_value_qbits - len(item_bit))
zeros = [value_qbits[i] for i, b in enumerate(item_bit) if b == "0"]
if zeros:
global_qc.x(zeros)
global_qc.mcx(value_qbits, phase_qbit)
if zeros:
global_qc.x(zeros)
global_qc = global_qc.compose(qc.inverse())
return global_qc
def add_diffuser(global_qc):
qc = QuantumCircuit(
QuantumRegister(n_index_qbits, "index"),
QuantumRegister(n_value_qbits, "value"),
QuantumRegister(1, "phase"),
)
qc.h(index_qbits)
qc.x(index_qbits)
qc.mcx(index_qbits, phase_qbit)
qc.x(index_qbits)
qc.h(index_qbits)
global_qc = global_qc.compose(qc)
return global_qc
for _ in range(n_grover_iterations):
qc = add_oracle(qc)
qc = add_diffuser(qc)
if save_circuit_plot:
qc.draw("mpl")
plt.savefig(f"figs/{plot_prefix}qc.png", bbox_inches="tight")
qc.measure(index_qbits, icr)
sampler = Sampler()
job = sampler.run(qc, shots=64)
result = job.result()
index_dist = result.quasi_dists[0]
if save_state_dist_plot:
state_dist = [(k, v) for k, v in index_dist.items()]
state = [to_bits(k)[:n_index_qbits] for k, _ in state_dist]
state = [s + ("0" * (n_index_qbits - len(s))) for s in state]
dist = [v for k, v in state_dist]
plt.figure(figsize=(15, 10))
plt.bar(state, dist)
plt.xlabel("system state")
plt.ylabel("probability")
plt.grid()
plt.savefig(f"figs/{plot_prefix}state-dist.png", bbox_inches="tight")
index_pred = max(index_dist.items(), key=lambda x: x[1])
print(f"Search result, index: {index_pred[0]}, " \
f"empirical prob to collapse in this state: {index_pred[1]}")
print(f"Prob to collapse into a correct state: {index_dist[array.index(item)]}")
if __name__ == "__main__":
Fire(main)
|
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/Zhaoyilunnn/qdao
|
Zhaoyilunnn
|
import os
from time import time
import numpy as np
import pytest
from qiskit import QuantumCircuit, qiskit
from qiskit.compiler import transpile
from qiskit.qasm2 import dumps
from qiskit.quantum_info import Statevector
from constants import *
from qdao.circuit import BaselinePartitioner
from qdao.engine import Engine
from qdao.simulator import QdaoSimObj
from qdao.util import retrieve_sv
from tests.qdao import QdaoBaseTest
class TestEngine(QdaoBaseTest):
def setup_method(self):
if not os.path.exists("qcs"):
os.system(f"git clone {QCS_URL} qcs")
def run_qiskit_diff_test(
self,
circ: QuantumCircuit,
NQ: int,
NP: int,
NL: int,
mode: str = "QDAO",
is_parallel: bool = True,
is_diff: bool = True,
sv_location: str = "disk",
device: str = "CPU",
):
if mode == "QDAO":
engine = Engine(
circuit=circ,
num_primary=NP,
num_local=NL,
backend="qiskit",
is_parallel=is_parallel,
sv_location=sv_location,
device=device,
)
elif mode == "BASELINE":
engine = Engine(
circuit=circ,
num_primary=NP,
num_local=NL,
backend="qiskit",
partitioner=BaselinePartitioner(np=NP, nl=NL, backend="qiskit"),
is_parallel=is_parallel,
)
else:
raise ValueError(
f"Unsupported mode::{mode}, should be either QDAO or BASELINE"
)
st = time()
engine.run()
print("Qdao runs:\t{}".format(time() - st))
# print(sv)
engine.print_statistics()
engine._manager.print_statistics()
if is_diff:
circ.save_state()
st = time()
try:
self._sv_sim.set_options(method="statevector")
self._sv_sim.set_options(device=device)
sv_org = self._sv_sim.run(circ).result().get_statevector().data
except Exception:
pass
print("Qiskit runs: {}".format(time() - st))
def test_run_qiskit_any_qasm(
self, nq, np, nl, mode, qasm, parallel, diff, sv_location, device
):
NQ, NP, NL = self.get_qdao_params(nq, np, nl)
parallel = True if int(parallel) == 1 else False
diff = True if int(diff) == 1 else False
print("\n::::::::::::::::::Config::::::::::::::::::\n")
print("NQ::\t{}".format(NQ))
print("NP::\t{}".format(NP))
print("NL::\t{}".format(NL))
print("\n::::::::::::::::::Config::::::::::::::::::\n")
try:
circ = qiskit.circuit.QuantumCircuit.from_qasm_file(
QCS_BENCHMARKS_DIR + qasm
)
except Exception as e:
raise ValueError(f"Cannot load qasm file {qasm}: {e}")
circ = transpile(circ, self._sv_sim)
self.run_qiskit_diff_test(
circ,
NQ,
NP,
NL,
mode,
is_parallel=parallel,
is_diff=diff,
sv_location=sv_location,
device=device,
)
def test_run_qiskit_random(self, nq):
NQ = int(nq)
NP = NQ - 2
NL = NQ - 10
circ = self.get_qiskit_circ("random", num_qubits=NQ, depth=9, measure=False)
circ = transpile(circ, self._sv_sim)
engine = Engine(circuit=circ, num_primary=NP, num_local=NL, is_parallel=True)
st = time()
engine.run()
print("Qdao runs: {}".format(time() - st))
sv = retrieve_sv(NQ, num_local=NL)
engine.print_statistics()
engine._manager.print_statistics()
circ.save_state()
st = time()
sv_org = self._sv_sim.run(circ).result().get_statevector().data
print("Qiskit runs: {}".format(time() - st))
assert Statevector(sv).equiv(Statevector(sv_org))
def run_quafu_diff_test(
self,
circ: QuantumCircuit,
NQ: int,
NP: int,
NL: int,
mode: str = "QDAO",
is_parallel: bool = True,
is_diff: bool = True,
):
"""Run test from qiskit QuantumCircuit
Args:
circ: Qiskit quantum circuit
NQ: number of qubits,
NP: number of qubits in a compute unit
NL: number of qubits in a storage unit
mode: "QDAO" or "BASELINE"
is_parallel: Whether enable parallel load/store
is_diff: Whether run diff test, if set False, only run QDAO
"""
from quafu.circuits.quantum_circuit import QuantumCircuit
quafu_circ = QuantumCircuit(1)
quafu_circ.from_openqasm(dumps(circ))
# quafu_circ = qasm_to_circuit(dumps(circ))
# print("\nOriginal Circ")
# quafu_circ.draw_circuit()
if mode == "QDAO":
engine = Engine(
circuit=quafu_circ,
num_primary=NP,
num_local=NL,
backend="quafu",
is_parallel=is_parallel,
)
elif mode == "BASELINE":
engine = Engine(
circuit=quafu_circ,
num_primary=NP,
num_local=NL,
backend="quafu",
partitioner=BaselinePartitioner(np=NP, nl=NL, backend="quafu"),
is_parallel=is_parallel,
)
else:
raise ValueError(
f"Unsupported mode::{mode}, should be either QDAO or BASELINE"
)
st = time()
engine.run()
print("Qdao runs:\t{}".format(time() - st))
# print(sv)
engine.print_statistics()
engine._manager.print_statistics()
if is_diff:
from quafu.simulators.simulator import simulate
st = time()
init_sv = np.zeros(1 << NQ, dtype=np.complex128)
init_sv[0] = 1
sv_org = simulate(
quafu_circ, psi=init_sv, output="state_vector"
).get_statevector()
print("Quafu runs:\t{}".format(time() - st))
# print(sv_org)
if NQ < 26:
sv = retrieve_sv(NQ, num_local=NL)
assert Statevector(sv).equiv(Statevector(sv_org))
def get_qdao_params(self, nq, np, nl):
nq = int(nq)
np = int(np)
nl = int(nl)
NQ = nq if nq > 0 else 12
NP = np if np > 0 else NQ - 2 # Normally set 2
NL = nl if nl > 0 else NQ - 10 # Normally set 10
return NQ, NP, NL
def test_run_quafu_any_qasm(self, nq, np, nl, mode, qasm, parallel, diff):
"""
Basic test to run random circuits and
compare performance between
1. Qdao on top of quafu
2. Quafu
"""
NQ, NP, NL = self.get_qdao_params(nq, np, nl)
parallel = True if int(parallel) == 1 else False
diff = True if int(diff) == 1 else False
print("\n::::::::::::::::::Config::::::::::::::::::\n")
print("NQ::\t{}".format(NQ))
print("NP::\t{}".format(NP))
print("NL::\t{}".format(NL))
print("\n::::::::::::::::::Config::::::::::::::::::\n")
try:
circ = qiskit.circuit.QuantumCircuit.from_qasm_file(
QCS_BENCHMARKS_DIR + qasm
)
except Exception as e:
raise ValueError(f"Cannot load qasm file {qasm}: {e}")
circ = transpile(circ, self._sv_sim)
self.run_quafu_diff_test(
circ, NQ, NP, NL, mode=mode, is_parallel=parallel, is_diff=diff
)
def test_run_quafu_random_single_vs_qiskit_with_init(self, nq):
NQ = int(nq)
from qdao.qiskit.utils import random_circuit
circ = random_circuit(NQ, NQ, measure=False)
circ = transpile(circ, self._sv_sim)
from quafu.circuits.quantum_circuit import QuantumCircuit
quafu_circ = QuantumCircuit(1)
quafu_circ.from_openqasm(dumps(circ))
# quafu_circ = qasm_to_circuit(dumps(circ))
from quafu.simulators.simulator import simulate
st = time()
init_sv = np.zeros(1 << NQ, dtype=np.complex128)
init_sv[0] = 1
sv_quafu = simulate(
quafu_circ, psi=init_sv, output="state_vector"
).get_statevector()
print("Quafu runs: {}".format(time() - st))
st = time()
init_sv = np.zeros(1 << NQ, dtype=np.complex128)
init_sv[0] = 1
init_circ = qiskit.circuit.QuantumCircuit(NQ)
init_circ.initialize(init_sv, range(NQ))
init_circ.compose(circ, inplace=True)
init_circ.save_state()
self._sv_sim.set_options(fusion_enable=False)
sv_qiskit = self._sv_sim.run(init_circ).result().get_statevector()
# FIXME(zhaoyilun): when testing small circuits, uncomment this
assert sv_qiskit.equiv(Statevector(sv_quafu))
# print(sv_quafu)
# print(sv_qiskit.data)
print("Qiskit runs: {}".format(time() - st))
|
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/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
from IPython.display import YouTubeVideo
YouTubeVideo('U6_wSh_-EQc', width=960, height=490)
!pip install qiskit --quiet
!pip install qiskit-aer --quiet
!pip install pylatexenc --quiet
# @markdown ### **1. Import `Qiskit` and essential packages for UI demonstration** { display-mode: "form" }
from abc import abstractmethod, ABCMeta # For define pure virtual functions
from IPython.display import clear_output
from ipywidgets import Output, Button, HBox, VBox, HTML, Dropdown
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, transpile
from qiskit.visualization import plot_bloch_multivector, plot_histogram
from qiskit_aer import AerSimulator
# @markdown ### **2. `Board` class for essential quantum operations** { display-mode: "form" }
class Board:
def __init__(self, size=3, simulator=None):
# Initialize the quantum circuit with one qubit and classical bit for each cell
self.size = size
self.simulator = simulator
self.superposition_count = 0
self.cells = [[' ' for _ in range(size)] for _ in range(size)] # Initialize the board representation
self.qubits = QuantumRegister(size**2, 'q')
self.bits = ClassicalRegister(size**2, 'c')
self.circuit = QuantumCircuit(self.qubits, self.bits)
''' For a 3x3 board, the winning lines are:
- Horizontal lines: (0, 1, 2), (3, 4, 5), (6, 7, 8)
- Vertical lines: (0, 3, 6), (1, 4, 7), (2, 5, 8)
- Diagonal lines: (0, 4, 8), (2, 4, 6)
'''
self.winning_lines = [tuple(range(i, size**2, size)) for i in range(size)] + \
[tuple(range(i * size, (i + 1) * size)) for i in range(size)] + \
[tuple(range(0, size**2, size + 1)), tuple(range(size - 1, size**2 - 1, size - 1))]
def make_classical_move(self, row, col, player_mark, is_collapsed=False):
if self.cells[row][col] == ' ' or is_collapsed: # Check if the cell is occupied
self.cells[row][col] = player_mark
index = row * self.size + col
if player_mark == 'X': self.circuit.x(self.qubits[index])
else: self.circuit.id(self.qubits[index])
return True
return False
def make_swap_move(self, row1, col1, row2, col2, **kwargs):
if self.cells[row1][col1] != ' ' and self.cells[row2][col2] != ' ':
indices = [row1 * self.size + col1, row2 * self.size + col2]
self.circuit.swap(self.qubits[indices[0]], self.qubits[indices[1]])
self.cells[row1][col1], self.cells[row2][col2] = self.cells[row2][col2], self.cells[row1][col1]
return True
return False
def make_superposition_move(self, row, col, player_mark, **kwargs):
if self.cells[row][col] == ' ':
index = row * self.size + col
self.circuit.h(self.qubits[index])
self.cells[row][col] = player_mark + '?'
self.superposition_count += 1
return True
return False
def make_entangled_move(self, *positions, risk_level, player_mark, **kwargs):
# Entangle the quantum states of 2 or 3 cells based on the risk level
pos_count = len(positions)
if pos_count not in [2, 3] or risk_level not in [1, 2, 3, 4] or len(set(positions)) != pos_count or \
(pos_count == 2 and risk_level not in [1, 3]) or (pos_count == 3 and risk_level not in [2, 4]) or \
any(self.cells[row][col] != ' ' for row, col in positions): return False
indices = [row * self.size + col for row, col in positions]
self.circuit.h(self.qubits[indices[0]])
if pos_count == 2:
# Pairwise Entanglement with Bell state for 2 qubits:
# Lv1. |Ψ+⟩ = (∣01⟩ + ∣10⟩)/√2 | Lv3. |Φ+⟩ = (∣00⟩ + ∣11⟩)/√2
if risk_level == 1: self.circuit.x(self.qubits[indices[1]])
self.circuit.cx(self.qubits[indices[0]], self.qubits[indices[1]])
else:
# Triple Entanglement with GHZ state for 3 qubits:
# Lv2. (∣010⟩ + ∣101⟩)/√2 | Lv4. (∣000⟩ + ∣111⟩)/√2
if risk_level == 2:
self.circuit.x(self.qubits[indices[1]])
self.circuit.x(self.qubits[indices[2]])
# Apply CNOT chain to entangle all 3 qubits
self.circuit.cx(self.qubits[indices[0]], self.qubits[indices[1]])
self.circuit.cx(self.qubits[indices[1]], self.qubits[indices[2]])
for row, col in positions: self.cells[row][col] = player_mark + '?'
self.superposition_count += pos_count
return True
def can_be_collapsed(self):
# If superpositions/entanglement cells form a potential winning line => collapse
for line in self.winning_lines:
if all(self.cells[i // self.size][i % self.size].endswith('?') for i in line):
return True
return False
def collapse_board(self):
# Update the board based on the measurement results and apply the corresponding classical moves
self.circuit.barrier()
self.circuit.measure(self.qubits, self.bits) # Measure all qubits to collapse them to classical states
transpiled_circuit = transpile(self.circuit, self.simulator)
job = self.simulator.run(transpiled_circuit, memory=True)
counts = job.result().get_counts()
max_state = max(counts, key=counts.get)[::-1] # Get the state with the highest probability
for i in range(self.size ** 2):
row, col = divmod(i, self.size)
if self.cells[row][col].endswith('?'):
self.circuit.reset(self.qubits[i])
self.make_classical_move(row, col, 'X' if max_state[i] == '1' else 'O', is_collapsed=True)
self.superposition_count = 0
return counts
def check_win(self):
# Dynamic implementation for above logic with dynamic winning lines
for line in self.winning_lines:
# Check if all cells in the line are the same and not empty
first_cell = self.cells[line[0] // self.size][line[0] % self.size]
if first_cell not in [' ', 'X?', 'O?']:
is_same = all(self.cells[i // self.size][i % self.size] == first_cell for i in line)
if is_same: return line
# If no spaces and no superpositions left => 'Draw'
# If all cells are filled but some are still in superpositions => collapse_board
if all(self.cells[i // self.size][i % self.size] not in [' '] for i in range(self.size**2)):
if self.superposition_count <= 0: return 'Draw'
return self.superposition_count
return None
# @markdown ### **3. `QuantumT3Widgets` class for game interface**
class QuantumT3Widgets(metaclass=ABCMeta):
def __init__(self, board, current_player, quantum_move_mode):
self.board = board
self.current_player = current_player
self.quantum_move_mode = quantum_move_mode
self.log = Output(layout={'margin': '10px 0 0 0'})
self.histogram_output = Output(layout={'margin': '0 0 10px 10px'})
self.circuit_output = Output()
self.create_widgets()
def create_widgets(self):
# Create widgets for each cell and controls for game actions
self.buttons = []
for row in range(self.board.size):
self.buttons.append([])
for col in range(self.board.size):
button = Button(
description = ' ',
layout = {'width': '100px', 'height': '100px', 'border': '1px solid black'},
style = {'button_color': 'lightgray', 'font_weight': 'bold', 'text_color': 'white'}
)
button.on_click(self.create_on_cell_clicked(row, col))
self.buttons[row].append(button)
self.create_action_buttons()
self.game_info = HTML(f'<b>Current Player: {self.current_player} / Quantum Mode: {self.quantum_move_mode}</b>')
self.board_histogram_widget = HBox(
[VBox([VBox([HBox(row) for row in self.buttons]), self.game_info]), self.histogram_output],
layout = {'display': 'flex', 'justify_content': 'center', 'align_items': 'flex-end'}
)
display(VBox([self.board_histogram_widget, self.action_buttons, self.log, self.circuit_output]))
def create_action_buttons(self):
self.reset_btn = Button(description='Reset', button_style='danger')
self.collapse_btn = Button(description='Collapse', button_style='warning')
self.classical_btn = Button(description='Classical Move', button_style='primary')
self.swap_btn = Button(description='SWAP Move', button_style='info')
self.superposition_btn = Button(description='Superposition', button_style='success')
self.entangled_btn = Button(description='Entanglement', button_style='success')
self.entangled_options = Dropdown(options=[
('', 0), # Qubits collapse to opposite states (not consecutive)
('Lv1. PAIRWAISE: ∣Ψ+⟩ = (∣01⟩ + ∣10⟩) / √2', 1), # Qubits collapse to opposite states (not consecutive)
('Lv2. TRIPLE: GHZ_Xs = (∣010⟩ + ∣101⟩) / √2', 2),
('Lv3. PAIRWAISE: ∣Φ+⟩ = (∣00⟩ + ∣11⟩) / √2', 3), # Can form consecutive winning cells or accidentally help the opponent
('Lv4. TRIPLE: GHZ = (∣000⟩ + ∣111⟩) / √2', 4),
], value=0, disabled=True)
self.entangled_options.observe(self.update_entangled_options, names='value')
self.reset_btn.on_click(self.on_reset_btn_clicked)
self.collapse_btn.on_click(self.on_collapse_btn_clicked)
self.classical_btn.on_click(self.create_on_move_clicked('CLASSICAL'))
self.swap_btn.on_click(self.create_on_move_clicked('SWAP', 'Select 2 cells to swap their states.'))
self.superposition_btn.on_click(self.create_on_move_clicked('SUPERPOSITION', 'Select a cell to put in superposition.'))
self.entangled_btn.on_click(self.create_on_move_clicked('ENTANGLED', 'Select 2/3 cells based on risk level to entangle.'))
self.action_buttons = HBox([
self.reset_btn, self.collapse_btn, self.classical_btn, self.swap_btn,
self.superposition_btn, self.entangled_btn, self.entangled_options
])
@abstractmethod # Pure virtual functions => Must be overridden in the derived classes
def on_reset_btn_clicked(self, btn=None):
raise NotImplementedError('on_reset_btn_clicked method is not implemented.')
@abstractmethod # Pure virtual functions => Must be overridden in the derived classes
def on_collapse_btn_clicked(self, btn=None):
raise NotImplementedError('on_collapse_btn_clicked method is not implemented.')
@abstractmethod # Pure virtual functions => Must be overridden in the derived classes
def on_move_clicked(self, mode, message=''):
raise NotImplementedError('on_move_clicked method is not implemented.')
@abstractmethod # Pure virtual functions => Must be overridden in the derived classes
def on_cell_clicked(self, btn, row, col):
raise NotImplementedError('on_cell_clicked method is not implemented.')
def update_entangled_options(self, change):
with self.log:
self.entangled_options.disabled = change.new != 0
for row in self.buttons:
for button in row: button.disabled = change.new == 0
# Check if there are enough empty cells for the selected operation
empty_count = sum(cell == ' ' for row in self.board.cells for cell in row)
total_empty_required = {1: 2, 2: 3, 3: 2, 4: 3} # Total empty cells required for each risk level
if change.new == 0: return
elif empty_count < total_empty_required[change.new]:
print(f'Not enough empty cells to perform entanglement with risk level {change.new}. Please select another.')
self.entangled_options.value = 0
else:
print(f'Risk Level {change.new} ACTIVATED =>', end=' ')
if change.new in [1, 3]: print(f'Select 2 cells (qubits) for this PAIRWAISE entanglement.')
else: print(f'Select 3 cells (qubits) for this TRIPLE entanglement.')
def create_on_move_clicked(self, mode, message=''):
def on_move_clicked(btn):
with self.log:
try: self.on_move_clicked(mode, message)
except Exception as e: print(f'ERROR: {e}')
return on_move_clicked
def create_on_cell_clicked(self, row, col):
def on_cell_clicked(btn):
with self.log:
try: self.on_cell_clicked(btn, row, col)
except Exception as e: print(f'ERROR: {e}')
return on_cell_clicked
def display_circuit(self):
with self.circuit_output:
clear_output(wait=True)
display(self.board.circuit.draw('mpl', fold=-1, initial_state=True))
def display_histogram(self, counts):
with self.histogram_output:
clear_output(wait=True)
display(plot_histogram(counts, figsize=(9, 4)))
# @markdown ### **4. `QuantumT3GUI` class for game flow and interaction between players and `Board`**
class QuantumT3GUI(QuantumT3Widgets):
def __init__(self, size=3, simulator=None):
super().__init__(Board(size, simulator), 'X', 'CLASSICAL')
self.quantum_moves_selected = [] # Selected cells for operation on multi-qubit gates
self.game_over = False
def buttons_disabled(self, is_disabled=True):
for btn in self.action_buttons.children[1:]: btn.disabled = is_disabled
for row in self.buttons:
for btn in row: btn.disabled = is_disabled
def update_entire_board(self):
for row in range(self.board.size):
for col in range(self.board.size):
cell = self.board.cells[row][col]
color_map = {'X': 'dodgerblue', 'O': 'purple', '?': 'green', ' ': 'lightgray'}
self.buttons[row][col].description = cell if cell != ' ' else ' '
self.buttons[row][col].style.button_color = color_map[cell[-1]]
def clean_incompleted_quantum_moves(self):
for row, col in self.quantum_moves_selected:
if self.board.cells[row][col] == ' ':
self.buttons[row][col].description = ' '
self.buttons[row][col].style.button_color = 'lightgray'
self.quantum_moves_selected = []
def on_reset_btn_clicked(self, btn=None):
with self.log:
clear_output(wait=True)
self.board = Board(self.board.size, self.board.simulator)
self.current_player = 'X'
self.quantum_move_mode = 'CLASSICAL'
self.quantum_moves_selected = []
self.game_info.value = f'<b>Current Player: {self.current_player} / Quantum Mode: {self.quantum_move_mode}</b>'
self.game_over = False
self.update_entire_board()
self.buttons_disabled(False)
self.entangled_options.disabled = True
with self.histogram_output: clear_output()
with self.circuit_output: clear_output()
print('Game reset. New game started.')
def on_collapse_btn_clicked(self, btn=None):
with self.log:
if self.quantum_moves_selected:
print('Please complete the current quantum operation before measuring the board.')
return
clear_output(wait=True)
counts = self.board.collapse_board()
self.display_histogram(counts)
self.update_entire_board() # Update the board cells with the collapsed states
self.check_win()
print('Board measured and quantum states collapsed.')
def on_move_clicked(self, mode, message=''):
clear_output(wait=True)
self.quantum_move_mode = mode
self.game_info.value = f'<b>Current Player: {self.current_player} / Quantum Mode: {self.quantum_move_mode}</b>'
self.clean_incompleted_quantum_moves()
for row in self.buttons:
for button in row: button.disabled = mode == 'ENTANGLED'
if mode == 'ENTANGLED': self.entangled_options.value = 0
self.entangled_options.disabled = mode != 'ENTANGLED'
print(f'{mode} mode ACTIVATED' + (f': {message}' if message else ''))
def on_cell_clicked(self, btn, row, col):
if self.quantum_move_mode == 'CLASSICAL':
if self.board.make_classical_move(row, col, self.current_player):
btn.description = self.board.cells[row][col]
btn.style.button_color = 'dodgerblue' if self.current_player == 'X' else 'purple'
self.check_win()
else: print('That position is already occupied. Please choose another.')
elif self.quantum_move_mode == 'SUPERPOSITION':
if self.board.cells[row][col] == ' ':
btn.description = self.current_player + '?'
btn.style.button_color = 'green'
self.make_quantum_move_wrapper(
pos=(row, col), board_func=self.board.make_superposition_move,
success_msg='Cell is now in superposition state.')
else: print('Invalid SUPERPOSITION move. Cell must be empty.')
elif len(self.quantum_moves_selected) < 3: # Multi-qubit gates operation
self.quantum_moves_selected.append((row, col)) # Store the selected cell of operation
print(f'Cell ({row + 1}, {col + 1}) selected for {self.quantum_move_mode} move.')
if self.quantum_move_mode == 'SWAP' and len(self.quantum_moves_selected) == 2:
flat_pos = sum(self.quantum_moves_selected, ()) # Flatten the tuple to match 4 arguments in Board.make_swap_move
pos1, pos2 = self.quantum_moves_selected
self.make_quantum_move_wrapper(
pos=flat_pos, board_func=self.board.make_swap_move,
success_msg=f'SWAPPED Cell {pos1} to {pos2}', success_func=self.swap_on_board,
failure_msg='Invalid SWAP move. Both cells must be non-empty.')
elif self.quantum_move_mode == 'ENTANGLED':
if self.board.cells[row][col] == ' ':
btn.description = self.current_player + '?'
btn.style.button_color = 'green'
total_empty_required = {1: 2, 2: 3, 3: 2, 4: 3} # Total empty cells required for each risk level
if len(self.quantum_moves_selected) == total_empty_required[self.entangled_options.value]:
self.make_quantum_move_wrapper(
pos=self.quantum_moves_selected, board_func=self.board.make_entangled_move,
success_msg='These positions are now entangled and in a superposition state.',
failure_msg='Invalid ENTANGLEMENT move. Duplicated cell selection.')
else:
clear_output(wait=True)
print('Invalid ENTANGLEMENT move. A position is already occupied.')
self.quantum_moves_selected.pop() # Remove the invalid cell from the selected list
def swap_on_board(self):
row1, col1 = self.quantum_moves_selected[0][0], self.quantum_moves_selected[0][1]
row2, col2 = self.quantum_moves_selected[1][0], self.quantum_moves_selected[1][1]
# Swap the description and color of the selected cells
self.buttons[row1][col1].description, self.buttons[row2][col2].description = \
self.buttons[row2][col2].description, self.buttons[row1][col1].description
self.buttons[row1][col1].style.button_color, self.buttons[row2][col2].style.button_color = \
self.buttons[row2][col2].style.button_color, self.buttons[row1][col1].style.button_color
def make_quantum_move_wrapper(self, pos, board_func, success_msg='', success_func=None, failure_msg=''):
if board_func(*pos, risk_level=self.entangled_options.value, player_mark=self.current_player):
if success_msg: print(success_msg)
if success_func: success_func()
if self.board.can_be_collapsed():
print('Perform automatic board measurement and collapse the states.')
self.quantum_moves_selected = []
self.on_collapse_btn_clicked()
else: self.check_win()
else:
clear_output(wait=True)
if failure_msg: print(failure_msg)
self.clean_incompleted_quantum_moves()
def check_win(self):
self.quantum_moves_selected = []
while not self.game_over: # Check if the game is over after each move
self.display_circuit()
result = self.board.check_win()
if result == 'Draw': # All cells are filled but no winner yet
self.game_over = True
print("Game Over. It's a draw!")
elif type(result) == tuple: # A player wins
self.game_over = True
for cell_index in result:
row, col = divmod(cell_index, self.board.size)
self.buttons[row][col].style.button_color = 'orangered'
print(f'Game Over. {self.board.cells[row][col]} wins!')
elif type(result) == int: # All cells are filled but some are still in superpositions
print(f'All cells are filled but {result} of them still in superpositions => Keep Collapsing...')
self.quantum_moves_selected = []
self.on_collapse_btn_clicked() # Automatically collapse the board
break
else: # Switch players if no winner yet then continue the game
self.current_player = 'O' if self.current_player == 'X' else 'X' # Switch players
self.game_info.value = f'<b>Current Player: {self.current_player} / Quantum Mode: {self.quantum_move_mode}</b>'
break
if self.game_over: self.buttons_disabled(True)
game = QuantumT3GUI(size=3, simulator=AerSimulator())
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
from docplex.mp.model import Model
from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
from qiskit_optimization.algorithms import CobylaOptimizer, MinimumEigenOptimizer
from qiskit_optimization.algorithms.admm_optimizer import ADMMParameters, ADMMOptimizer
from qiskit_optimization.translators import from_docplex_mp
# If CPLEX is installed, you can uncomment this line to import the CplexOptimizer.
# CPLEX can be used in this tutorial to solve the convex continuous problem,
# but also as a reference to solve the QUBO, or even the full problem.
#
# from qiskit.optimization.algorithms import CplexOptimizer
# define COBYLA optimizer to handle convex continuous problems.
cobyla = CobylaOptimizer()
# define QAOA via the minimum eigen optimizer
qaoa = MinimumEigenOptimizer(QAOA(sampler=Sampler(), optimizer=COBYLA()))
# exact QUBO solver as classical benchmark
exact = MinimumEigenOptimizer(NumPyMinimumEigensolver()) # to solve QUBOs
# in case CPLEX is installed it can also be used for the convex problems, the QUBO,
# or as a benchmark for the full problem.
#
# cplex = CplexOptimizer()
# construct model using docplex
mdl = Model("ex6")
v = mdl.binary_var(name="v")
w = mdl.binary_var(name="w")
t = mdl.binary_var(name="t")
u = mdl.continuous_var(name="u")
mdl.minimize(v + w + t + 5 * (u - 2) ** 2)
mdl.add_constraint(v + 2 * w + t + u <= 3, "cons1")
mdl.add_constraint(v + w + t >= 1, "cons2")
mdl.add_constraint(v + w == 1, "cons3")
# load quadratic program from docplex model
qp = from_docplex_mp(mdl)
print(qp.prettyprint())
admm_params = ADMMParameters(
rho_initial=1001, beta=1000, factor_c=900, maxiter=100, three_block=True, tol=1.0e-6
)
# define QUBO optimizer
qubo_optimizer = exact
# qubo_optimizer = cplex # uncomment to use CPLEX instead
# define classical optimizer
convex_optimizer = cobyla
# convex_optimizer = cplex # uncomment to use CPLEX instead
# initialize ADMM with classical QUBO and convex optimizer
admm = ADMMOptimizer(
params=admm_params, qubo_optimizer=qubo_optimizer, continuous_optimizer=convex_optimizer
)
# run ADMM to solve problem
result = admm.solve(qp)
print(result.prettyprint())
plt.plot(result.state.residuals)
plt.xlabel("Iterations")
plt.ylabel("Residuals")
plt.show()
# define QUBO optimizer
qubo_optimizer = qaoa
# define classical optimizer
convex_optimizer = cobyla
# convex_optimizer = cplex # uncomment to use CPLEX instead
# initialize ADMM with quantum QUBO optimizer and classical convex optimizer
admm_q = ADMMOptimizer(
params=admm_params, qubo_optimizer=qubo_optimizer, continuous_optimizer=convex_optimizer
)
# run ADMM to solve problem
result_q = admm_q.solve(qp)
print(result.prettyprint())
plt.clf()
plt.plot(result_q.state.residuals)
plt.xlabel("Iterations")
plt.ylabel("Residuals")
plt.show()
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 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.
"""DAGFixedPoint pass testing"""
import unittest
from qiskit.transpiler.passes import DAGFixedPoint
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.converters import circuit_to_dag
from qiskit.test import QiskitTestCase
class TestFixedPointPass(QiskitTestCase):
"""Tests for PropertySet methods."""
def test_empty_dag_true(self):
"""Test the dag fixed point of an empty dag."""
circuit = QuantumCircuit()
dag = circuit_to_dag(circuit)
pass_ = DAGFixedPoint()
pass_.run(dag)
self.assertFalse(pass_.property_set["dag_fixed_point"])
pass_.run(dag)
self.assertTrue(pass_.property_set["dag_fixed_point"])
def test_nonempty_dag_false(self):
"""Test the dag false fixed point of a non-empty dag."""
qr = QuantumRegister(2)
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
dag = circuit_to_dag(circuit)
pass_ = DAGFixedPoint()
pass_.run(dag)
self.assertFalse(pass_.property_set["dag_fixed_point"])
dag.remove_all_ops_named("h")
pass_.run(dag)
self.assertFalse(pass_.property_set["dag_fixed_point"])
if __name__ == "__main__":
unittest.main()
|
https://github.com/derivation/ThinkQuantum
|
derivation
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute, Aer
from qiskit.tools.visualization import circuit_drawer, plot_histogram
import numpy as np
from numpy import pi
num_measurements = 5
q = QuantumRegister(1)
c = ClassicalRegister(num_measurements)
circ = QuantumCircuit(q,c)
for m in range(num_measurements):
circ.measure(q[0],c[m])
circuit_drawer(circ, output='mpl')
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(circ, backend_sim, shots=1)
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
print(counts)
num_measurements = 5
q = QuantumRegister(1)
c = ClassicalRegister(num_measurements)
circ = QuantumCircuit(q,c)
for m in range(num_measurements):
circ.measure(q[0],c[m])
circ.rx(pi, q[0])
circuit_drawer(circ, output='mpl')
job_sim = execute(circ, backend_sim, shots=1)
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
print(counts)
num_measurements = 1
q = QuantumRegister(1)
c = ClassicalRegister(num_measurements)
circ = QuantumCircuit(q,c)
circ.rx(pi/2, q)
circ.measure(q, c)
circuit_drawer(circ, output='mpl')
job_sim = execute(circ, backend_sim, shots=1)
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
print(counts)
repetitions = 1024
job_sim = execute(circ, backend_sim, shots=repetitions)
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
print(counts)
plot_histogram(counts)
|
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.minimum_eigensolvers import NumPyMinimumEigensolver
numpy_solver = NumPyMinimumEigensolver()
from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.primitives import Estimator
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,
),
)
vqe_solver = VQE(Estimator(), ansatz, SLSQP())
vqe_solver.initial_point = [0.0] * ansatz.num_parameters
from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.circuit.library import TwoLocal
tl_circuit = TwoLocal(
rotation_blocks=["h", "rx"],
entanglement_blocks="cz",
entanglement="full",
reps=2,
parameter_prefix="y",
)
another_solver = VQE(Estimator(), tl_circuit, SLSQP())
from qiskit_nature.second_q.algorithms import GroundStateEigensolver
calc = GroundStateEigensolver(mapper, vqe_solver)
res = calc.solve(es_problem)
print(res)
calc = GroundStateEigensolver(mapper, numpy_solver)
res = calc.solve(es_problem)
print(res)
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit_nature.second_q.drivers import GaussianForcesDriver
from qiskit_nature.second_q.mappers import DirectMapper
from qiskit_nature.second_q.problems import HarmonicBasis
driver = GaussianForcesDriver(logfile="aux_files/CO2_freq_B3LYP_631g.log")
basis = HarmonicBasis([2, 2, 2, 2])
vib_problem = driver.run(basis=basis)
vib_problem.hamiltonian.truncation_order = 2
mapper = DirectMapper()
solver_without_filter = NumPyMinimumEigensolver()
solver_with_filter = NumPyMinimumEigensolver(
filter_criterion=vib_problem.get_default_filter_criterion()
)
gsc_wo = GroundStateEigensolver(mapper, solver_without_filter)
result_wo = gsc_wo.solve(vib_problem)
gsc_w = GroundStateEigensolver(mapper, solver_with_filter)
result_w = gsc_w.solve(vib_problem)
print(result_wo)
print("\n\n")
print(result_w)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/mickahell/quantum_pokemon-fight
|
mickahell
|
from train.robot_vs_robot import team, battle
from stats.gen_data import gen_team_data
from src.class_custom.attacks import Attack
from src.class_custom.player import Player
from src.class_custom.pokemon import Pokemon
from src.class_custom.type import Type
from qiskit import Aer, QuantumCircuit, QuantumRegister
import warnings
class Team:
def __init__(self):
warnings.filterwarnings("ignore", category=DeprecationWarning)
# Init Qasm simulator backend
qasm = Aer.get_backend("qasm_simulator")
backend_sim = qasm # Choose your backend : <quantum_computer> or <qasm>
for u in range(2):
# Types creation --> Sources : https://boutique-pokemon.com/blogs/blog-pokemon/table-types-pokemon
fire = Type("Fire")
normal = Type("Normal")
water = Type("Water")
grass = Type("Grass")
electric = Type("Electric")
fly = Type("Fly")
poison = Type("Poison")
bug = Type("Bug")
ghost = Type("Ghost")
ground = Type("Ground")
dark = Type("Dark")
ice = Type("Ice")
steel = Type("Steel")
resistance = [bug, grass, fire, ice, steel]
weakness = [water, ground]
imunite = ["None"]
fire.add_info(resistance, weakness, imunite)
resistance = ["None"]
weakness = ["None"]
imunite = [ghost]
normal.add_info(resistance, weakness, imunite)
resistance = [grass, ground]
weakness = [fire, fly]
imunite = ["None"]
bug.add_info(resistance, weakness, imunite)
resistance = [water, fire, steel]
weakness = [grass, electric]
imunite = ["None"]
water.add_info(resistance, weakness, imunite)
resistance = [water, electric, grass, ground]
weakness = [fire, bug, poison, fly, ice]
imunite = ["None"]
grass.add_info(resistance, weakness, imunite)
resistance = [electric, fly, steel]
weakness = [ground]
imunite = ["None"]
electric.add_info(resistance, weakness, imunite)
resistance = [bug, grass]
weakness = [electric, ice]
imunite = [ground]
fly.add_info(resistance, weakness, imunite)
resistance = [ghost, dark]
weakness = [bug]
imunite = ["None"]
dark.add_info(resistance, weakness, imunite)
resistance = [bug, poison]
weakness = [ghost, dark]
imunite = [normal]
ghost.add_info(resistance, weakness, imunite)
resistance = [bug, grass, poison]
weakness = [ground]
imunite = ["None"]
poison.add_info(resistance, weakness, imunite)
resistance = [poison]
weakness = [water, grass, ice]
imunite = [electric]
ground.add_info(resistance, weakness, imunite)
resistance = [ice]
weakness = [fire, steel]
imunite = ["None"]
ice.add_info(resistance, weakness, imunite)
resistance = [steel, ice, bug, normal, grass, fly]
weakness = [fire, ground]
imunite = [poison]
steel.add_info(resistance, weakness, imunite)
# type qubits creation
fire.qubit = QuantumRegister(1, "fire")
normal.qubit = QuantumRegister(1, "normal")
water.qubit = QuantumRegister(1, "water")
grass.qubit = QuantumRegister(1, "grass")
electric.qubit = QuantumRegister(1, "electric")
fly.qubit = QuantumRegister(1, "fly")
poison.qubit = QuantumRegister(1, "poison")
bug.qubit = QuantumRegister(1, "bug")
ghost.qubit = QuantumRegister(1, "ghost")
ground.qubit = QuantumRegister(1, "ground")
dark.qubit = QuantumRegister(1, "dark")
ice.qubit = QuantumRegister(1, "ice")
steel.qubit = QuantumRegister(1, "steel")
qc_type = QuantumCircuit(
steel.qubit,
fire.qubit,
normal.qubit,
water.qubit,
grass.qubit,
electric.qubit,
fly.qubit,
poison.qubit,
bug.qubit,
ghost.qubit,
ground.qubit,
dark.qubit,
ice.qubit,
)
# Attacks creation
fire_blast = Attack("Fire Blast", fire, 110, 0.85, "special")
hurricane = Attack("Hurricane", fly, 110, 0.70, "special")
earthquake = Attack("Earthquake", ground, 100, 1, "physical")
leaf_storm = Attack("Leaf Storm", grass, 90, 1, "special")
shadow_ball = Attack("Shadow Ball", ghost, 80, 1, "special")
sludge_bomb = Attack("Sludge Bomb", poison, 90, 1, "special")
thunder = Attack("Thunder", electric, 110, 0.70, "special")
dark_pulse = Attack("Dark Pulse", dark, 80, 1, "special")
ice_beam = Attack("Ice Beam", ice, 90, 1, "special")
hydroblast = Attack("Hydroblast", water, 110, 0.8, "special")
iron_tail = Attack("Iron Tail", steel, 100, 0.75, "physical")
slam = Attack("Slam", normal, 80, 0.75, "physical")
grass_knot = Attack("Grass Knot", grass, 80, 1, "special")
flash_cannon = Attack("Flash Cannon", steel, 80, 1, "special")
giga_impact = Attack("Giga-Impact", normal, 150, 0.9, "physical")
bite = Attack("Bite", dark, 60, 1, "physical")
tri_attack = Attack("Triplattaque", normal, 80, 1, "special")
#hyper_beam = Attack("Hyper Beam", normal, 150, 0.9, "special")
throat_chop = Attack("Throat Chop", dark, 80, 1, "physical")
fire_punch = Attack("Fire Punch", fire, 75, 1, "physical")
# Pokémon creation --> Sources : https://www.pokepedia.fr/Pikachu#Statistiques-remarques1
charizard = Pokemon("Charizard", [fire, fly], 360, 267, 255, 317, 269, 299)
gengar = Pokemon("Gengar", [ghost, poison], 324, 229, 219, 359, 249, 319)
blastoise = Pokemon("Blastoise", [water], 362, 265, 299, 269, 309, 255)
pikachu = Pokemon("Pikachu", [electric], 294, 259, 199, 249, 219, 339)
glaceon = Pokemon("Glaceon", [ice], 334, 219, 319, 359, 289, 229)
porygonz = Pokemon("Porygon-Z", [normal], 374, 259, 239, 369, 249, 279)
abomasnow = Pokemon("Abomasnow", [grass, ice], 384, 283, 249, 283, 269, 219)
toxtricity = Pokemon(
"Toxtricity", [electric, poison], 354, 295, 239, 327, 239, 249
)
# Attacks learning
charizard.learn_attacks([fire_blast, hurricane, earthquake, leaf_storm])
gengar.learn_attacks([sludge_bomb, dark_pulse, shadow_ball, thunder])
blastoise.learn_attacks([ice_beam, hydroblast, flash_cannon, giga_impact])
pikachu.learn_attacks([thunder, iron_tail, slam, grass_knot])
glaceon.learn_attacks([ice_beam, slam, iron_tail, bite])
porygonz.learn_attacks([thunder, ice_beam, tri_attack, dark_pulse])
abomasnow.learn_attacks([ice_beam, leaf_storm, earthquake, giga_impact])
toxtricity.learn_attacks([sludge_bomb, thunder, throat_chop, fire_punch])
# Player creation
me = Player("Oak", "j1", "human")
him = Player("Agatha", "j2", "robot")
##############################################################
# GAME
print(
"""
###################################################
# Welcome in the Quantum Pokémon fight - CLI
# Will you succeed to win against the Quantum AI ?
#
# Good Luck !!!
###################################################
"""
)
team(me, him, nb_team=3)
winner, looser = battle(me, him, qc_type, backend_sim)
for i, y in zip(winner.register_team, looser.register_team):
gen_team_data(pokemon=i, has_win="yes")
gen_team_data(pokemon=y, has_win="no")
print("Fight {} is finished !".format(u + 1))
print("Gen team data program ended !")
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
import qiskit
qiskit.__qiskit_version__
from math import pi
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
%matplotlib inline
# importing Qiskit
from qiskit import BasicAer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
# Load saved IBMQ accounts
IBMQ.load_account()
# We first define controlled gates used in the IPEA
def cu1fixed(qProg, c, t, a):
qProg.u1(-a, t)
qProg.cx(c, t)
qProg.u1(a, t)
qProg.cx(c, t)
def cu5pi8(qProg, c, t):
cu1fixed(qProg, c, t, -5.0*pi/8.0)
# We then prepare quantum and classical registers and the circuit
qr = QuantumRegister(2)
cr = ClassicalRegister(4)
circuitName="IPEAonSimulator"
ipeaCircuit = QuantumCircuit(qr, cr)
# Apply IPEA
ipeaCircuit.h(qr[0])
for i in range(8):
cu5pi8(ipeaCircuit, qr[0], qr[1])
ipeaCircuit.h(qr[0])
ipeaCircuit.measure(qr[0], cr[0])
ipeaCircuit.reset(qr[0])
ipeaCircuit.h(qr[0])
for i in range(4):
cu5pi8(ipeaCircuit, qr[0], qr[1])
ipeaCircuit.u1(-pi/2, qr[0]).c_if(cr, 1)
ipeaCircuit.h(qr[0])
ipeaCircuit.measure(qr[0], cr[1])
ipeaCircuit.reset(qr[0])
ipeaCircuit.h(qr[0])
for i in range(2):
cu5pi8(ipeaCircuit, qr[0], qr[1])
ipeaCircuit.u1(-pi/4, qr[0]).c_if(cr, 1)
ipeaCircuit.u1(-pi/2, qr[0]).c_if(cr, 2)
ipeaCircuit.u1(-3*pi/4, qr[0]).c_if(cr, 3)
ipeaCircuit.h(qr[0])
ipeaCircuit.measure(qr[0], cr[2])
ipeaCircuit.reset(qr[0])
ipeaCircuit.h(qr[0])
cu5pi8(ipeaCircuit, qr[0], qr[1])
ipeaCircuit.u1(-pi/8, qr[0]).c_if(cr, 1)
ipeaCircuit.u1(-2*pi/8, qr[0]).c_if(cr, 2)
ipeaCircuit.u1(-3*pi/8, qr[0]).c_if(cr, 3)
ipeaCircuit.u1(-4*pi/8, qr[0]).c_if(cr, 4)
ipeaCircuit.u1(-5*pi/8, qr[0]).c_if(cr, 5)
ipeaCircuit.u1(-6*pi/8, qr[0]).c_if(cr, 6)
ipeaCircuit.u1(-7*pi/8, qr[0]).c_if(cr, 7)
ipeaCircuit.h(qr[0])
ipeaCircuit.measure(qr[0], cr[3])
backend = BasicAer.get_backend('qasm_simulator')
shots = 1000
results = execute(ipeaCircuit, backend=backend, shots=shots).result()
plot_histogram(results.get_counts())
# We then prepare quantum and classical registers and the circuit
qr = QuantumRegister(5)
cr = ClassicalRegister(5)
realStep1Circuit = QuantumCircuit(qr, cr)
# Apply IPEA
realStep1Circuit.h(qr[0])
for i in range(8):
cu5pi8(realStep1Circuit, qr[0], qr[1])
realStep1Circuit.h(qr[0])
realStep1Circuit.measure(qr[0], cr[0])
#connect to remote API to be able to use remote simulators and real devices
print("Available backends:", [BasicAer.backends(), IBMQ.backends()])
backend = IBMQ.get_backend("ibmq_5_yorktown")
shots = 1000
job_exp1 = execute(realStep1Circuit, backend=backend, shots=shots)
job_monitor(job_exp1)
results1 = job_exp1.result()
plot_histogram(results1.get_counts())
realStep2Circuit = QuantumCircuit(qr, cr)
# Apply IPEA
realStep2Circuit.h(qr[0])
for i in range(4):
cu5pi8(realStep2Circuit, qr[0], qr[1])
realStep2Circuit.u1(-pi/2, qr[0]) # Assuming the value of the measurement on Step 1
realStep2Circuit.h(qr[0])
realStep2Circuit.measure(qr[0], cr[0])
job_exp2 = execute(realStep2Circuit, backend=backend, shots=shots)
job_monitor(job_exp1)
results2 = job_exp2.result()
plot_histogram(results2.get_counts())
realStep3Circuit = QuantumCircuit(qr, cr)
# Apply IPEA
realStep3Circuit.h(qr[0])
for i in range(2):
cu5pi8(realStep3Circuit, qr[0], qr[1])
realStep3Circuit.u1(-3*pi/4, qr[0]) # Assuming the value of the measurement on Step 1 and Step 2
realStep3Circuit.h(qr[0])
realStep3Circuit.measure(qr[0], cr[0])
job_exp3 = execute(realStep3Circuit, backend=backend, shots=shots)
job_monitor(job_exp3)
results3 = job_exp3.result()
plot_histogram(results3.get_counts())
realStep4Circuit = QuantumCircuit(qr, cr)
# Apply IPEA
realStep4Circuit.h(qr[0])
cu5pi8(realStep4Circuit, qr[0], qr[1])
realStep4Circuit.u1(-3*pi/8, qr[0]) # Assuming the value of the measurement on Step 1, 2, and 3
realStep4Circuit.h(qr[0])
realStep4Circuit.measure(qr[0], cr[0])
job_exp4 = execute(realStep4Circuit, backend=backend, shots=shots)
job_monitor(job_exp4)
results4 = job_exp4.result()
plot_histogram(results4.get_counts())
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
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":
### replaced x gate ###
qc.z(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
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=no-member,invalid-name,missing-docstring,no-name-in-module
# pylint: disable=attribute-defined-outside-init,unsubscriptable-object
import os
from qiskit.compiler import transpile
from qiskit import QuantumCircuit
from qiskit.transpiler import InstructionDurations
from qiskit.providers.fake_provider import FakeMelbourne
from .utils import build_qv_model_circuit
class TranspilerLevelBenchmarks:
params = [0, 1, 2, 3]
param_names = ["transpiler optimization level"]
timeout = 600
def setup(self, _):
self.rochester_coupling_map = [
[0, 5],
[0, 1],
[1, 2],
[1, 0],
[2, 3],
[2, 1],
[3, 4],
[3, 2],
[4, 6],
[4, 3],
[5, 9],
[5, 0],
[6, 13],
[6, 4],
[7, 16],
[7, 8],
[8, 9],
[8, 7],
[9, 10],
[9, 8],
[9, 5],
[10, 11],
[10, 9],
[11, 17],
[11, 12],
[11, 10],
[12, 13],
[12, 11],
[13, 14],
[13, 12],
[13, 6],
[14, 15],
[14, 13],
[15, 18],
[15, 14],
[16, 19],
[16, 7],
[17, 23],
[17, 11],
[18, 27],
[18, 15],
[19, 20],
[19, 16],
[20, 21],
[20, 19],
[21, 28],
[21, 22],
[21, 20],
[22, 23],
[22, 21],
[23, 24],
[23, 22],
[23, 17],
[24, 25],
[24, 23],
[25, 29],
[25, 26],
[25, 24],
[26, 27],
[26, 25],
[27, 26],
[27, 18],
[28, 32],
[28, 21],
[29, 36],
[29, 25],
[30, 39],
[30, 31],
[31, 32],
[31, 30],
[32, 33],
[32, 31],
[32, 28],
[33, 34],
[33, 32],
[34, 40],
[34, 35],
[34, 33],
[35, 36],
[35, 34],
[36, 37],
[36, 35],
[36, 29],
[37, 38],
[37, 36],
[38, 41],
[38, 37],
[39, 42],
[39, 30],
[40, 46],
[40, 34],
[41, 50],
[41, 38],
[42, 43],
[42, 39],
[43, 44],
[43, 42],
[44, 51],
[44, 45],
[44, 43],
[45, 46],
[45, 44],
[46, 47],
[46, 45],
[46, 40],
[47, 48],
[47, 46],
[48, 52],
[48, 49],
[48, 47],
[49, 50],
[49, 48],
[50, 49],
[50, 41],
[51, 44],
[52, 48],
]
self.basis_gates = ["u1", "u2", "u3", "cx", "id"]
self.qv_50_x_20 = build_qv_model_circuit(50, 20, 0)
self.qv_14_x_14 = build_qv_model_circuit(14, 14, 0)
self.qasm_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "qasm"))
large_qasm_path = os.path.join(self.qasm_path, "test_eoh_qasm.qasm")
self.large_qasm = QuantumCircuit.from_qasm_file(large_qasm_path)
self.melbourne = FakeMelbourne()
self.durations = InstructionDurations(
[
("u1", None, 0),
("id", None, 160),
("u2", None, 160),
("u3", None, 320),
("cx", None, 800),
("measure", None, 3200),
],
dt=1e-9,
)
def time_quantum_volume_transpile_50_x_20(self, transpiler_level):
transpile(
self.qv_50_x_20,
basis_gates=self.basis_gates,
coupling_map=self.rochester_coupling_map,
seed_transpiler=0,
optimization_level=transpiler_level,
)
def track_depth_quantum_volume_transpile_50_x_20(self, transpiler_level):
return transpile(
self.qv_50_x_20,
basis_gates=self.basis_gates,
coupling_map=self.rochester_coupling_map,
seed_transpiler=0,
optimization_level=transpiler_level,
).depth()
def time_transpile_from_large_qasm(self, transpiler_level):
transpile(
self.large_qasm,
basis_gates=self.basis_gates,
coupling_map=self.rochester_coupling_map,
seed_transpiler=0,
optimization_level=transpiler_level,
)
def track_depth_transpile_from_large_qasm(self, transpiler_level):
return transpile(
self.large_qasm,
basis_gates=self.basis_gates,
coupling_map=self.rochester_coupling_map,
seed_transpiler=0,
optimization_level=transpiler_level,
).depth()
def time_transpile_from_large_qasm_backend_with_prop(self, transpiler_level):
transpile(
self.large_qasm, self.melbourne, seed_transpiler=0, optimization_level=transpiler_level
)
def track_depth_transpile_from_large_qasm_backend_with_prop(self, transpiler_level):
return transpile(
self.large_qasm, self.melbourne, seed_transpiler=0, optimization_level=transpiler_level
).depth()
def time_transpile_qv_14_x_14(self, transpiler_level):
transpile(
self.qv_14_x_14, self.melbourne, seed_transpiler=0, optimization_level=transpiler_level
)
def track_depth_transpile_qv_14_x_14(self, transpiler_level):
return transpile(
self.qv_14_x_14, self.melbourne, seed_transpiler=0, optimization_level=transpiler_level
).depth()
def time_schedule_qv_14_x_14(self, transpiler_level):
transpile(
self.qv_14_x_14,
self.melbourne,
seed_transpiler=0,
optimization_level=transpiler_level,
scheduling_method="alap",
instruction_durations=self.durations,
)
# limit optimization levels to reduce time
time_schedule_qv_14_x_14.params = [0, 1]
|
https://github.com/qiskit-community/qiskit-cold-atom
|
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.
"""Module for cold-atom fermion backends."""
from abc import ABC
from typing import Union, List, Optional
import numpy as np
from qiskit.providers import BackendV1 as Backend
from qiskit import QuantumCircuit
from qiskit_nature.second_q.operators import FermionicOp
from qiskit_cold_atom.fermions.fermion_gate_library import LoadFermions
from qiskit_cold_atom.fermions.fermion_circuit_solver import FermionCircuitSolver
from qiskit_cold_atom.fermions.fermionic_state import FermionicState
from qiskit_cold_atom.exceptions import QiskitColdAtomError
class BaseFermionBackend(Backend, ABC):
"""Abstract base class for fermionic tweezer backends."""
def initialize_circuit(self, occupations: Union[List[int], List[List[int]]]):
"""
Initialize a fermionic quantum circuit with the given occupations.
Args:
occupations: List of occupation numbers. When ``List[int]`` is given, the occupations
correspond to the number of indistinguishable fermionic particles in each mode,
e.g. ``[0, 1, 1, 0]`` implies that sites one and two are occupied by a fermion.
When ``List[List[int]]`` is given, the occupations describe the number of particles in
fermionic modes with different (distinguishable) species of fermions. Each
inner list gives the occupations of one fermionic species.
Returns:
circuit: Qiskit QuantumCircuit with a quantum register for each fermionic species
initialized with the ``load`` instructions corresponding to the given occupations
Raises:
QiskitColdAtomError: If occupations do not match the backend
"""
try:
backend_size = self.configuration().to_dict()["n_qubits"]
except NameError as name_error:
raise QiskitColdAtomError(
f"Number of tweezers not specified for {self.name()}"
) from name_error
initial_state = FermionicState(occupations)
n_wires = initial_state.sites * initial_state.num_species
if n_wires > backend_size:
raise QiskitColdAtomError(
f"{self.name()} supports up to {backend_size} sites, {n_wires} were given"
)
# if num_species is specified by the backend, the wires describe different atomic species
# and the circuit must exactly match the expected wire count of the backend.
if "num_species" in self.configuration().to_dict().keys():
num_species = self.configuration().num_species
if num_species > 1 and n_wires < self.configuration().num_qubits:
raise QiskitColdAtomError(
f"{self.name()} requires circuits with exactly "
f"{self.configuration().num_qubits} wires, but an initial occupation of size "
f"{n_wires} was given."
)
from qiskit.circuit import QuantumRegister
if initial_state.num_species > 1:
registers = []
for i in range(initial_state.num_species):
registers.append(QuantumRegister(initial_state.sites, f"spin_{i}"))
circuit = QuantumCircuit(*registers)
else:
circuit = QuantumCircuit(QuantumRegister(initial_state.sites, "fer_mode"))
for i, occupation_list in enumerate(initial_state.occupations):
for j, occ in enumerate(occupation_list):
if occ:
circuit.append(LoadFermions(), qargs=[i * initial_state.sites + j])
return circuit
def measure_observable_expectation(
self,
circuits: Union[QuantumCircuit, List[QuantumCircuit]],
observable: FermionicOp,
shots: int,
seed: Optional[int] = None,
num_species: int = 1,
get_variance: bool = False,
):
"""Measure the expectation value of an observable in a state prepared by a given quantum circuit
that uses fermionic gates. Measurements are added to the entire register if they are not yet
applied in the circuit.
Args:
circuits: QuantumCircuit applying gates with fermionic generators
observable: A FermionicOp describing an observable of which the expectation value is sampled
shots: Number of measurement shots taken in case the circuit has measure instructions
seed: seed for the random number generator of the measurement simulation
num_species: number of different fermionic species described by the circuits
get_variance: If True, also returns an estimate of the variance of the observable
Raises:
QiskitColdAtomError: if the observable is non-diagonal
Returns:
observable_ev: List of the measured expectation values of the observables in given circuits
variance: List of the estimated variances of of the observables (if get_variance is True)
"""
if isinstance(circuits, QuantumCircuit):
circuits = [circuits]
observable_evs = [0] * len(circuits)
observable_vars = [0] * len(circuits)
for idx, circuit in enumerate(circuits):
# check whether the observable is diagonal in the computational basis.
solver = FermionCircuitSolver(num_species=2)
solver.preprocess_circuit(circuit)
observable_mat = solver.operator_to_mat(observable)
if list(observable_mat.nonzero()[0]) != list(observable_mat.nonzero()[1]):
raise QiskitColdAtomError(
"Measuring general observables that are non-diagonal in the "
"computational basis is not yet implemented for "
"fermionic backends. This requires non-trivial basis "
"transformations that are in general difficult to find and "
"depend on the backend's native gate set."
)
circuit.remove_final_measurements()
circuit.measure_all()
# pylint: disable=unexpected-keyword-arg
job = self.run(circuit, shots=shots, seed=seed, num_species=num_species)
counts = job.result().get_counts()
for bitstring in counts:
# Extract the index of the measured count-bitstring in the fermionic basis.
# In contrast to qubits, this is not trivial and requires an additional step.
ind = solver.basis.get_index_of_measurement(bitstring)
# contribution to the operator estimate of this outcome
p = counts[bitstring] / shots
observable_evs[idx] += p * observable_mat[ind, ind].real
if get_variance:
# contribution to the variance of the operator
observable_vars[idx] += (
np.sqrt(p * (1 - p) / shots) * observable_mat[ind, ind]
) ** 2
if get_variance:
return observable_evs, observable_vars
else:
return observable_evs
def draw(self, qc: QuantumCircuit, **draw_options):
"""Modified circuit drawer to better display atomic mixture quantum circuits.
Note that in the future this method may be modified and tailored to fermionic quantum circuits.
Args:
qc: The quantum circuit to draw.
draw_options: Key word arguments for the drawing of circuits.
"""
qc.draw(**draw_options)
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
#!pip install PySCF --upgrade
import networkx as nx
import numpy as np
import plotly.graph_objects as go
import matplotlib as mpl
import pandas as pd
from IPython.display import clear_output
from plotly.subplots import make_subplots
from matplotlib import pyplot as plt
from qiskit import Aer, transpile, assemble, IBMQ, execute
from qiskit import QuantumCircuit
from qiskit.visualization import plot_state_city
from qiskit.algorithms.optimizers import COBYLA, SLSQP, ADAM
from time import time
from copy import copy
from typing import List
from qc_grader.graph_util import display_maxcut_widget, QAOA_widget, graphs
mpl.rcParams['figure.dpi'] = 300
from qiskit.circuit import Parameter, ParameterVector
#Parameters are initialized with a simple string identifier
parameter_0 = Parameter('θ[0]')
parameter_1 = Parameter('θ[1]')
circuit = QuantumCircuit(1)
#We can then pass the initialized parameters as the rotation angle argument to the Rx and Ry gates
circuit.ry(theta = parameter_0, qubit = 0)
circuit.rx(theta = parameter_1, qubit = 0)
circuit.draw('mpl')
parameter = Parameter('θ')
circuit = QuantumCircuit(1)
circuit.ry(theta = parameter, qubit = 0)
circuit.rx(theta = parameter, qubit = 0)
circuit.draw('mpl')
#Set the number of layers and qubits
n=3
num_layers = 2
#ParameterVectors are initialized with a string identifier and an integer specifying the vector length
parameters = ParameterVector('θ', n*(num_layers+1))
circuit = QuantumCircuit(n, n)
for layer in range(num_layers):
#Appending the parameterized Ry gates using parameters from the vector constructed above
for i in range(n):
circuit.ry(parameters[n*layer+i], i)
circuit.barrier()
#Appending the entangling CNOT gates
for i in range(n):
for j in range(i):
circuit.cx(j,i)
circuit.barrier()
#Appending one additional layer of parameterized Ry gates
for i in range(n):
circuit.ry(parameters[n*num_layers+i], i)
circuit.barrier()
circuit.draw('mpl')
print(circuit.parameters)
#Create parameter dictionary with random values to bind
param_dict = {parameter: np.random.random() for parameter in parameters}
print(param_dict)
#Assign parameters using the assign_parameters method
bound_circuit = circuit.assign_parameters(parameters = param_dict)
bound_circuit.draw('mpl')
new_parameters = ParameterVector('Ψ',9)
new_circuit = circuit.assign_parameters(parameters = [k*new_parameters[k] for k in range(9)])
new_circuit.draw('mpl')
#Run the circuit with assigned parameters on Aer's statevector simulator
simulator = Aer.get_backend('statevector_simulator')
result = simulator.run(bound_circuit).result()
statevector = result.get_statevector(bound_circuit)
plot_state_city(statevector)
#The following line produces an error when run because 'circuit' still contains non-assigned parameters
#result = simulator.run(circuit).result()
for key in graphs.keys():
print(key)
graph = nx.Graph()
#Add nodes and edges
graph.add_nodes_from(np.arange(0,6,1))
edges = [(0,1,2.0),(0,2,3.0),(0,3,2.0),(0,4,4.0),(0,5,1.0),(1,2,4.0),(1,3,1.0),(1,4,1.0),(1,5,3.0),(2,4,2.0),(2,5,3.0),(3,4,5.0),(3,5,1.0)]
graph.add_weighted_edges_from(edges)
graphs['custom'] = graph
#Display widget
display_maxcut_widget(graphs['custom'])
def maxcut_cost_fn(graph: nx.Graph, bitstring: List[int]) -> float:
"""
Computes the maxcut cost function value for a given graph and cut represented by some bitstring
Args:
graph: The graph to compute cut values for
bitstring: A list of integer values '0' or '1' specifying a cut of the graph
Returns:
The value of the cut
"""
#Get the weight matrix of the graph
weight_matrix = nx.adjacency_matrix(graph).toarray()
size = weight_matrix.shape[0]
value = 0.
#INSERT YOUR CODE TO COMPUTE THE CUT VALUE HERE
for i in range(size):
for j in range(size):
value += weight_matrix[i][j]*bitstring[i]*(1-bitstring[j])
return value
def plot_maxcut_histogram(graph: nx.Graph) -> None:
"""
Plots a bar diagram with the values for all possible cuts of a given graph.
Args:
graph: The graph to compute cut values for
"""
num_vars = graph.number_of_nodes()
#Create list of bitstrings and corresponding cut values
bitstrings = ['{:b}'.format(i).rjust(num_vars, '0')[::-1] for i in range(2**num_vars)]
values = [maxcut_cost_fn(graph = graph, bitstring = [int(x) for x in bitstring]) for bitstring in bitstrings]
#Sort both lists by largest cut value
values, bitstrings = zip(*sorted(zip(values, bitstrings)))
#Plot bar diagram
bar_plot = go.Bar(x = bitstrings, y = values, marker=dict(color=values, colorscale = 'plasma', colorbar=dict(title='Cut Value')))
fig = go.Figure(data=bar_plot, layout = dict(xaxis=dict(type = 'category'), width = 1500, height = 600))
fig.show()
plot_maxcut_histogram(graph = graphs['custom'])
from qc_grader import grade_lab2_ex1
bitstring = [1, 0, 1, 1, 0, 0] #DEFINE THE CORRECT MAXCUT BITSTRING HERE
# Note that the grading function is expecting a list of integers '0' and '1'
grade_lab2_ex1(bitstring)
from qiskit_optimization import QuadraticProgram
quadratic_program = QuadraticProgram('sample_problem')
print(quadratic_program.export_as_lp_string())
quadratic_program.binary_var(name = 'x_0')
quadratic_program.integer_var(name = 'x_1')
quadratic_program.continuous_var(name = 'x_2', lowerbound = -2.5, upperbound = 1.8)
quadratic = [[0,1,2],[3,4,5],[0,1,2]]
linear = [10,20,30]
quadratic_program.minimize(quadratic = quadratic, linear = linear, constant = -5)
print(quadratic_program.export_as_lp_string())
def quadratic_program_from_graph(graph: nx.Graph) -> QuadraticProgram:
"""Constructs a quadratic program from a given graph for a MaxCut problem instance.
Args:
graph: Underlying graph of the problem.
Returns:
QuadraticProgram
"""
#Get weight matrix of graph
weight_matrix = nx.adjacency_matrix(graph)
shape = weight_matrix.shape
size = shape[0]
#Build qubo matrix Q from weight matrix W
qubo_matrix = np.zeros((size, size))
for i in range(size):
for j in range(size):
qubo_matrix[i, j] -= weight_matrix[i, j]
#INSERT YOUR CODE HERE
#Define quadratic_program
quadratic_program = QuadraticProgram('quadratic_program_from_graph')
#Initiate binary variables
for i in range(size):
quadratic_program.binary_var(name = f'x_{i}')
#Build the qubo vector c_vector from weight matrix W
c_vector = np.zeros(size)
for i in range(size):
for j in range(size):
c_vector[i] += weight_matrix[i, j]
quadratic_program.maximize(quadratic = qubo_matrix, linear = c_vector)
return quadratic_program
quadratic_program = quadratic_program_from_graph(graphs['custom'])
print(quadratic_program.export_as_lp_string())
from qc_grader import grade_lab2_ex2
# Note that the grading function is expecting a quadratic program
grade_lab2_ex2(quadratic_program)
def qaoa_circuit(qubo: QuadraticProgram, p: int = 1):
"""
Given a QUBO instance and the number of layers p, constructs the corresponding parameterized QAOA circuit with p layers.
Args:
qubo: The quadratic program instance
p: The number of layers in the QAOA circuit
Returns:
The parameterized QAOA circuit
"""
size = len(qubo.variables)
qubo_matrix = qubo.objective.quadratic.to_array(symmetric=True)
qubo_linearity = qubo.objective.linear.to_array()
#Prepare the quantum and classical registers
qaoa_circuit = QuantumCircuit(size,size)
#Apply the initial layer of Hadamard gates to all qubits
qaoa_circuit.h(range(size))
#Create the parameters to be used in the circuit
gammas = ParameterVector('gamma', p)
betas = ParameterVector('beta', p)
#Outer loop to create each layer
for i in range(p):
#Apply R_Z rotational gates from cost layer
#INSERT YOUR CODE HERE
for j in range(size):
qubo_matrix_row_sum = 0
for k in range(size):
qubo_matrix_row_sum += qubo_matrix[j, k]
qaoa_circuit.rz((qubo_linearity[j]+qubo_matrix_row_sum)*gammas[i], j)
qaoa_circuit.barrier()
#Apply R_ZZ rotational gates for entangled qubit rotations from cost layer
#INSERT YOUR CODE HERE
for j in range(size):
for k in range(size):
if j>=k:
continue
qaoa_circuit.rzz(0.5*qubo_matrix[j, k]*gammas[i], j, k)
qaoa_circuit.barrier()
# Apply single qubit X - rotations with angle 2*beta_i to all qubits
#INSERT YOUR CODE HERE
for j in range(size):
qaoa_circuit.rx(2.0*betas[i], j)
qaoa_circuit.barrier()
return qaoa_circuit
quadratic_program = quadratic_program_from_graph(graphs['custom'])
custom_circuit = qaoa_circuit(qubo = quadratic_program)
test = custom_circuit.assign_parameters(parameters=[1.0]*len(custom_circuit.parameters))
custom_circuit.draw()
from qc_grader import grade_lab2_ex3
# Note that the grading function is expecting a quantum circuit
grade_lab2_ex3(test)
from qiskit.algorithms import QAOA
from qiskit_optimization.algorithms import MinimumEigenOptimizer
backend = Aer.get_backend('statevector_simulator')
qaoa = QAOA(optimizer = ADAM(), quantum_instance = backend, reps=1, initial_point = [0.1,0.1])
eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver = qaoa)
quadratic_program = quadratic_program_from_graph(graphs['custom'])
result = eigen_optimizer.solve(quadratic_program)
print(result)
def plot_samples(samples):
"""
Plots a bar diagram for the samples of a quantum algorithm
Args:
samples
"""
#Sort samples by probability
samples = sorted(samples, key = lambda x: x.probability)
#Get list of probabilities, function values and bitstrings
probabilities = [sample.probability for sample in samples]
values = [sample.fval for sample in samples]
bitstrings = [''.join([str(int(i)) for i in sample.x]) for sample in samples]
#Plot bar diagram
sample_plot = go.Bar(x = bitstrings, y = probabilities, marker=dict(color=values, colorscale = 'plasma',colorbar=dict(title='Function Value')))
fig = go.Figure(
data=sample_plot,
layout = dict(
xaxis=dict(
type = 'category'
)
)
)
fig.show()
plot_samples(result.samples)
graph_name = 'custom'
quadratic_program = quadratic_program_from_graph(graph=graphs[graph_name])
trajectory={'beta_0':[], 'gamma_0':[], 'energy':[]}
offset = 1/4*quadratic_program.objective.quadratic.to_array(symmetric = True).sum() + 1/2*quadratic_program.objective.linear.to_array().sum()
def callback(eval_count, params, mean, std_dev):
trajectory['beta_0'].append(params[1])
trajectory['gamma_0'].append(params[0])
trajectory['energy'].append(-mean + offset)
optimizers = {
'cobyla': COBYLA(),
'slsqp': SLSQP(),
'adam': ADAM()
}
qaoa = QAOA(optimizer = optimizers['cobyla'], quantum_instance = backend, reps=1, initial_point = [6.2,1.8],callback = callback)
eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver = qaoa)
result = eigen_optimizer.solve(quadratic_program)
fig = QAOA_widget(landscape_file=f'./resources/energy_landscapes/{graph_name}.csv', trajectory = trajectory, samples = result.samples)
fig.show()
graph_name = 'custom'
quadratic_program = quadratic_program_from_graph(graphs[graph_name])
#Create callback to record total number of evaluations
max_evals = 0
def callback(eval_count, params, mean, std_dev):
global max_evals
max_evals = eval_count
#Create empty lists to track values
energies = []
runtimes = []
num_evals=[]
#Run QAOA for different values of p
for p in range(1,10):
print(f'Evaluating for p = {p}...')
qaoa = QAOA(optimizer = optimizers['cobyla'], quantum_instance = backend, reps=p, callback=callback)
eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver = qaoa)
start = time()
result = eigen_optimizer.solve(quadratic_program)
runtimes.append(time()-start)
num_evals.append(max_evals)
#Calculate energy of final state from samples
avg_value = 0.
for sample in result.samples:
avg_value += sample.probability*sample.fval
energies.append(avg_value)
#Create and display plots
energy_plot = go.Scatter(x = list(range(1,10)), y =energies, marker=dict(color=energies, colorscale = 'plasma'))
runtime_plot = go.Scatter(x = list(range(1,10)), y =runtimes, marker=dict(color=runtimes, colorscale = 'plasma'))
num_evals_plot = go.Scatter(x = list(range(1,10)), y =num_evals, marker=dict(color=num_evals, colorscale = 'plasma'))
fig = make_subplots(rows = 1, cols = 3, subplot_titles = ['Energy value', 'Runtime', 'Number of evaluations'])
fig.update_layout(width=1800,height=600, showlegend=False)
fig.add_trace(energy_plot, row=1, col=1)
fig.add_trace(runtime_plot, row=1, col=2)
fig.add_trace(num_evals_plot, row=1, col=3)
clear_output()
fig.show()
def plot_qaoa_energy_landscape(graph: nx.Graph, cvar: float = None):
num_shots = 1000
seed = 42
simulator = Aer.get_backend('qasm_simulator')
simulator.set_options(seed_simulator = 42)
#Generate circuit
circuit = qaoa_circuit(qubo = quadratic_program_from_graph(graph), p=1)
circuit.measure(range(graph.number_of_nodes()),range(graph.number_of_nodes()))
#Create dictionary with precomputed cut values for all bitstrings
cut_values = {}
size = graph.number_of_nodes()
for i in range(2**size):
bitstr = '{:b}'.format(i).rjust(size, '0')[::-1]
x = [int(bit) for bit in bitstr]
cut_values[bitstr] = maxcut_cost_fn(graph, x)
#Perform grid search over all parameters
data_points = []
max_energy = None
for beta in np.linspace(0,np.pi, 50):
for gamma in np.linspace(0, 4*np.pi, 50):
bound_circuit = circuit.assign_parameters([beta, gamma])
result = simulator.run(bound_circuit, shots = num_shots).result()
statevector = result.get_counts(bound_circuit)
energy = 0
measured_cuts = []
for bitstring, count in statevector.items():
measured_cuts = measured_cuts + [cut_values[bitstring]]*count
if cvar is None:
#Calculate the mean of all cut values
energy = sum(measured_cuts)/num_shots
else:
# raise NotImplementedError()
# INSERT YOUR CODE HERE
measured_cuts.sort(reverse=True) # sort the measured_cuts in descending order
reduced_size = cvar*num_shots
energy = sum(measured_cuts[:int(reduced_size)])/(reduced_size) # average only from the reduced sample
#Update optimal parameters
if max_energy is None or energy > max_energy:
max_energy = energy
optimum = {'beta': beta, 'gamma': gamma, 'energy': energy}
#Update data
data_points.append({'beta': beta, 'gamma': gamma, 'energy': energy})
#Create and display surface plot from data_points
df = pd.DataFrame(data_points)
df = df.pivot(index='beta', columns='gamma', values='energy')
matrix = df.to_numpy()
beta_values = df.index.tolist()
gamma_values = df.columns.tolist()
surface_plot = go.Surface(
x=gamma_values,
y=beta_values,
z=matrix,
coloraxis = 'coloraxis'
)
fig = go.Figure(data = surface_plot)
fig.show()
#Return optimum
return optimum
graph = graphs['custom']
optimal_parameters = plot_qaoa_energy_landscape(graph = graph)
print('Optimal parameters:')
print(optimal_parameters)
optimal_parameters = plot_qaoa_energy_landscape(graph = graph, cvar = 0.2)
print(optimal_parameters)
from qc_grader import grade_lab2_ex4
# Note that the grading function is expecting a python dictionary
# with the entries 'beta', 'gamma' and 'energy'
grade_lab2_ex4(optimal_parameters)
|
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 Quantum Dynamics algorithm.
"""
import logging
from qiskit import QuantumRegister
from qiskit.aqua.algorithms import QuantumAlgorithm
from qiskit.aqua import AquaError, Pluggable, PluggableType, get_pluggable_class
logger = logging.getLogger(__name__)
class EOH(QuantumAlgorithm):
"""
The Quantum EOH (Evolution of Hamiltonian) algorithm.
"""
PROP_OPERATOR_MODE = 'operator_mode'
PROP_EVO_TIME = 'evo_time'
PROP_NUM_TIME_SLICES = 'num_time_slices'
PROP_EXPANSION_MODE = 'expansion_mode'
PROP_EXPANSION_ORDER = 'expansion_order'
CONFIGURATION = {
'name': 'EOH',
'description': 'Evolution of Hamiltonian for Quantum Systems',
'input_schema': {
'$schema': 'http://json-schema.org/schema#',
'id': 'EOH_schema',
'type': 'object',
'properties': {
PROP_OPERATOR_MODE: {
'type': 'string',
'default': 'paulis',
'oneOf': [
{'enum': [
'paulis',
'grouped_paulis',
'matrix'
]}
]
},
PROP_EVO_TIME: {
'type': 'number',
'default': 1,
'minimum': 0
},
PROP_NUM_TIME_SLICES: {
'type': 'integer',
'default': 1,
'minimum': 0
},
PROP_EXPANSION_MODE: {
'type': 'string',
'default': 'trotter',
'oneOf': [
{'enum': [
'trotter',
'suzuki'
]}
]
},
PROP_EXPANSION_ORDER: {
'type': 'integer',
'default': 1,
'minimum': 1
}
},
'additionalProperties': False
},
'problems': ['eoh'],
'depends': [
{'pluggable_type': 'initial_state',
'default': {
'name': 'ZERO'
}
},
],
}
def __init__(self, operator, initial_state, evo_operator, operator_mode='paulis', evo_time=1, num_time_slices=1,
expansion_mode='trotter', expansion_order=1):
self.validate(locals())
super().__init__()
self._operator = operator
self._operator_mode = operator_mode
self._initial_state = initial_state
self._evo_operator = evo_operator
self._evo_time = evo_time
self._num_time_slices = num_time_slices
self._expansion_mode = expansion_mode
self._expansion_order = expansion_order
self._ret = {}
@classmethod
def init_params(cls, params, algo_input):
"""
Initialize via parameters dictionary and algorithm input instance
Args:
params: parameters dictionary
algo_input: EnergyInput instance
"""
if algo_input is None:
raise AquaError("EnergyInput instance is required.")
# For getting the extra operator, caller has to do something like: algo_input.add_aux_op(evo_op)
operator = algo_input.qubit_op
aux_ops = algo_input.aux_ops
if aux_ops is None or len(aux_ops) != 1:
raise AquaError("EnergyInput, a single aux op is required for evaluation.")
evo_operator = aux_ops[0]
if evo_operator is None:
raise AquaError("EnergyInput, invalid aux op.")
dynamics_params = params.get(Pluggable.SECTION_KEY_ALGORITHM)
operator_mode = dynamics_params.get(EOH.PROP_OPERATOR_MODE)
evo_time = dynamics_params.get(EOH.PROP_EVO_TIME)
num_time_slices = dynamics_params.get(EOH.PROP_NUM_TIME_SLICES)
expansion_mode = dynamics_params.get(EOH.PROP_EXPANSION_MODE)
expansion_order = dynamics_params.get(EOH.PROP_EXPANSION_ORDER)
# Set up initial state, we need to add computed num qubits to params
initial_state_params = params.get(Pluggable.SECTION_KEY_INITIAL_STATE)
initial_state_params['num_qubits'] = operator.num_qubits
initial_state = get_pluggable_class(PluggableType.INITIAL_STATE,
initial_state_params['name']).init_params(params)
return cls(operator, initial_state, evo_operator, operator_mode, evo_time, num_time_slices,
expansion_mode=expansion_mode,
expansion_order=expansion_order)
def construct_circuit(self):
"""
Construct the circuit.
Returns:
QuantumCircuit: the circuit.
"""
quantum_registers = QuantumRegister(self._operator.num_qubits, name='q')
qc = self._initial_state.construct_circuit('circuit', quantum_registers)
qc += self._evo_operator.evolve(
evo_time=self._evo_time,
evo_mode='circuit',
num_time_slices=self._num_time_slices,
quantum_registers=quantum_registers,
expansion_mode=self._expansion_mode,
expansion_order=self._expansion_order,
)
return qc
def _run(self):
qc = self.construct_circuit()
qc_with_op = self._operator.construct_evaluation_circuit(
self._operator_mode, qc, self._quantum_instance.backend
)
result = self._quantum_instance.execute(qc_with_op)
self._ret['avg'], self._ret['std_dev'] = self._operator.evaluate_with_result(
self._operator_mode, qc_with_op, self._quantum_instance.backend, result
)
return self._ret
|
https://github.com/ernchern/qiskit-vaqsd
|
ernchern
|
import numpy as np
from qiskit import(
QuantumCircuit,
execute,
Aer)
from qiskit import IBMQ
IBMQ.save_account("e69e6c2e07ed86d44bf6ba9dc2db3c727e01eceeaea1d4d5508a8331a192d414336aeec995677836051acafd09a886485064a85f4931d2fbeee945d6ea16801b")
IBMQ.load_account()
def setQubit(circuit, a, b):
if b!=0 :
circuit.u3(2*np.arccos(a),np.arccos(np.real(b)/abs(b)),0,0)
else:
circuit.u3(2*np.arccos(a),0,0,0)
def addLayer(circuit, params, index):
circuit.u3(params[0],params[1],params[2],index)
def build_circuit(params, a_1, b_1, a_2, b_2, a_3, b_3, bias, shots = 1000, verbose = False):
'''
Inputs:
params: 4 by 3 array of nodes
shots: number of executions of the circuit
a_n and b_n : nth qubit's parameters
Output:
p_success: Success rate
p_inconclusive: Probability of getting the leftover output
'''
# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
# Create a Quantum Circuit acting on the q register
circuit1 = QuantumCircuit(2, 2)
circuit2 = QuantumCircuit(2, 2)
circuit3 = QuantumCircuit(2, 2)
#Set the quits
setQubit(circuit1, a_1, b_1)
setQubit(circuit2, a_2, b_2)
setQubit(circuit3, a_3, b_3)
params = params.reshape((4,3))
#"Neural layers"
addLayer(circuit1, params[0][:],0)
addLayer(circuit1, params[1][:],1)
addLayer(circuit2, params[0][:],0)
addLayer(circuit2, params[1][:],1)
addLayer(circuit3, params[0][:],0)
addLayer(circuit3, params[1][:],1)
# CNOT gate
circuit1.cx(0,1)
circuit2.cx(0,1)
circuit3.cx(0,1)
#"Neural layers"
addLayer(circuit1, params[2][:],0)
addLayer(circuit1, params[3][:],1)
addLayer(circuit2, params[2][:],0)
addLayer(circuit2, params[3][:],1)
addLayer(circuit3, params[2][:],0)
addLayer(circuit3, params[3][:],1)
#CNOT gate
circuit1.cx(1,0)
circuit2.cx(1,0)
circuit3.cx(1,0)
# Measure
circuit1.measure([0,1], [0,1])
circuit2.measure([0,1], [0,1])
circuit3.measure([0,1], [0,1])
# Execute the circuit on the qasm simulator
job1 = execute(circuit1, simulator, shots = shots)
job2 = execute(circuit2, simulator, shots = shots)
job3 = execute(circuit3, simulator, shots = shots)
# Grab results from the job
result1 = job1.result()
result2 = job2.result()
result3 = job3.result()
# Returns counts
counts1 = result1.get_counts(circuit1)
counts2 = result2.get_counts(circuit2)
counts3 = result3.get_counts(circuit3)
if verbose:
print(circuit1)
print(counts1)
print(circuit2)
print(counts2)
print(circuit3)
print(counts3)
for i in ['00', '01','10','11']:
if not i in counts1:
counts1[i] = 0
if not i in counts2:
counts2[i] = 0
if not i in counts3:
counts3[i] = 0
p_success = (counts1['00']+counts2['01']+counts3['10'])/(3*shots)
p_inconclusive = (counts1['11']+counts2['11']+counts3['11'])/(3*shots)
#obj_value = p_success / (p_inconclusive + bias*shots)
#obj_value = 1.5 * p_success - p_inconclusive
return (p_success, p_inconclusive)
|
https://github.com/mathelatics/QGSS-2023-From-Theory-to-Implementations
|
mathelatics
|
import qiskit
qiskit.__qiskit_version__
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# importing Qiskit
from qiskit import BasicAer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.compiler import transpile
from qiskit.tools.visualization import plot_histogram
q = QuantumRegister(6)
qc = QuantumCircuit(q)
qc.x(q[2])
qc.cx(q[1], q[5])
qc.cx(q[2], q[5])
qc.cx(q[3], q[5])
qc.ccx(q[1], q[2], q[4])
qc.ccx(q[3], q[4], q[5])
qc.ccx(q[1], q[2], q[4])
qc.x(q[2])
qc.draw(output='mpl')
def black_box_u_f(circuit, f_in, f_out, aux, n, exactly_1_3_sat_formula):
"""Circuit that computes the black-box function from f_in to f_out.
Create a circuit that verifies whether a given exactly-1 3-SAT
formula is satisfied by the input. The exactly-1 version
requires exactly one literal out of every clause to be satisfied.
"""
num_clauses = len(exactly_1_3_sat_formula)
for (k, clause) in enumerate(exactly_1_3_sat_formula):
# This loop ensures aux[k] is 1 if an odd number of literals
# are true
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
# Flip aux[k] if all literals are true, using auxiliary qubit
# (ancilla) aux[num_clauses]
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
# Flip back to reverse state of negative literals and ancilla
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
# The formula is satisfied if and only if all auxiliary qubits
# except aux[num_clauses] are 1
if (num_clauses == 1):
circuit.cx(aux[0], f_out[0])
elif (num_clauses == 2):
circuit.ccx(aux[0], aux[1], f_out[0])
elif (num_clauses == 3):
circuit.ccx(aux[0], aux[1], aux[num_clauses])
circuit.ccx(aux[2], aux[num_clauses], f_out[0])
circuit.ccx(aux[0], aux[1], aux[num_clauses])
else:
raise ValueError('We only allow at most 3 clauses')
# Flip back any auxiliary qubits to make sure state is consistent
# for future executions of this routine; same loop as above.
for (k, clause) in enumerate(exactly_1_3_sat_formula):
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
# -- end function
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)
# -- end function
def inversion_about_average(circuit, f_in, n):
"""Apply inversion about the average step of Grover's algorithm."""
# Hadamards everywhere
for j in range(n):
circuit.h(f_in[j])
# D matrix: flips the sign of the state |000> only
for j in range(n):
circuit.x(f_in[j])
n_controlled_Z(circuit, [f_in[j] for j in range(n-1)], f_in[n-1])
for j in range(n):
circuit.x(f_in[j])
# Hadamards everywhere again
for j in range(n):
circuit.h(f_in[j])
# -- end function
qr = QuantumRegister(3)
qInvAvg = QuantumCircuit(qr)
inversion_about_average(qInvAvg, qr, 3)
qInvAvg.draw(output='mpl')
"""
Grover search implemented in Qiskit.
This module contains the code necessary to run Grover search on 3
qubits, both with a simulator and with a real quantum computing
device. This code is the companion for the paper
"An introduction to quantum computing, without the physics",
Giacomo Nannicini, https://arxiv.org/abs/1708.03684.
"""
def input_state(circuit, f_in, f_out, n):
"""(n+1)-qubit input state for Grover search."""
for j in range(n):
circuit.h(f_in[j])
circuit.x(f_out)
circuit.h(f_out)
# -- end function
# Make a quantum program for the n-bit Grover search.
n = 3
# Exactly-1 3-SAT formula to be satisfied, in conjunctive
# normal form. We represent literals with integers, positive or
# negative, to indicate a Boolean variable or its negation.
exactly_1_3_sat_formula = [[1, 2, -3], [-1, -2, -3], [-1, 2, 3]]
# Define three quantum registers: 'f_in' is the search space (input
# to the function f), 'f_out' is bit used for the output of function
# f, aux are the auxiliary bits used by f to perform its
# computation.
f_in = QuantumRegister(n)
f_out = QuantumRegister(1)
aux = QuantumRegister(len(exactly_1_3_sat_formula) + 1)
# Define classical register for algorithm result
ans = ClassicalRegister(n)
# Define quantum circuit with above registers
grover = QuantumCircuit()
grover.add_register(f_in)
grover.add_register(f_out)
grover.add_register(aux)
grover.add_register(ans)
input_state(grover, f_in, f_out, n)
T = 2
for t in range(T):
# Apply T full iterations
black_box_u_f(grover, f_in, f_out, aux, n, exactly_1_3_sat_formula)
inversion_about_average(grover, f_in, n)
# Measure the output register in the computational basis
for j in range(n):
grover.measure(f_in[j], ans[j])
# Execute circuit
backend = BasicAer.get_backend('qasm_simulator')
job = execute([grover], backend=backend, shots=1000)
result = job.result()
# Get counts and plot histogram
counts = result.get_counts(grover)
plot_histogram(counts)
IBMQ.load_account()
# get ibmq_16_melbourne configuration and coupling map
backend = IBMQ.get_backend('ibmq_16_melbourne')
# compile the circuit for ibmq_16_rueschlikon
grover_compiled = transpile(grover, backend=backend, seed_transpiler=1, optimization_level=3)
print('gates = ', grover_compiled.count_ops())
print('depth = ', grover_compiled.depth())
grover.draw(output='mpl', scale=0.5)
|
https://github.com/mnp-club/Quantum_Computing_Workshop_2020
|
mnp-club
|
from qiskit import *
from qiskit.compiler import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import numpy as np
from IPython.display import display, Math, Latex
%matplotlib inline
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
qc1=QuantumCircuit(2)
qc1.h(0)
qc1.h(1)
qc1.barrier() #The part between the barriers is our oracle
qc1.cz(0,1)
#We are using a controlled-Z gate which flips the sign of the second qubit when both qubits are set to '1'
qc1.barrier()
qc1.draw('mpl')
def final_vector(qc):
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
outputstate = result.get_statevector(qc, decimals=3)
return outputstate
print(final_vector(qc1)) #We can see that the desired state has been obtained
qc2=QuantumCircuit(3)
qc2.h(0)
qc2.h(1)
qc2.h(2)
qc2.barrier()
#The part between the barriers is our oracle
qc2.x(0)
qc2.h(1)
qc2.x(2)
qc2.ccx(0, 2, 1)
qc2.x(0)
qc2.h(1)
qc2.x(2)
qc2.barrier()
qc2.draw('mpl')
def final_vector(qc):
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
outputstate = result.get_statevector(qc, decimals=3)
return outputstate
print(final_vector(qc2))
def ccz_gate(qc,a,b,c):
qc.h(c)
qc.ccx(a,b,c)
qc.h(c)
#Let's create an oracle which will mark the states 101 and 110
#(This particular oracle won't be using ancilla qubits)
def phase_oracle(circuit):
circuit.cz(0, 2)
circuit.cz(0, 1)
n=3
qc2=QuantumCircuit(n,n)
for i in range(0,n):
qc2.h(i)
qc2.barrier([0,1,2])
#This creates a superposition of all states
#We will now perform the Grover iteration
phase_oracle(qc2)
qc2.barrier([0,1,2])
for i in range(0,n):
qc2.h(i)
#Performing a conditional phase shift
qc2.x(0)
qc2.x(1)
qc2.x(2)
ccz_gate(qc2,0,1,2)
qc2.x(0)
qc2.x(1)
qc2.x(2)
for i in range(0,n):
qc2.h(i)
#The Grover iteration is now complete
qc2.barrier([0,1,2])
qc2.draw('mpl')
qc2.measure(0,0)
qc2.measure(1,1)
qc2.measure(2,2)
qc2.draw('mpl')
def counts_circ(circ):
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(circ, backend_sim, shots=2000)
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
return(counts)
plot_histogram(counts_circ(qc2))
qc_mct=QuantumCircuit(5,5)
for i in range(0,4):
qc_mct.x(i)
qc_mct.mct([0,1,2,3],4)
qc_mct.draw('mpl')
qc_mct.measure(0,0)
qc_mct.measure(1,1)
qc_mct.measure(2,2)
qc_mct.measure(3,3)
qc_mct.measure(4,4)
plot_histogram(counts_circ(qc_mct))
def c3z_gate(qc, a, b, c, d):
qc.h(d)
qc.mct([a, b, c], d)
qc.h(d)
def phase_oracle(qc):
qc.x(1)
qc.x(3)
c3z_gate(qc, 0, 1, 2, 3) # Handles 1010
qc.x(2)
c3z_gate(qc, 0, 1, 2, 3) # Handles 1000
qc.x(3)
c3z_gate(qc, 0, 1, 2, 3) # Handles 1001
qc.x(2)
qc.x(0)
qc.x(3)
c3z_gate(qc, 0, 1, 2, 3) # Handles 0010
qc.x(0)
qc.x(1)
qc.x(3)
n = 4
qc3 = QuantumCircuit(n, n)
for i in range(0,n):
qc3.h(i)
qc3.barrier([0, 1, 2, 3])
phase_oracle(qc3)
qc3.barrier([0, 1, 2, 3])
for i in range(0,n):
qc3.h(i)
qc3.x(0)
qc3.x(1)
qc3.x(2)
qc3.x(3)
c3z_gate(qc3, 0, 1, 2, 3)
qc3.x(0)
qc3.x(1)
qc3.x(2)
qc3.x(3)
for i in range(0,n):
qc3.h(i)
qc3.barrier([0, 1, 2, 3])
qc3.measure(0, 0)
qc3.measure(1, 1)
qc3.measure(2, 2)
qc3.measure(3, 3)
qc3.draw('mpl')
def counts_circ(circ):
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(circ, backend_sim, shots=2000)
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
return(counts)
plot_histogram(counts_circ(qc3))
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# 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.
"""Disassemble function for a qobj into a list of circuits and its config"""
from typing import Any, Dict, List, NewType, Tuple, Union
import collections
import math
from qiskit import pulse
from qiskit.circuit.classicalregister import ClassicalRegister
from qiskit.circuit.instruction import Instruction
from qiskit.circuit.quantumcircuit import QuantumCircuit
from qiskit.circuit.quantumregister import QuantumRegister
from qiskit.qobj import PulseQobjInstruction
from qiskit.qobj.converters import QobjToInstructionConverter
# A ``CircuitModule`` is a representation of a circuit execution on the backend.
# It is currently a list of quantum circuits to execute, a run Qobj dictionary
# and a header dictionary.
CircuitModule = NewType(
"CircuitModule", Tuple[List[QuantumCircuit], Dict[str, Any], Dict[str, Any]]
)
# A ``PulseModule`` is a representation of a pulse execution on the backend.
# It is currently a list of pulse schedules to execute, a run Qobj dictionary
# and a header dictionary.
PulseModule = NewType("PulseModule", Tuple[List[pulse.Schedule], Dict[str, Any], Dict[str, Any]])
def disassemble(qobj) -> Union[CircuitModule, PulseModule]:
"""Disassemble a qobj and return the circuits or pulse schedules, run_config, and user header.
.. note::
``disassemble(assemble(qc))`` is not guaranteed to produce an exactly equal circuit to the
input, due to limitations in the :obj:`.QasmQobj` format that need to be maintained for
backend system compatibility. This is most likely to be the case when using newer features
of :obj:`.QuantumCircuit`. In most cases, the output should be equivalent, if not quite
equal.
Args:
qobj (Qobj): The input qobj object to disassemble
Returns:
Union[CircuitModule, PulseModule]: The disassembled program which consists of:
* programs: A list of quantum circuits or pulse schedules
* run_config: The dict of the run config
* user_qobj_header: The dict of any user headers in the qobj
Examples:
.. code-block:: python
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.compiler.assembler import assemble
from qiskit.assembler.disassemble import disassemble
# Create a circuit to assemble into a qobj
q = QuantumRegister(2)
c = ClassicalRegister(2)
qc = QuantumCircuit(q, c)
qc.h(q[0])
qc.cx(q[0], q[1])
qc.measure(q, c)
# Assemble the circuit into a Qobj
qobj = assemble(qc, shots=2000, memory=True)
# Disassemble the qobj back into a circuit
circuits, run_config_out, headers = disassemble(qobj)
"""
if qobj.type == "PULSE":
return _disassemble_pulse_schedule(qobj)
else:
return _disassemble_circuit(qobj)
def _disassemble_circuit(qobj) -> CircuitModule:
run_config = qobj.config.to_dict()
# convert lo freq back to Hz
qubit_lo_freq = run_config.get("qubit_lo_freq", [])
if qubit_lo_freq:
run_config["qubit_lo_freq"] = [freq * 1e9 for freq in qubit_lo_freq]
meas_lo_freq = run_config.get("meas_lo_freq", [])
if meas_lo_freq:
run_config["meas_lo_freq"] = [freq * 1e9 for freq in meas_lo_freq]
user_qobj_header = qobj.header.to_dict()
return CircuitModule((_experiments_to_circuits(qobj), run_config, user_qobj_header))
def _qobj_to_circuit_cals(qobj, pulse_lib):
"""Return circuit calibrations dictionary from qobj/exp config calibrations."""
qobj_cals = qobj.config.calibrations.to_dict()["gates"]
converter = QobjToInstructionConverter(pulse_lib)
qc_cals = {}
for gate in qobj_cals:
config = (tuple(gate["qubits"]), tuple(gate["params"]))
cal = {
config: pulse.Schedule(
name="{} {} {}".format(gate["name"], str(gate["params"]), str(gate["qubits"]))
)
}
for instruction in gate["instructions"]:
qobj_instruction = PulseQobjInstruction.from_dict(instruction)
schedule = converter(qobj_instruction)
cal[config] = cal[config].insert(schedule.ch_start_time(), schedule)
if gate["name"] in qc_cals:
qc_cals[gate["name"]].update(cal)
else:
qc_cals[gate["name"]] = cal
return qc_cals
def _experiments_to_circuits(qobj):
"""Return a list of QuantumCircuit object(s) from a qobj.
Args:
qobj (Qobj): The Qobj object to convert to QuantumCircuits
Returns:
list: A list of QuantumCircuit objects from the qobj
"""
if not qobj.experiments:
return None
circuits = []
for exp in qobj.experiments:
quantum_registers = [QuantumRegister(i[1], name=i[0]) for i in exp.header.qreg_sizes]
classical_registers = [ClassicalRegister(i[1], name=i[0]) for i in exp.header.creg_sizes]
circuit = QuantumCircuit(*quantum_registers, *classical_registers, name=exp.header.name)
qreg_dict = collections.OrderedDict()
creg_dict = collections.OrderedDict()
for reg in quantum_registers:
qreg_dict[reg.name] = reg
for reg in classical_registers:
creg_dict[reg.name] = reg
conditional = {}
for i in exp.instructions:
name = i.name
qubits = []
params = getattr(i, "params", [])
try:
for qubit in i.qubits:
qubit_label = exp.header.qubit_labels[qubit]
qubits.append(qreg_dict[qubit_label[0]][qubit_label[1]])
except Exception: # pylint: disable=broad-except
pass
clbits = []
try:
for clbit in i.memory:
clbit_label = exp.header.clbit_labels[clbit]
clbits.append(creg_dict[clbit_label[0]][clbit_label[1]])
except Exception: # pylint: disable=broad-except
pass
if hasattr(circuit, name):
instr_method = getattr(circuit, name)
if i.name in ["snapshot"]:
_inst = instr_method(
i.label, snapshot_type=i.snapshot_type, qubits=qubits, params=params
)
elif i.name == "initialize":
_inst = instr_method(params, qubits)
elif i.name == "isometry":
_inst = instr_method(*params, qubits, clbits)
elif i.name in ["mcx", "mcu1", "mcp"]:
_inst = instr_method(*params, qubits[:-1], qubits[-1], *clbits)
else:
_inst = instr_method(*params, *qubits, *clbits)
elif name == "bfunc":
conditional["value"] = int(i.val, 16)
full_bit_size = sum(creg_dict[x].size for x in creg_dict)
mask_map = {}
raw_map = {}
raw = []
for creg in creg_dict:
size = creg_dict[creg].size
reg_raw = [1] * size
if not raw:
raw = reg_raw
else:
for pos, val in enumerate(raw):
if val == 1:
raw[pos] = 0
raw = reg_raw + raw
mask = [0] * (full_bit_size - len(raw)) + raw
raw_map[creg] = mask
mask_map[int("".join(str(x) for x in mask), 2)] = creg
if bin(int(i.mask, 16)).count("1") == 1:
# The condition is on a single bit. This might be a single-bit condition, or it
# might be a register of length one. The case that it's a single-bit condition
# in a register of length one is ambiguous, and we choose to return a condition
# on the register. This may not match the input circuit exactly, but is at
# least equivalent.
cbit = int(math.log2(int(i.mask, 16)))
for reg in creg_dict.values():
size = reg.size
if cbit >= size:
cbit -= size
else:
conditional["register"] = reg if reg.size == 1 else reg[cbit]
break
mask_str = bin(int(i.mask, 16))[2:].zfill(full_bit_size)
mask = [int(item) for item in list(mask_str)]
else:
creg = mask_map[int(i.mask, 16)]
conditional["register"] = creg_dict[creg]
mask = raw_map[creg]
val = int(i.val, 16)
for j in reversed(mask):
if j == 0:
val = val >> 1
else:
conditional["value"] = val
break
else:
_inst = temp_opaque_instruction = Instruction(
name=name, num_qubits=len(qubits), num_clbits=len(clbits), params=params
)
circuit.append(temp_opaque_instruction, qubits, clbits)
if conditional and name != "bfunc":
_inst.c_if(conditional["register"], conditional["value"])
conditional = {}
pulse_lib = qobj.config.pulse_library if hasattr(qobj.config, "pulse_library") else []
# The dict update method did not work here; could investigate in the future
if hasattr(qobj.config, "calibrations"):
circuit.calibrations = dict(
**circuit.calibrations, **_qobj_to_circuit_cals(qobj, pulse_lib)
)
if hasattr(exp.config, "calibrations"):
circuit.calibrations = dict(
**circuit.calibrations, **_qobj_to_circuit_cals(exp, pulse_lib)
)
circuits.append(circuit)
return circuits
def _disassemble_pulse_schedule(qobj) -> PulseModule:
run_config = qobj.config.to_dict()
run_config.pop("pulse_library")
qubit_lo_freq = run_config.get("qubit_lo_freq")
if qubit_lo_freq:
run_config["qubit_lo_freq"] = [freq * 1e9 for freq in qubit_lo_freq]
meas_lo_freq = run_config.get("meas_lo_freq")
if meas_lo_freq:
run_config["meas_lo_freq"] = [freq * 1e9 for freq in meas_lo_freq]
user_qobj_header = qobj.header.to_dict()
# extract schedule lo settings
schedule_los = []
for program in qobj.experiments:
program_los = {}
if hasattr(program, "config"):
if hasattr(program.config, "qubit_lo_freq"):
for i, lo in enumerate(program.config.qubit_lo_freq):
program_los[pulse.DriveChannel(i)] = lo * 1e9
if hasattr(program.config, "meas_lo_freq"):
for i, lo in enumerate(program.config.meas_lo_freq):
program_los[pulse.MeasureChannel(i)] = lo * 1e9
schedule_los.append(program_los)
if any(schedule_los):
run_config["schedule_los"] = schedule_los
return PulseModule((_experiments_to_schedules(qobj), run_config, user_qobj_header))
def _experiments_to_schedules(qobj) -> List[pulse.Schedule]:
"""Return a list of :class:`qiskit.pulse.Schedule` object(s) from a qobj.
Args:
qobj (Qobj): The Qobj object to convert to pulse schedules.
Returns:
A list of :class:`qiskit.pulse.Schedule` objects from the qobj
Raises:
pulse.PulseError: If a parameterized instruction is supplied.
"""
converter = QobjToInstructionConverter(qobj.config.pulse_library)
schedules = []
for program in qobj.experiments:
insts = []
for inst in program.instructions:
insts.append(converter(inst))
schedule = pulse.Schedule(*insts)
schedules.append(schedule)
return schedules
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.drivers import PySCFDriver
driver = PySCFDriver()
problem = driver.run()
fermionic_op = problem.hamiltonian.second_q_op()
from qiskit_nature.second_q.mappers import JordanWignerMapper
mapper = JordanWignerMapper()
qubit_jw_op = mapper.map(fermionic_op)
print(qubit_jw_op)
from qiskit_nature.second_q.mappers import ParityMapper
mapper = ParityMapper()
qubit_p_op = mapper.map(fermionic_op)
print(qubit_p_op)
mapper = ParityMapper(num_particles=problem.num_particles)
qubit_op = mapper.map(fermionic_op)
print(qubit_op)
tapered_mapper = problem.get_tapered_mapper(mapper)
print(type(tapered_mapper))
qubit_op = tapered_mapper.map(fermionic_op)
print(qubit_op)
from qiskit_nature.second_q.circuit.library import HartreeFock
hf_state = HartreeFock(2, (1, 1), JordanWignerMapper())
hf_state.draw()
from qiskit_nature.second_q.mappers import InterleavedQubitMapper
interleaved_mapper = InterleavedQubitMapper(JordanWignerMapper())
hf_state = HartreeFock(2, (1, 1), interleaved_mapper)
hf_state.draw()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
# Build a quantum circuit
circuit = QuantumCircuit(3, 3)
circuit.x(1)
circuit.h(range(3))
circuit.cx(0, 1)
circuit.measure(range(3), range(3));
print(circuit)
circuit.draw()
# Matplotlib Drawing
circuit.draw(output='mpl')
# Draw a new circuit with barriers and more registers
q_a = QuantumRegister(3, name='qa')
q_b = QuantumRegister(5, name='qb')
c_a = ClassicalRegister(3)
c_b = ClassicalRegister(5)
circuit = QuantumCircuit(q_a, q_b, c_a, c_b)
circuit.x(q_a[1])
circuit.x(q_b[1])
circuit.x(q_b[2])
circuit.x(q_b[4])
circuit.barrier()
circuit.h(q_a)
circuit.barrier(q_a)
circuit.h(q_b)
circuit.cswap(q_b[0], q_b[1], q_b[2])
circuit.cswap(q_b[2], q_b[3], q_b[4])
circuit.cswap(q_b[3], q_b[4], q_b[0])
circuit.barrier(q_b)
circuit.measure(q_a, c_a)
circuit.measure(q_b, c_b);
# Draw the circuit
circuit.draw(output='mpl')
# Draw the circuit with reversed bit order
circuit.draw(output='mpl', reverse_bits=True)
# Draw the circuit without barriers
circuit.draw(output='mpl', plot_barriers=False)
# Draw the circuit without barriers and reverse bit order
circuit.draw(output='mpl', plot_barriers=False, reverse_bits=True)
# Set line length to 80 for above circuit
circuit.draw(output='text')
# Change the background color in mpl
style = {'backgroundcolor': 'lightgreen'}
circuit.draw(output='mpl', style=style)
# Scale the mpl output to 1/2 the normal size
circuit.draw(output='mpl', scale=0.5)
from qiskit.tools.visualization import circuit_drawer
circuit_drawer(circuit, output='mpl', plot_barriers=False)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from trebugger import TreBugger
from qiskit.circuit.random import random_circuit
from qiskit.test.mock import FakeCasablanca
from qiskit import transpile
rc = random_circuit(num_qubits = 5, depth = 10)
casb = FakeCasablanca()
trb = TreBugger()
trb.debug(rc,casb,1)
circs = []
for depth in range(5,40,5):
circs.append(random_circuit(num_qubits = 7, depth = depth, seed = depth))
circs[0].draw('mpl',scale = 0.4)
import time
trb = TreBugger()
depths = []
trb_times, transpile_times = [], []
for i in range(len(circs)):
circuit = circs[i]
t_times, tb_times = 0, 0
# do 5 experiments
for i in range(5):
t1 = time.time()
transpile(circuits = circuit, backend = casb, optimization_level = 1, seed_transpiler = 412)
t2 = time.time()
t_times+= round(t2-t1,3)
t1 = time.time()
trb.debug(circuit, casb, 1,seed = 412, disp = False)
t2 = time.time()
tb_times += round((t2-t1),3)
transpile_times.append(round(t_times/5,4))
trb_times.append(round(tb_times/5,4))
depths.append(circuit.depth())
import matplotlib.pyplot as plt
plt.figure(figsize = (9,8))
plt.title("Execution times for variable depth circuits with opt_level = 1")
plt.xlabel("Depths", fontsize = 15)
plt.ylabel("Execution time (sec)", fontsize = 15)
plt.plot(depths, trb_times, marker = 's', color = 'cyan', alpha = 0.6, label = 'Trebugger time')
plt.plot(depths, transpile_times, marker = 's', color = 'orange', alpha = 0.6, label = 'Transpiler time')
plt.legend()
plt.grid()
plt.savefig("Varied Depth opt-level1.png", dpi = 250)
from qiskit import Aer
backend = Aer.get_backend('qasm_simulator')
circs = []
for q in range(5,25,2):
circs.append(random_circuit(num_qubits = q, depth = 30, seed = q))
circs[0].draw('mpl',scale = 0.4)
import time
trb = TreBugger()
qubits = []
trb_times_q, transpile_times_q = [], []
for i in range(len(circs)):
circuit = circs[i]
q = len(circuit.qubits)
t_times, tr_times = 0,0
for i in range(5):
# transpile
t1 = time.time()
transpile(circuits = circuit, backend = backend, optimization_level = 1, seed_transpiler = q)
t2 = time.time()
t_times += round(t2-t1,3)
# debug
t1 = time.time()
trb.debug(circuit, backend, 1,seed = q, disp = False)
t2 = time.time()
tr_times += round(t2-t1,3)
transpile_times_q.append(round(t_times/5,3))
trb_times_q.append(round(tr_times/5,3))
qubits.append(q)
import matplotlib.pyplot as plt
plt.figure(figsize = (9,8))
plt.title("Execution times for variable qubit circuits with opt_level = 1")
plt.xlabel("Qubits", fontsize = 15)
plt.ylabel("Execution time (sec)", fontsize = 15)
plt.plot(qubits, trb_times_q, marker = 's', color = 'red', alpha = 0.6, label = 'Trebugger time')
plt.plot(qubits, transpile_times_q, marker = 's', color = 'grey', alpha = 0.6, label = 'Transpiler time')
plt.legend()
plt.grid()
plt.savefig("Varied qubits depth 30.png", dpi = 200)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import pulse
d0 = pulse.DriveChannel(0)
x90 = pulse.Gaussian(10, 0.1, 3)
x180 = pulse.Gaussian(10, 0.2, 3)
with pulse.build() as hahn_echo:
with pulse.align_equispaced(duration=100):
pulse.play(x90, d0)
pulse.play(x180, d0)
pulse.play(x90, d0)
hahn_echo.draw()
|
https://github.com/mcoggins96/Quantum-Computing-UK-Repository
|
mcoggins96
|
from qiskit import QuantumRegister
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, execute,IBMQ
from qiskit.tools.monitor import job_monitor
print('\nPhase Flip Code')
print('----------------')
IBMQ.enable_account('ENTER API KEY HERE')
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_qasm_simulator')
q = QuantumRegister(3,'q')
c = ClassicalRegister(1,'c')
circuit = QuantumCircuit(q,c)
circuit.cx(q[0],q[1])
circuit.cx(q[0],q[2])
circuit.h(q[0])
circuit.h(q[1])
circuit.h(q[2])
circuit.z(q[0]) #Add this to simulate a phase flip error
circuit.h(q[0])
circuit.h(q[1])
circuit.h(q[2])
circuit.cx(q[0],q[1])
circuit.cx(q[0],q[2])
circuit.ccx(q[2],q[1],q[0])
circuit.measure(q[0],c[0])
job = execute(circuit, backend, shots=1000)
job_monitor(job)
counts = job.result().get_counts()
print("\nPhase flip code with error")
print("----------------------")
print(counts)
input()
|
https://github.com/samabwhite/Grover-Search-Implementation
|
samabwhite
|
from qiskit import QuantumCircuit
from qiskit.tools.visualization import circuit_drawer
import numpy as np
from matplotlib import pyplot as plt
n=5
qc = QuantumCircuit(n)
qc.x(1)
qc.ccx(0, 1, 3)
qc.ccx(2, 3, 4)
qc.ccx(0, 1, 3)
qc.x(1)
qc.draw('mpl')
def phase_oracle(n, name = 'Uf'):
qc = QuantumCircuit(n, name = name)
qc.x(1)
qc.ccx(0, 1, 3)
qc.ccx(2, 3, 4)
qc.ccx(0, 1, 3)
qc.x(1)
return qc
n=5
qc = QuantumCircuit(n)
for i in range(n-2):
qc.x(i)
qc.ccx(0, 1, 3)
qc.ccx(2, 3, 4)
qc.ccx(0, 1, 3)
for i in range(n-2):
qc.x(i)
qc.draw('mpl')
def diffuser(n, name= 'V'):
qc = QuantumCircuit(n, name =name)
for qb in range(n-2): # First layer of Hadamards in diffuser
qc.h(qb)
for i in range(n-2):
qc.x(i)
qc.ccx(0, 1, 3)
qc.ccx(2, 3, 4)
qc.ccx(0, 1, 3)
for i in range(n-2):
qc.x(i)
for qb in range(n-2): # Second layer of Hadamards in diffuser
qc.h(qb)
return qc
n=5
gr = QuantumCircuit(n, n-2)
mu = 1 #number of solutions
r = int(np.floor(np.pi/4*np.sqrt(2**(n-2)/mu))) #determine r
print('r = ',r)
gr.h(range(n-2)) #step1: apply Hadamard gates on all working qubits
#put ancilla in state |->
gr.x(n-1)
gr.h(n-1)
#step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr.append(phase_oracle(n), range(n))
gr.append(diffuser(n), range(n))
gr.measure(range(n-2), range(n-2)) #step 3: measure all qubits
gr.draw('mpl')
from qiskit import BasicAer, Aer, execute, IBMQ
from qiskit.visualization import plot_histogram
simulator = Aer.get_backend('qasm_simulator')
result = execute(gr, backend = simulator, shots = 1024).result()
counts = result.get_counts()
plot_histogram(counts)
from qiskit import IBMQ
IBMQ.save_account('e19ab1a54fb68a1937a725b48b02eafb8af0db9189107e78762686e5bf12dff5642e1597470d966ea9d2e121cc86f4a0f08bea5d5e760de66c7be7be04fd2974')
IBMQ.load_account()
provider = IBMQ.get_provider(hub = 'ibm-q')
device = provider.get_backend('ibmq_qasm_simulator')
job = execute(gr, backend=device, shots=1024)
print(job.job_id())
from qiskit.tools.monitor import job_monitor
job_monitor(job)
device_result = job.result()
plot_histogram(device_result.get_counts(gr))
|
https://github.com/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.
""" Test qclib.gate.mcg """
from unittest import TestCase
import numpy as np
from scipy.stats import unitary_group
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
from qclib.util import get_cnot_count, get_depth
from qclib.gates.mcg import Mcg
# pylint: disable=maybe-no-member
# pylint: disable=missing-function-docstring
# pylint: disable=missing-class-docstring
class TestMcg(TestCase):
""" Testing qclib.gate.mcg """
def _build_su2_circuit(self, alpha, beta, n_qubits):
length = np.linalg.norm([alpha, beta])
su2 = np.array([
[alpha, -np.conj(beta)],
[beta, np.conj(alpha)]
]) / length
return self._build_circuit(su2, n_qubits)
def _build_circuit(self, unitary, n_qubits):
mcg_circuit = QuantumCircuit(n_qubits)
qiskit_circuit = QuantumCircuit(1)
if n_qubits > 1:
controls = list(range(n_qubits - 1))
target = n_qubits - 1
ctrl_state = f"{np.random.randint(2**(n_qubits - 1)):0{n_qubits - 1}b}"
mcg_circuit = Mcg(unitary, len(controls), ctrl_state=ctrl_state).definition
qiskit_circuit.unitary(unitary, 0)
qiskit_circuit = qiskit_circuit.control(
num_ctrl_qubits=n_qubits - 1, ctrl_state=ctrl_state
)
else:
mcg_circuit = Mcg(unitary, 0).definition
qiskit_circuit.unitary(unitary, 0)
return mcg_circuit, qiskit_circuit
def _su2_count(self, alpha, beta, n_qubits):
mcg_circuit, qiskit_circuit = self._build_su2_circuit(alpha, beta, n_qubits)
# Count cnots
mcg_cx = get_cnot_count(mcg_circuit)
qiskit_cx = get_cnot_count(qiskit_circuit)
self.assertTrue(mcg_cx <= qiskit_cx)
def _su2_depth(self, alpha, beta, n_qubits):
mcg_circuit, qiskit_circuit = self._build_su2_circuit(alpha, beta, n_qubits)
# Count cnots
mcg_dp = get_depth(mcg_circuit)
qiskit_dp = get_depth(qiskit_circuit)
self.assertTrue(mcg_dp <= qiskit_dp)
def _su2_compare(self, alpha, beta, n_qubits):
mcg_circuit, qiskit_circuit = self._build_su2_circuit(alpha, beta, n_qubits)
# Compare
mcg_op = Operator(mcg_circuit).data
qiskit_op = Operator(qiskit_circuit).data
self.assertTrue(np.allclose(mcg_op, qiskit_op))
def _u2_count(self, unitary, n_qubits):
mcg_circuit, qiskit_circuit = self._build_circuit(unitary, n_qubits)
# Count cnots
mcg_cx = get_cnot_count(mcg_circuit)
'''
Exact number of CNOTs for the Linear U(2) Decomposition as described
in "Linear-depth quantum circuits for multiqubit controlled gates"
https://arxiv.org/abs/2203.11882
4n^2 - 12n + 10
'''
estimate = 4*n_qubits**2 - 12*n_qubits + 10
self.assertTrue(mcg_cx <= estimate)
def _u2_compare(self, unitary, n_qubits):
mcg_circuit, qiskit_circuit = self._build_circuit(unitary, n_qubits)
# Compare
mcg_op = Operator(mcg_circuit).data
qiskit_op = Operator(qiskit_circuit).data
self.assertTrue(np.allclose(mcg_op, qiskit_op))
def test_su2_sec_diag_real(self):
alpha = np.random.rand() + 1.j * np.random.rand()
beta = np.random.rand()
for n_qubits in range(1, 8):
self._su2_compare(alpha, beta, n_qubits)
self._su2_count(alpha, beta, n_qubits)
def test_su2_pri_diag_real(self):
alpha = np.random.rand()
beta = np.random.rand() + 1.j * np.random.rand()
for n_qubits in range(1, 8):
self._su2_compare(alpha, beta, n_qubits)
self._su2_count(alpha, beta, n_qubits)
def test_su2_both_diag_real(self):
alpha = np.random.rand()
beta = np.random.rand()
for n_qubits in range(1, 8):
self._su2_compare(alpha, beta, n_qubits)
self._su2_count(alpha, beta, n_qubits)
def test_su2_both_diag_complex(self):
alpha = np.random.rand() + 1.j * np.random.rand()
beta = np.random.rand() + 1.j * np.random.rand()
for n_qubits in range(1, 8):
self._su2_compare(alpha, beta, n_qubits)
self._su2_count(alpha, beta, n_qubits)
#self._su2_depth(alpha, beta, n_qubits)
def test_u2(self):
unitary = unitary_group.rvs(2)
for n_qubits in range(1, 8):
self._u2_compare(unitary, n_qubits)
for n_qubits in range(1, 10):
self._u2_count(unitary, n_qubits)
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!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/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/ukzncqt/QC_Tuts
|
ukzncqt
|
!pip install qiskit
from qiskit import BasicAer
from qiskit import QuantumRegister ,ClassicalRegister ,QuantumCircuit ,execute
from qiskit.tools.visualization import plot_histogram ,circuit_drawer
from numpy import pi
qr = QuantumRegister(3)
cr = ClassicalRegister(3)
qc = QuantumCircuit(qr,cr)
qc.u3(pi/7,13*pi/4,0,qr[0])
qc.h(qr[1])
qc.cx(qr[1],qr[2])
qc.cx(qr[0],qr[1])
qc.h(qr[0])
qc.cx(qr[1],qr[2])
qc.cz(qr[0],qr[2])
qc.barrier()
qc.measure(qr,cr)
qc.draw()
backend = BasicAer.get_backend("qasm_simulator")
job = execute(qc,backend = backend, shots = 8192)
res = job.result()
counts1 = res.get_counts()
counts1
plot_histogram(counts1)
backend1 = BasicAer.get_backend("statevector_simulator")
qr = QuantumRegister(1)
qc = QuantumCircuit(qr,cr)
qc.u3(pi/7,13*pi/4,0,qr[0])
job = execute(qc,backend=backend1)
res = job.result()
message = res.get_statevector(qc,decimals=3)
message
from numpy import abs
prob0=(abs(message[0]))**2
prob0
prob1=(abs(message[1]))**2
prob1
prob_bob_0=0.232+0.245+0.238+0.237
prob_bob_0
prob_bob_1=0.013+0.012+0.012+0.011
prob_bob_1
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# You can show the phase of each state and use
# degrees instead of radians
from qiskit.quantum_info import DensityMatrix
import numpy as np
from qiskit import QuantumCircuit
from qiskit.visualization import plot_state_qsphere
qc = QuantumCircuit(2)
qc.h([0, 1])
qc.cz(0,1)
qc.ry(np.pi/3, 0)
qc.rx(np.pi/5, 1)
qc.z(1)
matrix = DensityMatrix(qc)
plot_state_qsphere(matrix,
show_state_phases = True, use_degrees = True)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
state = Statevector(qc)
plot_state_qsphere(state)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.