2. 程式人生 > >機器學習第六篇

機器學習第六篇

阿新 • • 發佈：2018-11-11

文件分類

是機器智慧的一個應用，最有價值的包括垃圾資訊過濾。

早期對垃圾資訊進行過濾所用的是基於規則的分類器，使用時事先設計好一組規則，用以指明某條資訊是否屬於垃圾資訊。典型的規則包括英文大寫字母的過度使用、與醫藥相關的單詞，或是過於花哨的HTML用色等

新：

程式在開始階段和逐漸收到更多訊息之後，根據人們提供給它的有關哪些是垃圾郵件，哪些不是垃圾郵件的資訊，不斷的進行學習

在選擇特徵集時須要做大量的權衡，而且還要不斷地進行調整

對文件的隨機蒐集很重要！！！！！

新建docclass.py

def getwords(doc):
    splitter = re.compile('\\W*')
    # 根據非字母字元進行拆分
    words = [s.lower() for s in splitter.split(doc) if len(s) > 2 and len(s) < 20]

    # ****只返回一組不重複的單詞****
    return dict([(w, 1) for w in words])

對分類器進行訓練：

import re
import math

def sampletrain(c1):
    c1.train('Nobody owns the water.', 'good')
    c1.train('the quick rabbit jumps fences', 'good')
    c1.train('buy pharmaceuticals now', 'bad')
    c1.train('make quick money at the online casino', 'bad')
    c1.train('the quick brown fox jumps', 'good')

def getwords(doc):
    splitter = re.compile('\\W*')
    # 根據非字母字元進行拆分
    words = [s.lower() for s in splitter.split(doc) if len(s) > 2 and len(s) < 20]

    # ****只返回一組不重複的單詞****
    return dict([(w, 1) for w in words])

class classifier:

    def __init__(self,getfeatures,filename=None):
        #統計特徵/分類組合的數量
        self.fc={}
        #統計每個分類中的文件數量
        self.cc={}
        #得到特徵集
        self.getfeatures=getfeatures

    # 增加對某一分類的計數值
    def incc(self, cat):
        self.cc.setdefault(cat, 0)
        self.cc[cat] += 1

    # 增加對特徵/分類組合的計數值
    def incf(self, f, cat):
        self.fc.setdefault(f, {})
        self.fc[f].setdefault(cat, 0)
        self.fc[f][cat] += 1
        # print(self.fc)

    # 返回某一特徵出現於某一分類中的次數
    def fcount(self, f, cat):
        if f in self.fc and cat in self.fc[f]:
            return float(self.fc[f][cat])
        return 0.0

    # 返回屬於某一分類的內容項數量
    def catcount(self, cat):
        if cat in self.cc:
            return float(self.cc[cat])
        return 0

    # 所有內容項的數量
    def totalcount(self):
        return sum(self.cc.values())

    # 所有分類的列表
    def categories(self):
        return self.cc.keys()

    def train(self, item, cat):
        features = self.getfeatures(item)
        # 針對該分類為每個特徵增加計數值
        for f in features:
            self.incf(f, cat)

        # 增加針對該分類的計數值
        self.incc(cat)

計算概率：P(good)+P(bad)!=1

    def fprob(self, f, cat):
        if self.catcount(cat) == 0: return 0
        # 特徵在分類中出現的總次數，除以分類中包含內容項的總數
        # print(self.fc)
        # print(self.cc)
        return self.fcount(f, cat) / self.catcount(cat)

fprob方法針對目前為止見到過的特徵與分類，給出了一個精確的結果，但只根據以往見過的資訊，會令其在訓練的初期階段，對那些極少出現的單詞變得異常敏感。

    # 加權     -----不是很明白-----
    def weightedprob(self, f, cat, prf, weight=1.0, ap=0.5):
        # 計算當前的概率值
        basicprob = prf(f, cat)

        # 統計特徵在所有分類中出現的次數
        totals = sum([self.fcount(f, c) for c in self.categories()])

        # 計算加權平均
        bp = ((weight * ap) + (totals * basicprob)) / (weight + totals)
        return bp

麼有看懂~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

對於一個過濾器而言，它最好應該有能力處理極少會出現的單詞。

樸素分類器

一旦求出指定單詞在一篇屬於某個分類的文件中出現的概率，就需要有一種方法將各個單詞的概率進行組合，從而得出整篇文件屬於該分類的概率。

樸素即一個單詞在屬於某個指定分類的文件中出現的概率，與其他單詞出現於該分類的概率是不相關的。

事實上，假設是不成立的。

但若不考慮假設的潛在缺陷，樸素貝葉斯分類器將被證明是一種非常有效的文件分類方法。

樸素貝葉斯分類器：通過將所有的概率相乘，計算出總的概率值，再乘以分類的概率。

**************************************************************普及貝葉斯**************************************************************

 

    def docprob(self, item, cat):
        features = self.getfeatures(item)

        # 將所有特徵的概率相乘
        p = 1
        for f in features: p *= self.weightedprob(f, cat, self.fprob)
        return p

    # 一個文件屬於某個分類的概率
    def prob(self, item, cat):
        catprob = self.catcount(cat) / self.totalcount()
        docprob = self.docprob(item, cat)
        return docprob * catprob

選擇分類：判定某個內容項所屬的分類

最簡單的方法：

計算被考察內容在每個不同分類中的概率，然後選擇概率最大的分類，但在某些應用中，承認不知道答案，要好過判斷答案就是概率值稍大一些的分類

為每個分類定義一個最小閾值！

class naivebayes(classifier):
    def __init__(self, getfeatures):
        classifier.__init__(self, getfeatures)
        self.thresholds = {}

    def setthresholds(self, cat, t):
        self.thresholds[cat] = t

    def getthresholds(self, cat):
        if cat not in self.thresholds: return 1.0
        return self.thresholds[cat]

    def docprob(self, item, cat):
        features = self.getfeatures(item)

        # 將所有特徵的概率相乘
        p = 1
        for f in features: p *= self.weightedprob(f, cat, self.fprob)
        return p

    # 一個文件屬於某個分類的概率
    def prob(self, item, cat):
        catprob = self.catcount(cat) / self.totalcount()
        docprob = self.docprob(item, cat)
        return docprob * catprob

    def classify(self, item, default=None):
        probs = {}
        # 尋找概率最大的分類
        max = 0.0
        for cat in self.categories():
            probs[cat] = self.prob(item, cat)
            if probs[cat] > max:
                max = probs[cat]
                best = cat

        # 確保概率值超出閾值*次大概率值   ***************************
        for cat in probs:
            if cat == best: continue
            if probs[cat] * self.getthresholds(best) > probs[best]: return default
        return best

費舍爾方法

與樸素貝葉斯過濾器利用特徵概率來計算整篇文章的概率文章的概率不同，費舍爾方法為文件中的每個特徵都求得了分類的概率，然後又將這些概率組合起來，並判斷其是否有可能構成一個隨機集合。

import math
from docclass import classifier

class fisherclassifier(classifier):

    def cprob(self, f, cat):
        # 特徵在該分類中出現的頻率
        clf = self.fprob(f, cat)
        if clf == 0: return 0

        # 特徵在所有分類中出現的頻率
        freqsum = sum([self.fprob(f, c) for c in self.categories()])

        # 概率等於特徵在該分類中出現的頻率除以總體頻率
        p = clf / (freqsum)
        return p

    def fisherprob(self, item, cat):
        # 將所有概率值相乘
        p = 1
        features = self.getfeatures(item)
        for f in features:
            p *= (self.weightedprob(f, cat, self.cprob))

        # 取自然對數，並乘以-2
        fscore = -2 * math.log(p)

        # 利用倒置對數卡方函式求得概率
        return self.invchi2(fscore, len(features) * 2)

    def invchi2(self, chi, df):
        m = chi / 2.0
        sum = term = math.exp(-m)
        for i in range(1, df // 2):
            term *= m / i
            sum += term
        return min(sum, 1.0)

公式沒有搞懂~~~~~~~~~~~~~~~~~~~

不同於貝葉斯那樣要乘以閾值，費舍爾方法可以為每個分類指定下限

    def __init__(self, getfeatures):
        classifier.__init__(self, getfeatures)
        self.minimums = {}

    def setminimum(self,cat,min):
        self.minimums[cat]=min

    def getminimum(self,cat):
        if cat not in self.minimums: return 0
        return self.minimums[cat]



    def classify(self,item,default=None):
        #迴圈遍歷並尋找最佳結果
        best=default
        max=0.0
        for c in self.categories():
            p=self.fisherprob(item,c)
            #確保其超過下限值
            if p>self.getminimum(c) and p>max:
                best=c
                max=p
        return best

使用SQLite

只是將上面存在字典中的資料存到了資料庫中而已~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class classifier:

    def __init__(self, getfeatures, filename=None):
        # 統計特徵/分類組合的數量
        self.fc = {}
        # 統計每個分類中的文件數量
        self.cc = {}
        # 得到特徵集
        self.getfeatures = getfeatures

    def setdb(self, dbfile):
        self.con = sqlite3.connect(dbfile)
        self.con.execute('create table if not exists fc(feature,category,count)')
        self.con.execute('create table if not exists cc(category,count)')

    # 增加對某一分類的計數值
    # def incc(self, cat):
    #     self.cc.setdefault(cat, 0)
    #     self.cc[cat] += 1
    def incc(self, cat):
        count = self.catcount(cat)
        if count == 0:
            self.con.execute("insert into cc values ('%s',1)" % (cat))
        else:
            self.con.execute("update cc set count=%d where category='%s'" % (count + 1, cat))

    # 增加對特徵/分類組合的計數值
    # def incf(self, f, cat):
    #     self.fc.setdefault(f, {})
    #     self.fc[f].setdefault(cat, 0)
    #     self.fc[f][cat] += 1
    # 增加對特徵/分類組合的計數值
    def incf(self, f, cat):
        count = self.fcount(f, cat)
        if count == 0:
            self.con.execute("insert into fc values('%s','%s',1)" % (f, cat))
        else:
            self.con.execute(
                "update fc set count=%d where feature='%s' and category='%s'" % (count + 1, f, cat))

    # 返回某一特徵出現於某一分類中的次數
    # def fcount(self, f, cat):
    #     if f in self.fc and cat in self.fc[f]:
    #         return float(self.fc[f][cat])
    #     return 0.0

    def fcount(self, f, cat):
        res = self.con.execute('select count from fc where feature="%s" and category="%s"' % (f, cat)).fetchone()
        if res == None:
            return 0
        else:
            return float(res[0])

    # 返回屬於某一分類的內容項數量
    # def catcount(self, cat):
    #     if cat in self.cc:
    #         return float(self.cc[cat])
    #     return 0
    def catcount(self, cat):
        res = self.con.execute('select count from cc where category="%s"' % (cat)).fetchone()
        if res == None:
            return 0
        else:
            return float(res[0])

    # 所有內容項的數量
    # def totalcount(self):
    #     return sum(self.cc.values())
    def totalcount(self):
        res=self.con.execute('select sum(count) from cc').fetchone()
        if res==None: return 0
        return res[0]

    # 所有分類的列表
    # def categories(self):
    #     return self.cc.keys()
    def categories(self):
        cur = self.con.execute('select category from cc')
        return [d[0] for d in cur]
    
    def train(self, item, cat):
        features = self.getfeatures(item)
        # 針對該分類為每個特徵增加計數值
        for f in features:
            self.incf(f, cat)

        # 增加針對該分類的計數值
        self.incc(cat)
        self.con.commit()
        
    def fprob(self, f, cat):
        if self.catcount(cat) == 0: return 0
        # 特徵在分類中出現的總次數，除以分類中包含內容項的總數
        # print(self.fc)
        # print(self.cc)
        return self.fcount(f, cat) / self.catcount(cat)

    # 加權     -----不是很明白-----
    def weightedprob(self, f, cat, prf, weight=1.0, ap=0.5):
        # 計算當前的概率值
        basicprob = prf(f, cat)

        # 統計特徵在所有分類中出現的次數
        totals = sum([self.fcount(f, c) for c in self.categories()])

        # 計算加權平均
        bp = ((weight * ap) + (totals * basicprob)) / (weight + totals)
        return bp

過濾部落格訂閱源

import feedparser
import docclass3
import docclass4

#接受一個部落格訂閱源的URL檔名並對內容項進行分類
def read(feed,classifier):
    #得到訂閱源的內容項並遍歷迴圈
    f=feedparser.parse(feed)
    for entry in f['entries']:
        print()
        print('--------')
        #將內容列印輸出
        print('Title:  '+str(entry['title'].encode('utf-8')))
        print('Publisher:  '+str(entry['publisher'].encode('utf-8')))
        print()
        print(str(entry['summary'].encode('utf-8')))

        #將所有文字組合在一起，為分類器構建一個內容項
        fulltext='%s\n%s\n%s' % (entry['title'],entry['publisher'],entry['summary'])
        #將當前分類的最佳推測結果列印輸出
        print('Guess:  '+str(classifier.classify(fulltext)))

        #請求使用者給出正確分類，並據此進行訓練
        c1=input('Enter category：')
        classifier.train(fulltext,c1)


c1=docclass3.fisherclassifier(docclass4.getwords)
c1.setdb('python_feed.db') #僅當你使用的是SQLite
# read('python_search.xml',c1)

print(c1.cprob('python','prog'))
print(c1.cprob('python','snake'))
print(c1.cprob('python','monty'))
print(c1.fprob('eric','monty'))

仔細思考就可以了喲~~~~~~~~~~ 

對特徵檢測的改進

import feedparser
import docclass3
import docclass4
import re

#接受一個部落格訂閱源的URL檔名並對內容項進行分類
def read(feed,classifier):
    #得到訂閱源的內容項並遍歷迴圈
    f=feedparser.parse(feed)
    for entry in f['entries']:
        print()
        print('--------')
        #將內容列印輸出
        print('Title:  '+str(entry['title'].encode('utf-8')))
        print('Publisher:  '+str(entry['publisher'].encode('utf-8')))
        print()
        print(str(entry['summary'].encode('utf-8')))

        #將所有文字組合在一起，為分類器構建一個內容項
        #fulltext='%s\n%s\n%s' % (entry['title'],entry['publisher'],entry['summary'])
        #將當前分類的最佳推測結果列印輸出
        # print('Guess:  '+str(classifier.classify(fulltext)))
        #
        # #請求使用者給出正確分類，並據此進行訓練
        # c1=input('Enter category：')
        # classifier.train(fulltext,c1)
        print('Guess: ' + str(classifier.classify(entry)))

        # 請求使用者給出正確分類，並據此進行訓練
        c1 = input('Enter category: ')
        classifier.train(entry, c1)
        break

#
# c1=docclass3.fisherclassifier(docclass4.getwords)
# c1.setdb('python_feed.db') #僅當你使用的是SQLite
# read('python_search.xml',c1)

# print(c1.cprob('python','prog'))
# print(c1.cprob('python','snake'))
# print(c1.cprob('python','monty'))
# print(c1.fprob('eric','monty'))


#替代getwords
def entryfeatures(entry):
    splitter=re.compile('\\W*')
    f={}

    #提取標題中的單詞並進行標示
    titlewords=[s.lower() for s in splitter.split(entry['title'])
                if len(s)>2 and len(s)<20]
    for w in titlewords: f['Title:'+w]=1   #*******************************************

    #提取摘要中的單詞
    summarywords=[s.lower() for s in splitter.split(entry['summary'])
                  if len(s)>2 and len(s)<20]

    #統計大寫單詞
    uc=0
    for i in range(len(summarywords)):
        w=summarywords[i]
        f[w]=1
        if w.isupper(): uc+=1   #???????????????????????

        #將從摘要中獲得的片語作為特徵
        if i<len(summarywords)-1:
            twowords=' '.join(summarywords[i:i+1])
            f[twowords]=1     #*******************************************

    #保持文章建立者和釋出者名字的完整性
    f['Publisher:'+entry['publisher']]=1         #*******************************************

    #UPPERCASE是一個‘虛擬’單詞，用以指示存在過多的大寫內容
    if float(uc)/len(summarywords)>0.3: f['UPPERCASE']=1
    print(f)
    return f


# c1=docclass3.fisherclassifier(entryfeatures)
# c1.setdb('python_feed.db')
# read('python_search.xml',c1)

s='Microsoft Hires Inventor of RubyCLR'
splitter=re.compile('\\W*')
f={}
summarywords=[s.lower() for s in splitter.split(s) if len(s)>2 and len(s)<20]
#統計大寫單詞
uc=0
for i in range(len(summarywords)):
    w=summarywords[i]
    print(w)
    f[w]=1
    if w.isupper(): uc+=1
    print(uc)

只是將getwords改成了entryfeatures,其他沒什麼變化，返回的字典形式如下

{'Title:new': 1, 'Title:baby': 1, 'Title:boy': 1, 'this': 1, 'new': 1, 'baby': 1, 'anthem': 1, 'and': 1, 'half': 1, 'month': 1, 'old': 1, 'ball': 1, 'python': 1, 'orange': 1, 'shaded': 1, 'normal': 1, 'pattern': 1, 'have': 1, 'held': 1, 'him': 1, 'about': 1, 'time': 1, 'since': 1, 'brought': 1, 'home': 1, 'tonight': 1, '00pm': 1, 'Publisher:Shetan Noir, the zombie belly dancer! - MySpace Blog': 1}

並沒有將片語連起來呀？？？

統計的大寫字母也沒用啊，懷疑這段程式碼有問題！

 

 Akismet

沒有看。。。。

小結

貝葉斯和費舍爾兩個分類器均為監督型學習方法。

貝葉斯分類器之所以經常被用於文件分類的原因是，與其他方法相比它所要求的計算資源更少。

神經網路是否會成為一種可行的替代方案，取決於訓練和查詢所要求的速度，以及實際執行的環境，神經網路的複雜性導致了其在理解上的困難。

神經網路和支援向量機有一個很大的優勢：他們可以捕捉到輸入特徵之間更為複雜的關係。在貝葉斯分類器中，每一個特徵都有一個針對各分類的概率值，將這些概率值組合起來之後就成為了一個整體上概率值，神經網路中，某個特徵的概率可能會依據其他特徵的存在或缺失而改變。

 

費時3天看完。。。。。。。。心涼涼。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

相關推薦

機器學習第六篇

文件分類 是機器智慧的一個應用，最有價值的包括垃圾資訊過濾。 早期對垃圾資訊進行過濾所用的是基於規則的分類器，使用時事先設計好一組規則，用以指明某條資訊是否屬於垃圾資訊。典型的規則包括英文大寫字母的過度使用、與醫藥相關的單詞，或是過於花哨的HTML用色等 新： 程式在開始階段和逐漸收

（筆記）斯坦福機器學習第六講--樸素貝葉斯

span || -h 沒有 height 單純 去除 變量 logistic 本講內容 1. Naive Bayes（樸素貝葉斯） 2.Event models（樸素貝葉斯的事件模型） 3.Neural network （神經網絡） 4.Support vector mac

機器學習第七篇

決策樹 相比於其他方法，決策樹是一種更為簡單的機器學習方法，它是對被觀測資料進行分類的一種相當直觀的方法，決策樹在經過訓練之後，看起來更像是以樹狀形式排列的一系列if-then語句。只要沿著樹的路徑一直向下，正確回答每一個問題，最終就會得到答案，沿著最終的葉節點向上回溯，就會得到一個有關最終分類

機器學習第八篇

構造價格模型 在利用多種不同屬性（比如價格）對數值型資料進行預測時，貝葉斯分類器、決策樹、支援向量機都不是最佳的演算法。 本篇將對一系列演算法進行考查，這些演算法可以接受訓練，根據之前見過的樣本資料作出資料類的預測，而且它們還可以顯示出預測的概率分佈情況，以幫助使用者對預測過程加以解釋。後續

機器學習第四篇

全文搜尋引擎允許人們在大量文件中搜索一系列單詞，並根據文件與這些單詞的相關程度對結果進行排序。 PageRank——標準演算法的一個變體 資訊檢索步驟： 1、找到一種蒐集文件的方法 爬蟲：接受一組等待建立索引的網頁，再根據這些網頁內部的連結進而找到其他的網頁，依此類推。程式碼通常會將

機器學習 | 吳恩達機器學習第六週學習筆記

課程視訊連結 第六週PPT  下載密碼:zgkq 本週主要講解了如何設計機器學習系統和如何改進機器學習系統，包括一些模型選擇的方法，模型效能的評價指標，模型改進的方法等。 目錄 一、應用機器學習建議 1.決定下一步做什麼 2.評估假設函式 3.模型選擇和訓練、驗

機器學習 | 吳恩達機器學習第六週程式設計作業(Python版）

實驗指導書  下載密碼:4t4y 本篇部落格主要講解，吳恩達機器學習第六週的程式設計作業，作業內容主要是實現一個正則化的線性迴歸演算法，涉及本週講的模型選擇問題，繪製學習曲線判斷高偏差/高方差問題。原始實驗使用Matlab實現，本篇部落格提供Python版本。 目錄 1.實驗包

Coursera-吳恩達-機器學習-第六週-程式設計作業: Regularized Linear Regression and Bias/Variance

本次文章內容： Coursera吳恩達機器學習課程，第六週程式設計作業。程式語言是Matlab。 學習演算法分兩部分進行理解，第一部分是根據code對演算法進行綜述，第二部分是程式碼。 0 Introduction  在這個練習中，應用regularized linea

Coursera-吳恩達-機器學習-第六週-測驗-Machine Learning System Design

說實話，這一次的測驗對我還是有一點難度的，為了刷到100分，刷了7次（哭）。 無奈，第2道和第4道題總是出錯，後來終於找到錯誤的地方，錯誤原因是思維定式，沒有動腦和審題正確。 這兩道題細節會在下面做出講解。 第二題分析：題意問，使用大量的資料，在哪兩種情況時

Python 語言學習 第六篇：迭代和解析

Python 語言學習 第六篇：迭代和解析 Python中的迭代是指按照元素的順序逐個呼叫的過程，迭代概念包括：迭代協議、可迭代物件和迭代器三個概念。 迭代協議是指有__next__()函式的物件會前進到下一個結果，而到達系列的末尾時，則會引發StopIteration異常。為了支援迭代協議

機器學習第十篇——尋找獨立特徵

尋找獨立特徵 如何在資料集並未明確標識結果的前提下，從中提取出重要的潛在特徵來，和聚類一樣，這些方法的目的不是為了預測，而是要嘗試對資料進行特徵識別，並且告訴我們值得關注的重要資訊 尋找獨立特徵應用： *雞尾酒宴會  ????????????????? *對重複出現於

c++學習第六篇（拷貝建構函式）

1.當函式的引數為類的物件時 #include<iostream> using namespace std; class CExample { private:     int a; public:     CExample(int b) &n

從.Net到Java學習第六篇——SpringBoot+mongodb&Thymeleaf&模型驗證

SpringBoot整合mongodb 　　MongoDB 是一個介於關係資料庫和非關係資料庫之間的產品，是非關係資料庫當中功能最豐富，最像關係資料庫的。如果你沒用過MongoDB，可以先去看下我的文章：https://www.cnblogs.com/jiekzou/category/851166.ht

思維導圖學習 | 第六篇：java學習特別篇，10-15k薪資應具備的技能

配套Ximnd學習導圖下載地址 寫在最後 歡迎關注、喜歡、和點贊後續將推出更多的思維導圖教程，敬請期待。 歡迎關注我的微信公眾號獲取更多更全的學習資源，視訊資料，技術乾貨！ 公眾號回覆“學習”

機器學習 第六章 支援向量機

6.1 間隔與支援向量 在樣本空間中，劃分超平面可通過如下線性方程來描述： 6.2 對偶問題 我們希望求解式（6.6）來得到大間隔劃分超平面所對應的模型： 對式（6.6）使用拉格朗日乘子法可得到其“對偶問

SpringBoot 2.X課程學習 | 第六篇：挖掘配置檔案的祕密

  一、兩種配置檔案獲取值的方式         因為普遍屬性

機器學習 第6篇：線性模型概述

在迴歸分析中，線性模型的一般預測公式是： 是預測值，讀作"y hat"，是特徵的線性組合，把向量w稱作 coef_（係數），公式是：    把w0稱作intercept_（截距），這兩個屬性是線性模型的共有屬性。 一，線性迴歸 最基本的線性模型是線性迴歸，也稱作最小二乘法（OL

機器學習 第2篇：資料預處理（缺失值）

在真實的世界中，缺失資料是經常出現的，並可能對分析的結果造成影響。我們需要了解資料缺失的原因和資料缺失的型別，並從資料中識別缺失值，探索資料缺失的模式，進而處理缺失的資料。本文概述處理資料缺失的方法。 一，資料缺失的原因 首先我們應該知道：資料為什麼缺失？資料的缺失是我們無法避免的，可能的原因有很多種，博主總

機器學習 第3篇：資料預處理（使用插補法處理缺失值）

插補法可以在一定程度上減少偏差，常用的插補法是熱卡插補、擬合插補和多重插補。擬合插補，要求變數間存在強的相關性；多重插補（MCMC法），是在高缺失率下的首選插補方法，優點是考慮了缺失值的不確定性。 一，熱卡插補 熱卡填充（Hot deck imputation）也叫就近補齊，對於一個包含空值的物件，熱卡填充法

機器學習 第4篇：資料預處理（sklearn 插補缺失值）

由於各種原因，現實世界中的許多資料集都包含缺失值，通常把缺失值編碼為空白，NaN或其他佔位符。但是，此類資料集與scikit-learn估計器不相容，這是因為scikit-learn的估計器假定陣列中的所有值都是數字，並且都存在有價值的含義。如果必須使用不完整資料集，那麼處理缺失資料的基本策略是丟棄包含缺失值