def with_linker_inplace(self, linker):
for xsh, ysh in [((5, 5), (5, 5)),
((5, 5), (1, 5)),
((5, 5), (5, 1)),
((1, 1), (1, 1)),
((2, 3, 4, 5), (2, 3, 4, 5)),
((2, 3, 4, 5), (1, 3, 1, 5)),
((2, 3, 4, 5), (1, 1, 1, 1)),
((), ())]:
x = TensorType('float64', [(entry == 1) for entry in xsh])('x')
y = TensorType('float64', [(entry == 1) for entry in ysh])('y')
e = Elemwise(scalar.Add(scalar.transfer_type(0)), {0: 0})(x, y)
f = copy(linker).accept(FunctionGraph([x, y], [e])).make_function()
xv = numpy.asarray(numpy.random.rand(*xsh))
yv = numpy.asarray(numpy.random.rand(*ysh))
zv = xv + yv
f(xv, yv)
self.assertTrue((xv == zv).all())
#test Elemwise.infer_shape
#the Shape op don't implement c_code!
if isinstance(linker, gof.PerformLinker):
x = TensorType('float64', [(entry == 1) for entry in xsh])('x')
y = TensorType('float64', [(entry == 1) for entry in ysh])('y')
e = Elemwise(scalar.Add(scalar.transfer_type(0)), {0: 0})(x, y)
f = copy(linker).accept(FunctionGraph([x,
y], [e.shape])).make_function()
xv = numpy.asarray(numpy.random.rand(*xsh))
yv = numpy.asarray(numpy.random.rand(*ysh))
zv = xv + yv
f(xv, yv)
assert xv.shape == zv.shape
def test_ctors(self):
if 0:
# when using an implementation that handles scalars with
# Scalar type
assert shared(7).type == Scalar('int64')
assert shared(7.0).type == Scalar('float64')
assert shared(7, dtype='float64').type == Scalar('float64')
else:
if theano.gof.python_int_bitwidth() == 32:
assert shared(7).type == theano.tensor.iscalar, shared(7).type
else:
assert shared(7).type == theano.tensor.lscalar, shared(7).type
assert shared(7.0).type == theano.tensor.dscalar
assert shared(numpy.float32(7)).type == theano.tensor.fscalar
# test tensor constructor
b = shared(numpy.zeros((5, 5), dtype='int32'))
assert b.type == TensorType('int32', broadcastable=[False, False])
b = shared(numpy.random.rand(4, 5))
assert b.type == TensorType('float64', broadcastable=[False, False])
b = shared(numpy.random.rand(5, 1, 2))
assert b.type == TensorType('float64',
broadcastable=[False, False, False])
assert shared([]).type == generic
def badfunc():
shared(7, bad_kw=False)
self.assertRaises(TypeError, badfunc)
def test_ctors(self):
if theano.configdefaults.python_int_bitwidth() == 32:
assert shared(7).type == theano.tensor.iscalar, shared(7).type
else:
assert shared(7).type == theano.tensor.lscalar, shared(7).type
assert shared(7.0).type == theano.tensor.dscalar
assert shared(np.float32(7)).type == theano.tensor.fscalar
# test tensor constructor
b = shared(np.zeros((5, 5), dtype="int32"))
assert b.type == TensorType("int32", broadcastable=[False, False])
b = shared(np.random.rand(4, 5))
assert b.type == TensorType("float64", broadcastable=[False, False])
b = shared(np.random.rand(5, 1, 2))
assert b.type == TensorType("float64",
broadcastable=[False, False, False])
assert shared([]).type == generic
def badfunc():
shared(7, bad_kw=False)
with pytest.raises(TypeError):
badfunc()
def test_fill_grad(self):
# Fix bug reported at
# https://groups.google.com/d/topic/theano-users/nQshB8gUA6k/discussion
x = TensorType(config.floatX, [0, 1, 0])('x')
y = TensorType(config.floatX, [0, 1, 0])('y')
e = tensor.second(x, y)
theano.grad(e.sum(), y)
def FreeVariable( name, shape, dtype = 'float64'):
"""creates a TensorVariable of the given shape and type"""
shape = np.atleast_1d(shape)
var = TensorType(str(dtype), shape == 1)(name)
var.dshape = tuple(shape)
var.dsize = int(np.prod(shape))
return var
def test_hash_and_eq_params_type(self):
w1 = ParamsType(a1=TensorType('int64', (False, False)),
a2=TensorType('int64',
(False, True, False, False, True)),
a3=Generic())
w2 = ParamsType(a1=TensorType('int64', (False, False)),
a2=TensorType('int64',
(False, True, False, False, True)),
a3=Generic())
assert w1 == w2
assert not (w1 != w2)
assert hash(w1) == hash(w2)
assert w1.name == w2.name
# Changing attributes names only.
w2 = ParamsType(
a1=TensorType('int64', (False, False)),
other_name=TensorType(
'int64',
(False, True, False, False, True)), # a2 -> other_name
a3=Generic())
assert w1 != w2
# Changing attributes types only.
w2 = ParamsType(
a1=TensorType('int64', (False, False)),
a2=Generic(), # changing class
a3=Generic())
assert w1 != w2
# Changing attributes types characteristics only.
w2 = ParamsType(
a1=TensorType('int64', (False, True)), # changing broadcasting
a2=TensorType('int64', (False, True, False, False, True)),
a3=Generic())
assert w1 != w2
def test_params_type_filtering(self):
shape_tensor5 = (1, 2, 2, 3, 2)
size_tensor5 = shape_tensor5[0] * shape_tensor5[1] * shape_tensor5[
2] * shape_tensor5[3] * shape_tensor5[4]
random_tensor = np.random.normal(
size=size_tensor5).reshape(shape_tensor5)
w = ParamsType(a1=TensorType('int32', (False, False)),
a2=TensorType('float64',
(False, False, False, False, False)),
a3=Generic())
# With a value that does not match the params type.
o = Params(w,
a1=np.asarray([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11,
12]]).astype('int64'),
a2=random_tensor.astype('float32'),
a3=2000)
# should fail (o.a1 is not int32, o.a2 is not float64)
self.assertRaises(TypeError, w.filter, o, True)
# should fail (o.a1 is not int32, o.a2 is not float64, and downcast is disallowed)
self.assertRaises(TypeError, w.filter, o, False, False)
# Should pass.
w.filter(o, strict=False, allow_downcast=True)
# With a value that matches the params type.
o1 = Params(w,
a1=np.asarray([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11,
12]]).astype('int32'),
a2=random_tensor.astype('float64'),
a3=2000)
# All should pass.
w.filter(o1, strict=True)
w.filter(o1, strict=False, allow_downcast=False)
w.filter(o1, strict=False, allow_downcast=True)
# Check values_eq and values_eq_approx.
o2 = Params(w,
a1=np.asarray([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11,
12]]).astype('int32'),
a2=random_tensor.astype('float64'),
a3=2000)
assert w.values_eq(o1, o2)
assert w.values_eq_approx(o1, o2)
# Check value_eq_approx.
# NB: I don't know exactly which kind of differences is rejected by values_eq but accepted by values_eq_approx.
# So, I just play a little with float values.
o3 = Params(w,
a1=np.asarray([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11,
12]]).astype('int32'),
a2=(random_tensor.astype('float32') * 10 / 2.2 *
2.19999999999 / 10).astype('float64'),
a3=2000.0 - 0.00000000000000001)
assert w.values_eq_approx(o1, o3)
def test_fill(self):
if not theano.config.cxx:
raise SkipTest("G++ not available, so we need to skip this test.")
x = TensorType('float64', [0, 0])('x')
y = TensorType('float64', [1, 1])('y')
e = Elemwise(scalar.Second(scalar.transfer_type(0)), {0: 0})(x, y)
f = gof.CLinker().accept(FunctionGraph([x, y], [e])).make_function()
xv = numpy.ones((5, 5))
yv = numpy.random.rand(1, 1)
f(xv, yv)
assert (xv == yv).all()
def test_weird_strides(self):
if not theano.config.cxx:
raise SkipTest("G++ not available, so we need to skip this test.")
x = TensorType('float64', [0, 0, 0, 0, 0])('x')
y = TensorType('float64', [0, 0, 0, 0, 0])('y')
e = Elemwise(scalar.add)(x, y)
f = gof.CLinker().accept(FunctionGraph([x, y], [e])).make_function()
xv = numpy.random.rand(2, 2, 2, 2, 2)
yv = numpy.random.rand(2, 2, 2, 2, 2).transpose(4, 0, 3, 1, 2)
zv = xv + yv
assert (f(xv, yv) == zv).all()
def load_random_data_set(data_settings,
batchsize,
in_time,
in_channels,
in_width,
in_height,
round=None):
cache_file = 'cache/set%s.p' % round
if not round == None and os.path.isfile(cache_file):
dataset = pickle.load(open(cache_file, "rb"))
return dataset
files_to_use = np.random.randint(len(data_settings['files']),
size=batchsize)
file_counts = {}
for i in files_to_use:
if data_settings['files'][i] in file_counts.keys():
file_counts[data_settings['files'][i]] += 1
else:
file_counts[data_settings['files'][i]] = 1
labels = [-1] * batchsize
segments = np.zeros((batchsize, in_time, in_channels, in_height, in_width),
dtype=TensorType(theano.config.floatX, (False, ) * 5))
counter = 0
for i in file_counts.keys():
print("Loading %d segments from %s which has %d frames" %
(file_counts[i], i, data_settings['inverse_frame_map'][i]))
frame_numbers = np.random.randint(
data_settings['inverse_frame_map'][i] - in_time,
size=file_counts[i])
for j in frame_numbers:
print("Chose to use frame number %d" % j)
num_read, video_frames = read_frames_from_video(
i, (in_width, in_height),
in_channels,
read_range=(j, j + in_time - 1))
labels[counter] = data_settings['inverse_label_map'][i]
segments[counter, :, :, :, :] = video_frames
counter += 1
if not epoch == None:
labels = np.asarray(labels, dtype=TensorType(int_type, (False, )))
dataset = pickle.dump((labels, segments), open(cache_file, "wb"))
return (labels, segments)
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 != 5:
raise TypeError('img must be 5D tensor')
if topgrad.type.ndim != 5:
raise TypeError('topgrad must be 5D tensor')
if self.subsample != (1, 1, 1) or self.border_mode == "half":
if shape is None:
raise ValueError(
'shape must be given if subsample != (1, 1, 1)'
' or border_mode == "half"')
height_width_depth = [
as_tensor_variable(shape[0]).astype('int64'),
as_tensor_variable(shape[1]).astype('int64'),
as_tensor_variable(shape[2]).astype('int64')
]
else:
height_width_depth = []
broadcastable = [
topgrad.type.broadcastable[1], img.type.broadcastable[1], False,
False, False
]
dtype = img.type.dtype
return Apply(self, [img, topgrad] + height_width_depth,
[TensorType(dtype, broadcastable)()])
def make_node(self, kern, topgrad, shape=None):
kern = as_tensor_variable(kern)
topgrad = as_tensor_variable(topgrad)
kern, topgrad = self.as_common_dtype(kern, topgrad)
if kern.type.ndim != 5:
raise TypeError('kern must be 5D tensor')
if topgrad.type.ndim != 5:
raise TypeError('topgrad must be 5D tensor')
if self.subsample != (1, 1, 1) and shape is None:
raise ValueError('shape must be given if subsample != (1, 1, 1)')
if self.subsample != (1, 1, 1):
height_width_depth = [
as_tensor_variable(shape[0]).astype('int64'),
as_tensor_variable(shape[1]).astype('int64'),
as_tensor_variable(shape[2]).astype('int64')
]
else:
height_width_depth = []
broadcastable = [
topgrad.type.broadcastable[0], kern.type.broadcastable[1], False,
False, False
]
dtype = kern.type.dtype
return Apply(self, [kern, topgrad] + height_width_depth,
[TensorType(dtype, broadcastable)()])
def make_node(self, kern, topgrad, shape=None):
kern = as_tensor_variable(kern)
topgrad = as_tensor_variable(topgrad)
kern, topgrad = self.as_common_dtype(kern, topgrad)
if self.unshared is True:
if kern.type.ndim != 6:
raise TypeError("kern must be 6D tensor")
else:
if kern.type.ndim != 4:
raise TypeError("kern 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):
raise ValueError("shape must be given if subsample != (1, 1)")
height_width = []
else:
height_width = [
as_tensor_variable(shape[0]).astype("int64"),
as_tensor_variable(shape[1]).astype("int64"),
]
if self.num_groups > 1:
broadcastable = [topgrad.type.broadcastable[0], False, False, False]
else:
broadcastable = [
topgrad.type.broadcastable[0],
kern.type.broadcastable[-3],
False,
False,
]
dtype = kern.type.dtype
return Apply(
self, [kern, topgrad] + height_width, [TensorType(dtype, broadcastable)()]
)
def test_basic(self):
for type1 in [
"uint8",
"uint16",
"uint32",
"uint64",
"int8",
"int16",
"int32",
"int64",
"float32",
"float64",
]:
x = TensorType(dtype=type1, broadcastable=(False, ))()
for type2, converter in zip(
["int8", "int16", "int32", "int64", "float32", "float64"],
[
_convert_to_int8,
_convert_to_int16,
_convert_to_int32,
_convert_to_int64,
_convert_to_float32,
_convert_to_float64,
],
):
y = converter(x)
f = function([In(x, strict=True)], y)
a = np.arange(10, dtype=type1)
b = f(a)
assert np.all(b == np.arange(10, dtype=type2))
def test_infer_shape(self):
for s_left, s_right in [((5, 6), (5, 6)), ((5, 6), (5, 1)),
((5, 6), (1, 6)), ((5, 1), (5, 6)),
((1, 6), (5, 6)), ((2, 3, 4, 5), (2, 3, 4, 5)),
((2, 3, 4, 5), (2, 3, 1, 5)),
((2, 3, 4, 5), (1, 3, 4, 5)),
((2, 1, 4, 5), (2, 3, 4, 5)),
((2, 3, 4, 1), (2, 3, 4, 5))]:
dtype = theano.config.floatX
t_left = TensorType(dtype, [(entry == 1) for entry in s_left])()
t_right = TensorType(dtype, [(entry == 1) for entry in s_right])()
t_left_val = numpy.zeros(s_left, dtype=dtype)
t_right_val = numpy.zeros(s_right, dtype=dtype)
self._compile_and_check([t_left, t_right],
[Elemwise(scalar.add)(t_left, t_right)],
[t_left_val, t_right_val], Elemwise)
def test_same_inputs(self):
if not theano.config.cxx:
raise SkipTest("G++ not available, so we need to skip this test.")
x = TensorType('float64', [0, 0])('x')
e = Elemwise(scalar.add)(x, x)
f = gof.CLinker().accept(FunctionGraph([x], [e])).make_function()
xv = numpy.random.rand(2, 2)
zv = xv + xv
assert (f(xv) == zv).all()
def make_theano_batch(self, name=None, dtype=None):
if dtype is None:
dtype = config.floatX
broadcastable = [False] * 4
broadcastable[self.axes.index('c')] = self.num_channels == 1
broadcastable = tuple(broadcastable)
return TensorType(dtype=dtype, broadcastable=broadcastable)(name=name)
def test_graphstructures_1(self):
x = T.dmatrix('x')
y = T.dmatrix('y')
z = x + y
x = T.matrix('x')
y = T.matrix('y')
z = T.matrix('z')
# create 2 Variables (one for 'e', one intermediate for y*z)
# create 2 Apply instances (one for '+', one for '*')
e = x + y * z
from theano.tensor import add, mul, Apply, Variable, TensorType
# Instantiate a type that represents a matrix of doubles
float64_matrix = TensorType(dtype='float64', # double
broadcastable=(False, False)) # matrix
# We make the Variable instances we need.
x = Variable(type=float64_matrix, name='x')
y = Variable(type=float64_matrix, name='y')
z = Variable(type=float64_matrix, name='z')
# This is the Variable that we want to symbolically represents y*z
mul_variable = Variable(type=float64_matrix)
assert mul_variable.owner is None
# Instantiate a symbolic multiplication
node_mul = Apply(op=mul,
inputs=[y, z],
outputs=[mul_variable])
# Fields 'owner' and 'index' are set by Apply
assert mul_variable.owner is node_mul
# 'index' is the position of mul_variable in mode_mul's outputs
assert mul_variable.index == 0
# This is the Variable that we want to symbolically represents x+(y*z)
add_variable = Variable(type=float64_matrix)
assert add_variable.owner is None
# Instantiate a symbolic addition
node_add = Apply(op=add,
inputs=[x, mul_variable],
outputs=[add_variable])
# Fields 'owner' and 'index' are set by Apply
assert add_variable.owner is node_add
assert add_variable.index == 0
e = add_variable
# We have access to x, y and z through pointers
assert e.owner.inputs[0] is x
assert e.owner.inputs[1] is mul_variable
assert e.owner.inputs[1].owner.inputs[0] is y
assert e.owner.inputs[1].owner.inputs[1] is z
def test_infer_shape(self, dtype=None, pre_scalar_op=None):
if dtype is None:
dtype = theano.config.floatX
for xsh, tosum in self.cases:
x = TensorType(dtype, [(entry == 1) for entry in xsh])('x')
if pre_scalar_op is not None:
x = pre_scalar_op(x)
if tosum is None:
tosum = range(len(xsh))
xv = numpy.asarray(numpy.random.rand(*xsh), dtype=dtype)
d = {}
if pre_scalar_op is not None:
xv = x.eval({x.owner.inputs[0]: xv})
d = {pre_scalar_op: pre_scalar_op}
self._compile_and_check([x],
[self.op(scalar.add, axis=tosum, *d)(x)],
[xv], self.op,
["local_cut_useless_reduce"],
warn=0 not in xsh)
def test_infer_shape(self, dtype=None, pre_scalar_op=None):
if dtype is None:
dtype = theano.config.floatX
for xsh, tosum in self.cases:
x = TensorType(dtype, [(entry == 1) for entry in xsh])('x')
if pre_scalar_op is not None:
x = pre_scalar_op(x)
if tosum is None:
tosum = range(len(xsh))
xv = numpy.asarray(numpy.random.rand(*xsh), dtype=dtype)
d = {}
if pre_scalar_op is not None:
xv = x.eval({x.owner.inputs[0]: xv})
d = {pre_scalar_op: pre_scalar_op}
self._compile_and_check([x],
[self.op(scalar.add, axis=tosum, *d)(x)],
[xv],
self.op, ["local_cut_useless_reduce"],
warn=0 not in xsh)
def test_infer_shape(self, dtype=None):
if dtype is None:
dtype = theano.config.floatX
for xsh, tosum in self.cases:
x = TensorType(dtype, [(entry == 1) for entry in xsh])('x')
if tosum is None:
tosum = range(len(xsh))
xv = numpy.asarray(numpy.random.rand(*xsh), dtype=dtype)
self._compile_and_check([x], [self.op(scalar.add, axis=tosum)(x)],
[xv],
self.op, ["local_cut_useless_reduce"],
warn=0 not in xsh)
def make_node(self, img, kern):
img = as_tensor_variable(img)
kern = as_tensor_variable(kern)
if img.type.ndim != 4:
raise TypeError('img must be 4D tensor')
if kern.type.ndim != 4:
raise TypeError('kern must be 4D tensor')
broadcastable = [img.type.broadcastable[0], kern.type.broadcastable[0],
False, False]
dtype = img.type.dtype
return Apply(self, [img, kern], [TensorType(dtype, broadcastable)()])
def make_theano_batch(self, name=None, dtype=None, batch_size=None):
if dtype is None:
dtype = config.floatX
broadcastable = [False] * 5
broadcastable[self.axes.index('c')] = (self.num_channels == 1)
broadcastable[self.axes.index('b')] = True
broadcastable = tuple(broadcastable)
rval = TensorType(dtype=dtype, broadcastable=broadcastable)(name=name)
if config.compute_test_value != 'off':
rval.tag.test_value = self.get_origin_batch(n=1)
def test_cdata():
i = TensorType('float32', (False, ))()
c = ProdOp()(i)
i2 = GetOp()(c)
# This should be a passthrough function for vectors
f = theano.function([i], i2)
v = numpy.random.randn(9).astype('float32')
v2 = f(v)
assert (v2 == v).all()
def test_convert_to_complex(self):
val64 = np.ones(3, dtype="complex64") + 0.5j
val128 = np.ones(3, dtype="complex128") + 0.5j
vec64 = TensorType("complex64", (False, ))()
vec128 = TensorType("complex128", (False, ))()
f = function([vec64], basic._convert_to_complex128(vec64))
# we need to compare with the same type.
assert vec64.type.values_eq_approx(val128, f(val64))
f = function([vec128], basic._convert_to_complex128(vec128))
assert vec64.type.values_eq_approx(val128, f(val128))
f = function([vec64], basic._convert_to_complex64(vec64))
assert vec64.type.values_eq_approx(val64, f(val64))
f = function([vec128], basic._convert_to_complex64(vec128))
assert vec128.type.values_eq_approx(val64, f(val128))
# upcasting to complex128
for t in ["int8", "int16", "int32", "int64", "float32", "float64"]:
a = theano.shared(np.ones(3, dtype=t))
b = theano.shared(np.ones(3, dtype="complex128"))
f = function([], basic._convert_to_complex128(a))
assert a.type.values_eq_approx(b.get_value(), f())
# upcasting to complex64
for t in ["int8", "int16", "int32", "int64", "float32"]:
a = theano.shared(np.ones(3, dtype=t))
b = theano.shared(np.ones(3, dtype="complex64"))
f = function([], basic._convert_to_complex64(a))
assert a.type.values_eq_approx(b.get_value(), f())
# downcast to complex64
for t in ["float64"]:
a = theano.shared(np.ones(3, dtype=t))
b = theano.shared(np.ones(3, dtype="complex64"))
f = function([], basic._convert_to_complex64(a))
assert a.type.values_eq_approx(b.get_value(), f())
def with_linker(self, linker):
for xsh, shuffle, zsh in [((2, 3), (1, 'x', 0), (3, 1, 2)),
((1, 2, 3), (1, 2), (2, 3)),
((1, 2, 1, 3), (1, 3), (2, 3)),
((2, 3, 4), (2, 1, 0), (4, 3, 2)),
((2, 3, 4), ('x', 2, 1, 0, 'x'), (1, 4, 3, 2,
1)),
((1, 4, 3, 2, 1), (3, 2, 1), (2, 3, 4)),
((1, 1, 4), (1, 2), (1, 4)),
((1, 1, 1), (), ()),
((1, ), ('x', 'x'), (1, 1))]:
ib = [(entry == 1) for entry in xsh]
x = TensorType('float64', ib)('x')
e = self.op(ib, shuffle)(x)
f = copy(linker).accept(FunctionGraph([x], [e])).make_function()
assert f(numpy.ones(xsh)).shape == zsh
#test that DimShuffle.infer_shape work correctly
x = TensorType('float64', ib)('x')
e = self.op(ib, shuffle)(x)
f = copy(linker).accept(FunctionGraph([x],
[e.shape])).make_function()
assert all(f(numpy.ones(xsh))) == all(zsh)
# Test when we drop a axis that is not broadcastable
ib = [False, True, False]
x = TensorType('float64', ib)('x')
self.assertRaises(ValueError, self.op, ib, shuffle)
# Test when we drop a axis that don't have shape 1
ib = [True, True, False]
x = TensorType('float64', ib)('x')
e = self.op(ib, (1, 2))(x)
f = copy(linker).accept(FunctionGraph([x], [e.shape])).make_function()
self.assertRaises(TypeError, f, numpy.ones((2, 1, 4)))
# Test that we can't take a dimensions multiple time
xsh, shuffle, zsh = ((1, 1, 4), (0, 1, 2, 0), (1, 4))
ib = [False, True, False]
x = TensorType('float64', ib)('x')
self.assertRaises(ValueError, DimShuffle, ib, shuffle)
def test_infer_shape(self):
for xsh, shuffle in [((2, 3), (1, 'x', 0)), ((1, 2, 3), (1, 2)),
((1, 2, 1, 3), (1, 3)), ((2, 3, 4), (2, 1, 0)),
((2, 3, 4), ('x', 2, 1, 0, 'x')),
((1, 4, 3, 2, 1), (3, 2, 1)), ((1, 1, 4), (1, 2)),
((1, 1, 1), ()), ((1, ), ('x', 'x'))]:
ib = [(entry == 1) for entry in xsh]
adtens = TensorType('float64', ib)('x')
adtens_val = numpy.ones(xsh)
self._compile_and_check([adtens],
[DimShuffle(ib, shuffle)(adtens)],
[adtens_val], DimShuffle)
def __init__(self, model):
raise NotImplementedError("Repeating class not implemented yet!")
# make sure the input model to repeat is a Model instance
assert isinstance(
model, Model
), "The initial model provided was type %s, not a Model." % str(
type(model))
self.model = model
# make this input one dimension more than the provided Model's input (since we are repeating over the
# first dimension)
model_input = raise_to_list(self.model.get_inputs())[0]
self.input = TensorType(model_input.dtype,
(False, ) * (model_input.ndim + 1))
def test_infer_shape(self):
for xsh, tosum in [((5, 6), None), ((5, 6), (0, 1)), ((5, 6), (0, )),
((5, 6), (1, )), ((5, 6), (-1, )), ((5, 6), (-2, )),
((2, 3, 4, 5), (0, 1, 3)), ((2, 3, 4, 5), (-2, -3)),
((5, 0), None), ((5, 0), (0, )), ((5, 0), (1, )),
((5, 6), ()), ((5, 0), ()), ((), None), ((), ())]:
dtype = theano.config.floatX
x = TensorType(dtype, [(entry == 1) for entry in xsh])('x')
if tosum is None:
tosum = range(len(xsh))
xv = numpy.asarray(numpy.random.rand(*xsh), dtype=dtype)
self._compile_and_check([x], [self.op(scalar.add, axis=tosum)(x)],
[xv], self.op,
["local_cut_useless_reduce"])
def test_cdata():
if not theano.config.cxx:
raise SkipTest("G++ not available, so we need to skip this test.")
i = TensorType('float32', (False, ))()
c = ProdOp()(i)
i2 = GetOp()(c)
# This should be a passthrough function for vectors
f = theano.function([i], i2)
v = numpy.random.randn(9).astype('float32')
v2 = f(v)
assert (v2 == v).all()
def test_cdata():
i = TensorType("float32", (False, ))()
c = ProdOp()(i)
i2 = GetOp()(c)
mode = None
if theano.config.mode == "FAST_COMPILE":
mode = "FAST_RUN"
# This should be a passthrough function for vectors
f = theano.function([i], i2, mode=mode)
v = np.random.randn(9).astype("float32")
v2 = f(v)
assert (v2 == v).all()
def _make_batch(self, is_symbolic, batch_size, dtype, name):
# if 'b' not in self.axes:
# raise ValueError("This format has no batch ('b') axis.")
if is_symbolic:
assert_is(batch_size, None)
# shape = list(self.shape)
# # ok if batch_size is None
# shape[self.axes.index('b')] = batch_size
broadcastable = [False] * len(self.axes)
# broadcastable = tuple(size == 1 for size in shape)
# broadcastable = [False] * len(self.axes)
# if 'f' in self.axes:
# f_index = self.axes.index('f')
# broadcastable[f_index] = (self.shape[f_index] == 1)
# if 'b' in self.axes:
# broadcastable[self.axes.index('b')] = (batch_size == 1)
# broadcastable = tuple(broadcastable)
tensor_type = TensorType(dtype=dtype, broadcastable=broadcastable)
result = tensor_type.make_variable(name=name)
if theano.config.compute_test_value != 'off':
test_batch_size = (None if 'b' not in self.axes
else formats.test_batch_size)
result.tag.test_value = self.make_batch(
is_symbolic=False,
batch_size=test_batch_size,
dtype=dtype)
# if batch_size is None:
# raise ValueError("When theano.config.compute_test_values "
# "is not 'off', you must supply a "
# "batch_size argument even when making"
# "symbolic batches.")
# else:
# result.tag.test_value = \
# self.make_batch(is_symbolic=False,
# batch_size=batch_size,
# dtype=dtype)
# Don't understand this, from
# pylearn2.space.ConvSpace2D.make_theano_batch, but keep it
# here in case it becomes clear later:
# if batch_size == 1:
# n = 1
# else:
# batch_size
# # TODO: try to extract constant scalar value
# # from batch_size
# n = 4
# rval.tag.test_value = self.get_origin_batch(batch_size=n,
# dtype=dtype)
return result
# This is what pylearn2.space.VectorSpace does, for efficiency
# reasons, but IIRC people on the mailing list were often
# complaining of breakages caused by batch type that changed from
# tensor.row to tensor.matrix depending on the value of batch_size.
# whether a batch was a row or a matrix. Seems like any
# efficiency gains may be more trouble that they're worth.
# if batch_size == 1:
# return theano.tensor.row(name=name, dtype=dtype)
# else:
# return theano.tensor.matrix(name=name, dtype=dtype)
else: # i.e. is_symbolic == False
if batch_size is None:
assert_not_in('b', self.axes)
else:
assert_in('b',
self.axes,
("batch_size argument provided ({}), but "
"this format has no batch "
"('b') axis.").format(batch_size))
shape = list(self.shape)
shape[self.axes.index('b')] = batch_size
dtype = dtype if dtype is not None else self.dtype
if dtype is None:
raise ValueError("When self.dtype is None, you must provide a "
"dtype argument to make_batch")
return numpy.zeros(shape, dtype)
if isinstance(exc, type(ref_e)):
return
else:
err_msg = ("Test %s::%s: exception raised during test "
"call was not the same as the reference "
"call (got: %s, expected %s)") % \
(self.gpu_op, testname, type(exc),
type(ref_e))
exc.args += (err_msg,)
raise
for i, (variable, expected) in \
enumerate(izip(variables, expecteds)):
if variable.dtype != expected.dtype or \
variable.shape != expected.shape or \
not TensorType.values_eq_approx(variable,
expected):
self.fail(("Test %s::%s: Output %s gave the wrong "
"value. With inputs %s, expected %s "
"(dtype %s), got %s (dtype %s).") % (
self.op, testname, i, inputs, expected,
expected.dtype, variable, variable.dtype))
for description, check in self.checks.items():
if not check(inputs, variables):
self.fail(("Test %s::%s: Failed check: %s "
"(inputs were %s, ouputs were %s)") %
(self.op, testname, description,
inputs, variables))
Checker.__name__ = name
return Checker
def run_case(self, testname, inputs):
inputs_ref = [theano.shared(inp) for inp in inputs]
inputs_tst = [theano.shared(inp) for inp in inputs]
try:
node_ref = safe_make_node(self.op, *inputs_ref)
node_tst = safe_make_node(self.op, *inputs_tst)
except Exception as exc:
err_msg = ("Test %s::%s: Error occured while making "
"a node with inputs %s") % (self.gpu_op, testname,
inputs)
exc.args += (err_msg,)
raise
try:
f_ref = inplace_func([], node_ref.outputs, mode=mode_nogpu)
f_tst = inplace_func([], node_tst.outputs, mode=mode_gpu)
except Exception as exc:
err_msg = ("Test %s::%s: Error occured while trying to "
"make a Function") % (self.gpu_op, testname)
exc.args += (err_msg,)
raise
self.assertFunctionContains1(f_tst, self.gpu_op)
ref_e = None
try:
expecteds = f_ref()
except Exception as exc:
ref_e = exc
try:
variables = f_tst()
except Exception as exc:
if ref_e is None:
err_msg = ("Test %s::%s: exception when calling the "
"Function") % (self.gpu_op, testname)
exc.args += (err_msg,)
raise
else:
# if we raised an exception of the same type we're good.
if isinstance(exc, type(ref_e)):
return
else:
err_msg = ("Test %s::%s: exception raised during test "
"call was not the same as the reference "
"call (got: %s, expected %s)") % \
(self.gpu_op, testname, type(exc),
type(ref_e))
exc.args += (err_msg,)
raise
for i, (variable, expected) in \
enumerate(izip(variables, expecteds)):
if variable.dtype != expected.dtype or \
variable.shape != expected.shape or \
not TensorType.values_eq_approx(variable,
expected):
self.fail(("Test %s::%s: Output %s gave the wrong "
"value. With inputs %s, expected %s "
"(dtype %s), got %s (dtype %s).") % (
self.op, testname, i, inputs, expected,
expected.dtype, variable, variable.dtype))
for description, check in self.checks.items():
if not check(inputs, variables):
self.fail(("Test %s::%s: Failed check: %s "
"(inputs were %s, ouputs were %s)") %
(self.op, testname, description,
inputs, variables))
