def _build_prior(self, name, Xs, jitter, **kwargs): self.N = int(np.prod([len(X) for X in Xs])) mu = self.mean_func(cartesian(*Xs)) chols = [cholesky(stabilize(cov(X), jitter)) for cov, X in zip(self.cov_funcs, Xs)] v = pm.Normal(name + "_rotated_", mu=0.0, sigma=1.0, size=self.N, **kwargs) f = pm.Deterministic(name, mu + at.flatten(kron_dot(chols, v))) return f
def max_pool(images, imgshp, maxpoolshp): """Implements a max pooling layer Takes as input a 2D tensor of shape batch_size x img_size and performs max pooling. Max pooling downsamples by taking the max value in a given area, here defined by maxpoolshp. Outputs a 2D tensor of shape batch_size x output_size. :param images: 2D tensor containing images on which to apply convolution. Assumed to be of shape batch_size x img_size :param imgshp: tuple containing image dimensions :param maxpoolshp: tuple containing shape of area to max pool over :return: out1, symbolic result (2D tensor) :return: out2, logical shape of the output """ poolsize = np.int64(np.prod(maxpoolshp)) # imgshp contains either 2 entries (height,width) or 3 (nfeatures,h,w) # in the first case, default nfeatures to 1 if np.size(imgshp) == 2: imgshp = (1, ) + imgshp # construct indices and index pointers for sparse matrix, which, # when multiplied with input images will generate a stack of image # patches indices, indptr, spmat_shape, sptype, outshp = convolution_indices.conv_eval( imgshp, maxpoolshp, maxpoolshp, mode="valid") # print 'XXXXXXXXXXXXXXXX MAX POOLING LAYER XXXXXXXXXXXXXXXXXXXX' # print 'imgshp = ', imgshp # print 'maxpoolshp = ', maxpoolshp # print 'outshp = ', outshp # build sparse matrix, then generate stack of image patches csc = aesara.sparse.CSM(sptype)(np.ones(indices.size), indices, indptr, spmat_shape) patches = sparse.structured_dot(csc, images.T).T pshape = aet.stack([ images.shape[0] * aet.as_tensor(np.prod(outshp)), aet.as_tensor(imgshp[0]), aet.as_tensor(poolsize), ]) patch_stack = reshape(patches, pshape, ndim=3) out1 = tt_max(patch_stack, axis=2) pshape = aet.stack([ images.shape[0], aet.as_tensor(np.prod(outshp)), aet.as_tensor(imgshp[0]), ]) out2 = reshape(out1, pshape, ndim=3) out3 = DimShuffle(out2.broadcastable, (0, 2, 1))(out2) return aet.flatten(out3, 2), outshp
def jacobian1(f, v): """jacobian of f wrt v""" f = at.flatten(f) idx = at.arange(f.shape[0], dtype="int32") def grad_i(i): return gradient1(f[i], v) return aesara.map(grad_i, idx)[0]
def _build_prior(self, name, Xs, **kwargs): self.N = np.prod([len(X) for X in Xs]) mu = self.mean_func(cartesian(*Xs)) chols = [ cholesky(stabilize(cov(X))) for cov, X in zip(self.cov_funcs, Xs) ] # remove reparameterization option v = pm.Normal(name + "_rotated_", mu=0.0, sigma=1.0, shape=self.N, **kwargs) f = pm.Deterministic(name, mu + at.flatten(kron_dot(chols, v))) return f
def test_log1msigm_to_softplus(self): x = matrix() out = log(1 - sigmoid(x)) f = aesara.function([x], out, mode=self.m) topo = f.maker.fgraph.toposort() assert len(topo) == 2 assert isinstance(topo[0].op.scalar_op, ScalarSoftplus) assert isinstance(topo[1].op.scalar_op, aesara.scalar.Neg) # assert check_stack_trace(f, ops_to_check='all') f(np.random.rand(54, 11).astype(config.floatX)) # Same test with a flatten out = log(1 - aet.flatten(sigmoid(x))) f = aesara.function([x], out, mode=self.m) # assert check_stack_trace(f, ops_to_check='all') topo = f.maker.fgraph.toposort() assert len(topo) == 3 assert aet.is_flat(topo[0].outputs[0]) assert isinstance(topo[1].op.scalar_op, ScalarSoftplus) assert isinstance(topo[2].op.scalar_op, aesara.scalar.Neg) f(np.random.rand(54, 11).astype(config.floatX)) # Same test with a reshape out = log(1 - sigmoid(x).reshape([x.size])) f = aesara.function([x], out, mode=self.m) topo = f.maker.fgraph.toposort() # assert len(topo) == 3 assert any(isinstance(node.op, Reshape) for node in topo) assert any( isinstance( getattr(node.op, "scalar_op", None), ScalarSoftplus, ) for node in topo) f(np.random.rand(54, 11).astype(config.floatX))
def gradient1(f, v): """flat gradient of f wrt v""" return at.flatten(grad(f, v, disconnected_inputs="warn"))
def conv2d( input, filters, image_shape=None, filter_shape=None, border_mode="valid", subsample=(1, 1), **kargs, ): """ signal.conv.conv2d performs a basic 2D convolution of the input with the given filters. The input parameter can be a single 2D image or a 3D tensor, containing a set of images. Similarly, filters can be a single 2D filter or a 3D tensor, corresponding to a set of 2D filters. Shape parameters are optional and will result in faster execution. Parameters ---------- input : Symbolic aesara tensor for images to be filtered. Dimensions: ([num_images], image height, image width) filters : Symbolic aesara tensor for convolution filter(s). Dimensions: ([num_filters], filter height, filter width) border_mode: {'valid', 'full'} See scipy.signal.convolve2d. subsample Factor by which to subsample output. image_shape : tuple of length 2 or 3 ([num_images,] image height, image width). filter_shape : tuple of length 2 or 3 ([num_filters,] filter height, filter width). kwargs See aesara.tensor.nnet.conv.conv2d. Returns ------- symbolic 2D,3D or 4D tensor Tensor of filtered images, with shape ([number images,] [number filters,] image height, image width). """ assert input.ndim in (2, 3) assert filters.ndim in (2, 3) # use shape information if it is given to us ### if filter_shape and image_shape: if input.ndim == 3: bsize = image_shape[0] else: bsize = 1 imshp = (1, ) + tuple(image_shape[-2:]) if filters.ndim == 3: nkern = filter_shape[0] else: nkern = 1 kshp = filter_shape[-2:] else: nkern, kshp = None, None bsize, imshp = None, None # reshape tensors to 4D, for compatibility with ConvOp ### if input.ndim == 3: sym_bsize = input.shape[0] else: sym_bsize = 1 if filters.ndim == 3: sym_nkern = filters.shape[0] else: sym_nkern = 1 new_input_shape = aet.join(0, aet.stack([sym_bsize, 1]), input.shape[-2:]) input4D = reshape(input, new_input_shape, ndim=4) new_filter_shape = aet.join(0, aet.stack([sym_nkern, 1]), filters.shape[-2:]) filters4D = reshape(filters, new_filter_shape, ndim=4) # perform actual convolution ### op = conv.ConvOp( output_mode=border_mode, dx=subsample[0], dy=subsample[1], imshp=imshp, kshp=kshp, nkern=nkern, bsize=bsize, **kargs, ) output = op(input4D, filters4D) # flatten to 3D tensor if convolving with single filter or single image if input.ndim == 2 and filters.ndim == 2: if config.warn__signal_conv2d_interface: warnings.warn( "aesara.tensor.signal.conv2d() now outputs a 2d tensor when both" " inputs are 2d. To disable this warning, set the Aesara flag" " warn__signal_conv2d_interface to False", stacklevel=3, ) output = aet.flatten(output.T, ndim=2).T elif input.ndim == 2 or filters.ndim == 2: output = aet.flatten(output.T, ndim=3).T return output
def convolve( kerns, kshp, nkern, images, imgshp, step=(1, 1), bias=None, mode="valid", flatten=True, ): """Convolution implementation by sparse matrix multiplication. :note: For best speed, put the matrix which you expect to be smaller as the 'kernel' argument "images" is assumed to be a matrix of shape batch_size x img_size, where the second dimension represents each image in raster order If flatten is "False", the output feature map will have shape: .. code-block:: python batch_size x number of kernels x output_size If flatten is "True", the output feature map will have shape: .. code-block:: python batch_size x number of kernels * output_size .. note:: IMPORTANT: note that this means that each feature map (image generate by each kernel) is contiguous in memory. The memory layout will therefore be: [ <feature_map_0> <feature_map_1> ... <feature_map_n>], where <feature_map> represents a "feature map" in raster order kerns is a 2D tensor of shape nkern x N.prod(kshp) :param kerns: 2D tensor containing kernels which are applied at every pixel :param kshp: tuple containing actual dimensions of kernel (not symbolic) :param nkern: number of kernels/filters to apply. nkern=1 will apply one common filter to all input pixels :param images: tensor containing images on which to apply convolution :param imgshp: tuple containing image dimensions :param step: determines number of pixels between adjacent receptive fields (tuple containing dx,dy values) :param mode: 'full', 'valid' see CSM.evaluate function for details :param sumdims: dimensions over which to sum for the tensordot operation. By default ((2,),(1,)) assumes kerns is a nkern x kernsize matrix and images is a batchsize x imgsize matrix containing flattened images in raster order :param flatten: flatten the last 2 dimensions of the output. By default, instead of generating a batchsize x outsize x nkern tensor, will flatten to batchsize x outsize*nkern :return: out1, symbolic result :return: out2, logical shape of the output img (nkern,heigt,width) :TODO: test for 1D and think of how to do n-d convolutions """ # start by computing output dimensions, size, etc kern_size = np.int64(np.prod(kshp)) # inshp contains either 2 entries (height,width) or 3 (nfeatures,h,w) # in the first case, default nfeatures to 1 if np.size(imgshp) == 2: imgshp = (1, ) + imgshp # construct indices and index pointers for sparse matrix, which, # when multiplied with input images will generate a stack of image # patches indices, indptr, spmat_shape, sptype, outshp = convolution_indices.conv_eval( imgshp, kshp, step, mode) # build sparse matrix, then generate stack of image patches csc = aesara.sparse.CSM(sptype)(np.ones(indices.size), indices, indptr, spmat_shape) patches = (sparse.structured_dot(csc, images.T)).T # compute output of linear classifier pshape = aet.stack([ images.shape[0] * aet.as_tensor(np.prod(outshp)), aet.as_tensor(imgshp[0] * kern_size), ]) patch_stack = reshape(patches, pshape, ndim=2) # kern is of shape: nkern x ksize*number_of_input_features # output is thus of shape: bsize*outshp x nkern output = dot(patch_stack, kerns.T) # add bias across each feature map (more efficient to do it now) if bias is not None: output += bias # now to have feature maps in raster order ... # go from bsize*outshp x nkern to bsize x nkern*outshp newshp = aet.stack([ images.shape[0], aet.as_tensor(np.prod(outshp)), aet.as_tensor(nkern) ]) tensout = reshape(output, newshp, ndim=3) output = DimShuffle((False, ) * tensout.ndim, (0, 2, 1))(tensout) if flatten: output = aet.flatten(output, 2) return output, np.hstack((nkern, outshp))
def diag(self, X): X, _ = self._slice(X, None) cov_diag = self.cov_func(X, diag=True) scf_diag = at.square(at.flatten(self.scaling_func(X, self.args))) return cov_diag * scf_diag