otto-产品分类挑战赛-神经网络

只是个用来尝试多分类问题的初级版本

import torch
import torch.nn as nn
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from torch.utils.data import Dataset, DataLoader
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.model_selection import train_test_split
device = ("cuda:0"if torch.cuda.is_available() else "cpu")
train_data = pd.read_csv("dataset/otto/train.csv")
test_data = pd.read_csv("dataset/otto/test.csv")
test_data = test_data.drop(["id"], axis=1)
le = LabelEncoder()
Scaler = StandardScaler()

epoch_list = np.arange(200)
loss_list = []
AC_list = []
_, test = train_test_split(train_data, test_size=0.2, random_state=42)
# print(test)
class TestDataset(Dataset):
    def __init__(self, tes):
        xy = tes
        xy = xy.drop(["id"], axis=1)
        xy["target"] = le.fit_transform(xy["target"])
        self.len = xy.shape[0]
        x_data = xy.drop(["target"], axis=1)
        x_data = Scaler.fit_transform(x_data)
        x_data = torch.from_numpy(x_data).float()
        y_data = xy["target"]
        y_data = torch.from_numpy(y_data.to_numpy()).long()
        self.x_data = x_data
        self.y_data = y_data

    def __getitem__(self, index):
        x = self.x_data[index]
        y = self.y_data[index]
        return x, y
    def __len__(self):
        return self.len


class TrainDataset(Dataset):
    def __init__(self, filepath):
        xy = pd.read_csv(filepath)
        xy = xy.drop(["id"], axis=1)
        xy["target"] = le.fit_transform(xy["target"])

        self.len = xy.shape[0]
        x_data = xy.drop(["target"], axis=1)
        x_data = Scaler.fit_transform(x_data)
        y_data = xy["target"]
        self.x_data = torch.from_numpy(x_data).float()
        self.y_data = torch.from_numpy(y_data.to_numpy()).long()

    def __getitem__(self, index):
        x = self.x_data[index]
        y = self.y_data[index]
        return x, y

    def __len__(self):
        return self.len


batch_size = 64
train_dataset = TrainDataset("dataset/otto/train.csv")
train_Dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=6)
test_dataset = TestDataset(test)
test_Dataloader = DataLoader(test_dataset, shuffle=True, batch_size=batch_size, num_workers=6)


class Module(nn.Module):
    def __init__(self):
        super(Module, self).__init__()
        self.l1 = nn.Linear(93, 784)
        self.l2 = nn.Linear(784, 256)
        self.l3 = nn.Linear(256, 128)
        self.l4 = nn.Linear(128, 64)
        self.l5 = nn.Linear(64, 16)
        self.l6 = nn.Linear(16, 9)
        self.relu = nn.ReLU()
        self.dro = nn.Dropout(0.2)


    def forward(self, x):
        x = self.relu(self.l1(x))
        x = self.dro(x)
        x = self.relu(self.l2(x))
        x = self.dro(x)
        x = self.relu(self.l3(x))
        x = self.dro(x)
        x = self.relu(self.l4(x))
        x = self.relu(self.l5(x))
        x = self.l6(x)
        return x


model = Module()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
model.to(device)
def train(epoch):
    loss_running = 0.0
    rem = 0.0
    for batch_idx, data in enumerate(train_Dataloader):
        inputs, labels = data[0].to(device), data[1].to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        loss_running += loss.item()
        if batch_idx % 300 == 299:
            print('[epoch: %d, batch_id: %d], loss: %.6f' % (epoch+1, batch_idx+1, loss_running/300))
            rem += loss_running/300
            loss_running = 0.0
        if batch_idx % 900 == 899:
            loss_list.append(rem/3)

test_data = Scaler.fit_transform(test_data)
test_data = torch.from_numpy(test_data).float()

def ACtest():
    with torch.no_grad():
        correct = 0.0
        total = 0.0
        for data in test_Dataloader:
            inputs, labels = data[0].to(device), data[1].to(device)
            # print(labels)
            outputs = model(inputs)
            _, pre = torch.max(outputs, dim=1)
            total += len(inputs)
            correct += (pre == labels).sum().item()
        print('AC : %.3f %%' % (correct*100/total))
        AC_list.append(correct*100/total)













def test(data):
    with torch.no_grad():
         outputs = model(data)
         _, pre = torch.max(outputs, dim=1)
         return pre





if __name__ == '__main__':
    for epoch in range(200):
        train(epoch)
        ACtest()

    final = test(test_data.to(device))
    plt.plot(epoch_list, loss_list, c='blue')
    plt.xlabel("epoch")
    plt.ylabel("loss")
    plt.show()


    plt.plot(epoch_list, AC_list, c='red')
    plt.xlabel("epoch")
    plt.ylabel("AC")
    plt.show()
    print(final)
    one_hot = torch.nn.functional.one_hot(final, num_classes=9)

    # 把独热编码矩阵转换为一个 numpy 数组
    one_hot = one_hot.cpu().numpy()

    # 创建一个 DataFrame，第一列是 id，后面九列是类别
    df = pd.DataFrame(one_hot, columns=['Class_' + str(i) for i in range(1, 10)])
    df.insert(0, 'id', range(1, len(df) + 1))

    # 把 DataFrame 保存为一个 csv 文件
    df.to_csv('sampleSubmission.csv', index=False)

. 本代码使用了pandas 与 dataset 相结合的方式

最终得分7点多，自己测试的时候loss 降到了0.2 以下大概是出现了过拟合情况，但对于这个比赛的评分系统属实没看懂所以就这样吧