(self, sents, filtering=True, remove_weak_pairs=True)
基本的新词识别算法

        在train的基础上，计算互信息，通过互信息找出强相关的邻字，然后
        通过这些邻字实现粗糙的分词，从粗糙的分词结果中筛选出可能的词语。

        【参数含义】
        filtering：是否过滤无关字符，只保留中文、数字和英文字母；
        remove_weak_pairs：是否在self.pairs中去掉低频项，以减少低频项的
                          的内存占用，这个参数只影响增量更新。
基本的新词识别算法
基本的新词识别算法
def find(self, sents, filtering=True, remove_weak_pairs=True):
        """基本的新词识别算法

        在train的基础上，计算互信息，通过互信息找出强相关的邻字，然后
        通过这些邻字实现粗糙的分词，从粗糙的分词结果中筛选出可能的词语。

        【参数含义】
        filtering：是否过滤无关字符，只保留中文、数字和英文字母；
        remove_weak_pairs：是否在self.pairs中去掉低频项，以减少低频项的
                          的内存占用，这个参数只影响增量更新。
        """
        log_min_proba = log(self.min_proba)
        log_total_chars = log(sum(self.chars.values()))
        log_total_pairs = log(sum(self.pairs.values()))
        chars = {i: log(j) - log_total_chars for i, j in self.chars.items()}
        pairs = {i: log(j) - log_total_pairs for i, j in self.pairs.items()}
        pairs = {i: j for i, j in pairs.items() if j > log_min_proba}

        if remove_weak_pairs:
            self.pairs = {i: j for i, j in self.pairs if i in pairs}

        pairs = {
            i: j
            for i, j in pairs.items()
            if j - chars[i[0]] - chars[i[1]] > self.min_pmi
        }

        logger = logging.getLogger(u'词库构建')
        for n, sent in enumerate(self.texts(sents, filtering)):
            if n % 10000 == 0 and n > 0:
                logger.info(u'已处理了 %s 个句子' % n)
            for s in sent:
                if s:
                    w = s[0]
                    for i, c in enumerate(s[1:]):
                        if s[i:i + 2] in pairs:
                            w += s[i + 1]
                        else:
                            self.words[w] += 1
                            w = s[i + 1]
                    self.words[w] += 1

        logger.info(u'共处理了 %s 个句子' % (n + 1))
        log_total_words = log(sum(self.words.values()))
        self.words = {
            i: j
            for i, j in self.words.items()
            if log(j) - log_total_words > log_min_proba
        }

        tokenizer = self.export_tokenizer()
        total = len(self.words)
        logger = logging.getLogger(u'词语去冗')

        for n, w in enumerate(sorted(self.words, key=lambda x: -len(x))):
            if n % 100000 == 0 and n > 0:
                logger.info(u'已处理了 %s/%s 个词语' % (n, total))
            if len(w) == 1:
                continue
            num = tokenizer.words[w]
            pmi = tokenizer.words.get_proba(w)
            del tokenizer.words[w]
            w_subwords = tokenizer.tokenize(w)
            for k in w_subwords:
                pmi -= tokenizer.words.get_proba(k)
            if pmi < len(w) - 1:
                for k in w_subwords:
                    tokenizer.words[k] += num
                    self.words[k] += num
                del self.words[w]
            else:
                tokenizer.words[w] = num
def find ( self , sents , filtering = True , remove_weak_pairs = True ) : log_min_proba = log ( self . min_proba ) log_total_chars = log ( sum ( self . chars . values ( ) ) ) log_total_pairs = log ( sum ( self . pairs . values ( ) ) ) chars = { i : log ( j ) - log_total_chars for i , j in self . chars . items ( ) } pairs = { i : log ( j ) - log_total_pairs for i , j in self . pairs . items ( ) } pairs = { i : j for i , j in pairs . items ( ) if j > log_min_proba } if remove_weak_pairs : self . pairs = { i : j for i , j in self . pairs if i in pairs } pairs = { i : j for i , j in pairs . items ( ) if j - chars [ i [ 0 ] ] - chars [ i [ 1 ] ] > self . min_pmi } logger = logging . getLogger ( u'词库构建') for n , sent in enumerate ( self . texts ( sents , filtering ) ) : if n % 10000 == 0 and n > 0 : logger . info ( u'已处理了 %s 个句子' % n) for s in sent : if s : w = s [ 0 ] for i , c in enumerate ( s [ 1 : ] ) : if s [ i : i + 2 ] in pairs : w += s [ i + 1 ] else : self . words [ w ] += 1 w = s [ i + 1 ] self . words [ w ] += 1 logger . info ( u'共处理了 %s 个句子' % (n + 1)) log_total_words = log ( sum ( self . words . values ( ) ) ) self . words = { i : j for i , j in self . words . items ( ) if log ( j ) - log_total_words > log_min_proba } tokenizer = self . export_tokenizer ( ) total = len ( self . words ) logger = logging . getLogger ( u'词语去冗') for n , w in enumerate ( sorted ( self . words , key = lambda x : - len ( x ) ) ) : if n % 100000 == 0 and n > 0 : logger . info ( u'已处理了 %s/%s 个词语' % (n, total)) if len ( w ) == 1 : continue num = tokenizer . words [ w ] pmi = tokenizer . words . get_proba ( w ) del tokenizer . words [ w ] w_subwords = tokenizer . tokenize ( w ) for k in w_subwords : pmi -= tokenizer . words . get_proba ( k ) if pmi < len ( w ) - 1 : for k in w_subwords : tokenizer . words [ k ] += num self . words [ k ] += num del self . words [ w ] else : tokenizer . words [ w ] = num