def test_extend_inplace(self): mySymbolicMatricesList1 = TypedListType( TensorType(aesara.config.floatX, (False, False)))() mySymbolicMatricesList2 = TypedListType( TensorType(aesara.config.floatX, (False, False)))() z = Extend()(mySymbolicMatricesList1, mySymbolicMatricesList2) m = aesara.compile.mode.get_default_mode().including( "typed_list_inplace_opt") f = aesara.function( [ In(mySymbolicMatricesList1, borrow=True, mutable=True), mySymbolicMatricesList2, ], z, mode=m, ) assert f.maker.fgraph.toposort()[0].op.inplace x = random_ranged(-1000, 1000, [100, 101]) y = random_ranged(-1000, 1000, [100, 101]) assert np.array_equal(f([x], [y]), [x, y])
def test_dtype_failure(self): arr = TensorType(FLOATX, [False] * 3)("arr") indices = TensorType(FLOATX, [False] * 3)("indices") arr.tag.test_value = np.zeros((1,) * arr.ndim, dtype=FLOATX) indices.tag.test_value = np.zeros((1,) * indices.ndim, dtype=FLOATX) with pytest.raises(IndexError): take_along_axis(arr, indices)
def test_convert_variable(): test_type = TensorType(config.floatX, [False, False]) test_var = test_type() test_type2 = TensorType(config.floatX, [True, False]) test_var2 = test_type2() res = test_type.convert_variable(test_var) assert res is test_var res = test_type.convert_variable(test_var2) assert res is test_var2 res = test_type2.convert_variable(test_var) assert res.type == test_type2 test_type3 = TensorType(config.floatX, [True, False, True]) test_var3 = test_type3() res = test_type2.convert_variable(test_var3) assert res is None const_var = at.as_tensor([[1, 2], [3, 4]], dtype=config.floatX) res = test_type.convert_variable(const_var) assert res is const_var
def test__getitem__AdvancedSubtensor_bool(): x = matrix("x") i = TensorType("bool", (False, False))("i") z = x[i] op_types = [ type(node.op) for node in aesara.graph.basic.io_toposort([x, i], [z]) ] assert op_types[-1] == AdvancedSubtensor i = TensorType("bool", (False, ))("i") z = x[:, i] op_types = [ type(node.op) for node in aesara.graph.basic.io_toposort([x, i], [z]) ] assert op_types[-1] == AdvancedSubtensor i = TensorType("bool", (False, ))("i") z = x[..., i] op_types = [ type(node.op) for node in aesara.graph.basic.io_toposort([x, i], [z]) ] assert op_types[-1] == AdvancedSubtensor with pytest.raises(TypeError): z = x[[True, False], i] z = x[ivector("b"), i] op_types = [ type(node.op) for node in aesara.graph.basic.io_toposort([x, i], [z]) ] assert op_types[-1] == AdvancedSubtensor
def make_node(self, x): x = aet.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 = [TensorType(broadcastable=broadcastable, dtype=x.dtype)()] typ = 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 Apply(self, [x], outputs)
def test_fill_grad(self): # Fix bug reported at # https://groups.google.com/d/topic/theano-users/nQshB8gUA6k/discussion x = TensorType(config.floatX, (False, True, False))("x") y = TensorType(config.floatX, (False, True, False))("y") e = second(x, y) aesara.grad(e.sum(), y)
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 = aesara.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 = np.zeros(s_left, dtype=dtype) t_right_val = np.zeros(s_right, dtype=dtype) self._compile_and_check( [t_left, t_right], [Elemwise(aes.add)(t_left, t_right)], [t_left_val, t_right_val], Elemwise, )
def _input_tensors(self, shape): ndim = len(shape) arr = TensorType(FLOATX, [False] * ndim)("arr") indices = TensorType(INTX, [False] * ndim)("indices") arr.tag.test_value = np.zeros(shape, dtype=FLOATX) indices.tag.test_value = np.zeros(shape, dtype=INTX) return arr, indices
def test_ctors(self): if PYTHON_INT_BITWIDTH == 32: assert shared(7).type == iscalar, shared(7).type else: assert shared(7).type == lscalar, shared(7).type assert shared(7.0).type == dscalar assert shared(np.float32(7)).type == 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_fixed_shape_clone(): t1 = TensorType("float64", (1,)) t2 = t1.clone(dtype="float32", shape=(2, 4)) assert t2.shape == (2, 4) t2 = t1.clone(dtype="float32", shape=(False, False)) assert t2.shape == (None, None)
def test_get_vector_length(): x = TensorVariable(TensorType("int64", (4, ))) res = get_vector_length(x) assert res == 4 x = TensorVariable(TensorType("int64", (None, ))) with pytest.raises(ValueError): get_vector_length(x)
def test_fixed_partial_shapes(self): x = TensorType("floatX", (None, None))("x") y = specify_shape(x, (None, 5)) assert y.type.shape == (None, 5) x = TensorType("floatX", (3, None))("x") y = specify_shape(x, (None, 5)) assert y.type.shape == (3, 5)
def _input_tensors(self, shape, floatX): intX = str(_conversion_map[floatX]) ndim = len(shape) arr = TensorType(floatX, [False] * ndim)("arr") indices = TensorType(intX, [False] * ndim)("indices") arr.tag.test_value = np.zeros(shape, dtype=floatX) indices.tag.test_value = np.zeros(shape, dtype=intX) return arr, indices
def test_dtype_failure(self, floatX): with aesara.config.change_flags(floatX=floatX): arr = TensorType(floatX, [False] * 3)("arr") indices = TensorType(floatX, [False] * 3)("indices") arr.tag.test_value = np.zeros((1, ) * arr.ndim, dtype=floatX) indices.tag.test_value = np.zeros((1, ) * indices.ndim, dtype=floatX) with pytest.raises(IndexError): take_along_axis(arr, indices)
def test_ndim_failure(self, floatX): with aesara.config.change_flags(floatX=floatX): intX = str(_conversion_map[floatX]) arr = TensorType(floatX, [False] * 3)("arr") indices = TensorType(intX, [False] * 2)("indices") arr.tag.test_value = np.zeros((1, ) * arr.ndim, dtype=floatX) indices.tag.test_value = np.zeros((1, ) * indices.ndim, dtype=intX) with pytest.raises(ValueError): take_along_axis(arr, indices)
def test_repeatOp(self): for ndim in [1, 3]: x = TensorType(config.floatX, [False] * ndim)() a = np.random.random((10, ) * ndim).astype(config.floatX) for axis in self._possible_axis(ndim): for dtype in integer_dtypes: r_var = scalar(dtype=dtype) r = np.asarray(3, dtype=dtype) if dtype == "uint64" or (dtype in self.numpy_unsupported_dtypes and r_var.ndim == 1): with pytest.raises(TypeError): repeat(x, r_var, axis=axis) else: f = aesara.function([x, r_var], repeat(x, r_var, axis=axis)) assert np.allclose(np.repeat(a, r, axis=axis), f(a, r)) r_var = vector(dtype=dtype) if axis is None: r = np.random.randint(1, 6, size=a.size).astype(dtype) else: r = np.random.randint(1, 6, size=(10, )).astype(dtype) if dtype in self.numpy_unsupported_dtypes and r_var.ndim == 1: with pytest.raises(TypeError): repeat(x, r_var, axis=axis) else: f = aesara.function([x, r_var], repeat(x, r_var, axis=axis)) assert np.allclose(np.repeat(a, r, axis=axis), f(a, r)) # check when r is a list of single integer, e.g. [3]. r = np.random.randint(1, 11, size=()).astype(dtype) + 2 f = aesara.function([x], repeat(x, [r], axis=axis)) assert np.allclose(np.repeat(a, r, axis=axis), f(a)) assert not np.any([ isinstance(n.op, RepeatOp) for n in f.maker.fgraph.toposort() ]) # check when r is aesara tensortype that broadcastable is (True,) r_var = TensorType(broadcastable=(True, ), dtype=dtype)() r = np.random.randint(1, 6, size=(1, )).astype(dtype) f = aesara.function([x, r_var], repeat(x, r_var, axis=axis)) assert np.allclose(np.repeat(a, r[0], axis=axis), f(a, r)) assert not np.any([ isinstance(n.op, RepeatOp) for n in f.maker.fgraph.toposort() ])
def make_node(self, x, y): x = aet.as_tensor_variable(x) y = aet.as_tensor_variable(y) outdim = x.ndim output1 = TensorType(dtype=aesara.scalar.upcast(x.dtype, y.dtype), broadcastable=[False] * outdim)() output2 = TensorType(dtype=aesara.scalar.upcast(x.dtype, y.dtype), broadcastable=[False] * outdim)() return Apply(self, inputs=[x, y], outputs=[output1, output2])
def test_may_share_memory(): a = np.array(2) b = np.broadcast_to(a, (2, 3)) res = TensorType.may_share_memory(a, b) assert res res = TensorType.may_share_memory(a, None) assert res is False
def test_deprecated_kwargs(): with pytest.warns(DeprecationWarning, match=".*broadcastable.*"): res = TensorType("float64", broadcastable=(True, False)) assert res.shape == (1, None) with pytest.warns(DeprecationWarning, match=".*broadcastable.*"): new_res = res.clone(broadcastable=(False, True)) assert new_res.shape == (None, 1)
def test_tensorvariable(self): # Get counter value autoname_id = next(Variable.__count__) Variable.__count__ = count(autoname_id) r1 = TensorType(dtype="int32", shape=())("myvar") r2 = TensorVariable(TensorType(dtype="int32", shape=())) r3 = shared(np.random.standard_normal((3, 4))) assert r1.auto_name == "auto_" + str(autoname_id) assert r2.auto_name == "auto_" + str(autoname_id + 1) assert r3.auto_name == "auto_" + str(autoname_id + 2)
def test_is_super(): test_type = TensorType(config.floatX, [False, False]) test_type2 = TensorType(config.floatX, [False, True]) assert test_type.is_super(test_type) assert test_type.is_super(test_type2) assert not test_type2.is_super(test_type) test_type3 = TensorType(config.floatX, [False, False, False]) assert not test_type3.is_super(test_type)
def test_conv(self): for conv_op in [conv.conv2d, conv2d]: for border_mode in ["valid", "full"]: image_shape = (2, 2, 4, 5) filter_shape = (2, 2, 2, 3) image_dim = len(image_shape) filter_dim = len(filter_shape) input = TensorType(aesara.config.floatX, [False] * image_dim)(name="input") filters = TensorType(aesara.config.floatX, [False] * filter_dim)(name="filter") ev_input = TensorType(aesara.config.floatX, [False] * image_dim)(name="ev_input") ev_filters = TensorType(aesara.config.floatX, [False] * filter_dim)(name="ev_filters") def sym_conv2d(input, filters): return conv_op(input, filters, border_mode=border_mode) output = sym_conv2d(input, filters).flatten() yv = Rop(output, [input, filters], [ev_input, ev_filters]) mode = None if aesara.config.mode == "FAST_COMPILE": mode = "FAST_RUN" rop_f = function( [input, filters, ev_input, ev_filters], yv, on_unused_input="ignore", mode=mode, ) sy, _ = aesara.scan( lambda i, y, x1, x2, v1, v2: (grad(y[i], x1) * v1).sum() + (grad(y[i], x2) * v2).sum(), sequences=aet.arange(output.shape[0]), non_sequences=[ output, input, filters, ev_input, ev_filters ], mode=mode, ) scan_f = function( [input, filters, ev_input, ev_filters], sy, on_unused_input="ignore", mode=mode, ) dtype = aesara.config.floatX image_data = np.random.random(image_shape).astype(dtype) filter_data = np.random.random(filter_shape).astype(dtype) ev_image_data = np.random.random(image_shape).astype(dtype) ev_filter_data = np.random.random(filter_shape).astype(dtype) v1 = rop_f(image_data, filter_data, ev_image_data, ev_filter_data) v2 = scan_f(image_data, filter_data, ev_image_data, ev_filter_data) assert np.allclose(v1, v2), f"Rop mismatch: {v1} {v2}"
def test_filter_memmap(): r"""Make sure `TensorType.filter` can handle NumPy `memmap`\s subclasses.""" data = np.arange(12, dtype=config.floatX) data.resize((3, 4)) filename = path.join(mkdtemp(), "newfile.dat") fp = np.memmap(filename, dtype=config.floatX, mode="w+", shape=(3, 4)) test_type = TensorType(config.floatX, [False, False]) res = test_type.filter(fp) assert res is fp
def test_fixed_shape_variable_basic(): x = TensorVariable(TensorType("int64", (4, ))) assert isinstance(x.shape, Constant) assert np.array_equal(x.shape.data, (4, )) x = TensorConstant(TensorType("int64", (False, False)), np.array([[1, 2], [2, 3]])) assert x.type.shape == (2, 2) with pytest.raises(ValueError): TensorConstant(TensorType("int64", (True, False)), np.array([[1, 2], [2, 3]]))
def test_nested_list_arg(self): # test for the 'depth' optional argument myNestedType = TypedListType( TensorType(aesara.config.floatX, (False, False)), 3 ) myType = TypedListType(TensorType(aesara.config.floatX, (False, False))) myManualNestedType = TypedListType(TypedListType(TypedListType(myType))) assert myNestedType == myManualNestedType
def test_var_interface(self, shape, broadcast): # same as test_op, but use a_aesara_var.squeeze. data = np.random.random(size=shape).astype(config.floatX) variable = TensorType(config.floatX, broadcast)() f = aesara.function([variable], variable.squeeze()) expected = np.squeeze(data) tested = f(data) assert tested.shape == expected.shape assert np.allclose(tested, expected)
def test_filter_ndarray_subclass(): """Make sure `TensorType.filter` can handle NumPy `ndarray` subclasses.""" test_type = TensorType(config.floatX, [False]) class MyNdarray(np.ndarray): pass test_val = np.array([1.0], dtype=config.floatX).view(MyNdarray) assert isinstance(test_val, MyNdarray) res = test_type.filter(test_val) assert isinstance(res, MyNdarray) assert res is test_val
def test_type_equality(self): # Typed list types should only be equal # when they contains the same aesara # variables # list of matrices myType1 = TypedListType(TensorType(aesara.config.floatX, (False, False))) # list of matrices myType2 = TypedListType(TensorType(aesara.config.floatX, (False, False))) # list of scalars myType3 = TypedListType(TensorType(aesara.config.floatX, ())) assert myType2 == myType1 assert myType3 != myType1
def test_axis(self): variable = TensorType(config.floatX, [False, True, False])() res = squeeze(variable, axis=1) assert res.broadcastable == (False, False) variable = TensorType(config.floatX, [False, True, False])() res = squeeze(variable, axis=(1, )) assert res.broadcastable == (False, False) variable = TensorType(config.floatX, [False, True, False, True])() res = squeeze(variable, axis=(1, 3)) assert res.broadcastable == (False, False)
def test_non_tensor_type(self): mySymbolicNestedMatricesList = TypedListType( TensorType(aesara.config.floatX, (False, False)), 1)() mySymbolicMatricesList = TypedListType( TensorType(aesara.config.floatX, (False, False)))() z = Count()(mySymbolicNestedMatricesList, mySymbolicMatricesList) f = aesara.function( [mySymbolicNestedMatricesList, mySymbolicMatricesList], z) x = rand_ranged_matrix(-1000, 1000, [100, 101]) y = rand_ranged_matrix(-1000, 1000, [100, 101]) assert f([[x, y], [x, y, y]], [x, y]) == 1