def test_create_param_bad_callable_raises():
from lasagne.utils import create_param
with pytest.raises(TypeError):
create_param(lambda x: {}, (1, 2, 3))
with pytest.raises(ValueError):
create_param(lambda x: np.array(1), (1, 2, 3))
def test_create_param_broadcast_pattern():
from lasagne.utils import create_param
for shape in (10, 1, 20), (1, 2), (3, 1), (2, 3):
bcast = tuple(s == 1 for s in shape)
assert create_param(np.zeros, shape).broadcastable == bcast
assert create_param(np.zeros(shape, np.float32),
shape).broadcastable == bcast
def test_create_param_bad_callable_raises():
from lasagne.utils import create_param
with pytest.raises(TypeError):
create_param(lambda x: {}, (1, 2, 3))
with pytest.raises(ValueError):
create_param(lambda x: np.array(1), (1, 2, 3))
def test_create_param_broadcast_pattern():
from lasagne.utils import create_param
for shape in (10, 1, 20), (1, 2), (3, 1), (2, 3):
bcast = tuple(s == 1 for s in shape)
assert create_param(np.zeros, shape).broadcastable == bcast
assert create_param(np.zeros(shape, np.float32),
shape).broadcastable == bcast
def test_create_param_callable_returns_wrong_type():
from lasagne.utils import create_param
param = 'string'
factory = Mock()
factory.return_value = param
with pytest.raises(TypeError):
create_param(factory, (1, 2))
def test_create_param_callable_returns_wrong_type():
from lasagne.utils import create_param
param = 'string'
factory = Mock()
factory.return_value = param
with pytest.raises(TypeError):
create_param(factory, (1, 2))
def test_create_param_callable_returns_shared_bad_ndim_raises_error():
from lasagne.utils import create_param
array = np.array([[1, 2], [3, 4]])
param = theano.shared(array)
factory = Mock()
factory.return_value = param
with pytest.raises(ValueError):
create_param(factory, (2, 3, 4))
def test_create_param_callable_returns_shared_bad_ndim_raises_error():
from lasagne.utils import create_param
array = np.array([[1, 2], [3, 4]])
param = theano.shared(array)
factory = Mock()
factory.return_value = param
with pytest.raises(ValueError):
create_param(factory, (2, 3, 4))
def test_create_param_retain_ndarray_dtype():
from lasagne.utils import create_param
param = np.array([[1, 2, 3], [4, 5, 6]])
param = param.astype('float64')
result = create_param(param, (2, 3))
assert (result.dtype == param.dtype)
param = param.astype('int16')
result = create_param(param, (2, 3))
assert (result.dtype == param.dtype)
def test_create_param_retain_ndarray_dtype():
from lasagne.utils import create_param
param = np.array([[1, 2, 3], [4, 5, 6]])
param = param.astype('float64')
result = create_param(param, (2, 3))
assert (result.dtype == param.dtype)
param = param.astype('int16')
result = create_param(param, (2, 3))
assert (result.dtype == param.dtype)
def test_create_param_numpy_returns_shared():
from lasagne.utils import create_param
param = np.array([[1, 2, 3], [4, 5, 6]])
result = create_param(param, (2, 3))
assert (result.get_value() == param).all()
assert isinstance(result, type(theano.shared(param)))
assert (result.get_value() == param).all()
def test_create_param_numpy_returns_shared():
from lasagne.utils import create_param
param = np.array([[1, 2, 3], [4, 5, 6]])
result = create_param(param, (2, 3))
assert (result.get_value() == param).all()
assert isinstance(result, type(theano.shared(param)))
assert (result.get_value() == param).all()
def add_param(self, init, in_shape, name, type):
par = create_param(init, in_shape, name)
self.params.append(par)
if type == 'r':
self.r_params.append(par)
elif type == 'p':
self.p_params.append(par)
return par
def test_create_param_callable_returns_return_value():
from lasagne.utils import create_param
array = np.array([[1, 2, 3], [4, 5, 6]])
factory = Mock()
factory.return_value = array
result = create_param(factory, (2, 3))
assert (result.get_value() == array).all()
factory.assert_called_with((2, 3))
def test_create_param_callable_returns_return_value():
from lasagne.utils import create_param
array = np.array([[1, 2, 3], [4, 5, 6]])
factory = Mock()
factory.return_value = array
result = create_param(factory, (2, 3))
assert (result.get_value() == array).all()
factory.assert_called_with((2, 3))
def __init__(self, incoming, num_units,
Wh=init.Orthogonal(),
Wx=init.Orthogonal(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
**kwargs):
super(SimpleRNN, self).__init__(incoming, **kwargs)
self.nonlinearity = (nonlinearities.identity if nonlinearity is None
else nonlinearity)
self.num_units = num_units
num_inputs = int(np.prod(self.input_shape[2:]))
self.Wx = utils.create_param(Wx, (num_inputs, num_units), name="Wx")
self.Wh = utils.create_param(Wh, (num_units, num_units), name="Wh")
self.b = utils.create_param(b, (num_units,), name="b") if b is not None else None
def test_create_param_callable_returns_theano_expr():
from lasagne.utils import create_param
array = np.array([[1, 2, 3], [4, 5, 6]])
param = theano.shared(array) * 2
factory = Mock()
factory.return_value = param
result = create_param(factory, (2, 3))
assert (result.eval() == array * 2).all()
assert result is param
def test_create_param_callable_returns_theano_expr():
from lasagne.utils import create_param
array = np.array([[1, 2, 3], [4, 5, 6]])
param = theano.shared(array) * 2
factory = Mock()
factory.return_value = param
result = create_param(factory, (2, 3))
assert (result.eval() == array * 2).all()
assert result is param
def test_nonpositive_dims_raises_value_error():
from lasagne.utils import create_param
neg_shape = (-1, -1)
zero_shape = (0, 0)
pos_shape = (1, 1)
spec = np.empty
with pytest.raises(ValueError):
create_param(spec, neg_shape)
with pytest.raises(ValueError):
create_param(spec, zero_shape)
create_param(spec, pos_shape)
def test_nonpositive_dims_raises_value_error():
from lasagne.utils import create_param
neg_shape = (-1, -1)
zero_shape = (0, 0)
pos_shape = (1, 1)
spec = np.empty
with pytest.raises(ValueError):
create_param(spec, neg_shape)
with pytest.raises(ValueError):
create_param(spec, zero_shape)
create_param(spec, pos_shape)
def add_param(self, spec, shape, name=None, **tags):
"""
Register and possibly initialize a parameter tensor for the layer.
When defining a layer class, this method is called in the constructor
to define which parameters the layer has, what their shapes are, how
they should be initialized and what tags are associated with them.
This allows layer classes to transparently support parameter
initialization from numpy arrays and callables, as well as setting
parameters to existing Theano shared variables or Theano expressions.
All registered parameters are stored along with their tags in the
ordered dictionary :attr:`Layer.params`, and can be retrieved with
:meth:`Layer.get_params()`, optionally filtered by their tags.
Parameters
----------
spec : Theano shared variable, expression, numpy array or callable
initial value, expression or initializer for this parameter.
See :func:`lasagne.utils.create_param` for more information.
shape : tuple of int
a tuple of integers representing the desired shape of the
parameter tensor.
name : str (optional)
a descriptive name for the parameter variable. This will be passed
to ``theano.shared`` when the variable is created, prefixed by the
layer's name if any (in the form ``'layer_name.param_name'``). If
``spec`` is already a shared variable or expression, this parameter
will be ignored to avoid overwriting an existing name.
**tags (optional)
tags associated with the parameter can be specified as keyword
arguments. To associate the tag ``tag1`` with the parameter, pass
``tag1=True``.
By default, the tags ``regularizable`` and ``trainable`` are
associated with the parameter. Pass ``regularizable=False`` or
``trainable=False`` respectively to prevent this.
Returns
-------
Theano shared variable or Theano expression
the resulting parameter variable or parameter expression
Notes
-----
It is recommended to assign the resulting parameter variable/expression
to an attribute of the layer for easy access, for example:
>>> self.W = self.add_param(W, (2, 3), name='W') #doctest: +SKIP
"""
# prefix the param name with the layer name if it exists
if name is not None:
if self.name is not None:
name = "%s.%s" % (self.name, name)
# create shared variable, or pass through given variable/expression
param = utils.create_param(spec, shape, name)
# parameters should be trainable and regularizable by default
tags['trainable'] = tags.get('trainable', True)
tags['regularizable'] = tags.get('regularizable', True)
self.params[param] = set(tag for tag, value in tags.items() if value)
return param
def __init__(self, incoming, num_units,
Wxi=init.Orthogonal(),
Wxf=init.Orthogonal(),
Wxo=init.Orthogonal(),
Wxg=init.Orthogonal(),
Whi=init.Orthogonal(),
Whf=init.Orthogonal(),
Who=init.Orthogonal(),
Whg=init.Orthogonal(),
bi=init.Constant(0.),
bf=init.Constant(0.),
bo=init.Constant(0.),
bg=init.Constant(0.),
nonlinearity=nonlinearities.tanh,
**kwargs):
super(LSTM, self).__init__(incoming, **kwargs)
self.nonlinearity = (nonlinearities.identity if nonlinearity is None
else nonlinearity)
self.num_units = num_units
num_inputs = int(np.prod(self.input_shape[2:]))
self.Wxi = utils.create_param(Wxi, (num_inputs, num_units), name="Wxi")
self.Wxf = utils.create_param(Wxf, (num_inputs, num_units), name="Wxf")
self.Wxo = utils.create_param(Wxo, (num_inputs, num_units), name="Wxo")
self.Wxg = utils.create_param(Wxg, (num_inputs, num_units), name="Wxg")
self.Whi = utils.create_param(Wxi, (num_units, num_units), name="Whi")
self.Whf = utils.create_param(Wxf, (num_units, num_units), name="Whf")
self.Who = utils.create_param(Wxo, (num_units, num_units), name="Who")
self.Whg = utils.create_param(Wxg, (num_units, num_units), name="Whg")
self.bi = utils.create_param(bi, (num_units,), name="bi") if bi is not None else None
self.bf = utils.create_param(bf, (num_units,), name="bf") if bf is not None else None
self.bo = utils.create_param(bo, (num_units,), name="bo") if bo is not None else None
self.bg = utils.create_param(bg, (num_units,), name="bg") if bg is not None else None
def test_create_param_shared_returns_same():
from lasagne.utils import create_param
param = theano.shared(np.array([[1, 2, 3], [4, 5, 6]]))
result = create_param(param, (2, 3))
assert result is param
def test_create_param_shared_bad_ndim_raises_error():
from lasagne.utils import create_param
param = theano.shared(np.array([[1, 2, 3], [4, 5, 6]]))
with pytest.raises(ValueError):
create_param(param, (2, 3, 4))
def test_create_param_shared_returns_same():
from lasagne.utils import create_param
param = theano.shared(np.array([[1, 2, 3], [4, 5, 6]]))
result = create_param(param, (2, 3))
assert result is param
def test_create_param_numpy_generic_returns_same():
from lasagne.utils import create_param
param = np.int_(2)
result = create_param(param, ())
assert result.get_value() == param
def test_create_param_number_returns_same():
from lasagne.utils import create_param
param = 1
result = create_param(param, ())
assert result.get_value() == param
def test_create_param_shared_bad_ndim_raises_error():
from lasagne.utils import create_param
param = theano.shared(np.array([[1, 2, 3], [4, 5, 6]]))
with pytest.raises(ValueError):
create_param(param, (2, 3, 4))
def test_create_param_numpy_bad_shape_raises_error():
from lasagne.utils import create_param
param = np.array([[1, 2, 3], [4, 5, 6]])
with pytest.raises(ValueError):
create_param(param, (3, 2))
def test_create_param_accepts_iterable_shape():
from lasagne.utils import create_param
factory = np.empty
create_param(factory, [2, 3])
create_param(factory, (x for x in [2, 3]))
def test_create_param_numpy_bad_shape_raises_error():
from lasagne.utils import create_param
param = np.array([[1, 2, 3], [4, 5, 6]])
with pytest.raises(ValueError):
create_param(param, (3, 2))
def test_create_param_bad_spec_raises():
from lasagne.utils import create_param
with pytest.raises(TypeError):
create_param({}, (1, 2, 3))
def test_create_param_numpy_generic_returns_same():
from lasagne.utils import create_param
param = np.int_(2)
result = create_param(param, ())
assert result.get_value() == param
def make_b(self, size, name):
P = create_param(Constant(0.), (size, ), name=name)
self.parameters[name] = P
return P
def test_create_param_number_returns_same():
from lasagne.utils import create_param
param = 1
result = create_param(param, ())
assert result.get_value() == param
def test_create_param_bad_spec_raises():
from lasagne.utils import create_param
with pytest.raises(TypeError):
create_param({}, (1, 2, 3))
def make_W(self, num_in, num_out, name):
P = create_param(self.igor.default_initializer, (num_in, num_out), name=name)
self.parameters[name] = P
return P
def test_create_param_accepts_iterable_shape():
from lasagne.utils import create_param
factory = np.empty
create_param(factory, [2, 3])
create_param(factory, (x for x in [2, 3]))
