Python theano.tensor 模块，as_tensor_variable() 实例源码

我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用theano.tensor.as_tensor_variable()。

项目：epfl-semester-project-biaxialnn 作者：onanypoint | 项目源码 | 文件源码

def make_node(self, state, time):
        """Creates an Apply node representing the application of the op on 
        the inputs provided.

        Parameters
        ----------
        state : array_like
            The state to transform into feature space
        time : int
            The current time being processed

        Returns
        -------
        theano.Apply
            [description]
        """
        state = T.as_tensor_variable(state)
        time = T.as_tensor_variable(time)
        return theano.Apply(self, [state, time], [T.bmatrix()])

项目：pl-cnn 作者：oval-group | 项目源码 | 文件源码

def compile_maxpool(output_shape, pool_size):

    X = T.tensor4()

    # compute output with both methods
    out1 = T.signal.pool.pool_2d(X, pool_size,
                                 ignore_border=True, st=None,
                                 padding=(0, 0), mode='max')

    out2 = my_pool_2d(X, pool_size,
                      ignore_border=True, st=None,
                      padding=(0, 0), mode='max')

    # compute gradient with random incoming gradient for both cases
    incoming_grad = T.as_tensor_variable(np.random.random(size=output_shape)
                                         .astype(np.float32))
    grad1 = T.grad(None, wrt=X, known_grads={out1: incoming_grad})
    grad2 = T.grad(None, wrt=X, known_grads={out2: incoming_grad})

    return theano.function([X], [out1, out2, grad1, grad2])

项目：lddmm-ot 作者：jeanfeydy | 项目源码 | 文件源码

def _HamiltonianShootingCarrying(self, q, p, i0) :
        """
        Given initial control points/momentums q0 and p0 given as n-by-d matrices,
        and a "template" image i0, outputs the trajectories q_t, p_t, I_t = I0 \circ phi_{t->0}.
        """
        # Here, we use the "scan" theano routine, which  can be understood as a "for" loop
        identity = T.as_tensor_variable(0. * self.dense_grid())  # We encode the identity as a null displacement field.

        # Here, we use the "scan" theano routine, which  can be understood as a "for" loop
        result, updates = theano.scan(fn            = lambda x,y,z : self._hamiltonian_step_carrying2(x,y,z),
                                      outputs_info  = [q,p, identity],
                                      n_steps       = int(np.round(1/self.dt) ))

        phi_inv_1 = result[2][-1]  # We do not store the intermediate results
        I1 = self._image_circ_diffeo(i0, self.dense_grid() + phi_inv_1)  # instead of interpolating the images It at all timesteps, we only do it in the end.
        return [result[0][-1], result[1][-1], I1]                       # and only return the final state + momentum + image

项目：DeepMonster 作者：olimastro | 项目源码 | 文件源码

def __init__(self, ratio=2, kernlen=5, **kwargs):
        # I imagine the idea could be aplied to a bigger ratio
        assert ratio == 2
        # the kernel is stripped from opencv, need a function that output such a sharp gauss kern
        assert kernlen == 5
        self.ratio = ratio
        #kernel = T.as_tensor_variable(gkern(kernlen))
        #self.kernel = kernel.dimshuffle('x','x',0,1)
        kernel = np.asarray([[1,4,6,4,1],
                             [4,16,26,16,4],
                             [6,26,64,26,6],
                             [1,4,6,4,1],
                             [4,16,26,16,4]])
        kernel = kernel[None,None,:,:] / 64.
        self.kernel = T.as_tensor_variable(kernel.astype(np.float32))
        super(GaussianKernelUpsampling, self).__init__(**kwargs)

项目：Attentive_reader 作者：caglar | 项目源码 | 文件源码

def shared_like(variable, name=None):
    """Construct a shared variable to hold the value of a tensor variable.

    Parameters
    ----------
    variable : :class:`~tensor.TensorVariable`
        The variable whose dtype and ndim will be used to construct
        the new shared variable.
    name : :obj:`str` or :obj:`None`
        The name of the shared variable. If None, the name is determined
        based on variable's name.

    """
    variable = tensor.as_tensor_variable(variable)
    if name is None:
        name = "shared_{}".format(variable.name)
    return theano.shared(numpy.zeros((0,) * variable.ndim,
                                     dtype=variable.dtype),
                         name=name)