Tensor的基本功能

Theano支持任何类型的Python对象,但它的重点是支持符号矩阵表达式。当你输入

>>> x = T.fmatrix()

x是一个TensorVariable实例。T.fmatrix对象本身是TensorType的实例。Theano知道x是什么类型的变量,因为x.type指回T.fmatrix

本章介绍创建张量变量的各种方法、TensorVariableTensorType的属性和方法,以及Theano对张量变量支持的各种基本符号数学和算术。

创建

Theano提供一个预定义张量类型的列表,可用于创建张量变量。可以命名变量以方便调试,并且所有这些构造函数接受可选的name参数。例如,以下每个语句都产生一个TensorVariable实例,来表示名为'myvar'的0维整数类型的ndarray:

>>> x = scalar('myvar', dtype='int32')
>>> x = iscalar('myvar')
>>> x = TensorType(dtype='int32', broadcastable=())('myvar')

可选dtype的变量定义函数

下面是在你的代码中创建符号变量的最简单且通常是首选的方法。默认情况下,它们产生浮点变量(dtype由config.floatX确定,参见floatX),所以如果你使用这些构造函数,很容易在不同级别的浮点精度之间切换你的代码。

theano.tensor.scalar(name=None, dtype=config.floatX)[source]

返回0维数组的变量

theano.tensor.vector(name=None, dtype=config.floatX)[source]

返回一维数组的变量

theano.tensor.row(name=None, dtype=config.floatX)[source]

返回一个二维数组的变量,其中行数保证为1。

theano.tensor.col(name=None, dtype=config.floatX)[source]

返回一个二维数组的变量,其中列数保证为1。

theano.tensor.matrix(name=None, dtype=config.floatX)[source]

返回二维数组的变量

theano.tensor.tensor3(name=None, dtype=config.floatX)[source]

返回三维参数的变量

theano.tensor.tensor4(name=None, dtype=config.floatX)[source]

返回四维数组的变量

theano.tensor.tensor5(name=None, dtype=config.floatX)[source]

返回五维数组的变量

各种类型的所有构造函数

在theano.tensor模块中提供以下TensorType实例。它们都是可调用的,并接受可选的name参数。例如:

from theano.tensor import *

x = dmatrix()        # creates one Variable with no name
x = dmatrix('x')     # creates one Variable with name 'x'
xyz = dmatrix('xyz') # creates one Variable with name 'xyz'
构造函数 dtype ndim 形状 broadcastable
bscalar int8 0 () ()
bvector int8 1 (?,) (False,)
brow int8 2 (1,?) (True, False)
bcol int8 2 (?,1) (False, True)
bmatrix int8 2 (?,?) (False, False)
btensor3 int8 3 (?,?,?) (False, False, False)
btensor4 int8 4 (?,?,?,?) (False, False, False, False)
btensor5 int8 5 (?,?,?,?,?) (False, False, False, False, False)
wscalar int16 0 () ()
wvector int16 1 (?,) (False,)
row int16 2 (1,?) (True, False)
wcol int16 2 (?,1) (False, True)
wmatrix int16 2 (?,?) (False, False)
wtensor3 int16 3 (?,?,?) (False, False, False)
wtensor4 int16 4 (?,?,?,?) (False, False, False, False)
wtensor5 int16 5 (?,?,?,?,?) (False, False, False, False, False)
iscalar int32 0 () ()
ivector int32 1 (?,) (False,)
irow int32 2 (1,?) (True, False)
icol int32 2 (?,1) (False, True)
imatrix int32 2 (?,?) (False, False)
itensor3 int32 3 (?,?,?) (False, False, False)
itensor4 int32 4 (?,?,?,?) (False, False, False, False)
itensor5 int32 5 (?,?,?,?,?) (False, False, False, False, False)
lscalar int64 0 () ()
lvector int64 1 (?,) (False,)
row int64 2 (1,?) (True, False)
lcol int64 2 (?,1) (False, True)
lmatrix int64 2 (?,?) (False, False)
ltensor3 int64 3 (?,?,?) (False, False, False)
ltensor4 int64 4 (?,?,?,?) (False, False, False, False)
ltensor5 int64 5 (?,?,?,?,?) (False, False, False, False, False)
dscalar float64 0 () ()
dvector float64 1 (?,) (False,)
drow float64 2 (1,?) (True, False)
dcol float64 2 (?,1) (False, True)
dmatrix float64 2 (?,?) (False, False)
dtensor3 float64 3 (?,?,?) (False, False, False)
dtensor4 float64 4 (?,?,?,?) (False, False, False, False)
dtensor5 float64 5 (?,?,?,?,?) (False, False, False, False, False)
fscalar float32 0 () ()
fvector float32 1 (?,) (False,)
row float32 2 (1,?) (True, False)
fcol float32 2 (?,1) (False, True)
fmatrix float32 2 (?,?) (False, False)
ftensor3 float32 3 (?,?,?) (False, False, False)
ftensor4 float32 4 (?,?,?,?) (False, False, False, False)
ftensor5 float32 5 (?,?,?,?,?) (False, False, False, False, False)
cscalar complex64 0 () ()
cvector complex64 1 (?,) (False,)
crow complex64 2 (1,?) (True, False)
ccol complex64 2 (?,1) (False, True)
cmatrix complex64 2 (?,?) (False, False)
ctensor3 complex64 3 (?,?,?) (False, False, False)
ctensor4 complex64 4 (?,?,?,?) (False, False, False, False)
ctensor5 complex64 5 (?,?,?,?,?) (False, False, False, False, False)
zscalar complex128 0 () ()
zvector complex128 1 (?,) (False,)
zrow complex128 2 (1,?) (True, False)
zcol complex128 2 (?,1) (False, True)
zmatrix complex128 2 (?,?) (False, False)
ztensor3 complex128 3 (?,?,?) (False, False, False)
ztensor4 complex128 4 (?,?,?,?) (False, False, False, False)
ztensor5 complex128 5 (?,?,?,?,?) (False, False, False, False, False)

多元构造函数

有几个构造函数可以一次生成多个变量。这些在实践中不常用,但经常用在教程示例中,以节省空间!

iscalars, lscalars, fscalars, dscalars

返回一个或多个标量变量。

ivectors, lvectors, fvectors, dvectors

返回一个或多个向量变量。

irows, lrows, frows, drows

返回一个或多个行变量。

icols, lcols, fcols, dcols

返回一个或多个列变量。

imatrices, lmatrices, fmatrices, dmatrices

返回一个或多个矩阵变量。

每个多元构造函数接受一个整数或多个字符串。如果提供一个整数,该方法将返回对应数目的变量,如果提供字符串,它将为每个字符串创建一个变量,使用字符串作为变量的名称。例如:

from theano.tensor import *

x, y, z = dmatrices(3) # creates three matrix Variables with no names
x, y, z = dmatrices('x', 'y', 'z') # creates three matrix Variables named 'x', 'y' and 'z'

自定义张量类型

如果你想构造一个具有非标准broadcasting模式或更大维数的张量变量,你需要创建你自己的TensorType实例。你可以通过传递dtype和broadcasting模式到构造函数创建这样的实例。例如,你可以创建你自己的6维张量类型

>>> dtensor6 = TensorType('float64', (False,)*6)
>>> x = dtensor6()
>>> z = dtensor6('z')

你也可以重新定义一些已经提供的类型,它们会正确交互:

>>> my_dmatrix = TensorType('float64', (False,)*2)
>>> x = my_dmatrix()       # allocate a matrix variable
>>> my_dmatrix == dmatrix
True

有关创建新类型的Tensor的更多信息,请参阅TensorType

从Python对象转换

另一种创建TensorVariable(更准确地说,应该是TensorSharedVariable)的方法是调用shared()

x = shared(numpy.random.randn(3,4))

这将返回一个shared variable,其.value是一个numpy ndarray。变量的维数和数据类型数从ndarray参数推断出来。shared 的参数不会被复制,随后的更改将反映在x.value中。

有关其他信息,请参阅shared()文档。

最后,当你在算术表达式中将numpy ndarry或Python数字和TensorVariable实例一起使用时,结果将为TensorVariablendarray或数字会发生什么?Theano要求所有表达式的输入都是Variable实例,因此Theano会自动将它们封装在一个TensorConstant中。

注意

Theano对你在表达式中使用的任何ndarray生成一个拷贝,所以对ndarray的后续更改不会对Theano表达式产生任何影响。

对于numpy ndarrays,dtype已经给出,但是broadcastable模式必须推断出来。TensorConstant将被赋予一个匹配dtype的类型,以及一个broadcastable模式,其中每个维度为1的维是True

对于python数字,broadcastable模式为(),但必须推断得到dtype。Python整数存储在能保存它们的最小dtype中,因此像1这样的小常数存储在bscalar中。同样,如果fscalar足以完整保存它们,Python浮点存储在一个fscalar中,否则存储在一个dscalar中。

注意

当config.floatX == float32(参见config)时,Python浮点将存储为单精度浮点数。

要精确控制此舍入策略,请参见theano.tensor.basic.autocast_float。

theano.tensor.as_tensor_variable(x, name=None, ndim=None)[source]

将参数x变为TensorVariable或TensorConstant。

许多张量操作通过这个函数运行它们的参数作为预处理。它传递进TensorVariable实例,并尝试将其他对象封装到TensorConstant中。

x是Python数字时,如上所述推断dtype。

x列表元组时,它通过numpy.asarray传递

如果ndim参数不是None,它必须是一个整数,如果有必要,输出将被broadcasted以具有这么多维度。

返回类型:TensorVariableTensorConstant

TensorType和TensorVariable

class theano.tensor.TensorType(Type)[source]

用于标记表示numpy.ndarray值的Variable的Type类(numpy.ndarray的子类numpy.memmap也允许)。回到教程,教程的图形结构图中的紫色框是此类的一个实例。

broadcastable[source]

True/False值组成的一个元组,每个维度一个值。位置'i'为True表示在计算时,ndarray在第i个维度的大小为1。这样的维度被称为broadcastable维度(参见Theano和Numpy中的Broadcasting )。

Broadcastable的模式表示维度的数量以及特定维度是否必须具有长度1。

以下是将一些broadcastable模式映射到其意义的表格:

模式 解释
[] 标量
[True] 1D标量(长度为1的向量)
[True, True] 2D标量(1x1矩阵)
[False] 向量
[False, False] 矩阵
[False] * n nD张量
[True, False] 行(1xN矩阵)
[False, True] 列(Mx1矩阵)
[False, True, False] Mx1xP张量(a)
[True, False, False] 1xNxP张量(b)
[False, False, False] MxNxP张量(a + b的模式)

对于broadcasting为False的维度,此维度的长度可以为1或更大。对于broadcasting为True的维度,此维度的长度必须为1。

当元素级别的操作(如加法或减法)的两个参数具有不同数量的维度时,可broadcastable模式通过使用True填充而向左扩展例如,向量的模式[False]可以扩展为[True, False],并且将表现得像行(1xN矩阵)。以相同的方式,矩阵([False, False])将表现为1xNxP张量([True , False, False])。

如果我们想创建一个类型来表示矩阵,当将它们相加到一起时,它们将在3维张量的中间维度上broadcast,我们将这样定义:

>>> middle_broadcaster = TensorType('complex64', [False, True, False])
ndim[source]

变量的值在计算时将具有的维数。当我们构建表达式图时,这必须是已知的。

dtype[source]

一个字符串,表示此类型的变量所在的ndarray的数值类型。

TensorType实例的dtype属性可以是以下任何字符串。

dtype
'int8' 有符号整数 8
'int16' 有符号整数 16
'int32' 有符号整数 32
'int64' 有符号整数 64
'uint8' 无符号整数 8
'uint16' 无符号整数 16
'uint32' 无符号整数 32
'uint64' 无符号整数 64
'float32' 浮点数 32
'float64' 浮点数 64
'complex64' 复数 64(两个float32)
'complex128' 复数 128(两个float64)
__init__(self, dtype, broadcastable)[source]

如果你想使用一种没有预置的张量类型(例如,5D张量),你可以通过实例化TensorType来建立一个合适的类型。

TensorVariable

class theano.tensor.TensorVariable(Variable, _tensor_py_operators)[source]

符号运算的结果通常具有这种类型。

有关你将要调用的大多数属性和方法,请参见_tensor_py_operators

class theano.tensor.TensorConstant(Variable, _tensor_py_operators)[source]

Python和numpy数字封装在此类型中。

有关你将要调用的大多数属性和方法,请参见_tensor_py_operators

class theano.tensor.TensorSharedVariable(Variable, _tensor_py_operators)[source]

当要共享的值是numpy ndarray时,此类型由shared()返回。

有关你将要调用的大多数属性和方法,请参见_tensor_py_operators

class theano.tensor._tensor_py_operators[source]

这是一个类,为Python操作符(参见运算符的支持)向TensorVariable、TensorConstant和TensorSharedVariable添加方便的属性、方法和支持。

type[source]

TensorType实例的一个引用,描述可能与此变量相关联的值的类型。

ndim[source]

该张量的维数。TensorType.ndim的别名。

dtype[source]

该张量的数值类型。TensorType.dtype的别名。

reshape(shape, ndim=None)[source]

返回reshaped后的张量的视图,类似numpy.reshape。如果shape是一个Variable参数,那么你可能需要使用可选的ndim参数来声明形状具有多少个元素,这样reshaped的变量将具有多少个维度。

请参阅reshape()

dimshuffle(*pattern)[source]

返回该张量的一个视图,并且维度已经置换。通常,pattern包括整数0、1、... ndim-1以及任意数量字符‘x’,如果张量相应的维度应该broadcast。

pattern的几个例子及其效果:

  • (‘x’) -> 将0d(标量)转换为1d向量
  • (0, 1) -> 2d向量
  • (1, 0) -> 对调第一维和第二维
  • (‘x’, 0) -> 从1d向量生成一个行(N到1xN)
  • (0, ‘x’) -> 从1d向量生成一个列(N到Nx1)
  • (2, 0, 1) -> AxBxC到CxAxB
  • (0, ‘x’, 1) -> AxB到Ax1xB
  • (1, ‘x’, 0) -> AxB到Bx1xA
  • (1,) -> 删除维度0。它必须是一个broadcastable的维度(1xA到A)
flatten(ndim=1)[source]

ndim维度返回此张量的视图,其中前ndim-1维的形状将与self相同,剩余维度的形状将被展开以适应来自自身的所有数据。

请参阅flatten()

ravel()[source]

返回self.flatten()。为了与NumPy兼容。

T[source]

转置这个张量。

>>> x = T.zmatrix()
>>> y = 3+.2j * x.T

注意

在numpy和theano中,向量的转置是完全相同的向量!使用reshapedimshuffle将你的向量变成行或列矩阵。

{any,all}(axis=None, keepdims=False)
{sum,prod,mean}(axis=None, dtype=None, keepdims=False, acc_dtype=None)
{var,std,min,max,argmin,argmax}(axis=None, keepdims=False),
diagonal(offset=0, axis1=0, axis2=1)[source]
astype(dtype)[source]
take(indices, axis=None, mode='raise')[source]
copy()返回一个新的符号变量,它是变量的副本。不复制标记。
norm(L, axis=None)[source]
nonzero(self, return_matrix=False)[source]
nonzero_values(self)[source]
sort(self, axis=-1, kind='quicksort', order=None)[source]
argsort(self, axis=-1, kind='quicksort', order=None)[source]
clip(self, a_min, a_max)[source]
conf()[source]
repeat(repeats, axis=None)[source]
round(mode="half_away_from_zero")[source]
trace()[source]
get_scalar_constant_value()[source]
zeros_like(model, dtype=None)[source]

在Theano中,当前张量的所有上述方法等价于NumPy。

__{abs,neg,lt,le,gt,ge,invert,and,or,add,sub,mul,div,truediv,floordiv}__

这些元素级别操作通过Python语法支持。

argmax(axis=None, keepdims=False)[source]

请参阅theano.tensor.argmax

argmin(axis=None, keepdims=False)[source]

请参阅theano.tensor.argmin

argsort axis = -1kind ='quicksort'order = None t4 > [source]

请参阅theano.tensor.argsort

broadcastable[source]

这个张量可broadcast的标记。

另见

broadcasting

choose(a, choices, out=None, mode='raise')[source]

从索引数组和一组数组构造数组以供选择。

clip(a_min, a_max)[source]

剪辑(限制)数组中的值。

compress(a, axis=None)[source]

仅返回所选切片。

conj()[source]

请参阅theano.tensor.conj

conjugate()[source]

请参阅theano.tensor.conj

copy(name=None)[source]

返回符号性的拷贝并可以选择对其命名。

不复制标签。

dimshuffle * pattern [source]

对此变量的维度重新排序,可选择插入要被broadcasted的维度。

参数:模式 - 整数与'x'(表示要broadcast的维度)混合的列表/元祖。

例子

例如,要创建[2D]矩阵的3D视图,请调用dimshuffle([0,'x',1])这将创建一个3D视图,且中间维度为将要broadcast的维度。要对该矩阵的转置矩阵执行相同的操作,请调用dimshuffle([1, 'x', 0])

注意事项

此函数支持以元组或可变长度参数传递的pattern(例如a.dimshuffle(pattern)等价于a.dimshuffle(*pattern)pattern是一个整数与'x'字符混合的列表/元组)。

也可以看看

DimShuffle()

dtype [source]

这个张量的dtype。

fill(value)[source]

用指定的值填充输入的张量。

imag[source]

返回复数类型张量z的虚分量

泛化了张量的标量操作。

所有输入必须具有相同的维数。执行Op时,对于每个维度,每个输入的尺寸大小必须相同。作为一种特殊情况,它也可以是1,但只有当输入的可广播标志对于该维度为True时。在这种情况下,沿着该维度(实际上)复制张量以匹配其他的大小。

输出的dtype反映被推广到张量的标量Op的那些。特别是,如果输出的计算是在输入上完成的,则输出类型必须与相应的输入类型相同(请参阅scalar.ScalarOp的文档以获取有关控制输出类型的帮助)

参数:
  • scalar_op - scalar.ScalarOp的子类的实例,它对标量有独特的作用。
  • inplace_pattern - 将输出的索引映射到输入的索引,从而使用输入的存储空间计算输出的字典。(就像destroymap,但没有列表。)
  • nfunc_spec - 无论是三个元素(nfunc_name,nin,nout)的元组,使得getattr(numpy,nfunc_name)实现此操作,需要nin个输入和nout输出。注意,nin不能总是从标量op的自己的nin字段推断,因为该值有时是0(意味着可变数量的输入),而numpy函数可能没有varargs。

例子

#表示+ =操作(x + = y)Elemwise(add,{0:1})#表示+ =在第二个参数(y + = x)Elemwise(mul)(rand(10,5),rand(1,5))#第二个输入完成#沿第一个维度匹配第一个输入Elemwise(true_div) rand(10,5),rand(10,1))#相同,但沿着#第二维Elemwise(int_div)(rand(1,5),rand )Elemwise(log)(rand(3,4,5))

max(axis=None, keepdims=False)[source]

请参阅theano.tensor.max

mean(axis=None, dtype=None, keepdims=False, acc_dtype=None)[source]

请参阅theano.tensor.mean

min(axis=None, keepdims=False)[source]

请参阅theano.tensor.min

ndim [source]

这个张量的秩。

nonzero(return_matrix=False)[source]

请参阅theano.tensor.nonzero

nonzero_values [source]

请参阅theano.tensor.nonzero_values

prod(axis=None, dtype=None, keepdims=False, acc_dtype=None)[source]

请参阅theano.tensor.prod

ptp(axis=None)[source]

参见'theano.tensor.ptp'。

real[source]

返回复值张量z的实部分量

泛化了张量的标量操作。

所有输入必须具有相同的维数。执行Op时,对于每个维度,每个输入的尺寸大小必须相同。作为一种特殊情况,它也可以是1,但只有当输入的可广播标志对于该维度为True时。在这种情况下,沿着该维度(实际上)复制张量以匹配其他的大小。

输出的dtype反映被推广到张量的标量Op的那些。特别是,如果输出的计算是在输入上完成的,则输出类型必须与相应的输入类型相同(请参阅scalar.ScalarOp的文档以获取有关控制输出类型的帮助)

参数:
  • scalar_op - scalar.ScalarOp的子类的实例,它对标量有独特的作用。
  • inplace_pattern - 将输出的索引映射到输入的索引,从而使用输入的存储空间计算输出的字典。(就像destroymap,但没有列表。)
  • nfunc_spec - 无论是三个元素(nfunc_name,nin,nout)的元组,使得getattr(numpy,nfunc_name)实现此操作,需要nin个输入和nout输出。注意,nin不能总是从标量op的自己的nin字段推断,因为该值有时是0(意味着可变数量的输入),而numpy函数可能没有varargs。

例子

#表示+ =操作(x + = y)Elemwise(add,{0:1})#表示+ =在第二个参数(y + = x)Elemwise(mul)(rand(10,5),rand(1,5))#第二个输入完成#沿第一个维度匹配第一个输入Elemwise(true_div) rand(10,5),rand(10,1))#相同,但沿着#第二维Elemwise(int_div)(rand(1,5),rand )Elemwise(log)(rand(3,4,5))

repeat(repeats, axis=None)[source]

请参阅theano.tensor.repeat

reshape 形状ndim =无 [source]

返回此变量的重新形成的视图/副本。

参数:
  • shape - 可以转换为整数的符号向量的东西。
  • ndim - 形状的长度。传递None此处意味着Theano尝试猜测形状的长度。
:param .. warning ::这有一个不同的签名比numpy的:ndarray.reshape!
在numpy你不需要包装形状参数在一个元组,在theano你需要。
round mode ='half_away_from_zero' [source]

请参阅theano.tensor.round

sort axis = -1kind ='quicksort'order = None t4 > [source]

请参阅theano.tensor.sort

squeeze()[source]

从数组的形状中删除可广告尺寸。

它返回输入数组,但删除可广播尺寸。这总是x本身或到x的视图。

std(axis=None, keepdims=False)[source]

请参阅theano.tensor.std

sum(axis=None, dtype=None, keepdims=False, acc_dtype=None)[source]

请参阅theano.tensor.sum

swapaxes(axis1, axis2)[source]

返回tensor.swapaxes(self,axis1,axis2)。

如果矩阵具有右轴,则其转置将被返回。

transfer(target)[source]

如果target'cpu',那么将传输到TensorType(如果还没有)。其他类型可以定义其他目标。

参数:目标str) - 输出变量的所需位置
transpose(*axes)[source]
返回:
  • 对象 - tensor.transpose(self,axes)tensor.transpose(self,axes [0])
  • 如果只提供一个参数,它是可迭代的,那么它是
  • 假定为整个轴元组,并完整传递到
  • tensor.transpose。
var(axis=None, keepdims=False)[source]

请参阅theano.tensor.var

Shaping和Shuffling

要重新排序变量的尺寸,要插入或删除broadcastable的维,请参阅_tensor_py_operators.dimshuffle()

theano.tensor.shape(x)[source]

返回表示x形状的lvector。

theano.tensor.reshape(x, newshape, ndim=None)[source]
参数:
  • x任何TensorVariable (或兼容的) —— 要reshape的变量
  • newshapelvector(或兼容的) —— x的新形状
  • ndim(可选) —— newshape的值将具有的长度。如果它为None,则reshape()将从newshape推断它。
返回类型:

x的dtype型的变量,但维度为ndim

注意

这个函数可以在某些情况下推断符号newshape的长度,但如果不能而且你没有提供ndim,那么这个函数将引发异常。

theano.tensor.shape_padleft(x, n_ones=1)[source]

通过用n_ones 1s左填充形状重塑形状x请注意,所有此新维度都将可广播。要使其不可广播,请参阅unbroadcast()

参数:x任何TensorVariable (或 兼容 ) - 要重新形成的变量
theano.tensor.shape_padright(x, n_ones=1)[source]

通过使用n_ones 1s右键填充形状来重塑x请注意,所有此新维度都将可广播。要使其不可广播,请参阅unbroadcast()

参数:x任何TensorVariable (或 兼容 ) - 要重新形成的变量
theano.tensor.shape_padaxis(t, axis)[source]

通过在尺寸处插入1来重塑t请注意,此新维度将可广播。要使其不可广播,请参阅unbroadcast()

参数:
  • x任何TensorVariable (或 兼容 ) - 要重新形成的变量
  • axisint) - 轴在x

例:

>>> tensor = theano.tensor.tensor3()
>>> theano.tensor.shape_padaxis(tensor, axis=0)
InplaceDimShuffle{x,0,1,2}.0
>>> theano.tensor.shape_padaxis(tensor, axis=1)
InplaceDimShuffle{0,x,1,2}.0
>>> theano.tensor.shape_padaxis(tensor, axis=3)
InplaceDimShuffle{0,1,2,x}.0
>>> theano.tensor.shape_padaxis(tensor, axis=-1)
InplaceDimShuffle{0,1,2,x}.0
theano.tensor.unbroadcast(x, *axes)[source]

使输入不能在指定的轴上broadcast。

例如,addbroadcast(x, 0)将使x的第一个维度broadcastable。当执行该函数时,如果沿该维度的x的长度不为1,则会引发ValueError。

这里我们应用这个操作是为了不污染图,特别是在gpu优化期间

参数:
  • xtensor_like) —— 输入的theano张量。
  • axis一个整数一个可迭代对象,例如整数组成的列表元组) —— 张量x沿着这个维度应当unbroadcastable。如果沿这些维度的x的长度不是1,将引发ValueError。
返回:

一个theano张量,沿着指定的维度unbroadcastable。

返回类型:

张量

theano.tensor.addbroadcast(x, *axes)[source]

使输入在指定的轴中可广播。

例如,addbroadcast(x,0)将使x的第一个可广播。当执行该函数时,如果沿该维度的x的长度不为1,则会引发ValueError。

这里我们应用这个操作是为了不污染图,特别是在gpu优化期间

参数:
  • xtensor_like) —— 输入的theano张量。
  • axis一个整数一个可迭代对象,例如整数组成的列表元组) —— 张量x沿着这个维度应当broadcastable。如果沿这些维度的x的长度不是1,将引发ValueError。
返回:

一个theano张量,它沿着指定的维度broadcastable。

返回类型:

张量

theano.tensor.patternbroadcast(x, broadcastable)[source]

使输入采用特定的broadcasting模式。

Broadcastable必须是可迭代的。例如,patternbroadcast(x, (True, False))将使得第一个维度broadcastable,第二个维不可broadcastable,因此x现在是一个行。

这里我们应用这个操作是为了不污染图,特别是在gpu优化期间。

参数:
  • xtensor_like) —— 输入的theano张量。
  • broadcastable一个可迭代对象,例如布尔值组成的列表元组)—— 一组布尔值,表示某个维度是否应该broadcastable。如果沿这些维度的x的长度不是1,将引发ValueError。
返回:

一个theano张量,它沿着指定的维度unbroadcastable 。

返回类型:

张量

theano.tensor.flatten(x, outdim=1)[source]

类似于reshape(),但形状是从x的形状推断的。

参数:
  • x任何TensorVariable (或 兼容 ) - 变量变平
  • outdimint) - 返回变量中的维数
返回类型:

变量,dtype与x相同且维度为outdim

返回:

变量在前导的outdim-1维度中具有与x相同的形状,但所有剩余维度x折叠到最后一个维度。

例如,如果我们用flatten(x, outdim=2)将形状为(2,3,4,5)的张量展平,那么我们将具有相同的(2-1=1)前导维度(2,),而其余维度被折叠。所以在这个例子中的输出将具有形状(2, 60)。

theano.tensor.tile(x, reps, ndim=None)[source]

通过根据reps模式重复输入x来构造数组。

根据reps对其输入进行平铺。reps的长度是x的维数,并且包含在每个维中平铺x的次数。

看到:numpy.tile文档中的示例。
看到:theano.tensor.extra_ops.repeat
注意:目前,reps必须是常数,x.ndimlen(reps)必须相等,如果指定,/ t3>必须等于两者。
theano.tensor.roll(x, shift, axis=None)[source]

方便功能沿给定轴滚动TensorTypes。

语法copy numpy.roll函数。

参数:
  • x张量类) - 输入张量。
  • shift (int (symbolic or literal)) – The number of places by which elements are shifted.
  • axis (int (symbolic or literal), optional) – The axis along which elements are shifted. 默认情况下,阵列在移位之前变平,之后恢复原始形状。
返回:

输出张量,形状与x相同。

返回类型:

张量

创建张量

theano.tensor.zeros_like(x, dtype=None)[source]
参数:
  • x —— 具有与输出形状相同的张量
  • dtype —— data-type,可选。缺省情况下,它为x.dtype。

返回一个张量,具有x的形状并填充dtype类型的零。

theano.tensor.ones_like(x)[source]
参数:
  • x — 与输出形状相同的张量
  • dtype — data-type,可选。默认情况下为x.dtype。

返回一个张量,形状与x相同,以dtype类型的1填充。

theano.tensor.zeros(shape, dtype=None)[source]
参数:
  • shape - 带有形状信息的标量/标量列表。
  • dtype - 新张量的dtype。如果为None,将使用floatX。

返回填充有所提供形状的0的张量。

theano.tensor.ones(shape, dtype=None)[source]
参数:
  • shape - 带有形状信息的标量/标量列表。
  • dtype - 新张量的dtype。如果为None,将使用floatX。

返回填充有所提供形状的1的张量。

theano.tensor.fill(a, b)[source]
参数:
  • a - 张量与输出形状相同
  • b - 要填充输出的theano标量或值

通过使用b填充a的形状来创建矩阵

theano.tensor.alloc(value, *shape)[source]
参数:
  • value - 用于填充输出的值
  • shape - 返回数组的尺寸
返回:

value初始化并具有指定形状的N维张量。

theano.tensor.eye(n, m=None, k=0, dtype=theano.config.floatX)[source]
参数:
  • n - 输出中的行数(值或aano标量)
  • m - 输出中的列数(值或aano标量)
  • k - 对角线的索引:0表示主对角线,正值表示上对角线,负值表示下对角线。它可以是一个anano标量。
返回:

一个数组,其中所有元素都等于零,除了k对角线,其值等于1。

theano.tensor.identity_like(x)[source]
参数:x - 张量
返回:x形状相同的张量,其除了主对角线之外的任何地方都用0填充,其值等于1。输出将具有与x相同的dtype。
theano.tensor.stack(tensors, axis=0)[source]

在给定轴上按顺序堆叠张量(默认值为0)。

取一系列张量并将它们堆叠在给定轴上以产生单张张量。结果的尺寸的大小将等于通过的张量的数量。

参数:
  • 张量 - 相同秩的一个或多个张量的列表或元组。
  • axis - 张力将沿其堆叠的轴。默认值为0。
返回:

张量,使得rval [0] ==张量[0],rval [1] ==张量[1]等

例子:

>>> a = theano.tensor.scalar()
>>> b = theano.tensor.scalar()
>>> c = theano.tensor.scalar()
>>> x = theano.tensor.stack([a, b, c])
>>> x.ndim # x is a vector of length 3.
1
>>> a = theano.tensor.tensor4()
>>> b = theano.tensor.tensor4()
>>> c = theano.tensor.tensor4()
>>> x = theano.tensor.stack([a, b, c])
>>> x.ndim # x is a 5d tensor.
5
>>> rval = x.eval(dict((t, np.zeros((2, 2, 2, 2))) for t in [a, b, c]))
>>> rval.shape # 3 tensors are stacked on axis 0
(3, 2, 2, 2, 2)

我们还可以指定不同于默认值0的轴

>>> x = theano.tensor.stack([a, b, c], axis=3)
>>> x.ndim
5
>>> rval = x.eval(dict((t, np.zeros((2, 2, 2, 2))) for t in [a, b, c]))
>>> rval.shape # 3 tensors are stacked on axis 3
(2, 2, 2, 3, 2)
>>> x = theano.tensor.stack([a, b, c], axis=-2)
>>> x.ndim
5
>>> rval = x.eval(dict((t, np.zeros((2, 2, 2, 2))) for t in [a, b, c]))
>>> rval.shape # 3 tensors are stacked on axis -2
(2, 2, 2, 3, 2)
theano.tensor.stack(*tensors)[source]

警告

接口stack(*tensors)已废弃!使用stack(tensors, axis=0)

垂直堆叠张量(行方向)。

取一系列张量,并垂直堆叠,以形成单张张量。

参数:张量 - 相同秩的一个或多个张量
返回:张量,使得rval [0] ==张量[0],rval [1] ==张量[1]等
>>> x0 = T.scalar()
>>> x1 = T.scalar()
>>> x2 = T.scalar()
>>> x = T.stack(x0, x1, x2)
>>> x.ndim # x is a vector of length 3.
1
theano.tensor.concatenate(tensor_list, axis=0)[source]
参数:
  • tensor_list (a list or tuple of Tensors that all have the same shape in the axes not specified by the axis argument.) - 一个或多个Tensors连接在一起成一个。
  • axis (literal or symbolic integer) – Tensors will be joined along this axis, so they may have different shape[axis]
>>> x0 = T.fmatrix()
>>> x1 = T.ftensor3()
>>> x2 = T.fvector()
>>> x = T.concatenate([x0, x1[0], T.shape_padright(x2)], axis=1)
>>> x.ndim
2
theano.tensor.stacklists(tensor_list)[source]
参数:tensor_list(包含张量或其他与张量列表相同类型的迭代器(换句话说,这是一个叶子是张量的树) - 张量堆叠在一起。

递归地堆叠张量以保持类似的结构。

此函数可以从成形的标量列表创建张量:

>>> from theano.tensor import stacklists, scalars, matrices
>>> from theano import function
>>> a, b, c, d = scalars('abcd')
>>> X = stacklists([[a, b], [c, d]])
>>> f = function([a, b, c, d], X)
>>> f(1, 2, 3, 4)
array([[ 1.,  2.],
       [ 3.,  4.]])

我们也可以堆叠任意形状的张量。这里我们把矩阵堆积成一个2×2的网格:

>>> from numpy import ones
>>> a, b, c, d = matrices('abcd')
>>> X = stacklists([[a, b], [c, d]])
>>> f = function([a, b, c, d], X)
>>> x = ones((4, 4), 'float32')
>>> f(x, x, x, x).shape
(2, 2, 4, 4)
theano.tensor.basic.choose(a, choices, out=None, mode='raise')[source]

从索引数组和一组数组构造数组以供选择。

首先,如果混淆或不确定,肯定看看示例 - 在其完全通用性,这个函数不如下面的代码描述(下面的ndi = numpy.lib.index_tricks)看起来简单:

np.choose(a,c)== np.array([c [a [I]] [I] for I in ndi.ndindex(a.shape)])。

但这里省略了一些细微之处。这里是一个完全一般的总结:

给定整数的index数组(a)和n个数组(选择)的序列,首先根据需要将a和每个选择数组广播到公共形状的数组;调用这些Ba和Bchoices [i],i = 0,...,n-1我们有必要,每个i的Ba.shape == Bchoices [i] .shape。然后,创建一个形状为Ba.shape的新数组,如下所示:

  • 如果mode = raise(默认),首先,a的每个元素(因此Ba)必须在范围[0,n-1]中;现在,假设i(在该范围内)是Ba中的(j0,j1,...,jm)位置处的值,则新数组中相同位置处的值是Bchoices [i]同一位置;
  • 如果mode = wrap,a(且因此Ba)中的值可以是任何(有符号)整数;模运算用于将范围[0,n-1]之外的整数映射回该范围;然后新数组如上构造;
  • 如果mode = clip,a(且因此Ba)中的值可以是任何(有符号)整数;负整数映射到0;大于n-1的值被映射到n-1;然后新数组如上构造。
参数:
  • aint数组) - 此数组必须包含[0,n-1]中的整数,其中n是选项数,除非mode = wrap或mode = clip ,在这种情况下,任何整数都是允许的。
  • 选择数组序列) - 选择数组。a和所有的选择必须可以广播到相同的形状。如果选择本身是一个数组(不推荐),那么它的最外层维度(即与choices.shape [0]对应的那个维度)被定义为sequence
  • out数组 可选) - 如果提供,结果将插入此数组。它应该是合适的形状和类型。
  • mode({raise(默认值),wrapclip} ,n-1]将被处理:raise:引发异常wrap:value变为值mod n clip:值n-1映射到n-1
返回:

合并的结果。

返回类型:

merged_array - array

上升:

ValueError - 形状不匹配 - 如果a和每个选择数组不能全部广播到相同的形状。

归约

theano.tensor.max(x, axis=None, keepdims=False)[source]
参数:x - 符号Tensor(或兼容)
参数:axis轴或沿其计算最大值的轴
参数:keepdims - (boolean)如果设置为True,则缩小的轴将作为尺寸为1的尺寸留在结果中。使用此选项,结果将相对原始张量正确广播。
返回:沿x的最大值
轴可以是:
  • - 在这种情况下,沿所有轴计算最大值(如numpy)
  • 沿此轴计算的int
  • a ints列表 - 沿这些轴计算
theano.tensor.argmax(x, axis=None, keepdims=False)[source]
参数:x — 符号张量(或兼容的)
参数:axis — 沿其计算最大值的索引的轴
参数:keepdims —(布尔)如果设置为True,则规约的轴将留在结果中作为大小为1的维。使用此选项,结果将相对原始张量正确broadcast 。
返回:沿给定轴的最大值的索引
如果axis = None,Theano 0.5rc1或更高版本:argmax则在扁平化的张量上计算(类似numpy)
old:那么轴被假定为ndim(x)-1
theano.tensor.max_and_argmax(x, axis=None, keepdims=False)[source]
参数:x - 符号Tensor(或兼容)
参数:axis - 沿其计算最大值及其索引
参数:keepdims - (boolean)如果设置为True,则缩小的轴将留在结果中作为尺寸为1的维。使用此选项,结果将相对原始张量正确广播。
返回:沿给定轴的最大值及其索引。
如果axis = None,Theano 0.5rc1或更高版本:max_and_argmax在扁平张量(如numpy)
old:那么轴被假定为ndim(x)-1
theano.tensor.min(x, axis=None, keepdims=False)[source]
参数:x - 符号Tensor(或兼容)
参数:axis轴或沿其计算最小值的轴
参数:keepdims - (boolean)如果设置为True,则缩小的轴将作为尺寸为1的尺寸留在结果中。使用此选项,结果将相对原始张量正确广播。
返回:沿的最小x
轴可以是:
  • - 在这种情况下,沿所有轴计算最小值(如numpy)
  • 沿此轴计算的int
  • a ints列表 - 沿这些轴计算
theano.tensor.argmin(x, axis=None, keepdims=False)[source]
参数:x - 符号Tensor(或兼容)
参数:axis - 沿其计算最小值的索引
参数:keepdims - (boolean)如果设置为True,则缩小的轴将作为尺寸为1的尺寸留在结果中。使用此选项,结果将相对原始张量正确广播。
返回:沿给定轴的最小值的索引
如果axis = None,Theano 0.5rc1或更高版本:argmin超过张量张量(如numpy)
old:那么轴被假定为ndim(x)-1
theano.tensor.sum(x, axis=None, dtype=None, keepdims=False, acc_dtype=None)[source]
参数:

x - 符号Tensor(或兼容)

参数:

axis — 一个或多个轴,将沿着它(们)计算和

参数:

dtype - 返回的张量的dtype。如果为None,那么我们使用与输入张量dtype相同的默认dtype,除非:

  • 输入dtype是有符号的精度整数
  • 输入dtype是无符号的精度整数

此默认dtype的_not_取决于“acc_dtype”的值。

参数:

keepdims - (boolean)如果设置为True,则缩小的轴将作为尺寸为1的尺寸留在结果中。使用此选项,结果将相对原始张量正确广播。

参数:

acc_dtype - 内部累加器的dtype。如果为None(默认),我们使用下面列表中的dtype,如果输入dtype的精度较高,则使用input dtype:

  • 对于int类型,我们至少使用int64;
  • 对于uint dtypes,我们至少使用uint64;
  • 对于float dtypes,我们至少使用float64;
  • 对于复杂的类型,我们至少使用complex128。
返回:

x沿axis的和

axis可以是:
  • None — 在这种情况下,沿所有轴计算和(类似numpy)
  • 一个int — 沿这个轴计算
  • 一个int的列表 — 沿这些轴计算
theano.tensor.prod(x, axis=None, dtype=None, keepdims=False, acc_dtype=None, no_zeros_in_input=False)[source]
参数:

x - 符号Tensor(或兼容)

参数:

axis轴或沿其计算产品的轴

参数:

dtype - 返回的张量的dtype。如果为None,那么我们使用与输入张量dtype相同的默认dtype,除非:

  • 输入dtype是有符号的精度整数
  • 输入dtype是无符号的精度整数

此默认dtype的_not_取决于“acc_dtype”的值。

参数:

keepdims - (boolean)如果设置为True,则缩小的轴将作为尺寸为1的尺寸留在结果中。使用此选项,结果将相对原始张量正确广播。

参数:

acc_dtype - 内部累加器的dtype。如果为None(默认),我们使用下面列表中的dtype,如果输入dtype的精度较高,则使用input dtype:

  • 对于int类型,我们至少使用int64;
  • 对于uint dtypes,我们至少使用uint64;
  • 对于float dtypes,我们至少使用float64;
  • 对于复杂的类型,我们至少使用complex128。
参数:

no_zeros_in_input - prod的grad是复杂的,因为我们需要处理3种不同的情况:在输入reduce组中没有零,有一个零或多个零。

这可能会拖慢你,但更重要的是,我们目前不支持3个案例的第二导数。所以你不能采取默认prod()的第二导数。

为了去除0的特殊情况的处理,所以得到一些小的加速,并允许第二导数集no_zeros_in_inputsTrue它默认为False

用户有责任确保输入中没有零。如果有,grad会错误。

返回:

沿x中每个项的乘积

轴可以是:
  • - 在这种情况下,沿所有轴计算和(如numpy)
  • 沿此轴计算的int
  • a ints列表 - 沿这些轴计算
theano.tensor.mean(x, axis=None, dtype=None, keepdims=False, acc_dtype=None)[source]
参数:x - 符号Tensor(或兼容)
参数:axis轴或沿其计算平均值的轴
参数:dtype - 将内部求和的结果转换为dtype。例如,默认情况下,float32张量的总和将在float64中完成(acc_dtype在默认情况下将是float64),但是该结果将被放回float32。
参数:keepdims - (boolean)如果设置为True,则缩小的轴将作为尺寸为1的尺寸留在结果中。使用此选项,结果将相对原始张量正确广播。
参数:acc_dtype - 内部求和的内部累加器的dtype。这不一定是输出的dtype(特别是如果它是一个离散(int / uint)dtype,输出将是一个float类型)。如果为None,那么我们使用与sum()相同的规则。
返回:沿着x的平均值
轴可以是:
  • - 在这种情况下,平均值沿所有轴计算(如numpy)
  • 沿此轴计算的int
  • a ints列表 - 沿这些轴计算
theano.tensor.var(x, axis=None, keepdims=False)[source]
参数:x - 符号Tensor(或兼容)
参数:axis轴或沿其计算方差的轴
参数:keepdims - (boolean)如果设置为True,则缩小的轴将作为尺寸为1的尺寸留在结果中。使用此选项,结果将相对原始张量正确广播。
返回:x沿的方差
轴可以是:
  • - 在这种情况下,方差沿所有轴计算(如numpy)
  • 沿此轴计算的int
  • a ints列表 - 沿这些轴计算
theano.tensor.std(x, axis=None, keepdims=False)[source]
参数:x - 符号Tensor(或兼容)
参数:轴或沿其计算标准偏差的轴
参数:keepdims - (boolean)如果设置为True,则缩小的轴将作为尺寸为1的尺寸留在结果中。使用此选项,结果将相对原始张量正确广播。
返回:x沿的方差
轴可以是:
  • - 在这种情况下,沿所有轴计算标准偏差(如numpy)
  • 沿此轴计算的int
  • a ints列表 - 沿这些轴计算
theano.tensor.all(x, axis=None, keepdims=False)[source]
参数:x - 符号Tensor(或兼容)
参数: - 要沿其应用的轴或“
参数:keepdims - (boolean)如果设置为True,则缩小的轴将作为尺寸为1的尺寸留在结果中。使用此选项,结果将相对原始张量正确广播。
返回:以及沿x
轴可以是:
  • - 在这种情况下'沿位和'沿所有轴计算(如numpy)
  • 沿此轴计算的int
  • a ints列表 - 沿这些轴计算
theano.tensor.any(x, axis=None, keepdims=False)[source]
参数:x - 符号Tensor(或兼容)
参数: - 按位或沿应用的轴
参数:keepdims - (boolean)如果设置为True,则缩小的轴将作为尺寸为1的尺寸留在结果中。使用此选项,结果将相对原始张量正确广播。
返回:或沿x
轴可以是:
  • - 在这种情况下'沿位或'沿所有轴计算(如numpy)
  • 沿此轴计算的int
  • a ints列表 - 沿这些轴计算
theano.tensor.ptp(x, axis = None)[source]

沿轴的值范围(最大 - 最小)。函数的名称来自峰到峰的首字母缩写。

参数:x输入张量。
参数:axis用于查找峰的轴。默认情况下,展平数组。
返回:保存结果的新数组。

索引

与NumPy一样,Theano区分基本高级索引。Theano完全支持基本索引(参见NumPy的索引)和整数高级索引我们不支持布尔掩码,因为Theano没有布尔类型(我们使用int8作为逻辑运算符的输出)。

带掩码的NumPy:

>>> n = np.arange(9).reshape(3,3)
>>> n[n > 4]
array([5, 6, 7, 8])

Theano索引与“掩码”(不正确的方法):

>>> t = theano.tensor.arange(9).reshape((3,3))
>>> t[t > 4].eval()  # an array with shape (3, 3, 3)  
Traceback (most recent call last):
  ...
TypeError: TensorType does not support boolean mask for indexing such as tensor[x==0].
Instead you can use non_zeros() such as tensor[(x == 0).nonzeros()].
If you are indexing on purpose with an int8, please cast it to int16.

获取像NumPy的一个Theano结果:

>>> t[(t > 4).nonzero()].eval()
array([5, 6, 7, 8])

索引赋值不支持如果你想做像a[5] = ba[5]+=b,请参阅theano.tensor.set_subtensor()theano.tensor.inc_subtensor()

theano.tensor.set_subtensor(x, y, inplace=False, tolerate_inplace_aliasing=False)[source]

返回x,给定的subtensor被y覆盖。

参数:
  • x —— 等号操作左值的符号变量。
  • y —— 等号操作右值的符号变量。
  • tolerate_inplace_aliasing —— 请参阅inc_subtensor文档。

例子

要得到numpy的表达式“r[10:] = 5”的等效操作,请键入

>>> r = ivector()
>>> new_r = set_subtensor(r[10:], 5)
theano.tensor.inc_subtensor(x, y, inplace=False, set_instead_of_inc=False, tolerate_inplace_aliasing=False)[source]

返回x,其给定的subtensor增加y。

参数:
  • x —— Subtensor操作的符号结果。
  • y —— 给所讨论的subtensor增加的值。
  • inplace —— 不要使用。Theano将尽可能做到。
  • set_instead_of_inc —— 如果为True,则改用set_subtensor。
  • tolerate_inplace_aliasing —— 允许x和y是单个底层数组的视图,即使在原位工作。为了正确的结果,x和y不能是重叠的视图;如果它们重叠,则该操作的结果通常是不正确的。如果inplace= alse,则此值不起作用。

例子

要复制numpy表达式“r[10:] += 5”,请键入

>>> r = ivector()
>>> new_r = inc_subtensor(r[10:], 5)

运算符的支持

支持许多Python运算符。

>>> a, b = T.itensor3(), T.itensor3() # example inputs

算数运算

>>> a + 3      # T.add(a, 3) -> itensor3
>>> 3 - a      # T.sub(3, a)
>>> a * 3.5    # T.mul(a, 3.5) -> ftensor3 or dtensor3 (depending on casting)
>>> 2.2 / a    # T.truediv(2.2, a)
>>> 2.2 // a   # T.intdiv(2.2, a)
>>> 2.2**a     # T.pow(2.2, a)
>>> b % a      # T.mod(b, a)

位级别的运算

>>> a & b      # T.and_(a,b)    bitwise and (alias T.bitwise_and)
>>> a ^ 1      # T.xor(a,1)     bitwise xor (alias T.bitwise_xor)
>>> a | b      # T.or_(a,b)     bitwise or (alias T.bitwise_or)
>>> ~a         # T.invert(a)    bitwise invert (alias T.bitwise_not)

原位运算

原位运算符支持。Theano的图优化将确定用于原位运算的中间值。如果你想更新shared variable的值,请考虑使用theano.function()updates参数。

元素级别的运算

类型转换

theano.tensor.cast(x, dtype)[source]

将任何张量x cast为相同形状的Tensor,但具有不同的数值类型dtype

这不是reinterpret cast,而是类似于numpy.asarray(x, dtype=dtype)的coersion cast。

import theano.tensor as T
x = T.matrix()
x_as_int = T.cast(x, 'int32')

尝试cast一个复数值为实数值是有歧义的,并会引发异常。使用real()imag()abs()angle()

theano.tensor.real(x)[source]

返回Tensor x的实数(不是虚数)分量。对于非复数x,此函数返回x。

theano.tensor.imag(x)[source]

返回Tensor x的虚部分量。对于非复数x,此函数返回zeros_like(x)。

比较运算

通常的六个相等和不相等运算符共享同一个接口。
参数:a —— 符号张量(或兼容的)
参数:b —— 符号张量(或兼容的)
返回类型:符号张量
返回:一个符号张量,表示元素级别逻辑运算符的应用结果。

注意

Theano没有布尔类型。取而代之的是,所有布尔张量用'int8'表示。

下面是一个使用小于运算符的示例。

import theano.tensor as T
x,y = T.dmatrices('x','y')
z = T.le(x,y)
theano.tensor.lt(a, b)[source]

Returns a symbolic 'int8' tensor representing the result of logical less-than (a

也可以使用语法a < b

theano.tensor.gt(a, b)[source]

返回表示逻辑大于(a> b)的结果的符号'int8'张量。

也可使用语法a > b

theano.tensor.le(a, b)[source]

返回表示逻辑小于或等于的结果的变量(a

也可使用语法a b

theano.tensor.ge(a, b)[source]

返回表示逻辑大于或等于(a> = b)的结果的变量。

也可使用语法a > = b

theano.tensor.eq(a, b)[source]

返回表示逻辑等式(a == b)结果的变量。

theano.tensor.neq(a, b)[source]

返回表示逻辑不等式结果的变量(a!= b)。

theano.tensor.isnan(a)[source]

返回表示a元素与nan的比较的变量。

这相当于numpy.isnan

theano.tensor.isinf(a)[source]

返回表示a元素与inf或-inf的比较的变量。

这相当于numpy.isinf

theano.tensor.isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)[source]

返回表示两个张量在公差内相等的符号'int8'张量。

公差值为正,通常为非常小的数字。The relative difference (rtol * abs(b)) and the absolute difference atol are added together to compare against the absolute difference between a and b.

对于有限值,isclose使用以下公式来测试两个浮点值是否相等:| a - b | &lt; = (atol + rtol * | b | t9>

对于无限值,isclose将检查这两个值是否都是相同的有符号的inf值。

如果equal_nan为True,isclose认为同一位置的NaN值接近。否则,NaN值不被认为接近。

这相当于numpy.isclose

theano.tensor.allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)[source]

返回一个符号'int8'的值,表示两个张量中的所有元素在公差内是否相等。

请参见isclose中的注释,以确定在公差内的值相等。

这相当于numpy.allclose

条件

theano.tensor.switch(cond, ift, iff)[source]
返回表示在ift(iftrue)和iff(iffalse)之间切换的变量。

基于条件cond。这是theano中相当于numpy.where的运算。

参数:cond —— 符号张量(或兼容的)
参数:ift —— 符号张量(或兼容的)
参数:iff —— 符号张量(或兼容的)
返回类型:符号张量
import theano.tensor as T
a,b = T.dmatrices('a','b')
x,y = T.dmatrices('x','y')
z = T.switch(T.lt(a,b), x, y)
theano.tensor.where(cond, ift, iff)[source]

switch的别名。where是numpy中的名称。

theano.tensor.clip(x, min, max)[source]

返回一个代表x的变量,但所有大于max的元素截取到max,所有小于min的元素截取到min

正常broadcasting规则适用于xminmax中的每一个。

位级别的运算

位级别的运算符拥有这个接口:
参数:a - 整数类型的符号Tensor。
参数:b - 整数类型的符号Tensor。

注意

按位运算符必须具有整数类型作为输入。

比特式不(反转)只需要一个参数。

返回类型:符号Tensor与相应的dtype。
theano.tensor.and_(a, b)[source]

返回表示按位和的结果的变量。

theano.tensor.or_(a, b)[source]

返回一个表示按位或的结果的变量。

theano.tensor.xor(a, b)[source]

返回一个表示按位xor结果的变量。

theano.tensor.invert(a)[source]

返回表示按位的结果的变量not。

theano.tensor.bitwise_and(a, b)[source]

和_的别名。bitwise_and是numpy名称。

theano.tensor.bitwise_or(a, b)[source]

或_的别名。bitwise_or是numpy名称。

theano.tensor.bitwise_xor(a, b)[source]

xor _的别名。bitwise_xor是numpy名称。

theano.tensor.bitwise_not(a, b)[source]

反转别名。invert是numpy名称。

这里是一个使用位操作符and_的示例:&

import theano.tensor as T
x,y = T.imatrices('x','y')
z = x & y

数学运算

theano.tensor.abs_(a)[source]

返回表示a的绝对值的变量,即|a|

注意

也可以使用abs(a)访问。

theano.tensor.angle(a)[source]

返回表示复值Tensor a的角分量的变量。

theano.tensor.exp(a)[source]

返回一个变量,表示a的指数,即e^a。

theano.tensor.maximum(a, b)[source]

返回表示a和b的元素的最大元素的变量

theano.tensor.minimum(a, b)[source]

返回表示a和b的元素的最小元素的变量

theano.tensor.neg(a)[source]

返回表示a(也为-a)否定的变量。

theano.tensor.inv(a)[source]

返回表示a的倒数的变量,即1.0 / a。也称为互惠。

theano.tensor.log(a), log2(a), log10(a)[source]

返回表示a的基数e,2或10的对数的变量。

theano.tensor.sgn(a)[source]

返回表示a的符号的变量。

theano.tensor.ceil(a)[source]

返回表示a的顶点的变量(例如ceil(2.1)为3)。

theano.tensor.floor(a)[source]

返回表示a的底的变量(例如floor(2.9)为2)。

theano.tensor.round(a, mode="half_away_from_zero")[source]

返回表示与a相同的dtype中的a的舍入的变量。实现的舍入模式为half_away_from_zero和half_to_even。

theano.tensor.iround(a, mode="half_away_from_zero")[source]

短手为cast(round(a,mode),'int64')。

theano.tensor.sqr(a)[source]

返回表示a的平方的变量,即a ^ 2。

theano.tensor.sqrt(a)[source]

返回一个表示a的变量,即a ^ 0.5。

theano.tensor.cos(a), sin(a), tan(a)[source]

返回表示(余弦,正弦和正切)的三角函数的变量。

theano.tensor.cosh(a), sinh(a), tanh(a)[source]

返回一个变量,表示(双曲余弦、正弦和正切)的双曲线三角函数。

theano.tensor.erf(a), erfc(a)[source]

返回表示错误函数或补偿误差函数的变量。维基百科

theano.tensor.erfinv(a), erfcinv(a)[source]

返回表示反向误差函数或反向互补误差函数的变量。维基百科

theano.tensor.gamma(a)[source]

返回表示gamma函数的变量。

theano.tensor.gammaln(a)[source]

返回表示伽马函数的对数的变量。

theano.tensor.psi(a)[source]

返回表示伽马函数(也称为digamma函数)的对数的导数的变量。

theano.tensor.chi2sf(a, df)[source]

返回一个代表生存函数的变量(1-cdf - 有时更精确)。

C代码在Theano_lgpl存储库中提供。这使它更快。

https://github.com/Theano/Theano_lgpl.git

Theano和Numpy中的Broadcasting

Broadcasting是一种机制,通过沿着缺少的维度(虚拟地)复制较小张量,允许具有不同维度数量的张量相加或相乘。

Broadcasting是标量与矩阵相加、向量与矩阵相加、或标量与向量相加的机制。

../../_images/bcast.png

Broadcasting一个行矩阵。T和F分别代表True和False,表示我们允许broadcasting的维度。

如果第二个参数是向量,其形状将是(2,)及其broadcastable模式将为(F,)它们将自动向扩展以匹配矩阵的维度(将1添加到形状,将T添加到模式),结果为(1, 2)(T, F)然后它的行为就像上面的例子。

与动态broadcasting的numpy不同,对于任何支持broadcasting的操作,Theano需要知道要broadcast哪些维度。如果适用,此信息在变量Type中给出。

另见:

线性代数

theano.tensor.dot(X, Y)[source]
对于2-D数组,其等效于矩阵乘法,对于1-D数组等效于向量的内积(没有复共轭)。对于N维,它是a的最后一个轴和b的倒数第二个轴的积的和:
参数:
  • X符号张量)— 左项
  • Y符号张量)— 右项
返回类型:

符号矩阵或向量

返回:

XY的内积。

theano.tensor.outer(X, Y)[source]
参数:
  • X符号向量) - 左项
  • Y符号向量) - 右项
返回类型:

符号矩阵

返回:

矢量 - 外部产品

theano.tensor.tensordot(a, b, axes=2)[source]

给定两个张量a和b,tensordot计算在所提供的轴上的广义点积。Theano的实现减少了矩阵或向量点积的所有表达式,并且基于来自Tijmen Tieleman的gnumpy(http://www.cs.toronto.edu/~tijmen/gnumpy.html)的代码。

参数:
  • a符号张量) - 第一个张量变量
  • b符号张量) - 第二个张量变量
  • axesint 长度为2的数组)

    整数或数组。如果是整数,则要求的轴数。如果是数组,它必须有两个数组元素,包含在每个张量中求和的轴。

    请注意,默认值2不能保证适用于a和b的所有值,如果是这种情况,将会引发错误。保持默认值的原因是保持与numpy的tensordot函数相同的签名(并且np.tensordot引起非兼容输入的类似错误)。

    如果是整数i,则将其转换为包含第一张量的最后i维和第二张量的第一i维的阵列:

    axis = [range(a.ndim-i,b.ndim),range(i)]

    如果是一个数组,它的两个元素必须包含两个张量的兼容轴。例如,[[1,2],[2,0]]表示a的第2轴和第3轴以及b的第3轴和第1轴的总和。(记住轴是零索引的!)a的第2轴和b的第3轴必须具有相同的形状;对于a的第3轴和b的第1轴也是如此。

返回:

形状等于a的形状(减去被求和后的任何尺寸)和b的形状(减去被求和后的任何尺寸)的连接的张量。

返回类型:

符号张量

它可能有助于考虑一个例子,看看什么tensordot。Theano的实现与NumPy的实现相同。这里,a具有形状(2,3,4),b具有形状(5,6,4,3)。总和的轴是[[1,2],[3,2]] - 注意a.shape [1] == b.shape [3]和a.shape [2] == b.shape [2] ];这些轴是兼容的。所得到的张量将具有形状(2,5,6) - 不被求和的尺寸:

import numpy as np

a = np.random.random((2,3,4))
b = np.random.random((5,6,4,3))

#tensordot
c = np.tensordot(a, b, [[1,2],[3,2]])

#loop replicating tensordot
a0, a1, a2 = a.shape
b0, b1, _, _ = b.shape
cloop = np.zeros((a0,b0,b1))

#loop over non-summed indices -- these exist
#in the tensor product.
for i in range(a0):
    for j in range(b0):
        for k in range(b1):
            #loop over summed indices -- these don't exist
            #in the tensor product.
            for l in range(a1):
                for m in range(a2):
                    cloop[i,j,k] += a[i,l,m] * b[j,k,m,l]

assert np.allclose(c, cloop)

这种具体实施方式通过调换a和b,使得a的总和轴是last,b的总和轴是first,从而避免了循环。所得到的阵列被重新成形为2维(或者如果合适的话留作矢量),并且获取矩阵或矢量点积。结果将重新整形为所需的输出尺寸。

在极端情况下,不能指定轴。所得到的张量将具有等于a和b的形状的级联的形状:

>>> c = np.tensordot(a, b, 0)
>>> a.shape
(2, 3, 4)
>>> b.shape
(5, 6, 4, 3)
>>> print(c.shape)
(2, 3, 4, 5, 6, 4, 3)
注意:有关更多示例,请参阅numpy.tensordot的文档。
theano.tensor.batched_dot(X, Y)[source]
参数:
  • x - 大小为例如:3D(dim1,dim3,dim2)
  • y - 尺寸例如为:3D(dim1,dim2,dim4)

此函数通过使用扫描对第一维进行迭代来计算两个张量之间的点积。返回大小的张量,例如如果是3D:(dim1,dim3,dim4)示例:

>>> first = T.tensor3('first')
>>> second = T.tensor3('second')
>>> result = batched_dot(first, second)
注意:

这是numpy.einsum的子集,但我们现在不提供它。但是numpy einsum比点或tensordot慢:http://mail.scipy.org/pipermail/numpy-discussion/2012-October/064259.html

参数:
  • X符号张量) - 左项
  • Y符号张量) - 右项
返回:

张量产品

theano.tensor.batched_tensordot(X, Y, axes=2)[source]
参数:
  • x - 大小为例如:3D(dim1,dim3,dim2)
  • y - 尺寸例如为:3D(dim1,dim2,dim4)
  • axesint 长度为2的数组)

    整数或数组。如果是整数,则要求的轴数。如果是数组,它必须有两个数组元素,包含在每个张量中求和的轴。

    如果是整数i,则将其转换为包含第一张量的最后i个维度和第二张量的第一个i维度(不包括第一(批次)维度)的数组:

    axes = [range(a.ndim - i, b.ndim), range(1,i+1)]
    

    如果是一个数组,它的两个元素必须包含两个张量的兼容轴。例如,[[1,2],[2,4]]表示a的第2轴和第3轴以及b的第3轴和第5轴的总和。(记住轴是零索引的!)a的第2轴和b的第3轴必须具有相同的形状;对于a的第3轴和b的第5轴也是如此。

返回:

形状等于a的形状(小于被求和的任何尺寸)和b的形状(小于第一维度和被求和的任何尺寸)的级联的张量。

返回类型:

张量数十

混合batch_dot和tensordot,此函数计算两个张量之间的tensordot乘积,通过使用扫描迭代第一维,以执行一系列的十点。

注意:有关补充文档,请参见tensordot()batched_dot()
theano.tensor.mgrid()[source]
返回:一个在索引时返回密集(或清除)网格的实例,以便每个返回的参数具有相同的形状。输出数组的维数和数量等于索引维数。如果步长不是复数,则停止不包括。

例:

>>> a = T.mgrid[0:5, 0:3]
>>> a[0].eval()
array([[0, 0, 0],
       [1, 1, 1],
       [2, 2, 2],
       [3, 3, 3],
       [4, 4, 4]])
>>> a[1].eval()
array([[0, 1, 2],
       [0, 1, 2],
       [0, 1, 2],
       [0, 1, 2],
       [0, 1, 2]])
theano.tensor.ogrid()[source]
返回:一个在索引时返回一个打开(即不是清理出)网格的实例,使得每个返回的数组只有一个维度大于1。输出数组的维数和数量等于索引维数。如果步长不是复数,则停止不包括。

例:

>>> b = T.ogrid[0:5, 0:3]
>>> b[0].eval()
array([[0],
       [1],
       [2],
       [3],
       [4]])
>>> b[1].eval()
array([[0, 1, 2]])

梯度/微分

梯度计算的驱动程序。

theano.gradient.grad(cost, wrt, consider_constant=None, disconnected_inputs='raise', add_names=True, known_grads=None, return_disconnected='zero', null_gradients='raise')[source]

返回某个cost对于一个或多个变量的符号梯度。

Theano中自动微分如何工作的有关更多信息,请参见gradient有关如何实现某个Op的梯度的信息,请参见grad()

参数:
  • cost标量0维张量None)— 我们微分所涉及的值。如果提供known_grads,可以为None
  • wrt变量变量列表)— 我们想要的梯度的项。
  • consider_constant变量列表)— 不反向传播的表达式。
  • disconnected_inputs ({'ignore', 'warn', 'raise'}) —

    如果wrt中的某些变量不是计算图计算cost的一部分(或者所有链接都是不可微分的),则定义相应的行为。可能的值为:

    • 'ignore':认为这些参数的梯度为零。
    • 'warn':认为梯度为零,并打印警告。
    • 'raise':引发DisconnectedInputError。
  • add_names(布尔值)— 如果为True,grad生成的变量将命名为(d<cost.name>/d<wrt.name>),只要cost和wrt都具有名字。
  • known_gradsdict可选)— 一个字典,映射变量到其梯度。这在你知道一些变量的梯度但不知道原始cost的情况下是有用的。
  • return_disconnected ({'zero', 'None', 'Disconnected'}) —
    • ‘zero’
      如果wrt[i]断开,返回值i将为
      wrt [i] .zeros_like()
    • ‘None’
      如果wrt[i]断开,返回值i将为
      None
    • “Disconnected”:返回DisconnectedType类型的变量
  • null_gradients ({'raise', 'return'}) —

    定义wrt中的某些变量具有空梯度时的行为。可能值为:

    • 'raise':引发一个NullTypeGradError异常
    • 'return':返回空梯度
返回:

cost相对于wrt项中的每一个的梯度的符号表达式。如果wrt的元素相对于输出不可微分,则返回零变量。

返回类型:

变量或变量组成的列表/元组(匹配wrt

有关梯度模块的完整文档,请参见gradient页面。