code stringlengths 52 7.75k | docs stringlengths 1 5.85k |
|---|---|
def _server_loop(self, client, client_addr):
while not self._stopped and not _shutting_down:
try:
with self._unlock():
request = mock_server_receive_request(client, self)
self._requests_count += 1
self._log('%d\t%r' % (req... | Read requests from one client socket, 'client'. |
def check_password(self, username, password):
try:
if SUPPORTS_VERIFY:
kerberos.checkPassword(username.lower(), password, getattr(settings, "KRB5_SERVICE", ""), getattr(settings, "KRB5_REALM", ""), getattr(settings, "KRB5_VERIFY_KDC", True))
else:
... | The actual password checking logic. Separated from the authenticate code from Django for easier updating |
def main():
from optparse import OptionParser
parser = OptionParser('Start mock MongoDB server')
parser.add_option('-p', '--port', dest='port', default=27017,
help='port on which mock mongod listens')
parser.add_option('-q', '--quiet',
action='store_false... | Start an interactive `MockupDB`.
Use like ``python -m mockupdb``. |
def _calculate_influence(self, neighborhood):
grid = np.exp(-self.distance_grid / (neighborhood ** 2))
return grid.reshape(self.num_neurons, self.num_neurons)[:, :, None] | Pre-calculate the influence for a given value of sigma.
The neighborhood has size num_neurons * num_neurons, so for a
30 * 30 map, the neighborhood will be size (900, 900).
Parameters
----------
neighborhood : float
The neighborhood value.
Returns
-... |
def _initialize_distance_grid(self):
p = [self._grid_distance(i) for i in range(self.num_neurons)]
return np.array(p) | Initialize the distance grid by calls to _grid_dist. |
def _grid_distance(self, index):
# Take every dimension but the first in reverse
# then reverse that list again.
dimensions = np.cumprod(self.map_dimensions[1::][::-1])[::-1]
coord = []
for idx, dim in enumerate(dimensions):
if idx != 0:
valu... | Calculate the distance grid for a single index position.
This is pre-calculated for fast neighborhood calculations
later on (see _calc_influence). |
def topographic_error(self, X, batch_size=1):
dist = self.transform(X, batch_size)
# Sort the distances and get the indices of the two smallest distances
# for each datapoint.
res = dist.argsort(1)[:, :2]
# Lookup the euclidean distance between these points in the distan... | Calculate the topographic error.
The topographic error is a measure of the spatial organization of the
map. Maps in which the most similar neurons are also close on the
grid have low topographic error and indicate that a problem has been
learned correctly.
Formally, the topogra... |
def neighbors(self, distance=2.0):
dgrid = self.distance_grid.reshape(self.num_neurons, self.num_neurons)
for x, y in zip(*np.nonzero(dgrid <= distance)):
if x != y:
yield x, y | Get all neighbors for all neurons. |
def neighbor_difference(self):
differences = np.zeros(self.num_neurons)
num_neighbors = np.zeros(self.num_neurons)
distance, _ = self.distance_function(self.weights, self.weights)
for x, y in self.neighbors():
differences[x] += distance[x, y]
num_neighbo... | Get the euclidean distance between a node and its neighbors. |
def spread(self, X):
distance, _ = self.distance_function(X, self.weights)
dists_per_neuron = defaultdict(list)
for x, y in zip(np.argmin(distance, 1), distance):
dists_per_neuron[x].append(y[x])
out = np.zeros(self.num_neurons)
average_spread = {k: np.mean(... | Calculate the average spread for each node.
The average spread is a measure of how far each neuron is from the
data points which cluster to it.
Parameters
----------
X : numpy array
The input data.
Returns
-------
spread : numpy array
... |
def invert_projection(self, X, identities):
distances = self.transform(X)
if len(distances) != len(identities):
raise ValueError("X and identities are not the same length: "
"{0} and {1}".format(len(X), len(identities)))
node_match = []
... | Calculate the inverted projection.
The inverted projectio of a SOM is created by association each weight
with the input which matches it the most, thus giving a good
approximation of the "influence" of each input item.
Works best for symbolic (instead of continuous) input data.
... |
def map_weights(self):
first_dim = self.map_dimensions[0]
if len(self.map_dimensions) != 1:
second_dim = np.prod(self.map_dimensions[1:])
else:
second_dim = 1
# Reshape to appropriate dimensions
return self.weights.reshape((first_dim,
... | Reshaped weights for visualization.
The weights are reshaped as
(W.shape[0], prod(W.shape[1:-1]), W.shape[2]).
This allows one to easily see patterns, even for hyper-dimensional
soms.
For one-dimensional SOMs, the returned array is of shape
(W.shape[0], 1, W.shape[2])
... |
def load(cls, path):
data = json.load(open(path))
weights = data['weights']
weights = np.asarray(weights, dtype=np.float64)
s = cls(data['map_dimensions'],
data['params']['lr']['orig'],
data['data_dimensionality'],
influence=data... | Load a SOM from a JSON file saved with this package..
Parameters
----------
path : str
The path to the JSON file.
Returns
-------
s : cls
A som of the specified class. |
def start(self):
LOG.info('Interacting with the CDN...')
with indicator.Spinner(run=self.run_indicator):
cdn_item = self._cdn()
self.print_virt_table(cdn_item.headers) | Return a list of objects from the API for a container. |
def remove_dirs(self, directory):
LOG.info('Removing directory [ %s ]', directory)
local_files = self._drectory_local_files(directory=directory)
for file_name in local_files:
try:
os.remove(file_name['local_object'])
except OSError as exp:
... | Delete a directory recursively.
:param directory: $PATH to directory.
:type directory: ``str`` |
def _list_contents(self, last_obj=None, single_page_return=False):
if self.job_args.get('cdn_containers'):
if not self.job_args.get('fields'):
self.job_args['fields'] = [
'name',
'cdn_enabled',
'log_retention',
... | Retrieve a long list of all files in a container.
:return final_list, list_count, last_obj: |
def _return_container_objects(self):
container_objects = self.job_args.get('object')
if container_objects:
return True, [{'container_object': i} for i in container_objects]
container_objects = self.job_args.get('objects_file')
if container_objects:
cont... | Return a list of objects to delete.
The return tuple will indicate if it was a userd efined list of objects
as True of False.
The list of objects is a list of dictionaries with the key being
"container_object".
:returns: tuple (``bol``, ``list``) |
def _index_fs(self):
indexed_objects = self._return_deque()
directory = self.job_args.get('directory')
if directory:
indexed_objects = self._return_deque(
deque=indexed_objects,
item=self._drectory_local_files(
directory=... | Returns a deque object full of local file system items.
:returns: ``deque`` |
def match_filter(self, idx_list, pattern, dict_type=False,
dict_key='name'):
if dict_type is False:
return self._return_deque([
obj for obj in idx_list
if re.search(pattern, obj)
])
elif dict_type is True:
... | Return Matched items in indexed files.
:param idx_list:
:return list |
def print_horiz_table(self, data):
# Build list of returned objects
return_objects = list()
fields = self.job_args.get('fields')
if not fields:
fields = set()
for item_dict in data:
for field_item in item_dict.keys():
... | Print a horizontal pretty table from data. |
def print_virt_table(self, data):
table = prettytable.PrettyTable()
keys = sorted(data.keys())
table.add_column('Keys', keys)
table.add_column('Values', [data.get(i) for i in keys])
for tbl in table.align.keys():
table.align[tbl] = 'l'
self.printer(... | Print a vertical pretty table from data. |
def printer(self, message, color_level='info'):
if self.job_args.get('colorized'):
print(cloud_utils.return_colorized(msg=message, color=color_level))
else:
print(message) | Print Messages and Log it.
:param message: item to print to screen |
def _get_method(method):
# Split the class out from the job
module = method.split(':')
# Set the import module
_module_import = module[0]
# Set the class name to use
class_name = module[-1]
# import the module
module_import = __import__(_modul... | Return an imported object.
:param method: ``str`` DOT notation for import with Colin used to
separate the class used for the job.
:returns: ``object`` Loaded class object from imported method. |
def run_manager(self, job_override=None):
for arg_name, arg_value in self.job_args.items():
if arg_name.endswith('_headers'):
if isinstance(arg_value, list):
self.job_args[arg_name] = self._list_headers(
headers=arg_value
... | The run manager.
The run manager is responsible for loading the plugin required based on
what the user has inputted using the parsed_command value as found in
the job_args dict. If the user provides a *job_override* the method
will attempt to import the module and class as provided by t... |
def range_initialization(X, num_weights):
# Randomly initialize weights to cover the range of each feature.
X_ = X.reshape(-1, X.shape[-1])
min_val, max_val = X_.min(0), X_.max(0)
data_range = max_val - min_val
return data_range * np.random.rand(num_weights,
... | Initialize the weights by calculating the range of the data.
The data range is calculated by reshaping the input matrix to a
2D matrix, and then taking the min and max values over the columns.
Parameters
----------
X : numpy array
The input data. The data range is calculated over the last ... |
def login(self, usr, pwd):
self._usr = usr
self._pwd = pwd | Use login() to Log in with a username and password. |
def send(self, me, to, subject, msg):
msg = MIMEText(msg)
msg['Subject'] = subject
msg['From'] = me
msg['To'] = to
server = smtplib.SMTP(self.host, self.port)
server.starttls()
# Check if user and password defined
if self._usr and self._pwd:
... | Send Message |
def _init_weights(self,
X):
X = np.asarray(X, dtype=np.float64)
if self.scaler is not None:
X = self.scaler.fit_transform(X)
if self.initializer is not None:
self.weights = self.initializer(X, self.num_neurons)
for v in self.param... | Set the weights and normalize data before starting training. |
def _pre_train(self,
stop_param_updates,
num_epochs,
updates_epoch):
# Calculate the total number of updates given early stopping.
updates = {k: stop_param_updates.get(k, num_epochs) * updates_epoch
for k, v in self.par... | Set parameters and constants before training. |
def fit_predict(self,
X,
num_epochs=10,
updates_epoch=10,
stop_param_updates=dict(),
batch_size=1,
show_progressbar=False):
self.fit(X,
num_epochs,
u... | First fit, then predict. |
def fit_transform(self,
X,
num_epochs=10,
updates_epoch=10,
stop_param_updates=dict(),
batch_size=1,
show_progressbar=False,
show_epoch=False):
self.... | First fit, then transform. |
def _epoch(self,
X,
epoch_idx,
batch_size,
updates_epoch,
constants,
show_progressbar):
# Create batches
X_ = self._create_batches(X, batch_size)
X_len = np.prod(X.shape[:-1])
update_step ... | Run a single epoch.
This function shuffles the data internally,
as this improves performance.
Parameters
----------
X : numpy array
The training data.
epoch_idx : int
The current epoch
batch_size : int
The batch size
u... |
def _update_params(self, constants):
for k, v in constants.items():
self.params[k]['value'] *= v
influence = self._calculate_influence(self.params['infl']['value'])
return influence * self.params['lr']['value'] | Update params and return new influence. |
def _create_batches(self, X, batch_size, shuffle_data=True):
if shuffle_data:
X = shuffle(X)
if batch_size > X.shape[0]:
batch_size = X.shape[0]
max_x = int(np.ceil(X.shape[0] / batch_size))
X = np.resize(X, (max_x, batch_size, X.shape[-1]))
re... | Create batches out of a sequence of data.
This function will append zeros to the end of your data to ensure that
all batches are even-sized. These are masked out during training. |
def _propagate(self, x, influences, **kwargs):
activation, difference_x = self.forward(x)
update = self.backward(difference_x, influences, activation)
# If batch size is 1 we can leave out the call to mean.
if update.shape[0] == 1:
self.weights += update[0]
e... | Propagate a single batch of examples through the network. |
def backward(self, diff_x, influences, activations, **kwargs):
bmu = self._get_bmu(activations)
influence = influences[bmu]
update = np.multiply(diff_x, influence)
return update | Backward pass through the network, including update.
Parameters
----------
diff_x : numpy array
A matrix containing the differences between the input and neurons.
influences : numpy array
A matrix containing the influence each neuron has on each
other... |
def _check_input(self, X):
if np.ndim(X) == 1:
X = np.reshape(X, (1, -1))
if X.ndim != 2:
raise ValueError("Your data is not a 2D matrix. "
"Actual size: {0}".format(X.shape))
if X.shape[1] != self.data_dimensionality:
r... | Check the input for validity.
Ensures that the input data, X, is a 2-dimensional matrix, and that
the second dimension of this matrix has the same dimensionality as
the weight matrix. |
def transform(self, X, batch_size=100, show_progressbar=False):
X = self._check_input(X)
batched = self._create_batches(X, batch_size, shuffle_data=False)
activations = []
prev = self._init_prev(batched)
for x in tqdm(batched, disable=not show_progressbar):
... | Transform input to a distance matrix by measuring the L2 distance.
Parameters
----------
X : numpy array.
The input data.
batch_size : int, optional, default 100
The batch size to use in transformation. This may affect the
transformation in stateful, ... |
def predict(self, X, batch_size=1, show_progressbar=False):
dist = self.transform(X, batch_size, show_progressbar)
res = dist.__getattribute__(self.argfunc)(1)
return res | Predict the BMU for each input data.
Parameters
----------
X : numpy array.
The input data.
batch_size : int, optional, default 100
The batch size to use in prediction. This may affect prediction
in stateful, i.e. sequential SOMs.
show_progres... |
def quantization_error(self, X, batch_size=1):
dist = self.transform(X, batch_size)
res = dist.__getattribute__(self.valfunc)(1)
return res | Calculate the quantization error.
Find the the minimum euclidean distance between the units and
some input.
Parameters
----------
X : numpy array.
The input data.
batch_size : int
The batch size to use for processing.
Returns
---... |
def load(cls, path):
data = json.load(open(path))
weights = data['weights']
weights = np.asarray(weights, dtype=np.float64)
s = cls(data['num_neurons'],
data['data_dimensionality'],
data['params']['lr']['orig'],
neighborhood=data... | Load a SOM from a JSON file saved with this package.
Parameters
----------
path : str
The path to the JSON file.
Returns
-------
s : cls
A som of the specified class. |
def save(self, path):
to_save = {}
for x in self.param_names:
attr = self.__getattribute__(x)
if type(attr) == np.ndarray:
attr = [[float(x) for x in row] for row in attr]
elif isinstance(attr, types.FunctionType):
attr = attr.... | Save a SOM to a JSON file. |
def get_authversion(job_args):
_version = job_args.get('os_auth_version')
for version, variants in AUTH_VERSION_MAP.items():
if _version in variants:
authversion = job_args['os_auth_version'] = version
return authversion
else:
raise exceptions.AuthenticationProb... | Get or infer the auth version.
Based on the information found in the *AUTH_VERSION_MAP* the authentication
version will be set to a correct value as determined by the
**os_auth_version** parameter as found in the `job_args`.
:param job_args: ``dict``
:returns: ``str`` |
def get_service_url(region, endpoint_list, lookup):
for endpoint in endpoint_list:
region_get = endpoint.get('region', '')
if region.lower() == region_get.lower():
return http.parse_url(url=endpoint.get(lookup))
else:
raise exceptions.AuthenticationProblem(
... | Lookup a service URL from the *endpoint_list*.
:param region: ``str``
:param endpoint_list: ``list``
:param lookup: ``str``
:return: ``object`` |
def get_headers(self):
try:
return {
'X-Auth-User': self.job_args['os_user'],
'X-Auth-Key': self.job_args['os_apikey']
}
except KeyError as exp:
raise exceptions.AuthenticationProblem(
'Missing Credentials. Err... | Setup headers for authentication request. |
def parse_auth_response(auth_response):
auth_dict = dict()
LOG.debug('Authentication Headers %s', auth_response.headers)
try:
auth_dict['os_token'] = auth_response.headers['x-auth-token']
auth_dict['storage_url'] = urlparse.urlparse(
auth_respons... | Parse the auth response and return the tenant, token, and username.
:param auth_response: the full object returned from an auth call
:returns: ``dict`` |
def auth_request(self, url, headers, body):
return self.req.post(url, headers, body=body) | Perform auth request for token. |
def parse_region(self):
try:
auth_url = self.job_args['os_auth_url']
if 'tokens' not in auth_url:
if not auth_url.endswith('/'):
auth_url = '%s/' % auth_url
auth_url = urlparse.urljoin(auth_url, 'tokens')
return au... | Pull region/auth url information from context. |
def execute():
if len(sys.argv) <= 1:
raise SystemExit(
'No Arguments provided. use [--help] for more information.'
)
# Capture user arguments
_args = arguments.ArgumentParserator(
arguments_dict=turbolift.ARGUMENTS,
env_name='TURBO',
epilog=turboli... | This is the run section of the application Turbolift. |
def write(self, log_file, msg):
try:
with open(log_file, 'a') as LogFile:
LogFile.write(msg + os.linesep)
except:
raise Exception('Error Configuring PyLogger.TextStorage Class.')
return os.path.isfile(log_file) | Append message to .log file |
def read(self, log_file):
if os.path.isdir(os.path.dirname(log_file)) and os.path.isfile(log_file):
with open(log_file, 'r') as LogFile:
data = LogFile.readlines()
data = "".join(line for line in data)
else:
data = ''
return data | Read messages from .log file |
def fit(self, X):
if X.ndim > 2:
X = X.reshape((np.prod(X.shape[:-1]), X.shape[-1]))
self.mean = X.mean(0)
self.std = X.std(0)
self.is_fit = True
return self | Fit the scaler based on some data.
Takes the columnwise mean and standard deviation of the entire input
array.
If the array has more than 2 dimensions, it is flattened.
Parameters
----------
X : numpy array
Returns
-------
scaled : numpy array
... |
def transform(self, X):
if not self.is_fit:
raise ValueError("The scaler has not been fit yet.")
return (X-self.mean) / (self.std + 10e-7) | Transform your data to zero mean unit variance. |
def retry(ExceptionToCheck, tries=3, delay=1, backoff=1):
def deco_retry(f):
@functools.wraps(f)
def f_retry(*args, **kwargs):
mtries, mdelay = tries, delay
while mtries > 1:
try:
return f(*args, **kwargs)
except Except... | Retry calling the decorated function using an exponential backoff.
http://www.saltycrane.com/blog/2009/11/trying-out-retry-decorator-python/
original from: http://wiki.python.org/moin/PythonDecoratorLibrary#Retry
:param ExceptionToCheck: the exception to check. may be a tuple of
... |
def stupid_hack(most=10, wait=None):
# Stupid Hack For Public Cloud so it is not overwhelmed with API requests.
if wait is not None:
time.sleep(wait)
else:
time.sleep(random.randrange(1, most)) | Return a random time between 1 - 10 Seconds. |
def time_stamp():
# Time constants
fmt = '%Y-%m-%dT%H:%M:%S.%f'
date = datetime.datetime
date_delta = datetime.timedelta
now = datetime.datetime.utcnow()
return fmt, date, date_delta, now | Setup time functions
:returns: ``tuple`` |
def unique_list_dicts(dlist, key):
return list(dict((val[key], val) for val in dlist).values()) | Return a list of dictionaries which are sorted for only unique entries.
:param dlist:
:param key:
:return list: |
def quoter(obj):
try:
try:
return urllib.quote(obj)
except AttributeError:
return urllib.parse.quote(obj)
except KeyError:
return obj | Return a Quoted URL.
The quote function will return a URL encoded string. If there is an
exception in the job which results in a "KeyError" the original
string will be returned as it will be assumed to already be URL
encoded.
:param obj: ``basestring``
:return: ``str`` |
def start(self):
LOG.info('Clone warm up...')
# Create the target args
self._target_auth()
last_list_obj = None
while True:
self.indicator_options['msg'] = 'Gathering object list'
with indicator.Spinner(**self.indicator_options):
... | Clone objects from one container to another.
This method was built to clone a container between data-centers while
using the same credentials. The method assumes that an authentication
token will be valid within the two data centers. |
def authenticate(job_args):
# Load any authentication plugins as needed
job_args = utils.check_auth_plugin(job_args)
# Set the auth version
auth_version = utils.get_authversion(job_args=job_args)
# Define the base headers that are used in all authentications
auth_headers = {
'Con... | Authentication For Openstack API.
Pulls the full Openstack Service Catalog Credentials are the Users API
Username and Key/Password.
Set a DC Endpoint and Authentication URL for the OpenStack environment |
def _config(self, **kargs):
for key, value in kargs.items():
setattr(self, key, value) | ReConfigure Package |
def getConfig(self, key):
if hasattr(self, key):
return getattr(self, key)
else:
return False | Get a Config Value |
def addFilter(self, filter):
self.FILTERS.append(filter)
return "FILTER#{}".format(len(self.FILTERS) - 1) | Register Custom Filter |
def addAction(self, action):
self.ACTIONS.append(action)
return "ACTION#{}".format(len(self.ACTIONS) - 1) | Register Custom Action |
def removeFilter(self, filter):
filter = filter.split('#')
del self.FILTERS[int(filter[1])]
return True | Remove Registered Filter |
def removeAction(self, action):
action = action.split('#')
del self.ACTIONS[int(action[1])]
return True | Remove Registered Action |
def info(self, msg):
self._execActions('info', msg)
msg = self._execFilters('info', msg)
self._processMsg('info', msg)
self._sendMsg('info', msg) | Log Info Messages |
def warning(self, msg):
self._execActions('warning', msg)
msg = self._execFilters('warning', msg)
self._processMsg('warning', msg)
self._sendMsg('warning', msg) | Log Warning Messages |
def error(self, msg):
self._execActions('error', msg)
msg = self._execFilters('error', msg)
self._processMsg('error', msg)
self._sendMsg('error', msg) | Log Error Messages |
def critical(self, msg):
self._execActions('critical', msg)
msg = self._execFilters('critical', msg)
self._processMsg('critical', msg)
self._sendMsg('critical', msg) | Log Critical Messages |
def log(self, msg):
self._execActions('log', msg)
msg = self._execFilters('log', msg)
self._processMsg('log', msg)
self._sendMsg('log', msg) | Log Normal Messages |
def _processMsg(self, type, msg):
now = datetime.datetime.now()
# Check If Path not provided
if self.LOG_FILE_PATH == '':
self.LOG_FILE_PATH = os.path.dirname(os.path.abspath(__file__)) + '/'
# Build absolute Path
log_file = self.LOG_FILE_PATH + now.strftim... | Process Debug Messages |
def _configMailer(self):
self._MAILER = Mailer(self.MAILER_HOST, self.MAILER_PORT)
self._MAILER.login(self.MAILER_USER, self.MAILER_PWD) | Config Mailer Class |
def _sendMsg(self, type, msg):
if self.ALERT_STATUS and type in self.ALERT_TYPES:
self._configMailer()
self._MAILER.send(self.MAILER_FROM, self.ALERT_EMAIL, self.ALERT_SUBJECT, msg) | Send Alert Message To Emails |
def _execFilters(self, type, msg):
for filter in self.FILTERS:
msg = filter(type, msg)
return msg | Execute Registered Filters |
def _execActions(self, type, msg):
for action in self.ACTIONS:
action(type, msg) | Execute Registered Actions |
def check_basestring(item):
try:
return isinstance(item, (basestring, unicode))
except NameError:
return isinstance(item, str) | Return ``bol`` on string check item.
:param item: Item to check if its a string
:type item: ``str``
:returns: ``bol`` |
def predict_distance(self, X, batch_size=1, show_progressbar=False):
X = self._check_input(X)
X_shape = reduce(np.multiply, X.shape[:-1], 1)
batched = self._create_batches(X, batch_size, shuffle_data=False)
activations = []
activation = self._init_prev(batched)
... | Predict distances to some input data. |
def generate(self, num_to_generate, starting_place):
res = []
activ = starting_place[None, :]
index = activ.__getattribute__(self.argfunc)(1)
item = self.weights[index]
for x in range(num_to_generate):
activ = self.forward(item, prev_activation=activ)[0]
... | Generate data based on some initial position. |
def forward(self, x, **kwargs):
prev = kwargs['prev_activation']
# Differences is the components of the weights subtracted from
# the weight vector.
distance_x, diff_x = self.distance_function(x, self.weights)
distance_y, diff_y = self.distance_function(prev, self.conte... | Perform a forward pass through the network.
The forward pass in recursive som is based on a combination between
the activation in the last time-step and the current time-step.
Parameters
----------
x : numpy array
The input data.
prev_activation : numpy arra... |
def load(cls, path):
data = json.load(open(path))
weights = data['weights']
weights = np.asarray(weights, dtype=np.float64)
try:
context_weights = data['context_weights']
context_weights = np.asarray(context_weights,
... | Load a recursive SOM from a JSON file.
You can use this function to load weights of other SOMs.
If there are no context weights, they will be set to 0.
Parameters
----------
path : str
The path to the JSON file.
Returns
-------
s : cls
... |
def backward(self, diff_x, influences, activations, **kwargs):
diff_y = kwargs['diff_y']
bmu = self._get_bmu(activations)
influence = influences[bmu]
# Update
x_update = np.multiply(diff_x, influence)
y_update = np.multiply(diff_y, influence)
return x_u... | Backward pass through the network, including update.
Parameters
----------
diff_x : numpy array
A matrix containing the differences between the input and neurons.
influences : numpy array
A matrix containing the influence each neuron has on each
other... |
def start(self):
LOG.info('Listing options...')
with indicator.Spinner(**self.indicator_options):
objects_list = self._list_contents()
if not objects_list:
return
if isinstance(objects_list[0], dict):
filter_dlo = self.job_args.get('f... | Return a list of objects from the API for a container. |
def _return_base_data(self, url, container, container_object=None,
container_headers=None, object_headers=None):
headers = self.job_args['base_headers']
headers.update({'X-Auth-Token': self.job_args['os_token']})
_container_uri = url.geturl().rstrip('/')
... | Return headers and a parsed url.
:param url:
:param container:
:param container_object:
:param container_headers:
:return: ``tuple`` |
def _chunk_putter(self, uri, open_file, headers=None):
count = 0
dynamic_hash = hashlib.sha256(self.job_args.get('container'))
dynamic_hash = dynamic_hash.hexdigest()
while True:
# Read in a chunk of an open file
file_object = open_file.read(self.job_args... | Make many PUT request for a single chunked object.
Objects that are processed by this method have a SHA256 hash appended
to the name as well as a count for object indexing which starts at 0.
To make a PUT request pass, ``url``
:param uri: ``str``
:param open_file: ``object``
... |
def _putter(self, uri, headers, local_object=None):
if not local_object:
return self.http.put(url=uri, headers=headers)
with open(local_object, 'rb') as f_open:
large_object_size = self.job_args.get('large_object_size')
if not large_object_size:
... | Place object into the container.
:param uri:
:param headers:
:param local_object: |
def _getter(self, uri, headers, local_object):
if self.job_args.get('sync'):
sync = self._sync_check(
uri=uri,
headers=headers,
local_object=local_object
)
if not sync:
return None
# perform Ob... | Perform HEAD request on a specified object in the container.
:param uri: ``str``
:param headers: ``dict`` |
def _deleter(self, uri, headers):
# perform Object HEAD request
resp = self.http.delete(url=uri, headers=headers)
self._resp_exception(resp=resp)
return resp | Perform HEAD request on a specified object in the container.
:param uri: ``str``
:param headers: ``dict`` |
def _header_getter(self, uri, headers):
# perform Object HEAD request
resp = self.http.head(url=uri, headers=headers)
self._resp_exception(resp=resp)
return resp | Perform HEAD request on a specified object in the container.
:param uri: ``str``
:param headers: ``dict`` |
def _header_poster(self, uri, headers):
resp = self.http.post(url=uri, body=None, headers=headers)
self._resp_exception(resp=resp)
return resp | POST Headers on a specified object in the container.
:param uri: ``str``
:param headers: ``dict`` |
def _obj_index(self, uri, base_path, marked_path, headers, spr=False):
object_list = list()
l_obj = None
container_uri = uri.geturl()
while True:
marked_uri = urlparse.urljoin(container_uri, marked_path)
resp = self.http.get(url=marked_uri, headers=heade... | Return an index of objects from within the container.
:param uri:
:param base_path:
:param marked_path:
:param headers:
:param spr: "single page return" Limit the returned data to one page
:type spr: ``bol``
:return: |
def _list_getter(self, uri, headers, last_obj=None, spr=False):
# Quote the file path.
base_path = marked_path = ('%s?limit=10000&format=json' % uri.path)
if last_obj:
marked_path = self._last_marker(
base_path=base_path,
last_object=cloud_u... | Get a list of all objects in a container.
:param uri:
:param headers:
:return list:
:param spr: "single page return" Limit the returned data to one page
:type spr: ``bol`` |
def list_items(self, url, container=None, last_obj=None, spr=False):
headers, container_uri = self._return_base_data(
url=url,
container=container
)
if container:
resp = self._header_getter(uri=container_uri, headers=headers)
if resp.sta... | Builds a long list of objects found in a container.
NOTE: This could be millions of Objects.
:param url:
:param container:
:param last_obj:
:param spr: "single page return" Limit the returned data to one page
:type spr: ``bol``
:return None | list: |
def update_object(self, url, container, container_object, object_headers,
container_headers):
headers, container_uri = self._return_base_data(
url=url,
container=container,
container_object=container_object,
container_headers=contai... | Update an existing object in a swift container.
This method will place new headers on an existing object or container.
:param url:
:param container:
:param container_object: |
def container_cdn_command(self, url, container, container_object,
cdn_headers):
headers, container_uri = self._return_base_data(
url=url,
container=container,
container_object=container_object,
object_headers=cdn_headers
... | Command your CDN enabled Container.
:param url:
:param container: |
def put_container(self, url, container, container_headers=None):
headers, container_uri = self._return_base_data(
url=url,
container=container,
container_headers=container_headers
)
resp = self._header_getter(
uri=container_uri,
... | Create a container if it is not Found.
:param url:
:param container: |
def put_object(self, url, container, container_object, local_object,
object_headers, meta=None):
headers, container_uri = self._return_base_data(
url=url,
container=container,
container_object=container_object,
container_headers=object... | This is the Sync method which uploads files to the swift repository
if they are not already found. If a file "name" is found locally and
in the swift repository an MD5 comparison is done between the two
files. If the MD5 is miss-matched the local file is uploaded to the
repository. If c... |
def get_items(self, url, container, container_object, local_object):
headers, container_uri = self._return_base_data(
url=url,
container=container,
container_object=container_object
)
return self._getter(
uri=container_uri,
h... | Get an objects from a container.
:param url:
:param container: |
def delete_items(self, url, container, container_object=None):
headers, container_uri = self._return_base_data(
url=url,
container=container,
container_object=container_object
)
return self._deleter(uri=container_uri, headers=headers) | Deletes an objects in a container.
:param url:
:param container: |
def _get_bmu(self, activations):
# If the neural gas is a recursive neural gas, we need reverse argsort.
if self.argfunc == 'argmax':
activations = -activations
sort = np.argsort(activations, 1)
return sort.argsort() | Get indices of bmus, sorted by their distance from input. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.