INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Reformat some of the parameters for sapi. | def _format_params(self, type_, params):
"""Reformat some of the parameters for sapi."""
if 'initial_state' in params:
# NB: at this moment the error raised when initial_state does not match lin/quad (in
# active qubits) is not very informative, but there is also no clean way to ... |
Test if an Ising model matches the graph provided by the solver. | def check_problem(self, linear, quadratic):
"""Test if an Ising model matches the graph provided by the solver.
Args:
linear (list/dict): Linear terms of the model (h).
quadratic (dict of (int, int):float): Quadratic terms of the model (J).
Returns:
boolean
... |
Resume polling for a problem previously submitted. | def _retrieve_problem(self, id_):
"""Resume polling for a problem previously submitted.
Args:
id_: Identification of the query.
Returns:
:obj: `Future`
"""
future = Future(self, id_, self.return_matrix, None)
self.client._poll(future)
ret... |
Return the converter type for identifier. | def _get_converter_type(identifier):
"""Return the converter type for `identifier`."""
if isinstance(identifier, str):
return ConverterType[identifier]
if isinstance(identifier, ConverterType):
return identifier
return ConverterType(identifier) |
Resample the signal in input_data at once. | def resample(input_data, ratio, converter_type='sinc_best', verbose=False):
"""Resample the signal in `input_data` at once.
Parameters
----------
input_data : ndarray
Input data. A single channel is provided as a 1D array of `num_frames` length.
Input data with several channels is repre... |
Set a new conversion ratio immediately. | def set_ratio(self, new_ratio):
"""Set a new conversion ratio immediately."""
from samplerate.lowlevel import src_set_ratio
return src_set_ratio(self._state, new_ratio) |
Resample the signal in input_data. | def process(self, input_data, ratio, end_of_input=False, verbose=False):
"""Resample the signal in `input_data`.
Parameters
----------
input_data : ndarray
Input data. A single channel is provided as a 1D array of `num_frames` length.
Input data with several chan... |
Create new callback resampler. | def _create(self):
"""Create new callback resampler."""
from samplerate.lowlevel import ffi, src_callback_new, src_delete
from samplerate.exceptions import ResamplingError
state, handle, error = src_callback_new(
self._callback, self._converter_type.value, self._channels)
... |
Set the starting conversion ratio for the next read call. | def set_starting_ratio(self, ratio):
""" Set the starting conversion ratio for the next `read` call. """
from samplerate.lowlevel import src_set_ratio
if self._state is None:
self._create()
src_set_ratio(self._state, ratio)
self.ratio = ratio |
Reset state. | def reset(self):
"""Reset state."""
from samplerate.lowlevel import src_reset
if self._state is None:
self._create()
src_reset(self._state) |
Read a number of frames from the resampler. | def read(self, num_frames):
"""Read a number of frames from the resampler.
Parameters
----------
num_frames : int
Number of frames to read.
Returns
-------
output_data : ndarray
Resampled frames as a (`num_output_frames`, `num_channels`) ... |
Batch variance calculation. | def get_variance(seq):
"""
Batch variance calculation.
"""
m = get_mean(seq)
return sum((v-m)**2 for v in seq)/float(len(seq)) |
Batch mean absolute error calculation. | def mean_absolute_error(seq, correct):
"""
Batch mean absolute error calculation.
"""
assert len(seq) == len(correct)
diffs = [abs(a-b) for a, b in zip(seq, correct)]
return sum(diffs)/float(len(diffs)) |
Scales each number in the sequence so that the sum of all numbers equals 1. | def normalize(seq):
"""
Scales each number in the sequence so that the sum of all numbers equals 1.
"""
s = float(sum(seq))
return [v/s for v in seq] |
Describes the probability that a real - valued random variable X with a given probability distribution will be found at a value less than or equal to X in a normal distribution. http:// en. wikipedia. org/ wiki/ Cumulative_distribution_function | def normcdf(x, mu, sigma):
"""
Describes the probability that a real-valued random variable X with a given
probability distribution will be found at a value less than or equal to X
in a normal distribution.
http://en.wikipedia.org/wiki/Cumulative_distribution_function
"""
t = x-mu
y... |
Describes the relative likelihood that a real - valued random variable X will take on a given value. http:// en. wikipedia. org/ wiki/ Probability_density_function | def normpdf(x, mu, sigma):
"""
Describes the relative likelihood that a real-valued random variable X will
take on a given value.
http://en.wikipedia.org/wiki/Probability_density_function
"""
u = (x-mu)/abs(sigma)
y = (1/(math.sqrt(2*pi)*abs(sigma)))*math.exp(-u*u/2)
return y |
Calculates the entropy of the attribute attr in given data set data. Parameters: data<dict|list >: = if dict treated as value counts of the given attribute name if list treated as a raw list from which the value counts will be generated attr<string >: = the name of the class attribute | def entropy(data, class_attr=None, method=DEFAULT_DISCRETE_METRIC):
"""
Calculates the entropy of the attribute attr in given data set data.
Parameters:
data<dict|list> :=
if dict, treated as value counts of the given attribute name
if list, treated as a raw list from which the valu... |
Calculates the variance fo a continuous class attribute to be used as an entropy metric. | def entropy_variance(data, class_attr=None,
method=DEFAULT_CONTINUOUS_METRIC):
"""
Calculates the variance fo a continuous class attribute, to be used as an
entropy metric.
"""
assert method in CONTINUOUS_METRICS, "Unknown entropy variance metric: %s" % (method,)
assert (class_attr is None a... |
Calculates the information gain ( reduction in entropy ) that would result by splitting the data on the chosen attribute ( attr ). Parameters: prefer_fewer_values: = Weights the gain by the count of the attribute s unique values. If multiple attributes have the same gain but one has slightly fewer attributes this will ... | def get_gain(data, attr, class_attr,
method=DEFAULT_DISCRETE_METRIC,
only_sub=0, prefer_fewer_values=False, entropy_func=None):
"""
Calculates the information gain (reduction in entropy) that would
result by splitting the data on the chosen attribute (attr).
Parameters:
prefer_fewe... |
Creates a list of all values in the target attribute for each record in the data list object and returns the value that appears in this list the most frequently. | def majority_value(data, class_attr):
"""
Creates a list of all values in the target attribute for each record
in the data list object, and returns the value that appears in this list
the most frequently.
"""
if is_continuous(data[0][class_attr]):
return CDist(seq=[record[class_attr] for... |
Returns the item that appears most frequently in the given list. | def most_frequent(lst):
"""
Returns the item that appears most frequently in the given list.
"""
lst = lst[:]
highest_freq = 0
most_freq = None
for val in unique(lst):
if lst.count(val) > highest_freq:
most_freq = val
highest_freq = lst.count(val)
... |
Returns a list made up of the unique values found in lst. i. e. it removes the redundant values in lst. | def unique(lst):
"""
Returns a list made up of the unique values found in lst. i.e., it
removes the redundant values in lst.
"""
lst = lst[:]
unique_lst = []
# Cycle through the list and add each value to the unique list only once.
for item in lst:
if unique_lst.count(item) <= ... |
Cycles through all the attributes and returns the attribute with the highest information gain ( or lowest entropy ). | def choose_attribute(data, attributes, class_attr, fitness, method):
"""
Cycles through all the attributes and returns the attribute with the
highest information gain (or lowest entropy).
"""
best = (-1e999999, None)
for attr in attributes:
if attr == class_attr:
continue
... |
Returns a new decision tree based on the examples given. | def create_decision_tree(data, attributes, class_attr, fitness_func, wrapper, **kwargs):
"""
Returns a new decision tree based on the examples given.
"""
split_attr = kwargs.get('split_attr', None)
split_val = kwargs.get('split_val', None)
assert class_attr not in attributes
node =... |
Increments the count for the given element. | def add(self, k, count=1):
"""
Increments the count for the given element.
"""
self.counts[k] += count
self.total += count |
Returns the element with the highest probability. | def best(self):
"""
Returns the element with the highest probability.
"""
b = (-1e999999, None)
for k, c in iteritems(self.counts):
b = max(b, (c, k))
return b[1] |
Returns a list of probabilities for all elements in the form [ ( value1 prob1 ) ( value2 prob2 )... ]. | def probs(self):
"""
Returns a list of probabilities for all elements in the form
[(value1,prob1),(value2,prob2),...].
"""
return [
(k, self.counts[k]/float(self.total))
for k in iterkeys(self.counts)
] |
Adds the given distribution s counts to the current distribution. | def update(self, dist):
"""
Adds the given distribution's counts to the current distribution.
"""
assert isinstance(dist, DDist)
for k, c in iteritems(dist.counts):
self.counts[k] += c
self.total += dist.total |
Returns the probability of a random variable being less than the given value. | def probability_lt(self, x):
"""
Returns the probability of a random variable being less than the
given value.
"""
if self.mean is None:
return
return normdist(x=x, mu=self.mean, sigma=self.standard_deviation) |
Returns the probability of a random variable falling between the given values. | def probability_in(self, a, b):
"""
Returns the probability of a random variable falling between the given
values.
"""
if self.mean is None:
return
p1 = normdist(x=a, mu=self.mean, sigma=self.standard_deviation)
p2 = normdist(x=b, mu=self.mean, sigma=s... |
Returns the probability of a random variable being greater than the given value. | def probability_gt(self, x):
"""
Returns the probability of a random variable being greater than the
given value.
"""
if self.mean is None:
return
p = normdist(x=x, mu=self.mean, sigma=self.standard_deviation)
return 1-p |
Returns a copy of the object without any data. | def copy_no_data(self):
"""
Returns a copy of the object without any data.
"""
return type(self)(
[],
order=list(self.header_modes),
types=self.header_types.copy(),
modes=self.header_modes.copy()) |
Returns true if the given value matches the type for the given name according to the schema. Returns false otherwise. | def is_valid(self, name, value):
"""
Returns true if the given value matches the type for the given name
according to the schema.
Returns false otherwise.
"""
if name not in self.header_types:
return False
t = self.header_types[name]
if t == AT... |
When a CSV file is given extracts header information the file. Otherwise this header data must be explicitly given when the object is instantiated. | def _read_header(self):
"""
When a CSV file is given, extracts header information the file.
Otherwise, this header data must be explicitly given when the object
is instantiated.
"""
if not self.filename or self.header_types:
return
rows = csv.reader(op... |
Ensure each element in the row matches the schema. | def validate_row(self, row):
"""
Ensure each element in the row matches the schema.
"""
clean_row = {}
if isinstance(row, (tuple, list)):
assert self.header_order, "No attribute order specified."
assert len(row) == len(self.header_order), \
... |
Returns two Data instances containing the data randomly split between the two according to the given ratio. The first instance will contain the ratio of data specified. The second instance will contain the remaining ratio of data. If leave_one_out is True the ratio will be ignored and the first instance will contain ex... | def split(self, ratio=0.5, leave_one_out=False):
"""
Returns two Data instances, containing the data randomly split between
the two according to the given ratio.
The first instance will contain the ratio of data specified.
The second instance will contain the remaining r... |
Gets the closest value for the current node s attribute matching the given record. | def _get_attribute_value_for_node(self, record):
"""
Gets the closest value for the current node's attribute matching the
given record.
"""
# Abort if this node has not get split on an attribute.
if self.attr_name is None:
return
# O... |
Retrieves the unique set of values seen for the given attribute at this node. | def get_values(self, attr_name):
"""
Retrieves the unique set of values seen for the given attribute
at this node.
"""
ret = list(self._attr_value_cdist[attr_name].keys()) \
+ list(self._attr_value_counts[attr_name].keys()) \
+ list(self._branches.keys())
... |
Returns the name of the attribute with the highest gain. | def get_best_splitting_attr(self):
"""
Returns the name of the attribute with the highest gain.
"""
best = (-1e999999, None)
for attr in self.attributes:
best = max(best, (self.get_gain(attr), attr))
best_gain, best_attr = best
return best_attr |
Calculates the entropy of a specific attribute/ value combination. | def get_entropy(self, attr_name=None, attr_value=None):
"""
Calculates the entropy of a specific attribute/value combination.
"""
is_con = self.tree.data.is_continuous_class
if is_con:
if attr_name is None:
# Calculate variance of class attribute.
... |
Calculates the information gain from splitting on the given attribute. | def get_gain(self, attr_name):
"""
Calculates the information gain from splitting on the given attribute.
"""
subset_entropy = 0.0
for value in iterkeys(self._attr_value_counts[attr_name]):
value_prob = self.get_value_prob(attr_name, value)
e = self.get_en... |
Returns the class value probability distribution of the given attribute value. | def get_value_ddist(self, attr_name, attr_value):
"""
Returns the class value probability distribution of the given
attribute value.
"""
assert not self.tree.data.is_continuous_class, \
"Discrete distributions are only maintained for " + \
"discrete class ... |
Returns the value probability of the given attribute at this node. | def get_value_prob(self, attr_name, value):
"""
Returns the value probability of the given attribute at this node.
"""
if attr_name not in self._attr_value_count_totals:
return
n = self._attr_value_counts[attr_name][value]
d = self._attr_value_count_totals[att... |
Returns the estimated value of the class attribute for the given record. | def predict(self, record, depth=0):
"""
Returns the estimated value of the class attribute for the given
record.
"""
# Check if we're ready to predict.
if not self.ready_to_predict:
raise NodeNotReadyToPredict
# Lookup attribute value... |
Returns true if this node is ready to branch off additional nodes. Returns false otherwise. | def ready_to_split(self):
"""
Returns true if this node is ready to branch off additional nodes.
Returns false otherwise.
"""
# Never split if we're a leaf that predicts adequately.
threshold = self._tree.leaf_threshold
if self._tree.data.is_continuous_class:
... |
Sets the probability distribution at a leaf node. | def set_leaf_dist(self, attr_value, dist):
"""
Sets the probability distribution at a leaf node.
"""
assert self.attr_name
assert self.tree.data.is_valid(self.attr_name, attr_value), \
"Value %s is invalid for attribute %s." \
% (attr_value, self.attr_... |
Incrementally update the statistics at this node. | def train(self, record):
"""
Incrementally update the statistics at this node.
"""
self.n += 1
class_attr = self.tree.data.class_attribute_name
class_value = record[class_attr]
# Update class statistics.
is_con = self.tree.data.is_continuous_class... |
Constructs a classification or regression tree in a single batch by analyzing the given data. | def build(cls, data, *args, **kwargs):
"""
Constructs a classification or regression tree in a single batch by
analyzing the given data.
"""
assert isinstance(data, Data)
if data.is_continuous_class:
fitness_func = gain_variance
else:
fitne... |
Returns the mean absolute error for predictions on the out - of - bag samples. | def out_of_bag_mae(self):
"""
Returns the mean absolute error for predictions on the out-of-bag
samples.
"""
if not self._out_of_bag_mae_clean:
try:
self._out_of_bag_mae = self.test(self.out_of_bag_samples)
self._out_of_bag_mae_clean = ... |
Returns the out - of - bag samples list inside a wrapper to keep track of modifications. | def out_of_bag_samples(self):
"""
Returns the out-of-bag samples list, inside a wrapper to keep track
of modifications.
"""
#TODO:replace with more a generic pass-through wrapper?
class O(object):
def __init__(self, tree):
self.tree = tree
... |
Sets the behavior for one or all attributes to use when traversing the tree using a query vector and it encounters a branch that does not exist. | def set_missing_value_policy(self, policy, target_attr_name=None):
"""
Sets the behavior for one or all attributes to use when traversing the
tree using a query vector and it encounters a branch that does not
exist.
"""
assert policy in MISSING_VALUE_POLICIES, \
... |
Incrementally updates the tree with the given sample record. | def train(self, record):
"""
Incrementally updates the tree with the given sample record.
"""
assert self.data.class_attribute_name in record, \
"The class attribute must be present in the record."
record = record.copy()
self.sample_count += 1
self.tre... |
Removes trees from the forest according to the specified fell method. | def _fell_trees(self):
"""
Removes trees from the forest according to the specified fell method.
"""
if callable(self.fell_method):
for tree in self.fell_method(list(self.trees)):
self.trees.remove(tree) |
Gets the prediction from the tree with the lowest mean absolute error. | def _get_best_prediction(self, record, train=True):
"""
Gets the prediction from the tree with the lowest mean absolute error.
"""
if not self.trees:
return
best = (+1e999999, None)
for tree in self.trees:
best = min(best, (tree.mae.mean, tree))
... |
Returns weights so that the tree with smallest out - of - bag mean absolute error | def best_oob_mae_weight(trees):
"""
Returns weights so that the tree with smallest out-of-bag mean absolute error
"""
best = (+1e999999, None)
for tree in trees:
oob_mae = tree.out_of_bag_mae
if oob_mae is None or oob_mae.mean is None:
cont... |
Returns weights proportional to the out - of - bag mean absolute error for each tree. | def mean_oob_mae_weight(trees):
"""
Returns weights proportional to the out-of-bag mean absolute error for each tree.
"""
weights = []
active_trees = []
for tree in trees:
oob_mae = tree.out_of_bag_mae
if oob_mae is None or oob_mae.mean is None:
... |
Adds new trees to the forest according to the specified growth method. | def _grow_trees(self):
"""
Adds new trees to the forest according to the specified growth method.
"""
if self.grow_method == GROW_AUTO_INCREMENTAL:
self.tree_kwargs['auto_grow'] = True
while len(self.trees) < self.size:
self.trees.append(Tree(data... |
Attempts to predict the value of the class attribute by aggregating the predictions of each tree. Parameters: weighting_formula: = a callable that takes a list of trees and returns a list of weights. | def predict(self, record):
"""
Attempts to predict the value of the class attribute by aggregating
the predictions of each tree.
Parameters:
weighting_formula := a callable that takes a list of trees and
returns a list of weights.
"""
... |
Updates the trees with the given training record. | def train(self, record):
"""
Updates the trees with the given training record.
"""
self._fell_trees()
self._grow_trees()
for tree in self.trees:
if random.random() < self.sample_ratio:
tree.train(record)
else:
tree.o... |
Return a list of local configuration file paths. | def get_configfile_paths(system=True, user=True, local=True, only_existing=True):
"""Return a list of local configuration file paths.
Search paths for configuration files on the local system
are based on homebase_ and depend on operating system; for example, for Linux systems
these might include ``dwav... |
Return the default configuration - file path. | def get_default_configfile_path():
"""Return the default configuration-file path.
Typically returns a user-local configuration file; e.g:
``~/.config/dwave/dwave.conf``.
Returns:
str:
Configuration file path.
Examples:
This example displays the default configuration fi... |
Load D - Wave Cloud Client configuration from a list of files. | def load_config_from_files(filenames=None):
"""Load D-Wave Cloud Client configuration from a list of files.
.. note:: This method is not standardly used to set up D-Wave Cloud Client configuration.
It is recommended you use :meth:`.Client.from_config` or
:meth:`.config.load_config` instead.
... |
Load a profile from a list of D - Wave Cloud Client configuration files. | def load_profile_from_files(filenames=None, profile=None):
"""Load a profile from a list of D-Wave Cloud Client configuration files.
.. note:: This method is not standardly used to set up D-Wave Cloud Client configuration.
It is recommended you use :meth:`.Client.from_config` or
:meth:`.config.... |
Load D - Wave Cloud Client configuration based on a configuration file. | def load_config(config_file=None, profile=None, client=None,
endpoint=None, token=None, solver=None, proxy=None):
"""Load D-Wave Cloud Client configuration based on a configuration file.
Configuration values can be specified in multiple ways, ranked in the following
order (with 1 the highes... |
Load configured URLs and token for the SAPI server. | def legacy_load_config(profile=None, endpoint=None, token=None, solver=None,
proxy=None, **kwargs):
"""Load configured URLs and token for the SAPI server.
.. warning:: Included only for backward compatibility. Please use
:func:`load_config` or the client factory
:meth:`~d... |
Check whether data is a valid input/ output for libsamplerate. | def _check_data(data):
"""Check whether `data` is a valid input/output for libsamplerate.
Returns
-------
num_frames
Number of frames in `data`.
channels
Number of channels in `data`.
Raises
------
ValueError: If invalid data is supplied.
"""
if not (data.dt... |
Perform a single conversion from an input buffer to an output buffer. | def src_simple(input_data, output_data, ratio, converter_type, channels):
"""Perform a single conversion from an input buffer to an output buffer.
Simple interface for performing a single conversion from input buffer to
output buffer at a fixed conversion ratio. Simple interface does not require
initia... |
Initialise a new sample rate converter. | def src_new(converter_type, channels):
"""Initialise a new sample rate converter.
Parameters
----------
converter_type : int
Converter to be used.
channels : int
Number of channels.
Returns
-------
state
An anonymous pointer to the internal state of the converte... |
Standard processing function. | def src_process(state, input_data, output_data, ratio, end_of_input=0):
"""Standard processing function.
Returns non zero on error.
"""
input_frames, _ = _check_data(input_data)
output_frames, _ = _check_data(output_data)
data = ffi.new('SRC_DATA*')
data.input_frames = input_frames
data... |
Internal callback function to be used with the callback API. | def _src_input_callback(cb_data, data):
"""Internal callback function to be used with the callback API.
Pulls the Python callback function from the handle contained in `cb_data`
and calls it to fetch frames. Frames are converted to the format required by
the API (float, interleaved channels). A referen... |
Initialisation for the callback based API. | def src_callback_new(callback, converter_type, channels):
"""Initialisation for the callback based API.
Parameters
----------
callback : function
Called whenever new frames are to be read. Must return a NumPy array
of shape (num_frames, channels).
converter_type : int
Conver... |
Read up to frames worth of data using the callback API. | def src_callback_read(state, ratio, frames, data):
"""Read up to `frames` worth of data using the callback API.
Returns
-------
frames : int
Number of frames read or -1 on error.
"""
data_ptr = ffi.cast('float*f', ffi.from_buffer(data))
return _lib.src_callback_read(state, ratio, fr... |
Client factory method to instantiate a client instance from configuration. | def from_config(cls, config_file=None, profile=None, client=None,
endpoint=None, token=None, solver=None, proxy=None,
legacy_config_fallback=False, **kwargs):
"""Client factory method to instantiate a client instance from configuration.
Configuration values can b... |
Perform a clean shutdown. | def close(self):
"""Perform a clean shutdown.
Waits for all the currently scheduled work to finish, kills the workers,
and closes the connection pool.
.. note:: Ensure your code does not submit new work while the connection is closing.
Where possible, it is recommended you use... |
Return a filtered list of solvers handled by this client. | def get_solvers(self, refresh=False, order_by='avg_load', **filters):
"""Return a filtered list of solvers handled by this client.
Args:
refresh (bool, default=False):
Force refresh of cached list of solvers/properties.
order_by (callable/str/None, default='avg_... |
Deprecated in favor of: meth:. get_solvers. | def solvers(self, refresh=False, **filters):
"""Deprecated in favor of :meth:`.get_solvers`."""
warnings.warn("'solvers' is deprecated in favor of 'get_solvers'.", DeprecationWarning)
return self.get_solvers(refresh=refresh, **filters) |
Load the configuration for a single solver. | def get_solver(self, name=None, refresh=False, **filters):
"""Load the configuration for a single solver.
Makes a blocking web call to `{endpoint}/solvers/remote/{solver_name}/`, where `{endpoint}`
is a URL configured for the client, and returns a :class:`.Solver` instance
that can be u... |
Enqueue a problem for submission to the server. | def _submit(self, body, future):
"""Enqueue a problem for submission to the server.
This method is thread safe.
"""
self._submission_queue.put(self._submit.Message(body, future)) |
Pull problems from the submission queue and submit them. | def _do_submit_problems(self):
"""Pull problems from the submission queue and submit them.
Note:
This method is always run inside of a daemon thread.
"""
try:
while True:
# Pull as many problems as we can, block on the first one,
#... |
Handle the results of a problem submission or results request. | def _handle_problem_status(self, message, future):
"""Handle the results of a problem submission or results request.
This method checks the status of the problem and puts it in the correct queue.
Args:
message (dict): Update message from the SAPI server wrt. this problem.
... |
Pull ids from the cancel queue and submit them. | def _do_cancel_problems(self):
"""Pull ids from the cancel queue and submit them.
Note:
This method is always run inside of a daemon thread.
"""
try:
while True:
# Pull as many problems as we can, block when none are available.
# ... |
Enqueue a problem to poll the server for status. | def _poll(self, future):
"""Enqueue a problem to poll the server for status."""
if future._poll_backoff is None:
# on first poll, start with minimal back-off
future._poll_backoff = self._POLL_BACKOFF_MIN
# if we have ETA of results, schedule the first poll for then
... |
Poll the server for the status of a set of problems. | def _do_poll_problems(self):
"""Poll the server for the status of a set of problems.
Note:
This method is always run inside of a daemon thread.
"""
try:
# grouped futures (all scheduled within _POLL_GROUP_TIMEFRAME)
frame_futures = {}
def... |
Submit a query asking for the results for a particular problem. | def _do_load_results(self):
"""Submit a query asking for the results for a particular problem.
To request the results of a problem: ``GET /problems/{problem_id}/``
Note:
This method is always run inside of a daemon thread.
"""
try:
while True:
... |
Encode the binary quadratic problem for submission to a given solver using the qp format for data. | def encode_bqm_as_qp(solver, linear, quadratic):
"""Encode the binary quadratic problem for submission to a given solver,
using the `qp` format for data.
Args:
solver (:class:`dwave.cloud.solver.Solver`):
The solver used.
linear (dict[variable, bias]/list[variable, bias]):
... |
Decode SAPI response that uses qp format without numpy. | def decode_qp(msg):
"""Decode SAPI response that uses `qp` format, without numpy.
The 'qp' format is the current encoding used for problems and samples.
In this encoding the reply is generally json, but the samples, energy,
and histogram data (the occurrence count of each solution), are all
base64 ... |
Helper for decode_qp turns a single byte into a list of bits. | def _decode_byte(byte):
"""Helper for decode_qp, turns a single byte into a list of bits.
Args:
byte: byte to be decoded
Returns:
list of bits corresponding to byte
"""
bits = []
for _ in range(8):
bits.append(byte & 1)
byte >>= 1
return bits |
Helper for decode_qp decodes an int array. | def _decode_ints(message):
"""Helper for decode_qp, decodes an int array.
The int array is stored as little endian 32 bit integers.
The array has then been base64 encoded. Since we are decoding we do these
steps in reverse.
"""
binary = base64.b64decode(message)
return struct.unpack('<' + (... |
Helper for decode_qp decodes a double array. | def _decode_doubles(message):
"""Helper for decode_qp, decodes a double array.
The double array is stored as little endian 64 bit doubles.
The array has then been base64 encoded. Since we are decoding we do these
steps in reverse.
Args:
message: the double array
Returns:
decod... |
Decode SAPI response results in a qp format explicitly using numpy. If numpy is not installed the method will fail. | def decode_qp_numpy(msg, return_matrix=True):
"""Decode SAPI response, results in a `qp` format, explicitly using numpy.
If numpy is not installed, the method will fail.
To use numpy for decoding, but return the results a lists (instead of
numpy matrices), set `return_matrix=False`.
"""
import ... |
Calculate the energy of a state given the Hamiltonian. | def evaluate_ising(linear, quad, state):
"""Calculate the energy of a state given the Hamiltonian.
Args:
linear: Linear Hamiltonian terms.
quad: Quadratic Hamiltonian terms.
state: Vector of spins describing the system state.
Returns:
Energy of the state evaluated by the gi... |
Calculate a set of all active qubits. Qubit is active if it has bias or coupling attached. | def active_qubits(linear, quadratic):
"""Calculate a set of all active qubits. Qubit is "active" if it has
bias or coupling attached.
Args:
linear (dict[variable, bias]/list[variable, bias]):
Linear terms of the model.
quadratic (dict[(variable, variable), bias]):
Q... |
Generates an Ising problem formulation valid for a particular solver using all qubits and all couplings and linear/ quadratic biases sampled uniformly from h_range/ j_range. | def generate_random_ising_problem(solver, h_range=None, j_range=None):
"""Generates an Ising problem formulation valid for a particular solver,
using all qubits and all couplings and linear/quadratic biases sampled
uniformly from `h_range`/`j_range`.
"""
if h_range is None:
h_range = solver... |
Uniform ( key value ) iteration on a dict or ( idx value ) on a list. | def uniform_iterator(sequence):
"""Uniform (key, value) iteration on a `dict`,
or (idx, value) on a `list`."""
if isinstance(sequence, abc.Mapping):
return six.iteritems(sequence)
else:
return enumerate(sequence) |
Uniform dict/ list item getter where index is interpreted as a key for maps and as numeric index for lists. | def uniform_get(sequence, index, default=None):
"""Uniform `dict`/`list` item getter, where `index` is interpreted as a key
for maps and as numeric index for lists."""
if isinstance(sequence, abc.Mapping):
return sequence.get(index, default)
else:
return sequence[index] if index < len(s... |
Strips elements of values from the beginning of sequence. | def strip_head(sequence, values):
"""Strips elements of `values` from the beginning of `sequence`."""
values = set(values)
return list(itertools.dropwhile(lambda x: x in values, sequence)) |
Strip values from the end of sequence. | def strip_tail(sequence, values):
"""Strip `values` from the end of `sequence`."""
return list(reversed(list(strip_head(reversed(sequence), values)))) |
Decorator to create eager Click info switch option as described in: http:// click. pocoo. org/ 6/ options/ #callbacks - and - eager - options. | def click_info_switch(f):
"""Decorator to create eager Click info switch option, as described in:
http://click.pocoo.org/6/options/#callbacks-and-eager-options.
Takes a no-argument function and abstracts the boilerplate required by
Click (value checking, exit on done).
Example:
@click.opt... |
Convert timezone - aware datetime to POSIX timestamp and return seconds since UNIX epoch. | def datetime_to_timestamp(dt):
"""Convert timezone-aware `datetime` to POSIX timestamp and
return seconds since UNIX epoch.
Note: similar to `datetime.timestamp()` in Python 3.3+.
"""
epoch = datetime.utcfromtimestamp(0).replace(tzinfo=UTC)
return (dt - epoch).total_seconds() |
Return User - Agent ~ name/ version language/ version interpreter/ version os/ version. | def user_agent(name, version):
"""Return User-Agent ~ "name/version language/version interpreter/version os/version"."""
def _interpreter():
name = platform.python_implementation()
version = platform.python_version()
bitness = platform.architecture()[0]
if name == 'PyPy':
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.