Various utilities that don’t fit anwhere else.

class allennlp.common.util.ScatterableList[source]

Bases: list

A normal list, but one that should be scattered like a tensor.

classmethod from_pointer_tensor(pointers: torch.LongTensor) → list[source]

The inverse of to_pointer_tensor except that a plain list is returned. Typically this will be called on a single chunk of the scattered tensor.

pointers : torch.LongTensor, required.

A tensor of shape (list_length,).

to_pointer_tensor() → torch.LongTensor[source]

Converts the elements to pointers, casts them to int64 and then returns them in a tensor. This cast is important as id gives back unsigned integers while torch.LongTensor is signed.


allennlp.common.util.add_noise_to_dict_values(dictionary: typing.Dict[A, float], noise_param: float) → typing.Dict[A, float][source]

Returns a new dictionary with noise added to every key in dictionary. The noise is uniformly distributed within noise_param percent of the value for every value in the dictionary.

allennlp.common.util.dump_metrics(file_path: str, metrics: typing.Dict[str, typing.Any], log: bool = False) → None[source]
allennlp.common.util.ensure_list(iterable: typing.Iterable[A]) → typing.List[A][source]

An Iterable may be a list or a generator. This ensures we get a list without making an unnecessary copy.

allennlp.common.util.get_frozen_and_tunable_parameter_names(model: torch.nn.modules.module.Module) → typing.List[source]
allennlp.common.util.get_spacy_model(spacy_model_name: str, pos_tags: bool, parse: bool, ner: bool) → spacy.language.Language[source]

In order to avoid loading spacy models a whole bunch of times, we’ll save references to them, keyed by the options we used to create the spacy model, so any particular configuration only gets loaded once.

allennlp.common.util.gpu_memory_mb() → typing.Dict[int, int][source]

Get the current GPU memory usage. Based on

``Dict[int, int]``

Keys are device ids as integers. Values are memory usage as integers in MB. Returns an empty dict if GPUs are not available.

allennlp.common.util.group_by_count(iterable: typing.List[typing.Any], count: int, default_value: typing.Any) → typing.List[typing.List[typing.Any]][source]

Takes a list and groups it into sublists of size count, using default_value to pad the list at the end if the list is not divisable by count.

For example: >>> group_by_count([1, 2, 3, 4, 5, 6, 7], 3, 0) [[1, 2, 3], [4, 5, 6], [7, 0, 0]]

This is a short method, but it’s complicated and hard to remember as a one-liner, so we just make a function out of it.

allennlp.common.util.import_submodules(package_name: str) → None[source]

Import all submodules under the given package. Primarily useful so that people using AllenNLP as a library can specify their own custom packages and have their custom classes get loaded and registered.

allennlp.common.util.is_lazy(iterable: typing.Iterable[A]) → bool[source]

Checks if the given iterable is lazy, which here just means it’s not a list.

allennlp.common.util.lazy_groups_of(iterator: typing.Iterator[A], group_size: int) → typing.Iterator[typing.List[A]][source]

Takes an iterator and batches the invididual instances into lists of the specified size. The last list may be smaller if there are instances left over.

allennlp.common.util.namespace_match(pattern: str, namespace: str)[source]

Matches a namespace pattern against a namespace string. For example, *tags matches passage_tags and question_tags and tokens matches tokens but not stemmed_tokens.

allennlp.common.util.pad_sequence_to_length(sequence: typing.List, desired_length: int, default_value: typing.Callable[typing.Any] = <function <lambda>>, padding_on_right: bool = True) → typing.List[source]

Take a list of objects and pads it to the desired length, returning the padded list. The original list is not modified.

sequence : List

A list of objects to be padded.

desired_length : int

Maximum length of each sequence. Longer sequences are truncated to this length, and shorter ones are padded to it.

default_value: Callable, default=lambda: 0

Callable that outputs a default value (of any type) to use as padding values. This is a lambda to avoid using the same object when the default value is more complex, like a list.

padding_on_right : bool, default=True

When we add padding tokens (or truncate the sequence), should we do it on the right or the left?

padded_sequence : List
allennlp.common.util.parse_cuda_device(cuda_device: typing.Union[str, int, typing.List[int]]) → typing.Union[int, typing.List[int]][source]

Disambiguates single GPU and multiple GPU settings for cuda_device param.

allennlp.common.util.peak_memory_mb() → float[source]

Get peak memory usage for this process, as measured by max-resident-set size:

Only works on OSX and Linux, returns 0.0 otherwise.

allennlp.common.util.prepare_environment(params: allennlp.common.params.Params)[source]

Sets random seeds for reproducible experiments. This may not work as expected if you use this from within a python project in which you have already imported Pytorch. If you use the scripts/ entry point to training models with this library, your experiments should be reasonably reproducible. If you are using this from your own project, you will want to call this function before importing Pytorch. Complete determinism is very difficult to achieve with libraries doing optimized linear algebra due to massively parallel execution, which is exacerbated by using GPUs.

params: Params object or dict, required.

A Params object or dict holding the json parameters.

allennlp.common.util.prepare_global_logging(serialization_dir: str, file_friendly_logging: bool) → None[source]

This function configures 3 global logging attributes - streaming stdout and stderr to a file as well as the terminal, setting the formatting for the python logging library and setting the interval frequency for the Tqdm progress bar.

Note that this function does not set the logging level, which is set in allennlp/

serializezation_dir : str, required.

The directory to stream logs to.

file_friendly_logging : bool, required.

Whether logs should clean the output to prevent carridge returns (used to update progress bars on a single terminal line). This option is typically only used if you are running in an environment without a terminal.

allennlp.common.util.sanitize(x: typing.Any) → typing.Any[source]

Sanitize turns PyTorch and Numpy types into basic Python types so they can be serialized into JSON.

allennlp.common.util.scatter(inputs, target_gpus, dim=0)[source]

Slices tensors and ScatterableLists into approximately equal chunks and distributes them across given GPUs. Duplicates references to objects that are not tensors or ScatterableLists.

Adapted from scatter at:

Please see the LICENSE and NOTICE files as well:

allennlp.common.util.scatter_kwargs(inputs, kwargs, target_gpus, dim=0)[source]

Scatter with support for kwargs dictionary.

Adapted from scatter_kwargs at:

Please see the LICENSE and NOTICE files as well: