国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

機(jī)器學(xué)習(xí) | 樸素貝葉斯

yuxue / 2928人閱讀

摘要：由于近期學(xué)業(yè)繁重，所以我就不說廢話了，直接上代碼樸素貝葉斯進(jìn)行文本詞匯分類詞表到向量的轉(zhuǎn)換創(chuàng)建實(shí)驗(yàn)樣本，返回的是進(jìn)行詞條切分后的文檔集合，還有一個類別標(biāo)簽侮辱性的非侮辱性的代表侮辱性文字代表正常言論創(chuàng)建一個包含在所有文檔中出現(xiàn)的不重復(fù)的詞的

由于近期學(xué)業(yè)繁重QAQ，所以我就不說廢話了，直接上代碼~

樸素貝葉斯進(jìn)行文本詞匯分類 
from numpy import *

#詞表到向量的轉(zhuǎn)換
#創(chuàng)建實(shí)驗(yàn)樣本，返回的是進(jìn)行詞條切分后的文檔集合，
#還有一個類別標(biāo)簽——侮辱性的or非侮辱性的
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"]]
    #1 代表侮辱性文字   0代表正常言論
    classVec = [0,1,0,1,0,1]
    return postingList,classVec
    
#創(chuàng)建一個包含在所有文檔中出現(xiàn)的不重復(fù)的詞的列表    
def createVocabList(dataSet):
    vocabSet=set([])
    #document:["my", "dog", "has", "flea", "problems", "help", "please"]
    for document in dataSet:
        #求并集
        vocabSet=vocabSet|set(document)
        #print(vocabSet)
    return list(vocabSet)
    
#參數(shù)為詞匯表以及某個文檔，輸出的是文檔向量
#輸出的向量的每一個元素為1或0，表示詞匯表中
#的單詞在輸入文檔中是否出現(xiàn)
def setOfWords2Vec(vocabList,inputSet):
    #創(chuàng)建一個所含元素都為0的向量
    returnVec=[0]*len(vocabList)
    #遍歷文檔中的所有單詞，如果出現(xiàn)了詞匯表中的單詞，
    #則將輸出文檔的對應(yīng)值設(shè)為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
    

    

#輸入的參數(shù)：文檔矩陣trainMatrix
#由每篇文檔類別標(biāo)簽構(gòu)成的向量trainCategory
#樸素貝葉斯分類器訓(xùn)練函數(shù)
#trainMatrix:每個詞向量中的詞，在詞匯表中出現(xiàn)的就是1
#trainMatrix:[[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], 
#[0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0],
#[1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
#[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0], 
#[0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1], 
#[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0]]
#該詞向量中帶有侮辱性的詞的就是1
#trainCategory:[0, 1, 0, 1, 0, 1]
def trainNBO(trainMatrix,trainCategory):
    #一共有幾個詞向量
    numTrainDocs=len(trainMatrix)
    #詞匯表的長度
    numWords=len(trainMatrix[0])
    #3/6 表示6個詞向量中，3個帶侮辱詞
    pAbusive=sum(trainCategory)/float(numTrainDocs)
    #初始化概率
    p0Num=ones(numWords)
    p1Num=ones(numWords)
    p0Denom=2.0;p1Denom=2.0
    #遍歷訓(xùn)練集trainMatrix中的所有文檔
    #一旦某個詞在某一文檔中出現(xiàn)
    #該文檔的總詞數(shù)加1
    #兩個類別都要進(jìn)行同樣的處理
    #i：012345
    for i in range(numTrainDocs):
        #該詞向量帶侮辱
        if trainCategory[i]==1:
            #向量相加
            p1Num+=trainMatrix[i]
            p1Denom+=sum(trainMatrix[i])
        else:
            p0Num+=trainMatrix[i]
            p0Denom+=sum(trainMatrix[i])
    #每個元素除以該類別的總詞數(shù)
    p1Vect=log(p1Num/p1Denom)
    p0Vect=log(p0Num/p0Denom)
    return p0Vect,p1Vect,pAbusive
            
    
    
    
#樸素貝葉斯分類函數(shù)
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    #元素相乘
    p1=sum(vec2Classify*p1Vec)+log(pClass1)
    p0=sum(vec2Classify*p0Vec)+log(1.0-pClass1)
    if p1>p0:
        return 1
    else:
        return 0    
    
    
def testingNB():
    listOPosts,listClasses=loadDataSet()
    myVocabList=createVocabList(listOPosts)
    trainMat=[]
    #使用詞向量填充trainMat列表
    for postinDoc in listOPosts:
        Vec01=setOfWords2Vec(myVocabList,postinDoc)
        trainMat.append(Vec01)    
    p0V,p1V,pAb=trainNBO(trainMat,listClasses)
    #測試集
    testEntry=["love","my","dalmation"]
    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))
    #print(thisDoc)
    print(testEntry," classified as: ",classifyNB(thisDoc,p0V,p1V,pAb))
    testEntry=["stupid","garbage"]
    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))
    #print(thisDoc)
    print(testEntry," classified as: ",classifyNB(thisDoc,p0V,p1V,pAb))

    
def main():
    testingNB()
    #創(chuàng)建數(shù)據(jù)    
    #listOPosts,listClasses=loadDataSet()
    #print(listOPosts)
    #構(gòu)建一個包含所有詞的列表
    #myVocabList=createVocabList(listOPosts)
    #print(myVocabList)
    #returnVec=setOfWords2Vec(myVocabList,listOPosts[0])
    #print(returnVec)
    #trainMat=[]
    #使用詞向量填充trainMat列表
    #for postinDoc in listOPosts:
        #傳入詞匯表 以及每一行詞向量
        #返回的是一個與詞匯表同樣size的向量
        #1表示這個詞在詞向量中出現(xiàn)過
        #Vec01=setOfWords2Vec(myVocabList,postinDoc)
        #print(Vec01)
        #將01list填充trainMat
        #trainMat.append(Vec01)
    #print(trainMat)
    #print(listClasses)
    #p0V,p1V,pAB=trainNBO(trainMat,listClasses)
    #print(p0V)
    #print(p1V)
    #print(pAB)
    
if __name__=="__main__":
    main()



樸素貝葉斯分類垃圾郵件 
#文件解析及完整的垃圾郵件測試函數(shù)
#返回傳入的bigString中的單詞
#接收一大個字符串并將其解析為字符串列表
#去掉少于兩個字符的字符串，并將所有的字符串轉(zhuǎn)換成小寫
def textParse(bigString):
    listOfTokens=re.split(r"W*",bigString)
    return [tok.lower() for tok in listOfTokens if len(tok)>2]


#對貝葉斯垃圾郵件分類器進(jìn)行自動化處理
#導(dǎo)入spam與ham下的文本文件，并將它們轉(zhuǎn)換為詞列表
#存留交叉驗(yàn)證：隨機(jī)選擇數(shù)據(jù)中的一部分作為訓(xùn)練集，
#而剩余的部分作為測試集
def spamTest():
    docList=[]
    classList=[]
    fullText=[]
    for i in range(1,26):
        wordList=textParse(open("./MLiA_SourceCode/machinelearninginaction/Ch04/email/spam/%d.txt" % i).read())
        #每篇郵件中組成的list
        #[[...],[...],[...]...]
        docList.append(wordList)
        #全部郵件組成的大list
        #[...]
        fullText.extend(wordList)
        #1010組成的list
        classList.append(1)
        wordList=textParse(open("./MLiA_SourceCode/machinelearninginaction/Ch04/email/ham/%d.txt" % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    #print(docList)
    #print(fullText)
    #print(classList)
    #創(chuàng)建詞匯表——所有的單詞都只出現(xiàn)一次
    vocabList=createVocabList(docList)
    #print(vocabList)
    #[1,2,...49]
    trainingSet=list(range(50))
    #print(trainingSet)
    testSet=[]
    #創(chuàng)建測試集
    #隨機(jī)選取10個文件作為測試集
    for i in range(10):
        #在1-49中取隨機(jī)數(shù)
        randIndex=int(random.uniform(0,len(trainingSet)))
        #print(randIndex)
        testSet.append(trainingSet[randIndex])
        #將選出來的數(shù)從訓(xùn)練集中delete
        del(trainingSet[randIndex])
    #[2, 6, 15, 31, 23, 12, 3, 17, 37, 47]
    #print(testSet)    
    trainMat=[]
    trainClasses=[]
    #進(jìn)行訓(xùn)練
    for docIndex in trainingSet:
        #返回一個和詞匯表size一樣的list，為1的表示這個詞匯在詞匯表中出現(xiàn)過
        trainMat.append(setOfWords2Vec(vocabList,docList[docIndex]))
        trainClasses.append(classList[docIndex])
    #print(trainMat)
    #print(trainClasses)
    #計(jì)算分類所需的概率
    p0V,p1V,pSpam=trainNBO(array(trainMat),array(trainClasses))
    errorCount=0
    #進(jìn)行測試
    #遍歷測試集，進(jìn)行分類
    for docIndex in testSet:
        wordVector=setOfWords2Vec(vocabList,docList[docIndex])
        #對測試集分類的準(zhǔn)確性進(jìn)行判斷
        if classifyNB(array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
            errorCount+=1
            print("classification error",docList[docIndex])
    #求出平均錯誤率
    print("the error rate is: ",float(errorCount)/len(testSet))



使用樸素貝葉斯分類器從個人廣告中獲取區(qū)域傾向 
#使用樸素貝葉斯分類器從個人廣告中獲取區(qū)域傾向
#rss源：https://www.nasa.gov/rss/dyn/image_of_the_day.rss
#http://www.ftchinese.com/rss/news
#RSS源分類器及高頻詞去除函數(shù)
#遍歷詞匯表中的每個詞 并統(tǒng)計(jì)他在文本中出現(xiàn)的次數(shù)
#根據(jù)出現(xiàn)次數(shù)從高到低對詞典進(jìn)行排序，最后返回排序最高的100個詞
def calcMostFreq(vocabList,fullText):
    freqDict={}
    for token in vocabList:
        freqDict[token]=fullText.count(token)
    #得到詞匯及其出現(xiàn)的次數(shù)
    #{"hours": 1, "airbus": 1, "柯特妮": 1, ... }
    #print(freqDict)
    sortedFreq=sorted(freqDict.items(),key=operator.itemgetter(1),reverse=True)
    #進(jìn)行排序
    #[("the", 32), ("http", 22), ("ftimg", 20), ... ]
    #print(sortedFreq)
    return sortedFreq[:30]
    
    
#使用兩個rss源作為參數(shù)    
def localWords(feed1,feed0):
    docList=[]
    classList=[]
    fullText=[]
    minLen=min(len(feed1["entries"]),len(feed0["entries"]))
    for i in range(minLen):
        #將summary的內(nèi)容拆分成一個個單詞
        wordList=textParse(feed1["entries"][i]["summary"])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        wordList=textParse(feed0["entries"][i]["summary"])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    #創(chuàng)建詞匯表
    vocabList=createVocabList(docList)
    
    ##增加下面三行代碼會導(dǎo)致錯誤率升高
    
    #得到詞匯表中出現(xiàn)頻率最高的top30
    top30Words=calcMostFreq(vocabList,fullText)
    #將高頻詞匯去除
    for pairW in top30Words:
        if pairW[0] in vocabList: vocabList.remove(pairW[0])
    
    ##
    
    #創(chuàng)建訓(xùn)練集與測試集
    trainingSet=list(range(2*minLen))
    testSet=[]
    for i in range(20):
        randIndex=int(random.uniform(0,len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del(trainingSet[randIndex])
    trainMat=[]
    trainClasses=[]
    
    #開始訓(xùn)練
    for docIndex in trainingSet:
        trainMat.append(bagOfWords2VecMN(vocabList,docList[docIndex]))
        trainClasses.append(classList[docIndex])
    #print(trainMat)
    
    p0V,p1V,pSpam=trainNBO(array(trainMat),array(trainClasses))
    errorCount=0
    for docIndex in testSet:
        wordVector=bagOfWords2VecMN(vocabList,docList[docIndex])
        if classifyNB(array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
            errorCount+=1
    print("the error rate is: ",float(errorCount)/len(testSet))
    return vocabList,p0V,p1V
    
    
#顯示地域相關(guān)的用詞
def getTopWords(ny,sf):
    import operator
    vocabList,p0V,p1V=localWords(ny,sf)
    topNY=[]
    topSF=[]
    for i in range(len(p0V)):
        #print(p0V[i])
        if p0V[i]>-5.0:
            topSF.append((vocabList[i],p0V[i]))
        if p1V[i]>-5.0:
            topNY.append((vocabList[i],p1V[i]))
    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")
    for item in sortedSF:
        print(item[0])
    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")
    for item in sortedNY:
        print(item[0])



完整代碼 
from numpy import *
import feedparser
import re
import operator

#詞表到向量的轉(zhuǎn)換
#創(chuàng)建實(shí)驗(yàn)樣本，返回的是進(jìn)行詞條切分后的文檔集合，
#還有一個類別標(biāo)簽——侮辱性的or非侮辱性的
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"]]
    #1 代表侮辱性文字   0代表正常言論
    classVec = [0,1,0,1,0,1]
    return postingList,classVec
    
#創(chuàng)建一個包含在所有文檔中出現(xiàn)的不重復(fù)的詞的列表    
def createVocabList(dataSet):
    vocabSet=set([])
    #document:["my", "dog", "has", "flea", "problems", "help", "please"]
    for document in dataSet:
        #求并集
        vocabSet=vocabSet|set(document)
        #print(vocabSet)
    return list(vocabSet)
    
#參數(shù)為詞匯表以及某個文檔，輸出的是文檔向量
#輸出的向量的每一個元素為1或0，表示詞匯表中
#的單詞在輸入文檔中是否出現(xiàn)
def setOfWords2Vec(vocabList,inputSet):
    #創(chuàng)建一個所含元素都為0的向量
    returnVec=[0]*len(vocabList)
    #遍歷文檔中的所有單詞，如果出現(xiàn)了詞匯表中的單詞，
    #則將輸出文檔的對應(yīng)值設(shè)為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
    
    
#樸素貝葉斯詞袋模型
#與上面的setOfWords2Vec功能基本相同，
#只是每遇到一個單詞就會增加詞向量中對應(yīng)的值
#而不是簡單地設(shè)置1
def bagOfWords2VecMN(vocabList,inputSet):
    returnVec =[0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)]+=1
    return returnVec
    

    

#輸入的參數(shù)：文檔矩陣trainMatrix
#由每篇文檔類別標(biāo)簽構(gòu)成的向量trainCategory
#樸素貝葉斯分類器訓(xùn)練函數(shù)
#trainMatrix:每個詞向量中的詞，在詞匯表中出現(xiàn)的就是1
#trainMatrix:[[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], 
#[0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0],
#[1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
#[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0], 
#[0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1], 
#[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0]]
#該詞向量中帶有侮辱性的詞的就是1
#trainCategory:[0, 1, 0, 1, 0, 1]
def trainNBO(trainMatrix,trainCategory):
    #一共有幾個詞向量
    numTrainDocs=len(trainMatrix)
    #詞匯表的長度
    numWords=len(trainMatrix[0])
    #3/6 表示6個詞向量中，3個帶侮辱詞
    pAbusive=sum(trainCategory)/float(numTrainDocs)
    #初始化概率
    p0Num=ones(numWords)
    p1Num=ones(numWords)
    p0Denom=2.0;p1Denom=2.0
    #遍歷訓(xùn)練集trainMatrix中的所有文檔
    #一旦某個詞在某一文檔中出現(xiàn)
    #該文檔的總詞數(shù)加1
    #兩個類別都要進(jìn)行同樣的處理
    #i：012345
    for i in range(numTrainDocs):
        #該詞向量帶侮辱
        if trainCategory[i]==1:
            #向量相加
            p1Num+=trainMatrix[i]
            p1Denom+=sum(trainMatrix[i])
        else:
            p0Num+=trainMatrix[i]
            p0Denom+=sum(trainMatrix[i])
    #每個元素除以該類別的總詞數(shù)
    p1Vect=log(p1Num/p1Denom)
    p0Vect=log(p0Num/p0Denom)
    return p0Vect,p1Vect,pAbusive
            
    
    
    
#樸素貝葉斯分類函數(shù)
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    #元素相乘
    p1=sum(vec2Classify*p1Vec)+log(pClass1)
    p0=sum(vec2Classify*p0Vec)+log(1.0-pClass1)
    if p1>p0:
        return 1
    else:
        return 0    
    
    
def testingNB():
    listOPosts,listClasses=loadDataSet()
    myVocabList=createVocabList(listOPosts)
    trainMat=[]
    #使用詞向量填充trainMat列表
    for postinDoc in listOPosts:
        Vec01=setOfWords2Vec(myVocabList,postinDoc)
        trainMat.append(Vec01)    
    p0V,p1V,pAb=trainNBO(trainMat,listClasses)
    #測試集
    testEntry=["love","my","dalmation"]
    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))
    #print(thisDoc)
    print(testEntry," classified as: ",classifyNB(thisDoc,p0V,p1V,pAb))
    testEntry=["stupid","garbage"]
    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))
    #print(thisDoc)
    print(testEntry," classified as: ",classifyNB(thisDoc,p0V,p1V,pAb))

    
#文件解析及完整的垃圾郵件測試函數(shù)
#返回傳入的bigString中的單詞
#接收一大個字符串并將其解析為字符串列表
#去掉少于兩個字符的字符串，并將所有的字符串轉(zhuǎn)換成小寫
def textParse(bigString):
    listOfTokens=re.split(r"W*",bigString)
    return [tok.lower() for tok in listOfTokens if len(tok)>2]


#對貝葉斯垃圾郵件分類器進(jìn)行自動化處理
#導(dǎo)入spam與ham下的文本文件，并將它們轉(zhuǎn)換為詞列表
#存留交叉驗(yàn)證：隨機(jī)選擇數(shù)據(jù)中的一部分作為訓(xùn)練集，
#而剩余的部分作為測試集
def spamTest():
    docList=[]
    classList=[]
    fullText=[]
    for i in range(1,26):
        wordList=textParse(open("./MLiA_SourceCode/machinelearninginaction/Ch04/email/spam/%d.txt" % i).read())
        #每篇郵件中組成的list
        #[[...],[...],[...]...]
        docList.append(wordList)
        #全部郵件組成的大list
        #[...]
        fullText.extend(wordList)
        #1010組成的list
        classList.append(1)
        wordList=textParse(open("./MLiA_SourceCode/machinelearninginaction/Ch04/email/ham/%d.txt" % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    #print(docList)
    #print(fullText)
    #print(classList)
    #創(chuàng)建詞匯表——所有的單詞都只出現(xiàn)一次
    vocabList=createVocabList(docList)
    #print(vocabList)
    #[1,2,...49]
    trainingSet=list(range(50))
    #print(trainingSet)
    testSet=[]
    #創(chuàng)建測試集
    #隨機(jī)選取10個文件作為測試集
    for i in range(10):
        #在1-49中取隨機(jī)數(shù)
        randIndex=int(random.uniform(0,len(trainingSet)))
        #print(randIndex)
        testSet.append(trainingSet[randIndex])
        #將選出來的數(shù)從訓(xùn)練集中delete
        del(trainingSet[randIndex])
    #[2, 6, 15, 31, 23, 12, 3, 17, 37, 47]
    #print(testSet)    
    trainMat=[]
    trainClasses=[]
    #進(jìn)行訓(xùn)練
    for docIndex in trainingSet:
        #返回一個和詞匯表size一樣的list，為1的表示這個詞匯在詞匯表中出現(xiàn)過
        trainMat.append(setOfWords2Vec(vocabList,docList[docIndex]))
        trainClasses.append(classList[docIndex])
    #print(trainMat)
    #print(trainClasses)
    #計(jì)算分類所需的概率
    p0V,p1V,pSpam=trainNBO(array(trainMat),array(trainClasses))
    errorCount=0
    #進(jìn)行測試
    #遍歷測試集，進(jìn)行分類
    for docIndex in testSet:
        wordVector=setOfWords2Vec(vocabList,docList[docIndex])
        #對測試集分類的準(zhǔn)確性進(jìn)行判斷
        if classifyNB(array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
            errorCount+=1
            print("classification error",docList[docIndex])
    #求出平均錯誤率
    print("the error rate is: ",float(errorCount)/len(testSet))
        
        
    
    
#使用樸素貝葉斯分類器從個人廣告中獲取區(qū)域傾向
#rss源：https://www.nasa.gov/rss/dyn/image_of_the_day.rss
#http://www.ftchinese.com/rss/news
#RSS源分類器及高頻詞去除函數(shù)
#遍歷詞匯表中的每個詞 并統(tǒng)計(jì)他在文本中出現(xiàn)的次數(shù)
#根據(jù)出現(xiàn)次數(shù)從高到低對詞典進(jìn)行排序，最后返回排序最高的100個詞
def calcMostFreq(vocabList,fullText):
    freqDict={}
    for token in vocabList:
        freqDict[token]=fullText.count(token)
    #得到詞匯及其出現(xiàn)的次數(shù)
    #{"hours": 1, "airbus": 1, "柯特妮": 1, ... }
    #print(freqDict)
    sortedFreq=sorted(freqDict.items(),key=operator.itemgetter(1),reverse=True)
    #進(jìn)行排序
    #[("the", 32), ("http", 22), ("ftimg", 20), ... ]
    #print(sortedFreq)
    return sortedFreq[:30]
    
    
#使用兩個rss源作為參數(shù)    
def localWords(feed1,feed0):
    docList=[]
    classList=[]
    fullText=[]
    minLen=min(len(feed1["entries"]),len(feed0["entries"]))
    for i in range(minLen):
        #將summary的內(nèi)容拆分成一個個單詞
        wordList=textParse(feed1["entries"][i]["summary"])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        wordList=textParse(feed0["entries"][i]["summary"])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    #創(chuàng)建詞匯表
    vocabList=createVocabList(docList)
    
    ##增加下面三行代碼會導(dǎo)致錯誤率升高
    
    #得到詞匯表中出現(xiàn)頻率最高的top30
    top30Words=calcMostFreq(vocabList,fullText)
    #將高頻詞匯去除
    for pairW in top30Words:
        if pairW[0] in vocabList: vocabList.remove(pairW[0])
    
    ##
    
    #創(chuàng)建訓(xùn)練集與測試集
    trainingSet=list(range(2*minLen))
    testSet=[]
    for i in range(20):
        randIndex=int(random.uniform(0,len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del(trainingSet[randIndex])
    trainMat=[]
    trainClasses=[]
    
    #開始訓(xùn)練
    for docIndex in trainingSet:
        trainMat.append(bagOfWords2VecMN(vocabList,docList[docIndex]))
        trainClasses.append(classList[docIndex])
    #print(trainMat)
    
    p0V,p1V,pSpam=trainNBO(array(trainMat),array(trainClasses))
    errorCount=0
    for docIndex in testSet:
        wordVector=bagOfWords2VecMN(vocabList,docList[docIndex])
        if classifyNB(array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
            errorCount+=1
    print("the error rate is: ",float(errorCount)/len(testSet))
    return vocabList,p0V,p1V
    
    
#顯示地域相關(guān)的用詞
def getTopWords(ny,sf):
    import operator
    vocabList,p0V,p1V=localWords(ny,sf)
    topNY=[]
    topSF=[]
    for i in range(len(p0V)):
        #print(p0V[i])
        if p0V[i]>-5.0:
            topSF.append((vocabList[i],p0V[i]))
        if p1V[i]>-5.0:
            topNY.append((vocabList[i],p1V[i]))
    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")
    for item in sortedSF:
        print(item[0])
    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")
    for item in sortedNY:
        print(item[0])
        
    
    
#rss源：https://www.nasa.gov/rss/dyn/image_of_the_day.rss
#http://www.ftchinese.com/rss/news
def main():
    ny=feedparser.parse("https://www.nasa.gov/rss/dyn/image_of_the_day.rss")
    sf=feedparser.parse("http://www.ftchinese.com/rss/news")
    #vocabList,pSF,pNY=localWords(ny,sf)
    getTopWords(ny,sf)
    #vocabList,pSF,pNY=localWords(ny,sf)
    #spamTest()
    #testingNB()
    #創(chuàng)建數(shù)據(jù)    
    #listOPosts,listClasses=loadDataSet()
    #print(listOPosts)
    #構(gòu)建一個包含所有詞的列表
    #myVocabList=createVocabList(listOPosts)
    #print(myVocabList)
    #returnVec=setOfWords2Vec(myVocabList,listOPosts[0])
    #print(returnVec)
    #trainMat=[]
    #使用詞向量填充trainMat列表
    #for postinDoc in listOPosts:
        #傳入詞匯表 以及每一行詞向量
        #返回的是一個與詞匯表同樣size的向量
        #1表示這個詞在詞向量中出現(xiàn)過
        #Vec01=setOfWords2Vec(myVocabList,postinDoc)
        #print(Vec01)
        #將01list填充trainMat
        #trainMat.append(Vec01)
    #print(trainMat)
    #print(listClasses)
    #p0V,p1V,pAB=trainNBO(trainMat,listClasses)
    #print(p0V)
    #print(p1V)
    #print(pAB)
    
if __name__=="__main__":
    main()

文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://specialneedsforspecialkids.com/yun/43453.html

相關(guān)文章

  • 機(jī)器學(xué)習(xí)實(shí)戰(zhàn)，使用樸素貝葉斯來做情感分析

    摘要：至于為什么選取樸素貝葉斯，很大一個原因是因?yàn)闃闼刎惾~斯在垃圾郵件分類上有不錯的效果，而確定一個句子屬于那種情感，和判斷一封郵件是否為垃圾郵件有異曲同工之妙。 前言 前段時間更新了一系列基礎(chǔ)的機(jī)器學(xué)習(xí)算法，感覺有些無味，而且恰好那時買了了國內(nèi)某公司的云服務(wù)器，就打算部署一套文本處理的WEB API，順別應(yīng)用一下之前學(xué)習(xí)到的機(jī)器學(xué)習(xí)算法。(文末放出地址) 本文不會涉及過于復(fù)雜的數(shù)學(xué)原理，主...

    levinit 評論0 收藏0

  • 機(jī)器學(xué)習(xí)3——樸素貝葉斯

    摘要：貝葉斯是基于概率論的分類方法，通過概率的方式來描述對象劃分到某個分類的可能性。對象有多個屬性假設(shè)各個屬性之間是相互獨(dú)立的，求解在出現(xiàn)的條件下各個類別出現(xiàn)的概率，選擇最大的作為的分類，通過這種方法構(gòu)造的分類算法稱為樸素貝葉斯。 貝葉斯是基于概率論的分類方法，通過概率的方式來描述對象劃分到某個分類的可能性。對象X有多個屬性$$X={a_{1}, a_{2}, a_{3}, ... , a_...

    TesterHome 評論0 收藏0

發(fā)表評論

0條評論

最新活動
閱讀需要支付1元查看
<