# -*- coding: utf-8 -*-
"""
我們會選擇高概率對應的類別。這就是貝葉斯決策理論的核心思想，即選擇具有最高概率的決策.
貝葉斯：p(A|B) = p(A) * p(B|A) / p(B)
我們把P(A)稱為"先驗概率"（Prior probability），即在B事件發生之前，我們對A事件概率的一個判斷。

P(A|B)稱為"後驗概率"（Posterior probability），即在B事件發生之後，我們對A事件概率的重新評估。
   也就是發生了事件B，對事件A進行修正，得到的概率

P(B|A)/P(B)稱為"可能性函式"（Likelyhood），這是一個調整因子，使得預估概率更接近真實概率。
"""
import numpy as np
from functools import reduce
"""
函式說明：建立實驗樣本
Parameters:
    無
Returns:
    postingList 實驗樣本切分的詞條
    classVec 類別標籤向量
"""
def loadDataSet():
    postingList = [
            ['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],                #切分的詞條
            ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
            ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
            ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
            ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
            ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
    classVec = [0, 1 ,0 , 1, 0, 1]
    return postingList, classVec

"""
函式說明：根據實驗樣本建立一個不重複的詞條列表，也就是詞彙表
Parameters:
    dataSet 整理成的樣本資料集
Returns:
    vocabSet 詞條列表,
"""
def createVocabList(dataSet):
    #建立一個空的不重複的列表。重複的被刪除，無序的
    vocabSet = set([])
    for document in dataSet:
        #取並集
        vocabSet = vocabSet | set(document)
    return list(vocabSet)
"""
函式說明：根據vocabSet詞彙表，將input向量化，向量的每個元素為0或者1
Parameters:
    vocabSet 詞彙表
    inputSet 實驗樣本切分的詞條,即句子
Returns:
    returnVec 文件向量，詞集模型
"""
def setOfWord2Vec(vocabList, inputSet):
    returnVec = [0] * len(vocabList)
    for word in inputSet:
        if word in vocabList:
            #如果詞條存在於詞彙表，則置1
            returnVec[vocabList.index(word)] = 1
        else:
            print("The word: %s is not in my vocabulary!" % word)
    return returnVec
    
"""
函式說明：樸素貝葉斯分類函式
Parameters:
    trainMatrix 訓練文件矩陣，即setOfWord2Vec返回值
    trainCategory 類別標籤向量，即loadDataSet返回值classVec
Returns:
    p0Vect 非侮辱類的條件概率陣列
    p1Vect 侮辱類的條件概率陣列
    PAbusive 文件中屬於侮辱類的詞彙
"""
def trainNB0(trainMatrix, trainCategory):
    #計算訓練的句子數目
    numTrainDocs = len(trainMatrix)
    #計算每一個句子的詞條數
    numWords = len(trainMatrix[0])
    #句子是侮辱類的概率
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    p0Num = np.zeros(numWords)
    p1Num = np.zeros(numWords)
    #分母初始化為零
    p0Denom = 0.0
    p1Denom = 0.0
    for i in range(numTrainDocs):
        #統計屬於侮辱類的條件概率
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
        #統計屬於非侮辱類的條件概率
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    p1Vect = p1Num / p1Denom
    p0Vect = p0Num / p0Denom
    return p0Vect, p1Vect, pAbusive
 
"""
函式說明：樸素貝葉斯分類函式
Parameters:
    vec2Classify 待分類的詞條陣列
    p0Vec 非侮辱類的條件概率陣列
    p1Vec 侮辱類的條件概率陣列
    pClass1 句子屬於侮辱類的概率
Returns:
    0 非侮辱類
    1 侮辱類
"""
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    """
    p(A+B) = p(A) + p(B) - p(AB)
    當AB互斥: p(A+B) = p(A) + p(B)
    
    當AB獨立: 
        p(AB) = p(A) * p(B)
        p(A1A2A3|B) = p(A1|B) * p(A2|B) * p(A3|B)
        
    因此：貝葉斯：p(Ci|(x,y)) = p(Ci) * p((x,y)|Ci) / p(x,y)
        
        s是句子，1是侮辱類，s1 s2 s3是句子拆分的詞彙
        p(1|s) = p(1) * p(s|1)
               = p(1) * p(s1s2s3|1)
               = p(1) *[ p(s1|1) * p(s2|1) * p(s3|1) ] 獨立
    """
    p1 = reduce(lambda x,y : x*y, vec2Classify * p1Vec) * pClass1
    p0 = reduce(lambda x,y : x*y, vec2Classify * p0Vec) * (1.0 - pClass1)
    print('p0:', p0)
    print('p1:', p1)
    if p1 > p0:
        return 1
    else:
        return 0

if  __name__ == '__main__':
    List0Posts, ListClasses = loadDataSet()
    myVocabList = createVocabList(List0Posts)
    trainMat = []
    for postinDoc in List0Posts:
        trainMat.append(setOfWord2Vec(myVocabList, postinDoc))
    p0V, p1V, pAb = trainNB0(np.array(trainMat), np.array(ListClasses))
    test1 = ['love', 'my', 'dalmation']
    #測試樣本向量化
    testVec = np.array(setOfWord2Vec(myVocabList, test1))
    if classifyNB(testVec, p0V, p1V, pAb):
        print(test1, '屬於侮辱類')
    else:
        print(test1, '屬於非侮辱類')
        
    test2 = ['stupid', 'garbage']
    #測試樣本向量化
    testVec2 = np.array(setOfWord2Vec(myVocabList, test2))
    if classifyNB(testVec2, p0V, p1V, pAb):
        print(test2, '屬於侮辱類')
    else:
        print(test2, '屬於非侮辱類')