INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Create a new bit condition that matches the provided bit string with the indicated per - index wildcard probability. | def cover(cls, bits, wildcard_probability):
"""Create a new bit condition that matches the provided bit string,
with the indicated per-index wildcard probability.
Usage:
condition = BitCondition.cover(bitstring, .33)
assert condition(bitstring)
Arguments:
... |
Perform 2 - point crossover on this bit condition and another of the same length returning the two resulting children. | def crossover_with(self, other, points=2):
"""Perform 2-point crossover on this bit condition and another of
the same length, returning the two resulting children.
Usage:
offspring1, offspring2 = condition1.crossover_with(condition2)
Arguments:
other: A second B... |
Get the currently used backend class. | def get_backend_cls(self):
"""Get the currently used backend class."""
backend_cls = self.backend_cls
if not backend_cls or isinstance(backend_cls, basestring):
backend_cls = get_backend_cls(backend_cls)
return backend_cls |
Ensure we have a connection to the server. | def ensure_connection(self, errback=None, max_retries=None,
interval_start=2, interval_step=2, interval_max=30):
"""Ensure we have a connection to the server.
If not retry establishing the connection with the settings
specified.
:keyword errback: Optional callback called ea... |
Close the currently open connection. | def close(self):
"""Close the currently open connection."""
try:
if self._connection:
backend = self.create_backend()
backend.close_connection(self._connection)
except socket.error:
pass
self._closed = True |
Get connection info. | def info(self):
"""Get connection info."""
backend_cls = self.backend_cls or "amqplib"
port = self.port or self.create_backend().default_port
return {"hostname": self.hostname,
"userid": self.userid,
"password": self.password,
"virtual_host... |
Deserialize the message body returning the original python structure sent by the publisher. | def decode(self):
"""Deserialize the message body, returning the original
python structure sent by the publisher."""
return serialization.decode(self.body, self.content_type,
self.content_encoding) |
The decoded message. | def payload(self):
"""The decoded message."""
if not self._decoded_cache:
self._decoded_cache = self.decode()
return self._decoded_cache |
Acknowledge this message as being processed. This will remove the message from the queue. | def ack(self):
"""Acknowledge this message as being processed.,
This will remove the message from the queue.
:raises MessageStateError: If the message has already been
acknowledged/requeued/rejected.
"""
if self.acknowledged:
raise self.MessageStateError... |
Reject this message. | def reject(self):
"""Reject this message.
The message will be discarded by the server.
:raises MessageStateError: If the message has already been
acknowledged/requeued/rejected.
"""
if self.acknowledged:
raise self.MessageStateError(
"Me... |
Reject this message and put it back on the queue. | def requeue(self):
"""Reject this message and put it back on the queue.
You must not use this method as a means of selecting messages
to process.
:raises MessageStateError: If the message has already been
acknowledged/requeued/rejected.
"""
if self.acknowle... |
Generate a unique id having - hopefully - a very small chance of collission. | def gen_unique_id():
"""Generate a unique id, having - hopefully - a very small chance of
collission.
For now this is provided by :func:`uuid.uuid4`.
"""
# Workaround for http://bugs.python.org/issue4607
if ctypes and _uuid_generate_random:
buffer = ctypes.create_string_buffer(16)
... |
Retry the function over and over until max retries is exceeded. | def retry_over_time(fun, catch, args=[], kwargs={}, errback=None,
max_retries=None, interval_start=2, interval_step=2, interval_max=30):
"""Retry the function over and over until max retries is exceeded.
For each retry we sleep a for a while before we try again, this interval
is increased for every... |
Get the next waiting message from the queue. | def get(self, *args, **kwargs):
"""Get the next waiting message from the queue.
:returns: A :class:`Message` instance, or ``None`` if there is
no messages waiting.
"""
if not mqueue.qsize():
return None
message_data, content_type, content_encoding = mque... |
Discard all messages in the queue. | def queue_purge(self, queue, **kwargs):
"""Discard all messages in the queue."""
qsize = mqueue.qsize()
mqueue.queue.clear()
return qsize |
Prepare message for sending. | def prepare_message(self, message_data, delivery_mode,
content_type, content_encoding, **kwargs):
"""Prepare message for sending."""
return (message_data, content_type, content_encoding) |
Return a numerical value representing the expected future payoff of the previously selected action given only the current match set. The match_set argument is a MatchSet instance representing the current match set. | def get_future_expectation(self, match_set):
"""Return a numerical value representing the expected future payoff
of the previously selected action, given only the current match
set. The match_set argument is a MatchSet instance representing the
current match set.
Usage:
... |
Return a Boolean indicating whether covering is required for the current match set. The match_set argument is a MatchSet instance representing the current match set before covering is applied. | def covering_is_required(self, match_set):
"""Return a Boolean indicating whether covering is required for the
current match set. The match_set argument is a MatchSet instance
representing the current match set before covering is applied.
Usage:
match_set = model.match(situa... |
Return a new classifier rule that can be added to the match set with a condition that matches the situation of the match set and an action selected to avoid duplication of the actions already contained therein. The match_set argument is a MatchSet instance representing the match set to which the returned rule may be ad... | def cover(self, match_set):
"""Return a new classifier rule that can be added to the match set,
with a condition that matches the situation of the match set and an
action selected to avoid duplication of the actions already
contained therein. The match_set argument is a MatchSet instance... |
Distribute the payoff received in response to the selected action of the given match set among the rules in the action set which deserve credit for recommending the action. The match_set argument is the MatchSet instance which suggested the selected action and earned the payoff. | def distribute_payoff(self, match_set):
"""Distribute the payoff received in response to the selected
action of the given match set among the rules in the action set
which deserve credit for recommending the action. The match_set
argument is the MatchSet instance which suggested the sele... |
Update the classifier set from which the match set was drawn e. g. by applying a genetic algorithm. The match_set argument is the MatchSet instance whose classifier set should be updated. | def update(self, match_set):
"""Update the classifier set from which the match set was drawn,
e.g. by applying a genetic algorithm. The match_set argument is the
MatchSet instance whose classifier set should be updated.
Usage:
match_set = model.match(situation)
m... |
Reduce the classifier set s population size if necessary by removing lower - quality * rules. Return a list containing any rules whose numerosities dropped to zero as a result of this call. ( The list may be empty if no rule s numerosity dropped to 0. ) The model argument is a ClassifierSet instance which utilizes this... | def prune(self, model):
"""Reduce the classifier set's population size, if necessary, by
removing lower-quality *rules. Return a list containing any rules
whose numerosities dropped to zero as a result of this call. (The
list may be empty, if no rule's numerosity dropped to 0.) The
... |
Update the fitness values of the rules belonging to this action set. | def _update_fitness(self, action_set):
"""Update the fitness values of the rules belonging to this action
set."""
# Compute the accuracy of each rule. Accuracy is inversely
# proportional to error. Below a certain error threshold, accuracy
# becomes constant. Accuracy values rang... |
Perform action set subsumption. | def _action_set_subsumption(self, action_set):
"""Perform action set subsumption."""
# Select a condition with maximum bit count among those having
# sufficient experience and sufficiently low error.
selected_rule = None
selected_bit_count = None
for rule in action_set:
... |
Return the average time stamp for the rules in this action set. | def _get_average_time_stamp(action_set):
"""Return the average time stamp for the rules in this action
set."""
# This is the average value of the iteration counter upon the most
# recent update of each rule in this action set.
total_time_stamps = sum(rule.time_stamp * rule.numero... |
Select a rule from this action set with probability proportionate to its fitness to act as a parent for a new rule in the classifier set. Return the selected rule. | def _select_parent(action_set):
"""Select a rule from this action set, with probability
proportionate to its fitness, to act as a parent for a new rule in
the classifier set. Return the selected rule."""
total_fitness = sum(rule.fitness for rule in action_set)
selector = random.u... |
Create a new condition from the given one by probabilistically applying point - wise mutations. Bits that were originally wildcarded in the parent condition acquire their values from the provided situation to ensure the child condition continues to match it. | def _mutate(self, condition, situation):
"""Create a new condition from the given one by probabilistically
applying point-wise mutations. Bits that were originally wildcarded
in the parent condition acquire their values from the provided
situation, to ensure the child condition continues... |
Establish connection to the AMQP broker. | def establish_connection(self):
"""Establish connection to the AMQP broker."""
conninfo = self.connection
if not conninfo.port:
conninfo.port = self.default_port
credentials = pika.PlainCredentials(conninfo.userid,
conninfo.password... |
Discard all messages in the queue. This will delete the messages and results in an empty queue. | def queue_purge(self, queue, **kwargs):
"""Discard all messages in the queue. This will delete the messages
and results in an empty queue."""
return self.channel.queue_purge(queue=queue).message_count |
Declare a named queue. | def queue_declare(self, queue, durable, exclusive, auto_delete,
warn_if_exists=False, arguments=None):
"""Declare a named queue."""
return self.channel.queue_declare(queue=queue,
durable=durable,
exclusive=e... |
Declare a consumer. | def declare_consumer(self, queue, no_ack, callback, consumer_tag,
nowait=False):
"""Declare a consumer."""
@functools.wraps(callback)
def _callback_decode(channel, method, header, body):
return callback((channel, method, header, body))
return self.channel.basic_... |
Close the channel if open. | def close(self):
"""Close the channel if open."""
if self._channel and not self._channel.handler.channel_close:
self._channel.close()
self._channel_ref = None |
Encapsulate data into a AMQP message. | def prepare_message(self, message_data, delivery_mode, priority=None,
content_type=None, content_encoding=None):
"""Encapsulate data into a AMQP message."""
properties = pika.BasicProperties(priority=priority,
content_type=content_type,
... |
Publish a message to a named exchange. | def publish(self, message, exchange, routing_key, mandatory=None,
immediate=None, headers=None):
"""Publish a message to a named exchange."""
body, properties = message
if headers:
properties.headers = headers
ret = self.channel.basic_publish(body=body,
... |
Generate a unique consumer tag. | def _generate_consumer_tag(self):
"""Generate a unique consumer tag.
:rtype string:
"""
return "%s.%s%s" % (
self.__class__.__module__,
self.__class__.__name__,
self._next_consumer_tag()) |
Declares the queue the exchange and binds the queue to the exchange. | def declare(self):
"""Declares the queue, the exchange and binds the queue to
the exchange."""
arguments = None
routing_key = self.routing_key
if self.exchange_type == "headers":
arguments, routing_key = routing_key, ""
if self.queue:
self.backend... |
Internal method used when a message is received in consume mode. | def _receive_callback(self, raw_message):
"""Internal method used when a message is received in consume mode."""
message = self.backend.message_to_python(raw_message)
if self.auto_ack and not message.acknowledged:
message.ack()
self.receive(message.payload, message) |
Receive the next message waiting on the queue. | def fetch(self, no_ack=None, auto_ack=None, enable_callbacks=False):
"""Receive the next message waiting on the queue.
:returns: A :class:`carrot.backends.base.BaseMessage` instance,
or ``None`` if there's no messages to be received.
:keyword enable_callbacks: Enable callbacks. The... |
This method is called when a new message is received by running: meth: wait: meth: process_next or: meth: iterqueue. | def receive(self, message_data, message):
"""This method is called when a new message is received by
running :meth:`wait`, :meth:`process_next` or :meth:`iterqueue`.
When a message is received, it passes the message on to the
callbacks listed in the :attr:`callbacks` attribute.
... |
Discard all waiting messages. | def discard_all(self, filterfunc=None):
"""Discard all waiting messages.
:param filterfunc: A filter function to only discard the messages this
filter returns.
:returns: the number of messages discarded.
*WARNING*: All incoming messages will be ignored and not processed.
... |
Declare consumer. | def consume(self, no_ack=None):
"""Declare consumer."""
no_ack = no_ack or self.no_ack
self.backend.declare_consumer(queue=self.queue, no_ack=no_ack,
callback=self._receive_callback,
consumer_tag=self.consumer_tag,
... |
Go into consume mode. | def wait(self, limit=None):
"""Go into consume mode.
Mostly for testing purposes and simple programs, you probably
want :meth:`iterconsume` or :meth:`iterqueue` instead.
This runs an infinite loop, processing all incoming messages
using :meth:`receive` to apply the message to a... |
Infinite iterator yielding pending messages by using synchronous direct access to the queue ( basic_get ). | def iterqueue(self, limit=None, infinite=False):
"""Infinite iterator yielding pending messages, by using
synchronous direct access to the queue (``basic_get``).
:meth:`iterqueue` is used where synchronous functionality is more
important than performance. If you can, use :meth:`itercons... |
Cancel a running: meth: iterconsume session. | def cancel(self):
"""Cancel a running :meth:`iterconsume` session."""
if self.channel_open:
try:
self.backend.cancel(self.consumer_tag)
except KeyError:
pass |
Close the channel to the queue. | def close(self):
"""Close the channel to the queue."""
self.cancel()
self.backend.close()
self._closed = True |
Request specific Quality of Service. | def qos(self, prefetch_size=0, prefetch_count=0, apply_global=False):
"""Request specific Quality of Service.
This method requests a specific quality of service. The QoS
can be specified for the current channel or for all channels
on the connection. The particular properties and seman... |
Declare the exchange. | def declare(self):
"""Declare the exchange.
Creates the exchange on the broker.
"""
self.backend.exchange_declare(exchange=self.exchange,
type=self.exchange_type,
durable=self.durable,
... |
With any data serialize it and encapsulate it in a AMQP message with the proper headers set. | def create_message(self, message_data, delivery_mode=None, priority=None,
content_type=None, content_encoding=None,
serializer=None):
"""With any data, serialize it and encapsulate it in a AMQP
message with the proper headers set."""
delivery_mode =... |
Send a message. | def send(self, message_data, routing_key=None, delivery_mode=None,
mandatory=False, immediate=False, priority=0, content_type=None,
content_encoding=None, serializer=None, exchange=None):
"""Send a message.
:param message_data: The message data to send. Can be a list,
... |
See: meth: Publisher. send | def send(self, message_data, delivery_mode=None):
"""See :meth:`Publisher.send`"""
self.publisher.send(message_data, delivery_mode=delivery_mode) |
Close any open channels. | def close(self):
"""Close any open channels."""
self.consumer.close()
self.publisher.close()
self._closed = True |
Internal method used when a message is received in consume mode. | def _receive_callback(self, raw_message):
"""Internal method used when a message is received in consume mode."""
message = self.backend.message_to_python(raw_message)
if self.auto_ack and not message.acknowledged:
message.ack()
try:
decoded = message.decode()
... |
Add another consumer from dictionary configuration. | def add_consumer_from_dict(self, queue, **options):
"""Add another consumer from dictionary configuration."""
options.setdefault("routing_key", options.pop("binding_key", None))
consumer = Consumer(self.connection, queue=queue,
backend=self.backend, **options)
... |
Add another consumer from a: class: Consumer instance. | def add_consumer(self, consumer):
"""Add another consumer from a :class:`Consumer` instance."""
consumer.backend = self.backend
self.consumers.append(consumer) |
Declare consumer so messages can be received from it using: meth: iterconsume. | def _declare_consumer(self, consumer, nowait=False):
"""Declare consumer so messages can be received from it using
:meth:`iterconsume`."""
if consumer.queue not in self._open_consumers:
# Use the ConsumerSet's consumer by default, but if the
# child consumer has a callbac... |
Declare consumers. | def consume(self):
"""Declare consumers."""
head = self.consumers[:-1]
tail = self.consumers[-1]
[self._declare_consumer(consumer, nowait=True)
for consumer in head]
self._declare_consumer(tail, nowait=False) |
Cycle between all consumers in consume mode. | def iterconsume(self, limit=None):
"""Cycle between all consumers in consume mode.
See :meth:`Consumer.iterconsume`.
"""
self.consume()
return self.backend.consume(limit=limit) |
Cancel a running: meth: iterconsume session. | def cancel(self):
"""Cancel a running :meth:`iterconsume` session."""
for consumer_tag in self._open_consumers.values():
try:
self.backend.cancel(consumer_tag)
except KeyError:
pass
self._open_consumers.clear() |
Try to convert the source an. md ( markdown ) file to an. rst ( reStructuredText ) file at the destination. If the destination isn t provided it defaults to be the same as the source path except for the filename extension. If the destination file already exists it will be overwritten. In the event of an error the desti... | def convert_md_to_rst(source, destination=None, backup_dir=None):
"""Try to convert the source, an .md (markdown) file, to an .rst
(reStructuredText) file at the destination. If the destination isn't
provided, it defaults to be the same as the source path except for the
filename extension. If the destin... |
Call the conversion routine on README. md to generate README. rst. Why do all this? Because pypi requires reStructuredText but markdown is friendlier to work with and is nicer for GitHub. | def build_readme(base_path=None):
"""Call the conversion routine on README.md to generate README.rst.
Why do all this? Because pypi requires reStructuredText, but markdown
is friendlier to work with and is nicer for GitHub."""
if base_path:
path = os.path.join(base_path, 'README.md')
else:
... |
Return a situation encoded as a bit string which represents the observable state of the environment. | def sense(self):
"""Return a situation, encoded as a bit string, which represents
the observable state of the environment.
Usage:
situation = scenario.sense()
assert isinstance(situation, BitString)
Arguments: None
Return:
The current situati... |
Execute the indicated action within the environment and return the resulting immediate reward dictated by the reward program. | def execute(self, action):
"""Execute the indicated action within the environment and
return the resulting immediate reward dictated by the reward
program.
Usage:
immediate_reward = scenario.execute(selected_action)
Arguments:
action: The action to be ex... |
Reset the scenario starting it over for a new run. | def reset(self):
"""Reset the scenario, starting it over for a new run.
Usage:
if not scenario.more():
scenario.reset()
Arguments: None
Return: None
"""
self.remaining_cycles = self.initial_training_cycles
self.needle_index = random.r... |
Return a situation encoded as a bit string which represents the observable state of the environment. | def sense(self):
"""Return a situation, encoded as a bit string, which represents
the observable state of the environment.
Usage:
situation = scenario.sense()
assert isinstance(situation, BitString)
Arguments: None
Return:
The current situati... |
Execute the indicated action within the environment and return the resulting immediate reward dictated by the reward program. | def execute(self, action):
"""Execute the indicated action within the environment and
return the resulting immediate reward dictated by the reward
program.
Usage:
immediate_reward = scenario.execute(selected_action)
Arguments:
action: The action to be ex... |
Return a sequence containing the possible actions that can be executed within the environment. | def get_possible_actions(self):
"""Return a sequence containing the possible actions that can be
executed within the environment.
Usage:
possible_actions = scenario.get_possible_actions()
Arguments: None
Return:
A sequence containing the possible actions... |
Return a situation encoded as a bit string which represents the observable state of the environment. | def sense(self):
"""Return a situation, encoded as a bit string, which represents
the observable state of the environment.
Usage:
situation = scenario.sense()
assert isinstance(situation, BitString)
Arguments: None
Return:
The current situati... |
Execute the indicated action within the environment and return the resulting immediate reward dictated by the reward program. | def execute(self, action):
"""Execute the indicated action within the environment and
return the resulting immediate reward dictated by the reward
program.
Usage:
immediate_reward = scenario.execute(selected_action)
Arguments:
action: The action to be ex... |
Return a Boolean indicating whether additional actions may be executed per the reward program. | def more(self):
"""Return a Boolean indicating whether additional actions may be
executed, per the reward program.
Usage:
while scenario.more():
situation = scenario.sense()
selected_action = choice(possible_actions)
reward = scenario.... |
Execute the indicated action within the environment and return the resulting immediate reward dictated by the reward program. | def execute(self, action):
"""Execute the indicated action within the environment and
return the resulting immediate reward dictated by the reward
program.
Usage:
immediate_reward = scenario.execute(selected_action)
Arguments:
action: The action to be ex... |
Return the classifications made by the algorithm for this scenario. | def get_classifications(self):
"""Return the classifications made by the algorithm for this
scenario.
Usage:
model.run(scenario, learn=False)
classifications = scenario.get_classifications()
Arguments: None
Return:
An indexable sequence conta... |
Create and return a new classifier set initialized for handling the given scenario. | def new_model(self, scenario):
"""Create and return a new classifier set initialized for handling
the given scenario.
Usage:
scenario = MUXProblem()
model = algorithm.new_model(scenario)
model.run(scenario, learn=True)
Arguments:
scenario... |
Run the algorithm utilizing a classifier set to choose the most appropriate action for each situation produced by the scenario. Improve the situation/ action mapping on each reward cycle to maximize reward. Return the classifier set that was created. | def run(self, scenario):
"""Run the algorithm, utilizing a classifier set to choose the
most appropriate action for each situation produced by the
scenario. Improve the situation/action mapping on each reward
cycle to maximize reward. Return the classifier set that was
created.
... |
Compute the combined prediction and prediction weight for this action set. The combined prediction is the weighted average of the individual predictions of the classifiers. The combined prediction weight is the sum of the individual prediction weights of the classifiers. | def _compute_prediction(self):
"""Compute the combined prediction and prediction weight for this
action set. The combined prediction is the weighted average of the
individual predictions of the classifiers. The combined prediction
weight is the sum of the individual prediction weights of... |
The highest value from among the predictions made by the action sets in this match set. | def best_prediction(self):
"""The highest value from among the predictions made by the action
sets in this match set."""
if self._best_prediction is None and self._action_sets:
self._best_prediction = max(
action_set.prediction
for action_set in self._... |
A tuple containing the actions whose action sets have the best prediction. | def best_actions(self):
"""A tuple containing the actions whose action sets have the best
prediction."""
if self._best_actions is None:
best_prediction = self.best_prediction
self._best_actions = tuple(
action
for action, action_set in self... |
Select an action according to the action selection strategy of the associated algorithm. If an action has already been selected raise a ValueError instead. | def select_action(self):
"""Select an action according to the action selection strategy of
the associated algorithm. If an action has already been selected,
raise a ValueError instead.
Usage:
if match_set.selected_action is None:
match_set.select_action()
... |
Setter method for the selected_action property. | def _set_selected_action(self, action):
"""Setter method for the selected_action property."""
assert action in self._action_sets
if self._selected_action is not None:
raise ValueError("The action has already been selected.")
self._selected_action = action |
Setter method for the payoff property. | def _set_payoff(self, payoff):
"""Setter method for the payoff property."""
if self._selected_action is None:
raise ValueError("The action has not been selected yet.")
if self._closed:
raise ValueError("The payoff for this match set has already"
... |
If the predecessor is not None gives the appropriate amount of payoff to the predecessor in payment for its contribution to this match set s expected future payoff. The predecessor argument should be either None or a MatchSet instance whose selected action led directly to this match set s situation. | def pay(self, predecessor):
"""If the predecessor is not None, gives the appropriate amount of
payoff to the predecessor in payment for its contribution to this
match set's expected future payoff. The predecessor argument should
be either None or a MatchSet instance whose selected action... |
Apply the payoff that has been accumulated from immediate reward and/ or payments from successor match sets. Attempting to call this method before an action has been selected or after it has already been called for the same match set will result in a ValueError. | def apply_payoff(self):
"""Apply the payoff that has been accumulated from immediate
reward and/or payments from successor match sets. Attempting to
call this method before an action has been selected or after it
has already been called for the same match set will result in a
Val... |
Accept a situation ( input ) and return a MatchSet containing the classifier rules whose conditions match the situation. If appropriate per the algorithm managing this classifier set create new rules to ensure sufficient coverage of the possible actions. | def match(self, situation):
"""Accept a situation (input) and return a MatchSet containing the
classifier rules whose conditions match the situation. If
appropriate per the algorithm managing this classifier set, create
new rules to ensure sufficient coverage of the possible actions.
... |
Add a new classifier rule to the classifier set. Return a list containing zero or more rules that were deleted from the classifier by the algorithm in order to make room for the new rule. The rule argument should be a ClassifierRule instance. The behavior of this method depends on whether the rule already exists in the... | def add(self, rule):
"""Add a new classifier rule to the classifier set. Return a list
containing zero or more rules that were deleted from the classifier
by the algorithm in order to make room for the new rule. The rule
argument should be a ClassifierRule instance. The behavior of this
... |
Remove one or more instances of a rule from the classifier set. Return a Boolean indicating whether the rule s numerosity dropped to zero. ( If the rule s numerosity was already zero do nothing and return False. ) | def discard(self, rule, count=1):
"""Remove one or more instances of a rule from the classifier set.
Return a Boolean indicating whether the rule's numerosity dropped
to zero. (If the rule's numerosity was already zero, do nothing and
return False.)
Usage:
if rule in... |
Return the existing version of the given rule. If the rule is not present in the classifier set return the default. If no default was given use None. This is useful for eliminating duplicate copies of rules. | def get(self, rule, default=None):
"""Return the existing version of the given rule. If the rule is
not present in the classifier set, return the default. If no
default was given, use None. This is useful for eliminating
duplicate copies of rules.
Usage:
unique_rule ... |
Run the algorithm utilizing the classifier set to choose the most appropriate action for each situation produced by the scenario. If learn is True improve the situation/ action mapping to maximize reward. Otherwise ignore any reward received. | def run(self, scenario, learn=True):
"""Run the algorithm, utilizing the classifier set to choose the
most appropriate action for each situation produced by the
scenario. If learn is True, improve the situation/action mapping to
maximize reward. Otherwise, ignore any reward received.
... |
List configuration files detected ( and/ or examined paths ). | def ls(system, user, local, include_missing):
"""List configuration files detected (and/or examined paths)."""
# default action is to list *all* auto-detected files
if not (system or user or local):
system = user = local = True
for path in get_configfile_paths(system=system, user=user, local=l... |
Inspect existing configuration/ profile. | def inspect(config_file, profile):
"""Inspect existing configuration/profile."""
try:
section = load_profile_from_files(
[config_file] if config_file else None, profile)
click.echo("Configuration file: {}".format(config_file if config_file else "auto-detected"))
click.echo(... |
Create and/ or update cloud client configuration file. | def create(config_file, profile):
"""Create and/or update cloud client configuration file."""
# determine the config file path
if config_file:
click.echo("Using configuration file: {}".format(config_file))
else:
# path not given, try to detect; or use default, but allow user to override... |
Helper method for the ping command that uses output () for info output and raises CLIError () on handled errors. | def _ping(config_file, profile, solver_def, request_timeout, polling_timeout, output):
"""Helper method for the ping command that uses `output()` for info output
and raises `CLIError()` on handled errors.
This function is invariant to output format and/or error signaling mechanism.
"""
config = di... |
Ping the QPU by submitting a single - qubit problem. | def ping(config_file, profile, solver_def, json_output, request_timeout, polling_timeout):
"""Ping the QPU by submitting a single-qubit problem."""
now = utcnow()
info = dict(datetime=now.isoformat(), timestamp=datetime_to_timestamp(now), code=0)
def output(fmt, **kwargs):
info.update(kwargs)
... |
Get solver details. | def solvers(config_file, profile, solver_def, list_solvers):
"""Get solver details.
Unless solver name/id specified, fetch and display details for
all online solvers available on the configured endpoint.
"""
with Client.from_config(
config_file=config_file, profile=profile, solver=solv... |
Submit Ising - formulated problem and return samples. | def sample(config_file, profile, solver_def, biases, couplings, random_problem,
num_reads, verbose):
"""Submit Ising-formulated problem and return samples."""
# TODO: de-dup wrt ping
def echo(s, maxlen=100):
click.echo(s if verbose else strtrunc(s, maxlen))
try:
client = Cl... |
Return a function that produces samples of a sine. | def get_input_callback(samplerate, params, num_samples=256):
"""Return a function that produces samples of a sine.
Parameters
----------
samplerate : float
The sample rate.
params : dict
Parameters for FM generation.
num_samples : int, optional
Number of samples to be ge... |
Return a sound playback callback. | def get_playback_callback(resampler, samplerate, params):
"""Return a sound playback callback.
Parameters
----------
resampler
The resampler from which samples are read.
samplerate : float
The sample rate.
params : dict
Parameters for FM generation.
"""
def call... |
Setup the resampling and audio output callbacks and start playback. | def main(source_samplerate, target_samplerate, params, converter_type):
"""Setup the resampling and audio output callbacks and start playback."""
from time import sleep
ratio = target_samplerate / source_samplerate
with sr.CallbackResampler(get_input_callback(source_samplerate, params),
... |
Returns the maximum number of reads for the given solver parameters. | def max_num_reads(self, **params):
"""Returns the maximum number of reads for the given solver parameters.
Args:
**params:
Parameters for the sampling method. Relevant to num_reads:
- annealing_time
- readout_thermalization
- ... |
Sample from the specified Ising model. | def sample_ising(self, linear, quadratic, **params):
"""Sample from the specified Ising model.
Args:
linear (list/dict): Linear terms of the model (h).
quadratic (dict of (int, int):float): Quadratic terms of the model (J).
**params: Parameters for the sampling metho... |
Sample from the specified QUBO. | def sample_qubo(self, qubo, **params):
"""Sample from the specified QUBO.
Args:
qubo (dict of (int, int):float): Coefficients of a quadratic unconstrained binary
optimization (QUBO) model.
**params: Parameters for the sampling method, specified per solver.
... |
Internal method for both sample_ising and sample_qubo. | def _sample(self, type_, linear, quadratic, params):
"""Internal method for both sample_ising and sample_qubo.
Args:
linear (list/dict): Linear terms of the model.
quadratic (dict of (int, int):float): Quadratic terms of the model.
**params: Parameters for the sampli... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.