def _compute_emissions(self, corpus, order=1):
        """ Computes the emissions and transitions probabilities of a corpus
            based on word types
        Args:
            corpus: the given corpus (a corpus_entry needs to be iterable)
            order: the maximal Markov chain order
        Computes:
            self.emissions: Probabilities to emit word (token_value) at state x (token_type)
            self.transitions_hmm: Transition probabilities to switch between states (token_type)
            self.emissions_past: Probabilities to emit a word (token_value) at state x
                                 (token_type) based on previous emissions (token_value)
        """
        self.emissions = defaultdict(lambda: defaultdict(int))
        self.transitions_hmm = defaultdict(lambda: defaultdict(int))
        self.emissions_past = defaultdict(
            lambda: defaultdict(lambda: defaultdict(int)))

        for corpus_entry in corpus:
            tokens = self.pos_tag(corpus_entry)

            last_tokens = utils.prefilled_buffer(
                self._start_symbol, length=self.order)
            last_emissions = utils.prefilled_buffer(
                self._start_symbol, length=self.order_emissions)

            for token in chain(tokens, [[self._end_symbol] * 2]):
                token_value = token[0]
                token_type = token[1]

                for suffix in utils.get_suffixes(last_tokens):
                    self.transitions_hmm[suffix][token_type] += 1
                    self.emissions[token_type][token_value] += 1

                for suffix in utils.get_suffixes(last_emissions):
                    self.emissions_past[token_type][
                        suffix][token_value] += 1

                last_tokens.append(token_type)
                last_emissions.append(token_value)

        self._compute_relative_probs(self.emissions)
        self._compute_relative_probs(self.transitions_hmm)
        for val in self.emissions_past.values():
            self._compute_relative_probs(val)