typed_list – Typed List

Note

This has been added in release 0.7.

Note

This works, but is not well integrated with the rest of Aesara. If speed is important, it is probably better to pad to a dense tensor.

This is a type that represents a list in Aesara. All elements must have the same Aesara type. Here is an example:

>>> import aesara.typed_list
>>> tl = aesara.typed_list.TypedListType(aesara.tensor.fvector)()
>>> v = aesara.tensor.fvector()
>>> o = aesara.typed_list.append(tl, v)
>>> f = aesara.function([tl, v], o)
>>> f([[1, 2, 3], [4, 5]], [2])
[array([ 1.,  2.,  3.], dtype=float32), array([ 4.,  5.], dtype=float32), array([ 2.], dtype=float32)]

A second example with Scan. Scan doesn’t yet have direct support of TypedList, so you can only use it as non_sequences (not in sequences or as outputs):

>>> import aesara.typed_list
>>> a = aesara.typed_list.TypedListType(aesara.tensor.fvector)()
>>> l = aesara.typed_list.length(a)
>>> s, _ = aesara.scan(fn=lambda i, tl: tl[i].sum(),
...                    non_sequences=[a],
...                    sequences=[aesara.tensor.arange(l, dtype='int64')])
>>> f = aesara.function([a], s)
>>> f([[1, 2, 3], [4, 5]])
array([ 6.,  9.], dtype=float32)

class aesara.typed_list.basic.Append(inplace=False)

c_code_cache_version()

Return a tuple of integers indicating the version of this Op.

An empty tuple indicates an “unversioned” Op that will not be cached between processes.

The cache mechanism may erase cached modules that have been superseded by newer versions. See ModuleCache for details.

See also

c_code_cache_version_apply

make_node(x, toAppend)

Construct an Apply node that represent the application of this operation to the given inputs.

This must be implemented by sub-classes.

Returns:node – The constructed Apply node. Return type:Apply

perform(node, inputs, outputs)

Calculate the function on the inputs and put the variables in the output storage.

Parameters:

• node – The symbolic Apply node that represents this computation.
• inputs – Immutable sequence of non-symbolic/numeric inputs. These are the values of each Variable in node.inputs.
• output_storage – List of mutable single-element lists (do not change the length of these lists). Each sub-list corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sub-lists.
• params – A tuple containing the values of each entry in Op.__props__.

Notes

The output_storage list might contain data. If an element of output_storage is not None, it has to be of the right type, for instance, for a TensorVariable, it has to be a NumPy ndarray with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such pre-set values were produced by a previous call to this Op.perform(); they could’ve been allocated by another Op’s perform method. An Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.

class aesara.typed_list.basic.Count

make_node(x, elem)

Construct an Apply node that represent the application of this operation to the given inputs.

This must be implemented by sub-classes.

Returns:node – The constructed Apply node. Return type:Apply

perform(node, inputs, outputs)

Inelegant workaround for ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all() being thrown when trying to remove a matrix from a matrices list

class aesara.typed_list.basic.Extend(inplace=False)

make_node(x, toAppend)

Construct an Apply node that represent the application of this operation to the given inputs.

This must be implemented by sub-classes.

Returns:node – The constructed Apply node. Return type:Apply

perform(node, inputs, outputs)

Calculate the function on the inputs and put the variables in the output storage.

Parameters:

• node – The symbolic Apply node that represents this computation.
• inputs – Immutable sequence of non-symbolic/numeric inputs. These are the values of each Variable in node.inputs.
• output_storage – List of mutable single-element lists (do not change the length of these lists). Each sub-list corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sub-lists.
• params – A tuple containing the values of each entry in Op.__props__.

Notes

The output_storage list might contain data. If an element of output_storage is not None, it has to be of the right type, for instance, for a TensorVariable, it has to be a NumPy ndarray with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such pre-set values were produced by a previous call to this Op.perform(); they could’ve been allocated by another Op’s perform method. An Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.

class aesara.typed_list.basic.GetItem

c_code(node, name, inp, out, sub)

Return the C implementation of an Op.

Returns C code that does the computation associated to this Op, given names for the inputs and outputs.

Parameters:

• node (Apply instance) – The node for which we are compiling the current C code. The same Op may be used in more than one node.
• name (str) – A name that is automatically assigned and guaranteed to be unique.
• inputs (list of strings) – There is a string for each input of the function, and the string is the name of a C variable pointing to that input. The type of the variable depends on the declared type of the input. There is a corresponding python variable that can be accessed by prepending "py_" to the name in the list.
• outputs (list of strings) – Each string is the name of a C variable where the Op should store its output. The type depends on the declared type of the output. There is a corresponding Python variable that can be accessed by prepending "py_" to the name in the list. In some cases the outputs will be preallocated and the value of the variable may be pre-filled. The value for an unallocated output is type-dependent.
• sub (dict of strings) – Extra symbols defined in CLinker sub symbols (such as 'fail').

c_code_cache_version()

Return a tuple of integers indicating the version of this Op.

An empty tuple indicates an “unversioned” Op that will not be cached between processes.

The cache mechanism may erase cached modules that have been superseded by newer versions. See ModuleCache for details.

See also

c_code_cache_version_apply

make_node(x, index)

Construct an Apply node that represent the application of this operation to the given inputs.

This must be implemented by sub-classes.

Returns:node – The constructed Apply node. Return type:Apply

perform(node, inputs, outputs)

Calculate the function on the inputs and put the variables in the output storage.

Parameters:

• node – The symbolic Apply node that represents this computation.
• inputs – Immutable sequence of non-symbolic/numeric inputs. These are the values of each Variable in node.inputs.
• output_storage – List of mutable single-element lists (do not change the length of these lists). Each sub-list corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sub-lists.
• params – A tuple containing the values of each entry in Op.__props__.

Notes

The output_storage list might contain data. If an element of output_storage is not None, it has to be of the right type, for instance, for a TensorVariable, it has to be a NumPy ndarray with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such pre-set values were produced by a previous call to this Op.perform(); they could’ve been allocated by another Op’s perform method. An Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.

view_map: Dict[int, List[int]] = {0: [0]}

A dict that maps output indices to the input indices of which they are a view.

Examples

view_map = {0: [1]} # first output is a view of second input
view_map = {1: [0]} # second output is a view of first input

class aesara.typed_list.basic.Index

make_node(x, elem)

Construct an Apply node that represent the application of this operation to the given inputs.

This must be implemented by sub-classes.

Returns:node – The constructed Apply node. Return type:Apply

perform(node, inputs, outputs)

Inelegant workaround for ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all() being thrown when trying to remove a matrix from a matrices list

class aesara.typed_list.basic.Insert(inplace=False)

c_code_cache_version()

Return a tuple of integers indicating the version of this Op.

An empty tuple indicates an “unversioned” Op that will not be cached between processes.

The cache mechanism may erase cached modules that have been superseded by newer versions. See ModuleCache for details.

See also

c_code_cache_version_apply

make_node(x, index, toInsert)

Construct an Apply node that represent the application of this operation to the given inputs.

This must be implemented by sub-classes.

Returns:node – The constructed Apply node. Return type:Apply

perform(node, inputs, outputs)

Calculate the function on the inputs and put the variables in the output storage.

Parameters:

• node – The symbolic Apply node that represents this computation.
• inputs – Immutable sequence of non-symbolic/numeric inputs. These are the values of each Variable in node.inputs.
• output_storage – List of mutable single-element lists (do not change the length of these lists). Each sub-list corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sub-lists.
• params – A tuple containing the values of each entry in Op.__props__.

Notes

The output_storage list might contain data. If an element of output_storage is not None, it has to be of the right type, for instance, for a TensorVariable, it has to be a NumPy ndarray with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such pre-set values were produced by a previous call to this Op.perform(); they could’ve been allocated by another Op’s perform method. An Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.

class aesara.typed_list.basic.Length

c_code(node, name, inp, out, sub)

Return the C implementation of an Op.

Returns C code that does the computation associated to this Op, given names for the inputs and outputs.

Parameters:

• node (Apply instance) – The node for which we are compiling the current C code. The same Op may be used in more than one node.
• name (str) – A name that is automatically assigned and guaranteed to be unique.
• inputs (list of strings) – There is a string for each input of the function, and the string is the name of a C variable pointing to that input. The type of the variable depends on the declared type of the input. There is a corresponding python variable that can be accessed by prepending "py_" to the name in the list.
• outputs (list of strings) – Each string is the name of a C variable where the Op should store its output. The type depends on the declared type of the output. There is a corresponding Python variable that can be accessed by prepending "py_" to the name in the list. In some cases the outputs will be preallocated and the value of the variable may be pre-filled. The value for an unallocated output is type-dependent.
• sub (dict of strings) – Extra symbols defined in CLinker sub symbols (such as 'fail').

c_code_cache_version()

Return a tuple of integers indicating the version of this Op.

An empty tuple indicates an “unversioned” Op that will not be cached between processes.

The cache mechanism may erase cached modules that have been superseded by newer versions. See ModuleCache for details.

See also

c_code_cache_version_apply

make_node(x)

Construct an Apply node that represent the application of this operation to the given inputs.

This must be implemented by sub-classes.

Returns:node – The constructed Apply node. Return type:Apply

perform(node, x, outputs)

Calculate the function on the inputs and put the variables in the output storage.

Parameters:

• node – The symbolic Apply node that represents this computation.
• inputs – Immutable sequence of non-symbolic/numeric inputs. These are the values of each Variable in node.inputs.
• output_storage – List of mutable single-element lists (do not change the length of these lists). Each sub-list corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sub-lists.
• params – A tuple containing the values of each entry in Op.__props__.

Notes

The output_storage list might contain data. If an element of output_storage is not None, it has to be of the right type, for instance, for a TensorVariable, it has to be a NumPy ndarray with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such pre-set values were produced by a previous call to this Op.perform(); they could’ve been allocated by another Op’s perform method. An Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.

class aesara.typed_list.basic.MakeList

make_node(a)

Construct an Apply node that represent the application of this operation to the given inputs.

This must be implemented by sub-classes.

Returns:node – The constructed Apply node. Return type:Apply

perform(node, inputs, outputs)

Calculate the function on the inputs and put the variables in the output storage.

Parameters:

• node – The symbolic Apply node that represents this computation.
• inputs – Immutable sequence of non-symbolic/numeric inputs. These are the values of each Variable in node.inputs.
• output_storage – List of mutable single-element lists (do not change the length of these lists). Each sub-list corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sub-lists.
• params – A tuple containing the values of each entry in Op.__props__.

Notes

The output_storage list might contain data. If an element of output_storage is not None, it has to be of the right type, for instance, for a TensorVariable, it has to be a NumPy ndarray with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such pre-set values were produced by a previous call to this Op.perform(); they could’ve been allocated by another Op’s perform method. An Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.

class aesara.typed_list.basic.Remove(inplace=False)

make_node(x, toRemove)

Construct an Apply node that represent the application of this operation to the given inputs.

This must be implemented by sub-classes.

Returns:node – The constructed Apply node. Return type:Apply

perform(node, inputs, outputs)

Calculate the function on the inputs and put the variables in the output storage.

Parameters:

• node – The symbolic Apply node that represents this computation.
• inputs – Immutable sequence of non-symbolic/numeric inputs. These are the values of each Variable in node.inputs.
• output_storage – List of mutable single-element lists (do not change the length of these lists). Each sub-list corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sub-lists.
• params – A tuple containing the values of each entry in Op.__props__.

Notes

The output_storage list might contain data. If an element of output_storage is not None, it has to be of the right type, for instance, for a TensorVariable, it has to be a NumPy ndarray with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such pre-set values were produced by a previous call to this Op.perform(); they could’ve been allocated by another Op’s perform method. An Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.

class aesara.typed_list.basic.Reverse(inplace=False)

c_code(node, name, inp, out, sub)

Return the C implementation of an Op.

Returns C code that does the computation associated to this Op, given names for the inputs and outputs.

Parameters:

• node (Apply instance) – The node for which we are compiling the current C code. The same Op may be used in more than one node.
• name (str) – A name that is automatically assigned and guaranteed to be unique.
• inputs (list of strings) – There is a string for each input of the function, and the string is the name of a C variable pointing to that input. The type of the variable depends on the declared type of the input. There is a corresponding python variable that can be accessed by prepending "py_" to the name in the list.
• outputs (list of strings) – Each string is the name of a C variable where the Op should store its output. The type depends on the declared type of the output. There is a corresponding Python variable that can be accessed by prepending "py_" to the name in the list. In some cases the outputs will be preallocated and the value of the variable may be pre-filled. The value for an unallocated output is type-dependent.
• sub (dict of strings) – Extra symbols defined in CLinker sub symbols (such as 'fail').

c_code_cache_version()

Return a tuple of integers indicating the version of this Op.

An empty tuple indicates an “unversioned” Op that will not be cached between processes.

The cache mechanism may erase cached modules that have been superseded by newer versions. See ModuleCache for details.

See also

c_code_cache_version_apply

make_node(x)

Construct an Apply node that represent the application of this operation to the given inputs.

This must be implemented by sub-classes.

Returns:node – The constructed Apply node. Return type:Apply

perform(node, inp, outputs)

Calculate the function on the inputs and put the variables in the output storage.

Parameters:

• node – The symbolic Apply node that represents this computation.
• inputs – Immutable sequence of non-symbolic/numeric inputs. These are the values of each Variable in node.inputs.
• output_storage – List of mutable single-element lists (do not change the length of these lists). Each sub-list corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sub-lists.
• params – A tuple containing the values of each entry in Op.__props__.

Notes

The output_storage list might contain data. If an element of output_storage is not None, it has to be of the right type, for instance, for a TensorVariable, it has to be a NumPy ndarray with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such pre-set values were produced by a previous call to this Op.perform(); they could’ve been allocated by another Op’s perform method. An Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.

class aesara.typed_list.basic.TypedListConstant(type: _TypeType, data: Any, name: Optional[str] = None)

Subclass to add the typed list operators to the basic Variable class.

class aesara.typed_list.basic.TypedListVariable(type: _TypeType, owner: OptionalApplyType, index: Optional[int] = None, name: Optional[str] = None)

Subclass to add the typed list operators to the basic Variable class.

aesara.typed_list.basic.append = <aesara.typed_list.basic.Append object>

Append an element at the end of another list.

Parameters:

• x – The base typed list.
• y – The element to append to x.

aesara.typed_list.basic.count = <aesara.typed_list.basic.Count object>

Count the number of times an element is in the typed list.

Parameters:

• x – The typed list to look into.
• elem – The element we want to count in list. The elements are compared with equals.

Notes

Python implementation of count doesn’t work when we want to count an ndarray from a list. This implementation works in that case.

aesara.typed_list.basic.extend = <aesara.typed_list.basic.Extend object>

Append all elements of a list at the end of another list.

Parameters:

• x – The typed list to extend.
• toAppend – The typed list that will be added at the end of x.

aesara.typed_list.basic.getitem = <aesara.typed_list.basic.GetItem object>

Get specified slice of a typed list.

Parameters:

• x – Typed list.
• index – The index of the value to return from x.

aesara.typed_list.basic.insert = <aesara.typed_list.basic.Insert object>

Insert an element at an index in a typed list.

Parameters:

• x – The typed list to modify.
• index – The index where to put the new element in x.
• toInsert – The new element to insert.

aesara.typed_list.basic.length = <aesara.typed_list.basic.Length object>

Returns the size of a list.

Parameters:x – Typed list.

aesara.typed_list.basic.make_list = <aesara.typed_list.basic.MakeList object>

Build a Python list from those Aesara variable.

Parameters:a (tuple/list of Aesara variable) –

Notes

All Aesara variables must have the same type.

aesara.typed_list.basic.remove = <aesara.typed_list.basic.Remove object>

Remove an element from a typed list.

Parameters:

• x – The typed list to be changed.
• toRemove – An element to be removed from the typed list. We only remove the first instance.

Notes

Python implementation of remove doesn’t work when we want to remove an ndarray from a list. This implementation works in that case.

aesara.typed_list.basic.reverse = <aesara.typed_list.basic.Reverse object>

Reverse the order of a typed list.

Parameters:x – The typed list to be reversed.