Introduction_to_NLP

2021-12-14

mathjax: true

1. Bag-of-words模型

Bag-of-words模型假设对于一个文档，忽略它的单词顺序和语法、句法等要素，将其仅仅看作是若干个词汇的集合，文档中出现的每个单词都是独立的，不依赖其他单词是否出现。

假设文档为

1	sents = ["I love you","do you love yourself"]

可以构造一个词典

1	dict = {1:"I",2:"love",3:"you",4:"do",5:"yourself"}

这个词典包含了5个不同的单词，利用词典的索引号，上下两个文档的每一个都可以用一个5维的向量表示，每个index就是单词出现的次数。

1 2	sent1: [1,1,1,0,0] sent2: [0,1,1,1,1]

代码实现如下：

class BagOfWord:
    def __init__(self,do_lower_case=False):
        self.vocab = {}
        self.do_lower_case = do_lower_case

    def fit(self,sent_list):
        for sent in sent_list:
            if self.do_lower_case:
                sent = sent.lower()
            words = sent.strip().split(" ")
            for word in words:
                if word not in self.vocab:#不在词汇表中就加入
                    self.vocab[word] = len(self.vocab)#词->加入的序号

    def transform(self,sent_list):
        vocab_size = len(self.vocab)
        #创建序列长度*字典长度的全零nparray
        '''
        测试中传入的是一个列表长度为2的列表，
        字符种类数为5的
        所以构成的nparray是2*5的
        '''
        bag_of_word_feature = np.zeros((len(sent_list),vocab_size))
        for idx,sent in enumerate(sent_list):
            if self.do_lower_case:
                sent = sent.lower()
            words = sent.strip().split(" ")#切分为词
            for word in words:
                '''idx控制list的行号，表示是第几行，也就是第几句话
                self.vocab[word]控制的是某句话中的某个词，统计这句话中的这个词的个数
                
                因为并不是所有的话中都会出现所有的词，所有有的地方会是0
                '''
                bag_of_word_feature[idx][self.vocab[word]] += 1
        return bag_of_word_feature

    def fit_transform(self,sent_list):
        self.fit(sent_list)
        return self.transform(sent_list)

2. N-Gram语言模型

n-gram是一种统计语言模型，用来根据前(n-1)个item来预测第n个item。一般来讲，可以从大规模文本活音频语料来生成n-gram模型，习惯上，1-gram叫unigram，2-gram称为bigram，3-gram是trigram。还有four-gram、five-gram等，不过大于n>5的应用很少见。

给定一串字母，下一个最大可能出现的字母是什么？从训练语料数据中，可以通过极大似然的方法，得到N个概率分布，如：a的概率是0.4，b的概率是0.01，......所有的概率之和是1.

根据条件概率和乘法公式：\(P(B|A)= \frac{P(AB)}{P(A)}\),可以得到\(P(A_1 A_2...A_n)=P(A_1)P(A_2|A_1)P(A_3|A_1 A_2)...P(A_n|A_1 A_2...A_{n-1})\)

假设T是由词序列\(A_1,A_2,...,A_n\)组成的，那么\(P(T) = P(A_1 A_2...A_n)=P(A_1)P(A_2|A_1)P(A_3|A_1 A_2)...P(A_n|A_1 A_2...A_{n-1})\)

计算量非常大，需要引入马尔科夫链，即：当一个item出现概率，只与前面m个item有关，当m=1就是uni-gram，m=2就是bi-gram。所以当使用bi-gram模型时，\(P(T)=P(A_1)P(A_2|A_1)P(A_3|A_2)...P(A_n|a_{n-1})\),而\(P(A_n|A_{n-1})\)条件概率可以通过极大似然估计求得，等于\(\frac {Count(A_{n-1},A_n)}{Count(A_{n-1})}\)。

假设文档为

1	sents = ["I love you","do you love yourself"]

可以构造一个词典（使用1-gram特征和2-gram特征）

1	dict = {'I': 0, 'love': 1, 'you': 2, 'do': 3, 'yourself': 4, 'I_love': 5, 'love_you': 6, 'do_you': 7, 'you_love': 8, 'love_yourself': 9}

这个词典包含了10个不同的单词，利用词典的索引号，上下两个文档的每一个都可以用一个10维的向量表示，每个index就是单词出现的次数。

1 2	[[1. 1. 1. 0. 0. 1. 1. 0. 0. 0.] [0. 1. 1. 1. 1. 0. 0. 1. 1. 1.]]

代码实现：

class NGram:
    def __init__(self,ngram,do_lower_case=False):
        self.ngram = ngram
        self.feature_map = {}
        self.do_lower_case = do_lower_case

    def fit(self,sentList):
        for gram in self.ngram:
            for sent in sentList:
                if self.do_lower_case:
                    sent = sent.lower()
                sent = sent.split(" ")
                #这里使用的是1-gram和2-gram模型
                for i in range(len(sent) - gram + 1):
                    feature = "_".join(sent[i:i + gram])
                    if feature not in self.feature_map:
                        self.feature_map[feature] = len(self.feature_map)#feature-map是记录的出现的idx
    def transform(self,sentList):
        n = len(sentList)#句子的个数
        m = len(self.feature_map)#单词的个数，包含1-gram和2-gram
        ngram_feature = np.zeros((n,m))
        for idx,sent in enumerate(sentList):
            if(self.do_lower_case):
                sent = sent.lower()
            sent = sent.split(" ")
            for gram in self.ngram:
                for i in range(len(sent) - gram + 1):
                    feature = "_".join(sent[i:i + gram])
                    if feature in self.feature_map:
                        ngram_feature[idx][self.feature_map[feature]] = 1
        return ngram_feature
    def fit_transform(self,sentList):
        self.fit(sentList)
        return self.transform(sentList)