基於機器學習和TFIDF的情感分類演算法，詳解自然語言處理

摘要：這篇文章將詳細講解自然語言處理過程，基於機器學習和TFIDF的情感分類演算法，並進行了各種分類演算法（SVM、RF、LR、Boosting）對比

本文分享自華為雲社區《[Python人工智慧] 二十三.基於機器學習和TFIDF的情感分類（含詳細的NLP數據清洗）》，作者： eastmount。

在數據分析和數據挖掘中，通常需要經歷前期準備、數據爬取、數據預處理、數據分析、數據可視化、評估分析等步驟，而數據分析之前的工作幾乎要花費數據工程師近一半的工作時間，其中的數據預處理也將直接影響後續模型分析的好壞。圖是數據預處理的基本步驟，包括中文分詞、詞性標註、數據清洗、特徵提取（向量空間模型存儲）、權重計算（TF-IDF）等。

一.中文分詞

當讀者使用Python爬取了中文數據集之後，首先需要對數據集進行中文分詞處理。由於英文中的詞與詞之間是採用空格關聯的，按照空格可以直接劃分片語，所以不需要進行分詞處理，而中文漢字之間是緊密相連的，並且存在語義，詞與詞之間沒有明顯的分隔點，所以需要藉助中文分詞技術將語料中的句子按空格分割，變成一段段詞序列。下面開始詳細介紹中文分詞技術及Jiaba中文分詞工具。

中文分詞（Chinese Word Segmentation）指將漢字序列切分成一個個單獨的詞或詞串序列，它能夠在沒有詞邊界的中文字元串中建立分隔標誌，通常採用空格分隔。下面舉個簡單示例，對句子「我是程式設計師」進行分詞操作。

輸入：我是程式設計師
輸出1：我\是\程\序\員
輸出2：我是\是程\程式\序員
輸出3：我\是\程式設計師

簡單舉個例子，程式碼中主要導入Jieba擴展包，然後調用其函數進行中文分詞。

#encoding=utf-8  
import jieba  
 
text = "北京理工大學生前來應聘"  

data = jieba.cut(text,cut_all=True)   #全模式
print("[全模式]: ", " ".join(data))
 
data = jieba.cut(text,cut_all=False)  #精確模式  
print("[精確模式]: ", " ".join(data))
 
data = jieba.cut(text)  #默認是精確模式 
print("[默認模式]: ", " ".join(data))

data = jieba.cut_for_search(text)  #搜索引擎模式   
print("[搜索引擎模式]: ", " ".join(data))

上述程式碼輸出如下，包括全模式、精確模式和搜索引擎模式輸出的結果。

二.數據清洗

在分析語料的過程中，通常會存在一些臟數據或雜訊片語干擾我們的實驗結果，這就需要對分詞後的語料進行數據清洗（Data Cleaning）。比如前面使用Jieba工具進行中文分詞，它可能存在一些臟數據或停用詞，如「我們」、「的」、「嗎」等。這些詞降低了數據品質，為了得到更好的分析結果，需要對數據集進行數據清洗或停用詞過濾等操作。

  • 殘缺數據
  • 重複數據
  • 錯誤數據
  • 停用詞

這裡主要講解停用詞過濾，將這些出現頻率高卻不影響文本主題的停用詞刪除。在Jieb分詞過程中引入stop_words.txt停用詞詞典，如果存在則過濾即可。

下面是從大眾點評、美團之類的網站抓取「黃果樹瀑布」的評論資訊，我們通過Jieba工具對其進行中文分詞。

  • 好評：5000條
  • 差評：1000條

完整程式碼：

# -*- coding:utf-8 -*-
import csv
import pandas as pd
import numpy as np
import jieba
import jieba.analyse

#添加自定義詞典和停用詞典
jieba.load_userdict("user_dict.txt")
stop_list = pd.read_csv('stop_words.txt',
                        engine='python',
                        encoding='utf-8',
                        delimiter="\n",
                        names=['t'])['t'].tolist()

#中文分詞函數
def txt_cut(juzi):
    return [w for w in jieba.lcut(juzi) if w not in stop_list]

#寫入分詞結果
fw = open('fenci_data.csv', "a+", newline = '',encoding = 'gb18030')
writer = csv.writer(fw)  
writer.writerow(['content','label'])

# 使用csv.DictReader讀取文件中的資訊
labels = []
contents = []
file = "data.csv"
with open(file, "r", encoding="UTF-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        # 數據元素獲取
        if row['label'] == '好評':
            res = 0
        else:
            res = 1
        labels.append(res)
        content = row['content']
        seglist = txt_cut(content)
        output = ' '.join(list(seglist))            #空格拼接
        contents.append(output)
 
        #文件寫入
        tlist = []
        tlist.append(output)
        tlist.append(res)
        writer.writerow(tlist)

print(labels[:5])
print(contents[:5])
fw.close()

運行結果如下圖所示，一方面它將特殊標點符號、停用詞過濾，另一方面導入了user_dict.txt詞典，將「黃果樹瀑布」、「風景區」等專有名詞分詞，否則它可能會劃分為「黃果樹」和「瀑布」、「風景」和「區」。

  • 數據清洗前

還記得小時候，常常守在電視機前，等候《西遊記》的播出。「你挑著擔,我牽著馬。翻山涉水兩肩雙滑……”熟悉的歌曲，又在耳邊響起時。 這歌詞中的水，就有貴州的水，準確的說，是貴州的黃果樹瀑布；那一簾瀑布，流進了我們的童年，讓我們流連忘返。 黃果樹瀑布並不是只有一個瀑布，而是一個大景區，包括陡坡塘瀑布、天星橋景區、黃果樹大瀑布，其中黃果樹大瀑布是最有名的。

  • 數據清洗後

記得 小時候 守 電視機 前 等候 西遊記 播出 挑 擔 牽 馬 翻山 涉水 兩肩 雙滑 熟悉 歌曲 耳邊 響起 時 歌詞 中 水 貴州 水 準確 說 貴州 黃果樹瀑布 那一簾 瀑布 流進 童年 流連忘返 黃果樹瀑布 瀑布 景區 包括 陡坡 塘 瀑布 天星橋 景區 黃果樹 瀑布 黃果樹 瀑布 有名

三.特徵提取及TF-IDF計算

1.基本概念

權重計算是指通過特徵權重來衡量特徵項在文檔表示中的重要程度，給特徵詞賦予一定的權重來衡量統計文本特徵詞。TF-IDF（Term Frequency-Invers Document Frequency）是近年來用於數據分析和資訊處理經典的權重計算技術。該技術根據特徵詞在文本中出現的次數和在整個語料中出現的文檔頻率來計算該特徵詞在整個語料中的重要程度，其優點是能過濾掉一些常見卻無關緊要的詞語，儘可能多的保留影響程度高的特徵詞。

TF-IDF的計算公式如下，式中TF-IDF表示詞頻TF和倒文本詞頻IDF的乘積，TF-IDF中權重與特徵項在文檔中出現的頻率成正比，與在整個語料中出現該特徵項的文檔數成反比。TF-IDF值越大則該特徵詞對這個文本的重要程度越高。

其中，TF詞頻的計算公式如下，ni,j 為特徵詞 ti 在訓練文本 Dj 中出現的次數，分母是文本 Dj 中所有特徵詞的個數，計算的結果即為某個特徵詞的詞頻。

倒文檔頻率（Inverse Document Frequency，簡稱IDF）是Spark Jones在1972年提出的，用於計算詞與文獻相關權重的經典方法。計算公式如下，參數|D|表示語料的文本總數，|Dt| 表示文本所包含特徵詞 tj 的數量。

在倒文檔頻率方法中，權重是隨著特徵詞的文檔數量的變化呈反向變化。如某些常用詞「我們」、「但是」、「的」等，在所有文檔中出現頻率很高，但它的IDF值卻非常低。甚至如果它每篇文檔都出現，則log1的計算結果為0，從而降低了這些常用詞的作用；相反，如果某篇介紹「人工智慧」的詞，僅僅在該篇文檔中出現很多次，它的作用就非常高。

TF-IDF技術的核心思想是如果某個特徵詞在一篇文章中出現的頻率TF高，並且在其他文章中很少出現，則認為此詞或者短語具有很好的類別區分能力，適合用來做權重計算。TF-IDF演算法簡單快速，結果也符合實際情況，是文本挖掘、情感分析、主題分布等領域的常用手段。

2.程式碼實現

Scikit-Learn中主要使用Scikit-Learn中的兩個類CountVectorizer和TfidfTransformer，用來計算詞頻和TF-IDF值。

  • CountVectorizer

該類是將文本詞轉換為詞頻矩陣的形式。比如「I am a teacher」文本共包含四個單詞，它們對應單詞的詞頻均為1，「I」、「am」、「a」、「teacher」分別出現一次。CountVectorizer將生成一個矩陣 a[M][N]，共M個文本語料，N個單詞，比如a[i][j]表示單詞j在i類文本下的詞頻。再調用fit_transform()函數計算各個詞語出現的次數，get_feature_names()函數獲取詞庫中的所有文本關鍵詞。

  • TfidTransformer

當使用CountVectorizer類計算得到詞頻矩陣後，接下來通過TfidfTransformer類實現統計vectorizer變數中每個詞語的TF-IDF值。TF-IDF值採用矩陣數組的形式存儲，每一行數據代表一個文本語料，每一行的每一列都代表其中一個特徵對應的權重，得到TF-IDF後就可以運用各種數據分析演算法進行分析，比如聚類分析、LDA主題分布、輿情分析等等。

完整程式碼：

# -*- coding:utf-8 -*-
import csv
import pandas as pd
import numpy as np
import jieba
import jieba.analyse
from scipy.sparse import coo_matrix
from sklearn import feature_extraction  
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer

#----------------------------------第一步 讀取文件--------------------------------
with open('fenci_data.csv', 'r', encoding='UTF-8') as f:
    reader = csv.DictReader(f)
    labels = []
    contents = []
    for row in reader:
        labels.append(row['label']) #0-好評 1-差評
        contents.append(row['content'])

print(labels[:5])
print(contents[:5])

#----------------------------------第二步 數據預處理--------------------------------
#將文本中的詞語轉換為詞頻矩陣 矩陣元素a[i][j] 表示j詞在i類文本下的詞頻
vectorizer = CountVectorizer()

#該類會統計每個詞語的tf-idf權值
transformer = TfidfTransformer()

#第一個fit_transform是計算tf-idf 第二個fit_transform是將文本轉為詞頻矩陣
tfidf = transformer.fit_transform(vectorizer.fit_transform(contents))
for n in tfidf[:5]:
    print(n)
print(type(tfidf))

# 獲取詞袋模型中的所有詞語  
word = vectorizer.get_feature_names()
for n in word[:10]:
    print(n)
print("單詞數量:", len(word))

#將tf-idf矩陣抽取出來，元素w[i][j]表示j詞在i類文本中的tf-idf權重
#X = tfidf.toarray()
X = coo_matrix(tfidf, dtype=np.float32).toarray() #稀疏矩陣 注意float
print(X.shape)
print(X[:10])

輸出結果如下所示：

<class 'scipy.sparse.csr.csr_matrix'>
aaaaa
achievements
amazing
ananananan
ancient
anshun
aperture
app

單詞數量: 20254
(6074, 20254)
[[0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 ...
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]]

3.MemoryError記憶體溢出錯誤

當我們數據量很大時，矩陣往往存儲不了這麼大的數據，會出現如下錯誤：

  • ValueError: array is too big; arr.size * arr.dtype.itemsize is larger than the maximum possible size.
  • MemoryError: Unable to allocate array with shape (26771, 69602) and data type float64

我提供的解決方法如下：

  • 停用詞過濾降低不需要的特徵詞
  • scipy包的提供了稀疏矩陣的創建，使用coo_matrix(tfidf, dtype=np.float32)轉換tfidf
  • CountVectorizer(min_df=5)增加min_df參數，過濾掉出現頻率少的特徵詞，該參數可以不斷調試
    max_df用於刪除過於頻繁出現的術語，稱為語料庫特定的停用詞，默認的max_df是1.0即忽略出現在100％文檔的術語；min_df用於刪除不經常出現的術語min_df=5表示忽略少於5個文檔中出現的術語。
  • 使用GPU或擴大記憶體解決

四.基於邏輯回歸的情感分類

獲取文本TF-IDF值之後，本小節簡單講解使用TF-IDF值進行情感分類的過程，主要包括如下步驟：

  • 對中文分詞和數據清洗後的語料進行詞頻矩陣生成操作。主要調用CountVectorizer類計算詞頻矩陣，生成的矩陣為X。
  • 調用TfidfTransformer類計算詞頻矩陣X的TF-IDF值，得到Weight權重矩陣。
  • 調用Sklearn機器學習包執行分類操作，調用fit()函數訓練，並將預測的類標賦值給pre數組。
  • 調用Sklearn庫PCA()函數進行降維操作，將這些特徵降低為二維，對應X和Y軸，接著進行可視化呈現。
  • 演算法優化及演算法評估。

邏輯回歸完整程式碼：

# -*- coding:utf-8 -*-
import csv
import pandas as pd
import numpy as np
import jieba
import jieba.analyse
from scipy.sparse import coo_matrix
from sklearn import feature_extraction  
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn import svm
from sklearn import neighbors
from sklearn.naive_bayes import MultinomialNB

#----------------------------------第一步 讀取文件--------------------------------
with open('fenci_data.csv', 'r', encoding='UTF-8') as f:
    reader = csv.DictReader(f)
    labels = []
    contents = []
    for row in reader:
        labels.append(row['label']) #0-好評 1-差評
        contents.append(row['content'])

print(labels[:5])
print(contents[:5])

#----------------------------------第二步 數據預處理--------------------------------
#將文本中的詞語轉換為詞頻矩陣 矩陣元素a[i][j] 表示j詞在i類文本下的詞頻
vectorizer = CountVectorizer(min_df=5)

#該類會統計每個詞語的tf-idf權值
transformer = TfidfTransformer()

#第一個fit_transform是計算tf-idf 第二個fit_transform是將文本轉為詞頻矩陣
tfidf = transformer.fit_transform(vectorizer.fit_transform(contents))
for n in tfidf[:5]:
    print(n)
print(type(tfidf))

# 獲取詞袋模型中的所有詞語  
word = vectorizer.get_feature_names()
for n in word[:10]:
    print(n)
print("單詞數量:", len(word))

#將tf-idf矩陣抽取出來，元素w[i][j]表示j詞在i類文本中的tf-idf權重
#X = tfidf.toarray()
X = coo_matrix(tfidf, dtype=np.float32).toarray() #稀疏矩陣 注意float
print(X.shape)
print(X[:10])

#----------------------------------第三步 數據劃分--------------------------------
#使用 train_test_split 分割 X y 列表
X_train, X_test, y_train, y_test = train_test_split(X, 
                                                    labels, 
                                                    test_size=0.3, 
                                                    random_state=1)

#--------------------------------第四步 機器學習分類--------------------------------
# 邏輯回歸分類方法模型
LR = LogisticRegression(solver='liblinear')
LR.fit(X_train, y_train)
print('模型的準確度:{}'.format(LR.score(X_test, y_test)))
pre = LR.predict(X_test)
print("邏輯回歸分類")
print(len(pre), len(y_test))
print(classification_report(y_test, pre))
print("\n")

運行結果如下圖所示：

五.演算法性能評估

演算法評價很多實時需要我們自己編寫程式去實現，比如繪製ROC曲線、統計各種特徵資訊、顯示4位數結果。這裡作者嘗試自定義準確率（Precision）、召回率（Recall）和F特徵值（F-measure），其計算公式如下：

由於本文主要針對2分類問題，其實驗評估主要分為0和1兩類，完整程式碼如下：

# -*- coding:utf-8 -*-
import csv
import pandas as pd
import numpy as np
import jieba
import jieba.analyse
from scipy.sparse import coo_matrix
from sklearn import feature_extraction  
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn import svm
from sklearn import neighbors
from sklearn.naive_bayes import MultinomialNB

#----------------------------------第一步 讀取文件--------------------------------
with open('fenci_data.csv', 'r', encoding='UTF-8') as f:
    reader = csv.DictReader(f)
    labels = []
    contents = []
    for row in reader:
        labels.append(row['label']) #0-好評 1-差評
        contents.append(row['content'])

print(labels[:5])
print(contents[:5])

#----------------------------------第二步 數據預處理--------------------------------
#將文本中的詞語轉換為詞頻矩陣 矩陣元素a[i][j] 表示j詞在i類文本下的詞頻
vectorizer = CountVectorizer(min_df=5)

#該類會統計每個詞語的tf-idf權值
transformer = TfidfTransformer()

#第一個fit_transform是計算tf-idf 第二個fit_transform是將文本轉為詞頻矩陣
tfidf = transformer.fit_transform(vectorizer.fit_transform(contents))
for n in tfidf[:5]:
    print(n)
print(type(tfidf))

# 獲取詞袋模型中的所有詞語  
word = vectorizer.get_feature_names()
for n in word[:10]:
    print(n)
print("單詞數量:", len(word))

#將tf-idf矩陣抽取出來，元素w[i][j]表示j詞在i類文本中的tf-idf權重
#X = tfidf.toarray()
X = coo_matrix(tfidf, dtype=np.float32).toarray() #稀疏矩陣 注意float
print(X.shape)
print(X[:10])

#----------------------------------第三步 數據劃分--------------------------------
#使用 train_test_split 分割 X y 列表
X_train, X_test, y_train, y_test = train_test_split(X, 
                                                    labels, 
                                                    test_size=0.3, 
                                                    random_state=1)

#--------------------------------第四步 機器學習分類--------------------------------
# 邏輯回歸分類方法模型
LR = LogisticRegression(solver='liblinear')
LR.fit(X_train, y_train)
print('模型的準確度:{}'.format(LR.score(X_test, y_test)))
pre = LR.predict(X_test)
print("邏輯回歸分類")
print(len(pre), len(y_test))
print(classification_report(y_test, pre))

#----------------------------------第五步 評價結果--------------------------------
def classification_pj(name, y_test, pre):
    print("演算法評價:", name)
 
    # 正確率 Precision = 正確識別的個體總數 /  識別出的個體總數
    # 召回率 Recall = 正確識別的個體總數 /  測試集中存在的個體總數
    # F值 F-measure = 正確率 * 召回率 * 2 / (正確率 + 召回率)

    YC_B, YC_G = 0,0  #預測 bad good
    ZQ_B, ZQ_G = 0,0  #正確
    CZ_B, CZ_G = 0,0  #存在

    #0-good 1-bad 同時計算防止類標變化
    i = 0
    while i<len(pre):
        z = int(y_test[i])   #真實 
        y = int(pre[i])      #預測

        if z==0:
            CZ_G += 1
        else:
            CZ_B += 1
 
        if y==0:
            YC_G += 1
        else:
            YC_B += 1

        if z==y and z==0 and y==0:
            ZQ_G += 1
        elif z==y and z==1 and y==1:
            ZQ_B += 1
        i = i + 1

    print(ZQ_B, ZQ_G, YC_B, YC_G, CZ_B, CZ_G)
    print("")

    # 結果輸出
    P_G = ZQ_G * 1.0 / YC_G
    P_B = ZQ_B * 1.0 / YC_B
    print("Precision Good 0:", P_G)
    print("Precision Bad 1:", P_B)

    R_G = ZQ_G * 1.0 / CZ_G
    R_B = ZQ_B * 1.0 / CZ_B
    print("Recall Good 0:", R_G)
    print("Recall Bad 1:", R_B)

    F_G = 2 * P_G * R_G / (P_G + R_G)
    F_B = 2 * P_B * R_B / (P_B + R_B)
    print("F-measure Good 0:", F_G)
    print("F-measure Bad 1:", F_B)

#函數調用
classification_pj("LogisticRegression", y_test, pre)

輸出結果如下：

邏輯回歸分類
1823 1823
              precision    recall  f1-score   support

           0       0.94      0.99      0.97      1520
           1       0.93      0.70      0.80       303

    accuracy                           0.94      1823
   macro avg       0.94      0.85      0.88      1823
weighted avg       0.94      0.94      0.94      1823

演算法評價: LogisticRegression
213 1504 229 1594 303 1520

Precision Good 0: 0.9435382685069009
Precision Bad 1: 0.9301310043668122
Recall Good 0: 0.9894736842105263
Recall Bad 1: 0.7029702970297029
F-measure Good 0: 0.9659601798330122
F-measure Bad 1: 0.800751879699248

六.演算法對比實驗

1.RandomForest

程式碼如下：

# 隨機森林分類方法模型 n_estimators：森林中樹的數量
clf = RandomForestClassifier(n_estimators=20)
clf.fit(X_train, y_train)
print('模型的準確度:{}'.format(clf.score(X_test, y_test)))
print("\n")
pre = clf.predict(X_test)
print('預測結果:', pre[:10])
print(len(pre), len(y_test))
print(classification_report(y_test, pre))
classification_pj("RandomForest", y_test, pre)
print("\n")

輸出結果：

2.SVM

程式碼如下：

# SVM分類方法模型
SVM = svm.LinearSVC() #支援向量機分類器LinearSVC
SVM.fit(X_train, y_train)
print('模型的準確度:{}'.format(SVM.score(X_test, y_test)))
pre = SVM.predict(X_test)
print("支援向量機分類")
print(len(pre), len(y_test))
print(classification_report(y_test, pre))
classification_pj("LinearSVC", y_test, pre)
print("\n")

輸出結果：

3.樸素貝葉斯

程式碼如下：

#樸素貝葉斯模型
nb = MultinomialNB()
nb.fit(X_train, y_train)
print('模型的準確度:{}'.format(nb.score(X_test, y_test)))
pre = nb.predict(X_test)
print("樸素貝葉斯分類")
print(len(pre), len(y_test))
print(classification_report(y_test, pre))
classification_pj("MultinomialNB", y_test, pre)
print("\n")

輸出結果：

4.KNN

該演算法準確率不高，並且執行時間較長，不建議大家用於文本分析。某些情況的演算法對比倒是還行，核心程式碼如下：

#最近鄰演算法
knn = neighbors.KNeighborsClassifier(n_neighbors=7) 
knn.fit(X_train, y_train)
print('模型的準確度:{}'.format(knn.score(X_test, y_test)))
pre = knn.predict(X_test)
print("最近鄰分類")
print(classification_report(y_test, pre))
classification_pj("KNeighbors", y_test, pre)
print("\n")

輸出結果：

5.決策樹

程式碼如下：

#決策樹演算法
dtc = DecisionTreeClassifier()
dtc.fit(X_train, y_train)
print('模型的準確度:{}'.format(dtc.score(X_test, y_test)))
pre = dtc.predict(X_test)
print("決策樹分類")
print(len(pre), len(y_test))
print(classification_report(y_test, pre))
classification_pj("DecisionTreeClassifier", y_test, pre)
print("\n")

輸出結果：

6.SGD

程式碼如下：

#SGD分類模型
from sklearn.linear_model.stochastic_gradient import SGDClassifier
sgd = SGDClassifier()
sgd.fit(X_train, y_train)
print('模型的準確度:{}'.format(sgd.score(X_test, y_test)))
pre = sgd.predict(X_test)
print("SGD分類")
print(len(pre), len(y_test))
print(classification_report(y_test, pre))
classification_pj("SGDClassifier", y_test, pre)
print("\n")

輸出結果：

7.MLP

該演算法時間比較慢，核心程式碼如下：

#MLP分類模型
from sklearn.neural_network.multilayer_perceptron import MLPClassifier
mlp = MLPClassifier()
mlp.fit(X_train, y_train)
print('模型的準確度:{}'.format(mlp.score(X_test, y_test)))
pre = mlp.predict(X_test)
print("MLP分類")
print(len(pre), len(y_test))
print(classification_report(y_test, pre))
classification_pj("MLPClassifier", y_test, pre)
print("\n")

輸出結果：

8.GradientBoosting

該演算法時間比較慢，程式碼如下：

#GradientBoosting分類模型
from sklearn.ensemble import GradientBoostingClassifier
gb = GradientBoostingClassifier()
gb.fit(X_train, y_train)
print('模型的準確度:{}'.format(gb.score(X_test, y_test)))
pre = gb.predict(X_test)
print("GradientBoosting分類")
print(len(pre), len(y_test))
print(classification_report(y_test, pre))
classification_pj("GradientBoostingClassifier", y_test, pre)
print("\n")

輸出結果：

9.AdaBoost

程式碼如下：

#AdaBoost分類模型
from sklearn.ensemble import AdaBoostClassifier
AdaBoost = AdaBoostClassifier()
AdaBoost.fit(X_train, y_train)
print('模型的準確度:{}'.format(AdaBoost.score(X_test, y_test)))
pre = AdaBoost.predict(X_test)
print("AdaBoost分類")
print(len(pre), len(y_test))
print(classification_report(y_test, pre))
classification_pj("AdaBoostClassifier", y_test, pre)
print("\n")

輸出結果：

 

點擊關注，第一時間了解華為雲新鮮技術~

Tags:

VirMach 便宜 VPS

QNews

QNews