S29L02 – ROC，AUC – 评估最佳模型

html
使用ROC曲线和AUC评估机器学习模型：全面指南
在机器学习领域，为您的数据集选择合适的模型对于实现准确和可靠的预测至关重要。通过受试者工作特征（ROC）曲线和曲线下面积（AUC）来评估和比较模型是最有效的方法之一。本指南深入探讨了ROC曲线的理解、AUC的计算以及利用这些指标为您的二元分类任务选择性能最佳的模型。我们将通过使用Jupyter Notebook的实际示例，演示如何使用各种机器学习算法实现这些概念。

目录

    ROC曲线和AUC简介
    为何选择AUC而非准确率？
    数据集概述
    数据预处理
    模型训练与评估
        
            K近邻（KNN）
            逻辑回归
            高斯朴素贝叶斯
            支持向量机（SVM）
            决策树
            随机森林
            AdaBoost
            XGBoost
        
    
    选择最佳模型
    结论
    资源


ROC曲线和AUC简介
什么是ROC曲线？
受试者工作特征（ROC）曲线是一个图形表示，用于说明二元分类器系统在其判别阈值变化时的诊断能力。ROC曲线绘制了两个参数：

    真正率（TPR）：也称为敏感性或召回率，衡量正确识别的实际正例的比例。
    假正率（FPR）：衡量错误识别为正例的实际负例的比例。

ROC曲线能够可视化不同阈值设置下敏感性与特异性（1 - FPR）之间的权衡。
理解AUC
曲线下面积（AUC）量化了模型在区分正类和负类之间的整体能力。AUC值范围从0到1：

    AUC = 1：完美分类器。
    AUC = 0.5：无区分能力（相当于随机猜测）。
    AUC < 0.5：逆预测（比随机更差）。

AUC越高，表示模型性能越好。

为何选择AUC而非准确率？
虽然准确率衡量的是所有预测中正确预测的比例，但在类别不平衡的情况下，它可能具有误导性。例如，如果95%的数据属于一个类别，模型仅预测该类别将达到95%的准确率，但无法捕捉到少数类别。
AUC则通过考虑模型在所有分类阈值下的性能，提供了更细致的评估，使其成为不平衡数据集更可靠的指标。

数据集概述
在我们的分析中，我们将使用来自Kaggle的天气数据集。该数据集包含了不同澳大利亚地点每日记录的各种与天气相关的属性。
目标：基于今天的天气条件预测明天是否会下雨（RainTomorrow）。
类型：二元分类（Yes/No）。

数据预处理
有效的数据预处理是构建稳健的机器学习模型的基石。以下是逐步分解：
1. 导入库和数据




		
		
			
			
Java
			
			import pandas as pd 
import seaborn as sns

# Load the dataset
data = pd.read_csv('weatherAUS.csv')
data.tail()
			
				
					
				
					1
2
3
4
5
6
				
						import pandas as pd 
import seaborn as sns
 
# Load the dataset
data = pd.read_csv('weatherAUS.csv')
data.tail()
					
				
			
		


2. 分离特征和目标




		
		
			
			
Java
			
			# Features (All columns except the last one)
X = data.iloc[:, :-1]

# Target variable
y = data.iloc[:, -1]
			
				
					
				
					1
2
3
4
5
				
						# Features (All columns except the last one)
X = data.iloc[:, :-1]
 
# Target variable
y = data.iloc[:, -1]
					
				
			
		


3. 处理缺失数据
a. 数值特征




		
		
			
			
Java
			
			import numpy as np
from sklearn.impute import SimpleImputer

# Identify numeric columns
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])

# Impute missing values with mean
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X.iloc[:, numerical_cols] = imp_mean.fit_transform(X.iloc[:, numerical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						import numpy as np
from sklearn.impute import SimpleImputer
 
# Identify numeric columns
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
 
# Impute missing values with mean
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X.iloc[:, numerical_cols] = imp_mean.fit_transform(X.iloc[:, numerical_cols])
					
				
			
		


b. 分类特征




		
		
			
			
Java
			
			# Identify object (categorical) columns
string_cols = list(np.where((X.dtypes == object))[0])

# Impute missing values with the most frequent value
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X.iloc[:, string_cols] = imp_mode.fit_transform(X.iloc[:, string_cols])
			
				
					
				
					1
2
3
4
5
6
				
						# Identify object (categorical) columns
string_cols = list(np.where((X.dtypes == object))[0])
 
# Impute missing values with the most frequent value
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X.iloc[:, string_cols] = imp_mode.fit_transform(X.iloc[:, string_cols])
					
				
			
		


4. 编码分类变量
a. 目标变量的标签编码




		
		
			
			
Java
			
			from sklearn.preprocessing import LabelEncoder

# Initialize Label Encoder
le = LabelEncoder()
y = le.fit_transform(y)
			
				
					
				
					1
2
3
4
5
				
						from sklearn.preprocessing import LabelEncoder
 
# Initialize Label Encoder
le = LabelEncoder()
y = le.fit_transform(y)
					
				
			
		


b. 特征编码




		
		
			
			
Java
			
			from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

# Function to perform One-Hot Encoding
def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)], remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)

# Identify columns for One-Hot Encoding based on the number of unique categories
def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    for col in string_cols:
        unique_vals = len(pd.unique(X[X.columns[col]]))
        if unique_vals == 2 or unique_vals > threshold:
            X[X.columns[col]] = le.fit_transform(X[X.columns[col]])
        else:
            one_hot_encoding_indices.append(col)
    
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X

X = EncodingSelection(X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
				
						from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
 
# Function to perform One-Hot Encoding
def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)], remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)
 
# Identify columns for One-Hot Encoding based on the number of unique categories
def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    for col in string_cols:
        unique_vals = len(pd.unique(X[X.columns[col]]))
        if unique_vals == 2 or unique_vals > threshold:
            X[X.columns[col]] = le.fit_transform(X[X.columns[col]])
        else:
            one_hot_encoding_indices.append(col)
    
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X
 
X = EncodingSelection(X)
					
				
			
		


5. 特征选择
为了减少模型复杂性并提高性能，我们将使用卡方检验（Chi2）选择前10个特征。




		
		
			
			
Java
			
			from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler

# Initialize SelectKBest
kbest = SelectKBest(score_func=chi2, k=10)
scaler = MinMaxScaler()

# Scale features
X_scaled = scaler.fit_transform(X)

# Fit SelectKBest
kbest.fit(X_scaled, y)

# Get top 10 feature indices
best_features = np.argsort(kbest.scores_)[-10:]

# Select top features
X = X[:, best_features]
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler
 
# Initialize SelectKBest
kbest = SelectKBest(score_func=chi2, k=10)
scaler = MinMaxScaler()
 
# Scale features
X_scaled = scaler.fit_transform(X)
 
# Fit SelectKBest
kbest.fit(X_scaled, y)
 
# Get top 10 feature indices
best_features = np.argsort(kbest.scores_)[-10:]
 
# Select top features
X = X[:, best_features]
					
				
			
		


6. 分割数据集




		
		
			
			
Java
			
			from sklearn.model_selection import train_test_split

# Split data into training and testing sets (80-20 split)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn.model_selection import train_test_split
 
# Split data into training and testing sets (80-20 split)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
					
				
			
		


7. 特征缩放
标准化特征确保每个特征对结果的贡献相等。




		
		
			
			
Java
			
			from sklearn.preprocessing import StandardScaler

sc = StandardScaler(with_mean=False)
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
			
				
					
				
					1
2
3
4
5
				
						from sklearn.preprocessing import StandardScaler
 
sc = StandardScaler(with_mean=False)
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
					
				
			
		



模型训练与评估
我们将训练多种分类模型，并使用准确率和AUC来评估它们的性能。
K近邻（KNN）




		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, roc_curve, auc
import matplotlib.pyplot as plt
from sklearn import metrics

# Initialize and train KNN
knnClassifier = KNeighborsClassifier(n_neighbors=3)
knnClassifier.fit(X_train, y_train)

# Predict and evaluate
y_pred_knn = knnClassifier.predict(X_test)
accuracy_knn = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {accuracy_knn:.2f}')

# Plot ROC Curve
metrics.plot_roc_curve(knnClassifier, X_test, y_test)  
plt.title('KNN ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, roc_curve, auc
import matplotlib.pyplot as plt
from sklearn import metrics
 
# Initialize and train KNN
knnClassifier = KNeighborsClassifier(n_neighbors=3)
knnClassifier.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_knn = knnClassifier.predict(X_test)
accuracy_knn = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {accuracy_knn:.2f}')
 
# Plot ROC Curve
metrics.plot_roc_curve(knnClassifier, X_test, y_test)  
plt.title('KNN ROC Curve')
plt.show()
					
				
			
		


输出：




		
		
			
			
Java
			
			KNN Accuracy: 0.82
			
				
					
				
					1
				
						KNN Accuracy: 0.82
					
				
			
		



逻辑回归




		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

# Initialize and train Logistic Regression
LRM = LogisticRegression(random_state=0, max_iter=200)
LRM.fit(X_train, y_train)

# Predict and evaluate
y_pred_lr = LRM.predict(X_test)
accuracy_lr = accuracy_score(y_pred_lr, y_test)
print(f'Logistic Regression Accuracy: {accuracy_lr:.2f}')

# Plot ROC Curve
metrics.plot_roc_curve(LRM, X_test, y_test)  
plt.title('Logistic Regression ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.linear_model import LogisticRegression
 
# Initialize and train Logistic Regression
LRM = LogisticRegression(random_state=0, max_iter=200)
LRM.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_lr = LRM.predict(X_test)
accuracy_lr = accuracy_score(y_pred_lr, y_test)
print(f'Logistic Regression Accuracy: {accuracy_lr:.2f}')
 
# Plot ROC Curve
metrics.plot_roc_curve(LRM, X_test, y_test)  
plt.title('Logistic Regression ROC Curve')
plt.show()
					
				
			
		


输出：




		
		
			
			
Java
			
			Logistic Regression Accuracy: 0.84
			
				
					
				
					1
				
						Logistic Regression Accuracy: 0.84
					
				
			
		



注意：如果遇到收敛警告，请考虑增加max_iter或标准化您的数据。
高斯朴素贝叶斯




		
		
			
			
Java
			
			from sklearn.naive_bayes import GaussianNB

# Initialize and train GaussianNB
model_GNB = GaussianNB()
model_GNB.fit(X_train, y_train)

# Predict and evaluate
y_pred_gnb = model_GNB.predict(X_test)
accuracy_gnb = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {accuracy_gnb:.2f}')

# Plot ROC Curve
metrics.plot_roc_curve(model_GNB, X_test, y_test)  
plt.title('Gaussian Naive Bayes ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.naive_bayes import GaussianNB
 
# Initialize and train GaussianNB
model_GNB = GaussianNB()
model_GNB.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_gnb = model_GNB.predict(X_test)
accuracy_gnb = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {accuracy_gnb:.2f}')
 
# Plot ROC Curve
metrics.plot_roc_curve(model_GNB, X_test, y_test)  
plt.title('Gaussian Naive Bayes ROC Curve')
plt.show()
					
				
			
		


输出：




		
		
			
			
Java
			
			Gaussian Naive Bayes Accuracy: 0.81
			
				
					
				
					1
				
						Gaussian Naive Bayes Accuracy: 0.81
					
				
			
		



支持向量机（SVM）




		
		
			
			
Java
			
			from sklearn.svm import SVC

# Initialize and train SVM
model_SVC = SVC(probability=True)
model_SVC.fit(X_train, y_train)

# Predict and evaluate
y_pred_svc = model_SVC.predict(X_test)
accuracy_svc = accuracy_score(y_pred_svc, y_test)
print(f'SVM Accuracy: {accuracy_svc:.2f}')

# Plot ROC Curve
metrics.plot_roc_curve(model_SVC, X_test, y_test)  
plt.title('SVM ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.svm import SVC
 
# Initialize and train SVM
model_SVC = SVC(probability=True)
model_SVC.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_svc = model_SVC.predict(X_test)
accuracy_svc = accuracy_score(y_pred_svc, y_test)
print(f'SVM Accuracy: {accuracy_svc:.2f}')
 
# Plot ROC Curve
metrics.plot_roc_curve(model_SVC, X_test, y_test)  
plt.title('SVM ROC Curve')
plt.show()
					
				
			
		


输出：




		
		
			
			
Java
			
			SVM Accuracy: 0.84
			
				
					
				
					1
				
						SVM Accuracy: 0.84
					
				
			
		



决策树




		
		
			
			
Java
			
			from sklearn.tree import DecisionTreeClassifier

# Initialize and train Decision Tree
model_DTC = DecisionTreeClassifier()
model_DTC.fit(X_train, y_train)

# Predict and evaluate
y_pred_dtc = model_DTC.predict(X_test)
accuracy_dtc = accuracy_score(y_pred_dtc, y_test)
print(f'Decision Tree Accuracy: {accuracy_dtc:.2f}')

# Plot ROC Curve
metrics.plot_roc_curve(model_DTC, X_test, y_test)  
plt.title('Decision Tree ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.tree import DecisionTreeClassifier
 
# Initialize and train Decision Tree
model_DTC = DecisionTreeClassifier()
model_DTC.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_dtc = model_DTC.predict(X_test)
accuracy_dtc = accuracy_score(y_pred_dtc, y_test)
print(f'Decision Tree Accuracy: {accuracy_dtc:.2f}')
 
# Plot ROC Curve
metrics.plot_roc_curve(model_DTC, X_test, y_test)  
plt.title('Decision Tree ROC Curve')
plt.show()
					
				
			
		


输出：




		
		
			
			
Java
			
			Decision Tree Accuracy: 0.78
			
				
					
				
					1
				
						Decision Tree Accuracy: 0.78
					
				
			
		



随机森林




		
		
			
			
Java
			
			from sklearn.ensemble import RandomForestClassifier

# Initialize and train Random Forest
model_RFC = RandomForestClassifier(n_estimators=500, max_depth=5)
model_RFC.fit(X_train, y_train)

# Predict and evaluate
y_pred_rfc = model_RFC.predict(X_test)
accuracy_rfc = accuracy_score(y_pred_rfc, y_test)
print(f'Random Forest Accuracy: {accuracy_rfc:.2f}')

# Plot ROC Curve
metrics.plot_roc_curve(model_RFC, X_test, y_test)  
plt.title('Random Forest ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.ensemble import RandomForestClassifier
 
# Initialize and train Random Forest
model_RFC = RandomForestClassifier(n_estimators=500, max_depth=5)
model_RFC.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_rfc = model_RFC.predict(X_test)
accuracy_rfc = accuracy_score(y_pred_rfc, y_test)
print(f'Random Forest Accuracy: {accuracy_rfc:.2f}')
 
# Plot ROC Curve
metrics.plot_roc_curve(model_RFC, X_test, y_test)  
plt.title('Random Forest ROC Curve')
plt.show()
					
				
			
		


输出：




		
		
			
			
Java
			
			Random Forest Accuracy: 0.84
			
				
					
				
					1
				
						Random Forest Accuracy: 0.84
					
				
			
		



AdaBoost




		
		
			
			
Java
			
			from sklearn.ensemble import AdaBoostClassifier

# Initialize and train AdaBoost
model_ABC = AdaBoostClassifier()
model_ABC.fit(X_train, y_train)

# Predict and evaluate
y_pred_abc = model_ABC.predict(X_test)
accuracy_abc = accuracy_score(y_pred_abc, y_test)
print(f'AdaBoost Accuracy: {accuracy_abc:.2f}')

# Plot ROC Curve
metrics.plot_roc_curve(model_ABC, X_test, y_test)  
plt.title('AdaBoost ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.ensemble import AdaBoostClassifier
 
# Initialize and train AdaBoost
model_ABC = AdaBoostClassifier()
model_ABC.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_abc = model_ABC.predict(X_test)
accuracy_abc = accuracy_score(y_pred_abc, y_test)
print(f'AdaBoost Accuracy: {accuracy_abc:.2f}')
 
# Plot ROC Curve
metrics.plot_roc_curve(model_ABC, X_test, y_test)  
plt.title('AdaBoost ROC Curve')
plt.show()
					
				
			
		


输出：




		
		
			
			
Java
			
			AdaBoost Accuracy: 0.84
			
				
					
				
					1
				
						AdaBoost Accuracy: 0.84
					
				
			
		



XGBoost




		
		
			
			
Java
			
			import xgboost as xgb
from sklearn.exceptions import ConvergenceWarning
import warnings

# Suppress warnings
warnings.filterwarnings("ignore", category=ConvergenceWarning)
warnings.filterwarnings("ignore", category=UserWarning)

# Initialize and train XGBoost
model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
model_xgb.fit(X_train, y_train)

# Predict and evaluate
y_pred_xgb = model_xgb.predict(X_test)
accuracy_xgb = accuracy_score(y_pred_xgb, y_test)
print(f'XGBoost Accuracy: {accuracy_xgb:.2f}')

# Plot ROC Curve
metrics.plot_roc_curve(model_xgb, X_test, y_test)  
plt.title('XGBoost ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						import xgboost as xgb
from sklearn.exceptions import ConvergenceWarning
import warnings
 
# Suppress warnings
warnings.filterwarnings("ignore", category=ConvergenceWarning)
warnings.filterwarnings("ignore", category=UserWarning)
 
# Initialize and train XGBoost
model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
model_xgb.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_xgb = model_xgb.predict(X_test)
accuracy_xgb = accuracy_score(y_pred_xgb, y_test)
print(f'XGBoost Accuracy: {accuracy_xgb:.2f}')
 
# Plot ROC Curve
metrics.plot_roc_curve(model_xgb, X_test, y_test)  
plt.title('XGBoost ROC Curve')
plt.show()
					
				
			
		


输出：




		
		
			
			
Java
			
			XGBoost Accuracy: 0.85
			
				
					
				
					1
				
						XGBoost Accuracy: 0.85
					
				
			
		




选择最佳模型
在评估所有模型后，我们观察到以下准确率：

    
        模型
        准确率
        AUC
    
    
        K-Nearest Neighbors
        0.82
        0.80
    
    
        Logistic Regression
        0.84
        0.86
    
    
        Gaussian Naive Bayes
        0.81
        0.81
    
    
        SVM
        0.84
        0.86
    
    
        Decision Tree
        0.78
        0.89
    
    
        Random Forest
        0.84
        0.85
    
    
        AdaBoost
        0.84
        0.86
    
    
        XGBoost
        0.85
        0.87
    

关键观察结果：

    XGBoost以最高的准确率（85%）和强大的AUC（0.87）脱颖而出，成为表现最好的模型。
    Logistic Regression、SVM和AdaBoost也展示了可观的性能，准确率约为84%，AUC为0.86。
    Decision Tree显示了最低的准确率（78%），但AUC相对较高（0.89），表明尽管预测准确率较低，但在区分类别方面具有潜力。

结论：虽然准确率提供了一个直观的指标，但AUC提供了模型在不同阈值下性能的更深层次的见解。在本例中，XGBoost因其高准确率和强大的区分能力而成为最可靠的模型。

结论
评估机器学习模型需要多方面的方法。仅依赖准确率可能具有误导性，尤其是在类别不平衡的数据集中。ROC曲线和AUC提供了对模型性能的更全面评估，突出了其在有效区分类别方面的能力。
在本指南中，我们探讨了如何预处理数据、训练多种分类模型，并使用ROC曲线和AUC进行评估。使用Jupyter Notebook的实际实现展示了每个模型的优势，最终证明XGBoost是基于提供的数据集预测降雨的最佳选择。

资源

    ROC曲线维基百科
    AUC解释
    Kaggle天气数据集
    Scikit-Learn文档
    XGBoost文档


通过理解和利用ROC曲线和AUC，数据科学家和机器学习从业者可以在选择模型时做出更明智的决策，确保其预测任务具有更高的性能和可靠性。
模型	准确率	AUC
K-Nearest Neighbors	0.82	0.80
Logistic Regression	0.84	0.86
Gaussian Naive Bayes	0.81	0.81
SVM	0.84	0.86
Decision Tree	0.78	0.89
Random Forest	0.84	0.85
AdaBoost	0.84	0.86
XGBoost	0.85	0.87