这里用BP神经网络模型对鸢尾花进行训练并分类，由于鸢尾花数据量本身较少，一共就150个数据，所以学习到的效果不如学习手写数据集那么的好。在预测时，也许会出现准确率不够高的情况。大家记得修改一下自己的路径，权重和数据保存的路径都需要修改。先看训练时候的代码：

import numpy as np
import torch
import matplotlib.pyplot as plt
import torch.nn as nn
from torch import optim as optim
from torch.utils.data import DataLoader, TensorDataset
from torchvision import datasets
import torch.nn.functional as F
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

iris = datasets.load_iris()
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, ) #划分测试集与训练集
# 所有数据标准化
transfer = StandardScaler()
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)

x_train = torch.tensor(x_train, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.int64)  # 注意标签数据类型应为整数类型
x_test = torch.tensor(x_test, dtype=torch.float32)
y_test = torch.tensor(y_test, dtype=torch.int64)
torch.save(x_test, 'xuexi/DL/BP/x_test.pt')
torch.save(y_test, 'xuexi/DL/BP/y_test.pt')
#定义模型
class BP(nn.Module):
    def __init__(self):
        super(BP, self).__init__()
        self.hidden1 = nn.Linear(4,100)
        
        self.hidden2 = nn.Linear(100,3)

        
    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = F.relu(self.hidden1(x))
        x = F.relu(self.hidden2(x))
        
    
        return x
    
if __name__ == '__main__':   

    train_dataset = TensorDataset(x_train, y_train) # 把x_train和y_train合并在一起
    train_loader = DataLoader(dataset=train_dataset, batch_size=32, shuffle=True)# 数据加载


    device = "cuda" if torch.cuda.is_available() else "cpu"
    print(f"Using {device} device") # 确保在使用GPU进行运算

    model1 = BP().to(device)
    loss_fun =  nn.CrossEntropyLoss() # 使用交叉熵来计算损失函数
    opt= optim.Adam(model1.parameters(),lr =0.009)  # 采用Adam算法
    epochs = 100
    num_batches = 0
    losses=[]
    for epoch in range(epochs):
        epoch_loss = 0.0  # 统计每个 epoch 的总损失
        for x, y in train_loader:
            x, y = x.to(device), y.to(device)  # 将数据移动到对应设备上
            
            opt.zero_grad()  # 梯度清零
            y_pred = F.softmax(model1(x), dim=1)  # 在计算损失前使用 softmax 函数
            loss = loss_fun(y_pred, y)
            loss.backward()
            opt.step()  # 进行梯度更新
            epoch_loss += loss.item()
            
        average_loss = epoch_loss / len(train_loader)  # 把每一次训练输出的损失和训练次数记录下来，平均一下输出
        losses.append(average_loss)
        print(f"Epoch [{epoch+1}/{epochs}], Loss: {average_loss:.4f}")
        torch.save(model1.state_dict(), '/home/wxc/xuexi/DL/BP/model_weights.pth')

    plt.plot(range(1, epochs + 1), losses)
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.title('Training Loss')
    plt.savefig('/home/wxc/xuexi/DL/BP/Training_loss.jpg')
    plt.show()     

        然后开始测试：

import numpy as np
import torch
import matplotlib.pyplot as plt
from torch import optim as optim
from torch.utils.data import DataLoader, TensorDataset
from BP_train import BP


x_test = torch.load('xuexi/DL/BP/x_test.pt') #导入在训练时所切分好的测试集数据
y_test = torch.load('xuexi/DL/BP/y_test.pt')
test_dataset = TensorDataset(x_test, y_test) # 把x_test和y_test合并在一起
test_loader = DataLoader(dataset=test_dataset, batch_size=8, shuffle=True)# 数据加载

model = BP()

device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using {device} device") # 确保在使用GPU进行运算

model.load_state_dict(torch.load('xuexi/DL/BP/model_weights.pth', map_location=device)) #导入训练时所保存的参数
model = model.to(device)#将模型放到GPU上
model.eval()# 设置模型为评估模式

correct = 0
total = 0
with torch.no_grad():
    total = 0
    correct = 0
    for data in test_loader:
        x, labels = data[0].cuda(), data[1].cuda() #将数据移动到GPU进行后续处理 
        outputs = model(x) #把数据输入进前面建立的模型
        _, predicted = torch.max(outputs.data, 1) #只需要一个最大的可能性的概率
        predicted_labels = predicted.cpu().numpy() # 将预测结果和真实标签移动到CPU
        true_labels = labels.cpu().numpy()
        total += labels.size(0)
        correct += (predicted == labels).sum().item() # 计算准确率
        indices = np.arange(len(predicted_labels))# 创建索引列表
        
        # 绘制预测标签和真实标签之间的比较图
        plt.figure(figsize=(10, 6))
        plt.plot(indices, predicted_labels, 'ro', label='Predicted Label')
        plt.plot(indices, true_labels, 'bo', label='True Label')
        plt.xlabel('Index')
        plt.ylabel('Label')
        plt.title('Predictions and True Labels')
        plt.legend()
        plt.savefig('/home/wxc/xuexi/DL/BP/Predictions and True Labels.jpg')# 保存真实与预测的图片
        plt.show()
        
    print('Accuracy on the test set: %d %%' % (100 * correct / total)) # 输出准确率