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 Theano. If speed is important, it is probably better to pad to a dense tensor.
This is a type that represents a list in Theano. All elements must have the same Theano type. Here is an example:
>>> import theano.typed_list
>>> tl = theano.typed_list.TypedListType(theano.tensor.fvector)()
>>> v = theano.tensor.fvector()
>>> o = theano.typed_list.append(tl, v)
>>> f = theano.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 theano.typed_list
>>> a = theano.typed_list.TypedListType(theano.tensor.fvector)()
>>> l = theano.typed_list.length(a)
>>> s, _ = theano.scan(fn=lambda i, tl: tl[i].sum(),
... non_sequences=[a],
... sequences=[theano.tensor.arange(l, dtype='int64')])
>>> f = theano.function([a], s)
>>> f([[1, 2, 3], [4, 5]])
array([ 6., 9.], dtype=float32)

class
theano.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 superceded 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 (Apply) – The symbolic Apply node that represents this computation.
 inputs (Sequence) – Immutable sequence of nonsymbolic/numeric inputs. These are the values of each Variable in node.inputs.
 output_storage (list of list) – List of mutable singleelement lists (do not change the length of these lists). Each sublist corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sublists.
 params (tuple) – A tuple containing the values of each entry in __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 preset values were produced by a previous call to this Op.perform; they could’ve been allocated by another Op’s perform method. A Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.


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

class
theano.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 (Apply) – The symbolic Apply node that represents this computation.
 inputs (Sequence) – Immutable sequence of nonsymbolic/numeric inputs. These are the values of each Variable in node.inputs.
 output_storage (list of list) – List of mutable singleelement lists (do not change the length of these lists). Each sublist corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sublists.
 params (tuple) – A tuple containing the values of each entry in __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 preset values were produced by a previous call to this Op.perform; they could’ve been allocated by another Op’s perform method. A Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.


class
theano.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’). WRITEME

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 superceded 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 (Apply) – The symbolic Apply node that represents this computation.
 inputs (Sequence) – Immutable sequence of nonsymbolic/numeric inputs. These are the values of each Variable in node.inputs.
 output_storage (list of list) – List of mutable singleelement lists (do not change the length of these lists). Each sublist corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sublists.
 params (tuple) – A tuple containing the values of each entry in __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 preset values were produced by a previous call to this Op.perform; they could’ve been allocated by another Op’s perform method. A Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.


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

class
theano.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 superceded 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 (Apply) – The symbolic Apply node that represents this computation.
 inputs (Sequence) – Immutable sequence of nonsymbolic/numeric inputs. These are the values of each Variable in node.inputs.
 output_storage (list of list) – List of mutable singleelement lists (do not change the length of these lists). Each sublist corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sublists.
 params (tuple) – A tuple containing the values of each entry in __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 preset values were produced by a previous call to this Op.perform; they could’ve been allocated by another Op’s perform method. A Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.


class
theano.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’). WRITEME

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 superceded 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 (Apply) – The symbolic Apply node that represents this computation.
 inputs (Sequence) – Immutable sequence of nonsymbolic/numeric inputs. These are the values of each Variable in node.inputs.
 output_storage (list of list) – List of mutable singleelement lists (do not change the length of these lists). Each sublist corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sublists.
 params (tuple) – A tuple containing the values of each entry in __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 preset values were produced by a previous call to this Op.perform; they could’ve been allocated by another Op’s perform method. A Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.


class
theano.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 (Apply) – The symbolic Apply node that represents this computation.
 inputs (Sequence) – Immutable sequence of nonsymbolic/numeric inputs. These are the values of each Variable in node.inputs.
 output_storage (list of list) – List of mutable singleelement lists (do not change the length of these lists). Each sublist corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sublists.
 params (tuple) – A tuple containing the values of each entry in __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 preset values were produced by a previous call to this Op.perform; they could’ve been allocated by another Op’s perform method. A Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.


class
theano.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 (Apply) – The symbolic Apply node that represents this computation.
 inputs (Sequence) – Immutable sequence of nonsymbolic/numeric inputs. These are the values of each Variable in node.inputs.
 output_storage (list of list) – List of mutable singleelement lists (do not change the length of these lists). Each sublist corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sublists.
 params (tuple) – A tuple containing the values of each entry in __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 preset values were produced by a previous call to this Op.perform; they could’ve been allocated by another Op’s perform method. A Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.


class
theano.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’). WRITEME

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 superceded 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 (Apply) – The symbolic Apply node that represents this computation.
 inputs (Sequence) – Immutable sequence of nonsymbolic/numeric inputs. These are the values of each Variable in node.inputs.
 output_storage (list of list) – List of mutable singleelement lists (do not change the length of these lists). Each sublist corresponds to value of each Variable in node.outputs. The primary purpose of this method is to set the values of these sublists.
 params (tuple) – A tuple containing the values of each entry in __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 preset values were produced by a previous call to this Op.perform; they could’ve been allocated by another Op’s perform method. A Op is free to reuse output_storage as it sees fit, or to discard it and allocate new memory.


class
theano.typed_list.basic.
TypedListConstant
(type, data, name=None)[source]¶ Subclass to add the typed list operators to the basic Variable class.

class
theano.typed_list.basic.
TypedListVariable
(type, owner=None, index=None, name=None)[source]¶ Subclass to add the typed list operators to the basic Variable class.

theano.typed_list.basic.
append
= <theano.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.

theano.typed_list.basic.
count
= <theano.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.

theano.typed_list.basic.
extend
= <theano.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.

theano.typed_list.basic.
getitem
= <theano.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.

theano.typed_list.basic.
insert
= <theano.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.

theano.typed_list.basic.
length
= <theano.typed_list.basic.Length object>[source]¶ Returns the size of a list.
Parameters: x – Typed list.

theano.typed_list.basic.
make_list
= <theano.typed_list.basic.MakeList object>[source]¶ Build a Python list from those Theano variable.
Parameters: a (tuple/list of Theano variable) – Notes
All Theano variables must have the same type.

theano.typed_list.basic.
remove
= <theano.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.