homework5——多分类

使用Otto数据集，标签列为[‘Class_1’, ‘Class_2’…, ‘Class_9’]

# 多分类
# https://www.kaggle.com/c/otto-group-product-classification-challenge/data

import pandas as pd
import torch
from torch.utils.data import DataLoader, Dataset
import matplotlib.pyplot as plt
import os

# os.environ['CUDA_LAUNCH_BLOCKING'] = '1'


class OttoData(Dataset):
    def __init__(self, filepath):
        xy = pd.read_csv(filepath, sep=',')  # 因为target列不能直接转成float格式，所以分别处理
        self.len = xy.shape[0]
        self.x_data = torch.tensor(xy.iloc[:, 1:-1].values, dtype=torch.float32)

        # 标签是“Class_1......”，所以将标签映射到0~8
        y_data = xy.iloc[:, -1]   # 标签列
        # 创建映射
        unique_labels = sorted(y_data.unique())
        self.label_to_index = {label: index for index, label in enumerate(unique_labels)}   # 映射字典
        self.index_to_label = {index: label for index, label in enumerate(unique_labels)}

        # 将标签映射到0~8
        y_data_mapped = y_data.map(self.label_to_index)    # 映射
        self.y_data = torch.tensor(y_data_mapped.values, dtype=torch.long)    # 长整型张量

    def __getitem__(self, item):
        return self.x_data[item], self.y_data[item]

    def __len__(self):
        return self.len

tra_dataset = OttoData("./datasets/otto/train.csv")
# test_data = OttoData("./datasets/otto/test.csv")   # 没有label

tra_dataloader = DataLoader(dataset=tra_dataset, batch_size=64, shuffle=True)
# test_dataloader = DataLoader(dataset=test_data, batch_size=64, shuffle=False)


# 定义classifier
class OttoNet(torch.nn.Module):
    def __init__(self):
        super(OttoNet, self).__init__()
        self.linear1 = torch.nn.Linear(93, 256)
        self.linear2 = torch.nn.Linear(256, 128)
        self.linear3 = torch.nn.Linear(128, 64)
        self.linear4 = torch.nn.Linear(64, 32)
        self.linear5 = torch.nn.Linear(32, 9)
        self.relu = torch.nn.ReLU()

    def forward(self, x):
        x = self.relu(self.linear1(x))
        x = self.relu(self.linear2(x))
        x = self.relu(self.linear3(x))
        x = self.relu(self.linear4(x))
        x = self.linear5(x)
        return x
model = OttoNet()
# model = model.cuda()

# loss和optimizer
criterion = torch.nn.CrossEntropyLoss()
# criterion = criterion.cuda()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3, momentum=0.5)

# 训练
def train(epoch):
    running_loss = 0.0
    total = 0
    correct = 0
    for i, data in enumerate(tra_dataloader):
        inputs, targets = data
        # inputs, targets = inputs.cuda(), targets.cuda()
        optimizer.zero_grad()
        # forward
        y_pred = model(inputs)
        l = criterion(y_pred, targets)
        # backward
        l.backward()
        # update
        optimizer.step()

        running_loss += l.item()
        if i % 300 == 299:
            print("[%d %5d], loss: %3f" % (epoch + 1, i + 1, running_loss / 500))
            running_loss = 0.0

        # 计算训练的accuracy
        _, predicted = torch.max(y_pred.data, dim=1)   # 取每个样本的分类最大值的下标
        total += targets.size(0)   # 总样本数量
        correct += (predicted == targets).sum().item()   # 正确预测的样本数量
    print("Accuracy on Train is: %d %%" % (100 * correct / total))
    return l.item()


if __name__ == '__main__':
    loss = []
    for epoch in range(50):
        l = train(epoch)
        loss.append(l)

        # 画图
    plt.plot(range(50), loss)
    plt.xlabel('epoch')
    plt.ylabel('loss')
    plt.show()
    plt.close()