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)[source]¶ 
c_code_cache_version
()[source]¶ 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)[source]¶ Construct an
Apply
node that represent the application of this operation to the given inputs.This must be implemented by subclasses.
Returns: node – The constructed Apply
node.Return type: Apply

perform
(node, inputs, outputs)[source]¶ 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 nonsymbolic/numeric inputs. These
are the values of each
Variable
innode.inputs
.  output_storage – List of mutable singleelement lists (do not change the length of
these lists). Each sublist corresponds to value of each
Variable
innode.outputs
. The primary purpose of this method is to set the values of these sublists.  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 notNone
, it has to be of the right type, for instance, for aTensorVariable
, it has to be a NumPyndarray
with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such preset values were produced by a previous call to thisOp.perform()
; they could’ve been allocated by anotherOp
’sperform
method. AnOp
is free to reuseoutput_storage
as it sees fit, or to discard it and allocate new memory. node – The symbolic


class
aesara.typed_list.basic.
Count
[source]¶

class
aesara.typed_list.basic.
Extend
(inplace=False)[source]¶ 
make_node
(x, toAppend)[source]¶ Construct an
Apply
node that represent the application of this operation to the given inputs.This must be implemented by subclasses.
Returns: node – The constructed Apply
node.Return type: Apply

perform
(node, inputs, outputs)[source]¶ 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 nonsymbolic/numeric inputs. These
are the values of each
Variable
innode.inputs
.  output_storage – List of mutable singleelement lists (do not change the length of
these lists). Each sublist corresponds to value of each
Variable
innode.outputs
. The primary purpose of this method is to set the values of these sublists.  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 notNone
, it has to be of the right type, for instance, for aTensorVariable
, it has to be a NumPyndarray
with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such preset values were produced by a previous call to thisOp.perform()
; they could’ve been allocated by anotherOp
’sperform
method. AnOp
is free to reuseoutput_storage
as it sees fit, or to discard it and allocate new memory. node – The symbolic


class
aesara.typed_list.basic.
GetItem
[source]¶ 
c_code
(node, name, inp, out, sub)[source]¶ 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 prefilled. The value for an unallocated output is typedependent.  sub (dict of strings) – Extra symbols defined in
CLinker
sub symbols (such as'fail'
).
 node (Apply instance) – The node for which we are compiling the current C code.
The same

c_code_cache_version
()[source]¶ 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)[source]¶ Construct an
Apply
node that represent the application of this operation to the given inputs.This must be implemented by subclasses.
Returns: node – The constructed Apply
node.Return type: Apply

perform
(node, inputs, outputs)[source]¶ 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 nonsymbolic/numeric inputs. These
are the values of each
Variable
innode.inputs
.  output_storage – List of mutable singleelement lists (do not change the length of
these lists). Each sublist corresponds to value of each
Variable
innode.outputs
. The primary purpose of this method is to set the values of these sublists.  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 notNone
, it has to be of the right type, for instance, for aTensorVariable
, it has to be a NumPyndarray
with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such preset values were produced by a previous call to thisOp.perform()
; they could’ve been allocated by anotherOp
’sperform
method. AnOp
is free to reuseoutput_storage
as it sees fit, or to discard it and allocate new memory. node – The symbolic


class
aesara.typed_list.basic.
Index
[source]¶

class
aesara.typed_list.basic.
Insert
(inplace=False)[source]¶ 
c_code_cache_version
()[source]¶ 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)[source]¶ Construct an
Apply
node that represent the application of this operation to the given inputs.This must be implemented by subclasses.
Returns: node – The constructed Apply
node.Return type: Apply

perform
(node, inputs, outputs)[source]¶ 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 nonsymbolic/numeric inputs. These
are the values of each
Variable
innode.inputs
.  output_storage – List of mutable singleelement lists (do not change the length of
these lists). Each sublist corresponds to value of each
Variable
innode.outputs
. The primary purpose of this method is to set the values of these sublists.  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 notNone
, it has to be of the right type, for instance, for aTensorVariable
, it has to be a NumPyndarray
with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such preset values were produced by a previous call to thisOp.perform()
; they could’ve been allocated by anotherOp
’sperform
method. AnOp
is free to reuseoutput_storage
as it sees fit, or to discard it and allocate new memory. node – The symbolic


class
aesara.typed_list.basic.
Length
[source]¶ 
c_code
(node, name, inp, out, sub)[source]¶ 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 prefilled. The value for an unallocated output is typedependent.  sub (dict of strings) – Extra symbols defined in
CLinker
sub symbols (such as'fail'
).
 node (Apply instance) – The node for which we are compiling the current C code.
The same

c_code_cache_version
()[source]¶ 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)[source]¶ Construct an
Apply
node that represent the application of this operation to the given inputs.This must be implemented by subclasses.
Returns: node – The constructed Apply
node.Return type: Apply

perform
(node, x, outputs)[source]¶ 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 nonsymbolic/numeric inputs. These
are the values of each
Variable
innode.inputs
.  output_storage – List of mutable singleelement lists (do not change the length of
these lists). Each sublist corresponds to value of each
Variable
innode.outputs
. The primary purpose of this method is to set the values of these sublists.  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 notNone
, it has to be of the right type, for instance, for aTensorVariable
, it has to be a NumPyndarray
with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such preset values were produced by a previous call to thisOp.perform()
; they could’ve been allocated by anotherOp
’sperform
method. AnOp
is free to reuseoutput_storage
as it sees fit, or to discard it and allocate new memory. node – The symbolic


class
aesara.typed_list.basic.
MakeList
[source]¶ 
make_node
(a)[source]¶ Construct an
Apply
node that represent the application of this operation to the given inputs.This must be implemented by subclasses.
Returns: node – The constructed Apply
node.Return type: Apply

perform
(node, inputs, outputs)[source]¶ 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 nonsymbolic/numeric inputs. These
are the values of each
Variable
innode.inputs
.  output_storage – List of mutable singleelement lists (do not change the length of
these lists). Each sublist corresponds to value of each
Variable
innode.outputs
. The primary purpose of this method is to set the values of these sublists.  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 notNone
, it has to be of the right type, for instance, for aTensorVariable
, it has to be a NumPyndarray
with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such preset values were produced by a previous call to thisOp.perform()
; they could’ve been allocated by anotherOp
’sperform
method. AnOp
is free to reuseoutput_storage
as it sees fit, or to discard it and allocate new memory. node – The symbolic


class
aesara.typed_list.basic.
Remove
(inplace=False)[source]¶ 
make_node
(x, toRemove)[source]¶ Construct an
Apply
node that represent the application of this operation to the given inputs.This must be implemented by subclasses.
Returns: node – The constructed Apply
node.Return type: Apply

perform
(node, inputs, outputs)[source]¶ 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 nonsymbolic/numeric inputs. These
are the values of each
Variable
innode.inputs
.  output_storage – List of mutable singleelement lists (do not change the length of
these lists). Each sublist corresponds to value of each
Variable
innode.outputs
. The primary purpose of this method is to set the values of these sublists.  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 notNone
, it has to be of the right type, for instance, for aTensorVariable
, it has to be a NumPyndarray
with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such preset values were produced by a previous call to thisOp.perform()
; they could’ve been allocated by anotherOp
’sperform
method. AnOp
is free to reuseoutput_storage
as it sees fit, or to discard it and allocate new memory. node – The symbolic


class
aesara.typed_list.basic.
Reverse
(inplace=False)[source]¶ 
c_code
(node, name, inp, out, sub)[source]¶ 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 prefilled. The value for an unallocated output is typedependent.  sub (dict of strings) – Extra symbols defined in
CLinker
sub symbols (such as'fail'
).
 node (Apply instance) – The node for which we are compiling the current C code.
The same

c_code_cache_version
()[source]¶ 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)[source]¶ Construct an
Apply
node that represent the application of this operation to the given inputs.This must be implemented by subclasses.
Returns: node – The constructed Apply
node.Return type: Apply

perform
(node, inp, outputs)[source]¶ 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 nonsymbolic/numeric inputs. These
are the values of each
Variable
innode.inputs
.  output_storage – List of mutable singleelement lists (do not change the length of
these lists). Each sublist corresponds to value of each
Variable
innode.outputs
. The primary purpose of this method is to set the values of these sublists.  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 notNone
, it has to be of the right type, for instance, for aTensorVariable
, it has to be a NumPyndarray
with the right number of dimensions and the correct dtype. Its shape and stride pattern can be arbitrary. It is not guaranteed that such preset values were produced by a previous call to thisOp.perform()
; they could’ve been allocated by anotherOp
’sperform
method. AnOp
is free to reuseoutput_storage
as it sees fit, or to discard it and allocate new memory. node – The symbolic


class
aesara.typed_list.basic.
TypedListConstant
(type: _TypeType, data: Any, name: Optional[str] = None)[source]¶ 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)[source]¶ Subclass to add the typed list operators to the basic
Variable
class.

aesara.typed_list.basic.
append
= <aesara.typed_list.basic.Append object>[source]¶ 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>[source]¶ 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>[source]¶ 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>[source]¶ 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>[source]¶ 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>[source]¶ Returns the size of a list.
Parameters: x – Typed list.

aesara.typed_list.basic.
make_list
= <aesara.typed_list.basic.MakeList object>[source]¶ 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>[source]¶ 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.