案例背景
trec06c是非常經典的郵件分類的數據，還是難能可貴的中文數據集。
這個數據集從一堆txt壓縮包里面提取出來整理為excel文件還真不容不易，肯定要做一下文本分類。
雖然現在文本分類基本都是深度學習了，但是傳統的機器學習也能做。本案例就演示傳統的貝葉斯，向量機，k近鄰，這種傳統模型怎么做郵件分類。
數據介紹
數據前3行，label是標簽，spam是垃圾郵件，ham是正常郵件。content就是純文字，中文的，還是很整潔的。
當然，需要本次案例演示數據和全部代碼文件的可以參考：郵件分類
代碼實現
導入需要的包、
import glob,random,re,math
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
plt.rcParams['font.sans-serif'] = ['KaiTi'] #指定默認字體 SimHei黑體
plt.rcParams['axes.unicode_minus'] = False #解決保存圖像是負號'from collections import Counter
from wordcloud import WordCloud
from matplotlib import colors
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split讀取數據
展示前3行
df1=pd.read_csv('email_data.csv')
df1.head(3)
統計一下數量
df1['Label'].value_counts() #統計
4w多的垃圾郵件，2w多的正常郵件，不平衡，我們抽取5k的正常郵件和5k的垃圾郵件合并作為數據。
數據量有點多，我正負樣本都抽取5k條。
# 從 DataFrame 中分別抽取 5k條垃圾郵件和 5k 條正常郵件，并合并
number=5000
df = pd.concat([df1[df1['Label'] == 'spam'].sample(n=number, random_state=7), # 抽取 5k 條垃圾郵件df1[df1['Label'] == 'ham'].sample(n=number, random_state=7) # 抽取 5k 條正常郵件
]).reset_index(drop=True) # 重置索引
df['Label'].value_counts()
畫圖查看：
plt.figure(figsize=(4,3),dpi=128)
sns.countplot(x=df['Label'])
#顯示圖像
plt.show()
分詞
中文文本都需要進行分詞，需要把里面的標點符號，通用詞去一下，然后變成一個個切割開的單詞。
import jieba #過濾停用詞，分詞
stop_list = pd.read_csv("停用詞.txt",index_col=False,quoting=3,sep="\t",names=['stopword'], encoding='utf-8')
def txt_cut(juzi): #Jieba分詞函數lis=[w for w in jieba.lcut(juzi) if w not in stop_list.values]return (" ").join(lis)
df['text']=df['Content'].astype('str').apply(txt_cut)查看前五行、
df.head()
后面的文本中間都像英文的空格一樣分開了。
然后，再把漏掉的標點符號，占位符，去一下
df['text']=df['text'].apply(lambda x: x.replace('）','').replace('( ','').replace('－','').replace('/','').replace('（ ',''))下面進行文本的分析
正常郵件
詞頻分析
這里用tf-idf的詞袋方法
from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer
from sklearn.decomposition import LatentDirichletAllocation
from sklearn.preprocessing import MinMaxScaler將文本轉為數值矩陣
df_ham=df[df['Label']=='ham'] #取出正常郵件
tf_vectorizer =TfidfVectorizer() #tf-idf詞袋
#tf_vectorizer = TfidfVectorizer(ngram_range=(2,2)) #2元詞袋
X = tf_vectorizer.fit_transform(df_ham['text'])
print(X.shape)feature_names = tf_vectorizer.get_feature_names_out()
tfidf_values = X.toarray()
print(feature_names.shape,tfidf_values.shape)
查看對應的詞匯名稱，tf-idf的值，權重等
# 從轉換器中提取詞匯和對應的 TF-IDF 值
data1 = {'word': tf_vectorizer.get_feature_names_out(),'frequency':np.count_nonzero(X.toarray(), axis=0),'weight': X.mean(axis=0).A.flatten(),}
df1 = pd.DataFrame(data1).sort_values(by="frequency" ,ascending=False,ignore_index=True)
df1.head()
可以儲存一下
#儲存
df1.to_excel('正常郵件詞頻.xlsx', index=False)查看評率最高前20的詞匯
#前20個頻率最高的詞匯
df2=pd.DataFrame(data1).sort_values(by="frequency" ,ascending=False,ignore_index=True)
plt.figure(figsize=(7,3),dpi=256)
sns.barplot(x=df2['word'][:20],y=df2['frequency'][:20])
plt.xticks(rotation=70,fontsize=9)
plt.ylabel('頻率')
plt.xlabel('')
#plt.title('前20個頻率最高的詞匯')
plt.show()
詞云圖?
畫出對應的詞云圖
#定義隨機生成顏色函數
def randomcolor():colorArr = ['1','2','3','4','5','6','7','8','9','A','B','C','D','E','F']color ="#"+''.join([random.choice(colorArr) for i in range(6)])return color#from imageio import imread #形狀設置
#mask = imread('愛心.png')
all_titles = ' '.join(df_ham['text'])
# Word segmentation
seg_list = jieba.cut(all_titles, cut_all=False)
seg_text = ' '.join(seg_list)
#對分詞文本做高頻詞統計
word_counts = Counter(seg_text.split())
word_counts_updated=word_counts.most_common()
#過濾標點符號
non_chinese_pattern = re.compile(r'[^\u4e00-\u9fa5]')
# 過濾掉非中文字符的詞匯
filtered_word_counts_regex = [item for item in word_counts_updated if not non_chinese_pattern.match(item[0])]
filtered_word_counts_regex[:5]
# Generate word cloud
wordcloud = WordCloud(font_path='simhei.ttf', background_color='white', max_words=80, # Limits the number of words to 100max_font_size=50) #.generate(seg_text) #文本可以直接生成，但是不好看
wordcloud = wordcloud.generate_from_frequencies(dict(filtered_word_counts_regex))
# Display the word cloud
plt.figure(figsize=(8, 5),dpi=256)
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.show()
上面都是正常郵件的詞匯分析，下面就是垃圾郵件的分析
垃圾郵件
詞頻分析
轉為tf-idf的詞矩陣
df_spam=df[df['Label']=='spam']
tf_vectorizer =TfidfVectorizer()
#tf_vectorizer = TfidfVectorizer(ngram_range=(2,2)) #2元詞袋
X = tf_vectorizer.fit_transform(df_spam['text'])
#print(tf_vectorizer.get_feature_names_out())
print(X.shape)feature_names = tf_vectorizer.get_feature_names_out()
tfidf_values = X.toarray()
print(feature_names.shape,tfidf_values.shape)
# 從轉換器中提取詞匯和對應的 TF-IDF 值
data1 = {'word': tf_vectorizer.get_feature_names_out(),'frequency':np.count_nonzero(X.toarray(), axis=0),'weight': X.mean(axis=0).A.flatten(),}
df1 = pd.DataFrame(data1).sort_values(by="frequency" ,ascending=False,ignore_index=True)
df1.head()
儲存一下，可以看到com較多，說明垃圾郵件里面的很多網址鏈接
也可以儲存一下
#儲存
df1.to_excel('垃圾郵件詞頻.xlsx', index=False)前20個詞匯
#前20個頻率最高的詞匯
df2=pd.DataFrame(data1).sort_values(by="frequency" ,ascending=False,ignore_index=True)
plt.figure(figsize=(7,3),dpi=256)
sns.barplot(x=df2['word'][:20],y=df2['frequency'][:20])
plt.xticks(rotation=70,fontsize=9)
plt.ylabel('頻率')
plt.xlabel('')
#plt.title('前20個頻率最高的詞匯')
plt.show()
詞云圖
#from imageio import imread #形狀設置
#mask = imread('愛心.png')
all_titles = ' '.join(df_spam['text'])
# Word segmentation
seg_list = jieba.cut(all_titles, cut_all=False)
seg_text = ' '.join(seg_list)
#對分詞文本做高頻詞統計
word_counts = Counter(seg_text.split())
word_counts_updated=word_counts.most_common()
#過濾標點符號
non_chinese_pattern = re.compile(r'[^\u4e00-\u9fa5]')
# 過濾掉非中文字符的詞匯
filtered_word_counts_regex = [item for item in word_counts_updated if not non_chinese_pattern.match(item[0])]
filtered_word_counts_regex[:5]
# Generate word cloud
wordcloud = WordCloud(font_path='simhei.ttf', background_color='white', max_words=80, # Limits the number of words to 100max_font_size=50) #.generate(seg_text) #文本可以直接生成，但是不好看
wordcloud = wordcloud.generate_from_frequencies(dict(filtered_word_counts_regex))
# Display the word cloud
plt.figure(figsize=(8, 5),dpi=256)
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.show()
機器學習
#準備X和y，還是一樣的tf-idf的詞表矩陣，這里限制一下矩陣的維度為5000，免得數據維度太大了訓練時間很長。
#取出X和y
X = df['text']
y = df['Label']
#創建一個TfidfVectorizer的實例
vectorizer = TfidfVectorizer(max_features=5000,max_df=0.1,min_df=3)
#使用Tfidf將文本轉化為向量
X = vectorizer.fit_transform(X)
#看看特征形狀
X.shape
查看詞匯頻率
data1 = {'word': vectorizer.get_feature_names_out(),'tfidf': X.toarray().sum(axis=0).tolist()}
df1 = pd.DataFrame(data1).sort_values(by="tfidf" ,ascending=False,ignore_index=True)
df1.head(10)
劃分訓練集和測試集
y映射一下，變成數值型
y1=y.map({'spam':1,'ham':0})
X_train, X_test, y_train, y_test =train_test_split(X,y,test_size=0.2,stratify=y,random_state = 0)
#可以檢查一下劃分后數據形狀
X_train.shape,X_test.shape, y_train.shape, y_test.shape
模型對比
#采用三種模型，對比測試集精度
from sklearn.naive_bayes import MultinomialNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC實例化模型
#樸素貝葉斯
model1 = MultinomialNB()
#K近鄰
model2 = KNeighborsClassifier(n_neighbors=100)
#支持向量機
model3 = SVC(kernel="rbf", random_state=77, probability=True)model_list=[model1,model2,model3]
model_name=['樸素貝葉斯','K近鄰','支持向量機']自定義一下訓練和評價函數
from sklearn.metrics import confusion_matrix, roc_curve, auc
from sklearn.metrics import ConfusionMatrixDisplaydef evaluate_model(model, X_train, X_test, y_train, y_test, model_name):# 訓練模型model.fit(X_train, y_train)# 計算準確率accuracy = model.score(X_test, y_test)print(f'{model_name}方法在測試集的準確率為{round(accuracy, 3)}')# 計算混淆矩陣cm = confusion_matrix(y_test, model.predict(X_test))print(f'混淆矩陣：\n{cm}')# 繪制混淆矩陣熱力圖disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['spam', 'ham'])disp.plot(cmap=plt.cm.Blues)plt.title(f'Confusion Matrix - {model_name}')plt.show()# 計算 ROC 曲線fpr, tpr, thresholds = roc_curve(y_test, model.predict_proba(X_test)[:, 1], pos_label='spam')roc_auc = auc(fpr, tpr)# 繪制 ROC 曲線plt.plot(fpr, tpr, label=f'{model_name} (AUC = {roc_auc:.6f})')plt.xlabel('False Positive Rate')plt.ylabel('True Positive Rate')plt.title('ROC Curve')plt.legend()plt.show()return accuracy對三個模型都進行一下訓練
accuracys=[]
for model, name in zip(model_list, model_name):accuracy=evaluate_model(model, X_train, X_test, y_train, y_test, name)accuracys.append(accuracy)
這個函數會畫出很多圖，混淆矩陣，ROC的圖，評價指標等。
查看三個模型的準確率
accuracys
準確率進行可視化
plt.figure(figsize=(7,3),dpi=128)
sns.barplot(y=model_name,x=accuracys,orient="h")
plt.xlabel('模型準確率')
plt.ylabel('模型名稱')
plt.xticks(fontsize=10,rotation=45)
plt.title("不同模型文本分類準確率對比")
plt.show()
支持向量機準確率最高！
ROC對比
plt.figure(figsize=(8, 6),dpi=128)# 遍歷每個模型，繪制其 ROC 曲線
for model, name in zip(model_list, model_name):model.fit(X_train, y_train) # 訓練模型fpr, tpr, _ = roc_curve(y_test, model.predict_proba(X_test)[:, 1], pos_label='spam') # 計算 ROC 曲線的參數roc_auc = auc(fpr, tpr) # 計算 AUCplt.plot(fpr, tpr, label=f'{name} (AUC = {roc_auc:.6f})') # 繪制 ROC 曲線# 繪制對角線
plt.plot([0, 1], [0, 1], linestyle='--', color='grey', label='Random')
# 設置圖形屬性
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.legend()
plt.show()
支持向量機的auc最高。
四個評價指標
模型再實例化一下，我們計算分類問題常用的四個評價指標，準確率，精準度，召回率，F1值
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report
from sklearn.metrics import cohen_kappa_score
#樸素貝葉斯
model1 = MultinomialNB()
#K近鄰
model2 = KNeighborsClassifier(n_neighbors=100)
#支持向量機
model3 = SVC(kernel="rbf", random_state=77, probability=True)model_list=[model1,model2,model3]
#model_name=['樸素貝葉斯','K近鄰','支持向量機']自定義評價指標
def evaluation(y_test, y_predict):accuracy=classification_report(y_test, y_predict,output_dict=True)['accuracy']s=classification_report(y_test, y_predict,output_dict=True)['weighted avg']precision=s['precision']recall=s['recall']f1_score=s['f1-score']#kappa=cohen_kappa_score(y_test, y_predict)return accuracy,precision,recall,f1_score #, kappa
def evaluation2(lis):array=np.array(lis)return array.mean() , array.std()循環，遍歷，預測，計算評價指標
df_eval=pd.DataFrame(columns=['Accuracy','Precision','Recall','F1_score'])
for i in range(3):model_C=model_list[i]name=model_name[i]model_C.fit(X_train, y_train)pred=model_C.predict(X_test)s=classification_report(y_test, pred)s=evaluation(y_test,pred)df_eval.loc[name,:]=list(s)查看
df_eval
可視化
bar_width = 0.4
colors = ['c', 'g', 'tomato', 'b', 'm', 'y', 'lime', 'k', 'orange', 'pink', 'grey', 'tan']
fig, axes = plt.subplots(2, 2, figsize=(7, 6), dpi=128)for i, col in enumerate(df_eval.columns):ax = axes[i//2, i%2] # 這將為每個子圖指定一個軸df_col = df_eval[col]m = np.arange(len(df_col))bars = ax.bar(x=m, height=df_col.to_numpy(), width=bar_width, color=colors)# 在柱狀圖上方顯示數值for bar in bars:yval = bar.get_height()ax.text(bar.get_x() + bar.get_width()/2, yval, round(yval, 4), ha='center', va='bottom', fontsize=8)# 設置x軸names = df_col.indexax.set_xticks(range(len(df_col)))ax.set_xticklabels(names, fontsize=10, rotation=40)# 設置y軸ax.set_ylim([0.94, df_col.max() + 0.02]) ax.set_ylabel(col, fontsize=14)plt.tight_layout()
# plt.savefig('柱狀圖.jpg', dpi=512) # 如果需要保存圖片取消注釋這行
plt.show()
很明顯支持向量機 效果最好
交叉驗證
自定義交叉驗證評價指標和函數
def evaluation(y_test, y_predict):accuracy=classification_report(y_test, y_predict,output_dict=True)['accuracy']s=classification_report(y_test, y_predict,output_dict=True)['weighted avg']precision=s['precision']recall=s['recall']f1_score=s['f1-score']#kappa=cohen_kappa_score(y_test, y_predict)return accuracy,precision,recall,f1_score #, kappa
def evaluation2(lis):array=np.array(lis)return array.mean() , array.std()from sklearn.model_selection import KFold
def cross_val(model=None,X=None,Y=None,K=5,repeated=1,show_confusion_matrix=True):df_mean=pd.DataFrame(columns=['Accuracy','Precision','Recall','F1_score']) df_std=pd.DataFrame(columns=['Accuracy','Precision','Recall','F1_score'])for n in range(repeated):print(f'正在進行第{n+1}次重復K折.....隨機數種子為{n}\n')kf = KFold(n_splits=K, shuffle=True, random_state=n)Accuracy=[]Precision=[]Recall=[]F1_score=[]print(f" 開始本次在{K}折數據上的交叉驗證.......\n")i=1for train_index, test_index in kf.split(X):print(f' 正在進行第{i}折的計算')X_train=X[train_index]y_train=np.array(y)[train_index]X_test=X[test_index]y_test=np.array(y)[test_index]model.fit(X_train,y_train)pred=model.predict(X_test)score=list(evaluation(y_test,pred))Accuracy.append(score[0])Precision.append(score[1])Recall.append(score[2])F1_score.append(score[3])if show_confusion_matrix:#數據透視表，混淆矩陣print("混淆矩陣：")table = pd.crosstab(y_test, pred, rownames=['Actual'], colnames=['Predicted'])#print(table)plt.figure(figsize=(4,3))sns.heatmap(table,cmap='Blues',fmt='.20g', annot=True)plt.tight_layout()plt.show()#計算混淆矩陣的各項指標print('混淆矩陣的各項指標為：')print(classification_report(y_test, pred))print(f' 第{i}折的準確率為：{round(score[0],4)}，Precision為{round(score[1],4)}，Recall為{round(score[2],4)}，F1_score為{round(score[3],4)}')i+=1print(f' ———————————————完成本次的{K}折交叉驗證———————————————————\n')Accuracy_mean,Accuracy_std=evaluation2(Accuracy)Precision_mean,Precision_std=evaluation2(Precision)Recall_mean,Recall_std=evaluation2(Recall)F1_score_mean,F1_score_std=evaluation2(F1_score)print(f'第{n+1}次重復K折，本次{K}折交叉驗證的總體準確率均值為{Accuracy_mean}，方差為{Accuracy_std}')print(f' 總體Precision均值為{Precision_mean}，方差為{Precision_std}')print(f' 總體Recall均值為{Recall_mean}，方差為{Recall_std}')print(f' 總體F1_score均值為{F1_score_mean}，方差為{F1_score_std}')print("\n====================================================================================================================\n")df1=pd.DataFrame(dict(zip(['Accuracy','Precision','Recall','F1_score'],[Accuracy_mean,Precision_mean,Recall_mean,F1_score_mean])),index=[n])df_mean=pd.concat([df_mean,df1])df2=pd.DataFrame(dict(zip(['Accuracy','Precision','Recall','F1_score'],[Accuracy_std,Precision_std,Recall_std,F1_score_std])),index=[n])df_std=pd.concat([df_std,df2])return df_mean,df_std實例化三個模型
model1 = MultinomialNB()
#K近鄰
model2 = KNeighborsClassifier(n_neighbors=100)
#支持向量機
model3 = SVC(kernel="rbf", random_state=77, probability=True)貝葉斯：?
model =MultinomialNB()
nb_crosseval,nb_crosseval2=cross_val(model=model,X=X,Y=y,K=5,repeated=6)
結果都打印出來的。
樸素貝葉斯的評價指標
nb_crosseval
K近鄰
model =KNeighborsClassifier(n_neighbors=100)
knn_crosseval,knn_crosseval2=cross_val(model=model,X=X,Y=y,K=5,repeated=6,show_confusion_matrix=False)不放過程了，直接上結果
knn_crosseval
支持向量機
model = SVC(kernel="rbf", random_state=77, probability=True)
svc_crosseval,svc_crosseval2=cross_val(model=model,X=X,Y=y,K=5,repeated=6,show_confusion_matrix=False)評價指標
svc_crosseval
均值的可視化
plt.subplots(1,4,figsize=(16,3),dpi=128)
for i,col in enumerate(nb_crosseval.columns):n=int(str('14')+str(i+1))plt.subplot(n)plt.plot(nb_crosseval[col], 'k', label='NB')plt.plot(knn_crosseval[col], 'b-.', label='KNN')plt.plot(svc_crosseval[col], 'r-^', label='SVC')plt.title(f'不同模型的{col}對比')plt.xlabel('重復交叉驗證次數')plt.ylabel(col,fontsize=16)plt.legend()
plt.tight_layout()
plt.show()?
方差的可視化
plt.subplots(1,4,figsize=(16,3),dpi=128)
for i,col in enumerate(nb_crosseval2.columns):n=int(str('14')+str(i+1))plt.subplot(n)plt.plot(nb_crosseval2[col], 'k', label='NB')plt.plot(knn_crosseval2[col], 'b-.', label='KNN')plt.plot(svc_crosseval2[col], 'r-^', label='SVC')plt.title(f'不同模型的{col}方差對比')plt.xlabel('重復交叉驗證次數')plt.ylabel(col,fontsize=16)plt.legend()
plt.tight_layout()
plt.show()
結論：
我們將進行三種機器學習模型的性能分析：樸素貝葉斯（Naive Bayes）、k近鄰（k-Nearest Neighbors）和支持向量機（Support Vector Machine）。
### 1. 樸素貝葉斯模型分析：
樸素貝葉斯模型在數據集上表現出了相對較高的性能。具體來說，它在準確率（Accuracy）、精確率（Precision）、召回率（Recall）和F1分數（F1-score）方面均取得了穩定的表現，分別達到了約96%的水平。這表明樸素貝葉斯模型在數據分類方面具有較高的效果，并且不易受到數據波動的影響。
### 2. k近鄰模型分析：
與樸素貝葉斯相比，k近鄰模型在性能上稍顯不及。盡管其在準確率和F1分數方面表現相當，但在精確率和召回率方面略有下降，分別在95%左右。這可能表明k近鄰模型在處理數據集中的某些特征時存在一定的困難，導致了一些分類錯誤。
### 3. 支持向量機模型分析：
支持向量機（SVM）模型在這份數據集上展現了最佳的性能。其在所有評估指標上均表現出了接近98%的高水平，包括準確率、精確率、召回率和F1分數。這表明支持向量機模型在數據分類任務中具有較強的魯棒性和泛化能力，能夠有效地捕捉數據之間的復雜關系，并進行準確的分類。
綜上所述，支持向量機模型在這份數據集上表現最佳，其穩定性和高性能使其成為首選模型。樸素貝葉斯模型在某些情況下也是一個可行的選擇，而k近鄰模型可能需要進一步優化以提高其性能。
支持向量機的準確率最高，模型波動的方差小，效果最好，下面對它進行超參數搜索。
超參數搜索
#利用K折交叉驗證搜索最優超參數
from sklearn.model_selection import KFold, StratifiedKFold
from sklearn.model_selection import GridSearchCV,RandomizedSearchCV參數范圍
param_grid = {'C': [0.1, 1, 10],'gamma': [ 0.01, 0.1, 1, 10]}model = GridSearchCV(estimator=SVC(kernel="rbf"), param_grid=param_grid, cv=3)
model.fit(X_train, y_train)
參數
model.best_params_?
評估
model = model.best_estimator_
pred=model.predict(X_test)
evaluation(y_test,pred)
對這個區間再度細化搜索
param_grid = {'C': [6,7,8,9,10,11,12,13,14],'gamma': [ 0.08,0.09,0.1,0.15,0.2,0.3]}model = GridSearchCV(estimator=SVC(kernel="rbf"), param_grid=param_grid, cv=3)
model.fit(X_train, y_train)model.best_params_?
model = model.best_estimator_
pred=model.predict(X_test)
evaluation(y_test,pred)
能達到99%準確率了。
畫圖：
import itertools
def plot_confusion_matrix(cm, classes,title='Confusion matrix',cmap=plt.cm.Blues):plt.imshow(cm, interpolation='nearest', cmap=cmap)plt.title(title)plt.colorbar()tick_marks = np.arange(len(classes))plt.xticks(tick_marks, classes, rotation=0)plt.yticks(tick_marks, classes)thresh = cm.max() / 2.for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):plt.text(j, i, cm[i, j],horizontalalignment="center",color="white" if cm[i, j] > thresh else "black")plt.tight_layout()plt.ylabel('True label')plt.xlabel('Predicted label')?最好的模型：
import time
svc=SVC(kernel="rbf",C=6 , gamma=0.09)
startTime = time.time()
svc.fit(X_train, y_train)
print('svc分類器訓練用時%.2f秒' %(time.time()-startTime))
pred=svc.predict(X_test)
print(f"準確率，精確度，召回率，F1值：{np.round(evaluation(y_test,pred),6)}")
plot_confusion_matrix(confusion_matrix(y_test,pred),[0,1])
plt.show()
模型保存
import joblib
# 模型已經選取了最佳估計器，存儲在變量 model 中
# 保存模型到文件
joblib.dump(model, 'best_model.pkl')
加載模型，然后預測
# 加載模型
loaded_model = joblib.load('best_model.pkl')
# 使用加載的模型進行預測
loaded_model.predict(X_test)
evaluation(y_test, pred)
?基本是99%的準確率，還是很好用的。
創作不易，看官覺得寫得還不錯的話點個關注和贊吧，本人會持續更新python數據分析領域的代碼文章~(需要定制類似的代碼可私信)
ii:uniapp路由響應攔截器處理token，以及微信小程序報錯當前頁面正在處于跳轉狀態，請稍后再進行跳轉....)
——完美轉發)