關聯文章：
一、垃圾郵件分類：
流程：
1）中文或英文的分詞
中文的分詞：用到了第三方分詞組件jieba參考 https://github.com/fxsjy/jieba
安裝過程：關聯文章：Anaconda 安裝第三方工具包
英文的分詞：使用正則表達式切分 import re 參考https://docs.python.org/zh-cn/3/library/re.html
2）構建全部訓練集的詞列表vocalList（不重複）
3）加載停用詞列表or所有的vocaList統計高頻詞，然後去除高頻詞或者是去除包含的停用詞
停用詞獲取地址：https://www.ranks.nl/stopwords
4）每篇文檔的詞列表轉換爲詞向量（01表示）4）每條詞向量以及類別劃分訓練集和測試集
5）訓練bayes算法獲得先驗概率、類0條件概率、類1的條件概率
機器學習實戰上的例子搞錯了！，參考：
https://blog.csdn.net/qq_27009517/article/details/80044431
https://blog.csdn.net/lming_08/article/details/37542331
樸素貝葉斯方法分爲：1）伯努利模型 2）多項式模型 3）高斯模型等
其中的伯努利模型：
P(c)= 類c下文件總數/整個訓練樣本的文檔總數
P(tk|c)=(類c下包含單詞tk的文件數+1)/(類c下文檔總數+2) 在這裏，m=2, p=1/2。
多項式模型：
先驗概率P(c)= 類c下單詞總數/整個訓練樣本的單詞總數
類條件概率P(tk|c)=(類c下單詞tk在各個文檔中出現過的次數之和+1)/(類c下單詞總數+|V|)
建立聯繫！
先驗分佈爲高斯分佈的Naive Bayes
6）測試算法
伯努利型樸素貝葉斯分類：
導入庫：
import numpy as np
import re
def spamTest():
docList = []; classList = []; fullText = []
#遍歷25個txt文件
for i in range(1, 26):
#讀取每個垃圾郵件，大字符串轉換成字符列表。
wordList = textParse(open('email/spam/%d.txt' % i, encoding="ISO-8859-1").read())
docList.append(wordList)#不展開列表
fullText.extend(wordList)#展開列表
#標記垃圾郵件，1表示垃圾郵件
classList.append(1)
#讀取每個非垃圾郵件，字符串轉換爲字符列表
wordList = textParse(open('email/ham/%d.txt' % i, encoding="ISO-8859-1").read())
docList.append(wordList)
fullText.extend(wordList)
#標記每個非垃圾郵件，0表示非垃圾郵件
classList.append(0)
#創建詞彙表，不重複
vocabList = createVocabList(docList)
#創建存儲訓練集的索引值的列表
trainingSet =list(range(50));
#創建存儲測試集的索引值的列表
testSet= []
#從50個郵件中，隨機挑選出40個作爲訓練集，10個作爲測試集
for i in range(10):
#隨機選取索引值
randIndex = int(np.random.uniform(0, len(trainingSet)))
#添加測試集的索引值
testSet.append(trainingSet[randIndex])
#在訓練集的列表中刪除添加到測試集的索引值
del(list(trainingSet)[randIndex])
#創建訓練集矩陣和訓練集類別標籤向量
trainMat = [];
trainClasses = []
#遍歷訓練集，目前只有40個訓練集
for docIndex in trainingSet:
#將生成的詞集模型添加到訓練矩陣中
trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))
#將類別標籤添加到訓練集的類別標籤向量中
trainClasses.append(classList[docIndex])
"""
訓練樸素貝葉斯模型
"""
#訓練樸素貝葉斯模型
p0V, p1V, pSpam = trainNB(np.array(trainMat), np.array(trainClasses))
#錯誤分類計數
errorCount = 0
#遍歷測試集
for docIndex in testSet:
#測試集的詞集模型
wordVector = setOfWords2Vec(vocabList, docList[docIndex])
if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
errorCount += 1
print("classification error", docList[docIndex])
print('the error rate is: ', float(errorCount)/len(testSet))
#將一個大字符串解析爲字符列表
def textParse(bigString):
import re
listOfTokens = re.split(r'\W+', bigString)
return [tok.lower() for tok in listOfTokens if len(tok) > 2] #找出長度大於兩個字母的單詞
#定義創建不重複的列表函數
"""
createVocabList()函數會創建一個包含在所有文檔中出現的不重複詞的列表
"""
def createVocabList(dataSet):
#創建一個空集
vocabSet = set([])
for document in dataSet:
#再創建一個空集後，將每篇文檔返回的新詞集合添加到該集合中，再求兩個集合的並集
vocabSet = vocabSet | set(document)
return list(vocabSet)
#定義詞集模型函數（set-of-words）
def setOfWords2Vec(vocabList, inputSet):
#函數首先創建一個和詞彙表等長的向量，並將其元素都設置爲0
returnVec = [0]*len(vocabList)
#接着，遍歷文檔中的所有單詞，如果出現了詞彙表中的單詞，則將輸出的文檔向量中的對應值設爲1。
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] = 1
else:
print("the word: %s is not in my Vocabulary!" % word)
return returnVec
#定義詞袋模型
def bagOfWords2VecMN(vocabList, inputSet):
returnVec = [0]*len(vocabList)
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] += 1
return returnVec
#定義樸素貝葉斯分類器訓練函數
"""
函數說明:樸素貝葉斯分類器訓練函數
trainMatrix--訓練文檔矩陣，即setOfWords2Vec返回的returnVec構成的矩陣；trainCategory--訓練類別標籤向量
p1Vect--標記爲1的類條件概率數組；p0Vect--標記爲0的類條件概率數組；pAbusive是標記爲1類的先驗概率
"""
def trainNB(trainMatrix, trainCategory):
#計算訓練的文檔數目
numTrainDocs = len(trainMatrix)
#計算每篇文檔的詞條數 相當於特徵數
numWords = len(trainMatrix[0])
#標記爲1類的先驗概率
pAbusive = sum(trainCategory)/float(numTrainDocs)
"""
創建numpy數組初始化爲1，拉普拉斯平滑。
創建numpy.zeros數組,詞條出現數初始化爲0。分母初始化爲2
"""
p0Num = np.ones(numWords); p1Num = np.ones(numWords)
p0Denom = 2.0; p1Denom = 2.0
#計算類條件概率
for i in range(numTrainDocs):
if trainCategory[i] == 1:
p1Num += trainMatrix[i]#矩陣相加
p1Denom += 1#表示類1文檔個數
# p1Denom += sum(trainMatrix[i])#有誤
else:
p0Num += trainMatrix[i]
p0Denom += 1#表示類0文檔個數
#p0Denom += sum(trainMatrix[i])#有誤
#由於大部分因子都非常小，防止數值下溢得不到正確答案。於是加log計算，可以使得答案不會過小。
p1Vect = np.log(p1Num/p1Denom) #change to np.log() 類1 爲1 的條件概率
p0Vect = np.log(p0Num/p0Denom) #change to np.log() 類0 爲0 的條件概率 和後面的計算有一些聯繫
return p0Vect, p1Vect, pAbusive
#函數說明:樸素貝葉斯分類器分類函數
#vec2Classify--待分類的詞條數組; p1Vec--標記爲類1的類條件概率數組; p0Vec--標記爲類0的類條件概率數組; pClass1--標記爲1類的先驗概率
"""
博客
https://blog.csdn.net/qq_27009517/article/details/80044431
https://blog.csdn.net/lming_08/article/details/37542331
"""
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
"""
1.計算待分類詞條數組爲1類的概率
"""
#尋找vec2Classify測試數組中，元素爲0時對應的索引值
index = np.where(vec2Classify==0)#返回一串索引值，相等爲true 否則爲false 只返回false索引
#遍歷元素爲0時的索引值，並從p1Vec--1類的條件概率數組中取出對應索引的數值，並存儲成列表的形式（p1Vec0=[]）
p1Vec0=[]
for i in index:#index爲tuple 取i=0 的tuple 只執行一次
for m in i:
p1Vec0.append(p1Vec[m])
#所有P(vec2Classify=0|1)組成的列表
x0=np.ones(len(p1Vec0))-p1Vec0##？和訓練過程得到的p1Vec有關，p1Vec它表示類1下爲1的條件概率
#尋找vec2Classify測試數組中，元素爲1時對應的索引值
index1= np.where(vec2Classify==1)
#遍歷元素爲1時的索引值，並從p1Vec--1類的條件概率數組中取出對應索引的數值，並存儲成列表的形式（p1Vec1=[]）
p1Vec1=[]
for i in index1:
for m in i:
p1Vec1.append(p1Vec[m])
#所有P(vec2Classify=1|1)組成的列表
x1=p1Vec1
##對應元素相乘。logA * B = logA + logB，所以這裏加上log(pClass1)
p1 = sum(x0)+sum(x1) + np.log(pClass1)
"""
2.計算待分類詞條數組爲0類的概率
"""
#尋找vec2Classify測試數組中，元素爲0時對應的索引值
index2 = np.where(vec2Classify==0)
#遍歷元素爲0時的索引值，並從p0Vec--0類的條件概率數組中取出對應索引的數值，並存儲成列表的形式（p0Vec0=[]）
p0Vec0=[]
for i in index2:
for m in i:
p0Vec0.append(p0Vec[m])
#所有P(vec2Classify=0|0)組成的列表
w0=np.ones(len(p0Vec0))-p0Vec0
#尋找vec2Classify測試數組中，元素爲1時對應的索引值
index3= np.where(vec2Classify==1)
#遍歷元素爲1時的索引值，並從p0Vec--0類的條件概率數組中取出對應索引的數值，並存儲成列表的形式（p0Vec1=[]）
p0Vec1=[]
for i in index3:
for m in i:
p0Vec1.append(p0Vec[m])
#所有P(vec2Classify=1|0)組成的列表
w1=p0Vec1
##對應元素相乘。logA * B = logA + logB，所以這裏加上log(pClass1)
p0 = sum(w0)+sum(w1) + np.log(1.0 - pClass1)
if p1 > p0:
return 1
else:
return 0
詳細見Github：https://github.com/codehgq/ML-note/tree/master/email%20Classify
歡迎Star ！關注
二、新聞分類：
1）數據集來源，加載並按索引切分（隨機打亂數據，先訓練樣本和類別打包，再打亂，在解壓）
2）中文分詞
3）不重複的詞頻統計，並按照詞頻次數倒序排列 獲得所有不重複的詞列表
4）剔除無關的詞後的特徵列表（去掉停用詞、詞的長度限制，數字限制）得feature_words
5）利用詞列表將訓練集文檔轉換爲每條條的詞向量
6）訓練
參考博主：http://blog.csdn.net/c406495762 （寫的不錯）的文章解讀。
以下爲代碼轉載部分：可能稍做了處理以符合自己的學習。（注意代碼爲Tab縮進方式）
# -*- coding: UTF-8 -*-
from sklearn.naive_bayes import MultinomialNB
import matplotlib.pyplot as plt
import os
import random
import jieba
"""
函數說明:中文文本處理
Parameters:
folder_path - 文本存放的路徑
test_size - 測試集佔比，默認佔所有數據集的百分之20
Returns:
all_words_list - 按詞頻降序排序的訓練集列表
train_data_list - 訓練集列表
test_data_list - 測試集列表
train_class_list - 訓練集標籤列表
test_class_list - 測試集標籤列表
Author:
Jack Cui
Blog:
http://blog.csdn.net/c406495762
Modify:
2017-08-22
"""
def TextProcessing(folder_path, test_size = 0.2):
folder_list = os.listdir(folder_path) #查看folder_path下的文件
data_list = [] #數據集數據
class_list = [] #數據集類別
#遍歷每個子文件夾
for folder in folder_list:
new_folder_path = os.path.join(folder_path, folder) #根據子文件夾，生成新的路徑
files = os.listdir(new_folder_path) #存放子文件夾下的txt文件的列表
j = 1
#遍歷每個txt文件
for file in files:
if j > 100: #每類txt樣本數最多100個
break
with open(os.path.join(new_folder_path, file), 'r', encoding = 'utf-8') as f: #打開txt文件
raw = f.read()
word_cut = jieba.cut(raw, cut_all = False) #精簡模式，返回一個可迭代的generator
word_list = list(word_cut) #generator轉換爲list
data_list.append(word_list) #添加數據集數據# 不展開
class_list.append(folder) #添加數據集類別
j += 1
print(data_list)
print(class_list)
data_class_list = list(zip(data_list, class_list)) #zip壓縮合並，將數據與標籤對應壓縮 打包成元組 利用 * 號操作符，可以將元組解壓爲列表
#https://www.runoob.com/python/python-func-zip.html
random.shuffle(data_class_list) #將data_class_list亂序
index = int(len(data_class_list) * test_size) + 1 #訓練集和測試集切分的索引值
train_list = data_class_list[index:] #訓練集
test_list = data_class_list[:index] #測試集
train_data_list, train_class_list = zip(*train_list) #訓練集解壓縮
test_data_list, test_class_list = zip(*test_list) #測試集解壓縮
all_words_dict = {} #統計訓練集詞頻
for word_list in train_data_list:
for word in word_list:#不重複的統計詞頻
if word in all_words_dict.keys():
all_words_dict[word] += 1
else:
all_words_dict[word] = 1
#根據鍵的值倒序排序
all_words_tuple_list = sorted(all_words_dict.items(), key = lambda f:f[1], reverse = True)#True 降序 False 升序
all_words_list, all_words_nums = zip(*all_words_tuple_list) #解壓縮
all_words_list = list(all_words_list) #轉換成列表
return all_words_list, train_data_list, test_data_list, train_class_list, test_class_list
#文本預處理
folder_path = './SogouC/Sample' #訓練集存放地址
TextProcessing(folder_path)
"""
函數說明:讀取文件裏的內容，並去重
Parameters:
words_file - 文件路徑
Returns:
words_set - 讀取的內容的set集合
Author:
Jack Cui
Blog:
http://blog.csdn.net/c406495762
Modify:
2017-08-22
"""
def MakeWordsSet(words_file):
words_set = set() #創建set集合
with open(words_file, 'r', encoding = 'utf-8') as f: #打開文件
for line in f.readlines(): #一行一行讀取
word = line.strip() #去回車
if len(word) > 0: #有文本，則添加到words_set中
words_set.add(word)
return words_set #返回處理結果
"""
函數說明:根據feature_words將文本向量化
Parameters:
train_data_list - 訓練集tuple
test_data_list - 測試集
feature_words - 特徵集
Returns:
train_feature_list - 訓練集向量化列表
test_feature_list - 測試集向量化列表
Author:
Jack Cui
Blog:
http://blog.csdn.net/c406495762
Modify:
2017-08-22
"""
def TextFeatures(train_data_list, test_data_list, feature_words):
def text_features(text, feature_words): #出現在特徵集中，則置1
text_words = set(text)
features = [1 if word in text_words else 0 for word in feature_words]
return features
train_feature_list = [text_features(text, feature_words) for text in train_data_list]
test_feature_list = [text_features(text, feature_words) for text in test_data_list]
return train_feature_list, test_feature_list #返回結果
"""
函數說明:文本特徵選取
Parameters:
all_words_list - 訓練集所有文本列表
deleteN - 刪除詞頻最高的deleteN個詞
stopwords_set - 指定的結束語
Returns:
feature_words - 特徵集
Author:
Jack Cui
Blog:
http://blog.csdn.net/c406495762
Modify:
2017-08-22
"""
def words_dict(all_words_list, deleteN, stopwords_set = set()):
feature_words = [] #特徵列表
n = 1
for t in range(deleteN, len(all_words_list), 1):
if n > 1000: #feature_words的維度爲1000
break
#如果這個詞不是數字，並且不是指定的結束語，並且單詞長度大於1小於5，那麼這個詞就可以作爲特徵詞
if not all_words_list[t].isdigit() and all_words_list[t] not in stopwords_set and 1 < len(all_words_list[t]) < 5:
feature_words.append(all_words_list[t])
n += 1
return feature_words
"""
函數說明:新聞分類器
Parameters:
train_feature_list - 訓練集向量化的特徵文本
test_feature_list - 測試集向量化的特徵文本
train_class_list - 訓練集分類標籤
test_class_list - 測試集分類標籤
Returns:
test_accuracy - 分類器精度
Author:
Jack Cui
Blog:
http://blog.csdn.net/c406495762
Modify:
2017-08-22
"""
def TextClassifier(train_feature_list, test_feature_list, train_class_list, test_class_list):
classifier = MultinomialNB().fit(train_feature_list, train_class_list)
test_accuracy = classifier.score(test_feature_list, test_class_list)
return test_accuracy
if __name__ == '__main__':
#文本預處理
folder_path = './SogouC/Sample' #訓練集存放地址
all_words_list, train_data_list, test_data_list, train_class_list, test_class_list = TextProcessing(folder_path, test_size=0.2)
# 生成stopwords_set 目的是去除一些數字 一些特點的詞語
stopwords_file = './stopwords_cn.txt'
stopwords_set = MakeWordsSet(stopwords_file)
test_accuracy_list = []
deleteNs = range(0, 1000, 20) #0 20 40 60 ... 980
for deleteN in deleteNs:
feature_words = words_dict(all_words_list, deleteN, stopwords_set)#詞向量列表
train_feature_list, test_feature_list = TextFeatures(train_data_list, test_data_list, feature_words)
test_accuracy = TextClassifier(train_feature_list, test_feature_list, train_class_list, test_class_list)
test_accuracy_list.append(test_accuracy)
# ave = lambda c: sum(c) / len(c)
# print(ave(test_accuracy_list))
plt.figure()
plt.plot(deleteNs, test_accuracy_list)
plt.title('Relationship of deleteNs and test_accuracy')
plt.xlabel('deleteNs')
plt.ylabel('test_accuracy')
plt.show()
三、個人廣告獲取區域傾向
加載RSS源
下載解析RSS源的包：https://github.com/kurtmckee/feedparser（Universal Feed Parser是Python中最常用的RSS程序庫
）
from numpy import *
import numpy as np
import bayes as ba
#從RSS源獲取文檔數據 計算分類的錯誤率
testRSS()
1）獲取RSS源
def testRSS():
import feedparser
ny=feedparser.parse('http://www.nasa.gov/rss/dyn/image_of_the_day.rss')#NASA
sf=feedparser.parse('http://sports.yahoo.com/nba/teams/hou/rss.xml')#Yahoo
vocabList,pSF,pNY = localWords(ny,sf)
2）根據RSS源進行文檔的解析---轉換爲剔除停用後的不重複詞列表--轉換爲詞向量---劃分數據集---訓練獲得先驗概率、條件概率和詞列表 --測試計算分類錯誤率
"""
函數說明:根據RSS源進行文檔的解析---轉換爲剔除停用後的不重複詞列表--轉換爲詞向量---劃分數據集---訓練獲得先驗概率、條件概率和詞列表 --測試計算分類錯誤率
Parameters:
feed1 - RSS源1
feed0 - RSS源2
Returns:
vocabList -不重複的詞列表(去掉停用詞)
p0V - 類0的條件概率
p1V - 類1的條件概率
Author:
heda3
Blog:
https://blog.csdn.net/heda3
Modify:
2019-09-30
"""
def localWords(feed1,feed0):
import feedparser
#引入RSS源，並提取相應的詞彙-轉換爲詞列表
docList=[]; classList = []; fullText =[]
print('feed1 entries length: ', len(feed1['entries']), '\nfeed0 entries length: ', len(feed0['entries']))
minLen = min(len(feed1['entries']),len(feed0['entries']))
print('\nmin Length: ', minLen)
for i in range(minLen):
wordList = textParse(feed1['entries'][i]['summary'])#英文分詞
print('\nfeed1\'s entries[',i,']\'s summary - ','parse text:\n',wordList)
docList.append(wordList)
fullText.extend(wordList)
classList.append(1) #NY is class 1
wordList = textParse(feed0['entries'][i]['summary'])
print('\nfeed0\'s entries[',i,']\'s summary - ','parse text:\n',wordList)
docList.append(wordList)
fullText.extend(wordList)#展開
classList.append(0)
#創建不重複詞的列表
vocabList = createVocabList(docList)#create vocabulary
print('\nVocabList is ',vocabList)
#調用停詞列表，移除不重複詞列表中包含停詞列表中的元素
print('\nRemove Stop Word:')
stopWordList = stopWords()
for stopWord in stopWordList:
if stopWord in vocabList:
vocabList.remove(stopWord)#去掉停止詞後的詞列表
print('Removed: ',stopWord)
#計算最高頻次的詞--從不重複的詞列表中刪除掉高頻詞 這個和前面的停用詞表的重複了
#vocabList:不重複的詞向量 fullText：所有的詞展開
top30Words = ba.calcMostFreq(vocabList,fullText) #remove top 30 words
print('\nTop 30 words: ', top30Words)
for pairW in top30Words:
if pairW[0] in vocabList:
vocabList.remove(pairW[0])
print('\nRemoved: ',pairW[0])
#訓練集和測試集劃分 並將輸入詞列表轉換爲詞向量
trainingSet =list(range(2*minLen));#在python3中range返回的是一個range對象，故轉換爲列表形式
testSet=[] #create test set
print('\n\nBegin to create a test set: \ntrainingSet:',trainingSet,'\ntestSet',testSet)
for i in range(5):
randIndex = int(random.uniform(0,len(trainingSet)))#隨機選取在0-n之間的實數
#從trainingSet中隨機找出索引值，並將它放置在測試集裏，同時刪除測試集的值
testSet.append(trainingSet[randIndex])
del(trainingSet[randIndex])
print('random select 5 sets as the testSet:\ntrainingSet:',trainingSet,'\ntestSet',testSet)
trainMat=[]; trainClasses = []
for docIndex in trainingSet:#train the classifier (get probs) trainNB0
#詞列表轉換爲詞向量
trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
trainClasses.append(classList[docIndex])
print('\ntrainMat length:',len(trainMat))
print('\ntrainClasses',trainClasses)
print('\n\ntrainNB0:')
#模型訓練
p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))
#print '\np0V:',p0V,'\np1V',p1V,'\npSpam',pSpam
##返回 條件概率p0V p1V，以及標記爲1類的先驗概率
#模型測試
errorCount = 0
for docIndex in testSet: #classify the remaining items
#詞列表轉換爲詞向量
wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
classifiedClass = classifyNB(array(wordVector),p0V,p1V,pSpam)
originalClass = classList[docIndex]
result = classifiedClass != originalClass
if result:
errorCount += 1
print('\n',docList[docIndex],'\nis classified as: ',classifiedClass,', while the original class is: ',originalClass,'. --',not result)
print('\nthe error rate is: ',float(errorCount)/len(testSet))
return vocabList,p0V,p1V
def createVocabList(dataSet):
vocabSet = set([]) #create empty set
for document in dataSet:
vocabSet = vocabSet | set(document) #union of the two sets
return list(vocabSet)
def bagOfWords2Vec(vocabList, inputSet):
returnVec = [0]*len(vocabList)
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] += 1
else: print("the word: %s is not in my Vocabulary!" % word)
return returnVec
"""
函數說明:詞袋模型，依據輸入文檔是否在詞列表中，相應的值累加次數
Parameters:
vocabList - 所有的詞列表（所有文檔的並集）
inputSet - 輸入文檔（詞列表）
Returns:
returnVec - 輸入文檔對應的詞向量（詞頻）
Author:
heda3
Blog:
https://blog.csdn.net/heda3
Modify:
2019-10-01
"""
def bagOfWords2VecMN(vocabList, inputSet):
returnVec = [0]*len(vocabList)
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] += 1
return returnVec
訓練函數：
#定義樸素貝葉斯分類器訓練函數
"""
函數說明:樸素貝葉斯分類器訓練函數
trainMatrix--訓練文檔矩陣，即setOfWords2Vec返回的returnVec構成的矩陣；trainCategory--訓練類別標籤向量
p1Vect--標記爲1的類條件概率數組；p0Vect--標記爲0的類條件概率數組；pAbusive是標記爲1類的先驗概率
"""
def trainNB(trainMatrix, trainCategory):
#計算訓練的文檔數目
numTrainDocs = len(trainMatrix)
#計算每篇文檔的詞條數 相當於特徵數
numWords = len(trainMatrix[0])
#標記爲1類的先驗概率
pAbusive = sum(trainCategory)/float(numTrainDocs)
"""
創建numpy數組初始化爲1，拉普拉斯平滑。
創建numpy.zeros數組,詞條出現數初始化爲0。分母初始化爲2
"""
p0Num = np.ones(numWords); p1Num = np.ones(numWords)
p0Denom = 2.0; p1Denom = 2.0
#計算類條件概率
for i in range(numTrainDocs):
if trainCategory[i] == 1:
p1Num += trainMatrix[i]#矩陣相加
p1Denom += 1#表示類1文檔個數
# p1Denom += sum(trainMatrix[i])#有誤
else:
p0Num += trainMatrix[i]
p0Denom += 1#表示類0文檔個數
#p0Denom += sum(trainMatrix[i])#有誤
#由於大部分因子都非常小，防止數值下溢得不到正確答案。於是加log計算，可以使得答案不會過小。
p1Vect = np.log(p1Num/p1Denom) #change to np.log() 類1 爲1 的條件概率
p0Vect = np.log(p0Num/p0Denom) #change to np.log() 類0 爲0 的條件概率 和後面的計算有一些聯繫
return p0Vect, p1Vect, pAbusive
測試函數：
"""
函數說明:樸素貝葉斯分類器預測函數
Parameters:
vec2Classify - 待分類詞向量
p0Vec - 類0的條件概率
p1Vec - 類1的條件概率
pClass1 - 先驗概率）
Returns:
returnVec - 輸入文檔對應的詞向量（詞頻）
Author:
heda3
""" #有誤
# =============================================================================
# def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
# p1 = sum(vec2Classify * p1Vec) + log(pClass1) #element-wise mult
# p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
# if p1 > p0:
# return 1
# else:
# return 0
# =============================================================================
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
"""
1.計算待分類詞條數組爲1類的概率
"""
#尋找vec2Classify測試數組中，元素爲0時對應的索引值
index = np.where(vec2Classify==0)#返回一串索引值，相等爲true 否則爲false 只返回false索引
#遍歷元素爲0時的索引值，並從p1Vec--1類的條件概率數組中取出對應索引的數值，並存儲成列表的形式（p1Vec0=[]）
p1Vec0=[]
for i in index:#index爲tuple 取i=0 的tuple 只執行一次
for m in i:
p1Vec0.append(p1Vec[m])
#所有P(vec2Classify=0|1)組成的列表
x0=np.ones(len(p1Vec0))-p1Vec0##？和訓練過程得到的p1Vec有關，p1Vec它表示類1下爲1的條件概率
#尋找vec2Classify測試數組中，元素爲1時對應的索引值
index1= np.where(vec2Classify==1)
#遍歷元素爲1時的索引值，並從p1Vec--1類的條件概率數組中取出對應索引的數值，並存儲成列表的形式（p1Vec1=[]）
p1Vec1=[]
for i in index1:
for m in i:
p1Vec1.append(p1Vec[m])
#所有P(vec2Classify=1|1)組成的列表
x1=p1Vec1
##對應元素相乘。logA * B = logA + logB，所以這裏加上log(pClass1)
p1 = sum(x0)+sum(x1) + np.log(pClass1)
"""
2.計算待分類詞條數組爲0類的概率
"""
#尋找vec2Classify測試數組中，元素爲0時對應的索引值
index2 = np.where(vec2Classify==0)
#遍歷元素爲0時的索引值，並從p0Vec--0類的條件概率數組中取出對應索引的數值，並存儲成列表的形式（p0Vec0=[]）
p0Vec0=[]
for i in index2:
for m in i:
p0Vec0.append(p0Vec[m])
#所有P(vec2Classify=0|0)組成的列表
w0=np.ones(len(p0Vec0))-p0Vec0
#尋找vec2Classify測試數組中，元素爲1時對應的索引值
index3= np.where(vec2Classify==1)
#遍歷元素爲1時的索引值，並從p0Vec--0類的條件概率數組中取出對應索引的數值，並存儲成列表的形式（p0Vec1=[]）
p0Vec1=[]
for i in index3:
for m in i:
p0Vec1.append(p0Vec[m])
#所有P(vec2Classify=1|0)組成的列表
w1=p0Vec1
##對應元素相乘。logA * B = logA + logB，所以這裏加上log(pClass1)
p0 = sum(w0)+sum(w1) + np.log(1.0 - pClass1)
if p1 > p0:
return 1
else:
return 0
超過某個閾值的區域詞分佈：
def getTopWords(ny,sf):
import operator
#獲取訓練數據的條件概率 和精選的詞列表
vocabList,p0V,p1V=localWords(ny,sf)
topNY=[]; topSF=[]
#返回大於某個閾值（注意概率是取對數後的）的詞
for i in range(len(p0V)):
if p0V[i] > -6.0 : topSF.append((vocabList[i],p0V[i]))#獲得詞以及對應的先驗概率（類爲0，此詞出現的概率）
if p1V[i] > -6.0 : topNY.append((vocabList[i],p1V[i]))
#輸出類0下先驗概率超過某個閾值的詞
sortedSF = sorted(topSF, key=lambda pair: pair[1], reverse=True)
print("SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**")
for item in sortedSF:
print(item[0])
#輸出類1下先驗概率超過某個閾值的詞
sortedNY = sorted(topNY, key=lambda pair: pair[1], reverse=True)
print("NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**")
for item in sortedNY:
print(item[0])
詳情見Github：https://github.com/codehgq/ML-note/tree/master/Regional%20Tendency
歡迎Star！關注
參考資料
【1】機器學習實戰
【2】深度之眼