def __init__(self,
backend_address=os.environ.get('DWAVE_SERVER_ADDRESS'),
*args,
**kwargs):
super(DWaveBackend, self).__init__()
self._backend_address = backend_address
self._solvers = {
solver_class.name(): solver_class
for solver_class in [QuboSolver]
}
self._client = Client(endpoint=backend_address, *args, **kwargs)
def __init__(self, solver=None, connection_close=True, **config):
# always use the base class (QPU client filters-out the hybrid solvers)
config['client'] = 'base'
if solver is None:
solver = {}
if isinstance(solver, abc.Mapping):
if solver.setdefault('category', 'hybrid') != 'hybrid':
raise ValueError(
"the only 'category' this sampler supports is 'hybrid'")
if solver.setdefault('supported_problem_types__contains',
'bqm') != 'bqm':
raise ValueError(
"the only problem type this sampler supports is 'bqm'")
self.client = Client.from_config(solver=solver,
connection_close=connection_close,
**config)
self.solver = self.client.get_solver()
# For explicitly named solvers:
if self.properties.get('category') != 'hybrid':
raise ValueError("selected solver is not a hybrid solver.")
if 'bqm' not in self.solver.supported_problem_types:
raise ValueError(
"selected solver does not support the 'bqm' problem type.")
def _config_create(config_file, profile, ask_full=False):
"""Full/simplified dwave create flows."""
if ask_full:
rs = Client._fetch_available_regions(DEFAULT_METADATA_API_ENDPOINT)
prompts = dict(
region=dict(prompt="Solver API region", choices=[r.code for r in rs]),
endpoint=dict(prompt="Solver API endpoint URL (overwrites 'region')"),
token=dict(prompt="Authentication token"),
client=dict(prompt="Client class", choices='base qpu sw hybrid'.split()),
solver=dict(prompt="Solver"))
else:
prompts = dict(
token=dict(prompt="Authentication token"))
click.echo("Using the simplified configuration flow.\n"
"Try 'dwave config create --full' for more options.\n")
# resolve config file path
ask_to_confirm_config_path = not config_file
if not config_file:
config_file = get_configfile_path()
if not config_file:
config_file = get_default_configfile_path()
config_file_exists = os.path.exists(config_file)
verb = "Updating existing" if config_file_exists else "Creating new"
click.echo(f"{verb} configuration file: {config_file}")
if ask_full and ask_to_confirm_config_path:
config_file = default_text_input("Confirm configuration file path", config_file)
config_file = os.path.expanduser(config_file)
config = _load_config(config_file)
default_section = config.default_section
# resolve profile
if not profile:
existing = config.sections()
if default_section in config: # not included in sections
existing.insert(0, default_section)
if config_file_exists:
click.echo(f"Available profiles: {', '.join(existing)}")
default_profile = next(iter(existing))
_note = " (select existing or create new)" if config_file_exists else ""
profile = default_text_input(f"Profile{_note}", default_profile)
verb = "Updating existing" if profile in config else "Creating new"
click.echo(f"{verb} profile: {profile}")
if profile != default_section and not config.has_section(profile):
config.add_section(profile)
_input_config_variables(config, profile, prompts)
_write_config(config, config_file)
click.echo("Configuration saved.")
def __init__(self, **config):
# strongly prefer hybrid solvers; requires kwarg-level override
config.setdefault('client', 'hybrid')
# default to short-lived session to prevent resets on slow uploads
config.setdefault('connection_close', True)
if FeatureFlags.hss_solver_config_override:
# use legacy behavior (override solver config from env/file)
solver = config.setdefault('solver', {})
if isinstance(solver, abc.Mapping):
solver.update(self.default_solver)
# prefer the latest hybrid CQM solver available, but allow for an easy
# override on any config level above the defaults (file/env/kwarg)
defaults = config.setdefault('defaults', {})
if not isinstance(defaults, abc.Mapping):
raise TypeError("mapping expected for 'defaults'")
defaults.update(solver=self.default_solver)
self.client = Client.from_config(**config)
self.solver = self.client.get_solver()
# For explicitly named solvers:
if self.properties.get('category') != 'hybrid':
raise ValueError("selected solver is not a hybrid solver.")
if 'cqm' not in self.solver.supported_problem_types:
raise ValueError(
"selected solver does not support the 'cqm' problem type.")
def dw(self):
try:
from dwave.cloud import Client
except ImportError:
raise ImportError(
"dw() requires dwave-cloud-client. Please install before call this function."
)
solver = Client.from_config(endpoint=self.dwaveendpoint,
token=self.dwavetoken,
solver=self.dwavesolver).get_solver()
if self.qubo != []:
self.qi()
# for hi
harr = np.diag(self.J)
larr = []
for i in solver.nodes:
if i < len(harr):
larr.append(harr[i])
linear = {index: larr[index] for index in range(len(larr))}
# for jij
qarr = []
qarrv = []
for i in solver.undirected_edges:
if i[0] < len(harr) and i[1] < len(harr):
qarr.append(i)
qarrv.append(self.J[i[0]][i[1]])
quad = {key: j for key, j in zip(qarr, qarrv)}
computation = solver.sample_ising(linear, quad, num_reads=1)
return computation.samples[0][:len(harr)]
def solve_ising_dwave(hii, Jij):
config_file = '/media/sf_QWorld/QWorld/QA_DeNovoAsb/dwcloud.conf'
client = Client.from_config(config_file, profile='aritra')
solver = client.get_solver(
) # Available QPUs: DW_2000Q_2_1 (2038 qubits), DW_2000Q_5 (2030 qubits)
dwsampler = DWaveSampler(config_file=config_file)
edgelist = solver.edges
adjdict = edgelist_to_adjacency(edgelist)
embed = minorminer.find_embedding(Jij.keys(), edgelist)
[h_qpu, j_qpu] = embed_ising(hii, Jij, embed, adjdict)
response_qpt = dwsampler.sample_ising(h_qpu,
j_qpu,
num_reads=solver.max_num_reads())
client.close()
bqm = dimod.BinaryQuadraticModel.from_ising(hii, Jij)
unembedded = unembed_sampleset(response_qpt,
embed,
bqm,
chain_break_method=majority_vote)
print("Maximum Sampled Configurations from D-Wave\t===>")
solnsMaxSample = sorted(unembedded.record, key=lambda x: -x[2])
for i in range(0, 10):
print(solnsMaxSample[i])
print("Minimum Energy Configurations from D-Wave\t===>")
solnsMinEnergy = sorted(unembedded.record, key=lambda x: +x[1])
for i in range(0, 10):
print(solnsMinEnergy[i])
def solve_qubo_dwave(Q, num_reads=1000):
# Create the solver (connecting to D-Wave) and the Sampler
config_file = '../dwave.conf'
client = Client.from_config(config_file, profile='ocete')
solver = client.get_solver(
) # Available QPUs: DW_2000Q_2_1 (2038 qubits), DW_2000Q_5 (2030 qubits)
dwsampler = DWaveSampler(config_file=config_file)
# We need to embed Q into a valid graph for the D-Wave architecture
edgelist = solver.edges
adjdict = edgelist_to_adjacency(edgelist)
embed = minorminer.find_embedding(Q, edgelist)
Q_embeded = embed_qubo(Q, embed, adjdict)
# Obtain the response from the solver. This is the actual D-Wave execution!
start = time.time()
response_qpt = dwsampler.sample_qubo(Q_embeded, num_reads=num_reads)
qpu_time = time.time() - start
client.close()
# Transform the response from the embeded graph to our original architecture
bqm = dimod.BinaryQuadraticModel.from_qubo(Q)
unembedded = unembed_sampleset(response_qpt,
embed,
bqm,
chain_break_method=majority_vote)
# Order the solutions by lower energy
return unembedded, qpu_time
def solvers(config_file, profile, solver_id, list_solvers):
"""Get solver details.
Unless solver name/id specified, fetch and display details for
all solvers available on configured endpoint.
"""
with Client.from_config(config_file=config_file, profile=profile) as client:
solvers = client.get_solvers().values()
if solver_id:
solvers = filter(lambda s: s.id == solver_id, solvers)
if not solvers:
click.echo("Solver {} not found.".format(solver_id))
return 1
if list_solvers:
for solver in solvers:
click.echo(solver.id)
return
# ~YAML output
for solver in solvers:
click.echo("Solver: {}".format(solver.id))
click.echo(" Parameters:")
for param, desc in sorted(solver.parameters.items()):
click.echo(" {}: {}".format(param, strtrunc(desc) if desc else '?'))
solver.properties.pop('parameters', None)
click.echo(" Properties:")
for k,v in sorted(solver.properties.items()):
click.echo(" {}: {}".format(k, strtrunc(v)))
click.echo()
def solvers(config_file, profile, solver_def, list_solvers):
"""Get solver details.
Unless solver name/id specified, fetch and display details for
all solvers available on configured endpoint.
"""
with Client.from_config(config_file=config_file,
profile=profile,
solver=solver_def) as client:
try:
solvers = client.get_solvers(**client.default_solver)
except SolverNotFoundError:
click.echo("Solver(s) {} not found.".format(solver_def))
return 1
if list_solvers:
for solver in solvers:
click.echo(solver.id)
return
# ~YAML output
for solver in solvers:
click.echo("Solver: {}".format(solver.id))
click.echo(" Parameters:")
for param, desc in sorted(solver.parameters.items()):
click.echo(" {}: {}".format(
param,
strtrunc(desc) if desc else '?'))
solver.properties.pop('parameters', None)
click.echo(" Properties:")
for k, v in sorted(solver.properties.items()):
click.echo(" {}: {}".format(k, strtrunc(v)))
click.echo()
def get_sampler_from_config(self, profile=None, solver=None, sampler_type=None):
"""Return a dimod.Sampler object found in the user's configuration file,
associated solver information, and any extra parameters needed."""
try:
with Client.from_config(profile=profile, client=sampler_type) as client:
if solver == None:
solver = client.default_solver
solver_name = solver["name__eq"]
else:
solver_name = solver
solver = {"name": solver}
if isinstance(client, hybrid.Client):
sampler = LeapHybridSampler(profile=profile, solver=solver)
elif isinstance(client, sw.Client):
self.qmasm.abend("QMASM does not currently support remote software solvers")
else:
sampler = DWaveSampler(profile=profile, solver=solver)
info = self._recursive_properties(sampler)
info["solver_name"] = solver_name
info["endpoint"] = client.endpoint
if profile != None:
info["profile"] = profile
return sampler, info, {}
except Exception as err:
self.qmasm.abend("Failed to construct a sampler (%s)" % str(err))
def default_solver():
with Client.from_config() as client:
try:
my_default_solver = client.get_solver(qpu=True).id
ds = "Solver: " + my_default_solver
print(ds)
except SolverNotFoundError:
my_default_solver = " "
print_markdown(
"<span style='color:red;font-weight:bold'>No D-Wave solver found.</span>"
)
print(
"Please check available solvers on the <span style='font-weight:bold'>Leap dashboard</span>."
)
my_default_token = os.getenv('DWAVE_API_TOKEN')
if not my_default_token or my_default_token == "None":
print_markdown(
"<span style='color:red;font-weight:bold'>No default API token.</span>"
)
print("An API token is not set for this environment.")
print_markdown(
"You can find your API token on the <span style='font-weight:bold'>Leap dashboard</span>."
)
print(
"Please uncomment the \"sampler =\" line in the next cell and paste your token there."
)
else:
dt = "API Token: " + my_default_token[:10] + "***" + my_default_token[
-5:]
print(dt)
return (my_default_solver, my_default_token)
def __init__(self,
config_file=None,
profile=None,
endpoint=None,
token=None,
solver=None,
solver_features=None,
proxy=None,
permissive_ssl=False):
self.client = Client.from_config(config_file=config_file,
profile=profile,
endpoint=endpoint,
token=token,
proxy=proxy,
permissive_ssl=permissive_ssl)
if solver_features is None:
# default to getting a QPU rather than a software solver
solver_features = {'qpu': True}
# TODO: deprecate `solver`` name in favor of name regex in `solver_features`
self.solver = self.client.get_solver(name=solver,
features=solver_features)
# need to set up the nodelist and edgelist, properties, parameters
self._nodelist = sorted(self.solver.nodes)
self._edgelist = sorted(
set(tuple(sorted(edge)) for edge in self.solver.edges))
self._properties = self.solver.properties.copy() # shallow copy
self._parameters = {
param: ['parameters']
for param in self.solver.properties['parameters']
}
def __init__(self,
failover=False,
retry_interval=-1,
order_by=None,
**config):
if config.get('solver_features') is not None:
warn("'solver_features' argument has been renamed to 'solver'.",
DeprecationWarning)
if config.get('solver') is not None:
raise ValueError(
"can not combine 'solver' and 'solver_features'")
config['solver'] = config.pop('solver_features')
self.client = Client.from_config(**config)
if order_by is None:
# use the default from the cloud-client
self.solver = self.client.get_solver()
else:
self.solver = self.client.get_solver(order_by=order_by)
self.failover = failover
self.retry_interval = retry_interval
def _get_sampler(self, profile, solver):
"Return a dimod.Sampler object."
# Handle built-in software samplers as special cases.
info = {}
if solver != None:
info["solver_name"] = solver
if solver == "exact":
return ExactSolver(), info
elif solver == "neal":
return SimulatedAnnealingSampler(), info
elif solver == "tabu":
return TabuSampler(), info
# In the common case, read the configuration file, either the
# default or the one named by the DWAVE_CONFIG_FILE environment
# variable.
if profile != None:
info["profile"] = profile
try:
with Client.from_config(profile=profile) as client:
if solver == None:
solver = client.default_solver
else:
solver = {"name": solver}
sampler = DWaveSampler(profile=profile, solver=solver)
info = {
"solver_name": sampler.solver.name,
"endpoint": client.endpoint
}
return sampler, info
except Exception as err:
self.qmasm.abend("Failed to construct a sampler (%s)" % str(err))
def __init__(self, solver=None, connection_close=True, **config):
# we want a Hybrid solver by default, but allow override
config.setdefault('client', 'hybrid')
if solver is None:
solver = {}
if isinstance(solver, abc.Mapping):
# TODO: instead of solver selection, try with user's default first
if solver.setdefault('category', 'hybrid') != 'hybrid':
raise ValueError(
"the only 'category' this sampler supports is 'hybrid'")
if solver.setdefault('supported_problem_types__contains',
'bqm') != 'bqm':
raise ValueError(
"the only problem type this sampler supports is 'bqm'")
# prefer the latest version, but allow kwarg override
solver.setdefault('order_by', '-version')
self.client = Client.from_config(solver=solver,
connection_close=connection_close,
**config)
self.solver = self.client.get_solver()
# For explicitly named solvers:
if self.properties.get('category') != 'hybrid':
raise ValueError("selected solver is not a hybrid solver.")
if 'bqm' not in self.solver.supported_problem_types:
raise ValueError(
"selected solver does not support the 'bqm' problem type.")
def getHardwareAdjacency(solver_name="DW_2000Q_VFYC_6"):
"""
:param solver_name: The D'Wave Annealer to be used
:return: A graph with the Chimera structure of the D'Wave Annealer
"""
with Client.from_config() as client:
solver = client.get_solver(solver_name)
return (solver.nodes, solver.undirected_edges)
def qpu_available():
"""Check whether QPU solver is available"""
try:
with Client.from_config() as client:
solver = client.get_solver(qpu=True)
except (ConfigFileError, ValueError) as e:
return False
else:
return True
def hybrid_solver_available():
"""Check whether hybrid solver is available"""
try:
with Client.from_config() as client:
solver = client.get_solver(hybrid=True)
except (ConfigFileError, ValueError, SolverNotFoundError) as e:
return False
else:
return True
def _get_client_solver(config, output=None):
"""Helper function to return an instantiated client, and solver, validating
parameters in the process, while wrapping errors in `CLIError` and using
`output` writer as a centralized printer.
"""
if output is None:
output = click.echo
# get client
try:
client = Client.from_config(**config)
except Exception as e:
raise CLIError("Invalid configuration: {}".format(e), code=1)
config_file = config.get('config_file')
if config_file:
output("Using configuration file: {config_file}", config_file=config_file)
profile = config.get('profile')
if profile:
output("Using profile: {profile}", profile=profile)
output("Using endpoint: {endpoint}", endpoint=client.endpoint)
output("Using region: {region}", region=client.region)
# get solver
try:
solver = client.get_solver()
except SolverAuthenticationError:
raise CLIError("Authentication error. Check credentials in your configuration file.", 2)
except SolverNotFoundError:
raise CLIError("Solver not available.", 6)
except (InvalidAPIResponseError, UnsupportedSolverError):
raise CLIError("Invalid or unexpected API response.", 3)
except RequestTimeout:
raise CLIError("API connection timed out.", 4)
except requests.exceptions.SSLError as e:
# we need to handle `ssl.SSLError` wrapped in several exceptions,
# with differences between py2/3; greping the message is the easiest way
if 'CERTIFICATE_VERIFY_FAILED' in str(e):
raise CLIError(
"Certificate verification failed. Please check that your API endpoint "
"is correct. If you are connecting to a private or third-party D-Wave "
"system that uses self-signed certificate(s), please see "
"https://support.dwavesys.com/hc/en-us/community/posts/360018930954.", 5)
raise CLIError("Unexpected SSL error while fetching solver: {!r}".format(e), 5)
except Exception as e:
raise CLIError("Unexpected error while fetching solver: {!r}".format(e), 5)
output("Using solver: {solver_id}", solver_id=solver.id)
return (client, solver)
def ping(config_file, profile):
"""Ping the QPU by submitting a single-qubit problem."""
try:
client = Client.from_config(config_file=config_file, profile=profile)
except Exception as e:
click.echo("Invalid config: {}".format(e))
return 1
if config_file:
click.echo("Using config file: {}".format(config_file))
if profile:
click.echo("Using profile: {}".format(profile))
click.echo("Using endpoint: {}".format(client.endpoint))
t0 = timer()
try:
solvers = client.get_solvers()
except SolverAuthenticationError:
click.echo(
"Authentication error. Check credentials in your config file.")
return 1
except (InvalidAPIResponseError, UnsupportedSolverError):
click.echo("Invalid or unexpected API response.")
return 2
try:
solver = client.get_solver()
except (ValueError, KeyError):
# if not otherwise defined (ValueError), or unavailable (KeyError),
# just use the first solver
if solvers:
_, solver = next(iter(solvers.items()))
else:
click.echo("No solvers available.")
return 1
t1 = timer()
click.echo("Using solver: {}".format(solver.id))
timing = solver.sample_ising({0: 1}, {}).timing
t2 = timer()
click.echo("\nWall clock time:")
click.echo(" * Solver definition fetch web request: {:.3f} ms".format(
(t1 - t0) * 1000.0))
click.echo(" * Problem submit and results fetch: {:.3f} ms".format(
(t2 - t1) * 1000.0))
click.echo(" * Total: {:.3f} ms".format((t2 - t0) * 1000.0))
click.echo("\nQPU timing:")
for component, duration in timing.items():
click.echo(" * {} = {} us".format(component, duration))
return 0
def test_limits():
n_reads = 2
while True:
# Create the solver (connecting to D-Wave) and the Sampler
config_file='../dwave.conf'
client = Client.from_config(config_file, profile='ocete')
solver = client.get_solver('Advantage_system1.1') # Use Advantage to test Pegasus
try_embedding(n_reads, solver, print_embedding=False)
n_reads += 1
client.close()
def solveWithDwave(qubo, num_reads=100, solver_name="DW_2000Q_VFYC_6"):
"""
:param qubo: The qubo to be solved
:param num_reads: The amount of reads the D'Wave quantum annealer should do
:param solver_name: The D'Wave Annealer to be used
:return: num_reads Solutions of the Qubo
"""
with Client.from_config() as client:
solver = client.get_solver(solver_name)
computation = solver.sample_qubo(qubo, num_reads=num_reads)
result = computation.result()
return result
def solve_qubo_dwave(Q,
n_genome_reads,
num_reads=100,
label='',
annealing_time=20):
# Create the solver (connecting to D-Wave) and the Sampler
config_file = '../dwave_adv.conf'
client = Client.from_config(config_file, profile='ocete')
solver = client.get_solver('Advantage_system1.1')
dwsampler = DWaveSampler(
solver={
'qpu': True,
'topology__type': 'pegasus',
'annealing_time': annealing_time
}, # Watch out, Leap doesn seem to take into account
# this parameter, you have to give it as a paramater in the dwsampler.sample() call
token=token,
endpoint=endpoint)
# We need to embed Q into a valid graph for the D-Wave architecture
adjdict = edgelist_to_adjacency(solver.edges)
embed = minorminer.find_embedding(Q, solver.edges)
Q_embeded = embed_qubo(Q, embed, adjdict)
# Obtain the response from the solver. This is the actual D-Wave execution!
start = time.time()
response_qpt = dwsampler.sample_qubo(Q_embeded,
num_reads=num_reads,
label=label,
annealing_time=annealing_time)
qpu_time = time.time() - start
client.close()
# Transform the response from the embeded graph to our original architecture
bqm = dimod.BinaryQuadraticModel.from_qubo(Q)
unembedded = unembed_sampleset(response_qpt,
embed,
bqm,
chain_break_method=majority_vote)
# Sort the solutions from lowest energy and format them to quboDict format
unformated_solutions_list = sorted(unembedded.record, key=lambda x: +x[1])
solutions_list = []
for sol, energy, num_appereances in unformated_solutions_list:
solutions_list.append([
rebuild_quboDict_from_vector(sol, n_genome_reads), energy,
num_appereances
])
return solutions_list, qpu_time, get_max_chain_length(embed)
def upload(config_file, profile, endpoint, region, client_type, solver_def,
problem_id, format, input_file):
"""Multipart problem upload with cold restart support."""
try:
client = Client.from_config(
config_file=config_file, profile=profile,
endpoint=endpoint, region=region,
client=client_type)
except Exception as e:
click.echo("Invalid configuration: {}".format(e))
return 1
if config_file:
click.echo("Using configuration file: {}".format(config_file))
if profile:
click.echo("Using profile: {}".format(profile))
click.echo("Using endpoint: {}".format(client.endpoint))
click.echo(("Preparing to upload a problem from {!r} "
"in {!r} format.").format(input_file.name, format))
if format == 'coo':
click.echo("Transcoding 'coo' to 'dimodbqm'.")
try:
import dimod
except ImportError: # pragma: no cover
raise RuntimeError("Can't decode 'coo' format without dimod. "
"Re-install the library with 'bqm' support.")
# note: `BQM.from_coo` doesn't support files opened in binary (yet);
# fallback to reopen for now
with open(input_file.name, 'rt') as fp:
bqm = dimod.BinaryQuadraticModel.from_coo(fp)
problem_file = bqm_as_file(bqm)
elif format == 'dimodbqm':
problem_file = input_file
click.echo("Uploading...")
try:
future = client.upload_problem_encoded(
problem=problem_file, problem_id=problem_id)
remote_problem_id = future.result()
except Exception as e:
click.echo(e)
return 2
click.echo("Upload done. Problem ID: {!r}".format(remote_problem_id))
def __init__(self, failover=False, retry_interval=-1, **config):
# strongly prefer QPU solvers; requires kwarg-level override
config.setdefault('client', 'qpu')
# weakly prefer QPU solver with the highest qubit count,
# easily overridden on any config level above defaults (file/env/kwarg)
defaults = config.setdefault('defaults', {})
if not isinstance(defaults, abc.Mapping):
raise TypeError("mapping expected for 'defaults'")
defaults.update(solver=dict(order_by='-num_active_qubits'))
self.client = Client.from_config(**config)
self.solver = self.client.get_solver()
self.failover = failover
self.retry_interval = retry_interval
def __init__(self, **config):
if config.get('solver_features') is not None:
warn("'solver_features' argument has been renamed to 'solver'.", DeprecationWarning)
if config.get('solver') is not None:
raise ValueError("can not combine 'solver' and 'solver_features'")
config['solver'] = config.pop('solver_features')
self.client = Client.from_config(**config)
self.solver = self.client.get_solver()
# need to set up the properties, parameters
self._properties = self.solver.properties.copy() # shallow copy
self._parameters = {param: ['parameters'] for param in self.solver.properties['parameters']}
def get_ocean_qubo_re(traveling_cost_qubo, traveling_qubo, B, cities_size):
with Client.from_config() as client:
solver = client.get_solver()
p_qubo = traveling_qubo + traveling_cost_qubo * B
keys = []
for i in range(len(p_qubo[0])):
for j in range(len(p_qubo[1])):
keys.append((i, j))
Q = {key: val for key, val in zip(keys, p_qubo.reshape(-1))}
# sampler = neal.SimulatedAnnealingSampler()
# print(Q)
computation = solver.sample_qubo(Q,num_reads=10)
for sample in computation.samples:
result = sample
print(result)
return result
def solvers(config_file, profile, client_type, solver_def, list_solvers,
list_all):
"""Get solver details.
Solver filter is inherited from environment or the specified configuration
file and profile.
"""
if list_all:
client_type = 'base'
solver_def = '{}'
with Client.from_config(config_file=config_file,
profile=profile,
client=client_type,
solver=solver_def) as client:
try:
solvers = client.get_solvers(**client.default_solver)
except SolverNotFoundError:
click.echo("Solver(s) {} not found.".format(solver_def))
return 1
if list_solvers:
for solver in solvers:
click.echo(solver.id)
return
# ~YAML output
for solver in solvers:
click.echo("Solver: {}".format(solver.id))
click.echo(" Parameters:")
for name, val in sorted(solver.parameters.items()):
click.echo(" {}: {}".format(name,
strtrunc(val) if val else '?'))
solver.properties.pop('parameters', None)
click.echo(" Properties:")
for name, val in sorted(solver.properties.items()):
click.echo(" {}: {}".format(name, strtrunc(val)))
click.echo(" Derived properties:")
for name in sorted(solver.derived_properties):
click.echo(" {}: {}".format(name,
strtrunc(getattr(solver,
name))))
click.echo()
def __init__(self, solver=None, connection_close=True, **config):
if solver is None:
solver = {}
if isinstance(solver, abc.Mapping):
if solver.setdefault('category', 'hybrid') != 'hybrid':
raise ValueError(
"the only 'category' this sampler supports is 'hybrid'")
self.client = Client.from_config(solver=solver,
connection_close=connection_close,
**config)
self.solver = self.client.get_solver()
# For explicitly named solvers:
if ('category' not in self.properties.keys()) or (
not self.properties['category'] == 'hybrid'):
raise ValueError("selected solver is not a hybrid solver.")
def dwave(self):
from dwave.cloud import Client
solver = Client.from_config(endpoint=self.dwaveendpoint,
token=self.dwavetoken,
solver=self.dwavesolver).get_solver()
if self.qubo != []:
self.qi()
harr = [-1, 1, -1, 1, -1, 1]
larr = []
for i in solver.nodes:
if i < len(harr):
larr.append(harr[i])
linear = {index: larr[index] for index in range(len(larr))}
#quad = {key: np.random.choice([-1, 1]) for key in solver.undirected_edges}
quad = {}
computation = solver.sample_ising(linear, quad, num_reads=100)
return computation.samples[0]
