(self, input_energy, mask=None, go_backwards=False, return_sequences=True, return_logZ=True, input_length=None)
Forward (alpha) or backward (beta) recursion

        If `return_logZ = True`, compute the logZ, the normalization constance:

        \[ Z = \sum_{y1, y2, y3} exp(-E) # energy
          = \sum_{y1, y2, y3} exp(-(u1' y1 + y1' W y2 + u2' y2 + y2' W y3 + u3' y3))
          = sum_{y2, y3} (exp(-(u2' y2 + y2' W y3 + u3' y3)) sum_{y1} exp(-(u1' y1' + y1' W y2))) \]

        Denote:
            \[ S(y2) := sum_{y1} exp(-(u1' y1 + y1' W y2)), \]
            \[ Z = sum_{y2, y3} exp(log S(y2) - (u2' y2 + y2' W y3 + u3' y3)) \]
            \[ logS(y2) = log S(y2) = log_sum_exp(-(u1' y1' + y1' W y2)) \]
        Note that:
              yi's are one-hot vectors
              u1, u3: boundary energies have been merged

        If `return_logZ = False`, compute the Viterbi's best path lookup table.
Forward (alpha) or backward (beta) recursion
Forward ( alpha ) or backward ( beta ) recursion
def recursion(self, input_energy, mask=None, go_backwards=False, return_sequences=True, return_logZ=True, input_length=None):
        """Forward (alpha) or backward (beta) recursion

        If `return_logZ = True`, compute the logZ, the normalization constance:

        \[ Z = \sum_{y1, y2, y3} exp(-E) # energy
          = \sum_{y1, y2, y3} exp(-(u1' y1 + y1' W y2 + u2' y2 + y2' W y3 + u3' y3))
          = sum_{y2, y3} (exp(-(u2' y2 + y2' W y3 + u3' y3)) sum_{y1} exp(-(u1' y1' + y1' W y2))) \]

        Denote:
            \[ S(y2) := sum_{y1} exp(-(u1' y1 + y1' W y2)), \]
            \[ Z = sum_{y2, y3} exp(log S(y2) - (u2' y2 + y2' W y3 + u3' y3)) \]
            \[ logS(y2) = log S(y2) = log_sum_exp(-(u1' y1' + y1' W y2)) \]
        Note that:
              yi's are one-hot vectors
              u1, u3: boundary energies have been merged

        If `return_logZ = False`, compute the Viterbi's best path lookup table.
        """
        chain_energy = self.chain_kernel
        chain_energy = K.expand_dims(chain_energy, 0)  # shape=(1, F, F): F=num of output features. 1st F is for t-1, 2nd F for t
        prev_target_val = K.zeros_like(input_energy[:, 0, :])  # shape=(B, F), dtype=float32

        if go_backwards:
            input_energy = K.reverse(input_energy, 1)
            if mask is not None:
                mask = K.reverse(mask, 1)

        initial_states = [prev_target_val, K.zeros_like(prev_target_val[:, :1])]
        constants = [chain_energy]

        if mask is not None:
            mask2 = K.cast(K.concatenate([mask, K.zeros_like(mask[:, :1])], axis=1), K.floatx())
            constants.append(mask2)

        def _step(input_energy_i, states):
            return self.step(input_energy_i, states, return_logZ)

        target_val_last, target_val_seq, _ = K.rnn(_step, input_energy, initial_states, constants=constants,
                                                   input_length=input_length, unroll=self.unroll)

        if return_sequences:
            if go_backwards:
                target_val_seq = K.reverse(target_val_seq, 1)
            return target_val_seq
        else:
            return target_val_last
def recursion ( self , input_energy , mask = None , go_backwards = False , return_sequences = True , return_logZ = True , input_length = None ) : chain_energy = self . chain_kernel chain_energy = K . expand_dims ( chain_energy , 0 ) # shape=(1, F, F): F=num of output features. 1st F is for t-1, 2nd F for t prev_target_val = K . zeros_like ( input_energy [ : , 0 , : ] ) # shape=(B, F), dtype=float32 if go_backwards : input_energy = K . reverse ( input_energy , 1 ) if mask is not None : mask = K . reverse ( mask , 1 ) initial_states = [ prev_target_val , K . zeros_like ( prev_target_val [ : , : 1 ] ) ] constants = [ chain_energy ] if mask is not None : mask2 = K . cast ( K . concatenate ( [ mask , K . zeros_like ( mask [ : , : 1 ] ) ] , axis = 1 ) , K . floatx ( ) ) constants . append ( mask2 ) def _step ( input_energy_i , states ) : return self . step ( input_energy_i , states , return_logZ ) target_val_last , target_val_seq , _ = K . rnn ( _step , input_energy , initial_states , constants = constants , input_length = input_length , unroll = self . unroll ) if return_sequences : if go_backwards : target_val_seq = K . reverse ( target_val_seq , 1 ) return target_val_seq else : return target_val_last