def make_node(self, inp, ws, stride=None, pad=None):
ctx_name = infer_context_name(inp)
inp = as_gpuarray_variable(inp, ctx_name)
nd = self.ndim
assert (inp.ndim == nd + 2)
if stride is None:
stride = ws
if pad is None:
pad = (0,) * nd
elif isinstance(pad, (tuple, list)):
if max(pad) != 0 and not self.ignore_border:
raise ValueError('Padding works only with ignore_border=True')
if isinstance(ws, (tuple, list)):
if any(pad[i] >= ws[i] for i in range(nd)):
raise ValueError('Padding must be smaller than strides')
ws = as_tensor_variable(ws)
stride = as_tensor_variable(stride)
pad = as_tensor_variable(pad)
assert ws.ndim == stride.ndim and ws.ndim == pad.ndim
assert ws.ndim == 1
if ws.dtype not in theano.tensor.int_dtypes:
raise TypeError('Window shape parameters must be ints.')
if stride.dtype not in theano.tensor.int_dtypes:
raise TypeError('Stride parameters must be ints.')
if pad.dtype not in theano.tensor.int_dtypes:
raise TypeError('Padding parameters must be ints.')
ws = theano.tensor.cast(ws, 'int64')
stride = theano.tensor.cast(stride, 'int64')
pad = theano.tensor.cast(pad, 'int64')
return Apply(self, [inp, ws, stride, pad], [inp.type()])
def make_node(self, inp, out, out_grad, ws, stride=None, pad=None):
ctx_name = infer_context_name(inp, out, out_grad)
nd = self.ndim
inp = as_gpuarray_variable(inp, ctx_name)
assert (inp.ndim == nd + 2)
out = as_gpuarray_variable(out, ctx_name)
assert (out_grad.ndim == nd + 2)
out_grad = as_gpuarray_variable(out_grad, ctx_name)
assert (out.ndim == nd + 2)
assert (out_grad.ndim == inp.ndim)
assert (inp.ndim == out.ndim)
if stride is None:
stride = ws
if pad is None:
pad = (0,) * nd
ws = as_tensor_variable(ws)
stride = as_tensor_variable(stride)
pad = as_tensor_variable(pad)
assert ws.ndim == stride.ndim and ws.ndim == pad.ndim
assert ws.ndim == 1
if ws.dtype not in theano.tensor.int_dtypes:
raise TypeError('Window shape parameters must be ints.')
if stride.dtype not in theano.tensor.int_dtypes:
raise TypeError('Stride parameters must be ints.')
if pad.dtype not in theano.tensor.int_dtypes:
raise TypeError('Padding parameters must be ints.')
ws = theano.tensor.cast(ws, 'int64')
stride = theano.tensor.cast(stride, 'int64')
pad = theano.tensor.cast(pad, 'int64')
return Apply(self, [inp, out, out_grad, ws, stride, pad], [inp.type()])
def make_node(self, inp, out_grad, ws, stride=None, pad=None):
ctx_name = infer_context_name(inp, out_grad)
nd = self.ndim
inp = as_gpuarray_variable(inp, ctx_name)
assert (inp.ndim == nd + 2)
out_grad = as_gpuarray_variable(out_grad, ctx_name)
assert (out_grad.ndim == nd + 2)
assert (out_grad.ndim == inp.ndim)
if stride is None:
stride = ws
if pad is None:
pad = (0,) * nd
elif isinstance(pad, (tuple, list)):
if max(pad) != 0 and not self.mode == 'average_exc_pad':
raise ValueError('Padding must be zero for average_exc_pad')
ws = as_tensor_variable(ws)
stride = as_tensor_variable(stride)
pad = as_tensor_variable(pad)
assert ws.ndim == stride.ndim and ws.ndim == pad.ndim
assert ws.ndim == 1
if ws.dtype not in theano.tensor.int_dtypes:
raise TypeError('Window shape parameters must be ints.')
if stride.dtype not in theano.tensor.int_dtypes:
raise TypeError('Stride parameters must be ints.')
if pad.dtype not in theano.tensor.int_dtypes:
raise TypeError('Padding parameters must be ints.')
ws = theano.tensor.cast(ws, 'int64')
stride = theano.tensor.cast(stride, 'int64')
pad = theano.tensor.cast(pad, 'int64')
return Apply(self, [inp, out_grad, ws, stride, pad], [inp.type()])
def make_node(self, V, W, b, d):
"""
Parameters
----------
V
Visible unit, input(batch,row,column,time,in channel)
W
Weights, filter(out channel,row,column,time,in channel)
b
bias, shape == (W.shape[0],)
d
strides when moving the filter over the input(dx,dy,dt)
"""
V_ = T.as_tensor_variable(V)
W_ = T.as_tensor_variable(W)
b_ = T.as_tensor_variable(b)
d_ = T.as_tensor_variable(d)
bcast = (V_.broadcastable[0], False, False, False, W_.broadcastable[0])
node = theano.Apply(self, inputs=[V_, W_, b_, d_],
outputs=[T.TensorType(V_.dtype, bcast)()])
return node
def make_node(self, V, d, WShape, dCdH):
V_ = T.as_tensor_variable(V)
d_ = T.as_tensor_variable(d)
WShape_ = T.as_tensor_variable(WShape)
dCdH_ = T.as_tensor_variable(dCdH)
return theano.Apply(self, inputs=[V_, d_, WShape_, dCdH_], outputs = [ T.TensorType(V_.dtype, (False,False,False,False,False))() ] )
def make_node(self, C, alpha, A, B, beta):
alpha = as_tensor_variable(alpha)
beta = as_tensor_variable(beta)
A = as_gpuarray_variable(A)
B = as_gpuarray_variable(B)
C = as_gpuarray_variable(C)
assert A.dtype == B.dtype == C.dtype
return Apply(self, [C, alpha, A, B, beta], [C.type()])
def make_node(self, a, *shape):
a = basic.as_tensor_variable(a)
shape = basic.as_tensor_variable(shape, ndim=1)
shape, bcast = basic.alloc_validate_shape(shape)
out = type(a.type)(dtype=a.type.dtype, broadcastable=bcast)()
return theano.Apply(self, [a] + shape, [out])
def make_node(self, V, d, WShape, dCdH):
V_ = T.as_tensor_variable(V)
d_ = T.as_tensor_variable(d)
WShape_ = T.as_tensor_variable(WShape)
dCdH_ = T.as_tensor_variable(dCdH)
return theano.Apply(
self,
inputs=[V_, d_, WShape_, dCdH_],
outputs=[
T.TensorType(V_.dtype, (False, False, False, False, False))()
])
def make_node(self, dy, sm):
dy = tensor.as_tensor_variable(dy)
sm = tensor.as_tensor_variable(sm)
if dy.type.ndim not in (1, 2) \
or dy.type.dtype not in tensor.float_dtypes:
raise ValueError('dy must be 1-d or 2-d tensor of floats. Got ',
dy.type)
if dy.ndim == 1:
dy = tensor.shape_padleft(dy, n_ones=1)
if sm.ndim == 1:
sm = tensor.shape_padleft(sm, n_ones=1)
return Apply(self, [dy, sm], [sm.type()])
def make_node(self, a, val):
a = basic.as_tensor_variable(a)
val = basic.as_tensor_variable(val)
if a.ndim < 2:
raise TypeError("%s: first parameter must have at least"
" two dimensions" % self.__class__.__name__)
elif val.ndim != 0:
raise TypeError("%s: second parameter must be a scalar" %
self.__class__.__name__)
val = basic.cast(val, dtype=upcast(a.dtype, val.dtype))
if val.dtype != a.dtype:
raise TypeError("%s: type of second parameter must be the same as"
" the first's" % self.__class__.__name__)
return Apply(self, [a, val], [a.type()])
def make_node(self, C, alpha, A, B, beta):
ctx_name = infer_context_name(C, A, B)
A = as_gpuarray_variable(A, ctx_name)
B = as_gpuarray_variable(B, ctx_name)
C = as_gpuarray_variable(C, ctx_name)
alpha = as_tensor_variable(alpha)
beta = as_tensor_variable(beta)
assert alpha.ndim == 0
assert beta.ndim == 0
assert A.ndim == 2
assert B.ndim == 2
assert C.ndim == 2
assert A.dtype == B.dtype == C.dtype
return Apply(self, [C, alpha, A, B, beta], [C.type()])
def make_node(self, y, alpha, A, x, beta):
ctx_name = infer_context_name(y, A, x)
A = as_gpuarray_variable(A, ctx_name)
x = as_gpuarray_variable(x, ctx_name)
y = as_gpuarray_variable(y, ctx_name)
alpha = as_tensor_variable(alpha)
beta = as_tensor_variable(beta)
assert alpha.ndim == 0
assert beta.ndim == 0
assert A.ndim == 2
assert x.ndim == 1
assert y.ndim == 1
assert A.dtype == x.dtype == y.dtype
return Apply(self, [y, alpha, A, x, beta], [y.type()])
def make_node(self, y, alpha, A, x, beta):
ctx_name = infer_context_name(y, A, x)
A = as_gpuarray_variable(A, ctx_name)
x = as_gpuarray_variable(x, ctx_name)
y = as_gpuarray_variable(y, ctx_name)
alpha = as_tensor_variable(alpha).astype('float64')
beta = as_tensor_variable(beta).astype('float64')
assert alpha.ndim == 0
assert beta.ndim == 0
assert A.ndim == 2
assert x.ndim == 1
assert y.ndim == 1
assert A.dtype == x.dtype == y.dtype
return Apply(self, [y, alpha, A, x, beta], [y.type()])
def make_node(self, C, alpha, A, B, beta):
ctx_name = infer_context_name(C, A, B)
A = as_gpuarray_variable(A, ctx_name)
B = as_gpuarray_variable(B, ctx_name)
C = as_gpuarray_variable(C, ctx_name)
alpha = as_tensor_variable(alpha).astype('float64')
beta = as_tensor_variable(beta).astype('float64')
assert alpha.ndim == 0
assert beta.ndim == 0
assert A.ndim == 3
assert B.ndim == 3
assert C.ndim == 3
assert A.dtype == B.dtype == C.dtype
return Apply(self, [C, alpha, A, B, beta], [C.type()])
def make_node(self, indices, dims):
indices = basic.as_tensor_variable(indices)
dims = basic.as_tensor_variable(dims)
if indices.dtype not in basic.int_dtypes:
raise TypeError("'%s' object cannot be interpreted as an index" % str(indices.dtype))
if dims.dtype not in basic.int_dtypes:
raise TypeError("'%s' object cannot be interpreted as an index" % str(dims.dtype))
if dims.ndim != 1:
raise TypeError("dims must be a 1D array")
return gof.Apply(
self, [indices, dims],
[basic.TensorType(dtype='int64', broadcastable=(False,) * indices.ndim)()
for i in xrange(self.ndim)])
def make_node(self, *inp):
multi_index = [basic.as_tensor_variable(i) for i in inp[:-1]]
dims = basic.as_tensor_variable(inp[-1])
for i in multi_index:
if i.dtype not in basic.int_dtypes:
raise TypeError("'%s' object cannot be interpreted as an index" % str(i.dtype))
if dims.dtype not in basic.int_dtypes:
raise TypeError("'%s' object cannot be interpreted as an index" % str(dims.dtype))
if dims.ndim != 1:
raise TypeError("dims must be a 1D array")
return gof.Apply(
self, multi_index + [dims],
[basic.TensorType(dtype='int64', broadcastable=(False,) * multi_index[0].ndim)()])
def make_node(self, *inp):
multi_index = [basic.as_tensor_variable(i) for i in inp[:-1]]
dims = basic.as_tensor_variable(inp[-1])
for i in multi_index:
if i.dtype not in basic.int_dtypes:
raise TypeError("'%s' object cannot be interpreted as an index" % str(i.dtype))
if dims.dtype not in basic.int_dtypes:
raise TypeError("'%s' object cannot be interpreted as an index" % str(dims.dtype))
if dims.ndim != 1:
raise TypeError("dims must be a 1D array")
return gof.Apply(
self, multi_index + [dims],
[basic.TensorType(dtype='int64', broadcastable=(False,) * multi_index[0].ndim)()])
def make_node(self, indices, dims):
indices = basic.as_tensor_variable(indices)
dims = basic.as_tensor_variable(dims)
if indices.dtype not in basic.int_dtypes:
raise TypeError("'%s' object cannot be interpreted as an index" % str(indices.dtype))
if dims.dtype not in basic.int_dtypes:
raise TypeError("'%s' object cannot be interpreted as an index" % str(dims.dtype))
if dims.ndim != 1:
raise TypeError("dims must be a 1D array")
return gof.Apply(
self, [indices, dims],
[basic.TensorType(dtype='int64', broadcastable=(False,) * indices.ndim)()
for i in xrange(self.ndim)])
def norm(x, ord):
x = as_tensor_variable(x)
ndim = x.ndim
if ndim == 0:
raise ValueError("'axis' entry is out of bounds.")
elif ndim == 1:
if ord is None:
return tensor.sum(x**2)**0.5
elif ord == "inf":
return tensor.max(abs(x))
elif ord == "-inf":
return tensor.min(abs(x))
elif ord == 0:
return x[x.nonzero()].shape[0]
else:
try:
z = tensor.sum(abs(x**ord))**(1.0 / ord)
except TypeError:
raise ValueError("Invalid norm order for vectors.")
return z
elif ndim == 2:
if ord is None or ord == "fro":
return tensor.sum(abs(x**2))**(0.5)
elif ord == "inf":
return tensor.max(tensor.sum(abs(x), 1))
elif ord == "-inf":
return tensor.min(tensor.sum(abs(x), 1))
elif ord == 1:
return tensor.max(tensor.sum(abs(x), 0))
elif ord == -1:
return tensor.min(tensor.sum(abs(x), 0))
else:
raise ValueError(0)
elif ndim > 2:
raise NotImplementedError("We don't support norm with ndim > 2")
def make_node(self, x):
x = basic.as_tensor_variable(x)
self_axis = self.axis
if self_axis is None:
broadcastable = [False]
else:
if self_axis < 0:
self_axis += len(x.broadcastable)
if self_axis < 0 or self_axis >= len(x.broadcastable):
raise RuntimeError(
"Unique axis `{}` is outside of input ndim = "
"{}.".format(self.axis, len(x.broadcastable)))
broadcastable = [
b if axis != self_axis else False
for axis, b in enumerate(x.broadcastable)
]
outputs = [
basic.TensorType(broadcastable=broadcastable, dtype=x.dtype)()
]
typ = basic.TensorType(broadcastable=[False], dtype="int64")
if self.return_index:
outputs.append(typ())
if self.return_inverse:
outputs.append(typ())
if self.return_counts:
outputs.append(typ())
return theano.Apply(self, [x], outputs)
def make_node(self, x):
x = basic.as_tensor_variable(x)
self_axis = self.axis
if self_axis is None:
broadcastable = [False]
else:
if self_axis < 0:
self_axis += len(x.broadcastable)
if self_axis < 0 or self_axis >= len(x.broadcastable):
raise RuntimeError(
"Unique axis `{}` is outside of input ndim = "
"{}.".format(self.axis, len(x.broadcastable))
)
broadcastable = [b if axis != self_axis else False
for axis, b in enumerate(x.broadcastable)]
outputs = [basic.TensorType(broadcastable=broadcastable,
dtype=x.dtype)()]
typ = basic.TensorType(broadcastable=[False], dtype='int64')
if self.return_index:
outputs.append(typ())
if self.return_inverse:
outputs.append(typ())
if self.return_counts:
outputs.append(typ())
return theano.Apply(self, [x], outputs)
def broadcast_like(value, template, fgraph, dtype=None):
"""
Return a Variable with the same shape and dtype as the template,
filled by broadcasting value through it. `value` will be cast as
necessary.
"""
value = T.as_tensor_variable(value)
if value.type == template.type:
return value
if template not in fgraph.variables:
raise NotImplementedError('broadcast_like currently requires the '
'template Variable to be in the fgraph already')
if hasattr(fgraph, 'shape_feature'):
new_shape = fgraph.shape_feature.shape_of[template]
else:
new_shape = template.shape
if dtype is None:
dtype = template.dtype
rval = T.alloc(T.cast(value, dtype), *new_shape)
# the template may have 1s in its shape without being broadcastable
if rval.broadcastable != template.broadcastable:
rval = T.unbroadcast(rval, *[i for i in xrange(rval.ndim)
if rval.broadcastable[i] and
not template.broadcastable[i]])
assert rval.type.dtype == dtype
if rval.type.broadcastable != template.broadcastable:
raise AssertionError("rval.type.broadcastable is " +
str(rval.type.broadcastable) +
" but template.broadcastable is" +
str(template.broadcastable))
return rval
def make_node(self, rv, val):
"""Make an `Observed` random variable.
Parameters
----------
rv: RandomVariable
The distribution from which `val` is assumed to be a sample value.
val: Variable
The observed value.
"""
val = as_tensor_variable(val)
if rv is not None:
if not hasattr(rv, "type") or rv.type.convert_variable(val) is None:
raise TypeError(
(
"`rv` and `val` do not have compatible types:"
f" rv={rv}, val={val}"
)
)
else:
rv = NoneConst.clone()
inputs = [rv, val]
return Apply(self, inputs, [val.type()])
def make_node(self, x):
x = tensor.as_tensor_variable(x)
if x.type.ndim not in (1, 2) \
or x.type.dtype not in tensor.float_dtypes:
raise ValueError('x must be 1-d or 2-d tensor of floats. Got ', x.type)
if x.ndim == 1:
x = tensor.shape_padleft(x, n_ones=1)
return Apply(self, [x], [x.type()])
def make_node(self, x):
x = basic.as_tensor_variable(x)
out_type = x.type()
if self.axis is None:
out_type = theano.tensor.vector(dtype=x.dtype) # Flatten
return theano.Apply(self, [x], [out_type])
def make_node(self, x):
x = basic.as_tensor_variable(x)
out_type = x.type()
if self.axis is None:
out_type = theano.tensor.vector(dtype=x.dtype) # Flatten
return theano.Apply(self, [x], [out_type])
def make_node(self, V, W, b, d):
"""
:param V: Visible unit, input(batch,row,column,time,in channel)
:param W: Weights, filter(out channel,row,column,time,in channel)
:param b: bias, shape == (W.shape[0],)
:param d: strides when moving the filter over the input(dx,dy,dt)
"""
V_ = T.as_tensor_variable(V)
W_ = T.as_tensor_variable(W)
b_ = T.as_tensor_variable(b)
d_ = T.as_tensor_variable(d)
node = theano.Apply(self, inputs=[V_, W_,b_,d_], outputs = [ T.TensorType(V_.dtype, (V_.broadcastable[0],False,False,False, W_.broadcastable[0]))() ] )
return node
def make_node(self, img, kern):
img = as_tensor_variable(img)
kern = as_tensor_variable(kern)
img, kern = self.as_common_dtype(img, kern)
if img.type.ndim != 5:
raise TypeError("img must be 5D tensor")
if kern.type.ndim != 5:
raise TypeError("kern must be 5D tensor")
broadcastable = [
img.type.broadcastable[0],
kern.type.broadcastable[0],
False,
False,
False,
]
dtype = img.type.dtype
return Apply(self, [img, kern], [TensorType(dtype, broadcastable)()])
def make_node(self, x):
x = tensor.as_tensor_variable(x)
if x.type.ndim not in (1, 2) \
or x.type.dtype not in tensor.float_dtypes:
raise ValueError('x must be 1-d or 2-d tensor of floats. Got ',
x.type)
if x.ndim == 1:
x = tensor.shape_padleft(x, n_ones=1)
return Apply(self, [x], [x.type()])
def make_node(self, x):
x = as_tensor_variable(x)
assert x.ndim == 2, "The input of qr function should be a matrix."
q = theano.tensor.matrix(dtype=x.dtype)
if self.mode != "raw":
r = theano.tensor.matrix(dtype=x.dtype)
else:
r = theano.tensor.vector(dtype=x.dtype)
return Apply(self, [x], [q, r])
def make_node(self, x):
x = basic.as_tensor_variable(x)
out_type = x.type()
if self.axis is None:
out_type = theano.tensor.vector(dtype=x.dtype) # Flatten
elif self.axis >= x.ndim or self.axis < -x.ndim:
raise ValueError('axis(={0}) out of bounds'.format(self.axis))
return theano.Apply(self, [x], [out_type])
def make_node(self, x):
x = as_tensor_variable(x)
assert x.ndim == 2, "The input of svd function should be a matrix."
s = theano.tensor.vector(dtype=x.dtype)
if self.compute_uv:
u = theano.tensor.matrix(dtype=x.dtype)
vt = theano.tensor.matrix(dtype=x.dtype)
return Apply(self, [x], [u, s, vt])
else:
return Apply(self, [x], [s])
def make_node(self, M):
M = basic.as_tensor_variable(M)
if M.ndim != 0:
raise TypeError(
f"{self.__class__.__name__} only works on scalar input")
elif M.dtype not in theano.tensor.integer_dtypes:
# dtype is a theano attribute here
raise TypeError(
f"{self.__class__.__name__} only works on integer input")
return Apply(self, [M], [basic.dvector()])
def make_node(self, points, dim):
assert (points.ndim == 3)
points = as_tensor_variable(points.astype("float32"))
dim = get_scalar_constant_value(dim)
if "int" not in str(dim.dtype):
raise ValueError("dim must be an integer.")
dim = constant(dim, dtype="int32", name="dim")
entries_type = TensorType("int32", broadcastable=(False, ))
keys_type = TensorType("int16", broadcastable=(False, False))
neib_ent_type = TensorType("int32",
broadcastable=(False, False, False))
bary_type = TensorType("float32",
broadcastable=points.type.broadcastable)
valid_entries_type = TensorType("int32", broadcastable=(False, ))
n_valid_type = TensorType("int32", broadcastable=(False, ))
out_vars = [
entries_type(name="hash_entries"),
keys_type(name="hash_keys"),
neib_ent_type(name="neighbor_entries"),
bary_type(name="barycentric_coords"),
valid_entries_type(name="valid_entries"),
n_valid_type(name="n_valid")
]
# Two sets of entries can't be meaningfully compared without also
# having the corresponding keys. Since we can only define per-output
# comparisons, we have to hope that any time someone compares two
# tables for equality, they will check all outputs.
out_vars[0].tag.values_eq_approx = lambda e1, e2: True
out_vars[2].tag.values_eq_approx = lambda e1, e2: True
# The number of valid entries between two equivalent tables may be
# different since it includes duplicates.
out_vars[5].tag.values_eq_approx = lambda n1, n2: True
def keys_comparison(k1, k2):
k1 = [tuple(k) for k in np.asarray(k1)]
k2 = [tuple(k) for k in np.asarray(k2)]
return set(k1) == set(k2)
out_vars[1].tag.values_eq_approx = keys_comparison
def valid_entries_comparison(e1, e2):
e1 = np.asarray(e1)
e2 = np.asarray(e2)
return len(np.unique(e1)) == len(np.unique(e2))
out_vars[4].tag.values_eq_approx = valid_entries_comparison
return Apply(self, [points, dim], out_vars)
def make_node(self, x, weights):
warnings.warn((
"Tile op is deprecated, use tile function instead."),
stacklevel=3)
x = basic.as_tensor_variable(x)
if x.dtype not in BinCountOp.compatible_type:
raise TypeError("Inputs dtype must be an integer.")
# Some dtypes are not supported by numpy's implementation of bincount.
# Until another one is available, we should fail at graph construction
# time, not wait for execution.
int_bitwidth = theano.gof.python_int_bitwidth()
if int_bitwidth == 64:
numpy_unsupported_dtypes = ('uint64',)
if int_bitwidth == 32:
numpy_unsupported_dtypes = ('uint32', 'int64', 'uint64')
intp_bitwidth = theano.gof.local_bitwidth()
if intp_bitwidth == 32:
out_type = basic.ivector()
elif intp_bitwidth == 64:
out_type = basic.lvector()
if x.dtype in numpy_unsupported_dtypes:
raise TypeError(
("Input dtypes %s are not supported by numpy.bincount, "
% numpy_unsupported_dtypes), x.dtype)
if x.ndim != 1:
raise TypeError("Inputs must be of dimension 1.")
if weights is None:
weights = theano.gof.Constant(theano.gof.Generic(), None)
else:
weights = basic.as_tensor_variable(weights)
out_type = basic.dvector()
if weights.ndim != 1:
raise TypeError("Weights cannot have a number of"
"dimension different of 1.")
return theano.Apply(self, [x, weights], [out_type])
def make_node(self, x):
x = basic.as_tensor_variable(x)
outputs = [basic.TensorType(broadcastable=[False], dtype=x.dtype)()]
typ = basic.TensorType(broadcastable=[False], dtype='int64')
if self.return_index:
outputs.append(typ())
if self.return_inverse:
outputs.append(typ())
if self.return_counts:
outputs.append(typ())
return theano.Apply(self, [x], outputs)
def __call__(self, a, size=None, replace=True, p=None, **kwargs):
a = as_tensor_variable(a, ndim=1)
if p is None:
p = theano.tensor.type_other.NoneConst.clone()
if isinstance(replace, bool):
replace = theano.tensor.constant(np.array(replace))
return super().__call__(a, p, replace, size=size, dtype=a.dtype, **kwargs)
def make_node(self, _x):
warnings.warn(
"DeprecationWarning: theano.tensor.nlinalg.AllocDiag"
"is deprecated, please use theano.tensor.AllocDiag"
"instead.",
category=DeprecationWarning,
)
x = as_tensor_variable(_x)
if x.type.ndim != 1:
raise TypeError("AllocDiag only works on vectors", _x)
return Apply(self, [x], [theano.tensor.matrix(dtype=x.type.dtype)])
def make_node(self, x, repeats):
x = basic.as_tensor_variable(x)
repeats = basic.as_tensor_variable(repeats)
if repeats.dtype not in tensor.integer_dtypes:
raise TypeError("repeats.dtype must be an integer.")
# Some dtypes are not supported by numpy's implementation of repeat.
# Until another one is available, we should fail at graph construction
# time, not wait for execution.
ptr_bitwidth = theano.configdefaults.local_bitwidth()
if ptr_bitwidth == 64:
numpy_unsupported_dtypes = ("uint64",)
if ptr_bitwidth == 32:
numpy_unsupported_dtypes = ("uint32", "int64", "uint64")
if repeats.dtype in numpy_unsupported_dtypes:
raise TypeError(
(
"dtypes %s are not supported by numpy.repeat "
"for the 'repeats' parameter, " % str(numpy_unsupported_dtypes)
),
repeats.dtype,
)
if self.axis is None:
broadcastable = [False]
else:
try:
const_reps = basic.get_scalar_constant_value(repeats)
except basic.NotScalarConstantError:
const_reps = None
if const_reps == 1:
broadcastable = x.broadcastable
else:
broadcastable = list(x.broadcastable)
broadcastable[self.axis] = False
out_type = theano.tensor.TensorType(x.dtype, broadcastable)
return theano.Apply(self, [x, repeats], [out_type()])
def make_node(self, img, topgrad, shape=None):
img = as_tensor_variable(img)
topgrad = as_tensor_variable(topgrad)
img, topgrad = self.as_common_dtype(img, topgrad)
if img.type.ndim != 4:
raise TypeError("img must be 4D tensor")
if topgrad.type.ndim != 4:
raise TypeError("topgrad must be 4D tensor")
if shape is None:
if self.subsample != (1, 1) or self.border_mode == "half":
raise ValueError(
"shape must be given if subsample != (1, 1)"
' or border_mode == "half"'
)
height_width = []
else:
height_width = [
as_tensor_variable(shape[0]).astype("int64"),
as_tensor_variable(shape[1]).astype("int64"),
]
if self.unshared is True:
broadcastable = [
topgrad.type.broadcastable[1],
False,
False,
img.type.broadcastable[1],
False,
False,
]
else:
broadcastable = [
topgrad.type.broadcastable[1],
img.type.broadcastable[1],
False,
False,
]
dtype = img.type.dtype
return Apply(
self, [img, topgrad] + height_width, [TensorType(dtype, broadcastable)()]
)
def make_node(self, x, repeats):
x = basic.as_tensor_variable(x)
repeats = basic.as_tensor_variable(repeats)
if repeats.dtype not in tensor.integer_dtypes:
raise TypeError("repeats.dtype must be an integer.")
# Some dtypes are not supported by numpy's implementation of repeat.
# Until another one is available, we should fail at graph construction
# time, not wait for execution.
ptr_bitwidth = theano.configdefaults.local_bitwidth()
if ptr_bitwidth == 64:
numpy_unsupported_dtypes = ("uint64",)
if ptr_bitwidth == 32:
numpy_unsupported_dtypes = ("uint32", "int64", "uint64")
if repeats.dtype in numpy_unsupported_dtypes:
raise TypeError(
(
"dtypes %s are not supported by numpy.repeat "
"for the 'repeats' parameter, " % str(numpy_unsupported_dtypes)
),
repeats.dtype,
)
if self.axis is None:
broadcastable = [False]
else:
try:
const_reps = basic.get_scalar_constant_value(repeats)
except basic.NotScalarConstantError:
const_reps = None
if const_reps == 1:
broadcastable = x.broadcastable
else:
broadcastable = list(x.broadcastable)
broadcastable[self.axis] = False
out_type = theano.tensor.TensorType(x.dtype, broadcastable)
return theano.Apply(self, [x, repeats], [out_type()])
def make_node(self, A, alpha, x, y):
ctx_name = infer_context_name(A, x, y)
A = as_gpuarray_variable(A, ctx_name)
x = as_gpuarray_variable(x, ctx_name)
y = as_gpuarray_variable(y, ctx_name)
alpha = as_tensor_variable(alpha).astype('float64')
assert alpha.ndim == 0
assert A.ndim == 2
assert x.ndim == 1
assert y.ndim == 1
assert A.dtype == x.dtype == y.dtype
return Apply(self, [A, alpha, x, y], [A.type()])
def make_node(self, x):
x = as_tensor_variable(x)
assert x.ndim == 2
# Numpy's linalg.eigh may return either double or single
# presision eigenvalues depending on installed version of
# LAPACK. Rather than trying to reproduce the (rather
# involved) logic, we just probe linalg.eigh with a trivial
# input.
w_dtype = self._numop([[np.dtype(x.dtype).type()]])[0].dtype.name
w = theano.tensor.vector(dtype=w_dtype)
v = theano.tensor.matrix(dtype=x.dtype)
return Apply(self, [x], [w, v])
def make_node(self, A, alpha, x, y):
ctx_name = infer_context_name(A, x, y)
A = as_gpuarray_variable(A, ctx_name)
x = as_gpuarray_variable(x, ctx_name)
y = as_gpuarray_variable(y, ctx_name)
alpha = as_tensor_variable(alpha)
assert alpha.ndim == 0
assert A.ndim == 2
assert x.ndim == 1
assert y.ndim == 1
assert A.dtype == x.dtype == y.dtype
return Apply(self, [A, alpha, x, y], [A.type()])
def make_node(
self, x, scale, bias, estimated_mean, estimated_variance, epsilon=1e-4
):
x = as_tensor_variable(x)
scale = as_tensor_variable(scale)
bias = as_tensor_variable(bias)
estimated_mean = as_tensor_variable(estimated_mean)
estimated_variance = as_tensor_variable(estimated_variance)
epsilon = as_tensor_variable(epsilon)
# Upcast to common dtype on the non-scalar
# Keep as is dtype of scalar (epsilon)
x, scale, bias, estimated_mean, estimated_variance = as_common_dtype(
x, scale, bias, estimated_mean, estimated_variance
)
assert (
x.ndim
== scale.ndim
== bias.ndim
== estimated_mean.ndim
== estimated_variance.ndim
)
return Apply(
self,
[x, scale, bias, estimated_mean, estimated_variance, epsilon],
[x.type()],
)
def make_node(self, W, b, d, H, RShape=None):
"""
Parameters
----------
W
Weights, filter
b
Bias, shape == (W.shape[0],).
d
Strides when moving the filter over the input.
H
The output of Conv3D.
"""
W_ = T.as_tensor_variable(W)
b_ = T.as_tensor_variable(b)
d_ = T.as_tensor_variable(d)
H_ = T.as_tensor_variable(H)
if RShape:
RShape_ = T.as_tensor_variable(RShape)
else:
RShape_ = T.as_tensor_variable([-1, -1, -1])
return theano.Apply(self,
inputs=[W_, b_, d_, H_, RShape_],
outputs=[T.TensorType(H_.dtype,
(False, False, False, False, False))()])
def make_node(self, W, b, d, H, RShape=None):
"""
Parameters
----------
W
Weights, filter
b
Bias, shape == (W.shape[0],).
d
Strides when moving the filter over the input.
H
The output of Conv3D.
"""
W_ = T.as_tensor_variable(W)
b_ = T.as_tensor_variable(b)
d_ = T.as_tensor_variable(d)
H_ = T.as_tensor_variable(H)
if RShape:
RShape_ = T.as_tensor_variable(RShape)
else:
RShape_ = T.as_tensor_variable([-1, -1, -1])
return theano.Apply(
self,
inputs=[W_, b_, d_, H_, RShape_],
outputs=[
T.TensorType(H_.dtype, (False, False, False, False, False))()
])
def multinomial(self, size=None, n=1, pvals=None, ndim=None, dtype='int64', nstreams=None):
if pvals is None:
raise TypeError('You have to specify pvals')
pvals = as_tensor_variable(pvals)
if size is not None:
if any([isinstance(i, int) and i <= 0 for i in size]):
raise ValueError('The specified size contains a dimension with value <= 0', size)
if n == 1 and pvals.ndim == 1:
if ndim is not None:
raise ValueError('Provided an ndim argument to ' +
'MRG_RandomStreams2.multinomial, which does not use ' +
'the ndim argument.')
unis = self.uniform(size=size, ndim=2, nstreams=nstreams)
op = MultinomialFromUniform2(dtype)
return op(pvals, unis)
else:
raise NotImplementedError('MRG_RandomStreams2.multinomial only ' +
' implemented with n == 1 and pvals.ndim = 2')
def multinomial(self, size=None, n=1, pvals=None, ndim=None, dtype='int32',
nstreams=None):
"""
Sample `n` (currently `n` needs to be 1) times from a multinomial
distribution defined by probabilities pvals.
Example : pvals = [[.98, .01, .01], [.01, .98, .01]] will
probably result in [[1,0,0],[0,1,0]].
.. note::
-`size` and `ndim` are only there keep the same signature as other
uniform, binomial, normal, etc.
todo : adapt multinomial to take that into account
-Does not do any value checking on pvals, i.e. there is no
check that the elements are non-negative, less than 1, or
sum to 1. passing pvals = [[-2., 2.]] will result in
sampling [[0, 0]]
"""
if pvals is None:
raise TypeError('You have to specify pvals')
pvals = as_tensor_variable(pvals)
if size is not None:
if any([isinstance(i, int) and i <= 0 for i in size]):
raise ValueError(
'The specified size contains a dimension with value <= 0',
size)
if n == 1 and pvals.ndim == 1:
if ndim is not None:
raise ValueError('Provided an ndim argument to ' +
'MRG_RandomStreams2.multinomial, which does not use ' +
'the ndim argument.')
unis = self.uniform(size=size, ndim=2, nstreams=nstreams)
op = MultinomialFromUniform2(dtype)
return op(pvals, unis)
else:
raise NotImplementedError('MRG_RandomStreams2.multinomial only ' +
' implemented with n == 1 and pvals.ndim = 2')
def make_node(self, x):
x = basic.as_tensor_variable(x)
return theano.Apply(self, [x], [x.type()])
def make_node(self, dy, sm, **kwargs):
dy = tensor.as_tensor_variable(dy)
sm = tensor.as_tensor_variable(sm)
return Apply(self, [dy, sm], [sm.type.make_variable()])
