strangeworks_hybrid_optimize package¶
Submodules¶
strangeworks_hybrid_optimize.sdk module¶
- class HybridParams(Nf: int, Ns: int, Ng: int, problem_size: int, maxiter: int, shotsin: int, type_subsystem: str | None = None, theta0: List[float] | None = None, optimizer: str | None = None, ansatz: str | None = None, optimization_level: int | None = 1, resilience_level: int | None = 1)¶
Bases:
object
- class OptimizationParams(solver: dict, bqm: BinaryQuadraticModel | None = None, options: dict | None = None)¶
Bases:
object
- class QAOAParams(maxiter: int, shotsin: int, theta0: List[float] | None = None, p: int | None = None, alpha: float | None = None, optimizer: str | None = None, ansatz: str | None = None, ising: bool | None = None, warm_start: bool | None = None, problem_type: str | None = 'Classical', optimization_level: int | None = 1, resilience_level: int | None = 1)¶
Bases:
object
- class StrangeworksHybrid(resource_slug: str | None = ' ')¶
Bases:
object
Strangeworks client object.
- backends()¶
- get_job(sw_job)¶
- get_results(sw_job, calculate_exact_sol=False, display_results=False)¶
- job_list()¶
- run(backend, problem, hybrid_params, problem_params: QAOAParams | OptimizationParams, backend_sub: str | None = None)¶
Method to submit QAOA problem to backend.
- Parameters:
backend (str) – Backend name for the final QAOA optimization step. Must be a
device. (gate based)
problem – Hamiltonian whose ground state we want to find. Can be either a networkx graph, a qiskit PauliSumOp operator, a QUBO Matrix or a Dwave BinaryQuadraticModel.
hybrid_params (Dict) –
Dictionary of hybrid parameters for the problem: Nf (int): Size of final vqe Ns (int): Number of sub-systems: Upper bound = np.pow(2, Nf) Ng (int): Size of sub-systems problem_size (int): Number of qubits in the problem type_subsystem (str): Type of subsystems to use. Options are:
’random’, ‘weighted_random’, ‘kernighan_lin_bisection’
maxiter (int): max number of iteration loops in minimisation shotsin (int): number of shots. Number of times quantum circuit is
run and measured
problem_params (Dict) – Dictionary of sub problem parameters for the problem
job (or 2) the parameters for a StrangeworksOptimization)
job –
- StrangeworksQAOA job parameters:
shotsin (int): number of shots. Number of times quantum circuit is run and measured maxiter (int): max number of iteration loops in minimisation p (int): Optional. Number of repetitions in qaoa ansatz alpha (float): Optional. Parameter between 0 and 1, which controls the CVar expectation value,
alpha = 1, usual expectation value alpha < 1, modified expectation value for quantum simulation with classical outputs
theta0 (array): Optional, initial vector of parameters. optimizer (str): Optional, string specifying classical optimizer,
default=’COBLYA’.
- ansatz (str or QuantumCircuit): Optional, Variational circuit
parametrized with coefficients to optimise for the energy
- ising (bool): Optional, If True then the input problem is treated as
an Ising problem. If False or unspecified, then the input problem is treated as a QUBO problem.
- problem_type (str): Optional, If the problem is a quantum encoding
of a classical problem (i.e. the solution is one of the basis states) then we can make some simplifications and employ some tricks to make the algorithm potentially more optimal.
- optimization_level: IBM only. How much optimization to perform on
the circuits. Higher levels generate more optimized circuits, at the expense of longer transpilation times. This is based on the
optimization_level
parameter in qiskit-terra but may include backend-specific optimization. Default: 1.0: no optimization
1: light optimization
2: heavy optimization
3: even heavier optimization
- resilience_level: IBM only. How much resilience to build against
errors. Higher levels generate more accurate results, at the expense of longer processing times. Default: 1.
0: No mitigation.
1: Minimal mitigation costs. Mitigate error
associated with readout errors. * 2: Medium mitigation costs. Typically reduces bias in estimators but is not guaranteed to be zero bias. Only applies to estimator. * 3: Heavy mitigation with layer sampling. Theoretically expected to deliver zero bias estimators. Only applies to estimator.
- StrangeworksOptimization job parameters:
var_type (str): Variable type of the problem. Either ‘BINARY’ or lagrange_multiplier (float): Lagrange multiplier for the problem. solver (Dict): Dictionary of solver parameters:
- solver (str): Name of the solver to use. Must be one of the
available solvers for the backend.
solver_options (Dict): Dictionary of solver options.
- Returns:
Strangeworks Job object
- update_status(sw_job)¶
strangeworks_hybrid_optimize.utils module¶
- convert_QUBO_to_Ising(QUBO_mat)¶
- get_Ham_from_PauliSumOp(H_pauliSum)¶
- get_Ham_from_QUBO(QUBO_mat)¶
- get_Ham_from_graph(G)¶
- get_Ising(G)¶
- get_PauliSumOp(G)¶
- get_QUBO(G)¶
- get_QUBO_from_Ham(H, nodes)¶
- get_cost_bitstring(bitstring, problem, ising=False)¶
- get_energy(x, H, ising=False)¶
Get the energy of the quantum state
- Parameters:
x (str) – bitstring of ones and zeros
H (List) – Hamiltonian which we are to find the minimum value
- Returns:
energy of the state x.
- Return type:
En (float)
- get_exact_en(G, nodes, ising=False)¶
- get_graph(nodes, seedin)¶
Generate networkX graph where each node is connected to all other nodes. The weights of the connections are random and uniformly distributed between -1 to 1
- get_graph_from_Ham(H, nqubits)¶
- get_nReg_MaxCut_PauliSumOp(n, nodes, seedin)¶
Generate PauliSumOp where each node has n connections to a random slection of the other nodes. The weights of the connections are random and uniformly distributed between -1 to 1
- get_nReg_MaxCut_QUBO(n, nodes, seedin)¶
Generate QUBO matrix where each node has n connections to a random slection of the other nodes. The weights of the connections are random and uniformly distributed between -1 to 1
- get_nReg_MaxCut_graph(n, nodes, seedin)¶
Generate networkX graph where each node has n connections to a random slection of the other nodes. The weights of the connections are random and uniformly distributed between -1 to 1
- get_rand_PauliSumOp(nodes, seedin)¶
Generate random PauliSumOp The weights of the connections are random and uniformly distributed between -1 to 1
- get_rand_QUBO(nodes, seedin)¶
Generate random QUBO matrix The weights of the connections are random and uniformly distributed between -1 to 1
Module contents¶
Strangeworks QAOA SDK Extension.