repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
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 majority gate """
from unittest import TestCase
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
from qclib.gates.majority import operate as majority
from qclib.util import get_counts
class TestMajority(TestCase):
""" Testing qclib.gate.majority """
@staticmethod
def _run_majority(bin_input):
""" Run majority gate and return counts """
# initialize quantum registers
controls = QuantumRegister(len(bin_input), 'controls')
target = QuantumRegister(1, 'target')
output = ClassicalRegister(1)
circuit = QuantumCircuit(controls, target, output)
# Pattern basis encoding
for k, bit in enumerate(bin_input):
if bit == 1:
circuit.x(controls[k])
majority(circuit, controls, target)
# measure output and verify results
# pylint: disable=maybe-no-member
circuit.measure(target, output)
counts = get_counts(circuit)
return counts
def _test_majority(self, n_qubits):
""" Testing majority """
for i in range(2 ** n_qubits):
bits = [int(j) for j in '{:0{}b}'.format(i, n_qubits)]
counts = TestMajority._run_majority(bits)
if sum(bits) >= n_qubits/2:
self.assertTrue(counts['1'] / 1024 == 1)
else:
self.assertTrue(counts['0'] / 1024 == 1)
# Keep tests separated by number of qubits to make it easier to identify errors.
def test_majority_2(self):
""" Testing 2 qubits majority """
TestMajority._test_majority(self, 2)
def test_majority_3(self):
""" Testing 3 qubits majority """
TestMajority._test_majority(self, 3)
def test_majority_4(self):
""" Testing 4 qubits majority """
TestMajority._test_majority(self, 4)
def test_majority_5(self):
""" Testing 5 qubits majority """
TestMajority._test_majority(self, 5)
|
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/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 linear mcx with ancilla """
from unittest import TestCase
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, transpile
from qiskit.quantum_info import Operator
from qclib.gates.mcx import McxVchainDirty, LinearMcx
def apply_control_state_on_quantum_circuit(
quantum_circuit: QuantumCircuit, control_qubits: QuantumRegister, ctrl_state: str
):
"""
Applies the X gate to the corresponding qubit in which the
bit string describes it to be in state 0 as a means to simulate
open controlled operations on a specific set of qubits. This operations
are applied using Qiskit's QuantumCircuit object instead of Gate object.
Parameters
----------
quantum_circuit : QuantumCircuit object on which the X gates are to be applied
control_bits : QuantumRegister containing with the qubits to be used as control
ctrl_state : String of binary digits describing wich state is used as control
in the multicontrolled operation
"""
if ctrl_state is not None:
for i, ctrl in enumerate(ctrl_state[::-1]):
if ctrl == "0":
quantum_circuit.x(control_qubits[i])
class TestLinearMCX(TestCase):
"""Testing qclib.gates.mcx_gate"""
def test_linear_mcx(self):
"""Test if linear_mcx is correct"""
for num_qubits in range(8, 9):
self._operator_cmp(
num_qubits=num_qubits, mcx_method=LinearMcx, mode="recursion"
)
def _compare_linear_mcx_action_only(self, num_qubits, ctrl_state=None):
"""Test if linear_mcx is correct"""
linear_circuit = QuantumCircuit(num_qubits)
qiskit_circuit = QuantumCircuit(num_qubits)
theta = np.random.uniform(0.0, 2.0 * np.pi)
mcx_method = LinearMcx(
num_qubits - 2, ctrl_state=ctrl_state, action_only=True
).definition
linear_circuit.append(mcx_method, list(range(num_qubits)))
linear_circuit.rz(theta, num_qubits - 1)
linear_circuit.append(mcx_method.inverse(), list(range(num_qubits)))
mcx_qiskit = self._build_qiskit_method_mcx_recursive(
num_qubits=num_qubits, ctrl_state=ctrl_state, mode="recursion"
)
qiskit_circuit.append(mcx_qiskit, list(range(num_qubits)))
qiskit_circuit.rz(theta, num_qubits - 1)
qiskit_circuit.append(mcx_qiskit, list(range(num_qubits)))
linear_op = Operator(linear_circuit).data
qiskit_op = Operator(qiskit_circuit).data
self.assertTrue(np.allclose(linear_op, qiskit_op))
def test_linear_mcx_action_only(self):
"""Test linear mcx action only"""
for num_qubits in range(8, 9):
self._compare_linear_mcx_action_only(num_qubits)
def test_linear_mcx_action_only_random_ctrl_state(self):
"""Test if linear_mcx is correct"""
num_qubit_range = list(range(8, 9))
basis_states = [
f"{np.random.randint(2 ** (n_ctrl - 2)):0{n_ctrl - 2}b}"
for n_ctrl in num_qubit_range
]
for num_qubits, ctrl_state in zip(num_qubit_range, basis_states):
self._compare_linear_mcx_action_only(num_qubits, ctrl_state)
def test_linear_mcx_depth(self):
"""Test linear_mcx depth"""
for num_qubits in range(10, 11):
mcx_dirty_ancilla = LinearMcx(num_qubits - 2).definition
mcx_qiskit = QuantumCircuit(num_qubits)
mcx_qiskit.mcx(
control_qubits=list(range(num_qubits - 2)),
target_qubit=num_qubits - 2,
ancilla_qubits=num_qubits - 1,
mode="recursion",
)
tr_mcx_dirty_ancilla = transpile(mcx_dirty_ancilla, basis_gates=["u", "cx"])
tr_mcx_qiskit = transpile(mcx_qiskit, basis_gates=["u", "cx"])
self.assertLess(tr_mcx_dirty_ancilla.depth(), tr_mcx_qiskit.depth())
def _operator_cmp(
self,
num_qubits,
mcx_method: LinearMcx,
mode: str,
ctrl_state: str = None,
action_only=False,
):
"""
Compares if the custom operator defined by the custom MCX method is the same
as the one defined by Qiskit MCX method.
Parameters
----------
params:
qubit_range : The number of qubits with which our method needs to be tested
McxMethod : The class definition of the method to be used. It must be `LinearMcx`
action_only : Decide wether or not use only the action of the V-Chain of Toffoli
gates
"""
# for num_qubits in qubit_range:
mcx_method = mcx_method(
num_qubits - 2, ctrl_state=ctrl_state, action_only=action_only
).definition
mcx_qiskit = self._build_qiskit_method_mcx_recursive(
num_qubits=num_qubits, ctrl_state=ctrl_state, mode=mode
)
mcx_method_op = Operator(mcx_method).data
mcx_qiskit_op = Operator(mcx_qiskit).data
self.assertTrue(np.allclose(mcx_method_op, mcx_qiskit_op))
def _build_qiskit_method_mcx_recursive(
self,
num_qubits,
ctrl_state: str = None,
mode="recursive",
):
"""
Bulds qiskit quantum circuit with mcx-recursive
method to be used as reference for comparison
Parameters
----------
num_qubits : Total number of qubits on the system
ctrl_state : string with binary digits that specifies the control state
mode : Decomposition mode to be used for multicontrolled operation
"""
num_controls = num_qubits - 2
control_qubits = QuantumRegister(num_controls)
target_qubit = QuantumRegister(1)
ancilla_qubits = QuantumRegister(1)
mcx_qiskit = QuantumCircuit(
control_qubits,
target_qubit,
ancilla_qubits,
)
apply_control_state_on_quantum_circuit(
quantum_circuit=mcx_qiskit,
control_qubits=control_qubits,
ctrl_state=ctrl_state,
)
mcx_qiskit.mcx(
control_qubits=control_qubits,
target_qubit=target_qubit,
ancilla_qubits=ancilla_qubits,
mode=mode,
)
apply_control_state_on_quantum_circuit(
quantum_circuit=mcx_qiskit,
control_qubits=control_qubits,
ctrl_state=ctrl_state,
)
return mcx_qiskit
class TestMcxVchainDirty(TestCase):
"""Test class McxVchainDirty"""
def test_mcx_v_chain_dirty_depth(self):
"""Test mcx_v_chain_dirty depth"""
for num_controls in range(10, 11):
num_ancilla = num_controls - 2
control_qubits = QuantumRegister(num_controls)
ancilla_qubits = QuantumRegister(num_ancilla)
target_qubit = QuantumRegister(1)
mcx_v_chain = McxVchainDirty(num_controls).definition
mcx_v_chain_qiskit = QuantumCircuit(
control_qubits, ancilla_qubits, target_qubit
)
mcx_v_chain_qiskit.mcx(
control_qubits=control_qubits,
target_qubit=target_qubit,
ancilla_qubits=ancilla_qubits,
mode="v-chain-dirty",
)
tr_mcx_v_chain = transpile(mcx_v_chain, basis_gates=["u", "cx"])
tr_mcx_v_chain_qiskit = transpile(
mcx_v_chain_qiskit, basis_gates=["u", "cx"]
)
self.assertTrue(8 * num_controls - 6 == tr_mcx_v_chain.count_ops()["cx"])
self.assertLess(tr_mcx_v_chain.depth(), tr_mcx_v_chain_qiskit.depth())
def test_mcx_v_chain_dirty(self):
"""Test McxVchainDirty"""
for num_controls in range(6, 7):
self._operator_cmp(
num_controls=num_controls,
mcx_method=McxVchainDirty,
mode="v-chain-dirty",
)
def test_mcx_v_chain_dirty_random_ctrl_state(self):
"""
Test if mcx_v_chain_dirty is correct
with non trivial randomly generated
control states
"""
control_qubit_range = list(range(6, 7))
basis_states = [
f"{np.random.randint(2 ** n_ctrl):0{n_ctrl}b}"
for n_ctrl in control_qubit_range
]
for num_controls, ctrl_state in zip(control_qubit_range, basis_states):
self._operator_cmp(
num_controls=num_controls,
mcx_method=McxVchainDirty,
mode="v-chain-dirty",
ctrl_state=ctrl_state,
)
def test_mcx_v_chain_3targets(self):
"""Test multiple targets McxVchainDirty"""
# mcx_v_chain_circuit
num_controls = 4
num_target_qubit = 3
mcx_v_chain_circuit = McxVchainDirty(
num_controls, num_target_qubit=num_target_qubit
).definition
# qiskit_circuit
qiskit_circuit = QuantumCircuit(9)
controls_idx = list(np.arange(4))
for target_idx in range(6, 9):
qiskit_circuit.mcx(controls_idx, [target_idx])
mcx_v_chain_op = Operator(mcx_v_chain_circuit).data
qiskit_mcx_op = Operator(qiskit_circuit).data
tr_mcx_v_chain = transpile(mcx_v_chain_circuit, basis_gates=["u", "cx"])
self.assertTrue(np.allclose(mcx_v_chain_op, qiskit_mcx_op))
if num_controls > 3:
self.assertTrue(
10 + 8 * (num_controls - 2) + 2 * (num_target_qubit - 1)
== tr_mcx_v_chain.count_ops()["cx"]
)
def _operator_cmp(
self,
num_controls,
mcx_method: McxVchainDirty,
mode: str,
ctrl_state: str = None,
action_only=False,
):
"""
Compares if the custom operator defined by the custom MCX method is the same
as the one defined by Qiskit MCX method.
Parameters
----------
control_qubit_range: The number of control qubits
mcx_method: The class definition of the method to be used. It must be `McxVchainDirty`
action_only: Decide wether or not use only the action of the V-Chain of Toffoli
gates
"""
mcx_method = mcx_method(
num_controls,
ctrl_state=ctrl_state,
action_only=action_only
).definition
# defining quiskit's
mcx_v_chain_qiskit = self._build_qiskit_method_mcx_vchain_dirty(
num_controls=num_controls, mode=mode, ctrl_state=ctrl_state
)
mcx_method_op = Operator(mcx_method).data
mcx_v_chain_qiskit_op = Operator(mcx_v_chain_qiskit).data
self.assertTrue(np.allclose(mcx_method_op, mcx_v_chain_qiskit_op))
def _build_qiskit_method_mcx_vchain_dirty(
self,
num_controls,
mode: str,
ctrl_state: str = None,
):
"""
Bulds qiskit quantum circuit with mcx-vchain-dirty
method to be used as reference for comparison
Parameters
----------
num_controls : Total number of control qubits on the system
ctrl_state : string with binary digits that specifies the control state
mode : Decomposition mode to be used for multicontrolled operation
"""
num_ancilla = num_controls - 2
control_qubits = QuantumRegister(num_controls)
ancilla_qubits = QuantumRegister(num_ancilla)
target_qubit = QuantumRegister(1)
mcx_qiskit = QuantumCircuit(control_qubits, ancilla_qubits, target_qubit)
apply_control_state_on_quantum_circuit(
quantum_circuit=mcx_qiskit,
control_qubits=control_qubits,
ctrl_state=ctrl_state,
)
mcx_qiskit.mcx(
control_qubits=control_qubits,
target_qubit=target_qubit,
ancilla_qubits=ancilla_qubits,
mode=mode,
)
apply_control_state_on_quantum_circuit(
quantum_circuit=mcx_qiskit,
control_qubits=control_qubits,
ctrl_state=ctrl_state,
)
return mcx_qiskit
|
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.qdmcu.QDMCU """
from unittest import TestCase
import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
from scipy.stats import unitary_group
from qclib.gates.qdmcu import Qdmcu
from qclib.util import get_cnot_count
class TestQDMCU(TestCase):
def _generate_u2(self):
return unitary_group.rvs(2)
def _build_qiskit_qdmcu(self, u2, num_controls, ctrl_state: str = None):
u2_gate = QuantumCircuit(1)
u2_gate.unitary(u2, 0)
controls_list = list(range(num_controls))
target = num_controls
qiskit_circ = QuantumCircuit(target + 1)
qiskit_circ.append(u2_gate.control(num_controls, ctrl_state=ctrl_state),
[*controls_list, target])
return qiskit_circ
def test_gate_trivial_ctrl_state(self):
"""Compares QDMCU result gate against qiskit's with a trivial state"""
u2 = self._generate_u2()
for n_ctrl in range(1, 8):
qiskit_circ = self._build_qiskit_qdmcu(u2, n_ctrl)
qdmcu_circ = Qdmcu(u2, n_ctrl).definition
qiskit_op = Operator(qiskit_circ).data
qdmcu_op = Operator(qdmcu_circ).data
self.assertTrue(np.allclose(qiskit_op, qdmcu_op))
def test_gate_random_ctrl_state(self):
"""Compares QDMCU result gate against qiskit's with a trivial state"""
u2 = self._generate_u2()
for n_ctrl in range(1, 8):
ctrl_state = f'{np.random.randint(1, 2**n_ctrl):0{n_ctrl}b}'
qiskit_circ = self._build_qiskit_qdmcu(u2, n_ctrl, ctrl_state=ctrl_state)
qdmcu_circ = Qdmcu(u2, n_ctrl, ctrl_state=ctrl_state).definition
qiskit_op = Operator(qiskit_circ).data
qdmcu_op = Operator(qdmcu_circ).data
self.assertTrue(np.allclose(qiskit_op, qdmcu_op))
def test_cnot_count(self):
"""Compares QDMCU cnot count against qiskit's cnot count"""
u2 = self._generate_u2()
for n_ctrl in range(1, 8):
ctrl_state = f'{np.random.randint(1, 2**n_ctrl):0{n_ctrl}b}'
qiskit_circ = self._build_qiskit_qdmcu(u2, n_ctrl, ctrl_state=ctrl_state)
qdmcu_circ = Qdmcu(u2, n_ctrl, ctrl_state=ctrl_state).definition
qiskit_cnots = get_cnot_count(qiskit_circ)
qdmcu_cnots = get_cnot_count(qdmcu_circ)
self.assertLessEqual(qdmcu_cnots, qiskit_cnots)
|
https://github.com/PennyLaneAI/pennylane
|
PennyLaneAI
|
# Copyright 2018-2021 Xanadu Quantum Technologies Inc.
# 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.
"""
This module contains functions to load circuits from other frameworks as
PennyLane templates.
"""
from collections import defaultdict
from importlib import metadata
from sys import version_info
# Error message to show when the PennyLane-Qiskit plugin is required but missing.
_MISSING_QISKIT_PLUGIN_MESSAGE = (
"Conversion from Qiskit requires the PennyLane-Qiskit plugin. "
"You can install the plugin by running: pip install pennylane-qiskit. "
"You may need to restart your kernel or environment after installation. "
"If you have any difficulties, you can reach out on the PennyLane forum at "
"https://discuss.pennylane.ai/c/pennylane-plugins/pennylane-qiskit/"
)
# get list of installed plugin converters
__plugin_devices = (
defaultdict(tuple, metadata.entry_points())["pennylane.io"]
if version_info[:2] == (3, 9)
else metadata.entry_points(group="pennylane.io") # pylint:disable=unexpected-keyword-arg
)
plugin_converters = {entry.name: entry for entry in __plugin_devices}
def from_qiskit(quantum_circuit, measurements=None):
r"""Converts a Qiskit `QuantumCircuit <https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.QuantumCircuit>`_
into a PennyLane :ref:`quantum function <intro_vcirc_qfunc>`.
.. note::
This function depends upon the PennyLane-Qiskit plugin. Follow the
`installation instructions <https://docs.pennylane.ai/projects/qiskit/en/latest/installation.html>`__
to get up and running. You may need to restart your kernel if you are running in a notebook
environment.
Args:
quantum_circuit (qiskit.QuantumCircuit): a quantum circuit created in Qiskit
measurements (None | MeasurementProcess | list[MeasurementProcess]): an optional PennyLane
measurement or list of PennyLane measurements that overrides any terminal measurements
that may be present in the input circuit
Returns:
function: The PennyLane quantum function, created based on the input Qiskit
``QuantumCircuit`` object.
**Example:**
.. code-block:: python
import pennylane as qml
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 2)
qc.rx(0.785, 0)
qc.ry(1.57, 1)
my_qfunc = qml.from_qiskit(qc)
The ``my_qfunc`` function can now be used within QNodes, as a two-wire quantum
template. We can also pass ``wires`` when calling the returned template to define
which wires it should operate on. If no wires are passed, it will default
to sequential wire labels starting at 0.
.. code-block:: python
dev = qml.device("default.qubit")
@qml.qnode(dev)
def circuit():
my_qfunc(wires=["a", "b"])
return qml.expval(qml.Z("a")), qml.var(qml.Z("b"))
>>> circuit()
(tensor(0.70738827, requires_grad=True),
tensor(0.99999937, requires_grad=True))
The measurements can also be passed directly to the function when creating the
quantum function, making it possible to create a PennyLane circuit with
:class:`qml.QNode <pennylane.QNode>`:
>>> measurements = [qml.expval(qml.Z(0)), qml.var(qml.Z(1))]
>>> circuit = qml.QNode(qml.from_qiskit(qc, measurements), dev)
>>> circuit()
(tensor(0.70738827, requires_grad=True),
tensor(0.99999937, requires_grad=True))
.. note::
The ``measurements`` keyword allows one to add a list of PennyLane measurements
that will **override** any terminal measurements present in the ``QuantumCircuit``,
so that they are not performed before the operations specified in ``measurements``.
``measurements=None``.
If an existing ``QuantumCircuit`` already contains measurements, ``from_qiskit``
will return those measurements, provided that they are not overriden as shown above.
These measurements can be used, e.g., for conditioning with
:func:`qml.cond() <~.cond>`, or simply included directly within the QNode's return:
.. code-block:: python
qc = QuantumCircuit(2, 2)
qc.rx(np.pi, 0)
qc.measure_all()
@qml.qnode(dev)
def circuit():
# Since measurements=None, the measurements present in the QuantumCircuit are returned.
measurements = qml.from_qiskit(qc)()
return [qml.expval(m) for m in measurements]
>>> circuit()
[tensor(1., requires_grad=True), tensor(0., requires_grad=True)]
.. note::
The ``measurements`` returned from a ``QuantumCircuit`` are in the computational basis
with 0 corresponding to :math:`|0\rangle` and 1 corresponding to :math:`|1 \rangle`. This
corresponds to the :math:`|1 \rangle \langle 1|` observable rather than the :math:`Z` Pauli
operator.
See below for more information regarding how to translate more complex circuits from Qiskit to
PennyLane, including handling parameterized Qiskit circuits, mid-circuit measurements, and
classical control flows.
.. details::
:title: Parameterized Quantum Circuits
A Qiskit ``QuantumCircuit`` is parameterized if it contains
`Parameter <https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.Parameter>`__ or
`ParameterVector <https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.ParameterVector>`__
references that need to be given defined values to evaluate the circuit. These can be passed
to the generated quantum function as keyword or positional arguments. If we define a
parameterized circuit:
.. code-block:: python
from qiskit.circuit import QuantumCircuit, Parameter
angle0 = Parameter("x")
angle1 = Parameter("y")
qc = QuantumCircuit(2, 2)
qc.rx(angle0, 0)
qc.ry(angle1, 1)
qc.cx(1, 0)
Then this circuit can be converted into a differentiable circuit in PennyLane and
executed:
.. code-block:: python
import pennylane as qml
from pennylane import numpy as np
dev = qml.device("default.qubit")
qfunc = qml.from_qiskit(qc, measurements=qml.expval(qml.Z(0)))
circuit = qml.QNode(qfunc, dev)
Now, ``circuit`` has a signature of ``(x, y)``. The parameters are ordered alphabetically.
>>> x = np.pi / 4
>>> y = 0
>>> circuit(x, y)
tensor(0.70710678, requires_grad=True)
>>> qml.grad(circuit, argnum=[0, 1])(np.pi/4, np.pi/6)
(array(-0.61237244), array(-0.35355339))
The ``QuantumCircuit`` may also be parameterized with a ``ParameterVector``. These can be
similarly converted:
.. code-block:: python
from qiskit.circuit import ParameterVector
angles = ParameterVector("angles", 2)
qc = QuantumCircuit(2, 2)
qc.rx(angles[0], 0)
qc.ry(angles[1], 1)
qc.cx(1, 0)
@qml.qnode(dev)
def circuit(angles):
qml.from_qiskit(qc)(angles)
return qml.expval(qml.Z(0))
>>> angles = [3.1, 0.45]
>>> circuit(angles)
tensor(-0.89966835, requires_grad=True)
.. details::
:title: Measurements and Classical Control Flows
When ``measurement=None``, all of the measurements performed in the ``QuantumCircuit`` will
be returned by the quantum function in the form of a :ref:`mid-circuit measurement
<mid_circuit_measurements>`. For example, if we define a ``QuantumCircuit`` with
measurements:
.. code-block:: python
import pennylane as qml
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.measure(0, 0)
qc.rz(0.24, [0])
qc.cx(0, 1)
qc.measure_all()
Then we can create a PennyLane circuit that uses this as a sub-circuit, and performs
additional operations conditional on the results. We can also calculate standard mid-circuit
measurement statistics, like expectation value, on the returned measurements:
.. code-block:: python
@qml.qnode(qml.device("default.qubit"))
def circuit():
# apply the QuantumCircuit and retrieve the measurements
mid_measure0, m0, m1 = qml.from_qiskit(qc)()
# conditionally apply an additional operation based on the results
qml.cond(mid_measure0==0, qml.RX)(np.pi/2, 0)
# return the expectation value of one of the mid-circuit measurements, and a terminal measurement
return qml.expval(mid_measure0), qml.expval(m1)
>>> circuit()
(tensor(0.5, requires_grad=True), tensor(0.5, requires_grad=True))
.. note::
The order of mid-circuit measurements returned by `qml.from_qiskit()` in the example
above is determined by the order in which measurements appear in the input Qiskit
``QuantumCircuit``.
Furthermore, the Qiskit `IfElseOp <https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.IfElseOp>`__,
`SwitchCaseOp <https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.SwitchCaseOp>`__ and
`c_if <https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.Instruction#c_if>`__
conditional workflows are automatically translated into their PennyLane counterparts during
conversion. For example, if we construct a ``QuantumCircuit`` with these workflows:
.. code-block:: python
qc = QuantumCircuit(4, 1)
qc.h(0)
qc.measure(0, 0)
# Use an `IfElseOp` operation.
noop = QuantumCircuit(1)
flip_x = QuantumCircuit(1)
flip_x.x(0)
qc.if_else((qc.clbits[0], True), flip_x, noop, [1], [])
# Use a `SwitchCaseOp` operation.
with qc.switch(qc.clbits[0]) as case:
with case(0):
qc.y(2)
# Use the `c_if()` function.
qc.z(3).c_if(qc.clbits[0], True)
qc.measure_all()
We can convert the ``QuantumCircuit`` into a PennyLane quantum function using:
.. code-block:: python
dev = qml.device("default.qubit")
measurements = [qml.expval(qml.Z(i)) for i in range(qc.num_qubits)]
cond_circuit = qml.QNode(qml.from_qiskit(qc, measurements=measurements), dev)
The result is:
>>> print(qml.draw(cond_circuit)())
0: ──H──┤↗├──────────╭||─┤ <Z>
1: ──────║───X───────├||─┤ <Z>
2: ──────║───║──Y────├||─┤ <Z>
3: ──────║───║──║──Z─╰||─┤ <Z>
╚═══╩══╩══╝
"""
try:
plugin_converter = plugin_converters["qiskit"].load()
return plugin_converter(quantum_circuit, measurements=measurements)
except KeyError as e:
raise RuntimeError(_MISSING_QISKIT_PLUGIN_MESSAGE) from e
def from_qiskit_op(qiskit_op, params=None, wires=None):
"""Converts a Qiskit `SparsePauliOp <https://docs.quantum.ibm.com/api/qiskit/qiskit.quantum_info.SparsePauliOp>`__
into a PennyLane :class:`Operator <pennylane.operation.Operator>`.
.. note::
This function depends upon the PennyLane-Qiskit plugin. Follow the
`installation instructions <https://docs.pennylane.ai/projects/qiskit/en/latest/installation.html>`__
to get up and running. You may need to restart your kernel if you are running in a notebook
environment.
Args:
qiskit_op (qiskit.quantum_info.SparsePauliOp): a ``SparsePauliOp`` created in Qiskit
params (Any): optional assignment of coefficient values for the ``SparsePauliOp``; see the
`Qiskit documentation <https://docs.quantum.ibm.com/api/qiskit/qiskit.quantum_info.SparsePauliOp#assign_parameters>`_
to learn more about the expected format of these parameters
wires (Sequence | None): optional assignment of wires for the converted ``SparsePauliOp``;
if the original ``SparsePauliOp`` acted on :math:`N` qubits, then this must be a
sequence of length :math:`N`
Returns:
Operator: The PennyLane operator, created based on the input Qiskit
``SparsePauliOp`` object.
.. note::
The wire ordering convention differs between PennyLane and Qiskit: PennyLane wires are
enumerated from left to right, while the Qiskit convention is to enumerate from right to
left. This means a ``SparsePauliOp`` term defined by the string ``"XYZ"`` applies ``Z`` on
wire 0, ``Y`` on wire 1, and ``X`` on wire 2. For more details, see the
`String representation <https://docs.quantum.ibm.com/api/qiskit/qiskit.quantum_info.Pauli>`_
section of the Qiskit documentation for the ``Pauli`` class.
**Example**
Consider the following script which creates a Qiskit ``SparsePauliOp``:
.. code-block:: python
from qiskit.quantum_info import SparsePauliOp
qiskit_op = SparsePauliOp(["II", "XY"])
The ``SparsePauliOp`` contains two terms and acts over two qubits:
>>> qiskit_op
SparsePauliOp(['II', 'XY'],
coeffs=[1.+0.j, 1.+0.j])
To convert the ``SparsePauliOp`` into a PennyLane :class:`pennylane.operation.Operator`, use:
>>> import pennylane as qml
>>> qml.from_qiskit_op(qiskit_op)
I(0) + X(1) @ Y(0)
.. details::
:title: Usage Details
You can convert a parameterized ``SparsePauliOp`` into a PennyLane operator by assigning
literal values to each coefficient parameter. For example, the script
.. code-block:: python
import numpy as np
from qiskit.circuit import Parameter
a, b, c = [Parameter(var) for var in "abc"]
param_qiskit_op = SparsePauliOp(["II", "XZ", "YX"], coeffs=np.array([a, b, c]))
defines a ``SparsePauliOp`` with three coefficients (parameters):
>>> param_qiskit_op
SparsePauliOp(['II', 'XZ', 'YX'],
coeffs=[ParameterExpression(1.0*a), ParameterExpression(1.0*b),
ParameterExpression(1.0*c)])
The ``SparsePauliOp`` can be converted into a PennyLane operator by calling the conversion
function and specifying the value of each parameter using the ``params`` argument:
>>> qml.from_qiskit_op(param_qiskit_op, params={a: 2, b: 3, c: 4})
(
(2+0j) * I(0)
+ (3+0j) * (X(1) @ Z(0))
+ (4+0j) * (Y(1) @ X(0))
)
Similarly, a custom wire mapping can be applied to a ``SparsePauliOp`` as follows:
>>> wired_qiskit_op = SparsePauliOp("XYZ")
>>> wired_qiskit_op
SparsePauliOp(['XYZ'],
coeffs=[1.+0.j])
>>> qml.from_qiskit_op(wired_qiskit_op, wires=[3, 5, 7])
Y(5) @ Z(3) @ X(7)
"""
try:
plugin_converter = plugin_converters["qiskit_op"].load()
return plugin_converter(qiskit_op, params=params, wires=wires)
except KeyError as e:
raise RuntimeError(_MISSING_QISKIT_PLUGIN_MESSAGE) from e
def from_qasm(quantum_circuit: str, measurements=None):
r"""
Loads quantum circuits from a QASM string using the converter in the
PennyLane-Qiskit plugin.
Args:
quantum_circuit (str): a QASM string containing a valid quantum circuit
measurements (None | MeasurementProcess | list[MeasurementProcess]): an optional PennyLane
measurement or list of PennyLane measurements that overrides the terminal measurements
that may be present in the input circuit. Defaults to ``None``, such that all existing measurements
in the input circuit are returned. See *Removing terminal measurements* for details.
Returns:
function: the PennyLane quantum function created based on the QASM string. This function itself returns the mid-circuit measurements plus the terminal measurements by default (``measurements=None``), and returns **only** the measurements from the ``measurements`` argument otherwise.
**Example:**
.. code-block:: python
qasm_code = 'OPENQASM 2.0;' \
'include "qelib1.inc";' \
'qreg q[2];' \
'creg c[2];' \
'h q[0];' \
'measure q[0] -> c[0];' \
'rz(0.24) q[0];' \
'cx q[0], q[1];' \
'measure q -> c;'
loaded_circuit = qml.from_qasm(qasm_code)
>>> print(qml.draw(loaded_circuit)())
0: ──H──┤↗├──RZ(0.24)─╭●──┤↗├─┤
1: ───────────────────╰X──┤↗├─┤
Calling the quantum function returns a tuple containing the mid-circuit measurements and the terminal measurements.
>>> loaded_circuit()
(MeasurementValue(wires=[0]),
MeasurementValue(wires=[0]),
MeasurementValue(wires=[1]))
A list of measurements can also be passed directly to ``from_qasm`` using the ``measurements`` argument, making it possible to create a PennyLane circuit with :class:`qml.QNode <pennylane.QNode>`.
.. code-block:: python
dev = qml.device("default.qubit")
measurements = [qml.var(qml.Y(0))]
circuit = qml.QNode(qml.from_qasm(qasm_code, measurements = measurements), dev)
>>> print(qml.draw(circuit)())
0: ──H──┤↗├──RZ(0.24)─╭●─┤ Var[Y]
1: ───────────────────╰X─┤
.. details::
:title: Removing terminal measurements
To remove all terminal measurements, set ``measurements=[]``. This removes the existing terminal measurements and keeps the mid-circuit measurements.
.. code-block:: python
loaded_circuit = qml.from_qasm(qasm_code, measurements=[])
>>> print(qml.draw(loaded_circuit)())
0: ──H──┤↗├──RZ(0.24)─╭●─┤
1: ───────────────────╰X─┤
Calling the quantum function returns the same empty list that we originally passed in.
>>> loaded_circuit()
[]
Note that mid-circuit measurements are always applied, but are only returned when ``measurements=None``. This can be exemplified by using the ``loaded_circuit`` without the terminal measurements within a ``QNode``.
.. code-block:: python
dev = qml.device("default.qubit")
@qml.qnode(dev)
def circuit():
loaded_circuit()
return qml.expval(qml.Z(1))
>>> print(qml.draw(circuit)())
0: ──H──┤↗├──RZ(0.24)─╭●─┤
1: ───────────────────╰X─┤ <Z>
.. details::
:title: Using conditional operations
We can take advantage of the mid-circuit measurements inside the QASM code by calling the returned function within a :class:`qml.QNode <pennylane.QNode>`.
.. code-block:: python
loaded_circuit = qml.from_qasm(qasm_code)
@qml.qnode(dev)
def circuit():
mid_measure, *_ = loaded_circuit()
qml.cond(mid_measure == 0, qml.RX)(np.pi / 2, 0)
return [qml.expval(qml.Z(0))]
>>> print(qml.draw(circuit)())
0: ──H──┤↗├──RZ(0.24)─╭●──┤↗├──RX(1.57)─┤ <Z>
1: ──────║────────────╰X──┤↗├──║────────┤
╚═════════════════════╝
.. details::
:title: Importing from a QASM file
We can also load the contents of a QASM file.
.. code-block:: python
# save the qasm code in a file
import locale
from pathlib import Path
filename = "circuit.qasm"
with Path(filename).open("w", encoding=locale.getpreferredencoding(False)) as f:
f.write(qasm_code)
with open("circuit.qasm", "r") as f:
loaded_circuit = qml.from_qasm(f.read())
The ``loaded_circuit`` function can now be used within a :class:`qml.QNode <pennylane.QNode>` as a two-wire quantum template.
.. code-block:: python
@qml.qnode(dev)
def circuit(x):
qml.RX(x, wires=1)
loaded_circuit(wires=(0, 1))
return qml.expval(qml.Z(0))
>>> print(qml.draw(circuit)(1.23))
0: ──H─────────┤↗├──RZ(0.24)─╭●──┤↗├─┤ <Z>
1: ──RX(1.23)────────────────╰X──┤↗├─┤
"""
try:
plugin_converter = plugin_converters["qasm"].load()
except Exception as e: # pragma: no cover
raise RuntimeError( # pragma: no cover
"Failed to load the qasm plugin. Please ensure that the pennylane-qiskit package is installed."
) from e
return plugin_converter(quantum_circuit, measurements=measurements)
def from_pyquil(pyquil_program):
"""Loads pyQuil Program objects by using the converter in the
PennyLane-Rigetti plugin.
**Example:**
>>> program = pyquil.Program()
>>> program += pyquil.gates.H(0)
>>> program += pyquil.gates.CNOT(0, 1)
>>> my_circuit = qml.from_pyquil(program)
The ``my_circuit`` template can now be used within QNodes, as a
two-wire quantum template.
>>> @qml.qnode(dev)
>>> def circuit(x):
>>> qml.RX(x, wires=1)
>>> my_circuit(wires=[1, 0])
>>> return qml.expval(qml.Z(0))
Args:
pyquil_program (pyquil.Program): a program created in pyQuil
Returns:
pennylane_forest.ProgramLoader: a ``pennylane_forest.ProgramLoader`` instance that can
be used like a PennyLane template and that contains additional inspection properties
"""
plugin_converter = plugin_converters["pyquil_program"].load()
return plugin_converter(pyquil_program)
def from_quil(quil: str):
"""Loads quantum circuits from a Quil string using the converter in the
PennyLane-Rigetti plugin.
**Example:**
.. code-block:: python
>>> quil_str = 'H 0\\n'
... 'CNOT 0 1'
>>> my_circuit = qml.from_quil(quil_str)
The ``my_circuit`` template can now be used within QNodes, as a
two-wire quantum template.
>>> @qml.qnode(dev)
>>> def circuit(x):
>>> qml.RX(x, wires=1)
>>> my_circuit(wires=(1, 0))
>>> return qml.expval(qml.Z(0))
Args:
quil (str): a Quil string containing a valid quantum circuit
Returns:
pennylane_forest.ProgramLoader: a ``pennylane_forest.ProgramLoader`` instance that can
be used like a PennyLane template and that contains additional inspection properties
"""
plugin_converter = plugin_converters["quil"].load()
return plugin_converter(quil)
def from_quil_file(quil_filename: str):
"""Loads quantum circuits from a Quil file using the converter in the
PennyLane-Rigetti plugin.
**Example:**
>>> my_circuit = qml.from_quil_file("teleportation.quil")
The ``my_circuit`` template can now be used within QNodes, as a
two-wire quantum template.
>>> @qml.qnode(dev)
>>> def circuit(x):
>>> qml.RX(x, wires=1)
>>> my_circuit(wires=(1, 0))
>>> return qml.expval(qml.Z(0))
Args:
quil_filename (str): path to a Quil file containing a valid quantum circuit
Returns:
pennylane_forest.ProgramLoader: a ``pennylane_forest.ProgramLoader`` instance that can
be used like a PennyLane template and that contains additional inspection properties
"""
plugin_converter = plugin_converters["quil_file"].load()
return plugin_converter(quil_filename)
|
https://github.com/MahamShafiq/Qiskit
|
MahamShafiq
|
!pip install qiskit
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 matplotlib import pyplot as plt
from time import time
%matplotlib inline
def preprocess(trainset):
labels = trainset.targets
labels = labels.numpy()
index1 = np.where(labels == 0) # filter 3's
index2 = np.where(labels == 1) # filter on 5's
n=200 # Number of datapoints per class
index = np.concatenate((index1[0][0:n],index2[0][0:n]))
trainset.targets = labels[index]
trainset.data = trainset.data[index]
return trainset
#converts the image into tensors
transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()])
trainset = datasets.MNIST(root='./mnistdata', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(preprocess(trainset), batch_size=1, shuffle=True)
dataiter = iter(trainloader)
images, labels = dataiter.next()
print(images.shape)
print(labels.shape)
plt.imshow(images[0].numpy().squeeze(), cmap='gray_r');
def to_numbers(tensor_list):
list = []
for tensor in tensor_list:
list += [tensor.item()]
return list
class QiskitCircuit():
# Specify initial parameters and the quantum circuit
def __init__(self,shots):
self.theta = Parameter('Theta')
self.shots = shots
def create_circuit():
qr = QuantumRegister(1,'q')
cr = ClassicalRegister(1,'c')
ckt = QuantumCircuit(qr,cr)
ckt.h(qr[0])
ckt.barrier()
ckt.ry(self.theta,qr[0])
ckt.barrier()
ckt.measure(qr,cr)
return ckt
self.circuit = create_circuit()
def N_qubit_expectation_Z(self, counts, shots, nr_qubits):
expects = np.zeros(nr_qubits)
for key in counts.keys():
perc = counts[key]/shots
check = np.array([(float(key[i])-1/2)*2*perc for i in range(nr_qubits)])
expects += check
return expects
def bind(self, parameters):
[self.theta] = to_numbers(parameters)
self.circuit.data[2][0]._params = to_numbers(parameters)
def run(self, i):
self.bind(i)
backend = Aer.get_backend('qasm_simulator')
job_sim = execute(self.circuit,backend,shots=self.shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(self.circuit)
return self.N_qubit_expectation_Z(counts,self.shots,1)
class TorchCircuit(Function):
@staticmethod
def forward(ctx, i):
if not hasattr(ctx, 'QiskitCirc'):
ctx.QiskitCirc = QiskitCircuit(shots=100)
exp_value = ctx.QiskitCirc.run(i[0])
result = torch.tensor([exp_value]) # store the result as a torch tensor
ctx.save_for_backward(result, i)
return result
@staticmethod
def backward(ctx, grad_output):
s = np.pi/2
forward_tensor, i = ctx.saved_tensors
# Obtain paramaters
input_numbers = to_numbers(i[0])
gradient = []
for k in range(len(input_numbers)):
input_plus_s = input_numbers
input_plus_s[k] = input_numbers[k] + s # Shift up by s
exp_value_plus = ctx.QiskitCirc.run(torch.tensor(input_plus_s))[0]
result_plus_s = torch.tensor([exp_value_plus])
input_minus_s = input_numbers
input_minus_s[k] = input_numbers[k] - s # Shift down by s
exp_value_minus = ctx.QiskitCirc.run(torch.tensor(input_minus_s))[0]
result_minus_s = torch.tensor([exp_value_minus])
gradient_result = (result_plus_s - result_minus_s)
gradient.append(gradient_result)
result = torch.tensor([gradient])
return result.float() * grad_output.float()
qc = TorchCircuit.apply
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.conv2_drop = nn.Dropout2d()
self.h1 = nn.Linear(320, 50)
self.h2 = nn.Linear(50, 1)
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), 2))
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
x = x.view(-1, 320)
x = F.relu(self.h1(x))
x = F.dropout(x, training=self.training)
x = self.h2(x)
x = qc(x)
x = (x+1)/2 # Normalise the inputs to 1 or 0
x = torch.cat((x, 1-x), -1)
return x
network = Net()
print(network)
optimizer = optim.SGD(network.parameters(), lr=0.003, momentum=0.9)
epochs = 30
time0 = time()
loss_list = []
for epoch in range(epochs):
total_loss = []
target_list = []
for batch_idx, (data, target) in enumerate(trainloader):
target_list.append(target.item())
optimizer.zero_grad()
output = network(data)
loss = F.nll_loss(output, target)
loss.backward()
optimizer.step()
total_loss.append(loss.item())
loss_list.append(sum(total_loss)/len(total_loss))
print("Loss = {:.2f} after epoch #{:2d}".format(loss_list[-1],epoch+1))
#print(loss_list[-1])
# Normalise the loss between 0 and 1
print("Training finished, took {:.2f}s after epoch #{:2d}".format(time() - time0,epochs))
for i in range(len(loss_list)):
loss_list[i] += 1
# Plot the loss per epoch
plt.plot(np.arange(epochs),loss_list)
plt.title("Hybrid NN Training Convergence")
plt.xlabel('Training Iterations')
plt.ylabel('Loss')
|
https://github.com/yaleqc/vqe-error-mitigation
|
yaleqc
|
# Imports needed for basic no noise VQE simulation
import numpy as np
import pylab
import copy
from qiskit import BasicAer
from qiskit.aqua import aqua_globals, QuantumInstance
from qiskit.aqua.algorithms import NumPyMinimumEigensolver, VQE
from qiskit.aqua.components.optimizers import SLSQP, SPSA
from qiskit.chemistry.components.initial_states import HartreeFock
from qiskit.chemistry.components.variational_forms import UCCSD
from qiskit.chemistry.drivers import PySCFDriver
from qiskit.chemistry.core import Hamiltonian, QubitMappingType
# Some deprecated package issue; one warning is enough.
import warnings
warnings.filterwarnings(action='once')
molecule = 'H .0 .0 -{0}; Li .0 .0 {0}' # Define molecule; could be H2 or LiH, etc.
distances = np.arange(0.5, 3.75, 0.25) # Distances in Angstrom
vqe_energies = []
hf_energies = [] # Hartree-Fock energies
exact_energies = [] # Exact energies from numerical diagonalization
for i, d in enumerate(distances):
print('step', i)
# initialize driver
driver = PySCFDriver(molecule.format(d/2), basis='sto3g')
qmolecule = driver.run()
operator = Hamiltonian(qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True, freeze_core=True,
orbital_reduction=[-3, -2]) # Approxns needed to make this
# problem tractable.
qubit_op, aux_ops = operator.run(qmolecule)
# exact diagonalization
exact_result = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops).run()
exact_result = operator.process_algorithm_result(exact_result)
# VQE
optimizer = SLSQP(maxiter=1000)
initial_state = HartreeFock(operator.molecule_info['num_orbitals'],
operator.molecule_info['num_particles'],
qubit_mapping=operator._qubit_mapping,
two_qubit_reduction=operator._two_qubit_reduction)
var_form = UCCSD(num_orbitals=operator.molecule_info['num_orbitals'],
num_particles=operator.molecule_info['num_particles'],
initial_state=initial_state,
qubit_mapping=operator._qubit_mapping,
two_qubit_reduction=operator._two_qubit_reduction)
algo = VQE(qubit_op, var_form, optimizer, aux_operators=aux_ops)
vqe_result = algo.run(QuantumInstance(BasicAer.get_backend('statevector_simulator')))
vqe_result = operator.process_algorithm_result(vqe_result)
exact_energies.append(exact_result.energy)
vqe_energies.append(vqe_result.energy)
hf_energies.append(vqe_result.hartree_fock_energy)
pylab.plot(distances, hf_energies, label='Hartree Fock')
pylab.plot(distances, vqe_energies, 'o', label='VQE')
pylab.plot(distances, exact_energies, 'x', label='Exact')
pylab.xlabel('Interatomic distance')
pylab.ylabel('Energy')
pylab.title('LiH Ground State Energy')
pylab.legend(loc='upper right')
# Uncomment to save plot!
#pylab.savefig('vqe.png', dpi=300)
|
https://github.com/yaleqc/vqe-error-mitigation
|
yaleqc
|
import numpy as np
import pylab
from qiskit import Aer
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.aqua.algorithms import VQE, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import SPSA
from qiskit.circuit.library import TwoLocal
from qiskit.aqua.operators import I, X, Z
H2_op = (-1.052373245772859 * I ^ I) + \
(0.39793742484318045 * I ^ Z) + \
(-0.39793742484318045 * Z ^ I) + \
(-0.01128010425623538 * Z ^ Z) + \
(0.18093119978423156 * X ^ X)
print(f'Number of qubits: {H2_op.num_qubits}')
npme = NumPyMinimumEigensolver()
result = npme.compute_minimum_eigenvalue(operator=H2_op)
ref_value = result.eigenvalue.real
print(f'Reference value: {ref_value:.5f}')
seed = 170
iterations = 125
aqua_globals.random_seed = seed
backend = Aer.get_backend('qasm_simulator')
qi = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
counts = []
values = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
var_form = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
spsa = SPSA(maxiter=iterations)
vqe = VQE(var_form=var_form, optimizer=spsa, callback=store_intermediate_result, quantum_instance=qi)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f'VQE on Aer qasm simulator (no noise): {result.eigenvalue.real:.5f}')
print(f'Delta from reference energy value is {(result.eigenvalue.real - ref_value):.5f}')
pylab.rcParams['figure.figsize'] = (12, 4)
pylab.plot(counts, values)
pylab.xlabel('Eval count')
pylab.ylabel('Energy')
pylab.title('Convergence with no noise')
import os
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer import QasmSimulator
from qiskit.test.mock import FakeVigo
device_backend = FakeVigo()
backend = Aer.get_backend('qasm_simulator')
counts1 = []
values1 = []
noise_model = None
os.environ['QISKIT_IN_PARALLEL'] = 'TRUE'
device = QasmSimulator.from_backend(device_backend)
coupling_map = device.configuration().coupling_map
noise_model = NoiseModel.from_backend(device)
basis_gates = noise_model.basis_gates
print(noise_model)
print()
aqua_globals.random_seed = seed
qi = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed,
coupling_map=coupling_map, noise_model=noise_model,)
def store_intermediate_result1(eval_count, parameters, mean, std):
counts1.append(eval_count)
values1.append(mean)
var_form = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
spsa = SPSA(maxiter=iterations)
vqe = VQE(var_form=var_form, optimizer=spsa, callback=store_intermediate_result1, quantum_instance=qi)
result1 = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f'VQE on Aer qasm simulator (with noise): {result1.eigenvalue.real:.5f}')
print(f'Delta from reference energy value is {(result1.eigenvalue.real - ref_value):.5f}')
if counts1 or values1:
pylab.rcParams['figure.figsize'] = (12, 4)
pylab.plot(counts1, values1)
pylab.xlabel('Eval count')
pylab.ylabel('Energy')
pylab.title('Convergence with noise')
from qiskit.ignis.mitigation.measurement import CompleteMeasFitter
counts2 = []
values2 = []
if noise_model is not None:
aqua_globals.random_seed = seed
qi = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed,
coupling_map=coupling_map, noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
cals_matrix_refresh_period=30)
def store_intermediate_result2(eval_count, parameters, mean, std):
counts2.append(eval_count)
values2.append(mean)
var_form = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
spsa = SPSA(maxiter=iterations)
vqe = VQE(var_form=var_form, optimizer=spsa, callback=store_intermediate_result2, quantum_instance=qi)
result2 = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f'VQE on Aer qasm simulator (with noise and measurement error mitigation): {result2.eigenvalue.real:.5f}')
print(f'Delta from reference energy value is {(result2.eigenvalue.real - ref_value):.5f}')
|
https://github.com/yaleqc/vqe-error-mitigation
|
yaleqc
|
# Imports needed for basic no noise VQE simulation
import numpy as np
import pylab
import copy
from qiskit import BasicAer
from qiskit.aqua import aqua_globals, QuantumInstance
from qiskit.aqua.algorithms import NumPyMinimumEigensolver, VQE
from qiskit.aqua.components.optimizers import SLSQP, SPSA
from qiskit.chemistry.components.initial_states import HartreeFock
from qiskit.chemistry.components.variational_forms import UCCSD
from qiskit.chemistry.drivers import PySCFDriver
from qiskit.chemistry.core import Hamiltonian, QubitMappingType
from qiskit.circuit.library import EfficientSU2
# Some deprecated package issue; one warning is enough.
import warnings
warnings.filterwarnings(action='once')
# Defining a noise model!
from qiskit import Aer
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer import QasmSimulator
from qiskit.test.mock import FakeVigo
from qiskit.ignis.mitigation.measurement import CompleteMeasFitter
device_backend = FakeVigo()
# NOTE the key difference that the noisy simulations need to use
# 'qasm_simulator' rather than 'statevector_simulator'
backend = Aer.get_backend('qasm_simulator')
device = QasmSimulator.from_backend(device_backend)
coupling_map = device.configuration().coupling_map
noise_model = NoiseModel.from_backend(device)
basis_gates = noise_model.basis_gates
print(noise_model)
print()
molecule = 'H .0 .0 -{0}; Li .0 .0 {0}' # Define molecule; could be H2 or LiH, etc.
distances = np.arange(0.5, 3.75, 0.25) # Distances in Angstrom
vqe_energies = []
hf_energies = [] # Hartree-Fock energies
exact_energies = [] # Exact energies from numerical diagonalization
for i, d in enumerate(distances):
print('step', i)
# initialize driver
driver = PySCFDriver(molecule.format(d/2), basis='sto3g')
qmolecule = driver.run()
operator = Hamiltonian(qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True, freeze_core=True,
orbital_reduction=[-3, -2])
qubit_op, aux_ops = operator.run(qmolecule)
# exact diagonalization
exact_result = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops).run()
exact_result = operator.process_algorithm_result(exact_result)
# VQE OPTION 1: SLSQP optimizer + UCCSD var_form; NO NOISE.
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(operator.molecule_info['num_orbitals'],
operator.molecule_info['num_particles'],
qubit_mapping=operator._qubit_mapping,
two_qubit_reduction=operator._two_qubit_reduction)
# Chemical approxns to make this problem tractable.
var_form = UCCSD(num_orbitals=operator.molecule_info['num_orbitals'],
num_particles=operator.molecule_info['num_particles'],
initial_state=initial_state,
qubit_mapping=operator._qubit_mapping,
two_qubit_reduction=operator._two_qubit_reduction)
algo = VQE(qubit_op, var_form, optimizer, aux_operators=aux_ops)
quantum_instance = QuantumInstance(backend=backend,
shots=8192,
noise_model=None)
###########################################################################
# VQE OPTION 2: SLSA optimizer + SU(2) [i.e. RYRZ] var_form; w/ NOISE + Mitigation
# optimizer = SLSA(maxiter=100)
# initial_state = HartreeFock(operator.molecule_info['num_orbitals'],
# operator.molecule_info['num_particles'],
# qubit_mapping=operator._qubit_mapping,
# two_qubit_reduction=operator._two_qubit_reduction)
# # Chemical approxns to make this problem tractable.
# var_form = EfficientSU2(qubit_op.num_qubits, entanglement="linear")
# algo = VQE(qubit_op, var_form, optimizer, aux_operators=aux_ops)
# quantum_instance = QuantumInstance(backend=backend,
# shots=8192,
# noise_model=noise_model,
# coupling_map=coupling_map,
# measurement_error_mitigation_cls=CompleteMeasFitter,
# cals_matrix_refresh_period=30)
# Nb: The last two inputs incorporate mitigation. Remove to get unmitigated result.
###########################################################################
vqe_result = algo.run(quantum_instance)
vqe_result = operator.process_algorithm_result(vqe_result)
exact_energies.append(exact_result.energy)
vqe_energies.append(vqe_result.energy)
hf_energies.append(vqe_result.hartree_fock_energy)
pylab.plot(distances, hf_energies, label='Hartree Fock')
pylab.plot(distances, vqe_energies, 'o', label='VQE')
pylab.plot(distances, exact_energies, 'x', label='Exact')
pylab.xlabel('Interatomic distance')
pylab.ylabel('Energy')
pylab.title('LiH Ground State Energy')
pylab.legend(loc='upper right')
# Uncomment to save plot!
#pylab.savefig('vqe.png', dpi=300)
pylab.plot(distances, hf_energies, label='Hartree Fock')
pylab.plot(distances, vqe_energies, 'o', label='VQE')
pylab.plot(distances, exact_energies, 'x', label='Exact')
pylab.xlabel('Interatomic distance')
pylab.ylabel('Energy')
pylab.title('LiH Ground State Energy')
pylab.legend(loc='upper right')
# Uncomment to save plot!
#pylab.savefig('vqe.png', dpi=300)
from qiskit import execute, QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import Kraus, SuperOp
from qiskit.providers.aer import QasmSimulator
from qiskit.tools.visualization import plot_histogram
# Import from Qiskit Aer noise module
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise import QuantumError, ReadoutError
from qiskit.providers.aer.noise import pauli_error
from qiskit.providers.aer.noise import depolarizing_error
from qiskit.providers.aer.noise import thermal_relaxation_error
# T1 and T2 values for qubits 0-3
T1s = np.random.normal(50e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec
T2s = np.random.normal(70e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec
# Truncate random T2s <= T1s
T2s = np.array([min(T2s[j], 2 * T1s[j]) for j in range(4)])
# Instruction times (in nanoseconds)
time_u1 = 0 # virtual gate
time_u2 = 50 # (single X90 pulse)
time_u3 = 100 # (two X90 pulses)
time_cx = 300
time_reset = 1000 # 1 microsecond
time_measure = 1000 # 1 microsecond
# QuantumError objects
errors_reset = [thermal_relaxation_error(t1, t2, time_reset)
for t1, t2 in zip(T1s, T2s)]
errors_measure = [thermal_relaxation_error(t1, t2, time_measure)
for t1, t2 in zip(T1s, T2s)]
errors_u1 = [thermal_relaxation_error(t1, t2, time_u1)
for t1, t2 in zip(T1s, T2s)]
errors_u2 = [thermal_relaxation_error(t1, t2, time_u2)
for t1, t2 in zip(T1s, T2s)]
errors_u3 = [thermal_relaxation_error(t1, t2, time_u3)
for t1, t2 in zip(T1s, T2s)]
errors_cx = [[thermal_relaxation_error(t1a, t2a, time_cx).expand(
thermal_relaxation_error(t1b, t2b, time_cx))
for t1a, t2a in zip(T1s, T2s)]
for t1b, t2b in zip(T1s, T2s)]
# Add errors to noise model
noise_thermal = NoiseModel()
for j in range(4):
noise_thermal.add_quantum_error(errors_reset[j], "reset", [j])
noise_thermal.add_quantum_error(errors_measure[j], "measure", [j])
noise_thermal.add_quantum_error(errors_u1[j], "u1", [j])
noise_thermal.add_quantum_error(errors_u2[j], "u2", [j])
noise_thermal.add_quantum_error(errors_u3[j], "u3", [j])
for k in range(4):
noise_thermal.add_quantum_error(errors_cx[j][k], "cx", [j, k])
print(noise_thermal)
|
https://github.com/yaleqc/vqe-error-mitigation
|
yaleqc
|
#Assign these values as per your requirements.
global min_qubits,max_qubits,skip_qubits,max_circuits,num_shots,Noise_Inclusion
min_qubits=4
max_qubits=15 #reference files are upto 12 Qubits only
skip_qubits=2
max_circuits=3
num_shots=4092
gate_counts_plots = True
Noise_Inclusion = False
saveplots = False
Memory_utilization_plot = True
Type_of_Simulator = "built_in" #Inputs are "built_in" or "FAKE" or "FAKEV2"
backend_name = "FakeGuadalupeV2" #Can refer to the README files for the available backends
#Change your Specification of Simulator in Declaring Backend Section
#By Default : built_in -> qasm_simulator and FAKE -> FakeSantiago() and FAKEV2 -> FakeSantiagoV2()
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, transpile, execute
from qiskit.opflow import PauliTrotterEvolution, Suzuki
from qiskit.opflow.primitive_ops import PauliSumOp
import time,os,json
import matplotlib.pyplot as plt
# Import from Qiskit Aer noise module
from qiskit_aer.noise import (NoiseModel, QuantumError, ReadoutError,pauli_error, depolarizing_error, thermal_relaxation_error,reset_error)
# Benchmark Name
benchmark_name = "VQE Simulation"
# Selection of basis gate set for transpilation
# Note: selector 1 is a hardware agnostic gate set
basis_selector = 1
basis_gates_array = [
[],
['rx', 'ry', 'rz', 'cx'], # a common basis set, default
['cx', 'rz', 'sx', 'x'], # IBM default basis set
['rx', 'ry', 'rxx'], # IonQ default basis set
['h', 'p', 'cx'], # another common basis set
['u', 'cx'] # general unitaries basis gates
]
np.random.seed(0)
def get_QV(backend):
import json
# Assuming backend.conf_filename is the filename and backend.dirname is the directory path
conf_filename = backend.dirname + "/" + backend.conf_filename
# Open the JSON file
with open(conf_filename, 'r') as file:
# Load the JSON data
data = json.load(file)
# Extract the quantum_volume parameter
QV = data.get('quantum_volume', None)
return QV
def checkbackend(backend_name,Type_of_Simulator):
if Type_of_Simulator == "built_in":
available_backends = []
for i in Aer.backends():
available_backends.append(i.name)
if backend_name in available_backends:
platform = backend_name
return platform
else:
print(f"incorrect backend name or backend not available. Using qasm_simulator by default !!!!")
print(f"available backends are : {available_backends}")
platform = "qasm_simulator"
return platform
elif Type_of_Simulator == "FAKE" or Type_of_Simulator == "FAKEV2":
import qiskit.providers.fake_provider as fake_backends
if hasattr(fake_backends,backend_name) is True:
print(f"Backend {backend_name} is available for type {Type_of_Simulator}.")
backend_class = getattr(fake_backends,backend_name)
backend_instance = backend_class()
return backend_instance
else:
print(f"Backend {backend_name} is not available or incorrect for type {Type_of_Simulator}. Executing with FakeSantiago!!!")
if Type_of_Simulator == "FAKEV2":
backend_class = getattr(fake_backends,"FakeSantiagoV2")
else:
backend_class = getattr(fake_backends,"FakeSantiago")
backend_instance = backend_class()
return backend_instance
if Type_of_Simulator == "built_in":
platform = checkbackend(backend_name,Type_of_Simulator)
#By default using "Qasm Simulator"
backend = Aer.get_backend(platform)
QV_=None
print(f"{platform} device is capable of running {backend.num_qubits}")
print(f"backend version is {backend.backend_version}")
elif Type_of_Simulator == "FAKE":
basis_selector = 0
backend = checkbackend(backend_name,Type_of_Simulator)
QV_ = get_QV(backend)
platform = backend.properties().backend_name +"-"+ backend.properties().backend_version #Replace this string with the backend Provider's name as this is used for Plotting.
max_qubits=backend.configuration().n_qubits
print(f"{platform} device is capable of running {backend.configuration().n_qubits}")
print(f"{platform} has QV={QV_}")
if max_qubits > 30:
print(f"Device is capable with max_qubits = {max_qubits}")
max_qubit = 30
print(f"Using fake backend {platform} with max_qubits {max_qubits}")
elif Type_of_Simulator == "FAKEV2":
basis_selector = 0
if "V2" not in backend_name:
backend_name = backend_name+"V2"
backend = checkbackend(backend_name,Type_of_Simulator)
QV_ = get_QV(backend)
platform = backend.name +"-" +backend.backend_version
max_qubits=backend.num_qubits
print(f"{platform} device is capable of running {backend.num_qubits}")
print(f"{platform} has QV={QV_}")
if max_qubits > 30:
print(f"Device is capable with max_qubits = {max_qubits}")
max_qubit = 30
print(f"Using fake backend {platform} with max_qubits {max_qubits}")
else:
print("Enter valid Simulator.....")
# saved circuits for display
QC_ = None
Hf_ = None
CO_ = None
################### Circuit Definition #######################################
# Construct a Qiskit circuit for VQE Energy evaluation with UCCSD ansatz
# param: n_spin_orbs - The number of spin orbitals.
# return: return a Qiskit circuit for this VQE ansatz
def VQEEnergy(n_spin_orbs, na, nb, circuit_id=0, method=1):
# number of alpha spin orbitals
norb_a = int(n_spin_orbs / 2)
# construct the Hamiltonian
qubit_op = ReadHamiltonian(n_spin_orbs)
# allocate qubits
num_qubits = n_spin_orbs
qr = QuantumRegister(num_qubits)
qc = QuantumCircuit(qr, name=f"vqe-ansatz({method})-{num_qubits}-{circuit_id}")
# initialize the HF state
Hf = HartreeFock(num_qubits, na, nb)
qc.append(Hf, qr)
# form the list of single and double excitations
excitationList = []
for occ_a in range(na):
for vir_a in range(na, norb_a):
excitationList.append((occ_a, vir_a))
for occ_b in range(norb_a, norb_a+nb):
for vir_b in range(norb_a+nb, n_spin_orbs):
excitationList.append((occ_b, vir_b))
for occ_a in range(na):
for vir_a in range(na, norb_a):
for occ_b in range(norb_a, norb_a+nb):
for vir_b in range(norb_a+nb, n_spin_orbs):
excitationList.append((occ_a, vir_a, occ_b, vir_b))
# get cluster operators in Paulis
pauli_list = readPauliExcitation(n_spin_orbs, circuit_id)
# loop over the Pauli operators
for index, PauliOp in enumerate(pauli_list):
# get circuit for exp(-iP)
cluster_qc = ClusterOperatorCircuit(PauliOp, excitationList[index])
# add to ansatz
qc.append(cluster_qc, [i for i in range(cluster_qc.num_qubits)])
# method 1, only compute the last term in the Hamiltonian
if method == 1:
# last term in Hamiltonian
qc_with_mea, is_diag = ExpectationCircuit(qc, qubit_op[1], num_qubits)
# return the circuit
return qc_with_mea
# now we need to add the measurement parts to the circuit
# circuit list
qc_list = []
diag = []
off_diag = []
global normalization
normalization = 0.0
# add the first non-identity term
identity_qc = qc.copy()
identity_qc.measure_all()
qc_list.append(identity_qc) # add to circuit list
diag.append(qubit_op[1])
normalization += abs(qubit_op[1].coeffs[0]) # add to normalization factor
diag_coeff = abs(qubit_op[1].coeffs[0]) # add to coefficients of diagonal terms
# loop over rest of terms
for index, p in enumerate(qubit_op[2:]):
# get the circuit with expectation measurements
qc_with_mea, is_diag = ExpectationCircuit(qc, p, num_qubits)
# accumulate normalization
normalization += abs(p.coeffs[0])
# add to circuit list if non-diagonal
if not is_diag:
qc_list.append(qc_with_mea)
else:
diag_coeff += abs(p.coeffs[0])
# diagonal term
if is_diag:
diag.append(p)
# off-diagonal term
else:
off_diag.append(p)
# modify the name of diagonal circuit
qc_list[0].name = qubit_op[1].primitive.to_list()[0][0] + " " + str(np.real(diag_coeff))
normalization /= len(qc_list)
return qc_list
# Function that constructs the circuit for a given cluster operator
def ClusterOperatorCircuit(pauli_op, excitationIndex):
# compute exp(-iP)
exp_ip = pauli_op.exp_i()
# Trotter approximation
qc_op = PauliTrotterEvolution(trotter_mode=Suzuki(order=1, reps=1)).convert(exp_ip)
# convert to circuit
qc = qc_op.to_circuit(); qc.name = f'Cluster Op {excitationIndex}'
global CO_
if CO_ == None or qc.num_qubits <= 4:
if qc.num_qubits < 7: CO_ = qc
# return this circuit
return qc
# Function that adds expectation measurements to the raw circuits
def ExpectationCircuit(qc, pauli, nqubit, method=2):
# copy the unrotated circuit
raw_qc = qc.copy()
# whether this term is diagonal
is_diag = True
# primitive Pauli string
PauliString = pauli.primitive.to_list()[0][0]
# coefficient
coeff = pauli.coeffs[0]
# basis rotation
for i, p in enumerate(PauliString):
target_qubit = nqubit - i - 1
if (p == "X"):
is_diag = False
raw_qc.h(target_qubit)
elif (p == "Y"):
raw_qc.sdg(target_qubit)
raw_qc.h(target_qubit)
is_diag = False
# perform measurements
raw_qc.measure_all()
# name of this circuit
raw_qc.name = PauliString + " " + str(np.real(coeff))
# save circuit
global QC_
if QC_ == None or nqubit <= 4:
if nqubit < 7: QC_ = raw_qc
return raw_qc, is_diag
# Function that implements the Hartree-Fock state
def HartreeFock(norb, na, nb):
# initialize the quantum circuit
qc = QuantumCircuit(norb, name="Hf")
# alpha electrons
for ia in range(na):
qc.x(ia)
# beta electrons
for ib in range(nb):
qc.x(ib+int(norb/2))
# Save smaller circuit
global Hf_
if Hf_ == None or norb <= 4:
if norb < 7: Hf_ = qc
# return the circuit
return qc
################ Helper Functions
# Function that converts a list of single and double excitation operators to Pauli operators
def readPauliExcitation(norb, circuit_id=0):
# load pre-computed data
filename = os.path.join(f'ansatzes/{norb}_qubit_{circuit_id}.txt')
with open(filename) as f:
data = f.read()
ansatz_dict = json.loads(data)
# initialize Pauli list
pauli_list = []
# current coefficients
cur_coeff = 1e5
# current Pauli list
cur_list = []
# loop over excitations
for ext in ansatz_dict:
if cur_coeff > 1e4:
cur_coeff = ansatz_dict[ext]
cur_list = [(ext, ansatz_dict[ext])]
elif abs(abs(ansatz_dict[ext]) - abs(cur_coeff)) > 1e-4:
pauli_list.append(PauliSumOp.from_list(cur_list))
cur_coeff = ansatz_dict[ext]
cur_list = [(ext, ansatz_dict[ext])]
else:
cur_list.append((ext, ansatz_dict[ext]))
# add the last term
pauli_list.append(PauliSumOp.from_list(cur_list))
# return Pauli list
return pauli_list
# Get the Hamiltonian by reading in pre-computed file
def ReadHamiltonian(nqubit):
# load pre-computed data
filename = os.path.join(f'Hamiltonians/{nqubit}_qubit.txt')
with open(filename) as f:
data = f.read()
ham_dict = json.loads(data)
# pauli list
pauli_list = []
for p in ham_dict:
pauli_list.append( (p, ham_dict[p]) )
# build Hamiltonian
ham = PauliSumOp.from_list(pauli_list)
# return Hamiltonian
return ham
# Create an empty noise model
noise_parameters = NoiseModel()
if Type_of_Simulator == "built_in":
# Add depolarizing error to all single qubit gates with error rate 0.05% and to all two qubit gates with error rate 0.5%
depol_one_qb_error = 0.05
depol_two_qb_error = 0.005
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(depol_one_qb_error, 1), ['rx', 'ry', 'rz'])
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(depol_two_qb_error, 2), ['cx'])
# Add amplitude damping error to all single qubit gates with error rate 0.0% and to all two qubit gates with error rate 0.0%
amp_damp_one_qb_error = 0.0
amp_damp_two_qb_error = 0.0
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(amp_damp_one_qb_error, 1), ['rx', 'ry', 'rz'])
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(amp_damp_two_qb_error, 2), ['cx'])
# Add reset noise to all single qubit resets
reset_to_zero_error = 0.005
reset_to_one_error = 0.005
noise_parameters.add_all_qubit_quantum_error(reset_error(reset_to_zero_error, reset_to_one_error),["reset"])
# Add readout error
p0given1_error = 0.000
p1given0_error = 0.000
error_meas = ReadoutError([[1 - p1given0_error, p1given0_error], [p0given1_error, 1 - p0given1_error]])
noise_parameters.add_all_qubit_readout_error(error_meas)
#print(noise_parameters)
elif Type_of_Simulator == "FAKE"or"FAKEV2":
noise_parameters = NoiseModel.from_backend(backend)
#print(noise_parameters)
### Analysis methods to be expanded and eventually compiled into a separate analysis.py file
import math, functools
def hellinger_fidelity_with_expected(p, q):
""" p: result distribution, may be passed as a counts distribution
q: the expected distribution to be compared against
References:
`Hellinger Distance @ wikipedia <https://en.wikipedia.org/wiki/Hellinger_distance>`_
Qiskit Hellinger Fidelity Function
"""
p_sum = sum(p.values())
q_sum = sum(q.values())
if q_sum == 0:
print("ERROR: polarization_fidelity(), expected distribution is invalid, all counts equal to 0")
return 0
p_normed = {}
for key, val in p.items():
p_normed[key] = val/p_sum
# if p_sum != 0:
# p_normed[key] = val/p_sum
# else:
# p_normed[key] = 0
q_normed = {}
for key, val in q.items():
q_normed[key] = val/q_sum
total = 0
for key, val in p_normed.items():
if key in q_normed.keys():
total += (np.sqrt(val) - np.sqrt(q_normed[key]))**2
del q_normed[key]
else:
total += val
total += sum(q_normed.values())
# in some situations (error mitigation) this can go negative, use abs value
if total < 0:
print(f"WARNING: using absolute value in fidelity calculation")
total = abs(total)
dist = np.sqrt(total)/np.sqrt(2)
fidelity = (1-dist**2)**2
return fidelity
def polarization_fidelity(counts, correct_dist, thermal_dist=None):
"""
Combines Hellinger fidelity and polarization rescaling into fidelity calculation
used in every benchmark
counts: the measurement outcomes after `num_shots` algorithm runs
correct_dist: the distribution we expect to get for the algorithm running perfectly
thermal_dist: optional distribution to pass in distribution from a uniform
superposition over all states. If `None`: generated as
`uniform_dist` with the same qubits as in `counts`
returns both polarization fidelity and the hellinger fidelity
Polarization from: `https://arxiv.org/abs/2008.11294v1`
"""
num_measured_qubits = len(list(correct_dist.keys())[0])
#print(num_measured_qubits)
counts = {k.zfill(num_measured_qubits): v for k, v in counts.items()}
# calculate hellinger fidelity between measured expectation values and correct distribution
hf_fidelity = hellinger_fidelity_with_expected(counts,correct_dist)
# to limit cpu and memory utilization, skip noise correction if more than 16 measured qubits
if num_measured_qubits > 16:
return { 'fidelity':hf_fidelity, 'hf_fidelity':hf_fidelity }
# if not provided, generate thermal dist based on number of qubits
if thermal_dist == None:
thermal_dist = uniform_dist(num_measured_qubits)
# set our fidelity rescaling value as the hellinger fidelity for a depolarized state
floor_fidelity = hellinger_fidelity_with_expected(thermal_dist, correct_dist)
# rescale fidelity result so uniform superposition (random guessing) returns fidelity
# rescaled to 0 to provide a better measure of success of the algorithm (polarization)
new_floor_fidelity = 0
fidelity = rescale_fidelity(hf_fidelity, floor_fidelity, new_floor_fidelity)
return { 'fidelity':fidelity, 'hf_fidelity':hf_fidelity }
## Uniform distribution function commonly used
def rescale_fidelity(fidelity, floor_fidelity, new_floor_fidelity):
"""
Linearly rescales our fidelities to allow comparisons of fidelities across benchmarks
fidelity: raw fidelity to rescale
floor_fidelity: threshold fidelity which is equivalent to random guessing
new_floor_fidelity: what we rescale the floor_fidelity to
Ex, with floor_fidelity = 0.25, new_floor_fidelity = 0.0:
1 -> 1;
0.25 -> 0;
0.5 -> 0.3333;
"""
rescaled_fidelity = (1-new_floor_fidelity)/(1-floor_fidelity) * (fidelity - 1) + 1
# ensure fidelity is within bounds (0, 1)
if rescaled_fidelity < 0:
rescaled_fidelity = 0.0
if rescaled_fidelity > 1:
rescaled_fidelity = 1.0
return rescaled_fidelity
def uniform_dist(num_state_qubits):
dist = {}
for i in range(2**num_state_qubits):
key = bin(i)[2:].zfill(num_state_qubits)
dist[key] = 1/(2**num_state_qubits)
return dist
from matplotlib.patches import Rectangle
import matplotlib.cm as cm
from matplotlib.colors import ListedColormap, LinearSegmentedColormap, Normalize
from matplotlib.patches import Circle
############### Color Map functions
# Create a selection of colormaps from which to choose; default to custom_spectral
cmap_spectral = plt.get_cmap('Spectral')
cmap_greys = plt.get_cmap('Greys')
cmap_blues = plt.get_cmap('Blues')
cmap_custom_spectral = None
# the default colormap is the spectral map
cmap = cmap_spectral
cmap_orig = cmap_spectral
# current cmap normalization function (default None)
cmap_norm = None
default_fade_low_fidelity_level = 0.16
default_fade_rate = 0.7
# Specify a normalization function here (default None)
def set_custom_cmap_norm(vmin, vmax):
global cmap_norm
if vmin == vmax or (vmin == 0.0 and vmax == 1.0):
print("... setting cmap norm to None")
cmap_norm = None
else:
print(f"... setting cmap norm to [{vmin}, {vmax}]")
cmap_norm = Normalize(vmin=vmin, vmax=vmax)
# Remake the custom spectral colormap with user settings
def set_custom_cmap_style(
fade_low_fidelity_level=default_fade_low_fidelity_level,
fade_rate=default_fade_rate):
#print("... set custom map style")
global cmap, cmap_custom_spectral, cmap_orig
cmap_custom_spectral = create_custom_spectral_cmap(
fade_low_fidelity_level=fade_low_fidelity_level, fade_rate=fade_rate)
cmap = cmap_custom_spectral
cmap_orig = cmap_custom_spectral
# Create the custom spectral colormap from the base spectral
def create_custom_spectral_cmap(
fade_low_fidelity_level=default_fade_low_fidelity_level,
fade_rate=default_fade_rate):
# determine the breakpoint from the fade level
num_colors = 100
breakpoint = round(fade_low_fidelity_level * num_colors)
# get color list for spectral map
spectral_colors = [cmap_spectral(v/num_colors) for v in range(num_colors)]
#print(fade_rate)
# create a list of colors to replace those below the breakpoint
# and fill with "faded" color entries (in reverse)
low_colors = [0] * breakpoint
#for i in reversed(range(breakpoint)):
for i in range(breakpoint):
# x is index of low colors, normalized 0 -> 1
x = i / breakpoint
# get color at this index
bc = spectral_colors[i]
r0 = bc[0]
g0 = bc[1]
b0 = bc[2]
z0 = bc[3]
r_delta = 0.92 - r0
#print(f"{x} {bc} {r_delta}")
# compute saturation and greyness ratio
sat_ratio = 1 - x
#grey_ratio = 1 - x
''' attempt at a reflective gradient
if i >= breakpoint/2:
xf = 2*(x - 0.5)
yf = pow(xf, 1/fade_rate)/2
grey_ratio = 1 - (yf + 0.5)
else:
xf = 2*(0.5 - x)
yf = pow(xf, 1/fade_rate)/2
grey_ratio = 1 - (0.5 - yf)
'''
grey_ratio = 1 - math.pow(x, 1/fade_rate)
#print(f" {xf} {yf} ")
#print(f" {sat_ratio} {grey_ratio}")
r = r0 + r_delta * sat_ratio
g_delta = r - g0
b_delta = r - b0
g = g0 + g_delta * grey_ratio
b = b0 + b_delta * grey_ratio
#print(f"{r} {g} {b}\n")
low_colors[i] = (r,g,b,z0)
#print(low_colors)
# combine the faded low colors with the regular spectral cmap to make a custom version
cmap_custom_spectral = ListedColormap(low_colors + spectral_colors[breakpoint:])
#spectral_colors = [cmap_custom_spectral(v/10) for v in range(10)]
#for i in range(10): print(spectral_colors[i])
#print("")
return cmap_custom_spectral
# Make the custom spectral color map the default on module init
set_custom_cmap_style()
# Arrange the stored annotations optimally and add to plot
def anno_volumetric_data(ax, depth_base=2, label='Depth',
labelpos=(0.2, 0.7), labelrot=0, type=1, fill=True):
# sort all arrays by the x point of the text (anno_offs)
global x_anno_offs, y_anno_offs, anno_labels, x_annos, y_annos
all_annos = sorted(zip(x_anno_offs, y_anno_offs, anno_labels, x_annos, y_annos))
x_anno_offs = [a for a,b,c,d,e in all_annos]
y_anno_offs = [b for a,b,c,d,e in all_annos]
anno_labels = [c for a,b,c,d,e in all_annos]
x_annos = [d for a,b,c,d,e in all_annos]
y_annos = [e for a,b,c,d,e in all_annos]
#print(f"{x_anno_offs}")
#print(f"{y_anno_offs}")
#print(f"{anno_labels}")
for i in range(len(anno_labels)):
x_anno = x_annos[i]
y_anno = y_annos[i]
x_anno_off = x_anno_offs[i]
y_anno_off = y_anno_offs[i]
label = anno_labels[i]
if i > 0:
x_delta = abs(x_anno_off - x_anno_offs[i - 1])
y_delta = abs(y_anno_off - y_anno_offs[i - 1])
if y_delta < 0.7 and x_delta < 2:
y_anno_off = y_anno_offs[i] = y_anno_offs[i - 1] - 0.6
#x_anno_off = x_anno_offs[i] = x_anno_offs[i - 1] + 0.1
ax.annotate(label,
xy=(x_anno+0.0, y_anno+0.1),
arrowprops=dict(facecolor='black', shrink=0.0,
width=0.5, headwidth=4, headlength=5, edgecolor=(0.8,0.8,0.8)),
xytext=(x_anno_off + labelpos[0], y_anno_off + labelpos[1]),
rotation=labelrot,
horizontalalignment='left', verticalalignment='baseline',
color=(0.2,0.2,0.2),
clip_on=True)
if saveplots == True:
plt.savefig("VolumetricPlotSample.jpg")
# Plot one group of data for volumetric presentation
def plot_volumetric_data(ax, w_data, d_data, f_data, depth_base=2, label='Depth',
labelpos=(0.2, 0.7), labelrot=0, type=1, fill=True, w_max=18, do_label=False, do_border=True,
x_size=1.0, y_size=1.0, zorder=1, offset_flag=False,
max_depth=0, suppress_low_fidelity=False):
# since data may come back out of order, save point at max y for annotation
i_anno = 0
x_anno = 0
y_anno = 0
# plot data rectangles
low_fidelity_count = True
last_y = -1
k = 0
# determine y-axis dimension for one pixel to use for offset of bars that start at 0
(_, dy) = get_pixel_dims(ax)
# do this loop in reverse to handle the case where earlier cells are overlapped by later cells
for i in reversed(range(len(d_data))):
x = depth_index(d_data[i], depth_base)
y = float(w_data[i])
f = f_data[i]
# each time we star a new row, reset the offset counter
# DEVNOTE: this is highly specialized for the QA area plots, where there are 8 bars
# that represent time starting from 0 secs. We offset by one pixel each and center the group
if y != last_y:
last_y = y;
k = 3 # hardcoded for 8 cells, offset by 3
#print(f"{i = } {x = } {y = }")
if max_depth > 0 and d_data[i] > max_depth:
#print(f"... excessive depth (2), skipped; w={y} d={d_data[i]}")
break;
# reject cells with low fidelity
if suppress_low_fidelity and f < suppress_low_fidelity_level:
if low_fidelity_count: break
else: low_fidelity_count = True
# the only time this is False is when doing merged gradation plots
if do_border == True:
# this case is for an array of x_sizes, i.e. each box has different width
if isinstance(x_size, list):
# draw each of the cells, with no offset
if not offset_flag:
ax.add_patch(box_at(x, y, f, type=type, fill=fill, x_size=x_size[i], y_size=y_size, zorder=zorder))
# use an offset for y value, AND account for x and width to draw starting at 0
else:
ax.add_patch(box_at((x/2 + x_size[i]/4), y + k*dy, f, type=type, fill=fill, x_size=x+ x_size[i]/2, y_size=y_size, zorder=zorder))
# this case is for only a single cell
else:
ax.add_patch(box_at(x, y, f, type=type, fill=fill, x_size=x_size, y_size=y_size))
# save the annotation point with the largest y value
if y >= y_anno:
x_anno = x
y_anno = y
i_anno = i
# move the next bar down (if using offset)
k -= 1
# if no data rectangles plotted, no need for a label
if x_anno == 0 or y_anno == 0:
return
x_annos.append(x_anno)
y_annos.append(y_anno)
anno_dist = math.sqrt( (y_anno - 1)**2 + (x_anno - 1)**2 )
# adjust radius of annotation circle based on maximum width of apps
anno_max = 10
if w_max > 10:
anno_max = 14
if w_max > 14:
anno_max = 18
scale = anno_max / anno_dist
# offset of text from end of arrow
if scale > 1:
x_anno_off = scale * x_anno - x_anno - 0.5
y_anno_off = scale * y_anno - y_anno
else:
x_anno_off = 0.7
y_anno_off = 0.5
x_anno_off += x_anno
y_anno_off += y_anno
# print(f"... {xx} {yy} {anno_dist}")
x_anno_offs.append(x_anno_off)
y_anno_offs.append(y_anno_off)
anno_labels.append(label)
if do_label:
ax.annotate(label, xy=(x_anno+labelpos[0], y_anno+labelpos[1]), rotation=labelrot,
horizontalalignment='left', verticalalignment='bottom', color=(0.2,0.2,0.2))
x_annos = []
y_annos = []
x_anno_offs = []
y_anno_offs = []
anno_labels = []
# init arrays to hold annotation points for label spreading
def vplot_anno_init ():
global x_annos, y_annos, x_anno_offs, y_anno_offs, anno_labels
x_annos = []
y_annos = []
x_anno_offs = []
y_anno_offs = []
anno_labels = []
# Number of ticks on volumetric depth axis
max_depth_log = 22
# average transpile factor between base QV depth and our depth based on results from QV notebook
QV_transpile_factor = 12.7
# format a number using K,M,B,T for large numbers, optionally rounding to 'digits' decimal places if num > 1
# (sign handling may be incorrect)
def format_number(num, digits=0):
if isinstance(num, str): num = float(num)
num = float('{:.3g}'.format(abs(num)))
sign = ''
metric = {'T': 1000000000000, 'B': 1000000000, 'M': 1000000, 'K': 1000, '': 1}
for index in metric:
num_check = num / metric[index]
if num_check >= 1:
num = round(num_check, digits)
sign = index
break
numstr = f"{str(num)}"
if '.' in numstr:
numstr = numstr.rstrip('0').rstrip('.')
return f"{numstr}{sign}"
# Return the color associated with the spcific value, using color map norm
def get_color(value):
# if there is a normalize function installed, scale the data
if cmap_norm:
value = float(cmap_norm(value))
if cmap == cmap_spectral:
value = 0.05 + value*0.9
elif cmap == cmap_blues:
value = 0.00 + value*1.0
else:
value = 0.0 + value*0.95
return cmap(value)
# Return the x and y equivalent to a single pixel for the given plot axis
def get_pixel_dims(ax):
# transform 0 -> 1 to pixel dimensions
pixdims = ax.transData.transform([(0,1),(1,0)])-ax.transData.transform((0,0))
xpix = pixdims[1][0]
ypix = pixdims[0][1]
#determine x- and y-axis dimension for one pixel
dx = (1 / xpix)
dy = (1 / ypix)
return (dx, dy)
############### Helper functions
# return the base index for a circuit depth value
# take the log in the depth base, and add 1
def depth_index(d, depth_base):
if depth_base <= 1:
return d
if d == 0:
return 0
return math.log(d, depth_base) + 1
# draw a box at x,y with various attributes
def box_at(x, y, value, type=1, fill=True, x_size=1.0, y_size=1.0, alpha=1.0, zorder=1):
value = min(value, 1.0)
value = max(value, 0.0)
fc = get_color(value)
ec = (0.5,0.5,0.5)
return Rectangle((x - (x_size/2), y - (y_size/2)), x_size, y_size,
alpha=alpha,
edgecolor = ec,
facecolor = fc,
fill=fill,
lw=0.5*y_size,
zorder=zorder)
# draw a circle at x,y with various attributes
def circle_at(x, y, value, type=1, fill=True):
size = 1.0
value = min(value, 1.0)
value = max(value, 0.0)
fc = get_color(value)
ec = (0.5,0.5,0.5)
return Circle((x, y), size/2,
alpha = 0.7, # DEVNOTE: changed to 0.7 from 0.5, to handle only one cell
edgecolor = ec,
facecolor = fc,
fill=fill,
lw=0.5)
def box4_at(x, y, value, type=1, fill=True, alpha=1.0):
size = 1.0
value = min(value, 1.0)
value = max(value, 0.0)
fc = get_color(value)
ec = (0.3,0.3,0.3)
ec = fc
return Rectangle((x - size/8, y - size/2), size/4, size,
alpha=alpha,
edgecolor = ec,
facecolor = fc,
fill=fill,
lw=0.1)
# Draw a Quantum Volume rectangle with specified width and depth, and grey-scale value
def qv_box_at(x, y, qv_width, qv_depth, value, depth_base):
#print(f"{qv_width} {qv_depth} {depth_index(qv_depth, depth_base)}")
return Rectangle((x - 0.5, y - 0.5), depth_index(qv_depth, depth_base), qv_width,
edgecolor = (value,value,value),
facecolor = (value,value,value),
fill=True,
lw=1)
def bkg_box_at(x, y, value=0.9):
size = 0.6
return Rectangle((x - size/2, y - size/2), size, size,
edgecolor = (.75,.75,.75),
facecolor = (value,value,value),
fill=True,
lw=0.5)
def bkg_empty_box_at(x, y):
size = 0.6
return Rectangle((x - size/2, y - size/2), size, size,
edgecolor = (.75,.75,.75),
facecolor = (1.0,1.0,1.0),
fill=True,
lw=0.5)
# Plot the background for the volumetric analysis
def plot_volumetric_background(max_qubits=11, QV=32, depth_base=2, suptitle=None, avail_qubits=0, colorbar_label="Avg Result Fidelity"):
if suptitle == None:
suptitle = f"Volumetric Positioning\nCircuit Dimensions and Fidelity Overlaid on Quantum Volume = {QV}"
QV0 = QV
qv_estimate = False
est_str = ""
if QV == 0: # QV = 0 indicates "do not draw QV background or label"
QV = 2048
elif QV < 0: # QV < 0 indicates "add est. to label"
QV = -QV
qv_estimate = True
est_str = " (est.)"
if avail_qubits > 0 and max_qubits > avail_qubits:
max_qubits = avail_qubits
max_width = 13
if max_qubits > 11: max_width = 18
if max_qubits > 14: max_width = 20
if max_qubits > 16: max_width = 24
if max_qubits > 24: max_width = 33
#print(f"... {avail_qubits} {max_qubits} {max_width}")
plot_width = 6.8
plot_height = 0.5 + plot_width * (max_width / max_depth_log)
#print(f"... {plot_width} {plot_height}")
# define matplotlib figure and axis; use constrained layout to fit colorbar to right
fig, ax = plt.subplots(figsize=(plot_width, plot_height), constrained_layout=True)
plt.suptitle(suptitle)
plt.xlim(0, max_depth_log)
plt.ylim(0, max_width)
# circuit depth axis (x axis)
xbasis = [x for x in range(1,max_depth_log)]
xround = [depth_base**(x-1) for x in xbasis]
xlabels = [format_number(x) for x in xround]
ax.set_xlabel('Circuit Depth')
ax.set_xticks(xbasis)
plt.xticks(xbasis, xlabels, color='black', rotation=45, ha='right', va='top', rotation_mode="anchor")
# other label options
#plt.xticks(xbasis, xlabels, color='black', rotation=-60, ha='left')
#plt.xticks(xbasis, xlabels, color='black', rotation=-45, ha='left', va='center', rotation_mode="anchor")
# circuit width axis (y axis)
ybasis = [y for y in range(1,max_width)]
yround = [1,2,3,4,5,6,7,8,10,12,15] # not used now
ylabels = [str(y) for y in yround] # not used now
#ax.set_ylabel('Circuit Width (Number of Qubits)')
ax.set_ylabel('Circuit Width')
ax.set_yticks(ybasis)
#create simple line plot (not used right now)
#ax.plot([0, 10],[0, 10])
log2QV = math.log2(QV)
QV_width = log2QV
QV_depth = log2QV * QV_transpile_factor
# show a quantum volume rectangle of QV = 64 e.g. (6 x 6)
if QV0 != 0:
ax.add_patch(qv_box_at(1, 1, QV_width, QV_depth, 0.87, depth_base))
else:
ax.add_patch(qv_box_at(1, 1, QV_width, QV_depth, 0.91, depth_base))
# the untranspiled version is commented out - we do not show this by default
# also show a quantum volume rectangle un-transpiled
# ax.add_patch(qv_box_at(1, 1, QV_width, QV_width, 0.80, depth_base))
# show 2D array of volumetric cells based on this QV_transpiled
# DEVNOTE: we use +1 only to make the visuals work; s/b without
# Also, the second arg of the min( below seems incorrect, needs correction
maxprod = (QV_width + 1) * (QV_depth + 1)
for w in range(1, min(max_width, round(QV) + 1)):
# don't show VB squares if width greater than known available qubits
if avail_qubits != 0 and w > avail_qubits:
continue
i_success = 0
for d in xround:
# polarization factor for low circuit widths
maxtest = maxprod / ( 1 - 1 / (2**w) )
# if circuit would fail here, don't draw box
if d > maxtest: continue
if w * d > maxtest: continue
# guess for how to capture how hardware decays with width, not entirely correct
# # reduce maxtext by a factor of number of qubits > QV_width
# # just an approximation to account for qubit distances
# if w > QV_width:
# over = w - QV_width
# maxtest = maxtest / (1 + (over/QV_width))
# draw a box at this width and depth
id = depth_index(d, depth_base)
# show vb rectangles; if not showing QV, make all hollow (or less dark)
if QV0 == 0:
#ax.add_patch(bkg_empty_box_at(id, w))
ax.add_patch(bkg_box_at(id, w, 0.95))
else:
ax.add_patch(bkg_box_at(id, w, 0.9))
# save index of last successful depth
i_success += 1
# plot empty rectangle after others
d = xround[i_success]
id = depth_index(d, depth_base)
ax.add_patch(bkg_empty_box_at(id, w))
# Add annotation showing quantum volume
if QV0 != 0:
t = ax.text(max_depth_log - 2.0, 1.5, f"QV{est_str}={QV}", size=12,
horizontalalignment='right', verticalalignment='center', color=(0.2,0.2,0.2),
bbox=dict(boxstyle="square,pad=0.3", fc=(.9,.9,.9), ec="grey", lw=1))
# add colorbar to right of plot
plt.colorbar(cm.ScalarMappable(cmap=cmap), cax=None, ax=ax,
shrink=0.6, label=colorbar_label, panchor=(0.0, 0.7))
return ax
# Function to calculate circuit depth
def calculate_circuit_depth(qc):
# Calculate the depth of the circuit
depth = qc.depth()
return depth
def calculate_transpiled_depth(qc,basis_selector):
# use either the backend or one of the basis gate sets
if basis_selector == 0:
qc = transpile(qc, backend)
else:
basis_gates = basis_gates_array[basis_selector]
qc = transpile(qc, basis_gates=basis_gates, seed_transpiler=0)
transpiled_depth = qc.depth()
return transpiled_depth,qc
def plot_fidelity_data(fidelity_data, Hf_fidelity_data, title):
avg_fidelity_means = []
avg_Hf_fidelity_means = []
avg_num_qubits_values = list(fidelity_data.keys())
# Calculate the average fidelity and Hamming fidelity for each unique number of qubits
for num_qubits in avg_num_qubits_values:
avg_fidelity = np.average(fidelity_data[num_qubits])
avg_fidelity_means.append(avg_fidelity)
avg_Hf_fidelity = np.mean(Hf_fidelity_data[num_qubits])
avg_Hf_fidelity_means.append(avg_Hf_fidelity)
return avg_fidelity_means,avg_Hf_fidelity_means
list_of_gates = []
def list_of_standardgates():
import qiskit.circuit.library as lib
from qiskit.circuit import Gate
import inspect
# List all the attributes of the library module
gate_list = dir(lib)
# Filter out non-gate classes (like functions, variables, etc.)
gates = [gate for gate in gate_list if isinstance(getattr(lib, gate), type) and issubclass(getattr(lib, gate), Gate)]
# Get method names from QuantumCircuit
circuit_methods = inspect.getmembers(QuantumCircuit, inspect.isfunction)
method_names = [name for name, _ in circuit_methods]
# Map gate class names to method names
gate_to_method = {}
for gate in gates:
gate_class = getattr(lib, gate)
class_name = gate_class.__name__.replace('Gate', '').lower() # Normalize class name
for method in method_names:
if method == class_name or method == class_name.replace('cr', 'c-r'):
gate_to_method[gate] = method
break
# Add common operations that are not strictly gates
additional_operations = {
'Measure': 'measure',
'Barrier': 'barrier',
}
gate_to_method.update(additional_operations)
for k,v in gate_to_method.items():
list_of_gates.append(v)
def update_counts(gates,custom_gates):
operations = {}
for key, value in gates.items():
operations[key] = value
for key, value in custom_gates.items():
if key in operations:
operations[key] += value
else:
operations[key] = value
return operations
def get_gate_counts(gates,custom_gate_defs):
result = gates.copy()
# Iterate over the gate counts in the quantum circuit
for gate, count in gates.items():
if gate in custom_gate_defs:
custom_gate_ops = custom_gate_defs[gate]
# Multiply custom gate operations by the count of the custom gate in the circuit
for _ in range(count):
result = update_counts(result, custom_gate_ops)
# Remove the custom gate entry as we have expanded it
del result[gate]
return result
dict_of_qc = dict()
custom_gates_defs = dict()
# Function to count operations recursively
def count_operations(qc):
dict_of_qc.clear()
circuit_traverser(qc)
operations = dict()
operations = dict_of_qc[qc.name]
del dict_of_qc[qc.name]
# print("operations :",operations)
# print("dict_of_qc :",dict_of_qc)
for keys in operations.keys():
if keys not in list_of_gates:
for k,v in dict_of_qc.items():
if k in operations.keys():
custom_gates_defs[k] = v
operations=get_gate_counts(operations,custom_gates_defs)
custom_gates_defs.clear()
return operations
def circuit_traverser(qc):
dict_of_qc[qc.name]=dict(qc.count_ops())
for i in qc.data:
if str(i.operation.name) not in list_of_gates:
qc_1 = i.operation.definition
circuit_traverser(qc_1)
def get_memory():
import resource
usage = resource.getrusage(resource.RUSAGE_SELF)
max_mem = usage.ru_maxrss/1024 #in MB
return max_mem
def analyzer(qc,references,num_qubits):
# total circuit name (pauli string + coefficient)
total_name = qc.name
# pauli string
pauli_string = total_name.split()[0]
# get the correct measurement
if (len(total_name.split()) == 2):
correct_dist = references[pauli_string]
else:
circuit_id = int(total_name.split()[2])
correct_dist = references[f"Qubits - {num_qubits} - {circuit_id}"]
return correct_dist,total_name
# Max qubits must be 12 since the referenced files only go to 12 qubits
MAX_QUBITS = 12
method = 1
def run (min_qubits=min_qubits, max_qubits=max_qubits, skip_qubits=2,
max_circuits=max_circuits, num_shots=num_shots):
creation_times = []
elapsed_times = []
quantum_times = []
circuit_depths = []
transpiled_depths = []
fidelity_data = {}
Hf_fidelity_data = {}
numckts = []
mem_usage = []
algorithmic_1Q_gate_counts = []
algorithmic_2Q_gate_counts = []
transpiled_1Q_gate_counts = []
transpiled_2Q_gate_counts = []
print(f"{benchmark_name} Benchmark Program - {platform}")
#defining all the standard gates supported by qiskit in a list
if gate_counts_plots == True:
list_of_standardgates()
max_qubits = max(max_qubits, min_qubits) # max must be >= min
# validate parameters (smallest circuit is 4 qubits and largest is 10 qubits)
max_qubits = min(max_qubits, MAX_QUBITS)
min_qubits = min(max(4, min_qubits), max_qubits)
if min_qubits % 2 == 1: min_qubits += 1 # min_qubits must be even
skip_qubits = max(1, skip_qubits)
if method == 2: max_circuits = 1
if max_qubits < 4:
print(f"Max number of qubits {max_qubits} is too low to run method {method} of VQE algorithm")
return
global max_ckts
max_ckts = max_circuits
global min_qbits,max_qbits,skp_qubits
min_qbits = min_qubits
max_qbits = max_qubits
skp_qubits = skip_qubits
print(f"min, max qubits = {min_qubits} {max_qubits}")
# Execute Benchmark Program N times for multiple circuit sizes
for input_size in range(min_qubits, max_qubits + 1, skip_qubits):
# reset random seed
np.random.seed(0)
# determine the number of circuits to execute for this group
num_circuits = min(3, max_circuits)
num_qubits = input_size
fidelity_data[num_qubits] = []
Hf_fidelity_data[num_qubits] = []
# decides number of electrons
na = int(num_qubits/4)
nb = int(num_qubits/4)
# random seed
np.random.seed(0)
numckts.append(num_circuits)
# create the circuit for given qubit size and simulation parameters, store time metric
ts = time.time()
# circuit list
qc_list = []
# Method 1 (default)
if method == 1:
# loop over circuits
for circuit_id in range(num_circuits):
# construct circuit
qc_single = VQEEnergy(num_qubits, na, nb, circuit_id, method)
qc_single.name = qc_single.name + " " + str(circuit_id)
# add to list
qc_list.append(qc_single)
# method 2
elif method == 2:
# construct all circuits
qc_list = VQEEnergy(num_qubits, na, nb, 0, method)
print(qc_list)
print(f"************\nExecuting [{len(qc_list)}] circuits with num_qubits = {num_qubits}")
for qc in qc_list:
print("*********************************************")
#print(f"qc of {qc} qubits for qc_list value: {qc_list}")
# get circuit id
if method == 1:
circuit_id = qc.name.split()[2]
else:
circuit_id = qc.name.split()[0]
#creation time
creation_time = time.time() - ts
creation_times.append(creation_time)
#print(qc)
print(f"creation time = {creation_time*1000} ms")
# Calculate gate count for the algorithmic circuit (excluding barriers and measurements)
if gate_counts_plots == True:
operations = count_operations(qc)
n1q = 0; n2q = 0
if operations != None:
for key, value in operations.items():
if key == "measure": continue
if key == "barrier": continue
if key.startswith("c") or key.startswith("mc"):
n2q += value
else:
n1q += value
print("operations: ",operations)
algorithmic_1Q_gate_counts.append(n1q)
algorithmic_2Q_gate_counts.append(n2q)
# collapse the sub-circuit levels used in this benchmark (for qiskit)
qc=qc.decompose()
#print(qc)
# Calculate circuit depth
depth = calculate_circuit_depth(qc)
circuit_depths.append(depth)
# Calculate transpiled circuit depth
transpiled_depth,qc = calculate_transpiled_depth(qc,basis_selector)
transpiled_depths.append(transpiled_depth)
#print(qc)
print(f"Algorithmic Depth = {depth} and Normalized Depth = {transpiled_depth}")
if gate_counts_plots == True:
# Calculate gate count for the transpiled circuit (excluding barriers and measurements)
tr_ops = qc.count_ops()
#print("tr_ops = ",tr_ops)
tr_n1q = 0; tr_n2q = 0
if tr_ops != None:
for key, value in tr_ops.items():
if key == "measure": continue
if key == "barrier": continue
if key.startswith("c"): tr_n2q += value
else: tr_n1q += value
transpiled_1Q_gate_counts.append(tr_n1q)
transpiled_2Q_gate_counts.append(tr_n2q)
print(f"Algorithmic 1Q gates = {n1q} ,Algorithmic 2Q gates = {n2q}")
print(f"Normalized 1Q gates = {tr_n1q} ,Normalized 2Q gates = {tr_n2q}")
#execution
if Type_of_Simulator == "built_in":
#To check if Noise is required
if Noise_Inclusion == True:
noise_model = noise_parameters
else:
noise_model = None
ts = time.time()
job = execute(qc, backend, shots=num_shots, noise_model=noise_model)
elif Type_of_Simulator == "FAKE" or Type_of_Simulator == "FAKEV2" :
ts = time.time()
job = backend.run(qc,shots=num_shots, noise_model=noise_parameters)
#retrieving the result
result = job.result()
#print(result)
#calculating elapsed time
elapsed_time = time.time() - ts
elapsed_times.append(elapsed_time)
# Calculate quantum processing time
quantum_time = result.time_taken
quantum_times.append(quantum_time)
print(f"Elapsed time = {elapsed_time*1000} ms and Quantum Time = {quantum_time*1000} ms")
#counts in result object
counts = result.get_counts()
# load pre-computed data
if len(qc.name.split()) == 2:
filename = os.path.join(f'_common/precalculated_data_{num_qubits}_qubit.json')
with open(filename) as f:
references = json.load(f)
else:
filename = os.path.join(f'_common/precalculated_data_{num_qubits}_qubit_method2.json')
with open(filename) as f:
references = json.load(f)
#Correct distribution to compare with counts
correct_dist,total_name = analyzer(qc,references,num_qubits)
#fidelity calculation comparision of counts and correct_dist
fidelity_dict = polarization_fidelity(counts, correct_dist)
print(fidelity_dict)
# modify fidelity based on the coefficient
if (len(total_name.split()) == 2):
fidelity_dict *= ( abs(float(total_name.split()[1])) / normalization )
fidelity_data[num_qubits].append(fidelity_dict['fidelity'])
Hf_fidelity_data[num_qubits].append(fidelity_dict['hf_fidelity'])
#maximum memory utilization (if required)
if Memory_utilization_plot == True:
max_mem = get_memory()
print(f"Maximum Memory Utilized: {max_mem} MB")
mem_usage.append(max_mem)
print("*********************************************")
##########
# print a sample circuit
print("Sample Circuit:"); print(QC_ if QC_ != None else " ... too large!")
print("\nHartree Fock Generator 'Hf' ="); print(Hf_ if Hf_ != None else " ... too large!")
print("\nCluster Operator Example 'Cluster Op' ="); print(CO_ if CO_ != None else " ... too large!")
return (creation_times, elapsed_times, quantum_times, circuit_depths, transpiled_depths,
fidelity_data, Hf_fidelity_data, numckts , algorithmic_1Q_gate_counts, algorithmic_2Q_gate_counts,
transpiled_1Q_gate_counts, transpiled_2Q_gate_counts,mem_usage)
# Execute the benchmark program, accumulate metrics, and calculate circuit depths
(creation_times, elapsed_times, quantum_times, circuit_depths,transpiled_depths, fidelity_data, Hf_fidelity_data, numckts,
algorithmic_1Q_gate_counts, algorithmic_2Q_gate_counts, transpiled_1Q_gate_counts, transpiled_2Q_gate_counts,mem_usage) = run()
# Define the range of qubits for the x-axis
num_qubits_range = range(min_qbits, max_qbits+1,skp_qubits)
print("num_qubits_range =",num_qubits_range)
# Calculate average creation time, elapsed time, quantum processing time, and circuit depth for each number of qubits
avg_creation_times = []
avg_elapsed_times = []
avg_quantum_times = []
avg_circuit_depths = []
avg_transpiled_depths = []
avg_1Q_algorithmic_gate_counts = []
avg_2Q_algorithmic_gate_counts = []
avg_1Q_Transpiled_gate_counts = []
avg_2Q_Transpiled_gate_counts = []
max_memory = []
start = 0
for num in numckts:
avg_creation_times.append(np.mean(creation_times[start:start+num]))
avg_elapsed_times.append(np.mean(elapsed_times[start:start+num]))
avg_quantum_times.append(np.mean(quantum_times[start:start+num]))
avg_circuit_depths.append(np.mean(circuit_depths[start:start+num]))
avg_transpiled_depths.append(np.mean(transpiled_depths[start:start+num]))
if gate_counts_plots == True:
avg_1Q_algorithmic_gate_counts.append(int(np.mean(algorithmic_1Q_gate_counts[start:start+num])))
avg_2Q_algorithmic_gate_counts.append(int(np.mean(algorithmic_2Q_gate_counts[start:start+num])))
avg_1Q_Transpiled_gate_counts.append(int(np.mean(transpiled_1Q_gate_counts[start:start+num])))
avg_2Q_Transpiled_gate_counts.append(int(np.mean(transpiled_2Q_gate_counts[start:start+num])))
if Memory_utilization_plot == True:max_memory.append(np.max(mem_usage[start:start+num]))
start += num
# Calculate the fidelity data
avg_f, avg_Hf = plot_fidelity_data(fidelity_data, Hf_fidelity_data, "Fidelity Comparison")
# Plot histograms for average creation time, average elapsed time, average quantum processing time, and average circuit depth versus the number of qubits
# Add labels to the bars
def autolabel(rects,ax,str='{:.3f}',va='top',text_color="black"):
for rect in rects:
height = rect.get_height()
ax.annotate(str.format(height), # Formatting to two decimal places
xy=(rect.get_x() + rect.get_width() / 2, height / 2),
xytext=(0, 0),
textcoords="offset points",
ha='center', va=va,color=text_color,rotation=90)
bar_width = 0.3
# Determine the number of subplots and their arrangement
if Memory_utilization_plot and gate_counts_plots:
fig, (ax1, ax2, ax3, ax4, ax5, ax6, ax7) = plt.subplots(7, 1, figsize=(18, 30))
# Plotting for both memory utilization and gate counts
# ax1, ax2, ax3, ax4, ax5, ax6, ax7 are available
elif Memory_utilization_plot:
fig, (ax1, ax2, ax3, ax6, ax7) = plt.subplots(5, 1, figsize=(18, 30))
# Plotting for memory utilization only
# ax1, ax2, ax3, ax6, ax7 are available
elif gate_counts_plots:
fig, (ax1, ax2, ax3, ax4, ax5, ax6) = plt.subplots(6, 1, figsize=(18, 30))
# Plotting for gate counts only
# ax1, ax2, ax3, ax4, ax5, ax6 are available
else:
fig, (ax1, ax2, ax3, ax6) = plt.subplots(4, 1, figsize=(18, 30))
# Default plotting
# ax1, ax2, ax3, ax6 are available
fig.suptitle(f"General Benchmarks : {platform} - {benchmark_name}", fontsize=16)
for i in range(len(avg_creation_times)): #converting seconds to milli seconds by multiplying 1000
avg_creation_times[i] *= 1000
ax1.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
x = ax1.bar(num_qubits_range, avg_creation_times, color='deepskyblue')
autolabel(ax1.patches, ax1)
ax1.set_xlabel('Number of Qubits')
ax1.set_ylabel('Average Creation Time (ms)')
ax1.set_title('Average Creation Time vs Number of Qubits',fontsize=14)
ax2.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
for i in range(len(avg_elapsed_times)): #converting seconds to milli seconds by multiplying 1000
avg_elapsed_times[i] *= 1000
for i in range(len(avg_quantum_times)): #converting seconds to milli seconds by multiplying 1000
avg_quantum_times[i] *= 1000
Elapsed= ax2.bar(np.array(num_qubits_range) - bar_width / 2, avg_elapsed_times, width=bar_width, color='cyan', label='Elapsed Time')
Quantum= ax2.bar(np.array(num_qubits_range) + bar_width / 2, avg_quantum_times,width=bar_width, color='deepskyblue',label ='Quantum Time')
autolabel(Elapsed,ax2,str='{:.1f}')
autolabel(Quantum,ax2,str='{:.1f}')
ax2.set_xlabel('Number of Qubits')
ax2.set_ylabel('Average Time (ms)')
ax2.set_title('Average Time vs Number of Qubits')
ax2.legend()
ax3.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Normalized = ax3.bar(np.array(num_qubits_range) - bar_width / 2, avg_transpiled_depths, color='cyan', label='Normalized Depth', width=bar_width) # Adjust width here
Algorithmic = ax3.bar(np.array(num_qubits_range) + bar_width / 2,avg_circuit_depths, color='deepskyblue', label='Algorithmic Depth', width=bar_width) # Adjust width here
autolabel(Normalized,ax3,str='{:.2f}')
autolabel(Algorithmic,ax3,str='{:.2f}')
ax3.set_xlabel('Number of Qubits')
ax3.set_ylabel('Average Circuit Depth')
ax3.set_title('Average Circuit Depth vs Number of Qubits')
ax3.legend()
if gate_counts_plots == True:
ax4.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Normalized_1Q_counts = ax4.bar(np.array(num_qubits_range) - bar_width / 2, avg_1Q_Transpiled_gate_counts, color='cyan', label='Normalized Gate Counts', width=bar_width) # Adjust width here
Algorithmic_1Q_counts = ax4.bar(np.array(num_qubits_range) + bar_width / 2, avg_1Q_algorithmic_gate_counts, color='deepskyblue', label='Algorithmic Gate Counts', width=bar_width) # Adjust width here
autolabel(Normalized_1Q_counts,ax4,str='{}')
autolabel(Algorithmic_1Q_counts,ax4,str='{}')
ax4.set_xlabel('Number of Qubits')
ax4.set_ylabel('Average 1-Qubit Gate Counts')
ax4.set_title('Average 1-Qubit Gate Counts vs Number of Qubits')
ax4.legend()
ax5.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Normalized_2Q_counts = ax5.bar(np.array(num_qubits_range) - bar_width / 2, avg_2Q_Transpiled_gate_counts, color='cyan', label='Normalized Gate Counts', width=bar_width) # Adjust width here
Algorithmic_2Q_counts = ax5.bar(np.array(num_qubits_range) + bar_width / 2, avg_2Q_algorithmic_gate_counts, color='deepskyblue', label='Algorithmic Gate Counts', width=bar_width) # Adjust width here
autolabel(Normalized_2Q_counts,ax5,str='{}')
autolabel(Algorithmic_2Q_counts,ax5,str='{}')
ax5.set_xlabel('Number of Qubits')
ax5.set_ylabel('Average 2-Qubit Gate Counts')
ax5.set_title('Average 2-Qubit Gate Counts vs Number of Qubits')
ax5.legend()
ax6.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Hellinger = ax6.bar(np.array(num_qubits_range) - bar_width / 2, avg_Hf, width=bar_width, label='Hellinger Fidelity',color='cyan') # Adjust width here
Normalized = ax6.bar(np.array(num_qubits_range) + bar_width / 2, avg_f, width=bar_width, label='Normalized Fidelity', color='deepskyblue') # Adjust width here
autolabel(Hellinger,ax6,str='{:.2f}')
autolabel(Normalized,ax6,str='{:.2f}')
ax6.set_xlabel('Number of Qubits')
ax6.set_ylabel('Average Value')
ax6.set_title("Fidelity Comparison")
ax6.legend()
if Memory_utilization_plot == True:
ax7.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
x = ax7.bar(num_qubits_range, max_memory, color='turquoise', width=bar_width, label="Memory Utilizations")
autolabel(ax7.patches, ax7)
ax7.set_xlabel('Number of Qubits')
ax7.set_ylabel('Maximum Memory Utilized (MB)')
ax7.set_title('Memory Utilized vs Number of Qubits',fontsize=14)
plt.tight_layout(rect=[0, 0, 1, 0.96])
if saveplots == True:
plt.savefig("ParameterPlotsSample.jpg")
plt.show()
# Quantum Volume Plot
Suptitle = f"Volumetric Positioning - {platform}"
appname=benchmark_name
if QV_ == None:
QV=2048
else:
QV=QV_
depth_base =2
ax = plot_volumetric_background(max_qubits=max_qbits, QV=QV,depth_base=depth_base, suptitle=Suptitle, colorbar_label="Avg Result Fidelity")
w_data = num_qubits_range
# determine width for circuit
w_max = 0
for i in range(len(w_data)):
y = float(w_data[i])
w_max = max(w_max, y)
d_tr_data = avg_transpiled_depths
f_data = avg_f
plot_volumetric_data(ax, w_data, d_tr_data, f_data, depth_base, fill=True,label=appname, labelpos=(0.4, 0.6), labelrot=15, type=1, w_max=w_max)
anno_volumetric_data(ax, depth_base,label=appname, labelpos=(0.4, 0.6), labelrot=15, type=1, fill=False)
|
https://github.com/Interlin-q/diskit
|
Interlin-q
|
"""The circuit remapper logic."""
from typing import (
Optional,
List,
Iterable,
)
import time
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.quantumcircuitdata import CircuitInstruction
from qiskit.circuit.quantumregister import Qubit
from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
from qiskit.circuit.exceptions import CircuitError
from qiskit import transpile
from .components import Layer, Topology
class CircuitRemapper:
"""
The circuit remapper class for remapping a ciruit to a topology.
"""
def __init__(self, topology: Topology):
self.topology = topology
@staticmethod
def _circuit_to_layers(
circuit: QuantumCircuit,
filter_function: Optional[callable] = lambda x: not getattr(
x.operation, "_directive", False
),
) -> "list[list]":
"""Given a Qiskit circuit, return an array of the layers of that circuit"""
# Assign each bit in the circuit a unique integer
# to index into op_stack.
circ = circuit
bit_indices = {bit: idx for idx,
bit in enumerate(circ.qubits + circ.clbits)}
# If no bits, return 0
if not bit_indices:
return 0
# A list that holds the height of each qubit
# and classical bit.
op_stack = [0] * len(bit_indices)
layers = []
for instruction in circ.data:
levels = []
reg_ints = []
max_pos = 0
for ind, reg in enumerate(instruction.qubits + instruction.clbits):
# Add to the stacks of the qubits and
# cbits used in the gate.
reg_ints.append(bit_indices[reg])
if filter_function(instruction):
levels.append(op_stack[reg_ints[ind]] + 1)
if len(layers) < (op_stack[reg_ints[ind]] + 1):
layers.append([])
max_pos = max(max_pos, (op_stack[reg_ints[ind]]))
else:
levels.append(op_stack[reg_ints[ind]])
layers[max_pos].append(instruction)
# Assuming here that there is no conditional
# snapshots or barriers ever.
if getattr(instruction.operation, "condition", None):
# Controls operate over all bits of a classical register
# or over a single bit
if isinstance(instruction.operation.condition[0], Clbit):
condition_bits = [instruction.operation.condition[0]]
else:
condition_bits = instruction.operation.condition[0]
for cbit in condition_bits:
idx = bit_indices[cbit]
if idx not in reg_ints:
reg_ints.append(idx)
levels.append(op_stack[idx] + 1)
max_level = max(levels)
for ind in reg_ints:
op_stack[ind] = max_level
assert max(op_stack) == len(layers)
return layers
@staticmethod
def _layer_to_circuit(layers: Iterable[List], qubits: Iterable[Qubit] = (),
clbits: Iterable[Clbit] = (),
name: Optional[str] = None,
global_phase=0,
metadata: Optional[dict] = None, ) -> "QuantumCircuit":
"""Return a circuit from a list of layers.
Args:
layers: A list of layers, where each layer is a list of
:class:`~qiskit.circuit.Instruction`
return: A circuit from the layers.
"""
circuit = QuantumCircuit(
name=name, global_phase=global_phase, metadata=metadata)
added_qubits = set()
added_clbits = set()
added_qregs = set()
added_cregs = set()
if qubits:
qubits = list(qubits)
circuit.add_bits(qubits)
added_qubits.update(qubits)
added_qregs.update(qubit.register for qubit in qubits)
circuit.add_register(*added_qregs)
if clbits:
clbits = list(clbits)
circuit.add_bits(clbits)
added_clbits.update(clbits)
added_cregs.update(clbit.register for clbit in clbits)
circuit.add_register(*added_cregs)
for layer in layers:
for instruction in layer:
if not isinstance(instruction, CircuitInstruction):
instruction = CircuitInstruction(*instruction)
qubits = [qubit for qubit in instruction.qubits if
qubit not in added_qubits and qubit.register not in added_qregs]
clbits = [clbit for clbit in instruction.clbits if
clbit not in added_clbits and clbit.register not in added_cregs]
qregs = [qubit.register for qubit in qubits]
cregs = [clbit.register for clbit in clbits]
circuit.add_bits(qubits)
circuit.add_bits(clbits)
circuit.add_register(*qregs)
circuit.add_register(*cregs)
added_qubits.update(qubits)
added_clbits.update(clbits)
added_qregs.update(qregs)
added_cregs.update(cregs)
circuit.append(instruction)
return circuit
@staticmethod
def _replace_nonlocal_control(operation: CircuitInstruction,
topology: Topology,
deeper_ops: List[CircuitInstruction] = None):
"""
Replace the non-local control gates with Cat entanglement gates for a given layer.
Args:
operation: a non-local control gate
topology: The network topology.
deeper_ops: The list of operations.
Returns:
(list): List of new operations to be added in the layer
"""
control_qubit = operation.qubits[0]
target_qubit = operation.qubits[1]
control_host = topology.get_host(control_qubit)
target_host = topology.get_host(target_qubit)
ent_inst = operation.copy()
epr_control = topology.get_epr_id(control_host)
epr_target = topology.get_epr_id(target_host)
epr_qubits = [epr_control, epr_target]
opr_qubits = [control_qubit, target_qubit]
if len(deeper_ops) > 0:
for opi in deeper_ops:
opr_qubits.append(opi.qubits[1])
measure_bits = ClassicalRegister(2, "cat_measure")
circ = QuantumCircuit(epr_qubits, opr_qubits, measure_bits)
# print(deeper_ops)
# Generate EPR pair
circ.h(0)
circ.cx(0, 1)
# cat entanglement
circ.cx(2, 0)
circ.measure(0, 0)
circ.x(1).c_if(measure_bits[0], 1)
ent_inst.qubits = [epr_qubits[1], opr_qubits[1]]
circ.data.append(ent_inst)
if len(deeper_ops) > 0:
ident = 2
for opi in deeper_ops:
ent_inst = opi.copy()
ent_inst.qubits = [epr_qubits[1], opr_qubits[ident]]
circ.data.append(ent_inst)
ident += 1
circ.h(1)
circ.measure(1, 1)
circ.z(2).c_if(measure_bits[1], 1)
circ.reset(epr_qubits)
# Make layers from this circuit
new_ops = []
for opi in circ.data:
new_ops.append([opi])
return new_ops
def remap_circuit(self, circuit: QuantumCircuit, decompose: bool = None,
decompose_list: List[str] = None):
"""
Remap the circuit for the topology.
Args:
circuit: The circuit to be distributed
decompose: Decompose the circuit into compatible 2-qubit gates if possible
decompose_list: Gate names which should be decomposed
Returns:
A distributed circuit over the topology.
"""
if decompose is not None:
if decompose_list is not None:
circuit, _ = self._decompose_ready(circuit, decompose_list)
else:
circuit, _ = self._decompose_ready(circuit)
else:
_, incompatible = self._decompose_ready(
circuit, do_decompose=False)
if incompatible:
raise CircuitError(
"The circuit contains incompatible gates, Please try decompose=True keyword argument.")
layers = self._circuit_to_layers(circuit=circuit)
qubits = circuit.qubits
clbits = circuit.clbits
distributed_layers = []
idx = 0
circ_qubits = self.topology.qubits
deep_dict = {qubit: 0 for qubit in circ_qubits}
for a_layer in layers:
layer_now = Layer(a_layer, self.topology)
non_local_ops = layer_now.non_local_operations()
new_layers = [[]]
if non_local_ops not in [[], None]:
for operation in non_local_ops:
control, target = operation.qubits[0], operation.qubits[1]
if deep_dict[control] > 0:
deep_dict[control] -= 1
continue
deeper_ops = self._get_deeper_nlcontrol(
layers[idx + 1:], control, target)
# deeper_ops = []
if len(deeper_ops) > 0:
deep_dict[control] += len(deeper_ops)
op_replaced = self._replace_nonlocal_control(
operation, self.topology, deeper_ops)
new_layers.extend(op_replaced)
local_ops = []
for operation in a_layer:
if operation not in non_local_ops:
local_ops.append(operation)
new_layers[0].extend(local_ops)
distributed_layers.extend(new_layers)
idx += 1
dist_circ = self._layer_to_circuit(distributed_layers, qubits, clbits)
return dist_circ
@staticmethod
def _qubit_ops(layers: List[Layer], qubit: Qubit = None):
"""
Get the operations on each qubit
Args:
layers: The list of layers.
qubit: The qubit to get the operations for.
Returns: dictionary of qubit to operations
"""
qubit_ops = []
for layer in layers:
for opi in layer:
for a_qubit in opi.qubits:
if qubit == a_qubit:
qubit_ops.append(opi)
return qubit_ops
def _get_deeper_nlcontrol(self, layers, control_qubit: Qubit, target_qubit: Qubit):
"""
Get the deeper control operation on a qubit.
"""
control_ops = self._qubit_ops(layers, control_qubit)
target_host = self.topology.get_host(target_qubit)
ops = []
track_dict = {
qubit: 0 for qubit in self.topology.get_qubits(target_host)}
for opi in control_ops:
if len(opi.qubits) == 2 and opi.qubits[0] == control_qubit:
if self.topology.get_host(opi.qubits[1]) == target_host:
target_ops = self._qubit_ops(layers, opi.qubits[1])
# print('here')
if target_ops[track_dict[opi.qubits[1]]] == opi:
ops.append(opi)
track_dict[opi.qubits[1]] += 1
else:
break
else:
break
return ops
@staticmethod
def collate_measurements(sim_results: dict, num_qubits: int):
"""
Collate the measurements from the simulation results.
Args:
sim_results: simulation results from the simulator
num_qubits: number of qubits in the circuit
Returns:
A dictionary of measurements
"""
sim_dict = {}
for key in sim_results.keys():
new_key = key[0:num_qubits]
dict_keys = sim_dict.keys()
if new_key not in dict_keys:
sim_dict[new_key] = sim_results[key]
else:
sim_dict[new_key] += sim_results[key]
return sim_dict
@staticmethod
def do_measure_ready(circ: QuantumCircuit, topology: Topology):
"""
Make the circuit is ready for measurement.
Args:
circ: the circuit to measure.
topology: The network topology.
Returns:
Circuit ready for measurement
"""
n_q = topology.num_qubits()
all_qubits = topology.get_all_qubits()
measure_bits = ClassicalRegister(n_q, "measure")
circ.add_register(measure_bits)
circ.measure(all_qubits, measure_bits)
@staticmethod
def _decompose_ready(circ: QuantumCircuit, list_of_gates: List[str] = None,
do_decompose: bool = True, max_time=60):
"""
Decompose the circuit into basic gates(1 and 2 qubit gates).
Args:
circ: the circuit to decompose.
list_of_gates: The network topology.
max_time: Seconds to spend decomposing the circuit before falling back to default gate set
Returns: Decomposed circuit
"""
timeout = time.time() + max_time
num_large_gates = 1
circ_copy = circ.copy()
incompatible_gate_present = False
printed_warning = False
if list_of_gates is None:
list_of_gates = []
while num_large_gates > 0:
num_large_gates = 0
for gate in circ_copy.data:
if len(gate[1]) > 2:
num_large_gates += 1
incompatible_gate_present = True
if do_decompose is False:
break
circ_copy = circ_copy.decompose(gate[0].name)
elif gate[0].name == 'swap':
num_large_gates += 1
incompatible_gate_present = True
if do_decompose is False:
break
if not printed_warning:
print('Warning: Swap gate found in circuit. '
'Swap gates cannot be automatically decomposed and should be'
'transpiled by the user. Skipping it for now but may lead to errors if ignored.')
printed_warning = True
num_large_gates -= 1
circ_copy = circ_copy.decompose(gate)
elif gate[0].name in list_of_gates:
num_large_gates += 1
circ_copy = circ_copy.decompose(gate)
if time.time() > timeout:
break
if do_decompose is False and num_large_gates > 0:
break
if do_decompose is True and time.time() > timeout:
print(f"Warning: Single level decomposition cutoff of {max_time} seconds reached.",
"Performing transpilation with basis gates: cx, u1, u2, u3, id")
circ_copy = transpile(circ_copy, basis_gates=[
'cx', 'u1', 'u2', 'u3', 'id'])
break
return circ_copy, incompatible_gate_present
|
https://github.com/Interlin-q/diskit
|
Interlin-q
|
import os
from qiskit import *
import qiskit.tools.visualization as qt
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
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))
circuits[0].reset(qreg_q[0])
circuits[0].reset(qreg_q[1])
circuits[0].cx(qreg_q[0], qreg_q[1])
circuits[0].measure(qreg_q[0], creg_c[0])
circuits[0].measure(qreg_q[1], creg_c[1])
circuits[0].draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result00 = execute(circuits[0], backend = simulator, shots = 1).result()
counts00 = result00.get_counts()
print(counts00)
qt.plot_histogram(counts00, title="Histogram with the evaluating of |00> state under CNOT transformation")
circuits[1].reset(qreg_q[0])
circuits[1].x(qreg_q[1])
circuits[1].cx(qreg_q[0], qreg_q[1])
circuits[1].measure(qreg_q[0], creg_c[0])
circuits[1].measure(qreg_q[1], creg_c[1])
circuits[1].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result01 = execute(circuits[1], backend = simulator, shots = 1).result()
counts01 = result01.get_counts()
print(counts01)
qt.plot_histogram(counts01, title="Histogram with the evaluating of |01> state under CNOT transformation")
circuits[2].x(qreg_q[0])
circuits[2].reset(qreg_q[1])
circuits[2].cx(qreg_q[0], qreg_q[1])
circuits[2].measure(qreg_q[0], creg_c[0])
circuits[2].measure(qreg_q[1], creg_c[1])
circuits[2].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result10 = execute(circuits[2], backend = simulator, shots = 1).result()
counts10 = result10.get_counts()
print(counts10)
qt.plot_histogram(counts10, title="Histogram with the evaluating of |10> state under CNOT transformation")
circuits[3].x(qreg_q[0])
circuits[3].x(qreg_q[1])
circuits[3].cx(qreg_q[0], qreg_q[1])
circuits[3].measure(qreg_q[0], creg_c[0])
circuits[3].measure(qreg_q[1], creg_c[1])
circuits[3].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result11 = execute(circuits[3], backend = simulator, shots = 1).result()
counts11 = result11.get_counts()
print(counts11)
qt.plot_histogram(counts11, title="Histogram with the evaluating of |11> state under CNOT transformation")
|
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/Interlin-q/diskit
|
Interlin-q
|
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Shor
N = 15
shor = Shor(N)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024)
ret = shor.run(quantum_instance)
print("The list of factors of {} as computed by the Shor's algorithm is {}.".format(N, ret['factors'][0]))
|
https://github.com/Interlin-q/diskit
|
Interlin-q
|
import sys
sys.path.append("..")
from diskit import *
import warnings
warnings.filterwarnings("ignore")
circuit_topo = Topology()
circuit_topo.create_qmap(3, [2, 3, 3], "sys")
circuit_topo.qmap, circuit_topo.emap
print("Total Number of Qubits in Topology : ", circuit_topo.num_qubits())
print("Total Number of QPUs in Topology: ", circuit_topo.num_hosts())
Qubit1 = circuit_topo.qmap["sys1"][2]
Qubit2 = circuit_topo.qmap["sys2"][1]
print("{} and {} are adjacent".format(Qubit1, Qubit2)
if circuit_topo.are_adjacent(Qubit1, Qubit2) else
"{} and {} are not adjacent".format(Qubit1, Qubit2))
for qubit in circuit_topo.qubits:
print("Qubit: {} --------- Host: {}".format(qubit, circuit_topo.get_host(qubit)))
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/Interlin-q/diskit
|
Interlin-q
|
import os
from qiskit import *
import qiskit.tools.visualization as qt
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
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))
circuits[0].reset(qreg_q[0])
circuits[0].reset(qreg_q[1])
circuits[0].cx(qreg_q[0], qreg_q[1])
circuits[0].measure(qreg_q[0], creg_c[0])
circuits[0].measure(qreg_q[1], creg_c[1])
circuits[0].draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result00 = execute(circuits[0], backend = simulator, shots = 1).result()
counts00 = result00.get_counts()
print(counts00)
qt.plot_histogram(counts00, title="Histogram with the evaluating of |00> state under CNOT transformation")
circuits[1].reset(qreg_q[0])
circuits[1].x(qreg_q[1])
circuits[1].cx(qreg_q[0], qreg_q[1])
circuits[1].measure(qreg_q[0], creg_c[0])
circuits[1].measure(qreg_q[1], creg_c[1])
circuits[1].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result01 = execute(circuits[1], backend = simulator, shots = 1).result()
counts01 = result01.get_counts()
print(counts01)
qt.plot_histogram(counts01, title="Histogram with the evaluating of |01> state under CNOT transformation")
circuits[2].x(qreg_q[0])
circuits[2].reset(qreg_q[1])
circuits[2].cx(qreg_q[0], qreg_q[1])
circuits[2].measure(qreg_q[0], creg_c[0])
circuits[2].measure(qreg_q[1], creg_c[1])
circuits[2].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result10 = execute(circuits[2], backend = simulator, shots = 1).result()
counts10 = result10.get_counts()
print(counts10)
qt.plot_histogram(counts10, title="Histogram with the evaluating of |10> state under CNOT transformation")
circuits[3].x(qreg_q[0])
circuits[3].x(qreg_q[1])
circuits[3].cx(qreg_q[0], qreg_q[1])
circuits[3].measure(qreg_q[0], creg_c[0])
circuits[3].measure(qreg_q[1], creg_c[1])
circuits[3].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result11 = execute(circuits[3], backend = simulator, shots = 1).result()
counts11 = result11.get_counts()
print(counts11)
qt.plot_histogram(counts11, title="Histogram with the evaluating of |11> state under CNOT transformation")
|
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/Interlin-q/diskit
|
Interlin-q
|
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Shor
N = 15
shor = Shor(N)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024)
ret = shor.run(quantum_instance)
print("The list of factors of {} as computed by the Shor's algorithm is {}.".format(N, ret['factors'][0]))
|
https://github.com/Interlin-q/diskit
|
Interlin-q
|
import sys
sys.path.append("..")
from diskit import *
import warnings
warnings.filterwarnings("ignore")
circuit_topo = Topology()
circuit_topo.create_qmap(3, [2, 3, 3], "sys")
circuit_topo.qmap, circuit_topo.emap
print("Total Number of Qubits in Topology : ", circuit_topo.num_qubits())
print("Total Number of QPUs in Topology: ", circuit_topo.num_hosts())
Qubit1 = circuit_topo.qmap["sys1"][2]
Qubit2 = circuit_topo.qmap["sys2"][1]
print("{} and {} are adjacent".format(Qubit1, Qubit2)
if circuit_topo.are_adjacent(Qubit1, Qubit2) else
"{} and {} are not adjacent".format(Qubit1, Qubit2))
for qubit in circuit_topo.qubits:
print("Qubit: {} --------- Host: {}".format(qubit, circuit_topo.get_host(qubit)))
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/Interlin-q/diskit
|
Interlin-q
|
import os
from qiskit import *
import qiskit.tools.visualization as qt
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
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))
circuits[0].reset(qreg_q[0])
circuits[0].reset(qreg_q[1])
circuits[0].cx(qreg_q[0], qreg_q[1])
circuits[0].measure(qreg_q[0], creg_c[0])
circuits[0].measure(qreg_q[1], creg_c[1])
circuits[0].draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result00 = execute(circuits[0], backend = simulator, shots = 1).result()
counts00 = result00.get_counts()
print(counts00)
qt.plot_histogram(counts00, title="Histogram with the evaluating of |00> state under CNOT transformation")
circuits[1].reset(qreg_q[0])
circuits[1].x(qreg_q[1])
circuits[1].cx(qreg_q[0], qreg_q[1])
circuits[1].measure(qreg_q[0], creg_c[0])
circuits[1].measure(qreg_q[1], creg_c[1])
circuits[1].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result01 = execute(circuits[1], backend = simulator, shots = 1).result()
counts01 = result01.get_counts()
print(counts01)
qt.plot_histogram(counts01, title="Histogram with the evaluating of |01> state under CNOT transformation")
circuits[2].x(qreg_q[0])
circuits[2].reset(qreg_q[1])
circuits[2].cx(qreg_q[0], qreg_q[1])
circuits[2].measure(qreg_q[0], creg_c[0])
circuits[2].measure(qreg_q[1], creg_c[1])
circuits[2].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result10 = execute(circuits[2], backend = simulator, shots = 1).result()
counts10 = result10.get_counts()
print(counts10)
qt.plot_histogram(counts10, title="Histogram with the evaluating of |10> state under CNOT transformation")
circuits[3].x(qreg_q[0])
circuits[3].x(qreg_q[1])
circuits[3].cx(qreg_q[0], qreg_q[1])
circuits[3].measure(qreg_q[0], creg_c[0])
circuits[3].measure(qreg_q[1], creg_c[1])
circuits[3].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result11 = execute(circuits[3], backend = simulator, shots = 1).result()
counts11 = result11.get_counts()
print(counts11)
qt.plot_histogram(counts11, title="Histogram with the evaluating of |11> state under CNOT transformation")
|
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/Interlin-q/diskit
|
Interlin-q
|
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Shor
N = 15
shor = Shor(N)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024)
ret = shor.run(quantum_instance)
print("The list of factors of {} as computed by the Shor's algorithm is {}.".format(N, ret['factors'][0]))
|
https://github.com/Interlin-q/diskit
|
Interlin-q
|
import sys
sys.path.append("..")
from diskit import *
import warnings
warnings.filterwarnings("ignore")
circuit_topo = Topology()
circuit_topo.create_qmap(3, [2, 3, 3], "sys")
circuit_topo.qmap, circuit_topo.emap
print("Total Number of Qubits in Topology : ", circuit_topo.num_qubits())
print("Total Number of QPUs in Topology: ", circuit_topo.num_hosts())
Qubit1 = circuit_topo.qmap["sys1"][2]
Qubit2 = circuit_topo.qmap["sys2"][1]
print("{} and {} are adjacent".format(Qubit1, Qubit2)
if circuit_topo.are_adjacent(Qubit1, Qubit2) else
"{} and {} are not adjacent".format(Qubit1, Qubit2))
for qubit in circuit_topo.qubits:
print("Qubit: {} --------- Host: {}".format(qubit, circuit_topo.get_host(qubit)))
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/Interlin-q/diskit
|
Interlin-q
|
import os
from qiskit import *
import qiskit.tools.visualization as qt
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
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))
circuits[0].reset(qreg_q[0])
circuits[0].reset(qreg_q[1])
circuits[0].cx(qreg_q[0], qreg_q[1])
circuits[0].measure(qreg_q[0], creg_c[0])
circuits[0].measure(qreg_q[1], creg_c[1])
circuits[0].draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result00 = execute(circuits[0], backend = simulator, shots = 1).result()
counts00 = result00.get_counts()
print(counts00)
qt.plot_histogram(counts00, title="Histogram with the evaluating of |00> state under CNOT transformation")
circuits[1].reset(qreg_q[0])
circuits[1].x(qreg_q[1])
circuits[1].cx(qreg_q[0], qreg_q[1])
circuits[1].measure(qreg_q[0], creg_c[0])
circuits[1].measure(qreg_q[1], creg_c[1])
circuits[1].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result01 = execute(circuits[1], backend = simulator, shots = 1).result()
counts01 = result01.get_counts()
print(counts01)
qt.plot_histogram(counts01, title="Histogram with the evaluating of |01> state under CNOT transformation")
circuits[2].x(qreg_q[0])
circuits[2].reset(qreg_q[1])
circuits[2].cx(qreg_q[0], qreg_q[1])
circuits[2].measure(qreg_q[0], creg_c[0])
circuits[2].measure(qreg_q[1], creg_c[1])
circuits[2].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result10 = execute(circuits[2], backend = simulator, shots = 1).result()
counts10 = result10.get_counts()
print(counts10)
qt.plot_histogram(counts10, title="Histogram with the evaluating of |10> state under CNOT transformation")
circuits[3].x(qreg_q[0])
circuits[3].x(qreg_q[1])
circuits[3].cx(qreg_q[0], qreg_q[1])
circuits[3].measure(qreg_q[0], creg_c[0])
circuits[3].measure(qreg_q[1], creg_c[1])
circuits[3].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result11 = execute(circuits[3], backend = simulator, shots = 1).result()
counts11 = result11.get_counts()
print(counts11)
qt.plot_histogram(counts11, title="Histogram with the evaluating of |11> state under CNOT transformation")
|
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/Interlin-q/diskit
|
Interlin-q
|
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Shor
N = 15
shor = Shor(N)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024)
ret = shor.run(quantum_instance)
print("The list of factors of {} as computed by the Shor's algorithm is {}.".format(N, ret['factors'][0]))
|
https://github.com/Interlin-q/diskit
|
Interlin-q
|
import sys
sys.path.append("..")
from diskit import *
import warnings
warnings.filterwarnings("ignore")
circuit_topo = Topology()
circuit_topo.create_qmap(3, [2, 3, 3], "sys")
circuit_topo.qmap, circuit_topo.emap
print("Total Number of Qubits in Topology : ", circuit_topo.num_qubits())
print("Total Number of QPUs in Topology: ", circuit_topo.num_hosts())
Qubit1 = circuit_topo.qmap["sys1"][2]
Qubit2 = circuit_topo.qmap["sys2"][1]
print("{} and {} are adjacent".format(Qubit1, Qubit2)
if circuit_topo.are_adjacent(Qubit1, Qubit2) else
"{} and {} are not adjacent".format(Qubit1, Qubit2))
for qubit in circuit_topo.qubits:
print("Qubit: {} --------- Host: {}".format(qubit, circuit_topo.get_host(qubit)))
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/qwqmlf/qwgc
|
qwqmlf
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.3.1
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import numpy as np
import copy
from qiskit import QuantumCircuit, QuantumRegister, Aer, execute
np.set_printoptions(linewidth=10000, threshold=10000)
# +
def theoretical_prob(initial, step, ptran, nq):
Pi_op = Pi_operator(ptran)
swap = swap_operator(nq)
operator = (2*Pi_op) - np.identity(len(Pi_op))
Szegedy = np.dot(operator, swap)
Szegedy_n = copy.copy(Szegedy)
print(id(Szegedy), id(Szegedy_n))
if step == 0:
init_prob = np.array([abs(i)**2 for i in initial], dtype=np.float)
return init_prob
elif step == 1:
prob = np.array([abs(i)**2 for i in np.dot(Szegedy, initial)],
dtype=np.float)
return prob
else:
for n in range(step-1):
Szegedy_n = np.dot(Szegedy_n, Szegedy)
probs = np.array([abs(i)**2 for i in np.dot(initial, Szegedy_n)],
dtype=np.float)
return probs
def swap_operator(n_qubit):
q1 = QuantumRegister(n_qubit//2)
q2 = QuantumRegister(n_qubit//2)
qc = QuantumCircuit(q1, q2)
for c, t in zip(q1, q2):
qc.swap(c, t)
# FIXME
backend = Aer.get_backend('unitary_simulator')
job = execute(qc, backend=backend)
swap = job.result().get_unitary(qc)
return swap
def Pi_operator(ptran):
'''
This is not a quantum operation,
just returning matrix
'''
lg = len(ptran)
psi_op = []
count = 0
for i in range(lg):
psi_vec = [0 for _ in range(lg**2)]
for j in range(lg):
psi_vec[count] = np.sqrt(ptran[j][i])
count += 1
psi_op.append(np.kron(np.array(psi_vec).T,
np.conjugate(psi_vec)).reshape((lg**2, lg**2)))
Pi = psi_op[0]
for i in psi_op[1:]:
Pi = np.add(Pi, i)
return Pi
def is_unitary(operator, tolerance=0.0001):
h, w = operator.shape
if not h == w:
return False
adjoint = np.conjugate(operator.transpose())
product1 = np.dot(operator, adjoint)
product2 = np.dot(adjoint, operator)
ida = np.eye(h)
return np.allclose(product1, ida) & np.allclose(product2, ida)
# +
alpha = 0.85
target_graph = np.array([[0, 1, 0, 0, 0, 0, 0, 1],
[0, 0, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 0, 0, 0],
[0, 0, 1, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 0, 1],
[0, 0, 0, 0, 0, 0, 1, 0]])
E = np.array([[1/8, 1/2, 0, 0, 0, 0, 0, 1/2],
[1/8, 0, 1/2, 0, 0, 0, 0, 0],
[1/8, 1/2, 0, 1/2, 0, 0, 0, 0],
[1/8, 0, 1/2, 0, 1/2, 0, 0, 0],
[1/8, 0, 0, 1/2, 0, 1/2, 0, 0],
[1/8, 0, 0, 0, 1/2, 0, 1/2, 0],
[1/8, 0, 0, 0, 0, 1/2, 0, 1/2],
[1/8, 0, 0, 0, 0, 0, 1/2, 0]])
# use google matrix
lt = len(target_graph)
prob_dist = alpha*E + ((1-alpha)/lt)*np.ones((lt, lt))
init_state_eight = 1/2*np.array([np.sqrt(prob_dist[j][i]) for i in range(lt) for j in range(lt)])
# -
Pi_op = Pi_operator(prob_dist)
operator = (2*Pi_op) - np.identity(len(Pi_op))
lo = len(operator)
initial = np.array([0 if i != 32 else 1 for i in range(lo)])
# initial = np.array([np.sqrt(1/lo) for i in range(lo)])
ideal = theoretical_prob(initial, 2, prob_dist, 6)
for i, v in enumerate(ideal):
print(i, v)
import networkx as nx
import matplotlib.pyplot as plt
target_graph = np.array([[0, 1, 0, 1],
[0, 0, 1, 0],
[0, 1, 0, 1],
[0, 0, 1, 0]])
Gs = nx.from_numpy_matrix(target_graph)
G = nx.MultiDiGraph()
pos = [(1, 1), (5, 1), (5, 5), (1, 5)]
G.add_edges_from(Gs.edges())
plt.figure(figsize=(8,8))
nx.draw_networkx(G, pos, node_size=1000, width=3, arrowsize=50)
plt.show()
# +
target_graph = np.array([[0, 1, 0, 0, 0, 0, 0, 1],
[0, 0, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 0, 0, 0],
[0, 0, 1, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 0, 1],
[0, 0, 0, 0, 0, 0, 1, 0]])
Gs = nx.from_numpy_matrix(target_graph)
G = nx.MultiDiGraph()
# pos = [(1, 1), (2, 2), (3, 3), (1, 5), (2, 2), (6, 2), (6, 6), (2, 6)]
pos = [(0, 0), (1, 1), (2, 2), (1, 3), (0, 4), (-1, 3), (-2, 2), (-1, 1)]
G.add_edges_from(Gs.edges())
# pos = nx.spring_layout(G)
plt.figure(figsize=(8,8))
nx.draw_networkx(G, pos, node_size=1000, width=3, arrowsize=50)
plt.show()
# +
target_graph = np.array([[0, 0, 0, 1, 1, 0, 0, 0],
[1, 0, 0, 0, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 1, 1]])
Gs = nx.from_numpy_matrix(target_graph)
print(Gs.edges())
G = nx.MultiDiGraph()
# pos = [(1, 1), (2, 2), (3, 3), (1, 5), (2, 2), (6, 2), (6, 6), (2, 6)]
pos = [(0, 0), (3, 3), (2, 9), (-1, 5), (5, 1), (4, 5), (8, 5), (9, 3)]
G.add_edges_from(Gs.edges())
G.add_edges_from([(7, 6)])
# pos = nx.spring_layout(G, k=10)
plt.figure(figsize=(10, 10))
nx.draw_networkx(G, pos, node_size=1000, width=3, arrowsize=50)
plt.show()
# -
|
https://github.com/qwqmlf/qwgc
|
qwqmlf
|
"""
This is archive version of previous qmnist project.
"""
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import execute, Aer
from numpy import pi
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from tqdm import trange
import numpy as np
import random
import copy
import umap.umap_ as umap
THETA_MIN, THETA_MAX = -pi, pi
BACKEND = Aer.get_backend('qasm_simulator')
SHOTS = 2048
class QMNIST:
"""
QMMIST is for quantum classifier for MNIST
This
"""
def __init__(self, encoder, alpha=0.0001,
n_particle=20, iteration=50, w=0.8, Cp=1.3, Cg=1.1):
self.encoder = encoder
self.alpha = alpha
self.n_particle = n_particle
self.iteration = iteration
self.w = w
self.Cp = Cp
self.Cg = Cg
def fit(self, x=None, y=None):
dim = len(x[0])
particles = np.array([[random.uniform(THETA_MIN, THETA_MAX)
for j in range(dim)]
for n in range(self.n_particle)])
velocities = np.array([[0 for i in range(dim)] for n in range(self.n_particle)])
personal_best_pos = copy.copy(particles)
personal_best_score = [self._get_error(x, y, theta)
for theta in particles]
best_particle = np.argmin(personal_best_score)
grobal_best_pos = personal_best_pos[best_particle]
errors = []
accs = []
print("Training start!")
for t in trange(self.iteration):
for n in range(self.n_particle):
ran_p = random.uniform(0, 1)
ran_g = random.uniform(0, 1)
particles[n] = particles[n] + velocities[n]
velocities[n] = (self.w*velocities[n] +
self.Cp*ran_p*(personal_best_pos[n]-particles[n]) +
self.Cg*ran_g*(grobal_best_pos-particles[n]))
score = self._get_error(x, y, particles[n])
if score < personal_best_score[n]:
personal_best_score[n] = score
personal_best_pos[n] = particles[n]
best_particle = np.argmin(personal_best_score)
grobal_best_pos = personal_best_pos[best_particle]
error = self._get_error(x, y, grobal_best_pos)
acc = self._get_accuracy(x, y, grobal_best_pos)
print(error, acc, grobal_best_pos)
errors.append(error)
accs.append(acc)
converg = [errors, accs]
return grobal_best_pos, converg
def _get_error(self, x, y, theta):
counts = self._get_counts(x, theta)
errors = []
for ct, lb in zip(counts, y):
emp_x = np.array([ct.get(b, 0)/SHOTS for b in self.encoder])
err = self._error_func(emp_x, np.array(y))
errors.append(err)
return np.mean(errors)
def _get_counts(self, x, theta):
qcs = self._classifier(x, theta)
job = execute(qcs, backend=BACKEND, shots=SHOTS)
result = job.result()
counts = [result.get_counts(qc) for qc in qcs]
# print(counts)
return counts
@staticmethod
def _error_func(x, bx, delta=1e-9):
return -np.sum(bx * np.log(x + delta))
@staticmethod
def _map_func(x):
val = x/np.arcsinh(x)
# print(val, x)
return val
def _classifier(self, x, theta):
qcs = []
ld = len(x[0])
for xt in x:
dataq = QuantumRegister(ld)
c = ClassicalRegister(ld)
qc = QuantumCircuit(dataq, c)
for xd, qr in zip(xt, dataq):
qc.h(qr)
qc.rz(self._map_func(xd), qr)
qc.h(qr)
qc.rz(self._map_func(xd), qr)
# anzatz
for r in range(4):
for ith, th in enumerate(theta):
qc.ry(th, dataq[ith])
for ids, d in enumerate(dataq[:-1]):
qc.cz(d, dataq[ids+1])
qc.cz(dataq[0], dataq[-1])
qc.measure(dataq, c)
qcs.append(qc)
return qcs
def _get_accuracy(self, x, y, theta):
counts = self._get_counts(x, theta)
answers = self._get_answer(counts)
count = 0
for ans, lb in zip(answers, y):
if ans == np.argmax(lb):
count += 1
accuracy = count/len(y)
return accuracy
def _get_answer(self, counts):
answers = []
for cs in counts:
answer = np.argmax([cs.get(b, 0) for b in self.encoder])
answers.append(answer)
return answers
def test(self, x, param):
counts = self._get_counts(x, param)
answer = self._get_answer(counts)
return answer
def performance(self, ans, label):
count = 0
for an, lb in zip(ans, label):
if np.argmax(lb) == an:
count += 1
return count/len(label)
if __name__ == '__main__':
digits = load_digits()
# qmnist = QMNIST(['0000000001', '0000000010',
# '0000000100', '0000001000',
# '0000010000', '0000100000',
# '0001000000', '0010000000',
# '0100000000', '1000000000'])
qmnist = QMNIST(['0000', '1000',
'0001', '1001',
'0010', '1010',
'0100', '1101',
'0101', '1111'])
# qmnist = QMNIST(['01', '10'])
onhot_labels = []
for i in digits.target:
lab = [0 for _ in range(10)]
lab[int(i)] = 1
onhot_labels.append(lab)
reducer = umap.UMAP(n_components=4)
reducer.fit(digits.data)
embedding = reducer.transform(digits.data)
# Verify that the result of calling transform is
# idenitical to accessing the embedding_ attribute
assert(np.all(embedding == reducer.embedding_))
x_train, x_test, y_train, y_test = train_test_split(embedding[:1000], onhot_labels[:1000])
param, conv = qmnist.fit(x_train, y_train)
answers = qmnist.test(x_test, param)
accs = qmnist.performance(answers, y_test)
print(param, conv)
print(accs)
|
https://github.com/qwqmlf/qwgc
|
qwqmlf
|
e1=[0.6286408520623922, 0.6289525825569178, 0.5412940012637213, 0.5399199822334315, 0.49756061144296837, 0.5386496534421491, 0.5110201664171742, 0.4785323556159, 0.4879992233852226, 0.49388898393628267, 0.4227883738901349, 0.47665407322957315, 0.49194537115508497, 0.4784480810071889, 0.5067394759922192, 0.4815508310174932, 0.4480058931682556, 0.5191713001759654, 0.5025600642057176, 0.47646282461622946, 0.4620775882390643, 0.5346632906032827, 0.4886131751452513, 0.5068477238076842, 0.4455982578380637, 0.5182468309511442, 0.5194051409981214, 0.5102047452714895, 0.4224846316777891, 0.4369363754766283, 0.47643414498658937, 0.5205363676955092, 0.5191792358482716, 0.43761845483213274, 0.4410680839960249, 0.5124071742830791, 0.5298468258800075, 0.5061098855038695, 0.48256532980818484, 0.4913228065366606, 0.4972612354925298, 0.4978721811109297, 0.4054224929939014, 0.4689590445321974, 0.47656007392483984, 0.4383041892763407, 0.44729094116756796, 0.4355191217281943, 0.39603253338464445]
e2=[0.6445889256767168, 0.6535514888883678, 0.650516819829064, 0.5756429937727983, 0.6142765741620072, 0.5835705610683382, 0.5912615393329274, 0.6146589955098392, 0.6122305885006271, 0.615096288252815, 0.5755860024839088, 0.544477825409265, 0.5426761288272395, 0.5468697195293689, 0.564680589127484, 0.5771165305986262, 0.5684633735633585, 0.5680884419879598, 0.5612183060968275, 0.559276953305883, 0.43673818405890585, 0.4411540650165362, 0.4598893136551889, 0.43005624189179076, 0.45188026405543275, 0.47144659911395703, 0.5244689044281716, 0.41605587984112, 0.4556096201350907, 0.46408102111806254, 0.4693180656437913, 0.4268421245136888, 0.4412494204726097, 0.39367845982910615]
e3=[0.662780905315912, 0.557526130143123, 0.5584640419156808, 0.5344490232122784, 0.593609022343057, 0.4937605123293818, 0.49679500580245917, 0.6381938409925619, 0.4969497574371143, 0.5490326065330788, 0.6127879707910444, 0.5089002055028583, 0.5504401226212559, 0.6142692709979238, 0.5721990951978606, 0.5018530856716944, 0.48248730823997454, 0.5393567930056656, 0.41791994591838755, 0.5305910774126542, 0.561185300298215, 0.595460105472618, 0.5115104804811111, 0.4495276525911773, 0.43500401066793454, 0.4161182946891324, 0.42475182877301493, 0.5073871378890902, 0.47263913226342963, 0.5149631515053271, 0.598002020559863, 0.41349915170939194, 0.47894825230795474, 0.5622578158963416, 0.5723435539368699, 0.4462502586322237, 0.4093627693814017, 0.5492960278816822, 0.510461265579312, 0.5808173512459651, 0.5597837733339822, 0.5640112157072309, 0.44698468041157, 0.5070970659950728, 0.48072844551751587, 0.5272173485178996, 0.5376622571610833, 0.5735053315795404, 0.4092035721307091, 0.5440903033836487, 0.5011121569382986, 0.5527630387469133, 0.4941897766576979, 0.470192162722345, 0.47418095121567044, 0.48084680432628457, 0.4239088964655666, 0.46940819486126134, 0.4537334210540194, 0.4864943090841813, 0.4687166558652696, 0.49614205816549944, 0.42874339930129546, 0.4479324170994075, 0.40787039901158556, 0.48786153290305956, 0.40963323764273557, 0.4352159063157325, 0.4888689022690961, 0.47162666268555464, 0.44671000444880116, 0.4967216183541344, 0.4012512434083865, 0.46064594635128436, 0.4049871203999046, 0.47170955324407465, 0.48706359188208187, 0.39931433341039707]
e4=[0.631157721764274, 0.626369631668824, 0.6435168046798363, 0.5756890928745755, 0.6805477459512386, 0.5457392115779026, 0.6670013898692743, 0.571441632419972, 0.5711226503295723, 0.5043703755755192, 0.5133700170618634, 0.4890578230830625, 0.48377985095373055, 0.5401161872295855, 0.5231897730483787, 0.5224417136122825, 0.48197008488419696, 0.5430021431008605, 0.48585065976376307, 0.4947049468193294, 0.5128519566834271, 0.5111700349984294, 0.5021240973161041, 0.44473351723091004, 0.5387269935977932, 0.5000663192282513, 0.47768543276690545, 0.4804686186752253, 0.5298907808582913, 0.4752329625280757, 0.44839780034261145, 0.4701039454704951, 0.4918735308810149, 0.4728677770754973, 0.4576550851711339, 0.502450222085708, 0.5163739719069254, 0.5213008138551934, 0.4652131556745651, 0.49846654870033724, 0.5137510967641185, 0.5446460345322064, 0.47656732480459313, 0.4516336465509245, 0.5271248472630446, 0.4559450905739887, 0.49738101909129345, 0.5253791961349298, 0.5135150601261252, 0.44079823430873305, 0.5324834268850102, 0.5035609323350201, 0.5182742329465138, 0.5504791701670207, 0.531284676694358, 0.474503007577341, 0.5366327134778044, 0.5011612366374507, 0.5127348471786759, 0.5019671684236049, 0.44189963776688185, 0.46295316911159845, 0.5348905595183858, 0.5269112370262575, 0.5090272490103386, 0.47609522731817105, 0.491370758355211, 0.4135600347595616, 0.4818512230353636, 0.512062390185624, 0.47933046522657563, 0.4934857435730518, 0.4806171151139013, 0.4608250672563326, 0.41268520144053455, 0.4918494520803791, 0.46745210963432454, 0.48071324978066593, 0.5057204328529747, 0.4996037331029218, 0.5413217090462604, 0.4508761552721001, 0.47468589579687376, 0.5642027975890482, 0.41545508292293726, 0.48314552116470366, 0.3997297679560264]
e5=[0.6682606140119535, 0.5778862814702397, 0.571284816447605, 0.5732217554886555, 0.576681243443929, 0.5696738503322155, 0.561619312862779, 0.5550863827708744, 0.5376039510952384, 0.5209829601641807, 0.5787276254893167, 0.5649896199922552, 0.5685287073392442, 0.4857622856463922, 0.5184760505457569, 0.5477220163966926, 0.5677443951422002, 0.546248508606815, 0.48857192683520445, 0.4844910863766792, 0.4503989103757882, 0.42963829512934754, 0.36462205360641897]
e6=[0.6052190978338532, 0.6168189279264902, 0.5742753886203199, 0.5916751574417829, 0.6499174495644433, 0.5572021688155816, 0.5875677462728359, 0.5882764329669297, 0.42224941745738764, 0.46388965858198655, 0.46894811449133583, 0.5386172982477864, 0.445138792658842, 0.5659195198584153, 0.4280846453576261, 0.5081342706424578, 0.591777700219891, 0.4300014148912618, 0.44029194146143813, 0.4655751631352384, 0.5144871176051569, 0.4302597905571364, 0.47086406673852405, 0.42197278841497904, 0.5666806007720256, 0.4684396130328333, 0.46515501410751087, 0.5854247908909535, 0.46820092150107384, 0.4542753960527196, 0.5136825397873981, 0.42490230795806355, 0.5681653948495334, 0.4982418526291404, 0.5297805255166854, 0.5255641991721257, 0.46604946752584037, 0.42125778606643877, 0.5572774702893012, 0.4857469072821239, 0.46583437875598993, 0.49471480783108884, 0.4960882334145554, 0.464275426856948, 0.4227442887486467, 0.4736773611229292, 0.49004926134414617, 0.49931503682149486, 0.4988062267806028, 0.49268082475005154, 0.4488809454972674, 0.5174211905808321, 0.42898509257033995, 0.41935662991751776, 0.4804755068098414, 0.5517276889852001, 0.6108761441851374, 0.5106562598517737, 0.5707976053860792, 0.5431404102118769, 0.610686118237394, 0.5640443974179815, 0.45304879473737386, 0.5000248112364134, 0.4302734132332332, 0.48721656167805666, 0.5295429629785897, 0.46752394358529753, 0.6145431584915981, 0.50988218844425, 0.49915956989048965, 0.5278205896473646, 0.620852541372503, 0.4237926102741802, 0.42282174131809014, 0.4208938526055965, 0.487461524736154, 0.4753131817344044, 0.4822918616140902, 0.44156923779603763, 0.41871631240516527, 0.46848062331449036, 0.46980532334976366, 0.4709761803139777, 0.3976063267327049]
e7=[0.6343177780040268, 0.619599304033062, 0.6242120198917819, 0.6031668480623487, 0.6402201060305929, 0.6231041583237609, 0.6293624185342378, 0.6458794486207945, 0.6827538772276097, 0.6720506480634977, 0.6899104720222323, 0.669870406811187, 0.6512371597807493, 0.6920056581481943, 0.5914131484170293, 0.6232179447484109, 0.5801354474941912, 0.6763159966305158, 0.56685784250218, 0.6637311529482484, 0.5847709695092046, 0.5633961429876598, 0.560108233954407, 0.52832327254978, 0.5283157800182223, 0.49202826266850064, 0.46519065544218025, 0.458531046376133, 0.48787502470038335, 0.4633186448926279, 0.5231878042415427, 0.5232549990667295, 0.45401437184614385, 0.4628743973973229, 0.46133926646432816, 0.4803737244518355, 0.4908663462940766, 0.47381789765142834, 0.46783045177687643, 0.46850374045145793, 0.4681717836248394, 0.4664232598009578, 0.475161204989716, 0.4698246364777594, 0.46279370428901806, 0.47086318835181673, 0.47130924184490053, 0.48004062896072147, 0.5380318909358003, 0.522459093653992, 0.5086512464786042, 0.4940124113230001, 0.5084629644805148, 0.49907221807047564, 0.5060149840853123, 0.5399783523243797, 0.5411928928687932, 0.5080996494638225, 0.49238446160879457, 0.5090379936341687, 0.4514971394109261, 0.5069246117398007, 0.5122056635240435, 0.5183315031961354, 0.5247657452974124, 0.5358356076290758, 0.5328220546034671, 0.5280624432744783, 0.5274743097746725, 0.4975618714767399, 0.49785887670110296, 0.5172247834730592, 0.5139599573220014, 0.5470670151810273, 0.5289727214355933, 0.5291905638247228, 0.4802756837124825, 0.5105438294031261, 0.4966151637696548, 0.4622230385770683, 0.5028894815058449, 0.5204636049862856, 0.46890755144793184, 0.536715875218253, 0.5287019172764743, 0.49212818638466355, 0.4978716350387547, 0.47170291861259944, 0.537535312754868, 0.5285083683899722, 0.5435672463104038, 0.5362293614488318, 0.48409470635156077, 0.45942009997388766, 0.5383618196483511, 0.5066198888774862, 0.5322328585016302, 0.5380757401024095, 0.5307318705952703, 0.49557513053245256, 0.540221765590457, 0.5319199897476646, 0.4425432496155992, 0.5424946438115121, 0.4967073166823288, 0.522464533354847, 0.48612498629064954, 0.5236114041318946, 0.5270520927976627, 0.5375392206453816, 0.49356780560525965, 0.5055856811585618, 0.5432119154861312, 0.5048427773577933, 0.45663313202496075, 0.45486778712936404, 0.44971790073868045, 0.5149780350294215, 0.5083240728859777, 0.44894944420421445, 0.5042145757006968, 0.48460426559739705, 0.4967351042896734, 0.5044661611141689, 0.43596825173934706, 0.5746881408014808, 0.5560117818174737, 0.48581143997140513, 0.4178848063830119, 0.4124531613792558, 0.41128625935257995, 0.5130877411153815, 0.5702506434152459, 0.5191608795298068, 0.40421862548733356, 0.49370921494417785, 0.47747102686452786, 0.4501159143626001, 0.42434966281242287, 0.5694928908915956, 0.4707648838018859, 0.46308786979076044, 0.5674826460753027, 0.41319744667993896, 0.43378581408673195, 0.5479508775304427, 0.42830800640058475, 0.5040567675034388, 0.5102932814824029, 0.5352098084517855, 0.4711907835610163, 0.4135569939522152, 0.5645434706974641, 0.39392153030740434]
e8=[0.5913407969216123, 0.5968027045561548, 0.5807132242546393, 0.6045555424432444, 0.5790465745724817, 0.5146519574308367, 0.5386476154031689, 0.5457725039582826, 0.5544308346069118, 0.5435916500554991, 0.5640535382781875, 0.5419371097075426, 0.5441329113708785, 0.5580210026385325, 0.539490557893939, 0.5427861674156166, 0.5546224894721118, 0.5497072631021152, 0.5562272792102939, 0.5191799008595017, 0.5651000039656113, 0.5648645310545621, 0.5442534059819037, 0.5442239567027761, 0.5569325490735977, 0.5570671528470494, 0.5707478917193466, 0.5520669114088126, 0.5560904525558917, 0.536186225898877, 0.567669985618328, 0.5404920496327675, 0.551565557944254, 0.5425809403646311, 0.5557752017202766, 0.5535524873136072, 0.54511963019625, 0.5578999806184163, 0.5430200803197988, 0.5600545158472466, 0.5495828613081718, 0.554367532743426, 0.5492933831513049, 0.5571854750471325, 0.542362247911772, 0.5480834794851243, 0.5262099870228901, 0.48032788936449317, 0.4782151124259759, 0.49380543526049225, 0.5064807825285621, 0.4947974190672037, 0.4937050456318475, 0.49423348593034644, 0.4934758389741058, 0.5088370646749851, 0.4945296999162127, 0.4980231753465324, 0.4966765276873942, 0.4921028081643773, 0.515243532046272, 0.505921332289337, 0.5040872928584723, 0.4934447759396242, 0.5075192382266717, 0.5097597347103172, 0.4742844879083192, 0.5442708524819456, 0.4999348179754739, 0.461829856728611, 0.4705040366840693, 0.4903857708284842, 0.4924730661893619, 0.5134988021147889, 0.4923443029208326, 0.4727467433790539, 0.5225885499341563, 0.47025597023306087, 0.49101448323887475, 0.5430488000164548, 0.46579466193938523, 0.5151981816002086, 0.5429112242988399, 0.5038012282289347, 0.524662590969537, 0.4958443962133329, 0.4577390007625348, 0.5445978798228361, 0.502963558160195, 0.4894387668322627, 0.5440032976839626, 0.4819860916037589, 0.4654945753767531, 0.5152589293772628, 0.49937169712317414, 0.4864882370386736, 0.4507856824420945, 0.46654016177363283, 0.5097213545853928, 0.5404550468061052, 0.5419278186965883, 0.4495814173506067, 0.5153273272247367, 0.45098667264602854, 0.46487961539249983, 0.5234411744015217, 0.5336811462704812, 0.4455712071824399, 0.5365523056268828, 0.5121995525704492, 0.4736035794709903, 0.4473335804233988, 0.4906554048692217, 0.43056341428429684, 0.48750676622735406, 0.46975202791639503, 0.41985163165128453, 0.42365061155579714, 0.46134934441088365, 0.46918184061159246, 0.4432015336494499, 0.4720567531651249, 0.4683567090279011, 0.42967603770654866, 0.4236602081687182, 0.4135466892675132, 0.45815086391436777, 0.3967556123885781]
e9=[0.6650768332261353, 0.5839188975158505, 0.5465120888927283, 0.5550907987683472, 0.567639764704636, 0.5085926678869052, 0.5275917470790742, 0.541221468537061, 0.5704477431835283, 0.5448885505140948, 0.5132874077181068, 0.5101701010115886, 0.5310406275923955, 0.5454947990050796, 0.5625857434190685, 0.5159442036807962, 0.5988034093157687, 0.5943047004640979, 0.551393955716915, 0.5233365342078535, 0.4752450983304961, 0.5050691325599479, 0.5235954093501491, 0.4552512305179317, 0.5831833398610338, 0.4731778439749536, 0.5687028273171127, 0.5889767650973098, 0.6064331743720209, 0.440816151178571, 0.448903119770252, 0.44343653750230294, 0.5001408741585447, 0.49118657617553213, 0.467956850971661, 0.4825464062978623, 0.5399849464121956, 0.47311507777648387, 0.4968562934355171, 0.46528754202033956, 0.5009424715411169, 0.4498238228474625, 0.5111711895467378, 0.46172956095965534, 0.48795037350222076, 0.49779900451624604, 0.41431572809038547, 0.5548793389362827, 0.5592370825347295, 0.47399601371736727, 0.5362121023064179, 0.5389262776700031, 0.48785242517507516, 0.48497470394201003, 0.48853758754813664, 0.452062814504457, 0.48515275520764484, 0.5178452313538177, 0.4370453782697105, 0.5143343530357027, 0.4733976407685126, 0.4377874336752083, 0.4225158612975633, 0.4079474669212051, 0.5525408255038543, 0.5199513551123233, 0.4448075381183994, 0.4889228086780745, 0.5444860707172519, 0.5482472432312546, 0.4715690031152096, 0.5860841514937343, 0.48233223561238736, 0.5260061348833885, 0.5273267432013465, 0.5210076022602085, 0.5551322110634548, 0.43377446518549584, 0.5930831673002215, 0.47734011874861937, 0.5223724082746285, 0.46364564600104363, 0.49103227014858114, 0.5078208924726832, 0.5142013832446156, 0.42539199248715004, 0.573131639889572, 0.4196562315745191, 0.5830005193887268, 0.5093072734962075, 0.5148966644389248, 0.4243085194017081, 0.6687310583399344, 0.46364319971652684, 0.49546870554391054, 0.5366528704484373, 0.5198103049962106, 0.5387543007216663, 0.582636034027522, 0.5363235009290618, 0.48327522215619056, 0.541926394132778, 0.5559785869462495, 0.6016761352697166, 0.5371624283020867, 0.5674319149578625, 0.5300704977548727, 0.5547608427601932, 0.4798895004992304, 0.4660034751436862, 0.524066221672807, 0.48431688551826535, 0.4902196506170733, 0.540522649117206, 0.4411247935696716, 0.5057168246330429, 0.6111460839056243, 0.5640026472940163, 0.5352351126005239, 0.43094285001997823, 0.5156524893462651, 0.43502378139170633, 0.4967973382630091, 0.49812092740202074, 0.5167071715045539, 0.5532030008701334, 0.5617041929433927, 0.5188911940730441, 0.5743757589835153, 0.5189928236553618, 0.4380557607907093, 0.5418787229350316, 0.44821135345496893, 0.5310716701733434, 0.5461678917843644, 0.519134739798097, 0.5511987988747173, 0.5773381630359999, 0.5233184425743422, 0.49873902095696, 0.5038420863478974, 0.5758701606630139, 0.5551576247842767, 0.5159133205832385, 0.5433872211476676, 0.5233134104986293, 0.5134074229814606, 0.49244212787856195, 0.5004507865528482, 0.5177767871179224, 0.5125121555910681, 0.5202937524719504, 0.5158894931633854, 0.518259284945597, 0.49879019957162246, 0.5138751753512852, 0.5193327327927922, 0.520053378362557, 0.4996759240244054, 0.5307492186079692, 0.5321791654099939, 0.512370357644313, 0.5051488492226954, 0.5155795339277843, 0.5850895438525353, 0.49333688234630446, 0.5146387574915534, 0.5152962059410358, 0.4916785527685588, 0.5220270697847215, 0.5108044898684504, 0.5225887670058841, 0.5054755192744912, 0.5200111921446353, 0.6186353617217828, 0.5162420347066328, 0.48991362080819656, 0.49458247546427553, 0.5310543800879368, 0.49156501831817023, 0.5209129827957445, 0.5071274285234982, 0.514889685151172, 0.4876652826616725, 0.5176711547960228, 0.501579488061985, 0.5219832016573605, 0.5211421406724956, 0.6102793042683985, 0.5092234796765647, 0.505841113259587, 0.5191361626567386, 0.509224562794439, 0.5095766326615782, 0.502079751965955, 0.5127003003234921, 0.5099580442929842, 0.5107503813960915, 0.5886776852182013, 0.5220688084678431, 0.5280708084273058, 0.5097898025489782, 0.5047902080968601, 0.5005626889772651, 0.596540291245381, 0.4996027048629127, 0.4934349312367303, 0.5409843332211969, 0.5017001340834972, 0.5094353513995228, 0.5170367406199069, 0.530769105638814, 0.5176185091437396, 0.5094759296400767, 0.5193568466416617, 0.4989014112392066, 0.5279480159795279, 0.5029211093859308, 0.5002122616570341, 0.5009459192487525, 0.5161268696467814, 0.5122714761320836, 0.4996834477594777, 0.5003828952897394, 0.5152310440552359, 0.5268164219017487, 0.4977712336603499, 0.5046063697037492, 0.5049611779603863, 0.471537858447829, 0.426280740636709, 0.4063048376824669, 0.4556689882653091, 0.429043458117716, 0.46098399335733065, 0.4783089903682395, 0.4548024144447215, 0.46235139284638144, 0.4855141050547884, 0.4525664843675803, 0.4752750869575304, 0.39445032834640115]
e10=[0.6443296151657899, 0.5846714977547917, 0.5672715023778702, 0.5730989175581916, 0.5384647413211849, 0.645025012113611, 0.5818761835357733, 0.5485799801801237, 0.5470440562426591, 0.6848038874433044, 0.5762873974699276, 0.5210875247502859, 0.5840268965938661, 0.5996170002320559, 0.5675317667073588, 0.530705152494162, 0.43856855545184587, 0.5336486205176295, 0.5041957778265646, 0.5331599343293132, 0.4638759111952121, 0.5702342410880747, 0.4641523004965677, 0.49632076472769915, 0.4134526096867966, 0.6395538621427509, 0.5807024881555874, 0.54209316417008, 0.4917106519049478, 0.5746860150482541, 0.4903252002874721, 0.407509811691121, 0.41193636837385816, 0.5197750790448739, 0.5015629445346276, 0.5122720293420352, 0.5089435162867448, 0.479120258101935, 0.9612299362567398, 0.5322306367524896, 0.5408316328291428, 0.5005022853080526, 0.40517976682543727, 0.4738710242232649, 0.5853321607871663, 0.6350323074683683, 0.6220323108115962, 0.5756956691561051, 0.5785318277560356, 0.5495550621945828, 0.6706174816054492, 0.6379782769471595, 0.7984002265429345, 0.5819019958048154, 0.565515984004764, 0.585069528132984, 0.7163610180148806, 0.5907315843404257, 0.5649416080557663, 0.5797493081636891, 0.5929644452090546, 0.7590981885358427, 0.6029722793981109, 0.753962026409037, 0.6612429927176287, 0.5633060981382474, 0.6934616792472114, 0.599324234927781, 0.6621616927728853, 0.5921192185054662, 0.43641299280375273, 0.5122249502827196, 0.409546418406672, 0.42286517450873307, 0.6224070628071293, 0.5023519159195332, 0.5663255019772804, 0.5678506389375136, 0.464807663895237, 0.4602657015700848, 0.41183164602462163, 0.4275251302283884, 0.5801912671155873, 0.5318028256314792, 0.5397358271202957, 0.4531821739411755, 0.44849727924771193, 0.46869408154450576, 0.4549633610858585, 0.4462452859369011, 0.524381047614326, 0.379113122281514]
# errors = [e1, e2, e3, e4, e5, e6, e7, e8, e9]
errors = [e1, e4, e2]
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
fig = plt.figure(figsize=(20, 10))
sns.set()
plt.xlabel("The number of iterations", fontsize=30)
plt.ylabel("Error", fontsize=30)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
for ier, er in enumerate(errors):
lens = len(er)
plt.plot(range(lens), er, label="Error rate in the training process.")
# plt.legend(fontsize=20)
plt.title("Error tranisition during the training process.", fontsize=30)
plt.show()
figure = plt.figure(figsize=(10, 10))
plt.boxplot([0.9473684210526315, 0.7894736842105263, 0.8947368421052632, 0.8947368421052632, 0.7894736842105263, 0.8947368421052632, 0.6842105263157895, 0.7368421052631579, 0.8888888888888888, 0.7777777777777778])
plt.title("Result of 10 cross validation", fontsize=20)
plt.xlabel("MUTAG experiment", fontsize=20)
plt.tick_params(labelsize=14)
plt.ylabel("Accuracy", fontsize=20)
e3s=[0.6114993145170406, 0.5580492397062562, 0.551723552407508, 0.5484116800260197, 0.5143462721841497, 0.628101523805724, 0.5356993571948219, 0.5266942280148578, 0.5141310873542365, 0.5638829554297106, 0.5496228055765812, 0.6360133689458043, 0.5201943196959011, 0.5481851459170456, 0.5055907141722972, 0.4941810064365272, 0.49340466605586575, 0.4634544459337397, 0.4611237576608274, 0.45213919591606666, 0.4534383746210488, 0.5054618981122072, 0.5165870609303926, 0.45209150635940387, 0.46805949776885464, 0.46960440853671903, 0.467819372880231, 0.4741484070294051, 0.4820804390230995, 0.4717719920228282, 0.5693892077112471, 0.5511274894354884, 0.5033156791541581, 0.5225321272437906, 0.5036599855410948, 0.51329297604302, 0.46424100042295025, 0.48893838154754043, 0.491828375814068, 0.5032194807511081, 0.4509417716028073, 0.4795241201436505, 0.5327343558753157, 0.4878793485411833, 0.4968022638355129, 0.47016307388363854, 0.5139168596002424, 0.44169284992918284, 0.4970774248606773, 0.5008123176407452, 0.5167832520763408, 0.5080038420660207, 0.48930759606351343, 0.513371961439122, 0.43260350311028717, 0.4378572126596461, 0.44645119576095627, 0.43974257495457336, 0.44501068910222275, 0.5046275199007141, 0.5248927422341266, 0.5057426950560957, 0.44435592756939385, 0.5028020254976295, 0.43205956750536756, 0.5095266443472911, 0.43189189288242835, 0.48790827272910336, 0.4615726181458669, 0.4708616965051463, 0.44032234603084713, 0.5179107099016528, 0.447553212974451, 0.4866584089091045, 0.5095162013165208, 0.5159928986646231, 0.5044830183103161, 0.4292861696424971, 0.5314628116720455, 0.43598839835680664, 0.4577829631040909, 0.4873913033076141, 0.4503809344508515, 0.484440023394841, 0.48888482964533436, 0.4920285335157382, 0.5073922782465428, 0.44670952906510897, 0.49607219758491355, 0.4308090376369893, 0.5268897603175041, 0.503559006011311, 0.5325591799558704, 0.5112110616324055, 0.4217329296463216, 0.4287457162429004, 0.5387852988261452, 0.5221160368806622, 0.509923902633072, 0.4411366299303317, 0.43803455040269307, 0.5335288104235335, 0.5272146852894581, 0.4602714866419109, 0.4465667728038471, 0.49895069098977923, 0.44450285295324765, 0.5251224372640607, 0.5278343169334901, 0.4596689338797286, 0.5217282828884132, 0.42935151668392935, 0.46706278369369864, 0.511648879842166, 0.49038583458744545, 0.4240684556714285, 0.5085615349599282, 0.4667558025833304, 0.5225293906551759, 0.4791700925332441, 0.42187666877056285, 0.4444577598049048, 0.43180975598120047, 0.47279635019359195, 0.40434165271953953, 0.4567439578687747, 0.4047810725738134, 0.45285436709795845, 0.5106699339221253, 0.41760528844233397, 0.463230639757571, 0.4583953066465225, 0.47033013236271226, 0.46012210399176057, 0.48140415708781703, 0.4471153121689473, 0.485398357745934, 0.4602156421568477, 0.48008157966420123, 0.4202314394133098, 0.504311984447005, 0.4655888166277228, 0.43114982313289985, 0.46496997393407696, 0.46041725990525456, 0.4662905080385762, 0.43186752985533855, 0.5113262759807295, 0.4719745720033306, 0.47791479563461675, 0.46799098060250977, 0.40620578584396677, 0.42314041607019615, 0.4162314065076259, 0.41579571768218204, 0.43814693535584737, 0.47413006835703997, 0.4974571568255316, 0.4935654224734384, 0.48136060672275627, 0.4550978367425495, 0.49706958170713433, 0.44513768595224995, 0.4253361121582329, 0.44381941515869333, 0.4761198169714065, 0.47667447892671105, 0.48046363042033574, 0.5199316709111657, 0.48927857372412814, 0.4808599995841265, 0.49799963296315697, 0.4492087033317719, 0.46986478238223167, 0.506700053418057, 0.4987938011003559, 0.4544414206143903, 0.5377744716063275, 0.5140073014745788, 0.42192876338556845, 0.4486045885520557, 0.42644917513144487, 0.4116325393736495, 0.4322134994562949, 0.476302541798784, 0.48675134068911835, 0.41824997807779385, 0.426746519901415, 0.46480259963728177, 0.5214455692010816, 0.41548303889992255, 0.42933136120094717, 0.4838030541852354, 0.494936691128753, 0.49186212498168014, 0.4217631685828114,
0.45602912462583534, 0.5125161938121239, 0.4457479372848052, 0.46618893650081916, 0.48881100807439615, 0.43768350802896466, 0.4739599720363637, 0.4955716129352989, 0.4804280162630706, 0.48163906724030736, 0.4143071427832678, 0.48475848400436833, 0.44899270858594775, 0.4838938111763643, 0.4848282167826762, 0.4838980545767503, 0.4866190119509327, 0.4717631934896995, 0.5165489359356199, 0.48360361419074716, 0.4804091649028527, 0.5097297759525212, 0.4571519002443824, 0.4452585896454598, 0.4414109845063244, 0.4235666003629125, 0.5153951286649423, 0.4883078008311837, 0.4346874565124854, 0.5005732966822127, 0.417852787993552, 0.4145857127347467, 0.48591110524336795, 0.4345903953415311, 0.41977222100784434, 0.5371283981310165, 0.47305277802964524, 0.44317952697867435, 0.4036964309526516, 0.4581214250541329, 0.5463341411652219, 0.46045127199889063, 0.4501169516101683, 0.4179825918218954, 0.49900783694877715, 0.4892906123586632, 0.42840660739898967, 0.47162708436149237, 0.4345798849491902, 0.47562520954776094, 0.4340927110566402, 0.4313336037367724, 0.4129143693247415, 0.5135537564781154, 0.47204003930970917, 0.4210640712529034, 0.4245605754426493, 0.4743745984824515, 0.48794937883439804, 0.4180700741879826, 0.4912515867736354, 0.4903159358869692, 0.49091273489139003, 0.4327263671175196, 0.5112962766853835, 0.418128526296058, 0.4832865396091334, 0.48082133074596606, 0.4832623410972604, 0.41270459153098055, 0.42109973525643424, 0.4998801209675613, 0.46762469008572893, 0.4799947903769364, 0.4736394640658181, 0.47211493605277344, 0.5287411401320841, 0.5200724040148723, 0.5066205296433474, 0.5127730183590961, 0.44369916589791547, 0.48456698587240804, 0.5051576392479146, 0.5081283632369991, 0.4193870952105006, 0.43548458423797165, 0.5146117075667941, 0.6496553944513833, 0.4143930795231045, 0.4289819520927289, 0.5080801555292406, 0.5131411994688787, 0.43696130146368667, 0.5427646826654766, 0.45345802627109194, 0.5433482910534887, 0.5143319170186181, 0.5097298427495505, 0.5136637813655547, 0.5106507420608952, 0.5548887569702587, 0.7065321055530301, 0.5168715814597589, 0.41794267534812685, 0.43090336510087845, 0.7212155749399769, 0.6165544559697002, 0.46033737106777256, 0.5089387495523169, 0.5253975539361965, 0.5115566116956278, 0.42320202401689294, 0.5246174570570632, 0.6281310330202612, 0.4751536510310882, 0.5950102991564058, 0.4978649425068354, 0.46610446928565485, 0.544534190394418, 0.6016255287956038, 0.5631491919128527, 0.6833236214330077, 0.4110880226407702, 0.4722339929634415, 0.5323749024552461, 0.4891842913332914, 0.6762690545068252, 0.41950833442907715, 0.4876659176727193, 0.6046630614307239, 0.4928000945510993, 0.553452844399436, 0.4511162775004234, 0.47151456349690807, 0.4909478739757076, 0.4918155366451409, 0.4431381515130087, 0.48011543632848297, 0.6012506969150045, 0.4602080508155012, 0.4857964362690456, 0.554271610426304, 0.41699549081779524, 0.4613389595659844, 0.413520621478622, 0.5796217614630786, 0.4849478885457273, 0.405352719966207, 0.4885767886098703, 0.5219683081108104, 0.4626909895475748, 0.5026622317544714, 0.5683235089403735, 0.40180703773062326, 0.41191760583198633, 0.39797130773487593]
plt.plot(range(len(e3s)), e3s)
import numpy as np
from sklearn.decomposition import PCA
predata = []
with open('../result.txt') as f:
lines = f.readlines()
for l in lines:
temp = []
for lsa in l[1:-2].split(","):
temp.append(complex(lsa))
predata.append(temp)
print(predata)
X = np.array(predata, dtype=complex)
reals = []
imags = []
for x in X:
temp_re = []
temp_im = []
for ele in x:
print(ele.real)
temp_re.append(ele.real)
temp_im.append(ele.imag)
reals.append(temp_re)
imags.append(temp_im)
labels = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1, 1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, -1, 1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1]
import matplotlib.pyplot as plt
import seaborn as sns
pca = PCA(n_components=2)
reals = pca.fit_transform(reals)
# class 1
group1 = [i for i, j in zip(reals, labels) if j==1]
g1_x, g1_y = [i[0] for i in group1], [i[1] for i in group1]
# class -1
group2 = [i for i, j in zip(reals, labels) if j==-1]
g2_x, g2_y = [i[0] for i in group2], [i[1] for i in group2]
sns.set()
fig = plt.figure(figsize=(15, 10))
plt.scatter(g1_x, g1_y, c="red")
plt.scatter(g2_x, g2_y, c="blue")
pca = PCA(n_components=2)
imags = pca.fit_transform(imags)
# class 1
group1 = [i for i, j in zip(imags, labels) if j==1]
g1_x, g1_y = [i[0] for i in group1], [i[1] for i in group1]
# class -1
group2 = [i for i, j in zip(imags, labels) if j==-1]
g2_x, g2_y = [i[0] for i in group2], [i[1] for i in group2]
sns.set()
fig = plt.figure(figsize=(15, 10))
plt.title("Feature Space before learning")
plt.scatter(g1_x, g1_y, c="red")
plt.scatter(g2_x, g2_y, c="blue")
import numpy as np
from sklearn.decomposition import PCA
predata = []
with open('../result2.txt') as f:
lines = f.readlines()
for l in lines:
temp = []
for lsa in l[1:-2].split(","):
temp.append(complex(lsa))
predata.append(temp)
print(predata)
X = np.array(predata, dtype=complex)
reals = []
imags = []
for x in X:
temp_re = []
temp_im = []
for ele in x:
print(ele.real)
temp_re.append(ele.real)
temp_im.append(ele.imag)
reals.append(temp_re)
imags.append(temp_im)
pca = PCA(n_components=2)
reals = pca.fit_transform(reals)
# class 1
group1 = [i for i, j in zip(reals, labels) if j==1]
g1_x, g1_y = [i[0] for i in group1], [i[1] for i in group1]
# class -1
group2 = [i for i, j in zip(reals, labels) if j==-1]
g2_x, g2_y = [i[0] for i in group2], [i[1] for i in group2]
sns.set()
fig = plt.figure(figsize=(15, 10))
plt.scatter(g1_x, g1_y, c="red")
plt.scatter(g2_x, g2_y, c="blue")
pca = PCA(n_components=2)
imags = pca.fit_transform(imags)
# class 1
group1 = [i for i, j in zip(imags, labels) if j==1]
g1_x, g1_y = [i[0] for i in group1], [i[1] for i in group1]
# class -1
group2 = [i for i, j in zip(imags, labels) if j==-1]
g2_x, g2_y = [i[0] for i in group2], [i[1] for i in group2]
sns.set()
fig = plt.figure(figsize=(15, 10))
plt.title("Feature Space before learning")
plt.scatter(g1_x, g1_y, c="red")
plt.scatter(g2_x, g2_y, c="blue")
|
https://github.com/qwqmlf/qwgc
|
qwqmlf
|
import numpy as np
import random
import copy
import sys
import networkx as nx
import matplotlib.pyplot as plt
from numpy import pi
from tqdm import trange
from grakel import datasets, Graph
from sklearn.model_selection import KFold
sys.path.append("../")
from qwgc.QWGC import QWGC
# MUTAGを取ってくる
Data = datasets.fetch_dataset('MUTAG', verbose=False)
data_x, data_y = np.array(Data.data), np.array(Data.target)
# visualization of data
subtract = 0
lens = []
for d, l in zip(data_x[:10], data_y[:10]):
print(l)
plt.figure(figsize=(10, 10))
G = nx.DiGraph()
connection = d[0]
nodesize = [(i+1)**800 for i in d[1].values()]
edge_weight = d[2]
lens.append(len([i for i in d[1].values()]))
adjacency = Graph(connection).get_adjacency_matrix()
nodes = np.array([str(i+1) for i, _ in enumerate(adjacency)])
edges = []
weight = []
for i, v in edge_weight.items():
ed = [str(st-subtract) for st in list(i)]
ed.append(v+1)
edges.append(tuple(ed))
subtract = max(d[1].keys())
G.add_nodes_from(nodes)
G.add_weighted_edges_from(edges)
pos = nx.kamada_kawai_layout(G)
edge_labels = {(i, j): w['weight'] for i, j, w in G.edges(data=True)}
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
nx.draw_networkx(G, pos, with_labels=True, alpha=0.8)
plt.show()
from qwgc.preprocess.qwalk import QuantumWalk
# 対象のデータ
data = data_x[0]
label = data_y[0]
# 隣接行列
adjacency = Graph(data[0]).get_adjacency_matrix()
count = np.count_nonzero(adjacency)//2
# 量子ウォークのハイパーパラメータ
step = 1
# 次数が2の場合のコインのパラメータ(今回は簡単のために全てアダマールコイン)
coin = np.kron(np.identity(count), 1/np.sqrt(2)*np.array([[1, 1], [1, -1]]))
# 初期状態 (0からスタート)
initial = None
# 量子ウォーカーが測定される確率
qwalk = QuantumWalk(initial, coin, adjacency)
qwalk.n_steps(step)
probs = qwalk.calc_probs()
# 描画
plt.figure(figsize=(10, 10))
G = nx.DiGraph()
# ノードの大きさで確率を表す
connection = data[0]
nodesize = [(i+0.1)*800 for i in probs]
edge_weight = data[2]
nodes = np.array([str(i+1) for i, _ in enumerate(adjacency)])
edges = []
weight = []
for i, v in edge_weight.items():
ed = [str(st) for st in list(i)]
ed.append(v+1)
edges.append(tuple(ed))
subtract = max(data[1].keys())
G.add_nodes_from(nodes)
G.add_weighted_edges_from(edges)
pos = nx.spring_layout(G)
edge_labels = {(i, j): w['weight'] for i, j, w in G.edges(data=True)}
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
nx.draw_networkx(G, pos, with_labels=True, alpha=0.8, node_size=nodesize)
plt.show()
def draw(nodesize):
plt.figure(figsize=(10, 10))
G = nx.DiGraph()
# ノードの大きさで確率を表す
connection = data[0]
nodesize = [(i)*800 for i in probs]
edge_weight = data[2]
nodes = np.array([str(i+1) for i, _ in enumerate(adjacency)])
edges = []
weight = []
for i, v in edge_weight.items():
ed = [str(st) for st in list(i)]
ed.append(v+1)
edges.append(tuple(ed))
subtract = max(data[1].keys())
G.add_nodes_from(nodes)
G.add_weighted_edges_from(edges)
pos = nx.spring_layout(G)
edge_labels = {(i, j): w['weight'] for i, j, w in G.edges(data=True)}
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
nx.draw_networkx(G, pos, with_labels=True, alpha=0.8, node_size=nodesize)
plt.show()
data = data_x[0]
label = data_y[0]
# 隣接行列
adjacency = Graph(data[0]).get_adjacency_matrix()
count = np.count_nonzero(adjacency)//2
# 量子ウォークのハイパーパラメータ
for step in range(1, 10):
# 次数が2の場合のコインのパラメータ(今回は簡単のために全てアダマールコイン)
coin = np.kron(np.identity(count), 1/np.sqrt(2)*np.array([[1, 1], [1, -1]]))
# 初期状態 (0からスタート)
initial = None
# 量子ウォーカーが測定される確率
qwalk = QuantumWalk(initial, coin, adjacency)
qwalk.n_steps(step)
probs = qwalk.calc_probs()
draw(probs)
from qwgc.preprocess.qwfilter import QWfilter
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute, transpile
data = data_x[0]
label = data_y[0]
# filter
u3param = [pi, 0, pi/2]
# step
step = 3
# initial 重ね合わせを初期状態として利用
initial = "super"
qwfilter = QWfilter(u3param, step, initial)
# 今回は測定をせずに、振幅をそのまま量子回路にマッピングを行います。
amplitude = qwfilter.single_amplitude(data)
la = len(amplitude)
new_amplitude = list(amplitude) + [0 for i in range(64 - 38)]
print(len(new_amplitude))
nq = 6
# 量子レジスタの定義
qr = QuantumRegister(nq, name="quantum walk")
ancilla = QuantumRegister(2, name="ancilla")
# 古典レジスタの定義
cr = ClassicalRegister(2)
# 量子回路の定義
qc = QuantumCircuit(qr, ancilla, cr)
qc.draw(output='mpl')
qc.initialize(new_amplitude, qr)
# 回転角を初期化
theta = [np.random.uniform(-pi, pi) for i in range(nq)]
for ith, th in enumerate(theta):
qc.cry(th, qr[ith], ancilla[ith%2])
qc.draw(output="mpl")
qc.measure(ancilla, cr)
backend = Aer.get_backend("qasm_simulator")
shots = 1024
job = execute(qc, backend=backend, shots=shots)
counts = job.result().get_counts(qc)
dinom = counts.get('01', 0) + counts.get('10', 0) + 1e-10
print("クラス-1である確率:", counts.get('01', 0)/dinom, "クラス1である確率:", counts.get('10', 0)/dinom)
if counts.get('01', 0)/dinom > counts.get('10', 0)/dinom:
answer = -1
else:
answer = 1
print("このグラフはクラス ", answer, "です.")
print("正解は", data_y[1], "です。")
|
https://github.com/qwqmlf/qwgc
|
qwqmlf
|
# -*- coding: utf-8 -*-
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.3.3
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Quantum Walk Graph Classifier
# 今回の成果物である量子ウォークにおけるグラフの分類器に関するチュートリアル
# +
import numpy as np
import random
import copy
import sys
import networkx as nx
import matplotlib.pyplot as plt
from numpy import pi
from tqdm import trange
from grakel import datasets, Graph
from sklearn.model_selection import KFold
sys.path.append("../")
from qwgc.QWGC import QWGC
# -
# # 量子ウォーク
# このプロジェクトにおける肝となる量子アルゴリズムである量子ウォークというものについてです。詳しくは我々の[プロジェクトページ](https://qwqmlf.github.io/QuantumFrontier/article)をご覧ください。今回は[MUTAG](https://rdrr.io/cran/QSARdata/man/mutagen.html)と呼ばれるデータセットを用いて、量子ウォークがグラフ上で行われるということがどういうことなのかということについて見ていきます。
# MUTAGを取ってくる
Data = datasets.fetch_dataset('MUTAG', verbose=False)
data_x, data_y = np.array(Data.data), np.array(Data.target)
# まずはMUTAGとはどのようなデータなのかという点について見ていきます。代表として先頭10データを可視化していきたいと思います。
# visualization of data
subtract = 0
lens = []
for d, l in zip(data_x[:10], data_y[:10]):
print(l)
plt.figure(figsize=(10, 10))
G = nx.DiGraph()
connection = d[0]
nodesize = [(i+1)**800 for i in d[1].values()]
edge_weight = d[2]
lens.append(len([i for i in d[1].values()]))
adjacency = Graph(connection).get_adjacency_matrix()
nodes = np.array([str(i+1) for i, _ in enumerate(adjacency)])
edges = []
weight = []
for i, v in edge_weight.items():
ed = [str(st-subtract) for st in list(i)]
ed.append(v+1)
edges.append(tuple(ed))
subtract = max(d[1].keys())
G.add_nodes_from(nodes)
G.add_weighted_edges_from(edges)
pos = nx.kamada_kawai_layout(G)
edge_labels = {(i, j): w['weight'] for i, j, w in G.edges(data=True)}
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
nx.draw_networkx(G, pos, with_labels=True, alpha=0.8)
plt.show()
# これらがMUTAGと呼ばれている変異原性があるのかないのかというデータセットになります。10から30程度のノード数を持ったグラフデータの集まりで、各ノードはある元素を表していて、各リンクは元素間の結合を表しています。各リンクの間についているラベルはその結合がどのような結合なのかということを表しています。ではここの上で量子ウォークを行うと、どのような状態がえられるのかということを見ていきたいと思います。
# 今回のプログラムはこちらの論文を参考としています。[Barr, Katie, Toby Fleming, and Viv Kendon. "Simulation methods for quantum walks on graphs applied to perfect state transfer and formal language recognition." Proceedings of the 2013 workshop on complex systems modelling and simulation, Milan, Italy. 2013.]
# まずは量子ウォーカーが1ステップ進んだ時を考えます。スタートは全て0ノードです。
# +
from qwgc.preprocess.qwalk import QuantumWalk
# 対象のデータ
data = data_x[0]
label = data_y[0]
# 隣接行列
adjacency = Graph(data[0]).get_adjacency_matrix()
count = np.count_nonzero(adjacency)//2
# 量子ウォークのハイパーパラメータ
step = 1
# 次数が2の場合のコインのパラメータ(今回は簡単のために全てアダマールコイン)
coin = np.kron(np.identity(count), 1/np.sqrt(2)*np.array([[1, 1], [1, -1]]))
# 初期状態 (0からスタート)
initial = None
# 量子ウォーカーが測定される確率
qwalk = QuantumWalk(initial, coin, adjacency)
qwalk.n_steps(step)
probs = qwalk.calc_probs()
# 描画
plt.figure(figsize=(10, 10))
G = nx.DiGraph()
# ノードの大きさで確率を表す
connection = data[0]
nodesize = [(i+0.1)*800 for i in probs]
edge_weight = data[2]
nodes = np.array([str(i+1) for i, _ in enumerate(adjacency)])
edges = []
weight = []
for i, v in edge_weight.items():
ed = [str(st) for st in list(i)]
ed.append(v+1)
edges.append(tuple(ed))
subtract = max(data[1].keys())
G.add_nodes_from(nodes)
G.add_weighted_edges_from(edges)
pos = nx.spring_layout(G)
edge_labels = {(i, j): w['weight'] for i, j, w in G.edges(data=True)}
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
nx.draw_networkx(G, pos, with_labels=True, alpha=0.8, node_size=nodesize)
plt.show()
# -
# このように初期のノードから隣り合った二つのノードにおいて量子ウォーカーが観測されうるのがわかるかと思います。
# もう少しステップを進めてみます。
def draw(nodesize):
plt.figure(figsize=(10, 10))
G = nx.DiGraph()
# ノードの大きさで確率を表す
connection = data[0]
nodesize = [(i)*800 for i in probs]
edge_weight = data[2]
nodes = np.array([str(i+1) for i, _ in enumerate(adjacency)])
edges = []
weight = []
for i, v in edge_weight.items():
ed = [str(st) for st in list(i)]
ed.append(v+1)
edges.append(tuple(ed))
subtract = max(data[1].keys())
G.add_nodes_from(nodes)
G.add_weighted_edges_from(edges)
pos = nx.spring_layout(G)
edge_labels = {(i, j): w['weight'] for i, j, w in G.edges(data=True)}
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
nx.draw_networkx(G, pos, with_labels=True, alpha=0.8, node_size=nodesize)
plt.show()
data = data_x[0]
label = data_y[0]
# 隣接行列
adjacency = Graph(data[0]).get_adjacency_matrix()
count = np.count_nonzero(adjacency)//2
# 量子ウォークのハイパーパラメータ
for step in range(1, 10):
# 次数が2の場合のコインのパラメータ(今回は簡単のために全てアダマールコイン)
coin = np.kron(np.identity(count), 1/np.sqrt(2)*np.array([[1, 1], [1, -1]]))
# 初期状態 (0からスタート)
initial = None
# 量子ウォーカーが測定される確率
qwalk = QuantumWalk(initial, coin, adjacency)
qwalk.n_steps(step)
probs = qwalk.calc_probs()
draw(probs)
# やや見辛いですが、少しずつ観測される確率が広がっていっていることがわかると思います。
# # 分類回路
# これらを実際に量子回路に流して分類を行なっていきます。
from qwgc.preprocess.qwfilter import QWfilter
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute, transpile
data = data_x[0]
label = data_y[0]
# filter
u3param = [pi, 0, pi/2]
# step
step = 3
# initial 重ね合わせを初期状態として利用
initial = "super"
qwfilter = QWfilter(u3param, step, initial)
# 今回は測定をせずに、振幅をそのまま量子回路にマッピングを行います。
amplitude = qwfilter.single_amplitude(data)
# これにより特定のステップが終了した後の量子ウォークの確率振幅を取り出すことができました。これをqiskitのinitialize関数というものを用いて量子ビットに情報として入れていきます。またこの時$2^n$の大きさのベクトルである必要があることから0埋めを行います。
la = len(amplitude)
new_amplitude = list(amplitude) + [0 for i in range(64 - 38)]
print(len(new_amplitude))
nq = 6
# 量子レジスタの定義
qr = QuantumRegister(nq, name="quantum walk")
ancilla = QuantumRegister(2, name="ancilla")
# 古典レジスタの定義
cr = ClassicalRegister(2)
# 量子回路の定義
qc = QuantumCircuit(qr, ancilla, cr)
qc.draw(output='mpl')
# このように合計8量子ビットを用意しました。このうち上6つが量子ウォークのデータ（実際の実験ではこの部分が7個になっています。）、下2つが補助の量子ビットになっています。ここに量子ウォーク後の確率振幅を入れていきます。
qc.initialize(new_amplitude, qr)
# そして、パラメータを初期化し、補助量子ビットに制御Ryゲートを用いてマッピングを行なっていきます。
# 回転角を初期化
theta = [np.random.uniform(-pi, pi) for i in range(nq)]
for ith, th in enumerate(theta):
qc.cry(th, qr[ith], ancilla[ith%2])
qc.draw(output="mpl")
# 最後に補助量子ビットを測定します。
qc.measure(ancilla, cr)
# この測定によって、このグラフがどのクラスに分類されるのかということを見ていきます。今回は01をクラス-1、（つまり変異原性の性質が陰性）10をクラスの1(性質が陽性)とします。
backend = Aer.get_backend("qasm_simulator")
shots = 1024
job = execute(qc, backend=backend, shots=shots)
counts = job.result().get_counts(qc)
dinom = counts.get('01', 0) + counts.get('10', 0) + 1e-10
print("クラス-1である確率:", counts.get('01', 0)/dinom, "クラス1である確率:", counts.get('10', 0)/dinom)
if counts.get('01', 0)/dinom > counts.get('10', 0)/dinom:
answer = -1
else:
answer = 1
print("このグラフはクラス ", answer, "です.")
# このような分類結果になります。これを実際のラベルと比較をしてみます。
print("正解は", data_y[1], "です。")
# これらを全てのデータに対して行い、エラーを計算し実際にパラメータのアップデートを行なっていきます。
|
https://github.com/qwqmlf/qwgc
|
qwqmlf
|
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
random_walk = np.random.randn(100000)
random_walk
fig = plt.figure(figsize=(10, 10))
plt.title("random walk", fontsize=20)
plt.xlabel("Position", fontsize=20)
plt.ylabel("Probability", fontsize=20)
plt.hist(random_walk, 1000)
|
https://github.com/qwqmlf/qwgc
|
qwqmlf
|
import numpy as np
import random
import matplotlib.pyplot as plt
from numpy import pi
from tqdm import tqdm, trange
from sklearn.model_selection import KFold
from grakel import datasets
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute
from sklearn import svm
from preprocess.qwfilter import QWfilter
try:
from utils.notification import Notify
notify = True
except Exception:
notify = False
step = 3
THETA_MIN, THETA_MAX = -pi, pi
iteration = 200
backend = Aer.get_backend('qasm_simulator')
shots = 1024
'''
This is just very prototype code
'''
def qw_kernel(train_data, train_label, lam=2):
'''
Input:
train_data: 2dim array (a series of training data)
train_label: 2dim array (a series of label, one hot)
Output:
theta: array
coin_param: ?
'''
ld = len(train_data)
# start training
# to check convergence of error, prepare this list
weights = np.zeros(ld)
print('training start!')
for i in trange(iteration):
it = random.randint(0, ld-1)
decision = 0
for j in range(it):
# FIXME ambiguous error message
try:
decision += weights[j] * train_label[it] * _kernel_function(train_data[it], train_data[j], 7)
except ValueError:
continue
decision *= train_label[it]/lam
if decision < 1:
weights[it] += 1
return weights
def test(x_train, y_train, x_test, y_test, weights):
print('test start!')
errors = 0
for ila, lb_test in tqdm(enumerate(y_test)):
decision = 0
for ilb, lb_train in enumerate(y_train):
decision += weights[ilb]*y_train[ilb]*_kernel_function(x_train[ilb], x_test[ila], 7)
if decision < 0:
prediction = -1
else:
prediction = 1
if prediction != y_test[ila]:
errors += 1
return 1 - errors/len(y_test)
def _kernel_function(x, y, qsize):
# definition of coin
coin_u3s = np.array([pi, 0, pi/2])
ampdata_x = QWfilter(coin_u3s, step, 'super').single_amplitude(x)
x_amp = _zero_fill(ampdata_x, 2**qsize)
q1 = QuantumRegister(qsize)
qc1 = QuantumCircuit(q1, name='QW1')
qc1.initialize(x_amp, q1)
qw1 = qc1.to_instruction()
ampdata_y = QWfilter(coin_u3s, step, 'super').single_amplitude(y)
y_amp = _zero_fill(ampdata_y, 2**qsize)
q2 = QuantumRegister(qsize)
qc2 = QuantumCircuit(q2)
qc2.initialize(y_amp, q2)
qw2 = qc2.to_instruction()
kq = QuantumRegister(qsize)
c = ClassicalRegister(qsize)
kqc = QuantumCircuit(kq, c)
kqc.append(qw1, qargs=kq)
kqc.append(qw2, qargs=kq)
kqc.measure(kq, c)
# calc prob '000...0'
job = execute(kqc, backend=backend, shots=shots)
count = job.result().get_counts(kqc)
return count.get('0'*qsize, 0)/shots
def ceilog(x):
return int(np.ceil(np.log2(x)))
def _zero_fill(x, base, array=True):
# FIXME efficiently
xl = list(x)
x_len = len(xl)
if base - x_len < 0:
raise ValueError('Error')
xs = xl + [0 for _ in range(base-x_len)]
if array:
return np.array(xs)
else:
return xs
if __name__ == '__main__':
data_name = 'MUTAG'
Data = datasets.fetch_dataset(data_name, verbose=False)
data_x, data_y = np.array(Data.data), np.array(Data.target)
k = 5
kf = KFold(n_splits=k, shuffle=True)
accuracy = []
for train_index, test_index in kf.split(data_x):
# preprocessing for generating data.
x_train, y_train = data_x[train_index], data_y[train_index]
x_test, y_test = data_x[test_index], data_y[test_index]
weight = qw_kernel(x_train, y_train)
accs = test(x_train, y_train, x_test, y_test, weight)
print(accs)
if notify:
Notify.notify_accs(accs, 'svm')
accuracy.append(accs)
Notify.notify_accs(accuracy, 'K5 result')
Notify.notify_accs(np.mean(accuracy), 'K5 result mean')
print(accuracy)
print(np.mean(accuracy))
|
https://github.com/qwqmlf/qwgc
|
qwqmlf
|
#!/usr/bin/env python
# coding: utf-8
# In[1]:
import numpy as np
from qiskit import QuantumCircuit
# ## Create Circuit
# In[2]:
def createInputCircuit(data):
qubits_num = len(data)
qcircuit = QuantumCircuit(qubits_num, qubits_num)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
return qcircuit
# In[3]:
def createModelCircuit(params):
qubits_num = len(params[0])
qcircuit = QuantumCircuit(qubits_num, qubits_num)
qubits = qcircuit.qubits
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
for i in range(qubits_num - 1):
qcircuit.cz(qubits[i], qubits[i + 1])
qcircuit.cz(qubits[0], qubits[qubits_num - 1])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
return qcircuit
# In[4]:
def createCircuit(params, data):
input_circuit = createInputCircuit(data)
model_circuit = createModelCircuit(params)
full_circuit = input_circuit.compose(model_circuit)
return full_circuit
# ## Create Noisy Circuit
# In[8]:
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.utils import insert_noise
from qiskit.providers.aer.noise import pauli_error, depolarizing_error
# In[9]:
def createNoiseModel(p, errorType):
# QuantumError objects
if errorType == 'bit_flip':
error = pauli_error([('X', p), ('I', 1 - p)])
elif errorType == 'phase_flip':
error = pauli_error([('Z', p), ('I', 1 - p)])
elif errorType == 'depolarizing':
error = depolarizing_error(p, num_qubits=1)
## two-qubits quantumError objects
if errorType == 'depolarizing':
error_2qubits = depolarizing_error(p, num_qubits=2)
else:
error_2qubits = error.tensor(error)
# Add errors to noise model
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ['u3'])
noise_model.add_all_qubit_quantum_error(error_2qubits, ['cz'])
return noise_model
# In[10]:
def createNoisyModelCircuit(params, p, errorType):
noise_model = createNoiseModel(p, errorType)
model_circuit = createModelCircuit(params)
return insert_noise(model_circuit, noise_model)
# In[12]:
|
https://github.com/ubsuny/QiskitNature_EnergyLevels
|
ubsuny
|
import sys, time
sys.path.append("../")
import Qconfig
qx_config = {
"APItoken": Qconfig.APItoken,
"url": Qconfig.config['url']}
print('Qconfig loaded from %s.' % Qconfig.__file__)
# Imports
import qiskit as qk
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import available_backends, execute, register, least_busy
from qiskit.tools.visualization import plot_histogram
from qiskit import IBMQ
from qiskit import Aer
from math import pi
print(qk.__version__)
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr,cr)
# circuit construction
# preparing the wavefunction
qc.h(qr[0])
qc.barrier()
qc.cx(qr[0], qr[1])
qc.barrier()
qc.u3(1.2309,0,0,qr[0])
qc.barrier()
# if we apply phase shift gate
qc.u1((2.0/3)*pi,qr[0])
qc.u1((2.0/3)*pi,qr[1])
qc.barrier()
# rotating the axis for measurement
#qc.cx(qr[0],qr[1]) # THE IMPLEMENTATION PROVIDED BY THE AUTHORS SKIPS THIS CNOT APPLICATION!!! it shouldn't be
# it shouldn't be there. Improves accuracy
#qc.barrier()
qc.u3(2.1862,6.5449,pi,qr[0])
qc.u3(0.9553,2*pi,pi,qr[1])
qc.barrier()
qc.measure(qr,cr)
# Running locally IBM backends respond too slowly
print(Aer.backends())
backend = Aer.get_backend('qasm_simulator')
job = execute(qc,backend)
job.status
result = job.result()
counts = result.get_counts(qc)
print(counts)
plot_histogram(counts)
performance = {
'success':(counts['01']+counts['10'])/1024,
'failure':1 - (counts['01']+counts['10'])/1024
}
plot_histogram(performance)
IBMQ.load_accounts()
# checking the backends
large_enough_devices = IBMQ.backends(filters=lambda x: x.configuration()['n_qubits'] > 1 and not x.configuration()['simulator'])
print(large_enough_devices)
backend = IBMQ.get_backend('ibmqx4')
job = execute(qc,backend,max_credits=3)
job.status
result = job.result()
counts = result.get_counts(qc)
print(counts)
plot_histogram(counts)
performance = {
'success':(counts['01']+counts['10'])/1024,
'failure':(counts['00']+counts['11'])/1024
}
plot_histogram(performance)
sqr = QuantumRegister(1)
scr = ClassicalRegister(1)
sqc = QuantumCircuit(sqr,scr)
# constructing the circuit
sqc.u3(1.1503,6.4850,2.2555,sqr[0])
sqc.barrier()
# unidentified gate -- now assumed to be R2pi3. if identity then use qc.u1(0,q[0])
sqc.u1((2.0/3)*pi,sqr[0])
sqc.barrier()
sqc.u3(1.231,0,0,sqr[0]) # X
sqc.barrier()
sqc.u1((2.0/3)*pi,sqr[0]) # U (unidentified gate)
sqc.barrier()
# measurement
sqc.u3(0.7854,6.0214,6.1913,sqr[0])
sqc.barrier()
sqc.measure(sqr,scr)
# Running on local simulator
backend = Aer.get_backend('qasm_simulator')
job = execute(sqc,backend)
result = job.result()
counts = result.get_counts(sqc)
print(counts)
plot_histogram(counts)
# Running on IBM
backend = IBMQ.get_backend('ibmqx4')
job = execute(sqc,backend,max_credits=3)
result = job.result()
counts = result.get_counts(sqc)
print(counts)
plot_histogram(counts)
|
https://github.com/quantastica/quantum-circuit
|
quantastica
|
from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram, plot_state_qsphere
# We create a quantum circuit with 2 qubits and 2 classical bits
qc1 = QuantumCircuit(2, 2)
# We apply the Hadamard gate to the first qubit
qc1.h(0)
# We apply the CNOT gate to the first and second qubits
qc1.cx(0, 1)
# We draw the circuit
qc1.draw(output='mpl')
# We execute the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')
result = execute(qc1, backend).result()
statevector = result.get_statevector()
# We plot the results
plot_state_qsphere(statevector)
# We create a quantum circuit with 2 qubits and 2 classical bits
qc2 = QuantumCircuit(2, 2)
# We initialize the input state to |01>
qc2.x(0)
qc2.barrier()
# We apply the Hadamard gate to the first qubit
qc2.h(0)
# We apply the CNOT gate to the first and second qubits
qc2.cx(0, 1)
qc2.barrier()
# We draw the circuit
qc2.draw(output='mpl')
# We execute the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')
result = execute(qc2, backend).result()
statevector = result.get_statevector()
# We plot the results
plot_state_qsphere(statevector)
# We create a quantum circuit with 2 qubits and 2 classical bits
qc3 = QuantumCircuit(2, 2)
# We initialize the input state to |10>
qc3.x(1)
qc3.barrier()
# We apply the Hadamard gate to the first qubit
qc3.h(0)
# We apply the CNOT gate to the first and second qubits
qc3.cx(0, 1)
qc3.barrier()
# We draw the circuit
qc3.draw(output='mpl')
# We execute the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')
result = execute(qc3, backend).result()
statevector = result.get_statevector()
# We plot the results
plot_state_qsphere(statevector)
# We create a quantum circuit with 2 qubits and 2 classical bits
qc4 = QuantumCircuit(2, 2)
# We initialize the input state to |11>
qc4.x(0)
qc4.x(1)
qc4.barrier()
# We apply the Hadamard gate to the first qubit
qc4.h(0)
# We apply the CNOT gate to the first and second qubits
qc4.cx(0, 1)
qc4.barrier()
# We draw the circuit
qc4.draw(output='mpl')
# We execute the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')
result = execute(qc4, backend).result()
statevector = result.get_statevector()
# We plot the results
plot_state_qsphere(statevector)
|
https://github.com/quantastica/quantum-circuit
|
quantastica
|
operation ExportedQsharpCode() : Result {
using(q_reg = Qubit[3]) {
X(q_reg[0]);
X(q_reg[1]);
X(q_reg[2]);
CCNOT(q_reg[0], q_reg[1], q_reg[2]);
let r = M(q_reg[2]);
ResetAll(q_reg);
return r;
}
}
%simulate ExportedQsharpCode
|
https://github.com/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
################################################################################
# © Copyright 2021-2022 Zapata Computing Inc.
################################################################################
import hashlib
from typing import Dict, Iterable, List, NamedTuple, Sequence, Tuple, Union
import numpy as np
import qiskit
import sympy
from orquestra.quantum.circuits import (
_builtin_gates,
_circuit,
_gates,
_operations,
_wavefunction_operations,
)
from orquestra.quantum.circuits.symbolic.sympy_expressions import (
SYMPY_DIALECT,
expression_from_sympy,
)
from orquestra.quantum.circuits.symbolic.translations import translate_expression
from ._qiskit_expressions import QISKIT_DIALECT, expression_from_qiskit
QiskitTriplet = Tuple[
qiskit.circuit.Instruction, List[qiskit.circuit.Qubit], List[qiskit.circuit.Clbit]
]
def _import_qiskit_qubit(qubit: qiskit.circuit.Qubit) -> int:
return qubit._index
def _qiskit_expr_from_orquestra(expr):
intermediate = expression_from_sympy(expr)
return translate_expression(intermediate, QISKIT_DIALECT)
def _orquestra_expr_from_qiskit(expr):
intermediate = expression_from_qiskit(expr)
return translate_expression(intermediate, SYMPY_DIALECT)
ORQUESTRA_QISKIT_GATE_MAP = {
_builtin_gates.X: qiskit.circuit.library.XGate,
_builtin_gates.Y: qiskit.circuit.library.YGate,
_builtin_gates.Z: qiskit.circuit.library.ZGate,
_builtin_gates.S: qiskit.circuit.library.SGate,
_builtin_gates.SX: qiskit.circuit.library.SXGate,
_builtin_gates.T: qiskit.circuit.library.TGate,
_builtin_gates.H: qiskit.circuit.library.HGate,
_builtin_gates.I: qiskit.circuit.library.IGate,
_builtin_gates.CNOT: qiskit.circuit.library.CXGate,
_builtin_gates.CZ: qiskit.circuit.library.CZGate,
_builtin_gates.SWAP: qiskit.circuit.library.SwapGate,
_builtin_gates.ISWAP: qiskit.circuit.library.iSwapGate,
_builtin_gates.RX: qiskit.circuit.library.RXGate,
_builtin_gates.RY: qiskit.circuit.library.RYGate,
_builtin_gates.RZ: qiskit.circuit.library.RZGate,
_builtin_gates.PHASE: qiskit.circuit.library.PhaseGate,
_builtin_gates.CPHASE: qiskit.circuit.library.CPhaseGate,
_builtin_gates.XX: qiskit.circuit.library.RXXGate,
_builtin_gates.YY: qiskit.circuit.library.RYYGate,
_builtin_gates.ZZ: qiskit.circuit.library.RZZGate,
_builtin_gates.U3: qiskit.circuit.library.U3Gate,
_builtin_gates.Delay: qiskit.circuit.Delay,
}
def _make_gate_instance(gate_ref, gate_params) -> _gates.Gate:
"""Returns a gate instance that's applicable to qubits.
For non-parametric gate refs like X, returns just the `X`
For parametric gate factories like `RX`, returns the produced gate, like `RX(0.2)`
"""
if _gates.gate_is_parametric(gate_ref, gate_params):
return gate_ref(*gate_params)
else:
return gate_ref
def _make_controlled_gate_prototype(wrapped_gate_ref, num_control_qubits=1):
def _factory(*gate_params):
return _gates.ControlledGate(
_make_gate_instance(wrapped_gate_ref, gate_params), num_control_qubits
)
return _factory
QISKIT_ORQUESTRA_GATE_MAP = {
**{q_cls: z_ref for z_ref, q_cls in ORQUESTRA_QISKIT_GATE_MAP.items()},
qiskit.extensions.SXdgGate: _builtin_gates.SX.dagger,
qiskit.extensions.SdgGate: _builtin_gates.S.dagger,
qiskit.extensions.TdgGate: _builtin_gates.T.dagger,
qiskit.circuit.library.CSwapGate: _builtin_gates.SWAP.controlled(1),
qiskit.circuit.library.CRXGate: _make_controlled_gate_prototype(_builtin_gates.RX),
qiskit.circuit.library.CRYGate: _make_controlled_gate_prototype(_builtin_gates.RY),
qiskit.circuit.library.CRZGate: _make_controlled_gate_prototype(_builtin_gates.RZ),
}
def export_to_qiskit(circuit: _circuit.Circuit) -> qiskit.QuantumCircuit:
q_circuit = qiskit.QuantumCircuit(circuit.n_qubits)
q_register = qiskit.circuit.QuantumRegister(circuit.n_qubits, "q")
gate_op_only_circuit = _circuit.Circuit(
[op for op in circuit.operations if isinstance(op, _gates.GateOperation)]
)
custom_names = {
gate_def.gate_name
for gate_def in gate_op_only_circuit.collect_custom_gate_definitions()
}
q_triplets = []
for gate_op in circuit.operations:
if isinstance(gate_op, _gates.GateOperation):
q_triplet = _export_gate_to_qiskit(
gate_op.gate,
applied_qubit_indices=gate_op.qubit_indices,
q_register=q_register,
custom_names=custom_names,
)
elif isinstance(gate_op, _wavefunction_operations.ResetOperation):
q_triplet = (
qiskit.circuit.library.Reset(),
[q_register[gate_op.qubit_indices[0]]],
[],
)
q_triplets.append(q_triplet)
for q_gate, q_qubits, q_clbits in q_triplets:
q_circuit.append(q_gate, q_qubits, q_clbits)
return q_circuit
def _export_gate_to_qiskit(gate, applied_qubit_indices, q_register, custom_names):
try:
return _export_gate_via_mapping(
gate, applied_qubit_indices, q_register, custom_names
)
except ValueError:
pass
try:
return _export_dagger_gate(
gate, applied_qubit_indices, q_register, custom_names
)
except ValueError:
pass
try:
return _export_controlled_gate(
gate, applied_qubit_indices, q_register, custom_names
)
except ValueError:
pass
try:
return _export_custom_gate(
gate, applied_qubit_indices, q_register, custom_names
)
except ValueError:
pass
raise NotImplementedError(f"Exporting gate {gate} to Qiskit is unsupported")
def _export_gate_via_mapping(gate, applied_qubit_indices, q_register, custom_names):
try:
qiskit_cls = ORQUESTRA_QISKIT_GATE_MAP[
_builtin_gates.builtin_gate_by_name(gate.name)
]
except KeyError:
raise ValueError(f"Can't export gate {gate} to Qiskit via mapping")
qiskit_params = [_qiskit_expr_from_orquestra(param) for param in gate.params]
qiskit_qubits = [q_register[index] for index in applied_qubit_indices]
return qiskit_cls(*qiskit_params), qiskit_qubits, []
def _export_dagger_gate(
gate: _gates.Dagger,
applied_qubit_indices,
q_register,
custom_names,
):
if not isinstance(gate, _gates.Dagger):
# Raising an exception here is redundant to the type hint, but it allows us
# to handle exporting all gates in the same way, regardless of type
raise ValueError(f"Can't export gate {gate} as a dagger gate")
target_gate, qiskit_qubits, qiskit_clbits = _export_gate_to_qiskit(
gate.wrapped_gate,
applied_qubit_indices=applied_qubit_indices,
q_register=q_register,
custom_names=custom_names,
)
return target_gate.inverse(), qiskit_qubits, qiskit_clbits
def _export_controlled_gate(
gate: _gates.ControlledGate,
applied_qubit_indices,
q_register,
custom_names,
):
if not isinstance(gate, _gates.ControlledGate):
# Raising an exception here is redundant to the type hint, but it allows us
# to handle exporting all gates in the same way, regardless of type
raise ValueError(f"Can't export gate {gate} as a controlled gate")
target_indices = applied_qubit_indices[gate.num_control_qubits :]
target_gate, _, _ = _export_gate_to_qiskit(
gate.wrapped_gate,
applied_qubit_indices=target_indices,
q_register=q_register,
custom_names=custom_names,
)
controlled_gate = target_gate.control(gate.num_control_qubits)
qiskit_qubits = [q_register[index] for index in applied_qubit_indices]
return controlled_gate, qiskit_qubits, []
def _export_custom_gate(
gate: _gates.MatrixFactoryGate,
applied_qubit_indices,
q_register,
custom_names,
):
if gate.name not in custom_names:
raise ValueError(
f"Can't export gate {gate} as a custom gate, the circuit is missing its "
"definition"
)
if gate.params:
raise ValueError(
f"Can't export parametrized gate {gate}, Qiskit doesn't support "
"parametrized custom gates"
)
# At that time of writing it Qiskit doesn't support parametrized gates defined with
# a symbolic matrix.
# See https://github.com/Qiskit/qiskit-terra/issues/4751 for more info.
qiskit_qubits = [q_register[index] for index in applied_qubit_indices]
qiskit_matrix = np.array(gate.matrix)
return (
qiskit.extensions.UnitaryGate(qiskit_matrix, label=gate.name),
qiskit_qubits,
[],
)
class AnonGateOperation(NamedTuple):
gate_name: str
matrix: sympy.Matrix
qubit_indices: Tuple[int, ...]
ImportedOperation = Union[_operations.Operation, AnonGateOperation]
def _apply_custom_gate(
anon_op: AnonGateOperation, custom_defs_map: Dict[str, _gates.CustomGateDefinition]
) -> _gates.GateOperation:
gate_def = custom_defs_map[anon_op.gate_name]
# Qiskit doesn't support custom gates with parametrized matrices
# so we can assume empty params list.
gate_params: Tuple[sympy.Symbol, ...] = tuple()
gate = gate_def(*gate_params)
return gate(*anon_op.qubit_indices)
def import_from_qiskit(circuit: qiskit.QuantumCircuit) -> _circuit.Circuit:
q_ops = [_import_qiskit_triplet(triplet) for triplet in circuit.data]
anon_ops = [op for op in q_ops if isinstance(op, AnonGateOperation)]
# Qiskit doesn't support custom gates with parametrized matrices
# so we can assume empty params list.
params_ordering: Tuple[sympy.Symbol, ...] = tuple()
custom_defs = {
anon_op.gate_name: _gates.CustomGateDefinition(
gate_name=anon_op.gate_name,
matrix=anon_op.matrix,
params_ordering=params_ordering,
)
for anon_op in anon_ops
}
imported_ops = [
_apply_custom_gate(op, custom_defs) if isinstance(op, AnonGateOperation) else op
for op in q_ops
]
return _circuit.Circuit(
operations=imported_ops,
n_qubits=circuit.num_qubits,
)
def _import_qiskit_triplet(qiskit_triplet: QiskitTriplet) -> ImportedOperation:
qiskit_op, qiskit_qubits, _ = qiskit_triplet
return _import_qiskit_op(qiskit_op, qiskit_qubits)
def _import_qiskit_op(qiskit_op, qiskit_qubits) -> ImportedOperation:
# We always wanna try importing via mapping to handle complex gate structures
# represented by a single class, like CNOT (Control + X) or CSwap (Control + Swap).
try:
return _import_qiskit_op_via_mapping(qiskit_op, qiskit_qubits)
except ValueError:
pass
try:
return _import_controlled_qiskit_op(qiskit_op, qiskit_qubits)
except ValueError:
pass
try:
return _import_custom_qiskit_gate(qiskit_op, qiskit_qubits)
except AttributeError:
raise ValueError(f"Conversion of {qiskit_op.name} from Qiskit is unsupported.")
def _import_qiskit_op_via_mapping(
qiskit_gate: qiskit.circuit.Instruction,
qiskit_qubits: Iterable[qiskit.circuit.Qubit],
) -> _operations.Operation:
qubit_indices = [_import_qiskit_qubit(qubit) for qubit in qiskit_qubits]
if isinstance(qiskit_gate, qiskit.circuit.library.Reset):
return _wavefunction_operations.ResetOperation(qubit_indices[0])
try:
gate_ref = QISKIT_ORQUESTRA_GATE_MAP[type(qiskit_gate)]
except KeyError:
raise ValueError(f"Conversion of {qiskit_gate} from Qiskit is unsupported.")
# values to consider:
# - gate matrix parameters (only parametric gates)
# - gate application indices (all gates)
orquestra_params = [
_orquestra_expr_from_qiskit(param) for param in qiskit_gate.params
]
gate = _make_gate_instance(gate_ref, orquestra_params)
return _gates.GateOperation(gate=gate, qubit_indices=tuple(qubit_indices))
def _import_controlled_qiskit_op(
qiskit_gate: qiskit.circuit.ControlledGate,
qiskit_qubits: Sequence[qiskit.circuit.Qubit],
) -> _gates.GateOperation:
if not isinstance(qiskit_gate, qiskit.circuit.ControlledGate):
# Raising an exception here is redundant to the type hint, but it allows us
# to handle exporting all gates in the same way, regardless of type
raise ValueError(f"Can't import gate {qiskit_gate} as a controlled gate")
wrapped_qubits = qiskit_qubits[qiskit_gate.num_ctrl_qubits :]
wrapped_op = _import_qiskit_op(qiskit_gate.base_gate, wrapped_qubits)
qubit_indices = map(_import_qiskit_qubit, qiskit_qubits)
if isinstance(wrapped_op, _gates.GateOperation):
return wrapped_op.gate.controlled(qiskit_gate.num_ctrl_qubits)(*qubit_indices)
else:
raise NotImplementedError(
"Importing of controlled anonymous gates not yet supported."
)
def _hash_hex(bytes_):
return hashlib.sha256(bytes_).hexdigest()
def _custom_qiskit_gate_name(gate_label: str, gate_name: str, matrix: np.ndarray):
matrix_hash = _hash_hex(matrix.tobytes())
target_name = gate_label or gate_name
return f"{target_name}.{matrix_hash}"
def _import_custom_qiskit_gate(
qiskit_op: qiskit.circuit.Gate, qiskit_qubits: Iterable[qiskit.circuit.Qubit]
) -> AnonGateOperation:
value_matrix = qiskit_op.to_matrix()
return AnonGateOperation(
gate_name=_custom_qiskit_gate_name(
qiskit_op.label, qiskit_op.name, value_matrix
),
matrix=sympy.Matrix(value_matrix),
qubit_indices=tuple(_import_qiskit_qubit(qubit) for qubit in qiskit_qubits),
)
|
https://github.com/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
################################################################################
# © Copyright 2021-2022 Zapata Computing Inc.
################################################################################
"""Translations between Qiskit parameter expressions and intermediate expression trees.
"""
import operator
from functools import lru_cache, reduce, singledispatch
from numbers import Number
import qiskit
from orquestra.quantum.circuits.symbolic.expressions import ExpressionDialect, reduction
from orquestra.quantum.circuits.symbolic.sympy_expressions import expression_from_sympy
from ._symengine_expressions import expression_from_symengine
@singledispatch
def expression_from_qiskit(expression):
"""Parse Qiskit expression into intermediate expression tree."""
raise NotImplementedError(
f"Expression {expression} of type {type(expression)} is currently not supported"
)
@expression_from_qiskit.register
def _number_identity(number: Number):
return number
@expression_from_qiskit.register
def _expr_from_qiskit_param_expr(
qiskit_expr: qiskit.circuit.parameterexpression.ParameterExpression,
):
# At the moment of writing this the qiskit version that we use (0.23.2) as well
# as the newest version 0.23.5) does not provide a better way to access symbolic
# expression wrapped by ParameterExpression.
inner_expr = qiskit_expr._symbol_expr
try:
return expression_from_symengine(inner_expr)
except NotImplementedError:
return expression_from_sympy(inner_expr)
def integer_pow(base, exponent: int):
"""Exponentiation to the power of an integer exponent."""
if not isinstance(exponent, int):
raise ValueError(
f"Cannot convert expression {base} ** {exponent} to Qiskit. "
"Only powers with integral exponent are convertible."
)
if exponent < 0:
if base != 0:
base = 1 / base
exponent = -exponent
else:
raise ValueError(
f"Invalid power: cannot raise 0 to exponent {exponent} < 0."
)
return reduce(operator.mul, exponent * [base], 1)
@lru_cache(maxsize=None)
def _qiskit_param_from_name(name):
return qiskit.circuit.Parameter(name)
QISKIT_DIALECT = ExpressionDialect(
symbol_factory=lambda symbol: _qiskit_param_from_name(symbol.name),
number_factory=lambda number: number,
known_functions={
"add": reduction(operator.add),
"mul": reduction(operator.mul),
"div": operator.truediv,
"sub": operator.sub,
"pow": integer_pow,
},
)
"""Mapping from the intermediate expression tree into Qiskit symbolic expression atoms.
Allows translating an expression into the Qiskit dialect. Can be used with
`orquestra.quantum.circuits.symbolic.translations.translate_expression`.
"""
|
https://github.com/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
# -*- 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/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
################################################################################
# © Copyright 2020-2022 Zapata Computing Inc.
################################################################################
from typing import Dict, Optional, Tuple
import numpy as np
import qiskit.providers.aer.noise as AerNoise
from qiskit.providers.aer.noise import (
NoiseModel,
amplitude_damping_error,
pauli_error,
phase_amplitude_damping_error,
phase_damping_error,
)
from qiskit.quantum_info import Kraus
from qiskit.transpiler import CouplingMap
from .._get_provider import get_provider
def get_qiskit_noise_model(
device_name: str,
hub: str = "ibm-q",
group: str = "open",
project: str = "main",
api_token: Optional[str] = None,
) -> Tuple[NoiseModel, list]:
"""Get a qiskit noise model to use noisy simulations with a qiskit simulator
Args:
device_name: The name of the device trying to be emulated
hub: The ibmq hub (see qiskit documentation)
group: The ibmq group (see qiskit documentation)
project: The ibmq project (see qiskit documentation)
api_token: The ibmq api token (see qiskit documentation)
"""
# Get qiskit noise model from qiskit
provider = get_provider(api_token=api_token, hub=hub, group=group, project=project)
noisy_device = provider.get_backend(device_name)
noise_model = AerNoise.NoiseModel.from_backend(noisy_device)
return noise_model, noisy_device.configuration().coupling_map
def create_amplitude_damping_noise(T_1: float, t_step: float = 10e-9) -> NoiseModel:
"""Creates an amplitude damping noise model
Args:
T_1: Relaxation time (seconds)
t_step: Discretized time step over which the relaxation occurs over (seconds)
"""
gamma = 1 - pow(np.e, -1 / T_1 * t_step)
error = amplitude_damping_error(gamma)
gate_error = error.tensor(error)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ["id", "u3"])
noise_model.add_all_qubit_quantum_error(gate_error, ["cx"])
return noise_model
def create_phase_damping_noise(T_2: float, t_step: float = 10e-9) -> NoiseModel:
"""Creates a dephasing noise model
Args:
T_2: dephasing time (seconds)
t_step: Discretized time step over which the relaxation occurs over (seconds)
"""
gamma = 1 - pow(np.e, -1 / T_2 * t_step)
error = phase_damping_error(gamma)
gate_error = error.tensor(error)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ["id", "u3"])
noise_model.add_all_qubit_quantum_error(gate_error, ["cx"])
return noise_model
def create_phase_and_amplitude_damping_error(
T_1: float, T_2: float, t_step: float = 10e-9
) -> NoiseModel:
"""Creates a noise model that does both phase and amplitude damping
Args:
T_1: Relaxation time (seconds)
T_2: dephasing time (seonds)
t_step: Discretized time step over which the relaxation occurs over (seconds)
"""
param_amp = 1 - pow(np.e, -1 / T_1 * t_step)
param_phase = 1 - pow(np.e, -1 / T_2 * t_step)
error = phase_amplitude_damping_error(param_amp, param_phase)
gate_error = error.tensor(error)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ["id", "u3"])
noise_model.add_all_qubit_quantum_error(gate_error, ["cx"])
return noise_model
def create_pta_channel(T_1: float, T_2: float, t_step: float = 10e-9) -> NoiseModel:
"""Creates a noise model that does both phase and amplitude damping but in the
Pauli Twirling Approximation discussed the following reference
https://arxiv.org/pdf/1305.2021.pdf
Args:
T_1: Relaxation time (seconds)
T_2: dephasing time (seconds)
t_step: Discretized time step over which the relaxation occurs over (seconds)
"""
p_x = 0.25 * (1 - pow(np.e, -t_step / T_1))
p_y = 0.25 * (1 - pow(np.e, -t_step / T_1))
exp_1 = pow(np.e, -t_step / (2 * T_1))
exp_2 = pow(np.e, -t_step / T_2)
p_z = 0.5 - p_x - 0.5 * exp_1 * exp_2
p_i = 1 - p_x - p_y - p_z
errors = [("X", p_x), ("Y", p_y), ("Z", p_z), ("I", p_i)]
pta_error = pauli_error(errors)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(pta_error, ["id", "u3"])
gate_error = pta_error.tensor(pta_error)
noise_model.add_all_qubit_quantum_error(gate_error, ["cx"])
return noise_model
def get_kraus_matrices_from_ibm_noise_model(noise_model: NoiseModel) -> Dict:
"""Gets the kraus operators from a pre defined noise model
Args:
noise_model: Noise model for circuit
Return
dict_of_kraus_operators: A dictionary labelled by keys which are
the basis gates and values are the list of kraus operators
"""
retrieved_quantum_error_dict = noise_model._default_quantum_errors
dict_of_kraus_operators = {
gate: Kraus(retrieved_quantum_error_dict[gate]).data
for gate in retrieved_quantum_error_dict
}
return dict_of_kraus_operators
|
https://github.com/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
import sys
import time
from typing import List, Optional
from qiskit import execute
from qiskit_aer.noise import NoiseModel
from qiskit_ibm_provider import IBMBackendApiError
from .._get_provider import get_provider
from ._qiskit_runner import QiskitRunner
def _execute_on_ibmq_with_retries(
retry_delay_seconds: int, retry_timeout_seconds: int = sys.maxsize
):
def _execute(*args, **kwargs):
start_time = time.time()
while (elapsed_seconds := (time.time() - start_time)) < retry_timeout_seconds:
try:
return execute(*args, **kwargs)
except IBMBackendApiError as e:
# 3458 is the error code for too many jobs
# https://docs.quantum-computing.ibm.com/errors
if '"code":3458' not in str(e):
raise RuntimeError(e) from e
print(f"Job limit reached. Retrying in {retry_delay_seconds}s.")
time.sleep(retry_delay_seconds)
raise RuntimeError(
f"Failed to submit job in {elapsed_seconds}s due to backend job " "limit."
)
return _execute
def create_ibmq_runner(
api_token: str,
backend_name: str,
hub: str = "ibm-q",
group: str = "open",
project: str = "main",
noise_model: Optional[NoiseModel] = None,
basis_gates: Optional[List[str]] = None,
optimization_level: int = 0,
seed: Optional[int] = None,
retry_delay_seconds: int = 60,
retry_timeout_seconds: int = 24 * 60 * 60, # default timeout of one day
discard_extra_measurements=False,
):
provider = get_provider(api_token=api_token, hub=hub, group=group, project=project)
backend = provider.get_backend(name=backend_name)
return QiskitRunner(
backend,
noise_model=noise_model,
basis_gates=basis_gates,
optimization_level=optimization_level,
seed=seed,
execute_function=_execute_on_ibmq_with_retries(
retry_delay_seconds, retry_timeout_seconds
),
discard_extra_measurements=discard_extra_measurements,
)
|
https://github.com/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
from typing import List, Optional, Sequence, Union
from orquestra.quantum.api import BaseCircuitRunner
from orquestra.quantum.circuits import (
Circuit,
combine_bitstrings,
expand_sample_sizes,
split_into_batches,
)
from orquestra.quantum.measurements import Measurements
from qiskit import ClassicalRegister, QuantumCircuit, execute
from qiskit.providers import BackendV1, BackendV2
from qiskit.transpiler import CouplingMap
from qiskit_aer.noise import NoiseModel
from orquestra.integrations.qiskit.conversions import export_to_qiskit
AnyQiskitBackend = Union[BackendV1, BackendV2]
def prepare_for_running_on_backend(circuit: Circuit) -> QuantumCircuit:
qiskit_circuit = export_to_qiskit(circuit)
qiskit_circuit.add_register(ClassicalRegister(size=qiskit_circuit.num_qubits))
qiskit_circuit.measure(qiskit_circuit.qubits, qiskit_circuit.clbits)
return qiskit_circuit
def _listify(counts):
return counts if isinstance(counts, list) else [counts]
class QiskitRunner(BaseCircuitRunner):
def __init__(
self,
qiskit_backend: AnyQiskitBackend,
noise_model: Optional[NoiseModel] = None,
coupling_map: Optional[CouplingMap] = None,
basis_gates: Optional[List[str]] = None,
optimization_level: int = 0,
seed: Optional[int] = None,
discard_extra_measurements: bool = False,
execute_function=execute,
):
super().__init__()
self.backend = qiskit_backend
self.seed = seed
self.backend = qiskit_backend
self.noise_model = noise_model
self.optimization_level = optimization_level
self.basis_gates = (
noise_model.basis_gates
if basis_gates is None and noise_model is not None
else basis_gates
)
self.coupling_map = coupling_map
self._execute = execute_function
self.discard_extra_measurements = discard_extra_measurements
def _run_and_measure(self, circuit: Circuit, n_samples: int) -> Measurements:
return self._run_batch_and_measure([circuit], [n_samples])[0]
def _run_batch_and_measure(
self, batch: Sequence[Circuit], samples_per_circuit: Sequence[int]
):
circuits_to_execute = [
prepare_for_running_on_backend(circuit) for circuit in batch
]
new_circuits, new_n_samples, multiplicities = expand_sample_sizes(
circuits_to_execute,
samples_per_circuit,
self.backend.configuration().max_shots,
)
batch_size = getattr(
self.backend.configuration(), "max_experiments", len(circuits_to_execute)
)
batches = split_into_batches(new_circuits, new_n_samples, batch_size)
jobs = [
self._execute(
list(circuits),
backend=self.backend,
shots=n_samples,
noise_model=self.noise_model,
coupling_map=self.coupling_map,
basis_gates=self.basis_gates,
optimization_level=self.optimization_level,
seed_simulator=self.seed,
seed_transpiler=self.seed,
memory=True,
)
for circuits, n_samples in batches
]
# Qiskit runners return single dictionary with counts when there was
# only one experiment. To simplify logic, we make sure to always have a
# list of counts from a job.
# One can use job.result().get_counts() to get all counts, but
# job.result().get_memory() does require index of the experiment
# This is why the below list comprehension looks so clumsy.
all_bitstrings = [
job.result().get_memory(i)
for job in jobs
for i in range(len(job.result().results))
]
combined_bitstrings = combine_bitstrings(all_bitstrings, multiplicities)
if self.discard_extra_measurements:
combined_bitstrings = [
bitstrings[:n_samples]
for bitstrings, n_samples in zip(
combined_bitstrings, samples_per_circuit
)
]
return [
Measurements([tuple(map(int, b[::-1])) for b in bitstrings])
for bitstrings in combined_bitstrings
]
|
https://github.com/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
################################################################################
# © Copyright 2022 Zapata Computing Inc.
################################################################################
from typing import List, Optional
import numpy as np
from orquestra.quantum.api.wavefunction_simulator import BaseWavefunctionSimulator
from orquestra.quantum.circuits import Circuit
from orquestra.quantum.circuits.layouts import CircuitConnectivity
from orquestra.quantum.typing import StateVector
from orquestra.quantum.wavefunction import flip_amplitudes
from qiskit import QuantumCircuit, execute
from qiskit.transpiler import CouplingMap
from qiskit_aer.noise import NoiseModel
from orquestra.integrations.qiskit.conversions import export_to_qiskit
from orquestra.integrations.qiskit.runner._qiskit_runner import AnyQiskitBackend
class QiskitWavefunctionSimulator(BaseWavefunctionSimulator):
"""Wavefunction simulator using Qiskit backends.
Note that this simulator only works with backends that supports save_state
instruction.
"""
def __init__(
self,
qiskit_backend: AnyQiskitBackend,
noise_model: Optional[NoiseModel] = None,
device_connectivity: Optional[CircuitConnectivity] = None,
basis_gates: Optional[List[str]] = None,
optimization_level: int = 0,
seed: Optional[int] = None,
):
super().__init__()
self.seed = seed
self.backend = qiskit_backend
self.noise_model = noise_model
self.optimization_level = optimization_level
self.basis_gates = (
noise_model.basis_gates
if basis_gates is None and noise_model is not None
else basis_gates
)
self.device_connectivity = device_connectivity
def _get_wavefunction_from_native_circuit(
self, circuit: Circuit, initial_state: StateVector
):
qiskit_circuit = export_to_qiskit(circuit)
if not np.array_equal(initial_state, [1] + [0] * (2**circuit.n_qubits - 1)):
state_prep_circuit = QuantumCircuit(circuit.n_qubits)
state_prep_circuit.initialize(flip_amplitudes(initial_state))
qiskit_circuit = state_prep_circuit.compose(qiskit_circuit)
qiskit_circuit.save_state()
coupling_map = (
None
if self.device_connectivity is None
else CouplingMap(self.device_connectivity.connectivity)
)
job = execute(
qiskit_circuit,
self.backend,
noise_model=self.noise_model,
coupling_map=coupling_map,
basis_gates=self.basis_gates,
optimization_level=self.optimization_level,
seed_simulator=self.seed,
seed_transpiler=self.seed,
)
return flip_amplitudes(
job.result().get_statevector(qiskit_circuit, decimals=20).data
)
|
https://github.com/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
################################################################################
# © Copyright 2021-2022 Zapata Computing Inc.
################################################################################
import numpy as np
import pytest
import qiskit
import qiskit.circuit.random
import sympy
from orquestra.quantum.circuits import (
_builtin_gates,
_circuit,
_gates,
_wavefunction_operations,
)
from orquestra.integrations.qiskit.conversions import (
export_to_qiskit,
import_from_qiskit,
)
# --------- gates ---------
EQUIVALENT_NON_PARAMETRIC_GATES = [
(_builtin_gates.X, qiskit.circuit.library.XGate()),
(_builtin_gates.Y, qiskit.circuit.library.YGate()),
(_builtin_gates.Z, qiskit.circuit.library.ZGate()),
(_builtin_gates.H, qiskit.circuit.library.HGate()),
(_builtin_gates.I, qiskit.circuit.library.IGate()),
(_builtin_gates.S, qiskit.circuit.library.SGate()),
(_builtin_gates.SX, qiskit.circuit.library.SXGate()),
(_builtin_gates.T, qiskit.circuit.library.TGate()),
(_builtin_gates.CNOT, qiskit.circuit.library.CXGate()),
(_builtin_gates.CZ, qiskit.circuit.library.CZGate()),
(_builtin_gates.SWAP, qiskit.circuit.library.SwapGate()),
(_builtin_gates.ISWAP, qiskit.circuit.library.iSwapGate()),
(_builtin_gates.S.dagger, qiskit.circuit.library.SdgGate()),
(_builtin_gates.T.dagger, qiskit.circuit.library.TdgGate()),
]
EQUIVALENT_PARAMETRIC_GATES = [
(orquestra_cls(theta), qiskit_cls(theta))
for orquestra_cls, qiskit_cls in [
(_builtin_gates.RX, qiskit.circuit.library.RXGate),
(_builtin_gates.RY, qiskit.circuit.library.RYGate),
(_builtin_gates.RZ, qiskit.circuit.library.RZGate),
(_builtin_gates.PHASE, qiskit.circuit.library.PhaseGate),
(_builtin_gates.CPHASE, qiskit.circuit.library.CPhaseGate),
(_builtin_gates.XX, qiskit.circuit.library.RXXGate),
(_builtin_gates.YY, qiskit.circuit.library.RYYGate),
(_builtin_gates.ZZ, qiskit.circuit.library.RZZGate),
]
for theta in [0, -1, np.pi / 5, 2 * np.pi]
]
TWO_QUBIT_SWAP_MATRIX = np.array(
[
[1, 0, 0, 0],
[0, 0, 1, 0],
[0, 1, 0, 0],
[0, 0, 0, 1],
]
)
def _fix_qubit_ordering(qiskit_matrix):
"""Import qiskit matrix to Orquestra matrix convention.
Qiskit uses different qubit ordering than we do.
It causes multi-qubit matrices to look different on first sight."""
if len(qiskit_matrix) == 2:
return qiskit_matrix
if len(qiskit_matrix) == 4:
return TWO_QUBIT_SWAP_MATRIX @ qiskit_matrix @ TWO_QUBIT_SWAP_MATRIX
else:
raise ValueError(f"Unsupported matrix size: {len(qiskit_matrix)}")
class TestGateConversion:
@pytest.mark.parametrize(
"orquestra_gate,qiskit_gate",
[
*EQUIVALENT_NON_PARAMETRIC_GATES,
*EQUIVALENT_PARAMETRIC_GATES,
],
)
def test_matrices_are_equal(self, orquestra_gate, qiskit_gate):
orquestra_matrix = np.array(orquestra_gate.matrix).astype(np.complex128)
qiskit_matrix = _fix_qubit_ordering(qiskit_gate.to_matrix())
np.testing.assert_allclose(orquestra_matrix, qiskit_matrix)
class TestU3GateConversion:
@pytest.mark.parametrize(
"theta, phi, lambda_",
[
(0, 0, 0),
(0, np.pi / 5, 0),
(np.pi / 3, 0, 0),
(0, 0, np.pi / 7),
(42, -20, 30),
],
)
def test_matrices_are_equal_up_to_phase_factor(self, theta, phi, lambda_):
orquestra_matrix = np.array(
_builtin_gates.U3(theta, phi, lambda_).matrix
).astype(np.complex128)
qiskit_matrix = qiskit.circuit.library.U3Gate(theta, phi, lambda_).to_matrix()
np.testing.assert_allclose(orquestra_matrix, qiskit_matrix, atol=1e-7)
class TestCU3GateConversion:
@pytest.mark.parametrize(
"theta, phi, lambda_",
[
(0, 0, 0),
(0, np.pi / 5, 0),
(np.pi / 3, 0, 0),
(0, 0, np.pi / 7),
(42, -20, 30),
],
)
def test_matrices_are_equal_up_to_phase_factor(self, theta, phi, lambda_):
orquestra_matrix = np.array(
_builtin_gates.U3(theta, phi, lambda_).controlled(1)(0, 1).lifted_matrix(2)
).astype(np.complex128)
qiskit_matrix = (
qiskit.circuit.library.U3Gate(theta, phi, lambda_).control(1).to_matrix()
)
# Rearrange the qiskit matrix, such that it matches the endianness of orquestra
qiskit_matrix_reversed_control = _fix_qubit_ordering(qiskit_matrix)
np.testing.assert_allclose(
orquestra_matrix, qiskit_matrix_reversed_control, atol=1e-7
)
# --------- circuits ---------
# NOTE: In Qiskit, 0 is the most significant qubit,
# whereas in Orquestra, 0 is the least significant qubit.
# Thus, we need to flip the indices.
#
# See more at
# https://qiskit.org/documentation/tutorials/circuits/1_getting_started_with_qiskit.html#Visualize-Circuit
def _make_qiskit_circuit(n_qubits, commands, n_cbits=0):
qc = qiskit.QuantumCircuit(n_qubits, n_cbits)
for method_name, method_args in commands:
method = getattr(qc, method_name)
method(*method_args)
return qc
SYMPY_THETA = sympy.Symbol("theta")
SYMPY_GAMMA = sympy.Symbol("gamma")
SYMPY_LAMBDA = sympy.Symbol("lambda_")
SYMPY_PARAMETER_VECTOR = [sympy.Symbol("p[0]"), sympy.Symbol("p[1]")]
QISKIT_THETA = qiskit.circuit.Parameter("theta")
QISKIT_GAMMA = qiskit.circuit.Parameter("gamma")
QISKIT_LAMBDA = qiskit.circuit.Parameter("lambda_")
QISKIT_PARAMETER_VECTOR = qiskit.circuit.ParameterVector("p", 2)
EXAMPLE_PARAM_VALUES = {
"gamma": 0.3,
"theta": -5,
"lambda_": np.pi / 5,
"p[0]": -5,
"p[1]": 0.3,
}
EQUIVALENT_NON_PARAMETRIZED_CIRCUITS = [
(
_circuit.Circuit([], 3),
_make_qiskit_circuit(3, []),
),
(
_circuit.Circuit(
[
_builtin_gates.X(0),
_builtin_gates.Z(2),
],
6,
),
_make_qiskit_circuit(
6,
[
("x", (0,)),
("z", (2,)),
],
),
),
(
_circuit.Circuit(
[
_builtin_gates.T.dagger(0),
],
6,
),
_make_qiskit_circuit(
6,
[
("tdg", (0,)),
],
),
),
(
_circuit.Circuit(
[
_wavefunction_operations.ResetOperation(0),
],
6,
),
_make_qiskit_circuit(
6,
[
("reset", (0,)),
],
),
),
(
_circuit.Circuit(
[
_builtin_gates.X(0),
_wavefunction_operations.ResetOperation(0),
],
6,
),
_make_qiskit_circuit(
6,
[
("x", (0,)),
("reset", (0,)),
],
),
),
(
_circuit.Circuit(
[
_builtin_gates.CNOT(0, 1),
],
4,
),
_make_qiskit_circuit(
4,
[
("cnot", (0, 1)),
],
),
),
(
_circuit.Circuit(
[
_builtin_gates.RX(np.pi)(1),
],
4,
),
_make_qiskit_circuit(
4,
[
("rx", (np.pi, 1)),
],
),
),
(
_circuit.Circuit(
[_builtin_gates.SWAP.controlled(1)(2, 0, 3)],
5,
),
_make_qiskit_circuit(
5,
[
("append", (qiskit.circuit.library.SwapGate().control(1), [2, 0, 3])),
],
),
),
(
_circuit.Circuit(
[_builtin_gates.Y.controlled(2)(4, 5, 2)],
6,
),
_make_qiskit_circuit(
6,
[
("append", (qiskit.circuit.library.YGate().control(2), [4, 5, 2])),
],
),
),
(
_circuit.Circuit([_builtin_gates.U3(np.pi / 5, np.pi / 2, np.pi / 4)(2)]),
_make_qiskit_circuit(
3,
[
(
"append",
(
qiskit.circuit.library.U3Gate(np.pi / 5, np.pi / 2, np.pi / 4),
[2],
),
)
],
),
),
(
_circuit.Circuit(
[_builtin_gates.U3(np.pi / 5, np.pi / 2, np.pi / 4).controlled(1)(1, 2)]
),
_make_qiskit_circuit(
3,
[
(
"append",
(
qiskit.circuit.library.U3Gate(
np.pi / 5, np.pi / 2, np.pi / 4
).control(1),
[1, 2],
),
)
],
),
),
(
_circuit.Circuit([_builtin_gates.Delay(1)(0)]),
_make_qiskit_circuit(1, [("delay", (1, 0))]),
),
]
EQUIVALENT_PARAMETRIZED_CIRCUITS = [
(
_circuit.Circuit(
[
_builtin_gates.RX(SYMPY_THETA)(1),
],
4,
),
_make_qiskit_circuit(
4,
[
("rx", (QISKIT_THETA, 1)),
],
),
),
(
_circuit.Circuit(
[
_builtin_gates.RX(SYMPY_THETA * SYMPY_GAMMA)(1),
],
4,
),
_make_qiskit_circuit(
4,
[
("rx", (QISKIT_THETA * QISKIT_GAMMA, 1)),
],
),
),
(
_circuit.Circuit(
[_builtin_gates.U3(SYMPY_THETA, SYMPY_GAMMA, SYMPY_LAMBDA)(3)]
),
_make_qiskit_circuit(
4,
[
(
"append",
(
qiskit.circuit.library.U3Gate(
QISKIT_THETA, QISKIT_GAMMA, QISKIT_LAMBDA
),
[3],
),
)
],
),
),
(
_circuit.Circuit(
[
_builtin_gates.U3(SYMPY_THETA, SYMPY_GAMMA, SYMPY_LAMBDA).controlled(1)(
2, 3
)
]
),
_make_qiskit_circuit(
4,
[
(
"append",
(
qiskit.circuit.library.U3Gate(
QISKIT_THETA, QISKIT_GAMMA, QISKIT_LAMBDA
).control(1),
[2, 3],
),
)
],
),
),
(
_circuit.Circuit(
[
_builtin_gates.RX(
SYMPY_PARAMETER_VECTOR[0] * SYMPY_PARAMETER_VECTOR[1]
)(1),
],
4,
),
_make_qiskit_circuit(
4,
[
("rx", (QISKIT_PARAMETER_VECTOR[0] * QISKIT_PARAMETER_VECTOR[1], 1)),
],
),
),
]
UNITARY_GATE_DEF = _gates.CustomGateDefinition(
"unitary.33c11b461fe67e717e37ac34a568cd1c27a89013703bf5b84194f0732a33a26d",
sympy.Matrix([[0, 1], [1, 0]]),
tuple(),
)
CUSTOM_A2_GATE_DEF = _gates.CustomGateDefinition(
"custom.A2.33c11b461fe67e717e37ac34a568cd1c27a89013703bf5b84194f0732a33a26d",
sympy.Matrix([[0, 1], [1, 0]]),
tuple(),
)
EQUIVALENT_CUSTOM_GATE_CIRCUITS = [
(
_circuit.Circuit(
operations=[UNITARY_GATE_DEF()(1)],
n_qubits=4,
),
_make_qiskit_circuit(
4,
[
("unitary", (np.array([[0, 1], [1, 0]]), 1)),
],
),
),
(
_circuit.Circuit(
operations=[CUSTOM_A2_GATE_DEF()(3)],
n_qubits=5,
),
_make_qiskit_circuit(
5,
[
("unitary", (np.array([[0, 1], [1, 0]]), 3, "custom.A2")),
],
),
),
(
_circuit.Circuit(
operations=[UNITARY_GATE_DEF()(1), UNITARY_GATE_DEF()(1)],
n_qubits=4,
),
_make_qiskit_circuit(
4,
[
("unitary", (np.array([[0, 1], [1, 0]]), 1)),
("unitary", (np.array([[0, 1], [1, 0]]), 1)),
],
),
),
(
_circuit.Circuit(
operations=[
UNITARY_GATE_DEF()(1),
CUSTOM_A2_GATE_DEF()(1),
UNITARY_GATE_DEF()(0),
],
n_qubits=4,
),
_make_qiskit_circuit(
4,
[
("unitary", (np.array([[0, 1], [1, 0]]), 1)),
("unitary", (np.array([[0, 1], [1, 0]]), 1, "custom.A2")),
("unitary", (np.array([[0, 1], [1, 0]]), 0)),
],
),
),
]
UNSUPPORTED_CIRCUITS = [
_make_qiskit_circuit(1, [("measure", (0, 0))], n_cbits=1),
_make_qiskit_circuit(1, [("break_loop", ())]),
]
def _draw_qiskit_circuit(circuit):
return qiskit.visualization.circuit_drawer(circuit, output="text")
class TestExportingToQiskit:
@pytest.mark.parametrize(
"orquestra_circuit, qiskit_circuit", EQUIVALENT_NON_PARAMETRIZED_CIRCUITS
)
def test_exporting_circuit_gives_equivalent_circuit(
self, orquestra_circuit, qiskit_circuit
):
converted = export_to_qiskit(orquestra_circuit)
assert converted == qiskit_circuit, (
f"Converted circuit:\n{_draw_qiskit_circuit(converted)}\n isn't equal "
f"to\n{_draw_qiskit_circuit(qiskit_circuit)}"
)
@pytest.mark.parametrize(
"orquestra_circuit",
[
orquestra_circuit
for orquestra_circuit, _ in EQUIVALENT_PARAMETRIZED_CIRCUITS
],
)
def test_exporting_parametrized_circuit_doesnt_change_symbol_names(
self, orquestra_circuit
):
converted = export_to_qiskit(orquestra_circuit)
converted_names = sorted(map(str, converted.parameters))
initial_names = sorted(map(str, orquestra_circuit.free_symbols))
assert converted_names == initial_names
@pytest.mark.parametrize(
"orquestra_circuit, qiskit_circuit", EQUIVALENT_PARAMETRIZED_CIRCUITS
)
def test_exporting_and_binding_parametrized_circuit_results_in_equivalent_circuit(
self, orquestra_circuit, qiskit_circuit
):
# 1. Export
converted = export_to_qiskit(orquestra_circuit)
# 2. Bind params
converted_bound = converted.bind_parameters(
{param: EXAMPLE_PARAM_VALUES[str(param)] for param in converted.parameters}
)
# 3. Bind the ref
ref_bound = qiskit_circuit.bind_parameters(
{
param: EXAMPLE_PARAM_VALUES[str(param)]
for param in qiskit_circuit.parameters
}
)
assert converted_bound == ref_bound, (
f"Converted circuit:\n{_draw_qiskit_circuit(converted_bound)}\n isn't "
f"equal to\n{_draw_qiskit_circuit(ref_bound)}"
)
@pytest.mark.parametrize(
"orquestra_circuit, qiskit_circuit", EQUIVALENT_PARAMETRIZED_CIRCUITS
)
def test_binding_and_exporting_parametrized_circuit_results_in_equivalent_circuit(
self, orquestra_circuit, qiskit_circuit
):
# 1. Bind params
bound = orquestra_circuit.bind(
{
symbol: EXAMPLE_PARAM_VALUES[str(symbol)]
for symbol in orquestra_circuit.free_symbols
}
)
# 2. Export
bound_converted = export_to_qiskit(bound)
# 3. Bind the ref
ref_bound = qiskit_circuit.bind_parameters(
{
param: EXAMPLE_PARAM_VALUES[str(param)]
for param in qiskit_circuit.parameters
}
)
assert bound_converted == ref_bound, (
f"Converted circuit:\n{_draw_qiskit_circuit(bound_converted)}\n isn't "
f"equal to\n{_draw_qiskit_circuit(ref_bound)}"
)
@pytest.mark.parametrize(
"orquestra_circuit, qiskit_circuit", EQUIVALENT_CUSTOM_GATE_CIRCUITS
)
def test_exporting_circuit_with_custom_gates_gives_equivalent_operator(
self, orquestra_circuit, qiskit_circuit
):
exported = export_to_qiskit(orquestra_circuit)
# We can't compare the circuits directly, because the gate names can differ.
# Qiskit allows multiple gate operations with the same label. Orquestra doesn't
# allow that, so we append a matrix hash to the name.
assert qiskit.quantum_info.Operator(exported) == qiskit.quantum_info.Operator(
qiskit_circuit
)
class TestImportingFromQiskit:
@pytest.mark.parametrize(
"orquestra_circuit, qiskit_circuit", EQUIVALENT_NON_PARAMETRIZED_CIRCUITS
)
def test_importing_circuit_gives_equivalent_circuit(
self, orquestra_circuit, qiskit_circuit
):
imported = import_from_qiskit(qiskit_circuit)
assert imported == orquestra_circuit
@pytest.mark.parametrize(
"qiskit_circuit",
[q_circuit for _, q_circuit in EQUIVALENT_PARAMETRIZED_CIRCUITS],
)
def test_importing_parametrized_circuit_doesnt_change_symbol_names(
self, qiskit_circuit
):
imported = import_from_qiskit(qiskit_circuit)
assert sorted(map(str, imported.free_symbols)) == sorted(
map(str, qiskit_circuit.parameters)
)
@pytest.mark.parametrize(
"orquestra_circuit, qiskit_circuit", EQUIVALENT_PARAMETRIZED_CIRCUITS
)
def test_importing_and_binding_parametrized_circuit_results_in_equivalent_circuit(
self, orquestra_circuit, qiskit_circuit
):
# 1. Import
imported = import_from_qiskit(qiskit_circuit)
symbols_map = {
symbol: EXAMPLE_PARAM_VALUES[str(symbol)]
for symbol in imported.free_symbols
}
# 2. Bind params
imported_bound = imported.bind(symbols_map)
# 3. Bind the ref
ref_bound = orquestra_circuit.bind(symbols_map)
assert imported_bound == ref_bound
@pytest.mark.parametrize(
"orquestra_circuit, qiskit_circuit", EQUIVALENT_PARAMETRIZED_CIRCUITS
)
def test_binding_and_importing_parametrized_circuit_results_in_equivalent_circuit(
self, orquestra_circuit, qiskit_circuit
):
# 1. Bind params
bound = qiskit_circuit.bind_parameters(
{
param: EXAMPLE_PARAM_VALUES[str(param)]
for param in qiskit_circuit.parameters
}
)
# 2. Import
bound_imported = import_from_qiskit(bound)
# 3. Bind the ref
ref_bound = orquestra_circuit.bind(
{
symbol: EXAMPLE_PARAM_VALUES[str(symbol)]
for symbol in orquestra_circuit.free_symbols
}
)
assert bound_imported == ref_bound
@pytest.mark.parametrize(
"orquestra_circuit, qiskit_circuit", EQUIVALENT_CUSTOM_GATE_CIRCUITS
)
def test_importing_circuit_with_custom_gates_gives_equivalent_circuit(
self, orquestra_circuit, qiskit_circuit
):
imported = import_from_qiskit(qiskit_circuit)
assert imported == orquestra_circuit
@pytest.mark.parametrize("unsupported_circuit", UNSUPPORTED_CIRCUITS)
def test_operation_not_implemented(self, unsupported_circuit):
with pytest.raises(ValueError):
import_from_qiskit(unsupported_circuit)
|
https://github.com/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
################################################################################
# © Copyright 2021-2022 Zapata Computing Inc.
################################################################################
import pytest
import qiskit
from orquestra.quantum.circuits.symbolic.expressions import FunctionCall, Symbol
from orquestra.quantum.circuits.symbolic.translations import translate_expression
from orquestra.integrations.qiskit.conversions._qiskit_expressions import (
QISKIT_DIALECT,
expression_from_qiskit,
integer_pow,
)
THETA = qiskit.circuit.Parameter("theta")
PHI = qiskit.circuit.Parameter("phi")
EQUIVALENT_EXPRESSIONS = [
(
FunctionCall(
name="add",
args=(1, FunctionCall(name="mul", args=(2, Symbol(name="theta")))),
),
THETA * 2 + 1,
),
(
FunctionCall(
name="add",
args=(1, FunctionCall(name="pow", args=(Symbol(name="theta"), 2))),
),
THETA * THETA + 1,
),
(
FunctionCall(
name="sub",
args=(
2,
FunctionCall(
name="mul", args=(Symbol(name="phi"), Symbol(name="theta"))
),
),
),
2 - THETA * PHI,
),
]
INTERMEDIATE_EXPRESSIONS = [expr for expr, _ in EQUIVALENT_EXPRESSIONS]
class TestParsingQiskitExpressions:
@pytest.mark.parametrize("intermediate_expr, qiskit_expr", EQUIVALENT_EXPRESSIONS)
def test_parsed_intermediate_expression_matches_equivalent_expression(
self, intermediate_expr, qiskit_expr
):
parsed_expr = expression_from_qiskit(qiskit_expr)
assert parsed_expr == intermediate_expr
@pytest.mark.parametrize("expr", INTERMEDIATE_EXPRESSIONS)
def test_translate_parse_identity(self, expr):
# NOTE: the other way round (Qiskit -> intermediate -> Qiskit) can't be done
# directly, because Qiskit expressions don't implement equality checks.
qiskit_expr = translate_expression(expr, QISKIT_DIALECT)
parsed_expr = expression_from_qiskit(qiskit_expr)
assert parsed_expr == expr
class TestIntegerPower:
def test_only_integer_exponents_are_valid(self):
with pytest.raises(ValueError):
integer_pow(2, 2.5)
@pytest.mark.parametrize("base", [10, THETA])
def test_with_exponent_0_is_equal_to_one(self, base):
assert integer_pow(base, 0) == 1
@pytest.mark.parametrize(
"base, exponent, expected_result",
[(2.5, 3, 2.5**3), (THETA, 2, THETA * THETA)],
)
def test_with_positive_exponent_is_converted_to_repeated_multiplication(
self, base, exponent, expected_result
):
assert integer_pow(base, exponent) == expected_result
def test_negative_exponent_cannot_be_used_if_base_is_zero(self):
with pytest.raises(ValueError):
integer_pow(0, -10)
@pytest.mark.parametrize(
"base, exponent, expected_result",
[(2.0, -4, 0.5**4), (THETA, -3, (1 / THETA) * (1 / THETA) * (1 / THETA))],
)
def test_with_neg_exponent_is_converted_to_repeated_multiplication_of_reciprocals(
self, base, exponent, expected_result
):
assert integer_pow(base, exponent) == expected_result
|
https://github.com/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
################################################################################
# © Copyright 2021-2022 Zapata Computing Inc.
################################################################################
import os
import unittest
import qiskit.providers.aer.noise as AerNoise
from orquestra.quantum.circuits.layouts import CircuitConnectivity
from qiskit.providers.exceptions import QiskitBackendNotFoundError
from orquestra.integrations.qiskit.noise.basic import (
create_amplitude_damping_noise,
create_phase_and_amplitude_damping_error,
create_phase_damping_noise,
create_pta_channel,
get_kraus_matrices_from_ibm_noise_model,
get_qiskit_noise_model,
)
class TestBasic(unittest.TestCase):
def setUp(self):
self.ibmq_api_token = os.getenv("ZAPATA_IBMQ_API_TOKEN")
self.all_devices = ["ibm_kyoto"]
self.T_1 = 10e-7
self.T_2 = 30e-7
self.t_step = 10e-9
self.t_1_t_2_models = [
create_phase_and_amplitude_damping_error,
create_pta_channel,
]
def test_get_qiskit_noise_model(self):
# Given
for device in self.all_devices:
# When
noise_model, coupling_map = get_qiskit_noise_model(
device, api_token=self.ibmq_api_token
)
# Then
self.assertIsInstance(noise_model, AerNoise.NoiseModel)
self.assertIsInstance(coupling_map, list)
def test_get_qiskit_noise_model_no_device(self):
# Given
not_real_devices = ["THIS IS NOT A REAL DEVICE", "qasm_simulator"]
for device in not_real_devices:
# When/then
self.assertRaises(
QiskitBackendNotFoundError,
lambda: get_qiskit_noise_model(device, api_token=self.ibmq_api_token),
)
def test_t_1_t_2_noise_models(self):
for noise in self.t_1_t_2_models:
self.assertIsInstance(
noise(self.T_1, self.T_2, self.t_step), AerNoise.NoiseModel
)
def test_amplitude_damping_model(self):
self.assertIsInstance(
create_amplitude_damping_noise(self.T_1, self.t_step), AerNoise.NoiseModel
)
def test_phase_damping_noise(self):
self.assertIsInstance(
create_phase_damping_noise(self.T_2, self.t_step), AerNoise.NoiseModel
)
def test_getting_kraus_matrices_from_noise_model(self):
noise_model = create_amplitude_damping_noise(self.T_1, self.t_step)
kraus_dict = get_kraus_matrices_from_ibm_noise_model(noise_model)
# Test to see if basis gates are in
self.assertEqual("id" in kraus_dict, True)
self.assertEqual("u3" in kraus_dict, True)
self.assertEqual("cx" in kraus_dict, True)
# Test to see if the number of kraus operators is right for a basis gate
self.assertEqual(len(kraus_dict["id"]), 2)
self.assertEqual(len(kraus_dict["u3"]), 2)
self.assertEqual(len(kraus_dict["cx"]), 4)
|
https://github.com/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
import os
from functools import partial
from unittest.mock import Mock
import pytest
from orquestra.quantum.api import EstimationTask
from orquestra.quantum.api.circuit_runner_contracts import (
CIRCUIT_RUNNER_CONTRACTS,
circuit_runner_gate_compatibility_contracts,
)
from orquestra.quantum.circuits import CNOT, Circuit, H, X
from orquestra.quantum.estimation import estimate_expectation_values_by_averaging
from orquestra.quantum.measurements import ExpectationValues
from orquestra.quantum.operators import PauliTerm
from qiskit import QiskitError, execute
from qiskit.transpiler import CouplingMap
from qiskit_aer import Aer
from orquestra.integrations.qiskit.noise import get_qiskit_noise_model
from orquestra.integrations.qiskit.runner import QiskitRunner
def _test_id(val):
return val.backend.name()
@pytest.fixture
def aer_backend_with_real_shots_limit():
"""Sophisticated AerBackend mock that actually respects reported limits."""
backend = Aer.get_backend("aer_simulator")
max_shots = backend.configuration().max_shots
old_run = backend.run
def _run(*args, **kwargs):
if kwargs.get("shots", 0) > max_shots:
raise QiskitError("Maximum number of shots in experiment_exceeded")
return old_run(*args, **kwargs)
backend.run = _run
return backend
COMPATIBLE_BACKENDS = (
# This list contains names of all possible AerBackends.
# The ones that are not working are commented out so that we
# remember why they are not used in the tests
"aer_simulator",
"aer_simulator_statevector",
"aer_simulator_density_matrix",
# "aer_simulator_stabilizer", # Has limited gateset
"aer_simulator_matrix_product_state",
# "aer_simulator_extended_stabilizer", # Technically compatible, incredibly slow
# "aer_simulator_unitary", # Does not support measurements
# "aer_simulator_superop", # Does not support measurements
# "qasm_simulator", # Compatible, but deprecated
# "statevector_simulator", # Compatible, but deprecated
# "unitary_simulator", # Does not support measurements
# "pulse_simulator" # Does not support measurements
)
@pytest.mark.parametrize(
"runner",
[*[QiskitRunner(Aer.get_backend(name)) for name in COMPATIBLE_BACKENDS]],
ids=_test_id,
)
@pytest.mark.parametrize("contract", CIRCUIT_RUNNER_CONTRACTS)
def test_qiskit_runner_fulfills_circuit_runner_contracts(runner, contract):
assert contract(runner)
@pytest.mark.parametrize(
"contract",
circuit_runner_gate_compatibility_contracts(
gates_to_exclude=["RH", "XY"], exp_val_spread=1.5
),
)
@pytest.mark.parametrize(
"runner",
[
*[
QiskitRunner(
Aer.get_backend(name),
execute_function=partial(execute, seed_simulator=1234),
)
for name in COMPATIBLE_BACKENDS
]
],
ids=_test_id,
)
def test_qiskit_runner_uses_correct_gate_definitions(runner, contract):
assert contract(runner)
def test_qiskit_runner_can_run_job_with_sample_size_exceeding_backends_limit(
aer_backend_with_real_shots_limit,
):
runner = QiskitRunner(aer_backend_with_real_shots_limit)
max_shots = runner.backend.configuration().max_shots
circuit = Circuit([H(0)])
measurements = runner.run_and_measure(circuit, n_samples=max_shots + 1)
assert len(measurements.bitstrings) >= max_shots + 1
@pytest.fixture(params=["aer_simulator"])
def noisy_simulator(request):
ibmq_api_token = os.getenv("ZAPATA_IBMQ_API_TOKEN")
noise_model, connectivity = get_qiskit_noise_model(
"ibm_kyoto", api_token=ibmq_api_token
)
backend = Aer.get_backend(request.param)
return QiskitRunner(backend, noise_model=noise_model, coupling_map=connectivity)
@pytest.mark.parametrize("num_flips", [10, 50])
def test_expectation_value_with_noisy_simulator(noisy_simulator, num_flips):
# Initialize in |1> state and flip even number of times.
# Thus, we and up in |1> state but decoherence is allowed to take effect
circuit = Circuit([X(0) for _ in range(num_flips + 1)])
qubit_operator = PauliTerm("Z0")
n_samples = 8192
estimation_tasks = [EstimationTask(qubit_operator, circuit, n_samples)]
expectation_values = estimate_expectation_values_by_averaging(
noisy_simulator, estimation_tasks
)[0]
assert isinstance(expectation_values, ExpectationValues)
assert len(expectation_values.values) == 1
assert -1 < expectation_values.values[0] < 0.0
def test_qiskit_runner_passes_coupling_map_to_execute_function():
circuit = Circuit([X(0), CNOT(1, 2)])
coupling_map = CouplingMap([(0, 2), (0, 1)])
execute_func = Mock(wraps=execute)
runner = QiskitRunner(
Aer.get_backend("aer_simulator_statevector"),
coupling_map=coupling_map,
execute_function=execute_func,
)
runner.run_and_measure(circuit, n_samples=10)
assert execute_func.call_args.kwargs["coupling_map"] == coupling_map
@pytest.mark.parametrize(
"runner",
[
*[
QiskitRunner(Aer.get_backend(name), discard_extra_measurements=True)
for name in COMPATIBLE_BACKENDS
]
],
ids=_test_id,
)
def test_qiskit_runner_discards_extra_measurements_exact_num_measurements_is_true(
runner: QiskitRunner,
):
circuits = [Circuit([X(0), CNOT(0, 1)])] * 3
n_samples = [5, 10, 15]
result = runner.run_batch_and_measure(circuits, n_samples=n_samples)
assert [len(r.bitstrings) for r in result] == n_samples
|
https://github.com/jwalaQ/my-qiskit-textbook-solutions
|
jwalaQ
|
n = 275
print("Answer = " + bin(n)[2:])
|
https://github.com/jwalaQ/my-qiskit-textbook-solutions
|
jwalaQ
|
from qiskit_textbook.widgets import plot_bloch_vector_spherical
from math import pi,sqrt
coords = [0,0,1]
plot_bloch_vector_spherical(coords)
coords = [pi,0,1]
plot_bloch_vector_spherical(coords)
coords = [pi/2,0,1]
plot_bloch_vector_spherical(coords)
coords = [pi/2,-pi/2,1]
plot_bloch_vector_spherical(coords)
coords = [pi/2,-pi/2,1]
plot_bloch_vector_spherical(coords)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/jwalaQ/my-qiskit-textbook-solutions
|
jwalaQ
|
from qiskit import *
from math import pi,sqrt
from qiskit.visualization import plot_bloch_multivector,plot_histogram
backend_s = Aer.get_backend('statevector_simulator')
backend_q = Aer.get_backend('qasm_simulator')
qc = QuantumCircuit(2)
qc.h(0)
qc.z(0)
qc.h(0)
qc.x(1)
display(qc.draw('mpl'))
# we use the statevector_simulator to obtain the statevector
job = execute(qc,backend_s)
job_result = job.result()
state_vec = job_result.get_statevector()
plot_bloch_multivector(state_vec)
qc = QuantumCircuit(2)
qc.x(0)
qc.z(0)
qc.y(1)
display(qc.draw('mpl'))
job = execute(qc,backend_s)
job_result = job.result()
state_vec = job_result.get_statevector()
plot_bloch_multivector(state_vec)
qc = QuantumCircuit(1,1)
# initialize qubit in state |+>
qc.initialize([1/sqrt(2),1/sqrt(2)],0)
qc.barrier()
qc.h(0)
qc.measure(0,0)
display(qc.draw('mpl'))
job = execute(qc, backend_q)
job_result = job.result()
res_counts = job_result.get_counts()
plot_histogram(res_counts)
# initialize in |+> state:
qc = QuantumCircuit(1,1)
qc.h(0)
qc.measure(0,0)
display(qc.draw('mpl'))
job = execute(qc, backend_q,shots=4000)
job_result = job.result()
res_counts = job_result.get_counts()
plot_histogram(res_counts)
qc = QuantumCircuit(1,1)
qc.x(0)
qc.h(0)
qc.measure(0,0)
display(qc.draw('mpl'))
job = execute(qc, backend_q,shots=4000)
job_result = job.result()
res_counts = job_result.get_counts()
plot_histogram(res_counts)
qc = QuantumCircuit(2)
qc.initialize([1/sqrt(2),1.j/sqrt(2)],0)
qc.initialize([1/sqrt(2),-1.j/sqrt(2)],1)
qc.sdg([0,1])
qc.h([0,1])
qc.measure_all()
qc.barrier()
qc.h([0,1])
qc.s([0,1])
qc.draw('mpl')
job = execute(qc,backend_q).result()
counts = job.get_counts()
plot_histogram(counts)
job = execute(qc,backend_s).result()
state_vec = job.get_statevector()
plot_bloch_multivector(state_vec)
import qiskit
qiskit.__qiskit_version__
|
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.x(0) # NOT gate to convert default 0 state to 1
qc.draw('mpl')
result_statevector = execute(qc,backend_s).result().get_statevector()
array_to_latex(result_statevector,pretext = "\\text{Result = }")
plot_bloch_multivector(result_statevector)
qc = QuantumCircuit(2)
qc.h(0)
qc.draw('mpl')
result_statevector = execute(qc,backend_s).result().get_statevector()
array_to_latex(result_statevector,pretext = "\\text{Result = }")
plot_bloch_multivector(result_statevector)
qc = QuantumCircuit(2)
qc.x(0)
qc.h(1)
qc.draw('mpl')
result_statevector = execute(qc,backend_s).result().get_statevector()
array_to_latex(result_statevector,pretext = "\\text{Result = }")
plot_bloch_multivector(result_statevector)
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
qc.h(1)
qc.draw('mpl')
result_statevector = execute(qc,backend_s).result().get_statevector()
array_to_latex(result_statevector,pretext = "\\text{Result = }")
plot_bloch_multivector(result_statevector)
qc = QuantumCircuit(1)
qc.x(0)
qc.z(0)
qc.h(0)
qc.draw('mpl')
result_unitary = execute(qc,backend_u).result().get_unitary()
array_to_latex(result_unitary,pretext = "\\text{U = XZH = }")
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
qc.draw('mpl')
array_to_latex(execute(qc,backend_u).result().get_unitary())
qc = QuantumCircuit(2)
qc.h(0)
qc.draw('mpl')
array_to_latex(execute(qc,backend_u).result().get_unitary())
qc = QuantumCircuit(2)
qc.sdg(1)
qc.z(0)
qc.draw('mpl')
array_to_latex(execute(qc,backend_u).result().get_unitary())
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
qc.cx(0,1)
qc.draw('mpl')
entangled = execute(qc,backend_s).result()
entangled_statevector = entangled.get_statevector()
entangled_counts = entangled.get_counts()
array_to_latex(entangled_statevector, pretext = "\\text{Statevector = }")
plot_histogram(entangled_counts)
import qiskit
qiskit.__qiskit_version__
|
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/jwalaQ/my-qiskit-textbook-solutions
|
jwalaQ
|
from qiskit import QuantumCircuit,Aer,execute
from qiskit.circuit import Gate
from math import pi,sqrt
qc = QuantumCircuit(2)
qc.x(0)
qc.h([0,1])
qc.barrier()
qc.h([0,1])
qc.cx(0,1)
qc.cx(1,0)
qc.cx(0,1)
qc.h([0,1])
qc.draw('mpl')
backend_s = Aer.get_backend('statevector_simulator')
job = execute(qc,backend_s).result()
sv = job.get_statevector()
from qiskit_textbook.tools import array_to_latex
array_to_latex(sv)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/jwalaQ/my-qiskit-textbook-solutions
|
jwalaQ
|
from qiskit import Aer, execute, QuantumCircuit, QuantumRegister
from qiskit.visualization import plot_bloch_multivector,plot_histogram
input_bit = QuantumRegister(1,'input')
output_bit = QuantumRegister(1,'output')
garbage_bit = QuantumRegister(1,'garbage')
Uf = QuantumCircuit(input_bit,output_bit,garbage_bit)
Uf.cx(input_bit,output_bit)
# Uf.draw('mpl',justify=None)
Vf = QuantumCircuit(input_bit,output_bit,garbage_bit)
Vf.cx(input_bit,garbage_bit)
Vf.cx(input_bit,output_bit)
# Vf.draw('mpl',justify=None)
qc = Uf + Vf.inverse()
# qc.draw('mpl')
final_output_bit = QuantumRegister(1,'final_output')
copy = QuantumCircuit(output_bit,final_output_bit)
copy.cx(output_bit,final_output_bit)
# copy.draw('mpl',justify='None')
(Vf.inverse() + copy + Vf).draw(output='mpl',justify='None')
qc0 = QuantumCircuit(input_bit,output_bit,garbage_bit,final_output_bit)
qc0 = qc0 + Vf.inverse() + copy + Vf
qc0.draw('mpl',justify='none')
qasm_sim = Aer.get_backend('qasm_simulator')
qc0.measure_all()
result = execute(qc0,backend=qasm_sim).result()
counts = result.get_counts()
plot_histogram(counts)
qc1 = QuantumCircuit(input_bit,output_bit,garbage_bit,final_output_bit)
qc1.x(0)
qc1 = qc1 + Vf.inverse() + copy + Vf
qc1.draw('mpl',justify='none')
qc1.measure_all()
result = execute(qc1,backend=qasm_sim).result()
counts = result.get_counts()
plot_histogram(counts)
qc = QuantumCircuit(input_bit,output_bit,garbage_bit,final_output_bit)
qc.x(1)
qc = qc + Vf.inverse() + copy + Vf
qc = qc.reverse_bits()
qc.draw('mpl',justify='none')
qc.measure_all()
result = execute(qc,backend=qasm_sim).result()
counts = result.get_counts()
plot_histogram(counts)
qc = QuantumCircuit(input_bit,output_bit,garbage_bit,final_output_bit)
qc.x([0,1])
qc = qc + Vf.inverse() + copy + Vf
qc = qc.reverse_bits()
qc.draw('mpl',justify='none')
qc.measure_all()
result = execute(qc,backend=qasm_sim).result()
counts = result.get_counts()
plot_histogram(counts)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/PaulaGarciaMolina/QNLP_Qiskit_Hackathon
|
PaulaGarciaMolina
|
import numpy as np
import math
import pickle
from discopy import Ty, Word # Import the classes for the type of word and for the word
s, n = Ty('s'), Ty('n') # Define the types s (sentence) and n (noun)
# Define the words (notice that we include both meaning and grammar)
# nouns (subjects)
man, woman = Word('man', n), Word('woman', n)
mujer, hombre = Word('mujer', n), Word('hombre', n)
# nouns (objects)
car, sofa, notebook = Word('car', n), Word('sofa', n), Word('notebook', n)
coche, sillon, cuaderno = Word('coche', n), Word('sillon', n), Word('cuaderno', n)
# adjectives
old, new, red, blue = Word('old', n @ n.l), Word('new', n @ n.l), Word('red', n @ n.l), Word('blue', n @ n.l)
viejo, nuevo, rojo, azul = Word('viejo', n.r @ n), Word('nuevo', n.r @ n ), Word('rojo', n.r @ n ), Word('azul', n.r @ n )
# Transitive verbs
buys, steals, breaks = Word('buys', n.r @ s @ n.l), Word('steals', n.r @ s @ n.l), Word('breaks', n.r @ s @ n.l)
compra, roba, rompe = Word('compra', n.r @ s @ n.l), Word('roba', n.r @ s @ n.l), Word('rompe', n.r @ s @ n.l)
subjects = [man, woman]
sujetos = [mujer, hombre]
verbs = [buys, steals, breaks]
verbos = [compra, roba, rompe]
adjectives = [old, new, red, blue]
adjetivos = [viejo, nuevo, rojo, azul]
objects = [car, sofa, notebook]
objetos = [coche, sillon, cuaderno]
#Save the vocabulary
vocab_E = subjects + verbs + adjectives + objects #English words
vocab_S = sujetos + verbos + adjetivos + objetos #Spanish words
from discopy import Cup, Id, pregroup
grammar = Cup(n, n.r) @ Id(s) @ Cup(n.l, n)
sentence = woman @ buys @ car >> grammar
pregroup.draw(sentence)
grammar = Cup(n, n.r) @ Id(s) @ Cup(n.l, n) @ Cup(n.l, n)
sentence = woman @ buys @ new @ car >> grammar
pregroup.draw(sentence)
grammar = Cup(n, n.r) @ Id (s @ n.l) @ Cup(n, n.r) @ Id(n) >> Id(s) @ Cup(n.l, n) >> Id(s)
sentence = mujer @ compra @ coche @ viejo >> grammar
pregroup.draw(sentence)
from discopy import Diagram
from discopy.grammar import draw
# Store the grammatical structures in a dictionary
grammar_dict = {
'NVN' : Cup(n, n.r) @ Id(s) @ Cup(n.l, n),
'NVAN' : Cup(n, n.r) @ Id(s) @ Cup(n.l, n) @ Cup(n.l, n),
'NVNA' : Cup(n, n.r) @ Id (s @ n.l) @ Cup(n, n.r) @ Id(n) >> Id(s) @ Cup(n.l, n) >> Id(s)}
# Create parsing (grammatical analysis) dictionary where the grammatical sentences
# are the keys and the associated values are the diagrams (words + grammar)
data_psr = {}
# English noun+verb+noun sentences
parsing_NVNe = {"{} {} {}.".format(subj, verb, obj): subj @ verb @ obj >> grammar_dict['NVN']
for subj in subjects for verb in verbs for obj in objects}
sentences_NVNe = list(parsing_NVNe.keys())
for sentence in sentences_NVNe:
diagram = parsing_NVNe[sentence]
data_psr[sentence] = parsing_NVNe[sentence]
# Spanish noun+verb+noun sentences
parsing_NVNs = {"{} {} {}.".format(subj, verb, obj): subj @ verb @ obj >> grammar_dict['NVN']
for subj in sujetos for verb in verbos for obj in objetos}
sentences_NVNs = list(parsing_NVNs.keys())
for sentence in sentences_NVNs:
diagram = parsing_NVNs[sentence]
data_psr[sentence] = parsing_NVNs[sentence]
# English noun+verb+adjective+noun sentences
parsing_NVANe = {"{} {} {} {}.".format(subj, verb, adj, obj): subj @ verb @ adj @ obj >> grammar_dict['NVAN']
for subj in subjects for verb in verbs for adj in adjectives for obj in objects}
sentences_NVANe = list(parsing_NVANe.keys())
for sentence in sentences_NVANe:
diagram = parsing_NVANe[sentence]
data_psr[sentence] = parsing_NVANe[sentence]
# Spanish noun+verb+noun+adjectives sentences
parsing_NVNAs = {"{} {} {} {}.".format(subj, verb, obj, adj): subj @ verb @ obj @ adj >> grammar_dict['NVNA']
for subj in sujetos for verb in verbos for obj in objetos for adj in adjetivos}
sentences_NVNAs = list(parsing_NVNAs.keys())
for sentence in sentences_NVNAs:
diagram = parsing_NVNAs[sentence]
data_psr[sentence] = parsing_NVNAs[sentence]
#*****************************************************************************************************
#Load datasets containing sentences and labels
#*****************************************************************************************************
#Small (20 sentences in english and 20 in spanish; 400 possible combinations)
with open('DataSet_SI_eng_small.txt') as f:
dataeng_small = f.readlines()
with open('DataSet_SI_spa_small.txt') as f:
dataspa_small = f.readlines()
with open('TrainingSet_SI_labels_small.txt') as f:
train_labels_small = f.readlines()
with open('TestSet_SI_labels_small.txt') as f:
test_labels_small = f.readlines()
#Medium (65 sentences in english and 65 in spanish; 4225 possible combinations)
with open('DataSet_SI_eng_medium.txt') as f:
dataeng_medium = f.readlines()
with open('DataSet_SI_spa_medium.txt') as f:
dataspa_medium = f.readlines()
with open('TrainingSet_SI_labels_medium.txt') as f:
train_labels_medium = f.readlines()
with open('TestSet_SI_labels_medium.txt') as f:
test_labels_medium = f.readlines()
#Big (90 sentences in english and 90 in spanish; 8100 possible combinations)
with open('DataSet_SI_eng_big.txt') as f:
dataeng_big = f.readlines()
with open('DataSet_SI_spa_big.txt') as f:
dataspa_big = f.readlines()
with open('TrainingSet_SI_labels_big.txt') as f:
train_labels_big = f.readlines()
with open('TestSet_SI_labels_big.txt') as f:
test_labels_big = f.readlines()
#*****************************************************************************************************
# Transform senteces into diagrams
#*****************************************************************************************************
#Small
dataeng_psr_dict_small, dataspa_psr_dict_small= {},{}
dict_small=[dataeng_psr_dict_small, dataspa_psr_dict_small]
sent_type_small={}
data_small=[dataeng_small,dataspa_small]
#Medium
dataeng_psr_dict_medium, dataspa_psr_dict_medium = {},{}
dict_medium=[dataeng_psr_dict_medium, dataspa_psr_dict_medium]
sent_type_medium={}
data_medium=[dataeng_medium,dataspa_medium]
#Big
dataeng_psr_dict_big, dataspa_psr_dict_big = {},{}
dict_big=[dataeng_psr_dict_big, dataspa_psr_dict_big]
sent_type_big={}
data_big=[dataeng_big,dataspa_big]
################
parsing=[parsing_NVNe,parsing_NVNs,parsing_NVANe,parsing_NVNAs]
types=['NVN','NVN','NVAN','NVNA']
for (datasize,dictsize,sent_type) in zip([data_small,data_medium,data_big],[dict_small,dict_medium,dict_big],
[sent_type_small,sent_type_medium,sent_type_big]):
for (data,data_psr_dict) in zip(datasize,dictsize):
for sentence in data:
sentstr = sentence[:-1]
for (par,typ) in zip(parsing,types):
if sentstr in list(par.keys()):
diagram = par[sentstr]
data_psr_dict[sentstr] = diagram
sent_type[sentstr] = typ
#*****************************************************************************************************
# Save labels in lists to be used later on
#*****************************************************************************************************
#Training set (To train the paramenters)
train_labelslist_small,train_labelslist_medium,train_labelslist_big=[],[],[]
train_labelslist=[train_labelslist_small,train_labelslist_medium,train_labelslist_big]
trainset_labels=[train_labels_small,train_labels_medium,train_labels_big]
for (labelslist,labelsset) in zip(train_labelslist,trainset_labels):
for pair in labelsset:
label=pair[-2]
labelslist.append(label)
#Testing set (To test the trained paramenters)
test_labelslist_small,test_labelslist_medium,test_labelslist_big=[],[],[]
test_labelslist=[test_labelslist_small,test_labelslist_medium,test_labelslist_big]
testset_labels=[test_labels_small,test_labels_medium,test_labels_big]
for (labelslist,labelsset) in zip(test_labelslist,testset_labels):
for pair in labelsset:
label=pair[-2]
labelslist.append(label)
#*****************************************************************************************************
# Remove resource-consumming cups and transform them into effects (see [2])
#*****************************************************************************************************
from discopy import Cap, Box
#Old data with cups
dataeng_psr_dict_sizes=[dataeng_psr_dict_small,dataeng_psr_dict_medium,dataeng_psr_dict_big]
dataspa_psr_dict_sizes=[dataspa_psr_dict_small,dataspa_psr_dict_medium,dataspa_psr_dict_big]
#New data with effects
dataeng_new_psr_dict_small,dataeng_new_psr_dict_medium,dataeng_new_psr_dict_big = {},{},{}
dataspa_new_psr_dict_small,dataspa_new_psr_dict_medium,dataspa_new_psr_dict_big = {},{},{}
dataeng_new_psr_dict_sizes=[dataeng_new_psr_dict_small,dataeng_new_psr_dict_medium,dataeng_new_psr_dict_big]
dataspa_new_psr_dict_sizes=[dataspa_new_psr_dict_small,dataspa_new_psr_dict_medium,dataspa_new_psr_dict_big]
###########
sent_type_size=[sent_type_small,sent_type_medium,sent_type_big]
for (dataeng_new_psr_dict,dataspa_new_psr_dict,
dataeng_psr_dict,dataspa_psr_dict,sent_type) in zip(dataeng_new_psr_dict_sizes,dataspa_new_psr_dict_sizes,
dataeng_psr_dict_sizes,dataspa_psr_dict_sizes,sent_type_size):
for (data_psr_dict,data_new_psr_dict) in zip([dataeng_psr_dict,dataspa_psr_dict],
[dataeng_new_psr_dict,dataspa_new_psr_dict]):
for sentstr in data_psr_dict.keys():
num_words = len(sentstr.split(' '))
words = data_psr_dict[sentstr].boxes[:num_words]
if sent_type[sentstr] == 'NVN': #noun-verb-noun sentences (English and Spanish)
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[2].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ Id(n) @ noun2) # Rearranged words
sentence = words_new >> grammar_dict['NVN'] # Apply grammar on rearranged words
data_new_psr_dict[sentstr] = sentence.normal_form() # Store sentence with optimum diagram
elif sent_type[sentstr] == 'NVAN': #noun-verb-adjective-noun sentences (English)
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['NVAN']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif sent_type[sentstr] == 'NVNA': #noun-verb-noun-adjective sentences (Spanish)
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[2].name, n.r, Ty())
words_new = (Cap(n.r, n) @ Cap(n.r, n)) >> (noun1 @ Id(n) @ words[1] @ noun2 @ Id(n) @ words[3])
sentence = words_new >> grammar_dict['NVNA']
data_new_psr_dict[sentstr] = sentence.normal_form()
#*****************************************************************************************************
# Redefine the vocabulary according to the new domain and code nouns as effects.
#*****************************************************************************************************
from discopy import Cap, Box
#English
vocab_psr_E = []
for word in vocab_E:
if word.cod == Ty('n'):
vocab_psr_E.append(Box(word.name, n.r, Ty()))
else:
vocab_psr_E.append(word)
#Spanish
vocab_psr_S = []
for word in vocab_S:
if word.cod == Ty('n'):
vocab_psr_S.append(Box(word.name, n.r, Ty()))
else:
vocab_psr_S.append(word)
vocab_psr=vocab_psr_E+vocab_psr_S
#*****************************************************
# Functions to deal with the ansätze (functions from [2])
#*****************************************************
from discopy.quantum import Ket, IQPansatz, Bra, qubit
from discopy.quantum import Ket, IQPansatz, Bra, qubit
from discopy.quantum.gates import Rx, Rz
from discopy.quantum.circuit import Functor, Id
from discopy.quantum.circuit import Circuit
from functools import reduce, partial
q_s = 2 # number of qubits for type s (sentence)
q_n = 1 # number of qubits for type n (noun)
depth = 1 # depth of the IQPansatz
p_n = 1 # number of parameters for a single-qubit word (noun); valued in {1,2,3}.
# Define the dimensions of the objects of the circuit functor
ob = {s: q_s, n: q_n}
ob_cqmap = {s: qubit ** q_s, n: qubit ** q_n}
# Define the ansätze for states and effects
def single_qubit_iqp_ansatz(params):
if len(params) == 1:
return Rx(params[0])
if len(params) == 2:
return Rx(params[0]) >> Rz(params[1])
if len(params) == 3:
return IQPansatz(1, params)
def ansatz_state(state, params):
arity = sum(ob[Ty(factor.name)] for factor in state.cod)
if arity == 1:
return Ket(0) >> single_qubit_iqp_ansatz(params)
else:
return Ket(*tuple([0 for i in range(arity)])) >> IQPansatz(arity, params)
def ansatz_effect(effect, params):
arity = sum(ob[Ty(factor.name)] for factor in effect.dom)
if arity == 1:
return single_qubit_iqp_ansatz(params) >> Bra(0)
else:
return IQPansatz(arity, params) >> Bra(*tuple([0 for i in range(arity)]))
def ansatz(box,params):
dom_type = box.dom
cod_type = box.cod
if len(dom_type) == 0 and len(cod_type) != 0:
return ansatz_state(box, params)
if len(dom_type) != 0 and len(cod_type) == 0:
return ansatz_effect(box, params)
# Construct the circuit functor
def F(params):
ar = dict()
for i in range(len(vocab_psr)):
pgbox = vocab_psr[i]
qbox = ansatz(vocab_psr[i], params[i])
ar.update({pgbox: qbox})
if pgbox.cod == Ty():
ar.update({Box(pgbox.name, n.l, Ty()): qbox})
return Functor(ob_cqmap, ar)
#*****************************************************
# Functions to deal with the parametrisation (functions from [2])
#*****************************************************
def paramshapes(vocab_psr):
parshapes = []
for box in vocab_psr:
dom_type = box.dom
cod_type = box.cod
dom_arity = sum(ob[Ty(factor.name)] for factor in box.dom)
cod_arity = sum(ob[Ty(factor.name)] for factor in box.cod)
if dom_arity == 0 or cod_arity == 0:
arity = max(dom_arity, cod_arity)
assert arity != 0
if arity == 1:
parshapes.append((p_n,))
if arity != 1:
parshapes.append((depth, arity-1))
return parshapes
def randparams(par_shapes):
params = np.array([])
for i in range(len(par_shapes)):
params = np.concatenate((params, np.ravel(np.random.rand(*par_shapes[i]))))
return params
def reshape_params(unshaped_pars, par_shapes):
pars_reshaped = [[] for ii in range(len(par_shapes))]
shift = 0
for ss, s in enumerate(par_shapes):
idx0 = 0 + shift
if len(s) == 1:
idx1 = s[0] + shift
elif len(s) == 2:
idx1 = s[0] * s[1] + shift
pars_reshaped[ss] = np.reshape(unshaped_pars[idx0:idx1], s)
if len(s) == 1:
shift += s[0]
elif len(s) == 2:
shift += s[0] * s[1]
return pars_reshaped
#****************************************
# Parameters of the current model
#****************************************
par_shapes = paramshapes(vocab_psr)
rand_unshaped_pars = randparams(par_shapes)
rand_shaped_pars = reshape_params(rand_unshaped_pars, par_shapes)
print('Number of parameters: ', len(rand_unshaped_pars))
#****************************************
# Transform sentences diagrams into Qiskit Quantum Circuits
#****************************************
from pytket.extensions.qiskit import tk_to_qiskit
from discopy.quantum import Measure
def to_qiskitcircuit(unshaped_params,diagrams_dict):
"""Function to transform a DisCoCat diagram into a Qiskit Quantum Circuit.
Args:
unshaped_params = parameters to the variationals circuits.
diagrams_dict = dictionary with the sentences as keys and their diagrams as values.
Returns:
Qiskit Quantum Circuit.
"""
func = F(reshape_params(unshaped_params, par_shapes))
circs=[]
for sentstr in diagrams_dict.keys():
diagram=diagrams_dict[sentstr]
circuit=(func(diagram) >> Measure() @ Measure()) #Add the measurements to the circuit
pytket_circuit = circuit.to_tk()
qiskit_circuit = tk_to_qiskit(pytket_circuit) #Create Qiskit Quantum Circuit
circs.append(qiskit_circuit)
return circs
##########
#For example (with random parameters "rand_shaped_pars")
circuits_eng_small,circuits_eng_medium,circuits_eng_big=[],[],[]
circuits_spa_small,circuits_spa_medium,circuits_spa_big=[],[],[]
circuits_eng = [circuits_eng_small,circuits_eng_medium,circuits_eng_big] # list of Qiskit Quantum Crcuits of english sentences
circuits_spa = [circuits_spa_small,circuits_spa_medium,circuits_spa_big] # list of Qiskit Quantum Circuits of spanish sentences
for (circ_eng,circ_spa,dataeng_new_psr_dict,dataspa_new_psr_dict) in zip(circuits_eng,circuits_spa,
dataeng_new_psr_dict_sizes,dataspa_new_psr_dict_sizes):
for (circ,data_new_psr_dict) in zip([circ_eng,circ_spa],
[dataeng_new_psr_dict,dataspa_new_psr_dict]):
circ.append(to_qiskitcircuit(rand_unshaped_pars,data_new_psr_dict))
j=2
print(list(dataeng_new_psr_dict_medium.keys())[j])
circuits_eng_medium[0][j].draw(output='mpl',filename='circuit_example_NVN.pdf')
j=45
print(list(dataeng_new_psr_dict_medium.keys())[j])
circuits_eng_medium[0][j].draw(output='mpl',filename='circuit_example_ADJenglish.pdf')
j=30
print(list(dataspa_new_psr_dict_medium.keys())[j])
circuits_spa_medium[0][j].draw(output='mpl',filename='circuit_example_ADJspanish.pdf')
#****************************************
# Load qiskit classes to execute circuits and IBM-Q account
#****************************************
from qiskit import BasicAer, execute, Aer, IBMQ
from qiskit.quantum_info import Statevector
from qiskit.providers.aer.noise import NoiseModel
provider=IBMQ.load_account()
#****************************************
# Functions to perform the hybrid quantum-classical machine learning (optimization of variational parameters)
#****************************************
####Predict labels (which sentences have the same meaning)
def get_probs(unshaped_params,withshots=True,simulation=True,withnoise=False):
"""Function to get the predicted labels of our dataset from a specific set of parameters.
Args:
unshaped_params = parameters to the variationals circuits.
withshots = True: a limited number of shots will be performed or simulated; False: a classical simulation
equivalent to an unlimited number of shots is performed (statevector simulation). (Default True)
simulation = True: QASM or statevector simulation ; False: real quantum device (ibmq_16_melbourne). (Default True)
withnoise = True: simulate ibmq_16_melbourne noise and architecture; False: not noise model. (Default False)
Returns:
array: predicted labels.
"""
circuits_eng = to_qiskitcircuit(unshaped_params,diagrams_eng)
circuits_spa = to_qiskitcircuit(unshaped_params,diagrams_spa)
if withshots:
if simulation:
if withnoise:
# Build noise model from backend properties
backend = provider.get_backend('ibmq_16_melbourne')
noise_model = NoiseModel.from_backend(backend)
# Get coupling map from backend
coupling_map = backend.configuration().coupling_map
# Get basis gates from noise model
basis_gates = noise_model.basis_gates
else:
noise_model,coupling_map,basis_gates = None,None,None
backend=Aer.get_backend('qasm_simulator')
results=execute(circuits_eng+circuits_spa, backend=backend,shots=n_shots, noise_model=noise_model,
coupling_map=coupling_map,basis_gates=basis_gates).result().get_counts()
else:
ibmq_device='ibmq_16_melbourne'
backend=IBMQ.get_provider(group='internal').get_backend(ibmq_device)
results=execute(circuits_eng+circuits_spa, backend=backend,shots=n_shots).result().get_counts()
results_eng=results[:len(circuits_eng)]
results_spa=results[len(circuits_spa):]
pred_labels_distrs=[]
for countssent_eng in results_eng: #Loop over English sentences
for countssent_spa in results_spa: #Loop over Spanish sentences
predlabel=0
for bits in countssent_eng.keys():
if bits[q_s:]==len(bits[q_s:])*'0': #Postselection
if bits in countssent_spa.keys():
predlabel+=countssent_eng[bits]*countssent_spa[bits]
else:
predlabel+=0
counteng_select,countspa_select=0,0
for bits in countssent_eng.keys():
if bits[q_s:]==len(bits[q_s:])*'0':
counteng_select+=countssent_eng[bits]
for bits in countssent_spa.keys():
if bits[q_s:]==len(bits[q_s:])*'0':
countspa_select+=countssent_spa[bits]
if counteng_select==0 or countspa_select==0:
#print('Total postselction 0')
label=1e-9
else:
label=abs(predlabel/(counteng_select*countspa_select) - 1e-9) #Final label
pred_labels_distrs.append(label)
maxlabel=max(pred_labels_distrs)
pred_labels_distrs_norm=[x/maxlabel for x in pred_labels_distrs]
elif simulation:
backend=Aer.get_backend('statevector_simulator')
state_vector_dicts=[]
for circ in circuits_eng+circuits_spa:
circ.remove_final_measurements()
state_vector_dicts.append(Statevector(circ).to_dict())
qsen=[1,2]
pred_labels_distrs=[]
for countssent_eng in state_vector_dicts[:len(circuits_eng)]:
for countssent_spa in state_vector_dicts[len(circuits_spa):]:
predlabel=0
for bits in countssent_eng.keys():
selections = ['0' * qsen[0] + val + '0' * (len(bits) - qsen[1] - 1) for val in ['00', '01', '10', '11']]
if bits in selections: #Postselection
if bits in countssent_spa.keys():
predlabel+=abs(countssent_eng[bits]**2*countssent_spa[bits]**2)
else:
predlabel+=0
counteng_select,countspa_select=0,0
for bits in countssent_eng.keys():
if bits in selections:
counteng_select+=abs(countssent_eng[bits]**2)
for bits in countssent_spa.keys():
if bits in selections:
countspa_select+=abs(countssent_spa[bits]**2)
if counteng_select==0 or countspa_select==0:
label=1e-9
else:
label=abs(predlabel/(counteng_select*countspa_select) - 1e-9) #Final label
pred_labels_distrs.append(label)
maxlabel=max(pred_labels_distrs)
pred_labels_distrs_norm=[x/maxlabel for x in pred_labels_distrs]
return pred_labels_distrs_norm
####Two possible cost functions for the model (the function that the machine tries to minimize)
def get_cost_crossentropy(pred_labels_distrs):
"""Function to compute the binary cross-entropy from predicted labels.
Args:
pred_labels_distrs = array of predicted labels.
Returns:
float: binary cross-entropy.
"""
cross_entropies = np.array([int(train_labels[s]) * math.log2(pred_labels_distrs[s])
for s in range(len(train_labels)) if train_labels[s]!='x'])
return -1 / len([train_labels[s] for s in range(len(train_labels)) if train_labels[s]!='x']) * np.sum(cross_entropies)
def get_cost_absoluteerror(pred_labels_distrs):
"""Function to compute the absolute error of the predicted labels with respect to the correct ones.
Args:
pred_labels_distrs = array of predicted labels.
Returns:
float: absolute error.
"""
error = 0
train_size=0
for (i, res) in enumerate(pred_labels_distrs):
if train_labels[i]!='x':
train_size+=1
error+=abs(int(train_labels[i])-res)
return error * 100 / train_size
####Error functions for the model (a measure of how many sentences the quantum device translates correctly)
def get_train_error(pred_labels_distrs):
"""Function to compute the percentage of sentences in the training set that the predicted labels translate correctly.
Args:
pred_labels_distrs = array of predicted labels.
Returns:
float: percentage of correct translations.
"""
correct = 0
train_size=0
for (i, res) in enumerate(pred_labels_distrs):
if train_labels[i]!='x':
train_size+=1
try:
pred_result = round(res) #We are taking as 1 (same meaning) when the output is >0.5 and viceversa
except:
pred_result = None
else:
pass
train_result = round(int(train_labels[i]))
if train_result == pred_result:
correct += 1
return 100 - correct * 100 / train_size
def get_test_error(pred_labels_distrs):
"""Function to compute the percentage of sentences in the test set that the predicted labels translate correctly.
Args:
pred_labels_distrs = array of predicted labels.
Returns:
float: percentage of correct translations.
"""
correct = 0
test_size=0
for (i, res) in enumerate(pred_labels_distrs):
if test_labels[i]!='x':
test_size+=1
pred_result = round(res) #We are taking as 1 (same meaning) when the output is >0.5 and viceversa
test_result = round(int(test_labels[i]))
if test_result == pred_result:
correct += 1
return 100 - correct * 100 / test_size
####Other useful functions for performing optimization and tracking intermediate results
def objective_function(unshaped_params,costfunction=get_cost_absoluteerror): #cost_function=get_cost_crossentropy or
"""Objective function to perform an evaluation of the classical optimization from a specific set of parameters.
Args:
unshaped_params = parameters to the variationals circuits.
costfunction = cost function that will be minimized by the classical optimization method.
The options are "get_cost_crossentropy" or "get_cost_absoluteerror". (Default get_cost_absoluteerror)
Returns:
float: value of cost function.
"""
#To perform optimization
pred_labels_distrs=get_probs(unshaped_params,withshots=withshots,simulation=simulation,withnoise=withnoise)
cost=costfunction(pred_labels_distrs)
#To track the results
trainerror=get_train_error(pred_labels_distrs)
testerror=get_test_error(pred_labels_distrs)
cost_crossentr=get_cost_crossentropy(pred_labels_distrs)
cost_abserr=get_cost_absoluteerror(pred_labels_distrs)
tracking=callback(trainerror,testerror,cost_crossentr,cost_abserr)
return cost
def callback(trainerror,testerror,cost_crossentr,cost_abserr):
"""Function to track the results in each objective function evaluation.
Args:
trainerror = array of get_train_error values for each objective function evaluation.
testerror = array of get_test_error values for each objective function evaluation.
cost_crossentr = array of get_cost_crossentropy values for each objective function evaluation.
cost_abserr = array of get_cost_absoluteerror values for each objective function evaluation.
Returns:
-
"""
global error_train_history,error_test_history,cost_crossentropy_history,cost_abserror_history,nevaluations
error_train_history[run].append(trainerror)
error_test_history[run].append(testerror)
cost_crossentropy_history[run].append(cost_crossentr)
cost_abserror_history[run].append(cost_abserr)
print("Cost_AbsErr: {} ,Cost_CrossEntr: {} , ErrorTrain: {}, ErrorTest: {}".format(cost_abserr,cost_crossentr,
trainerror,testerror))
nevaluations+=1
print('NºEvals: ',nevaluations)
#************************************
# Quantum-Classical run: training and error calculation
#************************************
from time import time
from qiskit.algorithms.optimizers import COBYLA,SPSA,L_BFGS_B
####Experiment Parameters
n_runs = 1
niter = 2000
cost_function=get_cost_absoluteerror #costfunction=get_cost_crossentropy or get_cost_absoluteerror
method='SPSA' #Classical optimization method= 'COBYLA','SPSA' or'L_BFGS_B'
n_shots = 8192 # number of shots (maximum in real hardware: 8192)
withshots=True
simulation=True
withnoise=True
dataset='small' #dataset='small','medium','big'
####Data for the experiment
if dataset=='small':
#Diagrams
diagrams_eng = dataeng_new_psr_dict_small
diagrams_spa = dataspa_new_psr_dict_small
#Training and test labels
train_labels = train_labelslist_small
test_labels = test_labelslist_small
if dataset=='medium':
#Diagrams
diagrams_eng = dataeng_new_psr_dict_medium
diagrams_spa = dataspa_new_psr_dict_medium
#Training and test labels
train_labels = train_labelslist_medium
test_labels = test_labelslist_medium
if dataset=='big':
#Diagrams
diagrams_eng = dataeng_new_psr_dict_big
diagrams_spa = dataspa_new_psr_dict_big
#Training and test labels
train_labels = train_labelslist_big
test_labels = test_labelslist_big
####Classical Optimizers (from qiskit.algorithms.optimizers)
if method=='COBYLA':
optimizer=COBYLA(maxiter=niter)
elif method=='SPSA': #Some additional function evaluations are performed to calibrate the hyperparameters
optimizer=SPSA(maxiter=niter)
elif method=='L_BFGS_B':
optimizer=L_BFGS_B(maxiter=niter)
####Tracking variables
param_histories = [[] for r in range(n_runs)]
error_train_history,error_test_history = [[] for r in range(n_runs)],[[] for r in range(n_runs)]
cost_crossentropy_history,cost_abserror_history = [[] for r in range(n_runs)],[[] for r in range(n_runs)]
final_result=[]
####Running
for run in range(n_runs):
print('---------------------------------')
print('Start run ', run+1)
rand_unshaped_pars = randparams(par_shapes)
start = time()
nevaluations=0
res = optimizer.optimize(len(rand_unshaped_pars),objective_function,initial_point=rand_unshaped_pars) #Optimization
print("Parameters: {} ,CostFunction: {} , NºEvaluations: {}".format(res[0],res[1],res[2]))
final_result.append(res)
print('run', run+1, 'done')
print('Time taken: ', time() - start)
####Save the results
data = {'param_histories': param_histories,
'cost_crossentropy_history': cost_crossentropy_history,
'cost_abserror_history': cost_abserror_history,
'error_train_history': error_train_history,
'error_test_history': error_test_history,
'final_result': final_result}
with open('SIresults_it'+str(niter)+'_met'+method+'_size-'+dataset+'_sim'+str(simulation)+'_shots'+str(withshots)+
str(n_shots)+'_withnoise'+str(withnoise)+'_costabserr'+'_0.pickle', 'wb') as file_handle:
pickle.dump(data, file_handle)
#************************************
# Results
#************************************
import matplotlib.pyplot as plt
import pickle
import numpy as np
#######StateVector Simulations
#SPSA 200 iterations
with open('SIresults_it200_metSPSA_size-small_simTrue_shotsFalse8192_costabserr_0.pickle', 'rb') as f:
small_sv_spsa200=pickle.load(f)
with open('SIresults_it200_metSPSA_size-medium_simTrue_shotsFalse8192_costabserr_0.pickle', 'rb') as f:
medium_sv_spsa200=pickle.load(f)
with open('SIresults_it200_metSPSA_size-big_simTrue_shotsFalse8192_costabserr_0.pickle', 'rb') as f:
big_sv_spsa200=pickle.load(f)
#SPSA 1000 iterations
with open('SIresults_it1000_metSPSA_size-small_simTrue_shotsFalse8192_costabserr_0.pickle', 'rb') as f:
small_sv_spsa1000=pickle.load(f)
with open('SIresults_it1000_metSPSA_size-medium_simTrue_shotsFalse8192_withnoiseFalse_costabserr_0.pickle', 'rb') as f:
medium_sv_spsa1000=pickle.load(f)
with open('SIresults_it1000_metSPSA_size-big_simTrue_shotsFalse8192_withnoiseFalse_costabserr_0.pickle', 'rb') as f:
big_sv_spsa1000=pickle.load(f)
#COBYLA 1000 ev
with open('SIresults_it1000_metCOBYLA_size-small_simTrue_shotsFalse8192_costabserr_0.pickle', 'rb') as f:
small_sv_cobyla1000=pickle.load(f)
with open('SIresults_it1000_metCOBYLA_size-medium_simTrue_shotsFalse8192_withnoiseFalse_costabserr_0.pickle', 'rb') as f:
medium_sv_cobyla1000=pickle.load(f)
with open('SIresults_it1000_metCOBYLA_size-big_simTrue_shotsFalse8192_withnoiseFalse_costabserr_0.pickle', 'rb') as f:
big_sv_cobyla1000=pickle.load(f)
#######QASM Simulations
#200 iterations
with open('SIresults_it200_metSPSA_size-small_simTrue_shotsTrue8192_costabserr_0.pickle', 'rb') as f:
small_qs_spsa200=pickle.load(f)
with open('SIresults_it200_metSPSA_size-medium_simTrue_shotsTrue8192_costabserr_0.pickle', 'rb') as f:
medium_qs_spsa200=pickle.load(f)
with open('SIresults_it200_metSPSA_size-big_simTrue_shotsTrue8192_costabserr_0.pickle', 'rb') as f:
big_qs_spsa200=pickle.load(f)
#2000 iterations
with open('SIresults_it2000_metSPSA_size-small_simTrue_shotsTrue8192_costabserr_0.pickle', 'rb') as f: #
small_qs_spsa2000=pickle.load(f)
with open('SIresults_it2000_metSPSA_size-medium_simTrue_shotsTrue8192_costabserr_0.pickle', 'rb') as f:
medium_qs_spsa2000=pickle.load(f)
with open('SIresults_it2000_metSPSA_size-big_simTrue_shotsTrue8192_costabserr_0.pickle', 'rb') as f:
big_qs_spsa2000=pickle.load(f)
####Noisy QASM Simulations
#300 iterations
with open('SIresults_it300_metSPSA_size-medium_simTrue_shotsTrue8192_withnoiseTrue_costabserr_0.pickle', 'rb') as f:
medium_mel_spsa300=pickle.load(f)
with open('SIresults_it300_metSPSA_size-big_simTrue_shotsTrue8192_withnoiseTrue_costabserr_0.pickle', 'rb') as f:
big_mel_spsa300=pickle.load(f)
#Many iterations
with open('SIresults_it2000_metSPSA_size-small_simTrue_shotsTrue8192_withnoiseTrue_costabserr_0.pickle', 'rb') as f:
small_mel_spsa2000=pickle.load(f)
with open('SIresults_it1309_metSPSA_size-medium_simTrue_shotsTrue8192_withnoiseTrue_costabserr_0.pickle', 'rb') as f:
medium_mel_spsa2000=pickle.load(f)
with open('SIresults_it928_metSPSA_size-big_simTrue_shotsTrue8192_withnoiseTrue_costabserr_0.pickle', 'rb') as f:
big_mel_spsa2000=pickle.load(f)
####Functions to process the results obtained from SPSA optimization
def process_result(result,nit):
"""Function to process SPSA results.
Args:
result = array of specific results (cost function or error).
nit = number of iterations performed in SPSA optimization.
Returns:
array: processed results.
"""
res=result[-(nit*2):] #remove calibration steps
return [(res[i]+res[i+1])/2 for i in range(len(res)) if i%2==0]
def secondprocess_result(processresult,nit):
"""Function to obtain the trend of the results.
Args:
processresult = array of result processed by process_result.
nit = number of iterations performed in SPSA optimization.
Returns:
[array,array]: [np.arange of the points, trend].
"""
res = processresult
for number in range(20,0,-1):
if nit%number==0:
break
y = [sum([res[i+x] for x in range(number)])/number for i in range(len(processresult)) if i%number==0]
x = np.arange(0,nit,nit/len(y))
return x,y
#************************************
# Plot the Results
#************************************
fig, axes = plt.subplots(3,2,figsize=(35,42))
nit=[[1000,1000,1000],[2000,2000,2000],[2000,1308,928]]
font=35
lw=5
colors=['red','green','orange']
label=['Small','Medium','Big']
results=[[small_sv_spsa1000,medium_sv_spsa1000,big_sv_spsa1000],[small_qs_spsa2000,medium_qs_spsa2000,big_qs_spsa2000],
[small_mel_spsa2000,medium_mel_spsa2000,big_mel_spsa2000]]
titles=[r'Statevector simulation (NºShots=$\infty$)',r'QASM simulation (NºShots=8192)',
'IBMQ_16_Melbourne simulation (NºShots=8192)']
for (result,ax,title,iterations) in zip(results,axes[:,0],titles,nit):
for (res,col,lab,it) in zip(result,colors,label,iterations):
y=process_result(res['error_train_history'][0],it)[:it]
x=np.arange(0,len(y))
pl=ax.plot(x,y,color=col,alpha=0.3)
x2,y2 = secondprocess_result(y,it)
pl=ax.plot(x2,y2,color=col,label=lab,linewidth=lw)
ax.set_ylabel('Train Error (%)',fontsize=font)
ax.set_xlabel('SPSA iterations',fontsize=font)
ax.set_title(title,fontsize=font)
ax.tick_params(axis='both', labelsize=font)
leg=ax.legend(title='Dataset size',fontsize=font-3)
plt.setp(leg.get_title(),fontsize=font-3)
for (result,ax,title,iterations) in zip(results,axes[:,1],titles,nit):
for (res,col,lab,it) in zip(result,colors,label,iterations):
y=process_result(res['error_test_history'][0],it)
x=np.arange(0,len(y))
pl=ax.plot(x,y,color=col,alpha=0.3)
x2,y2 = secondprocess_result(y,it)
pl=ax.plot(x2,y2,color=col,label=lab,linewidth=lw,linestyle='--')
ax.set_ylabel('Test Error (%)',fontsize=font)
ax.set_xlabel('SPSA iterations',fontsize=font)
ax.set_title(title,fontsize=font)
ax.tick_params(axis='both', labelsize=font)
leg=ax.legend(title='Dataset size',fontsize=font-3)
plt.setp(leg.get_title(),fontsize=font-3)
plt.savefig('results_itSPSA.pdf')
plt.show(pl)
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/PaulaGarciaMolina/QNLP_Qiskit_Hackathon
|
PaulaGarciaMolina
|
import numpy as np
import pickle
from discopy import Ty, Word # Import the classes for the type of word and for the word
s, n = Ty('s'), Ty('n') # Define the types s and n
nphr, adj, tv, iv, vphr = Ty('NP'), Ty('ADJ'), Ty('TV'), Ty('IV'), Ty('VP')
# Define the words (notice that we include both meaning and grammar)
# nouns
man, woman, kid = Word('man', n), Word('woman', n), Word('kid', n)
# adjectives
morose, irascible = Word('morose', n @ n.l), Word('irascible', n @ n.l)
frightened, cheerful = Word('frightened', n @ n.l), Word('cheerful', n @ n.l)
gloomy, furious = Word('gloomy', n @ n.l), Word('furious', n @ n.l)
terrified, joyful = Word('terrified', n @ n.l), Word('joyful', n @ n.l)
downcast, miserable = Word('downcast', n @ n.l), Word('miserable', n @ n.l)
old, young = Word('old', n @ n.l), Word('young', n @ n.l)
# Intransitive verbs
cries, shouts = Word('cries', n.r @ s), Word('shouts', n.r @ s)
laughs, snaps = Word('laughs', n.r @ s), Word('snaps', n.r @ s)
# Transitive verbs
grieves, startles = Word('grieves', n.r @ s @ n.l), Word('startles', n.r @ s @ n.l)
entertains, irritates = Word('entertains', n.r @ s @ n.l), Word('irritates', n.r @ s @ n.l)
nouns = [man, woman, kid]
adjectives = [morose, irascible, frightened, cheerful, gloomy, furious, terrified, joyful, downcast, miserable, old, young]
int_verbs = [cries, shouts, laughs, snaps]
t_verbs = [grieves, startles, entertains, irritates]
vocab = nouns + int_verbs + t_verbs + adjectives
from discopy import Cup, Id, pregroup
# Store the grammatical structures in a dictionary
grammar_dict = {
'ADJ_N_IV' : Id(n) @ Cup(n.l, n) @ Id(n.r @ s) >> Cup(n, n.r) @ Id(s) >> Id(s),
'N_TV_N': Cup(n, n.r) @ Id(s) @ Cup(n.l, n),
'ADJ_N_TV_N': Id(n) @ Cup(n.l, n) @ Id(n.r @ s) @ Cup(n.l, n) >> Cup(n, n.r) @ Id(s) >> Id(s),
'N_TV_ADJ_N': Cup(n, n.r) @ Id(s) @ Cup(n.l, n) @ Cup(n.l, n) >> Id(s)}
# Create parsing (grammatical analysis) dictionary where the grammatical sentences
# are the keys and the associated values are the diagrams (words + grammar)
data_psr = {}
# Intransitive sentences
parsing_int = {"{} {} {}.".format(adj, noun, int_verb): adj @ noun @ int_verb >> grammar_dict['ADJ_N_IV']
for adj in adjectives for noun in nouns for int_verb in int_verbs}
sentences_int = list(parsing_int.keys())
for sentence in sentences_int:
diagram = parsing_int[sentence]
data_psr[sentence] = parsing_int[sentence]
# Transitive sentences (without adjective)
parsing_tra = {"{} {} {}.".format(subj, t_verb, obj): subj @ t_verb @ obj >> grammar_dict['N_TV_N']
for subj in nouns for t_verb in t_verbs for obj in nouns}
# Transitive sentences (with adjective)
parsing_tra_ladj = {"{} {} {} {}.".format(adj, subj, t_verb, obj): adj @ subj @ t_verb @ obj >> grammar_dict['ADJ_N_TV_N']
for adj in adjectives for subj in nouns for t_verb in t_verbs for obj in nouns}
parsing_tra_radj = {"{} {} {} {}.".format(subj, t_verb, adj, obj): subj @ t_verb @ adj @ obj >> grammar_dict['N_TV_ADJ_N']
for subj in nouns for t_verb in t_verbs for adj in adjectives for obj in nouns}
parsing_tra.update(parsing_tra_ladj) #merges transitive adjectives into original dict
parsing_tra.update(parsing_tra_radj)
sentences_tra = list(parsing_tra.keys())
for sentence in sentences_tra:
diagram = parsing_tra[sentence]
data_psr[sentence] = parsing_tra[sentence]
with open('../sentiment_analysis_dataset.txt') as f:
data = f.readlines()
from sklearn.model_selection import train_test_split
labels_dict = {}
data_psr_dict = {}
sent_type = {}
adjective_words = [a.name for a in adjectives]
for sentence in data:
sentstr = sentence[:-7]
if sentence[-6:-3] == 'int':
diagram = parsing_int[sentstr]
data_psr_dict[sentstr] = diagram
labels_dict[sentstr] = sentence[-2]
sent_type[sentstr] = 'int'
elif sentence[-6:-3] == 'tra':
diagram = parsing_tra[sentstr]
data_psr_dict[sentstr] = diagram
labels_dict[sentstr] = sentence[-2]
if len(sentstr.split()) == 4:
if sentstr.split()[0] in adjective_words:
sent_type[sentstr] = 'tra_' + 'l'
else:
sent_type[sentstr] = 'tra_' + 'r'
else:
sent_type[sentstr] = 'tra'
# Code of this cell addapted from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
from discopy import Cap, Box
data_new_psr_dict = {}
for sentstr in data_psr_dict.keys():
num_words = len(sentstr.split(' '))
words = data_psr_dict[sentstr].boxes[:num_words]
if sent_type[sentstr] == 'int':
noun = Box(words[1].name, n.l, Ty())
words_new = (Cap(n, n.l)) >> (words[0] @ Id(n) @ noun @ words[2])
sentence = words_new >> grammar_dict['ADJ_N_IV']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif 'tra' in sent_type[sentstr]:
if sent_type[sentstr] == 'tra':
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[2].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['N_TV_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif sent_type[sentstr] == 'tra_l': #adjective at beginning
noun1 = Box(words[1].name, n.l, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n, n.l) @ Cap(n, n.l)) >> (words[0] @ Id(n) @ noun1 @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['ADJ_N_TV_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif sent_type[sentstr] == 'tra_r': #adjective on second noun
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['N_TV_ADJ_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
vocab_psr = []
for word in vocab:
if word.cod == Ty('n'):
vocab_psr.append(Box(word.name, n.r, Ty())) # n.l case is dealt with in definition of quantum functor
else:
vocab_psr.append(word)
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
#*****************************************************
# Translation to quantum circuits
#*****************************************************
from discopy.quantum import Ket, IQPansatz, Bra, qubit
from discopy.quantum.circuit import Functor, Id
from discopy.quantum.circuit import Circuit
from functools import reduce, partial
from discopy.quantum.gates import Rx, Rz
q_s = 1 # number of qubits for type s (sentence)
q_n = 1 # number of qubits for type n (noun)
depth = 1 # depth of the IQPansatz
p_n = 3 # number of parameters for the single qubit iqp ansatz
# Define the dimensions of the objects of the circuit functor
ob = {s: q_s, n: q_n}
ob_cqmap = {s: qubit ** q_s, n: qubit ** q_n}
#-----------------------------------------
# parametrised part of ansaetze
#-----------------------------------------
def single_qubit_iqp_ansatz(params):
if len(params) == 1:
return Rx(params[0])
if len(params) == 2:
return Rx(params[0]) >> Rz(params[1])
if len(params) == 3:
return IQPansatz(1, params)
def ansatz_state(state, params):
arity = sum(ob[Ty(factor.name)] for factor in state.cod)
if arity == 1:
return Ket(0) >> single_qubit_iqp_ansatz(params)
return Ket(*tuple([0 for i in range(arity)])) >> IQPansatz(arity, params)
def ansatz_effect(effect, params):
arity = sum(ob[Ty(factor.name)] for factor in effect.dom)
if arity == 1:
return single_qubit_iqp_ansatz(params) >> Bra(0)
return IQPansatz(arity, params) >> Bra(*tuple([0 for i in range(arity)]))
def ansatz(box,params):
dom_type = box.dom
cod_type = box.cod
if len(dom_type) == 0 and len(cod_type) != 0:
return ansatz_state(box, params)
if len(dom_type) != 0 and len(cod_type) == 0:
return ansatz_effect(box, params)
#----------------------------------------------------------
# Define parametrised functor to quantum circuits
#----------------------------------------------------------def F(params):
def F(params):
ar = dict()
for i in range(len(vocab_psr)):
pgbox = vocab_psr[i]
qbox = ansatz(vocab_psr[i], params[i])
ar.update({pgbox: qbox})
if pgbox.cod == Ty():
ar.update({Box(pgbox.name, n.l, Ty()): qbox}) # send the effect with n.l to same quantum effect
return Functor(ob_cqmap, ar)
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
#*****************************************************
# Functions to deal with the parametrisation
#*****************************************************
def paramshapes(vocab_psr):
parshapes = []
for box in vocab_psr:
dom_type = box.dom
cod_type = box.cod
dom_arity = sum(ob[Ty(factor.name)] for factor in box.dom)
cod_arity = sum(ob[Ty(factor.name)] for factor in box.cod)
if dom_arity == 0 or cod_arity == 0: # states and effects
arity = max(dom_arity, cod_arity)
assert arity != 0
parshapes.append((depth, arity-1))
return parshapes
def paramshapes(vocab_psr):
parshapes = []
for box in vocab_psr:
dom_type = box.dom
cod_type = box.cod
dom_arity = sum(ob[Ty(factor.name)] for factor in box.dom)
cod_arity = sum(ob[Ty(factor.name)] for factor in box.cod)
if dom_arity == 0 or cod_arity == 0: # states and effects
arity = max(dom_arity, cod_arity)
assert arity != 0
if arity == 1:
parshapes.append((p_n,))
if arity != 1:
parshapes.append((depth, arity-1))
return parshapes
def randparams(par_shapes):
params = np.array([])
for i in range(len(par_shapes)):
params = np.concatenate((params, np.ravel(np.random.rand(*par_shapes[i])))) # np.ravel flattens an array
return params
def reshape_params(unshaped_pars, par_shapes):
pars_reshaped = [[] for ii in range(len(par_shapes))]
shift = 0
for ss, s in enumerate(par_shapes):
idx0 = 0 + shift
if len(s) == 1:
idx1 = s[0] + shift
elif len(s) == 2:
idx1 = s[0] * s[1] + shift
pars_reshaped[ss] = np.reshape(unshaped_pars[idx0:idx1], s)
if len(s) == 1:
shift += s[0]
elif len(s) == 2:
shift += s[0] * s[1]
return pars_reshaped
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
#****************************************
# Parameters of the current model
#****************************************
par_shapes = paramshapes(vocab_psr)
rand_unshaped_pars = randparams(par_shapes)
rand_shaped_pars = reshape_params(rand_unshaped_pars, par_shapes)
print('Number of parameters: ', len(rand_unshaped_pars))
from sklearn.model_selection import train_test_split
psr_diagrams = []
psr_diagrams_dict = {}
psr_labels = []
sentences = []
for sentstr in data_new_psr_dict.keys():
sentences.append(sentstr)
diagram = data_new_psr_dict[sentstr]
psr_diagrams.append(diagram)
psr_diagrams_dict[sentstr] = diagram
if labels_dict[sentstr] == '0':
label = np.array([1,0,0,0])
elif labels_dict[sentstr] == '1':
label = np.array([0,1,0,0])
elif labels_dict[sentstr] == '2':
label = np.array([0,0,1,0])
elif labels_dict[sentstr] == '3':
label = np.array([0,0,0,1])
psr_labels.append(label)
train_data_psr, test_data_psr, train_labels, test_labels = \
train_test_split(psr_diagrams, psr_labels, test_size=0.25, random_state=42)
train_sent, test_sent, train_labels_sent, test_labels_sent = \
train_test_split(sentences, psr_labels, test_size=0.25, random_state=42)
from qiskit import BasicAer, Aer, execute, ClassicalRegister
from pytket.extensions.qiskit import tk_to_qiskit
from qiskit.quantum_info import Statevector
import matplotlib.pyplot as plt
def process_dataset(dataset):
""" Process a QNLP dataset.
Args:
dataset: txt dataset to be processed.
Returns:
psr_diagrams: parsing diagrams.
psr_labels: labels.
sentences: sentences.
sent_type: dictionary with the sentence type for each sentence.
"""
with open(dataset) as f:
data = f.readlines()
labels_dict = {} # Dictionary with the labels for each sentence
data_psr_dict = {} # Dictionary with the parsing for each sentence
sent_type = {} # Dictionary with the sentence type for each sentence
# Create the previous dictionaries from the given dataset
adjective_words = [a.name for a in adjectives]
for sentence in data:
sentstr = sentence[:-7]
if sentence[-6:-3] == 'int':
diagram = parsing_int[sentstr]
data_psr_dict[sentstr] = diagram
labels_dict[sentstr] = sentence[-2]
sent_type[sentstr] = 'int'
elif sentence[-6:-3] == 'tra':
diagram = parsing_tra[sentstr]
data_psr_dict[sentstr] = diagram
labels_dict[sentstr] = sentence[-2]
if len(sentstr.split()) == 4:
if sentstr.split()[0] in adjective_words:
sent_type[sentstr] = 'tra_' + 'l'
else:
sent_type[sentstr] = 'tra_' + 'r'
else:
sent_type[sentstr] = 'tra'
# Rearrange the parsing of the diagrams
data_new_psr_dict = {}
for sentstr in data_psr_dict.keys():
num_words = len(sentstr.split(' '))
words = data_psr_dict[sentstr].boxes[:num_words]
if sent_type[sentstr] == 'int':
noun = Box(words[1].name, n.l, Ty())
words_new = (Cap(n, n.l)) >> (words[0] @ Id(n) @ noun @ words[2]) # Rearranged words
sentence = words_new >> grammar_dict['ADJ_N_IV'] # Apply grammar on rearranged words
data_new_psr_dict[sentstr] = sentence.normal_form() # Store sentece with optimum diagram
elif 'tra' in sent_type[sentstr]:
if sent_type[sentstr] == 'tra':
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[2].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['N_TV_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif sent_type[sentstr] == 'tra_l': #adjective at beginning
noun1 = Box(words[1].name, n.l, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n, n.l) @ Cap(n, n.l)) >> (words[0] @ Id(n) @ noun1 @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['ADJ_N_TV_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif sent_type[sentstr] == 'tra_r': #adjective on second noun
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['N_TV_ADJ_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
# Store the diagrams, labels and sentences for the classification
psr_diagrams = []
psr_diagrams_dict = {}
psr_labels = []
sentences = []
for sentstr in data_new_psr_dict.keys():
sentences.append(sentstr)
diagram = data_new_psr_dict[sentstr]
psr_diagrams.append(diagram)
psr_diagrams_dict[sentstr] = diagram
if labels_dict[sentstr] == '0':
label = np.array([1,0])
elif labels_dict[sentstr] == '1':
label = np.array([0,1])
psr_labels.append(label)
return psr_diagrams, psr_labels, sentences, sent_type
def get_cost_and_final_params(file):
""" Get cost and finals params of a simulation file.
Args:
file = pickle simulation file.
Returns:
cost = cost of the training.
final_params = final parameters.
"""
# Load file with the results
with open(file, "rb") as fp:
data = pickle.load(fp)
# Store final params
final_params = data[0][0]
# Process stored cost
cost_data = data[1][:-1]
cost_save_plus = []
cost_save_minus = []
for j in range(0,len(cost_data)):
if j % 2:
cost_save_plus.append(cost_data[j])
else:
cost_save_minus.append(cost_data[j])
cost_save_plus = np.asarray(cost_save_plus)
cost_save_minus = np.asarray(cost_save_minus)
cost = 0.5 * (cost_save_plus+cost_save_minus)
return cost[25:], final_params
def get_qiskit_results(circ, s_type, retries=10, qasm=False, noise_model=None,
basis_gates=None, coupling_map=None, max_shots=8192):
"""Function to get the Qiskit's results from a DisCoPy circuit.
Args:
circ = DisCoPy circuit.
s_type = sentence type for the sentence associated to the circuit.
retries = number of retries before assigning a random result
if the postselection leads to zero values (Default is 10).
qasm = if True qasm_simulator is used, if not statevector_simulator
(Default is False).
noise_model = Qiskit's noise model object (Default is None).
basis_gates = basis gates of the device (Default is None).
coupling_map = coupling_map of the device (Default is None).
max_shots = number of shots (Default is 8192).
Returns:
array: results from the postselection measurement.
"""
# Select qubits for postselection according to the sentence type
if s_type == 'int':
n_qubits = 4
post = 2
elif s_type == 'tra':
n_qubits = 3
post = 1
elif s_type == 'tra_l':
n_qubits = 5
post = 2
else:
assert s_type == 'tra_r'
n_qubits = 5
post = 1
# From DisCoPy to Qiskit circuit
qc = tk_to_qiskit(circ.to_tk())
if qasm == True:
#qasm_simulator
out_reg = ClassicalRegister(1)
qc.add_register(out_reg)
qc.measure(post, out_reg[0])
if noise_model is not None:
backend = Aer.get_backend('qasm_simulator')
# Include noise model
results = execute(qc, backend, shots=max_shots, noise_model=noise_model,
coupling_map=coupling_map,basis_gates=basis_gates).result().get_counts()
else:
backend = BasicAer.get_backend('qasm_simulator')
results = execute(qc, backend, shots=max_shots).result().get_counts()
zeros = '0' * (n_qubits - 1)
if '0 ' + zeros not in results and '1 ' + zeros not in results:
if retries == 0:
return np.random.rand(2)
return get_qiskit_results(circ, s_type, retries=retries-1, qasm = qasm,
noise_model=noise_model, coupling_map=coupling_map,
basis_gates=basis_gates, max_shots=max_shots)
return parse_results(results, eff=zeros)
else:
# statevector_simulator
qc.remove_final_measurements()
state_dict = Statevector(qc).to_dict()
post0, post1 = '0' * n_qubits, '0' * n_qubits
post1 = post1[:post] + '1' + post1[post + 1:]
return [np.abs(state_dict[post0])**2, np.abs(state_dict[post1])**2]
def parse_results(results, eff='0'):
"""Parse results of qasm_simulator.
Args:
results: counts from quantum circuit's measurement.
eff: digits for splitting the results for post selection.
Returns:
array: post selected results.
"""
ks = [k for k in results.keys() if k.split()[1] == eff]
post_selected_results = {k.split()[0]:v for (k,v) in results.items() if k in ks}
if '0' not in post_selected_results:
post_selected_results['0'] = 0
if '1' not in post_selected_results:
post_selected_results['1'] = 0
total = post_selected_results['0'] + post_selected_results['1']
assert total > 0, 'total was 0 after postselection - try running with more shots'
return [post_selected_results['0']/total, post_selected_results['1']/total]
def obtain_train_predictions(final_params,train_data_cla, train_labels_cla,
train_sent_cla, sent_type, qasm=False, noise_model=None,
basis_gates=None, coupling_map=None, max_shots=8192):
""" Obtain train set predictions from the binary training
classifiers for 1vs1 classification.
Args:
final_params = final params for the optimization for each classifier.
train_data_cla = list of the training circuits
for each classifier.
train_labels_cla = list of the training labels
for each classifier.
train_sent_cla = list of the training sentences
for each classifier.
sent_type = dictionary sentences to sentence type.
qasm = if True qasm_simulator is used, if not statevector_simulator
(Default is False).
noise_model = Qiskit's noise model object (Default is None).
basis_gates = basis gates of the device (Default is None).
coupling_map = coupling_map of the device (Default is None).
max_shots = number of shots (Default is 8192).
Returns:
final_pred_test_results = test set predicted labels.
"""
# Create list for train predictions of each classifier
train_results_cla = []
for j in range(len(train_data_cla)):
train_pred = []
# Obtain train predicted results
func = F(reshape_params(final_params[j], par_shapes))
train_data_psr = train_data_cla[j]
train_labels_psr = train_labels_cla[j]
train_sent = train_sent_cla[j]
final_train_circuits = [func(diag) for diag in train_data_psr]
train_results = [get_qiskit_results(final_train_circuits[i], sent_type[train_sent[i]], qasm=qasm,
noise_model=noise_model, coupling_map=coupling_map,
basis_gates=basis_gates, max_shots=max_shots) for i in range(len(train_sent))]
train_results_tweaked = [np.abs(np.array(res) - 1e-9) for res in train_results]
pred_train_results = [res.flatten() / np.sum(res) for res in train_results_tweaked]
for i, res in enumerate(pred_train_results):
res = np.argmax(res)
train_pred.append(res)
train_results_cla.append(train_pred)
return train_results_cla
def obtain_test_predictions(final_params, sent_type, test_data_psr,
test_sent, qasm=False, noise_model=None,
basis_gates=None, coupling_map=None, max_shots=8192):
""" Obtain test set predictions from the binary training
classifiers for 1vs1 classification.
Args:
final_params = final params for the optimization for each classifier.
train_data_cla = list of the training circuits
for each classifier.
train_labels_cla = list of the training labels
for each classifier.
train_sent_cla = list of the training sentences
for each classifier.
sent_type = dictionary sentences to sentence type.
test_data_psr = test data.
test_sent = test_sentences.
qasm = if True qasm_simulator is used, if not statevector_simulator
(Default is False).
noise_model = Qiskit's noise model object (Default is None).
basis_gates = basis gates of the device (Default is None).
coupling_map = coupling_map of the device (Default is None).
max_shots = number of shots (Default is 8192).
Returns:
train_pred_results_cla = train set predicted labels for
each classifier.
final_pred_test_results = test set predicted labels.
"""
# Create list for test predictions of each classifier
test_pred = [None]*len(test_data_psr)
for i in range(len(test_data_psr)):
test_pred[i] = np.zeros(4)
for j in range(len(train_data_cla)):
func = F(reshape_params(final_params[j], par_shapes))
# Obtain test predicted results
final_test_circuits = [func(diag) for diag in test_data_psr]
test_results = [get_qiskit_results(final_test_circuits[i], sent_type[test_sent[i]], qasm=qasm,
noise_model=noise_model, coupling_map=coupling_map,
basis_gates=basis_gates, max_shots=max_shots) for i in range(len(test_sent))]
test_results_tweaked = [np.abs(np.array(res) - 1e-9) for res in test_results]
pred_test_results = [res.flatten() / np.sum(res) for res in test_results_tweaked]
# For the test results, add one for the element of the list test_pred
# whose index correspond to the resulting label.
for i, res in enumerate(pred_test_results):
res = np.argmax(res)
if j == 0:
if res == 0:
test_pred[i][0] += 1
elif res == 1:
test_pred[i][1] += 1
elif j == 1:
if res == 0:
test_pred[i][0] += 1
elif res == 1:
test_pred[i][2] += 1
elif j == 2:
if res == 0:
test_pred[i][0] += 1
elif res == 1:
test_pred[i][3] += 1
elif j == 3:
if res == 0:
test_pred[i][1] += 1
elif res == 1:
test_pred[i][2] += 1
elif j == 4:
if res == 0:
test_pred[i][1] += 1
elif res == 1:
test_pred[i][3] += 1
elif j == 5:
if res == 0:
test_pred[i][2] += 1
elif res == 1:
test_pred[i][3] += 1
# Obtain the most common label as test result
final_pred_test_results = []
for res in test_pred:
final_pred_test_results.append(select_label(res))
return final_pred_test_results
import random
def select_label(res):
""" Select label for test result.
Args:
res = test result for 1vs1 multi-class classification.
Returns:
int = test data predicted label"""
indices = []
max_label = max(res)
for i, r in enumerate(res):
if r == max_label:
indices.append(i)
# Choose the result randomly among the most common ones if they
# appear an equal number of times.
if len(indices) > 1 :
return random.choice(indices)
else:
return indices[0]
def print_accuracy(y_true, y_pred):
""" Print the final accuracy and the accuracy for each label
for set of predicted and true labels.
Args:
y_true = true labels.
y_pred = predicted labels.
"""
c_matrix = confusion_matrix(y_true, y_pred)
labels = np.arange(c_matrix.shape[0])
print('Total accuracy: ', sum(np.diag(c_matrix))/len(y_true))
for label in labels:
print(f'Accuracy label {label}: ', c_matrix[label,label]/sum(c_matrix[label,:]))
import pickle
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
from sklearn.metrics import confusion_matrix
# Define the binary classifiers names
classifiers = ['happy_vs_sad', 'happy_vs_angry', 'happy_vs_scared', 'sad_vs_angry', 'sad_vs_scared', 'angry_vs_scared']
# Define figure for cost plot
fig, ax = plt.subplots(2,3, figsize=(25,10))
# Define figure for test confusion matrices
fig3, ax3 = plt.subplots(1,2, figsize=(15,5))
colors = ['deepskyblue','rebeccapurple']
ax = ax.ravel()
max_shots = 8192
# Obtain the results for the different simulators
for s, simul in enumerate(['statevector', 'qasm']):
if simul == 'statevector':
qasm = False
else:
qasm = True
# Store the training data
final_params_cla = []
train_data_cla = []
train_labels_cla = []
train_sent_cla = []
ax = ax.ravel()
for i, cla in enumerate(classifiers):
results = f'./1vs1_results/sentiment_analysis_1vs1_train_{cla}_cost_train_niter2000_{simul}.pkl'
cost, final_params = get_cost_and_final_params(results)
final_params_cla.append(final_params)
dataset = f'./1vs1_datasets/train_{cla}.txt'
psr_diagrams, psr_labels, sentences, _ = process_dataset(dataset)
ax[i].plot(cost, label = f'{simul}_simulator', color = colors[s])
ax[i].set_title(cla)
ax[i].set_xlabel('Iterations')
ax[i].set_ylabel('Cost')
train_data_cla.append(psr_diagrams)
train_labels_cla.append(psr_labels)
train_sent_cla.append(sentences)
ax[0].legend()
train_results_cla = obtain_train_predictions(final_params_cla,
train_data_cla, train_labels_cla,
train_sent_cla, sent_type, qasm=qasm)
final_pred_test_results = obtain_test_predictions(final_params_cla, sent_type,
test_data_psr, test_sent, qasm=qasm)
fig2, ax2 = plt.subplots(2,3, figsize=(25,10))
ax2 = ax2.ravel()
fig2.suptitle(f'Confusion matrix training data {simul}_simulator')
for k, train_pred in enumerate(train_results_cla):
y_true = [np.argmax(train_label) for train_label in train_labels_cla[k]]
y_pred = train_pred
c_matrix = confusion_matrix(y_true, y_pred)
print(f'Accuracy training set {classifiers[k]} ({simul}_simulator)')
print_accuracy(y_true, y_pred)
labels = [classifiers[k].split('_')[0], classifiers[k].split('_')[2]]
df_cm = pd.DataFrame(c_matrix, labels, labels)
df_cm.index.name = 'Actual'
df_cm.columns.name = 'Predicted'
sns.heatmap(df_cm, ax=ax2[k], annot=True, annot_kws={"size": 16},cmap='viridis',
xticklabels=True, yticklabels=True)
ax2[k].set_title(classifiers[k])
fig3.suptitle(f'Confusion matrix test data')
y_true = [np.argmax(test_label) for test_label in test_labels]
y_pred = final_pred_test_results
c_matrix = confusion_matrix(y_true, y_pred)
print(f'Accuracy test set ({simul}_simulator)')
print_accuracy(y_true, y_pred)
df_cm = pd.DataFrame(c_matrix, ['happy','sad','angry','scared'], ['happy','sad','angry','scared'])
df_cm.index.name = 'Actual'
df_cm.columns.name = 'Predicted'
sns.heatmap(df_cm, ax=ax3[s], annot=True, annot_kws={"size": 16},cmap='viridis',
xticklabels=True, yticklabels=True)
ax3[s].set_title(f'{simul}_simulator')
rep = 100
classifiers = ['happy_vs_sad', 'happy_vs_angry', 'happy_vs_scared', 'sad_vs_angry', 'sad_vs_scared', 'angry_vs_scared']
for s, simul in enumerate(['statevector', 'qasm']):
if simul == 'statevector':
qasm = False
else:
qasm = True
final_params_cla = []
accuracy = 0
for i, cla in enumerate(classifiers):
results = f'./1vs1_results/sentiment_analysis_1vs1_train_{cla}_cost_train_niter2000_{simul}.pkl'
cost, final_params = get_cost_and_final_params(results)
final_params_cla.append(final_params)
for i in range(rep):
final_pred_test_results = obtain_test_predictions(final_params_cla, sent_type,
test_data_psr, test_sent, qasm=qasm)
y_true = [np.argmax(test_label) for test_label in test_labels]
y_pred = final_pred_test_results
c_matrix = confusion_matrix(y_true, y_pred)
accuracy += sum(np.diag(c_matrix))/len(y_true)
print(f'Accuracy test set ({simul}_simulator) averaged over {rep} repetitions:', accuracy/rep)
# Define the binary classifiers names
classifiers = ['happy_vs_sad', 'happy_vs_angry', 'happy_vs_scared', 'sad_vs_angry', 'sad_vs_scared', 'angry_vs_scared']
# Define figure for cost plot
fig, ax = plt.subplots(2,3, figsize=(25,10))
# Define figure for test confusion matrices
fig3, ax3 = plt.subplots(1,3, figsize=(25,5))
colors = ['deepskyblue','rebeccapurple','yellowgreen']
ax = ax.ravel()
noise_model = None
coupling_map = None
basis_gates= None
max_shots = 8192
# Obtain the results for the different simulators
for s, simul in enumerate(['statevector', 'qasm', 'qasm_noise']):
if simul == 'statevector':
niter = 2000
qasm = False
elif simul == 'qasm':
niter = 2000
qasm = True
elif simul == 'qasm_noise':
niter = 500
qasm = True
with open(f'./noise_model_melbourne.pkl', "rb") as fp:
data = pickle.load(fp)
noise_model, coupling_map, basis_gates = data[0], data[1], data[2]
# Store the training data
final_params_cla = []
train_data_cla = []
train_labels_cla = []
train_sent_cla = []
ax = ax.ravel()
for i, cla in enumerate(classifiers):
results = f'./1vs1_results/sentiment_analysis_1vs1_train_{cla}_cost_entropy_niter{niter}_{simul}.pkl'
if simul == 'qasm_noise':
with open(results, "rb") as fp:
data = pickle.load(fp)
cost, final_params = data[1], data[0][0]
else:
cost, final_params = get_cost_and_final_params(results)
final_params_cla.append(final_params)
dataset = f'./1vs1_datasets/train_{cla}.txt'
psr_diagrams, psr_labels, sentences, _ = process_dataset(dataset)
ax[i].plot(cost, label = f'{simul}_simulator', color = colors[s])
ax[i].set_title(cla)
ax[i].set_xlabel('Iterations')
ax[i].set_ylabel('Cost')
train_data_cla.append(psr_diagrams)
train_labels_cla.append(psr_labels)
train_sent_cla.append(sentences)
ax[0].legend()
train_results_cla = obtain_train_predictions(final_params_cla,
train_data_cla, train_labels_cla,
train_sent_cla, sent_type, qasm=qasm,
noise_model=noise_model, coupling_map=coupling_map,
basis_gates=basis_gates, max_shots=max_shots)
final_pred_test_results = obtain_test_predictions(final_params_cla, sent_type,
test_data_psr, test_sent, qasm=qasm,
noise_model=noise_model, coupling_map=coupling_map,
basis_gates=basis_gates, max_shots=max_shots)
fig2, ax2 = plt.subplots(2,3, figsize=(25,10))
ax2 = ax2.ravel()
fig2.suptitle(f'Confusion matrix training data {simul}_simulator')
for k, train_pred in enumerate(train_results_cla):
y_true = [np.argmax(train_label) for train_label in train_labels_cla[k]]
y_pred = train_pred
c_matrix = confusion_matrix(y_true, y_pred)
print(f'Accuracy training set {classifiers[k]} ({simul}_simulator)')
print_accuracy(y_true, y_pred)
labels = [classifiers[k].split('_')[0], classifiers[k].split('_')[2]]
df_cm = pd.DataFrame(c_matrix, labels, labels)
df_cm.index.name = 'Actual'
df_cm.columns.name = 'Predicted'
sns.heatmap(df_cm, ax=ax2[k], annot=True, annot_kws={"size": 16},cmap='viridis',
xticklabels=True, yticklabels=True)
ax2[k].set_title(classifiers[k])
fig3.suptitle(f'Confusion matrix test data')
y_true = [np.argmax(test_label) for test_label in test_labels]
y_pred = final_pred_test_results
c_matrix = confusion_matrix(y_true, y_pred)
print(f'Accuracy test set ({simul}_simulator)')
print_accuracy(y_true, y_pred)
df_cm = pd.DataFrame(c_matrix, ['happy','sad','angry','scared'], ['happy','sad','angry','scared'])
df_cm.index.name = 'Actual'
df_cm.columns.name = 'Predicted'
sns.heatmap(df_cm, ax=ax3[s], annot=True, annot_kws={"size": 16},cmap='viridis',
xticklabels=True, yticklabels=True)
ax3[s].set_title(f'{simul}_simulator')
rep = 100
classifiers = ['happy_vs_sad', 'happy_vs_angry', 'happy_vs_scared', 'sad_vs_angry', 'sad_vs_scared', 'angry_vs_scared']
noise_model = None
coupling_map = None
basis_gates= None
for s, simul in enumerate(['statevector', 'qasm', 'qasm_noise']):
if simul == 'statevector':
niter = 2000
qasm = False
elif simul == 'qasm':
niter = 2000
qasm = True
elif simul == 'qasm_noise':
niter = 500
qasm = True
with open(f'./noise_model_melbourne.pkl', "rb") as fp:
data = pickle.load(fp)
noise_model, coupling_map, basis_gates = data[0], data[1], data[2]
final_params_cla = []
accuracy = 0
for i, cla in enumerate(classifiers):
results = f'./1vs1_results/sentiment_analysis_1vs1_train_{cla}_cost_entropy_niter{niter}_{simul}.pkl'
if simul == 'qasm_noise':
with open(results, "rb") as fp:
data = pickle.load(fp)
cost, final_params = data[1], data[0][0]
else:
cost, final_params = get_cost_and_final_params(results)
final_params_cla.append(final_params)
for i in range(rep):
final_pred_test_results = obtain_test_predictions(final_params_cla, sent_type,
test_data_psr, test_sent, qasm=qasm,
noise_model=noise_model, coupling_map=coupling_map,
basis_gates=basis_gates, max_shots=max_shots)
y_true = [np.argmax(test_label) for test_label in test_labels]
y_true = [np.argmax(test_label) for test_label in test_labels]
y_pred = final_pred_test_results
c_matrix = confusion_matrix(y_true, y_pred)
accuracy += sum(np.diag(c_matrix))/len(y_true)
print(f'Accuracy test set ({simul}_simulator) averaged over {rep} repetitions:', accuracy/rep)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/PaulaGarciaMolina/QNLP_Qiskit_Hackathon
|
PaulaGarciaMolina
|
import numpy as np
import pickle
from discopy import Ty, Word # Import the classes for the type of word and for the word
s, n = Ty('s'), Ty('n') # Define the types s and n
# Define the words
# Nouns
man, woman, kid = Word('man', n), Word('woman', n), Word('kid', n)
# Adjectives
morose, irascible = Word('morose', n @ n.l), Word('irascible', n @ n.l)
frightened, cheerful = Word('frightened', n @ n.l), Word('cheerful', n @ n.l)
gloomy, furious = Word('gloomy', n @ n.l), Word('furious', n @ n.l)
terrified, joyful = Word('terrified', n @ n.l), Word('joyful', n @ n.l)
downcast, miserable = Word('downcast', n @ n.l), Word('miserable', n @ n.l)
old, young = Word('old', n @ n.l), Word('young', n @ n.l)
# Intransitive verbs
cries, shouts = Word('cries', n.r @ s), Word('shouts', n.r @ s)
laughs, snaps = Word('laughs', n.r @ s), Word('snaps', n.r @ s)
# Transitive verbs
grieves, startles = Word('grieves', n.r @ s @ n.l), Word('startles', n.r @ s @ n.l)
entertains, irritates = Word('entertains', n.r @ s @ n.l), Word('irritates', n.r @ s @ n.l)
nouns = [man, woman, kid]
adjectives = [morose, irascible, frightened, cheerful, gloomy, furious, terrified, joyful, downcast, miserable, old, young]
int_verbs = [cries, shouts, laughs, snaps]
t_verbs = [grieves, startles, entertains, irritates]
vocab = nouns + int_verbs + t_verbs + adjectives
from discopy import Cup, Id, pregroup
grammar = Id(n) @ Cup(n.l, n) @ Id(n.r @ s) >> Cup(n, n.r) @ Id(s) >> Id(s)
sentence = joyful @ woman @ laughs >> grammar
pregroup.draw(sentence)
grammar = Cup(n, n.r) @ Id(s) @ Cup(n.l, n)
sentence = woman @ grieves @ kid >> grammar
pregroup.draw(sentence)
grammar = Id(n) @ Cup(n.l, n) @ Id(n.r @ s) @ Cup(n.l, n) >> Cup(n, n.r) @ Id(s) >> Id(s)
sentence = morose @ woman @ grieves @ kid >> grammar
pregroup.draw(sentence)
grammar = Cup(n, n.r) @ Id(s) @ Cup(n.l, n) @ Cup(n.l, n) >> Id(s)
sentence = man @ grieves @ morose @ man >> grammar
pregroup.draw(sentence)
# Store the grammatical structures in a dictionary
grammar_dict = {
'ADJ_N_IV' : Id(n) @ Cup(n.l, n) @ Id(n.r @ s) >> Cup(n, n.r) @ Id(s) >> Id(s),
'N_TV_N': Cup(n, n.r) @ Id(s) @ Cup(n.l, n),
'ADJ_N_TV_N': Id(n) @ Cup(n.l, n) @ Id(n.r @ s) @ Cup(n.l, n) >> Cup(n, n.r) @ Id(s) >> Id(s),
'N_TV_ADJ_N': Cup(n, n.r) @ Id(s) @ Cup(n.l, n) @ Cup(n.l, n) >> Id(s)}
# Create parsing (grammatical analysis) dictionary where the grammatical sentences
# are the keys and the associated values are the diagrams (words + grammar)
data_psr = {}
# Intransitive sentences
parsing_int = {"{} {} {}.".format(adj, noun, int_verb): adj @ noun @ int_verb >> grammar_dict['ADJ_N_IV']
for adj in adjectives for noun in nouns for int_verb in int_verbs}
sentences_int = list(parsing_int.keys())
for sentence in sentences_int:
diagram = parsing_int[sentence]
data_psr[sentence] = parsing_int[sentence]
# Transitive sentences (without adjective)
parsing_tra = {"{} {} {}.".format(subj, t_verb, obj): subj @ t_verb @ obj >> grammar_dict['N_TV_N']
for subj in nouns for t_verb in t_verbs for obj in nouns}
# Transitive sentences (with adjective)
parsing_tra_ladj = {"{} {} {} {}.".format(adj, subj, t_verb, obj): adj @ subj @ t_verb @ obj >> grammar_dict['ADJ_N_TV_N']
for adj in adjectives for subj in nouns for t_verb in t_verbs for obj in nouns}
parsing_tra_radj = {"{} {} {} {}.".format(subj, t_verb, adj, obj): subj @ t_verb @ adj @ obj >> grammar_dict['N_TV_ADJ_N']
for subj in nouns for t_verb in t_verbs for adj in adjectives for obj in nouns}
parsing_tra.update(parsing_tra_ladj) #merges transitive adjectives into original dict
parsing_tra.update(parsing_tra_radj)
sentences_tra = list(parsing_tra.keys())
for sentence in sentences_tra:
diagram = parsing_tra[sentence]
data_psr[sentence] = parsing_tra[sentence]
with open('../sentiment_analysis_dataset.txt') as f:
data = f.readlines()
labels_dict = {} # Dictionary with the labels for each sentence
data_psr_dict = {} # Dictionary with the parsing for each sentence
sent_type = {} # Dictionary with the sentence type for each sentence
adjective_words = [a.name for a in adjectives]
for sentence in data:
sentstr = sentence[:-7] #seperates the sentence string from the data at the end
if sentence[-6:-3] == 'int':
diagram = parsing_int[sentstr]
data_psr_dict[sentstr] = diagram
labels_dict[sentstr] = sentence[-2]
sent_type[sentstr] = 'int'
elif sentence[-6:-3] == 'tra':
diagram = parsing_tra[sentstr]
data_psr_dict[sentstr] = diagram
labels_dict[sentstr] = sentence[-2]
if len(sentstr.split()) == 4:
if sentstr.split()[0] in adjective_words:
sent_type[sentstr] = 'tra_' + 'l' #adjective on the left
else:
sent_type[sentstr] = 'tra_' + 'r' #adjective on the right
else:
sent_type[sentstr] = 'tra' #the simple transitive verb sentence type
c0 = 0
c1 = 0
c2 = 0
c3 = 0
for value in labels_dict.values():
if value == '0':
c0 +=1
elif value == '1':
c1 += 1
elif value == '2':
c2 += 1
elif value == '3':
c3 += 1
print('Number of elements for each sentiment')
print('Happy: ', c0)
print('Sad: ', c1)
print('Angry: ', c2)
print('Scared: ', c3)
print('Total: ', len(data_psr_dict))
from discopy import Cap, Box
# Code of this cell addapted from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
data_new_psr_dict = {}
for sentstr in data_psr_dict.keys():
num_words = len(sentstr.split(' '))
words = data_psr_dict[sentstr].boxes[:num_words]
if sent_type[sentstr] == 'int':
noun = Box(words[1].name, n.l, Ty())
words_new = (Cap(n, n.l)) >> (words[0] @ Id(n) @ noun @ words[2]) # Rearranged words
sentence = words_new >> grammar_dict['ADJ_N_IV'] # Apply grammar on rearranged words
data_new_psr_dict[sentstr] = sentence.normal_form() # Store sentece with optimum diagram
elif 'tra' in sent_type[sentstr]:
if sent_type[sentstr] == 'tra':
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[2].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['N_TV_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif sent_type[sentstr] == 'tra_l': #adjective at beginning
noun1 = Box(words[1].name, n.l, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n, n.l) @ Cap(n, n.l)) >> (words[0] @ Id(n) @ noun1 @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['ADJ_N_TV_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif sent_type[sentstr] == 'tra_r': #adjective on second noun
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['N_TV_ADJ_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
vocab_psr = []
for word in vocab:
if word.cod == Ty('n'):
vocab_psr.append(Box(word.name, n.r, Ty())) # n.l case is dealt with in definition of quantum functor
else:
vocab_psr.append(word)
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
#*****************************************************
# Translation to quantum circuits
#*****************************************************
from discopy.quantum import Ket, IQPansatz, Bra, qubit
from discopy.quantum.circuit import Functor, Id
from discopy.quantum.circuit import Circuit
from functools import reduce, partial
from discopy.quantum.gates import Rx, Rz
q_s = 1 # number of qubits for type s (sentence)
q_n = 1 # number of qubits for type n (noun)
depth = 1 # depth of the IQPansatz
p_n = 3 # number of parameters for the single qubit iqp ansatz
# Define the dimensions of the objects of the circuit functor
ob = {s: q_s, n: q_n}
ob_cqmap = {s: qubit ** q_s, n: qubit ** q_n}
#-----------------------------------------
# parametrised part of ansaetze
#-----------------------------------------
def single_qubit_iqp_ansatz(params):
if len(params) == 1:
return Rx(params[0])
if len(params) == 2:
return Rx(params[0]) >> Rz(params[1])
if len(params) == 3:
return IQPansatz(1, params)
def ansatz_state(state, params):
arity = sum(ob[Ty(factor.name)] for factor in state.cod)
if arity == 1:
return Ket(0) >> single_qubit_iqp_ansatz(params)
return Ket(*tuple([0 for i in range(arity)])) >> IQPansatz(arity, params)
def ansatz_effect(effect, params):
arity = sum(ob[Ty(factor.name)] for factor in effect.dom)
if arity == 1:
return single_qubit_iqp_ansatz(params) >> Bra(0)
return IQPansatz(arity, params) >> Bra(*tuple([0 for i in range(arity)]))
def ansatz(box,params):
dom_type = box.dom
cod_type = box.cod
if len(dom_type) == 0 and len(cod_type) != 0:
return ansatz_state(box, params)
if len(dom_type) != 0 and len(cod_type) == 0:
return ansatz_effect(box, params)
#----------------------------------------------------------
# Define parametrised functor to quantum circuits
#----------------------------------------------------------def F(params):
def F(params):
ar = dict()
for i in range(len(vocab_psr)):
pgbox = vocab_psr[i]
qbox = ansatz(vocab_psr[i], params[i])
ar.update({pgbox: qbox})
if pgbox.cod == Ty():
ar.update({Box(pgbox.name, n.l, Ty()): qbox}) # send the effect with n.l to same quantum effect
return Functor(ob_cqmap, ar)
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
#*****************************************************
# Functions to deal with the parametrisation
#*****************************************************
def paramshapes(vocab_psr):
parshapes = []
for box in vocab_psr:
dom_type = box.dom
cod_type = box.cod
dom_arity = sum(ob[Ty(factor.name)] for factor in box.dom)
cod_arity = sum(ob[Ty(factor.name)] for factor in box.cod)
if dom_arity == 0 or cod_arity == 0: # states and effects
arity = max(dom_arity, cod_arity)
assert arity != 0
if arity == 1:
parshapes.append((p_n,))
if arity != 1:
parshapes.append((depth, arity-1))
return parshapes
def randparams(par_shapes):
params = np.array([])
for i in range(len(par_shapes)):
params = np.concatenate((params, np.ravel(np.random.rand(*par_shapes[i])))) # np.ravel flattens an array
return params
def reshape_params(unshaped_pars, par_shapes):
pars_reshaped = [[] for ii in range(len(par_shapes))]
shift = 0
for ss, s in enumerate(par_shapes):
idx0 = 0 + shift
if len(s) == 1:
idx1 = s[0] + shift
elif len(s) == 2:
idx1 = s[0] * s[1] + shift
pars_reshaped[ss] = np.reshape(unshaped_pars[idx0:idx1], s)
if len(s) == 1:
shift += s[0]
elif len(s) == 2:
shift += s[0] * s[1]
return pars_reshaped
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
#****************************************
# Parameters of the current model
#****************************************
par_shapes = paramshapes(vocab_psr)
rand_unshaped_pars = randparams(par_shapes)
rand_shaped_pars = reshape_params(rand_unshaped_pars, par_shapes)
print('Number of parameters: ', len(rand_unshaped_pars))
from sklearn.model_selection import train_test_split
psr_diagrams = []
psr_diagrams_dict = {}
psr_labels = []
sentences = []
for sentstr in data_new_psr_dict.keys():
sentences.append(sentstr)
diagram = data_new_psr_dict[sentstr]
psr_diagrams.append(diagram)
psr_diagrams_dict[sentstr] = diagram
if labels_dict[sentstr] == '0':
label = np.array([1,0])
elif labels_dict[sentstr] == '1':
label = np.array([0,1])
psr_labels.append(label)
train_data_psr, test_data_psr, train_labels, test_labels = \
train_test_split(psr_diagrams, psr_labels, test_size=0.25, random_state=42)
from qiskit import BasicAer, execute, ClassicalRegister
from pytket.extensions.qiskit import tk_to_qiskit
from qiskit.quantum_info import Statevector
#from qiskit import IBMQ
#from qiskit.providers.aer.noise import NoiseModel
backend = BasicAer.get_backend('qasm_simulator')
noise_model = None
coupling_map = None
basis_gates= None
## Build noise model from backend properties
#provider = IBMQ.load_account()
#backend = provider.get_backend('ibmq_16_melbourne')
#noise_model = NoiseModel.from_backend(backend)
## Get coupling map from backend
#coupling_map = backend.configuration().coupling_map
## Get basis gates from noise model
#basis_gates = noise_model.basis_gates
#backend = Aer.get_backend('qasm_simulator')
max_shots = 8192
#with open(f'./noise_model_melbourne.pkl', "rb") as fp:
#data = pickle.load(fp)
#noise_model, coupling_map, basis_gates = data[0], data[1], data[2]
from qiskit import Aer
def get_qiskit_results(circ, s_type, retries=10, qasm=False, noise_model=None,
basis_gates=None, coupling_map=None, max_shots=8192):
"""Function to get the Qiskit's results from a DisCoPy circuit.
Args:
circ = DisCoPy circuit.
s_type = sentence type for the sentence associated to the circuit.
retries = number of retries before assigning a random result
if the postselection leads to zero values (Default is 10).
qasm = if True qasm_simulator is used, if not statevector_simulator
(Default is False).
noise_model = Qiskit's noise model object (Default is None).
basis_gates = basis gates of the device (Default is None).
coupling_map = coupling_map of the device (Default is None).
max_shots = number of shots (Default is 8192).
Returns:
array: results from the postselection measurement.
"""
# Select qubits for postselection according to the sentence type
if s_type == 'int':
n_qubits = 4
post = 2
elif s_type == 'tra':
n_qubits = 3
post = 1
elif s_type == 'tra_l':
n_qubits = 5
post = 2
else:
assert s_type == 'tra_r'
n_qubits = 5
post = 1
# From DisCoPy to Qiskit circuit
qc = tk_to_qiskit(circ.to_tk())
if qasm == True:
#qasm_simulator
out_reg = ClassicalRegister(1)
qc.add_register(out_reg)
qc.measure(post, out_reg[0])
if noise_model is not None:
backend = Aer.get_backend('qasm_simulator')
# Include noise model
results = execute(qc, backend, shots=max_shots, noise_model=noise_model,
coupling_map=coupling_map,basis_gates=basis_gates).result().get_counts()
else:
backend = BasicAer.get_backend('qasm_simulator')
results = execute(qc, backend, shots=max_shots).result().get_counts()
zeros = '0' * (n_qubits - 1)
if '0 ' + zeros not in results and '1 ' + zeros not in results:
if retries == 0:
return np.random.rand(2)
return get_qiskit_results(circ, s_type, retries=retries-1, qasm = qasm,
noise_model=noise_model, coupling_map=coupling_map,
basis_gates=basis_gates, max_shots = max_shots)
return parse_results(results, eff=zeros)
else:
# statevector_simulator
qc.remove_final_measurements()
state_dict = Statevector(qc).to_dict()
post0, post1 = '0' * n_qubits, '0' * n_qubits
post1 = post1[:post] + '1' + post1[post + 1:]
return [np.abs(state_dict[post0])**2, np.abs(state_dict[post1])**2]
def parse_results(results, eff='0'):
"""Parse results of qasm_simulator.
Args:
results: counts from quantum circuit's measurement.
eff: digits for splitting the results for post selection.
Returns:
array: post selected results.
"""
ks = [k for k in results.keys() if k.split()[1] == eff]
post_selected_results = {k.split()[0]:v for (k,v) in results.items() if k in ks}
if '0' not in post_selected_results:
post_selected_results['0'] = 0
if '1' not in post_selected_results:
post_selected_results['1'] = 0
total = post_selected_results['0'] + post_selected_results['1']
assert total > 0, 'total was 0 after postselection - try running with more shots'
return [post_selected_results['0']/total, post_selected_results['1']/total]
def process_dataset(dataset):
""" Process a QNLP dataset.
Args:
dataset: txt dataset to be processed.
Returns:
psr_diagrams: parsing diagrams.
psr_labels: labels.
sentences: sentences.
sent_type: dictionary with the sentence type for each sentence.
"""
with open(dataset) as f:
data = f.readlines()
labels_dict = {} # Dictionary with the labels for each sentence
data_psr_dict = {} # Dictionary with the parsing for each sentence
sent_type = {} # Dictionary with the sentence type for each sentence
# Create the previous dictionaries from the given dataset
adjective_words = [a.name for a in adjectives]
for sentence in data:
sentstr = sentence[:-7]
if sentence[-6:-3] == 'int':
diagram = parsing_int[sentstr]
data_psr_dict[sentstr] = diagram
labels_dict[sentstr] = sentence[-2]
sent_type[sentstr] = 'int'
elif sentence[-6:-3] == 'tra':
diagram = parsing_tra[sentstr]
data_psr_dict[sentstr] = diagram
labels_dict[sentstr] = sentence[-2]
if len(sentstr.split()) == 4:
if sentstr.split()[0] in adjective_words:
sent_type[sentstr] = 'tra_' + 'l'
else:
sent_type[sentstr] = 'tra_' + 'r'
else:
sent_type[sentstr] = 'tra'
# Rearrange the parsing of the diagrams
data_new_psr_dict = {}
for sentstr in data_psr_dict.keys():
num_words = len(sentstr.split(' '))
words = data_psr_dict[sentstr].boxes[:num_words]
if sent_type[sentstr] == 'int':
noun = Box(words[1].name, n.l, Ty())
words_new = (Cap(n, n.l)) >> (words[0] @ Id(n) @ noun @ words[2]) # Rearranged words
sentence = words_new >> grammar_dict['ADJ_N_IV'] # Apply grammar on rearranged words
data_new_psr_dict[sentstr] = sentence.normal_form() # Store sentece with optimum diagram
elif 'tra' in sent_type[sentstr]:
if sent_type[sentstr] == 'tra':
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[2].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['N_TV_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif sent_type[sentstr] == 'tra_l': #adjective at beginning
noun1 = Box(words[1].name, n.l, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n, n.l) @ Cap(n, n.l)) >> (words[0] @ Id(n) @ noun1 @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['ADJ_N_TV_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif sent_type[sentstr] == 'tra_r': #adjective on second noun
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['N_TV_ADJ_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
# Store the diagrams, labels and sentences for the classification
psr_diagrams = []
psr_diagrams_dict = {}
psr_labels = []
sentences = []
for sentstr in data_new_psr_dict.keys():
sentences.append(sentstr)
diagram = data_new_psr_dict[sentstr]
psr_diagrams.append(diagram)
psr_diagrams_dict[sentstr] = diagram
if labels_dict[sentstr] == '0':
label = np.array([1,0])
elif labels_dict[sentstr] == '1':
label = np.array([0,1])
psr_labels.append(label)
return psr_diagrams, psr_labels, sentences, sent_type
from qiskit.aqua.components.optimizers import SPSA
import time
def QNLP_optimize(dataset, initial_point, n_iterations, cost_function, qasm_bool=False,
noise_model=None, coupling_map=None, basis_gates=None, max_shots = 8192):
""" Optimize a QNLP dataset.
Args:
dataset = dataset for the optimization.
initial_point = initial value of the parameters.
niter = number of iterations for SPSA optimizer.
cost_function = cost function for the optimization
qasm_bool: if True qasm_simulator is used, if not
statevector_simulator (Default is False).
Returns:
list: Qiskit's SPSA results.
cost_save: cost of each evaluation of the cost function.
params_save: parameters of each evaluation of the cost function.
"""
# Obtain the data from the dataset
train_data_psr, train_labels, train_sent, sent_type = process_dataset(dataset)
# Qiskit's SPSA parameters
num_vars = len(initial_point)
bounds = [[0.0, 1.0] for _ in range(len(initial_point))]
# Initialize cost function global parameters
cost_save = []
params_save = []
i_cost = []
# Choose cost function
if cost_function == 'cost_train':
def get_cost_train_error(unshaped_params):
""" Cost function using training error.
Args:
unshaped_params: parameters for the optimization.
Returns:
float: cost.
"""
# Print iterations
i_cost.append(1)
if len(i_cost) % 2 == 0:
print('Iteration', len(i_cost)/2)
# Create functor to construct DisCoPy circuits
func = F(reshape_params(unshaped_params, par_shapes))
circs = [func(diag) for diag in train_data_psr]
# Get Qiskit's results
results = np.array([get_qiskit_results(circs[i], sent_type[train_sent[i]], qasm = qasm_bool,
noise_model=noise_model, coupling_map=coupling_map,
basis_gates=basis_gates, max_shots=max_shots) for i in range(len(train_sent))])
#Tweak results
results_tweaked = [np.abs(np.array(res) - 1e-9) for res in results]
pred_labels_distrs = [res.flatten() / np.sum(res) for res in results_tweaked]
# Compute cost
error = 0
for i, r in enumerate(pred_labels_distrs):
error += int(np.argmax(r) != np.argmax(train_labels[i]))
# Print cost
print('Cost', error/len(pred_labels_distrs))
# Save cost and parameters
cost_save.append(error/len(pred_labels_distrs))
params_save.append(unshaped_params)
return error/len(pred_labels_distrs)
get_cost = get_cost_train_error
elif cost_function == 'cost_entropy':
def get_cost_cross_entropy(unshaped_params):
""" Cost function using cross entropy.
Args:
unshaped_params: parameters for the optimization.
Returns:
float: cost.
"""
# Print iterations
i_cost.append(1)
if len(i_cost) % 2 == 0:
print('Iteration', len(i_cost)/2)
# Create functor to construct DisCoPy circuits
func = F(reshape_params(unshaped_params, par_shapes))
circs = [func(diag) for diag in train_data_psr]
# Get Qiskit's results
results = np.array([get_qiskit_results(circs[i], sent_type[train_sent[i]], qasm = qasm_bool,
noise_model=noise_model, coupling_map=coupling_map,
basis_gates=basis_gates, max_shots=max_shots) for i in range(len(train_sent))])#Tweak results
results_tweaked = [np.abs(np.array(res) - 1e-9) for res in results]
pred_labels_distrs = [res.flatten() / np.sum(res) for res in results_tweaked]
# Compute cost
cross_entropies = np.array([np.sum(train_labels[s] * np.log2(pred_labels_distrs[s])) for s in range(len(train_labels))])
# Print cost
print('Cost', -1 / len(train_data_psr) * np.sum(cross_entropies))
# Save cost and parameters
cost_save.append(-1 / len(train_data_psr) * np.sum(cross_entropies))
params_save.append(unshaped_params)
return -1 / len(train_data_psr) * np.sum(cross_entropies)
get_cost = get_cost_cross_entropy
else:
raise NameError('No valid cost function name.')
# Optimization
t1 = time.time()
opt = SPSA(maxiter=n_iterations)
ps = opt.optimize(num_vars, get_cost, initial_point=initial_point, variable_bounds=bounds)
print("Final time", time.time() - t1)
if qasm_bool == True:
simul = 'qasm'
else:
simul = 'statevector'
pickle.dump([ps, cost_save, params_save],
open(f"sentiment_analysis_1vs1_{dataset[16:-4]}_{str(cost_function)}_niter{n_iterations}_{simul}.pkl", "wb"))
return ps, cost_save, params_save
datasets = ['train_happy_vs_sad.txt', 'train_happy_vs_angry.txt', 'train_happy_vs_scared.txt',
'train_sad_vs_angry.txt', 'train_sad_vs_scared.txt', 'train_angry_vs_scared.txt']
n_iterations = 1
cost_function = 'cost_train'
initial_point = randparams(par_shapes)
for dataset in datasets:
dataset = './1vs1_datasets/' + dataset
qasm_bool = False
results = QNLP_optimize(dataset,initial_point, n_iterations, cost_function, qasm_bool=qasm_bool,
noise_model=noise_model, coupling_map=coupling_map,
basis_gates=basis_gates, max_shots=max_shots)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/PaulaGarciaMolina/QNLP_Qiskit_Hackathon
|
PaulaGarciaMolina
|
import numpy as np
import pickle
import qiskit
qiskit.__qiskit_version__
from discopy import Ty, Word # Import the classes for the type of word and for the word
s, n = Ty('s'), Ty('n') # Define the types s and n
nphr, adj, tv, iv, vphr = Ty('NP'), Ty('ADJ'), Ty('TV'), Ty('IV'), Ty('VP')
# Define the words (notice that we include both meaning and grammar)
# nouns
man, woman, kid = Word('man', n), Word('woman', n), Word('kid', n)
# adjectives
morose, irascible = Word('morose', n @ n.l), Word('irascible', n @ n.l)
frightened, cheerful = Word('frightened', n @ n.l), Word('cheerful', n @ n.l)
gloomy, furious = Word('gloomy', n @ n.l), Word('furious', n @ n.l)
terrified, joyful = Word('terrified', n @ n.l), Word('joyful', n @ n.l)
downcast, miserable = Word('downcast', n @ n.l), Word('miserable', n @ n.l)
old, young = Word('old', n @ n.l), Word('young', n @ n.l)
# Intransitive verbs
cries, shouts = Word('cries', n.r @ s), Word('shouts', n.r @ s)
laughs, snaps = Word('laughs', n.r @ s), Word('snaps', n.r @ s)
# Transitive verbs
grieves, startles = Word('grieves', n.r @ s @ n.l), Word('startles', n.r @ s @ n.l)
entertains, irritates = Word('entertains', n.r @ s @ n.l), Word('irritates', n.r @ s @ n.l)
nouns = [man, woman, kid]
adjectives = [morose, irascible, frightened, cheerful, gloomy, furious, terrified, joyful, downcast, miserable, old, young]
int_verbs = [cries, shouts, laughs, snaps]
t_verbs = [grieves, startles, entertains, irritates]
vocab = nouns + int_verbs + t_verbs + adjectives
from discopy import Cup, Id, pregroup
grammar = Id(n) @ Cup(n.l, n) @ Id(n.r @ s) >> Cup(n, n.r) @ Id(s) >> Id(s)
sentence = joyful @ woman @ laughs >> grammar
pregroup.draw(sentence)
grammar = Cup(n, n.r) @ Id(s) @ Cup(n.l, n)
sentence = woman @ grieves @ kid >> grammar
pregroup.draw(sentence)
from discopy import Diagram
from discopy.grammar import draw
# Store the grammatical structures in a dictionary
grammar_dict = {
'ADJ_N_IV' : Id(n) @ Cup(n.l, n) @ Id(n.r @ s) >> Cup(n, n.r) @ Id(s) >> Id(s),
'N_TV_N': Cup(n, n.r) @ Id(s) @ Cup(n.l, n),
'ADJ_N_TV_N': Id(n) @ Cup(n.l, n) @ Id(n.r @ s) @ Cup(n.l, n) >> Cup(n, n.r) @ Id(s) >> Id(s),
'N_TV_ADJ_N': Cup(n, n.r) @ Id(s) @ Cup(n.l, n) @ Cup(n.l, n) >> Id(s)}
# Create parsing (grammatical analysis) dictionary where the grammatical sentences
# are the keys and the associated values are the diagrams (words + grammar)
data_psr = {}
# Intransitive sentences
parsing_int = {"{} {} {}.".format(adj, noun, int_verb): adj @ noun @ int_verb >> grammar_dict['ADJ_N_IV']
for adj in adjectives for noun in nouns for int_verb in int_verbs}
sentences_int = list(parsing_int.keys())
for sentence in sentences_int:
diagram = parsing_int[sentence]
data_psr[sentence] = parsing_int[sentence]
# Transitive sentences (without adjective)
parsing_tra = {"{} {} {}.".format(subj, t_verb, obj): subj @ t_verb @ obj >> grammar_dict['N_TV_N']
for subj in nouns for t_verb in t_verbs for obj in nouns}
#Due to time limitations, we are exlcuding transitive sentences with adjectives in this implementation
"""
# Transitive sentences (with adjective)
parsing_tra_ladj = {"{} {} {} {}.".format(adj, subj, t_verb, obj): adj @ subj @ t_verb @ obj >> grammar_dict['ADJ_N_TV_N']
for adj in adjectives for subj in nouns for t_verb in t_verbs for obj in nouns}
parsing_tra_radj = {"{} {} {} {}.".format(subj, t_verb, adj, obj): subj @ t_verb @ adj @ obj >> grammar_dict['N_TV_ADJ_N']
for subj in nouns for t_verb in t_verbs for adj in adjectives for obj in nouns}
parsing_tra.update(parsing_tra_ladj) #merges transitive adjectives into original dict
parsing_tra.update(parsing_tra_radj)
"""
sentences_tra = list(parsing_tra.keys())
for sentence in sentences_tra:
diagram = parsing_tra[sentence]
data_psr[sentence] = parsing_tra[sentence]
with open('../sentiment_analysis_dataset.txt') as f:
data = f.readlines()
labels_dict = {} # Dictionary with the labels for each sentence
data_psr_dict = {} # Dictionary with the parsing for each sentence
sent_type = {} # Dictionary with the sentence type for each sentence
adjective_words = [a.name for a in adjectives]
for sentence in data:
sentstr = sentence[:-7] #seperates the sentence string from the data at the end
if sentence[-6:-3] == 'int':
diagram = parsing_int[sentstr]
data_psr_dict[sentstr] = diagram
labels_dict[sentstr] = sentence[-2]
sent_type[sentstr] = 'int'
elif sentence[-6:-3] == 'tra':
diagram = parsing_tra[sentstr]
data_psr_dict[sentstr] = diagram
labels_dict[sentstr] = sentence[-2]
#ignoring transitive adjective sentences in this run
"""if len(sentstr.split()) == 4:
if sentstr.split()[0] in adjective_words:
sent_type[sentstr] = 'tra_' + 'l' #adjective on the left
else:
sent_type[sentstr] = 'tra_' + 'r' #adjective on the right
else:
sent_type[sentstr] = 'tra' #the simple transitive verb sentence type
"""
sent_type[sentstr] = 'tra'
c0 = 0
c1 = 0
c2 = 0
c3 = 0
for value in labels_dict.values():
if value == '0':
c0 +=1
elif value == '1':
c1 += 1
elif value == '2':
c2 += 1
elif value == '3':
c3 += 1
print('Number of elements for each sentiment')
print('Happy: ', c0)
print('Sad: ', c1)
print('Angry: ', c2)
print('Scared: ', c3)
print('Total', len(data_psr_dict))
from discopy import Cap, Box
woman2 = Box('woman', n.l, Ty())
words_new = (Cap(n, n.l)) >> (joyful @ Id(n) @ woman2 @ laughs)
sentence = words_new >> grammar_dict['ADJ_N_IV']
sentence = sentence.normal_form()
sentence.draw()
woman2 = Box('woman', n.r, Ty())
kid2 = Box('kid', n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (woman2 @ Id(n) @ grieves @ Id(n) @ kid2)
sentence = words_new >> grammar_dict['N_TV_N']
sentence = sentence.normal_form()
sentence.draw()
data_psr['morose man grieves woman.'].draw()
# Code of this cell addapted from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
#iterates through all sentences and reshapes them as above according to their type
data_new_psr_dict = {}
for sentstr in data_psr_dict.keys():
num_words = len(sentstr.split(' '))
words = data_psr_dict[sentstr].boxes[:num_words]
if sent_type[sentstr] == 'int':
noun = Box(words[1].name, n.l, Ty())
words_new = (Cap(n, n.l)) >> (words[0] @ Id(n) @ noun @ words[2])
sentence = words_new >> grammar_dict['ADJ_N_IV']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif 'tra' in sent_type[sentstr]:
if sent_type[sentstr] == 'tra':
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[2].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['N_TV_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
"""
elif sent_type[sentstr] == 'tra_l': #adjective at beginning
noun1 = Box(words[1].name, n.l, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n, n.l) @ Cap(n, n.l)) >> (words[0] @ Id(n) @ noun1 @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['ADJ_N_TV_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif sent_type[sentstr] == 'tra_r': #adjective on second noun
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['N_TV_ADJ_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
"""
vocab_psr = []
for word in vocab:
if word.cod == Ty('n'):
vocab_psr.append(Box(word.name, n.r, Ty())) # n.l case is dealt with in definition of quantum functor
else:
vocab_psr.append(word)
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
from discopy.quantum import Ket, IQPansatz, Bra, qubit
from discopy.quantum.circuit import Functor, Id
from discopy.quantum.circuit import Circuit
from functools import reduce, partial
import numpy as np
q_s = 2 # number of qubits for type s (sentence)
q_n = 2 # number of qubits for type n (noun)
depth = 1 # depth of the IQPansatz
# Define the dimensions of the objects of the circuit functor
ob = {s: q_s, n: q_n}
ob_cqmap = {s: qubit ** q_s, n: qubit ** q_n}
# Define the ansätze for states and effects
def ansatz_state(state, params):
arity = sum(ob[Ty(factor.name)] for factor in state.cod)
return Ket(*tuple([0 for i in range(arity)])) >> IQPansatz(arity, params)
def ansatz_effect(effect, params):
arity = sum(ob[Ty(factor.name)] for factor in effect.dom)
return IQPansatz(arity, params) >> Bra(*tuple([0 for i in range(arity)]))
def ansatz(box,params):
dom_type = box.dom
cod_type = box.cod
if len(dom_type) == 0 and len(cod_type) != 0:
return ansatz_state(box, params)
if len(dom_type) != 0 and len(cod_type) == 0:
return ansatz_effect(box, params)
# Construct the circuit functor
def F(params):
ar = dict()
for i in range(len(vocab_psr)):
pgbox = vocab_psr[i]
qbox = ansatz(vocab_psr[i], params[i])
ar.update({pgbox: qbox})
if pgbox.cod == Ty():
ar.update({Box(pgbox.name, n.l, Ty()): qbox})
return Functor(ob_cqmap, ar)
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
#*****************************************************
# Functions to deal with the parametrisation
#*****************************************************
def paramshapes(vocab_psr):
parshapes = []
for box in vocab_psr:
dom_type = box.dom
cod_type = box.cod
dom_arity = sum(ob[Ty(factor.name)] for factor in box.dom)
cod_arity = sum(ob[Ty(factor.name)] for factor in box.cod)
if dom_arity == 0 or cod_arity == 0: # states and effects
arity = max(dom_arity, cod_arity)
assert arity != 0
parshapes.append((depth, arity-1))
return parshapes
def randparams(par_shapes):
params = np.array([])
for i in range(len(par_shapes)):
params = np.concatenate((params, np.ravel(np.random.rand(*par_shapes[i])))) # np.ravel flattens an array
return params
def reshape_params(unshaped_pars, par_shapes):
pars_reshaped = [[] for ii in range(len(par_shapes))]
shift = 0
for ss, s in enumerate(par_shapes):
idx0 = 0 + shift
if len(s) == 1:
idx1 = s[0] + shift
elif len(s) == 2:
idx1 = s[0] * s[1] + shift
pars_reshaped[ss] = np.reshape(unshaped_pars[idx0:idx1], s)
if len(s) == 1:
shift += s[0]
elif len(s) == 2:
shift += s[0] * s[1]
return pars_reshaped
#****************************************
# Parameters of the current model
#****************************************
par_shapes = paramshapes(vocab_psr)
rand_unshaped_pars = randparams(par_shapes)
rand_shaped_pars = reshape_params(rand_unshaped_pars, par_shapes)
print('Number of parameters: ', len(rand_unshaped_pars))
# Print the quantum circuit for each sentence
func = F(rand_shaped_pars)
for sentstr in data_new_psr_dict:
print(sentstr)
print(data_new_psr_dict[sentstr])
#func(data_new_psr_dict[sentstr]).draw(draw_box_labels=True, figsize=(5, 5))
from sklearn.model_selection import train_test_split
psr_diagrams = []
psr_diagrams_dict = {}
psr_labels = []
sentences = []
for sentstr in data_new_psr_dict.keys():
sentences.append(sentstr)
diagram = data_new_psr_dict[sentstr]
psr_diagrams.append(diagram)
psr_diagrams_dict[sentstr] = diagram
label = int(labels_dict[sentstr])
psr_labels.append(label)
#create lists of sentences and corresponding diagram and labels
train_data_psr, test_data_psr, orig_train_labels, orig_test_labels = \
train_test_split(psr_diagrams, psr_labels, test_size=0.25, random_state=42)
train_sent, test_sent, train_labels_sent, test_labels_sent = \
train_test_split(sentences, psr_labels, test_size=0.25, random_state=42)
def num_to_vec(x):
if x:
return [0,1] #True
else:
return [1,0]
data_sets_labels = {}
for i, cla in enumerate(['happy', 'sad', 'angry', 'scared']):
data_sets_labels[cla] = {}
tr_labels = [num_to_vec(i == t) for t in orig_train_labels]
data_sets_labels[cla]['train'] = tr_labels
te_labels = [num_to_vec(i == t) for t in orig_test_labels]
data_sets_labels[cla]['test'] = te_labels
from qiskit import BasicAer, execute, ClassicalRegister
from pytket.extensions.qiskit import tk_to_qiskit
from qiskit.quantum_info import Statevector
func(data_new_psr_dict['morose woman cries.']).draw()
func(data_new_psr_dict['woman grieves man.']).draw()
def get_qiskit_results(circ, sent, retries=10):
"""Function to get the Qiskit's results from a DisCoPy circuit.
Args:
circ: DisCoPy circuit.
sent: English sentence for circ
Returns:
array: results from the postselection measurement.
"""
#Finds the sentence's type to determine the number of qubits and position of the sentence qubits
s_type = sent_type[sent]
if s_type == 'int':
n_qubits = 4
post = 2
elif s_type == 'tra':
n_qubits = 3
post = 1
elif s_type == 'tra_l':
n_qubits = 5
post = 2
else:
assert s_type == 'tra_r'
n_qubits = 5
post = 1
#the diagrams are initially in discopy, so we first convert them to tket and then to qiskit
qc = tk_to_qiskit(circ.to_tk())
qc.remove_final_measurements()
state_dict = Statevector(qc).to_dict()
#The only values we care about are the ones when the non-sentence qubits are all zero.
#This leaves only two possible states - the sentence qubit is 0 or 1 (and the rest are all 0)
selections = ['0' * post + val + '0' * (n_qubits - post - 1) for val in ['0', '1']]
return [np.abs(state_dict[sel])**2 for sel in selections] #returns the amplitude for the two states
from qiskit.algorithms.optimizers import SPSA
import time
global_costs = [] #global variable to keep track of cost during training
def cost_ce(unshaped_params): #finds cross entropy cost
#creates a functor which turns a sentence diagram into a circuit parameterized by unshaped_params
func = F(reshape_params(unshaped_params, par_shapes))
#Applies this functor to every training diagram
circs = [func(diag) for diag in train_data_psr]
#Finds the post-selected qiskit results for each circuit
results = np.array([get_qiskit_results(circs[i], train_sent[i]) for i in range(len(train_sent))])
#Turns each result into a probability distribution
results_tweaked = [np.abs(np.array(res) - 1e-9) for res in results]
pred_labels_distrs = [res.flatten() / np.sum(res) for res in results_tweaked]
#finds the cross entropy
cross_entropies = np.array([np.sum(train_labels[s] * np.log2(pred_labels_distrs[s])) for s in range(len(train_labels))])
cost = -1 / len(train_data_psr) * np.sum(cross_entropies)
#stores the cost in a global list so we can track progress
global_costs.append(cost)
if len(global_costs) % 100 == 0: #since SPSA calls the cost function twice per iteration, this prints every 50 iterations
print("at iteration", len(global_costs)/2, time.time() - begin_time)
return cost
rand_unshaped_pars = randparams(par_shapes)
num_vars = len(rand_unshaped_pars)
bounds = [[0.0, 1.0] for _ in range(len(rand_unshaped_pars))]
ps = {}
n_iterations = 1000
#creates a classifier 1vall classifier for each sentiment
for cla in ['happy', 'sad', 'angry', 'scared']:
#chooses random starting parameters
rand_unshaped_pars = randparams(par_shapes)
#finds the labels for the current classifier
train_labels = data_sets_labels[cla]['train']
test_labels = data_sets_labels[cla]['test']
a = time.time()
#creates a qiskit optimizer
opt = SPSA(maxiter=n_iterations)
print("\n\ncalibrating", cla)
opt.calibrate(cost_ce, initial_point=rand_unshaped_pars) #calibrates according to cost function
print("training")
global_costs = []
o = opt.optimize(num_vars, cost_ce, initial_point=rand_unshaped_pars, variable_bounds=bounds) #performs optimization
ps[cla] = [o, global_costs.copy()] #saves parameters and cost history
print("took", time.time() - a)
final_train_predictions = [(0,'') for _ in range(len(orig_train_labels))] # list of tuples of the form (probability, class)
final_test_predictions = [(0,'') for _ in range(len(orig_test_labels))]
test_predictions_dict = {}
individual_train_predictions = {}
individual_test_predictions = {}
classes = ['happy', 'sad', 'angry', 'scared']
for j, cla in enumerate(classes):
params = ps[cla][0][0]
func = F(reshape_params(params, par_shapes))
train_data = train_data_psr
#train_data = data_sets[cla]['train']
train_labels = data_sets_labels[cla]['train']
test_labels = data_sets_labels[cla]['test']
final_train_circuits = [func(diag) for diag in train_data_psr]
train_results = [get_qiskit_results(final_train_circuits[i], train_sent[i]) for i in range(len(train_sent))]
final_test_circuits = [func(diag) for diag in test_data_psr]
test_results = [get_qiskit_results(final_test_circuits[i], test_sent[i]) for i in range(len(test_sent))]
train_results_tweaked = [np.abs(np.array(res) - 1e-9) for res in train_results]
test_results_tweaked = [np.abs(np.array(res) - 1e-9) for res in test_results]
pred_train_results = [res.flatten() / np.sum(res) for res in train_results_tweaked]
pred_test_results = [res.flatten() / np.sum(res) for res in test_results_tweaked]
test_predictions_dict[cla] = ([np.argmax(r) for r in pred_test_results], test_labels)
#Since each tuple (p, j) in these lists represents a probability that sentence i is in class j, this update keeps
#track of the most likely prediction so far
final_train_predictions = [max(final_train_predictions[i], (pred_train_results[i][1], j)) for i in range(len(pred_train_results))]
final_test_predictions = [max(final_test_predictions[i], (pred_test_results[i][1], j)) for i in range(len(pred_test_results))]
individual_train_predictions[cla] = [np.argmax(pred) for pred in pred_train_results]
individual_test_predictions[cla] = [np.argmax(pred) for pred in pred_test_results]
#individual accuracy
for cla in classes:
train_pred = individual_train_predictions[cla]
train_actual = data_sets_labels[cla]['train']
acc = [train_pred[i] == np.argmax(train_actual[i]) for i in range(len(train_pred))]
print("\n\nfor", cla, ": train accuracy =", sum(acc)/len(acc))
test_pred = individual_test_predictions[cla]
test_actual = data_sets_labels[cla]['test']
acc = [test_pred[i] == np.argmax(test_actual[i]) for i in range(len(test_pred))]
print("for", cla, ": test accuracy =", sum(acc)/len(acc))
from sklearn.metrics import confusion_matrix
for cla in classes:
print("\n\n for", cla, "\n", confusion_matrix([np.argmax(t) for t in test_predictions_dict[cla][1]], test_predictions_dict[cla][0])) #true, pred
confusion_matrix(orig_test_labels, [r[1] for r in final_test_predictions])
correct = 0
for i, res in enumerate(final_train_predictions):
pred_result = res[1]
train_result = orig_train_labels[i]
#print(train_sent[i])
#print(res.flatten())
#print(pred_result,train_result)
if train_result == pred_result:
correct += 1
#print(f'Result: {train_array, train_result}, Predicted result: {res, pred_result}')
print('Correct overall predictions (train):',correct/len(train_results_tweaked))
correct = 0
for i, res in enumerate(final_test_predictions):
pred_result = res[1]
test_result = orig_test_labels[i]
if test_result == pred_result:
correct += 1
print('Correct overall predictions (test):',correct/len(test_results_tweaked))
pickle.dump(ps, open("results/sentiment_analysis_qiskit_1vall.p", "wb"))
fig, axs = plt.subplots(2,2, figsize=(15,10))
import matplotlib.pyplot as plt
colours = ['blue', 'red', 'orange', 'green']
for i in range(4):
costs = ps[classes[i]][1][51:] #excluding the first 51 values since they are used for calibration
n = ps[cla][0][-1]
costs = [(costs[j*2] + costs[j*2 + 1])/2 for j in range(n//2)] #averages over xplus and xminus values
axs[i//2, i%2].plot(ps[classes[i]][1][51:], color=colours[i])
axs[i//2, i%2].set_title(classes[i])
axs[i//2, i%2].set_xlabel('iterations')
axs[i//2, i%2].set_ylabel('cost')
axs[i//2, i%2].set_ylim(0,2.5)
|
https://github.com/PaulaGarciaMolina/QNLP_Qiskit_Hackathon
|
PaulaGarciaMolina
|
import numpy as np
import pickle
import qiskit
qiskit.__qiskit_version__
from discopy import Ty, Word # Import the classes for the type of word and for the word
s, n = Ty('s'), Ty('n') # Define the types s and n
# Define the words (notice that we include both meaning and grammar)
# nouns
man, woman, kid = Word('man', n), Word('woman', n), Word('kid', n)
# adjectives
morose, irascible = Word('morose', n @ n.l), Word('irascible', n @ n.l)
frightened, cheerful = Word('frightened', n @ n.l), Word('cheerful', n @ n.l)
gloomy, furious = Word('gloomy', n @ n.l), Word('furious', n @ n.l)
terrified, joyful = Word('terrified', n @ n.l), Word('joyful', n @ n.l)
downcast, miserable = Word('downcast', n @ n.l), Word('miserable', n @ n.l)
old, young = Word('old', n @ n.l), Word('young', n @ n.l)
# Intransitive verbs
cries, shouts = Word('cries', n.r @ s), Word('shouts', n.r @ s)
laughs, snaps = Word('laughs', n.r @ s), Word('snaps', n.r @ s)
# Transitive verbs
grieves, startles = Word('grieves', n.r @ s @ n.l), Word('startles', n.r @ s @ n.l)
entertains, irritates = Word('entertains', n.r @ s @ n.l), Word('irritates', n.r @ s @ n.l)
nouns = [man, woman, kid]
adjectives = [morose, irascible, frightened, cheerful, gloomy, furious, terrified, joyful, downcast, miserable, old, young]
int_verbs = [cries, shouts, laughs, snaps]
t_verbs = [grieves, startles, entertains, irritates]
vocab = nouns + int_verbs + t_verbs + adjectives
from discopy import Cup, Id, pregroup
grammar = Id(n) @ Cup(n.l, n) @ Id(n.r @ s) >> Cup(n, n.r) @ Id(s) >> Id(s)
sentence = joyful @ woman @ laughs >> grammar
pregroup.draw(sentence)
grammar = Cup(n, n.r) @ Id(s) @ Cup(n.l, n)
sentence = woman @ grieves @ kid >> grammar
pregroup.draw(sentence)
grammar = Id(n) @ Cup(n.l, n) @ Id(n.r @ s) @ Cup(n.l, n) >> Cup(n, n.r) @ Id(s) >> Id(s)
sentence = morose @ woman @ grieves @ kid >> grammar
pregroup.draw(sentence)
grammar = Cup(n, n.r) @ Id(s) @ Cup(n.l, n) @ Cup(n.l, n) >> Id(s)
sentence = man @ grieves @ morose @ man >> grammar
pregroup.draw(sentence)
from discopy import Diagram
from discopy.grammar import draw
# Store the grammatical structures of each sentence type in a dictionary
grammar_dict = {
'ADJ_N_IV' : Id(n) @ Cup(n.l, n) @ Id(n.r @ s) >> Cup(n, n.r) @ Id(s) >> Id(s),
'N_TV_N': Cup(n, n.r) @ Id(s) @ Cup(n.l, n),
'ADJ_N_TV_N': Id(n) @ Cup(n.l, n) @ Id(n.r @ s) @ Cup(n.l, n) >> Cup(n, n.r) @ Id(s) >> Id(s),
'N_TV_ADJ_N': Cup(n, n.r) @ Id(s) @ Cup(n.l, n) @ Cup(n.l, n) >> Id(s)}
# Create parsing (grammatical analysis) dictionary where the grammatical sentences
# are the keys and the associated values are the diagrams (words + grammar)
data_psr = {}
#Creates all possible sentences
# Intransitive sentences
parsing_int = {"{} {} {}.".format(adj, noun, int_verb): adj @ noun @ int_verb >> grammar_dict['ADJ_N_IV']
for adj in adjectives for noun in nouns for int_verb in int_verbs}
sentences_int = list(parsing_int.keys())
for sentence in sentences_int:
diagram = parsing_int[sentence]
data_psr[sentence] = parsing_int[sentence]
# Transitive sentences (without adjective)
parsing_tra = {"{} {} {}.".format(subj, t_verb, obj): subj @ t_verb @ obj >> grammar_dict['N_TV_N']
for subj in nouns for t_verb in t_verbs for obj in nouns}
# Transitive sentences (with adjective)
parsing_tra_ladj = {"{} {} {} {}.".format(adj, subj, t_verb, obj): adj @ subj @ t_verb @ obj >> grammar_dict['ADJ_N_TV_N']
for adj in adjectives for subj in nouns for t_verb in t_verbs for obj in nouns}
parsing_tra_radj = {"{} {} {} {}.".format(subj, t_verb, adj, obj): subj @ t_verb @ adj @ obj >> grammar_dict['N_TV_ADJ_N']
for subj in nouns for t_verb in t_verbs for adj in adjectives for obj in nouns}
parsing_tra.update(parsing_tra_ladj) #merges transitive adjectives into original dict
parsing_tra.update(parsing_tra_radj)
sentences_tra = list(parsing_tra.keys())
for sentence in sentences_tra:
diagram = parsing_tra[sentence]
data_psr[sentence] = parsing_tra[sentence]
with open('../sentiment_analysis_dataset.txt') as f:
data = f.readlines()
labels_dict = {} # Dictionary with the labels for each sentence
data_psr_dict = {} # Dictionary with the parsing for each sentence
sent_type = {} # Dictionary with the sentence type for each sentence
adjective_words = [a.name for a in adjectives]
for sentence in data:
sentstr = sentence[:-7] #seperates the sentence string from the data at the end
if sentence[-6:-3] == 'int':
diagram = parsing_int[sentstr]
data_psr_dict[sentstr] = diagram
labels_dict[sentstr] = sentence[-2]
sent_type[sentstr] = 'int'
elif sentence[-6:-3] == 'tra':
diagram = parsing_tra[sentstr]
data_psr_dict[sentstr] = diagram
labels_dict[sentstr] = sentence[-2]
if len(sentstr.split()) == 4:
if sentstr.split()[0] in adjective_words:
sent_type[sentstr] = 'tra_' + 'l' #adjective on the left
else:
sent_type[sentstr] = 'tra_' + 'r' #adjective on the right
else:
sent_type[sentstr] = 'tra' #the simple transitive verb sentence type
c0 = 0
c1 = 0
c2 = 0
c3 = 0
for value in labels_dict.values():
if value == '0':
c0 +=1
elif value == '1':
c1 += 1
elif value == '2':
c2 += 1
elif value == '3':
c3 += 1
print('Number of elements for each sentiment')
print('Happy: ', c0)
print('Sad: ', c1)
print('Angry: ', c2)
print('Scared: ', c3)
print('Total', len(data_psr_dict))
from discopy import Cap, Box
# Code of this cell addapted from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
#iterates through all sentences and reshapes them as above according to their type
data_new_psr_dict = {}
for sentstr in data_psr_dict.keys():
num_words = len(sentstr.split(' '))
words = data_psr_dict[sentstr].boxes[:num_words]
if sent_type[sentstr] == 'int':
noun = Box(words[1].name, n.l, Ty())
words_new = (Cap(n, n.l)) >> (words[0] @ Id(n) @ noun @ words[2])
sentence = words_new >> grammar_dict['ADJ_N_IV']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif 'tra' in sent_type[sentstr]:
if sent_type[sentstr] == 'tra':
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[2].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['N_TV_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif sent_type[sentstr] == 'tra_l': #adjective at beginning
noun1 = Box(words[1].name, n.l, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n, n.l) @ Cap(n, n.l)) >> (words[0] @ Id(n) @ noun1 @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['ADJ_N_TV_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
elif sent_type[sentstr] == 'tra_r': #adjective on second noun
noun1 = Box(words[0].name, n.r, Ty())
noun2 = Box(words[3].name, n.l, Ty())
words_new = (Cap(n.r, n) @ Cap(n, n.l)) >> (noun1 @ Id(n) @ words[1] @ words[2] @ Id(n) @ noun2)
sentence = words_new >> grammar_dict['N_TV_ADJ_N']
data_new_psr_dict[sentstr] = sentence.normal_form()
vocab_psr = []
for word in vocab:
if word.cod == Ty('n'):
vocab_psr.append(Box(word.name, n.r, Ty())) # n.l case is dealt with in definition of quantum functor
else:
vocab_psr.append(word)
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
from discopy.quantum import Ket, IQPansatz, Bra, qubit
from discopy.quantum.circuit import Functor, Id
from discopy.quantum.circuit import Circuit
from functools import reduce, partial
from discopy.quantum.gates import Rx, Rz
import numpy as np
q_s = 1 # number of qubits for type s (sentence)
q_n = 1 # number of qubits for type n (noun)
depth = 1 # depth of the IQPansatz
p_n = 3 # number of parameters for the single qubit iqp ansatz
# Define the dimensions of the objects of the circuit functor
ob = {s: q_s, n: q_n}
ob_cqmap = {s: qubit ** q_s, n: qubit ** q_n}
# Define the ansätze for states and effects
def single_qubit_iqp_ansatz(params):
if len(params) == 1:
return Rx(params[0])
if len(params) == 2:
return Rx(params[0]) >> Rz(params[1])
if len(params) == 3:
return IQPansatz(1, params)
def ansatz_state(state, params):
arity = sum(ob[Ty(factor.name)] for factor in state.cod)
if arity == 1:
return Ket(0) >> single_qubit_iqp_ansatz(params)
return Ket(*tuple([0 for i in range(arity)])) >> IQPansatz(arity, params)
def ansatz_effect(effect, params):
arity = sum(ob[Ty(factor.name)] for factor in effect.dom)
if arity == 1:
return single_qubit_iqp_ansatz(params) >> Bra(0)
return IQPansatz(arity, params) >> Bra(*tuple([0 for i in range(arity)]))
def ansatz(box,params):
dom_type = box.dom
cod_type = box.cod
if len(dom_type) == 0 and len(cod_type) != 0:
return ansatz_state(box, params)
if len(dom_type) != 0 and len(cod_type) == 0:
return ansatz_effect(box, params)
# Construct the circuit functor
def F(params):
ar = dict()
for i in range(len(vocab_psr)):
pgbox = vocab_psr[i]
qbox = ansatz(vocab_psr[i], params[i])
ar.update({pgbox: qbox})
if pgbox.cod == Ty():
ar.update({Box(pgbox.name, n.l, Ty()): qbox})
return Functor(ob_cqmap, ar)
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
#*****************************************************
# Functions to deal with the parametrisation
#*****************************************************
def paramshapes(vocab_psr):
parshapes = []
for box in vocab_psr:
dom_type = box.dom
cod_type = box.cod
dom_arity = sum(ob[Ty(factor.name)] for factor in box.dom)
cod_arity = sum(ob[Ty(factor.name)] for factor in box.cod)
if dom_arity == 0 or cod_arity == 0: # states and effects
arity = max(dom_arity, cod_arity)
assert arity != 0
parshapes.append((depth, arity-1))
return parshapes
def randparams(par_shapes):
params = np.array([])
for i in range(len(par_shapes)):
params = np.concatenate((params, np.ravel(np.random.rand(*par_shapes[i])))) # np.ravel flattens an array
return params
def reshape_params(unshaped_pars, par_shapes):
pars_reshaped = [[] for ii in range(len(par_shapes))]
shift = 0
for ss, s in enumerate(par_shapes):
idx0 = 0 + shift
if len(s) == 1:
idx1 = s[0] + shift
elif len(s) == 2:
idx1 = s[0] * s[1] + shift
pars_reshaped[ss] = np.reshape(unshaped_pars[idx0:idx1], s)
if len(s) == 1:
shift += s[0]
elif len(s) == 2:
shift += s[0] * s[1]
return pars_reshaped
# Code of this cell from https://github.com/CQCL/qnlp_lorenz_etal_2021_resources
#****************************************
# Parameters of the current model
#****************************************
par_shapes = paramshapes(vocab_psr)
rand_unshaped_pars = randparams(par_shapes)
rand_shaped_pars = reshape_params(rand_unshaped_pars, par_shapes)
print('Number of parameters: ', len(rand_unshaped_pars))
# Print the quantum circuit for each sentence
func = F(rand_shaped_pars)
for sentstr in data_new_psr_dict:
print(sentstr)
print(data_new_psr_dict[sentstr])
#func(data_new_psr_dict[sentstr]).draw(draw_box_labels=True, figsize=(5, 5))
from sklearn.model_selection import train_test_split
psr_diagrams = []
psr_diagrams_dict = {}
psr_labels = []
sentences = []
#create lists of sentences and corresponding diagram and labels
for sentstr in data_new_psr_dict.keys():
sentences.append(sentstr)
diagram = data_new_psr_dict[sentstr]
psr_diagrams.append(diagram)
psr_diagrams_dict[sentstr] = diagram
if labels_dict[sentstr] == '0':
label = np.array([1,0,0,0])
elif labels_dict[sentstr] == '1':
label = np.array([0,1,0,0])
elif labels_dict[sentstr] == '2':
label = np.array([0,0,1,0])
elif labels_dict[sentstr] == '3':
label = np.array([0,0,0,1])
psr_labels.append(label)
#Splits the sentences and corresponding labels into train and test sets
train_sent, test_sent, train_labels, test_labels = \
train_test_split(sentences, psr_labels, test_size=0.25, random_state=42)
#Finds the discopy diagrams for the sentences in train and test
train_data_psr = [psr_diagrams_dict[sent] for sent in train_sent]
test_data_psr = [psr_diagrams_dict[sent] for sent in test_sent]
from qiskit import BasicAer, execute, ClassicalRegister
from pytket.extensions.qiskit import tk_to_qiskit
from qiskit.quantum_info import Statevector
#intransitive sentence
func(psr_diagrams_dict['morose woman cries.']).draw()
#basic transitive sentence
func(psr_diagrams_dict['man grieves woman.']).draw()
#transitive sentence, left adjective
func(psr_diagrams_dict['morose man grieves woman.']).draw()
#transitive sentence, right adjective
func(psr_diagrams_dict['man entertains joyful woman.']).draw()
def get_qiskit_results(circ, sent, retries=10, qasm=False):
"""Function to get the Qiskit's results from a DisCoPy circuit.
Args:
circ: DisCoPy circuit.
sent: English sentence corresponding to circuit
retries: number of retries before assigning a random result
if the postselection leads to zero values (Default is 10).
qasm: if True qasm_simulator is used, if not statevector_simulator
(Default is False).
Returns:
array: results from the postselection measurement.
"""
#Finds the sentence's type to determine the number of qubits and position of the sentence qubits
s_type = sent_type[sent]
if s_type == 'int':
n_qubits = 8
posts = [4,5]
elif s_type == 'tra':
n_qubits = 6
posts = [2,3]
elif s_type == 'tra_l':
n_qubits = 10
posts = [4,5]
else:
assert s_type == 'tra_r'
n_qubits = 10
posts = [2,3]
#the diagrams are initially in discopy, so we first convert them to tket and then to qiskit
qc = tk_to_qiskit(circ.to_tk())
if qasm == True:
backend = Aer.get_backend('qasm_simulator')
#qasm_simulator
out_reg = ClassicalRegister(2)
qc.add_register(out_reg)
qc.measure(posts, out_reg)
if noise_model is not None:
# Include noise model
results = execute(qc, backend, shots=max_shots, noise_model=noise_model,
coupling_map=coupling_map,basis_gates=basis_gates).result().get_counts()
else:
results = execute(qc, backend, shots=max_shots).result().get_counts()
zeros = '0' * (n_qubits - 1)
if '0 ' + zeros not in results and '1 ' + zeros not in results:
if retries == 0:
return np.random.rand(2)
return get_qiskit_results(circ, s_type, transpile, retries=retries-1, qasm = qasm_bool)
return parse_results(results, eff=zeros)
else:
qc.remove_final_measurements()
state_dict = Statevector(qc).to_dict()
#The only values we care about are the ones when the non-sentence qubits are all zero. This leaves 4 possible values
#for the sentence qubits, which we store in a list here
selections = ['0' * posts[0] + val + '0' * (n_qubits - posts[1] - 1) for val in ['00', '01', '10', '11']]
return [np.abs(state_dict[sel])**2 for sel in selections] #returns the amplitude of each of these four states
from qiskit.algorithms.optimizers import SPSA
import time
global_costs = [] #global variable to keep track of cost during training
begin_time = time.time()
def cost_ce(unshaped_params): #finds cross entropy cost
#creates a functor which turns a sentence diagram into a circuit parameterized by unshaped_params
func = F(reshape_params(unshaped_params, par_shapes))
#Applies this functor to every training diagram
circs = [func(diag) for diag in train_data_psr]
#Finds the post-selected qiskit results for each circuit
results = np.array([get_qiskit_results(circs[i], train_sent[i]) for i in range(len(train_sent))])
#Turns each result into a probability distribution
results_tweaked = [np.abs(np.array(res) - 1e-9) for res in results]
pred_labels_distrs = [res.flatten() / np.sum(res) for res in results_tweaked]
#finds the cross entropy
cross_entropies = np.array([np.sum(train_labels[s] * np.log2(pred_labels_distrs[s])) for s in range(len(train_labels))])
cost = -1 / len(train_data_psr) * np.sum(cross_entropies)
#stores the cost in a global list so we can track progress
global_costs.append(cost)
if len(global_costs) % 100 == 0: #since SPSA calls the cost function twice per iteration, this prints every 50 iterations
print("at iteration", len(global_costs)/2, time.time() - begin_time)
return cost
ps = {}
#Chooses random parameters to begin with
rand_unshaped_pars = randparams(par_shapes)
num_vars = len(rand_unshaped_pars)
#create bounds between 0 and 1 for every variable
bounds = [[0.0, 1.0] for _ in range(len(rand_unshaped_pars))]
n_iterations = 1250
a = time.time()
#creates a qiskit SPSA optimizer
opt = SPSA(maxiter=n_iterations)
print("\n\ncalibrating")
opt.calibrate(cost_ce, initial_point=rand_unshaped_pars) #calibrates it with the cost function and starting parameters
print("training")
global_costs = []
begin_time = time.time()
ps = opt.optimize(num_vars, cost_ce, initial_point=rand_unshaped_pars, variable_bounds=bounds)
print("took", time.time() - a)
pickle.dump([ps, global_costs], open("sentiment_analysis_qiskit_ce_1250.p", "wb"))
func = F(reshape_params(ps[0], par_shapes))
circs = [func(diag) for diag in test_data_psr]
results = np.array([get_qiskit_results(circs[i], test_sent[i]) for i in range(len(test_sent))])
results_tweaked = [np.abs(np.array(res) - 1e-9) for res in results]
pred_labels_distrs = [res.flatten() / np.sum(res) for res in results_tweaked]
from sklearn.metrics import confusion_matrix
import pandas as pd
import seaborn as sns
c_matrix = confusion_matrix([np.argmax(t) for t in test_labels], [np.argmax(r) for r in pred_labels_distrs])
df_cm = pd.DataFrame(c_matrix, ['happy','sad','angry','scared'], ['happy','sad','angry','scared'])
df_cm.index.name = 'Actual'
df_cm.columns.name = 'Predicted'
sns.heatmap(df_cm, annot=True, annot_kws={"size": 16},cmap='viridis',
xticklabels=True, yticklabels=True)
print("test accuracy =", sum([np.argmax(test_labels[i]) == np.argmax(pred_labels_distrs[i]) for i in range(len(test_labels))])/len(test_labels))
costs = global_costs[51:]
n = ps[-1]
costs = [(costs[j*2] + costs[j*2 + 1])/2 for j in range(n//2)]
import matplotlib.pyplot as plt
plt.xlabel('Iterations')
plt.ylabel('Cross Entropy')
plt.title("2-Qubit Multi-class Classification")
plt.plot(costs)
|
https://github.com/steffencruz/FockWits
|
steffencruz
|
import sys
sys.path.append("/home/artix41/Toronto/qiskit-terra/")
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import Aer, execute
import numpy as np
import matplotlib.pyplot as plt
from CVCircuit import CVCircuit
def bose_hubard(n_layers=2, J=1, U=0.1, t=0):
# ===== Constants =====
n_qubits_per_mode = 3
n_qumodes = 2
alpha = 1
phi = np.pi/16
# ==== Initialize circuit =====
qr = QuantumRegister(n_qubits_per_mode*n_qumodes)
cr = ClassicalRegister(n_qubits_per_mode*n_qumodes)
circuit = QuantumCircuit(qr, cr)
cv_circuit = CVCircuit(circuit, qr, n_qubits_per_mode)
# ==== Build circuit ====
cv_circuit.initialize([0,0])
for layer in range(n_layers):
phi = -1j * J * t / n_layers
r = -U * t / (2*n_layers)
cv_circuit.BSGate(phi, (0,1))
cv_circuit.KGate(r, 0)
cv_circuit.KGate(-r, 1)
cv_circuit.RGate(r, 0)
cv_circuit.RGate(-r, 1)
print(circuit)
# ==== Compilation =====
backend = Aer.get_backend('statevector_simulator')
job = execute(circuit, backend)
result = job.result()
state = job.result().get_statevector(circuit)
# ==== Tests ====
print(state)
prob = np.abs(state)**2
plt.plot(prob,'-o')
plt.show()
if __name__ == '__main__':
bose_hubard(t=1)
# def BHM(self,tmax,k,J=1,U=0.1):
# #Implement simple two-mode Bose-Hubbard simulation
# j = np.complex(0,1)
# BKR = {}
# for t in np.linspace(0,tmax,10):
# for layer in range(k):
# phi = -j*J*t/k
# r = -U*t/(2*k)
# BS = self.BS(phi)
# K = np.kron(self.mode.K(r),self.mode.K(r))
# R = np.kron(self.mode.R(-r),self.mode.R(-r))
# BK = np.matmul(BS,K)
# BKR[t] = np.matmul(BK,R)
# return BKR
|
https://github.com/steffencruz/FockWits
|
steffencruz
|
from CVCircuit import CVCircuit
import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from ops import Interferometer
def gbs(z, U, n_qubits_per_mode=2, n_qumodes=4):
qr = QuantumRegister(n_qubits_per_mode*n_qumodes)
cr = ClassicalRegister(n_qubits_per_mode*n_qumodes)
circuit = QuantumCircuit(qr, cr)
cv_circuit = CVCircuit(circuit, qr, n_qubits_per_mode)
interferometer = Interferometer(U)
for n in range(4):
cv_circuit.SGate(z, n)
for n, m, theta, phi, N in interferometer.BS1:
if np.round(phi, 13) != 0:
cv_circuit.RGate(phi, n)
if np.round(theta, 13) != 0:
cv_circuit.BSGate(theta, [n, m])
for n, expphi in enumerate(interferometer.R):
if np.round(expphi, 13) != 1.0:
q = log(expphi).imag
cv_circuit.RGate(q, n)
for n, m, theta, phi, N in reversed(interferometer.BS2):
if np.round(theta, 13) != 0:
cv_circuit.BSgate(-theta, [n, m])
if np.round(phi, 13) != 0:
cv_circuit.RGate(-phi, n)
result = []
for i in range(4):
result.append(cv_circuit.Measure(i))
return result
if __name__ == '__main__':
U = np.array([
[0.219546940711 - 0.256534554457j, 0.611076853957 + 0.524178937791j,
-0.102700187435 + 0.474478834685j, -0.027250232925 + 0.03729094623j],
[0.451281863394 + 0.602582912475j, 0.456952590016 + 0.01230749109j,
0.131625867435 - 0.450417744715j, 0.035283194078 - 0.053244267184j],
[0.038710094355 + 0.492715562066j, -0.019212744068 - 0.321842852355j,
-0.240776471286 + 0.524432833034j, -0.458388143039 + 0.329633367819j],
[-0.156619083736 + 0.224568570065j, 0.109992223305 - 0.163750223027j,
-0.421179844245 + 0.183644837982j, 0.818769184612 + 0.068015658737j]
])
"""print(TiUs)
print(TUs)
print(phis)"""
gbs(1, U)
|
https://github.com/steffencruz/FockWits
|
steffencruz
|
import os
import sys
sys.path.append("/home/artix41/Toronto/qiskit-terra/")
import qiskit
print(qiskit.__file__)
import matplotlib.pyplot as plt
import numpy as np
from qiskit.tools.visualization._circuit_visualization import circuit_drawer
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import Aer, execute
from CVGates import CVGates
class CVCircuit:
def __init__(self, circuit, qr, n_qubits_per_mode=2):
self.n_qubits_per_mode = n_qubits_per_mode
self.n_qumodes = len(circuit)
self.circuit = circuit
self.qr = qr
self.gates = CVGates(n_qubits_per_mode)
def initialize(self, fock_states):
for qumode, n in enumerate(fock_states):
if n >= 2**self.n_qubits_per_mode:
raise ValueError("The parameter n should be lower than the cutoff")
vector = np.zeros((2**self.n_qubits_per_mode,))
vector[n] = 1
start_qumode = self.n_qubits_per_mode * qumode
self.circuit.initialize(vector, [self.qr[i] for i in range(start_qumode, start_qumode+self.n_qubits_per_mode)])
def DGate(self, alpha, qumode):
start_qumode = self.n_qubits_per_mode * qumode
self.circuit.unitary(self.gates.D(alpha), *(self.qr[i] for i in range(start_qumode, start_qumode+self.n_qubits_per_mode)))
def SGate(self, z, qumode):
start_qumode = self.n_qubits_per_mode * qumode
self.circuit.unitary(self.gates.S(z), *(self.qr[i] for i in range(start_qumode, start_qumode+self.n_qubits_per_mode)))
def RGate(self, phi, qumode):
start_qumode = self.n_qubits_per_mode * qumode
self.circuit.unitary(self.gates.R(phi), *(self.qr[i] for i in range(start_qumode, start_qumode+self.n_qubits_per_mode)))
def KGate(self, kappa, qumode):
start_qumode = self.n_qubits_per_mode * qumode
self.circuit.unitary(self.gates.K(kappa), *(self.qr[i] for i in range(start_qumode, start_qumode+self.n_qubits_per_mode)))
def BSGate(self, phi, qumodes):
start_qumodes = [self.n_qubits_per_mode * qumodes[0], self.n_qubits_per_mode * qumodes[1]]
self.circuit.unitary(self.gates.BS(phi), *([self.qr[i] for i in range(start_qumodes[0], start_qumodes[0]+self.n_qubits_per_mode)] +
[self.qr[i] for i in range(start_qumodes[1], start_qumodes[1]+self.n_qubits_per_mode)]))
def S2Gate(self, z, qumodes):
start_qumodes = [self.n_qubits_per_mode * qumodes[0], self.n_qubits_per_mode * qumodes[1]]
self.circuit.unitary(self.gates.S2(z), *([self.qr[i] for i in range(start_qumodes[0], start_qumodes[0]+self.n_qubits_per_mode)] +
[self.qr[i] for i in range(start_qumodes[1], start_qumodes[1]+self.n_qubits_per_mode)]))
if __name__ == '__main__':
# ===== Constants =====
n_qubits_per_mode = 3
n_qumodes = 2
alpha = 1
phi = np.pi/2
# ==== Initialize circuit =====
qr = QuantumRegister(n_qubits_per_mode*n_qumodes)
cr = ClassicalRegister(n_qubits_per_mode*n_qumodes)
circuit = QuantumCircuit(qr, cr)
cv_circuit = CVCircuit(circuit, qr, n_qubits_per_mode)
# ==== Build circuit ====
cv_circuit.initialize([0,0])
cv_circuit.DGate(alpha, 0)
cv_circuit.BSGate(phi, (0,1))
# cv_circuit.BSGate(theta, phi, 0, 1)
# circuit.measure(qr, cr)
print(circuit)
# ==== Compilation =====
backend = Aer.get_backend('statevector_simulator')
job = execute(circuit, backend)
result = job.result()
state = job.result().get_statevector(circuit)
# ==== Tests ====
print(state)
prob = np.abs(state)**2
plt.plot(prob,'-o')
plt.show()
|
https://github.com/steffencruz/FockWits
|
steffencruz
|
# diplacementn_qubits_per_mode=2
# rotation
# squeezing
from qiskit import QuantumCircuit,QuantumRegister,ClassicalRegister
from qiskit import execute,Aer
import numpy as np
from scipy.linalg import expm
import matplotlib.pyplot as plt
import argparse
class CVGates:
def __init__(self,n_qubits_per_mode=2):
self.n_qubits_per_mode = n_qubits_per_mode
self.n_dim = 2**n_qubits_per_mode
I = np.eye(self.n_dim)
# Annihilation operator
self.a = np.zeros((self.n_dim,self.n_dim))
for i in range(self.n_dim-1):
self.a[i,i+1]= np.sqrt(i+1)
# Creation operator
self.a_dag = self.a.conj().T
# Number operator
self.N = np.matmul(self.a_dag,self.a)
# 2-qumodes operators
self.a1 = np.kron(self.a, I)
self.a2 = np.kron(I, self.a)
self.a1_dag = self.a1.conj().T
self.a2_dag = self.a2.conj().T
def D(self, alpha):
# Displacement operator matrix for nxn
arg = alpha*self.a_dag-np.conjugate(alpha)*self.a
return expm(arg)
def S(self, z):
#Single mode squeezing
a2 = np.matmul(self.a, self.a)
a2_dag = np.matmul(self.a_dag, self.a_dag)
arg = np.conjugate(z)*a2 - z*a2_dag
return expm(arg)
def R(self, phi):
arg = 1j*phi*np.matmul(self.a_dag, self.a)
return expm(arg)
def K(self, kappa):
j = np.complex(0,1)
arg = j*kappa*np.matmul(self.N, self.N)
return expm(arg)
def S2(self, z):
#two mode squeeze
a12 = np.matmul(self.a1, self.a2)
a12_dag = np.matmul(self.a1_dag, self.a2_dag)
arg = np.conjugate(z)*a12 - z*a12_dag
return expm(arg)
def BS(self, phi):
a12dag = np.matmul(self.a1, self.a2_dag)
a1dag2 = np.matmul(self.a1_dag, self.a2)
arg = phi*a12dag - np.conjugate(phi)*a1dag2
return expm(arg)
def test(self,op='D',vals=None,v0=None):
if vals is None:
vals = [0.0,0.1,0.2,0.3,0.4]
if v0 is None:
v0 = np.zeros(self.n_dim)
v0[0]=1
allowed_op = ['S','D','R']
if op not in allowed_op:
print('Operation \'%s\' not recognized. Must be in'%(op),allowed_op)
return
for v in vals:
mat = eval('self.{}({})'.format(op,v))
state0 = np.matmul(mat,v0)
state0 = state0*state0.conj()
plt.plot(state0,'-o',ms=3,lw=1,alpha=0.5,label='{}'.format(round(v,3)))
labels = ['{:04b}'.format(i) for i in range(self.n_dim)]
plt.xticks(range(self.n_dim),labels,rotation=80)
plt.xlabel('Qubit')
plt.ylabel('Probability')
plt.legend(title=op)
plt.title('Results for {} Qubits per Mode'.format(self.n_qubits_per_mode))
plt.pause(0.1)
if __name__=='__main__':
# parse some optional arguments
parser = argparse.ArgumentParser()
parser.add_argument('-n','--number_per_mode', help='Number of qubits per mode',choices=[1,2,3,4],nargs='?',const=2,type=int)
args = parser.parse_args()
if args.number_per_mode is None:
args.number_per_mode = 2
m = CVGates(args.number_per_mode)
# standard init
v0 = np.zeros(m.n_dim)
v0[0] = 1
# displacement
dmat = m.D(0.1)
new_input= np.matmul(dmat,v0)
# build circuit
q = QuantumRegister(name='qr',size=args.number_per_mode)
c = ClassicalRegister(name='cr',size=args.number_per_mode)
circ = QuantumCircuit(q,c)
circ.initialize(new_input, q)
|
https://github.com/JavaFXpert/QiskitBlocksService
|
JavaFXpert
|
#!/usr/bin/env python3
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, Aer, execute
def run_qasm(qasm, backend_to_run="qasm_simulator"):
qc = QuantumCircuit.from_qasm_str(qasm)
backend = Aer.get_backend(backend_to_run)
job_sim = execute(qc, backend)
sim_result = job_sim.result()
return sim_result.get_counts(qc)
|
https://github.com/Zhaoyilunnn/qdao
|
Zhaoyilunnn
|
from qiskit import transpile
from qiskit.circuit.random import random_circuit
from qiskit_aer import Aer
from qdao import Engine
num_qubits = 12
num_primary = 10
num_local = 8
# Create a qiskit quantum circuit `circ`
circ = random_circuit(num_qubits, 10, measure=False, max_operands=2)
backend = Aer.get_backend("aer_simulator")
circ = transpile(circ, backend=backend)
# `num_primary`: size of a compute unit
# `num_local`: size of a storage unit
eng = Engine(circuit=circ, num_primary=num_primary, num_local=num_local)
eng.run()
# First transform qiskit circuit to a quafu circuit
from quafu import QuantumCircuit
quafu_circ = QuantumCircuit(1)
# For qiskit >= 1.0, `qasm()` api has been deprecated.
from qiskit.qasm2 import dumps
quafu_circ.from_openqasm(dumps(circ))
# For qiskit < 1.0
# quafu_circ.from_openqasm(circ.qasm())
# Create a new engine using quafu backend
eng = Engine(
circuit=quafu_circ, num_primary=num_primary, num_local=num_local, backend="quafu"
)
eng.run()
from qdao.util import retrieve_sv
res = retrieve_sv(num_qubits, num_local=num_local)
print(res)
|
https://github.com/Zhaoyilunnn/qdao
|
Zhaoyilunnn
|
"""
Generate the walk-through example circuit
Pleas run in qcs root directory
"""
import sys
sys.path.append(".")
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit
from qdao.engine import Engine
if __name__ == "__main__":
# circ_path = "qdao/benchmarks/qasm/random_8_5_max_operands_2_gen.qasm"
circ_path = "qdao/benchmarks/qasm/random_5_2_max_operands_2_gen.qasm"
circ = QuantumCircuit.from_qasm_file(circ_path)
# Show and save original circuit
fig = circ.draw(output="mpl")
print(circ.draw(output="latex_source"))
plt.show()
plt.savefig("complete_circ.pdf")
# engine = Engine(circuit=circ, num_primary=6, num_local=4)
engine = Engine(circuit=circ, num_primary=4, num_local=1)
sub_circs = engine._part.run(circ)
for i, sc in enumerate(sub_circs):
sc.circ.data.pop(-1)
print(sc.real_qubits)
print(sc.circ.draw(output="latex_source"))
fig = sc.circ.draw(output="mpl")
plt.show()
plt.savefig("sub_circ-{}.pdf".format(i))
|
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/feedback
|
Qiskit
|
from qiskit.circuit import QuantumCircuit
from qiskit.visualization import dag_drawer
from qiskit.converters import circuit_to_dag
# Create basic Bell circuit
qc = QuantumCircuit(2, 1)
qc.x(1)
qc.h(0)
qc.cx(0, 1)
display(qc.draw('mpl', cregbundle=False))
print(qc._data)
# Convert circuit to dag and display dag
dag = circuit_to_dag(qc)
display(dag_drawer(dag))
# Using pre-6567 branch
for node in dag.topological_nodes():
if node.type == "op":
print(type(node), node.type, node.op)
else:
print(type(node), node.type, node.wire)
# Using post-6567 branch
from qiskit.dagcircuit import DAGOpNode
for node in dag.topological_nodes():
if isinstance(node, DAGOpNode):
print(type(node), node.op)
else:
print(type(node), node.wire)
<class 'qiskit.dagcircuit.dagnode.DAGInNode'> Qubit(QuantumRegister(2, 'q'), 0)
<class 'qiskit.dagcircuit.dagnode.DAGOpNode'> <qiskit.circuit.library.standard_gates.h.HGate object at 0x7f65b6f89d30>
<class 'qiskit.dagcircuit.dagnode.DAGInNode'> Qubit(QuantumRegister(2, 'q'), 1)
<class 'qiskit.dagcircuit.dagnode.DAGOpNode'> <qiskit.circuit.library.standard_gates.x.XGate object at 0x7f65b6f89fd0>
<class 'qiskit.dagcircuit.dagnode.DAGOpNode'> <qiskit.circuit.library.standard_gates.x.CXGate object at 0x7f65b6f89400>
<class 'qiskit.dagcircuit.dagnode.DAGOutNode'> Qubit(QuantumRegister(2, 'q'), 0)
<class 'qiskit.dagcircuit.dagnode.DAGOutNode'> Qubit(QuantumRegister(2, 'q'), 1)
<class 'qiskit.dagcircuit.dagnode.DAGInNode'> Clbit(ClassicalRegister(1, 'c'), 0)
<class 'qiskit.dagcircuit.dagnode.DAGOutNode'> Clbit(ClassicalRegister(1, 'c'), 0)
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import warnings
warnings.filterwarnings('ignore')
import datetime
import os
import json
import numpy as np
import matplotlib.pyplot as plt
import scipy.optimize as opt
from scipy import signal
from qiskit import IBMQ, pulse, circuit
from qiskit.visualization.pulse_v2 import IQXDebugging
from qiskit.result import Result, marginal_counts
from qiskit.providers.ibmq.utils.json_encoder import IQXJsonEncoder
from qiskit.providers.ibmq.utils.json_decoder import decode_result
class DateTimeEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, (datetime.datetime, datetime.date, datetime.time)):
return obj.isoformat()
elif isinstance(obj, datetime.timedelta):
return (datetime.datetime.min + obj).time().isoformat()
return super(DateTimeEncoder, self).default(obj)
IBMQ.load_account()
backend = IBMQ.get_provider("ibm-q-internal", "deployed", "default").get_backend("ibmq_lima")
qubits = 0, 1
durs1 = 160, 880
durs2 = 320, 1760
basename = "lima_20210813"
def get_params(sx_dur, cx_dur, sigma_r=4, cx_sigma=64, cx_risefall=2):
return {
"sx0": {"duration": sx_dur, "amp": 0., "sigma": sx_dur/sigma_r, "beta": 0.},
"sx1": {"duration": sx_dur, "amp": 0., "sigma": sx_dur/sigma_r, "beta": 0.},
"ecr": {"duration": cx_dur, "amp": 0., "phase": 0., "sigma": cx_sigma, "risefall_sigma_ratio": cx_risefall}
}
def rough_amp(qubits, amps, cals):
amp = circuit.Parameter("amp")
with pulse.build(backend, default_alignment="sequential") as sched:
with pulse.align_left():
for ind, q in enumerate(qubits):
sxcal = cals[f"sx{ind}"].copy()
sxcal["amp"] = amp
pulse.play(pulse.Drag(**sxcal), pulse.drive_channel(q))
pulse.measure(qubits, [pulse.MemorySlot(ind) for ind in range(len(qubits))])
return [sched.assign_parameters({amp: amp_val}, inplace=False) for amp_val in amps]
def rough_amp_cr(qubits, amps, cals):
amp = circuit.Parameter("amp")
qc, qt = qubits
with pulse.build(backend, default_alignment="sequential") as sched:
sxcal = cals["sx0"]
crcal = cals["ecr"].copy()
crcal["amp"] = amp * np.exp(1j*crcal.pop("phase", 0.))
u_chan = pulse.control_channels(*qubits)[0]
pulse.play(pulse.GaussianSquare(**crcal), u_chan)
pulse.play(pulse.Drag(**sxcal), pulse.drive_channel(qc))
pulse.play(pulse.Drag(**sxcal), pulse.drive_channel(qc))
with pulse.phase_offset(np.pi, u_chan):
pulse.play(pulse.GaussianSquare(**crcal), u_chan)
pulse.measure([qt], [pulse.MemorySlot(0)])
return [sched.assign_parameters({amp: amp_val}, inplace=False) for amp_val in amps]
def phase_cr(qubits, phases, cals):
phase = circuit.Parameter("phase")
qc, qt = qubits
with pulse.build(backend, default_alignment="sequential") as sched:
sxcal_c = cals["sx0"]
sxcal_t = cals["sx1"]
crcal = cals["ecr"].copy()
crcal.pop("phase")
crcal["amp"] *= np.exp(1j*phase)
u_chan = pulse.control_channels(*qubits)[0]
pulse.play(pulse.GaussianSquare(**crcal), u_chan)
pulse.play(pulse.Drag(**sxcal_c), pulse.drive_channel(qc))
pulse.play(pulse.Drag(**sxcal_c), pulse.drive_channel(qc))
with pulse.phase_offset(np.pi, u_chan):
pulse.play(pulse.GaussianSquare(**crcal), u_chan)
pulse.play(pulse.Drag(**sxcal_t), pulse.drive_channel(qt))
pulse.measure([qt], [pulse.MemorySlot(0)])
return [sched.assign_parameters({phase: val}, inplace=False) for val in phases]
def fine_amp(qubits, delta_amps, n_rep, cals):
delta_amp = circuit.Parameter("delta_amp")
with pulse.build(backend=backend, default_alignment="sequential") as sched_p:
with pulse.align_left():
for ind, q in enumerate(qubits):
sxcal = cals[f"sx{ind}"].copy()
sxcal["amp"] += delta_amp
sx_pulse = pulse.Drag(**sxcal)
for _ in range(4 * n_rep):
pulse.play(sx_pulse, pulse.drive_channel(q))
pulse.play(sx_pulse, pulse.drive_channel(q))
pulse.measure(qubits, [pulse.MemorySlot(ind) for ind in range(len(qubits))])
with pulse.build(backend=backend, default_alignment="sequential") as sched_m:
with pulse.align_left():
for ind, q in enumerate(qubits):
sxcal = cals[f"sx{ind}"].copy()
sxcal["amp"] += delta_amp
sx_pulse = pulse.Drag(**sxcal)
with pulse.phase_offset(np.pi, pulse.drive_channel(q)):
for _ in range(4 * n_rep):
pulse.play(sx_pulse, pulse.drive_channel(q))
pulse.play(sx_pulse, pulse.drive_channel(q))
pulse.measure(qubits, [pulse.MemorySlot(ind) for ind in range(len(qubits))])
sched_p_assigned = [sched_p.assign_parameters({delta_amp: val}, inplace=False) for val in delta_amps]
sched_m_assigned = [sched_m.assign_parameters({delta_amp: val}, inplace=False) for val in delta_amps]
return sched_p_assigned + sched_m_assigned
def fine_amp_cr(qubits, delta_amps, n_rep, cals):
delta_amp = circuit.Parameter("delta_amp")
qc, qt = qubits
sxcal_c = cals["sx0"]
sxcal_t = cals["sx1"]
crcal = cals["ecr"].copy()
_amp = (crcal["amp"] + delta_amp) * np.exp(1j*crcal.pop("phase", 0.))
crcal["amp"] = _amp
with pulse.build(backend, default_alignment="sequential") as sched_p:
u_chan = pulse.control_channels(*qubits)[0]
for _ in range (4 * n_rep):
pulse.play(pulse.GaussianSquare(**crcal), u_chan)
pulse.play(pulse.Drag(**sxcal_c), pulse.drive_channel(qc))
pulse.play(pulse.Drag(**sxcal_c), pulse.drive_channel(qc))
with pulse.phase_offset(np.pi, u_chan):
pulse.play(pulse.GaussianSquare(**crcal), u_chan)
pulse.play(pulse.Drag(**sxcal_c), pulse.drive_channel(qc))
pulse.play(pulse.Drag(**sxcal_c), pulse.drive_channel(qc))
pulse.play(pulse.Drag(**sxcal_t), pulse.drive_channel(qt))
pulse.measure([qt], [pulse.MemorySlot(0)])
with pulse.build(backend=backend, default_alignment="sequential") as sched_m:
u_chan = pulse.control_channels(*qubits)[0]
for _ in range (4 * n_rep):
with pulse.phase_offset(np.pi, u_chan):
pulse.play(pulse.GaussianSquare(**crcal), u_chan)
pulse.play(pulse.Drag(**sxcal_c), pulse.drive_channel(qc))
pulse.play(pulse.Drag(**sxcal_c), pulse.drive_channel(qc))
pulse.play(pulse.GaussianSquare(**crcal), u_chan)
pulse.play(pulse.Drag(**sxcal_c), pulse.drive_channel(qc))
pulse.play(pulse.Drag(**sxcal_c), pulse.drive_channel(qc))
pulse.play(pulse.Drag(**sxcal_t), pulse.drive_channel(qt))
pulse.measure([qt], [pulse.MemorySlot(0)])
sched_p_assigned = [sched_p.assign_parameters({delta_amp: val}, inplace=False) for val in delta_amps]
sched_m_assigned = [sched_m.assign_parameters({delta_amp: val}, inplace=False) for val in delta_amps]
return sched_p_assigned + sched_m_assigned
def fine_beta(qubits, delta_betas, n_rep, cals):
delta_beta = circuit.Parameter("beta")
with pulse.build(backend=backend, default_alignment="sequential") as sched_p:
with pulse.align_left():
for ind, q in enumerate(qubits):
sxcal = cals[f"sx{ind}"].copy()
sxcal["beta"] += delta_beta
sx_pulse = pulse.Drag(**sxcal)
pulse.play(sx_pulse, pulse.drive_channel(q))
for _ in range(n_rep):
pulse.play(sx_pulse, pulse.drive_channel(q))
with pulse.phase_offset(np.pi, pulse.drive_channel(q)):
pulse.play(sx_pulse, pulse.drive_channel(q))
with pulse.phase_offset(0.5 * np.pi, pulse.drive_channel(q)):
pulse.play(sx_pulse, pulse.drive_channel(q))
pulse.measure(qubits, [pulse.MemorySlot(ind) for ind in range(len(qubits))])
with pulse.build(backend=backend, default_alignment="sequential") as sched_m:
with pulse.align_left():
for ind, q in enumerate(qubits):
sxcal = cals[f"sx{ind}"].copy()
sxcal["beta"] += delta_beta
sx_pulse = pulse.Drag(**sxcal)
pulse.play(sx_pulse, pulse.drive_channel(q))
for _ in range(n_rep):
pulse.play(sx_pulse, pulse.drive_channel(q))
with pulse.phase_offset(np.pi, pulse.drive_channel(q)):
pulse.play(sx_pulse, pulse.drive_channel(q))
with pulse.phase_offset(-0.5 * np.pi, pulse.drive_channel(q)):
pulse.play(sx_pulse, pulse.drive_channel(q))
pulse.measure(qubits, [pulse.MemorySlot(ind) for ind in range(len(qubits))])
sched_p_assigned = [sched_p.assign_parameters({delta_beta: val}, inplace=False) for val in delta_betas]
sched_m_assigned = [sched_m.assign_parameters({delta_beta: val}, inplace=False) for val in delta_betas]
return sched_p_assigned + sched_m_assigned
def run(scheds, exp_name, **options):
fpstr = f"./{basename}_{exp_name}.json"
if os.path.isfile(fpstr):
with open(fpstr, "r") as fp:
cache = json.load(fp)
return Result.from_dict(cache)
job = backend.run(scheds, **options)
result = job.result(timeout=3600)
with open(fpstr, "w") as fp:
json.dump(result.to_dict(), fp, cls=DateTimeEncoder)
return result
def get_expval(result, ind, shots):
res = []
for circ_res in result.get_counts():
counts = 0
for key, count in circ_res.items():
if key[::-1][ind] == "1":
counts += count
res.append(counts/shots)
return 2 * (0.5 - np.asarray(res, dtype=float))
def find_cross_point(xdata, ydata1, ydata2, n=4, filt_dim=5):
ydata1 = signal.savgol_filter(ydata1, filt_dim, 1)
ydata2 = signal.savgol_filter(ydata2, filt_dim, 1)
cross_points = xdata[1:][np.diff(np.sign(ydata1 - ydata2)) != 0]
main_cross = cross_points[np.argmin(np.abs(cross_points))]
idx = np.argmin(np.abs(xdata - main_cross))
x_reduced = xdata[idx-n:idx+n]
y1_reduced = ydata1[idx-n:idx+n]
y2_reduced = ydata2[idx-n:idx+n]
p1 = np.polyfit(x_reduced, y1_reduced, 1)
p2 = np.polyfit(x_reduced, y2_reduced, 1)
cross_opt = (p2[1] - p1[1]) / (p1[0] - p2[0])
return cross_opt
params1 = get_params(*durs1)
params2 = get_params(*durs2)
amps = np.linspace(-0.2, 0.2, 31)
result = run(
rough_amp(qubits, amps, params1) + rough_amp(qubits, amps, params2),
"rough_amp",
shots=128
)
fig, axs = plt.subplots(2, 1, sharex=True)
fit_func = lambda x, a, b, f: a * np.cos(2 * np.pi * f * x) + b
bounds = (0, -1, 0), (1, 1, np.inf)
for qind, ax in enumerate(axs):
expvals = np.split(get_expval(result, qind, 128), 2)
for expval, params_dict, color in zip(expvals, (params1, params2), ("r", "b")):
# freq init guess
fft_data = np.fft.fft(expval - np.average(expval))
freqs = np.fft.fftfreq(len(amps), amps[1] - amps[0])
positive_freqs = freqs[freqs >= 0]
positive_fft_data = fft_data[freqs >= 0]
f0 = positive_freqs[np.argmax(np.abs(positive_fft_data))]
# fit
pcov, _ = opt.curve_fit(fit_func, amps, expval, p0=[1, 0, f0], bounds=bounds)
# plot
ax.plot(amps, expval, "o", color=color)
ax.plot(amps, fit_func(amps, *pcov), ":", color=color)
hpi_amp = 1/(2*pcov[2])/2
ax.axvline(hpi_amp, color=color)
# update parameters
print(f"qubit {qind} amp = {hpi_amp}")
params_dict[f"sx{qind}"]["amp"] = hpi_amp
delta_amps = np.linspace(-0.02, 0.02, 21)
result = run(
fine_amp(qubits, delta_amps, 1, params1) + fine_amp(qubits, delta_amps, 1, params2),
"fine_amp1",
shots=128
)
fig, axs = plt.subplots(2, 1, sharex=True)
for qind, ax in enumerate(axs):
expvals = np.split(get_expval(result, qind, 128), 2)
for expval, params_dict, color in zip(expvals, (params1, params2), ("red", "blue")):
yp, ym = np.split(expval, 2)
p = find_cross_point(delta_amps, yp, ym)
# plot
ax.plot(delta_amps, yp, "^", color=color)
ax.plot(delta_amps, ym, "v", color=color)
ax.axvline(p, color=color)
# update parameters
print(f"qubit {qind}, Δamp = {p}")
params_dict[f"sx{qind}"]["amp"] += p
delta_betas = np.linspace(-10, 10, 21)
result = run(
fine_beta(qubits, delta_betas, 3, params1) + fine_beta(qubits, delta_betas, 3, params2),
"fine_beta1",
shots=1024
)
fig, axs = plt.subplots(2, 1, sharex=True)
for qind, ax in enumerate(axs):
expvals = np.split(get_expval(result, qind, 1024), 2)
for expval, params_dict, color in zip(expvals, (params1, params2), ("red", "blue")):
yp, ym = np.split(expval, 2)
p = find_cross_point(delta_betas, yp, ym)
# plot
ax.plot(delta_betas, yp, "^", color=color)
ax.plot(delta_betas, ym, "v", color=color)
ax.axvline(p, color=color)
# update parameters
print(f"qubit {qind}, Δbeta = {p}")
params_dict[f"sx{qind}"]["beta"] += p
delta_amps = np.linspace(-0.005, 0.005, 21)
result = run(
fine_amp(qubits, delta_amps, 2, params1) + fine_amp(qubits, delta_amps, 2, params2),
"fine_amp2",
shots=128
)
fig, axs = plt.subplots(2, 1, sharex=True)
for qind, ax in enumerate(axs):
expvals = np.split(get_expval(result, qind, 128), 2)
for expval, params_dict, color in zip(expvals, (params1, params2), ("red", "blue")):
yp, ym = np.split(expval, 2)
p = find_cross_point(delta_amps, yp, ym)
# plot
ax.plot(delta_amps, yp, "^", color=color)
ax.plot(delta_amps, ym, "v", color=color)
ax.axvline(p, color=color)
# update parameters
print(f"qubit {qind}, amp = {p}")
params_dict[f"sx{qind}"]["amp"] += p
amps = np.linspace(-0.8, 0.8, 51)
result = run(
rough_amp_cr(qubits, amps, params1) + rough_amp_cr(qubits, amps, params2),
"rough_amp_cr",
shots=128
)
fit_func = lambda x, a, b, f: a * np.cos(2 * np.pi * f * x) + b
bounds = (0, -1, 0), (1, 1, np.inf)
expvals = np.split(get_expval(result, 0, 128), 2)
for expval, params_dict, color in zip(expvals, (params1, params2), ("r", "b")):
# freq init guess
fft_data = np.fft.fft(expval - np.average(expval))
freqs = np.fft.fftfreq(len(amps), amps[1] - amps[0])
positive_freqs = freqs[freqs >= 0]
positive_fft_data = fft_data[freqs >= 0]
f0 = positive_freqs[np.argmax(np.abs(positive_fft_data))]
# fit
pcov, _ = opt.curve_fit(
fit_func,
amps,
expval,
p0=[1, 0, f0],
bounds=bounds,
sigma=1/(1-np.abs(amps)) - 0.99,
absolute_sigma=True,
)
# plot
plt.plot(amps, expval, "o", color=color)
plt.plot(amps, fit_func(amps, *pcov), ":", color=color)
hpi_amp = 1/(2*pcov[2])/2
plt.axvline(hpi_amp, color=color)
# update parameters
print(f"ECR amp = {hpi_amp}")
params_dict["ecr"]["amp"] = hpi_amp
phases = np.linspace(-np.pi, np.pi, 31)
result = run(
phase_cr(qubits, phases, params1) + phase_cr(qubits, phases, params2),
"rough_phase_cr",
shots=128
)
fit_func = lambda x, a, b, phi: a * np.cos(x - phi) + b
bounds = (0, -1, -np.pi), (1, 1, np.pi)
expvals = np.split(get_expval(result, 0, 128), 2)
for expval, params_dict, color in zip(expvals, (params1, params2), ("r", "b")):
# fit
pcov, _ = opt.curve_fit(fit_func, phases, expval, p0=[1, 0, 0], bounds=bounds)
# plot
plt.plot(phases, expval, "o", color=color)
plt.plot(phases, fit_func(phases, *pcov), ":", color=color)
cr_phase = pcov[2] + np.pi
if cr_phase > np.pi:
cr_phase -= 2 * np.pi
plt.axvline(cr_phase, color=color)
# update parameters
print(f"ECR phase = {cr_phase}")
params_dict["ecr"]["phase"] = cr_phase
delta_amps = np.linspace(-0.05, 0.05, 21)
result = run(
fine_amp_cr(qubits, delta_amps, 1, params1) + fine_amp_cr(qubits, delta_amps, 1, params2),
"fine_amp_cr",
shots=128
)
expvals = np.split(get_expval(result, 0, 128), 2)
for expval, params_dict, color in zip(expvals, (params1, params2), ("red", "blue")):
yp, ym = np.split(expval, 2)
p = find_cross_point(delta_amps, yp, ym)
# plot
plt.plot(delta_amps, yp, "^", color=color)
plt.plot(delta_amps, ym, "v", color=color)
plt.axvline(p, color=color)
# update parameters
print(f"ECR Δamp = {p}")
params_dict[f"ecr"]["amp"] += p
params1
params2
from qiskit_experiments.calibration_management import BackendCalibrations
from qiskit_experiments.calibration_management.parameter_value import ParameterValue
from datetime import datetime
import pandas as pd
cal_manager = BackendCalibrations(backend=backend)
# add sx schedule
sx_amp = circuit.Parameter("amp")
sx_dur = circuit.Parameter("τ")
sx_beta = circuit.Parameter("β")
sx_sigma = circuit.Parameter("σ")
ch_d = pulse.DriveChannel(circuit.Parameter("ch0"))
with pulse.build(name="sx") as sx_sched:
pulse.play(
pulse.Drag(duration=sx_dur, amp=sx_amp, sigma=sx_sigma, beta=sx_beta),
ch_d
)
cal_manager.add_schedule(sx_sched)
# parameters for ecr
ecr_amp = circuit.Parameter("amp")
ecr_phase = circuit.Parameter("θ")
ecr_dur = circuit.Parameter("τ")
ecr_sigma = circuit.Parameter("σ")
ch_u = backend.configuration().control(qubits)[0]
with pulse.build(name="ecr", default_alignment="sequential") as ecr_sched:
with pulse.phase_offset(ecr_phase, ch_u):
pulse.play(
pulse.GaussianSquare(duration=ecr_dur, amp=ecr_amp, sigma=ecr_sigma, risefall_sigma_ratio=2),
ch_u
)
pulse.call(cal_manager.get_template("sx", qubits=(qubits[0], )))
pulse.call(cal_manager.get_template("sx", qubits=(qubits[0], )))
pulse.play(
pulse.GaussianSquare(duration=ecr_dur, amp=-ecr_amp, sigma=ecr_sigma, risefall_sigma_ratio=2),
ch_u
)
cal_manager.add_schedule(ecr_sched)
for ind, param in enumerate([params1, params2]):
group = ind + 1
# sx
for qind in qubits:
cal_manager.add_parameter_value(
value=ParameterValue(value=param[f"sx{qind}"]["duration"], date_time=datetime.now(), group=f"sf{group}"),
param=sx_dur,
qubits=qind,
schedule="sx",
)
cal_manager.add_parameter_value(
value=ParameterValue(value=param[f"sx{qind}"]["amp"], date_time=datetime.now(), group=f"sf{group}"),
param=sx_amp,
qubits=qind,
schedule="sx",
)
cal_manager.add_parameter_value(
value=ParameterValue(value=param[f"sx{qind}"]["sigma"], date_time=datetime.now(), group=f"sf{group}"),
param=sx_sigma,
qubits=qind,
schedule="sx",
)
cal_manager.add_parameter_value(
value=ParameterValue(value=param[f"sx{qind}"]["beta"], date_time=datetime.now(), group=f"sf{group}"),
param=sx_beta,
qubits=qind,
schedule="sx",
)
cal_manager.add_parameter_value(
value=ParameterValue(value=qind, date_time=datetime.now(), group=f"sf{group}"),
param=ch_d,
qubits=qind,
schedule="sx",
)
# ecr
cal_manager.add_parameter_value(
value=ParameterValue(value=param["ecr"]["duration"], date_time=datetime.now(), group=f"sf{group}"),
param=ecr_dur,
qubits=qubits,
schedule="ecr",
)
cal_manager.add_parameter_value(
value=ParameterValue(value=param["ecr"]["amp"], date_time=datetime.now(), group=f"sf{group}"),
param=ecr_amp,
qubits=qubits,
schedule="ecr",
)
cal_manager.add_parameter_value(
value=ParameterValue(value=param["ecr"]["phase"], date_time=datetime.now(), group=f"sf{group}"),
param=ecr_phase,
qubits=qubits,
schedule="ecr",
)
cal_manager.add_parameter_value(
value=ParameterValue(value=param["ecr"]["sigma"], date_time=datetime.now(), group=f"sf{group}"),
param=ecr_sigma,
qubits=qubits,
schedule="ecr",
)
cal_manager.add_parameter_value(
value=ParameterValue(value=qubits[0], date_time=datetime.now(), group=f"sf{group}"),
param=ch_d,
qubits=qubits[0],
schedule="ecr",
)
df = pd.DataFrame(cal_manager.parameters_table())
df[df["schedule"].notna()].sort_values(["group", "schedule"])
df.query("schedule == 'ecr' and parameter in ['amp', 'τ']").sort_values(["parameter"])
fig, axs = plt.subplots(2, 1, sharex=True, figsize=(13, 8))
cal_manager.get_schedule("ecr", qubits=qubits, group="sf1").draw(backend=backend, axis=axs[0], style=IQXDebugging(**{"formatter.margin.left_percent": 0.1}))
cal_manager.get_schedule("ecr", qubits=qubits, group="sf2").draw(backend=backend, axis=axs[1], style=IQXDebugging())
gates_to_output = {"sx": [0, 1], "ecr": [(0, 1)]}
sf1_backend = cal_manager.export_backend(
outputs=gates_to_output,
basis_gates=["sx", "rz", "ecr"],
coupling_map=[[0, 1]],
group="sf1",
)
sf2_backend = cal_manager.export_backend(
outputs=gates_to_output,
basis_gates=["sx", "rz", "ecr"],
coupling_map=[[0, 1]],
group="sf2",
)
sf1_backend.configuration().basis_gates
sf1_backend.configuration().coupling_map
ecr_sched_sf1 = sf1_backend.defaults().instruction_schedule_map.get("ecr", (0, 1))
ecr_sched_sf1.draw(backend=backend)
ecr_sched_sf1.metadata
sf1_backend.defaults().instruction_schedule_map.get("rz", (0,)).metadata
from qiskit_nature.drivers import PySCFDriver, UnitsType, Molecule
from qiskit_nature.problems.second_quantization import ElectronicStructureProblem
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.mappers.second_quantization import ParityMapper
from qiskit.circuit.library import EfficientSU2
from qiskit.algorithms.optimizers import SPSA
from qiskit.algorithms import VQE
from qiskit_nature.algorithms.ground_state_solvers import GroundStateEigensolver
from qiskit.utils import QuantumInstance
molecule = Molecule(
geometry=[['H', [0., 0., 0.]], ['H', [0., 0., 0.735]]],
charge=0,
multiplicity=1
)
driver = PySCFDriver(molecule = molecule, unit=UnitsType.ANGSTROM, basis='sto3g')
es_problem = ElectronicStructureProblem(driver)
qubit_converter = QubitConverter(ParityMapper(), two_qubit_reduction=True)
ansatz = EfficientSU2(num_qubits=2, reps=1, entanglement='linear')
optimizer = SPSA(maxiter=80)
np.random.seed(5)
initial_point = np.random.random(ansatz.num_parameters)
def run_vqe(quantum_instance):
local_vqe = VQE(
ansatz=ansatz,
optimizer=optimizer,
initial_point=initial_point,
quantum_instance=quantum_instance,
)
local_vqe_groundstate_solver = GroundStateEigensolver(qubit_converter, local_vqe)
res = local_vqe_groundstate_solver.solve(es_problem)
print(f"Energy = {np.real(res.eigenenergies + res.nuclear_repulsion_energy)[0]}")
return res, local_vqe.get_optimal_circuit()
quantum_instance_sf1 = QuantumInstance(backend=sf1_backend, initial_layout=qubits)
res_sf1, opt_circ_sf1 = run_vqe(quantum_instance_sf1)
quantum_instance_sf2 = QuantumInstance(backend=sf2_backend, initial_layout=qubits)
res_sf2, opt_circ_sf2 = run_vqe(quantum_instance_sf2)
from qiskit import transpile
transpiled_circ = transpile(opt_circ_sf1, sf1_backend); transpiled_circ.draw(output="mpl")
transpiled_circ.calibrations.keys()
from qiskit.algorithms import NumPyMinimumEigensolver
np_solver = NumPyMinimumEigensolver()
np_groundstate_solver = GroundStateEigensolver(qubit_converter, np_solver)
np_result = np_groundstate_solver.solve(es_problem)
target_energy = np.real(np_result.eigenenergies + np_result.nuclear_repulsion_energy)[0]
print('Energy:', target_energy)
get_ek = lambda res: np.real(res.eigenenergies + res.nuclear_repulsion_energy)[0]
cs = [2, -1]
extrapolate_energy = cs[0] * get_ek(res_sf1) + cs[1] * get_ek(res_sf2)
print('Energy:', extrapolate_energy)
print(res_sf1)
print(res_sf2)
import pickle
with open("res_sf1.pk", "wb") as fp:
pickle.dump(res_sf1, fp)
with open("res_sf2.pk", "wb") as fp:
pickle.dump(res_sf2, fp)
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import sys
sys.path.append('../../')
import numpy as np
from numpy import linalg as la
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit
from compilers.aqc_demo.cnot_structures import full_conn, spin
from compilers.aqc_demo.parametric_circuit import ParametricCircuit
from compilers.aqc_demo.test_sample_data import ORIGINAL_CIRCUIT, INITIAL_THETAS
from compilers.aqc_demo.aqc_optimizers import FISTAOptimizer, GDOptimizer
from compilers.aqc_demo.aqc import AQC
num_qubits = int(np.log2(ORIGINAL_CIRCUIT.shape[0]))
num_qubits
def cnots_to_qc(num_qubits: int, cnots) -> QuantumCircuit:
circuit = QuantumCircuit(num_qubits)
for ii, elements in enumerate(cnots[0]):
circuit.cx(elements - 1, cnots[1][ii] - 1)
return circuit
cnots = spin(num_qubits, full_conn(num_qubits))
cnots_qc = cnots_to_qc(num_qubits, cnots)
cnots_qc.draw(output="mpl")
cnots_qc.depth()
target_circuit = ParametricCircuit(num_qubits, cnots)
initial_thetas_qc = target_circuit.make_circuit(INITIAL_THETAS, reverse=True)
initial_thetas_qc.draw(output="mpl")
initial_thetas_qc.depth()
def approximation_error(expected, actual) -> float:
return .5 * (la.norm(expected - actual, 'fro') ** 2)
target_unitary = target_circuit.compute_unitary(INITIAL_THETAS)
error = approximation_error(ORIGINAL_CIRCUIT, target_unitary)
error
optimizer = FISTAOptimizer(method="nesterov", maxiter=5000, eta=0.1, tol=0.01, eps=0.0, reg=0.7, group=True)
thetas, objective, gradient, _ = optimizer.optimize(ORIGINAL_CIRCUIT, INITIAL_THETAS, target_circuit)
target_unitary = target_circuit.compute_unitary(thetas)
error = approximation_error(ORIGINAL_CIRCUIT, target_unitary)
error
compressed_cnots, compressed_thetas, spar = target_circuit.compress(thetas, synth=False)
compressed_target_circuit = ParametricCircuit(num_qubits, compressed_cnots)
compressed_qc_circuit = compressed_target_circuit.make_circuit(compressed_thetas, reverse=True)
compressed_qc_circuit.draw(output="mpl")
compressed_qc_circuit.depth()
optimizer = GDOptimizer(method="nesterov", maxiter=5000, eta=0.1, tol=0.01, eps=0.0)
thetas, objective, gradient, thetas_min = optimizer.optimize(ORIGINAL_CIRCUIT,
compressed_thetas,
compressed_target_circuit)
num_iterations = np.shape(objective)[0]
plt.loglog(range(num_iterations), objective)
plt.xlabel('Iteration')
plt.ylabel('Approximation error')
plt.show()
target_unitary = compressed_target_circuit.compute_unitary(thetas)
error = approximation_error(ORIGINAL_CIRCUIT, target_unitary)
error
aqc = AQC(method="nesterov", maxiter=5000, eta=0.1, tol=0.01, eps=0.0, reg=0.7, group=True)
parametric_circuit, thetas = aqc.compile_unitary(ORIGINAL_CIRCUIT, cnots, INITIAL_THETAS)
target_unitary = parametric_circuit.compute_unitary(thetas)
error = approximation_error(ORIGINAL_CIRCUIT, target_unitary)
error
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import sys
#add local qiskit-terra/test/python path here to import transpiler._dummy_passes
#test_path='<enter path here>'
sys.path.append(test_path)
from transpiler import test_pass_scheduler
from qiskit import QuantumCircuit,QuantumRegister
from qiskit.transpiler import PassManager
from qiskit.transpiler.runningpassmanager import ConditionalController,DoWhileController
from transpiler._dummy_passes import (
PassA_TP_NR_NP,
PassB_TP_RA_PA,
PassC_TP_RA_PA,
PassD_TP_NR_NP,
PassE_AP_NR_NP,
PassF_reduce_dag_property,
PassI_Bad_AP,
PassJ_Bad_NoReturn,
PassK_check_fixed_point_property,
PassM_AP_NR_NP,
)
from transpiler.test_pass_scheduler import SchedulerTestCase
def show_run(passmanager,circuit):
myScheduler=SchedulerTestCase()
with myScheduler.assertLogs("LocalLogger", level="INFO") as cm:
out = passmanager.run(circuit)
return [record.message for record in cm.records]
#Creating a nested ConditionalController
#Defining PassManager and circuit
passmanager=PassManager()
circuit = QuantumCircuit(QuantumRegister(1))
#Runs PassA_TP_NR_NP if property_set["property"] is True
#Passes like PassA_TP_NR_NP are just test passes used in the test suite
nested_conditional=[ConditionalController(
[PassA_TP_NR_NP()],
condition=lambda property_set: property_set["property"])]
passmanager.append([PassE_AP_NR_NP(True)] +
nested_conditional)
show_run(passmanager,circuit)
#Nesting a ConditionalController inside of a loop
#Defining PassManager and circuit
passmanager=PassManager()
circuit = QuantumCircuit(QuantumRegister(1))
#Runs PassA_TP_NR_NP if property_set["property"] is True
nested_conditional=[ConditionalController(
[PassA_TP_NR_NP()],
condition=lambda property_set: property_set["property"])]
passmanager.append([PassK_check_fixed_point_property(), PassE_AP_NR_NP(True)]
+ nested_conditional
+ [PassF_reduce_dag_property()],
do_while=lambda property_set: not property_set["property_fixed_point"])
show_run(passmanager,circuit)
#Nesting ConditionalControllers more than one level
passmanager=PassManager()
circuit = QuantumCircuit(QuantumRegister(1))
nested_level3=ConditionalController([PassC_TP_RA_PA()], condition=lambda property_set: property_set["property"])
nested_level2=ConditionalController([PassF_reduce_dag_property(),nested_level3],condition=lambda property_set: property_set["property"])
nested_level1=[ConditionalController([PassA_TP_NR_NP(),nested_level2], condition=lambda property_set: property_set["property"])]
passmanager.append([PassE_AP_NR_NP(True)]
+ nested_level1)
show_run(passmanager,circuit)
#Multiple nested ConditionalControllers on the same level
passmanager=PassManager()
circuit = QuantumCircuit(QuantumRegister(1))
nested_conditional1=[ConditionalController([PassB_TP_RA_PA()], condition=lambda property_set: property_set["property"])]
nested_conditional2=[ConditionalController([PassC_TP_RA_PA()], condition=lambda property_set: property_set["property"])]
nested_conditional3=[ConditionalController([PassD_TP_NR_NP()], condition=lambda property_set: property_set["property"])]
passmanager.append([PassE_AP_NR_NP(True)]
+ nested_conditional1
+ [PassE_AP_NR_NP(False)]
+ nested_conditional2
+ [PassE_AP_NR_NP(True)]
+ nested_conditional3)
show_run(passmanager,circuit)
#Nested DoWhileController
passmanager=PassManager()
circuit = QuantumCircuit(QuantumRegister(1))
nested_do_while = [DoWhileController([PassK_check_fixed_point_property(),PassF_reduce_dag_property()],
do_while=lambda property_set: not property_set["property_fixed_point"])]
passmanager.append([PassD_TP_NR_NP()]
+ nested_do_while
+ [PassD_TP_NR_NP()])
show_run(passmanager,circuit)
from qiskit.circuit.library import QuantumVolume
from qiskit import *
from qiskit.test.mock import FakeBelem
qcomp = FakeBelem()
qv_circuit=QuantumVolume(3)
qv_circuit.draw()
from IPython.display import display
from qiskit.converters import dag_to_circuit
from qiskit.transpiler import TransformationPass
from qiskit.converters import dag_to_circuit
def my_callback(pass_,dag, time, property_set, count):
circuit = dag_to_circuit(dag)
print(pass_.name())
#display(circuit.draw(output='mpl'))
circuit = dag_to_circuit(dag)
transpile(qv_circuit,backend=qcomp, optimization_level=3,callback=my_callback,translation_method='synthesis').draw(output='mpl')
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit import *
q = QuantumRegister(3,'q')
c = ClassicalRegister(2,'c')
q1 = QuantumRegister(4,'q1')
c1 = ClassicalRegister(2,'c1')
res = ClassicalRegister(1,'r')
backend = Aer.get_backend('qasm_simulator')
qc = QuantumCircuit(q,c,res)
qc.x([0,1])
qc.measure([0,1],[0,1])
qc.h(2).c_if([c[0],c[1]],3)
qc.measure(2,res)
qjob = execute(qc,backend)
counts = qjob.result().get_counts()
print(counts)
qc.draw('mpl', cregbundle=False)
qc1 = QuantumCircuit(q,c,c1,res)
qc1.x([0,1])
qc1.measure([0,1],[c[0],c1[0]])
qc1.h(2).c_if([c[0],c1[1]],2)
qc1.measure(2,res)
qjob1 = execute(qc1,backend)
counts = qjob1.result().get_counts()
print(counts)
qc1.draw('mpl',cregbundle=False)
|
https://github.com/Qiskit/feedback
|
Qiskit
|
%load_ext autoreload
%autoreload 2
import numpy as np
from qiskit.circuit.library import RealAmplitudes
from qiskit.opflow import PauliSumOp
observable = PauliSumOp.from_list(
[
("II", -1.052373245772859),
("IZ", 0.39793742484318045),
("ZI", -0.39793742484318045),
("ZZ", -0.01128010425623538),
("XX", 0.18093119978423156),
]
)
print("observable")
print(observable)
ansatz = RealAmplitudes(num_qubits=2, reps=2)
print("\nansatz")
ansatz.decompose().draw("mpl")
from qiskit.evaluators import PauliExpectationValue
from qiskit.providers.aer import AerSimulator
backend = AerSimulator()
expval = PauliExpectationValue(ansatz, observable, backend=backend)
expval.evaluate([0, 1, 1, 2, 3, 5], shots=1000)
# multi prameters
expval = PauliExpectationValue(ansatz, observable, backend=backend)
expval.evaluate([[0, 1, 1, 2, 3, 5], [1, 1, 2, 3, 5, 8]], shots=3000)
from qiskit.evaluators import ExactExpectationValue
expval = ExactExpectationValue(ansatz, observable, backend=backend)
expval.evaluate([0, 1, 1, 2, 3, 5])
expval = ExactExpectationValue(ansatz, observable, backend=backend)
expval.evaluate(np.array([[0, 1, 1, 2, 3, 5], [1, 1, 2, 3, 5, 8]]))
from qiskit.test.mock import FakeBogota
backend = AerSimulator.from_backend(FakeBogota())
expval = PauliExpectationValue(ansatz, observable, backend=backend)
expval.set_transpile_options(initial_layout=[3, 2])
print(expval.evaluate([0, 1, 1, 2, 3, 5]))
expval.transpiled_circuits[0].draw("mpl")
try:
from qiskit import QuantumCircuit, QiskitError
qc = QuantumCircuit(1, 1)
qc.h(0)
qc.measure(0, 0)
from qiskit import IBMQ
prov = IBMQ.load_account()
ibmq_qasm_sim = prov.get_backend('ibmq_qasm_simulator')
print(f"max_shots {backend.configuration().max_shots}")
ibmq_qasm_sim.run(qc, shots=10000).result().get_counts()
except QiskitError as ex:
print(ex.message)
expval = PauliExpectationValue(ansatz, observable, backend=ibmq_qasm_sim)
expval.evaluate([0, 1, 1, 2, 3, 5], shots=10000)
from qiskit.evaluators.backends import ReadoutErrorMitigation
backend = AerSimulator.from_backend(FakeBogota())
mit_tensored = ReadoutErrorMitigation(
backend, mitigation="tensored", refresh=600, shots=2000, mit_pattern=[[0], [1]]
)
mit_mthree = ReadoutErrorMitigation(
backend, mitigation="mthree", refresh=600, shots=2000, qubits=[0, 1]
)
expval_raw = PauliExpectationValue(ansatz, observable, backend=backend)
expval_tensored = PauliExpectationValue(ansatz, observable, backend=mit_tensored)
expval_mthree = PauliExpectationValue(ansatz, observable, backend=mit_mthree)
shots = 4000
print(f"w/o mitigation shots={shots}, result={expval_raw.evaluate([0, 1, 1, 2, 3, 5], shots=shots)}")
print(f"w/ tensored mitigation shots={shots}, result={expval_tensored.evaluate([0, 1, 1, 2, 3, 5], shots=shots)}")
print(f"w/ M3 mitigation shots={shots}, result={expval_mthree.evaluate([0, 1, 1, 2, 3, 5], shots=shots)}")
from qiskit.evaluators.expectation_value.expectation_value_gradient import (
FiniteDiffGradient,
ParameterShiftGradient,
)
parameters = [0, 1, 1, 2, 3, 5]
exact_expval = ExactExpectationValue(ansatz, observable, backend=AerSimulator())
exact_findiff = FiniteDiffGradient(exact_expval, 1e-8)
print(f"fin diff of exact {exact_findiff.evaluate(parameters).values}")
exact_expval = ExactExpectationValue(ansatz, observable, backend=AerSimulator())
exact_findiff = ParameterShiftGradient(exact_expval)
print(f"param shift of exact {exact_findiff.evaluate([0, 1, 1, 2, 3, 5]).values}")
shots = 2000
findiff = FiniteDiffGradient(expval_raw, 1e-1)
paramshift = ParameterShiftGradient(expval_raw)
print(f"fin diff w/o mit {findiff.evaluate(parameters, shots=shots).values}")
print(f"param shift w/o mit {paramshift.evaluate(parameters, shots=shots).values}")
findiff = FiniteDiffGradient(expval_mthree, 1e-1)
paramshift = ParameterShiftGradient(expval_mthree)
print(f"fin diff w/ mit {findiff.evaluate([0, 1, 1, 2, 3, 5], shots=shots).values}")
print(f"param shift w/ mit {paramshift.evaluate(parameters, shots=shots).values}")
from scipy.optimize import minimize
shots = 1000
expval = PauliExpectationValue(ansatz, observable, backend=AerSimulator(), append=True)
paramshift = ParameterShiftGradient(expval)
# this may take a long time...
result = minimize(
lambda x: expval.evaluate(x, shots=shots, seed_simulator=123).value,
np.zeros(6),
jac=lambda x: paramshift.evaluate(x, shots=shots, seed_simulator=123).values,
)
print(result)
import matplotlib.pyplot as plt
from qiskit.evaluators.results import ExpectationValueResult
plt.figure(figsize=(12, 8))
y = [h.value for h in expval.history if isinstance(h, ExpectationValueResult)]
x = list(range(len(y)))
yerr = np.array(
[tuple(abs(c - h.value) for c in h.confidence_interval) for h in expval.history if isinstance(h, ExpectationValueResult)]
).transpose()
plt.plot(y, color="blue")
plt.errorbar(x, y, yerr=yerr, capsize=5, fmt="o", markersize=8, ecolor="blue", markeredgecolor="blue", color="w")
plt.xlabel("Eval count")
plt.ylabel("Energy")
plt.show()
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit import QuantumCircuit, transpile, schedule, IBMQ
from qiskit.transpiler import PassManager
import numpy as np
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-internal', group='deployed', project='default')
backend = provider.get_backend('ibm_lagos')
%matplotlib inline
%config InlineBackend.figure_format = 'retina'
from IPython.display import display
from qiskit.circuit.library.standard_gates.equivalence_library import StandardEquivalenceLibrary as std_eqlib
# Transpiler passes
from qiskit.transpiler.passes import Collect2qBlocks
from qiskit.transpiler.passes import ConsolidateBlocks
from qiskit.transpiler.passes import Optimize1qGatesDecomposition
from qiskit.transpiler.passes.basis import BasisTranslator, UnrollCustomDefinitions
from qiskit.transpiler.passes.calibration.builders import RZXCalibrationBuilderNoEcho
# New transpiler pass
from qiskit.transpiler.passes.optimization.echo_rzx_weyl_decomposition import EchoRZXWeylDecomposition
from qiskit.circuit.library.standard_gates import (RZZGate, RXXGate, RYYGate, RZXGate,
CPhaseGate, CRZGate, HGate, SwapGate, CXGate, iSwapGate)
import qiskit.quantum_info as qi
from qiskit.quantum_info.synthesis.two_qubit_decompose import (TwoQubitControlledUDecomposer,
TwoQubitWeylDecomposition)
theta = 0.8
qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.rz(theta, 1)
qc.cx(0, 1)
qc.draw('mpl')
qct = transpile(qc, backend)
schedule(qct, backend).draw()
theta = 0.8
# equivalent decomposition in terms of echoed Cross-Resonance gates.
qc = QuantumCircuit(2)
qc.rz(np.pi / 2, 1)
qc.sx(1)
qc.rz(np.pi / 2, 1)
qc.rzx(theta / 2, 0, 1)
qc.x(0)
qc.rzx(-theta / 2, 0, 1)
qc.x(0)
qc.rz(np.pi / 2, 1)
qc.sx(1)
qc.rz(np.pi / 2, 1)
qc.draw('mpl')
# Add the calibrations.
pm = PassManager([RZXCalibrationBuilderNoEcho(backend)])
qc_pulse_efficient = pm.run(qc)
# qc_pulse_efficient.calibrations
schedule(qc_pulse_efficient, backend).draw()
# Compare the schedule durations
print('Duration of standard CNOT-based circuit:')
print(schedule(qct, backend).duration)
print('Duration of pulse-efficient circuit:')
print(schedule(qc_pulse_efficient, backend).duration)
# random two-qubit circuit
qc = QuantumCircuit(2)
qc.rzx(0.2, 1, 0)
qc.cp(1, 0, 1)
qc.s(0)
qc.rzz(-0.6, 0, 1)
qc.swap(0, 1)
qc.h(0)
qc.ryy(2.3, 0, 1)
qc.iswap(0, 1)
qc.draw('mpl')
unitary = qi.Operator(qc)
decomposer_weyl = TwoQubitWeylDecomposition(unitary)
decomposer_weyl.circuit().draw('mpl')
gate = RZXGate
two_qubit_decompose = TwoQubitControlledUDecomposer(gate)
new_circuit = two_qubit_decompose(unitary)
new_circuit.draw('mpl')
# Random circuit
delta = 8 * np.pi / 5
epsilon = np.pi / 2
eta = -5.1
theta = 0.02
qc = QuantumCircuit(3)
qc.ryy(theta, 0, 1)
qc.s(0)
qc.rz(eta, 1)
qc.rzz(epsilon, 0, 1)
qc.swap(0, 1)
qc.cx(1, 0)
qc.rzz(delta, 1, 2)
qc.swap(1, 2)
qc.h(2)
print('Original circuit:')
display(qc.draw('mpl', idle_wires=False))
qct = transpile(qc, backend)
print('Standard Qiskit transpilation:')
display(qct.draw('mpl', idle_wires=False))
pm = PassManager(
[
# Consolidate consecutive two-qubit operations.
Collect2qBlocks(),
ConsolidateBlocks(basis_gates=['rz', 'sx', 'x', 'rxx']),
]
)
qct_consolidated = pm.run(qct)
qct_consolidated.draw('mpl', idle_wires=None)
pm = PassManager(
[
# Rewrite circuit in terms of Weyl-decomposed echoed RZX gates.
EchoRZXWeylDecomposition(backend),
]
)
qct_rzx_weyl = pm.run(qct_consolidated )
qct_rzx_weyl.draw('mpl', idle_wires=None)
# Random circuit
delta = 8 * np.pi / 5
epsilon = np.pi / 2
eta = -5.1
theta = 0.02
qc = QuantumCircuit(3)
qc.ryy(theta, 0, 1)
qc.s(0)
qc.rz(eta, 1)
qc.rzz(epsilon, 0, 1)
qc.swap(0, 1)
qc.cx(1, 0)
qc.rzz(delta, 1, 2)
qc.swap(1, 2)
qc.h(2)
print('Original circuit:')
display(qc.draw('mpl', idle_wires=False))
qct = transpile(qc, backend)
print('Standard Qiskit transpilation:')
display(qct.draw('mpl', idle_wires=False))
rzx_basis = ['rzx', 'rz', 'x', 'sx']
# Build a pass manager that contains all needed transpiler passes
pm = PassManager(
[
# Consolidate consecutive two-qubit operations.
Collect2qBlocks(),
ConsolidateBlocks(basis_gates=['rz', 'sx', 'x', 'rxx']),
# Rewrite circuit in terms of Weyl-decomposed echoed RZX gates.
EchoRZXWeylDecomposition(backend),
# Attach scaled CR pulse schedules to the RZX gates.
RZXCalibrationBuilderNoEcho(backend),
# Simplify single-qubit gates.
UnrollCustomDefinitions(std_eqlib, rzx_basis),
BasisTranslator(std_eqlib, rzx_basis),
Optimize1qGatesDecomposition(rzx_basis)
]
)
# Run the pass manager
qc_pulse_efficient = pm.run(qct)
print('Pulse-efficient, RZX-based circuit:')
display(qc_pulse_efficient.draw('mpl', idle_wires=False))
# Compare the schedule durations
print('Duration of standard CNOT-based circuit:')
print(schedule(qct, backend).duration)
print('Duration of pulse-efficient circuit:')
print(schedule(qc_pulse_efficient, backend).duration)
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from matplotlib import pyplot as plt
import numpy as np
from scipy.integrate import quad
from qiskit.quantum_info.states import Statevector, DensityMatrix
from qiskit.quantum_info.operators import Operator
from qiskit.quantum_info.operators import SuperOp, Choi, Kraus, PTM
from qiskit_dynamics import solve_ode, solve_lmde
from qiskit_dynamics.signals import Signal
from qiskit_dynamics.models import (HamiltonianModel,
LindbladModel,
rotating_wave_approximation)
def gaussian(amp, sig, t0, t):
return amp * np.exp( -(t - t0)**2 / (2 * sig**2) )
amp = 1. # amplitude
sig = 2. # sigma
t0 = 3.5*sig # center of Gaussian
T = 7*sig # end of signal
gaussian_envelope = lambda t: gaussian(amp, sig, t0, t)
gauss_signal = Signal(envelope=gaussian_envelope, carrier_freq=0.5)
print(gauss_signal.envelope(0.25))
print(gauss_signal(0.25))
gauss_signal.draw(0, T, 100, function='envelope')
gauss_signal.draw(0, T, 200)
#####################
# construct operators
#####################
r = 0.5
w = 1.
X = Operator.from_label('X')
Y = Operator.from_label('Y')
Z = Operator.from_label('Z')
drift = 2 * np.pi * w * Z/2
operators = [2 * np.pi * r * X/2]
###################
# construct signals
###################
# Define gaussian envelope function to have max amp and area approx 2
amp = 1.
sig = 0.399128/r
t0 = 3.5*sig
T = 7*sig
gaussian_envelope = lambda t: gaussian(amp, sig, t0, t)
signals = [Signal(envelope=gaussian_envelope, carrier_freq=w)]
#################
# construct model
#################
hamiltonian = HamiltonianModel(drift=drift, operators=operators, signals=signals)
print(hamiltonian.evaluate(0.12))
hamiltonian.get_drift()
def plot_qubit_hamiltonian_components(hamiltonian, t0, tf, N=200):
t_vals = np.linspace(t0, tf, N)
model_vals = np.array([1j*hamiltonian.evaluate(t) for t in t_vals])
x_coeff = model_vals[:, 0, 1].real
y_coeff = -model_vals[:, 0, 1].imag
z_coeff = model_vals[:, 0, 0].real
plt.plot(t_vals, x_coeff, label='X component')
plt.plot(t_vals, y_coeff, label='Y component')
plt.plot(t_vals, z_coeff, label='Z component')
plt.legend()
plot_qubit_hamiltonian_components(hamiltonian, 0., T)
hamiltonian.rotating_frame = hamiltonian.get_drift()
print(hamiltonian.evaluate(0.12))
# validate with independent computation
t = 0.12
-1j*(2 * np.pi * r * np.real(signals[0](t)) * (np.cos(2*np.pi * w * t) * X / 2
- np.sin(2*np.pi * w * t) * Y / 2 ))
plot_qubit_hamiltonian_components(hamiltonian, 0., T)
# set the cutoff frequency
rwa_hamiltonian = rotating_wave_approximation(hamiltonian, 2*w)
# evaluate again
print(rwa_hamiltonian.evaluate(0.12))
plot_qubit_hamiltonian_components(rwa_hamiltonian, 0., T)
# solve the problem, with some options specified
y0 = Statevector([0., 1.])
%time sol = solve_lmde(hamiltonian, t_span=[0., T], y0=y0, atol=1e-10, rtol=1e-10)
y = sol.y[-1]
print("\nFinal state:")
print("----------------------------")
print(y)
print("\nPopulation in excited state:")
print("----------------------------")
print(np.abs(y[0])**2)
%time sol = solve_lmde(rwa_hamiltonian, t_span=[0., T], y0=y0, atol=1e-10, rtol=1e-10)
y = sol.y[-1]
print("\nFinal state:")
print("----------------------------")
print(y)
print("\nPopulation in excited state:")
print("----------------------------")
print(np.abs(y[0])**2)
# construct quantum model with noise operators
noise_ops = [np.array([[0., 0.],
[1., 0.]])]
noise_signals = [0.001]
lindblad_model = LindbladModel.from_hamiltonian(hamiltonian=hamiltonian,
dissipator_operators=noise_ops,
dissipator_signals=noise_signals)
lindblad_model = LindbladModel(hamiltonian_operators=operators,
drift=drift,
rotating_frame=drift,
hamiltonian_signals=signals,
dissipator_operators=noise_ops,
dissipator_signals=noise_signals)
# density matrix
y0 = DensityMatrix([[0., 0.], [0., 1.]])
%time sol = solve_lmde(lindblad_model, t_span=[0., T], y0=y0, atol=1e-10, rtol=1e-10)
sol.y[-1]
rwa_lindblad_model = rotating_wave_approximation(lindblad_model, 2.0*w)
%time sol = solve_lmde(rwa_lindblad_model, t_span=[0., T], y0=y0, atol=1e-10, rtol=1e-10)
sol.y[-1]
lindblad_model.evaluation_mode = 'dense_vectorized'
lindblad_model.rotating_frame = None
# identity quantum channel in superop representation
y0 = SuperOp(np.eye(4))
%time sol = solve_lmde(lindblad_model.__call__, t_span=[0., T], y0=y0, atol=1e-12, rtol=1e-12)
print(sol.y[-1])
print(PTM(sol.y[-1]))
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import numpy as np
from qiskit_dynamics.models import (
HamiltonianModel,
LindbladModel,
rotating_wave_approximation,
)
from qiskit_dynamics.signals import Signal
Omega_0 = 0.5
tau = 3
omega_0 = 1
nu = 1/(2*np.pi) #2\pi\nu = \omega_0
Omega = lambda t: Omega_0 * np.exp(-t**2/(2*tau**2))
drive_signal = Signal(Omega,nu,0)
drive_operator = np.array([[[0,-1],[-1,0]]])
drift_operator = omega_0*np.array([[1,0],[0,-1]])
model = HamiltonianModel(drive_operator,drift=drift_operator,signals=[drive_signal])
print(model.evaluate(0))
model.set_evaluation_mode("sparse")
print(model.evaluate(0))
model.rotating_frame = np.array([1,-1])
print(model(0))
rwa_model = rotating_wave_approximation(model, cutoff_freq=1/4)
print(np.round(rwa_model(0),6))
model.rotating_frame = np.array([1,-1])
dis_op = np.array([[[0,0],[1,0]]])
rho = np.diag([1,0]) # excited state
dis_model = LindbladModel.from_hamiltonian(model, dissipator_operators=dis_op, dissipator_signals=[1], evaluation_mode="dense")
print(help(dis_model.set_evaluation_mode))
dis_model.set_evaluation_mode('dense')
print(dis_model.evaluate_hamiltonian(0))
print(dis_model(0,rho))
dis_model.set_evaluation_mode('sparse')
print(dis_model.evaluate_hamiltonian(0))
print(dis_model(0,rho))
rho_vec = rho.flatten(order="F") # vectorized operator using column stacking convention
dis_model.set_evaluation_mode('dense_vectorized')
print(dis_model(0))
print(dis_model(0) @ rho_vec)
print(dis_model(0,rho_vec))
sig_vals = model.signals(0)
model.set_evaluation_mode("dense")
operator_collection = model._operator_collection
print(type(operator_collection))
print(operator_collection.evaluate(sig_vals))
model.set_evaluation_mode("sparse")
operator_collection = model._operator_collection
print(type(operator_collection))
print(operator_collection.evaluate(sig_vals))
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import numpy
from qiskit.circuit.library import GraphState
from qiskit.test.mock import FakeMumbai
from qiskit.transpiler import CouplingMap
from qiskit.transpiler.passes import VF2Layout, CSPLayout
from qiskit.visualization import plot_gate_map, plot_circuit_layout
backend = FakeMumbai()
config = backend.configuration()
cm = config.coupling_map
size = config.n_qubits
display(plot_gate_map(backend))
rows = [x[0] for x in cm]
cols = [x[1] for x in cm]
A = numpy.zeros((size, size))
A[rows, cols] = 1
from random import shuffle
random_map = list(range(size))
shuffle(random_map)
B = numpy.zeros((size, size))
for i in range(size):
for j in range(size):
B[i][j] = A[random_map[i]][random_map[j]]
A = B
circuit = GraphState(A).decompose()
circuit.draw(fold=-1)
vf2_pass = VF2Layout(CouplingMap(cm))
csp_pass = CSPLayout(CouplingMap(cm), time_limit=None, call_limit=None)
csp_transpiled = csp_pass(circuit)
vf2_transpiled = vf2_pass(circuit)
plot_circuit_layout(vf2_transpiled, backend)
plot_circuit_layout(csp_transpiled, backend)
from qiskit import QuantumCircuit
# T-shape interaction map
circuit = QuantumCircuit(5)
circuit.cx(0,1)
circuit.cx(0,2)
circuit.cx(0,3)
circuit.cx(3,4)
# Multiple possible answers. This allows for noise-awareness (ish).
vf2_transpiled = vf2_pass(circuit)
vf2_transpiled
|
https://github.com/Qiskit/feedback
|
Qiskit
|
%load_ext autoreload
%autoreload 2
import numpy as np
from qiskit import QuantumCircuit, BasicAer
from qiskit.circuit.library import RealAmplitudes
from qiskit.opflow import PauliSumOp
observable = PauliSumOp.from_list(
[
("IIXZ", -1.052373245772859),
("IZXZ", 0.39793742484318045),
("ZIZZ", -0.39793742484318045),
("ZZXZ", -0.01128010425623538),
("XXZZ", 0.18093119978423156),
]
)
U = RealAmplitudes(num_qubits=2, reps=2)
bitsrings = [[0, 1], [1, 0]]
schmidts = [1/np.sqrt(2**2), 1/np.sqrt(2**2)]
print("Schmidts:", schmidts)
print("Observable:")
print(observable)
print("U:")
U.decompose().draw()
from qiskit.evaluators import EntanglementForgingExpectationValue
expval = EntanglementForgingExpectationValue(U, observable,
bitstrings=bitsrings,
schmidts=schmidts,
backend=BasicAer.get_backend("qasm_simulator"))
expectation = expval.evaluate([0, 1, 1, 2, 3, 5], shots=1000).value
print("EF exp value: {}".format(expectation))
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from math import pi
import numpy as np
from qiskit_nature.operators.second_quantization.fermionic_op import FermionicOp
from qiskit_nature.problems.second_quantization.lattice import HyperCubicLattice, LineLattice, SquareLattice, TriangularLattice
from qiskit_nature.problems.second_quantization.lattice import FermiHubbardModel
num_nodes = 6
boundary_condition = 'open'
line = LineLattice(
num_nodes = num_nodes,
boundary_condition=boundary_condition
)
line.draw()
num_nodes = 11
boundary_condition = 'periodic' # `boundary_condition` must be 'open' or 'periodic'.
line_p = LineLattice(
num_nodes = num_nodes,
boundary_condition=boundary_condition
)
line_p.draw()
rows = 4
cols = 3
boundary_condition = 'open'
square = SquareLattice(
rows=rows,
cols=cols,
boundary_condition=boundary_condition
)
square.draw()
rows = 4
cols = 3
boundary_condition = ('open', 'periodic') # open in the x-direction, periodic in the y-direction
square_op = SquareLattice(
rows=rows,
cols=cols,
boundary_condition=boundary_condition
)
square_op.draw()
size = (3, 4, 5)
boundary_condition = ('open', 'open', 'open')
hypercubic = HyperCubicLattice(
size=size,
boundary_condition=boundary_condition
)
# function for setting the positions
def indextocoord_3d(index:int, size:tuple, angle) -> list:
z = index // (size[0]*size[1])
a = index % (size[0]*size[1])
y = a // size[0]
x = a % size[0]
vec_x = np.array([1, 0])
vec_y = np.array([np.cos(angle), np.sin(angle)])
vec_z = np.array([0, 1])
return_coord = x*vec_x + y*vec_y + z*vec_z
return return_coord.tolist()
pos = dict([(index, indextocoord_3d(index, size, angle=pi/4)) for index in range(np.prod(size))])
hypercubic.draw(pos=pos)
rows = 4
cols = 3
boundary_condition = 'open'
triangular = TriangularLattice(
rows=rows,
cols=cols,
boundary_condition=boundary_condition
)
triangular.draw()
line = LineLattice(
num_nodes=3,
boundary_condition='open'
)
line.draw()
t = -1.0
t_onsite = 0.0
U = 5.0
fhm = FermiHubbardModel.uniform_parameters(
lattice=line,
uniform_hopping=t,
uniform_onsite_potential=t_onsite,
onsite_interaction=U)
FermionicOp.set_truncation(0)
print(fhm.second_q_ops(display_format='sparse'))
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.mappers.second_quantization import JordanWignerMapper
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import RealAmplitudes
from qiskit.opflow import AerPauliExpectation
from qiskit.providers.aer import AerSimulator
# make a lattice
line = LineLattice(
num_nodes=3,
boundary_condition='open'
)
# the FHM
t = -1.0
t_onsite = 0.0
U = 5.0
fhm = FermiHubbardModel.uniform_parameters(
lattice=line,
uniform_hopping=t,
uniform_onsite_potential=t_onsite,
onsite_interaction=U
)
# the FHM in terms of `FermionicOp`
ham = fhm.second_q_ops(display_format='sparse')
print(ham.reduce())
# convert the Hamiltonian to qubits
qubit_converter = QubitConverter(mapper=JordanWignerMapper())
qubit_op = qubit_converter.convert(ham)
# define the quantum circuit
circ = RealAmplitudes(num_qubits=ham.register_length, reps=2)
print('Quantum circuit')
print(circ.decompose().draw())
# make the vqe instance
vqe = VQE(
ansatz=circ,
optimizer=SLSQP(),
expectation=AerPauliExpectation(),
max_evals_grouped=9999,
quantum_instance=AerSimulator()
)
result = vqe.compute_minimum_eigenvalue(operator=qubit_op)
energy = np.real(result.eigenvalue)
print(f'Energy: {energy}')
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit import QuantumCircuit, transpile
import ipywidgets as widgets
from IPython.display import HTML
import logging
class WidgetLayout:
timeline_layout = {
'border': '1px inset #eee',
'padding': '2px',
'height': '275px',
'overflow': 'auto',
'width': '70%'
}
accordion_layout = {
'border': '1px inset #eee',
'padding': '0',
'height': '275px',
'width': '30%'
}
tabular_data_layout = {
'padding': '5px',
'grid_template_columns': 'repeat(2, 50%)'
}
timeline_panel = widgets.VBox([], layout = { 'width': '100%' })
timeline_wpr = widgets.Box([timeline_panel], layout = WidgetLayout.timeline_layout)
stats_labels = [
widgets.Label('1Q ops'), widgets.Label(''),
widgets.Label('2Q ops'), widgets.Label(''),
widgets.Label('Depth'), widgets.Label(''),
widgets.Label('Size'), widgets.Label(''),
widgets.Label('Width'), widgets.Label(''),
]
stats_panel = widgets.GridBox(stats_labels, layout = WidgetLayout.tabular_data_layout)
properties_panel = widgets.GridBox([], layout = WidgetLayout.tabular_data_layout)
accordion = widgets.Accordion(children = [stats_panel, properties_panel], layout = WidgetLayout.accordion_layout)
accordion.set_title(0, 'Circuit Stats')
accordion.set_title(1, 'Property Set')
main_view = widgets.HBox([timeline_wpr, accordion], layout = { 'width': '100%' })
modal = widgets.Output(layout = { 'width': '100%' })
tp_widget = widgets.VBox([
main_view,
modal
], layout = { 'width': '100%' })
tp_widget.add_class('tp-widget')
import sys
from types import ModuleType, FunctionType
from gc import get_referents
# Custom objects know their class.
# Function objects seem to know way too much, including modules.
# Exclude modules as well.
BLACKLIST = type, ModuleType, FunctionType
def getsize(obj):
"""sum size of object & members."""
#if isinstance(obj, BLACKLIST):
# raise TypeError('getsize() does not take argument of type: '+ str(type(obj)))
seen_ids = set()
size = 0
objects = [obj]
while objects:
need_referents = []
for obj in objects:
if not isinstance(obj, BLACKLIST) and id(obj) not in seen_ids:
# if id(obj) not in seen_ids:
seen_ids.add(id(obj))
size += sys.getsizeof(obj)
need_referents.append(obj)
objects = get_referents(*need_referents)
return size
from enum import Enum
class PassType(Enum):
ANALYSIS = 'A'
TRANSFORMATION = 'T'
class Property:
LARGE_VALUE_THRESHOLD = 2 ** 20
def __init__(self, name, type, value) -> None:
self.name = name
self.type = type
if getsize(value) > self.LARGE_VALUE_THRESHOLD:
self.value = 'LARGE_VALUE'
else:
self.value = value
def __repr__(self) -> str:
return f"{self.name} ({self.type.__name__}) : {self.value}"
class CircuitStats:
def __init__(self) -> None:
self.width = None
self.size = None
self.depth = None
self.ops_1q = None
self.ops_2q = None
def __eq__(self, other):
return self.width == other.width and self.size == other.size and self.depth == other.depth and self.ops_1q == other.ops_1q and self.ops_2q == other.ops_2q
def __repr__(self) -> str:
return f"CircuitStats(width={self.width}, size={self.size}, depth={self.depth}, 1Q ops={self.ops_1q}, 2Q ops={self.ops_2q})"
from time import time
class LogEntry:
def __init__(self, levelname, msg, args) -> None:
self.levelname = levelname
self.msg = msg
self.args = args
self.time = time()
def __repr__(self) -> str:
return f"[{self.levelname}] {self.msg}"
class TranspilationStep:
def __init__(self, name, type) -> None:
self.name = name
self.type = type
self.docs = ''
self.run_docs = ''
self.duration = 0
self.circuit_stats = CircuitStats()
self.property_set = {}
self.logs = []
self.dag = None
def __repr__(self) -> str:
return f"(name={self.name}, type={self.type})"
class ButtonWithValue(widgets.Button):
def __init__(self, *args, **kwargs):
self.value = kwargs['value']
kwargs.pop('value', None)
super(ButtonWithValue, self).__init__(*args, **kwargs)
from datetime import datetime
import html
%matplotlib inline
def on_logs(btn):
step = transpilation_sequence.steps[int(btn.value)]
logs = step.logs
#TEMP:
if len(logs) > 22:
logs[7].levelname = 'WARNING'
logs[10].levelname = 'ERROR'
logs[13].levelname = 'CRITICAL'
logs[15].levelname = 'INFO'
logs[16].levelname = 'INFO'
logs[20].levelname = 'ERROR'
logs[21].levelname = 'CRITICAL'
#END-TEMP
html_str = '<div class="logs-wpr">'
for entry in logs:
html_str = html_str + "<pre class='date'>{0}</pre><pre class='level {1}'>[{1}]</pre><pre class='log-entry {1}'>{2}</pre>".format(datetime.fromtimestamp(entry.time).strftime("%H:%M:%S.%f")[:-3], entry.levelname, entry.msg % entry.args)
html_str = html_str + '</div>'
show_modal(step.name + ' Logs', html_str, '')
def on_circ(btn):
from qiskit.converters import dag_to_circuit
from io import BytesIO
from binascii import b2a_base64
circ = dag_to_circuit(transpilation_sequence.steps[int(btn.value)].dag)
fig = circ.draw('mpl', idle_wires = False, with_layout = False, scale = 0.8, fold = 20)
bio = BytesIO()
#fig.canvas.print_png(bio)
fig.savefig(bio, format = 'png', bbox_inches = 'tight')
img_data = b2a_base64(bio.getvalue()).decode()
img_html = '<img src="data:image/png;base64,{} ">'.format(img_data)
show_modal('Circuit Plot', img_html, '840px')
def on_info(btn):
step = transpilation_sequence.steps[int(btn.value)]
html_str = '<pre class="help">' + step.docs + '</pre>'
html_str = html_str + '<div class="help-header"><span style="color: #e83e8c;">' + step.name + '</span>.run(<span style="color: #0072c3;">dag</span>)</div>'
html_str = html_str + '<pre class="help">' + step.run_docs + '</pre>'
show_modal(step.name, html_str, '')
def on_property(btn):
step_index, property_name = btn.value.split(',')
property_set = transpilation_sequence.steps[int(step_index)].property_set
property = property_set[property_name]
html_str = '<table>'
for v in property.value:
###
# ??? if type(v) == tuple:
if property_name == 'block_list':
html_str = html_str + '<tr><td><pre>' + html.escape(str([node.name for node in v])) + '</pre></td></tr>'
else:
html_str = html_str + '<tr><td><pre>' + html.escape(str(v)) + '</pre></td></tr>'
html_str = html_str + '</table>'
show_modal('Property: ' + property_name, html_str, '')
def show_modal(title, content, width):
modal.remove_class('show')
html_str = """
<script>
// Fix z-index issue:
var stackingContextRoot = document.querySelector(".tp-widget").closest("div.cell");
if(stackingContextRoot) {{
stackingContextRoot.classList.add("stacking-context");
}}
var closeButton = document.getElementsByClassName("close-wdgt-modal")[0];
closeButton.addEventListener("click", function(ev) {{
document.querySelectorAll(".output_wrapper").forEach(function(div) {{
div.classList.remove("show");
}});
}});
</script>
<div class="wdgt-modal-background"></div>
<div class="wdgt-modal" style="width: {width}">
<div class="wdgt-modal-header">
<h3>{title}</h3>
<span class="close-wdgt-modal">
<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAdVBMVEUAAABNTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU0N3NIOAAAAJnRSTlMAAQIDBAUGBwgRFRYZGiEjQ3l7hYaqtLm8vsDFx87a4uvv8fP1+bbY9ZEAAAB8SURBVBhXXY5LFoJAAMOCIP4VBRXEv5j7H9HFDOizu2TRFljedgCQHeocWHVaAWStXnKyl2oVWI+kd1XLvFV1D7Ng3qrWKYMZ+MdEhk3gbhw59KvlH0eTnf2mgiRwvQ7NW6aqNmncukKhnvo/zzlQ2PR/HgsAJkncH6XwAcr0FUY5BVeFAAAAAElFTkSuQmCC" width="16" height="16" alt="">
</span>
</div>
<div class="wdgt-modal-content">{content}</div></div>
""".format(title = title, content = content, width = width)
modal.outputs = []
modal.append_display_data(HTML(html_str))
modal.add_class('show')
class TranspilationSequence:
def __init__(self) -> None:
self.steps = []
self._collected_logs = {}
self._prop_labels_map = {}
def add_step(self, step) -> None:
if step.name in self._collected_logs:
step.logs = self._collected_logs[step.name]
self._collected_logs.pop(step.name, None)
######
if len(transpilation_sequence.steps) == 0:
prev_stats = CircuitStats()
else:
prev_stats = self.steps[-1].circuit_stats
if prev_stats.ops_1q != step.circuit_stats.ops_1q:
stats_labels[1].value = str(step.circuit_stats.ops_1q)
stats_labels[1].add_class('highlight')
else:
stats_labels[1].remove_class('highlight')
if prev_stats.ops_2q != step.circuit_stats.ops_2q:
stats_labels[3].value = str(step.circuit_stats.ops_2q)
stats_labels[3].add_class('highlight')
else:
stats_labels[3].remove_class('highlight')
if prev_stats.depth != step.circuit_stats.depth:
stats_labels[5].value = str(step.circuit_stats.depth)
stats_labels[5].add_class('highlight')
else:
stats_labels[5].remove_class('highlight')
if prev_stats.size != step.circuit_stats.size:
stats_labels[7].value = str(step.circuit_stats.size)
stats_labels[7].add_class('highlight')
else:
stats_labels[7].remove_class('highlight')
if prev_stats.width != step.circuit_stats.width:
stats_labels[9].value = str(step.circuit_stats.width)
stats_labels[9].add_class('highlight')
else:
stats_labels[9].remove_class('highlight')
######
for prop_name in step.property_set:
property = step.property_set[prop_name]
if property.name in self._prop_labels_map:
index = self._prop_labels_map[property.name]
else:
####
u = widgets.Label(value = property.name)
if type(property.value) == list:
prop_label = widgets.Label('(list)', layout = { 'width': '80%' })
prop_button = ButtonWithValue(value = str(len(self.steps)) + ',' + property.name, description = '...', layout = { 'width': '20%' })
prop_button.on_click(on_property)
v = widgets.HBox([prop_label, prop_button], layout = { 'width': '100%' })
else:
v = widgets.Label(value = str(property.value))
index = len(properties_panel.children)
properties_panel.children = properties_panel.children + (u, v)
####
self._prop_labels_map[property.name] = index
u = widgets.Label(value = property.name)
if type(property.value) != list:
properties_panel.children[index + 1].value = str(property.value)
######
a = widgets.Label(step.type.value)
a.add_class(step.type.name.lower())
b = widgets.Label(step.name)
from math import log10
if step.duration > 0:
duration_font_size = 10
duration_font_size = 10 + round(log10(step.duration))
t = widgets.Label(str(round(step.duration, 1)) + ' ms')
t.add_class('fs' + str(duration_font_size))
else:
t = widgets.Label('')
if type(step.logs) == list and len(step.logs) > 0:
c = ButtonWithValue(value = str(len(self.steps)), tooltip = str(len(step.logs)) + ' logs entries', icon = 'align-justify', layout = { 'width': '32px' })
c.on_click(on_logs)
else:
c = widgets.Label('', layout = { 'width': '32px' })
# Due to a bug in DAGCircuit.__eq__, we can not use ``step.dag != None``
from qiskit.dagcircuit import DAGCircuit
if isinstance(step.dag, DAGCircuit):
d = ButtonWithValue(value = str(len(self.steps)), icon = 'sliders', layout = { 'width': '32px' })
d.on_click(on_circ)
else:
d = widgets.Label('', layout = { 'width': '32px' })
e = ButtonWithValue(value = str(len(self.steps)), icon = 'info-circle', layout = { 'width': '32px' })
e.on_click(on_info)
item = widgets.GridBox([a, b, t, c, d, e], layout = { 'width': '100%', 'grid_template_columns': '20px auto 70px 35px 35px 35px', 'min_height': '35px' })
item.add_class('transpilation-step')
timeline_panel.children = timeline_panel.children + (item, )
######
self.steps.append(step)
def add_log_entry(self, pass_name, log_entry) -> None:
if not pass_name in self._collected_logs:
self._collected_logs[pass_name] = []
self._collected_logs[pass_name].append(log_entry)
transpilation_sequence = TranspilationSequence()
class TranspilerLoggingHandler(logging.Handler):
def __init__(self, *args, **kwargs):
self.loggers_map = kwargs['loggers_map']
kwargs.pop('loggers_map', None)
super(TranspilerLoggingHandler, self).__init__(*args, **kwargs)
def emit(self, record):
log_entry = LogEntry(record.levelname, record.msg, record.args)
transpilation_sequence.add_log_entry(self.loggers_map[record.name], log_entry)
from qiskit.transpiler.basepasses import AnalysisPass, TransformationPass
all_loggers = logging.Logger.manager.loggerDict
passes_loggers = {key:value for (key, value) in all_loggers.items() if key.startswith('qiskit.transpiler.passes.')}
loggers_map = {}
for _pass in AnalysisPass.__subclasses__():
if _pass.__module__ in passes_loggers.keys():
loggers_map[_pass.__module__] = _pass.__name__
for _pass in TransformationPass.__subclasses__():
if _pass.__module__ in passes_loggers.keys():
loggers_map[_pass.__module__] = _pass.__name__
handler = TranspilerLoggingHandler(loggers_map = loggers_map)
logger = logging.getLogger('qiskit.transpiler.passes')
logger.setLevel(logging.DEBUG)
logger.addHandler(handler)
_properties = {}
def transpiler_callback(**kwargs):
pass_ = kwargs['pass_']
pass_name = pass_.name()
pass_type = ''
if pass_.is_analysis_pass:
pass_type = PassType.ANALYSIS
elif pass_.is_transformation_pass:
pass_type = PassType.TRANSFORMATION
transpilation_step = TranspilationStep(pass_name, pass_type)
transpilation_step.docs = pass_.__doc__
transpilation_step.run_docs = getattr(pass_, 'run').__doc__
duration_value = round(1000 * kwargs['time'], 2)
transpilation_step.duration = duration_value
# Properties
_props_updated = False
property_set = kwargs['property_set']
for key in property_set:
if key not in _properties.keys():
_props_updated = True
_properties[key] = property_set[key]
if _props_updated:
from collections import defaultdict
for property_name in property_set:
#if property_name == 'commutation_set':
# print(property_set[property_name])
property_type = type(property_set[property_name])
property_value = None
if property_type in (int, float, bool, str):
property_value = property_set[property_name]
elif property_type == list:
property_value = []
for value in property_set[property_name]:
property_value.append(value)
elif property_type == defaultdict:
#print('defaultdict')
property_value = []
for key, value in property_set[property_name].items():
#print(key, value)
#print('------------------------')
property_value.append(str(key) + ': ' + str(value))
else:
property_value = '(' + property_type.__name__ + ')'
transpilation_step.property_set[property_name] = Property(property_name, property_type, property_value)
# circuit stats:
dag = kwargs['dag']
transpilation_step.circuit_stats.width = dag.width()
transpilation_step.circuit_stats.size = dag.size()
transpilation_step.circuit_stats.depth = dag.depth()
nodes = dag.op_nodes(include_directives = False)
circ_ops_1q = 0
circ_ops_2q = 0
for node in nodes:
if len(node.qargs) > 1:
circ_ops_2q += 1
else:
circ_ops_1q += 1
transpilation_step.circuit_stats.ops_1q = circ_ops_1q
transpilation_step.circuit_stats.ops_2q = circ_ops_2q
# ???
if transpilation_step.type == PassType.TRANSFORMATION and transpilation_step.circuit_stats.depth < 200:
# if len(transpilation_sequence.steps) == 0 or transpilation_sequence.steps[-1].circuit_stats != transpilation_step.circuit_stats:
transpilation_step.dag = dag
transpilation_sequence.add_step(transpilation_step)
%%html
<style>
.tp-widget { border:1px solid #aaa; }
.p-TabPanel-tabContents { padding: 10px !important; }
.p-Collapse-header { padding: 1px 5px; background: #eee; }
.p-Collapse-open > .p-Collapse-header { background: #ddd; }
.p-Collapse-contents { padding-top: 0; padding-left: 0; padding-bottom: 0;
padding-right: 0; height: 220px; background: #f5f5f5; }
.p-Collapse-contents button {
width: 20%;
background: #fff;
text-align: center;
padding: 0;
font-weight: bold; }
.widget-gridbox { background: #f5f5f5; }
.widget-checkbox { padding-left: 40px; }
div.output_scroll { box-shadow: none }
.p-Accordion .widget-gridbox .widget-label { background-color: #fff; padding: 0 3px;
font-family: 'Roboto Mono', monospace; font-size: 14px; }
.highlight { background-color: #ffc !important; font-weight: bold; }
.transpilation-step { background: #fff; border-bottom: 1px solid #ccc; }
.transpilation-step button { background: #fff; }
.transpilation-step .transformation { color: red; }
.transpilation-step .analysis { color: green; }
.transpilation-step div.fs10 { font-size: 10px; }
.transpilation-step div.fs11 { font-size: 11px; }
.transpilation-step div.fs12 { font-size: 12px; }
.transpilation-step div.fs13 { font-size: 13px; }
.transpilation-step div.fs14 { font-size: 14px; }
.transpilation-step div.fs15 { font-size: 15px; }
.transpilation-step > :nth-child(1) { text-align: center; font-weight: bold; font-size: 14px; }
.transpilation-step > :nth-child(2) { font-family: 'Roboto Mono', monospace; font-size: 15px; }
.transpilation-step > :nth-child(3) { font-family: 'Roboto Mono', monospace; font-size: 10px; color: #900;}
.transpilation-step > :nth-child(4) { color: #ff9d85; }
.transpilation-step > :nth-child(5) { color: #b587f7; }
.transpilation-step > :nth-child(6) { color: #6ea2c9; }
.logs-wpr { display: grid; grid-template-columns: 70px 60px auto; }
.logs-wpr pre.date { font-size: 10px; }
.logs-wpr pre.level { font-size: 10px; text-align: right; padding-right: 5px; }
.logs-wpr pre.log-entry { font-size: 12px; }
.logs-wpr pre.DEBUG { color: #000000; }
.logs-wpr pre.INFO { color: #1c84a2; }
.logs-wpr pre.WARNING { color: #ed7723; }
.logs-wpr pre.ERROR { color: #d64e4a; }
.logs-wpr pre.CRITICAL { color: white; background: #d64e4a; }
div.output_area pre.help { font-family: Helvetica,Arial,sans-serif; font-size: 13px;
border: 1px solid #ccc; padding: 10px;}
div.help-header {
font-family: 'Roboto Mono', monospace;
font-size: 12px;
border: 1px solid #ccc;
border-bottom: none;
margin-top: 4px;
padding: 5px 10px;
font-weight: bold;
background: #f5f5f5;
}
.stacking-context { position: relative; z-index: 99997; }
.wdgt-modal-background {
width: 100%;
height: 100%;
background-color: rgba(0,0,0,0.5);
position: fixed;
top: 0;
left: 0;
display: none;
z-index: 99998;
}
.wdgt-modal {
position: fixed;
top: 0;
left: 0;
right: 0;
bottom: 0;
margin: auto;
display: none;
width: 700px;
height: 300px;
background-color: #fff;
box-sizing: border-box;
border: 1px solid #eee;
border-radius: 5px;
overflow:hidden;
z-index: 99999;
}
.wdgt-modal-header {
background-color: #ccc;
border-bottom: 1px solid #dddddd;
box-sizing: border-box;
height: 50px;
padding: 0;
}
.wdgt-modal-header h3 {
margin: 0 !important;
box-sizing: border-box;
padding-left: 15px;
line-height: 50px;
color: #4d4d4d;
font-size: 16px;
display: inline-block;
}
.wdgt-modal-header span.close-wdgt-modal {
box-sizing: border-box;
border-left: 1px solid #dddddd;
float: right;
line-height: 50px;
margin-top: 18px;
padding: 0 15px 0 15px;
cursor: pointer;
}
.wdgt-modal-header span.close-wdgt-modal:hover img {
opacity: 0.6;
}
.wdgt-modal-content { overflow-y: auto; height: 250px; margin: 0; padding: 10px; }
.wdgt-modal-content pre { background: #fff; text-align: left; }
.show .wdgt-modal, .show .wdgt-modal-background { display: block; }
div.output_area .wdgt-modal-content img { max-width: none; /*height: 100%;*/ }
</style>
from qiskit.circuit.random import random_circuit
from qiskit.test.mock import FakeAlmaden
backend = FakeAlmaden()
transpilation_sequence = TranspilationSequence()
circ = random_circuit(5, 20, measure = True)
tp_widget
start_time = time()
circ_tr = transpile(circ, backend, optimization_level = 3, callback = transpiler_callback)
print(time() - start_time)
|
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/feedback
|
Qiskit
|
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
from sklearn.svm import SVC, LinearSVC
from sklearn.datasets import make_blobs
# blue
color_0 = '#1f77b4'
color_0_light = '#8fbbd9'
# orange
color_1 = '#ff7f0e'
color_1_light = '#ffbf86'
cmap = LinearSegmentedColormap.from_list('blue_orange', [color_0_light, '#FFFFFF', color_1_light], N=100)
X, y = make_blobs(n_samples=50, n_features=2, centers=np.array([[0,0], [4,4]]), random_state=9)
X[:, 0] = 2* X[:, 0]
svc = SVC(kernel='linear')
svc.fit(X, y)
fig, ax = plt.subplots(figsize=(12, 8))
s = 100
# decision boundary
x = np.linspace(-2, 10, 50)
ax.plot(x, - 1/svc.coef_[0][1] * (svc.coef_[0][0]*x + svc.intercept_), color='k')
# margin
b_0 = np.dot(svc.support_vectors_[0], svc.coef_[0])
ax.plot(x, - 1/svc.coef_[0][1] * (svc.coef_[0][0]*x - b_0), color='k', linestyle=':', zorder=0)
b_1 = np.dot(svc.support_vectors_[1], svc.coef_[0])
ax.plot(x, - 1/svc.coef_[0][1] * (svc.coef_[0][0]*x - b_1), color='k', linestyle=':', zorder=0)
# data
ax.scatter(X[:,0][y==0], X[:,1][y==0], color=color_0, s=s)
ax.scatter(X[:,0][y==1], X[:,1][y==1], color=color_1, s=s)
# highlight support vectors
ax.scatter(X[:,0][svc.support_][y[svc.support_]==0], X[:,1][svc.support_][y[svc.support_]==0], color=color_0, edgecolors='k', s=s, linewidth=3)
ax.scatter(X[:,0][svc.support_][y[svc.support_]==1], X[:,1][svc.support_][y[svc.support_]==1], color=color_1, edgecolors='k', s=s, linewidth=3)
# cosmetics
ax.set(ylim=(-2, 6), xlim=(-2, 10))
ax.text(7.1, -0.1, r'$\frac{2}{||w||}$', fontdict={'size': 20}, color='g')
x_margin = np.linspace(7.75, 8.57, 2)
ax.plot(x_margin, 1/svc.coef_[0][0] * (svc.coef_[0][1]*x_margin - 7) , color='g', linestyle='--', marker='o')
ax.set_aspect(1)
import sys
import os
from sklearn.preprocessing import MinMaxScaler
from qiskit import BasicAer
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.circuit.library import ZFeatureMap, ZZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
# import the implementation of Pegasos
sys.path.insert(1, os.path.join(sys.path[0], 'C:/Users/4rnet/git/qiskit-machine-learning/qiskit_machine_learning/algorithms/classifiers/'))
from pegasos_qsvc import PegasosQSVC
def make_meshgrid(X, h=.02):
"""
:param X: ndarray of shape (x_samples, 2)
:param h: float, stepsize for meshgrid
:return: ndarray
"""
assert X.shape[1] == 2
x_min, x_max = X[:,0].min() - 0.1*X[:,0].max(), X[:,0].max() + 0.1*X[:,0].max()
y_min, y_max = X[:,1].min() - 0.1*X[:,1].max(), X[:,1].max() + 0.1*X[:,1].max()
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
return xx, yy
# example dataset
sample, label = make_blobs(
n_samples=20, n_features=2, centers=2, random_state=3, shuffle=True
)
# preprocessing to ensure compatibility with the rotation encoding
sample = MinMaxScaler(feature_range=(0, np.pi)).fit_transform(sample)
# split into train and test set
sample_train = sample[:15]
label_train = label[:15]
sample_test = sample[15:]
label_test = label[15:]
# number of qubits is equal to the number of features
q = 2
# number of steps performed during the training procedure
tau = 100
# regularization parameter
C = 1000
feature_map = ZFeatureMap(feature_dimension=q, reps=1)
statevector_simulator = QuantumInstance(
BasicAer.get_backend("statevector_simulator"),
shots=1,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
qkernel = QuantumKernel(
feature_map=feature_map, quantum_instance=statevector_simulator
)
pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=C, num_steps=tau)
# training
pegasos_qsvc.fit(sample_train, label_train)
# testing
score = pegasos_qsvc.score(sample_test, label_test)
print(f'test score = {score}')
# plot
fig, ax = plt.subplots(figsize=(12,12))
xx, yy = make_meshgrid(sample_train[:, :2], h=0.1)
# prediction
Z = pegasos_qsvc.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
ax.pcolormesh(xx, yy, Z, cmap=cmap, shading='auto')
# data
ax.scatter(sample_train[:,0][label_train==0], sample_train[:,1][label_train==0], color=color_0)
ax.scatter(sample_train[:,0][label_train==1], sample_train[:,1][label_train==1], color=color_1)
pegasos_qsvc = PegasosQSVC(C=C, num_steps=tau, precomputed=True)
# training
kernel_matrix_train = qkernel.evaluate(sample_train, sample_train)
pegasos_qsvc.fit(kernel_matrix_train, label_train)
# testing
kernel_matrix_test = qkernel.evaluate(sample_test, sample_train)
score = pegasos_qsvc.score(kernel_matrix_test, label_test)
print(f'test score = {score}')
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit.opflow import I, X, Y, Z
h2_op = (
-1.052373245772859 * (I ^ I)
+ 0.39793742484318045 * (I ^ Z)
- 0.39793742484318045 * (Z ^ I)
- 0.01128010425623538 * (Z ^ Z)
+ 0.18093119978423156 * (X ^ X)
)
list_aux_ops = [
2.0 * (I ^ I),
0.5 * (
(I ^ I) + (Z ^ Z) + (Y ^ Y) - (X ^ X)
),
]
dict_aux_ops = {
"AuxOp1": 2.0 * (I ^ I),
"AuxOp2": 0.5 * (
(I ^ I) + (Z ^ Z) + (Y ^ Y) - (X ^ X)
),
}
from qiskit.algorithms import NumPyMinimumEigensolver
solver = NumPyMinimumEigensolver()
list_result = solver.compute_minimum_eigenvalue(h2_op, aux_operators=list_aux_ops)
print(list_result)
dict_result = solver.compute_minimum_eigenvalue(h2_op, aux_operators=dict_aux_ops)
print(dict_result)
from qiskit_nature.drivers import Molecule
from qiskit_nature.drivers.second_quantization import (
ElectronicStructureMoleculeDriver,
ElectronicStructureDriverType,
)
molecule = Molecule(geometry=[("H", (0.0, 0.0, 0.0)), ("H", (0.0, 0.0, 0.735))])
driver = ElectronicStructureMoleculeDriver(molecule, "sto3g", driver_type=ElectronicStructureDriverType.PYSCF)
from qiskit_nature.problems.second_quantization import ElectronicStructureProblem
problem = ElectronicStructureProblem(driver)
problem.second_q_ops()
from qiskit_nature import settings
settings.dict_aux_operators = True
problem.second_q_ops()
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.mappers.second_quantization import JordanWignerMapper
converter = QubitConverter(JordanWignerMapper())
from qiskit_nature.algorithms.ground_state_solvers import GroundStateEigensolver
from qiskit_nature.algorithms.ground_state_solvers.minimum_eigensolver_factories import NumPyMinimumEigensolverFactory
solver = GroundStateEigensolver(converter, NumPyMinimumEigensolverFactory(use_default_filter_criterion=True))
result = solver.solve(problem)
print(result)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit import transpile
from qiskit.circuit import QuantumRegister, QuantumCircuit, Parameter
from qiskit.quantum_info.synthesis.xx_decompose import XXDecomposer
from qiskit.quantum_info import random_unitary
import numpy as np
u = random_unitary(4)
decomposer = XXDecomposer(euler_basis='U')
output_circuit = decomposer(u, basis_fidelity=0.99, approximate=True)
output_circuit.draw('mpl', style='bw')
# emit XX everywhere
xx_circuit = QuantumCircuit(2)
theta = Parameter('theta')
xx_circuit.rxx(theta, 0, 1)
# except at theta=pi/2, emit CX
cx_circuit = QuantumCircuit(2)
cx_circuit.h(0)
cx_circuit.cx(0, 1)
cx_circuit.h(1)
cx_circuit.s(0)
cx_circuit.s(1)
cx_circuit.h(0)
cx_circuit.h(1)
cx_circuit.global_phase += np.pi / 4
embodiments = {t: xx_circuit.bind_parameters({theta: t}) for t in [np.pi/4, np.pi/6]}
embodiments.update({np.pi/2: cx_circuit})
decomposer = XXDecomposer(euler_basis='U3', embodiments=embodiments)
output_circuit = decomposer(u, basis_fidelity=.99)
output_circuit.draw('mpl')
from qiskit import transpile, QuantumRegister, QuantumCircuit
from qiskit.quantum_info import random_unitary
import numpy as np
# generate a random unitary
u = random_unitary(4)
q = QuantumRegister(2)
circuit = QuantumCircuit(q)
circuit.append(u, q)
output_circuit, = transpile([circuit], basis_gates=['rzx', 'rz', 'sx'], approximation_degree=0.99)
display(circuit.draw('mpl'))
display(output_circuit.draw('mpl'))
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit.transpiler import AnalysisPass
class IJustShout(AnalysisPass):
"""Pass that just prints a message."""
def __init__(self, important_message):
super().__init__()
self.important_message = important_message
def run(self, dag):
print(self.important_message)
return dag
from qiskit.transpiler import PassManager
step1_pm = PassManager(IJustShout("Calling step 1!"))
step2_pm = PassManager(IJustShout("Calling step 2!"))
from qiskit.providers.aer import AerSimulator
from qiskit.utils import QuantumInstance
sim = AerSimulator()
quantum_instance = QuantumInstance(sim, pass_manager=step1_pm, bound_pass_manager=step2_pm)
from qiskit.circuit import QuantumCircuit, Parameter
x = Parameter("x")
circuit = QuantumCircuit(2)
circuit.ry(x, 0)
circuit.cx(0, 1)
circuit.draw("mpl", style="iqx")
from qiskit.opflow import CircuitSampler, AerPauliExpectation, StateFn, H
expectation = StateFn(H ^ H, is_measurement=True) @ StateFn(circuit)
expectation = AerPauliExpectation().convert(expectation)
sampler = CircuitSampler(quantum_instance)
sampler.convert(expectation, {x: 1}).eval()
sampler.convert(expectation, {x: 0.6}).eval()
sampler.convert(expectation, {x: 0.2}).eval()
from qiskit.test.mock import FakeBelem
from qiskit.transpiler import PassManagerConfig
from qiskit.transpiler.preset_passmanagers import level_1_pass_manager
backend = FakeBelem()
unbound_pm = level_1_pass_manager(PassManagerConfig.from_backend(FakeBelem()))
unbound_pm += PassManager(IJustShout("Level 1 pass manager"))
from qiskit.circuit.library.standard_gates.equivalence_library import StandardEquivalenceLibrary as std_eqlib
from qiskit.transpiler.passes import (
Collect2qBlocks, ConsolidateBlocks, Optimize1qGatesDecomposition,
RZXCalibrationBuilderNoEcho, UnrollCustomDefinitions, BasisTranslator
)
from qiskit.transpiler.passes.optimization.echo_rzx_weyl_decomposition import EchoRZXWeylDecomposition
# Build the pass manager for the parameterized circuit
rzx_basis = ['rzx', 'rz', 'x', 'sx']
# Build a pass manager for the CX decomposition (works only on bound circuits)
bound_pm = PassManager([
IJustShout("Pulse-efficient pass manager"),
# Consolidate consecutive two-qubit operations.
Collect2qBlocks(),
ConsolidateBlocks(basis_gates=['rz', 'sx', 'x', 'rxx']),
# Rewrite circuit in terms of Weyl-decomposed echoed RZX gates.
EchoRZXWeylDecomposition(backend.defaults().instruction_schedule_map),
# Attach scaled CR pulse schedules to the RZX gates.
RZXCalibrationBuilderNoEcho(backend),
# Simplify single-qubit gates.
UnrollCustomDefinitions(std_eqlib, rzx_basis),
BasisTranslator(std_eqlib, rzx_basis),
Optimize1qGatesDecomposition(rzx_basis),
])
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import L_BFGS_B
from qiskit.opflow import Z
quantum_instance = QuantumInstance(
backend, pass_manager=unbound_pm, bound_pass_manager=bound_pm
)
vqe = VQE(optimizer=L_BFGS_B(), quantum_instance=quantum_instance)
result = vqe.compute_minimum_eigenvalue(Z ^ Z)
print(result)
|
https://github.com/Qiskit/feedback
|
Qiskit
|
# a T1 circuit
from qiskit.circuit import QuantumCircuit
qc = QuantumCircuit(1, 1)
qc.x(0)
qc.delay(10, 0, unit="us")
qc.measure(0, 0)
qc.draw(output="mpl")
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device_backend = provider.get_backend('ibmq_armonk')
device_backend
from qiskit import transpile
from qiskit.providers.aer import AerSimulator
from qiskit.providers.aer.noise import NoiseModel
from qiskit_experiments.library import T1 as T1Experiment
print(f"(Backend: {device_backend.name()}, Qubit: 0)")
print(f"Reported T1={device_backend.properties().t1(0) * 1e+3:.3f}[ms]")
t1exp = T1Experiment(0, delays=list(range(1, 400, 10)), unit="us")
t1exp.circuits()[0].draw(output="mpl") # the first T1 circuit
t1exp.circuits()[1].draw(output="mpl") # the second T1 circuit
t1exp.circuits()[-1].draw(output="mpl") # the last T1 circuit
old_noise_model = NoiseModel.from_backend(device_backend)
old_noise_model._custom_noise_passes = []
old_sim = AerSimulator.from_backend(device_backend, noise_model=old_noise_model)
t1exp.set_transpile_options(scheduling_method="alap")
exp_data = t1exp.run(old_sim, seed_simulator=123).block_for_results()
result = exp_data.analysis_results()[0]
print(f"Ref: Simulated T1 with old noise model={result.value}")
display(exp_data.figure(0))
new_sim = AerSimulator.from_backend(device_backend) # call NoiseModel.from_backend() behind the scene
t1exp.set_transpile_options(scheduling_method="alap")
exp_data = t1exp.run(new_sim, seed_simulator=123).block_for_results()
result = exp_data.analysis_results()[0]
print(f"Simulated T1={result.value}")
print(f"Ref: Reported T1={device_backend.properties().t1(0) * 1e+3:.3f}[ms]")
display(exp_data.figure(0))
# original circuit
circ = t1exp.circuits()[1]
circ.draw(output="mpl")
# transpiled circuit (scheduled circuit)
transpiled_circ = transpile(circ, device_backend, scheduling_method="alap")
transpiled_circ.draw(output="mpl")
# noisy circuit
noise_model = NoiseModel.from_backend(device_backend)
noisy_circ = noise_model._pass_manager().run(transpiled_circ) # within assembler
noisy_circ.draw(output="mpl")
noise_model = NoiseModel.from_backend(device_backend)
nmp = noise_model._pass_manager()
print(nmp.passes())
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import numpy as np
from qiskit.providers.basicaer import BasicAer
from qiskit.utils import QuantumInstance
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import L_BFGS_B
from qiskit.opflow.gradients import Gradient
from qiskit_nature.algorithms import AdaptVQE, VQEUCCFactory
from qiskit_nature.circuit.library import HartreeFock, UCC
from qiskit_nature.drivers import UnitsType
from qiskit_nature.drivers.second_quantization import PySCFDriver, HDF5Driver
from qiskit_nature.mappers.second_quantization import ParityMapper
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.problems.second_quantization import ElectronicStructureProblem
from qiskit_nature.properties.second_quantization.electronic import (
ElectronicEnergy,
ParticleNumber,
)
from qiskit_nature.transformers.second_quantization.electronic import ActiveSpaceTransformer
from qiskit_nature.properties.second_quantization.electronic.bases import ElectronicBasis
from qiskit_nature.properties.second_quantization.electronic.integrals import (
OneBodyElectronicIntegrals,
TwoBodyElectronicIntegrals,)
#OLD CODE
class AdaptVQE(GroundStateEigensolver):
"""A ground state calculation employing the AdaptVQE algorithm."""
def __init__(
self,
qubit_converter: QubitConverter,
solver: MinimumEigensolverFactory,
threshold: float = 1e-5,
delta: float = 1,
max_iterations: Optional[int] = None,
) -> None:
#NEW CODE
class AdaptVQE(GroundStateEigensolver):
"""A ground state calculation employing the AdaptVQE algorithm."""
def __init__(
self,
qubit_converter: QubitConverter,
solver: MinimumEigensolverFactory,
threshold: float = 1e-5,
delta: float = 1, #this is going to be deprecated
max_iterations: Optional[int] = None,
gradient: Optional[Gradient] = None,
) -> None:
def _compute_gradients(
self,
theta: List[float],
vqe: VQE,
) -> List[Tuple[float, PauliSumOp]]:
res = []
for exc in self._excitation_pool:
# add next excitation to ansatz
self._ansatz.operators = self._excitation_list + [exc]
# set the current ansatz
vqe.ansatz = self._ansatz
# evaluate energies
parameter_sets = theta + [-self._delta] + theta + [self._delta]
energy_evaluation = vqe.get_energy_evaluation(self._main_operator)
energy_results = energy_evaluation(np.asarray(parameter_sets))
# compute gradient
gradient = (energy_results[0] - energy_results[1]) / (2 * self._delta)
res.append((np.abs(gradient), exc))
return res
def _compute_gradients(
self,
theta: List[float],
vqe: VQE,
) -> List[Tuple[float, PauliSumOp]]:
res=[]
for exc in self._excitation_pool:
self._ansatz.operators = self._excitation_list + [exc]
if self.gradient.grad_method.analytic:
vqe.ansatz = self._ansatz
else:
vqe.ansatz = self._ansatz.decompose()
param_sets = vqe._ansatz_params
op = vqe.construct_expectation(theta, self._main_operator)
state_grad = self.gradient.convert(operator=op, params=param_sets)
# Assign the parameters and evaluate the gradient
value_dict = {param_sets[-1]:0.0}
state_grad_result = state_grad.assign_parameters(value_dict).eval()
logger.info("State gradient computed with parameter shift", state_grad_result)
res.append((np.abs(state_grad_result[-1]), exc))
return res
driver = PySCFDriver(
atom="H .0 .0 .0; H .0 .0 0.735", unit=UnitsType.ANGSTROM, basis="sto3g"
)
problem = ElectronicStructureProblem(driver)
expected = -1.85727503
qubit_converter = QubitConverter(ParityMapper())
solver=VQEUCCFactory(QuantumInstance(BasicAer.get_backend("statevector_simulator")))
%%time
#logging.basicConfig(level = logging.DEBUG)
grad=Gradient(grad_method="fin_diff")
calc= AdaptVQE(qubit_converter,solver,gradient=grad)
res = calc.solve(problem)
print("Energy calculated: ",res.electronic_energies[0])
print("Expected energy: ", expected)
%%time
grad=Gradient(grad_method="param_shift")
calc= AdaptVQE(qubit_converter,solver,gradient=grad)
res = calc.solve(problem)
print("Energy calculated: ",res.electronic_energies[0])
print("Expected energy: ", expected)
qubit_converter = QubitConverter(ParityMapper())
solver=VQEUCCFactory(QuantumInstance(BasicAer.get_backend("statevector_simulator")))
inter_dist = 1.6
driver1 = PySCFDriver(
atom="Li .0 .0 .0; H .0 .0 " + str(inter_dist),
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis="sto3g",
)
transformer = ActiveSpaceTransformer(
num_electrons=2,
num_molecular_orbitals=3,
)
problem1 = ElectronicStructureProblem(driver1, [transformer])
solver = VQEUCCFactory(QuantumInstance(BasicAer.get_backend("statevector_simulator")))
%%time
grad=Gradient(grad_method="fin_diff")
calc = AdaptVQE(qubit_converter, solver,gradient=grad)
res = calc.solve(problem1)
print("Energy calculated: ",res.electronic_energies[0])
%%time
grad=Gradient(grad_method="param_shift")
calc = AdaptVQE(qubit_converter, solver,gradient=grad)
res = calc.solve(problem1)
print("Energy calculated: ",res.electronic_energies[0])
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit_nature.hdf5 import load_from_hdf5, save_to_hdf5
from qiskit_nature.drivers.second_quantization import PySCFDriver, GaussianForcesDriver
from qiskit_nature.properties.second_quantization.vibrational.bases import HarmonicBasis
electronic_driver = PySCFDriver(
atom="H 0.0 0.0 0.0; Li 0.0 0.0 1.3",
basis="sto-3g",
)
electronic_structure_driver_result = electronic_driver.run()
print(electronic_structure_driver_result)
save_to_hdf5(electronic_structure_driver_result, "tmp_electronic_structure_driver_result.hdf5", replace=True)
new_electronic_structure_driver_result = load_from_hdf5("tmp_electronic_structure_driver_result.hdf5")
print(new_electronic_structure_driver_result)
vibrational_driver = GaussianForcesDriver(
logfile="test/drivers/second_quantization/gaussiand/test_driver_gaussian_log_C01.txt"
)
vibrational_structure_driver_result = vibrational_driver.run()
vibrational_structure_driver_result.basis = HarmonicBasis(num_modals_per_mode=2)
print(vibrational_structure_driver_result)
save_to_hdf5(vibrational_structure_driver_result, "tmp_vibrational_structure_driver_result.hdf5", replace=True)
new_vibrational_structure_driver_result = load_from_hdf5("tmp_vibrational_structure_driver_result.hdf5")
print(new_vibrational_structure_driver_result)
from __future__ import annotations
from typing import Protocol
import h5py
class HDF5Storable(Protocol):
"""A Protocol implemented by those classes which support conversion methods for HDF5."""
def to_hdf5(self, parent: h5py.Group) -> None:
"""Stores this instance in an HDF5 group inside of the provided parent group.
...
"""
...
@staticmethod
def from_hdf5(h5py_group: h5py.Group) -> HDF5Storable:
"""Constructs a new instance from the data stored in the provided HDF5 group.
...
"""
...
class Molecule:
VERSION = 1
def to_hdf5(self, parent: h5py.Group) -> None:
group = parent.require_group(self.__class__.__name__)
group.attrs["__class__"] = self.__class__.__name__
group.attrs["__module__"] = self.__class__.__module__
group.attrs["__version__"] = self.VERSION
geometry_group = group.create_group("geometry", track_order=True)
for idx, geom in enumerate(self._geometry):
symbol, coords = geom
geometry_group.create_dataset(str(idx), data=coords)
geometry_group[str(idx)].attrs["symbol"] = symbol
group.attrs["units"] = self.units.value
group.attrs["multiplicity"] = self.multiplicity
group.attrs["charge"] = self.charge
if self._masses:
group.create_dataset("masses", data=self._masses)
@staticmethod
def from_hdf5(h5py_group: h5py.Group) -> Molecule:
geometry = []
for atom in h5py_group["geometry"].values():
geometry.append((atom.attrs["symbol"], list(atom[...])))
units: UnitsType
for unit in UnitsType:
if unit.value == h5py_group.attrs["units"]:
units = unit
break
else:
units = UnitsType.ANGSTROM
multiplicity = h5py_group.attrs["multiplicity"]
charge = h5py_group.attrs["charge"]
masses = None
if "masses" in h5py_group.keys():
masses = list(h5py_group["masses"])
return Molecule(
geometry,
multiplicity=multiplicity,
charge=charge,
units=units,
masses=masses,
)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Qiskit/feedback
|
Qiskit
|
#pylint: disable=import-error, wrong-import-position
# Python imports
import os
import sys
# External imports
from pylab import cm
from sklearn import metrics
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# Qiskit imports
from qiskit import BasicAer
from qiskit.visualization import circuit_drawer
from qiskit.algorithms.optimizers import SPSA
from qiskit_machine_learning.kernels import QuantumKernel
from qiskit_machine_learning.kernels.algorithms import QuantumKernelTrainer
from qiskit_machine_learning.algorithms import QSVC
# Put this repository on the Python path and import qkt pkgs
module_path = os.path.abspath(os.path.join('../..'))
sys.path.append(module_path)
from qkt.feature_maps import CovariantFeatureMap
from qkt.utils import train_test_split, QKTCallback
# Load the dataset and split into train and test sets
DATA_FILEPATH = '../../data/dataset_graph7.csv'
X_train, y_train, X_test, y_test = train_test_split(DATA_FILEPATH)
num_features = np.shape(X_train)[1]
entangler_map = [[0,2],[3,4],[2,5],[1,4],[2,3],[4,6]]
# Note that [[0,1],[2,3],[4,5],[6,7],[8,9],[1,2],[3,4],[5,6],[7,8]]
# is a suitable input for the 10-qubit dataset
fm = CovariantFeatureMap(
feature_dimension=num_features,
entanglement=entangler_map,
single_training_parameter=True
)
circuit_drawer(fm)
print(fm.user_parameters)
# Use the qasm simulator backend
backend = BasicAer.get_backend('statevector_simulator')
# Instantiate quantum kernel
quant_kernel = QuantumKernel(fm,
user_parameters=fm.user_parameters,
quantum_instance=backend)
# Set up the optimizer
cb_qkt = QKTCallback()
spsa_opt = SPSA(maxiter=5,
callback=cb_qkt.callback,
learning_rate=0.1,
perturbation=0.1
)
# Instantiate a quantum kernel trainer.
qkt = QuantumKernelTrainer(
quantum_kernel=quant_kernel,
loss="svc_loss",
optimizer=spsa_opt,
initial_point=[0.1]*len(fm.user_parameters)
)
# Train the kernel using QKT directly
qka_results = qkt.fit(X_train, y_train)
optimized_kernel = qka_results.quantum_kernel
# Use QSVC for classification
qsvc = QSVC(quantum_kernel=optimized_kernel)
# Fit the QSVC
qsvc.fit(X_train, y_train)
# Predict the labels
labels_test = qsvc.predict(X_test)
# Evalaute the test accuracy
accuracy_test = metrics.balanced_accuracy_score(y_true=y_test, y_pred=labels_test)
print(f"accuracy test: {accuracy_test}")
plot_data = cb_qkt.get_callback_data() # callback data
K=optimized_kernel.evaluate(X_train) # kernel matrix evaluated on the training samples
plt.rcParams['font.size'] = 20
fig, ax = plt.subplots(1,2, figsize=(14,5))
ax[0].plot([i+1 for i in range(len(plot_data[0]))],
np.array(plot_data[2]),
c='k',
marker='o'
)
ax[0].set_xlabel('Iterations')
ax[0].set_ylabel('Loss')
ax[1].imshow(K, cmap=cm.get_cmap('bwr', 20))
ax[1].axis('off')
fig.tight_layout()
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import numpy as np
from qiskit_nature.operators.second_quantization import QuadraticHamiltonian
# create Hamiltonian
hermitian_part = np.array(
[
[1.0, 2.0, 0.0, 0.0],
[2.0, 1.0, 2.0, 0.0],
[0.0, 2.0, 1.0, 2.0],
[0.0, 0.0, 2.0, 1.0],
]
)
antisymmetric_part = np.array(
[
[0.0, 3.0, 0.0, 0.0],
[-3.0, 0.0, 3.0, 0.0],
[0.0, -3.0, 0.0, 3.0],
[0.0, 0.0, -3.0, 0.0],
]
)
constant = 4.0
hamiltonian = QuadraticHamiltonian(
hermitian_part=hermitian_part,
antisymmetric_part=antisymmetric_part,
constant=constant,
)
# convert it to a FermionicOp and print it
hamiltonian_ferm = hamiltonian.to_fermionic_op()
hamiltonian_ferm.display_format = "sparse"
hamiltonian_ferm.set_truncation(0)
print(hamiltonian_ferm)
# get the transformation matrix W and orbital energies {epsilon_j}
(
transformation_matrix,
orbital_energies,
transformed_constant,
) = hamiltonian.diagonalizing_bogoliubov_transform()
print("Shape of matrix W:")
print(transformation_matrix.shape)
print()
print("Orbital energies:")
print(orbital_energies)
print()
print("Transformed constant:")
print(transformed_constant)
from qiskit_nature.circuit.library import FermionicGaussianState
occupied_orbitals = (0, 2)
eig = np.sum(orbital_energies[list(occupied_orbitals)]) + transformed_constant
print("Eigenvalue:")
print(eig)
circuit = FermionicGaussianState(
transformation_matrix, occupied_orbitals=occupied_orbitals
)
circuit.draw("mpl")
from qiskit.quantum_info import Statevector
from qiskit_nature.mappers.second_quantization import JordanWignerMapper
# simulate the circuit to get the final state
state = np.array(Statevector(circuit))
# convert the Hamiltonian to a matrix
hamiltonian_jw = JordanWignerMapper().map(hamiltonian_ferm).to_matrix()
# check that the state is an eigenvector with the expected eigenvalue
np.testing.assert_allclose(hamiltonian_jw @ state, eig * state, atol=1e-8)
# create Hamiltonian
hermitian_part = np.array(
[
[1.0, 2.0, 0.0, 0.0],
[2.0, 1.0, 2.0, 0.0],
[0.0, 2.0, 1.0, 2.0],
[0.0, 0.0, 2.0, 1.0],
]
)
constant = 4.0
hamiltonian = QuadraticHamiltonian(
hermitian_part=hermitian_part,
constant=constant,
)
print("Hamiltonian conserves particle number:")
print(hamiltonian.conserves_particle_number())
# get the transformation matrix W and orbital energies {epsilon_j}
(
transformation_matrix,
orbital_energies,
transformed_constant,
) = hamiltonian.diagonalizing_bogoliubov_transform()
print("Shape of matrix W:")
print(transformation_matrix.shape)
print()
print("Orbital energies:")
print(orbital_energies)
print()
print("Transformed constant:")
print(transformed_constant)
from qiskit_nature.circuit.library import SlaterDeterminant
occupied_orbitals = (0, 2)
eig = np.sum(orbital_energies[list(occupied_orbitals)]) + transformed_constant
print("Eigenvalue:")
print(eig)
circuit = SlaterDeterminant(transformation_matrix[list(occupied_orbitals)])
circuit.draw("mpl")
from qiskit.quantum_info import random_hermitian
# construct and display some larger circuits
N = 8
n_particles = 4
hermitian_part = np.array(random_hermitian(N))
hamiltonian = QuadraticHamiltonian(hermitian_part)
transformation_matrix, _, _ = hamiltonian.diagonalizing_bogoliubov_transform()
occupied_orbitals = range(n_particles)
circuit = SlaterDeterminant(transformation_matrix[list(occupied_orbitals)])
circuit.draw("mpl")
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit_ibm_runtime import IBMRuntimeService
# Option 1 - Save default accounts per channel
IBMRuntimeService.save_account(channel="ibm_quantum", token="<IBM Quantum API token>")
IBMRuntimeService.save_account(
channel="ibm_cloud",
token="<IBM Cloud API key>",
instance="<CRN> or <Service Instance Name>",
)
# Option 2 - Save account by name
IBMRuntimeService.save_account(name="backup-account", channel="ibm_quantum", token="<IBM Quantum API token>")
IBMRuntimeService.saved_accounts()
IBMRuntimeService.delete_account(name="backup-account")
# Option 1 - Based on saved default accounts per channel
service = IBMRuntimeService(channel="ibm_quantum")
service = IBMRuntimeService(channel="ibm_cloud")
# Option 2 - Based on saved named account
service = IBMRuntimeService(name="backup-account")
# Option 3 - By passing account credentials
service = IBMRuntimeService(channel="ibm_quantum", token="<IBM Quantum API token>")
service = IBMRuntimeService(channel="ibm_cloud", token="<IBM Cloud API key>", instance="<CRN> or <Service Instance Name>")
# Option 4 - By reading from environment variables
service = IBMRuntimeService() # requires environment configuration via QISKIT_IBM_TOKEN, QISKIT_IBM_URL, QISKIT_IBM_INSTANCE
service.pprint_programs()
service.programs()
program = service.program("sampler")
print(program)
service.backends()
service.backends(operational=True, min_num_qubits=64)
service.least_busy()
from qiskit import QuantumCircuit
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
bell.draw()
# Specify the program inputs here.
program_inputs = {
"circuits": bell,
"circuit_indices": [0],
}
job = service.run(
program_id="sampler",
inputs=program_inputs,
)
# Printing the job ID in case we need to retrieve it later.
print(f"Job ID: {job.job_id}")
# Get the job result - this is blocking and control may not return immediately.
result = job.result()
print(result)
# see which backend the job was executed on
print(job.backend)
backend = service.backend("ibmq_qasm_simulator")
backend
backend.name
backend.num_qubits
backend.max_circuits
backend.basis_gates
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import sys
!git checkout 44bfc66a8aef1baf6794ab43ea9c73e5be34ce8e && {sys.executable} -m pip install -e . > /dev/null
import numpy as np
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit_machine_learning.algorithms.classifiers import VQC
features = np.random.rand(20, 2)
target = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]
target = np.tile(target, 2)
print(f"Features:\n{features.T}")
print(f"Target:", target)
onehot_target = np.zeros((target.size, int(target.max() + 1)))
onehot_target[np.arange(target.size), target.astype(int)] = 1
print(onehot_target.T)
backend = Aer.get_backend("aer_simulator_statevector")
quantum_instance = QuantumInstance(backend)
vqc = VQC(
num_qubits=2,
loss="cross_entropy",
warm_start=True,
quantum_instance=quantum_instance,
)
vqc.fit(features[:10, :], onehot_target[:10])
print("First fit complete.")
vqc.fit(features[10:, :], onehot_target[10:])
print("Second fit complete.")
import sys
!git checkout 5a02c7639db6a86beb9a944b14721935a48932e6 && {sys.executable} -m pip install -e . > /dev/null
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 1)
qc.sx(0)
qc.delay(100, 0)
qc.cx(0, 1)
qc.measure(1, 0)
qc.draw()
from qiskit.test.mock import FakeWashington
FakeWashington().configuration().timing_constraints
from qiskit.transpiler.passmanager import PassManager
from qiskit.transpiler.passes import ALAPSchedule, AlignMeasures
from qiskit.transpiler.instruction_durations import InstructionDurations
durations = InstructionDurations([("sx", (0, ), 160), ("cx", (0, 1), 800), ("measure", (1, ), 1600)])
# this is as of Qiskit v0.19
pm = PassManager([ALAPSchedule(durations)])
pm.run(qc).draw()
# this is as of Qiskit v0.19
pm = PassManager([ALAPSchedule(durations), AlignMeasures(alignment=16)])
pm.run(qc).draw()
FakeWashington().configuration().conditional_latency
FakeWashington().configuration().acquisition_latency
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 1)
qc.x(0)
qc.measure(0, 0)
qc.x(0).c_if(0, 0)
qc.measure(1, 0)
qc.draw()
from qiskit.transpiler.passmanager import PassManager
from qiskit.transpiler.passes import ALAPSchedule
from qiskit.transpiler.instruction_durations import InstructionDurations
from qiskit.visualization import timeline_drawer
durations = InstructionDurations([("x", None, 160), ("measure", None, 1600)])
# this is as of Qiskit v0.19
pm = PassManager([ALAPSchedule(durations)])
qc_scheduled = pm.run(qc)
qc_scheduled.draw()
# this is as of Qiskit v0.19
timeline_drawer(qc_scheduled)
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 1)
qc.x(0)
qc.measure(0, 0)
qc.measure(1, 0)
qc.draw()
# this is as of Qiskit v0.19
pm = PassManager([ALAPSchedule(durations)])
qc_scheduled = pm.run(qc)
qc_scheduled.draw()
# this is as of Qiskit v0.19
timeline_drawer(qc_scheduled)
# this is as of Qiskit v0.19
from qiskit import schedule
from qiskit.test.mock import FakeBelem
try:
sched = schedule(qc, FakeBelem())
except Exception as ex:
print(ex)
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 1)
qc.sx(0)
qc.delay(100, 0)
qc.cx(0, 1)
qc.measure(1, 0)
qc.draw()
from qiskit.transpiler.passmanager import PassManager
from qiskit.transpiler.passes import ALAPSchedule, PadDelay, ConstrainedReschedule
from qiskit.transpiler.instruction_durations import InstructionDurations
durations = InstructionDurations([("sx", (0, ), 160), ("cx", (0, 1), 800), ("measure", (1, ), 1600)])
pm = PassManager([ALAPSchedule(durations)])
pm.run(qc).draw()
for node, t in pm.property_set["node_start_time"].items():
print(f"{t :4d} dt: {node.name} ({node.qargs} {node.cargs})")
pm = PassManager(
[
ALAPSchedule(durations),
ConstrainedReschedule(acquire_alignment=16, pulse_alignment=16),
]
)
pm.run(qc).draw()
for node, t in pm.property_set["node_start_time"].items():
print(f"{t :4d} dt: {node.name} ({node.qargs} {node.cargs})")
pm = PassManager(
[
ALAPSchedule(durations),
ConstrainedReschedule(acquire_alignment=16, pulse_alignment=16),
PadDelay(),
]
)
pm.run(qc).draw()
from qiskit import QuantumCircuit
from qiskit.visualization import timeline_drawer
durations = InstructionDurations([("x", None, 160), ("measure", None, 1600)])
qc = QuantumCircuit(2, 1)
qc.x(0)
qc.measure(0, 0)
qc.x(0).c_if(0, 0)
qc.measure(1, 0)
pm = PassManager(
[
ALAPSchedule(durations),
PadDelay(),
]
)
qc_scheduled = pm.run(qc)
qc_scheduled.draw()
timeline_drawer(qc_scheduled)
pm = PassManager(
[
ALAPSchedule(durations, clbit_write_latency=300, conditional_latency=200),
PadDelay(),
]
)
qc_scheduled = pm.run(qc)
timeline_drawer(qc_scheduled)
pm = PassManager(
[
ALAPSchedule(durations, clbit_write_latency=1600, conditional_latency=0),
PadDelay(),
]
)
qc_scheduled = pm.run(qc)
timeline_drawer(qc_scheduled)
from qiskit.transpiler.passes import DynamicalDecoupling
from qiskit.circuit.library import XGate, YGate
ghz4 = QuantumCircuit(4)
ghz4.h(0)
ghz4.cx(0, 1)
ghz4.cx(1, 2)
ghz4.cx(2, 3)
ghz4.draw()
durations = InstructionDurations([("h", None, 160), ("x", None, 160), ("y", None, 160), ("cx", None, 800)])
dd_sequence = [XGate(), YGate(), XGate(), YGate()]
pm = PassManager(
[
ALAPSchedule(durations, clbit_write_latency=1600, conditional_latency=0),
PadDelay(),
]
)
qc_scheduled = pm.run(ghz4)
timeline_drawer(qc_scheduled)
pm = PassManager(
[
ALAPSchedule(durations, clbit_write_latency=1600, conditional_latency=0),
DynamicalDecoupling(durations, dd_sequence),
]
)
qc_scheduled = pm.run(ghz4)
timeline_drawer(qc_scheduled)
qc_scheduled.draw()
pm = PassManager(
[
ALAPSchedule(durations, clbit_write_latency=1600, conditional_latency=0),
DynamicalDecoupling(durations, dd_sequence, pulse_alignment=16),
]
)
qc_scheduled = pm.run(ghz4)
qc_scheduled.draw()
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import numpy as np
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import GradientDescent
from qiskit.circuit.library import EfficientSU2
from qiskit.opflow import Z, I, Gradient, AerPauliExpectation
from qiskit.providers.aer import AerSimulator
hamiltonian = (Z ^ Z ^ I) + (Z ^ I ^ I)
ansatz = EfficientSU2(3, reps=1, entanglement="linear")
ansatz.decompose().draw("mpl", style="iqx")
gradient = Gradient(method="param_shift")
backend = AerSimulator()
energies = []
def store_energy(*args):
energies.append(args[2])
vqe = VQE(ansatz,
optimizer=GradientDescent(maxiter=300, learning_rate=0.01, callback=store_energy),
gradient=gradient,
expectation=AerPauliExpectation(),
initial_point=np.arange(ansatz.num_parameters),
quantum_instance=backend)
result = vqe.compute_minimum_eigenvalue(hamiltonian)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 6))
plt.plot(energies, color="royalblue", label="VQE")
plt.axhline(y=-2, ls="--", color="crimson", label="target")
plt.xlabel("iteration")
plt.ylabel("energy");
from time import time
from qiskit.opflow import CircuitSampler, StateFn
num_qubits = 5
gradient = Gradient(method="param_shift")
sampler = CircuitSampler(backend)
hamiltonian = Z ^ 5
timings = []
for reps in range(10):
circuit = EfficientSU2(num_qubits, reps=reps, entanglement="pairwise")
value_dict = dict(zip(circuit.parameters, np.arange(circuit.num_parameters)))
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(circuit)
start = time()
_ = sampler.convert(gradient.convert(expectation), params=value_dict).eval()
timings.append(time() - start)
plt.figure(figsize=(10, 6))
plt.plot(10 * (1 + np.arange(10)), timings)
plt.xlabel("number of parameters")
plt.ylabel("time $s$");
from surfer.gradient import ForwardGradient # classical O(d^2) method
from surfer.gradient import ReverseGradient # classical O(d) method!
reverse = ReverseGradient()
hamiltonian = (Z ^ Z ^ I) + (Z ^ I ^ I)
circuit = EfficientSU2(3, reps=1, entanglement="linear")
values = np.random.random(ansatz.num_parameters)
grad = reverse.compute(hamiltonian, circuit, values)
print(grad)
from surfer.gradient import ForwardGradient
reverse_timings = []
forward_timings = []
forward = ForwardGradient()
hamiltonian = Z ^ 5
for reps in range(10):
circuit = EfficientSU2(num_qubits, reps=reps, entanglement="pairwise")
values = np.arange(circuit.num_parameters)
start = time()
_ = reverse.compute(hamiltonian, circuit, values)
reverse_timings.append(time() - start)
circuit = circuit.decompose()
start = time()
_ = forward.compute(hamiltonian, circuit, values)
forward_timings.append(time() - start)
plt.figure(figsize=(10, 6))
plt.plot(10 * (1 + np.arange(10)), timings, label="Qiskit")
plt.plot(10 * (1 + np.arange(10)), reverse_timings, label="Reverse gradients")
plt.plot(10 * (1 + np.arange(10)), forward_timings, label="Forward gradients")
plt.xlabel("number of parameters")
plt.ylabel("time $s$")
plt.legend();
from surfer.qfi import ReverseQFI
reverse_qfi = ReverseQFI()
circuit = EfficientSU2(3, reps=1, entanglement="linear")
values = np.random.random(ansatz.num_parameters)
qfi = reverse_qfi.compute(circuit, values)
from qiskit.opflow import QFI
num_qubits = 5
qfi = QFI()
qfi_timings = []
sampler = CircuitSampler(backend)
for reps in [0, 1, 2, 3, 4, 8]:
circuit = EfficientSU2(num_qubits, reps=reps, entanglement="pairwise")
value_dict = dict(zip(circuit.parameters, np.arange(circuit.num_parameters)))
start = time()
_ = sampler.convert(qfi.convert(StateFn(circuit)), params=value_dict).eval()
qfi_timings.append(time() - start)
num_qubits = 5
reverse_qfi_timings = []
for reps in 2 ** np.arange(6):
circuit = EfficientSU2(num_qubits, reps=reps, entanglement="pairwise")
values = np.arange(circuit.num_parameters)
start = time()
_ = reverse_qfi.compute(circuit, values)
reverse_qfi_timings.append(time() - start)
plt.figure(figsize=(10, 6))
plt.plot(10 * (1 + np.array([0, 1, 2, 3, 4, 8])), qfi_timings, label="Qiskit")
plt.plot(10 * (1 + 2 ** np.arange(6)), reverse_qfi_timings, label="Classically efficient QFI")
plt.xlabel("number of parameters")
plt.ylabel("time $s$")
plt.legend();
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import numpy as np
import math
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.extensions.quantum_initializer import Initialize
from qiskit.circuit.library import StatePreparation
qr = QuantumRegister(2)
qc_init = QuantumCircuit(qr)
# int param
init = Initialize(2)
# string param
# init = Initialize('11')
# statevector param
# init = Initialize([1 / math.sqrt(2), 0, 0, 1 / math.sqrt(2)])
qc_init.append(init, qr)
qc_init.draw()
qc_init.decompose().draw()
qc_init.decompose().decompose().draw()
qc_init2 = QuantumCircuit(2)
qc_init2.initialize(2)
qc_init2.draw()
circ = QuantumCircuit(2)
# int param
# my_state = StatePreparation(2, label="my state")
# string param
# my_state = StatePreparation('11', label="my state")
# statevector param
# my_state = StatePreparation([1 / math.sqrt(2), 0, 0, 1 / math.sqrt(2)], label="my state")
circ.append(my_state, [0,1])
circ.draw()
circ.decompose().draw()
circ.append(my_state.inverse(), [0,1])
circ.draw()
circ.decompose().draw()
qc_control = QuantumCircuit(3)
stateprep = StatePreparation('11')
controlled_stateprep = stateprep.control(1)
qc_control.append(controlled_stateprep, [0,1,2])
qc_control.draw()
qc = QuantumCircuit(2)
# int param
# qc.prepare_state(2, label="my cool state")
# string param
# qc.prepare_state('11', label="my cool state")
# statevector param
qc.prepare_state([1 / math.sqrt(2), 0, 0, 1 / math.sqrt(2)], label="my cool state")
qc.draw()
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit_ibm_experiment import IBMExperimentService
from qiskit_experiments.framework.json import ExperimentDecoder, ExperimentEncoder
from IPython.display import SVG, display
IBMExperimentService.save_account(token="MY_API_TOKEN")
IBMExperimentService.save_account(name="staging", token="MY_STAGING_API_TOKEN", url='https://api-dev.quantum-computing.ibm.com')
service = IBMExperimentService()
service.experiments()
exp_id = 'b4bebb95-66d4-461b-9287-1441443a3336'
service.experiment(exp_id)
service.experiments(experiment_type='readout_test')
service.analysis_results(experiment_id = exp_id)
fig = service.figure(exp_id, 'figure_b4bebb95_2022-03-30T11:40:21.656059_0.svg')
display(SVG(fig))
service = IBMExperimentService(name="staging")
service.experiments()
from qiskit.providers.ibmq import IBMQ, least_busy
provider = IBMQ.enable_account(url='https://api-dev.quantum-computing.ibm.com/v2', token="c0026ac13d5f10513555e5f396f20b60f97eabf85ba8591a3415ebcfb54e4961c8c095938a29ff4b657a725fa48e301d993ef509a7699ceddc891b0d1eddb137")
backend = least_busy(provider.backends(simulator=False, min_num_qubits=5))
exp_id = service.create_experiment(experiment_type="demo_day",
backend_name = backend.name(),
provider=provider,
metadata = {'complex_number': 3+2j},
json_encoder=ExperimentEncoder
)
exp_id
service.experiment(exp_id, json_decoder=ExperimentDecoder)
for i in range(30):
service.create_analysis_result(exp_id,
result_data = {'100': 100-i, '010': 24+i},
result_type = f'result{i}'
)
service.analysis_results(experiment_id = exp_id)
service.analysis_results(experiment_id = exp_id,
result_type = 'result1',
result_type_operator='like')
fig_name, _ = service.create_figure(exp_id, fig)
new_fig = service.figure(exp_id, fig_name)
display(SVG(new_fig))
|
https://github.com/Qiskit/feedback
|
Qiskit
|
# based on https://github.com/Qiskit-Extensions/qiskit-alt/blob/main/bench/jordan_wigner_nature_time.py
from timeit import timeit
from qiskit import __qiskit_version__
from qiskit_nature.drivers import UnitsType, Molecule
from qiskit_nature.drivers.second_quantization import (
ElectronicStructureDriverType,
ElectronicStructureMoleculeDriver,
)
from qiskit_nature.problems.second_quantization import ElectronicStructureProblem
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.mappers.second_quantization import JordanWignerMapper
from qiskit_nature.operators.second_quantization import FermionicOp
geometry = {
"h2": [["H", [0.0, 0.0, 0.0]], ["H", [0.0, 0.0, 0.735]]],
"h2o": [["O", [0.0, 0.0, 0.0]], ["H", [0.757, 0.586, 0.0]], ["H", [-0.757, 0.586, 0.0]]],
}
def setup(basis, geom):
molecule = Molecule(geometry=geom, charge=0, multiplicity=1)
driver = ElectronicStructureMoleculeDriver(
molecule, basis=basis, driver_type=ElectronicStructureDriverType.PYSCF
)
es_problem = ElectronicStructureProblem(driver)
second_q_op = es_problem.second_q_ops()
qubit_converter = QubitConverter(mapper=JordanWignerMapper())
hamiltonian = second_q_op[0].reduce()
return qubit_converter, hamiltonian
def run_one_basis(basis, molecule, num_repetitions):
qubit_converter, hamiltonian = setup(basis, geometry[molecule])
time = timeit(lambda: qubit_converter.convert(hamiltonian), number=num_repetitions)
t = 1000 * time / num_repetitions
print(f"geometry={molecule}, basis={basis}, size={len(hamiltonian)}, time={t:0.2f} ms")
return t
print(__qiskit_version__)
for basis, molecule, num_repetitions in [
("sto3g", "h2", 10),
("631g", "h2", 10),
("631++g", "h2", 5),
("sto3g", "h2o", 5),
("631g", "h2o", 1),
]:
run_one_basis(basis, molecule, num_repetitions)
# Pure-Python PoC of unique
# https://github.com/Qiskit/qiskit-terra/pull/7656/commits/7e886dde94a7c2e46345d85b97b8bb4f7c928fc0
def _unique(array):
# This function corresponds to
# _, indexes, inverses = np.unique(array, return_index=True, return_inverse=True, axis=0)
table = {}
indexes = []
inverses = np.empty(array.shape[0], dtype=int)
for i, ary in enumerate(array):
b = ary.data.tobytes()
if b in table:
inverses[i] = table[b]
else:
inverses[i] = table[b] = len(table)
indexes.append(i)
return indexes, inverses
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import qiskit_alt
qiskit_alt.project.ensure_init(calljulia="pyjulia", compile=False, depot=True)
julia = qiskit_alt.project.julia
julia.Main.zeros(10)
from qiskit_nature.drivers import UnitsType, Molecule
from qiskit_nature.drivers.second_quantization import ElectronicStructureDriverType, ElectronicStructureMoleculeDriver
# Specify the geometry of the H_2 molecule
geometry = [['H', [0., 0., 0.]],
['H', [0., 0., 0.735]]]
basis = 'sto3g'
molecule = Molecule(geometry=geometry,
charge=0, multiplicity=1)
driver = ElectronicStructureMoleculeDriver(molecule, basis=basis, driver_type=ElectronicStructureDriverType.PYSCF)
from qiskit_nature.problems.second_quantization import ElectronicStructureProblem
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.mappers.second_quantization import JordanWignerMapper
es_problem = ElectronicStructureProblem(driver)
second_q_op = es_problem.second_q_ops()
fermionic_hamiltonian = second_q_op[0]
qubit_converter = QubitConverter(mapper=JordanWignerMapper())
nature_qubit_op = qubit_converter.convert(fermionic_hamiltonian)
nature_qubit_op.primitive
import qiskit_alt.electronic_structure
fermi_op = qiskit_alt.electronic_structure.fermionic_hamiltonian(geometry, basis)
pauli_op = qiskit_alt.electronic_structure.jordan_wigner(fermi_op)
pauli_op.simplify() # The Julia Pauli operators use a different sorting convention; we sort again for comparison.
%run ../bench/jordan_wigner_nature_time.py
nature_times
%run ../bench/jordan_wigner_alt_time.py
alt_times
[t_nature / t_qk_alt for t_nature, t_qk_alt in zip(nature_times, alt_times)]
%run ../bench/fermionic_nature_time.py
nature_times
%run ../bench/fermionic_alt_time.py
alt_times
[t_nature / t_qk_alt for t_nature, t_qk_alt in zip(nature_times, alt_times)]
from qiskit_alt.pauli_operators import QuantumOps, PauliSum_to_SparsePauliOp
import numpy as np
m = np.random.rand(2**3, 2**3) # 3-qubit operator
pauli_sum = QuantumOps.PauliSum(m) # This is a wrapped Julia object
PauliSum_to_SparsePauliOp(pauli_sum) # Convert to qiskit.quantum_info.SparsePauliOp
%run ../bench/from_matrix_quantum_info.py
%run ../bench/from_matrix_alt.py
[t_pyqk / t_qk_alt for t_pyqk, t_qk_alt in zip(pyqk_times, qk_alt_times)]
%run ../bench/pauli_from_list_qinfo.py
%run ../bench/pauli_from_list_alt.py
[x / y for x,y in zip(quantum_info_times, qkalt_times)]
%load_ext julia.magic
%julia using Random: randstring
%julia pauli_strings = [randstring("IXYZ", 10) for _ in 1:1000]
None;
%julia import Pkg; Pkg.add("BenchmarkTools")
%julia using BenchmarkTools: @btime
%julia @btime QuantumOps.PauliSum($pauli_strings)
None;
%julia pauli_sum = QuantumOps.PauliSum(pauli_strings);
%julia println(length(pauli_sum))
%julia println(pauli_sum[1])
6.9 * 2.29 / .343 # Ratio of time to construct PauliSum via qiskit_alt to time in pure Julia
import qiskit.tools.jupyter
d = qiskit.__qiskit_version__._version_dict
d['qiskit_alt'] = qiskit_alt.__version__
%qiskit_version_table
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.