import csv
import torch
import torch.nn as nn
import numpy as np
from torch.utils.data import Dataset, DataLoader
import pandas as pd
from torch import optim
import time
import matplotlib.pyplot as plt
import matplotlib
matplotlib.use(‘TkAgg’)
device = “cuda” if torch.cuda.is_available() else “cpu”

class CovidDataset(Dataset):
def init(self, file_path, mode=“train”):
with open(file_path, “r”) as f:
ori_data = list(csv.reader(f))
# 1: 跳过表头行；1:-1：跳过id列，保留【所有特征+标签】，一共93列
csv_data = np.array(ori_data)[1:, 1:].astype(np.float32)
c = torch.tensor(1.5)
if mode == “train”:
indices = [i for i in range(len(csv_data)) if i % 5 != 0]
self.data = torch.tensor(csv_data[indices, :-1])
self.y = torch.tensor(csv_data[indices, -1])
elif mode == “val”:
indices = [i for i in range(len(csv_data)) if i % 5 == 0]
self.data = torch.tensor(csv_data[indices, :-1])
self.y = torch.tensor(csv_data[indices, -1])
else: # test
indices = [i for i in range(len(csv_data))]
self.data = torch.tensor(csv_data[indices, :])
self.y = None
self.mode = mode
self.data = (self.data - self.data.mean(dim=0, keepdim=True) )/ (self.data.std(dim=0, keepdim=True)+1e-6)
def getitem(self, index):
if self.mode == “test”:
return self.data[index]
else:
return self.data[index], self.y[index]

def __len__(self):
     return len(self.data)

-------------------------------------------------------------------------

train_path = ‘covid.train.csv’
test_path = ‘covid.test.csv’

train_dataset = CovidDataset(train_path, “train”)
val_dataset = CovidDataset(train_path, “val”)
test_dataset = CovidDataset(test_path, “test”)

batch_size = 16

train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False)
#-------------------------------------------------------------------------

model

class MyModel(nn.Module):
def init(self, inDim):
super().init()
self.fc1 = nn.Linear(inDim, 64)
self.relu1 = nn.ReLU()
self.fc2 = nn.Linear(64, 1)

 def forward(self, x):
      x = self.fc1(x)
      x = self.relu1(x)
      x = self.fc2(x)

      if len(x.size()) > 1:
           return x.squeeze(1)
      return x

def train_val(model, train_loader, val_loader, device, epochs, optimizer, loss, save_path):
model = model.to(device)
plt_train_loss = []
plt_val_loss = []
min_val_loss = 99999999999
for epoch in range(epochs):
train_loss = 0.0
val_loss = 0.0
start_time = time.time()

      model.train()  # train model
      for batch_x, batch_y in train_loader:
           x, target = batch_x.to(device).float(), batch_y.to(device).float()
           pred = model(x)
           train_bat_loss = loss(pred, target)
           train_bat_loss.backward()
           optimizer.step()
           optimizer.zero_grad()
           train_loss += train_bat_loss.cpu().item()

      plt_train_loss.append(train_loss / train_loader.__len__())

      model.eval()
      with torch.no_grad():
           for batch_x, batch_y in val_loader:
                x, target = batch_x.to(device), batch_y.to(device)
                pred = model(x)
                val_bat_loss = loss(pred, target)
                val_loss += val_bat_loss.cpu().item()

      plt_val_loss.append(val_loss / val_loader.__len__())

      if val_loss < min_val_loss:
            #torch.save(model.state_dict(), save_path)
           torch.save(model, save_path)
           min_val_loss = val_loss
      cost_time = time.time() - start_time

      print(f'第{epoch}轮：用时{cost_time},训练损失{plt_train_loss[-1] :.3f},验证损失{plt_val_loss[-1] :.3f}')
 plt.plot(plt_train_loss)
 plt.plot(plt_val_loss)
 # plt.title("loss图")
 plt.show()

def evaluate(save_path, out_path, test_loader, device):
# model = torch.load(save_path).to(device)
model = torch.load(save_path, weights_only=False).to(device)
out = []
model.eval()
with torch.no_grad():
for x in test_loader:
pred = model(x.to(device))
out.append(pred.cpu().item())
print(out)
with open(out_path, ‘w’) as f:
csvWriter = csv.writer(f)
csvWriter.writerow(([‘id’, ‘test_positived’]))
for i in range(len(test_loader)):
csvWriter.writerow([str(i), str(out[i])])
print(‘File has been saved!’)

config = {
“lr”: 0.0003,
“epochs”: 20,
“momentum”: 0.9,
“save_path”: “best_model.pth”,
‘out_path’: ‘out.csv’
}

model = MyModel(inDim=93)
loss = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), config[“lr”], config[“momentum”])

train_val(model, train_loader, val_loader, device, config[“epochs”], optimizer, loss, config[“save_path”])
evaluate(config[‘save_path’], config[‘out_path’], test_loader, device)