alien package

Subpackages

Submodules

alien.classes module

alien.classes.parent_locals()[source]
alien.classes.final(fn)[source]

Decorates a method, to prohibit subclasses from overriding it (unless the overriding method is decorated with @override). This prohibition is actually enforced (during subclass creation), unlike with python’s typing.final decorator, which is only used by external type checkers. Decorating with this version of final does also apply typing.final, so no need to use both.

alien.classes.override(fn)[source]

Decorates a method to allow it to override @final methods.

alien.classes.init_subclass(subclass, superclass, **kwargs)[source]
alien.classes.abstract_group(id, n=1)[source]

Decorates a group of methods so that at least n (typically 1) of them must be overriden by a subclass. Each group is determined by its id, which must be a hashable key.

alien.decorators module

alien.decorators.default_decorator(dec)[source]

Enhances a parametrized decorator by giving it the following functionality:

If the decorator is applied directly to a function, without any parameters specified, then it decorates the function in the usual way, with default values for the parameters.

If the decorator is passed parameters, then it returns a new decorator (with the given parameter values), able to accept a function to decorate.

In other words, if we have

@default_decorator decorator(fn, a=1, b=2, …):

…

then

@decorator def fn(…):

…

gives the usual behaviour for a decorator, but

@decorator(3, b=4) def fn(…):

…

gives us the function

decorator(fn, a=3, b=4)

alien.decorators.flatten_batch(*args, **kwargs)[source]
alien.decorators.get_args(other_fn=None, exclude={})[source]
alien.decorators.do_normalize(X, bdim=-1, euclidean=False)[source]
alien.decorators.sig_append(fn, name, kind=_ParameterKind.KEYWORD_ONLY, default, annotation)[source]

Appends a new parameter to the signature of fn.

alien.decorators.normalize_args(*args, **kwargs)[source]
alien.decorators.get_Xy(fn)[source]

This decorator ensures that a method gets appropriate X and y values. A method decorated in this way can assume that its X (or x) and y arguments have nontrivial values, drawn from an appropriate source.

If both X (or x) and y are passed in (Nones don’t count), then all’s well. If neither are passed in, then this wrapper looks for them in self.X and self.y.

If an X value can be found, but no y value, this wrapper treats X as combined data, and tries to split it into data.X and data.y. Failing that, it tries to take X = data[:,:-1] and y = data[:,-1].

If none of this can be accomplished, this wrapper raises a ValueError.

class alien.decorators.RecursionContext(fn, error=None)[source]

Bases: object

Raises an error if fn is called recursively.

alien.decorators.no_recursion(*args, **kwargs)[source]
alien.decorators.get_defaults_from_self(fn)[source]

Decorator that enhances a method so that if arguments are not passed in, then it will look for argument values in self.’argname’

This functionality is invoked on arguments with default values None or NEED (see below; must include NEED from this module to use this). In the latter case, an exception is raised if an argument is neither passed directly nor can it be found at self.’argname’

alien.decorators.NEED()[source]

alien.stats module

alien.stats.multiply_std_dev(ensemble, multiple: float)[source]

Modifies an ensemble to change its standard deviation by a factor of ‘multiple’.

Parameters:

ensemble – ensembles are over the last dimension only.

alien.stats.augment_ensemble(preds, N: int, multiple=1.0, rng=None)[source]

Augments ensemble predictions to an ensemble of size N per variable.

Extra observations are generated from a multivariate normal distribution to have the same covariances (within the last batch dimension) as existing observations

Parameters:

multiple – returns an ensemble with ‘multiple’ times the covariance of the original.

alien.stats.covariance_from_ensemble(preds, weights=None)[source]
alien.stats.std_dev_from_ensemble(preds, weights=None)[source]
alien.stats.ensemble_from_covariance(mean, cov, ensemble_size, rng=None, random_seed=None)[source]
alien.stats.similarity_gaussian(X, relevant_features=None, normalize=True, scale=1.0)[source]

Computes a similarity matrix from a Gaussian function of distances, as follows:

Restricts X to only look at ‘relevant_features’.

If ‘normalize’ is True, rescales the input to have standard deviation 1 in each feature, then rescales by another factor of sqrt(X.shape[-1]).

Then the distance matrix is put into a Gaussian of std dev equal to ‘scale’.

alien.stats.similarity_exp(X, relevant_features=None, normalize=True, scale=1.0)[source]
alien.stats.similarity_cosine(X, relevant_indices=None, normalize=True)[source]
alien.stats.covariance_from_similarity(similarity, variance)[source]

Given a similarity matrix, and a vector of variances, returns a covariance matrix, using the similarity matrix as correlations.

alien.stats.joint_entropy(X)[source]

Not regularized. Is liable to underestimate the entropy, i.e., samples may actually be less correlated than they appear from this calculation, due to the limited size of the ensemble.

Parameters:

X – ensemble of class predictions, of shape … x batch_size x ensemble_size

alien.stats.joint_entropy_regularized(X, n_classes=None, rng=None, random_seed=None)[source]
Parameters:

  • X – ensemble of class predictions, of shape … x batch_size x ensemble_size

  • n_classes – to avoid computing it, you can pass in the number of classes.

alien.stats.group_sizes(size, group_size)[source]
alien.stats.group_edges(size, group_size)[source]

alien.utils module

alien.utils.seed_all(seed)[source]
alien.utils.as_list(x)[source]
alien.utils.match(target, pool, fn=<function <lambda>>)[source]
alien.utils.isint(i)[source]

Check whether i can be cast to an integer

Parameters:

i (_type_) – _description_

Returns:

_description_

Return type:

_type_

alien.utils.dict_get(d, *keys, _pop=False, **kwargs)[source]
alien.utils.dict_pop(d, *keys, **kwargs)[source]
alien.utils.std_keys(d, *groups, **defaults)[source]

Standardizes keys in a dictionary. Each positional arg, g, apart from the first one (d) should be an iterable of keys. Then d is processed so that all keys in g are replaced with the first key in g. If more than one key in g is in d, then all keys in g except the first (in d) will be removed.

alien.utils.update_copy(d1, d2=None, **kwargs)[source]
alien.utils.any_get(s, elements, default='f6b1c433450cb749f45844dd60ab3b27')[source]
alien.utils.any_pop(s, keys, default='f6b1c433450cb749f45844dd60ab3b27')[source]
alien.utils.alias(argname)[source]

Aliases an argument

alien.utils.multisearch(a, query, one_to_one=True)[source]

Finds the indices of multiple query values. Searches over the first axis of ‘a’, with further axes corresponding to ‘feature space’, i.e., the shape of the search terms. Return type depends on one_to_one.

Parameters:

  • a – the array to search

  • query – an array of query values

One_to_one:

if True, validates that each search term appears exactly once, and returns a corresponding array of indices. If False, returns a 2D array with 2nd axis of length 2, with each pair of the form (query_index, array_index)

alien.utils.ufunc(f)[source]
alien.utils.shift_seed(seed, shift)[source]
alien.utils.ranges(*args)[source]

Takes arguments ([start,] stop, step). Returns a list of pairs consisting of (start_i, stop_i), which together divide up range(start, stop) into chunks of size step (plus final chunk).

class alien.utils.chunks(seq, *args)[source]

Bases: object

Takes arguments (seq, [[start,] stop,] step). Returns an iterator which iterates over chunks of seq, of size step.

alien.utils.frac_enum(seq, start_zero=True)[source]

Much like enumerate, returns an iterator yielding ordered pairs (t, x) where x is an element of seq and t is the fraction of the way through the sequence. if start_zero==True, the fraction starts at 0 and ends just short of 1. Otherwise, starts just over 0 and ends at 1.

alien.utils.add_slice(s: slice, i: int) → slice[source]

Returns a ‘shifted’ slice slice(s.start + i, s.stop + i, s.step), unless s is None, in which case it returns a slice representing the whole window, minus a bit at the start (if i > 0) or the end (if i < 0).

alien.utils.reshape(x, shape, index=None)[source]
alien.utils.flatten(a, dims)[source]
alien.utils.diagonal(x, dims=2, degree=1, bdim=0)[source]
alien.utils.concatenate(*args)[source]

Concatenates a series of datasets, or one of the supported datatypes, along axis 0 (the samples axis)

alien.utils.join(*args, make_ds=False)[source]

Concatenates a series of datasets along axis 1 (the first feature axis). Datasets must have same length, and if they are numpy or torch arrays, they must have the same shape in dimensions >= 2.

alien.utils.is_iterable(x)[source]
alien.utils.as_numpy(data)[source]
alien.utils.is_one(x)[source]
alien.utils.zip_dict(*dicts)[source]

Similar behavior of zip(*) for dictionaries. Assumes that all dicts have the same keys. >>> zip_dict({‘a’: 1}, {‘a’: 2}) {‘a’: (1, 2)}

Returns:

_description_

Return type:

_type_

alien.utils.axes_except(X, non_axes)[source]
alien.utils.sum_except(X, non_axes)[source]
alien.utils.no_default()[source]
class alien.utils.SelfDict(*args, default=<function no_default>, **kwargs)[source]

Bases: dict

Subclass of dict class which allows you to refer to, eg., d[‘attr’] as d.attr and vice versa.

You can also index with lists, where d[[‘a’, ‘b’]] == {‘a’: d[‘a’], ‘b’: d[‘b’]} Similarly with pop()

pop(k[, d]) → v, remove specified key and return the corresponding value.[source]

If key is not found, default is returned if given, otherwise KeyError is raised

clear() → None.  Remove all items from D.
copy() → a shallow copy of D
fromkeys(value=None, /)

Create a new dictionary with keys from iterable and values set to value.

get(key, default=None, /)

Return the value for key if key is in the dictionary, else default.

items() → a set-like object providing a view on D's items
keys() → a set-like object providing a view on D's keys
popitem()

Remove and return a (key, value) pair as a 2-tuple.

Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty.

setdefault(key, default=None, /)

Insert key with a value of default if key is not in the dictionary.

Return the value for key if key is in the dictionary, else default.

update([E, ]**F) → None.  Update D from dict/iterable E and F.

If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

values() → an object providing a view on D's values
class alien.utils.CachedDict(get, *init_keys, **d2)[source]

Bases: object

alien.utils.dot_last(a, b)[source]

Module contents