repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/Alice-Bob-SW/qiskit-alice-bob-provider
|
Alice-Bob-SW
|
'''
qiskitpool/job.py
Contains the QJob class
'''
from functools import partial
from qiskit import execute
class QJob():
'''
QJob
Job manager for asynch qiskit backends
'''
def __init__(self, *args, qjob_id=None, **kwargs):
'''
QJob.__init__
Initialiser for a qiksit job
:: *args :: Args for qiskit execute
:: **kwargs :: Kwargs for qiskit execute
'''
self.job_fn = partial(execute, *args, **kwargs)
self.job = None
self.done = False
self.test_count = 10
self.qjob_id = qjob_id
def __call__(self):
'''
QJob.__call__
Wrapper for QJob.run
'''
return self.run()
def run(self):
'''
QJob.run
Send async job to qiskit backend
'''
self.job = self.job_fn()
return self
def poll(self):
'''
QJob.poll
Poll qiskit backend for job completion status
'''
if self.job is not None:
return self.job.done()
return False
def cancel(self):
'''
QJob.cancel
Cancel job on backend
'''
if self.job is None:
return None
return self.job.cancel()
def position(self):
pos = self.job.queue_position()
if pos is None:
return 0
return pos
def status(self):
if self.job is None:
return 'LOCAL QUEUE'
else:
status = self.job.status().value
if 'running' in status:
return 'RUNNING'
if 'run' in status:
return 'COMPLETE'
if 'validated' in status:
return 'VALIDATING'
if 'queued' in status:
pos = self.position()
return f'QISKIT QUEUE: {self.position()}'
def status_short(self):
if self.job is None:
return ' '
else:
status = self.job.status().value
if 'running' in status:
return 'R'
if 'run' in status:
return 'C'
if 'validated' in status:
return 'V'
if 'queued' in status:
return str(self.position())
def result(self):
'''
QJob.result
Get result from backend
Non blocking - returns False if a job is not yet ready
'''
if self.poll():
return self.job.result()
return False
|
https://github.com/Alice-Bob-SW/qiskit-alice-bob-provider
|
Alice-Bob-SW
|
##############################################################################
# Copyright 2023 Alice & Bob
#
# 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.
##############################################################################
# pylint: disable=unused-argument
from pathlib import Path
from textwrap import dedent
import pytest
from qiskit import QiskitError, QuantumCircuit, execute, transpile
from qiskit.providers import Options
from qiskit.pulse.schedule import Schedule
from qiskit.result import Result
from qiskit.transpiler.exceptions import TranspilerError
from requests_mock.mocker import Mocker
from qiskit_alice_bob_provider.remote.api.client import AliceBobApiException
from qiskit_alice_bob_provider.remote.backend import (
AliceBobRemoteBackend,
_ab_input_params_from_options,
_qiskit_to_qir,
)
from qiskit_alice_bob_provider.remote.provider import AliceBobRemoteProvider
def test_get_backend(mocked_targets) -> None:
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
assert isinstance(backend, AliceBobRemoteBackend)
assert backend.options['average_nb_photons'] == 4.0 # Default value.
def test_get_backend_with_options(mocked_targets) -> None:
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend(
'EMU:1Q:LESCANNE_2020', average_nb_photons=6.0
)
assert isinstance(backend, AliceBobRemoteBackend)
assert backend.options['average_nb_photons'] == 6.0
def test_get_backend_options_validation(mocked_targets) -> None:
provider = AliceBobRemoteProvider(api_key='foo')
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', average_nb_photons=40)
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', average_nb_photons=-1)
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', shots=0)
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', shots=1e10)
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', bad_option=1)
def test_execute_options_validation(mocked_targets) -> None:
# We are permissive in our options sytem, allowing the user to both
# define options when creating the backend and executing.
# We therefore need to test both behaviors.
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
with pytest.raises(ValueError):
execute(c, backend, average_nb_photons=40)
with pytest.raises(ValueError):
execute(c, backend, average_nb_photons=-1)
with pytest.raises(ValueError):
execute(c, backend, bad_option=1)
with pytest.raises(ValueError):
execute(c, backend, shots=0)
with pytest.raises(ValueError):
execute(c, backend, shots=1e10)
def test_too_many_qubits_clients_side(mocked_targets) -> None:
c = QuantumCircuit(3, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
with pytest.raises(TranspilerError):
execute(c, backend)
def test_input_not_quantum_circuit(mocked_targets) -> None:
c1 = QuantumCircuit(1, 1)
c2 = QuantumCircuit(1, 1)
s1 = Schedule()
s2 = Schedule()
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
with pytest.raises(NotImplementedError):
execute([c1, c2], backend)
with pytest.raises(NotImplementedError):
execute(s1, backend)
with pytest.raises(NotImplementedError):
execute([s1, s2], backend)
def test_counts_ordering(successful_job: Mocker) -> None:
c = QuantumCircuit(1, 2)
c.initialize('+', 0)
c.measure_x(0, 0)
c.measure(0, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
job = execute(c, backend)
counts = job.result(wait=0).get_counts()
expected = {'11': 12, '10': 474, '01': 6, '00': 508}
assert counts == expected
counts = job.result(wait=0).get_counts() # testing memoization
assert counts == expected
def test_failed_transpilation(failed_transpilation_job: Mocker) -> None:
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
job = execute(c, backend)
res: Result = job.result(wait=0)
assert res.results[0].data.input_qir is not None
assert res.results[0].data.transpiled_qir is None
res = job.result(wait=0) # testing memoization
assert res.results[0].data.input_qir is not None
assert res.results[0].data.transpiled_qir is None
with pytest.raises(QiskitError):
res.get_counts()
def test_failed_execution(failed_execution_job: Mocker) -> None:
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
job = execute(c, backend)
res: Result = job.result(wait=0)
assert res.results[0].data.input_qir is not None
assert res.results[0].data.transpiled_qir is not None
with pytest.raises(QiskitError):
res.get_counts()
def test_cancel_job(cancellable_job: Mocker) -> None:
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
job = execute(c, backend)
job.cancel()
res: Result = job.result(wait=0)
assert res.results[0].data.input_qir is not None
assert res.results[0].data.transpiled_qir is not None
with pytest.raises(QiskitError):
res.get_counts()
def test_failed_server_side_validation(failed_validation_job: Mocker) -> None:
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
with pytest.raises(AliceBobApiException):
execute(c, backend)
def test_delay_instruction_recognized() -> None:
c = QuantumCircuit(1, 2)
c.initialize('+', 0)
c.measure_x(0, 0)
c.delay(3000, 0, unit='ns')
c.measure(0, 1)
qir = _qiskit_to_qir(c)
delay_call = (
'call void @__quantum__qis__delay__body'
'(double 3.000000e+00, %Qubit* null)'
)
assert delay_call in qir
def test_ab_input_params_from_options() -> None:
options = Options(shots=43, average_nb_photons=3.2, foo_hey='bar')
params = _ab_input_params_from_options(options)
assert params == {'nbShots': 43, 'averageNbPhotons': 3.2, 'fooHey': 'bar'}
def test_translation_plugin_and_qir(mocked_targets) -> None:
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('ALL_INSTRUCTIONS')
c = QuantumCircuit(4, 4)
c.initialize('-01+')
c.measure([0, 1], [2, 3])
c.x(2).c_if(2, 1)
c.measure_x(2, 0)
c.measure_x(3, 1)
transpiled = transpile(c, backend)
qir = _qiskit_to_qir(transpiled)
assert (
dedent(
Path(
'tests/resources/test_translation_plugin_and_qir.ll'
).read_text(encoding='utf-8')
)
in qir
)
def test_determine_translation_plugin(mocked_targets) -> None:
p = AliceBobRemoteProvider(api_key='foo')
# Rotations available
assert (
p.get_backend('ALL_INSTRUCTIONS').get_translation_stage_plugin()
== 'state_preparation'
)
# H and T missing
assert (
p.get_backend('EMU:1Q:LESCANNE_2020').get_translation_stage_plugin()
== 'state_preparation'
)
# T missing
assert (
p.get_backend('H').get_translation_stage_plugin()
== 'state_preparation'
)
# ok
assert (
p.get_backend('H_T').get_translation_stage_plugin() == 'sk_synthesis'
)
|
https://github.com/Alice-Bob-SW/qiskit-alice-bob-provider
|
Alice-Bob-SW
|
import pytest
from qiskit import QuantumCircuit
from qiskit.transpiler import PassManager
from qiskit_alice_bob_provider.local.quantum_errors import (
build_quantum_error_passes,
)
from qiskit_alice_bob_provider.processor.description import (
ProcessorDescription,
)
from .processor_fixture import (
AllToAllProcessorWithQubitInstruction,
QubitProcessorWithAllToAllInstruction,
SimpleAllToAllProcessor,
SimpleProcessor,
)
def test_noise_not_on_all_qubits() -> None:
circ = QuantumCircuit(3)
for i in range(3):
circ.y(i)
pm = PassManager(build_quantum_error_passes(SimpleProcessor()))
transpiled = pm.run(circ)
# Y noise was only activated on qubits 0 and 1
y_errors = transpiled.get_instructions('y_error')
assert len(y_errors) == 2
qubits = {circ.find_bit(e.qubits[0])[0] for e in y_errors}
assert qubits == {0, 1}
@pytest.mark.parametrize(
'proc', [SimpleProcessor(), SimpleAllToAllProcessor()]
)
def test_noise_on_initialize(proc: ProcessorDescription) -> None:
circ = QuantumCircuit(3)
circ.initialize('+', 0)
circ.initialize('-', 1)
circ.initialize('0', 2)
pm = PassManager(build_quantum_error_passes(proc))
transpiled = pm.run(circ)
for label, n_qubits, index in [
('p+_error', 1, 0),
('p-_error', 0, 0),
('p0_error', 1, 2),
('p1_error', 0, 0),
]:
errors = transpiled.get_instructions(label)
assert len(errors) == n_qubits
if n_qubits == 1:
qubit = circ.find_bit(errors[0].qubits[0]).index
assert qubit == index
@pytest.mark.parametrize(
'proc', [SimpleProcessor(), SimpleAllToAllProcessor()]
)
def test_noise_on_mx(proc: ProcessorDescription) -> None:
circ = QuantumCircuit(3, 3)
circ.measure_x(0, 0)
circ.measure_x(1, 1)
circ.measure(2, 2)
pm = PassManager(build_quantum_error_passes(proc))
transpiled = pm.run(circ)
# Only qubits 0 and 1 had a measure in the x basis
mx_errors = transpiled.get_instructions('mx_error')
assert len(mx_errors) == 2
qubits = {circ.find_bit(e.qubits[0])[0] for e in mx_errors}
assert qubits == {0, 1}
@pytest.mark.parametrize(
'proc', [SimpleProcessor(), SimpleAllToAllProcessor()]
)
def test_pass_with_none_chi_matrix(proc: ProcessorDescription) -> None:
circ = QuantumCircuit(10)
circ.x(0)
pm = PassManager(build_quantum_error_passes(proc))
transpiled = pm.run(circ)
assert len(transpiled.get_instructions('x_error')) == 0
@pytest.mark.parametrize(
'proc', [SimpleProcessor(), SimpleAllToAllProcessor()]
)
def test_chi_vs_pauli_errors(proc: ProcessorDescription) -> None:
pm = PassManager(build_quantum_error_passes(proc))
# Circuit with diagonal chi matrix -> quantum channel of Pauli errors
circ = QuantumCircuit(10)
circ.y(0)
transpiled = pm.run(circ)
assert len(transpiled.decompose().get_instructions('quantum_channel')) == 1
# Circuit with none diagonal chi matrix -> Kraus map
circ = QuantumCircuit(10)
circ.h(0)
transpiled = pm.run(circ)
print(transpiled.decompose())
assert len(transpiled.decompose().get_instructions('kraus')) == 1
@pytest.mark.parametrize(
'proc',
[
AllToAllProcessorWithQubitInstruction(),
QubitProcessorWithAllToAllInstruction(),
],
)
def test_bad_instruction_with_processor_type(
proc: ProcessorDescription,
) -> None:
with pytest.raises(ValueError):
PassManager(build_quantum_error_passes(proc))
|
https://github.com/Alice-Bob-SW/qiskit-alice-bob-provider
|
Alice-Bob-SW
|
import pytest
from qiskit import QuantumCircuit, execute
from qiskit_alice_bob_provider.local.backend import ProcessorSimulator
from qiskit_alice_bob_provider.local.readout_errors import (
build_readout_noise_model,
)
from qiskit_alice_bob_provider.processor.description import (
ProcessorDescription,
)
from .processor_fixture import (
AllToAllProcessorWithQubitInstruction,
AllToAllReadoutErrorProcessor,
ConflictingReadoutErrorsProcessor,
QubitProcessorWithAllToAllInstruction,
ReadoutErrorProcessor,
)
def test_one_readout_error() -> None:
backend = ProcessorSimulator(processor=ReadoutErrorProcessor())
circ = QuantumCircuit(2, 2)
circ.initialize('++')
circ.measure_x(0, 0)
circ.measure_x(1, 1)
counts = execute(circ, backend, shots=1).result().get_counts()
assert counts.keys() == {'01'}
circ = QuantumCircuit(2, 2)
circ.initialize('--')
circ.measure_x(0, 0)
circ.measure_x(1, 1)
counts = execute(circ, backend, shots=1).result().get_counts()
assert counts.keys() == {'01'}
def test_all_to_all_one_readout_error() -> None:
with pytest.warns(UserWarning):
backend = ProcessorSimulator(processor=AllToAllReadoutErrorProcessor())
circ = QuantumCircuit(2, 2)
circ.initialize('++')
circ.measure_x(0, 0)
circ.measure_x(1, 1)
counts = execute(circ, backend, shots=1).result().get_counts()
assert counts.keys() == {'11'}
circ = QuantumCircuit(2, 2)
circ.initialize('--')
circ.measure_x(0, 0)
circ.measure_x(1, 1)
counts = execute(circ, backend, shots=1).result().get_counts()
assert counts.keys() == {'11'}
def test_conflicting_readout_errors() -> None:
proc = ConflictingReadoutErrorsProcessor()
with pytest.warns(UserWarning):
backend = ProcessorSimulator(processor=proc)
circ = QuantumCircuit(1, 1)
circ.initialize('+')
circ.measure_x(0, 0)
counts = execute(circ, backend, shots=1).result().get_counts()
assert counts.keys() == {'1'}
circ = QuantumCircuit(1, 1)
circ.initialize('-')
circ.measure_x(0, 0)
counts = execute(circ, backend, shots=1).result().get_counts()
assert counts.keys() == {'1'}
@pytest.mark.parametrize(
'proc',
[
AllToAllProcessorWithQubitInstruction(),
QubitProcessorWithAllToAllInstruction(),
],
)
def test_bad_instruction_with_processor_type(
proc: ProcessorDescription,
) -> None:
with pytest.raises(ValueError):
build_readout_noise_model(proc)
|
https://github.com/Alice-Bob-SW/qiskit-alice-bob-provider
|
Alice-Bob-SW
|
from typing import Iterator, Tuple
import pytest
from qiskit import QuantumCircuit, transpile
from qiskit.extensions.quantum_initializer import Initialize
from qiskit_alice_bob_provider.local.backend import ProcessorSimulator
from qiskit_alice_bob_provider.processor.description import (
ProcessorDescription,
)
from .processor_fixture import SimpleAllToAllProcessor, SimpleProcessor
def gen_circuits() -> Iterator[Tuple[str, QuantumCircuit, int]]:
circ = QuantumCircuit(2, 2)
circ.initialize('0', 0)
circ.initialize('+', 1)
circ.x(0)
circ.rz(11, 1)
circ.cx(0, 1)
circ.measure(0, 0)
circ.measure_x(1, 1)
yield ('qubits_competing_for_duration', circ, 11100110)
sub_sub_circ = QuantumCircuit(2, 0)
sub_sub_circ.x(0)
sub_sub_circ.rz(11, 1)
sub_circ = QuantumCircuit(2, 0)
sub_circ.append(sub_sub_circ.to_instruction(), [1, 0])
circ = QuantumCircuit(2, 2)
circ.initialize('0', 0)
circ.initialize('+', 1)
circ.append(sub_circ.to_instruction(), [1, 0])
circ.cx(0, 1)
circ.measure(0, 0)
circ.measure_x(1, 1)
yield ('sub_circuits', circ, 11100110)
def gen_all_to_all_circuits() -> Iterator[Tuple[str, QuantumCircuit, int]]:
circ = QuantumCircuit(2, 2)
circ.initialize('0', 0) # 1e3
circ.initialize('+', 1) # 1e2
circ.x(0) # 1e7
circ.t(1) # 1e6
circ.cx(0, 1) # 1e1
circ.measure(0, 0) # 1e5
circ.measure_x(1, 1) # 1e4
yield ('qubits_competing_for_duration', circ, 10101010)
sub_sub_circ = QuantumCircuit(2, 0)
sub_sub_circ.x(0) # 1e7
sub_sub_circ.t(1) # 1e6
sub_circ = QuantumCircuit(2, 0)
sub_circ.append(sub_sub_circ.to_instruction(), [1, 0])
circ = QuantumCircuit(2, 2)
circ.initialize('0', 0) # 1e3
circ.initialize('+', 1) # 1e2
circ.append(sub_circ.to_instruction(), [1, 0])
circ.cx(0, 1) # 1e1
circ.measure(0, 0) # 1e5
circ.measure_x(1, 1) # 1e4
yield ('sub_circuits', circ, 10101010)
@pytest.mark.parametrize(
'tup,proc',
[(tup, SimpleAllToAllProcessor(1)) for tup in gen_all_to_all_circuits()]
+ [(tup, SimpleProcessor(1)) for tup in gen_circuits()],
)
def test_circuit(
tup: Tuple[str, QuantumCircuit, int], proc: ProcessorDescription
) -> None:
_, circ, expected_duration = tup
backend = ProcessorSimulator(proc)
transpiled = transpile(circ, backend)
try:
assert transpiled.duration == expected_duration
except AssertionError:
print('==== Original circuit ====')
print(circ)
print('==== Transpiled circuit ====')
print(transpiled)
raise
@pytest.mark.parametrize(
'proc',
[
SimpleProcessor(1),
SimpleAllToAllProcessor(1),
],
)
def test_reset_to_initialize(proc: ProcessorDescription) -> None:
circ = QuantumCircuit(1, 0)
circ.reset(0)
backend = ProcessorSimulator(proc)
transpiled = transpile(circ, backend)
initializes = transpiled.get_instructions('initialize')
print(circ)
print(transpiled)
assert len(initializes) == 1
assert isinstance(initializes[0].operation, Initialize)
assert initializes[0].operation.params[0] == '0'
assert len(transpiled.get_instructions('reset')) == 0
|
https://github.com/Alice-Bob-SW/qiskit-alice-bob-provider
|
Alice-Bob-SW
|
from typing import Iterator, List, Set, Tuple
import numpy as np
import pytest
from qiskit import QuantumCircuit, execute
from qiskit_aer.backends import AerSimulator
from qiskit_aer.noise import NoiseModel, pauli_error
from qiskit_alice_bob_provider.local.backend import ProcessorSimulator
from qiskit_alice_bob_provider.local.job import ProcessorSimulationJob
from qiskit_alice_bob_provider.processor.description import (
AppliedInstruction,
InstructionProperties,
ProcessorDescription,
)
from qiskit_alice_bob_provider.processor.interpolated_cat import (
InterpolatedCatProcessor,
)
from qiskit_alice_bob_provider.processor.serialization.model import (
SerializedProcessor,
)
from qiskit_alice_bob_provider.processor.utils import pauli_errors_to_chi
from .processor_fixture import (
LargeSimpleProcessor,
OneQubitProcessor,
SimpleAllToAllProcessor,
SimpleProcessor,
)
def gen_circuits() -> Iterator[Tuple[str, QuantumCircuit, Set[str]]]:
circ = QuantumCircuit(2, 2)
circ.initialize('0', 0)
circ.initialize('+', 1)
circ.x(0)
circ.cx(0, 1)
circ.measure(0, 0)
circ.measure_x(1, 1)
yield ('everything_circuit', circ, {'11'})
@pytest.mark.parametrize(
['tup', 'backend'],
(
(tup, backend)
for tup in gen_circuits()
for backend in [
ProcessorSimulator(SimpleProcessor()),
ProcessorSimulator(
SimpleAllToAllProcessor(),
translation_stage_plugin='sk_synthesis',
),
]
),
)
def test_circuit(
tup: Tuple[str, QuantumCircuit, Set[str]], backend: ProcessorSimulator
) -> None:
_, circ, expected_keys = tup
# backend = ProcessorSimulator(SimpleProcessor())
job: ProcessorSimulationJob = execute(circ, backend)
result = job.result()
try:
assert result.get_counts().keys() == expected_keys
except AssertionError:
print('==== Original circuit ====')
print(circ)
print('==== Scheduled circuit ====')
print(job.circuits()[0])
print('==== Noisy circuit ====')
print(job.noisy_circuits()[0])
raise
def test_multiple_experiments() -> None:
circ1 = QuantumCircuit(1, 1)
circ1.x(0)
circ1.measure(0, 0)
circ2 = QuantumCircuit(1, 1)
circ2.initialize('+')
circ2.measure_x(0, 0)
backend = ProcessorSimulator(SimpleProcessor())
job: ProcessorSimulationJob = execute([circ1, circ2], backend)
result = job.result()
assert len(result.get_counts()) == 2
def test_non_default_shots() -> None:
circ = QuantumCircuit(1, 1)
circ.x(0)
circ.measure(0, 0)
shots = 5
backend = ProcessorSimulator(SimpleProcessor())
job: ProcessorSimulationJob = execute(circ, backend, shots=shots)
result = job.result()
assert sum(result.get_counts().values()) == shots
class _CXProcessor(ProcessorDescription):
clock_cycle = 1
def all_instructions(self) -> Iterator[InstructionProperties]:
for i in range(2):
yield InstructionProperties(name='p0', params=[], qubits=(i,))
yield InstructionProperties(name='mz', params=[], qubits=(i,))
yield InstructionProperties(name='cx', params=[], qubits=(0, 1))
yield InstructionProperties(name='cx', params=[], qubits=(1, 0))
def apply_instruction(
self, name: str, qubits: Tuple[int, ...], params: List[float]
) -> AppliedInstruction:
if name == 'cx':
return AppliedInstruction(
duration=self.clock_cycle,
quantum_errors=pauli_errors_to_chi({'IX': 1.0}),
readout_errors=None,
)
return AppliedInstruction(
duration=self.clock_cycle,
quantum_errors=None,
readout_errors=None,
)
def gen_circuits_ordering() -> Iterator[Tuple[str, QuantumCircuit]]:
circ = QuantumCircuit(2, 2)
circ.cx(0, 1)
circ.measure(0, 0)
circ.measure(1, 1)
yield ('01_circuit', circ)
circ = QuantumCircuit(2, 2)
circ.cx(1, 0)
circ.measure(0, 0)
circ.measure(1, 1)
yield ('10_circuit', circ)
@pytest.mark.parametrize('tup', gen_circuits_ordering())
def test_qubit_ordering(tup: Tuple[str, QuantumCircuit]) -> None:
_, circ = tup
aer = AerSimulator()
nm = NoiseModel()
nm.add_all_qubit_quantum_error(pauli_error([('IX', 1.0)]), 'cx')
aer_counts = execute(circ, aer, noise_model=nm).result().get_counts()
backend = ProcessorSimulator(_CXProcessor())
proc_counts = execute(circ, backend).result().get_counts()
try:
assert aer_counts == proc_counts
except AssertionError:
print(circ)
def test_interpolated_cat() -> None:
with open(
'tests/processor/serialization/data/all_types.json',
encoding='utf-8',
) as f:
ser = SerializedProcessor.model_validate_json(f.read())
proc = InterpolatedCatProcessor(ser, alpha=np.sqrt(5))
backend = ProcessorSimulator(proc)
circ = QuantumCircuit(2, 2)
circ.initialize('+', 0)
circ.initialize('0', 1)
circ.x(0)
circ.delay(800, 0, unit='s')
circ.y(0)
circ.rz(1.57, 0)
circ.cx(0, 1)
circ.measure_x(0, 0)
circ.measure(0, 1)
job = execute(circ, backend)
assert isinstance(job, ProcessorSimulationJob)
noisy_circ = job.noisy_circuits()[0]
assert len(noisy_circ.get_instructions('p0_error')) == 1
assert len(noisy_circ.get_instructions('p+_error')) == 1
assert len(noisy_circ.get_instructions('mx_error')) == 1
assert len(noisy_circ.get_instructions('x_error')) == 1
assert len(noisy_circ.get_instructions('y_error')) == 0
assert len(noisy_circ.get_instructions('rz_error')) == 1
assert len(noisy_circ.get_instructions('cx_error')) == 1
assert len(noisy_circ.get_instructions('mx_error')) == 1
assert len(noisy_circ.get_instructions('mz_error')) == 1
assert len(noisy_circ.get_instructions('delay')) == 1
# The next lines test that we can simulate without errors
job.result().get_counts()
def test_no_delay() -> None:
"""This test makes sure that quantum errors get inserted even when there
are no delay in the circuit after scheduling."""
backend = ProcessorSimulator(OneQubitProcessor())
circ = QuantumCircuit(1, 1)
circ.initialize('+')
circ.measure_x(0, 0)
assert execute(circ, backend, shots=1).result().get_counts() == {'1': 1}
class _ConditioningProcessor(ProcessorDescription):
def __init__(self, clock_cycle: float = 1):
self.clock_cycle = clock_cycle
self.n_qubits = 2
def all_instructions(self) -> Iterator[InstructionProperties]:
yield InstructionProperties(name='p+', params=[], qubits=None)
yield InstructionProperties(name='p-', params=[], qubits=None)
yield InstructionProperties(name='mx', params=[], qubits=None)
yield InstructionProperties(name='x', params=[], qubits=None)
def apply_instruction(
self, name: str, qubits: Tuple[int, ...], params: List[float]
) -> AppliedInstruction:
if name == 'mx':
return AppliedInstruction(
duration=1e4,
quantum_errors=None,
readout_errors=None,
)
elif name in {'p+', 'p-'}:
return AppliedInstruction(
duration=1e2,
quantum_errors=None,
readout_errors=None,
)
elif name == 'x':
return AppliedInstruction(
duration=1e3,
quantum_errors=pauli_errors_to_chi({'Z': 1.0}),
readout_errors=None,
)
raise NotImplementedError()
def test_conditional_instruction() -> None:
# Noiseless backend, except the X gate that has a 100% Z-flip error
backend = ProcessorSimulator(_ConditioningProcessor())
circ = QuantumCircuit(2, 2)
circ.initialize('++')
circ.measure_x(0, 0)
circ.x(1).c_if(0, 0)
circ.measure_x(1, 1)
assert execute(circ, backend, shots=1).result().get_counts() == {'10': 1}
circ = QuantumCircuit(2, 2)
circ.initialize('+-')
circ.measure_x(0, 0)
circ.x(1).c_if(0, 0)
circ.measure_x(1, 1)
job = execute(circ, backend, shots=1)
assert job.result().get_counts() == {'01': 1}
def test_large_processor() -> None:
"""A processor with more qubits (40 here) than accepted by AerSimulator
(29 on my machine, this is based on system memory) would fail. A fix was
implemented in local/backend.py"""
backend = ProcessorSimulator(LargeSimpleProcessor())
circ = QuantumCircuit(1, 1)
circ.initialize('0')
circ.delay(1, 0, unit='s')
circ.measure(0, 0)
execute(circ, backend)
|
https://github.com/Alice-Bob-SW/qiskit-alice-bob-provider
|
Alice-Bob-SW
|
# 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.
"""
StatePreparation test.
"""
import unittest
import math
import numpy as np
from ddt import ddt, data
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.quantum_info import Statevector, Operator
from qiskit.test import QiskitTestCase
from qiskit.exceptions import QiskitError
from qiskit.circuit.library import StatePreparation
@ddt
class TestStatePreparation(QiskitTestCase):
"""Test initialization with StatePreparation class"""
def test_prepare_from_label(self):
"""Prepare state from label."""
desired_sv = Statevector.from_label("01+-lr")
qc = QuantumCircuit(6)
qc.prepare_state("01+-lr", range(6))
actual_sv = Statevector(qc)
self.assertTrue(desired_sv == actual_sv)
def test_prepare_from_int(self):
"""Prepare state from int."""
desired_sv = Statevector.from_label("110101")
qc = QuantumCircuit(6)
qc.prepare_state(53, range(6))
actual_sv = Statevector(qc)
self.assertTrue(desired_sv == actual_sv)
def test_prepare_from_list(self):
"""Prepare state from list."""
desired_sv = Statevector([1 / math.sqrt(2), 0, 0, 1 / math.sqrt(2)])
qc = QuantumCircuit(2)
qc.prepare_state([1 / math.sqrt(2), 0, 0, 1 / math.sqrt(2)])
actual_sv = Statevector(qc)
self.assertTrue(desired_sv == actual_sv)
def test_prepare_single_qubit(self):
"""Prepare state in single qubit."""
qreg = QuantumRegister(2)
circuit = QuantumCircuit(qreg)
circuit.prepare_state([1 / math.sqrt(2), 1 / math.sqrt(2)], qreg[1])
expected = QuantumCircuit(qreg)
expected.prepare_state([1 / math.sqrt(2), 1 / math.sqrt(2)], [qreg[1]])
self.assertEqual(circuit, expected)
def test_nonzero_state_incorrect(self):
"""Test final state incorrect if initial state not zero"""
desired_sv = Statevector([1 / math.sqrt(2), 0, 0, 1 / math.sqrt(2)])
qc = QuantumCircuit(2)
qc.x(0)
qc.prepare_state([1 / math.sqrt(2), 0, 0, 1 / math.sqrt(2)])
actual_sv = Statevector(qc)
self.assertFalse(desired_sv == actual_sv)
@data(2, "11", [1 / math.sqrt(2), 0, 0, 1 / math.sqrt(2)])
def test_inverse(self, state):
"""Test inverse of StatePreparation"""
qc = QuantumCircuit(2)
stateprep = StatePreparation(state)
qc.append(stateprep, [0, 1])
qc.append(stateprep.inverse(), [0, 1])
self.assertTrue(np.allclose(Operator(qc).data, np.identity(2**qc.num_qubits)))
def test_double_inverse(self):
"""Test twice inverse of StatePreparation"""
desired_sv = Statevector([1 / math.sqrt(2), 0, 0, 1 / math.sqrt(2)])
qc = QuantumCircuit(2)
stateprep = StatePreparation([1 / math.sqrt(2), 0, 0, 1 / math.sqrt(2)])
qc.append(stateprep.inverse().inverse(), [0, 1])
actual_sv = Statevector(qc)
self.assertTrue(desired_sv == actual_sv)
def test_incompatible_state_and_qubit_args(self):
"""Test error raised if number of qubits not compatible with state arg"""
qc = QuantumCircuit(3)
with self.assertRaises(QiskitError):
qc.prepare_state("11")
def test_incompatible_int_state_and_qubit_args(self):
"""Test error raised if number of qubits not compatible with integer state arg"""
# pylint: disable=pointless-statement
with self.assertRaises(QiskitError):
stateprep = StatePreparation(5, num_qubits=2)
stateprep.definition
def test_int_state_and_no_qubit_args(self):
"""Test automatic determination of qubit number"""
stateprep = StatePreparation(5)
self.assertEqual(stateprep.num_qubits, 3)
def test_repeats(self):
"""Test repeat function repeats correctly"""
qc = QuantumCircuit(2)
qc.append(StatePreparation("01").repeat(2), [0, 1])
self.assertEqual(qc.decompose().count_ops()["state_preparation"], 2)
if __name__ == "__main__":
unittest.main()
|
https://github.com/Alice-Bob-SW/qiskit-alice-bob-provider
|
Alice-Bob-SW
|
##############################################################################
# Copyright 2023 Alice & Bob
#
# 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.
##############################################################################
import pytest
from qiskit import QuantumCircuit, execute
from qiskit_alice_bob_provider import AliceBobRemoteProvider
realserver = pytest.mark.skipif(
"not config.getoption('api_key') and not config.getoption('base_url')"
)
@realserver
def test_happy_path(base_url: str, api_key: str) -> None:
c = QuantumCircuit(1, 2)
c.initialize('+', 0)
c.measure_x(0, 0)
c.measure(0, 1)
provider = AliceBobRemoteProvider(
api_key=api_key,
url=base_url,
)
backend = provider.get_backend(
'EMU:1Q:LESCANNE_2020', average_nb_photons=6.0
)
job = execute(c, backend, shots=100)
res = job.result()
res.get_counts()
|
https://github.com/Alice-Bob-SW/qiskit-alice-bob-provider
|
Alice-Bob-SW
|
##############################################################################
# Copyright 2023 Alice & Bob
#
# 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.
##############################################################################
# pylint: disable=unused-argument
from pathlib import Path
from textwrap import dedent
import pytest
from qiskit import QiskitError, QuantumCircuit, execute, transpile
from qiskit.providers import Options
from qiskit.pulse.schedule import Schedule
from qiskit.result import Result
from qiskit.transpiler.exceptions import TranspilerError
from requests_mock.mocker import Mocker
from qiskit_alice_bob_provider.remote.api.client import AliceBobApiException
from qiskit_alice_bob_provider.remote.backend import (
AliceBobRemoteBackend,
_ab_input_params_from_options,
_qiskit_to_qir,
)
from qiskit_alice_bob_provider.remote.provider import AliceBobRemoteProvider
def test_get_backend(mocked_targets) -> None:
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
assert isinstance(backend, AliceBobRemoteBackend)
assert backend.options['average_nb_photons'] == 4.0 # Default value.
def test_get_backend_with_options(mocked_targets) -> None:
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend(
'EMU:1Q:LESCANNE_2020', average_nb_photons=6.0
)
assert isinstance(backend, AliceBobRemoteBackend)
assert backend.options['average_nb_photons'] == 6.0
def test_get_backend_options_validation(mocked_targets) -> None:
provider = AliceBobRemoteProvider(api_key='foo')
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', average_nb_photons=40)
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', average_nb_photons=-1)
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', shots=0)
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', shots=1e10)
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', bad_option=1)
def test_execute_options_validation(mocked_targets) -> None:
# We are permissive in our options sytem, allowing the user to both
# define options when creating the backend and executing.
# We therefore need to test both behaviors.
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
with pytest.raises(ValueError):
execute(c, backend, average_nb_photons=40)
with pytest.raises(ValueError):
execute(c, backend, average_nb_photons=-1)
with pytest.raises(ValueError):
execute(c, backend, bad_option=1)
with pytest.raises(ValueError):
execute(c, backend, shots=0)
with pytest.raises(ValueError):
execute(c, backend, shots=1e10)
def test_too_many_qubits_clients_side(mocked_targets) -> None:
c = QuantumCircuit(3, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
with pytest.raises(TranspilerError):
execute(c, backend)
def test_input_not_quantum_circuit(mocked_targets) -> None:
c1 = QuantumCircuit(1, 1)
c2 = QuantumCircuit(1, 1)
s1 = Schedule()
s2 = Schedule()
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
with pytest.raises(NotImplementedError):
execute([c1, c2], backend)
with pytest.raises(NotImplementedError):
execute(s1, backend)
with pytest.raises(NotImplementedError):
execute([s1, s2], backend)
def test_counts_ordering(successful_job: Mocker) -> None:
c = QuantumCircuit(1, 2)
c.initialize('+', 0)
c.measure_x(0, 0)
c.measure(0, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
job = execute(c, backend)
counts = job.result(wait=0).get_counts()
expected = {'11': 12, '10': 474, '01': 6, '00': 508}
assert counts == expected
counts = job.result(wait=0).get_counts() # testing memoization
assert counts == expected
def test_failed_transpilation(failed_transpilation_job: Mocker) -> None:
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
job = execute(c, backend)
res: Result = job.result(wait=0)
assert res.results[0].data.input_qir is not None
assert res.results[0].data.transpiled_qir is None
res = job.result(wait=0) # testing memoization
assert res.results[0].data.input_qir is not None
assert res.results[0].data.transpiled_qir is None
with pytest.raises(QiskitError):
res.get_counts()
def test_failed_execution(failed_execution_job: Mocker) -> None:
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
job = execute(c, backend)
res: Result = job.result(wait=0)
assert res.results[0].data.input_qir is not None
assert res.results[0].data.transpiled_qir is not None
with pytest.raises(QiskitError):
res.get_counts()
def test_cancel_job(cancellable_job: Mocker) -> None:
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
job = execute(c, backend)
job.cancel()
res: Result = job.result(wait=0)
assert res.results[0].data.input_qir is not None
assert res.results[0].data.transpiled_qir is not None
with pytest.raises(QiskitError):
res.get_counts()
def test_failed_server_side_validation(failed_validation_job: Mocker) -> None:
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
with pytest.raises(AliceBobApiException):
execute(c, backend)
def test_delay_instruction_recognized() -> None:
c = QuantumCircuit(1, 2)
c.initialize('+', 0)
c.measure_x(0, 0)
c.delay(3000, 0, unit='ns')
c.measure(0, 1)
qir = _qiskit_to_qir(c)
delay_call = (
'call void @__quantum__qis__delay__body'
'(double 3.000000e+00, %Qubit* null)'
)
assert delay_call in qir
def test_ab_input_params_from_options() -> None:
options = Options(shots=43, average_nb_photons=3.2, foo_hey='bar')
params = _ab_input_params_from_options(options)
assert params == {'nbShots': 43, 'averageNbPhotons': 3.2, 'fooHey': 'bar'}
def test_translation_plugin_and_qir(mocked_targets) -> None:
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('ALL_INSTRUCTIONS')
c = QuantumCircuit(4, 4)
c.initialize('-01+')
c.measure([0, 1], [2, 3])
c.x(2).c_if(2, 1)
c.measure_x(2, 0)
c.measure_x(3, 1)
transpiled = transpile(c, backend)
qir = _qiskit_to_qir(transpiled)
assert (
dedent(
Path(
'tests/resources/test_translation_plugin_and_qir.ll'
).read_text(encoding='utf-8')
)
in qir
)
def test_determine_translation_plugin(mocked_targets) -> None:
p = AliceBobRemoteProvider(api_key='foo')
# Rotations available
assert (
p.get_backend('ALL_INSTRUCTIONS').get_translation_stage_plugin()
== 'state_preparation'
)
# H and T missing
assert (
p.get_backend('EMU:1Q:LESCANNE_2020').get_translation_stage_plugin()
== 'state_preparation'
)
# T missing
assert (
p.get_backend('H').get_translation_stage_plugin()
== 'state_preparation'
)
# ok
assert (
p.get_backend('H_T').get_translation_stage_plugin() == 'sk_synthesis'
)
|
https://github.com/BoschSamuel/QizGloria
|
BoschSamuel
|
from qiskit import *
import torch
from torch.autograd import Function
class myExp(Function):
@staticmethod
def forward(ctx, i):
result = i.exp()
ctx.save_for_backward(result)
return result
@staticmethod
def backward(ctx, grad_output):
result, = ctx.saved_tensors
return grad_output * result
x = torch.tensor([[1., -1.], [1., 1.]], requires_grad=True)
myexp = myExp.apply
y1 = x**2
y2 = myexp(y1).sum().backward()
x.grad
np.ones(1)
import numpy as np
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
import matplotlib.pyplot as plt
%matplotlib inline
parameters = np.random.rand(3)
shots = 1000
circuit = QuantumCircuit(2, 2)
def add_measurements(circuit):
nr_qubits = circuit.n_qubits
circuit.measure(range(nr_qubits), range(nr_qubits))
return circuit
def add_x_rotation(circuit):
nr_qubits = circuit.n_qubits
for i in range(nr_qubits):
circuit.rx(np.pi/2, i)
return circuit
def add_y_rotation(circuit):
nr_qubits = circuit.n_qubits
for i in range(nr_qubits):
circuit.ry(np.pi/2, i)
return circuit
def execute_job(circuit, shots):
simulator = Aer.get_backend('qasm_simulator')
job = execute(circuit, simulator, shots=shots)
result = job.result()
counts = result.get_counts(circuit)
return counts
def N_qubit_expectation(circuit, shots, measurement='Z'):
if measurement=='Z':
print("Measure in Z")
nr_qubits = circuit.n_qubits
circuit = add_measurements(circuit)
counts = execute_job(circuit, shots)
return N_qubit_expectation_Z(counts, shots, nr_qubits)
if measurement=='X':
print("Measure in X")
nr_qubits = circuit.n_qubits
circuit = add_x_rotation(circuit)
#circuit.h(0)
circuit = add_measurements(circuit)
counts = execute_job(circuit, shots)
return N_qubit_expectation_Z(counts, shots, nr_qubits), circuit
if measurement=='Y':
nr_qubits = circuit.n_qubits
circuit = add_y_rotation(circuit)
circuit = add_measurements(circuit)
counts = execute_job(circuit, shots)
return N_qubit_expectation_Z(counts, shots, nr_qubits)
else:
print("Measurement type not yet defined")
def N_qubit_expectation_Z(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 one_qubit_expectation_Z(counts, shots):
probs = sorted([(i, c/shots) for i, c in counts.items()])
P = np.float64(np.array(probs)[:, 1])
print(P[0], P[1])
return P[0]*1 + P[1]*-1
def one_qubit_error(counts, shots, Z_traget):
return (one_qubit_expectation_Z(counts, shots)- Z_target)**2
def N_qubit_error(counts, shots, nr_qubits, target_array):
return ((N_qubit_expectation_Z(counts, shots, nr_qubits)-target_array)**2).sum()
#circuit = add_measurements(circuit)
#counts = execute_job(circuit, 1000)
expects, circuit = N_qubit_expectation(circuit, shots, measurement="X")
circuit.draw()
print(expects, circuit)
circuit.n_qubits
class QiskitCircuit():
def __init__(self,shots):
self.theta = Parameter('Theta')
self.phi = Parameter('Phi')
self.lam = Parameter('Lambda')
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.u3(self.theta,self.phi,self.lam,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,self.phi,self.lam] = parameters
self.circuit.data[2][0]._params = parameters
return self.circuit
def run(self):
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=100000)
ckt = ctx.QiskitCirc.bind([i[0][0].item(), i[0][1].item(), i[0][2].item()])
exp_value = ctx.QiskitCirc.run()
result = torch.tensor([[exp_value]])
ctx.save_for_backward(result, i)
print(result)
return result
@staticmethod
def backward(ctx, grad_output):
eps = 0.01
forward_tensor, i = ctx.saved_tensors
input_numbers = [i[0][0].item(), i[0][1].item(), i[0][2].item()]
gradient = [0,0,0]
for k in range(len(input_numbers)):
input_eps = input_numbers
input_eps[k] = input_numbers[k] + eps
_ckt = ctx.QiskitCirc.bind(input_eps)
exp_value = ctx.QiskitCirc.run()[0]
result_eps = torch.tensor([[exp_value]])
gradient_result = (exp_value - forward_tensor[0][0].item())
gradient[k] = gradient_result
result = torch.tensor([gradient])
return result.float() * grad_output.float()
# useful additional packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
%matplotlib inline
import numpy as np
import networkx as nx
from qiskit import BasicAer
from qiskit.tools.visualization import plot_histogram
from qiskit.aqua import run_algorithm
from qiskit.aqua.input import EnergyInput
from qiskit.aqua.translators.ising import max_cut, tsp
from qiskit.aqua.algorithms import VQE, ExactEigensolver
from qiskit.aqua.components.optimizers import SPSA
from qiskit.aqua.components.variational_forms import RY
from qiskit.aqua import QuantumInstance
# setup aqua logging
import logging
from qiskit.aqua import set_qiskit_aqua_logging
# Generating a graph of 4 nodes
n=4 # Number of nodes in graph
G=nx.Graph()
G.add_nodes_from(np.arange(0,n,1))
elist=[(0,1,1.0),(0,2,1.0),(0,3,1.0),(1,2,1.0),(2,3,1.0)]
# tuple is (i,j,weight) where (i,j) is the edge
G.add_weighted_edges_from(elist)
colors = ['r' for node in G.nodes()]
pos = nx.spring_layout(G)
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
from docplex.mp.model import Model
from qiskit.aqua.translators.ising import docplex
n=4
w = np.zeros([n,n])
for i in range(n):
for j in range(n):
temp = G.get_edge_data(i,j,default=0)
if temp != 0:
w[i,j] = temp['weight']
print(w)
qubitOp, offset = max_cut.get_max_cut_qubitops(w)
algo_input = EnergyInput(qubitOp)
mdl = Model(name='max_cut')
x = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(n)}
# Object function
max_cut_func = mdl.sum(w[i,j]* x[i] * ( 1 - x[j] ) for i in range(n) for j in range(n))
mdl.maximize(max_cut_func)
# No constraints for Max-Cut problems.
qubitOp_docplex, offset_docplex = docplex.get_qubitops(mdl)
seed = 10598
spsa = SPSA(max_trials=300)
ry = RY(qubitOp.num_qubits, depth=1, entanglement='linear')
vqe = VQE(qubitOp, ry, spsa)
print(vqe.setting)
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed)
parameters = np.random.rand(8)
circuits = vqe.construct_circuit(parameters)
print(circuits[0])
algorithm_cfg = {'name': 'VQE'}
dictio = {'problem': {'name': 'ising'},'algorithm': algorithm_cfg}
vqe.energy_evaluation(parameters)
import torch
import numpy as np
from torchvision import datasets, transforms
batch_size_train = 64
batch_size_test = 1000
learning_rate = 0.01
momentum = 0.5
log_interval = 10
torch.backends.cudnn.enabled = False
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor()])
mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
labels = mnist_trainset.targets #get labels
labels = labels.numpy()
idx1 = np.where(labels == 0) #search all zeros
idx2 = np.where(labels == 1) # search all ones
idx = np.concatenate((idx1[0],idx2[0])) # concatenate their indices
mnist_trainset.targets = labels[idx]
mnist_trainset.data = mnist_trainset.data[idx]
print(mnist_trainset)
train_loader = torch.utils.data.DataLoader(mnist_trainset, batch_size=batch_size_train, shuffle=True)
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
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.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 2)
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.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.softmax(x)
network = Net()
optimizer = optim.SGD(network.parameters(), lr=learning_rate,
momentum=momentum)
epochs = 3
for epoch in range(epochs):
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
output = network(data)
loss = F.nll_loss(output, target)
loss.backward()
optimizer.step()
print(loss)
length = target.shape[0]
print(length)
for i in range(length):
print(target[i], output[i][1])
|
https://github.com/BoschSamuel/QizGloria
|
BoschSamuel
|
# -- coding: utf-8 --
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Function
import time
from matplotlib import pyplot as plt
%matplotlib inline
from tqdm import tqdm
import scipy
from scipy import optimize
from qiskit import QuantumRegister,QuantumCircuit,ClassicalRegister,execute
from qiskit.circuit import Parameter
from qiskit import Aer
import numpy as np
class L2L(nn.Module):
'''
define Learning-2-Learn class with LSTM architecture
'''
def __init__(self, circ_function, num_feats=1, batch_size=16):
# circ_function should be a function which is a pennylane qnode
super().__init__()
self.num_feats = num_feats # rnn_output, qnn input params
self.batch_size = batch_size
# does pennylane support circuits that return multiple measurements?
self.rnn_input_size = 1 # qnn output size
self.function = circ_function
# the target is required
self.target = None
self.hid_cell = None
self.rnn_output = None
self.qnn_output = None
self.lstm = nn.LSTM(
input_size=self.rnn_input_size, hidden_size=self.num_feats, num_layers=1, dropout=0
)
def init_hid_cell(self, seq_len=1):
# concatenate and store all the output tensors here
self.rnn_output = torch.tensor([])
self.qnn_output = torch.zeros(seq_len, self.batch_size, self.rnn_input_size)
hidden = torch.zeros(seq_len, self.batch_size, self.num_feats)
cell = torch.zeros(seq_len, self.batch_size, self.num_feats)
self.hid_cell = (hidden, cell)
def step(self):
ckt = self.function.apply
assert self.hid_cell is not None
x = self.qnn_output[[-1], :, :]
# print(f'RNN input {x.shape}')
rnn_output, self.hid_cell = self.lstm(x, self.hid_cell)
self.rnn_output = torch.cat((self.rnn_output, rnn_output), dim=0) # dims are : (seq_dim, batch_size, feature_size)
# print(f'RNN output: {rnn_output.shape} RNN hist {self.rnn_output.shape}')
assert rnn_output.shape[0] == 1
qnn_output = torch.zeros_like(x)
# # qnode can't handle batching; iterate through the batch one at a time
# for i in range(rnn_output.shape[1]):
# qnn_input_batch_element = rnn_output[0, i, :].unsqueeze_(0)
# qnn_output_batch_element = ckt(qnn_input_batch_element)
# assert qnn_output_batch_element.nelement() == self.rnn_input_size
# qnn_output[0, i, :] = qnn_output_batch_element
#trying with batch
qnn_input_element = rnn_output[0, :, :]
qnn_output_element = ckt(qnn_input_element)
# assert qnn_output_batch_element.nelement() == self.rnn_input_size
qnn_output[0, :, :] = qnn_output_element
# subtract target value so that loss is simply minimized at 0
qnn_output[0,:,:] = qnn_output[0,:,:] - self.target
# print(f'circuit output: {qnn_output.shape}')
self.qnn_output = torch.cat((self.qnn_output, qnn_output), dim=0)
return self.qnn_output
def loss(self, true=None):
# compare the qnn output to the given target ('true')
# print(f'true: {true.shape}, pred: {self.qnn_output.shape}')
if true==None:
true = torch.zeros(self.qnn_output.shape)
assert true.shape == self.qnn_output.shape
return F.mse_loss(self.qnn_output, true)
def numpy_output(self):
return self.qnn_output.detach().numpy().squeeze()
def to_numbers(tensor_list):
num_list = []
for tensor in tensor_list:
num_list += [tensor.item()]
return num_list
class QiskitCircuit():
def __init__(self,shots):
self.theta = Parameter('Theta')
self.phi = Parameter('Phi')
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 = []
for j in range(len(i)):
exp_value.append(ctx.QiskitCirc.run(i[j]))
result = torch.tensor(exp_value)
# print(result)
ctx.save_for_backward(result, i)
return result
@staticmethod
def backward(ctx, grad_output):
eps = np.pi/2
forward_tensor, i = ctx.saved_tensors
gradient = []
for j in range(len(i)):
input_numbers = to_numbers(i[j])
for k in range(len(input_numbers)):
input_eps_plus = input_numbers
input_eps_plus[k] = input_numbers[k] + eps
exp_value_plus = ctx.QiskitCirc.run(torch.tensor(input_eps_plus))[0]
result_eps_plus = torch.tensor([exp_value_plus])
input_eps_minus = input_numbers
input_eps_minus[k] = input_numbers[k] - eps
exp_value_minus = ctx.QiskitCirc.run(torch.tensor(input_eps_minus))[0]
result_eps_minus = torch.tensor([exp_value_minus])
gradient_result = 0.5 * (result_eps_plus - result_eps_minus)
gradient.append(gradient_result)
# print(gradient)
result = torch.tensor(gradient)
# print(result)
return result.float() * grad_output.float()
class L2LRot(L2L):
def init_target(self):
# pick a random number between 0 and 1 as the target expectation value
self.target = (torch.rand(self.batch_size, self.rnn_input_size) - 0.5) * 2
# def circ_function(dev):
# @qml.qnode(dev, interface='torch')
# def circuit(parameters):
# assert len(parameters) == 3
# phi = 2 * np.pi * parameters[:2]
# theta = 2 * np.pi * parameters[-1]
# qml.RX(phi[0], wires=0)
# qml.RZ(phi[1], wires=1)
# qml.CNOT(wires=[0, 1])
# qml.RX(theta, wires=0)
# return qml.expval(qml.PauliZ(0))
# return circuit
circ_function = TorchCircuit
%%time
torch.autograd.set_detect_anomaly(True)
l2l = L2LRot(circ_function, num_feats=1, batch_size=1)
optimizer = optim.Adam(l2l.parameters(), lr=0.1)
num_epoch = 100
num_steps = 10 #25
all_loss = []
for epoch_ind in tqdm(range(num_epoch)):
l2l.zero_grad()
l2l.init_hid_cell()
l2l.init_target()
for i in range(num_steps):
# print(i)
l2l.step()
loss = l2l.loss()
loss.backward()
optimizer.step()
all_loss.append(loss.item())
plt.plot(all_loss)
|
https://github.com/BoschSamuel/QizGloria
|
BoschSamuel
|
# -- coding: utf-8 --
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
from qiskit import *
import numpy as np
import torch
from torch.autograd import Function
class myExp(Function):
@staticmethod
def forward(ctx, i):
result = i.exp()
ctx.save_for_backward(result)
return result
@staticmethod
def backward(ctx, grad_output):
result, = ctx.saved_tensors
return grad_output * result
x = torch.tensor([[1., -1.], [1., 1.]], requires_grad=True)
myexp = myExp.apply
y1 = x**2
y2 = myexp(y1).sum().backward()
x.grad
np.ones(1)
import numpy as np
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
import matplotlib.pyplot as plt
%matplotlib inline
parameters = np.random.rand(3)
shots = 1000
circuit = QuantumCircuit(2, 2)
def add_measurements(circuit):
nr_qubits = circuit.n_qubits
circuit.measure(range(nr_qubits), range(nr_qubits))
return circuit
def add_x_rotation(circuit):
nr_qubits = circuit.n_qubits
for i in range(nr_qubits):
circuit.rx(np.pi/2, i)
return circuit
def add_y_rotation(circuit):
nr_qubits = circuit.n_qubits
for i in range(nr_qubits):
circuit.ry(np.pi/2, i)
return circuit
def execute_job(circuit, shots):
simulator = Aer.get_backend('qasm_simulator')
job = execute(circuit, simulator, shots=shots)
result = job.result()
counts = result.get_counts(circuit)
return counts
def N_qubit_expectation(circuit, shots, measurement='Z'):
if measurement=='Z':
print("Measure in Z")
nr_qubits = circuit.n_qubits
circuit = add_measurements(circuit)
counts = execute_job(circuit, shots)
return N_qubit_expectation_Z(counts, shots, nr_qubits)
if measurement=='X':
print("Measure in X")
nr_qubits = circuit.n_qubits
circuit = add_x_rotation(circuit)
#circuit.h(0)
circuit = add_measurements(circuit)
counts = execute_job(circuit, shots)
return N_qubit_expectation_Z(counts, shots, nr_qubits), circuit
if measurement=='Y':
nr_qubits = circuit.n_qubits
circuit = add_y_rotation(circuit)
circuit = add_measurements(circuit)
counts = execute_job(circuit, shots)
return N_qubit_expectation_Z(counts, shots, nr_qubits)
else:
print("Measurement type not yet defined")
def N_qubit_expectation_Z(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 one_qubit_expectation_Z(counts, shots):
probs = sorted([(i, c/shots) for i, c in counts.items()])
P = np.float64(np.array(probs)[:, 1])
print(P[0], P[1])
return P[0]*1 + P[1]*-1
def one_qubit_error(counts, shots, Z_traget):
return (one_qubit_expectation_Z(counts, shots)- Z_target)**2
def N_qubit_error(counts, shots, nr_qubits, target_array):
return ((N_qubit_expectation_Z(counts, shots, nr_qubits)-target_array)**2).sum()
#circuit = add_measurements(circuit)
#counts = execute_job(circuit, 1000)
expects, circuit = N_qubit_expectation(circuit, shots, measurement="X")
circuit.draw()
print(expects, circuit)
circuit.n_qubits
class QiskitCircuit():
def __init__(self,shots):
self.theta = Parameter('Theta')
self.phi = Parameter('Phi')
self.lam = Parameter('Lambda')
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.u3(self.theta,self.phi,self.lam,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,self.phi,self.lam] = parameters
self.circuit.data[2][0]._params = parameters
return self.circuit
def run(self):
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=100000)
ckt = ctx.QiskitCirc.bind([i[0][0].item(), i[0][1].item(), i[0][2].item()])
exp_value = ctx.QiskitCirc.run()
result = torch.tensor([[exp_value]])
ctx.save_for_backward(result, i)
print(result)
return result
@staticmethod
def backward(ctx, grad_output):
eps = 0.01
forward_tensor, i = ctx.saved_tensors
input_numbers = [i[0][0].item(), i[0][1].item(), i[0][2].item()]
gradient = [0,0,0]
for k in range(len(input_numbers)):
input_eps = input_numbers
input_eps[k] = input_numbers[k] + eps
_ckt = ctx.QiskitCirc.bind(input_eps)
exp_value = ctx.QiskitCirc.run()[0]
result_eps = torch.tensor([[exp_value]])
gradient_result = (exp_value - forward_tensor[0][0].item())
gradient[k] = gradient_result
result = torch.tensor([gradient])
return result.float() * grad_output.float()
# useful additional packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
%matplotlib inline
import numpy as np
import networkx as nx
from qiskit import BasicAer
from qiskit.tools.visualization import plot_histogram
from qiskit.aqua import run_algorithm
from qiskit.aqua.input import EnergyInput
from qiskit.aqua.translators.ising import max_cut, tsp
from qiskit.aqua.algorithms import VQE, ExactEigensolver
from qiskit.aqua.components.optimizers import SPSA
from qiskit.aqua.components.variational_forms import RY
from qiskit.aqua import QuantumInstance
# setup aqua logging
import logging
from qiskit.aqua import set_qiskit_aqua_logging
# Generating a graph of 4 nodes
n=4 # Number of nodes in graph
G=nx.Graph()
G.add_nodes_from(np.arange(0,n,1))
elist=[(0,1,1.0),(0,2,1.0),(0,3,1.0),(1,2,1.0),(2,3,1.0)]
# tuple is (i,j,weight) where (i,j) is the edge
G.add_weighted_edges_from(elist)
colors = ['r' for node in G.nodes()]
pos = nx.spring_layout(G)
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
from docplex.mp.model import Model
from qiskit.aqua.translators.ising import docplex
n=4
w = np.zeros([n,n])
for i in range(n):
for j in range(n):
temp = G.get_edge_data(i,j,default=0)
if temp != 0:
w[i,j] = temp['weight']
print(w)
qubitOp, offset = max_cut.get_max_cut_qubitops(w)
algo_input = EnergyInput(qubitOp)
mdl = Model(name='max_cut')
x = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(n)}
# Object function
max_cut_func = mdl.sum(w[i,j]* x[i] * ( 1 - x[j] ) for i in range(n) for j in range(n))
mdl.maximize(max_cut_func)
# No constraints for Max-Cut problems.
qubitOp_docplex, offset_docplex = docplex.get_qubitops(mdl)
seed = 10598
spsa = SPSA(max_trials=300)
ry = RY(qubitOp.num_qubits, depth=1, entanglement='linear')
vqe = VQE(qubitOp, ry, spsa)
print(vqe.setting)
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed)
parameters = np.random.rand(8)
circuits = vqe.construct_circuit(parameters)
print(circuits[0])
algorithm_cfg = {'name': 'VQE'}
dictio = {'problem': {'name': 'ising'},'algorithm': algorithm_cfg}
vqe.energy_evaluation(parameters)
import torch
import numpy as np
from torchvision import datasets, transforms
batch_size_train = 64
batch_size_test = 1000
learning_rate = 0.01
momentum = 0.5
log_interval = 10
torch.backends.cudnn.enabled = False
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor()])
mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
labels = mnist_trainset.targets #get labels
labels = labels.numpy()
idx1 = np.where(labels == 0) #search all zeros
idx2 = np.where(labels == 1) # search all ones
idx = np.concatenate((idx1[0],idx2[0])) # concatenate their indices
mnist_trainset.targets = labels[idx]
mnist_trainset.data = mnist_trainset.data[idx]
print(mnist_trainset)
train_loader = torch.utils.data.DataLoader(mnist_trainset, batch_size=batch_size_train, shuffle=True)
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
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.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 2)
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.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.softmax(x)
network = Net()
optimizer = optim.SGD(network.parameters(), lr=learning_rate,
momentum=momentum)
epochs = 3
for epoch in range(epochs):
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
output = network(data)
loss = F.nll_loss(output, target)
loss.backward()
optimizer.step()
print(loss)
length = target.shape[0]
print(length)
for i in range(length):
print(target[i], output[i][1])
|
https://github.com/BoschSamuel/QizGloria
|
BoschSamuel
|
# -- coding: utf-8 --
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import torch
from torch.autograd import Function
import torch.optim as optim
from qiskit import QuantumRegister,QuantumCircuit,ClassicalRegister,execute
from qiskit.circuit import Parameter
from qiskit import Aer
import numpy as np
from tqdm import tqdm
from matplotlib import pyplot as plt
%matplotlib inline
def to_numbers(tensor_list):
num_list = []
for tensor in tensor_list:
num_list += [tensor.item()]
return num_list
class QiskitCircuit():
def __init__(self,shots):
self.theta = Parameter('Theta')
self.phi = Parameter('Phi')
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])
ctx.save_for_backward(result, i)
return result
@staticmethod
def backward(ctx, grad_output):
eps = np.pi/2
forward_tensor, i = ctx.saved_tensors
input_numbers = to_numbers(i[0])
gradient = []
for k in range(len(input_numbers)):
input_eps_plus = input_numbers
input_eps_plus[k] = input_numbers[k] + eps
exp_value_plus = ctx.QiskitCirc.run(torch.tensor(input_eps_plus))[0]
result_eps_plus = torch.tensor([exp_value_plus])
input_eps_minus = input_numbers
input_eps_minus[k] = input_numbers[k] - eps
exp_value_minus = ctx.QiskitCirc.run(torch.tensor(input_eps_minus))[0]
result_eps_minus = torch.tensor([exp_value_minus])
gradient_result = 0.5 * (result_eps_plus - result_eps_minus)
gradient.append(gradient_result)
# print(gradient)
result = torch.tensor([gradient])
# print(result)
return result.float() * grad_output.float()
# x = torch.tensor([np.pi/4, np.pi/4, np.pi/4], requires_grad=True)
x = torch.tensor([[0.0]], requires_grad=True)
qc = TorchCircuit.apply
y1 = qc(x)
y1.backward()
print(x.grad)
qc = TorchCircuit.apply
def cost(x):
target = -1
expval = qc(x)
return torch.abs(qc(x) - target) ** 2, expval
x = torch.tensor([[0.0]], requires_grad=True)
opt = torch.optim.Adam([x], lr=0.1)
num_epoch = 50
loss_list = []
expval_list = []
for i in tqdm(range(num_epoch)):
# for i in range(num_epoch):
opt.zero_grad()
loss, expval = cost(x)
loss.backward()
opt.step()
loss_list.append(loss.item())
expval_list.append(expval.item())
# print(loss.item())
plt.plot(loss_list)
# print(circuit(phi, theta))
# print(cost(x))
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import torchvision
from torchvision import datasets, transforms
batch_size_train = 1
batch_size_test = 1
learning_rate = 0.01
momentum = 0.5
log_interval = 10
torch.backends.cudnn.enabled = False
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor()])
mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
labels = mnist_trainset.targets #get labels
labels = labels.numpy()
idx1 = np.where(labels == 0) #search all zeros
idx2 = np.where(labels == 1) # search all ones
n=100
idx = np.concatenate((idx1[0][0:n],idx2[0][0:n])) # concatenate their indices
mnist_trainset.targets = labels[idx]
mnist_trainset.data = mnist_trainset.data[idx]
print(mnist_trainset)
train_loader = torch.utils.data.DataLoader(mnist_trainset, batch_size=batch_size_train, shuffle=True)
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.fc1 = nn.Linear(320, 50)
self.fc2 = 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.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
# return F.softmax(x)
# x = np.pi*F.tanh(x)
# print(x)
x = qc(x)
x = (x+1)/2
x = torch.cat((x, 1-x), -1)
return x
network = Net()
# optimizer = optim.SGD(network.parameters(), lr=learning_rate,
# momentum=momentum)
optimizer = optim.Adam(network.parameters(), lr=learning_rate/10)
epochs = 30
loss_list = []
for epoch in range(epochs):
total_loss = []
target_list = []
for batch_idx, (data, target) in enumerate(train_loader):
target_list.append(target.item())
# print(batch_idx)
optimizer.zero_grad()
output = network(data)
loss = F.nll_loss(output, target)
# loss = F.cross_entropy(output, target)
# print(output)
# print(output[0][1].item(), target.item())
loss.backward()
optimizer.step()
total_loss.append(loss.item())
loss_list.append(sum(total_loss)/len(total_loss))
print(loss_list[-1])
plt.plot(loss_list)
for i in range(len(loss_list)):
loss_list[i] += 1
plt.plot(loss_list)
|
https://github.com/BoschSamuel/QizGloria
|
BoschSamuel
|
# -- coding: utf-8 --
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import torch
from torch.autograd import Function
import torch.optim as optim
from qiskit import QuantumRegister,QuantumCircuit,ClassicalRegister,execute
from qiskit.circuit import Parameter
from qiskit import Aer
import numpy as np
from tqdm import tqdm
from matplotlib import pyplot as plt
%matplotlib inline
def to_numbers(tensor_list):
num_list = []
for tensor in tensor_list:
num_list += [tensor.item()]
return num_list
class QiskitCircuit():
def __init__(self,shots):
self.theta = Parameter('Theta')
self.phi = Parameter('Phi')
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=1000)
exp_value = ctx.QiskitCirc.run(i[0])
result = torch.tensor([exp_value])
ctx.save_for_backward(result, i)
return result
@staticmethod
def backward(ctx, grad_output):
eps = 0.01
forward_tensor, i = ctx.saved_tensors
input_numbers = to_numbers(i[0])
gradient = []
for k in range(len(input_numbers)):
input_eps = input_numbers
input_eps[k] = input_numbers[k] + eps
exp_value = ctx.QiskitCirc.run(torch.tensor(input_eps))[0]
result_eps = torch.tensor([exp_value])
gradient_result = (exp_value - forward_tensor[0][0].item())/eps
gradient.append(gradient_result)
# print(gradient)
result = torch.tensor([gradient])
# print(result)
return result.float() * grad_output.float()
# x = torch.tensor([np.pi/4, np.pi/4, np.pi/4], requires_grad=True)
x = torch.tensor([[0.0]], requires_grad=True)
qc = TorchCircuit.apply
y1 = qc(x)
y1.backward()
print(x.grad)
qc = TorchCircuit.apply
def cost(x):
target = -1
expval = qc(x)
return torch.abs(qc(x) - target) ** 2, expval
x = torch.tensor([[0.0]], requires_grad=True)
opt = torch.optim.Adam([x], lr=0.1)
num_epoch = 50
loss_list = []
expval_list = []
for i in tqdm(range(num_epoch)):
# for i in range(num_epoch):
opt.zero_grad()
loss, expval = cost(x)
loss.backward()
opt.step()
loss_list.append(loss.item())
expval_list.append(expval.item())
# print(loss.item())
plt.plot(loss_list)
# print(circuit(phi, theta))
# print(cost(x))
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import torchvision
from torchvision import datasets, transforms
batch_size_train = 1
batch_size_test = 1
learning_rate = 0.01
momentum = 0.5
log_interval = 10
torch.backends.cudnn.enabled = False
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor()])
mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
labels = mnist_trainset.targets #get labels
labels = labels.numpy()
idx1 = np.where(labels == 0) #search all zeros
idx2 = np.where(labels == 1) # search all ones
n=100
idx = np.concatenate((idx1[0][0:n],idx2[0][0:n])) # concatenate their indices
mnist_trainset.targets = labels[idx]
mnist_trainset.data = mnist_trainset.data[idx]
print(mnist_trainset)
train_loader = torch.utils.data.DataLoader(mnist_trainset, batch_size=batch_size_train, shuffle=True)
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.fc1 = nn.Linear(320, 50)
self.fc2 = 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.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
# return F.softmax(x)
# x = np.pi*F.tanh(x)
# print(x)
x = qc(x)
x = (x+1)/2
x = torch.cat((x, 1-x), -1)
return x
network = Net()
# optimizer = optim.SGD(network.parameters(), lr=learning_rate,
# momentum=momentum)
optimizer = optim.Adam(network.parameters(), lr=learning_rate/10)
epochs = 30
loss_list = []
for epoch in range(epochs):
total_loss = []
target_list = []
for batch_idx, (data, target) in enumerate(train_loader):
target_list.append(target.item())
# print(batch_idx)
optimizer.zero_grad()
output = network(data)
# loss = F.nll_loss(output, target)
loss = F.cross_entropy(output, target)
# print(output)
# print(output[0][1].item(), target.item())
loss.backward()
optimizer.step()
total_loss.append(loss.item())
loss_list.append(sum(total_loss)/len(total_loss))
print(loss_list[-1])
plt.plot(loss_list)
|
https://github.com/BoschSamuel/QizGloria
|
BoschSamuel
|
# -- coding: utf-8 --
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import torch
from torch.autograd import Function
import torch.optim as optim
from qiskit import QuantumRegister,QuantumCircuit,ClassicalRegister,execute
from qiskit.circuit import Parameter
from qiskit import Aer
import numpy as np
from tqdm import tqdm
from matplotlib import pyplot as plt
%matplotlib inline
def to_numbers(tensor_list):
num_list = []
for tensor in tensor_list:
num_list += [tensor.item()]
return num_list
class QiskitCircuit():
def __init__(self,shots):
self.theta = Parameter('Theta')
self.phi = Parameter('Phi')
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.u2(self.theta,self.phi,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,self.phi] = to_numbers(parameters)
self.circuit.data[1][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=10000)
exp_value = ctx.QiskitCirc.run(i[0])
result = torch.tensor([exp_value])
ctx.save_for_backward(result, i)
return result
@staticmethod
def backward(ctx, grad_output):
eps = 0.01
forward_tensor, i = ctx.saved_tensors
input_numbers = to_numbers(i[0])
gradient = [0,0]
for k in range(len(input_numbers)):
input_eps = input_numbers
input_eps[k] = input_numbers[k] + eps
exp_value = ctx.QiskitCirc.run(torch.tensor(input_eps))[0]
result_eps = torch.tensor([exp_value])
gradient_result = (exp_value - forward_tensor[0][0].item())/eps
gradient[k] = gradient_result
# print(gradient)
result = torch.tensor([gradient])
# print(result)
return result.float() * grad_output.float()
# x = torch.tensor([np.pi/4, np.pi/4, np.pi/4], requires_grad=True)
x = torch.tensor([[0.0, 0.0]], requires_grad=True)
qc = TorchCircuit.apply
y1 = qc(x)
y1.backward()
print(x.grad)
qc = TorchCircuit.apply
def cost(x):
target = -1
expval = qc(x)
return torch.abs(qc(x) - target) ** 2, expval
x = torch.tensor([[0.0, np.pi/4]], requires_grad=True)
opt = torch.optim.Adam([x], lr=0.1)
num_epoch = 100
loss_list = []
expval_list = []
for i in tqdm(range(num_epoch)):
# for i in range(num_epoch):
opt.zero_grad()
loss, expval = cost(x)
loss.backward()
opt.step()
loss_list.append(loss.item())
expval_list.append(expval.item())
# print(loss.item())
plt.plot(loss_list)
# print(circuit(phi, theta))
# print(cost(x))
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import torchvision
from torchvision import datasets, transforms
batch_size_train = 1
batch_size_test = 1
learning_rate = 0.01
momentum = 0.5
log_interval = 10
torch.backends.cudnn.enabled = False
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor()])
mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
labels = mnist_trainset.targets #get labels
labels = labels.numpy()
idx1 = np.where(labels == 0) #search all zeros
idx2 = np.where(labels == 1) # search all ones
idx = np.concatenate((idx1[0][0:100],idx2[0][0:100])) # concatenate their indices
mnist_trainset.targets = labels[idx]
mnist_trainset.data = mnist_trainset.data[idx]
print(mnist_trainset)
train_loader = torch.utils.data.DataLoader(mnist_trainset, batch_size=batch_size_train, shuffle=True)
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.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 2)
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.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
# return F.softmax(x)
# x = np.pi*F.tanh(x)
# print(x)
x = qc(x)
x = (x+1)/2
x = torch.cat((x, 1-x), -1)
return x
network = Net()
# optimizer = optim.SGD(network.parameters(), lr=learning_rate,
# momentum=momentum)
optimizer = optim.Adam(network.parameters(), lr=learning_rate/10)
epochs = 10
loss_list = []
for epoch in range(epochs):
total_loss = []
target_list = []
for batch_idx, (data, target) in enumerate(train_loader):
target_list.append(target.item())
# print(batch_idx)
optimizer.zero_grad()
output = network(data)
# loss = F.nll_loss(output, target)
loss = F.cross_entropy(output, target)
# print(output)
# print(output[0][1].item(), target.item())
loss.backward()
optimizer.step()
total_loss.append(loss.item())
loss_list.append(sum(total_loss)/len(total_loss))
print(loss_list[-1])
plt.plot(loss_list)
|
https://github.com/BoschSamuel/QizGloria
|
BoschSamuel
|
# -- coding: utf-8 --
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import torch
from torch.autograd import Function
import torch.optim as optim
from qiskit import QuantumRegister,QuantumCircuit,ClassicalRegister,execute
from qiskit.circuit import Parameter
from qiskit import Aer
import numpy as np
from tqdm import tqdm
from matplotlib import pyplot as plt
%matplotlib inline
np.random.seed = 42
def to_numbers(tensor_list):
num_list = []
for tensor in tensor_list:
num_list += [tensor.item()]
return num_list
class QiskitCircuit():
def __init__(self,shots):
self.theta = Parameter('Theta')
self.phi = Parameter('Phi')
self.lam = Parameter('Lambda')
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.u3(self.theta,self.phi,self.lam,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,self.phi,self.lam] = 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=10000)
exp_value = ctx.QiskitCirc.run(i[0])
result = torch.tensor([exp_value])
ctx.save_for_backward(result, i)
return result
@staticmethod
def backward(ctx, grad_output):
eps = 0.01
forward_tensor, i = ctx.saved_tensors
input_numbers = to_numbers(i[0])
gradient = [0,0,0]
for k in range(len(input_numbers)):
input_eps = input_numbers
input_eps[k] = input_numbers[k] + eps
exp_value = ctx.QiskitCirc.run(torch.tensor(input_eps))[0]
result_eps = torch.tensor([exp_value])
gradient_result = (exp_value - forward_tensor[0][0].item())#/eps
gradient[k] = gradient_result
# print(gradient)
result = torch.tensor([gradient])
# print(result)
return result.float() * grad_output.float()
# x = torch.tensor([np.pi/4, np.pi/4, np.pi/4], requires_grad=True)
x = torch.tensor([[0.0, 0.0, 0.0]], requires_grad=True)
qc = TorchCircuit.apply
y1 = qc(x)
y1.backward()
print(x.grad)
qc = TorchCircuit.apply
def cost(x):
target = -1
expval = qc(x)
return torch.abs(qc(x) - target) ** 2, expval
x = torch.tensor([[np.pi/4, np.pi/4, np.pi/4]], requires_grad=True)
opt = torch.optim.Adam([x], lr=0.1)
num_epoch = 100
loss_list = []
expval_list = []
for i in tqdm(range(num_epoch)):
# for i in range(num_epoch):
opt.zero_grad()
loss, expval = cost(x)
loss.backward()
opt.step()
loss_list.append(loss.item())
expval_list.append(expval.item())
# print(loss.item())
plt.plot(loss_list)
# print(circuit(phi, theta))
# print(cost(x))
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import torchvision
from torchvision import datasets, transforms
batch_size_train = 1
batch_size_test = 1
learning_rate = 0.01
momentum = 0.5
log_interval = 10
torch.backends.cudnn.enabled = False
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor()])
mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
labels = mnist_trainset.targets #get labels
labels = labels.numpy()
idx1 = np.where(labels == 0) #search all zeros
idx2 = np.where(labels == 1) # search all ones
idx = np.concatenate((idx1[0][0:20],idx2[0][0:20])) # concatenate their indices
mnist_trainset.targets = labels[idx]
mnist_trainset.data = mnist_trainset.data[idx]
print(mnist_trainset)
train_loader = torch.utils.data.DataLoader(mnist_trainset, batch_size=batch_size_train, shuffle=True)
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.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 3)
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.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
# return F.softmax(x)
x = np.pi*F.tanh(x)
x = qc(x) # This is the q node
x = (x+1)/2 # Translate expectation values [-1,1] to labels [0,1]
x = torch.cat((x, 1-x), -1)
return x
network = Net()
optimizer = optim.SGD(network.parameters(), lr=learning_rate,
momentum=momentum)
# optimizer = optim.Adam(network.parameters(), lr=learning_rate)
epochs = 10
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
# print(batch_idx)
optimizer.zero_grad()
output = network(data)
loss = F.nll_loss(output, target)
# loss = F.cross_entropy(output, target)
# print(output)
# print(output[0][1].item(), target.item())
loss.backward()
optimizer.step()
total_loss.append(loss.item())
print(loss.item())
accuracy = 0
number = 0
for batch_idx, (data, target) in enumerate(train_loader):
number +=1
output = network(data)
output = (output>0.5).float()
accuracy += (output[0][1].item() == target[0].item())*1
print("Accuracy is: {}".format(accuracy/number))
|
https://github.com/BoschSamuel/QizGloria
|
BoschSamuel
|
# -- coding: utf-8 --
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import torch
from torch.autograd import Function
import torch.optim as optim
from qiskit import QuantumRegister,QuantumCircuit,ClassicalRegister,execute
from qiskit.circuit import Parameter
from qiskit import Aer
import numpy as np
from tqdm import tqdm
from matplotlib import pyplot as plt
%matplotlib inline
np.random.seed = 42
def to_numbers(tensor_list):
num_list = []
for tensor in tensor_list:
num_list += [tensor.item()]
return num_list
class QiskitCircuit():
def __init__(self,shots):
self.theta = Parameter('Theta')
self.phi = Parameter('Phi')
self.lam = Parameter('Lambda')
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.u3(self.theta,self.phi,self.lam,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,self.phi,self.lam] = 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=10000)
exp_value = ctx.QiskitCirc.run(i[0])
result = torch.tensor([exp_value])
ctx.save_for_backward(result, i)
return result
@staticmethod
def backward(ctx, grad_output):
eps = 0.01
forward_tensor, i = ctx.saved_tensors
input_numbers = to_numbers(i[0])
gradient = [0,0,0]
for k in range(len(input_numbers)):
input_eps = input_numbers
input_eps[k] = input_numbers[k] + eps
exp_value = ctx.QiskitCirc.run(torch.tensor(input_eps))[0]
result_eps = torch.tensor([exp_value])
gradient_result = (exp_value - forward_tensor[0][0].item())/eps
gradient[k] = gradient_result
# print(gradient)
result = torch.tensor([gradient])
# print(result)
return result.float() * grad_output.float()
torch.manual_seed(42)
# x = torch.tensor([np.pi/4, np.pi/4, np.pi/4], requires_grad=True)
x = torch.tensor([[0.0, 0.0, 0.0]], requires_grad=True)
qc = TorchCircuit.apply
y1 = qc(x)
y1.backward()
print(x.grad)
qc = TorchCircuit.apply
def cost(x):
target = -1
expval = qc(x)
return torch.abs(qc(x) - target) ** 2, expval
x = torch.tensor([[np.pi/4, np.pi/4, np.pi/4]], requires_grad=True)
opt = torch.optim.Adam([x], lr=0.1)
num_epoch = 100
loss_list = []
expval_list = []
for i in tqdm(range(num_epoch)):
# for i in range(num_epoch):
opt.zero_grad()
loss, expval = cost(x)
loss.backward()
opt.step()
loss_list.append(loss.item())
expval_list.append(expval.item())
# print(loss.item())
plt.plot(loss_list)
# print(circuit(phi, theta))
# print(cost(x))
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import torchvision
from torchvision import datasets, transforms
batch_size_train = 1
batch_size_test = 1
learning_rate = 0.01
momentum = 0.5
log_interval = 10
torch.backends.cudnn.enabled = False
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor()])
mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
labels = mnist_trainset.targets #get labels
labels = labels.numpy()
idx1 = np.where(labels == 0) #search all zeros
idx2 = np.where(labels == 1) # search all ones
idx = np.concatenate((idx1[0][0:10],idx2[0][0:10])) # concatenate their indices
mnist_trainset.targets = labels[idx]
mnist_trainset.data = mnist_trainset.data[idx]
print(mnist_trainset)
train_loader = torch.utils.data.DataLoader(mnist_trainset, batch_size=batch_size_train, shuffle=True)
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.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 3)
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.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
# x = np.pi*F.tanh(x)
print(x)
x = qc(x)
# print(x)
x = (x+1)/2
x = torch.cat((x, 1-x), -1)
return x
# return F.softmax(x)
network = Net()
optimizer = optim.SGD(network.parameters(), lr=learning_rate,
momentum=momentum)
epochs = 100
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
# print(batch_idx)
optimizer.zero_grad()
output = network(data)
loss = F.nll_loss(output, target)
# print(output)
# print(output[0][1].item(), target.item())
loss.backward()
optimizer.step()
total_loss.append(loss.item())
print(sum(total_loss)/len(total_loss))
|
https://github.com/BoschSamuel/QizGloria
|
BoschSamuel
|
# -- coding: utf-8 --
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import torch
from torch.autograd import Function
import torch.optim as optim
from qiskit import QuantumRegister,QuantumCircuit,ClassicalRegister,execute
from qiskit.circuit import Parameter
from qiskit import Aer
import numpy as np
from tqdm import tqdm
from matplotlib import pyplot as plt
from torch.autograd import Function
%matplotlib inline
np.random.seed = 42
def to_numbers(tensor_list):
num_list = []
for tensor in tensor_list:
num_list += [tensor.item()]
return num_list
class QiskitCircuit_QAOA():
def __init__(self,shots):
self.beta = Parameter('Beta')
self.gamma = Parameter('Gamma')
self.shots = shots
def create_circuit():
ckt = QuantumCircuit(2, 2)
# add mixer part
ckt.rx(self.beta, 0)
ckt.rx(self.beta, 1)
# add H_target part, for each Zi Zj do this
ckt.cx(0,1)
ckt.rz(-1*self.gamma, 1)
ckt.cx(0,1)
ckt.measure([0,1],[0,1])
return ckt
self.circuit = create_circuit()
def energy_expectation(self, counts, shots, i,j, Cij=-1): #calculate expectation for one qubit pair
expects = 0
#print(counts)
for key in counts.keys():
perc = counts[key]/shots
check = Cij*(float(key[i])-1/2)*(float(key[j])-1/2)*perc
expects += check
return [expects]
def bind(self,parameters):
[self.beta,self.gamma] = parameters
#print(self.circuit.data)
self.circuit.data[0][0]._params = to_numbers(parameters)[0:1]
self.circuit.data[1][0]._params = to_numbers(parameters)[0:1]
self.circuit.data[3][0]._params = to_numbers(parameters)[1:2]
return self.circuit
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)
#print(counts)
return self.energy_expectation(counts, self.shots, 0,1)
class TorchCircuit(Function):
@staticmethod
def forward(ctx, i):
if not hasattr(ctx, 'QiskitCirc'):
ctx.QiskitCirc = QiskitCircuit_QAOA(shots=10000)
#print(i[0])
exp_value = ctx.QiskitCirc.run(i[0])
result = torch.tensor([exp_value])
ctx.save_for_backward(result, i)
return result
@staticmethod
def backward(ctx, grad_output):
eps = 0.01
forward_tensor, i = ctx.saved_tensors
input_numbers = to_numbers(i[0])
gradient = []
for k in range(len(input_numbers)):
input_eps = input_numbers
input_eps[k] = input_numbers[k] + eps
exp_value = ctx.QiskitCirc.run(torch.tensor(input_eps))[0]
result_eps = torch.tensor([exp_value])
gradient_result = (exp_value - forward_tensor[0][0].item())/eps
gradient.append(gradient_result)
# print(gradient)
result = torch.tensor([gradient])
# print(result)
#print("test tens size", result.float(), grad_output.float())
return result.float() * grad_output.float()
torch.manual_seed(42)
# x = torch.tensor([np.pi/4, np.pi/4, np.pi/4], requires_grad=True)
x = torch.tensor([[0.3, 0.2]], requires_grad=True)
qc = TorchCircuit.apply
y1 = qc(x)
print(y1)
y1.backward()
print(x.grad)
qc = TorchCircuit.apply
def cost(x):
target = -0.25
expval = qc(x)
return torch.abs(qc(x).sum() - target) ** 2, expval
x = torch.tensor([[np.pi/4, np.pi/4]], requires_grad=True)
opt = torch.optim.Adam([x], lr=0.1)
num_epoch = 100
loss_list = []
expval_list = []
for i in tqdm(range(num_epoch)):
# for i in range(num_epoch):
opt.zero_grad()
loss, expval = cost(x)
loss.backward()
opt.step()
loss_list.append(loss.item())
expval_list.append(expval.item())
# print(loss.item())
plt.plot(loss_list)
# print(circuit(phi, theta))
# print(cost(x))
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import torchvision
from torchvision import datasets, transforms
batch_size_train = 1
batch_size_test = 1
learning_rate = 0.01
momentum = 0.5
log_interval = 10
torch.backends.cudnn.enabled = False
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor()])
mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
labels = mnist_trainset.targets #get labels
labels = labels.numpy()
idx1 = np.where(labels == 0) #search all zeros
idx2 = np.where(labels == 1) # search all ones
idx = np.concatenate((idx1[0][0:10],idx2[0][0:10])) # concatenate their indices
#idx = idx2
mnist_trainset.targets = labels[idx]
mnist_trainset.data = mnist_trainset.data[idx]
print(mnist_trainset)
train_loader = torch.utils.data.DataLoader(mnist_trainset, batch_size=batch_size_train, shuffle=True)
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.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 6)
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.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
#x = np.pi*F.tanh(x)
#print(x)
x = qc(x)
# print(x)
x = (x+1)/4
x = torch.cat((x, 1-x), -1)
return x
# return F.softmax(x)
network = Net()
optimizer = optim.SGD(network.parameters(), lr=learning_rate,
momentum=momentum)
epochs = 100
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
# print(batch_idx)
optimizer.zero_grad()
output = network(data)
print(output[0].data, target)
loss = F.nll_loss(output, target)
# print(output)
# print(output[0][1].item(), target.item())
#print(loss)
loss.backward()
optimizer.step()
total_loss.append(loss.item())
print(sum(total_loss)/len(total_loss))
|
https://github.com/BoschSamuel/QizGloria
|
BoschSamuel
|
# -- coding: utf-8 --
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# -- coding: utf-8 --
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import torch
from torch.autograd import Function
import torch.optim as optim
from qiskit import QuantumRegister,QuantumCircuit,ClassicalRegister,execute
from qiskit.circuit import Parameter
from qiskit import Aer
import numpy as np
from tqdm import tqdm
from matplotlib import pyplot as plt
from torch.autograd import Function
%matplotlib inline
np.random.seed = 42
def to_numbers(tensor_list):
num_list = []
for tensor in tensor_list:
num_list += [tensor.item()]
return num_list
class QiskitCircuit_QAOA():
def __init__(self,shots):
self.beta = Parameter('Beta')
self.gamma = Parameter('Gamma')
self.delta = Parameter('Delta')
self.beta2 = Parameter('Beta2')
self.delta2 = Parameter('Delta2')
self.shots = shots
def create_circuit():
ckt = QuantumCircuit(2, 2)
# add mixer part
ckt.rx(self.beta, 0)
ckt.rx(self.beta2, 1)
# add H_target part, for each Zi Zj do this
ckt.cx(0,1)
ckt.rz(-1*self.gamma, 1)
ckt.cx(0,1)
ckt.ry(self.delta, 0)
ckt.ry(self.delta2, 1)
ckt.measure([0,1],[0,1])
return ckt
self.circuit = create_circuit()
def expectation(self, counts, shots, nr_qubits): #calculate expectation for one qubit pair
expects = 0
#print(counts)
for key in counts.keys():
perc = counts[key]/shots
#check = Cij*((float(key[i])-1/2)+(float(key[j])-1/2))*perc
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.beta, self.beta2, self.gamma, self.delta, self.delta2] = parameters
#print(self.circuit.data)
self.circuit.data[0][0]._params = to_numbers(parameters)[0:1]
self.circuit.data[1][0]._params = to_numbers(parameters)[1:2]
self.circuit.data[3][0]._params = to_numbers(parameters)[2:3]
self.circuit.data[5][0]._params = to_numbers(parameters)[3:4]
self.circuit.data[6][0]._params = to_numbers(parameters)[4:5]
return self.circuit
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)
#print(counts)
return self.expectation(counts, self.shots, 2)
class TorchCircuit(Function):
@staticmethod
def forward(ctx, i):
if not hasattr(ctx, 'QiskitCirc'):
ctx.QiskitCirc = QiskitCircuit_QAOA(shots=10000)
#print(i[0])
exp_value = ctx.QiskitCirc.run(i[0])
result = torch.tensor([exp_value])
ctx.save_for_backward(result, i)
return result
@staticmethod
def backward(ctx, grad_output):
eps = 0.01
forward_tensor, i = ctx.saved_tensors
input_numbers = to_numbers(i[0])
gradient = []
for k in range(len(input_numbers)):
input_eps = input_numbers
input_eps[k] = input_numbers[k] + eps
exp_value = ctx.QiskitCirc.run(torch.tensor(input_eps))
result_eps = torch.tensor([exp_value])
gradient_result = (exp_value - forward_tensor[0][0].item())/eps
gradient.append(gradient_result)
# print(gradient)
result = torch.tensor([gradient])
#print(grad_output.shape)
#print(result.shape)
#print(torch.einsum('abc,ac->ab',result.float(),grad_output.float()))
#print("test tens size", result.float(), grad_output.float())
return torch.einsum('abc,ac->ab',result.float(),grad_output.float())#result.float() * grad_output.float()
torch.manual_seed(42)
# x = torch.tensor([np.pi/4, np.pi/4, np.pi/4], requires_grad=True)
x = torch.tensor([[0.3, 0.2, 0.1, 0.1, 0.2]], requires_grad=True)
qc = TorchCircuit.apply
y1 = qc(x)
print(y1)
y1 = torch.abs(y1[0] - 1.0) ** 2
y1.backward()
qc = TorchCircuit.apply
def cost(x):
target = 0.25
expval = qc(x)
return torch.abs(qc(x).sum() - target) ** 2, expval
x = torch.tensor([[np.pi/4, np.pi/4, 1.0, 0.5, 0.1]], requires_grad=True)
opt = torch.optim.Adam([x], lr=0.1)
num_epoch = 100
loss_list = []
expval_list = []
for i in tqdm(range(num_epoch)):
# for i in range(num_epoch):
opt.zero_grad()
loss, expval = cost(x)
loss.backward()
opt.step()
loss_list.append(loss.item())
# print(loss.item())
plt.plot(loss_list)
# print(circuit(phi, theta))
# print(cost(x))
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import torchvision
from torchvision import datasets, transforms
batch_size_train = 1
batch_size_test = 1
learning_rate = 0.01
momentum = 0.5
log_interval = 10
torch.backends.cudnn.enabled = False
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor()])
mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
labels = mnist_trainset.targets #get labels
labels = labels.numpy()
idx1 = np.where(labels == 0) #search all zeros
idx2 = np.where(labels == 1) # search all ones
idx = np.concatenate((idx1[0][0:10],idx2[0][0:10])) # concatenate their indices
#idx = idx2
mnist_trainset.targets = labels[idx]
mnist_trainset.data = mnist_trainset.data[idx]
print(mnist_trainset)
train_loader = torch.utils.data.DataLoader(mnist_trainset, batch_size=batch_size_train, shuffle=True)
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.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 5)
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.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
#x = np.pi*F.tanh(x)
#print(x)
x = qc(x)
x = (x+1)/2
# print(x)
#x = torch.cat((x, 1-x), -1)
# return x
return F.softmax(x)
network = Net()
optimizer = optim.SGD(network.parameters(), lr=learning_rate,
momentum=momentum)
epochs = 100
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
# print(batch_idx)
optimizer.zero_grad()
#print(data)
output = network(data)
print(output[0].data, target)
loss = F.nll_loss(output, target)
# print(output)
# print(output[0][1].item(), target.item())
#print(loss)
loss.backward()
optimizer.step()
total_loss.append(loss.item())
print(sum(total_loss)/len(total_loss))
|
https://github.com/BoschSamuel/QizGloria
|
BoschSamuel
|
# -- coding: utf-8 --
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import torch
from torch.autograd import Function
import torch.optim as optim
from qiskit import QuantumRegister,QuantumCircuit,ClassicalRegister,execute
from qiskit.circuit import Parameter
from qiskit import Aer
import numpy as np
from tqdm import tqdm
from matplotlib import pyplot as plt
%matplotlib inline
np.random.seed = 42
def to_numbers(tensor_list):
num_list = []
for tensor in tensor_list:
num_list += [tensor.item()]
return num_list
class QiskitCircuit():
def __init__(self,shots):
self.theta = Parameter('Theta')
self.phi = Parameter('Phi')
self.lam = Parameter('Lambda')
self.theta2 = Parameter('Theta2')
self.phi2 = Parameter('Phi2')
self.lam2 = Parameter('Lambda2')
self.shots = shots
def create_circuit():
qr = QuantumRegister(2,'q')
cr = ClassicalRegister(2,'c')
ckt = QuantumCircuit(qr,cr)
ckt.h(qr[0])
ckt.h(qr[1])
ckt.cx(0,1)
ckt.barrier()
ckt.u3(self.theta,self.phi,self.lam,qr[0])
ckt.u3(self.theta2,self.phi2,self.lam2,qr[1])
ckt.barrier()
ckt.cx(1,0)
ckt.measure(qr,cr)
return ckt
self.circuit = create_circuit()
def N_qubit_expectation_Z(self,counts, shots, nr_qubits):
expects = 0
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)])
check = (float(key[0])-1/2)*2*(float(key[1])-1/2)*2*perc
expects += check
return [expects]
def bind(self, parameters):
#print(to_numbers(parameters))
[self.theta,self.phi,self.lam] = to_numbers(parameters)[0:3]
[self.theta2,self.phi2,self.lam2] = to_numbers(parameters)[3:6]
self.circuit.data[4][0]._params = to_numbers(parameters)[0:3]
self.circuit.data[5][0]._params = to_numbers(parameters)[3:6]
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,2)
class TorchCircuit(Function):
@staticmethod
def forward(ctx, i):
if not hasattr(ctx, 'QiskitCirc'):
ctx.QiskitCirc = QiskitCircuit(shots=10000)
exp_value = ctx.QiskitCirc.run(i[0])
result = torch.tensor([exp_value])
ctx.save_for_backward(result, i)
#print(result)
return result
@staticmethod
def backward(ctx, grad_output):
eps = 0.01
forward_tensor, i = ctx.saved_tensors
input_numbers = to_numbers(i[0])
gradient = []
for k in range(len(input_numbers)):
input_eps = input_numbers
input_eps[k] = input_numbers[k] + eps
exp_value = ctx.QiskitCirc.run(torch.tensor(input_eps))[0]
result_eps = torch.tensor([exp_value])
gradient_result = (exp_value - forward_tensor[0][0].item())/eps
gradient.append(gradient_result)
# print(gradient)
result = torch.tensor([gradient])
# print(result)
#print("test tens size", result.float(), grad_output.float())
return result.float() * grad_output.float()
torch.manual_seed(42)
# x = torch.tensor([np.pi/4, np.pi/4, np.pi/4], requires_grad=True)
x = torch.tensor([[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]], requires_grad=True)
qc = TorchCircuit.apply
y1 = qc(x)
print(y1)
y1.backward()
print(x.grad)
qc = TorchCircuit.apply
def cost(x):
target = -1
expval = qc(x)
return torch.abs(qc(x).sum() - target) ** 2, expval
x = torch.tensor([[np.pi/4, np.pi/4, np.pi/4, np.pi/4, np.pi/4, np.pi/4]], requires_grad=True)
opt = torch.optim.Adam([x], lr=0.1)
num_epoch = 100
loss_list = []
expval_list = []
for i in tqdm(range(num_epoch)):
# for i in range(num_epoch):
opt.zero_grad()
loss, expval = cost(x)
loss.backward()
opt.step()
loss_list.append(loss.item())
expval_list.append(expval.item())
# print(loss.item())
plt.plot(loss_list)
# print(circuit(phi, theta))
# print(cost(x))
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import torchvision
from torchvision import datasets, transforms
batch_size_train = 1
batch_size_test = 1
learning_rate = 0.01
momentum = 0.5
log_interval = 10
torch.backends.cudnn.enabled = False
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor()])
mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
labels = mnist_trainset.targets #get labels
labels = labels.numpy()
idx1 = np.where(labels == 0) #search all zeros
idx2 = np.where(labels == 1) # search all ones
idx = np.concatenate((idx1[0][0:10],idx2[0][0:10])) # concatenate their indices
#idx = idx2
mnist_trainset.targets = labels[idx]
mnist_trainset.data = mnist_trainset.data[idx]
print(mnist_trainset)
train_loader = torch.utils.data.DataLoader(mnist_trainset, batch_size=batch_size_train, shuffle=True)
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.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 6)
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.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
#x = np.pi*F.tanh(x)
#print(x)
x = qc(x)
# print(x)
x = (x+1)/4
x = torch.cat((x, 1-x), -1)
return x
# return F.softmax(x)
network = Net()
optimizer = optim.SGD(network.parameters(), lr=learning_rate,
momentum=momentum)
epochs = 100
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
# print(batch_idx)
optimizer.zero_grad()
output = network(data)
print(output[0].data, target)
loss = F.nll_loss(output, target)
# print(output)
# print(output[0][1].item(), target.item())
#print(loss)
loss.backward()
optimizer.step()
total_loss.append(loss.item())
print(sum(total_loss)/len(total_loss))
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
import qiskit
from qiskit import IBMQ # requires qiskit version >= 0.6
IBMQ.save_account("MY_TOKEN")
IBMQ.load_accounts()
for backend in IBMQ.backends():
print(backend)
backend_0 = IBMQ.backends()[0] # retrieve the Backend at index 0
print(backend_0.configuration())
print("Go check its specification at %s" % backend_0.configuration()["url"])
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
from qiskit import ClassicalRegister
# Create a Classical Register with 2 bits.
c = ClassicalRegister(2)
from qiskit import QuantumRegister
# Create a Quantum Register with 2 qubits.
q = QuantumRegister(2)
from qiskit import QuantumCircuit
# Create a Quantum Circuit
qc = QuantumCircuit(q, c)
# perform a measurement of our qubits into our bits
qc.measure(q, c); # ; hides the output
# Jupyter command to activate matplotlib and allow the preview of our circuit
%matplotlib inline
from qiskit.tools.visualization import matplotlib_circuit_drawer as draw
draw(qc) # visualize quantum circuit
# Try both and use the one you like best
from qiskit.tools.visualization import circuit_drawer as draw2
draw2(qc) # visualize quantum circuit
# if you want to save it to a file
from qiskit.tools.visualization import circuit_drawer
diagram = circuit_drawer(qc, filename="my_first_quantum_circuit.png")
diagram.show() # or even open it on an external program (no need to save first)
# get the QASM representation of our circuit
print(qc.qasm())
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
# Choose the drawer you like best:
from qiskit.tools.visualization import matplotlib_circuit_drawer as draw
#from qiskit.tools.visualization import circuit_drawer as draw
from qiskit import IBMQ
IBMQ.load_accounts() # make sure you have setup your token locally to use this
%matplotlib inline
import matplotlib.pyplot as plt
def show_results(D):
# D is a dictionary with classical bits as keys and count as value
# example: D = {'000': 497, '001': 527}
plt.bar(range(len(D)), list(D.values()), align='center')
plt.xticks(range(len(D)), list(D.keys()))
plt.show()
from qiskit import Aer
# See a list of available local simulators
print("Aer backends: ", Aer.backends())
# see a list of available remote backends (these are freely given by IBM)
print("IBMQ Backends: ", IBMQ.backends())
# execute circuit and either display a histogram of the results
def execute_locally(qc, draw_circuit=False):
# Compile and run the Quantum circuit on a simulator backend
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend_sim)
result_sim = job_sim.result()
result_counts = result_sim.get_counts(qc)
# Print the results
print("simulation: ", result_sim, result_counts)
if draw_circuit: # draw the circuit
draw(qc)
else: # or show the results
show_results(result_counts)
from qiskit.backends.ibmq import least_busy
import time
# Compile and run on a real device backend
def execute_remotely(qc, draw_circuit=False):
if draw_circuit: # draw the circuit
draw(qc)
try:
# select least busy available device and execute.
least_busy_device = least_busy(IBMQ.backends(simulator=False))
print("Running on current least busy device: ", least_busy_device)
# running the job
job_exp = execute(qc, backend=least_busy_device, shots=1024, max_credits=10)
lapse, interval = 0, 10
while job_exp.status().name != 'DONE':
print('Status @ {} seconds'.format(interval * lapse))
print(job_exp.status())
time.sleep(interval)
lapse += 1
print(job_exp.status())
exp_result = job_exp.result()
result_counts = exp_result.get_counts(qc)
# Show the results
print("experiment: ", exp_result, result_counts)
if not draw_circuit: # show the results
show_results(result_counts)
except:
print("All devices are currently unavailable.")
def new_circuit(size):
# Create a Quantum Register with size qubits
qr = QuantumRegister(size)
# Create a Classical Register with size bits
cr = ClassicalRegister(size)
# Create a Quantum Circuit acting on the qr and cr register
return qr, cr, QuantumCircuit(qr, cr)
# H gate on qubit 0
# measure the specific qubit
# H gate on qubit 1
# measure the specific qubit
# CNOT gate
# measure the specific qubit
# H gate on 2 qubits
# CNOT gate
# measure
# measure
# execute_remotely(circuit)
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
# Choose the drawer you like best:
from qiskit.tools.visualization import matplotlib_circuit_drawer as draw
#from qiskit.tools.visualization import circuit_drawer as draw
from qiskit import IBMQ
IBMQ.load_accounts() # make sure you have setup your token locally to use this
%matplotlib inline
import matplotlib.pyplot as plt
def show_results(D):
# D is a dictionary with classical bits as keys and count as value
# example: D = {'000': 497, '001': 527}
plt.bar(range(len(D)), list(D.values()), align='center')
plt.xticks(range(len(D)), list(D.keys()))
plt.show()
from qiskit import Aer
# See a list of available local simulators
print("Aer backends: ", Aer.backends())
# see a list of available remote backends (these are freely given by IBM)
print("IBMQ Backends: ", IBMQ.backends())
# execute circuit and either display a histogram of the results
def execute_locally(qc, draw_circuit=False):
# Compile and run the Quantum circuit on a simulator backend
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend_sim)
result_sim = job_sim.result()
result_counts = result_sim.get_counts(qc)
# Print the results
print("simulation: ", result_sim, result_counts)
if draw_circuit: # draw the circuit
draw(qc)
else: # or show the results
show_results(result_counts)
from qiskit.backends.ibmq import least_busy
import time
# Compile and run on a real device backend
def execute_remotely(qc, draw_circuit=False):
if draw_circuit: # draw the circuit
draw(qc)
try:
# select least busy available device and execute.
least_busy_device = least_busy(IBMQ.backends(simulator=False))
print("Running on current least busy device: ", least_busy_device)
# running the job
job_exp = execute(qc, backend=least_busy_device, shots=1024, max_credits=10)
lapse, interval = 0, 10
while job_exp.status().name != 'DONE':
print('Status @ {} seconds'.format(interval * lapse))
print(job_exp.status())
time.sleep(interval)
lapse += 1
print(job_exp.status())
exp_result = job_exp.result()
result_counts = exp_result.get_counts(qc)
# Show the results
print("experiment: ", exp_result, result_counts)
if not draw_circuit: # show the results
show_results(result_counts)
except:
print("All devices are currently unavailable.")
def new_circuit(size):
# Create a Quantum Register with size qubits
qr = QuantumRegister(size)
# Create a Classical Register with size bits
cr = ClassicalRegister(size)
# Create a Quantum Circuit acting on the qr and cr register
return qr, cr, QuantumCircuit(qr, cr)
qr, cr, circuit = new_circuit(2)
# H gate on qubit 0
circuit.h(qr[0]);
# measure the specific qubit
circuit.measure(qr[0], cr[0]); # ; hides the output
# Try both commands:
execute_locally(circuit,draw_circuit=True)
# execute_locally(circuit,draw_circuit=False)
qr, cr, circuit = new_circuit(2)
# H gate on qubit 1
circuit.x(qr[1]);
# measure the specific qubit
circuit.measure(qr[1], cr[0]); # ; hides the output
# Try both commands:
execute_locally(circuit,draw_circuit=True)
# execute_circuit(circuit,draw_circuit=False)
qr, cr, circuit = new_circuit(2)
# CNOT gate
circuit.cx(qr[0], qr[1]);
# measure the specific qubit
circuit.measure(qr, cr); # ; hides the output
# Try both commands:
execute_locally(circuit,draw_circuit=True)
# execute_circuit(circuit,draw_circuit=False)
qr, cr, circuit = new_circuit(2)
# H gate on 2 qubits
circuit.h(qr);
# CNOT gate
circuit.cx(qr[0], qr[1]);
# measure
circuit.measure(qr, cr); # ; hides the output
# Try both commands:
execute_locally(circuit,draw_circuit=True)
# execute_circuit(circuit,draw_circuit=False)
qr, cr, circuit = new_circuit(5)
circuit.measure(qr, cr);
execute_remotely(circuit)
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
# Choose the drawer you like best:
from qiskit.tools.visualization import matplotlib_circuit_drawer as draw
#from qiskit.tools.visualization import circuit_drawer as draw
from qiskit import IBMQ
IBMQ.load_accounts() # make sure you have setup your token locally to use this
%matplotlib inline
import matplotlib.pyplot as plt
def show_results(D):
# D is a dictionary with classical bits as keys and count as value
# example: D = {'000': 497, '001': 527}
plt.bar(range(len(D)), list(D.values()), align='center')
plt.xticks(range(len(D)), list(D.keys()))
plt.show()
from qiskit import Aer
# See a list of available local simulators
print("Aer backends: ", Aer.backends())
# see a list of available remote backends (these are freely given by IBM)
print("IBMQ Backends: ", IBMQ.backends())
# execute circuit and either display a histogram of the results
def execute_locally(qc, draw_circuit=False):
# Compile and run the Quantum circuit on a simulator backend
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend_sim)
result_sim = job_sim.result()
result_counts = result_sim.get_counts(qc)
# Print the results
print("simulation: ", result_sim, result_counts)
if draw_circuit: # draw the circuit
draw(qc)
else: # or show the results
show_results(result_counts)
from qiskit.backends.ibmq import least_busy
import time
# Compile and run on a real device backend
def execute_remotely(qc, draw_circuit=False):
if draw_circuit: # draw the circuit
draw(qc)
try:
# select least busy available device and execute.
least_busy_device = least_busy(IBMQ.backends(simulator=False))
print("Running on current least busy device: ", least_busy_device)
# running the job
job_exp = execute(qc, backend=least_busy_device, shots=1024, max_credits=10)
lapse, interval = 0, 10
while job_exp.status().name != 'DONE':
print('Status @ {} seconds'.format(interval * lapse))
print(job_exp.status())
time.sleep(interval)
lapse += 1
print(job_exp.status())
exp_result = job_exp.result()
result_counts = exp_result.get_counts(qc)
# Show the results
print("experiment: ", exp_result, result_counts)
if not draw_circuit: # show the results
show_results(result_counts)
except:
print("All devices are currently unavailable.")
def new_circuit(size):
# Create a Quantum Register with size qubits
qr = QuantumRegister(size)
# Create a Classical Register with size bits
cr = ClassicalRegister(size)
# Create a Quantum Circuit acting on the qr and cr register
return qr, cr, QuantumCircuit(qr, cr)
# create the circuit
# H gate on qubit 0
# measure the qubits
# create the circuit
# H gate on qubit 0
# X gate on qubit 1
# measure the qubits
# create the circuit
execute_remotely(circuit)
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
# Choose the drawer you like best:
from qiskit.tools.visualization import matplotlib_circuit_drawer as draw
#from qiskit.tools.visualization import circuit_drawer as draw
from qiskit import IBMQ
IBMQ.load_accounts() # make sure you have setup your token locally to use this
%matplotlib inline
import matplotlib.pyplot as plt
def show_results(D):
# D is a dictionary with classical bits as keys and count as value
# example: D = {'000': 497, '001': 527}
plt.bar(range(len(D)), list(D.values()), align='center')
plt.xticks(range(len(D)), list(D.keys()))
plt.show()
from qiskit import Aer
# See a list of available local simulators
print("Aer backends: ", Aer.backends())
# see a list of available remote backends (these are freely given by IBM)
print("IBMQ Backends: ", IBMQ.backends())
# execute circuit and either display a histogram of the results
def execute_locally(qc, draw_circuit=False):
# Compile and run the Quantum circuit on a simulator backend
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend_sim)
result_sim = job_sim.result()
result_counts = result_sim.get_counts(qc)
# Print the results
print("simulation: ", result_sim, result_counts)
if draw_circuit: # draw the circuit
draw(qc)
else: # or show the results
show_results(result_counts)
from qiskit.backends.ibmq import least_busy
import time
# Compile and run on a real device backend
def execute_remotely(qc, draw_circuit=False):
if draw_circuit: # draw the circuit
draw(qc)
try:
# select least busy available device and execute.
least_busy_device = least_busy(IBMQ.backends(simulator=False))
print("Running on current least busy device: ", least_busy_device)
# running the job
job_exp = execute(qc, backend=least_busy_device, shots=1024, max_credits=10)
lapse, interval = 0, 10
while job_exp.status().name != 'DONE':
print('Status @ {} seconds'.format(interval * lapse))
print(job_exp.status())
time.sleep(interval)
lapse += 1
print(job_exp.status())
exp_result = job_exp.result()
result_counts = exp_result.get_counts(qc)
# Show the results
print("experiment: ", exp_result, result_counts)
if not draw_circuit: # show the results
show_results(result_counts)
except:
print("All devices are currently unavailable.")
def new_circuit(size):
# Create a Quantum Register with size qubits
qr = QuantumRegister(size)
# Create a Classical Register with size bits
cr = ClassicalRegister(size)
# Create a Quantum Circuit acting on the qr and cr register
return qr, cr, QuantumCircuit(qr, cr)
qr, cr, circuit = new_circuit(2)
# H gate on qubit 0
circuit.h(qr[0]);
circuit.cx(qr[0], qr[1]);
# measure the qubits
circuit.measure(qr, cr);
# Try both commands:
execute_locally(circuit,draw_circuit=True)
# execute_locally(circuit,draw_circuit=False)
print(circuit.qasm())
# create the circuit
qr, cr, circuit = new_circuit(2)
# H gate on qubit 0
circuit.h(qr[0]);
# X gate on qubit 1
circuit.x(qr[1]);
circuit.cx(qr[0], qr[1]);
# measure the qubits
circuit.measure(qr, cr);
# Try both commands:
execute_locally(circuit,draw_circuit=True)
# execute_locally(circuit,draw_circuit=False)
# create the circuit
qr, cr, circuit = new_circuit(2)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1]);
circuit.h(qr);
circuit.measure(qr, cr)
execute_locally(circuit,draw_circuit=True)
qr, cr, circuit = new_circuit(2)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
circuit.h(qr)
circuit.measure(qr, cr);
execute_remotely(circuit)
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
# Choose the drawer you like best:
from qiskit.tools.visualization import matplotlib_circuit_drawer as draw
#from qiskit.tools.visualization import circuit_drawer as draw
from qiskit import IBMQ
IBMQ.load_accounts() # make sure you have setup your token locally to use this
%matplotlib inline
import matplotlib.pyplot as plt
def show_results(D):
# D is a dictionary with classical bits as keys and count as value
# example: D = {'000': 497, '001': 527}
plt.bar(range(len(D)), list(D.values()), align='center')
plt.xticks(range(len(D)), list(D.keys()))
plt.show()
from qiskit import Aer
# See a list of available local simulators
print("Aer backends: ", Aer.backends())
# see a list of available remote backends (these are freely given by IBM)
print("IBMQ Backends: ", IBMQ.backends())
# execute circuit and either display a histogram of the results
def execute_locally(qc, draw_circuit=False, show_results=False):
# Compile and run the Quantum circuit on a simulator backend
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend_sim)
result_sim = job_sim.result()
result_counts = result_sim.get_counts(qc)
if draw_circuit or show_results: # Print the results
print("simulation: ", result_sim, result_counts)
if draw_circuit: # draw the circuit
draw(qc)
elif show_results: # or show the results
show_results(result_counts)
return result_counts
from qiskit.backends.ibmq import least_busy
import time
# Compile and run on a real device backend
def execute_remotely(qc, draw_circuit=False, show_results=False):
if draw_circuit: # draw the circuit
draw(qc)
try:
# select least busy available device and execute.
least_busy_device = least_busy(IBMQ.backends(simulator=False))
print("Running on current least busy device: ", least_busy_device)
# running the job
job_exp = execute(qc, backend=least_busy_device, shots=1024, max_credits=10)
lapse, interval = 0, 10
while job_exp.status().name != 'DONE':
print('Status @ {} seconds'.format(interval * lapse))
print(job_exp.status())
time.sleep(interval)
lapse += 1
print(job_exp.status())
exp_result = job_exp.result()
result_counts = exp_result.get_counts(qc)
# Show the results
print("experiment: ", exp_result, result_counts)
if show_results: # show the results
show_results(result_counts)
return result_counts
except:
print("All devices are currently unavailable.")
return {}
def new_circuit(size):
# Create a Quantum Register with size qubits
qr = QuantumRegister(size)
# Create a Classical Register with size bits
cr = ClassicalRegister(size)
# Create a Quantum Circuit acting on the qr and cr register
return qr, cr, QuantumCircuit(qr, cr)
ERROR_MESSAGE = "Looks like your Deutsch has a bug"
def quantum_oracle_1(qr, cr, circuit):
pass
def quantum_oracle_2(qr, cr, circuit):
circuit.cx(qr[0], qr[1])
def quantum_oracle_3(qr, cr, circuit):
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[0])
circuit.cx(qr[0], qr[1])
def quantum_oracle_4(qr, cr, circuit):
circuit.z(qr[1])
circuit.cx(qr[0], qr[1])
def get_deutsch_verdict(res):
return "CONSTANT" or "BALANCED"
print(get_deutsch_verdict(results))
def deutsch(black_box):
# ...
black_box(circuit)
#...
return "CONSTANT" or "BALANCED"
assert deutsch(quantum_oracle_1) == 'CONSTANT', ERROR_MESSAGE
assert deutsch(quantum_oracle_2) == 'BALANCED', "Looks like your Deutsch has a bug"
assert deutsch(quantum_oracle_3) == 'BALANCED', "Looks like your Deutsch has a bug"
assert deutsch(quantum_oracle_4) == 'CONSTANT', "Looks like your Deutsch has a bug"
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
# Choose the drawer you like best:
from qiskit.tools.visualization import matplotlib_circuit_drawer as draw
#from qiskit.tools.visualization import circuit_drawer as draw
from qiskit import IBMQ
IBMQ.load_accounts() # make sure you have setup your token locally to use this
%matplotlib inline
import matplotlib.pyplot as plt
def show_results(D):
# D is a dictionary with classical bits as keys and count as value
# example: D = {'000': 497, '001': 527}
plt.bar(range(len(D)), list(D.values()), align='center')
plt.xticks(range(len(D)), list(D.keys()))
plt.show()
from qiskit import Aer
# See a list of available local simulators
print("Aer backends: ", Aer.backends())
# see a list of available remote backends (these are freely given by IBM)
print("IBMQ Backends: ", IBMQ.backends())
# execute circuit and either display a histogram of the results
def execute_locally(qc, draw_circuit=False, show_results=False):
# Compile and run the Quantum circuit on a simulator backend
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend_sim)
result_sim = job_sim.result()
result_counts = result_sim.get_counts(qc)
if draw_circuit or show_results: # Print the results
print("simulation: ", result_sim, result_counts)
if draw_circuit: # draw the circuit
draw(qc)
elif show_results: # or show the results
show_results(result_counts)
return result_counts
from qiskit.backends.ibmq import least_busy
import time
# Compile and run on a real device backend
def execute_remotely(qc, draw_circuit=False, show_results=False):
if draw_circuit: # draw the circuit
draw(qc)
try:
# select least busy available device and execute.
least_busy_device = least_busy(IBMQ.backends(simulator=False))
print("Running on current least busy device: ", least_busy_device)
# running the job
job_exp = execute(qc, backend=least_busy_device, shots=1024, max_credits=10)
lapse, interval = 0, 10
while job_exp.status().name != 'DONE':
print('Status @ {} seconds'.format(interval * lapse))
print(job_exp.status())
time.sleep(interval)
lapse += 1
print(job_exp.status())
exp_result = job_exp.result()
result_counts = exp_result.get_counts(qc)
# Show the results
print("experiment: ", exp_result, result_counts)
if show_results: # show the results
show_results(result_counts)
return result_counts
except:
print("All devices are currently unavailable.")
return {}
def new_circuit(size):
# Create a Quantum Register with size qubits
qr = QuantumRegister(size)
# Create a Classical Register with size bits
cr = ClassicalRegister(size)
# Create a Quantum Circuit acting on the qr and cr register
return qr, cr, QuantumCircuit(qr, cr)
ERROR_MESSAGE = "Looks like your Deutsch has a bug"
def quantum_oracle_1(qr, cr, circuit):
pass
def quantum_oracle_2(qr, cr, circuit):
circuit.cx(qr[0], qr[1])
def quantum_oracle_3(qr, cr, circuit):
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[0])
circuit.cx(qr[0], qr[1])
def quantum_oracle_4(qr, cr, circuit):
circuit.z(qr[1])
circuit.cx(qr[0], qr[1])
qr, cr, circuit = new_circuit(2)
# X gate on qubit 1 (bit flip)
circuit.x(qr[1]);
circuit.h(qr);
quantum_oracle_1(qr, cr, circuit)
circuit.h(qr[0]);
# measure the specific qubit
circuit.measure(qr[0], cr[0]);
# Try both commands:
# results = execute_locally(circuit, draw_circuit=False, show_results=False) # silent mode
results = execute_locally(circuit, draw_circuit=True, show_results=False)
# results = execute_locally(circuit, draw_circuit=False, show_results=True)
# results = execute_locally(circuit, draw_circuit=True, show_results=True) # this will be the same as True, False
if '00' in results:
print("CONSTANT")
elif '10' in results:
print("BALANCED")
def get_deutsch_verdict(res): # should be improved for error handling
if '00' in res:
return "CONSTANT"
elif '01' in res:
return "BALANCED"
print(get_deutsch_verdict(results))
def deutsch(black_box):
qr, cr, circuit = new_circuit(2)
circuit.x(qr[1]) # X gate on qubit 1 (bit flip)
circuit.h(qr) # Hadamard on both qubits
black_box(qr, cr, circuit)
circuit.h(qr[0]) # Hadamard on interesting qubit
circuit.measure(qr[0], cr[0]) # measure the specific qubit
results = execute_locally(circuit, draw_circuit=False, show_results=False) # silent mode
return get_deutsch_verdict(results)
deutsch(quantum_oracle_1)
assert deutsch(quantum_oracle_1) == 'CONSTANT', ERROR_MESSAGE
assert deutsch(quantum_oracle_2) == 'BALANCED', "Looks like your Deutsch has a bug"
assert deutsch(quantum_oracle_3) == 'BALANCED', "Looks like your Deutsch has a bug"
assert deutsch(quantum_oracle_4) == 'CONSTANT', "Looks like your Deutsch has a bug"
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# importing Qiskit
from qiskit import Aer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import available_backends, execute, register, get_backend, compile
from qiskit.tools import visualization
from qiskit.tools.visualization import circuit_drawer
q = QuantumRegister(6)
qc = QuantumCircuit(q)
qc.x(q[2])
qc.cx(q[1], q[5])
qc.cx(q[2], q[5])
qc.cx(q[3], q[5])
qc.ccx(q[1], q[2], q[4])
qc.ccx(q[3], q[4], q[5])
qc.ccx(q[1], q[2], q[4])
qc.x(q[2])
circuit_drawer(qc)
def black_box_u_f(circuit, f_in, f_out, aux, n, exactly_1_3_sat_formula):
"""Circuit that computes the black-box function from f_in to f_out.
Create a circuit that verifies whether a given exactly-1 3-SAT
formula is satisfied by the input. The exactly-1 version
requires exactly one literal out of every clause to be satisfied.
"""
num_clauses = len(exactly_1_3_sat_formula)
for (k, clause) in enumerate(exactly_1_3_sat_formula):
# This loop ensures aux[k] is 1 if an odd number of literals
# are true
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
# Flip aux[k] if all literals are true, using auxiliary qubit
# (ancilla) aux[num_clauses]
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
# Flip back to reverse state of negative literals and ancilla
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
# The formula is satisfied if and only if all auxiliary qubits
# except aux[num_clauses] are 1
if (num_clauses == 1):
circuit.cx(aux[0], f_out[0])
elif (num_clauses == 2):
circuit.ccx(aux[0], aux[1], f_out[0])
elif (num_clauses == 3):
circuit.ccx(aux[0], aux[1], aux[num_clauses])
circuit.ccx(aux[2], aux[num_clauses], f_out[0])
circuit.ccx(aux[0], aux[1], aux[num_clauses])
else:
raise ValueError('We only allow at most 3 clauses')
# Flip back any auxiliary qubits to make sure state is consistent
# for future executions of this routine; same loop as above.
for (k, clause) in enumerate(exactly_1_3_sat_formula):
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
# -- end function
def n_controlled_Z(circuit, controls, target):
"""Implement a Z gate with multiple controls"""
if (len(controls) > 2):
raise ValueError('The controlled Z with more than 2 ' +
'controls is not implemented')
elif (len(controls) == 1):
circuit.h(target)
circuit.cx(controls[0], target)
circuit.h(target)
elif (len(controls) == 2):
circuit.h(target)
circuit.ccx(controls[0], controls[1], target)
circuit.h(target)
# -- end function
def inversion_about_mean(circuit, f_in, n):
"""Apply inversion about the mean step of Grover's algorithm."""
# Hadamards everywhere
for j in range(n):
circuit.h(f_in[j])
# D matrix: flips the sign of the state |000> only
for j in range(n):
circuit.x(f_in[j])
n_controlled_Z(circuit, [f_in[j] for j in range(n-1)], f_in[n-1])
for j in range(n):
circuit.x(f_in[j])
# Hadamards everywhere again
for j in range(n):
circuit.h(f_in[j])
# -- end function
qr = QuantumRegister(3)
qInvAvg = QuantumCircuit(qr)
inversion_about_mean(qInvAvg, qr, 3)
circuit_drawer(qInvAvg)
"""
Grover search implemented in Qiskit.
This module contains the code necessary to run Grover search on 3
qubits, both with a simulator and with a real quantum computing
device. This code is the companion for the paper
"An introduction to quantum computing, without the physics",
Giacomo Nannicini, https://arxiv.org/abs/1708.03684.
"""
def input_state(circuit, f_in, f_out, n):
"""(n+1)-qubit input state for Grover search."""
for j in range(n):
circuit.h(f_in[j])
circuit.x(f_out)
circuit.h(f_out)
# -- end function
# Make a quantum program for the n-bit Grover search.
n = 3
# Exactly-1 3-SAT formula to be satisfied, in conjunctive
# normal form. We represent literals with integers, positive or
# negative, to indicate a Boolean variable or its negation.
exactly_1_3_sat_formula = [[1, 2, -3], [-1, -2, -3], [-1, 2, 3]]
# Define three quantum registers: 'f_in' is the search space (input
# to the function f), 'f_out' is bit used for the output of function
# f, aux are the auxiliary bits used by f to perform its
# computation.
f_in = QuantumRegister(n)
f_out = QuantumRegister(1)
aux = QuantumRegister(len(exactly_1_3_sat_formula) + 1)
# Define classical register for algorithm result
ans = ClassicalRegister(n)
# Define quantum circuit with above registers
grover = QuantumCircuit()
grover.add(f_in)
grover.add(f_out)
grover.add(aux)
grover.add(ans)
input_state(grover, f_in, f_out, n)
T = 2
for t in range(T):
# Apply T full iterations
black_box_u_f(grover, f_in, f_out, aux, n, exactly_1_3_sat_formula)
inversion_about_mean(grover, f_in, n)
# Measure the output register in the computational basis
for j in range(n):
grover.measure(f_in[j], ans[j])
# Execute circuit
backend = Aer.get_backend('qasm_simulator')
job = execute([grover], backend=backend, shots=1000)
result = job.result()
# Get counts and plot histogram
counts = result.get_counts(grover)
visualization.plot_histogram(counts)
IBMQ.load_accounts()
# get ibmq_16_rueschlikon configuration and coupling map
backend = IBMQ.get_backend('ibmq_16_melbourne')
backend_config = backend.configuration()
backend_coupling = backend_config['coupling_map']
# compile the circuit for ibmq_16_rueschlikon
grover_compiled = compile(grover, backend=backend, coupling_map=backend_coupling, seed=1)
grover_compiled_qasm = grover_compiled.experiments[0].header.compiled_circuit_qasm
print("Number of gates for", backend.name(), "is", len(grover_compiled_qasm.split("\n")) - 4)
circuit_drawer(grover)
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
import math
# importing Qiskit
from qiskit import Aer, IBMQ
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute
from qiskit.backends.ibmq import least_busy
# useful additional packages
from qiskit.wrapper.jupyter import *
from qiskit.tools.visualization import plot_histogram
IBMQ.load_accounts()
def input_state(circ, q, n):
"""n-qubit input state for QFT that produces output 1."""
for j in range(n):
circ.h(q[j])
circ.u1(math.pi/float(2**(j)), q[j]).inverse()
def qft(circ, q, n):
"""n-qubit QFT on q in circ."""
for j in range(n):
for k in range(j):
circ.cu1(math.pi/float(2**(j-k)), q[j], q[k])
circ.h(q[j])
q = QuantumRegister(3)
c = ClassicalRegister(3)
qft3 = QuantumCircuit(q, c)
input_state(qft3, q, 3)
qft(qft3, q, 3)
for i in range(3):
qft3.measure(q[i], c[i])
print(qft3.qasm())
# run on local simulator
backend = Aer.get_backend("qasm_simulator")
simulate = execute(qft3, backend=backend, shots=1024).result()
simulate.get_counts()
%%qiskit_job_status
# Use the IBM Quantum Experience
backend = least_busy(IBMQ.backends(simulator=False))
shots = 1024
job_exp = execute(qft3, backend=backend, shots=shots)
results = job_exp.result()
plot_histogram(results.get_counts())
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
from IPython.display import HTML
HTML('<div align="center"><iframe width="560" height="315" align="centre" src="https://www.youtube.com/embed/hOlOY7NyMfs?start=75&end=126" frameborder="0" allowfullscreen></iframe></div>')
# Brute force period finding algorithm
def find_period_classical(x, N):
n = 1
t = x
while t != 1:
t *= x
t %= N
n += 1
return n
import random, itertools
# Sieve of Eratosthenes algorithm
def sieve( ):
D = { }
yield 2
for q in itertools.islice(itertools.count(3), 0, None, 2):
p = D.pop(q, None)
if p is None:
D[q*q] = q
yield q
else:
x = p + q
while x in D or not (x&1):
x += p
D[x] = p
# Creates a list of prime numbers up to the given argument
def get_primes_sieve(n):
return list(itertools.takewhile(lambda p: p<n, sieve()))
def get_semiprime(n):
primes = get_primes_sieve(n)
l = len(primes)
p = primes[random.randrange(l)]
q = primes[random.randrange(l)]
return p*q
N = get_semiprime(1000)
print("semiprime N =",N)
import math
def shors_algorithm_classical(N):
x = random.randint(0,N) # step one
if(math.gcd(x,N) != 1): # step two
return x,0,math.gcd(x,N),N/math.gcd(x,N)
r = find_period_classical(x,N) # step three
while(r % 2 != 0):
r = find_period_classical(x,N)
p = math.gcd(x**int(r/2)+1,N) # step four, ignoring the case where (x^(r/2) +/- 1) is a multiple of N
q = math.gcd(x**int(r/2)-1,N)
return x,r,p,q
x,r,p,q = shors_algorithm_classical(N)
print("semiprime N = ",N,", coprime x = ",x,", period r = ",r,", prime factors = ",p," and ",q,sep="")
from qiskit import Aer
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, register, get_backend, compile
from qiskit.tools.visualization import plot_histogram, circuit_drawer
# qc = quantum circuit, qr = quantum register, cr = classical register, a = 2, 7, 8, 11 or 13
def circuit_amod15(qc,qr,cr,a):
if a == 2:
qc.cswap(qr[4],qr[3],qr[2])
qc.cswap(qr[4],qr[2],qr[1])
qc.cswap(qr[4],qr[1],qr[0])
elif a == 7:
qc.cswap(qr[4],qr[1],qr[0])
qc.cswap(qr[4],qr[2],qr[1])
qc.cswap(qr[4],qr[3],qr[2])
qc.cx(qr[4],qr[3])
qc.cx(qr[4],qr[2])
qc.cx(qr[4],qr[1])
qc.cx(qr[4],qr[0])
elif a == 8:
qc.cswap(qr[4],qr[1],qr[0])
qc.cswap(qr[4],qr[2],qr[1])
qc.cswap(qr[4],qr[3],qr[2])
elif a == 11: # this is included for completeness
qc.cswap(qr[4],qr[2],qr[0])
qc.cswap(qr[4],qr[3],qr[1])
qc.cx(qr[4],qr[3])
qc.cx(qr[4],qr[2])
qc.cx(qr[4],qr[1])
qc.cx(qr[4],qr[0])
elif a == 13:
qc.cswap(qr[4],qr[3],qr[2])
qc.cswap(qr[4],qr[2],qr[1])
qc.cswap(qr[4],qr[1],qr[0])
qc.cx(qr[4],qr[3])
qc.cx(qr[4],qr[2])
qc.cx(qr[4],qr[1])
qc.cx(qr[4],qr[0])
# qc = quantum circuit, qr = quantum register, cr = classical register, a = 2, 7, 8, 11 or 13
def circuit_aperiod15(qc,qr,cr,a):
if a == 11:
circuit_11period15(qc,qr,cr)
return
# Initialize q[0] to |1>
qc.x(qr[0])
# Apply a**4 mod 15
qc.h(qr[4])
# controlled identity on the remaining 4 qubits, which is equivalent to doing nothing
qc.h(qr[4])
# measure
qc.measure(qr[4],cr[0])
# reinitialise q[4] to |0>
qc.reset(qr[4])
# Apply a**2 mod 15
qc.h(qr[4])
# controlled unitary
qc.cx(qr[4],qr[2])
qc.cx(qr[4],qr[0])
# feed forward
if cr[0] == 1:
qc.u1(math.pi/2.,qr[4])
qc.h(qr[4])
# measure
qc.measure(qr[4],cr[1])
# reinitialise q[4] to |0>
qc.reset(qr[4])
# Apply a mod 15
qc.h(qr[4])
# controlled unitary.
circuit_amod15(qc,qr,cr,a)
# feed forward
if cr[1] == 1:
qc.u1(math.pi/2.,qr[4])
if cr[0] == 1:
qc.u1(math.pi/4.,qr[4])
qc.h(qr[4])
# measure
qc.measure(qr[4],cr[2])
def circuit_11period15(qc,qr,cr):
# Initialize q[0] to |1>
qc.x(qr[0])
# Apply a**4 mod 15
qc.h(qr[4])
# controlled identity on the remaining 4 qubits, which is equivalent to doing nothing
qc.h(qr[4])
# measure
qc.measure(qr[4],cr[0])
# reinitialise q[4] to |0>
qc.reset(qr[4])
# Apply a**2 mod 15
qc.h(qr[4])
# controlled identity on the remaining 4 qubits, which is equivalent to doing nothing
# feed forward
if cr[0] == 1:
qc.u1(math.pi/2.,qr[4])
qc.h(qr[4])
# measure
qc.measure(qr[4],cr[1])
# reinitialise q[4] to |0>
qc.reset(qr[4])
# Apply 11 mod 15
qc.h(qr[4])
# controlled unitary.
qc.cx(qr[4],qr[3])
qc.cx(qr[4],qr[1])
# feed forward
if cr[1] == 1:
qc.u1(math.pi/2.,qr[4])
if cr[0] == 1:
qc.u1(math.pi/4.,qr[4])
qc.h(qr[4])
# measure
qc.measure(qr[4],cr[2])
q = QuantumRegister(5, 'q')
c = ClassicalRegister(5, 'c')
shor = QuantumCircuit(q, c)
circuit_aperiod15(shor,q,c,7)
backend = Aer.get_backend('qasm_simulator')
sim_job = execute([shor], backend)
sim_result = sim_job.result()
sim_data = sim_result.get_counts(shor)
plot_histogram(sim_data)
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
import pylab
from qiskit_aqua import run_algorithm
from qiskit_aqua.input import get_input_instance
from qiskit.tools.visualization import matplotlib_circuit_drawer as draw
from qiskit.tools.visualization import plot_histogram
with open('3sat3-5.cnf', 'r') as f:
sat_cnf = f.read()
print(sat_cnf)
algorithm_cfg = {
'name': 'Grover'
}
oracle_cfg = {
'name': 'SAT',
'cnf': sat_cnf
}
params = {
'problem': {'name': 'search', 'random_seed': 50},
'algorithm': algorithm_cfg,
'oracle': oracle_cfg,
'backend': {'name': 'qasm_simulator'}
}
result = run_algorithm(params)
print(result['result'])
pylab.rcParams['figure.figsize'] = (8, 4)
plot_histogram(result['measurements'])
#draw(result['circuit'])
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
from qsvm_datasets import *
from qiskit_aqua.utils import split_dataset_to_data_and_labels, map_label_to_class_name
from qiskit_aqua.input import get_input_instance
from qiskit_aqua import run_algorithm
# setup aqua logging
import logging
from qiskit_aqua._logging import set_logging_config, build_logging_config
# set_logging_config(build_logging_config(logging.DEBUG)) # choose INFO, DEBUG to see the log
from qiskit import IBMQ
IBMQ.load_accounts()
feature_dim=2 # we support feature_dim 2 or 3
sample_Total, training_input, test_input, class_labels = ad_hoc_data(training_size=20, test_size=10, n=feature_dim, gap=0.3, PLOT_DATA=True)
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
print(class_to_label)
params = {
'problem': {'name': 'svm_classification', 'random_seed': 10598},
'algorithm': {
'name': 'QSVM.Kernel'
},
'backend': {'name': 'qasm_simulator', 'shots': 1024},
'feature_map': {'name': 'SecondOrderExpansion', 'depth': 2, 'entanglement': 'linear'}
}
algo_input = get_input_instance('SVMInput')
algo_input.training_dataset = training_input
algo_input.test_dataset = test_input
algo_input.datapoints = datapoints[0] # 0 is data, 1 is labels
result = run_algorithm(params, algo_input)
print("testing success ratio: ", result['testing_accuracy'])
print("predicted classes:", result['predicted_classes'])
print("kernel matrix during the training:")
kernel_matrix = result['kernel_matrix_training']
img = plt.imshow(np.asmatrix(kernel_matrix),interpolation='nearest',origin='upper',cmap='bone_r')
plt.show()
sample_Total, training_input, test_input, class_labels = Breast_cancer(training_size=20, test_size=10, n=2, PLOT_DATA=True)
# n =2 is the dimension of each data point
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
label_to_class = {label:class_name for class_name, label in class_to_label.items()}
print(class_to_label, label_to_class)
algo_input = get_input_instance('SVMInput')
algo_input.training_dataset = training_input
algo_input.test_dataset = test_input
algo_input.datapoints = datapoints[0]
result = run_algorithm(params, algo_input)
print("testing success ratio: ", result['testing_accuracy'])
print("ground truth: {}".format(map_label_to_class_name(datapoints[1], label_to_class)))
print("predicted: {}".format(result['predicted_classes']))
print("kernel matrix during the training:")
kernel_matrix = result['kernel_matrix_training']
img = plt.imshow(np.asmatrix(kernel_matrix),interpolation='nearest',origin='upper',cmap='bone_r')
plt.show()
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
# useful additional packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
%matplotlib inline
import numpy as np
import networkx as nx
from qiskit.tools.visualization import plot_histogram
from qiskit_aqua import Operator, run_algorithm, get_algorithm_instance
from qiskit_aqua.input import get_input_instance
from qiskit_aqua.translators.ising import maxcut, tsp
# setup aqua logging
import logging
from qiskit_aqua._logging import set_logging_config, build_logging_config
# set_logging_config(build_logging_config(logging.DEBUG)) # choose INFO, DEBUG to see the log
# ignoring deprecation errors on matplotlib
import warnings
import matplotlib.cbook
warnings.filterwarnings("ignore",category=matplotlib.cbook.mplDeprecation)
from qiskit import IBMQ
IBMQ.load_accounts()
# Generating a graph of 4 nodes
n=4 # Number of nodes in graph
G=nx.Graph()
G.add_nodes_from(np.arange(0,n,1))
elist=[(0,1,1.0),(0,2,1.0),(0,3,1.0),(1,2,1.0),(2,3,1.0)]
# tuple is (i,j,weight) where (i,j) is the edge
G.add_weighted_edges_from(elist)
colors = ['r' for node in G.nodes()]
pos = nx.spring_layout(G)
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
# Computing the weight matrix from the random graph
w = np.zeros([n,n])
for i in range(n):
for j in range(n):
temp = G.get_edge_data(i,j,default=0)
if temp != 0:
w[i,j] = temp['weight']
print(w)
best_cost_brute = 0
for b in range(2**n):
x = [int(t) for t in reversed(list(bin(b)[2:].zfill(n)))]
cost = 0
for i in range(n):
for j in range(n):
cost = cost + w[i,j]*x[i]*(1-x[j])
if best_cost_brute < cost:
best_cost_brute = cost
xbest_brute = x
print('case = ' + str(x)+ ' cost = ' + str(cost))
colors = ['r' if xbest_brute[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, pos=pos)
print('\nBest solution = ' + str(xbest_brute) + ' cost = ' + str(best_cost_brute))
qubitOp, offset = maxcut.get_maxcut_qubitops(w)
algo_input = get_input_instance('EnergyInput')
algo_input.qubit_op = qubitOp
#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
algorithm_cfg = {
'name': 'ExactEigensolver',
}
params = {
'problem': {'name': 'ising'},
'algorithm': algorithm_cfg
}
result = run_algorithm(params,algo_input)
x = maxcut.sample_most_likely(result['eigvecs'][0])
print('energy:', result['energy'])
print('maxcut objective:', result['energy'] + offset)
print('solution:', maxcut.get_graph_solution(x))
print('solution objective:', maxcut.maxcut_value(x, w))
colors = ['r' if maxcut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
algorithm_cfg = {
'name': 'VQE',
'operator_mode': 'matrix'
}
optimizer_cfg = {
'name': 'SPSA',
'max_trials': 300
}
var_form_cfg = {
'name': 'RY',
'depth': 5,
'entanglement': 'linear'
}
params = {
'problem': {'name': 'ising', 'random_seed': 10598},
'algorithm': algorithm_cfg,
'optimizer': optimizer_cfg,
'variational_form': var_form_cfg,
'backend': {'name': 'statevector_simulator'}
}
result = run_algorithm(params, algo_input)
x = maxcut.sample_most_likely(result['eigvecs'][0])
print('energy:', result['energy'])
print('time:', result['eval_time'])
print('maxcut objective:', result['energy'] + offset)
print('solution:', maxcut.get_graph_solution(x))
print('solution objective:', maxcut.maxcut_value(x, w))
colors = ['r' if maxcut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
# run quantum algorithm with shots
params['algorithm']['operator_mode'] = 'grouped_paulis'
params['backend']['name'] = 'qasm_simulator'
params['backend']['shots'] = 1024
result = run_algorithm(params, algo_input)
x = maxcut.sample_most_likely(result['eigvecs'][0])
print('energy:', result['energy'])
print('time:', result['eval_time'])
print('maxcut objective:', result['energy'] + offset)
print('solution:', maxcut.get_graph_solution(x))
print('solution objective:', maxcut.maxcut_value(x, w))
plot_histogram(result['eigvecs'][0])
colors = ['r' if maxcut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
# useful additional packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
%matplotlib inline
import numpy as np
import networkx as nx
from qiskit.tools.visualization import plot_histogram
from qiskit_aqua import Operator, run_algorithm, get_algorithm_instance
from qiskit_aqua.input import get_input_instance
from qiskit_aqua.translators.ising import maxcut, tsp
# setup aqua logging
import logging
from qiskit_aqua._logging import set_logging_config, build_logging_config
# set_logging_config(build_logging_config(logging.DEBUG)) # choose INFO, DEBUG to see the log
# ignoring deprecation errors on matplotlib
import warnings
import matplotlib.cbook
warnings.filterwarnings("ignore",category=matplotlib.cbook.mplDeprecation)
from qiskit import IBMQ
IBMQ.load_accounts()
# Generating a graph of 3 nodes
n = 3
num_qubits = n ** 2
ins = tsp.random_tsp(n)
G = nx.Graph()
G.add_nodes_from(np.arange(0, n, 1))
colors = ['r' for node in G.nodes()]
pos = {k: v for k, v in enumerate(ins.coord)}
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
print('distance\n', ins.w)
from itertools import permutations
def brute_force_tsp(w, N):
a=list(permutations(range(1,N)))
last_best_distance = 1e10
for i in a:
distance = 0
pre_j = 0
for j in i:
distance = distance + w[j,pre_j]
pre_j = j
distance = distance + w[pre_j,0]
order = (0,) + i
if distance < last_best_distance:
best_order = order
last_best_distance = distance
print('order = ' + str(order) + ' Distance = ' + str(distance))
return last_best_distance, best_order
best_distance, best_order = brute_force_tsp(ins.w, ins.dim)
print('Best order from brute force = ' + str(best_order) + ' with total distance = ' + str(best_distance))
def draw_tsp_solution(G, order, colors, pos):
G2 = G.copy()
n = len(order)
for i in range(n):
j = (i + 1) % n
G2.add_edge(order[i], order[j])
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G2, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
draw_tsp_solution(G, best_order, colors, pos)
qubitOp, offset = tsp.get_tsp_qubitops(ins)
algo_input = get_input_instance('EnergyInput')
algo_input.qubit_op = qubitOp
#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
algorithm_cfg = {
'name': 'ExactEigensolver',
}
params = {
'problem': {'name': 'ising'},
'algorithm': algorithm_cfg
}
result = run_algorithm(params,algo_input)
print('energy:', result['energy'])
#print('tsp objective:', result['energy'] + offset)
x = tsp.sample_most_likely(result['eigvecs'][0])
print('feasible:', tsp.tsp_feasible(x))
z = tsp.get_tsp_solution(x)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
draw_tsp_solution(G, z, colors, pos)
algorithm_cfg = {
'name': 'VQE',
'operator_mode': 'matrix'
}
optimizer_cfg = {
'name': 'SPSA',
'max_trials': 300
}
var_form_cfg = {
'name': 'RY',
'depth': 5,
'entanglement': 'linear'
}
params = {
'problem': {'name': 'ising', 'random_seed': 10598},
'algorithm': algorithm_cfg,
'optimizer': optimizer_cfg,
'variational_form': var_form_cfg,
'backend': {'name': 'statevector_simulator'}
}
result = run_algorithm(params,algo_input)
print('energy:', result['energy'])
print('time:', result['eval_time'])
#print('tsp objective:', result['energy'] + offset)
x = tsp.sample_most_likely(result['eigvecs'][0])
print('feasible:', tsp.tsp_feasible(x))
z = tsp.get_tsp_solution(x)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
draw_tsp_solution(G, z, colors, pos)
# run quantum algorithm with shots
params['algorithm']['operator_mode'] = 'grouped_paulis'
params['backend']['name'] = 'qasm_simulator'
params['backend']['shots'] = 1024
result = run_algorithm(params,algo_input)
print('energy:', result['energy'])
print('time:', result['eval_time'])
#print('tsp objective:', result['energy'] + offset)
x = tsp.sample_most_likely(result['eigvecs'][0])
print('feasible:', tsp.tsp_feasible(x))
z = tsp.get_tsp_solution(x)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
plot_histogram(result['eigvecs'][0])
draw_tsp_solution(G, z, colors, pos)
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
from qiskit_aqua_chemistry import AquaChemistry
from qiskit import IBMQ
IBMQ.load_accounts()
# Input dictionary to configure Qiskit AQUA Chemistry for the chemistry problem.
aqua_chemistry_dict = {
'driver': {'name': 'HDF5'},
'HDF5': {'hdf5_input': '0.7_sto-3g.hdf5'},
'operator': {'name': 'hamiltonian'},
'algorithm': {'name': 'VQE'},
'optimizer': {'name': 'COBYLA'},
'variational_form': {'name': 'UCCSD'},
'initial_state': {'name': 'HartreeFock'},
'backend': {'name': 'statevector_simulator'}
}
solver = AquaChemistry()
result = solver.run(aqua_chemistry_dict)
print('Ground state energy: {}'.format(result['energy']))
for line in result['printable']:
print(line)
|
https://github.com/rochisha0/quantum-ugly-duckling
|
rochisha0
|
import numpy as np
from qiskit import execute, QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.providers.aer import QasmSimulator
# 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
## Applying bit flip error
def get_noise():
p_reset = 0.03
p_meas = 0.1
p_gate1 = 0.05
# QuantumError objects
error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)])
error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])
error_gate1 = pauli_error([('X',p_gate1), ('I', 1 - p_gate1)])
error_gate2 = error_gate1.tensor(error_gate1)
# Add errors to noise model
noise_bit_flip = NoiseModel()
noise_bit_flip.add_all_qubit_quantum_error(error_reset, "reset")
noise_bit_flip.add_all_qubit_quantum_error(error_meas, "measure")
noise_bit_flip.add_all_qubit_quantum_error(error_gate1, ["u1", "u2", "u3"])
noise_bit_flip.add_all_qubit_quantum_error(error_gate2, ["cx"])
return noise_bit_flip
def random_number():
circ = QuantumCircuit(4)
simulator = QasmSimulator()
#NQRNS Circuit
for i in range(200):
circ.u3(0,0,0,0)
circ.u3(0,0,0,1)
circ.u3(0,0,0,2)
circ.u3(0,0,0,3)
circ.cx(0,1)
circ.cx(1,2)
circ.cx(0,2)
circ.cx(0,3)
circ.cx(1,3)
circ.cx(2,3)
circ.barrier()
circ.measure_all()
noise_bit_flip = get_noise()
#get output
job = execute(circ, simulator,
basis_gates=noise_bit_flip.basis_gates,
noise_model=noise_bit_flip, shots= 1)
result_bit_flip = job.result()
counts_bit_flip = result_bit_flip.get_counts(0)
num=list(counts_bit_flip.keys())[0]
num = int(num, 2)
return num
|
https://github.com/rochisha0/quantum-ugly-duckling
|
rochisha0
|
#importing libraries
from qiskit import QuantumCircuit, QuantumRegister, Aer, execute, IBMQ
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
provider = IBMQ.load_account()
backend = provider.backends.ibmqx2
real_circ = QuantumCircuit(3, 3)
for i in range(200):
real_circ.u3(0,0,0,0)
real_circ.u3(0,0,0,1)
real_circ.u3(0,0,0,2)
real_circ.cx(0,1)
real_circ.cx(1,2)
real_circ.cx(2,0)
real_circ.barrier()
real_circ.measure([0, 1, 2], [0, 1, 2])
job_exp = execute(real_circ, backend=backend, shots=8192)
print(job_exp.job_id())
job_monitor(job_exp)
exp_result = job_exp.result()
exp_measurement_result = exp_result.get_counts(real_circ)
print(exp_measurement_result)
plot_histogram(exp_measurement_result, color='midnightblue', title="NQRNG result on IBM Yorktown backend")
backend = provider.backends.ibmqx2
hada= QuantumCircuit(3, 3)
hada.h(0)
hada.h(1)
hada.h(2)
hada.measure([0, 1, 2], [0, 1, 2])
job_exp = execute(hada, backend=backend, shots=8192)
print(job_exp.job_id())
from qiskit.tools.monitor import job_monitor
job_monitor(job_exp)
exp_result = job_exp.result()
exp_measurement_result_hada = exp_result.get_counts(hada)
print(exp_measurement_result_hada)
plot_histogram(exp_measurement_result_hada, color='midnightblue', title="QRNS result on IBM Yorktown backend")
plot_histogram(exp_measurement_result_hada, color='midnightblue', title="QRNG result on IBM Yorktown backend")
plot_histogram(exp_measurement_result, color='midnightblue', title="NQRNG result on IBM Yorktown backend")
hada.draw('mpl')
backend = provider.backends.ibmqx2
real_circ = QuantumCircuit(3, 3)
real_circ.u3(0,0,0,0)
real_circ.u3(0,0,0,1)
real_circ.u3(0,0,0,2)
real_circ.cx(0,1)
real_circ.cx(1,2)
real_circ.cx(2,0)
real_circ.measure([0, 1, 2], [0, 1, 2])
job_exp = execute(real_circ, backend=backend, shots=8192)
print(job_exp.job_id())
job_monitor(job_exp)
exp_result = job_exp.result()
exp_measurement_result = exp_result.get_counts(real_circ)
print(exp_measurement_result)
plot_histogram(exp_measurement_result, color='midnightblue', title="Basic circuit on IBM Yorktown backend")
real_circ.draw('mpl')
|
https://github.com/rochisha0/quantum-ugly-duckling
|
rochisha0
|
from qiskit.tools.jupyter import *
from qiskit import IBMQ
IBMQ.save_account('IBMQ ID', overwrite=True)
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
backend = provider.get_backend('ibmq_armonk')
backend_config = backend.configuration()
assert backend_config.open_pulse, "Backend doesn't support Pulse"
dt = backend_config.dt
print(f"Sampling time: {dt*1e9} ns") # The configuration returns dt in seconds, so multiply by
# 1e9 to get nanoseconds
backend_defaults = backend.defaults()
import numpy as np
# unit conversion factors -> all backend properties returned in SI (Hz, sec, etc)
GHz = 1.0e9 # Gigahertz
MHz = 1.0e6 # Megahertz
us = 1.0e-6 # Microseconds
ns = 1.0e-9 # Nanoseconds
# We will find the qubit frequency for the following qubit.
qubit = 0
# The sweep will be centered around the estimated qubit frequency.
center_frequency_Hz = backend_defaults.qubit_freq_est[qubit] # The default frequency is given in Hz
# warning: this will change in a future release
print(f"Qubit {qubit} has an estimated frequency of {center_frequency_Hz / GHz} GHz.")
# scale factor to remove factors of 10 from the data
scale_factor = 1e-14
# We will sweep 40 MHz around the estimated frequency
frequency_span_Hz = 40 * MHz
# in steps of 1 MHz.
frequency_step_Hz = 1 * MHz
# We will sweep 20 MHz above and 20 MHz below the estimated frequency
frequency_min = center_frequency_Hz - frequency_span_Hz / 2
frequency_max = center_frequency_Hz + frequency_span_Hz / 2
# Construct an np array of the frequencies for our experiment
frequencies_GHz = np.arange(frequency_min / GHz,
frequency_max / GHz,
frequency_step_Hz / GHz)
print(f"The sweep will go from {frequency_min / GHz} GHz to {frequency_max / GHz} GHz \
in steps of {frequency_step_Hz / MHz} MHz.")
# samples need to be multiples of 16
def get_closest_multiple_of_16(num):
return int(num + 8 ) - (int(num + 8 ) % 16)
from qiskit import pulse # This is where we access all of our Pulse features!
from qiskit.pulse import Play
from qiskit.pulse import pulse_lib # This Pulse module helps us build sampled pulses for common pulse shapes
# Drive pulse parameters (us = microseconds)
drive_sigma_us = 0.075 # This determines the actual width of the gaussian
drive_samples_us = drive_sigma_us*8 # This is a truncating parameter, because gaussians don't have
# a natural finite length
drive_sigma = get_closest_multiple_of_16(drive_sigma_us * us /dt) # The width of the gaussian in units of dt
drive_samples = get_closest_multiple_of_16(drive_samples_us * us /dt) # The truncating parameter in units of dt
drive_amp = 0.3
# Drive pulse samples
drive_pulse = pulse_lib.gaussian(duration=drive_samples,
sigma=drive_sigma,
amp=drive_amp,
name='freq_sweep_excitation_pulse')
# Find out which group of qubits need to be acquired with this qubit
meas_map_idx = None
for i, measure_group in enumerate(backend_config.meas_map):
if qubit in measure_group:
meas_map_idx = i
break
assert meas_map_idx is not None, f"Couldn't find qubit {qubit} in the meas_map!"
inst_sched_map = backend_defaults.instruction_schedule_map
measure = inst_sched_map.get('measure', qubits=backend_config.meas_map[meas_map_idx])
### Collect the necessary channels
drive_chan = pulse.DriveChannel(qubit)
meas_chan = pulse.MeasureChannel(qubit)
acq_chan = pulse.AcquireChannel(qubit)
# Create the base schedule
# Start with drive pulse acting on the drive channel
schedule = pulse.Schedule(name='Frequency sweep')
schedule += Play(drive_pulse, drive_chan)
# The left shift `<<` is special syntax meaning to shift the start time of the schedule by some duration
schedule += measure << schedule.duration
# Create the frequency settings for the sweep (MUST BE IN HZ)
frequencies_Hz = frequencies_GHz*GHz
schedule_frequencies = [{drive_chan: freq} for freq in frequencies_Hz]
schedule.draw(label=True)
from qiskit import assemble
num_shots_per_frequency = 1024
frequency_sweep_program = assemble(schedule,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots_per_frequency,
schedule_los=schedule_frequencies)
job = backend.run(frequency_sweep_program)
# print(job.job_id())
from qiskit.tools.monitor import job_monitor
job_monitor(job)
frequency_sweep_results = job.result(timeout=120) # timeout parameter set to 120 seconds
import matplotlib.pyplot as plt
sweep_values = []
for i in range(len(frequency_sweep_results.results)):
# Get the results from the ith experiment
res = frequency_sweep_results.get_memory(i)*scale_factor
# Get the results for `qubit` from this experiment
sweep_values.append(res[qubit])
plt.scatter(frequencies_GHz, sweep_values_inverted, color='black') # plot real part of sweep values
plt.xlim([min(frequencies_GHz), max(frequencies_GHz)])
plt.xlabel("Frequency [GHz]")
plt.ylabel("Measured signal [a.u.]")
plt.show()
sweep_values_inverted = -1*np.real(sweep_values)
from scipy.optimize import curve_fit
def fit_function(x_values, y_values, function, init_params):
fitparams, conv = curve_fit(function, x_values, y_values, init_params)
y_fit = function(x_values, *fitparams)
return fitparams, y_fit
fit_params, y_fit = fit_function(frequencies_GHz,
sweep_values_inverted,
lambda x, A, q_freq, B, C: (A / np.pi) * (B / ((x - q_freq)**2 + B**2)) + C,
[5, 4.975, 1, 3] # initial parameters for curve_fit
)
plt.scatter(frequencies_GHz, sweep_values_inverted, color='black')
plt.plot(frequencies_GHz, y_fit, color='red')
plt.xlim([min(frequencies_GHz), max(frequencies_GHz)])
plt.xlabel("Frequency [GHz]")
plt.ylabel("Measured Signal [a.u.]")
plt.show()
A, rough_qubit_frequency, B, C = fit_params
rough_qubit_frequency = rough_qubit_frequency*GHz # make sure qubit freq is in Hz
print(f"We've updated our qubit frequency estimate from "
f"{round(backend_defaults.qubit_freq_est[qubit] / GHz, 5)} GHz to {round(rough_qubit_frequency/GHz, 5)} GHz.")
print(rough_qubit_frequency)
# This experiment uses these values from the previous experiment:
# `qubit`,
# `measure`, and
# `rough_qubit_frequency`.
# Rabi experiment parameters
num_rabi_points = 50
# Drive amplitude values to iterate over: 50 amplitudes evenly spaced from 0 to 0.75
drive_amp_min = 0
drive_amp_max = 0.75
drive_amps = np.linspace(drive_amp_min, drive_amp_max, num_rabi_points)
# Build the Rabi experiments:
# A drive pulse at the qubit frequency, followed by a measurement,
# where we vary the drive amplitude each time.
rabi_schedules = []
for drive_amp in drive_amps:
rabi_pulse = pulse_lib.gaussian(duration=drive_samples, amp=drive_amp,
sigma=drive_sigma, name=f"Rabi drive amplitude = {drive_amp}")
this_schedule = pulse.Schedule(name=f"Rabi drive amplitude = {drive_amp}")
this_schedule += Play(rabi_pulse, drive_chan)
# Reuse the measure instruction from the frequency sweep experiment
this_schedule += measure << this_schedule.duration
rabi_schedules.append(this_schedule)
rabi_schedules[-1].draw(label=True)
# Assemble the schedules into a Qobj
num_shots_per_point = 1024
rabi_experiment_program = assemble(rabi_schedules,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots_per_point,
schedule_los=[{drive_chan: rough_qubit_frequency}]
* num_rabi_points)
# print(job.job_id())
job = backend.run(rabi_experiment_program)
job_monitor(job)
rabi_results = job.result(timeout=120)
# center data around 0
def baseline_remove(values):
return np.array(values) - np.mean(values)
rabi_values = []
for i in range(num_rabi_points):
# Get the results for `qubit` from the ith experiment
rabi_values.append(rabi_results.get_memory(i)[qubit]*scale_factor)
rabi_values = np.real(baseline_remove(rabi_values))
plt.xlabel("Drive amp [a.u.]")
plt.ylabel("Measured signal [a.u.]")
plt.scatter(drive_amps, rabi_values, color='black') # plot real part of Rabi values
plt.show()
fit_params, y_fit = fit_function(drive_amps,
rabi_values,
lambda x, A, B, drive_period, phi: (A*np.cos(2*np.pi*x/drive_period - phi) + B),
[3, 0.1, 0.5, 0])
plt.scatter(drive_amps, rabi_values, color='black')
plt.plot(drive_amps, y_fit, color='red')
drive_period = fit_params[2] # get period of rabi oscillation
plt.axvline(drive_period/2, color='red', linestyle='--')
plt.axvline(drive_period, color='red', linestyle='--')
plt.annotate("", xy=(drive_period, 0), xytext=(drive_period/2,0), arrowprops=dict(arrowstyle="<->", color='red'))
plt.annotate("$\pi$", xy=(drive_period/2-0.03, 0.1), color='red')
plt.xlabel("Drive amp [a.u.]", fontsize=15)
plt.ylabel("Measured signal [a.u.]", fontsize=15)
plt.show()
pi_amp = abs(drive_period / 2)
print(f"Pi Amplitude = {pi_amp}")
pi_pulse = pulse_lib.gaussian(duration=drive_samples,
amp=pi_amp,
sigma=drive_sigma,
name='pi_pulse')
# T1 experiment parameters
time_max_us = 450
time_step_us = 6
times_us = np.arange(1, time_max_us, time_step_us)
# Convert to units of dt
delay_times_dt = times_us * us / dt
# We will use the same `pi_pulse` and qubit frequency that we calibrated and used before
# Create schedules for the experiment
t1_schedules = []
for delay in delay_times_dt:
this_schedule = pulse.Schedule(name=f"T1 delay = {delay * dt/us} us")
this_schedule += Play(pi_pulse, drive_chan)
this_schedule |= measure << int(delay)
t1_schedules.append(this_schedule)
sched_idx = 0
t1_schedules[sched_idx].draw(label=True)
# Execution settings
num_shots = 256
t1_experiment = assemble(t1_schedules,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots,
schedule_los=[{drive_chan: rough_qubit_frequency}] * len(t1_schedules))
job = backend.run(t1_experiment)
# print(job.job_id())
job_monitor(job)
t1_results = job.result(timeout=120)
t1_values = []
for i in range(len(times_us)):
t1_values.append(t1_results.get_memory(i)[qubit]*scale_factor)
t1_values = np.real(t1_values)
plt.scatter(times_us, t1_values, color='black')
plt.title("$T_1$ Experiment", fontsize=15)
plt.xlabel('Delay before measurement [$\mu$s]', fontsize=15)
plt.ylabel('Signal [a.u.]', fontsize=15)
plt.show()
# Fit the data
fit_params, y_fit = fit_function(times_us, t1_values,
lambda x, A, C, T1: (A * np.exp(-x / T1) + C),
[-3, 3, 100]
)
_, _, T1 = fit_params
plt.scatter(times_us, t1_values, color='black')
plt.plot(times_us, y_fit, color='red', label=f"T1 = {T1:.2f} us")
plt.xlim(0, np.max(times_us))
plt.title("$T_1$ Experiment", fontsize=15)
plt.xlabel('Delay before measurement [$\mu$s]', fontsize=15)
plt.ylabel('Signal [a.u.]', fontsize=15)
plt.legend()
plt.show()
print("Value of T1 is {} us".format(T1))
# Ramsey experiment parameters
time_max_us = 1.8
time_step_us = 0.025
times_us = np.arange(0.1, time_max_us, time_step_us)
# Convert to units of dt
delay_times_dt = times_us * us / dt
# Drive parameters
# The drive amplitude for pi/2 is simply half the amplitude of the pi pulse
drive_amp = pi_amp / 2
# x_90 is a concise way to say pi_over_2; i.e., an X rotation of 90 degrees
x90_pulse = pulse_lib.gaussian(duration=drive_samples,
amp=drive_amp,
sigma=drive_sigma,
name='x90_pulse')
# create schedules for Ramsey experiment
ramsey_schedules = []
for delay in delay_times_dt:
this_schedule = pulse.Schedule(name=f"Ramsey delay = {delay * dt / us} us")
this_schedule |= Play(x90_pulse, drive_chan)
this_schedule |= Play(x90_pulse, drive_chan) << int(this_schedule.duration + delay)
this_schedule |= measure << int(this_schedule.duration)
ramsey_schedules.append(this_schedule)
ramsey_schedules[0].draw(label=True)
# Execution settings
num_shots = 256
detuning_MHz = 2
ramsey_frequency = round(rough_qubit_frequency + detuning_MHz * MHz, 6) # need ramsey freq in Hz
ramsey_program = assemble(ramsey_schedules,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots,
schedule_los=[{drive_chan: ramsey_frequency}]*len(ramsey_schedules)
)
job = backend.run(ramsey_program)
# print(job.job_id())
job_monitor(job)
ramsey_results = job.result(timeout=120)
ramsey_values = []
for i in range(len(times_us)):
ramsey_values.append(ramsey_results.get_memory(i)[qubit]*scale_factor)
plt.scatter(times_us, np.real(ramsey_values), color='black')
plt.xlim(0, np.max(times_us))
plt.title("Ramsey Experiment", fontsize=15)
plt.xlabel('Delay between X90 pulses [$\mu$s]', fontsize=15)
plt.ylabel('Measured Signal [a.u.]', fontsize=15)
plt.show()
fit_params, y_fit = fit_function(times_us, np.real(ramsey_values),
lambda x, A, del_f_MHz, C, B: (
A * np.cos(2*np.pi*del_f_MHz*x - C) + B
),
[5, 1./0.4, 0, 0.25]
)
# Off-resonance component
_, del_f_MHz, _, _, = fit_params # freq is MHz since times in us
plt.scatter(times_us, np.real(ramsey_values), color='black')
plt.plot(times_us, y_fit, color='red', label=f"df = {del_f_MHz:.2f} MHz")
plt.xlim(0, np.max(times_us))
plt.xlabel('Delay between X90 pulses [$\mu$s]', fontsize=15)
plt.ylabel('Measured Signal [a.u.]', fontsize=15)
plt.title('Ramsey Experiment', fontsize=15)
plt.legend()
plt.show()
precise_qubit_freq = rough_qubit_frequency + (del_f_MHz - detuning_MHz) * MHz # get new freq in Hz
print(f"Our updated qubit frequency is now {round(precise_qubit_freq/GHz, 6)} GHz. "
f"It used to be {round(rough_qubit_frequency / GHz, 6)} GHz")
precise_qubit_freq
# Ramsey experiment parameters
time_max_us = 240
time_step_us = 4
times_us = np.arange(0.1, time_max_us, time_step_us)
# Convert to units of dt
delay_times_dt = times_us * us / dt
# Drive parameters
# The drive amplitude for pi/2 is simply half the amplitude of the pi pulse
drive_amp = pi_amp / 2
# x_90 is a concise way to say pi_over_2; i.e., an X rotation of 90 degrees
x90_pulse = pulse_lib.gaussian(duration=drive_samples,
amp=drive_amp,
sigma=drive_sigma,
name='x90_pulse')
# create schedules for Ramsey experiment
ramsey_schedules = []
for delay in delay_times_dt:
this_schedule = pulse.Schedule(name=f"Ramsey delay = {delay * dt / us} us")
this_schedule |= Play(x90_pulse, drive_chan)
this_schedule |= Play(x90_pulse, drive_chan) << int(this_schedule.duration + delay)
this_schedule |= measure << int(this_schedule.duration)
ramsey_schedules.append(this_schedule)
ramsey_schedules[0].draw(label=True)
# Execution settings
num_shots = 256
detuning_MHz = 2
ramsey_frequency = round(precise_qubit_freq, 6) # need ramsey freq in Hz
ramsey_program = assemble(ramsey_schedules,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots,
schedule_los=[{drive_chan: ramsey_frequency}]*len(ramsey_schedules)
)
job = backend.run(ramsey_program)
# print(job.job_id())
job_monitor(job)
ramsey_results = job.result(timeout=120)
ramsey_values = []
for i in range(len(times_us)):
ramsey_values.append(ramsey_results.get_memory(i)[qubit]*scale_factor)
plt.scatter(times_us, np.real(ramsey_values), color='black')
plt.xlim(0, np.max(times_us))
plt.title("Ramsey Experiment", fontsize=15)
plt.xlabel('Delay between X90 pulses [$\mu$s]', fontsize=15)
plt.ylabel('Measured Signal [a.u.]', fontsize=15)
plt.show()
fit_params, y_fit = fit_function(times_us, np.real(ramsey_values),
lambda x, A, del_f_MHz, C, B: (
A * np.cos(2*np.pi*del_f_MHz*x - C) + B
),
[5, 1./0.4, 0, 0.25]
)
# Off-resonance component
_, del_f_MHz, _, _, = fit_params # freq is MHz since times in us
plt.scatter(times_us, np.real(ramsey_values), color='black')
plt.plot(times_us, y_fit, color='red', label=f"df = {del_f_MHz:.2f} MHz")
plt.xlim(0, np.max(times_us))
plt.xlabel('Delay between X90 pulses [$\mu$s]', fontsize=15)
plt.ylabel('Measured Signal [a.u.]', fontsize=15)
plt.title('Ramsey Experiment', fontsize=15)
plt.legend()
plt.show()
# Ramsey experiment parameters
# time_max_us = 400
# time_step_us = 8
# times_us = np.arange(0.1, time_max_us, time_step_us)
times_us = np.array([100])
# Convert to units of dt
delay_times_dt = times_us * us / dt
# Drive parameters
# The drive amplitude for pi/2 is simply half the amplitude of the pi pulse
drive_amp = pi_amp / 2
# x_90 is a concise way to say pi_over_2; i.e., an X rotation of 90 degrees
x90_pulse = pulse_lib.gaussian(duration=drive_samples,
amp=drive_amp,
sigma=drive_sigma,
name='x90_pulse')
# create schedules for Ramsey experiment
ramsey_schedules_ = []
for delay in delay_times_dt:
this_schedule = pulse.Schedule(name=f"Ramsey delay = {delay * dt / us} us")
this_schedule |= Play(x90_pulse, drive_chan)
this_schedule |= Play(x90_pulse, drive_chan) << int(this_schedule.duration + delay)
this_schedule |= measure << int(this_schedule.duration)
ramsey_schedules_.append(this_schedule)
ramsey_schedules_[0].draw(label=True)
# Execution settings
num_shots = 1024
detuning_MHz = 2
ramsey_frequency = round(precise_qubit_freq, 6) # need ramsey freq in Hz
ramsey_program = assemble(ramsey_schedules,
backend=backend,
meas_level=2,
meas_return='avg',
shots=num_shots,
schedule_los=[{drive_chan: ramsey_frequency}]*len(ramsey_schedules_)
)
ramsey_schedules
job = backend.run(ramsey_program)
# print(job.job_id())
job_monitor(job)
ramsey_results = job.result(timeout=120)
len(counts)
counts = ramsey_results.get_counts()
from qiskit.visualization import plot_histogram
plot_histogram(counts[-1])
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider('ibm-q')
backend = provider.get_backend("ibmq_armonk")
pulse_job = backend.retrieve_job('5f8053f2d2769f00132c6bd9')
counts = pulse_job.result().get_counts()
counts
|
https://github.com/rochisha0/quantum-ugly-duckling
|
rochisha0
|
import math
import statistics
import matplotlib.pyplot as plt
import numpy as np
from qiskit import execute, QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.providers.aer import QasmSimulator
# 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
def runsTest(l, l_median):
'''
Returns Z; If Z>1.96 then numbers are not random
'''
runs, n1, n2 = 0, 0, 0
# Checking for start of new run
for i in range(len(l)):
# no. of runs
if (l[i] >= l_median and l[i-1] < l_median) or (l[i] < l_median and l[i-1] >= l_median):
runs += 1
# no. of positive values
if(l[i]) >= l_median:
n1 += 1
# no. of negative values
else:
n2 += 1
runs_exp = ((2*n1*n2)/(n1+n2))+1
stan_dev = math.sqrt((2*n1*n2*(2*n1*n2-n1-n2))/ (((n1+n2)**2)*(n1+n2-1)))
z = (runs-runs_exp)/stan_dev
return z
def get_noise():
'''
It returns the the noise model that uses bit flip error noise model.
When applying a single qubit gate, flip the state of the qubit with probability p_gate1.
When applying a 2-qubit gate apply single-qubit errors to each qubit.
When resetting a qubit reset to 1 instead of 0 with probability p_reset.
When measuring a qubit, flip the state of the qubit with probability p_meas.
'''
p_reset = 0.03
p_meas = 0.1
p_gate1 = 0.05
# QuantumError objects
error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)])
error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])
error_gate1 = pauli_error([('X',p_gate1), ('I', 1 - p_gate1)])
error_gate2 = error_gate1.tensor(error_gate1)
# Add errors to noise model
noise_bit_flip = NoiseModel()
noise_bit_flip.add_all_qubit_quantum_error(error_reset, "reset")
noise_bit_flip.add_all_qubit_quantum_error(error_meas, "measure")
noise_bit_flip.add_all_qubit_quantum_error(error_gate1, ["u1", "u2", "u3"])
noise_bit_flip.add_all_qubit_quantum_error(error_gate2, ["cx"])
return noise_bit_flip
def random_number():
'''
Returns random numbers between 0 to 15
'''
circ = QuantumCircuit(4)
simulator = QasmSimulator()
#NQRNS Circuit
for i in range(200):
circ.u3(0,0,0,0)
circ.u3(0,0,0,1)
circ.u3(0,0,0,2)
circ.u3(0,0,0,3)
circ.cx(0,1)
circ.cx(1,2)
circ.cx(0,2)
circ.cx(0,3)
circ.cx(1,3)
circ.cx(2,3)
circ.barrier()
circ.measure_all()
noise_bit_flip = get_noise()
#get output
job = execute(circ, simulator,
basis_gates=noise_bit_flip.basis_gates,
noise_model=noise_bit_flip, shots= 1)
result_bit_flip = job.result()
counts_bit_flip = result_bit_flip.get_counts(0)
num=list(counts_bit_flip.keys())[0]
num = int(num, 2)
return num
l= []
for i in range(100):
l.append(random_number())
l_median= statistics.median(l)
Z = abs(runsTest(l, l_median))
print('Z-statistic= ', Z)
dt = .1 #some time
n = 1000 #n-number of datapoints
for i in range(1000):
l.append(random_number())
fhat=np.fft.fft(l,n) #f-data ,n-number of datapoints per set
freq=(1/(dt*n))*np.arange(n)
PSD2=np.log(np.abs(np.fft.fftshift(fhat))**2)
plt.plot(freq.real,PSD2.real)
plt.xlabel('frequency')
plt.ylabel('number of occurence')
plt.show()
|
https://github.com/GroenteLepel/qiskit-quantum-knn
|
GroenteLepel
|
from qiskit_quantum_knn.qknn import QKNeighborsClassifier
from qiskit_quantum_knn.encoding import analog
from qiskit.utils import QuantumInstance
from sklearn import datasets
import qiskit as qk
# initialising the quantum instance
backend = qk.BasicAer.get_backend('qasm_simulator')
instance = QuantumInstance(backend, shots=10000)
# initialising the qknn model
qknn = QKNeighborsClassifier(
n_neighbors=3,
quantum_instance=instance
)
n_variables = 2 # should be positive power of 2
n_train_points = 4 # can be any positive integer
n_test_points = 2 # can be any positive integer
# use iris dataset
iris = datasets.load_iris()
labels = iris.target
data_raw = iris.data
# encode data
encoded_data = analog.encode(data_raw[:, :n_variables])
# now pick these indices from the data
train_data = encoded_data[:n_train_points]
train_labels = labels[:n_train_points]
test_data = encoded_data[n_train_points:(n_train_points+n_test_points), :n_variables]
test_labels = labels[n_train_points:(n_train_points+n_test_points)]
qknn.fit(train_data, train_labels)
qknn_prediction = qknn.predict(test_data)
print(qknn_prediction)
print(test_labels)
from qiskit_quantum_knn.qknn.qknn_construction import create_qknn
test_data = [1, 0]
train_data = [
[1, 0],
[1, 0]
]
circuit = create_qknn(test_data, train_data, add_measurement=True)
print(circuit.draw())
|
https://github.com/GroenteLepel/qiskit-quantum-knn
|
GroenteLepel
|
#!/usr/bin/env python
# coding: utf-8
# In[1]:
from qiskit_quantum_knn.qknn import QKNeighborsClassifier
from qiskit_quantum_knn.encoding import analog
from sklearn import datasets
import qiskit as qk
from qiskit.utils import QuantumInstance
# initialising the quantum instance
backend = qk.BasicAer.get_backend('qasm_simulator')
instance = QuantumInstance(backend, shots=10000)
# initialising the qknn model
qknn = QKNeighborsClassifier(
n_neighbors=3,
quantum_instance=instance
)
n_variables = 2 # should be positive power of 2
n_train_points = 4 # can be any positive integer
n_test_points = 2 # can be any positive integer
# use iris dataset
iris = datasets.load_iris()
labels = iris.target
data_raw = iris.data
# encode data
encoded_data = analog.encode(data_raw[:, :n_variables])
# now pick these indices from the data
train_data = encoded_data[:n_train_points]
train_labels = labels[:n_train_points]
test_data = encoded_data[n_train_points:(n_train_points+n_test_points), :n_variables]
test_labels = labels[n_train_points:(n_train_points+n_test_points)]
qknn.fit(train_data, train_labels)
qknn_prediction = qknn.predict(test_data)
print(qknn_prediction)
print(test_labels)
# In[2]:
from qiskit_quantum_knn.qknn.qknn_construction import create_qknn
test_data = [1, 0]
train_data = [
[1, 0],
[1, 0]
]
circuit = create_qknn(test_data, train_data, add_measurement=True)
print(circuit.draw())
|
https://github.com/GroenteLepel/qiskit-quantum-knn
|
GroenteLepel
|
# -*- 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/GroenteLepel/qiskit-quantum-knn
|
GroenteLepel
|
# -*- 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/GroenteLepel/qiskit-quantum-knn
|
GroenteLepel
|
"""The quantum KNN algorithm."""
from typing import Dict, Optional, Union
import logging
import itertools
import numpy as np
import scipy.stats as stats
import qiskit as qk
import qiskit.result as qres
import qiskit.tools as qktools
from qiskit.utils import QuantumInstance
import qiskit.providers as qkp
import qiskit.circuit.instruction as qinst
from qiskit_quantum_knn.qknn._qknn import _QKNN
from qiskit_quantum_knn.qknn import qknn_construction as qc
from qiskit_quantum_knn.qknn.quantum_algorithm import QuantumAlgorithm
from qiskit_quantum_knn.qknn.utils import get_subsystems_counts
logger = logging.getLogger(__name__)
UnionQInstBaseB = Union[QuantumInstance, qkp.BaseBackend]
OptionalQInstance = Optional[UnionQInstBaseB]
class QKNeighborsClassifier(QuantumAlgorithm):
""" Quantum KNN algorithm.
Maintains the construction of a QkNN Quantumcircuit, and manages the data
corresponding with this circuit by setting up training and test data and
maintaining the classes and labels to the data.
Args:
n_neighbors (int): number of neighbors to perform the voting.
training_dataset (array-like): data shaped ``(n, d)``, with ``n``
the number of data points, and ``d`` the dimensionality.
Corresponds to the training data, which is classified and will be
used to classify new data. ``d`` must be a positive power of two,
``n`` not per se, because it can be zero-padded to fit on a quantum
register.
training_labels (array): the labels corresponding to the training data,
must be ``len(n)``.
test_dataset (array-like): data shaped ``(m, d)``, with ``m`` the
the number of data points, and ``d`` the dimensionality. Describes
test data which is used to test the algorithm and give an
accuracy score.
TODO: this is not implemented yet, for now a test is performed manually.
data_points (array-like): data shaped ``(k, d)``, with ``k`` the number
of data points, and ``d`` the dimensionality of the data. This is
the unlabelled data which must be classified by the algorithm.
quantum_instance (:class: `QuantumInstance` or :class: BaseBackend):
the instance which ``qiskit`` will use to run the quantum algorithm.
Example:
Classify data using the Iris dataset.
.. jupyter-execute::
from qiskit_quantum_knn.qknn import QKNeighborsClassifier
from qiskit_quantum_knn.encoding import analog
from qiskit.utils import QuantumInstance
from sklearn import datasets
import qiskit as qk
# initialising the quantum instance
backend = qk.BasicAer.get_backend('qasm_simulator')
instance = QuantumInstance(backend, shots=10000)
# initialising the qknn model
qknn = QKNeighborsClassifier(
n_neighbors=3,
quantum_instance=instance
)
n_variables = 2 # should be positive power of 2
n_train_points = 4 # can be any positive integer
n_test_points = 2 # can be any positive integer
# use iris dataset
iris = datasets.load_iris()
labels = iris.target
data_raw = iris.data
# encode data
encoded_data = analog.encode(data_raw[:, :n_variables])
# now pick these indices from the data
train_data = encoded_data[:n_train_points]
train_labels = labels[:n_train_points]
test_data = encoded_data[n_train_points:(n_train_points+n_test_points), :n_variables]
test_labels = labels[n_train_points:(n_train_points+n_test_points)]
qknn.fit(train_data, train_labels)
qknn_prediction = qknn.predict(test_data)
print(qknn_prediction)
print(test_labels)
"""
def __init__(self, n_neighbors: int = 3,
training_dataset: Optional[np.ndarray] = None,
training_labels: Optional[np.ndarray] = None,
test_dataset: Optional[np.ndarray] = None,
data_points: Optional[np.ndarray] = None,
quantum_instance: OptionalQInstance = None) -> None:
super().__init__(quantum_instance)
self.n_neighbors = n_neighbors
# the datasets for training, testing and predicting
self.training_dataset = None
self.test_dataset = None
self.data_points = None
# dictionaries containing the class vs labels and reverse, respectively
self.class_to_label = None
self.label_to_class = None
# the number of classes in the provided data sets
self.num_classes = None
# setup of the data
self.training_dataset = training_dataset
self.training_labels = training_labels
self.test_dataset = test_dataset
self.data_points = data_points
# indicates the kind of instance this classifier is using, e.g.
# _QSVM_Binary, _QSVM_Multiclass, or, in this case, _QKNN. This
# instance has all the methods for running, testing and predicting.
self.instance = _QKNN(self)
def fit(self, X, y):
"""Fit the model using X as training data and y as target values
Notes:
There is no real "fitting" done here, since the data cannot
be stored somewhere. It only assigns the values so that these
cane be accessed when running.
Args:
X (array-like): Training data of shape [n_samples, n_features].
y (array-like): Target values of shape [n_samples].
"""
# TODO: create some validation and checks for the provided data
self.training_dataset = X
self.training_labels = y
@staticmethod
def construct_circuit(state_to_classify: np.ndarray,
oracle: qinst.Instruction,
add_measurement: bool = False) -> qk.QuantumCircuit:
r"""Construct one QkNN QuantumCircuit.
The Oracle provided is mentioned in :afham2020:`Afham et al. (2020)`
as the parameter :math:`\mathcal{W}`, and is created via the method
:py:func:`~qiskit_quantum_knn.qknn.qknn_construction.create_oracle`.
Args:
state_to_classify (array-like): array of dimension ``N`` complex
values describing the state to classify via kNN.
oracle (qiskit Instruction): oracle :math:`\mathcal{W}` for applying
training data.
add_measurement (bool): controls if measurements must be added
to the classical registers.
Returns:
QuantumCircuit: The constructed circuit.
"""
return qc.construct_circuit(
state_to_classify,
oracle,
add_measurement
)
@staticmethod
def construct_circuits(data_to_predict,
training_data) -> qk.QuantumCircuit:
"""Constructs all quantum circuits for each datum to classify.
Args:
data_to_predict (array): data points, 2-D array, of shape
``(N, D)``, where ``N`` is the number of data points and ``D``
is the dimensionality of the vector. ``D`` should coincide with
the provided training data.
training_data (array): data points which you want to know
the distance of between :py:attr:`data_to_predict`.
Returns:
numpy.ndarray: The constructed circuits.
Raises:
ValueError: Quantum instance is not present.
"""
measurement = True # can be adjusted if statevector_sim
oracle = qc.create_oracle(training_data)
# parallel_map() creates QuantumCircuits in parallel to be executed by
# a QuantumInstance
logger.info("Starting parallel map for constructing circuits.")
circuits = qktools.parallel_map(
QKNeighborsClassifier.construct_circuit,
data_to_predict,
task_args=[
oracle,
measurement
]
)
logger.info("Done.")
return circuits
@staticmethod
def execute_circuits(quantum_instance: UnionQInstBaseB,
circuits) -> qres.Result:
"""Executes the provided circuits (type array-like)."""
logger.info("Executing circuits")
result = quantum_instance.execute(circuits)
logger.info("Done.")
return result
def get_circuit_results(self,
circuits,
quantum_instance: OptionalQInstance = None) -> qres.Result:
"""Get the qiskit Results from the provided quantum circuits."""
self._quantum_instance = self._quantum_instance \
if quantum_instance is None else quantum_instance
if self._quantum_instance is None:
raise ValueError(
"Either provide a quantum instance or set one up."
)
return QKNeighborsClassifier.execute_circuits(
self.quantum_instance,
circuits
)
@staticmethod
def get_all_fidelities(circuit_results: qres.Result):
r"""Get all contrasts.
Gets the fidelity values which are calculated via
:func:`calculate_fidelities` and saves these in an array. For more about
fidelities, see :meth:`calculate_fidelities`.
Args:
circuit_results (qiskit.result.Result): the results from a QkNN
circuit build using ``QKNeighborsClassifier``.
Returns:
array: all fidelities corresponding to the QkNN.
"""
logger.info("Getting fidelity values.")
# get all counts from the circuit results
all_counts = circuit_results.get_counts()
# determine the length of the computational basis register by checking
# the length of the count result
# the -2 is there to compensate for the ' 0' or ' 1' at the end of
# the key.
num_qubits = len(list(all_counts[0].keys())[0]) - 2
# initialize the array which will hold the contrast values
n_occurrences = len(all_counts) # number of occurring states
n_datapoints = 2 ** num_qubits # number of data points
all_fidelities = np.empty(
shape=(n_occurrences, n_datapoints),
)
# loop over all counted states
for i, counts in enumerate(all_counts):
# calculate the contrast values q(i) for this set of counts
all_fidelities[i] = \
QKNeighborsClassifier.calculate_fidelities(counts)
logger.info("Done.")
return all_fidelities
@staticmethod
def calculate_fidelities(counts: Dict[str, int]) -> np.ndarray:
r"""Calculate the fidelities :math:`F_i`.
Calculates fidelities :math:`F_i` for each training state ``i`` in the
computational basis of the kNN QuantumCircuit. The fidelity can be
calculated via:
.. math::
F_i = \frac{M}{2} \left(p_0 (i) - p_1 (i)\right) \cdot \
\left(1 - \left( p(0) - p(1) \right) ^2 \right) + \
\left( p(0) - p(1) \right).
The values :math:`p(n)` are the probabilities that the control qubit is
in state :math:`n`, and the values :math:`p_n (i)` are the probabilities
that the computational basis is in state :math:`i` given the control
qubit is in state :math:`n`.
These values can be approximated by running the circuit :math:`T`
times using:
.. math::
p_n (i) \sim \bar{p}_n (i) = c_n(i) / T_n , \
p (n) \sim \bar{p} (n) = T_n / T,
where :math:`c_n(i), T_n` are the counts of the computational basis
in state :math:`i` given the control qubit in state :math:`n` and the
control qubit in state :math:`n`, respectively.
Args:
counts (dict): counts pulled from a qiskit Result from the QkNN.
Returns:
array: the fidelity values.
ndarray of length ``n_samples`` with each index ``i`` (representing
state :math:`|i\rangle` from the computational basis) the fidelity
belonging to :math:`|i\rangle`.
"""
# first get the total counts of 0 and 1 in the control qubit
subsystem_counts = get_subsystems_counts(counts)
# the counts from the control qubit are in the second register
# by some magical qiskit reason
control_counts = QKNeighborsClassifier.setup_control_counts(
subsystem_counts[1]
)
total_counts = control_counts['0'] + control_counts['1']
exp_fidelity = np.abs(control_counts['0'] - control_counts['1']) / \
total_counts
# now get the counts for the fidelities define possible states that
# the computational can be in.
num_qubits = len(list(subsystem_counts[0].keys())[0])
comp_basis_states = \
list(itertools.product(['0', '1'], repeat=num_qubits))
# initialise dict which is going to contain the fidelity values
fidelities = np.zeros(2 ** num_qubits, dtype=float)
for comp_state in comp_basis_states:
# convert list of '0's and '1's to one string e.g.
# ('0', '1', '0') --> '010'
comp_state = ''.join(comp_state)
# init fidelity value for this state
fidelity = 0.
for control_state in control_counts.keys():
state_str = comp_state + ' ' + control_state
if state_str not in counts:
logger.debug(
"State {0:s} not found in counts {1}. Adding"
"naught to contrast value."
.format(
state_str,
counts
)
)
fidelity += 0 # added for readability
else:
fidelity += \
(-1) ** int(control_state) * \
(counts[state_str]) / control_counts[control_state] * \
(1 - exp_fidelity ** 2)
index_state = int(comp_state, 2)
fidelity *= 2 ** num_qubits / 2
fidelity += exp_fidelity
fidelities[index_state] = fidelity
return fidelities
@staticmethod
def calculate_contrasts(counts: Dict[str, int]) -> np.ndarray:
r"""Calculate contrasts :math:`q(i)`.
Calculates contrasts :math:`q(i)` for each training state ``i`` in the
computational basis of the KNN QuantumCircuit. The contrasts
are according to :afham2020:`Afham et al. (2020)`.
.. math::
q(i) &= p_0(i) - p_1(i) \\
&= \frac{1 + F_i}
{M + \sum_{j=1}^M F_j} - \
\frac{1 - F_i}
{M - \sum_{j=1}^M F_j} \\
&= \frac{2(F_i - \langle F \rangle)}
{M(1 - \langle F \rangle^2)},
and correspond linearly to the fidelity :math:`F_i` between the
unclassified datum :math:`\psi` and :math:`\phi_i`.
Args:
counts (dict): counts pulled from a qiskit Result from the QkNN.
Returns:
array: the contrasts values.
ndarray of length ``n_samples`` with each index ``i`` (representing
state :math:`|i\rangle` from the computational basis) the contrast
belonging to :math:`|i\rangle`.
"""
# first get the total counts of 0 and 1 in the control qubit
subsystem_counts = get_subsystems_counts(counts)
# the counts from the control qubit are in the second register
# by some magical qiskit reason
control_counts = QKNeighborsClassifier.setup_control_counts(
subsystem_counts[1]
)
# now get the counts for the contrasts define possible states that
# the computational can be in.
num_qubits = len(list(subsystem_counts[0].keys())[0])
comp_basis_states = \
list(itertools.product(['0', '1'], repeat=num_qubits))
# initialise dict which is going to contain the contrast values
contrasts = np.zeros(2 ** num_qubits, dtype=float)
for comp_state in comp_basis_states:
# convert list of '0's and '1's to one string e.g.
# ('0', '1', '0') --> '010'
comp_state = ''.join(comp_state)
# init contrast value for this state
contrast = 0.
for control_state in control_counts.keys():
state_str = comp_state + ' ' + control_state
if state_str not in counts:
logger.debug(
"State {0:s} not found in counts {1}. Adding"
"naught to contrast value."
.format(
state_str,
counts
)
)
contrast += 0 # added for readability
else:
contrast += \
(-1) ** int(control_state) * \
(counts[state_str]) / control_counts[control_state]
index_state = int(comp_state, 2)
contrasts[index_state] = contrast
return contrasts
@staticmethod
def setup_control_counts(control_counts: Dict[str, int]) -> Dict[str, int]:
"""Sets up control counts dict.
In Qiskit, if a certain value is not measured (or counted), it has
no appearance in the ``counts`` dictionary from the :py:class:`Result`.
Thus, this method checks if this has happened and adds a value with
counts set to 0.
Notes:
This means that if the :py:attr:`control_counts` has both
occurrences of ``0`` and ``1``, this method just returns that exact
same dictionary, unmodified.
Args:
control_counts (dict): dictionary from a :py:class:`Result`
representing the control qubit in the QkNN circuit.
Returns:
dict: The modified control counts.
The same control_counts dict as provided but with non-counted
occurrence added as well if needed.
Raises:
ValueError: if the provided dictionary does not coincide with the
:py:class:`Result` from the QkNN.
"""
# constant describing the states possible in control_counts
control_states = np.array(['0', '1'])
# check if substition of 0 count value must be done
if control_states[0] not in control_counts:
to_substitute = int(control_states[0])
elif control_states[1] not in control_counts:
to_substitute = int(control_states[1])
else:
to_substitute = None
if to_substitute is not None:
# if to_substitute = 1, make it -1 * (1 - 1) = 0, else, make it
# -1 * (0 - 1) = 1
sole_occurrence = -1 * (to_substitute - 1)
logger.debug(
"Only one value is counted in the control qubit: {0:d},"
"setting the counts of state {1:d} to 0."
.format(
sole_occurrence,
to_substitute
)
)
control_counts = {
str(to_substitute): 0,
str(sole_occurrence): control_counts[str(sole_occurrence)]
}
return control_counts
def majority_vote(self,
labels: np.ndarray,
fidelities: np.ndarray) -> np.ndarray:
"""Performs majority vote with the :math:`k` nearest to determine class.
Args:
labels (array-like): The labels of the training data provided to
the :class:`QKNeighborsClassifier`.
fidelities (array-like): The fidelities calculated using
:meth:`get_all_fidelities'.
Returns:
ndarray: The labels resulted from the majority vote.
"""
logger.info("Performing majority vote.")
# get the neighbors sorted on their distance (lowest first) per data
# point.
if np.any(fidelities < -0.2) or np.any(fidelities > 1.2):
raise ValueError("Fidelities contain values outside range 0<=F<=1:"
f"{fidelities[fidelities < -0.2]}"
f"{fidelities[fidelities > 1.2]}")
sorted_neighbors = np.argpartition(
1 - fidelities,
-self.n_neighbors
)
# get the number of participating values
n_queries = len(labels)
# modify the argpartition to remove any "filler" qubits, e.g. if 5
# train data are given, n_queries=5 but number of qubits states must
# always be a positive number of 2 (will be 8 in example case)
# these values can accidentally participate in the voting, hence these
# must be removed
sorted_neighbors = sorted_neighbors[sorted_neighbors < n_queries]\
.reshape(sorted_neighbors.shape[0], n_queries)
if n_queries == 1:
n_closest_neighbors = sorted_neighbors[:self.n_neighbors]
else:
# this is the case when more than one data point is given to this
# majority vote, so the shape will be of (n_points, m)
n_closest_neighbors = sorted_neighbors[:, :self.n_neighbors]
# voters = np.take(data, indices_of_neighbors, axis=0)
voter_labels = np.take(labels, n_closest_neighbors)
if n_queries == 1:
votes, counts = stats.mode(voter_labels)
else:
votes, counts = stats.mode(voter_labels, axis=1)
logger.info("Done.")
return votes.real.flatten()
@property
def ret(self) -> Dict:
""" Returns result.
Returns:
Dict: return value(s).
"""
return self.instance.ret
@ret.setter
def ret(self, new_value):
""" Sets result.
Args:
new_value: new value to set.
"""
self.instance.ret = new_value
def predict(self, data) -> np.ndarray:
"""Predict the labels of the provided data."""
return self.instance.predict(data)
def _run(self) -> Dict:
return self.instance.run()
|
https://github.com/GroenteLepel/qiskit-quantum-knn
|
GroenteLepel
|
"""Construction of a QkNN QuantumCircuit."""
import logging, warnings
from typing import List, Union
import numpy as np
import qiskit as qk
import qiskit.extensions.quantum_initializer as qi
import qiskit.circuit as qcirc
import qiskit.circuit.instruction as qinst
import qiskit_quantum_knn.qknn.quantumgates as gates
logger = logging.getLogger(__name__)
def create_qknn(state_to_classify: Union[List, np.ndarray],
classified_states: Union[List, np.ndarray],
add_measurement: bool = False) -> qk.QuantumCircuit:
""" Construct one QkNN QuantumCircuit.
This method creates a circuit to perform distance measurements
using quantum fidelity as distance metric :afham2020:`Afham et al.
(2020)`. It initialises one register
with a state to classify, and uses an Oracle to act as QRAM to
hold the training data. This Oracle writes all training data in
superposition to a register. After that, a swap-test circuit
:buhrman2020:`Buhrman et al. (2020)` is created to perform the fidelity
measurement.
Example:
Creating a circuit with simple data.
.. jupyter-execute::
from qiskit_quantum_knn.qknn.qknn_construction import create_qknn
test_data = [1, 0]
train_data = [
[1, 0],
[0, 1]
]
circuit = create_qknn(test_data, train_data, add_measurement=True)
print(circuit.draw())
Args:
state_to_classify (numpy.ndarray): array of dimension N complex
values describing the state to classify via KNN.
classified_states (numpy.ndarray): array containing M training
samples of dimension N.
add_measurement (bool): controls if measurements must be added
to the classical registers.
Returns:
QuantumCircuit: the constructed circuit.
"""
oracle = create_oracle(classified_states)
return construct_circuit(
state_to_classify,
oracle,
add_measurement
)
def construct_circuit(state_to_classify: np.ndarray,
oracle: qinst.Instruction,
add_measurement: bool) -> qk.QuantumCircuit:
r"""Setup for a QkNN QuantumCircuit.
Constructs the QkNN QuantumCircuit according to the stepwise "instructions"
in :afham2020:`Afham et al. (2020)`. These instructions are\:
1. Initialisation:
creates the registers and applies the unclassified
datum :math:`\psi` (see :py:func:`initialise_qknn`);
2. State transformation:
applies :math:`H`-gates and the Oracle
:math:`\mathcal{W}` to the circuit, and applies the
:math:`SWAP`-test (see :py:func:`state_transformation`);
3. Adding measurments:
add the measurement gates to the control and
computational basis (see :py:func:`add_measurements`).
Args:
state_to_classify (numpy.ndarray): array of dimension N complex
values describing the state to classify via KNN.
oracle (qiskit Instruction): oracle :math:`\mathcal{W}` for applying
training data.
add_measurement (bool): controls if measurements must be added
to the classical registers.
Raises:
ValueError: If the number of data points in :attr:`state_to_classify`
is more than 2.
ValueError: If the length of the vectors in the
:attr:`classified_states` and/or test data are not a positive
power of 2.
Returns:
QuantumCircuit: constructed circuit.
"""
if len(np.array(state_to_classify).shape) != 1:
raise ValueError(
f"Please only one data point to classify. Number of data points "
f"provided is: {np.array(state_to_classify).shape[0]}. "
)
# get the dimensions of the state to classify
state_dimension = len(state_to_classify)
# get the number of qubits for the registers containing the state to
# classify and the number of train samples
n = np.log2(state_dimension) # n qubits for describing states
m = oracle.num_qubits - n # n qubits for computational basis
# Check if param is a power of 2
if (n == 0 or not n.is_integer()) and (m == 0 or not m.is_integer()):
raise ValueError(
"Desired statevector length not a positive power of 2."
)
# step 1: initialise (creates registers, sets qubits to |0> or the
# state to classify
qknn_circ = initialise_qknn(n, m, state_to_classify)
# step 2: state trans. (applies oracle)
qknn_circ = state_transformation(qknn_circ, oracle)
# step 3: adds the measurement gates
if add_measurement:
qknn_circ = add_measurements(qknn_circ)
logger.debug(f"Final circuit:\n{qknn_circ.draw(fold=90)}")
return qknn_circ
# noinspection PyTypeChecker
def create_oracle(train_data: Union[List, np.ndarray]) -> qinst.Instruction:
r"""Create an Oracle to perform as QRAM.
The oracle works as follows\:
.. math:: \mathcal{W}|i\rangle |0\rangle = |i\rangle |\phi_i\rangle
where the equation is from :afham2020:`Afham et al. (2020)`. This oracle
acts as QRAM, which holds the training dataset :math:`\Phi` to assign to
the register for performing a swap test. It is located in the center of
the quantum circuit (see :py:func:`create_qknn`).
Notes:
The Oracle works with controlled initializers which check the
state of the computational basis. The computational basis is described
by :math:`|i\rangle`, where :math:`i` is any real number, which is then
described by qubits in binary.
To check the the state of the computational basis, a network of
:math:`X`-gates is created to bring the computational basis
systematically into all possible states. If all qubits in the register
are :math:`|1\rangle`, the datum is assigned via the initialize. Where
to apply the :math:`X`-gates is determined by
:py:func:`where_to_apply_x`.
Example:
Creating a simple oracle for dataset with 4 points.
.. jupyter-execute::
from qiskit_quantum_knn.qknn.qknn_construction import create_oracle
train_data = [
[1, 0],
[1, 0],
[0, 1],
[0, 1]
]
oracle = create_oracle(train_data)
print(oracle.definition.draw())
Args:
train_data (array-like): List of vectors with dimension
``len(r_train)`` to initialize ``r_train`` to.
Returns:
circuit.instruction.Instruction: Instruction of the Oracle.
"""
# get shape of training data
train_shape = np.shape(train_data)
# check if training data is two dimensional
if len(train_shape) != 2:
raise ValueError("Provided training data not 2-dimensional. Provide"
"a matrix of shape n_samples x dim")
# get the log2 values of the number of samples
# m from training data and dimension of vectors n
m, n = np.log2(train_shape)
# check if m should be ceiled.
if not m.is_integer():
warnings.warn("Number of training states not a positive power of 2,"
"adding extra qubit to comply.")
m = np.ceil(m)
# create quantum registers
r_train = qk.QuantumRegister(n, name='train_states')
r_comp_basis = qk.QuantumRegister(m, name='comp_basis')
# initialize the list containing the controlled inits, which will assign
# each training state i to r_train (so should be as long as number of
# samples)
controlled_inits = [qcirc.ControlledGate] * train_shape[0]
# create an empty circuit with the registers
oracle_circ = qk.QuantumCircuit(
r_train,
r_comp_basis,
name='oracle'
)
# create all the controlled inits for each vector in train data
for i, train_state in enumerate(train_data):
controlled_inits[i] = \
gates.controlled_initialize(
r_train,
train_state,
num_ctrl_qubits=r_comp_basis.size,
name="phi_{}".format(i)
)
# apply all the x-gates and controlled inits to the circuit
# define the length of the binary string which will translate |i>
bin_number_length = r_comp_basis.size
where_x = where_to_apply_x(bin_number_length)
for i, (c_init, x_idx) in enumerate(zip(controlled_inits, where_x)):
# represent i in binary number with length bin_number_length, so
# leading zeros are included
logger.debug(f"applying x-gates to: {x_idx}")
# apply the x-gates
oracle_circ.x(r_comp_basis[x_idx])
# apply the controlled init
oracle_circ.append(c_init, r_comp_basis[:] + r_train[:])
logger.debug(f"Created oracle as:\n{oracle_circ.draw()}")
return oracle_circ.to_instruction()
def where_to_apply_x(bin_number_length: int) -> List:
r""" Create an array to apply :math:`X`-gates systematically to create all
possible register combinations.
This method returns the indices on where to apply :math:`X`-gates on a
quantum register with ``n`` qubits to generate all possible binary numbers
on that register.
Example:
Suppose we have a register with 2 qubits. We want to make sure we check
all possible states this register can be in, such that a data point
can be assigned. A register with 2 qubits can be in 4 states:
.. math::
|0\rangle = |00\rangle, |1\rangle = |01\rangle,
|2\rangle = |10\rangle, |3\rangle = |11\rangle
So to apply :math:`\phi_1`, the register must be in state
:math:`|01\rangle`, and we need to apply the :math:`X`-gate only to the
first qubit. The state becomes :math:`|11\rangle` and the controlled
initialise will trigger.
Because the algorithm will check for all states in succession, this can
be reduced to prevent double placements of :math:`X`-gates, and it
determines where to place the :math:`X`-gates via:
.. math:: |i-1\rangle XOR |i\rangle
A full list of all these configurations is created by this method\:
.. jupyter-execute::
from qiskit_quantum_knn.qknn.qknn_construction import where_to_apply_x
num_qubits = 2
where_to_apply_x(num_qubits)
Args:
bin_number_length (int): the length of the highest binary value (or
the number of qubits).
Returns:
List: All possible combinations.
A length ``2**bin_number_length`` of the indices of the qubits where
the :math:`X`-gate must be applied to.
"""
powers_of_two = 2 ** np.arange(bin_number_length)
indices = \
[
[
ind for ind, v in enumerate(powers_of_two)
if v & (pos ^ (pos - 1)) == v
] for pos in range(2 ** bin_number_length)
]
return indices
def initialise_qknn(log2_dim: int,
log2_n_samps: int,
test_state: np.ndarray) -> qk.QuantumCircuit:
r"""Creates the registers and applies the unclassified datum :math:`\psi`.
Coincides with Step 1: the "initialisation" section in
:afham2020:`Afham et al. (2020)`. Initialises a QuantumCircuit
with 1 + 2n + m qubits (n: log2_dimension, m: log2_samples) for a QkNN
network, where qubits 1 till n are initialised in some state psi (
state_to_classify).
Example:
Set up the scaffolds for a QkNN :class:`QuantumCircuit`.
.. jupyter-execute::
from qiskit_quantum_knn.qknn.qknn_construction import initialise_qknn
n_dim_qubits = 1
n_samps_qubits = 1
test_state = [0, 1]
init_circ = initialise_qknn(n_dim_qubits, n_samps_qubits, test_state)
print(init_circ.draw())
Args:
log2_dim (int): int, log2 value of the
dimension of the test and train states.
log2_n_samps (int): int,
log2 value of the number of training samples M.
test_state (numpy.ndarray): 2 ** log2_dimension complex values to
initialise the r_1 test state in (psi).
Returns:
QuantumCircuit: The initialised circuit.
"""
if len(test_state) != 2 ** log2_dim:
raise ValueError(
"Dimensionality of test state or provided dimension not correct;"
" test state dim is {0:d}, and dimension given is {1:d}".format(
len(test_state), 2 ** log2_dim
)
)
# register for control qubit
r_0 = qk.QuantumRegister(1, name='control')
# register for test state
r_1 = qk.QuantumRegister(log2_dim, name='state_to_classify')
# register for train state
r_2 = qk.QuantumRegister(log2_dim, name='train_states')
# register for computational basis
r_3 = qk.QuantumRegister(log2_n_samps, name='comp_basis')
# classical register for measuring the control and computational basis
c_0 = qk.ClassicalRegister(r_0.size, name='meas_control')
c_1 = qk.ClassicalRegister(r_3.size, name="meas_comp_basis")
init_circ = qk.QuantumCircuit(r_0, r_1, r_2, r_3, c_0, c_1)
init = qi.Isometry(test_state, 0, 0)
init.name = "init test state"
init_circ.append(init, r_1)
init_circ.barrier()
logger.debug(f"Initialised circuit as:\n{init_circ.draw()}")
return init_circ
def state_transformation(qknn_circ: qk.QuantumCircuit,
oracle: qinst.Instruction) -> qk.QuantumCircuit:
r"""applies :math:`H`-gates and the Oracle :math:`\mathcal{W}` to the
circuit, and applies the :math:`SWAP`-test.
Coincides with Step 2: the "state transformation" section from
:afham2020:`Afham et al. (2020)`. Applies Hadamard gates and
Quantum Oracle to bring :math:`r_1, r_2, r_3, r_4` in the desired states.
Note:
This needs the :class:`QuantumCircuit` created by
:py:func:`initialise_qknn` as a parameter in order to function
properly.
Example:
Apply the oracle and test data in a :class:`QuantumCircuit`.
.. jupyter-execute::
from qiskit_quantum_knn.qknn.qknn_construction import create_oracle, \
initialise_qknn, state_transformation
n_dim_qubits = 1 # must be log(len(test_state))
n_samps_qubits = 1 # must be log(len(train_data))
test_state = [0, 1]
train_data = [
[1, 0],
[0, 1]
]
oracle = create_oracle(train_data)
init_circ = initialise_qknn(n_dim_qubits, n_samps_qubits, test_state)
state_circ = state_transformation(init_circ, oracle)
print(state_circ.draw())
Args:
qknn_circ (QuantumCircuit): has been initialised according to
initialise_qknn().
oracle (qiskit Instruction): oracle W|i>|0> = W|i>|phi_i> for applying
training data.
Returns:
QuantumCircuit: the transformed :class:`QuantumCircuit`.
"""
# initialising registers for readability
[control, test_register, train_register, comp_basis] = qknn_circ.qregs
# perform equation 13 from Afham; Afham, Afrad; Goyal, Sandeep K. (2020).
qknn_circ.h(control)
qknn_circ.h(comp_basis)
# perform equation 15
# append to circuit
qknn_circ.append(oracle, train_register[:] + comp_basis[:])
# controlled swap
for psi_bit, phi_bit in zip(test_register, train_register):
qknn_circ.cswap(control, psi_bit, phi_bit)
# final Hadamard gate
qknn_circ.h(control)
# barrier to round it of
qknn_circ.barrier()
logger.info(f"transformed registers to circuit:\n{qknn_circ.draw()}")
return qknn_circ
def add_measurements(qknn_circ: qk.QuantumCircuit) -> qk.QuantumCircuit:
"""Adds measurement gates to the control and computational basis.
Performs the third and final step of the building of the QkNN circuit by
adding measurements to the control qubit and the computational basis.
Note:
This needs the :class:`QuantumCircuit` created by
:py:func:`state_transformation` as a parameter in order to function
properly.
Example:
.. jupyter-execute::
from qiskit_quantum_knn.qknn.qknn_construction import create_oracle, \
initialise_qknn, state_transformation, add_measurements
n_dim_qubits = 1 # must be log(len(test_state))
n_samps_qubits = 1 # must be log(len(train_data))
test_state = [0, 1]
train_data = [
[1, 0],
[0, 1]
]
oracle = create_oracle(train_data)
init_circ = initialise_qknn(n_dim_qubits, n_samps_qubits, test_state)
state_circ = state_transformation(init_circ, oracle)
final_circ = add_measurements(state_circ)
print(final_circ.draw())
Args:
qknn_circ (qk.QuantumCircuit): has been build up by first applying
initialise_qknn() and
state_transformation().
Returns:
QuantumCircuit: the :class:`QuantumCircuit` with measurements applied.
"""
comp_basis_creg = qknn_circ.cregs[-1]
comp_basis_qreg = qknn_circ.qregs[-1]
qknn_circ.measure(qknn_circ.qregs[0], qknn_circ.cregs[0])
for qbit, cbit in zip(comp_basis_qreg, reversed(comp_basis_creg)):
qknn_circ.measure(qbit, cbit)
logger.debug("Added measurements.")
return qknn_circ
|
https://github.com/GroenteLepel/qiskit-quantum-knn
|
GroenteLepel
|
from typing import Optional
import numpy as np
import qiskit as qk
import qiskit.extensions.quantum_initializer as qi
from qiskit.circuit.controlledgate import ControlledGate
from qiskit.circuit.gate import Gate
"""
Extra file containing some decomposed quantum gates to get familiar with them
and Qiskit.
"""
def swap():
"""A self-written decomposition of the SWAP-gate.
Example:
.. jupyter-execute::
from qiskit_quantum_knn.qknn.quantumgates import swap
swap_circ = swap()
print(swap_circ.definition.draw())
Returns:
Instruction: the SWAP-gate.
"""
swap_circuit = qk.QuantumCircuit(2, name='swap_gate')
swap_circuit.cx(0, 1)
swap_circuit.cx(1, 0)
swap_circuit.cx(0, 1)
return swap_circuit.to_instruction()
def fidelity_instruction():
r"""A decomposition of the SWAP-measurement.
The fidelity between the state on ``q_1`` and the state on ``q_2``
is defined as:
.. math:: \mathbb{P}(q_0 = 0) - \mathbb{P}(q_0 = 1)
Example:
.. jupyter-execute::
from qiskit_quantum_knn.qknn.quantumgates import fidelity_instruction
fid_inst = fidelity_instruction()
print(fid_inst.definition.draw())
Returns:
Instruction: The Fidelity gate (swap measurement).
"""
fidelity_circ = qk.QuantumCircuit(3, 1)
fidelity_circ.h(0)
fidelity_circ.cswap(0, 1, 2)
fidelity_circ.h(0)
fidelity_circ.measure(0, 0)
fidelity_instr = fidelity_circ.to_instruction()
return fidelity_instr
def init_to_state(reg_to_init: qk.QuantumRegister,
init_state: np.ndarray,
name: Optional[str] = None) -> Gate:
"""Initialize a :class:`QuantumRegister` to the provided state.
Args:
reg_to_init (QuantumRegister): register which needs to be initialized.
init_state (np.ndarray): state to which the :py:attr:`reg_to_init`
must be initialized to.
name (str): optional, name for the ``init_gate``.
Raises:
ValueError: if the register and state do not have the same dimension.
Returns:
Gate: The initialiser.
A gate of size ``reg_to_init.size`` which performs the
initialization.
"""
# check if provided values are correct
if len(init_state) != 2 ** len(reg_to_init):
raise ValueError(
"Dimensionality of the init_state does not coincide with the "
"length of the register to initialise to: is {0} and {1}".format(
len(init_state), len(reg_to_init)
)
)
init_circ = qk.QuantumCircuit(reg_to_init, name=name) # create temp circuit
init = qi.Isometry(init_state, 0, 0) # create Isometry for init
init_circ.append(init, reg_to_init) # apply init to temp circuit
basis_gates = ['u1', 'u2', 'u3', 'cx'] # list basis gates
# transpile circuit so that it is decomposed to the basis gates above,
# making it unitary and possible to convert from Instruction to Gate
transpiled = qk.transpile(init_circ, basis_gates=basis_gates)
init_gate = transpiled.to_gate() # convert to Gate
return init_gate
def controlled_initialize(reg_to_init: qk.QuantumRegister,
init_state: np.ndarray,
num_ctrl_qubits: Optional[int] = 1,
name: Optional[str] = None) -> ControlledGate:
"""Initialize a register to provided state with control.
This method uses :py:func:`init_to_state` to create the initialiser.
Args:
reg_to_init (QuantumRegister): register which needs to be initialized.
init_state (np.ndarray): state to which the ``reg_to_init`` must be
initialized to.
num_ctrl_qubits (int): optional, number of desired controls.
name (str): optional, name for the ``init_gate``.
Returns:
ControlledGate: The produced controlled initialise.
A Gate of size ``reg_to_init.size + num_ctrl_qubits`` which
performs the initialize with control.
"""
# create the init state
init_gate = init_to_state(reg_to_init, init_state, name)
# make it controlled
controlled_init = init_gate.control(num_ctrl_qubits=num_ctrl_qubits)
return controlled_init
|
https://github.com/GroenteLepel/qiskit-quantum-knn
|
GroenteLepel
|
# -*- 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/GroenteLepel/qiskit-quantum-knn
|
GroenteLepel
|
import numpy as np
import qiskit as qk
from qiskit.utils import QuantumInstance
import pytest
from qiskit_quantum_knn.qknn import QKNeighborsClassifier
def test_get_all_contrasts():
assert True
def test_calculate_fidelities():
ex_counts = {
'00 0': 10,
'00 1': 1,
'01 0': 20,
'01 1': 1,
'10 0': 15,
'10 1': 3,
'11 0': 2,
'11 1': 4,
}
fidelities = QKNeighborsClassifier.calculate_fidelities(ex_counts)
print(fidelities)
# no physically correct fidelities but
np.testing.assert_allclose(
fidelities,
[0.78826531, 1.01785714, 0.66326531, 0.24489796]
)
def test_calculate_contrasts():
assert True
def test_setup_control_counts():
assert True
def test_majority_vote_voting():
qknn = QKNeighborsClassifier(n_neighbors=3)
example_fidelities = np.array([
[0.1, 0.9, 0.1, 0.9],
[0.9, 0.1, 0.9, 0.1],
])
example_labels = np.array([-1, 1, -1, 1])
votes = qknn.majority_vote(
labels=example_labels,
fidelities=example_fidelities
)
np.testing.assert_array_equal(votes, [1, -1])
@pytest.mark.parametrize(
"n_train_states,n_test_states,n_qubit_states",
[(8, 1, 8), (8, 8, 8), (5, 8, 8)]
)
def test_majority_vote_result_shape(n_train_states: int,
n_test_states: int,
n_qubit_states: int):
qknn = QKNeighborsClassifier(n_neighbors=3)
example_fidelities = np.random.rand(n_test_states, n_qubit_states)
example_labels = np.random.choice(
[-1, 1],
n_train_states
)
votes = qknn.majority_vote(
labels=example_labels,
fidelities=example_fidelities
)
assert votes.shape == (n_test_states,)
def test_qknn():
backend = qk.BasicAer.get_backend('qasm_simulator')
instance = QuantumInstance(backend, shots=10000)
# initialising the qknn model
qknn = QKNeighborsClassifier(
n_neighbors=3,
quantum_instance=instance
)
train_data = [
[1/np.sqrt(2), 1/np.sqrt(2), 0, 0],
[1/np.sqrt(2), 1/np.sqrt(2), 0, 0],
[0, 0, 1/np.sqrt(2), 1/np.sqrt(2)],
[0, 0, 1/np.sqrt(2), 1/np.sqrt(2)]
]
train_labels = [
1,
1,
-1,
-1
]
test_data = [
[1 / np.sqrt(2), 1 / np.sqrt(2), 0, 0],
[0, 0, 1 / np.sqrt(2), 1 / np.sqrt(2)]
]
qknn.fit(train_data, train_labels)
qknn_prediction = qknn.predict(test_data)
np.testing.assert_array_equal(qknn_prediction, [1, -1])
|
https://github.com/amyami187/QiskitML
|
amyami187
|
import numpy as np
import torch
from torch.autograd import Function
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from torchvision import datasets, transforms
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister, execute
from qiskit.circuit import Parameter
from qiskit import Aer
from tqdm import tqdm
from matplotlib import pyplot as plt
%matplotlib inline
def to_numbers(tensor_list):
num_list = []
for tensor in tensor_list:
num_list += [tensor.item()]
return num_list
class 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()
transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()]) # transform images to tensors/vectors
mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
labels = mnist_trainset.targets # get the labels for the data
labels = labels.numpy()
idx1 = np.where(labels == 0) # filter on zeros
idx2 = np.where(labels == 1) # filter on ones
# Specify number of datapoints per class (i.e. there will be n pictures of 1 and n pictures of 0 in the training set)
n=100
# concatenate the data indices
idx = np.concatenate((idx1[0][0:n],idx2[0][0:n]))
# create the filtered dataset for our training set
mnist_trainset.targets = labels[idx]
mnist_trainset.data = mnist_trainset.data[idx]
train_loader = torch.utils.data.DataLoader(mnist_trainset, batch_size=1, shuffle=True)
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()
optimizer = optim.Adam(network.parameters(), lr=0.001)
epochs = 30
loss_list = []
for epoch in range(epochs):
total_loss = []
target_list = []
for batch_idx, (data, target) in enumerate(train_loader):
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_list[-1])
# Normalise the loss between 0 and 1
for i in range(len(loss_list)):
loss_list[i] += 1
# Plot the loss per epoch
plt.plot(loss_list)
|
https://github.com/pyRiemann/pyRiemann-qiskit
|
pyRiemann
|
import logging
import numpy as np
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
from qiskit.circuit.library import RealAmplitudes
from qiskit.quantum_info import Statevector
from qiskit_algorithms.optimizers import SPSA
from qiskit_algorithms.utils import algorithm_globals
from qiskit_machine_learning.circuit.library import RawFeatureVector
from qiskit_machine_learning.neural_networks import SamplerQNN
from sklearn.base import TransformerMixin
def _ansatz(num_qubits):
return RealAmplitudes(num_qubits, reps=5)
def _auto_encoder_circuit(num_latent, num_trash):
qr = QuantumRegister(num_latent + 2 * num_trash + 1, "q")
cr = ClassicalRegister(1, "c")
circuit = QuantumCircuit(qr, cr)
circuit.compose(
_ansatz(num_latent + num_trash), range(0, num_latent + num_trash), inplace=True
)
circuit.barrier()
auxiliary_qubit = num_latent + 2 * num_trash
# swap test
circuit.h(auxiliary_qubit)
for i in range(num_trash):
circuit.cswap(auxiliary_qubit, num_latent + i, num_latent + num_trash + i)
circuit.h(auxiliary_qubit)
circuit.measure(auxiliary_qubit, cr[0])
return circuit
class BasicQnnAutoencoder(TransformerMixin):
"""Quantum denoising
This class implements a quantum auto encoder.
The implementation was adapted from [1]_, to be compatible with scikit-learn.
Parameters
----------
num_latent : int, default=3
The number of qubits in the latent space.
num_trash : int, default=2
The number of qubits in the trash space.
opt : Optimizer, default=SPSA(maxiter=100, blocking=True)
The classical optimizer to use.
callback : Callable[int, double], default=None
An additional callback for the optimizer.
The first parameter is the number of cost evaluation call.
The second parameter is the cost.
Notes
-----
.. versionadded:: 0.3.0
Attributes
----------
costs_ : list
The values of the cost function.
fidelities_ : list, shape (n_samples,)
fidelities (one fidelity for each sample).
References
----------
.. [1] \
https://qiskit-community.github.io/qiskit-machine-learning/tutorials/12_quantum_autoencoder.html
.. [2] A. Mostafa et al., 2024 \
‘Quantum Denoising in the Realm of Brain-Computer Interfaces:
A Preliminary Study’,
https://hal.science/hal-04501908
"""
def __init__(
self,
num_latent=3,
num_trash=2,
opt=SPSA(maxiter=100, blocking=True),
callback=None,
):
self.num_latent = num_latent
self.num_trash = num_trash
self.opt = opt
self.callback = callback
def _log(self, msg):
logging.info(f"[BasicQnnAutoencoder] {msg}")
def _get_transformer(self):
# encoder
transformer = QuantumCircuit(self.n_qubits)
transformer = transformer.compose(self._feature_map)
ansatz_qc = _ansatz(self.n_qubits)
transformer = transformer.compose(ansatz_qc)
transformer.barrier()
# trash space
for i in range(self.num_trash):
transformer.reset(self.num_latent + i)
transformer.barrier()
# decoder
transformer = transformer.compose(ansatz_qc.inverse())
self._transformer = transformer
return transformer
def _compute_fidelities(self, X):
fidelities = []
for x in X:
param_values = np.concatenate((x, self._opt_result.x))
output_qc = self._transformer.assign_parameters(param_values)
output_state = Statevector(output_qc).data
original_qc = self._feature_map.assign_parameters(x)
original_state = Statevector(original_qc).data
fidelity = np.sqrt(np.dot(original_state.conj(), output_state) ** 2)
fidelities.append(fidelity.real)
return fidelities
@property
def n_qubits(self):
return self.num_latent + self.num_trash
def fit(self, X, _y=None, **kwargs):
"""Fit the autoencoder.
Parameters
----------
X : ndarray, shape (n_samples, n_features)
Set of time epochs.
n_features must equal 2 ** n_qubits,
where n_qubits = num_trash + num_latent.
Returns
-------
self : BasicQnnAutoencoder
The BasicQnnAutoencoder instance.
"""
_, n_features = X.shape
self.costs_ = []
self.fidelities_ = []
self._iter = 0
self._log(
f"raw feature size: {2 ** self.n_qubits} and feature size: {n_features}"
)
assert 2**self.n_qubits == n_features
self._feature_map = RawFeatureVector(2**self.n_qubits)
self._auto_encoder = _auto_encoder_circuit(self.num_latent, self.num_trash)
qc = QuantumCircuit(self.num_latent + 2 * self.num_trash + 1, 1)
qc = qc.compose(self._feature_map, range(self.n_qubits))
qc = qc.compose(self._auto_encoder)
qnn = SamplerQNN(
circuit=qc,
input_params=self._feature_map.parameters,
weight_params=self._auto_encoder.parameters,
interpret=lambda x: x,
output_shape=2,
)
def cost_func(params_values):
self._iter += 1
if self._iter % 10 == 0:
self._log(f"Iteration {self._iter}")
probabilities = qnn.forward(X, params_values)
cost = np.sum(probabilities[:, 1]) / X.shape[0]
self.costs_.append(cost)
if self.callback:
self.callback(self._iter, cost)
return cost
initial_point = algorithm_globals.random.random(
self._auto_encoder.num_parameters
)
self._opt_result = self.opt.minimize(fun=cost_func, x0=initial_point)
# encoder/decoder circuit
self._transformer = self._get_transformer()
# compute fidelity
self.fidelities_ = self._compute_fidelities(X)
self._log(f"Mean fidelity: {np.mean(self.fidelities_)}")
return self
def transform(self, X, **kwargs):
"""Apply the transformer circuit.
Parameters
----------
X : ndarray, shape (n_samples, n_features)
Set of time epochs.
n_features must equal 2 ** n_qubits,
where n_qubits = num_trash + num_latent.
Returns
-------
outputs : ndarray, shape (n_samples, 2 ** n_qubits)
The autocoded sample. n_qubits = num_trash + num_latent.
"""
_, n_features = X.shape
outputs = []
for x in X:
param_values = np.concatenate((x, self._opt_result.x))
output_qc = self._transformer.assign_parameters(param_values)
output_sv = Statevector(output_qc).data
output_sv = np.reshape(np.abs(output_sv) ** 2, n_features)
outputs.append(output_sv)
return np.array(outputs)
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
import os
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
# PROGRAM_PREFIX = 'qiskit-test'
def main():
provider = DellRuntimeProvider()
here = os.path.dirname(os.path.realpath(__file__))
program_id = provider.runtime.upload_program(here + "/dirtest", metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
job.result(timeout=120)
if __name__ == "__main__":
main()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# Copyright 2021 Dell (www.dell.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from dell_runtime.emulator_runtime_job import EmulatorRuntimeJob
import unittest
from qiskit import QuantumCircuit, execute, transpile
from dell_runtime import DellRuntimeProvider
from qiskit.providers import JobStatus
from time import sleep
import os
import logging
import json
import requests
from urllib.parse import urljoin
from qiskit.providers.ibmq.runtime.utils import RuntimeDecoder
logger = logging.getLogger(__name__)
RUNTIME_PROGRAM = """
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
user_messenger.publish({'results': 'intermittently'})
circuits = transpile(
circuits,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
user_messenger.publish({'results': 'finally'})
user_messenger.publish(result.to_dict(), final=True)
print("job complete successfully")
"""
FAIL_PROGRAM = """
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
raise Exception('test failure')
"""
VQE_PROGRAM = """
from qiskit import Aer
from qiskit.opflow import X, Z, I
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.providers.ibmq.runtime.utils import RuntimeEncoder
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
import json
def result_to_jsonstr(res):
resd = {}
resd['eigenvalue'] = res.eigenvalue
resd['opt_time'] = res.optimizer_time
return json.dumps(resd, cls=RuntimeEncoder)
def main(backend, user_messenger, **kwargs):
H2_op = (-1.052373245772859 * I ^ I) + \
(0.39793742484318045 * I ^ Z) + \
(-0.39793742484318045 * Z ^ I) + \
(-0.01128010425623538 * Z ^ Z) + \
(0.18093119978423156 * X ^ X)
# seed = random.randint(0, 1000)
# print(seed)
seed = kwargs['seed']
algorithm_globals.random_seed = seed
qi = QuantumInstance(backend, seed_transpiler=seed, seed_simulator=seed, shots=kwargs['shots'])
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=slsqp, quantum_instance=qi, include_custom=kwargs['include_custom'])
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
result = result_to_jsonstr(result)
user_messenger.publish(result, final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
PROGRAM_PREFIX = 'qiskit-test'
SERVER_URL = os.getenv('SERVER_URL')
class AcceptanceTest(unittest.TestCase):
def test_circuit_runner(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
# program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
def test_remote_fail(self):
exc = False
try:
provider = DellRuntimeProvider()
provider.remote("http://thisurldoesntexist.com")
except Exception:
exc = True
self.assertTrue(exc)
def test_upload(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
proglist = provider.runtime.programs()
self.assertIsNotNone(proglist[program_id])
findProgId = False
logger.debug(proglist)
if program_id in proglist:
findProgId = True
self.assertTrue(findProgId)
def test_view_program(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
runtime_program = provider.runtime.program(program_id)
self.assertEqual(runtime_program.description, "Qiskit test program")
self.assertEqual(runtime_program.program_id, program_id)
def test_view_program_refresh(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
prog_list = provider.runtime.programs(refresh=False)
self.assertTrue(len(prog_list) >= 1)
new_program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
new_prog_list = provider.runtime.programs(refresh=False)
self.assertEqual(len(prog_list), len(new_prog_list))
newnew_prog_list = provider.runtime.programs(refresh=True)
self.assertGreater(len(newnew_prog_list), len(prog_list))
def test_run_program(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
self.assertEqual(job.host, SERVER_URL)
def test_get_results(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
# runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
response = job.result(timeout=180)
logger.debug("through")
# print(json.dumps(results))
# results['results'] = json.loads(results['results'])
results = response['results'][0]
self.assertIsNotNone(results)
self.assertTrue(results['success'])
self.assertTrue(results['success'])
self.assertEqual("DONE", results['status'])
shots = results['shots']
count = results['data']['counts']['0x0']
self.assertGreater(count, (0.45 * shots))
self.assertLess(count, (0.55 * shots))
def test_delete_program(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
prog_list = provider.runtime.programs(refresh=False)
self.assertTrue(len(prog_list) >= 1)
deleted = provider.runtime.delete_program(program_id)
self.assertTrue(deleted)
new_prog_list = provider.runtime.programs(refresh=True)
self.assertGreater(len(prog_list), len(new_prog_list))
def test_update_program(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
new_meta = {'description': 'Qiskit Test Update', 'max_execution_time': RUNTIME_PROGRAM_METADATA['max_execution_time']}
updated = provider.runtime.update_program(program_id, name='Test Update', metadata=new_meta)
self.assertTrue(updated)
program2 = provider.runtime.program(program_id, refresh=True)
self.assertEqual('Qiskit Test Update', program2.description)
self.assertEqual('Test Update', program2.name)
def test_intermittent_results(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
# runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
result = job.result(timeout=120)
messages = job.get_unread_messages()
logger.debug(f'unread messages {messages}')
self.assertEqual(len(messages), 2)
self.assertEqual("intermittently", messages[0]['results'])
self.assertEqual("finally", messages[1]['results'])
messages = job.get_unread_messages()
self.assertEqual(0, len(messages))
def test_get_status(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
# runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
status = job.status()
correct_status = status == "Creating" or status == "Pending" or status == "Running"
self.assertTrue(correct_status)
job.result(timeout=120)
status = job.status()
self.assertEqual(status, "Completed")
def test_get_failed_status(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(FAIL_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
status = job.status()
self.assertTrue(status == "Creating" or status == "Pending")
while status == "Running" or status == "Creating" or status == "Pending":
status = job.status()
sleep(5)
self.assertEqual(status, "Failed")
def test_cancel_job(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
# runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
res = job.cancel()
self.assertTrue(res)
status = job.status()
self.assertEqual(status, "Canceled")
def test_pprint_programs(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
self.assertIsNotNone(provider)
self.assertIsNotNone(provider.runtime)
pr_id_1 = provider.runtime.upload_program("fake-program1", metadata=RUNTIME_PROGRAM_METADATA)
import sys
import io
old_stdout = sys.stdout
new_stdout = io.StringIO()
sys.stdout = new_stdout
provider.runtime.pprint_programs()
output = new_stdout.getvalue()
sys.stdout = old_stdout
print(output)
self.assertTrue(
'''==================================================
{}:
Name: {}'''.format(pr_id_1,pr_id_1)
in output)
def test_dir_circuit_runner(self):
from . import dir_circuit_runner as dcr
try:
dcr.main()
except Exception as e:
self.fail("should pass")
def test_upload_file(self):
provider = DellRuntimeProvider()
self.assertIsNotNone(provider)
self.assertIsNotNone(provider.runtime)
here = os.path.dirname(os.path.realpath(__file__))
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(here + "/program.py", metadata=RUNTIME_PROGRAM_METADATA)
self.assertGreaterEqual(len(provider.runtime.programs()), 1)
runtime_program = provider.runtime.program(program_id)
self.assertIsNotNone(runtime_program)
try:
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
result = job.result(timeout=90)
self.assertIsNotNone(result)
except Exception:
self.fail("should pass")
def test_reserved_names(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
try:
here = os.path.dirname(os.path.realpath(__file__))
program_id = provider.runtime.upload_program(here + "/dirfail/", metadata=RUNTIME_PROGRAM_METADATA)
self.fail("Should not allow upload")
except Exception:
self.assertTrue(True)
def test_large_directory(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
here = os.path.dirname(os.path.realpath(__file__))
program_id = provider.runtime.upload_program(here + "/qkad", metadata=RUNTIME_PROGRAM_METADATA)
job = provider.runtime.run(program_id, options=None, inputs={'garbage': 'nonsense'})
res = job.result(timeout=600)
self.assertTrue("aligned_kernel_parameters" in res)
self.assertTrue("aligned_kernel_matrix" in res)
def test_callback_function(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
import sys
import io
old_stdout = sys.stdout
new_stdout = io.StringIO()
sys.stdout = new_stdout
job = provider.runtime.run(program_id, options=None, inputs=program_inputs,callback=print)
result =job.result(timeout=120)
output = new_stdout.getvalue()
sys.stdout = old_stdout
print(output)
self.assertTrue("{'results': 'intermittently'}" in output)
def test_reconnect(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
del(provider)
# delete session and sign back in via SSO
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
response = job.result(timeout=120)
logger.debug("through")
results = response['results'][0]
self.assertIsNotNone(results)
self.assertTrue(results['success'])
self.assertTrue(results['success'])
self.assertEqual("DONE", results['status'])
shots = results['shots']
count = results['data']['counts']['0x0']
self.assertGreater(count, (0.45 * shots))
self.assertLess(count, (0.55 * shots))
def test_data_security(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
url = urljoin(SERVER_URL, f'/program/{program_id}/data')
res = requests.get(url)
self.assertEqual(res.text, "Id and token not presented")
self.assertEqual(res.status_code, 401)
def test_block_nonsso_on_sso_server(self):
res = requests.get(urljoin(SERVER_URL, '/sso_enabled'))
sso_enabled = json.loads(res.text)
if sso_enabled:
url = urljoin(SERVER_URL, '/new_user')
res = requests.get(url)
self.assertEqual(res.status_code, 401)
url = urljoin(SERVER_URL, '/existing_user/2187121124')
res = requests.get(url)
self.assertEqual(res.status_code, 401)
def test_block_sso_on_nonsso_server(self):
res = requests.get(urljoin(SERVER_URL, '/sso_enabled'))
sso_enabled = json.loads(res.text)
if not sso_enabled:
url = urljoin(SERVER_URL, '/login')
res = requests.get(url)
self.assertEqual(res.status_code, 401)
url = urljoin(SERVER_URL, '/authenticate')
res = requests.post(url)
self.assertEqual(res.status_code, 401)
url = urljoin(SERVER_URL, '/tokeninfo/109129612')
res = requests.get(url)
self.assertEqual(res.status_code, 401)
url = urljoin(SERVER_URL, '/callback')
res = requests.get(url)
self.assertEqual(res.status_code, 401)
def test_vqe_emulation(self):
vqe_inputs = {
'shots': 2,
'seed': 10,
'include_custom': True
}
provider = DellRuntimeProvider()
provider.remote(os.getenv("SERVER_URL"))
program_id = provider.runtime.upload_program(VQE_PROGRAM)
job = provider.runtime.run(
program_id=program_id,
inputs=vqe_inputs,
options=None)
# result = job.result()
result = job.result(timeout=100)
result = json.loads(job.result(), cls=RuntimeDecoder)
self.assertEqual(-1.8572748921516753, result['eigenvalue'])
self.assertLessEqual(result['opt_time'], 0.4)
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2022.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test QRAO steps on various hardware and simulator backends"""
import pytest
from docplex.mp.model import Model
from qiskit.utils import QuantumInstance
from qiskit.algorithms.minimum_eigen_solvers import VQE
from qiskit.circuit.library import RealAmplitudes
from qiskit.algorithms.optimizers import SPSA
from qiskit import BasicAer
from qiskit_aer import Aer
from qiskit_optimization.algorithms import OptimizationResultStatus
from qiskit_optimization.translators import from_docplex_mp
from qiskit_ibm_provider import IBMProvider, least_busy, IBMAccountError
from qrao import (
QuantumRandomAccessOptimizer,
QuantumRandomAccessEncoding,
MagicRounding,
)
# pylint: disable=redefined-outer-name
# TODO:
# - update these tests to include solution checking once behavior can be made
# - deterministic.
# - This might just require us to set seeds in the QuantumInstance and
# - remove that as an argument altogether.
backends = [
(BasicAer.get_backend, "qasm_simulator"),
(Aer.get_backend, "qasm_simulator"),
(Aer.get_backend, "statevector_simulator"),
(Aer.get_backend, "aer_simulator"),
(Aer.get_backend, "aer_simulator_statevector"),
(Aer.get_backend, "aer_simulator_density_matrix"),
(Aer.get_backend, "aer_simulator_matrix_product_state"),
# The following takes forever, haven't yet waited long enough to know the
# real timescale
# (Aer.get_backend, "aer_simulator_extended_stabilizer"),
]
@pytest.fixture(scope="module")
def my_encoding():
"""Fixture to construct ``my_encoding`` for use in this file"""
# Load small reference problem
elist = [(0, 1), (0, 4), (0, 3), (1, 2), (1, 5), (2, 3), (2, 4), (4, 5), (5, 3)]
num_nodes = 6
mod = Model("maxcut")
nodes = list(range(num_nodes))
var = [mod.binary_var(name="x" + str(i)) for i in nodes]
mod.maximize(mod.sum((var[i] + var[j] - 2 * var[i] * var[j]) for i, j in elist))
problem = from_docplex_mp(mod)
encoding = QuantumRandomAccessEncoding(max_vars_per_qubit=3)
encoding.encode(problem)
return encoding
@pytest.fixture(scope="module")
def my_ansatz(my_encoding):
"""Fixture to construct ``my_ansatz`` for use in this file"""
return RealAmplitudes(my_encoding.num_qubits)
@pytest.mark.parametrize("relaxed_backend", backends)
@pytest.mark.parametrize("rounding_backend", backends)
@pytest.mark.filterwarnings("ignore::PendingDeprecationWarning")
@pytest.mark.filterwarnings(
"ignore:.*statevector_simulator.*:UserWarning"
) # ignore magic rounding's UserWarning when using statevector_simulator
@pytest.mark.backend
def test_backend(relaxed_backend, rounding_backend, my_encoding, my_ansatz, shots=3):
"""Smoke test of each backend combination"""
def cb(f, *args):
"Construct backend"
return f(*args)
relaxed_qi = QuantumInstance(backend=cb(*relaxed_backend), shots=shots)
rounding_qi = QuantumInstance(backend=cb(*rounding_backend), shots=shots)
vqe = VQE(
ansatz=my_ansatz,
optimizer=SPSA(maxiter=1, learning_rate=0.01, perturbation=0.1),
quantum_instance=relaxed_qi,
)
rounding_scheme = MagicRounding(rounding_qi)
qrao = QuantumRandomAccessOptimizer(
encoding=my_encoding, min_eigen_solver=vqe, rounding_scheme=rounding_scheme
)
result = qrao.solve()
assert result.status == OptimizationResultStatus.SUCCESS
@pytest.mark.backend
def test_magic_rounding_on_hardware_backend(my_encoding, my_ansatz):
"""Test *magic rounding* on a hardware backend, if available."""
try:
provider = IBMProvider()
except IBMAccountError:
pytest.skip("No hardware backend available")
print(f"Encoding requires {my_encoding.num_qubits} qubits")
backend = least_busy(
provider.backends(
min_num_qubits=my_encoding.num_qubits,
simulator=False,
operational=True,
)
)
print(f"Using backend: {backend}")
relaxed_qi = QuantumInstance(backend=Aer.get_backend("aer_simulator"), shots=100)
rounding_qi = QuantumInstance(backend=backend, shots=32)
vqe = VQE(
ansatz=my_ansatz,
optimizer=SPSA(maxiter=1, learning_rate=0.01, perturbation=0.1),
quantum_instance=relaxed_qi,
)
rounding_scheme = MagicRounding(quantum_instance=rounding_qi)
qrao = QuantumRandomAccessOptimizer(
encoding=my_encoding, min_eigen_solver=vqe, rounding_scheme=rounding_scheme
)
result = qrao.solve()
assert result.status == OptimizationResultStatus.SUCCESS
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""The FeatureMap class."""
import json
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
class FeatureMap:
"""Mapping data with the feature map."""
def __init__(self, feature_dimension, entangler_map=None):
"""
Args:
feature_dimension (int): number of features (twice the number of qubits for this
encoding)
entangler_map (list[list]): connectivity of qubits with a list of [source, target],
or None for full entanglement. Note that the order in the list is the order of
applying the two-qubit gate.
Raises:
ValueError: If the value of ``feature_dimension`` is odd.
"""
if isinstance(feature_dimension, int):
if feature_dimension % 2 == 0:
self._feature_dimension = feature_dimension
else:
raise ValueError("Feature dimension must be an even integer.")
else:
raise ValueError("Feature dimension must be an even integer.")
self._num_qubits = int(feature_dimension / 2)
if entangler_map is None:
self._entangler_map = [
[i, j] for i in range(self._num_qubits) for j in range(i + 1, self._num_qubits)
]
else:
self._entangler_map = entangler_map
self._num_parameters = self._num_qubits
def construct_circuit(self, x=None, parameters=None, q=None, inverse=False, name=None):
"""Construct the feature map circuit.
Args:
x (numpy.ndarray): data vector of size feature_dimension
parameters (numpy.ndarray): optional parameters in feature map
q (QauntumRegister): the QuantumRegister object for the circuit
inverse (bool): whether or not to invert the circuit
name (str): The name to use for the constructed ``QuantumCircuit`` object
Returns:
QuantumCircuit: a quantum circuit transforming data x
Raises:
ValueError: If the input parameters or vector are invalid
"""
if parameters is not None:
if isinstance(parameters, (int, float)):
raise ValueError("Parameters must be a list.")
if len(parameters) == 1:
parameters = parameters * np.ones(self._num_qubits)
else:
if len(parameters) != self._num_parameters:
raise ValueError(
"The number of feature map parameters must be {}.".format(
self._num_parameters
)
)
if len(x) != self._feature_dimension:
raise ValueError(
"The input vector must be of length {}.".format(self._feature_dimension)
)
if q is None:
q = QuantumRegister(self._num_qubits, name="q")
circuit = QuantumCircuit(q, name=name)
for i in range(self._num_qubits):
circuit.ry(-parameters[i], q[i])
for source, target in self._entangler_map:
circuit.cz(q[source], q[target])
for i in range(self._num_qubits):
circuit.rz(-2 * x[2 * i + 1], q[i])
circuit.rx(-2 * x[2 * i], q[i])
if inverse:
return circuit.inverse()
else:
return circuit
def to_json(self):
"""Return JSON representation of this object.
Returns:
str: JSON string representing this object.
"""
return json.dumps(
{"feature_dimension": self._feature_dimension, "entangler_map": self._entangler_map}
)
@classmethod
def from_json(cls, data):
"""Return an instance of this class from the JSON representation.
Args:
data (str): JSON string representing an object.
Returns:
FeatureMap: An instance of this class.
"""
return cls(**json.loads(data))
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=invalid-name
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
from qtils.featuremap import FeatureMap
from qtils.qka import QKA
import os
import pandas as pd
def main(backend, user_messenger, **kwargs):
df = pd.read_csv(os.path.dirname(os.path.abspath(__file__)) + '/aux_file/dataset_graph7.csv',sep=',', header=None) # alterative problem: dataset_graph10.csv
data = df.values
# choose number of training and test samples per class:
num_train = 10
num_test = 10
# extract training and test sets and sort them by class label
train = data[:2*num_train, :]
test = data[2*num_train:2*(num_train+num_test), :]
ind=np.argsort(train[:,-1])
x_train = train[ind][:,:-1]
y_train = train[ind][:,-1]
ind=np.argsort(test[:,-1])
x_test = test[ind][:,:-1]
y_test = test[ind][:,-1]
C = 1
maxiters = 1
initial_point = [0.1]
initial_layout = [10, 11, 12, 13, 14, 15, 16] # see figure above for the 7-qubit graph
# initial_layout = [9, 8, 11, 14, 16, 19, 22, 25, 24, 23] # see figure above for the 10-qubit graph
d = np.shape(data)[1]-1 # feature dimension is twice the qubit number
em = [[0,2],[3,4],[2,5],[1,4],[2,3],[4,6]]
fm = FeatureMap(feature_dimension=d, entangler_map=em)
qka = QKA(
feature_map=fm,
backend=backend,
initial_layout=initial_layout,
user_messenger=user_messenger,
)
qka_results = qka.align_kernel(
data=x_train,
labels=y_train,
initial_kernel_parameters=initial_point,
maxiters=maxiters,
C=C,
)
user_messenger.publish(qka_results, final=True)
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
from .qka import QKA
class FeatureMap:
def __init__(self, feature_dimension, entangler_map=None):
if isinstance(feature_dimension, int):
if feature_dimension % 2 == 0:
self._feature_dimension = feature_dimension
else:
raise ValueError("Feature dimension must be an even integer.")
else:
raise ValueError("Feature dimension must be an even integer.")
self._num_qubits = int(feature_dimension / 2)
if entangler_map is None:
self._entangler_map = [
[i, j]
for i in range(self._feature_dimension)
for j in range(i + 1, self._feature_dimension)
]
else:
self._entangler_map = entangler_map
self._num_parameters = self._num_qubits
def construct_circuit(self, x=None, parameters=None, q=None, inverse=False, name=None):
if parameters is not None:
if isinstance(parameters, (int, float)):
raise ValueError("Parameters must be a list.")
if len(parameters) == 1:
parameters = parameters * np.ones(self._num_qubits)
else:
if len(parameters) != self._num_parameters:
raise ValueError(
"The number of feature map parameters must be {}.".format(
self._num_parameters
)
)
if len(x) != self._feature_dimension:
raise ValueError(
"The input vector must be of length {}.".format(self._feature_dimension)
)
if q is None:
q = QuantumRegister(self._num_qubits, name="q")
circuit = QuantumCircuit(q, name=name)
for i in range(self._num_qubits):
circuit.ry(-parameters[i], q[i])
for source, target in self._entangler_map:
circuit.cz(q[source], q[target])
for i in range(self._num_qubits):
circuit.rz(-2 * x[2 * i + 1], q[i])
circuit.rx(-2 * x[2 * i], q[i])
if inverse:
return circuit.inverse()
else:
return circuit
def to_json(self):
return json.dumps(
{"feature_dimension": self._feature_dimension, "entangler_map": self._entangler_map}
)
@classmethod
def from_json(cls, data):
return cls(**json.loads(data))
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
class QKA:
def __init__(self, feature_map, backend, initial_layout=None, user_messenger=None):
self.feature_map = feature_map
self.feature_map_circuit = self.feature_map.construct_circuit
self.backend = backend
self.initial_layout = initial_layout
self.num_parameters = self.feature_map._num_parameters
self._user_messenger = user_messenger
self.result = {}
self.kernel_matrix = KernelMatrix(
feature_map=self.feature_map, backend=self.backend, initial_layout=self.initial_layout
)
def spsa_parameters(self):
spsa_params = np.zeros((5))
spsa_params[0] = 0.05 # a
spsa_params[1] = 0.1 # c
spsa_params[2] = 0.602 # alpha
spsa_params[3] = 0.101 # gamma
spsa_params[4] = 0 # A
return spsa_params
def cvxopt_solver(self, K, y, C, max_iters=10000, show_progress=False):
if y.ndim == 1:
y = y[:, np.newaxis]
H = np.outer(y, y) * K
f = -np.ones(y.shape)
n = K.shape[1] # number of training points
y = y.astype("float")
P = matrix(H)
q = matrix(f)
G = matrix(np.vstack((-np.eye((n)), np.eye((n)))))
h = matrix(np.vstack((np.zeros((n, 1)), np.ones((n, 1)) * C)))
A = matrix(y, y.T.shape)
b = matrix(np.zeros(1), (1, 1))
solvers.options["maxiters"] = max_iters
solvers.options["show_progress"] = show_progress
ret = solvers.qp(P, q, G, h, A, b, kktsolver="ldl")
return ret
def spsa_step_one(self, lambdas, spsa_params, count):
prng = RandomState(count)
c_spsa = float(spsa_params[1]) / np.power(count + 1, spsa_params[3])
delta = 2 * prng.randint(0, 2, size=np.shape(lambdas)[0]) - 1
lambda_plus = lambdas + c_spsa * delta
lambda_minus = lambdas - c_spsa * delta
return lambda_plus, lambda_minus, delta
def spsa_step_two(self, cost_plus, cost_minus, lambdas, spsa_params, delta, count):
a_spsa = float(spsa_params[0]) / np.power(count + 1 + spsa_params[4], spsa_params[2])
c_spsa = float(spsa_params[1]) / np.power(count + 1, spsa_params[3])
g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)
lambdas_new = lambdas - a_spsa * g_spsa
lambdas_new = lambdas_new.flatten()
cost_final = (cost_plus + cost_minus) / 2
return cost_final, lambdas_new
def align_kernel(self, data, labels, initial_kernel_parameters=None, maxiters=1, C=1):
if initial_kernel_parameters is not None:
lambdas = initial_kernel_parameters
else:
lambdas = np.random.uniform(-1.0, 1.0, size=(self.num_parameters))
spsa_params = self.spsa_parameters()
lambda_save = []
cost_final_save = []
for count in range(maxiters):
lambda_plus, lambda_minus, delta = self.spsa_step_one(
lambdas=lambdas, spsa_params=spsa_params, count=count
)
kernel_plus = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambda_plus
)
kernel_minus = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambda_minus
)
ret_plus = self.cvxopt_solver(K=kernel_plus, y=labels, C=C)
cost_plus = -1 * ret_plus["primal objective"]
ret_minus = self.cvxopt_solver(K=kernel_minus, y=labels, C=C)
cost_minus = -1 * ret_minus["primal objective"]
cost_final, lambda_best = self.spsa_step_two(
cost_plus=cost_plus,
cost_minus=cost_minus,
lambdas=lambdas,
spsa_params=spsa_params,
delta=delta,
count=count,
)
lambdas = lambda_best
interim_result = {"cost": cost_final, "kernel_parameters": lambdas}
print(interim_result)
self._user_messenger.publish(interim_result)
lambda_save.append(lambdas)
cost_final_save.append(cost_final)
# Evaluate aligned kernel matrix with optimized set of
# parameters averaged over last 10% of SPSA steps:
num_last_lambdas = int(len(lambda_save) * 0.10)
if num_last_lambdas > 0:
last_lambdas = np.array(lambda_save)[-num_last_lambdas:, :]
lambdas = np.sum(last_lambdas, axis=0) / num_last_lambdas
else:
lambdas = np.array(lambda_save)[-1, :]
kernel_best = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambdas
)
self.result["aligned_kernel_parameters"] = lambdas
self.result["aligned_kernel_matrix"] = kernel_best
return self.result
class KernelMatrix:
def __init__(self, feature_map, backend, initial_layout=None):
self._feature_map = feature_map
self._feature_map_circuit = self._feature_map.construct_circuit
self._backend = backend
self._initial_layout = initial_layout
self.results = {}
def construct_kernel_matrix(self, x1_vec, x2_vec, parameters=None):
is_identical = False
if np.array_equal(x1_vec, x2_vec):
is_identical = True
experiments = []
measurement_basis = "0" * self._feature_map._num_qubits
if is_identical:
my_product_list = list(
itertools.combinations(range(len(x1_vec)), 2)
) # all pairwise combos of datapoint indices
for index_1, index_2 in my_product_list:
circuit_1 = self._feature_map_circuit(
x=x1_vec[index_1], parameters=parameters, name="{}_{}".format(index_1, index_2)
)
circuit_2 = self._feature_map_circuit(
x=x1_vec[index_2], parameters=parameters, inverse=True
)
circuit = circuit_1.compose(circuit_2)
circuit.measure_all()
experiments.append(circuit)
experiments = transpile(
experiments, backend=self._backend, initial_layout=self._initial_layout
)
program_data = self._backend.run(experiments, shots=8192).result()
self.results["program_data"] = program_data
mat = np.eye(
len(x1_vec), len(x1_vec)
) # kernel matrix element on the diagonal is always 1
for experiment, [index_1, index_2] in enumerate(my_product_list):
counts = program_data.get_counts(experiment=experiment)
shots = sum(counts.values())
mat[index_1][index_2] = (
counts.get(measurement_basis, 0) / shots
) # kernel matrix element is the probability of measuring all 0s
mat[index_2][index_1] = mat[index_1][index_2] # kernel matrix is symmetric
return mat
else:
for index_1, point_1 in enumerate(x1_vec):
for index_2, point_2 in enumerate(x2_vec):
circuit_1 = self._feature_map_circuit(
x=point_1, parameters=parameters, name="{}_{}".format(index_1, index_2)
)
circuit_2 = self._feature_map_circuit(
x=point_2, parameters=parameters, inverse=True
)
circuit = circuit_1.compose(circuit_2)
circuit.measure_all()
experiments.append(circuit)
experiments = transpile(
experiments, backend=self._backend, initial_layout=self._initial_layout
)
program_data = self._backend.run(experiments, shots=8192).result()
self.results["program_data"] = program_data
mat = np.zeros((len(x1_vec), len(x2_vec)))
i = 0
for index_1, _ in enumerate(x1_vec):
for index_2, _ in enumerate(x2_vec):
counts = program_data.get_counts(experiment=i)
shots = sum(counts.values())
mat[index_1][index_2] = counts.get(measurement_basis, 0) / shots
i += 1
return mat
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# Copyright 2021 Dell (www.dell.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from dell_runtime.emulator_runtime_job import EmulatorRuntimeJob
import unittest
from qiskit import QuantumCircuit, execute, transpile
from qiskit.providers import JobStatus
import unittest
from urllib.parse import urljoin
import os, requests
import json
# import pytest_mysql
from server.orchestrator.models import DBService, Job, User, RuntimeProgram, Message, db_service
import pytest
from datetime import datetime
from time import sleep
SERVER_URL = os.getenv('SERVER_URL')
RUNTIME_PROGRAM = """
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
user_messenger.publish({'results': 'intermittently'})
circuits = transpile(
circuits,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
user_messenger.publish({'results': 'finally'})
user_messenger.publish(result.to_dict(), final=True)
print("job complete successfully")
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
# mysql_proc = pytest_mysql.factories.mysql_proc(port=3307)
def test_fetch_program_owner():
db_service = DBService()
rp = RuntimeProgram()
rp.program_id = "12"
rp.user_id = 1
rp.name = "test program"
rp.data = b'test program'
rp.program_metadata = "meta"
rp.status = 'Active'
rp.data_type = "DIR"
db_service.save_runtime_program(rp)
assert(db_service.fetch_program_owner("12") == 1)
def test_fetch_job_owner():
db_service = DBService()
rp = RuntimeProgram()
rp.program_id = "12"
rp.user_id = 1
rp.name = "test program"
rp.data = b'test program'
rp.program_metadata = "meta"
rp.status = 'Active'
rp.data_type = "DIR"
db_service.save_runtime_program(rp)
jb = Job()
jb.job_id = "123"
jb.program_id = "12"
jb.job_status = "Completed"
jb.pod_name = "pod"
jb.pod_status = "Running"
jb.data_token = "USED"
db_service.save_runtime_program(jb)
assert(db_service.fetch_job_owner("123") == 1)
def test_see_programs():
db_service = DBService()
rp = RuntimeProgram()
rp.program_id = "14"
rp.user_id = 1
rp.name = "test program"
rp.data = b'test program'
rp.program_metadata = "meta"
rp.status = 'Active'
rp.data_type = "DIR"
db_service.save_runtime_program(rp)
rp = RuntimeProgram()
rp.program_id = "13"
rp.user_id = 1
rp.name = "test program"
rp.data = b'test program'
rp.program_metadata = "meta"
rp.status = 'Active'
rp.data_type = "DIR"
db_service.save_runtime_program(rp)
rp = RuntimeProgram()
rp.program_id = "12"
rp.user_id = 2
rp.name = "test program"
rp.data = b'test program'
rp.program_metadata = "meta"
rp.status = 'Active'
rp.data_type = "DIR"
db_service.save_runtime_program(rp)
assert(len(db_service.fetch_runtime_programs(1)) == 2)
def test_use_job_token():
db_service = DBService()
jb = Job()
jb.job_id = "123"
jb.program_id = "12"
jb.job_status = "Completed"
jb.pod_name = "pod"
jb.pod_status = "Running"
jb.data_token = "token"
db_service.save_runtime_program(jb)
db_service.use_job_token("123")
assert(db_service.fetch_job_token("123") == "USED")
def test_fetch_messages_timestamp():
db_service = DBService()
db_service.save_message("123", "this message")
msgs = db_service.fetch_messages("123", None)
assert(len(msgs) == 1)
ts = datetime.fromisoformat(msgs[0]["timestamp"])
sleep(2)
db_service.save_message("123", "another message")
newmsgs = db_service.fetch_messages("123", ts)
assert(len(newmsgs) == 1)
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
import logging
import requests
import time
import os
RUNTIME_PROGRAM = """
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
circuits = transpile(
circuits,
)
user_messenger.publish({'results': 'intermittently'}, final=False)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results using either simulator or QPU backend.
result = backend.run(circuits, **kwargs).result()
user_messenger.publish(result.to_dict(), final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
PROGRAM_PREFIX = 'qiskit-test'
REMOTE_RUNTIME = os.getenv("SERVER_URL")
logging.basicConfig(level=logging.DEBUG)
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
print(f"PROGRAM ID: {program_id}")
programs = provider.runtime.pprint_programs(refresh=True)
provider.runtime.update_program(program_id, description="IBM/Dell Updated Qiskit Runtime Program")
programs = provider.runtime.pprint_programs(refresh=True)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
results = job.result(timeout=60)
print(results)
def callback_function(msg):
print(f'******************\n\n\nFrom Callback Function: {msg}\n\n\n******************')
job = provider.runtime.run(program_id, inputs=program_inputs, options=None, callback=callback_function)
program_inputs['backend_name'] = 'emulator'
job = provider.runtime.run(program_id, inputs=program_inputs, options=None, callback=callback_function)
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
import logging
import requests
import time
import os
RUNTIME_PROGRAM = """
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
circuits = transpile(
circuits,
)
user_messenger.publish({'results': 'intermittently'}, final=False)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
user_messenger.publish(result.to_dict(), final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
PROGRAM_PREFIX = 'qiskit-test'
REMOTE_RUNTIME = os.getenv("SERVER_URL")
logging.basicConfig(level=logging.DEBUG)
provider = DellRuntimeProvider()
provider.remote(REMOTE_RUNTIME)
text_program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
print(f"PROGRAM ID: {text_program_id}")
programs = provider.runtime.pprint_programs(refresh=True)
provider.runtime.update_program(text_program_id, description="IBM/Dell Updated Qiskit Runtime Program")
programs = provider.runtime.pprint_programs(refresh=True)
file_program_id = provider.runtime.upload_program("qka.py", description="File Upload to Orchestrator")
dir_program_id = provider.runtime.upload_program("./qkad", description="Directory Upload to Orchestrator")
provider.runtime.pprint_programs(refresh=True)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(text_program_id, options=None, inputs=program_inputs)
results = job.result(timeout=60)
print(results)
program_inputs['backend_name'] = 'emulator'
job = provider.runtime.run(text_program_id, inputs=program_inputs, options=None, callback=callback_function)
results = job.result(timeout=600)
print(results)
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
import pandas as pd
from time import sleep
import os
import base64
import shutil
import json
provider = DellRuntimeProvider()
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
provider.remote(os.getenv("SERVER_URL"))
here = os.path.dirname(os.path.realpath(__file__))
program_id = provider.runtime.upload_program(here + "../examples/programs/qkad", metadata=RUNTIME_PROGRAM_METADATA)
job = provider.runtime.run(program_id, options=None, inputs={})
res = job.result(timeout=1000)
print(res)
from qiskit.opflow import Z, I
from qiskit.circuit.library import EfficientSU2
import numpy as np
from qiskit.algorithms.optimizers import SPSA
from dell_runtime import DellRuntimeProvider
import os
from time import sleep
from datetime import datetime, timedelta
num_qubits = 4
hamiltonian = (Z ^ Z) ^ (I ^ (num_qubits - 2))
target_energy = -1
# the rotation gates are chosen randomly, so we set a seed for reproducibility
ansatz = EfficientSU2(num_qubits, reps=1, entanglement='linear', insert_barriers=True)
# ansatz.draw('mpl', style='iqx')
optimizer = SPSA(maxiter=50)
np.random.seed(10) # seed for reproducibility
initial_point = np.random.random(ansatz.num_parameters)
intermediate_info = {
'nfev': [],
'parameters': [],
'energy': [],
'stddev': []
}
timestamps = []
def raw_callback(*args):
(nfev, parameters, energy, stddev) = args[0]
intermediate_info['nfev'].append(nfev)
intermediate_info['parameters'].append(parameters)
intermediate_info['energy'].append(energy)
intermediate_info['stddev'].append(stddev)
vqe_inputs = {
'ansatz': ansatz,
'operator': hamiltonian,
'optimizer': {'name': 'SPSA', 'maxiter': 15}, # let's only do a few iterations!
'initial_point': initial_point,
'measurement_error_mitigation': True,
'shots': 1024,
# Include this parameter to use the snapshot instruction and return the ideal outcome
# that has no shot noise and avoids using the statevector simulator.
# 'include_custom': True
}
provider = DellRuntimeProvider()
provider.remote(os.getenv("SERVER_URL"))
program_id = provider.runtime.upload_program("vqe.py", description="Variational Quantum Eigensolver Program")
job = provider.runtime.run(
program_id=program_id,
inputs=vqe_inputs,
options=None,
callback=raw_callback
)
print('Job ID:', job.job_id)
result = job.result()
while not result:
print('no result yet.')
sleep(0.5)
result = job.result()
print(f"Intermediate Results: {intermediate_info}")
print(f'Reached {result["optimal_value"]} after {result["optimizer_evals"]} evaluations.')
print('Available keys:', list(result.keys()))
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
provider = DellRuntimeProvider()
provider.remote({server IP/URL})
program_id = provider.runtime.upload_program( \
(required) {data}, \
(optional) metadata={metadata}, \
(optional) name={name}, \
(optional) max_execution_time={max_execution_time}, \
(optional) description={description}, \
(optional) version={version}, \
(optional) backend_requirements={backend_requirements}, \
(optional) parameters={parameters}, \
(optional) return_values={return_values}, \
(optional) interim_results={interim_results}, \
)
job = provider.runtime.run( \
(required) {program_id}, \
(required) options={options}, \
(required) inputs={inputs}, \
(optional) callback={callback} \
)
int_results = job.get_unread_messages()
final_results = job.result()
final_results = job.result(timeout=60)
def custom_callback(*args):
(nfev, parameters, energy, stddev) = args[0]
intermediate_info['nfev'].append(nfev)
intermediate_info['parameters'].append(parameters)
intermediate_info['energy'].append(energy)
intermediate_info['stddev'].append(stddev)
job = provider.runtime.run(program_id, options=options, inputs=inputs, callback=custom_callback)
inputs = {
'backend_name': '{name_of_quantum_backend}',
'backend_token': '{backend_access_token}'
}
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
from dell_runtime import BackendProvider
provider = BackendProvider()
provider.backends()
backend = provider.get_backend(name="emulator")
backend_config = backend.configuration()
backend_config.backend_name
from qiskit import QuantumCircuit, execute
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
job = backend.run(qc, shots=1024)
result = job.result()
counts = result.get_counts(qc)
from qiskit.tools.visualization import plot_histogram, plot_state_city
plot_histogram(counts, title='Bell-State counts')
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
RUNTIME_PROGRAM = """
import random
from qiskit import transpile
from qiskit.circuit.random import random_circuit
def prepare_circuits(backend):
circuit = random_circuit(num_qubits=5, depth=4, measure=True,
seed=random.randint(0, 1000))
return transpile(circuit, backend)
def main(backend, user_messenger, **kwargs):
iterations = kwargs['iterations']
interim_results = kwargs.pop('interim_results', {})
final_result = kwargs.pop("final_result", {})
for it in range(iterations):
qc = prepare_circuits(backend)
user_messenger.publish({"iteration": it, "interim_results": interim_results})
backend.run(qc).result()
user_messenger.publish(final_result, final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
PROGRAM_PREFIX = 'qiskit-test'
provider = DellRuntimeProvider()
provider.runtime.programs()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
provider.runtime.pprint_programs()
runtime_program = provider.runtime.program(program_id)
program_inputs = {
"iterations": 10
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
job.status()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
from dell_runtime import BackendProvider
from qiskit import QuantumCircuit
provider = DellRuntimeProvider()
RUNTIME_PROGRAM = """
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# This is a simplified version of the circuit-runner program.
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
initial_layout=None,
seed_transpiler=None,
optimization_level=None,
transpiler_options=None,
scheduling_method=None,
schedule_circuit=False,
inst_map=None,
meas_map=None,
measurement_error_mitigation=False,
**kwargs,
):
# transpiling the circuits using given transpile options
transpiler_options = transpiler_options or {}
circuits = transpile(
circuits,
initial_layout=initial_layout,
seed_transpiler=seed_transpiler,
optimization_level=optimization_level,
backend=backend,
**transpiler_options,
)
if schedule_circuit:
circuits = schedule(
circuits=circuits,
backend=backend,
inst_map=inst_map,
meas_map=meas_map,
method=scheduling_method,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
if measurement_error_mitigation:
# Performs measurement error mitigation.
pass
user_messenger.publish(result.to_dict(), final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
N = 6
qc = QuantumCircuit(N)
qc.x(range(0, N))
qc.h(range(0, N))
for kk in range(N//2,0,-1):
qc.ch(kk, kk-1)
for kk in range(N//2, N-1):
qc.ch(kk, kk+1)
qc.measure_all()
program_inputs = {
'circuits': qc,
'shots': 2048,
'optimization_level': 0,
'initial_layout': [0,1,4,7,10,12],
'measurement_error_mitigation': False
}
runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
job.status()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
!pip install pandas
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
import pandas as pd
import os
from time import sleep
df = pd.read_csv('./aux_file/dataset_graph7.csv',sep=',', header=None) # alterative problem: dataset_graph10.csv
data = df.values
provider = DellRuntimeProvider()
print(df.head(4))
RUNTIME_PROGRAM = """
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=invalid-name
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
class FeatureMap:
def __init__(self, feature_dimension, entangler_map=None):
if isinstance(feature_dimension, int):
if feature_dimension % 2 == 0:
self._feature_dimension = feature_dimension
else:
raise ValueError("Feature dimension must be an even integer.")
else:
raise ValueError("Feature dimension must be an even integer.")
self._num_qubits = int(feature_dimension / 2)
if entangler_map is None:
self._entangler_map = [
[i, j]
for i in range(self._feature_dimension)
for j in range(i + 1, self._feature_dimension)
]
else:
self._entangler_map = entangler_map
self._num_parameters = self._num_qubits
def construct_circuit(self, x=None, parameters=None, q=None, inverse=False, name=None):
if parameters is not None:
if isinstance(parameters, (int, float)):
raise ValueError("Parameters must be a list.")
if len(parameters) == 1:
parameters = parameters * np.ones(self._num_qubits)
else:
if len(parameters) != self._num_parameters:
raise ValueError(
"The number of feature map parameters must be {}.".format(
self._num_parameters
)
)
if len(x) != self._feature_dimension:
raise ValueError(
"The input vector must be of length {}.".format(self._feature_dimension)
)
if q is None:
q = QuantumRegister(self._num_qubits, name="q")
circuit = QuantumCircuit(q, name=name)
for i in range(self._num_qubits):
circuit.ry(-parameters[i], q[i])
for source, target in self._entangler_map:
circuit.cz(q[source], q[target])
for i in range(self._num_qubits):
circuit.rz(-2 * x[2 * i + 1], q[i])
circuit.rx(-2 * x[2 * i], q[i])
if inverse:
return circuit.inverse()
else:
return circuit
def to_json(self):
return json.dumps(
{"feature_dimension": self._feature_dimension, "entangler_map": self._entangler_map}
)
@classmethod
def from_json(cls, data):
return cls(**json.loads(data))
class KernelMatrix:
def __init__(self, feature_map, backend, initial_layout=None):
self._feature_map = feature_map
self._feature_map_circuit = self._feature_map.construct_circuit
self._backend = backend
self._initial_layout = initial_layout
self.results = {}
def construct_kernel_matrix(self, x1_vec, x2_vec, parameters=None):
is_identical = False
if np.array_equal(x1_vec, x2_vec):
is_identical = True
experiments = []
measurement_basis = "0" * self._feature_map._num_qubits
if is_identical:
my_product_list = list(
itertools.combinations(range(len(x1_vec)), 2)
) # all pairwise combos of datapoint indices
for index_1, index_2 in my_product_list:
circuit_1 = self._feature_map_circuit(
x=x1_vec[index_1], parameters=parameters, name="{}_{}".format(index_1, index_2)
)
circuit_2 = self._feature_map_circuit(
x=x1_vec[index_2], parameters=parameters, inverse=True
)
circuit = circuit_1.compose(circuit_2)
circuit.measure_all()
experiments.append(circuit)
experiments = transpile(
experiments, backend=self._backend, initial_layout=self._initial_layout
)
program_data = self._backend.run(experiments, shots=8192).result()
self.results["program_data"] = program_data
mat = np.eye(
len(x1_vec), len(x1_vec)
) # kernel matrix element on the diagonal is always 1
for experiment, [index_1, index_2] in enumerate(my_product_list):
counts = program_data.get_counts(experiment=experiment)
shots = sum(counts.values())
mat[index_1][index_2] = (
counts.get(measurement_basis, 0) / shots
) # kernel matrix element is the probability of measuring all 0s
mat[index_2][index_1] = mat[index_1][index_2] # kernel matrix is symmetric
return mat
else:
for index_1, point_1 in enumerate(x1_vec):
for index_2, point_2 in enumerate(x2_vec):
circuit_1 = self._feature_map_circuit(
x=point_1, parameters=parameters, name="{}_{}".format(index_1, index_2)
)
circuit_2 = self._feature_map_circuit(
x=point_2, parameters=parameters, inverse=True
)
circuit = circuit_1.compose(circuit_2)
circuit.measure_all()
experiments.append(circuit)
experiments = transpile(
experiments, backend=self._backend, initial_layout=self._initial_layout
)
program_data = self._backend.run(experiments, shots=8192).result()
self.results["program_data"] = program_data
mat = np.zeros((len(x1_vec), len(x2_vec)))
i = 0
for index_1, _ in enumerate(x1_vec):
for index_2, _ in enumerate(x2_vec):
counts = program_data.get_counts(experiment=i)
shots = sum(counts.values())
mat[index_1][index_2] = counts.get(measurement_basis, 0) / shots
i += 1
return mat
class QKA:
def __init__(self, feature_map, backend, initial_layout=None, user_messenger=None):
self.feature_map = feature_map
self.feature_map_circuit = self.feature_map.construct_circuit
self.backend = backend
self.initial_layout = initial_layout
self.num_parameters = self.feature_map._num_parameters
self._user_messenger = user_messenger
self.result = {}
self.kernel_matrix = KernelMatrix(
feature_map=self.feature_map, backend=self.backend, initial_layout=self.initial_layout
)
def spsa_parameters(self):
spsa_params = np.zeros((5))
spsa_params[0] = 0.05 # a
spsa_params[1] = 0.1 # c
spsa_params[2] = 0.602 # alpha
spsa_params[3] = 0.101 # gamma
spsa_params[4] = 0 # A
return spsa_params
def cvxopt_solver(self, K, y, C, max_iters=10000, show_progress=False):
if y.ndim == 1:
y = y[:, np.newaxis]
H = np.outer(y, y) * K
f = -np.ones(y.shape)
n = K.shape[1] # number of training points
y = y.astype("float")
P = matrix(H)
q = matrix(f)
G = matrix(np.vstack((-np.eye((n)), np.eye((n)))))
h = matrix(np.vstack((np.zeros((n, 1)), np.ones((n, 1)) * C)))
A = matrix(y, y.T.shape)
b = matrix(np.zeros(1), (1, 1))
solvers.options["maxiters"] = max_iters
solvers.options["show_progress"] = show_progress
ret = solvers.qp(P, q, G, h, A, b, kktsolver="ldl")
return ret
def spsa_step_one(self, lambdas, spsa_params, count):
prng = RandomState(count)
c_spsa = float(spsa_params[1]) / np.power(count + 1, spsa_params[3])
delta = 2 * prng.randint(0, 2, size=np.shape(lambdas)[0]) - 1
lambda_plus = lambdas + c_spsa * delta
lambda_minus = lambdas - c_spsa * delta
return lambda_plus, lambda_minus, delta
def spsa_step_two(self, cost_plus, cost_minus, lambdas, spsa_params, delta, count):
a_spsa = float(spsa_params[0]) / np.power(count + 1 + spsa_params[4], spsa_params[2])
c_spsa = float(spsa_params[1]) / np.power(count + 1, spsa_params[3])
g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)
lambdas_new = lambdas - a_spsa * g_spsa
lambdas_new = lambdas_new.flatten()
cost_final = (cost_plus + cost_minus) / 2
return cost_final, lambdas_new
def align_kernel(self, data, labels, initial_kernel_parameters=None, maxiters=1, C=1):
if initial_kernel_parameters is not None:
lambdas = initial_kernel_parameters
else:
lambdas = np.random.uniform(-1.0, 1.0, size=(self.num_parameters))
spsa_params = self.spsa_parameters()
lambda_save = []
cost_final_save = []
for count in range(maxiters):
lambda_plus, lambda_minus, delta = self.spsa_step_one(
lambdas=lambdas, spsa_params=spsa_params, count=count
)
kernel_plus = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambda_plus
)
kernel_minus = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambda_minus
)
ret_plus = self.cvxopt_solver(K=kernel_plus, y=labels, C=C)
cost_plus = -1 * ret_plus["primal objective"]
ret_minus = self.cvxopt_solver(K=kernel_minus, y=labels, C=C)
cost_minus = -1 * ret_minus["primal objective"]
cost_final, lambda_best = self.spsa_step_two(
cost_plus=cost_plus,
cost_minus=cost_minus,
lambdas=lambdas,
spsa_params=spsa_params,
delta=delta,
count=count,
)
lambdas = lambda_best
interim_result = {"cost": cost_final, "kernel_parameters": lambdas}
self._user_messenger.publish(interim_result)
lambda_save.append(lambdas)
cost_final_save.append(cost_final)
# Evaluate aligned kernel matrix with optimized set of
# parameters averaged over last 10% of SPSA steps:
num_last_lambdas = int(len(lambda_save) * 0.10)
if num_last_lambdas > 0:
last_lambdas = np.array(lambda_save)[-num_last_lambdas:, :]
lambdas = np.sum(last_lambdas, axis=0) / num_last_lambdas
else:
lambdas = np.array(lambda_save)[-1, :]
kernel_best = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambdas
)
self.result["aligned_kernel_parameters"] = lambdas
self.result["aligned_kernel_matrix"] = kernel_best
return self.result
def main(backend, user_messenger, **kwargs):
# Reconstruct the feature map object.
feature_map = kwargs.get("feature_map")
fm = FeatureMap.from_json(feature_map)
data = kwargs.get("data")
labels = kwargs.get("labels")
initial_kernel_parameters = kwargs.get("initial_kernel_parameters", None)
maxiters = kwargs.get("maxiters", 1)
C = kwargs.get("C", 1)
initial_layout = kwargs.get("initial_layout", None)
qka = QKA(
feature_map=fm,
backend=backend,
initial_layout=initial_layout,
user_messenger=user_messenger,
)
qka_results = qka.align_kernel(
data=data,
labels=labels,
initial_kernel_parameters=initial_kernel_parameters,
maxiters=maxiters,
C=C,
)
user_messenger.publish(qka_results, final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
import numpy as np
import featuremaps
# choose number of training and test samples per class:
num_train = 10
num_test = 10
# extract training and test sets and sort them by class label
train = data[:2*num_train, :]
test = data[2*num_train:2*(num_train+num_test), :]
ind=np.argsort(train[:,-1])
x_train = train[ind][:,:-1]
y_train = train[ind][:,-1]
ind=np.argsort(test[:,-1])
x_test = test[ind][:,:-1]
y_test = test[ind][:,-1]
C = 1
maxiters = 10
initial_point = [0.1]
initial_layout = [10, 11, 12, 13, 14, 15, 16] # see figure above for the 7-qubit graph
# initial_layout = [9, 8, 11, 14, 16, 19, 22, 25, 24, 23] # see figure above for the 10-qubit graph
d = np.shape(data)[1]-1 # feature dimension is twice the qubit number
em = [[0,2],[3,4],[2,5],[1,4],[2,3],[4,6]]
fm = featuremaps.FeatureMap(feature_dimension=d, entangler_map=em)
program_inputs = {
'feature_map': fm,
'data': x_train,
'labels': y_train,
'initial_kernel_parameters': initial_point,
'maxiters': maxiters,
'C': C,
'initial_layout': initial_layout
}
runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
status = job.status()
while (status == "Creating" or status == "Running"):
sleep(5)
status = job.status()
print(f'job status: {status}')
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
import os
provider = DellRuntimeProvider()
provider.remote(os.getenv("SERVER_URL"))
provider.runtime.programs()
provider.runtime.pprint_programs()
RUNTIME_PROGRAM = """
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
user_messenger.publish({'results': 'intermittently'})
circuits = transpile(
circuits,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
user_messenger.publish({'results': 'finally'})
user_messenger.publish(result.to_dict(), final=True)
print("job complete successfully")
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
proglist = provider.runtime.programs()
proglist
program_id
provider.runtime.pprint_programs(refresh=True)
from qiskit import QuantumCircuit, execute, transpile
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
result = job.result(timeout=120)
job.status()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from qiskit import QuantumCircuit, execute, transpile
from dell_runtime import DellRuntimeProvider
provider = DellRuntimeProvider()
provider.remote('http://qdr-dev.oro-sandbox-small1.k8s.cec.lab.emc.com')
provider.runtime.programs()
RUNTIME_PROGRAM = """
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
user_messenger.publish({'results': 'intermittently'})
circuits = transpile(
circuits,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
for i in range(0, 10):
result = backend.run(circuits, **kwargs).result()
user_messenger.publish({f'result_{i}': result})
user_messenger.publish('completed', final=True)
print("job complete successfully")
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
program_id
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs, callback=print)
job.get_unread_messages()
job.result(timeout=20)
job.status()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""The FeatureMap class."""
import json
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
class FeatureMap:
"""Mapping data with the feature map."""
def __init__(self, feature_dimension, entangler_map=None):
"""
Args:
feature_dimension (int): number of features (twice the number of qubits for this
encoding)
entangler_map (list[list]): connectivity of qubits with a list of [source, target],
or None for full entanglement. Note that the order in the list is the order of
applying the two-qubit gate.
Raises:
ValueError: If the value of ``feature_dimension`` is odd.
"""
if isinstance(feature_dimension, int):
if feature_dimension % 2 == 0:
self._feature_dimension = feature_dimension
else:
raise ValueError("Feature dimension must be an even integer.")
else:
raise ValueError("Feature dimension must be an even integer.")
self._num_qubits = int(feature_dimension / 2)
if entangler_map is None:
self._entangler_map = [
[i, j] for i in range(self._num_qubits) for j in range(i + 1, self._num_qubits)
]
else:
self._entangler_map = entangler_map
self._num_parameters = self._num_qubits
def construct_circuit(self, x=None, parameters=None, q=None, inverse=False, name=None):
"""Construct the feature map circuit.
Args:
x (numpy.ndarray): data vector of size feature_dimension
parameters (numpy.ndarray): optional parameters in feature map
q (QauntumRegister): the QuantumRegister object for the circuit
inverse (bool): whether or not to invert the circuit
name (str): The name to use for the constructed ``QuantumCircuit`` object
Returns:
QuantumCircuit: a quantum circuit transforming data x
Raises:
ValueError: If the input parameters or vector are invalid
"""
if parameters is not None:
if isinstance(parameters, (int, float)):
raise ValueError("Parameters must be a list.")
if len(parameters) == 1:
parameters = parameters * np.ones(self._num_qubits)
else:
if len(parameters) != self._num_parameters:
raise ValueError(
"The number of feature map parameters must be {}.".format(
self._num_parameters
)
)
if len(x) != self._feature_dimension:
raise ValueError(
"The input vector must be of length {}.".format(self._feature_dimension)
)
if q is None:
q = QuantumRegister(self._num_qubits, name="q")
circuit = QuantumCircuit(q, name=name)
for i in range(self._num_qubits):
circuit.ry(-parameters[i], q[i])
for source, target in self._entangler_map:
circuit.cz(q[source], q[target])
for i in range(self._num_qubits):
circuit.rz(-2 * x[2 * i + 1], q[i])
circuit.rx(-2 * x[2 * i], q[i])
if inverse:
return circuit.inverse()
else:
return circuit
def to_json(self):
"""Return JSON representation of this object.
Returns:
str: JSON string representing this object.
"""
return json.dumps(
{"feature_dimension": self._feature_dimension, "entangler_map": self._entangler_map}
)
@classmethod
def from_json(cls, data):
"""Return an instance of this class from the JSON representation.
Args:
data (str): JSON string representing an object.
Returns:
FeatureMap: An instance of this class.
"""
return cls(**json.loads(data))
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
RUNTIME_PROGRAM = """
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
circuits = transpile(
circuits,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
user_messenger.publish(result.to_dict(), final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
# PROGRAM_PREFIX = 'qiskit-test'
def main():
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
job.result(timeout=120)
if __name__ == "__main__":
main()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""The FeatureMap class."""
import json
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
class FeatureMap:
"""Mapping data with the feature map."""
def __init__(self, feature_dimension, entangler_map=None):
"""
Args:
feature_dimension (int): number of features (twice the number of qubits for this
encoding)
entangler_map (list[list]): connectivity of qubits with a list of [source, target],
or None for full entanglement. Note that the order in the list is the order of
applying the two-qubit gate.
Raises:
ValueError: If the value of ``feature_dimension`` is odd.
"""
if isinstance(feature_dimension, int):
if feature_dimension % 2 == 0:
self._feature_dimension = feature_dimension
else:
raise ValueError("Feature dimension must be an even integer.")
else:
raise ValueError("Feature dimension must be an even integer.")
self._num_qubits = int(feature_dimension / 2)
if entangler_map is None:
self._entangler_map = [
[i, j] for i in range(self._num_qubits) for j in range(i + 1, self._num_qubits)
]
else:
self._entangler_map = entangler_map
self._num_parameters = self._num_qubits
def construct_circuit(self, x=None, parameters=None, q=None, inverse=False, name=None):
"""Construct the feature map circuit.
Args:
x (numpy.ndarray): data vector of size feature_dimension
parameters (numpy.ndarray): optional parameters in feature map
q (QauntumRegister): the QuantumRegister object for the circuit
inverse (bool): whether or not to invert the circuit
name (str): The name to use for the constructed ``QuantumCircuit`` object
Returns:
QuantumCircuit: a quantum circuit transforming data x
Raises:
ValueError: If the input parameters or vector are invalid
"""
if parameters is not None:
if isinstance(parameters, (int, float)):
raise ValueError("Parameters must be a list.")
if len(parameters) == 1:
parameters = parameters * np.ones(self._num_qubits)
else:
if len(parameters) != self._num_parameters:
raise ValueError(
"The number of feature map parameters must be {}.".format(
self._num_parameters
)
)
if len(x) != self._feature_dimension:
raise ValueError(
"The input vector must be of length {}.".format(self._feature_dimension)
)
if q is None:
q = QuantumRegister(self._num_qubits, name="q")
circuit = QuantumCircuit(q, name=name)
for i in range(self._num_qubits):
circuit.ry(-parameters[i], q[i])
for source, target in self._entangler_map:
circuit.cz(q[source], q[target])
for i in range(self._num_qubits):
circuit.rz(-2 * x[2 * i + 1], q[i])
circuit.rx(-2 * x[2 * i], q[i])
if inverse:
return circuit.inverse()
else:
return circuit
def to_json(self):
"""Return JSON representation of this object.
Returns:
str: JSON string representing this object.
"""
return json.dumps(
{"feature_dimension": self._feature_dimension, "entangler_map": self._entangler_map}
)
@classmethod
def from_json(cls, data):
"""Return an instance of this class from the JSON representation.
Args:
data (str): JSON string representing an object.
Returns:
FeatureMap: An instance of this class.
"""
return cls(**json.loads(data))
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
import logging
import requests
import time
RUNTIME_PROGRAM = """
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
from qiskit.compiler import transpile, schedule
import time
def main(backend, user_messenger, **kwargs):
iterations = kwargs.pop("iterations", 5)
for it in range(iterations):
user_messenger.publish({"iteration": it })
time.sleep(5)
user_messenger.publish("All done!", final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
PROGRAM_PREFIX = 'qiskit-test'
REMOTE_RUNTIME = 'http://localhost:8080'
def main():
print("Starting...")
logging.basicConfig(level=logging.DEBUG)
provider = DellRuntimeProvider()
# provider.remote(REMOTE_RUNTIME)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
print(f"PROGRAM ID: {program_id}")
program_inputs = {
'iterations': 3,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
time.sleep(2)
print(job.get_unread_messages())
results = job.result(timeout=25)
print(results)
if __name__ == "__main__":
main()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
import os
import logging
logging.basicConfig(level=logging.DEBUG)
RUNTIME_PROGRAM = """
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# This is a simplified version of the circuit-runner program.
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
initial_layout=None,
seed_transpiler=None,
optimization_level=None,
transpiler_options=None,
scheduling_method=None,
schedule_circuit=False,
inst_map=None,
meas_map=None,
measurement_error_mitigation=False,
**kwargs,
):
# transpiling the circuits using given transpile options
transpiler_options = transpiler_options or {}
circuits = transpile(
circuits,
initial_layout=initial_layout,
seed_transpiler=seed_transpiler,
optimization_level=optimization_level,
backend=backend,
**transpiler_options,
)
if schedule_circuit:
circuits = schedule(
circuits=circuits,
backend=backend,
inst_map=inst_map,
meas_map=meas_map,
method=scheduling_method,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
if measurement_error_mitigation:
# Performs measurement error mitigation.
pass
user_messenger.publish(result.to_dict(), final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
PROGRAM_PREFIX = 'qiskit-test'
def main():
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
N = 6
qc = QuantumCircuit(N)
qc.x(range(0, N))
qc.h(range(0, N))
for kk in range(N//2,0,-1):
qc.ch(kk, kk-1)
for kk in range(N//2, N-1):
qc.ch(kk, kk+1)
qc.measure_all()
program_inputs = {
'circuits': qc,
'shots': 2048,
'optimization_level': 0,
'initial_layout': [0,1,4,7,10,12],
'measurement_error_mitigation': False
}
runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
res = job.result(timeout=120)
print(f"res: {res}")
if __name__ == "__main__":
main()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
class QKA:
def __init__(self, feature_map, backend, initial_layout=None, user_messenger=None):
self.feature_map = feature_map
self.feature_map_circuit = self.feature_map.construct_circuit
self.backend = backend
self.initial_layout = initial_layout
self.num_parameters = self.feature_map._num_parameters
self._user_messenger = user_messenger
self.result = {}
self.kernel_matrix = KernelMatrix(
feature_map=self.feature_map, backend=self.backend, initial_layout=self.initial_layout
)
def spsa_parameters(self):
spsa_params = np.zeros((5))
spsa_params[0] = 0.05 # a
spsa_params[1] = 0.1 # c
spsa_params[2] = 0.602 # alpha
spsa_params[3] = 0.101 # gamma
spsa_params[4] = 0 # A
return spsa_params
def cvxopt_solver(self, K, y, C, max_iters=10000, show_progress=False):
if y.ndim == 1:
y = y[:, np.newaxis]
H = np.outer(y, y) * K
f = -np.ones(y.shape)
n = K.shape[1] # number of training points
y = y.astype("float")
P = matrix(H)
q = matrix(f)
G = matrix(np.vstack((-np.eye((n)), np.eye((n)))))
h = matrix(np.vstack((np.zeros((n, 1)), np.ones((n, 1)) * C)))
A = matrix(y, y.T.shape)
b = matrix(np.zeros(1), (1, 1))
solvers.options["maxiters"] = max_iters
solvers.options["show_progress"] = show_progress
ret = solvers.qp(P, q, G, h, A, b, kktsolver="ldl")
return ret
def spsa_step_one(self, lambdas, spsa_params, count):
prng = RandomState(count)
c_spsa = float(spsa_params[1]) / np.power(count + 1, spsa_params[3])
delta = 2 * prng.randint(0, 2, size=np.shape(lambdas)[0]) - 1
lambda_plus = lambdas + c_spsa * delta
lambda_minus = lambdas - c_spsa * delta
return lambda_plus, lambda_minus, delta
def spsa_step_two(self, cost_plus, cost_minus, lambdas, spsa_params, delta, count):
a_spsa = float(spsa_params[0]) / np.power(count + 1 + spsa_params[4], spsa_params[2])
c_spsa = float(spsa_params[1]) / np.power(count + 1, spsa_params[3])
g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)
lambdas_new = lambdas - a_spsa * g_spsa
lambdas_new = lambdas_new.flatten()
cost_final = (cost_plus + cost_minus) / 2
return cost_final, lambdas_new
def align_kernel(self, data, labels, initial_kernel_parameters=None, maxiters=1, C=1):
if initial_kernel_parameters is not None:
lambdas = initial_kernel_parameters
else:
lambdas = np.random.uniform(-1.0, 1.0, size=(self.num_parameters))
spsa_params = self.spsa_parameters()
lambda_save = []
cost_final_save = []
for count in range(maxiters):
lambda_plus, lambda_minus, delta = self.spsa_step_one(
lambdas=lambdas, spsa_params=spsa_params, count=count
)
kernel_plus = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambda_plus
)
kernel_minus = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambda_minus
)
ret_plus = self.cvxopt_solver(K=kernel_plus, y=labels, C=C)
cost_plus = -1 * ret_plus["primal objective"]
ret_minus = self.cvxopt_solver(K=kernel_minus, y=labels, C=C)
cost_minus = -1 * ret_minus["primal objective"]
cost_final, lambda_best = self.spsa_step_two(
cost_plus=cost_plus,
cost_minus=cost_minus,
lambdas=lambdas,
spsa_params=spsa_params,
delta=delta,
count=count,
)
lambdas = lambda_best
interim_result = {"cost": cost_final, "kernel_parameters": lambdas}
print(interim_result)
self._user_messenger.publish(interim_result)
lambda_save.append(lambdas)
cost_final_save.append(cost_final)
# Evaluate aligned kernel matrix with optimized set of
# parameters averaged over last 10% of SPSA steps:
num_last_lambdas = int(len(lambda_save) * 0.10)
if num_last_lambdas > 0:
last_lambdas = np.array(lambda_save)[-num_last_lambdas:, :]
lambdas = np.sum(last_lambdas, axis=0) / num_last_lambdas
else:
lambdas = np.array(lambda_save)[-1, :]
kernel_best = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambdas
)
self.result["aligned_kernel_parameters"] = lambdas
self.result["aligned_kernel_matrix"] = kernel_best
return self.result
class KernelMatrix:
def __init__(self, feature_map, backend, initial_layout=None):
self._feature_map = feature_map
self._feature_map_circuit = self._feature_map.construct_circuit
self._backend = backend
self._initial_layout = initial_layout
self.results = {}
def construct_kernel_matrix(self, x1_vec, x2_vec, parameters=None):
is_identical = False
if np.array_equal(x1_vec, x2_vec):
is_identical = True
experiments = []
measurement_basis = "0" * self._feature_map._num_qubits
if is_identical:
my_product_list = list(
itertools.combinations(range(len(x1_vec)), 2)
) # all pairwise combos of datapoint indices
for index_1, index_2 in my_product_list:
circuit_1 = self._feature_map_circuit(
x=x1_vec[index_1], parameters=parameters, name="{}_{}".format(index_1, index_2)
)
circuit_2 = self._feature_map_circuit(
x=x1_vec[index_2], parameters=parameters, inverse=True
)
circuit = circuit_1.compose(circuit_2)
circuit.measure_all()
experiments.append(circuit)
experiments = transpile(
experiments, backend=self._backend, initial_layout=self._initial_layout
)
program_data = self._backend.run(experiments, shots=8192).result()
self.results["program_data"] = program_data
mat = np.eye(
len(x1_vec), len(x1_vec)
) # kernel matrix element on the diagonal is always 1
for experiment, [index_1, index_2] in enumerate(my_product_list):
counts = program_data.get_counts(experiment=experiment)
shots = sum(counts.values())
mat[index_1][index_2] = (
counts.get(measurement_basis, 0) / shots
) # kernel matrix element is the probability of measuring all 0s
mat[index_2][index_1] = mat[index_1][index_2] # kernel matrix is symmetric
return mat
else:
for index_1, point_1 in enumerate(x1_vec):
for index_2, point_2 in enumerate(x2_vec):
circuit_1 = self._feature_map_circuit(
x=point_1, parameters=parameters, name="{}_{}".format(index_1, index_2)
)
circuit_2 = self._feature_map_circuit(
x=point_2, parameters=parameters, inverse=True
)
circuit = circuit_1.compose(circuit_2)
circuit.measure_all()
experiments.append(circuit)
experiments = transpile(
experiments, backend=self._backend, initial_layout=self._initial_layout
)
program_data = self._backend.run(experiments, shots=8192).result()
self.results["program_data"] = program_data
mat = np.zeros((len(x1_vec), len(x2_vec)))
i = 0
for index_1, _ in enumerate(x1_vec):
for index_2, _ in enumerate(x2_vec):
counts = program_data.get_counts(experiment=i)
shots = sum(counts.values())
mat[index_1][index_2] = counts.get(measurement_basis, 0) / shots
i += 1
return mat
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
#!/usr/bin/env python
# coding: utf-8
# In[2]:
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
import pandas as pd
from time import sleep
import os
import base64
import shutil
import json
# here = os.path.dirname(os.path.realpath(__file__))
# zipped = shutil.make_archive(here + "/tmp", "zip", here + "/qkad")
# with open(zipped, "rb") as z:
# data = z.read()
# data = base64.urlsafe_b64encode(data)
# sdata = str(data, "utf-8")
# bdata = bytes(sdata, "utf-8")
# sdata = str(bdata, "utf-8")
# obj = {
# 'data': sdata,
# 'data_type': "DIR"
# }
# jsonstr = json.dumps(obj)
# ljson = json.loads(jsonstr)
# bdata = bytes(ljson['data'], "utf-8")
# b64data = base64.urlsafe_b64decode(bdata)
# with open(zipped, "wb") as temp:
# temp.write(b64data)
# shutil.unpack_archive(zipped, extract_dir=here + "/qkad1", format="zip")
# os.remove(zipped)
provider = DellRuntimeProvider()
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
provider.remote(os.getenv("SERVER_URL"))
here = os.path.dirname(os.path.realpath(__file__))
program_id = provider.runtime.upload_program(here + "/qkad", metadata=RUNTIME_PROGRAM_METADATA)
job = provider.runtime.run(program_id, options=None, inputs={})
res = job.result(timeout=1000)
print(res)
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
import logging
import requests
import time
import os
RUNTIME_PROGRAM = """
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
circuits = transpile(
circuits,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
user_messenger.publish(result.to_dict(), final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
PROGRAM_PREFIX = 'qiskit-test'
REMOTE_RUNTIME = os.getenv("SERVER_URL")
def main():
print("Starting...")
logging.basicConfig(level=logging.DEBUG)
provider = DellRuntimeProvider()
provider.remote(REMOTE_RUNTIME)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
print(f"PROGRAM ID: {program_id}")
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
# job.stream_results(print)
results = job.result(timeout=60)
print(results)
if __name__ == "__main__":
main()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=invalid-name
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
from qtils.featuremap import FeatureMap
from qtils.qka import QKA
import os
import pandas as pd
def main(backend, user_messenger, **kwargs):
df = pd.read_csv(os.path.dirname(os.path.abspath(__file__)) + '/aux_file/dataset_graph7.csv',sep=',', header=None) # alterative problem: dataset_graph10.csv
data = df.values
# choose number of training and test samples per class:
num_train = 10
num_test = 10
# extract training and test sets and sort them by class label
train = data[:2*num_train, :]
test = data[2*num_train:2*(num_train+num_test), :]
ind=np.argsort(train[:,-1])
x_train = train[ind][:,:-1]
y_train = train[ind][:,-1]
ind=np.argsort(test[:,-1])
x_test = test[ind][:,:-1]
y_test = test[ind][:,-1]
C = 1
maxiters = 1
initial_point = [0.1]
initial_layout = [10, 11, 12, 13, 14, 15, 16] # see figure above for the 7-qubit graph
# initial_layout = [9, 8, 11, 14, 16, 19, 22, 25, 24, 23] # see figure above for the 10-qubit graph
d = np.shape(data)[1]-1 # feature dimension is twice the qubit number
em = [[0,2],[3,4],[2,5],[1,4],[2,3],[4,6]]
fm = FeatureMap(feature_dimension=d, entangler_map=em)
qka = QKA(
feature_map=fm,
backend=backend,
initial_layout=initial_layout,
user_messenger=user_messenger,
)
qka_results = qka.align_kernel(
data=x_train,
labels=y_train,
initial_kernel_parameters=initial_point,
maxiters=maxiters,
C=C,
)
user_messenger.publish(qka_results, final=True)
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
from .qka import QKA
class FeatureMap:
def __init__(self, feature_dimension, entangler_map=None):
if isinstance(feature_dimension, int):
if feature_dimension % 2 == 0:
self._feature_dimension = feature_dimension
else:
raise ValueError("Feature dimension must be an even integer.")
else:
raise ValueError("Feature dimension must be an even integer.")
self._num_qubits = int(feature_dimension / 2)
if entangler_map is None:
self._entangler_map = [
[i, j]
for i in range(self._feature_dimension)
for j in range(i + 1, self._feature_dimension)
]
else:
self._entangler_map = entangler_map
self._num_parameters = self._num_qubits
def construct_circuit(self, x=None, parameters=None, q=None, inverse=False, name=None):
if parameters is not None:
if isinstance(parameters, (int, float)):
raise ValueError("Parameters must be a list.")
if len(parameters) == 1:
parameters = parameters * np.ones(self._num_qubits)
else:
if len(parameters) != self._num_parameters:
raise ValueError(
"The number of feature map parameters must be {}.".format(
self._num_parameters
)
)
if len(x) != self._feature_dimension:
raise ValueError(
"The input vector must be of length {}.".format(self._feature_dimension)
)
if q is None:
q = QuantumRegister(self._num_qubits, name="q")
circuit = QuantumCircuit(q, name=name)
for i in range(self._num_qubits):
circuit.ry(-parameters[i], q[i])
for source, target in self._entangler_map:
circuit.cz(q[source], q[target])
for i in range(self._num_qubits):
circuit.rz(-2 * x[2 * i + 1], q[i])
circuit.rx(-2 * x[2 * i], q[i])
if inverse:
return circuit.inverse()
else:
return circuit
def to_json(self):
return json.dumps(
{"feature_dimension": self._feature_dimension, "entangler_map": self._entangler_map}
)
@classmethod
def from_json(cls, data):
return cls(**json.loads(data))
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
class QKA:
def __init__(self, feature_map, backend, initial_layout=None, user_messenger=None):
self.feature_map = feature_map
self.feature_map_circuit = self.feature_map.construct_circuit
self.backend = backend
self.initial_layout = initial_layout
self.num_parameters = self.feature_map._num_parameters
self._user_messenger = user_messenger
self.result = {}
self.kernel_matrix = KernelMatrix(
feature_map=self.feature_map, backend=self.backend, initial_layout=self.initial_layout
)
def spsa_parameters(self):
spsa_params = np.zeros((5))
spsa_params[0] = 0.05 # a
spsa_params[1] = 0.1 # c
spsa_params[2] = 0.602 # alpha
spsa_params[3] = 0.101 # gamma
spsa_params[4] = 0 # A
return spsa_params
def cvxopt_solver(self, K, y, C, max_iters=10000, show_progress=False):
if y.ndim == 1:
y = y[:, np.newaxis]
H = np.outer(y, y) * K
f = -np.ones(y.shape)
n = K.shape[1] # number of training points
y = y.astype("float")
P = matrix(H)
q = matrix(f)
G = matrix(np.vstack((-np.eye((n)), np.eye((n)))))
h = matrix(np.vstack((np.zeros((n, 1)), np.ones((n, 1)) * C)))
A = matrix(y, y.T.shape)
b = matrix(np.zeros(1), (1, 1))
solvers.options["maxiters"] = max_iters
solvers.options["show_progress"] = show_progress
ret = solvers.qp(P, q, G, h, A, b, kktsolver="ldl")
return ret
def spsa_step_one(self, lambdas, spsa_params, count):
prng = RandomState(count)
c_spsa = float(spsa_params[1]) / np.power(count + 1, spsa_params[3])
delta = 2 * prng.randint(0, 2, size=np.shape(lambdas)[0]) - 1
lambda_plus = lambdas + c_spsa * delta
lambda_minus = lambdas - c_spsa * delta
return lambda_plus, lambda_minus, delta
def spsa_step_two(self, cost_plus, cost_minus, lambdas, spsa_params, delta, count):
a_spsa = float(spsa_params[0]) / np.power(count + 1 + spsa_params[4], spsa_params[2])
c_spsa = float(spsa_params[1]) / np.power(count + 1, spsa_params[3])
g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)
lambdas_new = lambdas - a_spsa * g_spsa
lambdas_new = lambdas_new.flatten()
cost_final = (cost_plus + cost_minus) / 2
return cost_final, lambdas_new
def align_kernel(self, data, labels, initial_kernel_parameters=None, maxiters=1, C=1):
if initial_kernel_parameters is not None:
lambdas = initial_kernel_parameters
else:
lambdas = np.random.uniform(-1.0, 1.0, size=(self.num_parameters))
spsa_params = self.spsa_parameters()
lambda_save = []
cost_final_save = []
for count in range(maxiters):
lambda_plus, lambda_minus, delta = self.spsa_step_one(
lambdas=lambdas, spsa_params=spsa_params, count=count
)
kernel_plus = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambda_plus
)
kernel_minus = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambda_minus
)
ret_plus = self.cvxopt_solver(K=kernel_plus, y=labels, C=C)
cost_plus = -1 * ret_plus["primal objective"]
ret_minus = self.cvxopt_solver(K=kernel_minus, y=labels, C=C)
cost_minus = -1 * ret_minus["primal objective"]
cost_final, lambda_best = self.spsa_step_two(
cost_plus=cost_plus,
cost_minus=cost_minus,
lambdas=lambdas,
spsa_params=spsa_params,
delta=delta,
count=count,
)
lambdas = lambda_best
interim_result = {"cost": cost_final, "kernel_parameters": lambdas}
print(interim_result)
self._user_messenger.publish(interim_result)
lambda_save.append(lambdas)
cost_final_save.append(cost_final)
# Evaluate aligned kernel matrix with optimized set of
# parameters averaged over last 10% of SPSA steps:
num_last_lambdas = int(len(lambda_save) * 0.10)
if num_last_lambdas > 0:
last_lambdas = np.array(lambda_save)[-num_last_lambdas:, :]
lambdas = np.sum(last_lambdas, axis=0) / num_last_lambdas
else:
lambdas = np.array(lambda_save)[-1, :]
kernel_best = self.kernel_matrix.construct_kernel_matrix(
x1_vec=data, x2_vec=data, parameters=lambdas
)
self.result["aligned_kernel_parameters"] = lambdas
self.result["aligned_kernel_matrix"] = kernel_best
return self.result
class KernelMatrix:
def __init__(self, feature_map, backend, initial_layout=None):
self._feature_map = feature_map
self._feature_map_circuit = self._feature_map.construct_circuit
self._backend = backend
self._initial_layout = initial_layout
self.results = {}
def construct_kernel_matrix(self, x1_vec, x2_vec, parameters=None):
is_identical = False
if np.array_equal(x1_vec, x2_vec):
is_identical = True
experiments = []
measurement_basis = "0" * self._feature_map._num_qubits
if is_identical:
my_product_list = list(
itertools.combinations(range(len(x1_vec)), 2)
) # all pairwise combos of datapoint indices
for index_1, index_2 in my_product_list:
circuit_1 = self._feature_map_circuit(
x=x1_vec[index_1], parameters=parameters, name="{}_{}".format(index_1, index_2)
)
circuit_2 = self._feature_map_circuit(
x=x1_vec[index_2], parameters=parameters, inverse=True
)
circuit = circuit_1.compose(circuit_2)
circuit.measure_all()
experiments.append(circuit)
experiments = transpile(
experiments, backend=self._backend, initial_layout=self._initial_layout
)
program_data = self._backend.run(experiments, shots=8192).result()
self.results["program_data"] = program_data
mat = np.eye(
len(x1_vec), len(x1_vec)
) # kernel matrix element on the diagonal is always 1
for experiment, [index_1, index_2] in enumerate(my_product_list):
counts = program_data.get_counts(experiment=experiment)
shots = sum(counts.values())
mat[index_1][index_2] = (
counts.get(measurement_basis, 0) / shots
) # kernel matrix element is the probability of measuring all 0s
mat[index_2][index_1] = mat[index_1][index_2] # kernel matrix is symmetric
return mat
else:
for index_1, point_1 in enumerate(x1_vec):
for index_2, point_2 in enumerate(x2_vec):
circuit_1 = self._feature_map_circuit(
x=point_1, parameters=parameters, name="{}_{}".format(index_1, index_2)
)
circuit_2 = self._feature_map_circuit(
x=point_2, parameters=parameters, inverse=True
)
circuit = circuit_1.compose(circuit_2)
circuit.measure_all()
experiments.append(circuit)
experiments = transpile(
experiments, backend=self._backend, initial_layout=self._initial_layout
)
program_data = self._backend.run(experiments, shots=8192).result()
self.results["program_data"] = program_data
mat = np.zeros((len(x1_vec), len(x2_vec)))
i = 0
for index_1, _ in enumerate(x1_vec):
for index_2, _ in enumerate(x2_vec):
counts = program_data.get_counts(experiment=i)
shots = sum(counts.values())
mat[index_1][index_2] = counts.get(measurement_basis, 0) / shots
i += 1
return mat
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# Copyright 2021 Dell (www.dell.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from qiskit.providers import JobV1
from qiskit.providers import JobStatus, JobError
from qiskit import transpile
from qiskit_aer import Aer
import functools
def requires_submit(func):
"""
Decorator to ensure that a submit has been performed before
calling the method.
Args:
func (callable): test function to be decorated.
Returns:
callable: the decorated function.
"""
@functools.wraps(func)
def _wrapper(self, *args, **kwargs):
if self.my_job is None:
raise JobError("Job not submitted yet!. You have to .submit() first!")
return func(self, *args, **kwargs)
return _wrapper
class EmulatorJob(JobV1):
def __init__(self, backend, job_id, circuit, shots):
super().__init__(backend, job_id)
self.circuit = circuit
self.shots = shots
self.my_job = None
@requires_submit
def result(self, timeout=None):
return self.my_job.result(timeout=timeout)
def submit(self):
backend = Aer.get_backend('aer_simulator')
self.my_job = backend.run(self.circuit, shots = self.shots)
@requires_submit
def cancel(self):
return self.my_job.cancel()
@requires_submit
def status(self):
return self.my_job.status()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# Copyright 2021 Dell (www.dell.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from qiskit_aer import Aer
from qiskit.providers.exceptions import QiskitBackendNotFoundError
# from qiskit import IBMQ
from .emulator_backend import EmulatorBackend
class LocalSubProviderManager():
def __init__(self, provider):
self._provider = provider
self._init_backends()
def _init_backends(self):
self._backends = [Aer.get_backend('aer_simulator')]
self._backends.append(EmulatorBackend(self._provider))
# for sub_provider in self.sub_providers:
# self._backends += sub_provider.backends()
self._backends_by_name = {}
for backend in self._backends:
self._backends_by_name[backend.name] = backend
def backends(self):
return self._backends
def get_backend(self, name=None, **kwargs):
if name not in self._backends_by_name:
raise QiskitBackendNotFoundError("No backend matches criteria.")
else:
return self._backends_by_name[name]
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
RUNTIME_PROGRAM = """
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
circuits = transpile(
circuits,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
user_messenger.publish(result.to_dict(), final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
# PROGRAM_PREFIX = 'qiskit-test'
def main():
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
job.result(timeout=120)
if __name__ == "__main__":
main()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
import os
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
# PROGRAM_PREFIX = 'qiskit-test'
def main():
provider = DellRuntimeProvider()
here = os.path.dirname(os.path.realpath(__file__))
program_id = provider.runtime.upload_program(here + "/dirtest", metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
job.result(timeout=120)
if __name__ == "__main__":
main()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# Copyright 2021 Dell (www.dell.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
import os
import json
import logging
# from ..dell_runtime.emulation_executor import EmulationExecutor
from dell_runtime import EmulationExecutor
RUNTIME_PROGRAM = """
import random
from qiskit import transpile
from qiskit.circuit.random import random_circuit
def prepare_circuits(backend):
circuit = random_circuit(num_qubits=5, depth=4, measure=True,
seed=random.randint(0, 1000))
return transpile(circuit, backend)
def main(backend, user_messenger, **kwargs):
iterations = kwargs['iterations']
interim_results = kwargs.pop('interim_results', {})
final_result = kwargs.pop("final_result", {})
for it in range(iterations):
qc = prepare_circuits(backend)
user_messenger.publish({"iteration": it, "interim_results": interim_results})
backend.run(qc).result()
user_messenger.publish(final_result, final=True)
"""
logger = logging.getLogger(__name__)
class EmulationExecutorTest(unittest.TestCase):
def test_pre_post_run(self):
try:
executor = EmulationExecutor(program=None, program_data=(RUNTIME_PROGRAM, "STRING"))
self.assertIsNotNone(executor)
executor._pre_run()
self.assertTrue(os.path.isdir(executor.temp_dir()))
program_path = os.path.join(executor.temp_dir(), "program.py")
self.assertTrue(os.path.isfile(program_path))
with open(program_path, "r") as program_file:
program_text = program_file.read()
self.assertEqual(RUNTIME_PROGRAM, program_text)
executor_path = os.path.join(executor.temp_dir(), "executor.py")
self.assertTrue(os.path.isfile(executor_path))
finally:
executor._post_run()
self.assertFalse(os.path.isdir(executor.temp_dir()))
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# Copyright 2021 Dell (www.dell.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
from qiskit import QuantumCircuit, execute, transpile
from dell_runtime import BackendProvider
from qiskit.providers import JobStatus
from time import sleep
class ProviderTest(unittest.TestCase):
def test_job_submission(self):
provider = BackendProvider()
self.assertIsNotNone(provider)
backend = provider.get_backend(name="aer_simulator")
self.assertIsNotNone(backend)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
job = backend.run(qc, shots=1)
self.assertIsNotNone(job)
# self.assertNotEqual(JobStatus.DONE, job.status())
count = 0
# 5 second
max = 50
while count < max and job.status() != JobStatus.DONE:
count += 1
sleep(0.1)
self.assertEqual(JobStatus.DONE, job.status())
job.result()
def test_execute(self):
provider = BackendProvider()
self.assertIsNotNone(provider)
backend = provider.get_backend(name="aer_simulator")
self.assertIsNotNone(backend)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
job = execute(qc, backend, shots=2)
self.assertIsNotNone(job)
count = 0
# 5 second
max = 50
while count < max and job.status() != JobStatus.DONE:
count += 1
sleep(0.1)
self.assertEqual(JobStatus.DONE, job.status())
def test_get_counts(self):
provider = BackendProvider()
self.assertIsNotNone(provider)
backend = provider.get_backend(name="aer_simulator")
self.assertIsNotNone(backend)
circ = QuantumCircuit(2)
circ.h(0)
circ.cx(0, 1)
circ.measure_all()
# Transpile for simulator
circ = transpile(circ, backend)
# Run and get counts
result = backend.run(circ).result()
counts = result.get_counts(circ)
total = counts.get('11') + counts.get('00')
self.assertEqual(total, 1024)
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# Copyright 2021 Dell (www.dell.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from dell_runtime import DellRuntimeProvider
import unittest
from dell_runtime import LocalUserMessengerClient
from dell_runtime import EmulatorRuntimeJob, EmulationExecutor
from qiskit import QuantumCircuit, execute, transpile
from time import sleep
import logging
# RUNTIME_PROGRAM = """
# import random
# from qiskit import transpile
# from qiskit.circuit.random import random_circuit
# def prepare_circuits(backend):
# circuit = random_circuit(num_qubits=5, depth=4, measure=True,
# seed=random.randint(0, 1000))
# return transpile(circuit, backend)
# def main(backend, user_messenger, **kwargs):
# iterations = kwargs['iterations']
# interim_results = kwargs.pop('interim_results', {})
# final_result = kwargs.pop("final_result", {})
# for it in range(iterations):
# qc = prepare_circuits(backend)
# user_messenger.publish({"iteration": it, "interim_results": interim_results})
# backend.run(qc).result()
# user_messenger.publish(final_result, final=True)
# """
RUNTIME_PROGRAM = """
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
user_messenger.publish({'results': 'intermittently'})
circuits = transpile(
circuits,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
user_messenger.publish({'results': 'finally'})
user_messenger.publish(result.to_dict(), final=True)
print("job complete successfully")
"""
FAIL_PROGRAM = """
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
raise Exception('test failure')
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
logger = logging.getLogger(__name__)
class EmulatorRuntimeJobTest(unittest.TestCase):
def test_multiple_runtime_jobs(self):
executor = EmulationExecutor(program=None, program_data=(RUNTIME_PROGRAM, "STRING"), inputs = { "iterations": 2 })
executor2 = EmulationExecutor(program=None, program_data=(RUNTIME_PROGRAM, "STRING"), inputs = { "iterations": 2 })
executor3 = EmulationExecutor(program=None, program_data=(RUNTIME_PROGRAM, "STRING"), inputs = { "iterations": 2 })
self.assertIsNotNone(executor)
job = EmulatorRuntimeJob("1", None, executor=executor)
job2 = EmulatorRuntimeJob("1", None, executor=executor2)
job3 = EmulatorRuntimeJob("1", None, executor=executor3)
sleep(1)
self.assertIsNotNone(job)
job.cancel()
job2.cancel()
job3.cancel()
# pdb.set_trace()
sleep(1)
status = job.status()
self.assertEqual(status, "Canceled")
def test_intermittent_results(self):
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
# runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
result = job.result(timeout=120)
messages = job.get_unread_messages()
logger.debug(f'unread messages {messages}')
self.assertEqual(len(messages), 2)
self.assertEqual("intermittently", messages[0]['results'])
self.assertEqual("finally", messages[1]['results'])
messages = job.get_unread_messages()
self.assertEqual(0, len(messages))
def test_get_results(self):
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
response = job.result(timeout=120)
results = response['results'][0]
self.assertIsNotNone(results)
self.assertTrue(results['success'])
self.assertTrue(results['success'])
self.assertEqual("DONE", results['status'])
shots = results['shots']
count = results['data']['counts']['0x0']
self.assertGreater(count, (0.45 * shots))
self.assertLess(count, (0.55 * shots))
def test_get_status(self):
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
# runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
status = job.status()
correct_status = status == "Creating" or status == "Running"
self.assertTrue(correct_status)
job.result(timeout=120)
status = job.status()
max_try = 50
attempt = 0
while (status == "Creating" or status == "Running") and attempt < max_try:
sleep(0.1)
attempt += 1
status = job.status()
self.assertEqual(status, "Completed")
def test_get_failed_status(self):
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(FAIL_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
status = job.status()
self.assertEqual(status, "Creating")
max_try = 500
attempt = 0
while (status == "Creating" or status == "Running") and attempt < max_try:
sleep(0.1)
attempt += 1
status = job.status()
self.assertEqual(status, "Failed")
def test_cancel_job(self):
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
# runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
sleep(1)
res = job.cancel()
self.assertTrue(res)
status = job.status()
self.assertEqual(status, "Canceled")
def test_callback_function(self):
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
import sys
import io
old_stdout = sys.stdout
new_stdout = io.StringIO()
sys.stdout = new_stdout
job = provider.runtime.run(program_id, options=None, inputs=program_inputs,callback=print)
result =job.result(timeout=600)
output = new_stdout.getvalue()
sys.stdout = old_stdout
self.assertTrue("{'results': 'intermittently'}"
in output)
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# Copyright 2021 Dell (www.dell.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
from dell_runtime import DellRuntimeProvider
from qiskit.providers.ibmq.runtime import RuntimeProgram, RuntimeJob, ResultDecoder
from qiskit import QuantumCircuit
import os
RUNTIME_PROGRAM = """
import random
from qiskit import transpile
from qiskit.circuit.random import random_circuit
def prepare_circuits(backend):
circuit = random_circuit(num_qubits=5, depth=4, measure=True,
seed=random.randint(0, 1000))
return transpile(circuit, backend)
def main(backend, user_messenger, **kwargs):
iterations = kwargs['iterations']
interim_results = kwargs.pop('interim_results', {})
final_result = kwargs.pop("final_result", {})
for it in range(iterations):
qc = prepare_circuits(backend)
# user_messenger.publish({"iteration": it, "interim_results": interim_results})
backend.run(qc).result()
user_messenger.publish(final_result, final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"description": "Test program",
"max_execution_time": 300,
"backend_requirements": {"min_num_qubits": 5},
"parameters": [
{"name": "param1", "description": "Some parameter.",
"type": "integer", "required": True}
],
"return_values": [
{"name": "ret_val", "description": "Some return value.", "type": "string"}
],
"interim_results": [
{"name": "int_res", "description": "Some interim result", "type": "string"},
],
"name": "qiskit-test",
}
# PROGRAM_PREFIX = 'qiskit-test'
class EmulatorRuntimeServiceTest(unittest.TestCase):
def test_upload(self):
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
proglist = provider.runtime.programs()
self.assertIsNotNone(proglist[program_id])
findProgId = False
if program_id in proglist:
findProgId = True
self.assertTrue(findProgId)
def test_runtime_backends(self):
provider = DellRuntimeProvider()
backends = provider.runtime.backends()
self.assertGreater(len(backends), 1)
def test_view_program(self):
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
runtime_program = provider.runtime.program(program_id)
self.assertEqual(runtime_program.description, "Test program")
self.assertEqual(runtime_program.program_id, program_id)
def test_run_program(self):
provider = DellRuntimeProvider()
self.assertIsNotNone(provider)
self.assertIsNotNone(provider.runtime)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
self.assertEqual(1, len(provider.runtime.programs()))
runtime_program = provider.runtime.program(program_id)
self.assertIsNotNone(runtime_program)
try:
job = provider.runtime.run(program_id, options=None, inputs={"iterations": 2})
result = job.result(timeout=120)
self.assertIsNotNone(result)
except Exception:
self.fail("should pass")
def test_programs(self):
provider = DellRuntimeProvider()
self.assertIsNotNone(provider)
self.assertIsNotNone(provider.runtime)
provider.runtime.upload_program("fake-program1", metadata=RUNTIME_PROGRAM_METADATA)
provider.runtime.upload_program("fake-program2", metadata=RUNTIME_PROGRAM_METADATA)
programs = provider.runtime.programs()
self.assertEqual(len(programs), 2)
def test_update_program(self):
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
new_meta = {'description': 'Qiskit Test Update', 'max_execution_time': RUNTIME_PROGRAM_METADATA['max_execution_time']}
updated = provider.runtime.update_program(program_id, name='Test Update', metadata=new_meta)
self.assertTrue(updated)
program2 = provider.runtime.program(program_id, refresh=True)
self.assertEqual('Qiskit Test Update', program2.description)
self.assertEqual('Test Update', program2.name)
def test_pprint_programs(self):
provider = DellRuntimeProvider()
self.assertIsNotNone(provider)
self.assertIsNotNone(provider.runtime)
pr_id_1 = provider.runtime.upload_program("fake-program1", metadata=RUNTIME_PROGRAM_METADATA)
import sys
import io
old_stdout = sys.stdout
new_stdout = io.StringIO()
sys.stdout = new_stdout
provider.runtime.pprint_programs()
output = new_stdout.getvalue()
sys.stdout = old_stdout
self.assertTrue(output.startswith(
'''==================================================
{}:
Name: {}'''.format(pr_id_1,'qiskit-test')
))
def test_has_service(self):
provider = DellRuntimeProvider()
self.assertTrue(provider.has_service('runtime'))
self.assertFalse(provider.has_service('fake-service'))
def test_metadata(self):
provider = DellRuntimeProvider()
pr_id = provider.runtime.upload_program("fake-program1", metadata=RUNTIME_PROGRAM_METADATA)
program = provider.runtime.program(pr_id)
self.assertEqual('qiskit-test', program.name)
self.assertEqual(RUNTIME_PROGRAM_METADATA['description'], program.description)
self.assertEqual(RUNTIME_PROGRAM_METADATA['max_execution_time'],
program.max_execution_time)
self.assertEqual(RUNTIME_PROGRAM_METADATA['backend_requirements'],
program.backend_requirements)
def test_circuit_runner(self):
from . import circuit_runner as cr
try:
cr.main()
except Exception as e:
self.fail("should pass")
def test_dir_circuit_runner(self):
from . import dir_circuit_runner as dcr
try:
dcr.main()
except Exception as e:
self.fail("should pass")
def test_upload_file(self):
provider = DellRuntimeProvider()
self.assertIsNotNone(provider)
self.assertIsNotNone(provider.runtime)
here = os.path.dirname(os.path.realpath(__file__))
program_id = provider.runtime.upload_program(here + "/dirtest/", metadata=RUNTIME_PROGRAM_METADATA)
self.assertEqual(1, len(provider.runtime.programs()))
runtime_program = provider.runtime.program(program_id)
self.assertIsNotNone(runtime_program)
try:
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
result = job.result(timeout=120)
self.assertIsNotNone(result)
except Exception:
self.fail("should pass")
def test_reserved_names(self):
provider = DellRuntimeProvider()
self.assertIsNotNone(provider)
self.assertIsNotNone(provider.runtime)
try:
here = os.path.dirname(os.path.realpath(__file__))
program_id = provider.runtime.upload_program(here + "/dirfail/", metadata=RUNTIME_PROGRAM_METADATA)
self.fail("Should not allow upload")
except Exception:
self.assertTrue(True)
def test_delete_program(self):
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
prog_list = provider.runtime.programs(refresh=False)
self.assertTrue(len(prog_list) >= 1)
deleted = provider.runtime.delete_program(program_id)
self.assertTrue(deleted)
new_prog_list = provider.runtime.programs(refresh=True)
self.assertGreater(len(prog_list), len(new_prog_list))
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# Copyright 2021 Dell (www.dell.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from dell_runtime import DellRuntimeProvider
import unittest
from qiskit import QuantumCircuit, execute, transpile
from time import sleep
import logging
RUNTIME_PROGRAM = """
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
user_messenger.publish({'results': 'intermittently'})
circuits = transpile(
circuits,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
user_messenger.publish({'results': 'finally'})
user_messenger.publish(result.to_dict(), final=True)
print("job complete successfully")
"""
FAIL_PROGRAM = """
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
raise Exception('test failure')
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
logger = logging.getLogger(__name__)
class MultiLocalBackendTest(unittest.TestCase):
def test_get_results_emulator_backend(self):
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
'backend_name': 'emulator'
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
response = job.result(timeout=120)
results = response['results'][0]
self.assertIsNotNone(results)
self.assertTrue(results['success'])
self.assertTrue(results['success'])
self.assertEqual("DONE", results['status'])
shots = results['shots']
count = results['data']['counts']['0x0']
self.assertGreater(count, (0.45 * shots))
self.assertLess(count, (0.55 * shots))
def test_get_results_aer_backend(self):
provider = DellRuntimeProvider()
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
'backend_name': 'aer_simulator'
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
response = job.result(timeout=120)
results = response['results'][0]
self.assertIsNotNone(results)
self.assertTrue(results['success'])
self.assertTrue(results['success'])
self.assertEqual("DONE", results['status'])
shots = results['shots']
count = results['data']['counts']['0x0']
self.assertGreater(count, (0.45 * shots))
self.assertLess(count, (0.55 * shots))
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""The FeatureMap class."""
import json
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
class FeatureMap:
"""Mapping data with the feature map."""
def __init__(self, feature_dimension, entangler_map=None):
"""
Args:
feature_dimension (int): number of features (twice the number of qubits for this
encoding)
entangler_map (list[list]): connectivity of qubits with a list of [source, target],
or None for full entanglement. Note that the order in the list is the order of
applying the two-qubit gate.
Raises:
ValueError: If the value of ``feature_dimension`` is odd.
"""
if isinstance(feature_dimension, int):
if feature_dimension % 2 == 0:
self._feature_dimension = feature_dimension
else:
raise ValueError("Feature dimension must be an even integer.")
else:
raise ValueError("Feature dimension must be an even integer.")
self._num_qubits = int(feature_dimension / 2)
if entangler_map is None:
self._entangler_map = [
[i, j] for i in range(self._num_qubits) for j in range(i + 1, self._num_qubits)
]
else:
self._entangler_map = entangler_map
self._num_parameters = self._num_qubits
def construct_circuit(self, x=None, parameters=None, q=None, inverse=False, name=None):
"""Construct the feature map circuit.
Args:
x (numpy.ndarray): data vector of size feature_dimension
parameters (numpy.ndarray): optional parameters in feature map
q (QauntumRegister): the QuantumRegister object for the circuit
inverse (bool): whether or not to invert the circuit
name (str): The name to use for the constructed ``QuantumCircuit`` object
Returns:
QuantumCircuit: a quantum circuit transforming data x
Raises:
ValueError: If the input parameters or vector are invalid
"""
if parameters is not None:
if isinstance(parameters, (int, float)):
raise ValueError("Parameters must be a list.")
if len(parameters) == 1:
parameters = parameters * np.ones(self._num_qubits)
else:
if len(parameters) != self._num_parameters:
raise ValueError(
"The number of feature map parameters must be {}.".format(
self._num_parameters
)
)
if len(x) != self._feature_dimension:
raise ValueError(
"The input vector must be of length {}.".format(self._feature_dimension)
)
if q is None:
q = QuantumRegister(self._num_qubits, name="q")
circuit = QuantumCircuit(q, name=name)
for i in range(self._num_qubits):
circuit.ry(-parameters[i], q[i])
for source, target in self._entangler_map:
circuit.cz(q[source], q[target])
for i in range(self._num_qubits):
circuit.rz(-2 * x[2 * i + 1], q[i])
circuit.rx(-2 * x[2 * i], q[i])
if inverse:
return circuit.inverse()
else:
return circuit
def to_json(self):
"""Return JSON representation of this object.
Returns:
str: JSON string representing this object.
"""
return json.dumps(
{"feature_dimension": self._feature_dimension, "entangler_map": self._entangler_map}
)
@classmethod
def from_json(cls, data):
"""Return an instance of this class from the JSON representation.
Args:
data (str): JSON string representing an object.
Returns:
FeatureMap: An instance of this class.
"""
return cls(**json.loads(data))
|
https://github.com/QuTech-Delft/quantuminspire
|
QuTech-Delft
|
import logging
import os
from projectq import MainEngine
from projectq.setups import linear
from projectq.ops import H, Rx, Rz, CNOT, CZ, Measure, All
from quantuminspire.credentials import get_authentication
from quantuminspire.api import QuantumInspireAPI
from quantuminspire.projectq.backend_qx import QIBackend
QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/')
authentication = get_authentication()
qi_api = QuantumInspireAPI(QI_URL, authentication)
projectq_backend = QIBackend(quantum_inspire_api=qi_api)
engine = MainEngine(backend=projectq_backend) # create default compiler (simulator back-end)
qubits = engine.allocate_qureg(5)
q1 = qubits[0]
q2 = qubits[-1]
H | q1 # apply a Hadamard gate
CNOT | (q1, q2)
All(Measure) | qubits # measure the qubits
engine.flush() # flush all gates (and execute measurements)
print("Measured {}".format(','.join([str(int(q)) for q in qubits])))
print('Probabilities: %s' % (projectq_backend.get_probabilities(qubits),))
print(projectq_backend.cqasm())
projectq_backend = QIBackend(quantum_inspire_api=qi_api)
engine_list = linear.get_engine_list(num_qubits=5, one_qubit_gates=(Rx, Rz), two_qubit_gates=(CNOT,))
engine = MainEngine(backend=projectq_backend, engine_list=engine_list) # create default compiler (simulator back-end)
qubits = engine.allocate_qureg(5)
q1 = qubits[0]
q2 = qubits[-1]
H | q1 # apply a Hadamard gate
CNOT | (q1, q2)
All(Measure) | qubits # measure the qubits
engine.flush() # flush all gates (and execute measurements)
print("Measured {}".format(','.join([str(int(q)) for q in qubits])))
print('Probabilities: %s' % (projectq_backend.get_probabilities(qubits),))
print(projectq_backend.cqasm())
current_mapping = engine.mapper.current_mapping
for l, p in current_mapping.items():
print('mapping logical qubit %d to physical qubit %d' % (l, p))
|
https://github.com/QuTech-Delft/quantuminspire
|
QuTech-Delft
|
"""Example usage of the Quantum Inspire backend with the Qiskit SDK.
A simple example that demonstrates how to use the SDK to create
a circuit to demonstrate conditional gate execution.
For documentation on how to use Qiskit we refer to
[https://qiskit.org/](https://qiskit.org/).
Specific to Quantum Inspire is the creation of the QI instance, which is used to set the authentication
of the user and provides a Quantum Inspire backend that is used to execute the circuit.
Copyright 2018-2022 QuTech Delft. Licensed under the Apache License, Version 2.0.
"""
import os
from qiskit import transpile
from qiskit.providers.basic_provider import BasicProvider
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from quantuminspire.credentials import get_authentication
from quantuminspire.qiskit import QI
QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/')
authentication = get_authentication()
QI.set_authentication(authentication, QI_URL)
qi_backend = QI.get_backend('QX single-node simulator')
q = QuantumRegister(3, "q")
c0 = ClassicalRegister(1, "c0")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(1, "c2")
qc = QuantumCircuit(q, c0, c1, c2, name="conditional")
qc.h(q[0])
qc.h(q[1]).c_if(c0, 0) # h-gate on q[1] is executed
qc.h(q[2]).c_if(c1, 1) # h-gate on q[2] is not executed
qc.measure(q[0], c0)
qc.measure(q[1], c1)
qc.measure(q[2], c2)
qc = transpile(qc, backend=qi_backend)
qi_job = qi_backend.run(qc, shots=1024)
qi_result = qi_job.result()
histogram = qi_result.get_counts(qc)
print("\nResult from the remote Quantum Inspire backend:\n")
print('State\tCounts')
[print('{0}\t{1}'.format(state, counts)) for state, counts in histogram.items()]
print("\nResult from the local Qiskit simulator backend:\n")
backend = BasicProvider().get_backend(name="basic_simulator") # qasm_simulator
qc = transpile(qc, backend=backend)
job = backend.run(qc, shots=1024)
result = job.result()
print(result.get_counts(qc))
|
https://github.com/QuTech-Delft/quantuminspire
|
QuTech-Delft
|
"""Example usage of the Quantum Inspire backend with the Qiskit SDK.
A simple example that demonstrates how to use the SDK to create
a circuit to create a Bell state, and simulate the circuit on
Quantum Inspire.
For documentation on how to use Qiskit we refer to
[https://qiskit.org/](https://qiskit.org/).
Specific to Quantum Inspire is the creation of the QI instance, which is used to set the authentication
of the user and provides a Quantum Inspire backend that is used to execute the circuit.
Copyright 2018-2022 QuTech Delft. Licensed under the Apache License, Version 2.0.
"""
import os
from qiskit import transpile
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from quantuminspire.credentials import get_authentication
from quantuminspire.qiskit import QI
QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/')
project_name = 'Qiskit-entangle'
authentication = get_authentication()
QI.set_authentication(authentication, QI_URL, project_name=project_name)
qi_backend = QI.get_backend('QX single-node simulator')
q = QuantumRegister(2)
b = ClassicalRegister(2)
circuit = QuantumCircuit(q, b)
circuit.h(q[0])
circuit.cx(q[0], q[1])
circuit.measure(q, b)
circuit = transpile(circuit, backend=qi_backend)
qi_job = qi_backend.run(circuit, shots=256)
qi_result = qi_job.result()
histogram = qi_result.get_counts(circuit)
print('\nState\tCounts')
[print('{0}\t\t{1}'.format(state, counts)) for state, counts in histogram.items()]
# Print the full state probabilities histogram
probabilities_histogram = qi_result.get_probabilities(circuit)
print('\nState\tProbabilities')
[print('{0}\t\t{1}'.format(state, val)) for state, val in probabilities_histogram.items()]
|
https://github.com/QuTech-Delft/quantuminspire
|
QuTech-Delft
|
import numpy as np
import os
from qiskit import transpile, QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit_aer import Aer
from qiskit.providers.basic_provider import BasicProvider
from qiskit.visualization import circuit_drawer, plot_histogram
from IPython.display import display, Math, Latex
from quantuminspire.credentials import get_authentication
from quantuminspire.api import QuantumInspireAPI
from quantuminspire.qiskit import QI
QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/')
def format_vector(state_vector, decimal_precision=7):
""" Format the state vector into a LaTeX formatted string.
Args:
state_vector (list or array): The state vector with complex
values e.g. [-1, 2j+1].
Returns:
str: The LaTeX format.
"""
result = []
epsilon = 1/pow(10, decimal_precision)
state_vector = np.asarray(state_vector)
bit_length = (len(state_vector) - 1).bit_length()
for index, complex_value in enumerate(state_vector):
has_imag_part = np.round(complex_value.imag, decimal_precision) != 0.0
value = complex_value if has_imag_part else complex_value.real
value_round = np.round(value, decimal_precision)
if np.abs(value_round) < epsilon:
continue
binary_state = '{0:0{1}b}'.format(index, bit_length)
result.append(r'{0:+2g}\left\lvert {1}\right\rangle '.format(value_round, binary_state))
return ''.join(result)
def run_circuit(q_circuit, q_register, number_of_qubits=None, backend_name='statevector_simulator'):
""" Run a circuit on all base state vectors and show the output.
Args:
q_circuit (QuantumCircuit):
q_register (QuantumRegister)
number_of_qubits (int or None): The number of qubits.
backend (str): ...
"""
if not isinstance(number_of_qubits, int):
number_of_qubits = q_register.size
if q_register.size != number_of_qubits:
warnings.warn('incorrect register size?')
latex_text = r'\mathrm{running\ circuit\ on\ set\ of\ basis\ states:}'
display(Math(latex_text))
base_states = 2 ** number_of_qubits
backend = Aer.get_backend(backend_name)
for base_state in range(base_states):
pre_circuit = QuantumCircuit(q_register)
state = base_state
for kk in range(number_of_qubits):
if state % 2 == 1:
pre_circuit.x(q[kk])
state = state // 2
input_state = r'\left\lvert{0:0{1}b}\right\rangle'.format(base_state, number_of_qubits)
circuit_total = pre_circuit.compose(q_circuit)
circuit_total = transpile(circuit_total, backend)
job = backend.run(circuit_total, shots=10)
output_state = job.result().get_statevector(circuit_total)
latex_text = input_state + r'\mathrm{transforms\ to}: ' + format_vector(output_state)
display(Math(latex_text))
n=3
N=2**n
q = QuantumRegister(n)
qc = QuantumCircuit(q)
if n==1:
def black_box(qc, q):
qc.z(q)
elif n==2:
def black_box(qc, q):
for i in range(n):
qc.s(q[i])
qc.h(q[1])
qc.cx(q[0], q[1])
qc.h(q[1])
for i in range(n):
qc.s(q[i])
else:
def black_box(qc, q):
qc.h(q[2])
qc.ccx(q[0], q[1], q[2])
qc.h(q[2])
black_box(qc,q)
cplot=qc.draw(output='mpl')
display(cplot)
print('black box circuit:')
run_circuit(qc, q)
def n_controlled_Z(circuit, controls, target):
"""Implement a Z gate with multiple controls"""
if (len(controls) > 2):
raise ValueError('The controlled Z with more than 2 ' +
'controls is not implemented')
elif (len(controls) == 1):
circuit.h(target)
circuit.cx(controls[0], target)
circuit.h(target)
elif (len(controls) == 2):
circuit.h(target)
circuit.ccx(controls[0], controls[1], target)
circuit.h(target)
def inversion_about_average(circuit, f_in, n):
"""Apply inversion about the average step of Grover's algorithm."""
# Hadamards everywhere
if n==1:
circuit.x(f_in[0])
return
for j in range(n):
circuit.h(f_in[j])
# D matrix: flips the sign of the state |000> only
for j in range(n):
circuit.x(f_in[j])
n_controlled_Z(circuit, [f_in[j] for j in range(n-1)], f_in[n-1])
for j in range(n):
circuit.x(f_in[j])
# Hadamards everywhere again
for j in range(n):
circuit.h(f_in[j])
qInvAvg = QuantumCircuit(q)
inversion_about_average(qInvAvg, q, n)
qInvAvg.draw(output='mpl')
print('inversion average circuit:')
qc = QuantumCircuit(q)
inversion_about_average(qc, q, n)
run_circuit(qc, q, n)
theta = 2*np.arcsin(1/np.sqrt(N))
r=np.pi*np.sqrt(N)/4
display(Math(r'\textrm{Rotation of the winner: } \theta = %.2f \mathrm{\ [deg]}' % (np.rad2deg(theta))) )
print('Optimal number of Grover iterations for n=%d: %.1f' % (n,r) )
T=int(r)
for i in range(int(r+2)):
p=np.sin((i+1/2)*theta)**2
print('%d iterations: p %.2f' % (i, p))
"""Grover search implemented in Qiskit.
This module contains the code necessary to run Grover search on 3
qubits, both with a simulator and with a real quantum computing
device. This code is the companion for the paper
"An introduction to quantum computing, without the physics",
Giacomo Nannicini, https://arxiv.org/abs/1708.03684.
"""
def input_state(circuit, f_in, n):
"""(n+1)-qubit input state for Grover search."""
for j in range(n):
circuit.h(f_in[j])
q = QuantumRegister(n)
ans = ClassicalRegister(n)
qc = QuantumCircuit(q, ans)
input_state(qc, q, n)
backend = Aer.get_backend('statevector_simulator')
qc = transpile(qc, backend)
job = backend.run(qc, shots=10)
result = job.result()
state_vector = result.get_statevector(qc)
m=display( Math(r'\mathrm{state\ after\ initialization:\ }' + format_vector(state_vector)))
# apply T rounds of oracle and inversion about the average
print('number of iterations T=%d'% T)
for t in range(T):
for i in range(n):
qc.barrier(q[i]) # for better visualization
qc.id(q[0])
# Apply T full iterations
black_box(qc, q)
for i in range(n):
qc.barrier(q[i])
qc.id(q[0])
inversion_about_average(qc, q, n)
# Measure the output register in the computational basis
for j in range(n):
qc.measure(q[j], ans[j])
# Execute circuit
backend = BasicProvider().get_backend(name="basic_simulator")
qc = transpile(qc, backend=backend)
job = backend.run(qc, shots=10)
result = job.result()
# Get counts and plot histogram
counts = result.get_counts()
plot_histogram(counts)
qc.draw(output='mpl')
authentication = get_authentication()
QI.set_authentication(authentication, QI_URL)
QI.backends()
qi_backend = QI.get_backend('QX single-node simulator')
qc=transpile(qc, backend=qi_backend)
j=qi_backend.run(qc, shots=512)
result = j.result()
print('Generated histogram:')
print(result.get_counts())
plot_histogram(result.get_counts(qc))
|
https://github.com/QuTech-Delft/quantuminspire
|
QuTech-Delft
|
import time
import os
import numpy as np
from IPython.display import display
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, transpile
from qiskit.visualization import plot_histogram, circuit_drawer
from quantuminspire.credentials import get_authentication
from quantuminspire.qiskit import QI
QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/')
def pcircuit(nqubits, depth = 10):
""" Circuit to test performance of quantum computer """
q = QuantumRegister(nqubits)
ans = ClassicalRegister(nqubits)
qc = QuantumCircuit(q, ans)
for level in range(depth):
for qidx in range(nqubits):
qc.h( q[qidx] )
qc.barrier()
for qidx in range(nqubits):
qc.rx(np.pi/2, q[qidx])
qc.barrier()
for qidx in range(nqubits):
if qidx!=0:
qc.cx(q[qidx], q[0])
for qidx in range(nqubits):
qc.measure(q[qidx], ans[qidx])
return q, qc
q,qc = pcircuit(4, 1)
qc.draw(output='mpl')
authentication = get_authentication()
QI.set_authentication(authentication, QI_URL)
qi_backend = QI.get_backend('QX single-node simulator')
qc = transpile(qc, qi_backend)
job = qi_backend.run(qc)
result = job.result()
print('Generated histogram:')
print(result.get_counts())
plot_histogram(result.get_counts(qc))
q, qc = pcircuit(10, 10)
start_time = time.time()
qc = transpile(qc, qi_backend)
job = qi_backend.run(qc, shots=8)
job.result()
interval = time.time() - start_time
print('time needed: %.1f [s]' % (interval,))
|
https://github.com/QuTech-Delft/quantuminspire
|
QuTech-Delft
|
""" Quantum Inspire SDK
Copyright 2022 QuTech Delft
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
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import copy
import unittest
from unittest.mock import Mock
import numpy as np
import qiskit
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.compiler import assemble, transpile
from qiskit.circuit import Instruction
from quantuminspire.qiskit.circuit_parser import CircuitToString
from quantuminspire.qiskit.backend_qx import QuantumInspireBackend
from quantuminspire.qiskit.measurements import Measurements
from quantuminspire.exceptions import ApiError
class TestQiCircuitToString(unittest.TestCase):
@staticmethod
def _generate_cqasm_from_circuit(circuit, full_state_projection=True, transpile_first=False):
run_config_dict = {'shots': 25, 'memory': True}
configuration = copy.copy(QuantumInspireBackend.DEFAULT_CONFIGURATION)
if transpile_first:
# qiskit transpiler expects coupling map
configuration.simulator = False
configuration.coupling_map = [[0, 1], [0, 2], [1, 3], [2, 3]]
backend = QuantumInspireBackend(Mock(), Mock(), configuration)
if transpile_first:
circuit = transpile(circuit, backend=backend)
qobj = assemble(circuit, backend, **run_config_dict)
experiment = qobj.experiments[0]
measurements = Measurements.from_experiment(experiment)
result = backend._generate_cqasm(experiment, measurements, full_state_projection)
return result
@staticmethod
def _generate_cqasm_from_instructions(instructions, number_of_qubits=2, full_state_projection=True):
""" Needed to create invalid qiskit circuits for triggering Exceptions """
experiment_dict = {'instructions': instructions,
'header': {'n_qubits': number_of_qubits,
'memory_slots': number_of_qubits,
'compiled_circuit_qasm': ''},
'config': {'coupling_map': 'all-to-all',
'basis_gates': 'x,y,z,h,rx,ry,rz,s,cx,ccx,p,id,snapshot',
'n_qubits': number_of_qubits}}
experiment = qiskit.qobj.QasmQobjExperiment.from_dict(experiment_dict)
for instruction in experiment.instructions:
if hasattr(instruction, 'params'):
# convert params to params used in qiskit instructions
qiskit_instruction = Instruction('dummy', 0, 0, instruction.params)
instruction.params = qiskit_instruction.params
measurements = Measurements.from_experiment(experiment)
simulator = QuantumInspireBackend(Mock(), Mock())
result = simulator._generate_cqasm(experiment, measurements, full_state_projection)
return result
def test_generate_cqasm_with_entangle_algorithm(self):
q = QuantumRegister(2)
b = ClassicalRegister(2)
circuit = QuantumCircuit(q, b)
circuit.h(q[0])
circuit.cx(q[0], q[1])
circuit.measure(q[0], b[0])
circuit.measure(q[1], b[1])
result = self._generate_cqasm_from_circuit(circuit)
expected = "version 1.0\n" \
"# cQASM generated by QI backend for Qiskit\n" \
"qubits 2\n" \
"H q[0]\n" \
"CNOT q[0], q[1]\n"
self.assertEqual(result, expected)
def test_generate_cqasm_correct_output_controlled_z(self):
qc = QuantumCircuit(2, 2)
qc.cz(0, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('CZ q[0], q[1]\n' in result)
def test_generate_cqasm_correct_output_conditional_controlled_z(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.cz(0, 1).c_if(c, 14)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[0]\nC-CZ b[0,1,2,3], q[0], q[1]\nnot b[0]\n' in result)
def test_generate_cqasm_correct_output_controlled_not(self):
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('CNOT q[0], q[1]\n' in result)
def test_generate_cqasm_correct_output_conditional_controlled_not(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.cx(0, 1).c_if(c, 14)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[0]\nC-CNOT b[0,1,2,3], q[0], q[1]\nnot b[0]\n' in result)
def test_generate_cqasm_correct_output_toffoli(self):
qc = QuantumCircuit(3, 3)
qc.ccx(0, 1, 2)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Toffoli q[0], q[1], q[2]\n' in result)
def test_generate_cqasm_correct_output_conditional_toffoli(self):
q = QuantumRegister(8, "q")
c = ClassicalRegister(8, "c")
qc = QuantumCircuit(q, c, name="test")
qc.ccx(0, 1, 2).c_if(c, 14)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[0,4,5,6,7]\nC-Toffoli b[0,1,2,3,4,5,6,7], q[0], q[1], q[2]\nnot b[0,4,5,6,7]\n' in result)
def test_generate_cqasm_correct_output_measure(self):
qc = QuantumCircuit(2, 2)
qc.measure(0, 0)
result = self._generate_cqasm_from_circuit(qc)
measure_line = 'measure q[0]\n'
self.assertTrue(measure_line not in result)
def test_generate_cqasm_correct_output_measure_q0_non_fsp(self):
qc = QuantumCircuit(2, 2)
qc.measure(0, 0)
result = self._generate_cqasm_from_circuit(qc, False)
measure_line = 'measure q[0]\n'
self.assertTrue(measure_line in result)
def test_generate_cqasm_correct_output_measure_q1_non_fsp(self):
qc = QuantumCircuit(2, 2)
qc.measure(1, 0)
result = self._generate_cqasm_from_circuit(qc, False)
measure_line = 'measure q[1]\n'
self.assertTrue(measure_line in result)
def test_generate_cqasm_correct_output_hadamard(self):
qc = QuantumCircuit(2, 2)
qc.h(0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('H q[0]\n' in result)
def test_generate_cqasm_correct_output_conditional_hadamard(self):
q = QuantumRegister(8, "q")
c = ClassicalRegister(8, "c")
qc = QuantumCircuit(q, c, name="test")
qc.h(0).c_if(c, 14)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[0,4,5,6,7]\nC-H b[0,1,2,3,4,5,6,7], q[0]\nnot b[0,4,5,6,7]\n' in result)
def test_generate_cqasm_correct_output_barrier(self):
qc = QuantumCircuit(2, 2)
qc.barrier(0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('barrier q[0]\n' in result)
def test_generate_cqasm_correct_output_barrier_multiple_qubits(self):
q1 = QuantumRegister(2, "q1")
q2 = QuantumRegister(4, "q2")
c1 = ClassicalRegister(2, "c1")
c2 = ClassicalRegister(4, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.barrier(q1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('barrier q[0,1]\n' in result)
qc.barrier(q2)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('barrier q[2,3,4,5]\n' in result)
def test_generate_cqasm_correct_output_barrier_all_qubits(self):
q1 = QuantumRegister(2, "q1")
q2 = QuantumRegister(4, "q2")
c1 = ClassicalRegister(2, "c1")
c2 = ClassicalRegister(4, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.barrier()
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('barrier q[0,1,2,3,4,5]\n' in result)
def test_generate_cqasm_correct_output_delay_all_qubits(self):
q1 = QuantumRegister(1, "q1")
q2 = QuantumRegister(2, "q2")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(2, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.delay(1.0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('wait q[0], 1\n' in result)
self.assertTrue('wait q[1], 1\n' in result)
self.assertTrue('wait q[2], 1\n' in result)
def test_generate_cqasm_correct_output_delay_qarg(self):
q1 = QuantumRegister(1, "q1")
q2 = QuantumRegister(2, "q2")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(2, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.delay(1, q2)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('wait q[1], 1\n' in result)
self.assertTrue('wait q[2], 1\n' in result)
# float is translated to int
qc.delay(2.0, q1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('wait q[0], 2\n' in result)
def test_generate_cqasm_correct_output_delay_units_in_dt(self):
q1 = QuantumRegister(2, "q1")
q2 = QuantumRegister(2, "q2")
c1 = ClassicalRegister(2, "c1")
c2 = ClassicalRegister(2, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.delay(1.0, q1, unit="dt")
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('wait q[0], 1\n' in result)
self.assertTrue('wait q[1], 1\n' in result)
qc.delay(2, q1, unit="dt")
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('wait q[0], 2\n' in result)
self.assertTrue('wait q[1], 2\n' in result)
def test_generate_cqasm_correct_output_delay_units_in_s(self):
# we need to transpile first to let the circuit convert the delay to seconds
q1 = QuantumRegister(2, "q1")
q2 = QuantumRegister(2, "q2")
c1 = ClassicalRegister(2, "c1")
c2 = ClassicalRegister(2, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.delay(1.1, q1, "ms")
result = self._generate_cqasm_from_circuit(qc, transpile_first=True)
self.assertTrue('wait q[0], 0\n' in result)
self.assertTrue('wait q[1], 0\n' in result)
qc.delay(0.9, q2, "ns")
result = self._generate_cqasm_from_circuit(qc, transpile_first=True)
self.assertTrue('wait q[2], 0\n' in result)
self.assertTrue('wait q[3], 0\n' in result)
qc.delay(1.0, unit="s")
result = self._generate_cqasm_from_circuit(qc, transpile_first=True)
self.assertTrue('wait q[0], 1\n' in result)
self.assertTrue('wait q[1], 1\n' in result)
self.assertTrue('wait q[2], 1\n' in result)
self.assertTrue('wait q[3], 1\n' in result)
def test_generate_cqasm_correct_output_reset_qubit(self):
q1 = QuantumRegister(1, "q1")
q2 = QuantumRegister(2, "q2")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(2, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.reset(q1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('prep_z q[0]\n' in result)
def test_generate_cqasm_correct_output_reset_qubits(self):
q1 = QuantumRegister(1, "q1")
q2 = QuantumRegister(2, "q2")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(2, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.reset(q2)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('prep_z q[1]\nprep_z q[2]\n' in result)
def test_generate_cqasm_correct_output_identity(self):
qc = QuantumCircuit(2, 2)
qc.id(0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('I q[0]\n' in result)
def test_generate_cqasm_correct_output_conditional_identity(self):
q = QuantumRegister(8, "q")
c = ClassicalRegister(8, "c")
qc = QuantumCircuit(q, c, name="test")
qc.id(0).c_if(c, 14)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[0,4,5,6,7]\nC-I b[0,1,2,3,4,5,6,7], q[0]\nnot b[0,4,5,6,7]\n' in result)
def test_generate_cqasm_correct_output_gate_s(self):
qc = QuantumCircuit(2, 2)
qc.s(1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('S q[1]\n' in result)
def test_generate_cqasm_correct_output_conditional_gate_s(self):
q = QuantumRegister(9, "q")
c = ClassicalRegister(9, "c")
qc = QuantumCircuit(q, c, name="test")
qc.s(2).c_if(c, 11)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,4,5,6,7,8]\nC-S b[0,1,2,3,4,5,6,7,8], q[2]\nnot b[2,4,5,6,7,8]\n' in result)
def test_generate_cqasm_correct_output_gate_sdag(self):
qc = QuantumCircuit(3, 3)
qc.sdg(2)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Sdag q[2]\n' in result)
def test_generate_cqasm_correct_output_conditional_gate_sdag(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.sdg(0).c_if(c, 14)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[0]\nC-Sdag b[0,1,2,3], q[0]\nnot b[0]\n' in result)
def test_generate_cqasm_correct_output_gate_swap(self):
qc = QuantumCircuit(4, 4)
qc.swap(2, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('SWAP q[2], q[3]\n' in result)
def test_generate_cqasm_correct_output_conditional_gate_swap(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.swap(0, 1).c_if(c, 14)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[0]\nC-SWAP b[0,1,2,3], q[0], q[1]\nnot b[0]\n' in result)
def test_generate_cqasm_correct_output_gate_t(self):
qc = QuantumCircuit(3, 3)
qc.t(2)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('T q[2]\n' in result)
def test_generate_cqasm_correct_output_conditional_gate_t(self):
q = QuantumRegister(9, "q")
c = ClassicalRegister(9, "c")
qc = QuantumCircuit(q, c, name="test")
qc.t(1).c_if(c, 11)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,4,5,6,7,8]\nC-T b[0,1,2,3,4,5,6,7,8], q[1]\nnot b[2,4,5,6,7,8]\n' in result)
def test_generate_cqasm_correct_output_gate_tdag(self):
qc = QuantumCircuit(3, 3)
qc.tdg(2)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Tdag q[2]\n' in result)
def test_generate_cqasm_correct_output_conditional_gate_tdag(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.tdg(0).c_if(c, 14)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[0]\nC-Tdag b[0,1,2,3], q[0]\nnot b[0]\n' in result)
def test_generate_cqasm_correct_output_gate_x(self):
qc = QuantumCircuit(2, 2)
qc.x(0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('X q[0]\n' in result)
def test_generate_cqasm_correct_output_conditional_gate_x(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.x(0).c_if(c, 14)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[0]\nC-X b[0,1,2,3], q[0]\nnot b[0]\n' in result)
def test_generate_cqasm_correct_output_gate_y(self):
qc = QuantumCircuit(2, 2)
qc.y(0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Y q[0]\n' in result)
def test_generate_cqasm_correct_output_conditional_gate_y(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.y(0).c_if(c, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[1,2,3]\nC-Y b[0,1,2,3], q[0]\nnot b[1,2,3]\n' in result)
def test_generate_cqasm_correct_output_gate_z(self):
qc = QuantumCircuit(2, 2)
qc.z(0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Z q[0]\n' in result)
def test_generate_cqasm_correct_output_conditional_gate_z(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.z(0).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Z b[0,1,2,3], q[0]\nnot b[2,3]\n' in result)
def test_generate_cqasm_correct_output_gate_u(self):
qc = QuantumCircuit(2, 2)
qc.u(0, 0, np.pi / 2, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[0], 1.570796\n' in result)
qc = QuantumCircuit(2, 2)
qc.u(-np.pi / 2, 0, 0, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Ry q[0], -1.570796\n' in result)
qc = QuantumCircuit(2, 2)
qc.u(np.pi / 4, np.pi / 2, -np.pi / 2, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[0], -1.570796\nRy q[0], 0.785398\nRz q[0], 1.570796\n' in result)
qc = QuantumCircuit(2, 2)
qc.u(0.123456, 0.654321, -0.333333, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[1], -0.333333\nRy q[1], 0.123456\nRz q[1], 0.654321\n' in result)
def test_generate_cqasm_correct_output_conditional_gate_u(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(0, 0, np.pi / 2, 0).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[0], 1.570796\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(-np.pi / 2, 0, 0, 0).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Ry b[0,1,2,3], q[0], -1.570796\nnot b[2,3]' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(np.pi / 4, np.pi / 2, -np.pi / 2, 0).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[0], -1.570796\nC-Ry b[0,1,2,3], q[0], 0.785398\nC-Rz b[0,1,2,3],'
' q[0], 1.570796\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(0.123456, 0.654321, -0.333333, 1).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[1], -0.333333\nC-Ry b[0,1,2,3], q[1], 0.123456\nC-Rz b[0,1,2,3],'
' q[1], 0.654321\nnot b[2,3]\n' in result)
def test_generate_cqasm_correct_output_gate_p(self):
qc = QuantumCircuit(2, 2)
qc.p(np.pi / 2, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[0], 1.570796\n' in result)
qc = QuantumCircuit(2, 2)
qc.p(np.pi / 4, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[1], 0.785398\n' in result)
qc = QuantumCircuit(3, 3)
qc.p(-np.pi / 4, 2)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[2], -0.785398\n' in result)
qc = QuantumCircuit(3, 3)
qc.p(0.123456, 2)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[2], 0.123456\n' in result)
qc = QuantumCircuit(2, 2)
qc.p(0, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertFalse('q[0]' in result)
def test_generate_cqasm_correct_output_conditional_gate_p(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.p(np.pi / 2, 0).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[0], 1.570796\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.p(np.pi / 4, 1).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[1], 0.785398\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.p(-np.pi / 4, 2).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[2], -0.785398\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.p(0.123456, 2).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[2], 0.123456\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.p(0, 0).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertFalse('q[0]' in result)
def test_generate_cqasm_correct_output_gate_u2(self):
# Qiskit u2 is deprecated from 0.16.0. u2(a, b) -> u(pi/2, a, b)
qc = QuantumCircuit(2, 2)
qc.u(np.pi / 2, np.pi, np.pi / 2, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[0], 1.570796\nRy q[0], 1.570796\nRz q[0], 3.141593\n' in result)
qc = QuantumCircuit(2, 2)
qc.u(np.pi / 2, 0, np.pi, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[1], 3.141593\nRy q[1], 1.570796\n' in result)
qc = QuantumCircuit(3, 3)
qc.u(np.pi / 2, 0.123456, -0.654321, 2)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[2], -0.654321\nRy q[2], 1.570796\nRz q[2], 0.123456\n' in result)
qc = QuantumCircuit(3, 3)
qc.u(np.pi / 2, 0, 0, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Ry q[0], 1.570796\n' in result)
def test_generate_cqasm_correct_output_conditional_gate_u2(self):
# Qiskit u2 is deprecated from 0.16.0. u2(a, b) -> u(pi/2, a, b)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(np.pi / 2, np.pi, np.pi / 2, 0).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[0], 1.570796\nC-Ry b[0,1,2,3], q[0], 1.570796\nC-Rz b[0,1,2,3], q[0],'
' 3.141593\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(np.pi / 2, 0, np.pi, 1).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[1], 3.141593\nC-Ry b[0,1,2,3], q[1], 1.570796\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(np.pi / 2, 0.123456, -0.654321, 2).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[2], -0.654321\nC-Ry b[0,1,2,3], q[2], 1.570796\nC-Rz b[0,1,2,3], q[2],'
' 0.123456\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(np.pi / 2, 0, 0, 0).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Ry b[0,1,2,3], q[0], 1.570796\nnot b[2,3]\n' in result)
def test_generate_cqasm_correct_output_gate_u3(self):
# Qiskit u3 is deprecated from 0.16.0. u3 -> u
qc = QuantumCircuit(2, 2)
qc.u(1, 2, 3, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[0], 3.000000\nRy q[0], 1.000000\nRz q[0], 2.000000\n' in result)
qc = QuantumCircuit(2, 2)
qc.u(0.123456, 0.654321, -0.333333, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[1], -0.333333\nRy q[1], 0.123456\nRz q[1], 0.654321\n' in result)
qc = QuantumCircuit(2, 2)
qc.u(0, 0.654321, 0, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[1], 0.654321\n' in result)
qc = QuantumCircuit(3, 3)
qc.u(0.654321, 0, 0, 2)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Ry q[2], 0.654321\n' in result)
qc = QuantumCircuit(2, 2)
qc.u(0, 0, 0, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertFalse('q[0]' in result)
def test_generate_cqasm_correct_output_conditional_gate_u3(self):
# Qiskit u3 is deprecated from 0.16.0. u3 -> u
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(1, 2, 3, 0).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[0], 3.000000\nC-Ry b[0,1,2,3], q[0], 1.000000\nC-Rz b[0,1,2,3], q[0],'
' 2.000000\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(0.123456, 0.654321, -0.333333, 1).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[1], -0.333333\nC-Ry b[0,1,2,3], q[1], 0.123456\nC-Rz b[0,1,2,3], q[1],'
' 0.654321\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(0, 0.654321, 0, 1).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Rz b[0,1,2,3], q[1], 0.654321\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(0.654321, 0, 0, 2).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Ry b[0,1,2,3], q[2], 0.654321\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.u(0, 0, 0, 0).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertFalse('q[0]' in result)
def test_generate_cqasm_correct_output_sympy_special_cases(self):
# Zero
qc = QuantumCircuit(2, 2)
qc.rx(0, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rx q[1], 0.000000\n' in result)
# One
qc = QuantumCircuit(2, 2)
qc.rx(1, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rx q[1], 1.000000\n' in result)
# Integer
qc = QuantumCircuit(2, 2)
qc.rx(2, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rx q[1], 2.000000\n' in result)
# NegativeOne
qc = QuantumCircuit(2, 2)
qc.rx(-1, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rx q[1], -1.000000\n' in result)
# Float
qc = QuantumCircuit(2, 2)
qc.rx(np.pi / 2, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rx q[0], 1.570796\n' in result)
def test_generate_cqasm_correct_output_rotation_x(self):
qc = QuantumCircuit(2, 2)
qc.rx(np.pi / 2, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rx q[0], 1.570796\n' in result)
qc = QuantumCircuit(2, 2)
qc.rx(0.123456, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rx q[1], 0.123456\n' in result)
def test_generate_cqasm_correct_output_conditional_rotation_x(self):
q = QuantumRegister(8, "q")
c = ClassicalRegister(8, "c")
qc = QuantumCircuit(q, c, name="test")
qc.rx(np.pi / 2, 0).c_if(c, 14)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[0,4,5,6,7]\nC-Rx b[0,1,2,3,4,5,6,7], q[0], 1.570796\nnot b[0,4,5,6,7]\n' in result)
q = QuantumRegister(8, "q")
c = ClassicalRegister(8, "c")
qc = QuantumCircuit(q, c, name="test")
qc.rx(0.123456, 1).c_if(c, 14)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[0,4,5,6,7]\nC-Rx b[0,1,2,3,4,5,6,7], q[1], 0.123456\nnot b[0,4,5,6,7]\n' in result)
def test_generate_cqasm_correct_output_rotation_y(self):
qc = QuantumCircuit(2, 2)
qc.ry(np.pi / 2, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Ry q[0], 1.570796\n' in result)
qc = QuantumCircuit(2, 2)
qc.ry(0.654321, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Ry q[1], 0.654321\n' in result)
def test_generate_cqasm_correct_output_conditional_rotation_y(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.ry(np.pi / 2, 0).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Ry b[0,1,2,3], q[0], 1.570796\nnot b[2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.ry(0.654321, 1).c_if(c, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[2,3]\nC-Ry b[0,1,2,3], q[1], 0.654321\nnot b[2,3]\n' in result)
def test_generate_cqasm_correct_output_rotation_z(self):
qc = QuantumCircuit(2, 2)
qc.rz(np.pi / 2, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[0], 1.570796\n' in result)
qc = QuantumCircuit(2, 2)
qc.rz(-np.pi / 2, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('Rz q[1], -1.570796\n' in result)
def test_generate_cqasm_correct_output_conditional_rotation_z(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.rz(np.pi / 2, 0).c_if(c, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[1,2,3]\nC-Rz b[0,1,2,3], q[0], 1.570796\nnot b[1,2,3]\n' in result)
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.rz(-np.pi / 2, 1).c_if(c, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[1,2,3]\nC-Rz b[0,1,2,3], q[1], -1.570796\nnot b[1,2,3]\n' in result)
def test_generate_cqasm_correct_output_unknown_gate(self):
instructions = [{'name': 'bla', 'qubits': [1], 'params': [-np.pi / 2]}]
self.assertRaisesRegex(ApiError, "Gate 'bla' not supported", self._generate_cqasm_from_instructions,
instructions, 2)
def test_generate_cqasm_correct_output_unknown_controlled_gate(self):
instructions = [{'mask': '0xF', 'name': 'bfunc', 'register': 17, 'relation': '==', 'val': '0x1'},
{'conditional': 17, 'name': 'bla', 'qubits': [1], 'params': [-np.pi / 2]}]
self.assertRaisesRegex(ApiError, "Conditional gate 'c-bla' not supported",
self._generate_cqasm_from_instructions, instructions, 2)
def test_generate_cqasm_correct_output_no_bit_negation(self):
q = QuantumRegister(4, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="test")
qc.rx(-np.pi / 2, 1).c_if(c, 15)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('C-Rx b[0,1,2,3], q[1], -1.570796\n' in result)
self.assertFalse('not\n' in result)
def test_generate_cqasm_correct_output_one_bit_condition(self):
q1 = QuantumRegister(1, "q1")
q2 = QuantumRegister(1, "q2")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(1, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.rx(-np.pi / 2, q2).c_if(c1, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('C-Rx b[0], q[1], -1.570796\n' in result)
self.assertFalse('not\n' in result)
q1 = QuantumRegister(1, "q1")
q2 = QuantumRegister(1, "q2")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(1, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.rx(-np.pi / 2, q2).c_if(c2, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('C-Rx b[1], q[1], -1.570796\n' in result)
self.assertFalse('not\n' in result)
q1 = QuantumRegister(6, "q1")
q2 = QuantumRegister(1, "q2")
c1 = ClassicalRegister(6, "c1")
c2 = ClassicalRegister(1, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.rx(-np.pi / 2, 1).c_if(c2, 1)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('C-Rx b[6], q[1], -1.570796\n' in result)
self.assertFalse('not\n' in result)
q1 = QuantumRegister(6, "q1")
q2 = QuantumRegister(1, "q2")
c1 = ClassicalRegister(6, "c1")
c2 = ClassicalRegister(1, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.rx(-np.pi / 2, 1).c_if(c2, 0)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[6]\nC-Rx b[6], q[1], -1.570796\nnot b[6]\n' in result)
def test_generate_cqasm_correct_output_more_bit_condition(self):
q1 = QuantumRegister(3, "q1")
q2 = QuantumRegister(3, "q2")
c1 = ClassicalRegister(3, "c1")
c2 = ClassicalRegister(3, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.y(2).c_if(c2, 3)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[5]\nC-Y b[3,4,5], q[2]\nnot b[5]\n' in result)
q1 = QuantumRegister(1, "q1")
q2 = QuantumRegister(7, "q2")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(7, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.y(2).c_if(c2, 12)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[1,2,5,6,7]\nC-Y b[1,2,3,4,5,6,7], q[2]\nnot b[1,2,5,6,7]\n' in result)
q1 = QuantumRegister(1, "q1")
q2 = QuantumRegister(7, "q2")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(7, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.y(2).c_if(c2, 27)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[3,6,7]\nC-Y b[1,2,3,4,5,6,7], q[2]\nnot b[3,6,7]\n' in result)
q1 = QuantumRegister(5, "q1")
q2 = QuantumRegister(2, "q2")
c1 = ClassicalRegister(5, "c1")
c2 = ClassicalRegister(2, "c2")
qc = QuantumCircuit(q1, q2, c1, c2, name="test")
qc.y(2).c_if(c2, 2)
result = self._generate_cqasm_from_circuit(qc)
self.assertTrue('not b[5]\nC-Y b[5,6], q[2]\nnot b[5]\n' in result)
def test_generate_cqasm_correct_output_unknown_type(self):
instructions = [{'mask': '0xF', 'name': 'bfunc', 'register': 18, 'relation': '!=', 'val': '0x1'},
{'conditional': 18, 'name': 'rx', 'qubits': [1], 'params': [-np.pi / 2]}]
self.assertRaisesRegex(ApiError, 'Conditional statement with relation != not supported',
self._generate_cqasm_from_instructions, instructions, 2)
def test_generate_cqasm_correct_output_no_mask(self):
instructions = [{'mask': '0x0', 'name': 'bfunc', 'register': 18, 'relation': '==', 'val': '0x1'},
{'conditional': 18, 'name': 'rx', 'qubits': [1], 'params': [-np.pi / 2]}]
self.assertRaisesRegex(ApiError, 'Conditional statement rx without a mask',
self._generate_cqasm_from_instructions, instructions, 2)
def test_generate_cqasm_register_no_match(self):
instructions = [{'mask': '0xF', 'name': 'bfunc', 'register': 1, 'relation': '==', 'val': '0x3'},
{'conditional': 2, 'name': 'rx', 'qubits': [1], 'params': [-np.pi / 2]}]
self.assertRaisesRegex(ApiError, 'Conditional not found: reg_idx = 2',
self._generate_cqasm_from_instructions, instructions, 2)
def test_get_mask_data(self):
mask = 0
lowest_mask_bit, mask_length = CircuitToString.get_mask_data(mask)
self.assertEqual(lowest_mask_bit, -1)
self.assertEqual(mask_length, 0)
mask = 56
lowest_mask_bit, mask_length = CircuitToString.get_mask_data(mask)
self.assertEqual(lowest_mask_bit, 3)
self.assertEqual(mask_length, 3)
mask = 1
lowest_mask_bit, mask_length = CircuitToString.get_mask_data(mask)
self.assertEqual(lowest_mask_bit, 0)
self.assertEqual(mask_length, 1)
mask = 255
lowest_mask_bit, mask_length = CircuitToString.get_mask_data(mask)
self.assertEqual(lowest_mask_bit, 0)
self.assertEqual(mask_length, 8)
mask = 510
lowest_mask_bit, mask_length = CircuitToString.get_mask_data(mask)
self.assertEqual(lowest_mask_bit, 1)
self.assertEqual(mask_length, 8)
mask = 128
lowest_mask_bit, mask_length = CircuitToString.get_mask_data(mask)
self.assertEqual(lowest_mask_bit, 7)
self.assertEqual(mask_length, 1)
mask = 192
lowest_mask_bit, mask_length = CircuitToString.get_mask_data(mask)
self.assertEqual(lowest_mask_bit, 6)
self.assertEqual(mask_length, 2)
|
https://github.com/QuTech-Delft/quantuminspire
|
QuTech-Delft
|
""" Quantum Inspire SDK
Copyright 2022 QuTech Delft
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.
"""
import unittest
from unittest.mock import Mock
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.compiler import assemble
from quantuminspire.qiskit.backend_qx import QuantumInspireBackend
from quantuminspire.exceptions import QiskitBackendError
from quantuminspire.qiskit.measurements import Measurements
class TestMeasurements(unittest.TestCase):
@staticmethod
def _circuit_to_qobj(circuit):
run_config_dict = {'shots': 25, 'memory': True}
backend = QuantumInspireBackend(Mock(), Mock())
qobj = assemble(circuit, backend, **run_config_dict)
return qobj
@staticmethod
def _circuit_to_experiment(circuit):
qobj = TestMeasurements._circuit_to_qobj(circuit)
return qobj.experiments[0]
def test_from_experiment(self):
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
qc.measure(0, 1)
qc.measure(1, 0)
experiment = self._circuit_to_experiment(qc)
measurements = Measurements.from_experiment(experiment)
expected_result = {'measurements_state': [[1, 0], [0, 1]],
'measurements_reg': [[0, 1], [1, 0]],
'number_of_qubits': 2,
'number_of_clbits': 2
}
self.assertDictEqual(measurements.to_dict(), expected_result)
self.assertEqual(measurements.nr_of_qubits, 2)
self.assertEqual(measurements.nr_of_clbits, 2)
def test_collect_measurements_without_measurements(self):
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
experiment = self._circuit_to_experiment(qc)
measurements = Measurements.from_experiment(experiment)
expected_result = {'measurements_state': [[0, 0], [1, 1]],
'measurements_reg': [[0, 0], [1, 1]],
'number_of_qubits': 2,
'number_of_clbits': 2
}
self.assertDictEqual(measurements.to_dict(), expected_result)
self.assertEqual(measurements.nr_of_qubits, 2)
self.assertEqual(measurements.nr_of_clbits, 2)
def test_validate_nr_classical_qubits_less_than_needed_for_storing_measured_qubits(self):
q = QuantumRegister(2, 'q')
c = ClassicalRegister(1, 'c')
qc = QuantumCircuit(q, c, name='conditional')
qc.cx(q[0], q[1])
experiment = self._circuit_to_experiment(qc)
self.assertRaisesRegex(QiskitBackendError, 'Number of classical bits \(1\) is not sufficient for storing the '
'outcomes of the experiment',
Measurements.from_experiment, experiment)
def test_invalid_number_of_classical_bits(self):
qc = QuantumCircuit(2, 2)
qc.measure(1, 0)
qobj = self._circuit_to_qobj(qc)
qobj.experiments[0].header.memory_slots = 0
experiment = qobj.experiments[0]
self.assertRaisesRegex(QiskitBackendError, 'Invalid number of classical bits \(0\)!',
Measurements.from_experiment, experiment)
def test_max_measurement_index(self):
qr = QuantumRegister(5)
cr = ClassicalRegister(3)
cr_ghz = ClassicalRegister(2)
circuit = QuantumCircuit(qr, cr, cr_ghz)
circuit.measure(2, 3)
circuit.measure(3, 4)
circuit.measure([0, 1, 4], cr)
circuit.measure([2, 3], cr_ghz)
experiment = self._circuit_to_experiment(circuit)
measurements = Measurements.from_experiment(experiment)
self.assertEqual(measurements.max_measurement_index, 4)
def test_max_measurement_index_less_than_nr_of_clbits(self):
qr = QuantumRegister(5)
cr = ClassicalRegister(3)
cr_ghz = ClassicalRegister(2)
circuit = QuantumCircuit(qr, cr, cr_ghz)
circuit.measure(2, 3)
circuit.measure([0, 1, 4], cr)
circuit.measure([2], cr_ghz[0])
experiment = self._circuit_to_experiment(circuit)
measurements = Measurements.from_experiment(experiment)
self.assertEqual(measurements.max_measurement_index, 3)
def test_get_qreg_for_conditional_creg(self):
qr = QuantumRegister(5)
cr = ClassicalRegister(3)
cr_ghz = ClassicalRegister(2)
circuit = QuantumCircuit(qr, cr, cr_ghz)
circuit.measure(2, 3)
circuit.measure([1, 4], [1, 2])
circuit.measure([2], cr_ghz[0])
experiment = self._circuit_to_experiment(circuit)
measurements = Measurements.from_experiment(experiment)
self.assertEqual(measurements.get_qreg_for_conditional_creg(3), 2)
self.assertEqual(measurements.get_qreg_for_conditional_creg(1), 1)
self.assertEqual(measurements.get_qreg_for_conditional_creg(2), 4)
self.assertEqual(measurements.get_qreg_for_conditional_creg(0), 0)
self.assertRaisesRegex(QiskitBackendError, 'Classical bit 4 used in a conditional gate is not measured and the '
'equivalent qubit 4 is measured to another classical bit 2',
measurements.get_qreg_for_conditional_creg, 4)
def test_from_dict(self):
input = {'measurements_state': [[0, 0], [1, 1]],
'measurements_reg': [[0, 0], [1, 1]],
'number_of_qubits': 2,
'number_of_clbits': 2
}
measurements = Measurements.from_dict(input)
self.assertEqual(measurements.nr_of_qubits, 2)
self.assertEqual(measurements.nr_of_clbits, 2)
self.assertDictEqual(measurements.to_dict(), input)
def test_measurement_2_qubits_to_1_classical_bit(self):
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
qc.measure(0, 0)
qc.x(0)
qc.measure(1, 0)
experiment = self._circuit_to_experiment(qc)
measurements = Measurements.from_experiment(experiment)
self.assertRaisesRegex(QiskitBackendError, 'Measurement of different qubits to the same classical '
'register 0 is not supported',
measurements.validate_unsupported_measurements)
def test_measurement_1_qubit_to_2_classical_bits(self):
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
qc.measure(1, 1)
qc.measure(0, 0)
qc.x(0)
qc.measure(1, 0)
experiment = self._circuit_to_experiment(qc)
measurements = Measurements.from_experiment(experiment)
self.assertRaisesRegex(QiskitBackendError, 'Measurement of qubit 1 to different classical registers '
'is not supported',
measurements.validate_unsupported_measurements)
def test_qubit_to_classical_hex(self):
qc = QuantumCircuit(4, 4)
qc.measure(0, 0)
qc.measure(1, 1)
qc.measure(2, 2)
qc.measure(3, 3)
experiment = self._circuit_to_experiment(qc)
measurements = Measurements.from_experiment(experiment)
self.assertEqual(measurements.qubit_to_classical_hex('3'), '0x3')
self.assertEqual(measurements.qubit_to_classical_hex('7'), '0x7')
self.assertEqual(measurements.qubit_to_classical_hex('10'), '0xa')
def test_qubit_to_classical_hex_reversed(self):
qc = QuantumCircuit(4, 4)
qc.measure(0, 3)
qc.measure(1, 2)
qc.measure(2, 1)
qc.measure(3, 0)
experiment = self._circuit_to_experiment(qc)
measurements = Measurements.from_experiment(experiment)
self.assertEqual(measurements.qubit_to_classical_hex('3'), '0xc')
self.assertEqual(measurements.qubit_to_classical_hex('7'), '0xe')
self.assertEqual(measurements.qubit_to_classical_hex('10'), '0x5')
|
https://github.com/derek-wang-ibm/coding-with-qiskit
|
derek-wang-ibm
|
import qiskit
qiskit.__version__
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService(channel="ibm_quantum", # ibm_cloud
token = 'YOURTOKENHERE')
QiskitRuntimeService.save_account(channel='ibm_quantum',
token = 'YOURTOKENHERE')
backend = service.backend(name = "ibm_brisbane")
backend.num_qubits
|
https://github.com/derek-wang-ibm/coding-with-qiskit
|
derek-wang-ibm
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.draw(output='mpl')
from qiskit.quantum_info import Pauli
ZZ = Pauli('ZZ')
ZI = Pauli('ZI')
IZ = Pauli('IZ')
XX = Pauli('XX')
XI = Pauli('XI')
IX = Pauli('IX')
observables = [ZZ, ZI, IZ, XX, XI, IX]
from qiskit_aer.primitives import Estimator
estimator = Estimator()
job = estimator.run([qc] * len(observables), observables)
job.result()
import matplotlib.pyplot as plt
data = ['ZZ', 'ZI', 'IZ', 'XX', 'XI', 'IX']
values = job.result().values
plt.plot(data, values, '-o')
plt.xlabel('Observables')
plt.ylabel('Expectation value')
plt.show()
def get_qc_for_n_qubit_GHZ_state(n):
qc = QuantumCircuit(n)
qc.h(0)
for i in range(n-1):
qc.cx(i, i+1)
return qc
n = 100
qc = get_qc_for_n_qubit_GHZ_state(n)
qc.draw(output='mpl')
from qiskit.quantum_info import SparsePauliOp
operator_strings = ['Z' + 'I' * i + 'Z' + 'I' * (n-2-i) for i in range(n-1)]
print(operator_strings)
print(len(operator_strings))
operators = [SparsePauliOp(operator_string) for operator_string in operator_strings]
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
backend = QiskitRuntimeService().least_busy(simulator=False, operational=True, min_num_qubits=100)
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend)
qc_transpiled = pass_manager.run(qc)
operators_transpiled_list = [op.apply_layout(qc_transpiled.layout) for op in operators]
from qiskit_ibm_runtime import EstimatorV2 as Estimator
from qiskit_ibm_runtime import EstimatorOptions
options = EstimatorOptions()
options.resilience_level = 1
options.optimization_level = 0
options.dynamical_decoupling.enable = True
options.dynamical_decoupling.sequence_type = "XY4"
estimator = Estimator(backend, options=options)
job = estimator.run([(qc_transpiled, operators_transpiled_list)])
job_id = job.job_id()
print(job_id)
job_id = 'cqq05tz267h0008fj6qg'
service = QiskitRuntimeService()
job = service.job(job_id)
import matplotlib.pyplot as plt
data = list(range(1, len(operators)+1))
result = job.result()[0]
values = result.data.evs
values = [v / values[0] for v in values]
plt.scatter(data, values, marker='o', label='100-qubit GHZ state')
plt.xlabel('Distance between qubits $i$')
plt.ylabel(r'$\langle Z_0 Z_i \rangle / \langle Z_0 Z_1 \rangle$')
plt.legend()
plt.show()
|
https://github.com/derek-wang-ibm/coding-with-qiskit
|
derek-wang-ibm
|
from qiskit import QuantumCircuit
from qiskit.circuit.library import YGate, UnitaryGate
import numpy as np
SYGate = UnitaryGate(YGate().power(1/2), label=r"$\sqrt{Y}$")
SYdgGate = UnitaryGate(SYGate.inverse(), label=r"$\sqrt{Y}^\dag$")
def generate_1d_tfim_circuit(num_qubits, num_trotter_steps, rx_angle, num_cl_bits=0, trotter_barriers = False, layer_barriers = False):
if num_cl_bits == 0:
qc = QuantumCircuit(num_qubits)
else:
qc = QuantumCircuit(num_qubits, num_cl_bits)
for trotter_step in range(num_trotter_steps):
add_1d_tfim_trotter_layer(qc, rx_angle, layer_barriers)
if trotter_barriers:
qc.barrier()
return qc
def add_1d_tfim_trotter_layer(qc, rx_angle, layer_barriers = False):
# Adding Rzz in the even layers
for i in range(0, qc.num_qubits-1, 2):
qc.sdg([i, i+1])
qc.append(SYGate, [i+1])
qc.cx(i, i+1)
qc.append(SYdgGate, [i+1])
if layer_barriers:
qc.barrier()
# Adding Rzz in the odd layers
for i in range(1, qc.num_qubits-1, 2):
qc.sdg([i, i+1])
qc.append(SYGate, [i+1])
qc.cx(i, i+1)
qc.append(SYdgGate, [i+1])
if layer_barriers:
qc.barrier()
qc.rx(rx_angle, list(range(qc.num_qubits)))
if layer_barriers:
qc.barrier()
num_qubits = 6
num_trotter_steps = 1
rx_angle = 0.5 * np.pi
qc = generate_1d_tfim_circuit(num_qubits, num_trotter_steps, rx_angle, trotter_barriers=True, layer_barriers=True)
qc.draw(output='mpl', fold=-1)
def append_mirrored_1d_tfim_circuit(qc, num_qubits, num_trotter_steps, rx_angle, trotter_barriers = False, layer_barriers = False):
for trotter_step in range(num_trotter_steps):
add_mirrored_1d_tfim_trotter_layer(qc, rx_angle, layer_barriers)
if trotter_barriers:
qc.barrier()
def add_mirrored_1d_tfim_trotter_layer(qc, rx_angle, layer_barriers = False):
# Note after filming:
# I constructed the inverse by hand here
# But you could also use QuantumCircuit.inverse() to do this more efficiently
qc.rx(-rx_angle, list(range(qc.num_qubits)))
if layer_barriers:
qc.barrier()
# Adding Rzz in the odd layers
for i in range(1, qc.num_qubits-1, 2):
qc.append(SYGate, [i+1])
qc.cx(i, i+1)
qc.append(SYdgGate, [i+1])
qc.s([i, i+1])
if layer_barriers:
qc.barrier()
# Adding Rzz in the even layers
for i in range(0, qc.num_qubits-1, 2):
qc.append(SYGate, [i+1])
qc.cx(i, i+1)
qc.append(SYdgGate, [i+1])
qc.s([i, i+1])
if layer_barriers:
qc.barrier()
append_mirrored_1d_tfim_circuit(qc, num_qubits, num_trotter_steps, rx_angle, trotter_barriers=True, layer_barriers=True)
qc.draw(output='mpl', fold=-1)
max_trotter_steps = 10
num_qubits = 100
measured_qubits = [49, 50]
qc_list = []
for trotter_step in range(max_trotter_steps):
qc = generate_1d_tfim_circuit(num_qubits, trotter_steps, rx_angle, num_cl_bits=len(measured_qubits), trotter_barriers=True, layer_barriers=True)
append_mirrored_1d_tfim_circuit(qc, num_qubits, trotter_steps, rx_angle, trotter_barriers=True, layer_barriers=True)
qc.measure(measured_qubits, list(range(len(measured_qubits))))
qc_list.append(qc)
from qiskit import transpile
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
backend = service.backend(name='ibm_brisbane')
print("Done getting the backend")
# Note after filming:
# `transpile` will be deprecated soon
# so in the future, use `generate_preset_pass_manager` to achieve similar functionality
qc_transpiled_list = transpile(qc_list, backend=backend, optimization_level=1)
from qiskit_ibm_runtime import SamplerV2 as Sampler
sampler = Sampler(backend=backend)
sampler.options.dynamical_decoupling.enable = True
sampler.options.dynamical_decoupling.sequence_type = "XY4"
job = sampler.run(qc_transpiled_list)
print(job.job_id())
job_id = "cqp5rvb417q0008yq3b0"
job = service.job(job_id)
survival_probability_list = []
for trotter_step in range(max_trotter_steps):
try:
data = job.result()[trotter_step].data
survival_probability_list.append(data.c.get_counts()['0' * len(measured_qubits)] / data.c.num_shots)
except:
survival_probability_list.append(0)
import matplotlib.pyplot as plt
plt.plot(list(range(0, 4 * max_trotter_steps, 4)), survival_probability_list, '--o')
plt.xlabel('2Q Gate Depth')
plt.ylabel('Survival Probability of the all-0 bitstring')
plt.xticks(np.arange(0, 44, 4))
plt.show()
from qiskit.circuit import Parameter
rx_angle = Parameter("rx_angle")
trotter_steps = 2
qc = generate_1d_tfim_circuit(num_qubits, trotter_steps, rx_angle)
from qiskit.quantum_info import SparsePauliOp
middle_index = num_qubits // 2
observable = SparsePauliOp("I" * middle_index + "Z" + "I" * (middle_index-1))
from qiskit import transpile
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
backend = service.backend(name='ibm_brisbane')
# Note after filming:
# `transpile` will be deprecated soon
# so in the future, use `generate_preset_pass_manager` to achieve similar functionality
qc_transpiled = transpile(qc, backend=backend, optimization_level=1)
observable = observable.apply_layout(qc_transpiled.layout)
from qiskit_ibm_runtime import EstimatorV2, EstimatorOptions
min_rx_angle = 0
max_rx_angle = np.pi/2
num_rx_angle = 12
rx_angle_list = np.linspace(min_rx_angle, max_rx_angle, num_rx_angle)
options = EstimatorOptions()
options.resilience_level = 1
options.dynamical_decoupling.enable = True
options.dynamical_decoupling.sequence_type = "XY4"
estimator = EstimatorV2(backend=backend, options=options)
job = estimator.run([(qc_transpiled, observable, rx_angle_list)])
print(job.job_id())
job_id = "cqp5xtq417q0008yq43g"
job = service.job(job_id)
exp_val_list = job.result()[0].data.evs
plt.plot(rx_angle_list / np.pi, exp_val_list, '--o')
plt.xlabel(r'Rx angle ($\pi$)')
plt.ylabel(r'$\langle Z \rangle$ in the middle of the chain')
plt.ylim(-0.1, 1.1)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.