def check_type_forward(self, in_types): n_in = in_types.size().eval() if n_in != 3 and n_in != 5: raise type_check.InvalidType( '%s or %s' % (in_types.size() == 3, in_types.size() == 5), '%s == %s' % (in_types.size(), n_in)) x_type, gamma_type, beta_type = in_types[:3] type_check.expect( x_type.dtype == numpy.float32, x_type.ndim >= gamma_type.ndim + 1, # TODO(beam2d): Check shape gamma_type.dtype == numpy.float32, beta_type.dtype == numpy.float32, gamma_type.shape == beta_type.shape, ) if len(in_types) == 5: mean_type, var_type = in_types[3:] type_check.expect( mean_type.dtype == numpy.float32, mean_type.shape == gamma_type.shape, var_type.dtype == numpy.float32, var_type.shape == gamma_type.shape, )
def check_type_forward(self, in_types): n_in = type_check.eval(in_types.size()) if n_in != 3 and n_in != 5: raise type_check.InvalidType( '%s or %s' % (in_types.size() == 3, in_types.size() == 5), '%s == %s' % (in_types.size(), n_in)) x_type, gamma_type, beta_type = in_types[:3] M = type_check.eval(gamma_type.ndim) type_check.expect( x_type.dtype.kind == 'f', x_type.ndim >= gamma_type.ndim + 1, x_type.shape[1:1 + M] == gamma_type.shape, # TODO(beam2d): Check shape gamma_type.dtype == x_type.dtype, beta_type.dtype == x_type.dtype, gamma_type.shape == beta_type.shape, ) if len(in_types) == 5: mean_type, var_type = in_types[3:] type_check.expect( mean_type.dtype == x_type.dtype, mean_type.shape == gamma_type.shape, var_type.dtype == x_type.dtype, var_type.shape == gamma_type.shape, )
def _check_data_type_forward(self, in_data): in_type = type_check.get_types(in_data, 'in_types', False) try: self.check_type_forward(in_type) except type_check.InvalidType as e: msg = """ Invalid operation is performed in: {0} (Forward) {1}""".format(self.label, str(e)) raise type_check.InvalidType(e.expect, e.actual, msg=msg)
def check_type_forward(self, in_types): type_check.expect(in_types.size() > 0) shapes = [t.eval().shape for t in in_types] r_shapes = [s[::-1] for s in shapes] r_filled = six.moves.zip_longest(*r_shapes, fillvalue=1) for ss in r_filled: d = max(ss) if not all(s == d or s == 1 for s in ss): expect = 'each dimension has the same size or is 1' actual = 'shapes: ' + ', '.join(map(str, shapes)) raise type_check.InvalidType(expect, actual)
def check_type_forward(self, in_types): n_in = type_check.eval(in_types.size()) if n_in != 3: raise type_check.InvalidType('%s == %s' % (in_types.size(), n_in)) x_type, gamma_type, beta_type = in_types[:3] M = type_check.eval(gamma_type.ndim) type_check.expect( x_type.dtype.kind == 'f', x_type.ndim >= gamma_type.ndim + 1, x_type.shape[1:1 + M] == gamma_type.shape, gamma_type.dtype == x_type.dtype, beta_type.dtype == x_type.dtype, gamma_type.shape == beta_type.shape, )
def check_type_forward(self, in_types): type_check.expect(in_types.size() == 1) ndim = type_check.Variable(len(self._shape), 'len(shape)') type_check.expect(in_types[0].ndim <= ndim) shape = in_types[0].shape.eval() # check the shape in inverse order for i in six.moves.range(-1, -len(shape) - 1, -1): if shape[i] == self._shape[i] or shape[i] == 1: continue expect = 'in_type[0].shape[%d] == %d' % (i, self._shape[i]) if self._shape[i] != 1: expect += ' or in_type[0].shape[%d] == 1' % i actual = 'in_type[0].shape: %s' % str(shape) raise type_check.InvalidType(expect, actual)
def maxout(x, pool_size, axis=1): """Maxout activation function. It accepts an input tensor ``x``, reshapes the ``axis`` dimension (say the size being ``M * pool_size``) into two dimensions ``(M, pool_size)``, and takes maximum along the ``axis`` dimension. The output of this function is same as ``x`` except that ``axis`` dimension is transformed from ``M * pool_size`` to ``M``. Typically, ``x`` is the output of a linear layer or a convolution layer. The following is the example where we use :func:`maxout` in combination with a Linear link. >>> import numpy, chainer, chainer.links as L >>> in_size, out_size, pool_size = 100, 100, 100 >>> l = L.Linear(in_size, out_size * pool_size) >>> x = chainer.Variable(numpy.zeros((1, in_size), 'f')) # prepare data >>> x = l(x) >>> y = maxout(x, pool_size) Args: x (~chainer.Variable): Input variable. Its first dimension is assumed to be the *minibatch dimension*. The other dimensions are treated as one concatenated dimension. Returns: ~chainer.Variable: Output variable. .. seealso:: :class:`~chainer.links.Maxout` """ if pool_size <= 0: raise ValueError('pool_size must be a positive integer.') x_shape = x.data.shape if x_shape[axis] % pool_size != 0: expect = 'x.data.shape[axis] % pool_size == 0' actual = 'x.data.shape[axis]={}, pool_size={}'.format( x_shape[axis], pool_size) msg = 'axis dimension must be divided by pool_size' raise type_check.InvalidType(expect, actual, msg) shape = (x_shape[:axis] + (x_shape[axis] // pool_size, pool_size) + x_shape[axis + 1:]) x = reshape.reshape(x, shape) return minmax.max(x, axis=axis + 1)
def check_type_forward(self, in_types): n_in = in_types.size().eval() if n_in != 2 and n_in != 4: raise type_check.InvalidType( "%s or %s" % (in_types.size() == 2, in_types.size() == 4), "%s == %s" % (in_types.size(), n_in)) x_type, gamma_type = in_types[:2] type_check.expect( x_type.dtype == np.float32, x_type.ndim >= gamma_type.ndim + 1, gamma_type.dtype == np.float32, ) if len(in_types) == 4: mean_type, var_type = in_types[2:] type_check.expect( mean_type.dtype == np.float32, mean_type.shape == gamma_type.shape, var_type.dtype == np.float32, var_type.shape == gamma_type.shape, )
def check_type_forward(self, in_types): n_in = type_check.eval(in_types.size()) if n_in != 3 and n_in != 6: raise type_check.InvalidType( '{0} or {1}'.format(in_types.size() == 3, in_types.size() == 6), '{0} == {1}'.format(in_types.size(), n_in)) e1_type, e2_type, W_type = in_types[:3] type_check_prod = type_check.make_variable(numpy.prod, 'prod') type_check.expect( e1_type.dtype == numpy.float32, e1_type.ndim >= 2, e2_type.dtype == numpy.float32, e2_type.ndim >= 2, e1_type.shape[0] == e2_type.shape[0], W_type.dtype == numpy.float32, W_type.ndim == 3, type_check_prod(e1_type.shape[1:]) == W_type.shape[0], type_check_prod(e2_type.shape[1:]) == W_type.shape[1], ) if n_in == 6: out_size = W_type.shape[2] V1_type, V2_type, b_type = in_types[3:] type_check.expect( V1_type.dtype == numpy.float32, V1_type.ndim == 2, V1_type.shape[0] == W_type.shape[0], V1_type.shape[1] == out_size, V2_type.dtype == numpy.float32, V2_type.ndim == 2, V2_type.shape[0] == W_type.shape[1], V2_type.shape[1] == out_size, b_type.dtype == numpy.float32, b_type.ndim == 1, b_type.shape[0] == out_size, )
def maxout(x, pool_size, axis=1): """Maxout activation function. It accepts an input tensor ``x``, reshapes the ``axis`` dimension (say the size being ``M * pool_size``) into two dimensions ``(M, pool_size)``, and takes maximum along the ``axis`` dimension. Args: x (:class:`~chainer.Variable` or :ref:`ndarray`): Input variable. A :math:`n`-dimensional (:math:`n \\ge` ``axis``) float array. In general, its first dimension is assumed to be the *minibatch dimension*. The other dimensions are treated as one concatenated dimension. pool_size (int): The size used for downsampling of pooling layer. axis (int): The ``axis`` dimension to be reshaped. The size of ``axis`` dimension should be ``M * pool_size``. Returns: ~chainer.Variable: Output variable. The shape of the output is same as ``x`` except that ``axis`` dimension is transformed from ``M * pool_size`` to ``M``. .. seealso:: :class:`~chainer.links.Maxout` .. admonition:: Example Typically, ``x`` is the output of a linear layer or a convolution layer. The following is the example where we use :func:`maxout` in combination with a Linear link. >>> in_size, out_size, pool_size = 10, 10, 10 >>> bias = np.arange(out_size * pool_size).astype(np.float32) >>> l = L.Linear(in_size, out_size * pool_size, initial_bias=bias) >>> x = np.zeros((1, in_size), np.float32) # prepare data >>> x = l(x) >>> y = F.maxout(x, pool_size) >>> x.shape (1, 100) >>> y.shape (1, 10) >>> x.reshape((out_size, pool_size)).data array([[ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.], [10., 11., 12., 13., 14., 15., 16., 17., 18., 19.], [20., 21., 22., 23., 24., 25., 26., 27., 28., 29.], [30., 31., 32., 33., 34., 35., 36., 37., 38., 39.], [40., 41., 42., 43., 44., 45., 46., 47., 48., 49.], [50., 51., 52., 53., 54., 55., 56., 57., 58., 59.], [60., 61., 62., 63., 64., 65., 66., 67., 68., 69.], [70., 71., 72., 73., 74., 75., 76., 77., 78., 79.], [80., 81., 82., 83., 84., 85., 86., 87., 88., 89.], [90., 91., 92., 93., 94., 95., 96., 97., 98., 99.]], \ dtype=float32) >>> y.data array([[ 9., 19., 29., 39., 49., 59., 69., 79., 89., 99.]], \ dtype=float32) """ if pool_size <= 0: raise ValueError('pool_size must be a positive integer.') x_shape = x.shape if x_shape[axis] % pool_size != 0: expect = 'x.shape[axis] % pool_size == 0' actual = 'x.shape[axis]={}, pool_size={}'.format( x_shape[axis], pool_size) msg = 'axis dimension must be divided by pool_size' raise type_check.InvalidType(expect, actual, msg) shape = (x_shape[:axis] + (x_shape[axis] // pool_size, pool_size) + x_shape[axis + 1:]) x = reshape.reshape(x, shape) return minmax.max(x, axis=axis + 1)
def test_pickle(self): exc = T.InvalidType('foo', 'bar', 'baz') new = pickle.loads(pickle.dumps(exc)) self.assertEqual(exc.args, new.args) self.assertEqual(exc.expect, new.expect) self.assertEqual(exc.actual, new.actual)