root/lang/python/spam/bayes.py

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import MeCab, operator, math, collections
from chi2p import chi2p

class Samples (object):
        """
        シリアライズ化のために切り離して使うことにする。
        """
        def __init__(self):
                self.spam_dict    = collections.defaultdict(float) # スパム文章の単語辞書
                self.nonspam_dict = collections.defaultdict(float) # 非スパム文章の単語辞書
                self.n_spam       = 0.0 # スパム文章のサンプル数
                self.n_nonspam    = 0.0 # 非スパム文章のサンプル数
        
        def getNumberOfWord(self, word):
                """
                Robinson方式で用います。
                単語wordにおける辞書の出現回数を返します。
                """
                return self.spam_dict[word] + self.nonspam_dict[word]

class Bayes (object):
        LIMIT_MAX = 1.0 - 1.0e-5
        LIMIT_MIN = 1.0e-5
        DEFAULT_PERCENTAGE = 0.4

        def __init__(self, samples=None):
                if samples:
                        self._s = samples
                else:
                        self._s = Samples()
                self.tagger = MeCab.Tagger("-Ochasen")
        
        def addSample(self, sentence, isSpam):
                """
                予め判別されたセンテンスを追加し、ベイズ学習器に学習させます。
                """
                n_list = self.parseToNoun(sentence)
                if isSpam:
                        self._s.n_spam += 1.0
                        for n in n_list: self._s.spam_dict[n] += 1.0
                else:
                        self._s.n_nonspam += 1.0
                        for n in n_list: self._s.nonspam_dict[n] += 1.0
        
        def evaluateByGraham(self, sentence, bias=2.0):
                """
                学習機での学習結果を元にスパムかどうかを判定し、スパムである確率を返します。
                """
                n_list    = self.parseToNoun(sentence)
                p_list    = [self.getPercentage(n, bias) for n in n_list]
                p_spam    = reduce( operator.mul, p_list )
                p_nonspam = reduce( operator.mul, [1.0-p for p in p_list] )
                p = p_spam / (p_spam + p_nonspam)
                return p
        
        def evaluateByRobinson(self, sentence, s=1.0, x=0.5):
                """
                学習機での学習結果を元にスパムかどうかを判定し、スパムである指標を返します。
                基本的にRobinson方式のほうがGraham方式よりも優れています。
                """
                n_list    = self.parseToNoun(sentence)
                twoN = 2.0*len(n_list)
                ds  = [self.getDegreeOfBelief(w,s,x) for w in n_list]
                dsi = [1.0-d for d in ds]
                H = chi2p(-2.0*math.log(reduce(operator.mul, ds)), twoN)
                S = chi2p(-2.0*math.log(reduce(operator.mul, dsi)), twoN)
                I = (1.0+H-S)/2.0
                return I
        
        def getSamples(self):
                """
                学習に使われているサンプルを取得します。
                """
                return self._s
        
        def getDegreeOfBelief(self, word, s, x):
                """
                Robinson方式で用います。
                p(w_i)における信頼度の具合を返します。
                
                x:今まで1度もメールの中に出現していない単語が初めてメールに出現したときに、
                そのメールがスパムメールである予測確率([0,1])
                s:xの予測に与える強さ（strength）
                """
                n = self._s.getNumberOfWord(word)
                
                if n == 0.0:
                        return s*x / (s+n)
                else:
                        return (s*x + n*self.getPercentage(word, 1.0))/(s+n)
        
        def getPercentage(self, word, bias):
                """
                各単語のスパム確率を返します。
                """
                # 各確率の計算
                pgood = 0.0
                pbad  = 0.0
                if (word in self._s.nonspam_dict):
                        pgood = min( (1.0, self._s.nonspam_dict[word] / self._s.n_nonspam * bias) )
                if (word in self._s.spam_dict):
                        pbad  = min( (1.0, self._s.spam_dict[word] / self._s.n_spam) )
                # スパム確率の算出
                p = 0.0
                if (pgood == 0.0 and pbad == 0.0):
                        p = Bayes.DEFAULT_PERCENTAGE # 判定できないのでデフォルト値を返す
                else:
                        p = pbad / (pgood + pbad)
                        if p < Bayes.LIMIT_MIN   : p = Bayes.LIMIT_MIN # 確率pが0に収束しないためにする。
                        elif p > Bayes.LIMIT_MAX : p = Bayes.LIMIT_MAX # 同様。
                return p
        
        def parseToNoun(self, sentence):
                """
                文章から、名詞から成るリストを返します。
                """
                n_list = []
                m = self.tagger.parseToNode(sentence)
                while m:
                        if m.feature.startswith("名詞"):
                                n_list.append(m.surface)
                        m = m.next
                return n_list