def check_and_load_accounts(): if IBMQ.active_account() is None: # try loading account IBMQ.load_account() if IBMQ.active_account() is None: # try grabbing token from environment logger.debug("Using token: {}".format(os.environ['QE_TOKEN'])) IBMQ.enable_account(os.environ['QE_TOKEN'])
def run_grover(algorithm,oracle_type,oracle_method): # Run the algorithm on a simulator, printing the most frequently occurring result backend = Aer.get_backend('qasm_simulator') result = algorithm.run(backend) print("Oracle method:",oracle_method) print("Oracle for:", oracle_type) print("Aer Result:",result['top_measurement']) display(plot_histogram(result['measurement'])) # Run the algorithm on an IBM Q backend, printing the most frequently occurring result print("Getting provider...") if not IBMQ.active_account(): IBMQ.load_account() provider = IBMQ.get_provider() from qiskit.providers.ibmq import least_busy filtered_backend = least_busy(provider.backends(n_qubits=5, operational=True, simulator=False)) result = algorithm.run(filtered_backend) print("Oracle method:",oracle_method) print("Oracle for:", oracle_type) print("IBMQ "+filtered_backend.name()+" Result:",result['top_measurement']) display(plot_histogram(result['measurement'])) print(result)
def _get_provider(): if IBMQ.active_account() is None: ibmq_token = os.environ["IBMQ_TOKEN"] provider = IBMQ.enable_account(ibmq_token) else: provider = IBMQ.get_provider(hub="ibm-q", group="open", project="main") return provider
def login_IBMQ_okay() -> bool: ibmq_token = os.environ.get("IBMQ_TOKEN", "") if ibmq_token: QiskitIBMQ.enable_account(ibmq_token) else: QiskitIBMQ.load_account() return bool(QiskitIBMQ.active_account())
def load_IBMQ(token, hub, group, project): if len(IBMQ.stored_account()) == 0: IBMQ.save_account(token) IBMQ.load_account() elif IBMQ.active_account() == None: IBMQ.load_account() provider = IBMQ.get_provider(hub=hub, group=group, project=project) return provider
def save_IBMQ_account(self, token, url): print('update IBMQ account now.') IBMQ.save_account(token, url, overwrite=True) IBMQ.load_account() IBMQ.enable_account(token, url) if self.outputTestLog: print('The actived account:') print(IBMQ.active_account())
def connect(kwargs): """Function that allows connection to IBMQ. Args: kwargs(dict): dictionary that contains the token and the url""" token = kwargs.get("ibmqx_token", None) or os.getenv("IBMQX_TOKEN") url = kwargs.get("ibmqx_url", None) or os.getenv("IBMQX_URL") # TODO: remove "no cover" when #173 is resolved if token is not None: # pragma: no cover # token was provided by the user, so attempt to enable an # IBM Q account manually def login(): ibmq_kwargs = {"url": url} if url is not None else {} IBMQ.enable_account(token, **ibmq_kwargs) active_account = IBMQ.active_account() if active_account is None: login() else: # There is already an active account: # If the token is the same, do nothing. # If the token is different, authenticate with the new account. if active_account["token"] != token: IBMQ.disable_account() login() else: # check if an IBM Q account is already active. # # * IBMQ v2 credentials stored in active_account(). # If no accounts are active, it returns None. if IBMQ.active_account() is None: # no active account try: # attempt to load a v2 account stored on disk IBMQ.load_account() except IBMQAccountError: # attempt to enable an account manually using # a provided token raise IBMQAccountError( "No active IBM Q account, and no IBM Q token provided." ) from None
def find_least_busy_backend_from_open(cls, n): if account_details.account_token_open is None: account_token = input("Insert your account token: ") else: account_token = account_details.account_token_open if IBMQ.active_account() is None: IBMQ.enable_account(account_token) provider = IBMQ.get_provider(hub='ibm-q') return least_busy( provider.backends(filters=lambda x: x.configuration().n_qubits >= (n + 1) and not x.configuration( ).simulator and x.status().operational == True))
def __init__(self, wires, provider=None, backend="ibmq_qasm_simulator", shots=1024, **kwargs): token = os.getenv("IBMQX_TOKEN") or kwargs.get("ibmqx_token", None) url = os.getenv("IBMQX_URL") or kwargs.get("ibmqx_url", None) # Specify a single hub, group and project hub = kwargs.get("hub", "ibm-q") group = kwargs.get("group", "open") project = kwargs.get("project", "main") if token is not None: # token was provided by the user, so attempt to enable an # IBM Q account manually ibmq_kwargs = {"url": url} if url is not None else {} IBMQ.enable_account(token, **ibmq_kwargs) else: # check if an IBM Q account is already active. # # * IBMQ v2 credentials stored in active_account(). # If no accounts are active, it returns None. if IBMQ.active_account() is None: # no active account try: # attempt to load a v2 account stored on disk IBMQ.load_account() except IBMQAccountError: # attempt to enable an account manually using # a provided token raise IBMQAccountError( "No active IBM Q account, and no IBM Q token provided." ) from None # IBM Q account is now enabled # get a provider p = provider or IBMQ.get_provider( hub=hub, group=group, project=project) super().__init__(wires=wires, provider=p, backend=backend, shots=shots, **kwargs)
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 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 __init__(self, wires, provider=None, backend="ibmq_qasm_simulator", shots=1024, **kwargs): token = os.getenv("IBMQX_TOKEN") or kwargs.get("ibmqx_token", None) url = os.getenv("IBMQX_URL") or kwargs.get("ibmqx_url", None) if token is not None: # token was provided by the user, so attempt to enable an # IBM Q account manually ibmq_kwargs = {"url": url} if url is not None else {} IBMQ.enable_account(token, **ibmq_kwargs) else: # turn off deprecation warnings # TODO: remove IBM Q v1 API calls when fully deprecated with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=DeprecationWarning) # check if an IBM Q account is already active. # # * IBMQ v1 credentials stored in active_accounts(). # If no accounts are active, it returns [] # # * IBMQ v2 credentials stored in active_account(). # If no accounts are active, it returns None. if IBMQ.active_account() is None and not IBMQ.active_accounts(): # no active account try: # attempt to load a v1 account stored on disk IBMQ.load_accounts() except IBMQAccountError: try: # attempt to load a v2 account stored on disk IBMQ.load_account() except IBMQAccountError: # attempt to enable an account manually using # a provided token raise IBMQAccountError( "No active IBM Q account, and no IBM Q token provided." ) from None # IBM Q account is now enabled # get a provider p = provider or IBMQ.get_provider() super().__init__(wires=wires, provider=p, backend=backend, shots=shots, **kwargs)
def run_qasm(qasm, backend_to_run="qasm_simulator", api_token=None, shots=1024, memory=False): active_account = IBMQ.active_account() if api_token: if active_account is None: IBMQ.enable_account(api_token) elif active_account['token'] != api_token: IBMQ.enable_account(api_token) qc = QuantumCircuit.from_qasm_str(qasm) backend = Aer.get_backend(backend_to_run) job_sim = execute(qc, backend, shots=shots, memory=memory) sim_result = job_sim.result() if memory: return sim_result.get_memory(qc) else: return sim_result.get_counts(qc)
def run_shor(N): if N <= 64: #Arbitrarily set upper limit for local simulator print("Getting local simulator backend...") backend = Aer.get_backend('qasm_simulator') else: print("Getting provider...") if not IBMQ.active_account(): IBMQ.load_account() provider = IBMQ.get_provider() print("Getting IBM Q simulator backend...") backend = provider.get_backend('ibmq_qasm_simulator') print("Running Shor's algorithm for", str(N), "on", backend, "...") results = Shor(N=N).run(backend) print("\nResults:") if results['factors'] == []: print("No prime factors: ", str(N), "=", str(N)) elif isinstance(results['factors'][0], int): print("Prime factors: ", str(N), "=", results['factors'][0], "^ 2") else: print("Prime factors: ", str(N), "=", results['factors'][0][0], "*", results['factors'][0][1])
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created Nov 2020 @author: hassi """ print("Ch 7: IBM Q simulators and how they are used") print("--------------------------------------------") # Import Qiskit and load account from qiskit import Aer, IBMQ print("Getting provider...") if not IBMQ.active_account(): IBMQ.load_account() provider = IBMQ.get_provider() # Load backends backends = Aer.backends() print("\nAer backends:\n\n", backends) # Collect Aer simulators simulators = [] for sim in range(0, len(backends)): backend = Aer.get_backend(str(backends[sim])) simulators.append(backend.configuration()) # Add IBM Q simulator ibmq_simulator = provider.backends(simulator=True)
import qiskit from qiskit import IBMQ # Load account from disk: provider = IBMQ.load_account() # list the account currently in the session print(IBMQ.active_account()) # list all available providers print(IBMQ.providers()) print(provider.backends())
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