snownlp情感分析源码解析

最新推荐文章于 2025-03-29 12:36:19 发布

S_H-A_N

最新推荐文章于 2025-03-29 12:36:19 发布

阅读量1.8w

点赞数 6

分类专栏：机器学习

本文链接：https://blog.csdn.net/lom9357bye/article/details/78565432

版权

机器学习专栏收录该内容

10 篇文章

订阅专栏

snownlp github:https://github.com/isnowfy/snownlp

使用snownlp进行情感分析：

from snownlp import SnowNLP

#创建snownlp对象，设置要测试的语句
s = SnowNLP('这东西不错。。')
# 调用sentiments方法获取积极情感概率
print(s.sentiments)

输出： 0.8371034573341097

实现过程：

1.首先从SnowNLP入手，看一下sentiments方法，在sentiments方法中，调用了sentiment下的分类方法

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

from . import normal
from . import seg
from . import tag
from . import sentiment
from .sim import bm25
from .summary import textrank
from .summary import words_merge


class SnowNLP(object):

    def __init__(self, doc):
        self.doc = doc
        self.bm25 = bm25.BM25(doc)

    @property
    def words(self):
        return seg.seg(self.doc)

    @property
    def sentences(self):
        return normal.get_sentences(self.doc)

    @property
    def han(self):
        return normal.zh2hans(self.doc)

    @property
    def pinyin(self):
        return normal.get_pinyin(self.doc)

    @property
    def sentiments(self):
        return sentiment.classify(self.doc)#调用了sentiment的classify分类方法

    @property
    def tags(self):
        words = self.words
        tags = tag.tag(words)
        return zip(words, tags)

    @property
    def tf(self):
        return self.bm25.f

    @property
    def idf(self):
        return self.bm25.idf

    def sim(self, doc):
        return self.bm25.simall(doc)

    def summary(self, limit=5):
        doc = []
        sents = self.sentences
        for sent in sents:
            words = seg.seg(sent)
            words = normal.filter_stop(words)
            doc.append(words)
        rank = textrank.TextRank(doc)
        rank.solve()
        ret = []
        for index in rank.top_index(limit):
            ret.append(sents[index])
        return ret

    def keywords(self, limit=5, merge=False):
        doc = []
        sents = self.sentences
        for sent in sents:
            words = seg.seg(sent)
            words = normal.filter_stop(words)
            doc.append(words)
        rank = textrank.KeywordTextRank(doc)
        rank.solve()
        ret = []
        for w in rank.top_index(limit):
            ret.append(w)
        if merge:
            wm = words_merge.SimpleMerge(self.doc, ret)
            return wm.merge()
        return ret

2.sentiment文件夹下的__init__文件

sentiment中创建了Sentiment对象

首先调用load方法加载训练好的数据字典，然后调用classify方法，在classify方法中实际调用的是Bayes对象中的classify方法，这个稍后再说。

# -*- 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对象
        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

    # 训练数据集
    def train(self, neg_docs, pos_docs):
        data = []
        #读取消极评论list，同时为每条评论加上neg标签，也放入到一个list中
        for sent in neg_docs:
            data.append([self.handle(sent), 'neg'])
        #读取积极评论list，为每条评论加上pos标签
        for sent in pos_docs:
            data.append([self.handle(sent), 'pos'])
        #调用分类器的训练数据集方法，对模型进行训练
        self.classifier.train(data)

    #分类
    def classify(self, sent):
        #调用贝叶斯分类器的分类方法，获取分类标签和概率
        ret, prob = self.classifier.classify(self.handle(sent))
        #如果分类标签是pos直接返回概率值
        if ret == 'pos':
            return prob
        #如果返回的是neg，由于显示的是积极概率值，因此用1减去消极概率值
        return 1-prob


classifier = Sentiment()
classifier.load()

#训练数据
def train(neg_file, pos_file):
    #打开消极数据文件
    neg = codecs.open(neg_file, 'r', 'utf-8').readlines()
    pos = codecs.open(pos_file, 'r', 'utf-8').readlines()
    neg_docs = []
    pos_docs = []
    #遍历每一条消极评论，放入到list中
    for line in neg:
        neg_docs.append(line.rstrip("\r\n"))
    #遍历每一条积极评论，放入到list中
    for line in pos:
        pos_docs.append(line.rstrip("\r\n"))
    global classifier
    classifier = Sentiment()
    #训练数据，传入积极、消极评论list
    classifier.train(neg_docs, pos_docs)

#保存数据字典
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)

sentiment中包含了训练数据集的方法，看一下是如何训练数据集的：
在sentiment文件夹下，包含了以下文件

neg.txt和pos.txt是已经分类好的评论数据，neg.txt中都是消极评论，pos中是积极评论

sentiment.marshal和sentiment.marshal.3中存放的是序列化后的数据字典，这个也稍后再说

（1）在train()方法中，首先读取消极和积极评论txt文件，然后获取每一条评论，放入到list集合中，格式大致如下

[ ' 还没有收到书！！！还没有收到书 ' , ' 小熊宝宝我觉得孩子不喜欢，能换别的吗 ' , ......]

#训练数据
def train(neg_file, pos_file):
    #打开消极数据文件
    neg = codecs.open(neg_file, 'r', 'utf-8').readlines()
    pos = codecs.open(pos_file, 'r', 'utf-8').readlines()
    neg_docs = []
    pos_docs = []
    #遍历每一条消极评论，放入到list中
    for line in neg:
        neg_docs.append(line.rstrip("\r\n"))
    #遍历每一条积极评论，放入到list中
    for line in pos:
        pos_docs.append(line.rstrip("\r\n"))
    global classifier
    classifier = Sentiment()
    #训练数据，传入积极、消极评论list
    classifier.train(neg_docs, pos_docs)

然后调用了Sentiment对象中的train()方法：

在train方法中，遍历了传入的积极、消极评论list，为每条评论进行分词，并为加上了分类标签，此时的数据格式如下：

评论分词后的数据格式：['收到','没有'...]

加上标签后的数据格式(以消极评论为例)：[ [['收到','没有' ...],'neg'] , [['小熊','宝宝' ...],‘neg’] ........]]

可以看到每一条评论都是一个list，其中又包含了评论分词后的list和评论的分类标签

 # 训练数据集
    def train(self, neg_docs, pos_docs):
        data = []
        #读取消极评论list，对每条评论分词，并加上neg标签，也放入到一个list中
        for sent in neg_docs:
            data.append([self.handle(sent), 'neg'])
        #读取积极评论list，为每条评论分词，加上pos标签
        for sent in pos_docs:
            data.append([self.handle(sent), 'pos'])
        #调用分类器的训练数据集方法，对模型进行训练
        self.classifier.train(data)

经过了此步骤，已经对数据处理完毕，接下来就可以对数据进行训练

3.classification下的bayes.py

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

import sys
import gzip
import marshal
from math import log, exp

from ..utils.frequency import AddOneProb


class Bayes(object):

    def __init__(self):
        #标签数据对象
        self.d = {}
        #所有分类的词数之和
        self.total = 0

    #保存字典数据
    def save(self, fname, iszip=True):
        #创建对象，用来存储训练结果
        d = {}
        #添加total，也就是积极消极评论分词总词数
        d['total'] = self.total
        #d为分类标签，存储每个标签的数据对象
        d['d'] = {}
        for k, v in self.d.items():
            #k为分类标签，v为标签对应的所有分词数据，是一个AddOneProb对象
            d['d'][k] = v.__dict__
        #这里判断python版本
        if sys.version_info[0] == 3:
            fname = fname + '.3'
        #这里可有两种方法可以选择进行存储
        if not iszip:
            ##将序列化后的二进制数据直接写入文件
            marshal.dump(d, open(fname, 'wb'))
        else:
            #首先获取序列化后的二进制数据，然后写入文件
            f = gzip.open(fname, 'wb')
            f.write(marshal.dumps(d))
            f.close()

    #加载数据字典
    def load(self, fname, iszip=True):
        #判断版本
        if sys.version_info[0] == 3:
            fname = fname + '.3'
        #判断打开文件方式
        if not iszip:
            d = marshal.load(open(fname, 'rb'))
        else:
            try:
                f = gzip.open(fname, 'rb')
                d = marshal.loads(f.read())
            except IOError:
                f = open(fname, 'rb')
                d = marshal.loads(f.read())
            f.close()
        #从文件中读取数据，为total和d对象赋值
        self.total = d['total']
        self.d = {}
        for k, v in d['d'].items():
            self.d[k] = AddOneProb()
            self.d[k].__dict__ = v

    #训练数据集
    def train(self, data):
        #遍历数据集
        for d in data:
            #d[1]标签-->分类类别
            c = d[1]
            #判断数据字典中是否有当前的标签
            if c not in self.d:
                #如果没有该标签，加入标签，值是一个AddOneProb对象
                self.d[c] = AddOneProb()
            #d[0]是评论的分词list，遍历分词list
            for word in d[0]:
                #调用AddOneProb中的add方法，添加单词
                self.d[c].add(word, 1)
        #计算总词数
        self.total = sum(map(lambda x: self.d[x].getsum(), self.d.keys()))

    #贝叶斯分类
    def classify(self, x):
        tmp = {}
        #遍历每个分类标签
        for k in self.d:
            #获取每个分类标签下的总词数和所有标签总词数，求对数差相当于log（某标签下的总词数/所有标签总词数）
            tmp[k] = log(self.d[k].getsum()) - log(self.total)
            for word in x:
                #获取每个单词出现的频率，log[（某标签下的总词数/所有标签总词数）*单词出现频率]
                tmp[k] += log(self.d[k].freq(word))
        #计算概率，由于直接得到的概率值比较小，这里应该使用了一种方法来转换，原理还不是很明白
        ret, prob = 0, 0
        for k in self.d:
            now = 0
            try:
                for otherk in self.d:
                    now += exp(tmp[otherk]-tmp[k])
                now = 1/now
            except OverflowError:
                now = 0
            if now > prob:
                ret, prob = k, now
        return (ret, prob)

from . import good_turing

class BaseProb(object):

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

    def exists(self, key):
        return key in self.d

    def getsum(self):
        return self.total

    def get(self, key):
        if not self.exists(key):
            return False, self.none
        return True, self.d[key]

    def freq(self, 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):

    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):
            #将单词加入对应标签的数据字典中，value设为1
            self.d[key] = 1
            #更新总词数
            self.total += 1
        #如果单词出现过，对该单词的value值加1
        self.d[key] += value

在bayes对象中，有两个属性d和total,d是一个数据字典，total存储所有分类的总词数，经过train方法训练数据集后，d中存储的是每个分类标签的数据key为分类标签，value是一个AddOneProb对象。

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

在AddOneProb对象中，同样存在d和total属性，这里的total存储的是每个分类各自的单词总数，d中存储的是所有出现过的单词，单词作为key，单词出现的次数作为value.

为了下次计算概率时，不用重新训练，可以将训练得到的数据序列化到文件中，下次直接加载文件，将文件反序列为对象，从对象中获取数据即可(save和load方法)。

4.得到了训练的数据后，可以使用朴素贝叶斯分类对进行分类了

朴素贝叶斯分类可参考:NLP系列(2)_用朴素贝叶斯进行文本分类(上)