情感分析snownlp包部分核心代碼理解

 

snownlps是用Python寫的個中文情感分析的包，自帶了中文正負情感的訓練集，主要是評論的語料庫。使用的是朴素貝葉斯原理來訓練和預測數據。主要看了一下這個包的幾個主要的核心代碼，看的過程作了一些注釋，記錄一下免得以后再忘了。

1. sentiment文件夾下的__init__.py，主要是集成了前面寫的幾個模塊的功能，進行打包。

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

import os
import codecs

from .. import normal
from .. import seg
from ..classification.bayes import Bayes

data_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                         'sentiment.marshal')


class Sentiment(object):

    def __init__(self):# 實例化Bayes()類作為屬性，下面的很多方法都是調用的Bayes()的方法完成的
        self.classifier = Bayes()

    def save(self, fname, iszip=True):# 保存最終的模型
        self.classifier.save(fname, iszip)

    def load(self, fname=data_path, iszip=True):
        self.classifier.load(fname, iszip)# 加載貝葉斯模型

    # 分詞以及去停用詞的操作
    def handle(self, doc):
        words = seg.seg(doc)# 分詞
        words = normal.filter_stop(words)# 去停用詞
        return words# 返回分詞后的結果，是一個list列表

    def train(self, neg_docs, pos_docs):
        data = []
        for sent in neg_docs:# 讀入負樣本
            data.append([self.handle(sent), 'neg'])
            # 所以可以看出進入bayes（）的訓練的數據data格式是[[[第一行分詞],類別],
            #                                             [[第二行分詞], 類別]，
            #                                             [[第n行分詞],類別]
            #                                                              ]
        for sent in pos_docs: # 讀入正樣本
            data.append([self.handle(sent), 'pos'])
        self.classifier.train(data)  # 調用的是Bayes模型的訓練方法train()

    def classify(self, sent):
        ret, prob = self.classifier.classify(self.handle(sent))#得到分類結果和概率
        if ret == 'pos':#默認返回的是pos('正面'），否則就是負面
            return prob
        return 1-prob


classifier = Sentiment()#實例化Sentiment()對象
classifier.load()


def train(neg_file, pos_file):
    #讀取正負語料庫文本
    neg_docs = codecs.open(neg_file, 'r', 'utf-8').readlines()
    pos_docs = codecs.open(pos_file, 'r', 'utf-8').readlines()
    global classifier#聲明classifier為全局變量，下面重新賦值，雖然值仍然是Sentiment()函數
    classifier = Sentiment()
    classifier.train(neg_docs, pos_docs)#調用Sentment()模塊里的train（）方法


def save(fname, iszip=True):
    classifier.save(fname, iszip)


def load(fname, iszip=True):
    classifier.load(fname, iszip)


def classify(sent):
    return classifier.classify(sent)

2.使用的朴素貝葉斯原理及公式變形

推薦一篇解釋得很好的文章：情感分析——深入snownlp原理和實踐

 

classification文件夾下的Bayes.py模塊主要包含兩個方法train（data）和classify（X），訓練和預測方法

    # 訓練數據集
    # 訓練的數據data格式是[[['分詞1','分詞2','分詞x'],類別],
    #                     [[第二行分詞], 類別],
    #                     [[第n行分詞],類別]
    #                                      ]
    def train(self, data):#訓練后得到的self.d={'neg':AddOneProb,'pos':AddOneProb},AddOneProb包含重要的分詞信息，他里面也有一個self.d={'分詞1':v1,'分詞2':v2,'分詞3':v3,...}包含分詞和相應的分詞個數。

        # 遍歷數據集
        for d in data:
            # d[1]標簽-->分類類別
            c = d[1]
            # 判斷數據字典中是否有當前的標簽
            if c not in self.d:
                # 如果沒有該標簽，加入標簽，值是一個AddOneProb對象。其實就是為每個分詞建一個AddOnePro對象來計數
                self.d[c] = AddOneProb()
            # d[0]是評論的分詞list，遍歷分詞list
            for word in d[0]:
                # 調用AddOneProb中的add方法，添加單詞
                self.d[c].add(word, 1)#self.d[c]是AddOneProb對象，調用AddOneProb的add（）函數來對詞word計數，重點看frequency.py中的幾個類
        # 計算總詞數
        self.total = sum(map(lambda x: self.d[x].getsum(), self.d.keys()))#self.d[x].getsum()是調用AddOneProb對象的getsum()函數計算詞

    #對句子x分類,而x是被分過詞的列表,(將句子分詞的步驟會在Sentiment類中的分類函數classify()執行，這里不要管，只要知道x是分詞后的的列表）
    def classify(self, x):
        tmp = {}
        # 遍歷每個分類標簽，本案例中只有兩個類別
        for k in self.d:
            tmp[k] = log(self.d[k].getsum()) - log(self.total)#計算先驗概率，即p(neg)和p(pos)兩個類別的概率
            for word in x:
                tmp[k] += log(self.d[k].freq(word))#計算后驗概率，即每個類別條件下某個分詞的概率p('詞A'|neg)和p('詞A'|pos)，# 詞頻，詞word不在字典里的話就為0
        ret, prob = 0, 0
        for k in self.d:#遍歷兩個類
            now = 0#預測值賦初值為0
            try:
                for otherk in self.d:#當類相同時now=1，類不同時now累加exp（tmp[otherk]-tmp[k]），最終計算now為變形后的朴素貝葉斯預測值的分母
                    now += exp(tmp[otherk]-tmp[k])#朴素貝葉斯變形式可見博客
                now = 1/now#求倒數為得到的這個類的預測值
            except OverflowError:
                now = 0
            if now > prob:#比較兩個類別的概率誰大，大的就是這個文本的類別。注意：初始prob等於0，經過遍歷后悔更新prob並且prob等於相應類別的朴素貝葉斯概率
                ret, prob = k, now
        return (ret, prob)
        #這里用朴素貝葉斯方法計算

注意：classify()方法中的朴素貝葉斯變形方法的編寫，下面兩個for循環，先是遍歷兩個類，比例第一個類，now表示對這個類計算的貝葉斯預測值，賦初值為0，第二個循環遍歷第一個類（otherk=k），

exp(tmp[otherk]-tmp[k])=exp（0）=1，則now=1，再遍歷第二個類得到上面變形公式中的第二部分值，這兩個相加得到的new就是

最后再倒數就得到了

   

 

再附加一個上面的AddOneProb()方法的源代碼解析，他就是一個對輸入的分詞計數的函數，將語料庫的詞進行分類計數，為了訓練做得到先后驗概率准備：

'''對詞計算頻數'''
class BaseProb(object):

    def __init__(self):
        self.d = {}#用來存儲分詞和分詞的個數，鍵是分詞，值是分詞的個數
        self.total = 0.0#計數總共的詞個數
        self.none = 0

    def exists(self, key):#判斷字典self.d中是否存在這個詞key
        return key in self.d

    def getsum(self):#返回語self.d中存儲的詞的總數
        return self.total

    def get(self, key):#判斷字典中是否存在這個詞key,並且返回這分詞的詞個數
        if not self.exists(key):
            return False, self.none
        return True, self.d[key]

    def freq(self, key):#計算詞key的頻率
        return float(self.get(key)[1])/self.total

    def samples(self):#返回字典的鍵，其實就是返回所有的分詞，以列表形式
        return self.d.keys()


class NormalProb(BaseProb):

    def add(self, key, value):
        if not self.exists(key):
            self.d[key] = 0
        self.d[key] += value
        self.total += value


'''對詞計數'''
class AddOneProb(BaseProb):#繼承BaseProb類，所以BaseProb類中的屬性和函數都能用。

    def __init__(self):
        self.d = {}
        self.total = 0.0
        self.none = 1

    def add(self, key, value):
        self.total += value#計算總詞數
        if not self.exists(key):#如果這個詞key不在self.d中的話，那么在字典中加上這個詞，即鍵為此，並且給這個詞計數1，同時總的詞數量total加1.
            self.d[key] = 1
            self.total += 1#感覺不應該再加1了，上面都已經計算過總數了？？？？說是后面預測要用到，可能是要平滑
        self.d[key] += value#如果字典已經有這個詞了的話，那么給這個詞數量加1

 

對於局進行分詞的方法Handle()感覺也很重要，也需要看一看。

再碼個帖子：snownlp情感分析源碼解析，snownlp的Github代碼