Python utils.shared_floatx_zeros方法代碼示例

# 需要導入模塊: from blocks import utils [as 別名]
# 或者: from blocks.utils import shared_floatx_zeros [as 別名]
def _allocate(self):
        self.W_state = shared_floatx_nans((self.dim, 4*self.dim),
                                          name='W_state')
        self.W_cell_to_in = shared_floatx_nans((self.dim,),
                                               name='W_cell_to_in')
        self.W_cell_to_forget = shared_floatx_nans((self.dim,),
                                                   name='W_cell_to_forget')
        self.W_cell_to_out = shared_floatx_nans((self.dim,),
                                                name='W_cell_to_out')
        # The underscore is required to prevent collision with
        # the `initial_state` application method
        self.initial_state_ = shared_floatx_zeros((self.dim,),
                                                  name="initial_state")
        self.initial_cells = shared_floatx_zeros((self.dim,),
                                                 name="initial_cells")
        add_role(self.W_state, WEIGHT)
        add_role(self.W_cell_to_in, WEIGHT)
        add_role(self.W_cell_to_forget, WEIGHT)
        add_role(self.W_cell_to_out, WEIGHT)
        add_role(self.initial_state_, INITIAL_STATE)
        add_role(self.initial_cells, INITIAL_STATE)

        self.parameters = [
            self.W_state, self.W_cell_to_in, self.W_cell_to_forget,
            self.W_cell_to_out, self.initial_state_, self.initial_cells] 

# 需要導入模塊: from blocks import utils [as 別名]
# 或者: from blocks.utils import shared_floatx_zeros [as 別名]
def initial_states(self, batch_size):
        initial_h1 = self.rnn1.initial_states(batch_size)
        initial_h2 = self.rnn2.initial_states(batch_size)
        initial_h3 = self.rnn3.initial_states(batch_size)

        last_h1 = shared_floatx_zeros((batch_size, self.rnn_h_dim))
        last_h2 = shared_floatx_zeros((batch_size, self.rnn_h_dim))
        last_h3 = shared_floatx_zeros((batch_size, self.rnn_h_dim))

        # Defining for all
        initial_k = tensor.zeros(
            (batch_size, self.attention_size), dtype=floatX)
        last_k = shared_floatx_zeros((batch_size, self.attention_size))

        # Trainable initial state for w. Why not for k?
        initial_w = tensor.repeat(self.initial_w[None, :], batch_size, 0)

        last_w = shared_floatx_zeros((batch_size, self.encoded_input_dim))

        return initial_h1, last_h1, initial_h2, last_h2, initial_h3, last_h3, \
            initial_w, last_w, initial_k, last_k 

# 需要導入模塊: from blocks import utils [as 別名]
# 或者: from blocks.utils import shared_floatx_zeros [as 別名]
def _allocate(self):
        """In addition to the GRU parameters ``state_to_state`` and 
        ``state_to_gates``, add the initial state if the search
        strategy is "constant".
        """
        self.parameters.append(shared_floatx_nans((self.dim, self.dim),
                               name='state_to_state'))
        self.parameters.append(shared_floatx_nans((self.dim, 2 * self.dim),
                               name='state_to_gates'))
        for i in range(2):
            if self.parameters[i]:
                add_role(self.parameters[i], WEIGHT)
        if self.init_strategy == 'constant':
            self.parameters.append(shared_floatx_zeros((self.dim,),
                                                       name="initial_state"))
            add_role(self.parameters[2], INITIAL_STATE) 

# 需要導入模塊: from blocks import utils [as 別名]
# 或者: from blocks.utils import shared_floatx_zeros [as 別名]
def _allocate(self):
        self.W_ss = shared_floatx_nans((self.dim, 4*self.dim), name='W_ss')
        self.W_is = shared_floatx_nans((self.dim,), name='W_is')
        # The underscore is required to prevent collision with
        # the `initial_state` application method
        self.initial_state_ = shared_floatx_zeros((self.dim,),
                                                  name="initial_state")
        add_role(self.W_ss, WEIGHT)
        add_role(self.W_is, WEIGHT)
        add_role(self.initial_state_, INITIAL_STATE)

        self.parameters = [
            self.W_ss, self.W_is, self.initial_state_] 

# 需要導入模塊: from blocks import utils [as 別名]
# 或者: from blocks.utils import shared_floatx_zeros [as 別名]
def _allocate(self):
        self.initial_w = shared_floatx_zeros(
            (self.encoded_input_dim,), name="initial_w")

        add_role(self.initial_w, INITIAL_STATE) 

# 需要導入模塊: from blocks import utils [as 別名]
# 或者: from blocks.utils import shared_floatx_zeros [as 別名]
def _allocate(self):
        self.params.append(shared_floatx_nans((self.dim, self.dim),
                           name='state_to_state'))
        self.params.append(shared_floatx_nans((self.dim, 2 * self.dim),
                           name='state_to_gates'))
        self.params.append(shared_floatx_zeros((self.dim,),
                           name="initial_state"))
        for i in range(2):
            if self.params[i]:
                add_role(self.params[i], WEIGHT)
        add_role(self.params[2], INITIAL_STATE) 

# 需要導入模塊: from blocks import utils [as 別名]
# 或者: from blocks.utils import shared_floatx_zeros [as 別名]
def _allocate(self):
        self.W_state = shared_floatx_nans((self.dim, 4.5 * self.dim),
                                          name='W_state')
        # The underscore is required to prevent collision with
        # the `initial_state` application method
        self.initial_state_ = shared_floatx_zeros((self.dim,),
                                                  name="initial_state")
        self.initial_cells = shared_floatx_zeros((self.num_copies, self.dim),
                                                 name="initial_cells")
        add_role(self.W_state, WEIGHT)
        # add_role(self.initial_state_, INITIAL_STATE)
        # add_role(self.initial_cells, INITIAL_STATE)

        self.parameters = [self.W_state] 

# 需要導入模塊: from blocks import utils [as 別名]
# 或者: from blocks.utils import shared_floatx_zeros [as 別名]
def _allocate(self):
        self.initial_w = shared_floatx_zeros(
            (self.num_letters,), name="initial_w")

        add_role(self.initial_w, INITIAL_STATE) 

# 需要導入模塊: from blocks import utils [as 別名]
# 或者: from blocks.utils import shared_floatx_zeros [as 別名]
def initial_states(self, batch_size):
        initial_h1 = self.cell1.initial_states(batch_size)
        initial_kappa = shared_floatx_zeros((batch_size, self.att_size))
        initial_w = tensor.repeat(self.initial_w[None, :], batch_size, 0)
        last_h1 = shared_floatx_zeros((batch_size, self.rec_h_dim))
        last_w = shared_floatx_zeros((batch_size, self.num_letters))
        use_last_states = shared(numpy.asarray(0., dtype=floatX))

        return initial_h1, initial_kappa, initial_w, \
            last_h1, last_w, use_last_states 

# 需要導入模塊: from blocks import utils [as 別名]
# 或者: from blocks.utils import shared_floatx_zeros [as 別名]
def compile(self):
        """Do not add any more tasks after this function is called.
        Compiles the state update and logprobs theano functions for
        this bucket.
        """
        self.n_tasks = len(self.tasks)
        self.n_finished = 0
        self.all_attended = shared_floatx_zeros((1, 1, 1))
        self.all_masks = shared_floatx_zeros((1, 1))
        self.src_indices = T.ivector()
        givens = self._construct_givens()
        self._compile_next_state_computer(givens)
        self._compile_logprobs_computer(givens) 

# 需要導入模塊: from blocks import utils [as 別名]
# 或者: from blocks.utils import shared_floatx_zeros [as 別名]
def _push_allocation_config(self):
        """Sets the dimensions of rnn inputs. """
        self.rnn_inputs = {name: shared_floatx_zeros(
                                            self.transition.get_dim(name))
                              for name in self.transition.apply.sequences 
                              if name != 'mask'}