使用Stacking集成学习(逻辑回归、随机森林)对鸢尾花数据集进行分类

Stacking集成学习的步骤

Stacking（堆叠）是一种集成学习方法，它通常使用多个基础分类器和一个元分类器来提高模型的预测性能。下面是Stacking的一般步骤：

准备数据集：从原始数据中获取训练集和测试集，并确保数据集可以被分成若干部分。

定义基础分类器：选择多个不同类型的基础分类器，并对其进行训练。这些基础分类器可以是任何类型的分类器，例如决策树、支持向量机或神经网络等。

利用基础分类器生成元特征：将训练数据集分成两部分，一部分用于训练基础分类器，另一部分用于生成元特征。对于每个基础分类器，利用其中一部分训练数据集进行训练并在剩余部分数据上生成元特征，以此来获取各个基础分类器对样本的预测结果。

构建元特征矩阵：将所有基础分类器的生成的元特征整合到一起，构成一个元特征矩阵。

训练元分d类器：使用元特征矩阵作为输入，训练一个元分类器来预测样本的目标类别。元分类器可以是任何类型的分类器，例如逻辑回归、支持向量机或神经网络等。

预测并评估：使用测试数据集来评估Stacking模型的性能。首先，利用所有基础分类器预测测试数据集，并将这些预测结果整合到一起构成一个元特征矩阵。然后，将该元特征矩阵作为输入传递给训练好的元分类器，以获得最终的预测结果。最后，通过比较预测结果和实际标签，计算模型的性能指标，例如准确率、精确率、召回率和F1分数等。

需要注意的是，Stacking的性能取决于选择的基础分类器和元分类器的类型和数量，以及如何对数据集进行划分、调参和优化等。因此，在使用Stacking时需要谨慎选择和调整参数，以获得最佳的性能。

使用逻辑回归、随机森林对鸢尾花数据集进行分类

基础分类器:；逻辑回归、随机森林
元分类器:多层感知机
code:

import torch
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression

# Check if CUDA is available
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f'Using device: {device}')

# Load the Iris dataset
iris = load_iris()
X, y = iris.data, iris.target

# Split the data into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Move the data to the device
X_train_tensor = torch.from_numpy(X_train).float().to(device)
X_test_tensor = torch.from_numpy(X_test).float().to(device)
y_train_tensor = torch.from_numpy(y_train).long().to(device)
y_test_tensor = torch.from_numpy(y_test).long().to(device)


# Define two base classifiers
rf = RandomForestClassifier(n_estimators=100, random_state=42)
lr = LogisticRegression(random_state=42)


# Split the training set into two parts
X_base, X_meta, y_base, y_meta = train_test_split(
    X_train, y_train, test_size=0.5, random_state=42)

# Train the base classifiers on the first half of the training set
rf.fit(X_base, y_base)
lr.fit(X_base, y_base)

# Predict the second half of the training set using the base classifiers
X_meta_rf = rf.predict_proba(X_meta)
X_meta_lr = lr.predict_proba(X_meta)

# Convert the predictions to PyTorch tensors
X_meta_tensor = torch.from_numpy(np.concatenate((X_meta_rf, X_meta_lr), axis=1)).float().to(device)
y_meta_tensor = torch.from_numpy(y_meta).long().to(device)


# Define the meta-classifier model
class MetaClassifier(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = torch.nn.Linear(6, 4)
        self.fc2 = torch.nn.Linear(4, 3)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

meta_classifier = MetaClassifier().to(device)


# Define the loss function and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(meta_classifier.parameters(), lr=0.01)

# Train the meta-classifier model
for epoch in range(2000):
    # Forward pass
    outputs = meta_classifier(X_meta_tensor)
    loss = criterion(outputs, y_meta_tensor)

    # Backward and optimize
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch+1) % 100 == 0:
        print(f'Epoch [{epoch+1}/{1000}], Loss: {loss.item():.4f}')
# Predict the test set using the meta-classifier
# predict_proba返回每个类别的概率，类别矩阵（60，3）
X_test_rf = rf.predict_proba(X_test)#（30，3）
X_test_lr = lr.predict_proba(X_test)#（30，3）
X_test_meta_tensor = torch.from_numpy(np.concatenate((X_test_rf, X_test_lr), axis=1)).float().to(device)#（30，6）
y_pred = torch.argmax(meta_classifier(X_test_meta_tensor), dim=1)
# Compute the accuracy
accuracy = (y_pred == y_test_tensor).sum().item() / len(y_test_tensor)
print(f'The accuracy of the Stacking model is {accuracy:.2f}')