def _refresh_ibmq_account():
"""
Refresh IBMQ account by enabling or disabling it depending on preferences stored values
"""
preferences = Preferences().ibmq_credentials_preferences
token = preferences.token or ''
proxies = preferences.proxies or {}
hub = preferences.hub
group = preferences.group
project = preferences.project
provider = None
try:
# pylint: disable=no-name-in-module, import-error
from qiskit import IBMQ
providers = IBMQ.providers()
if token != '':
# check if there was a previous account that needs to be disabled first
disable_account = False
enable_account = True
for provider in providers:
if provider.credentials.token == token and provider.credentials.proxies == proxies:
enable_account = False
else:
disable_account = True
if disable_account:
IBMQ.disable_account()
logger.info('Disabled IBMQ account.')
if enable_account:
IBMQ.enable_account(token, proxies=proxies)
logger.info('Enabled IBMQ account.')
providers = IBMQ.providers(hub=hub, group=group, project=project)
provider = providers[0] if providers else None
if provider is None:
logger.info(
"No Provider found for IBMQ account. "
"Hub/Group/Project: '%s/%s/%s' Proxies:'%s'", hub, group,
project, proxies)
else:
if providers:
IBMQ.disable_account()
logger.info('Disabled IBMQ account.')
except Exception as ex: # pylint: disable=broad-except
logger.warning(
"IBMQ account Account Failure. "
"Hub/Group/Project: '%s/%s/%s' "
"Proxies:'%s' :%s", hub, group, project, proxies, str(ex))
return provider
def get_unique_backends():
"""Gets the unique backends that are available.
Returns:
list: Unique available backends.
Raises:
QiskitError: No backends available.
ImportError: If qiskit-ibmq-provider is not installed
"""
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
raise ImportError("The IBMQ provider is necessary for this function "
" to work. Please ensure it's installed before "
"using this function")
backends = []
for provider in IBMQ.providers():
for backend in provider.backends():
backends.append(backend)
unique_hardware_backends = []
unique_names = []
for back in backends:
if back.name(
) not in unique_names and not back.configuration().simulator:
unique_hardware_backends.append(back)
unique_names.append(back.name())
if not unique_hardware_backends:
raise QiskitError('No backends available.')
return unique_names
def iqx_dashboard(self, line='', cell=None):
"""A Jupyter magic function to enable job watcher.
"""
from qiskit import IBMQ
pro = IBMQ.providers()
if not pro:
try:
IBMQ.load_account()
except Exception:
raise QiskitError(
"Could not load IBMQ account from local file.")
else:
pro = IBMQ.providers()
if not pro:
raise QiskitError(
"No providers found. Must load your IBMQ account.")
_IQX_DASHBOARD.stop_dashboard()
_IQX_DASHBOARD.start_dashboard()
def get_ibmq_systems():
"""Get instances for all IBMQ systems that the user has access to.
Returns:
dict: A dict of all IBMQ systems that a user has access to.
"""
ibmq_backends = {}
for pro in IBMQ.providers():
for back in pro.backends():
if not back.configuration().simulator:
if back.name() not in ibmq_backends \
and ('alt' not in back.name()) \
and back.name().startswith('ibmq'):
ibmq_backends[back.name()] = back
return ibmq_backends
def _get_backends(self):
from qiskit import IBMQ
ibmq_backends = {}
for pro in IBMQ.providers():
pro_name = "{hub}/{group}/{project}".format(
hub=pro.credentials.hub,
group=pro.credentials.group,
project=pro.credentials.project)
for back in pro.backends():
if not back.configuration().simulator:
if back.name() not in ibmq_backends.keys():
ibmq_backends[back.name()] = [back, [pro_name]]
else:
ibmq_backends[back.name()][1].append(pro_name)
self.backend_dict = ibmq_backends
def __init__(self, num_qubits, coupling_map=[], device='simulator'):
'''
Args:
num_qubits: The number of qubits, and hence the number of nodes in the graph.
coupling_map: A list of pairs of qubits, corresponding to edges in the graph.
If none is given, a fully connected graph is used.
device: The device on which the graph will be run. Can be given as a Qiskit backend object
or a description of the device as a string. If none is given, a local simulator is used.
'''
self.num_qubits = num_qubits
# the coupling map consists of pairs [j,k] with the convention j<k
self.coupling_map = []
for j in range(self.num_qubits - 1):
for k in range(j + 1, self.num_qubits):
if ([j, k] in coupling_map) or ([
j, k
] in coupling_map) or (not coupling_map):
self.coupling_map.append([j, k])
# use the `device` input to make a Qiskit backend object
if type(device) is str:
if device == 'simulator':
self.backend = Aer.get_backend('qasm_simulator')
else:
try:
if device[0:4] == 'ibmq':
backend_name = device
else:
backend_name = 'ibmq_' + backend
for provider in IBMQ.providers():
for potential_backend in provider.backends():
if potential_backend.name() == backend_name:
self.backend = potential_backend
self.coupling_map = self.backend.configuration(
).coupling_map
except:
print(
'The given device does not correspond to a valid IBMQ backend'
)
else:
self.backend = device
# create the quantum circuit, and initialize the tomography
self.qc = QuantumCircuit(self.num_qubits)
self.update_tomography()
def test_process_characterisation() -> None:
if not IBMQ.active_account():
IBMQ.load_account()
provider = IBMQ.providers(hub="ibm-q", group="open")[0]
back = provider.get_backend("ibmq_santiago")
char = process_characterisation(back)
dev = Device(
char.get("NodeErrors", {}),
char.get("EdgeErrors", {}),
char.get("Architecture", Architecture([])),
)
assert len(dev.nodes) == 5
assert len(dev.errors_by_node) == 5
assert len(dev.coupling) == 8
def test_tketautopass() -> None:
backends = [
Aer.get_backend("statevector_simulator"),
Aer.get_backend("qasm_simulator"),
Aer.get_backend("unitary_simulator"),
]
if not skip_remote_tests:
if not IBMQ.active_account():
IBMQ.load_account()
provider = IBMQ.providers()[0]
backends.append(provider.get_backend("ibmq_santiago"))
for back in backends:
for o_level in range(3):
tkpass = TketAutoPass(back, o_level)
qc = get_test_circuit(True)
pm = PassManager(passes=tkpass)
pm.run(qc)
def enable_ibmq_account(url, token, proxies):
"""
Enable IBMQ account, if not alreay enabled.
"""
provider = None
if not has_ibmq():
return provider
try:
url = url or ''
token = token or ''
proxies = proxies or {}
if url != '' and token != '':
# pylint: disable=no-name-in-module, import-error
from qiskit import IBMQ
from qiskit.providers.ibmq.credentials import Credentials
credentials = Credentials(token, url, proxies=proxies)
unique_id = credentials.unique_id()
if IBMQ._v1_provider._accounts:
if unique_id in IBMQ._v1_provider._accounts:
# disable first any existent previous account with same unique_id and different properties
enabled_credentials = IBMQ._v1_provider._accounts[unique_id].credentials
if enabled_credentials.url != url or enabled_credentials.token != token or enabled_credentials.proxies != proxies:
del IBMQ._v1_provider._accounts[unique_id]
else:
return IBMQ._v1_provider
elif IBMQ._credentials:
enabled_credentials = IBMQ._credentials
# disable first any existent previous account with same unique_id and different properties
if enabled_credentials.url != url or enabled_credentials.token != token or enabled_credentials.proxies != proxies:
IBMQ.disable_account()
else:
providers = IBMQ.providers(hub=unique_id.hub, group=unique_id.group, project=unique_id.project)
return providers[0] if providers else None
provider = IBMQ.enable_account(token, url=url, proxies=proxies)
logger.info("Enabled IBMQ account. Url:'{}' Token:'{}' "
"Proxies:'{}'".format(url, token, proxies))
except Exception as e:
logger.warning("Failed to enable IBMQ account. Url:'{}' Token:'{}' "
"Proxies:'{}' :{}".format(url, token, proxies, str(e)))
return provider
def test_backend_monitor(self, qe_token, qe_url):
"""Test backend_monitor"""
from qiskit import IBMQ # pylint: disable: import-error
IBMQ.enable_account(qe_token, qe_url)
self.addCleanup(IBMQ.disable_account)
for provider in IBMQ.providers():
for back in provider.backends():
if not back.configuration().simulator:
backend = back
break
with patch('sys.stdout', new=StringIO()) as fake_stdout:
backend_monitor(backend)
stdout = fake_stdout.getvalue()
self.assertIn('Configuration', stdout)
self.assertIn(
'Qubits [Name / Freq / T1 / T2 / U1 err / U2 err / U3 err / Readout err]',
stdout)
self.assertIn('Multi-Qubit Gates [Name / Type / Gate Error]', stdout)
def __init__(self):
super().__init__()
# load accounts
from qiskit import IBMQ
IBMQ.load_account()
# check whether we have accounts
providers = IBMQ.providers()
assert len(providers) > 0, "no account loaded"
# choose account with most backends coming up last
providers.sort(key=lambda p: len(p.backends()))
self.IBMQ_cloud_providers = providers
print_hl(
f"IBMQ cloud account{'s' if len(providers)>1 else ''} loaded: " +
" ".join(p.credentials.group for p in providers))
def _system_loader(service):
if not any(IBMQ.providers()):
try:
IBMQ.load_account()
except Exception: # pylint: disable=broad-except
pass
systems = get_ibmq_systems()
with warnings.catch_warnings():
warnings.simplefilter("ignore")
for name, system in systems.items():
new_name = '{}_'+name.split('_')[-1]+'_simulator'
system = DeviceSimulator(system,
new_name.format('aer'),
local=True)
system2 = DeviceSimulator(system,
new_name.format('ibmq'),
local=False)
setattr(service, system.name(), system)
setattr(service, system2.name(), system2)
service.refreshing = False
#2πJ(ala†k+a†lak),
#where the subscript denotes which qubit the operators act on. - Additionally, for numerical simulation, it is necessary to specify a cutoff dimension; the Duffing oscillator model is infinite dimensional, and computer simulation requires restriction of the operators to a finite dimensional subspace.
#%matplotlib inline
import qiskit
#qiskit.__version__
from qiskit import IBMQ
MY_API_TOKEN = 'a93830f80226030329fc4e2e4d78c06bdf1942ce349fcf8f5c8021cfe8bd5abb01e4205fbd7b9c34f0b26bd335de7f1bcb9a9187a2238388106d16c6672abea2'
provider = IBMQ.enable_account(MY_API_TOKEN)
IBMQ.save_account(MY_API_TOKEN , overwrite=True)
#IBMQ.get_provider(hub='ibm-q', group='open', project='main')
#IBMQ.load_account()
print(IBMQ.providers())
backend = provider.get_backend('ibmq_qasm_simulator')
#IBMQ.update_account(MY_API_TOKEN)
#provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
#backend = provider.get_backend('ibmq_armonk')
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Loading your IBM Q account(s)
#provider = IBMQ.load_account()
import warnings
warnings.filterwarnings('ignore')
from qiskit.tools.jupyter import *
#!/usr/bin/env python
# coding: utf-8
# In[1]:
get_ipython().run_line_magic('matplotlib', 'inline')
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Loading your IBM Q account(s)
TOKEN = '4bb7bfab446013a8f953525f3692437a0a314f4f2784431d78ee3eaacd042dfbba453ede40f604c8c996197cde23c9fb509d22c8132c5ac0fd3ffe10c5885bf4'
IBMQ.load_account() # Load account from disk
providers = IBMQ.providers()
provider = IBMQ.get_provider(hub='ibm-q')
print(provider)
print(provider.backends())
backend = provider.get_backend('ibmq_london')
# In[9]:
from qiskit import *
from qiskit.providers.aer import noise, QasmSimulator, StatevectorSimulator, UnitarySimulator
from qiskit.providers.aer.noise import NoiseModel
#Using simulator from Qiskit Aer
backend_sim = Aer.get_backend('qasm_simulator')
#Using real machine as a backend
import argparse
import random
import math
from qiskit import IBMQ, QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.tools.monitor import job_monitor
import executor
IBMQ.providers()
SHOTS = 1024
run_on_real = False
def comp_move():
return random.randint(0, 5) # Computer's moves are dumb. But that doesn't matter for this exercise
def print_status(status, ship_pos): # Clean this method up
status_for_pos = status_at_pos(ship_pos, status)
print_layout(status_for_pos)
def status_at_pos(ship_pos, status):
status_for_pos = []
for pos in range(5):
if pos in ship_pos:
idx = ship_pos.index(pos)
damage_to_ship = status[idx]
if damage_to_ship - 0 < 5:
# setting up the backend
print("(BasicAER Backends)")
print(BasicAer.backends())
# running the job
job_sim = execute([qc1, qc2], BasicAer.get_backend('qasm_simulator'))
sim_result = job_sim.result()
# Show the results
print(sim_result.get_counts(qc1))
print(sim_result.get_counts(qc2))
# see a list of available remote backends
print("\n(IBMQ Backends)")
print(IBMQ.providers()[0].backends())
# Compile and run on a real device backend
try:
# select least busy available device and execute.
least_busy_device = least_busy(provider.backends(simulator=False))
except:
print("All devices are currently unavailable.")
print("Running on current least busy device: ", least_busy_device)
# running the job
job_exp = execute([qc1, qc2], backend=least_busy_device, shots=1024, max_credits=10)
job_monitor(job_exp)
exp_result = job_exp.result()
#
# Our supported backends have helper methods for creating Devices. This requires installation of qiskit and a valid IBMQ user logged in.
from qiskit import IBMQ
IBMQ.load_account()
# If ```IBMQBackend``` available in ```pytket_qiskit``` is used the characterisation and Device is automatically constructed.
#
# Alternatively, lets use the ```process_characterisation``` method to access characterisation information for the athens computer and then construct a pytket device from suitable characteristics.
#
# The dictionary returned by ```process_characterisation``` returns additional characterisation information as provided by IBMQ, including t1 times, t2 times, qubit frequencies and gate times.
from pytket.extensions.qiskit import process_characterisation
provider = IBMQ.providers()[0]
athens_backend = provider.get_backend("ibmq_athens")
athens_characterisation = process_characterisation(athens_backend)
athens_device = Device(
athens_characterisation["NodeErrors"],
athens_characterisation["EdgeErrors"],
athens_characterisation["Architecture"],
)
print(athens_device.__repr__())
print(athens_characterisation.keys())
draw_graph(athens_device.coupling)
# Let's look at the some single-qubit Device information for different qubits:
from qiskit import Aer
from qiskit import IBMQ
for backend in Aer.backends():
print(backend.name())
for backend in IBMQ.providers():
print(backend.name())
# First, import the ```SpamCorrecter``` class.
from pytket.utils.spam import SpamCorrecter
# The SpamCorrecter class has methods for generating State Preparation and Measurement (SPAM) calibration experiments for pytket backends and correcting counts generated from those same backends.
#
# Let's first mitigate error from a noisy simulation, using a noise model straight from the 5-qubit IBMQ Santiago device. This will require a preloaded IBMQ account.
from qiskit import IBMQ
IBMQ.load_account()
from pytket.extensions.qiskit import process_characterisation
from pytket.device import Device
ibmq_santiago_backend = IBMQ.providers()[0].get_backend("ibmq_santiago")
pytket_santiago_characterisation = process_characterisation(
ibmq_santiago_backend)
pytket_santiago_device = Device(
pytket_santiago_characterisation["NodeErrors"],
pytket_santiago_characterisation["EdgeErrors"],
pytket_santiago_characterisation["Architecture"],
)
import networkx as nx
import matplotlib.pyplot as plt
santiago_graph = nx.Graph(pytket_santiago_device.coupling)
nx.draw(santiago_graph, labels={node: node for node in santiago_graph.nodes()})
# SPAM correction requires subsets of qubits which are assumed to only have SPAM errors correlated with each other, and no other qubits.
def __init__(
self,
backend_name: str,
hub: Optional[str] = None,
group: Optional[str] = None,
project: Optional[str] = None,
monitor: bool = True,
):
"""A backend for running circuits on remote IBMQ devices.
:param backend_name: Name of the IBMQ device, e.g. `ibmqx4`,
`ibmq_16_melbourne`.
:type backend_name: str
:param hub: Name of the IBMQ hub to use for the provider.
If None, just uses the first hub found. Defaults to None.
:type hub: Optional[str], optional
:param group: Name of the IBMQ group to use for the provider. Defaults to None.
:type group: Optional[str], optional
:param project: Name of the IBMQ project to use for the provider.
Defaults to None.
:type project: Optional[str], optional
:param monitor: Use the IBM job monitor. Defaults to True.
:type monitor: bool, optional
:raises ValueError: If no IBMQ account is loaded and none exists on the disk.
"""
super().__init__()
if not IBMQ.active_account():
if IBMQ.stored_account():
IBMQ.load_account()
else:
raise NoIBMQAccountError()
provider_kwargs = {}
if hub:
provider_kwargs["hub"] = hub
if group:
provider_kwargs["group"] = group
if project:
provider_kwargs["project"] = project
try:
if provider_kwargs:
provider = IBMQ.get_provider(**provider_kwargs)
else:
provider = IBMQ.providers()[0]
except qiskit.providers.ibmq.exceptions.IBMQProviderError as err:
logging.warn(
("Provider was not specified enough, specify hub,"
"group and project correctly (check your IBMQ account)."))
raise err
self._backend: "_QiskIBMQBackend" = provider.get_backend(backend_name)
self._config: "QasmBackendConfiguration" = self._backend.configuration(
)
self._gate_set: Set[OpType]
# simulator i.e. "ibmq_qasm_simulator" does not have `supported_instructions`
# attribute
self._gate_set = _tk_gate_set(self._backend)
self._mid_measure = self._config.simulator or self._config.multi_meas_enabled
self._legacy_gateset = OpType.V not in self._gate_set
if self._legacy_gateset:
if not self._gate_set >= {
OpType.U1, OpType.U2, OpType.U3, OpType.CX
}:
raise NotImplementedError(
f"Gate set {self._gate_set} unsupported")
self._rebase_pass = RebaseIBM()
else:
if not self._gate_set >= {
OpType.X, OpType.V, OpType.Rz, OpType.CX
}:
raise NotImplementedError(
f"Gate set {self._gate_set} unsupported")
self._rebase_pass = RebaseCustom(
{OpType.CX},
Circuit(2).CX(0, 1),
{OpType.X, OpType.V, OpType.Rz},
_tk1_to_x_v_rz,
)
if hasattr(self._config, "max_experiments"):
self._max_per_job = self._config.max_experiments
else:
self._max_per_job = 1
self._characterisation: Dict[str, Any] = process_characterisation(
self._backend)
self._device = Device(
self._characterisation.get("NodeErrors", {}),
self._characterisation.get("EdgeErrors", {}),
self._characterisation.get("Architecture", Architecture([])),
)
self._monitor = monitor
self._MACHINE_DEBUG = False
def ChooseBackEnd(quantumCircuit, backendType="statevector_simulator", qubitsToBeMeasured=range(4), numberShots=4096, noisePresent=False, RealDeviceName="ibmq_ourense",number=12):
if backendType == "statevector_simulator":
backend = Aer.get_backend('statevector_simulator')
result = execute(quantumCircuit, backend).result()
probabilityVectors = np.square(np.absolute(result.get_statevector()))
listForMusic = []
for k in range(2**len(qubitsToBeMeasured)):
listForMusic.append("%.3f" % (probabilityVectors[k]))
elif backendType == "qasm_simulator":
if noisePresent == False:
# no noise
quantumCircuit.measure(qubitsToBeMeasured, qubitsToBeMeasured)
print(qubitsToBeMeasured)
backend = Aer.get_backend('qasm_simulator')
result = execute(quantumCircuit, backend, shots=numberShots).result()
counts = result.get_counts()
listForMusic = []
for i in range(2**len(qubitsToBeMeasured)):
bitstring = str(bin(i)[2:])
bitstring = "0"*(4-len(bitstring))+bitstring
if bitstring in counts.keys():
listForMusic.append("%.3f" % (counts[bitstring]/float(numberShots)))
else:
listForMusic.append("0.000")
else:
print(qubitsToBeMeasured)
quantumCircuit.measure(qubitsToBeMeasured,qubitsToBeMeasured)
provider=IBMQ.save_account('XXX-YOUR-TOKEN')
# simulate noise of a real device
IBMQ.load_account()
IBMQ.providers()
device = IBMQ.get_provider(hub='ibm-q', group='open', project='main').get_backend(RealDeviceName)
properties = device.properties()
coupling_map = device.configuration().coupling_map
# Generate an Aer noise model for device
noise_model = noise.device.basic_device_noise_model(properties)
basis_gates = noise_model.basis_gates
# Perform noisy simulation
backend = Aer.get_backend('qasm_simulator')
job_sim = execute(quantumCircuit, backend,
coupling_map=coupling_map,
noise_model=noise_model,
basis_gates=basis_gates)
result = job_sim.result()
counts = result.get_counts()
listForMusic = []
for i in range(2**len(qubitsToBeMeasured)):
bitstring = str(bin(i)[2:])
bitstring = "0"*(4-len(bitstring))+bitstring
if bitstring in counts.keys():
listForMusic.append("%.3f" % (counts[bitstring]/float(numberShots)))
else:
listForMusic.append("0.000")
elif backendType == "real_device":
# real device
quantumCircuit.measure(qubitsToBeMeasured,qubitsToBeMeasured)
provider=IBMQ.save_account('XXX-YOUR-TOKEN')
# simulate noise of a real device
IBMQ.load_account()
IBMQ.providers()
device = IBMQ.get_provider(hub='ibm-q', group='open', project='main').get_backend(RealDeviceName)
job_exp = execute(quantumCircuit, backend=device)
job_monitor(job_exp)
result = job_exp.result()
counts = result.get_counts()
listForMusic = []
for i in range(2**len(qubitsToBeMeasured)):
bitstring = str(bin(i)[2:])
bitstring = "0"*(4-len(bitstring))+bitstring
if bitstring in counts.keys():
listForMusic.append(" %.3f" % (counts[bitstring]/float(numberShots)))
else:
listForMusic.append("0.000")
return listForMusic
df_sig = df.loc[df.isSignal==1, SelectedFeatures]
df_bkg = df.loc[df.isSignal==0, SelectedFeatures]
df_sig_training = df_sig.values[:training_size]
df_bkg_training = df_bkg.values[:training_size]
df_sig_test = df_sig.values[training_size:training_size+testing_size]
df_bkg_test = df_bkg.values[training_size:training_size+testing_size]
training_input = {'1':df_sig_training, '0':df_bkg_training}
test_input = {'1':df_sig_test, '0':df_bkg_test}
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
from qiskit import IBMQ
IBMQ.load_account()
print("Available backends:",IBMQ.providers())
provider0 = IBMQ.get_provider(project='icepp')
print("Backends for project 'icepp':",provider0.backends())
backend = provider0.get_backend(backend_name)
properties = backend.properties()
coupling_map = backend.configuration().coupling_map
print("coupling_map =",coupling_map)
simulator = Aer.get_backend('qasm_simulator')
optimizer = COBYLA(maxiter=niter, disp=True)
feature_map = FEATMAPExpansion(feature_dimension=feature_dim, depth=uin_depth)
var_form = RYRZ(num_qubits=feature_dim, depth=uvar_depth)
vqc = VQC(optimizer, feature_map, var_form, training_input, test_input)
real_data = take_from_dist_1(N)
print('Data bounds:', bounds)
print('Batch size:', batch_size)
print('Number of qubits:', num_qubits)
print('Target relative entropy:', target_rel_ent)
print('Initial data length:', N)
print('Initial data:', real_data)
print('Unknown target probabilities:', unknown_target_data_prob)
print('')
# Set quantum instance to run the quantum generator
if real_backend:
print('Real backend loading...')
IBMQ.load_account() # Load account from disk
IBMQ.providers() # List all available providers
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_santiago')
quantum_instance = QuantumInstance(backend=backend)
print('Backend:', backend)
print('')
else:
quantum_instance = QuantumInstance(backend=BasicAer.get_backend('statevector_simulator'))
# Initialize qGAN
iqgan = IQGAN(
real_data,
target_rel_ent,
num_qubits,
bounds,
batch_size,
from async_job.api.object_store import ObjectStore
from qiskit import *
from qiskit import IBMQ
import json
from client import QobjEncoder
from qiskit.compiler import transpile, assemble
from qiskit.qobj.qasm_qobj import QasmQobj as QasmQobj
import os
token = os.getenv('BACKEND_TOKEN')
IBMQ.save_account(token)
IBMQ.load_account() # Load account from disk
print(IBMQ.providers()) # List all available providers
provider = IBMQ.get_provider(hub='ibm-q')
IBMQ.get_provider(group='open')
print("The backends are:")
print(provider.backends())
print("Selecting backend ibmq_qasm_simulator...")
backend = provider.get_backend('ibmq_qasm_simulator')
print(backend)
#Asynchronous using run
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
mapped_circuit = transpile(qc, backend=backend)
qobj = assemble(mapped_circuit, backend=backend, shots=1024)
