Did I find the right examples for you? yes no      Crawl my project      Python Jobs

All Samples(44)  |  Call(30)  |  Derive(0)  |  Import(14)

src/p/y/pylearn2-HEAD/pylearn2/sandbox/lisa_rl/bandit/gaussian_bandit.py   pylearn2(Download)
from pylearn2.sandbox.lisa_rl.bandit.environment import Environment
from pylearn2.utils import sharedX
from pylearn2.utils.rng import make_np_rng, make_theano_rng
 
 
    def __init__(self, num_arms, mean_std = 1.0, std_std = 1.0):
        self.rng = make_np_rng(None, [2013, 11, 12], which_method="randn")
        self.means = sharedX(self.rng.randn(num_arms) * mean_std)
        self.stds = sharedX(np.abs(self.rng.randn(num_arms) * std_std))
        self.theano_rng = make_theano_rng(None, self.rng.randint(2 ** 16), which_method="normal")

src/p/y/pylearn2-HEAD/pylearn2/models/dbm/layer.py   pylearn2(Download)
from pylearn2.utils import is_block_gradient
from pylearn2.utils import sharedX, safe_zip, py_integer_types, block_gradient
from pylearn2.utils.rng import make_theano_rng
"""
.. todo::
        p_state = sharedX(empty_output)
 
        theano_rng = make_theano_rng(None, numpy_rng.randint(2 ** 16), which_method="binomial")
 
        default_z = T.zeros_like(h_state) + self.b
        default_z = T.zeros_like(h_state) + self.b
 
        theano_rng = make_theano_rng(None, numpy_rng.randint(2 ** 16),
                                     which_method="binomial")
 
        """
        if noise:
            theano_rng = make_theano_rng(None, 2012+10+30, which_method="binomial")
            return T.nnet.softmax(theano_rng.normal(avg=0., size=Y.shape, std=1., dtype='float32'))
        rval =  T.nnet.softmax(self.b)
 
        if noise:
            theano_rng = make_theano_rng(None, 42, which_method="binomial")
            unmasked = theano_rng.normal(avg = 0.,
                    std = 1., size = masked_mu.shape,

src/p/y/pylearn2-HEAD/pylearn2/models/rbm.py   pylearn2(Download)
from pylearn2.space import VectorSpace
from pylearn2.utils import safe_union
from pylearn2.utils.rng import make_np_rng, make_theano_rng
theano.config.warn.sum_div_dimshuffle_bug = False
 
        rng = make_np_rng(rng, which_method="randn")
        seed = int(rng.randint(2 ** 30))
        self.s_rng = make_theano_rng(seed, which_method="binomial")
        self.particles = sharedX(particles, name='particles')
 
        """
        V = data
        theano_rng = make_theano_rng(None, 42, which_method="binomial")
 
        H = self.mean_h_given_v(V)

src/p/y/pylearn2-HEAD/pylearn2/models/dbm/ising.py   pylearn2(Download)
from pylearn2.space import VectorSpace
from pylearn2.utils import sharedX
from pylearn2.utils.rng import make_theano_rng
 
 
 
        if self.noisy_sampling_b is not None:
            theano_rng = make_theano_rng(None, self.dbm.rng.randint(2**16), which_method="normal")
 
            b = updates[self.boltzmann_bias]
 
            if self.noisy_sampling_b is not None:
                theano_rng = make_theano_rng(None, self.dbm.rng.randint(2**16), which_method="normal")
 
                b = self.boltzmann_bias
 
        if self.noisy_sampling_W is not None:
            theano_rng = make_theano_rng(None, self.dbm.rng.randint(2**16), which_method="normal")
 
            W = updates[self.W]
 
            if self.noisy_sampling_b is not None:
                theano_rng = make_theano_rng(None, self.dbm.rng.randint(2**16), which_method="normal")
 
                b = self.boltzmann_b

src/p/y/pylearn2-HEAD/pylearn2/expr/sampling.py   pylearn2(Download)
 
from pylearn2.blocks import Block
from pylearn2.utils.rng import make_theano_rng
 
 
    def __init__(self, theano_rng = None, seed=None, input_space=None):
        super(SampleBernoulli, self).__init__()
        assert theano_rng is None or seed is None
        theano_rng = make_theano_rng(theano_rng if theano_rng is not None else seed,
                                     2012+11+22, which_method='binomial')

src/p/y/pylearn2-HEAD/pylearn2/costs/dbm.py   pylearn2(Download)
from pylearn2.utils import safe_zip
from pylearn2.utils import sharedX
from pylearn2.utils.rng import make_theano_rng
 
 
    def __init__(self, num_chains, num_gibbs_steps, supervised=False,
                 toronto_neg=False, theano_rng=None):
        self.__dict__.update(locals())
        del self.self
        self.theano_rng = make_theano_rng(theano_rng, 2012+10+14,
            include_prob_Y = model.inference_procedure.include_prob_Y
 
            theano_rng = make_theano_rng(None, 2012+10+20,
                    which_method="binomial")
            for elem in flatten([model.inference_procedure.V_dropout]):
        self.called = True
        assert X.dtype == config.floatX
        theano_rng = make_theano_rng(getattr(self, 'seed', None), default_seed,
                                     which_method="binomial")
 

src/p/y/pylearn2-HEAD/pylearn2/sandbox/lisa_rl/bandit/classifier_agent.py   pylearn2(Download)
from pylearn2.sandbox.lisa_rl.bandit.agent import Agent
from pylearn2.utils import sharedX
from pylearn2.utils.rng import make_theano_rng
 
 
        y_hat = self.mlp.fprop(X)
 
        theano_rng = make_theano_rng(None, 2013+11+20, which_method="multinomial")
        if self.stochastic:
            a = theano_rng.multinomial(pvals=y_hat, dtype='float32')

src/p/y/pylearn2-HEAD/pylearn2/expr/stochastic_pool.py   pylearn2(Download)
from theano import tensor
from theano.gof.op import get_debug_values
from pylearn2.utils.rng import make_theano_rng
 
def stochastic_max_pool_bc01(bc01, pool_shape, pool_stride, image_shape, rng = None):
    channel = bc01.shape[1]
 
    rng = make_theano_rng(rng, 2022, which_method='multinomial')
 
    # Compute index in pooled space of last needed pool
    channel = bc01.shape[1]
 
    rng = make_theano_rng(rng, 2022, which_method='multinomial')
 
    # Compute index in pooled space of last needed pool

src/p/y/pylearn2-HEAD/pylearn2/models/dbm/__init__.py   pylearn2(Download)
from pylearn2.blocks import Block
from pylearn2.utils import block_gradient
from pylearn2.utils.rng import make_theano_rng
 
 
    def __init__(self, dbm):
        super(DBMSampler, self).__init__()
        self.theano_rng = make_theano_rng(None, 2012+10+14, which_method="binomial")
        self.dbm = dbm
        assert len(self.dbm.hidden_layers) == 1

src/p/y/pylearn2-HEAD/pylearn2/models/autoencoder.py   pylearn2(Download)
from pylearn2.utils import sharedX
from pylearn2.utils.theano_graph import is_pure_elemwise
from pylearn2.utils.rng import make_np_rng, make_theano_rng
from pylearn2.space import VectorSpace
 
 
        # why a theano rng? should we remove it?
        self.s_rng = make_theano_rng(seed, which_method="uniform")
 
        if tied_weights and self.weights is not None:

  1 | 2  Next