def make_node(self, A):
ctx_name = infer_context_name(A)
A = as_gpuarray_variable(A, ctx_name)
A = gpu_contiguous(A)
if A.ndim != 2:
raise LinAlgError("Matrix rank error")
if A.dtype != "float32":
raise TypeError("only `float32` is supported for now")
if self.compute_uv:
return aesara.Apply(
self,
[A],
# return S, U, VT
[
GpuArrayType(
A.dtype, broadcastable=[False], context_name=ctx_name
)(),
A.type(),
A.type(),
],
)
else:
return aesara.Apply(
self,
[A],
# return only S
[GpuArrayType(A.dtype, broadcastable=[False], context_name=ctx_name)()],
)
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 aesara.Apply(self, [x], outputs)
def make_node(self, inp1, inp2):
if not cusolver_available:
raise RuntimeError(
"CUSOLVER is not available and "
"GpuCusolverSolve Op can not be constructed."
)
if skcuda.__version__ <= "0.5.1":
warnings.warn(
"The GpuSolve op requires scikit-cuda > 0.5.1 to work with CUDA 8"
)
context_name = infer_context_name(inp1, inp2)
inp1 = as_gpuarray_variable(inp1, context_name)
inp2 = as_gpuarray_variable(inp2, context_name)
inp1 = gpu_contiguous(inp1)
inp2 = gpu_contiguous(inp2)
assert inp1.ndim == 2
assert inp2.ndim == 2
assert inp1.dtype == inp2.dtype
return aesara.Apply(
self,
[inp1, inp2],
[
GpuArrayType(
inp1.dtype,
broadcastable=inp1.broadcastable,
context_name=context_name,
)()
],
)
def make_node(self, inp1, inp2):
if not cublas_available:
raise RuntimeError(
"CUBLAS is not available and "
"GpuCublasTriangularSolve Op "
"can not be constructed."
)
context_name = infer_context_name(inp1, inp2)
inp1 = as_gpuarray_variable(inp1, context_name)
inp2 = as_gpuarray_variable(inp2, context_name)
inp1 = gpu_contiguous(inp1)
inp2 = gpu_contiguous(inp2)
assert inp1.ndim == 2
assert inp2.ndim in [1, 2]
assert inp1.dtype == inp2.dtype
return aesara.Apply(
self,
[inp1, inp2],
[
GpuArrayType(
inp1.dtype,
broadcastable=inp2.broadcastable,
context_name=context_name,
)()
],
)
def make_node(self, inp, s=None):
# A shape parameter s can be provided as an input. For now this is used to
# manage odd transform sizes.
# Later this could be extended to handle padding and trunkation,
# following numpy's interface. However, cuFFT expects array that match
# the shape given to the plan, so padding will have to be done in the op.
# The effect of padding on gradients has yet to be investigated.
if not skcuda_available:
raise RuntimeError("skcuda is needed for CuFFTOp")
if not pygpu_available:
raise RuntimeError("pygpu is needed for CuFFTOp")
if not pycuda_available:
raise RuntimeError("pycuda is needed for CuFFTOp")
inp = gpu_contiguous(as_gpuarray_variable(inp,
infer_context_name(inp)))
# If no shape is provided as input, default to input data shape.
if s is None:
s = inp.shape[1:]
s = tt.as_tensor_variable(s)
assert inp.dtype == "float32"
assert s.ndim == 1
assert s.dtype in tt.integer_dtypes
return aesara.Apply(self, [inp, s], [self.output_type(inp)()])
def make_node(self, x, v, sorter=None):
x = basic.as_tensor(x, ndim=1)
v = basic.as_tensor(v)
out_type = v.type.clone(dtype="int64")
if sorter is None:
return aesara.Apply(self, [x, v], [out_type()])
else:
sorter = basic.as_tensor(sorter, ndim=1)
if (aesara.configdefaults.python_int_bitwidth() == 32
and sorter.dtype == "int64"):
raise TypeError(
"numpy.searchsorted with Python 32bit do not support a"
" sorter of int64.")
if sorter.type not in basic.int_vector_types:
raise TypeError("sorter must be an integer vector",
sorter.type)
return aesara.Apply(self, [x, v, sorter], [out_type()])
def make_node(self, x, y):
x = aesara.tensor.as_tensor_variable(x)
y = aesara.tensor.as_tensor_variable(y)
outdim = x.ndim
output = aesara.tensor.TensorType(
dtype=aesara.scalar.upcast(x.dtype, y.dtype), broadcastable=[False] * outdim
)()
return aesara.Apply(self, inputs=[x, y], outputs=[output])
def make_node(self, x):
# x could be one of a number of types
# the only thing we require is that the variable have a .ndim,
# and that the value have a .shape
if not isinstance(x, aesara.Variable):
raise TypeError("x must be Variable with ndim attribute", x)
if x.ndim <= self.i:
raise TypeError("x has too few dimensions for Shape_i", (x, self.i))
return aesara.Apply(self, [x], [aesara.tensor.lscalar()])
def make_node(self, input, axis=-1):
input = aesara.tensor.as_tensor_variable(input)
axis = aesara.tensor.as_tensor_variable(axis)
bcast = input.type.broadcastable
return aesara.Apply(
self,
[input, axis],
[aesara.tensor.TensorType(dtype="int64", broadcastable=bcast)()],
)
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 aesara.Apply(self, [a] + shape, [out])
def make_node(self, A):
ctx_name = infer_context_name(A)
A = as_gpuarray_variable(A, ctx_name)
A = gpu_contiguous(A)
if A.ndim != 2:
raise LinAlgError("Matrix rank error")
if A.dtype != "float32":
raise TypeError("only `float32` is supported for now")
return aesara.Apply(self, [A], [A.type()])
def make_node(self, x):
x = basic.as_tensor_variable(x)
out_type = x.type()
if self.axis is None:
out_type = aesara.tensor.vector(dtype=x.dtype) # Flatten
elif self.axis >= x.ndim or self.axis < -x.ndim:
raise ValueError("axis(={}) out of bounds".format(self.axis))
return aesara.Apply(self, [x], [out_type])
def make_node(self, x, y, rcond):
x = aesara.tensor.as_tensor_variable(x)
y = aesara.tensor.as_tensor_variable(y)
rcond = aesara.tensor.as_tensor_variable(rcond)
return aesara.Apply(
self,
[x, y, rcond],
[
aesara.tensor.matrix(),
aesara.tensor.dvector(),
aesara.tensor.lscalar(),
aesara.tensor.dvector(),
],
)
def make_node(self, activations, labels, input_lengths):
context_name = infer_context_name(activations)
t_activations = as_gpuarray_variable(activations,
context_name=context_name)
# Ensure activations array is C-contiguous
t_activations = gpu_contiguous(t_activations)
# Labels and input lengths are always on the CPU
t_labels = tt.as_tensor_variable(labels)
t_input_lengths = tt.as_tensor_variable(input_lengths)
if t_activations.type.dtype != "float32":
raise TypeError("activations must use the float32 type.")
if t_activations.ndim != 3:
raise ValueError("activations must have 3 dimensions.")
if t_labels.type.dtype != "int32":
raise TypeError("labels must use the int32 type.")
if t_labels.ndim != 2:
raise ValueError("labels must have 2 dimensions.")
if t_input_lengths.type.dtype != "int32":
raise TypeError("input_lengths must use the int32 type.")
if t_input_lengths.ndim != 1:
raise ValueError("input_lengths must have 1 dimension.")
costs = GpuArrayType(dtype="float32",
broadcastable=(False, ),
context_name=context_name)()
outputs = [costs]
if self.compute_grad:
gradients = GpuArrayType(
dtype="float32",
broadcastable=(
False,
False,
False,
),
context_name=context_name,
)()
outputs += [gradients]
return aesara.Apply(self,
inputs=[t_activations, t_labels, t_input_lengths],
outputs=outputs)
def make_node(self, x, repeats):
x = basic.as_tensor_variable(x)
repeats = basic.as_tensor_variable(repeats)
if repeats.dtype not in basic.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 = aesara.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 = aesara.tensor.TensorType(x.dtype, broadcastable)
return aesara.Apply(self, [x, repeats], [out_type()])
def make_node(self, inp, kth):
inp = aesara.tensor.as_tensor_variable(inp)
ndim = inp.ndim
if ndim == 0:
raise ValueError("Cannot take scalar as input")
if not -ndim <= self.axis < ndim:
raise IndexError(
'"axis" parameter out of range,'
" expected integer within [%d, %d]" % (-ndim, ndim - 1)
)
kth = aesara.tensor.as_tensor_variable(kth)
_check_tensor_is_scalar(kth)
bcast = inp.type.broadcastable
outs = []
if self.return_values:
outs.append(inp.type())
if self.return_indices:
outs.append(
aesara.tensor.TensorType(dtype=self.idx_dtype, broadcastable=bcast)()
)
return aesara.Apply(self, [inp, kth], outs)
def make_node(self, inp):
if not cusolver_available:
raise RuntimeError(
"CUSOLVER is not available and "
"GpuCholesky Op can not be constructed."
)
if skcuda.__version__ <= "0.5.1":
warnings.warn(
"The GpuCholesky op requires scikit-cuda > " "0.5.1 to work with CUDA 8"
)
if not pygpu_available:
raise RuntimeError(
"Missing pygpu or triu/tril functions." "Install or update libgpuarray."
)
context_name = infer_context_name(inp)
inp = as_gpuarray_variable(inp, context_name)
inp = gpu_contiguous(inp)
assert inp.ndim == 2
return aesara.Apply(self, [inp], [inp.type()])
def make_node(self, input, axis=-1):
input = aesara.tensor.as_tensor_variable(input)
axis = aesara.tensor.as_tensor_variable(axis)
out_type = input.type()
return aesara.Apply(self, [input, axis], [out_type])
def make_node(self, inp):
inp = cuda.basic_ops.gpu_contiguous(
cuda.basic_ops.as_cuda_ndarray_variable(inp))
assert inp.dtype == "float32"
return aesara.Apply(self, [inp], [inp.type()])
def make_node(self, x):
return aesara.Apply(self,
inputs=[x],
outputs=[x.type(),
aesara.tensor.scalar()])
def make_node(self, x):
x = aesara.tensor.as_tensor_variable(x)
return aesara.Apply(self, [x], [x.type()])
def make_node(self, f, g):
return aesara.Apply(self,
inputs=[f, g],
outputs=[aesara.tensor.scalar()])
def make_node(self, x):
return aesara.Apply(self, [x], [x.type()])
