kNN算法怎么用python實現

本篇內容主要講解“kNN算法怎么用python實現”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“kNN算法怎么用python實現”吧!

2.1 文本挖掘和文本分類的概念

1，文本挖掘：指從大量的文本數據中抽取事先未知的，可理解的，最終可使用的知識的過程，同時運用這些知識更好的組織信息以便將來參考。
簡言之，就是從非結構化的文本中尋找知識的過程
2，文本挖掘的細分領域：搜索和信息檢索(IR)，文本聚類，文本分類，Web挖掘，信息抽取(IE)，自然語言處理（NLP),概念提取。
3，文本分類：為用戶給出的每個文檔找到所屬的正確類別
4，文本分類的應用：文本檢索，垃圾郵件過濾，網頁分層目錄自動生成元數據，題材檢測5，文本分類的方法：一是基于模式系統，二是分類模型

2.2 文本分類項目

中文語言的文本分類技術和流程:

1）預處理：去除文本的噪聲信息：HTML標簽，文本格式轉換
2）中文分詞：使用中文分詞器為文本分詞，并去除停用詞
3）構建詞向量空間：統計文本詞頻，生成文本的詞向量空間
4 ) 權重策略--TF-IDF方法：使用TF-IDF發現特征詞，并抽取為反映文檔主題的特征
5）分類器：使用算法訓練分類器
6）評價分類結果：分類器的測試結果分析

2.2.1 文本預處理：

文本處理的核心任務：將非結構化的文本轉換為結構化的形式，即向量空間模型

文本處理之前需要對不同類型的文本進行預處理

文本預處理的步驟：

1，選擇處理的文本的范圍：整個文檔或其中段落
2，建立分類文本語料庫：
訓練集語料：已經分好類的文本資源。（文件名:train_corpus_small）
測試集語料：待分類的文本語料（本項目的測試語料隨機選自訓練語料）（文件名：test_corpus）
3，文本格式轉換：統一轉換為純文本格式。（注意問題：亂碼）
4，檢測句子邊界：標記句子結束

2.2.2 中文分詞介紹

1，中文分詞：將一個漢字序列（句子）切分成一個單獨的詞（中文自然語言處理的核心問題）
2，中文分詞的算法：基于概率圖模型的條件隨機場（CRF）
3，分詞后文本的結構化表示：詞向量空間模型，主題模型，依存句法的樹表示，RDF的圖表示
4，本項目的分詞系統：采用jieba分詞
5, jieba分詞支持的分詞模式：默認切分，全切分，搜索引擎切分
6，jieba分詞的代碼見文件：對未分詞語料庫進行分詞并持久化對象到一個dat文件(創建分詞后的語料文件：train_corpus_seg)

import sysimport osimport jiebareload(sys)sys.setdefaultencoding('utf-8')    def savefile(savpath,content):       fp = open(savepath,"wb")    fp.write(content)    fp.close()    def readfile(path):        fp = open(path,"rb")    content = fp.read()    fp.close()    return content            corpus_path = "train_corpus_small/"   seg_path = "train_corpus_seg/"  catelist = os.listdir(corpus_path) for mydir in catelist:           class_path = corpus_path+mydir+"/"      seg_dir = seg_path+mydir+"/"          if not os.path.exists(seg_dir):          os.makedirs(seg_dir)            file_list = os.listdir(class_path)          for file_path in file_list:              fullname = class_path+file_path            content = readfile(full.name).strip()           content = content.replace("\r\n","").strip()          content_seg = jieba.cut(content)                    savefile(seg_dir+file_path," ".join(content_seg))           print "中文語料分詞結束"from sklearn.datasets.base import Bunchbunch = Bunch{target_name=[],label=[],filename=[],contents=[]}wordbag_path = "train_word_bad/train_set.dat"  seg_path = "train_corpus_seg/"   catelist = os.listdir(seg_path)  bunch.target_name.extend(catelist)   for mydir in catelist:         class_path = seg_path+mydir+"/"     file_list = os.listdir(class_path)        for file_path in file_list:             fullname = class_path+file_path            bunch.label.append(mydir)              bunch.filenames.append(fullname)          bunch.contents.append(readfile(fullname).strip())          file_obj = open(wordbad_path,"wb")  pickle.dump(bunch,file_obj)   file_obj.close()print "構建文本對象結束！！"

2.2.3 Scikit-Learn庫簡介

1，模塊分類：

1）分類和回歸算法：廣義線性模型，支持向量機，kNN,樸素貝葉斯，決策樹，特征選擇
2）聚類算法：K-means
3）維度約簡：PCA
4）模型選擇:交叉驗證
5）數據預處理：標準化，去除均值率和方差縮放，正規化，二值化，編碼分類特征，缺失值的插補

2.2.4 向量空間模型：文本分類的結構化方法

1，向量空間模型：將文本表示為一個向量，該向量的每個特征表示為文本中出現的詞2，停用詞：文本分類前，自動過濾掉某些字或詞，以節省儲存空間。根據停用詞表去除，表可下載。代碼見文件

2.2.5 權重策略：TF-IDF方法

1，詞向量空間模型：將文本中的詞轉換為數字，整個文本集轉換為維度相等的詞向量矩陣（簡單理解，抽取出不重復的每個詞，以詞出現的次數表示文本）
2，歸一化：指以概率的形式表示，例如：0，1/5,0,0,1/5,2/5,0,0,也稱為：詞頻TF（僅針對該文檔自身）
3，詞條的文檔頻率IDF：針對所有文檔的詞頻

TF-IDF權重策略：計算文本的權重向量

1，TF-IDF的含義：詞頻逆文檔頻率。如果某個詞在一篇文章中出現的頻率高（詞頻高），并且在其他文章中很少出現（文檔頻率低），則認為該詞具有很好的類別區分能力，適合用來分類。IDF其實是對TF起抵消作用。
2，詞頻TF的定義：某一個給定的詞語在該文件中出現的頻率（對詞數的歸一化）
3，逆文件頻率IDF：某一特定詞語的IDF，由總文件數除以包含該詞語的文件的數目，再將商取對數
4，TF-IDF的計算：TF與IDF的乘積
5，將分詞后的持久化語料庫文件dat利用TF-IDF策略轉化，并持久化的代碼見文件

import sysimport os from sklearn.datasets.base import Bunch  import cPickle as pickle  from sklearn import feature_extractionfrom sklearn.feature_extraction.text import TfidfTransformer   from sklearn.feature_extraction.text import TfidfVectorizer   reload(sys)sys.setdefaultencoding('utf-8')  def readbunchobj(path):       file_obj = open(path,"rb")    bunch = pickle.load(file_obj)      file_obj.cloase()    return bunch    def writebunchobj(path,bunchobj):       file_obj = open(path,"wb")    pickle.dump(bunchobj,file_obj)       file_obj.close()path = "train_word_bag/train_set.dat"  bunch = readbunchobj(path)   tfidfspace = Bunch(target_name=bunch.target_name,label=bunch.label,filenames=bunch.filenames,tdm=[],vocabulary=[])     vectorizer = TfidfVectorizer(stop_words=stpwrdlist,sublinear_tf=True,max_df=0.5)transformer=TfidfTransformer()   tfidfspace.tdm = vectorilzer.fit_transform(bunch.contents)  tfidfspace.vocabulary = vectorizer.vocabulary   space_path = "train_word_bag/tfidfspace.dat"   writebunchobj(space_path,tfidfspace)

2.2.6 使用樸素貝葉斯分類模塊

常用的文本分類方法：kNN最近鄰算法，樸素貝葉斯算法，支持向量機算法

本節選擇樸素貝葉斯算法進行文本分類，測試集隨機選取自訓練集的文檔集合，每個分類取10個文檔

訓練步驟和訓練集相同：分詞 (文件test_corpus)  》生成文件詞向量文件   》 生成詞向量模型。

（不同點：在訓練詞向量模型時，需加載訓練集詞袋，將測試集生成的詞向量映射到訓練集詞袋的詞典中，生成向量空間模型。）代碼見文件。

path = "test_word_bag/test_set.dat"   bunch = readbunchobj(path)  testspace = Bunch(target_name=bunch.target_name,label+bunch.label,filenames=bunch.filenames.tdm=[],vocabulary=[])   trainbunch = readbunchobj("train_word_bag/tfidfspace.dat")  vectorizer=TfidfVectorizer(stop_words=stpwrdlst,sublinear_tf=True,max_df=0.5,vocabulary=trainbunch.vocabulary)transformer=TfidfTransformer()    testspace.tdm=vectorizer.fit_transform(bunch.contents)   testspace.vocabulary=trainbunch.vocabularyspace_path = "test_word_bag/testspace.dat"  writebunchobj(space_path,testspace)

執行多項式貝葉斯算法進行測試文本分類，并返回分類精度，代碼見文件

from sklearn.naive_bayes import MultinomialNB trainpath = "train_word_bag/tfidfspace.dat"train_set = readbunchobj(trainpath)     testpath = "test_word_bag/testspace.dat"test_set = readbunchobj(testpath)        clf = MultinomialNB(alpha = 0.001).fit(train_set.tdm,train_set.label)predicted = clf.predict(test_set.tdm)total = len(predicted);rate = 0for flabel,file_name,expct_cate in zip(test_set.label,test_set.filenames,predicted):    if flabel !=expct_cate:        rate+=1        print file_name,":實際類別：",flabel,"-->預測類別：",expct-cate        print "error rate:",float(rate)*100/float(total),"%"

2.2.7 分類結果評估

機器學習領域的算法評估的指標：
（1）召回率（查全率）：檢索出的相關文檔數和文檔庫中所有的相關文檔數的比率，是衡量檢索系統的查全率
召回率=系統檢索到的相關文件/系統所有相關的文檔總數
（2）準確率（精度）：檢索出的相關文檔數與檢索出的文檔總數的比率
準確率=系統檢索到的相關文件/系統所有檢索到的文件總數
（3）Fp-Measure
Fp=(p2+1)PR/(p2P+R),P是準確率，R是召回率
p=1時，就是F1-Measure
文本分類項目的分類評估結果評估：代碼見文件

import numpy as npfrom sklearn import metricsdef metrics_result(actual,predict):    print '精度：{0:3f}'.format(metrics.precision_score(actual,predict))    print '召回:{0:0.3f}'.format(metrics.recall_score(actual,predict))    print 'f1-score:{0:3f}'.format(metrics.f1_score(actual,predict))    metrics_result(test_set.label,predicted)

2.3 分類算法：樸素貝葉斯

本節主要討論樸素貝葉斯算法的基本原理和python實現

2.3.1 貝葉斯公式推導

樸素貝葉斯文本分類的思想：它認為詞袋中的兩兩詞之間是相互獨立的，即一個對象的特征向量中的每個維度都是相互獨立的。
樸素貝葉斯分類的定義:
（1），設x={a1,a2,^am}為一個待分類項，而每個a為x的一個特征屬性
（2），有類別集合C={y1,y2,……yn}.
（3），計算P(y1|x),P(y2|x),……,P(yn|x)
（4），如果P（yk|x）=max{P1,P2,……,Pn}，則x屬于yk

-- 計算第（3）步的各個條件概率：
（1）找到一個已知分類的待分類集合，即訓練集
（2）統計得到在各個類別下的各個特征屬性的條件概率估計，即：
P(a1|y1),P(a2|y2),……，P(am|y1)
P(a1|y2),P(a2|y2),……，P（am|y2）
……
（3），如果各個特征屬性是條件獨立的，根據貝葉斯定理有：
P(yi|x) = P(x|yi)*P(yi)/P(x)
分母對于所有類別為常數，故只需將分子最大化即可

故，貝葉斯分類的流程為：
第一階段 ：訓練數據生成訓練樣本集：TF-IDF
第二階段：對每個類別計算P(yi)
第三階段：對每個特征屬性計算所有劃分的條件概率
第四階段：對每個類別計算P(x|yi)P(yi)
第五階段：以P(x|yi)P(yi)的最大項作為x的所屬類別

2.3.2 樸素貝葉斯算法實現

樣例：使用簡單的英文語料作為數據集，代碼見文件

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','my'],                 ['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      class NBayes(object):         def __init__(self):               self.vocabulary = []          self.idf = 0                  self.tf = 0                   self.tdm = 0                  self.Pcates = {}              self.labels = []              self.doclength = 0            self.vocablen = 0             self.testset = 0              def train_set(self,trainset,classVec):          self.cate_prob(classVec)        self.doclength = len(trainset)         tempset = set()      [tempset.add(word) for doc in trainset for word in doc]             self.vocabulary = list(tempset)     self.vocablen = len(self.vocabulary)        self.calc_wordfreq(trainset)      self.build_tdm()          def cate_prob(self,classVec):      self.labels = classVec         labeltemps = set(self.labels)      for labeltemp in labeltemps:            self.labels.count(labeltemp)          self.Pcates[labeltemp] = float(self.labels.count(labeltemp))/float(len(self.labels))                        def calc_wordfred(self,trainset):           self.idf = np.zeros([1,self.vocablen])     self.tf = np.zeros([self.doclength,self.vocablen])             for indx in xrange(self.doclength):              for word in trainset[indx]:             self.tf[indx,self.vocabulary.index(word)] +=1                                            for signleword in set(trainset[indx]):              self.idf[0,self.vocabulary.index(signleword)] +=1                                      def build_tdm(self):       self.tdm = np.zeros([len(self.Pcates),self.vocablen])      sumlist = np.zeros([len(self.Pcates),1])              for indx in xrange(self.doclength):                                    self.tdm[self.labels[indx]] += self.tf[indx]                                   sumlist[self.labels[indx]] = np.sum(self.tdm[self.labels[indx]])                                                         self.tdm = self.tdm/sumlist             (3)-(5)函數都被train_set函數調用    def map2vocab(self,testdata):      self.testset = np.zeros([1,self.vocablen])      for word in testdata:            self.testset[0,self.vocabulary.index(word)] +=1               def predict(self,testset):        if np.shape(testset)[1] != self.vocablen:         print "輸出錯誤"        exit(0)            predvalue = 0      predclass = ""          for tdm_vect,keyclass in zip(self.tdm,self.Pcates):                            temp = np.sum(testset*tdm_vect*self.Pacate[keyclass])                  if temp > predvalue:              predvalue = temp            predclass = keyclass    return predclass       def calc_tfidf(self,trainset):            self.idf = np.zeros([1,self.vocablen])       self.tf = np.zeros([self.doclength,self.vocablen])          for indx in xrange(self.doclength):           for word in trainset[indx]:                    self.tf[indx,self.vocabulary.index(word)]+=1                      self.tf[indx] = self.tf[indx]/float(len(trainset[indx]))                  for signleword in set(trainset[indx]):            self.idf[0,self.vocabulary.index(signleword)] +=1    self.idf = np.log(float(self.doclength)/self.idf)        self.tf = np.multiply(self.tf,self.idf)       import sysimport osfrom numpy import *import numpy as npfrom NBayes_lib import *dataSet,listClasses = loadDataSet()  nb = NBayes()  nb.train_set(dataSet,listClasses) nb.map2vocab(dataSet[0])   print nb.predict(nb.testset)

2.4  分類算法：KNN

KNN算法：計算向量間的距離衡量相似度來進行文本分類

2.4.1 KNN算法的原理

1，算法思想：如果一個樣本在特征空間的k個最近鄰（最近似）的樣本中的大多數都屬于某一類別，則該樣本也屬于這個類別，k是由自己定義的外部變量。

2，KNN算法的步驟：

第一階段：確定k值（就是最近鄰的個數），一般是奇數
第二階段：確定距離度量公式，文本分類一般使用夾角余弦，得出待分類數據點與所有已知類別的樣本點，從中選擇距離最近的k個樣本
夾角余弦公式：cos =AB/|A|*|B|
第三階段:統計k個樣本點中各個類別的數量，哪個類別的數量最多，就把數據點分為什么類別

2.4.2 kNN算法的python實現

import sysimport osfrom numpy import *import numpy as *import operatorfrom Nbayes_lib import *reload(sys)sys.setdefaultencoding('utf-8')k=3def cosdist(vector1,vector2):    return dot(vector1,vector2)/(linalg.norm(vector1)*linalg.norm(vector2))     def classify(testdata,trainSet,listClasses,k):    dataSetSize=trainSet.shape[0]         distances=array(zeros(dataSetSize))          for indx in xrange(dataSetSize):           distances[indx]=cosdist(testdata,trainSet[indx])        sortedDisIndicies=argsort(-distances)        classCount={}        for i in range(k)：voteIlabel=listClasses[sortedDistIndices[i]]                        classCount[voteIlabel]=classCount.get(voteIlabel,0) +1                                                    sortedClassCount=sorted(classCount.iteritem(),key=operator.itemgetter(1),reverse=True)        return sortedClassCount[0][0]           dataSet,listClasses=loadDataSet()nb.NBayes()nb.train_set(dataSet,listClasses)  print classify(nb.tf[3],nb.tf,listClasses,k)

到此，相信大家對“kNN算法怎么用python實現”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！