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)