def test_hash_and_eq_params(self):
wp1 = ParamsType(a=Generic(),
array=TensorType('int64', (False, )),
floatting=Scalar('float64'),
npy_scalar=TensorType('float64', tuple()))
wp2 = ParamsType(a=Generic(),
array=TensorType('int64', (False, )),
floatting=Scalar('float64'),
npy_scalar=TensorType('float64', tuple()))
w1 = Params(wp1,
a=1,
array=np.asarray([1, 2, 4, 5, 7]),
floatting=-4.5,
npy_scalar=np.asarray(12))
w2 = Params(wp2,
a=1,
array=np.asarray([1, 2, 4, 5, 7]),
floatting=-4.5,
npy_scalar=np.asarray(12))
assert w1 == w2
assert not (w1 != w2)
assert hash(w1) == hash(w2)
# Changing attributes names only (a -> other_name).
wp2_other = ParamsType(other_name=Generic(),
array=TensorType('int64', (False, )),
floatting=Scalar('float64'),
npy_scalar=TensorType('float64', tuple()))
w2 = Params(wp2_other,
other_name=1,
array=np.asarray([1, 2, 4, 5, 7]),
floatting=-4.5,
npy_scalar=np.asarray(12))
assert w1 != w2
# Changing attributes values only (now a=2).
w2 = Params(wp2,
a=2,
array=np.asarray([1, 2, 4, 5, 7]),
floatting=-4.5,
npy_scalar=np.asarray(12))
assert w1 != w2
# Changing NumPy array values (5 -> -5).
w2 = Params(wp2,
a=1,
array=np.asarray([1, 2, 4, -5, 7]),
floatting=-4.5,
npy_scalar=np.asarray(12))
assert w1 != w2
def test_invalid_modes(self):
# Modes 'r+', 'r', and 'w+' cannot work with Theano, becausei
# the output array may be modified inplace, and that should not
# modify the original file.
path = Variable(Generic())
for mmap_mode in ('r+', 'r', 'w+', 'toto'):
self.assertRaises(ValueError, tensor.load, path, 'int32',
(False, ), mmap_mode)
def test0(self):
path = Variable(Generic())
# Not specifying mmap_mode defaults to None, and the data is
# copied into main memory
x = tensor.load(path, 'int32', (False, ))
y = x * 2
fn = function([path], y)
assert (fn(self.filename) == (self.data * 2)).all()
def test_memmap(self):
data = numpy.arange(5, dtype=numpy.int32)
filename = os.path.join(theano.config.base_compiledir, "_test.npy")
numpy.save(filename, data)
path = Variable(Generic())
x = tensor.load(path, 'int32', (False,), mmap_mode='r+')
fn = function([path], x)
assert type(fn(filename)) == numpy.core.memmap
def test_invalid_modes(self):
# Modes 'r+', 'r', and 'w+' cannot work with Theano, becausei
# the output array may be modified inplace, and that should not
# modify the original file.
path = Variable(Generic())
for mmap_mode in ("r+", "r", "w+", "toto"):
with pytest.raises(ValueError):
tensor.load(path, "int32", (False, ), mmap_mode)
def test0(self):
data = numpy.arange(5, dtype=numpy.int32)
filename = os.path.join(theano.config.base_compiledir, "_test.npy")
numpy.save(filename, data)
path = Variable(Generic())
x = tensor.load(path, 'int32', (False,))
y = x*2
fn = function([path], y)
assert (fn(filename) == data*2).all()
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 test1(self):
path = Variable(Generic())
# 'c' means "copy-on-write", which allow the array to be overwritten
# by an inplace Op in the graph, without modifying the underlying
# file.
x = tensor.load(path, 'int32', (False, ), 'c')
# x ** 2 has been chosen because it will work inplace.
y = (x**2).sum()
fn = function([path], y)
# Call fn() twice, to check that inplace ops do not cause trouble
assert (fn(self.filename) == (self.data**2).sum()).all()
assert (fn(self.filename) == (self.data**2).sum()).all()
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
from __future__ import absolute_import, print_function, division
import theano
import numpy as np
from unittest import TestCase
from theano.gof import Op, COp, Apply
from theano import Generic
from theano.scalar import Scalar
from theano.tensor import TensorType
from theano.gof import ParamsType, Params, EnumList
from theano import tensor
from theano.tests import unittest_tools as utt
tensor_type_0d = TensorType('float64', tuple())
scalar_type = Scalar('float64')
generic_type = Generic()
# A test op to compute `y = a*x^2 + bx + c` for any tensor x, with a, b, c as op params.
class QuadraticOpFunc(Op):
__props__ = ('a', 'b', 'c')
params_type = ParamsType(a=tensor_type_0d, b=scalar_type, c=generic_type)
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def make_node(self, x):
x = tensor.as_tensor_variable(x)
return Apply(self, [x], [x.type()])
def test_memmap(self):
path = Variable(Generic())
x = tensor.load(path, 'int32', (False, ), mmap_mode='c')
fn = function([path], x)
assert type(fn(self.filename)) == numpy.core.memmap