S30L01 – 投票分类器

html
掌握机器学习中的集成技术：深入探讨投票分类器和手动集成
在不断发展的机器学习领域，实现最佳模型性能通常需要利用多种算法。这就是集成技术发挥作用的地方。集成方法结合了各种模型的优势，提供比任何单一模型更准确和更强大的预测。在本综合指南中，我们将探讨两种关键的集成技术：投票分类器和手动集成。我们将通过 Python 的 scikit-learn 库实现它们，并结合 Kaggle 的天气数据集的实际示例。

目录

    集成技术简介
    理解投票分类器
        
            硬投票与软投票
            在 Python 中实施投票分类器
        
    
    探索手动集成方法
        
            手动集成实施步骤
        
    
    实际应用：天气预测
        
            数据预处理
            模型构建
            评估集成方法
        
    
    结论



集成技术简介
集成学习是机器学习中的一种强大范式，其中多个模型，通常称为“弱学习器”，被策略性地组合以形成一个“强学习器”。基本前提是，虽然单个模型的准确性可能存在差异，但它们的集体智慧可以导致性能的提升、方差的减少和泛化能力的增强。

为什么使用集成技术？

    提高准确性：结合多个模型通常会带来更好的预测性能。
    减少过拟合：集成方法可以通过平衡单个模型的偏差和方差来缓解过拟合。
    多功能性：适用于各种领域，并且兼容不同类型的模型。



理解投票分类器
投票分类器是最简单且最有效的集成方法之一。它结合多个不同模型的预测，并输出获得多数票的类别。

硬投票与软投票

    硬投票：最终预测是每个模型预测类别的众数。基本上，每个模型都有一票，获得最多票数的类别获胜。
    软投票：软投票不仅依赖于预测类别，还考虑每个类别的预测概率。最终预测基于概率的总和，选择具有最高聚合概率的类别。


在 Python 中实施投票分类器
让我们深入探讨如何使用 Python 的 scikit-learn 库进行实际实现。我们将利用一个天气数据集来预测明天是否会下雨。

1. 导入必要的库




		
		
			
			
Java
			
			import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.metrics import accuracy_score, classification_report
			
				
					
				
					1
2
3
4
5
6
7
8
				
						import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.metrics import accuracy_score, classification_report
					
				
			
		



2. 数据加载和预处理




		
		
			
			
Java
			
			# Load the dataset
data = pd.read_csv('weatherAUS - tiny.csv')

# Display the last few rows
print(data.tail())
			
				
					
				
					1
2
3
4
5
				
						# Load the dataset
data = pd.read_csv('weatherAUS - tiny.csv')
 
# Display the last few rows
print(data.tail())
					
				
			
		



3. 处理缺失数据




		
		
			
			
Java
			
			# Separate features and target
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

# Numeric columns
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
imputer_num = SimpleImputer(strategy='mean')
X[numerical_cols] = imputer_num.fit_transform(X[numerical_cols])

# Categorical columns
categorical_cols = X.select_dtypes(include=['object']).columns
imputer_cat = SimpleImputer(strategy='most_frequent')
X[categorical_cols] = imputer_cat.fit_transform(X[categorical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						# Separate features and target
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
 
# Numeric columns
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
imputer_num = SimpleImputer(strategy='mean')
X[numerical_cols] = imputer_num.fit_transform(X[numerical_cols])
 
# Categorical columns
categorical_cols = X.select_dtypes(include=['object']).columns
imputer_cat = SimpleImputer(strategy='most_frequent')
X[categorical_cols] = imputer_cat.fit_transform(X[categorical_cols])
					
				
			
		



4. 编码分类变量




		
		
			
			
Java
			
			# One-Hot Encoding
encoder = OneHotEncoder(drop='first', sparse=False)
encoded_cols = encoder.fit_transform(X[categorical_cols])
encoded_col_names = encoder.get_feature_names_out(categorical_cols)
X_encoded = pd.DataFrame(encoded_cols, columns=encoded_col_names)

# Combine with numerical features
X = pd.concat([X[numerical_cols], X_encoded], axis=1)
			
				
					
				
					1
2
3
4
5
6
7
8
				
						# One-Hot Encoding
encoder = OneHotEncoder(drop='first', sparse=False)
encoded_cols = encoder.fit_transform(X[categorical_cols])
encoded_col_names = encoder.get_feature_names_out(categorical_cols)
X_encoded = pd.DataFrame(encoded_cols, columns=encoded_col_names)
 
# Combine with numerical features
X = pd.concat([X[numerical_cols], X_encoded], axis=1)
					
				
			
		



5. 特征选择




		
		
			
			
Java
			
			# Feature Scaling
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Selecting top 5 features
selector = SelectKBest(score_func=chi2, k=5)
X_new = selector.fit_transform(X_scaled, y)
selected_features = selector.get_support(indices=True)
feature_names = X.columns[selected_features]
print(f"Selected Features: {feature_names}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						# Feature Scaling
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
 
# Selecting top 5 features
selector = SelectKBest(score_func=chi2, k=5)
X_new = selector.fit_transform(X_scaled, y)
selected_features = selector.get_support(indices=True)
feature_names = X.columns[selected_features]
print(f"Selected Features: {feature_names}")
					
				
			
		



6. 训练集与测试集划分




		
		
			
			
Java
			
			X_train, X_test, y_train, y_test = train_test_split(
    X_new, y, test_size=0.20, random_state=1
)
			
				
					
				
					1
2
3
				
						X_train, X_test, y_train, y_test = train_test_split(
    X_new, y, test_size=0.20, random_state=1
)
					
				
			
		



7. 构建单个分类器




		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
import xgboost as xgb

# Initialize models
knn = KNeighborsClassifier(n_neighbors=3)
lr = LogisticRegression(random_state=0, max_iter=200)
gnb = GaussianNB()
svc = SVC(probability=True)
dtc = DecisionTreeClassifier()
rfc = RandomForestClassifier(n_estimators=500, max_depth=5)
abc = AdaBoostClassifier()
xgb_model = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
import xgboost as xgb
 
# Initialize models
knn = KNeighborsClassifier(n_neighbors=3)
lr = LogisticRegression(random_state=0, max_iter=200)
gnb = GaussianNB()
svc = SVC(probability=True)
dtc = DecisionTreeClassifier()
rfc = RandomForestClassifier(n_estimators=500, max_depth=5)
abc = AdaBoostClassifier()
xgb_model = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
					
				
			
		



8. 训练和评估单个模型




		
		
			
			
Java
			
			# List of models and their names
models = [
    ('KNN', knn),
    ('Logistic Regression', lr),
    ('GaussianNB', gnb),
    ('SVC', svc),
    ('Decision Tree', dtc),
    ('Random Forest', rfc),
    ('AdaBoost', abc),
    ('XGBoost', xgb_model)
]

# Training and evaluating
for name, model in models:
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f"{name} Accuracy: {accuracy:.4f}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						# List of models and their names
models = [
    ('KNN', knn),
    ('Logistic Regression', lr),
    ('GaussianNB', gnb),
    ('SVC', svc),
    ('Decision Tree', dtc),
    ('Random Forest', rfc),
    ('AdaBoost', abc),
    ('XGBoost', xgb_model)
]
 
# Training and evaluating
for name, model in models:
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f"{name} Accuracy: {accuracy:.4f}")
					
				
			
		


样本输出：




		
		
			
			
Java
			
			KNN Accuracy: 0.8455
Logistic Regression Accuracy: 0.8690
GaussianNB Accuracy: 0.8220
SVC Accuracy: 0.8700
Decision Tree Accuracy: 0.8345
Random Forest Accuracy: 0.8720
AdaBoost Accuracy: 0.8715
XGBoost Accuracy: 0.8650
			
				
					
				
					1
2
3
4
5
6
7
8
				
						KNN Accuracy: 0.8455
Logistic Regression Accuracy: 0.8690
GaussianNB Accuracy: 0.8220
SVC Accuracy: 0.8700
Decision Tree Accuracy: 0.8345
Random Forest Accuracy: 0.8720
AdaBoost Accuracy: 0.8715
XGBoost Accuracy: 0.8650
					
				
			
		



9. 实施投票分类器




		
		
			
			
Java
			
			from sklearn.ensemble import VotingClassifier

# Initialize Voting Classifier with soft voting
voting_clf = VotingClassifier(
    estimators=[
        ('knn', knn),
        ('lr', lr),
        ('gnb', gnb),
        ('svc', svc),
        ('dtc', dtc),
        ('rfc', rfc),
        ('abc', abc),
        ('xgb', xgb_model)
    ],
    voting='soft'
)

# Train Voting Classifier
voting_clf.fit(X_train, y_train)

# Predict and evaluate
y_pred_voting = voting_clf.predict(X_test)
voting_accuracy = accuracy_score(y_pred_voting, y_test)
print(f"Voting Classifier Accuracy: {voting_accuracy:.4f}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
				
						from sklearn.ensemble import VotingClassifier
 
# Initialize Voting Classifier with soft voting
voting_clf = VotingClassifier(
    estimators=[
        ('knn', knn),
        ('lr', lr),
        ('gnb', gnb),
        ('svc', svc),
        ('dtc', dtc),
        ('rfc', rfc),
        ('abc', abc),
        ('xgb', xgb_model)
    ],
    voting='soft'
)
 
# Train Voting Classifier
voting_clf.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_voting = voting_clf.predict(X_test)
voting_accuracy = accuracy_score(y_pred_voting, y_test)
print(f"Voting Classifier Accuracy: {voting_accuracy:.4f}")
					
				
			
		


样本输出：




		
		
			
			
Java
			
			Voting Classifier Accuracy: 0.8650
			
				
					
				
					1
				
						Voting Classifier Accuracy: 0.8650
					
				
			
		




探索手动集成方法
虽然投票分类器提供了一种直接的集成学习方法，手动集成方法通过允许自定义策略来组合模型预测，提供了更大的灵活性。本节将通过平均各个分类器的预测概率来讲解手动集成的实施过程。

手动集成实施步骤

1. 使用单个模型预测概率




		
		
			
			
Java
			
			# Predict probabilities with KNN
p1 = knn.predict_proba(X_test)

# Predict probabilities with Logistic Regression
p2 = lr.predict_proba(X_test)
			
				
					
				
					1
2
3
4
5
				
						# Predict probabilities with KNN
p1 = knn.predict_proba(X_test)
 
# Predict probabilities with Logistic Regression
p2 = lr.predict_proba(X_test)
					
				
			
		



2. 平均概率




		
		
			
			
Java
			
			# Average the predicted probabilities
p_avg = (p1 + p2) / 2
			
				
					
				
					1
2
				
						# Average the predicted probabilities
p_avg = (p1 + p2) / 2
					
				
			
		



3. 基于平均概率的最终预测




		
		
			
			
Java
			
			# Convert averaged probabilities to final predictions
y_pred_manual = np.argmax(p_avg, axis=1)

# Evaluate accuracy
manual_accuracy = accuracy_score(y_pred_manual, y_test)
print(f"Manual Ensemble Accuracy: {manual_accuracy:.4f}")
			
				
					
				
					1
2
3
4
5
6
				
						# Convert averaged probabilities to final predictions
y_pred_manual = np.argmax(p_avg, axis=1)
 
# Evaluate accuracy
manual_accuracy = accuracy_score(y_pred_manual, y_test)
print(f"Manual Ensemble Accuracy: {manual_accuracy:.4f}")
					
				
			
		


样本输出：




		
		
			
			
Java
			
			Manual Ensemble Accuracy: 0.8600
			
				
					
				
					1
				
						Manual Ensemble Accuracy: 0.8600
					
				
			
		




实际应用：天气预测
为了说明集成技术的应用，我们将使用 Kaggle 的一个天气数据集，该数据集基于各种气象因素预测明天是否会下雨。

数据预处理
适当的数据预处理对于构建有效的机器学习模型至关重要。这包括处理缺失值、编码分类变量、选择相关特征和对数据进行缩放。

1. 处理缺失数据

    数值特征：使用均值策略进行填补。
    分类特征：使用最频繁策略进行填补。


2. 编码分类变量

    独热编码：应用于具有两个以上唯一类别的分类特征。
    标签编码：应用于二元分类特征。


3. 特征选择
使用 SelectKBest 结合卡方统计量选择与目标变量具有最强关系的前5个特征。

4. 特征缩放
应用 StandardScaler 来规范化特征集，确保每个特征在模型性能中均等贡献。

模型构建
构建并评估了几个单独的分类器，包括 K 近邻、逻辑回归、高斯朴素贝叶斯、支持向量机、决策树、随机森林、AdaBoost 和 XGBoost。

评估集成方法
实施了投票分类器和手动集成，以评估它们相对于单个模型的性能。


结论
集成技术，特别是投票分类器和手动集成，是机器学习从业者的宝贵工具。通过策略性地结合多个模型，这些方法提高了预测性能，降低了过拟合的风险，并利用了多种算法的优势。无论您是追求更高的准确性还是更强健的模型，掌握集成方法都能显著提升您的机器学习项目。

关键要点：

    投票分类器：通过多数投票或概率平均，提供了一种简单而有效的组合多个模型的方法。
    手动集成：提供了对如何组合预测的精细控制，允许定制策略，能够超越标准化的集成方法。
    数据预处理：确保您的模型在干净、结构良好的数据上进行训练，这是集成技术效果的直接影响因素。
    模型评估：始终将集成方法与单个模型进行比较，以验证其附加价值。

拥抱集成学习，释放您的机器学习模型的全部潜力，在项目中推动更准确、可靠的预测。


关键词：集成技术，投票分类器，手动集成，机器学习，Python，scikit-learn，模型准确性，数据预处理，特征选择，天气预测，K 近邻，逻辑回归，高斯朴素贝叶斯，支持向量机，决策树，随机森林，AdaBoost，XGBoost