这篇文章做了什么
不先介绍点基础？
朴素贝叶斯，真的很朴素
情感分析是啥
朴素贝叶斯如何实现情感分析
1.前期准备：
做好正负面标记的文本作为训练集
正负面词库
2.针对文本实现：
分词，推荐使用Jieba分词引擎，无论是python, C#, 还是R语言上都有非常优秀的第三方库，而且可以导入词库
获取正负面词，此时需要用到正负面词库，即通过正负面词库的匹配，筛选出文本中能够反映情感的词。
进入训练集中匹配，获取每个正面或者负面的词在两个训练集的词频，如“好吃”这个词在正面训练集里出现频率为0.1%,而在负面训练集里频率为0.001%。
通过贝叶斯公式计算出在文本出现“好吃”这个词的条件下位正面或者为负面的概率，例如：
$p(正面|"好吃") = \frac{p(正面)p("好吃"|正面)}{p(正面)p("好吃"|正面)+ p(负面)p("好吃"|负面)} $
得到的概率即是在好吃这个词出现的条件下，该句子为正面的概率。
- 然而一句话可能有多个表示情感的词，比如"不好看"、"开心"，我们最终要求得在这些词出现的条件下该文本为正面的条件概率:\(p(正面|"好吃","不好看","开心")\)，具体计算过程见如下推导，令上述三个词分别为a,b,c,正面为pos，负面为neg：
\[\begin{eqnarray}
p(pos|a,b,c) &=& \frac{p(pos)p(a,b,c|pos)}{p(pos)p(a,b,c|pos)+p(neg)p(a,b,c|neg)}\\\\
&=& \frac{p(pos)p(a|pos)p(b|pos)p(c|pos)}{p(pos)p(a|pos)p(b|pos)p(c|pos)+p(neg)p(a|neg)p(b|neg)p(c|neg)}
\end{eqnarray}
\]
p(pos|a,b,c) &=& \frac{p(pos)p(a,b,c|pos)}{p(pos)p(a,b,c|pos)+p(neg)p(a,b,c|neg)}\\\\
&=& \frac{p(pos)p(a|pos)p(b|pos)p(c|pos)}{p(pos)p(a|pos)p(b|pos)p(c|pos)+p(neg)p(a|neg)p(b|neg)p(c|neg)}
\end{eqnarray}
\]
假设一句话为正面或是负面的先验概率均为0.5，则\(p(pos) = p(neg) = 0.5\)，那么(2)式等于:
\[\begin{eqnarray}
= \frac{p(a|pos)p(b|pos)p(c|pos)}{p(a|pos)p(b|pos)p(c|pos) + p(a|neg)p(b|neg)p(c|neg)}
\end{eqnarray}
\]
= \frac{p(a|pos)p(b|pos)p(c|pos)}{p(a|pos)p(b|pos)p(c|pos) + p(a|neg)p(b|neg)p(c|neg)}
\end{eqnarray}
\]
拉普拉斯平滑：为了避免某个词在训练集中出现概率为0导致结果有偏，拉普拉斯平滑法讲所有词出现次数加一，在样本量很大时，每个分量加一几乎不会对最终估计结果造成太大影响，但这样的好处是很好的解决了词频为0导致的有偏问题。
-
其他变式
贝叶斯推断及其互联网应用（二）：过滤垃圾邮件这篇文章中做了如下变形，将结果以单个词下正面或是负面的条件概率表示，但是文章并未提及拉普拉斯校准，而是用拍脑袋想出来的1%作为校准概率。由于：
\[\begin{eqnarray}
p(a|pos)& =& \frac{p(a|pos)p(a)}{p(a)}\\\\
&=& \frac{p(a|pos)p(a)}{p(a|pos)p(pos)+p(a|neg)p(neg)} (全概率公式)\\\\
&=& \frac{p(a|pos)p(pos)}{p(a|pos)p(pos)+p(a|neg)p(neg)}p(a)/p(pos)\\\\
&=& \frac{p(pos|a)p(a)}{p(pos)}\\\\
\end{eqnarray}
\]
p(a|pos)& =& \frac{p(a|pos)p(a)}{p(a)}\\\\
&=& \frac{p(a|pos)p(a)}{p(a|pos)p(pos)+p(a|neg)p(neg)} (全概率公式)\\\\
&=& \frac{p(a|pos)p(pos)}{p(a|pos)p(pos)+p(a|neg)p(neg)}p(a)/p(pos)\\\\
&=& \frac{p(pos|a)p(a)}{p(pos)}\\\\
\end{eqnarray}
\]
所以有(3)式等于：
\[\begin{eqnarray}
(3)式& =& \frac{\frac{p(pos|a)p(pos|b)p(pos|c)p(a)p(b)p(c)}{p(pos)^3}}{\frac{p(pos|a)p(pos|b)p(pos|c)p(a)p(b)p(c)}{p(pos)^3} + \frac{p(neg|a)p(neg|b)p(neg|c)p(a)p(b)p(c)}{p(neg)^3}}\\\\
&=& \frac{p(pos|a)p(pos|b)p(pos|c)}{p(pos|a)p(pos|b)p(pos|c)+p(neg|a)p(neg|b)p(neg|c)}\\\\
&=& \frac{p(pos|a)p(pos|b)p(pos|c)}{p(pos|a)p(pos|b)p(pos|c)+(1-p(pos|a))(1-p(pos|b))(1-p(pos|c))}\\\\
\end{eqnarray}
\]
(3)式& =& \frac{\frac{p(pos|a)p(pos|b)p(pos|c)p(a)p(b)p(c)}{p(pos)^3}}{\frac{p(pos|a)p(pos|b)p(pos|c)p(a)p(b)p(c)}{p(pos)^3} + \frac{p(neg|a)p(neg|b)p(neg|c)p(a)p(b)p(c)}{p(neg)^3}}\\\\
&=& \frac{p(pos|a)p(pos|b)p(pos|c)}{p(pos|a)p(pos|b)p(pos|c)+p(neg|a)p(neg|b)p(neg|c)}\\\\
&=& \frac{p(pos|a)p(pos|b)p(pos|c)}{p(pos|a)p(pos|b)p(pos|c)+(1-p(pos|a))(1-p(pos|b))(1-p(pos|c))}\\\\
\end{eqnarray}
\]
以上公式均为自己推导，作者原文中并未详细写出，如涉及侵权问题请通知我删除此部分。如有问题也欢迎大家指出，谢谢~。
3.聊一聊其他的
python号称最强大的中文自然语言处理库SnowNLP，其中的情感分析事实上非常粗糙，首先它并没有一个正负面的词库，而是把一个句子分出的所有词都参与计算，包括各种各样的无意义词、符号等等，而事实上这些词并不能反映任何情感。作者可能先验的认为正负面训练集中这些无情感词频率可以认为是近似的，但事实并非如此，所以这些词将导致计算结果有偏。
缺点：
- 朴素贝叶斯假设每个词是独立的，但是事实并非如此，尤其是针对长篇文章，或者是出现多个复杂语气词情况，独立性假设失效。
- 无法处理句子中比较的情况，无法落在句子中某一个产品或者属性上，难以做意见挖掘。
- 依赖于高质量的语料库
优点：
- 无需对句子成分进行分解，无需分析语法语义
- 针对无法判断正负面的词时有效（“呵呵”，“卧槽”等）
- 正负面词混杂时，依旧可以根据训练集做出较为准确的判断
说了这么多，我该如何实现呢？
在此小弟附上c#代码,如果觉得不清晰，您可以移步至我的GitHub：
//首先需要加载Jieba.Net，可以通过NuGet自行安装，然后using
//建立jieba类，用以处理训练集和文本
class Jieba
{
public string doc{get;set;}
public string PosWords {get;set;}
public string NegWords {get;set;}
public string stopwords {get;set;}
public List<string> JiebaCut()
{
JiebaSegmenter jiebaseg = new JiebaSegmenter();
var segment = jiebaseg.Cut(doc);
List<string> cutresult = new List<string>();
foreach (var i in segment)
{
if (!stopwords.Contains(i))
cutresult.Add(i);
}
return cutresult;
}
public List<string> handle_sentiment(bool pos = true)
{
var words = JiebaCut();
string PosOrNegWords = pos ? PosWords:NegWords;
List<string> handle_result = new List<string>();
foreach (var word in words)
{
if (PosOrNegWords.Contains(word))
handle_result.Add(word);
}
return handle_result;
}
public List<string> handle_words()
{
var words = JiebaCut();
List<string> handle_result = new List<string>();
foreach (var word in words)
{
if ((PosWords + NegWords).Contains(word))
handle_result.Add(word);
}
return handle_result;
}
}
然后，我们需要定义一个处理概率的类，以及派生类
class BaseProb
{
public Dictionary<string, double> d = new Dictionary<string, double>();
public double total = 0.0;
public int none = 0;
public bool exists(string key) { return d.Keys.Contains(key); }
public double getsum() { return total; }
public void get(string key, out bool para1, out double para2)
{
if (!exists(key))
{
para1 = false; para2 = none;
}
else
{
para1 = true;para2 = d[key];
}
}
public double freq(string key)
{
bool para1;
double para2;
get(key, out para1, out para2);
return para2 / total;
}
//def samples(self):
// return self.d.keys()
}
class AddOneProb : BaseProb
{
//public Dictionary<string, double> d = new Dictionary<string, double>();
//public double total = 0.0;
//public int none = 1;
public void add(string key, int value)
{
total += value;
if (!exists(key))
{
d.Add(key, 1);
total += 1;
}
d[key] += value;
}
public void DPrint()
{
Console.WriteLine(d.Count);
Console.ReadKey();
foreach (var key in d.Keys)
{
Console.WriteLine(key+" : "+d[key].ToString());
}
}
}
接下来需要将原始训练集序列化为Json格式，方便以后调用，我使用的是LitJson，转为["pos":{"我是一个词":10},"neg":{"我也是一个词":20}]的形式，以后直接读取词频而非整个句子再进行分词与统计。我们通过以下代码读取序列化后的数据：
public static Dictionary<string, AddOneProb> Load(string filepath, out double total)
{
string json;
using (var sr = new StreamReader(filepath, Encoding.Default))
json = sr.ReadToEnd();
JsonData jd = JsonMapper.ToObject(json);
Dictionary<string, AddOneProb> d = new Dictionary<string, AddOneProb>() { { "neg", new AddOneProb() }, { "pos", new AddOneProb() } };
foreach (var i in jd["d"]["neg"]["d"])
{
var arr = i.ToString().Replace("[","").Replace("]","").Split(',');
int count = 0;
if (int.TryParse(arr[1],out count ))
d["neg"].add(arr[0], count);
}
foreach (var i in jd["d"]["pos"]["d"])
{
var arr = i.ToString().Replace("[", "").Replace("]", "").Split(',');
int count = 0;
if (int.TryParse(arr[1], out count))
d["pos"].add(arr[0], count);
}
total = Convert.ToDouble (jd["total"].ToString());
return d;
}
当然如果你不想进行序列化，也行，可以通过以下代码训练样本
public static void Train_data(string negFilePath, string negWords, string posFilePath, string posWords,
ref Dictionary<string, AddOneProb> d, ref double total, string stopwordFilepath)
{
//d = new Dictionary<string, AddOneProb>() { { "pos", new AddOneProb() }, { "neg", new AddOneProb() } };
string negfile = "", posfile = "";
using (var sr1 = new StreamReader(negFilePath, Encoding.Default))
negfile = sr1.ReadToEnd();
using (var sr2 = new StreamReader(posFilePath, Encoding.Default))
posfile = sr2.ReadToEnd();
string stopwords = ReadTxtToEnd(stopwordFilepath);
List<Tuple<List<string>, string>> data = new List<Tuple<List<string>, string>>();
var sent_cut = new Jieba();
sent_cut.NegWords = negWords;
sent_cut.PosWords = posWords;
foreach (var sent in posfile.Replace("\r", "").Split('\n'))
{
sent_cut.doc = sent;
sent_cut.stopwords = stopwords;
data.Add(new Tuple<List<string>, string>(sent_cut.handle_sentiment(), "pos"));
}
Console.WriteLine("正面词库导入完毕");
foreach (var sent in negfile.Replace("\r", "").Split('\n'))
{
sent_cut.doc = sent;
sent_cut.stopwords = stopwords;
data.Add(new Tuple<List<string>, string>(sent_cut.handle_sentiment(false), "neg"));
}
Console.WriteLine("负面词库导入完毕");
foreach (var d_ in data)
{
var c = d_.Item2.ToString();
if (d_.Item1 == null)
continue;
else
{
foreach (var word in d_.Item1)
d[c].add(word, 1);
}
}
total = 0;
foreach (var value in d.Values)
{
total += value.total;
}
}
接下来就可以写分类函数了，是这样的：
protected static Tuple<string, double> Classify(List<string> x,
Dictionary<string, AddOneProb> d, double total)
{
Dictionary<string, double> temp = new Dictionary<string, double>();
foreach (var k in d.Keys)
{
temp.Add(k, Math.Log(0.5));
foreach (var word in x)
{
Console.WriteLine(k+" : "+word + " : " + d[k].freq(word));
temp[k] += Math.Log(d[k].freq(word));
}
Console.ReadKey();
}
string ret = "";
double prob = 0;
double now;
foreach (var k in d.Keys)
{
now = 0;
foreach (var otherk in d.Keys)
{
try
{
now += Math.Exp(temp[otherk] - temp[k]);
}
catch (Exception)
{
now = 10000;
}
}
now = 1 / now;
if (now > prob)
{
ret = k;
prob = now;
}
}
return new Tuple<string, double>(ret, prob);
}
public static double classify_(string sent, Dictionary<string, AddOneProb> d,
double total, string stopwordFilepath)
{
Jieba jiebaword = new Jieba();
jiebaword.doc = sent;
jiebaword.stopwords = ReadTxtToEnd(stopwordFilepath);
var retprob = Classify(jiebaword.JiebaCut(), d, total);
if (retprob.Item1 == "pos")
return retprob.Item2;
else
return 1 - retprob.Item2;
}
如何使用：
static void Main(string[] args)
{
double total = 0;
var d = Train.Load(SentimentFilepath + "sentiment_json.txt",out total);
var poswords = Train.ReadTxtToEnd(SentimentFilepath + "pos.csv");
var negwords = Train.ReadTxtToEnd(SentimentFilepath + "neg.csv");
Train.Train_data(SentimentFilepath + "neg_train.csv", negwords, SentimentFilepath + "pos_train.csv", poswords,ref d, ref total, SentimentFilepath + "stopwords.csv");
string testsentence = "很忽悠，不好";
var sent = Train.classify_(testsentence, d, total, SentimentFilepath + "stopwords.csv");
Console.WriteLine(sent);
Console.ReadKey();
}