gdown --id '1kLSW_-cW2Huj7bh84YTdimGBOJaODiOS' --output covid.train.csv

down --id '1iiI5qROrAhZn-o4FPqsE97bMzDEFvIdg' --output covid.test.csv

# Numerical Operations

import math

import numpy as np

# Reading/Writing Data

import pandas as pd

import os

import csv

# For Progress Bar

from tqdm import tqdm

# Pytorch

import torch 

import torch.nn as nn

from torch.utils.data import Dataset, DataLoader, random_split

# For plotting learning curve

from torch.utils.tensorboard import SummaryWriter

# For plot

import matplotlib.pyplot as plt

import seaborn as sns

# seed: 自行设定的随机数种子

def same_seed(seed):

    """Fixes random number generator seeds for reproducibility."""

    torch.backends.cudnn.deterministic = True # 强制使用确定性算法

    torch.backends.cudnn.benchmark = False # 禁用 cuDNN 的卷积基准测试

    np.random.seed(seed) # 设置 numpy 的随机数生成

    torch.manual_seed(seed) # 设置 PyTorch 的随机数生成

    if torch.cuda.is_available(): # 可以不要，新版本 PyTorch 中 manual_seed 会同时设置 CPU 和 GPU 版本的随机数种子

        torch.cuda.manual_seed_all(seed)

# data: 训练集（矩阵）

# valid_ratio: 验证集的比例 (validation_size = train_size * valid_ratio)

# seed: 随机数种子

def train_valid_split(data_set, valid_ratio, seed):

    """Split provided training data into training set and validation set"""

    valid_set_size = int(valid_ratio * len(data_set))

    train_set_size = len(data_set) - valid_set_size

    train_set, valid_set = random_split(data_set, [train_set_size, valid_set_size], generator=torch.Generator().manual_seed(seed)) # 将一个数据集随机拆成两个无重叠的数据集，两个数据集的大小由第二个参数指定

    return np.array(train_set), np.array(valid_set)

def predict(test_loader, model, device):

    model.eval() # Set your model to evaluation mode.

    preds = []

    for x in tqdm(test_loader): # test_loader 是测试数据

        x = x.to(device) # 将模型加载到 CPU 上                    

        with torch.no_grad(): # 禁用梯度计算，节省时间               

            pred = model(x) # 调用模型进行预测

            preds.append(pred.detach().cpu()) # pred 可直接当参数也不会报错，这里是标准化处理

    preds = torch.cat(preds, dim=0).numpy()

    return preds

def save_pred(preds, file):

    """ Save predictions to specified file """

    with open(file, 'w') as fp:

        writer = csv.writer(fp)

        writer.writerow(['id', 'tested_positive']) # 保存成 id, tested_positive 两列

        for i, p in enumerate(preds):

            writer.writerow([i, p])

class COVID19Dataset(Dataset):

    """

    x: Features.

    y: Targets, if none, do prediction.

    """

    def __init__(self, x, y=None): # 定义初始化方法

        if y is None:

            self.y = y

        else:

            self.y = torch.FloatTensor(y) # 预测目标是浮点数

        self.x = torch.FloatTensor(x) # 特征也是浮点数

    def __getitem__(self, idx): # 定义数据集索引方法

        if self.y is None:

            return self.x[idx]

        else:

            return self.x[idx], self.y[idx]

    def __len__(self): # 定义获取数据长度方法

        return len(self.x)

# Set seed for reproducibility

same_seed(config['seed'])

# train_data size: 2699 x 118 (id + 37 states + 16 features x 5 days) 

# test_data size: 1078 x 117 (without last day's positive rate)

train_data, test_data = pd.read_csv('./covid.train.csv').values, pd.read_csv('./covid.test.csv').values

train_data, valid_data = train_valid_split(train_data, config['valid_ratio'], config['seed'])

# Print out the data size.

print(f"""train_data size: {train_data.shape} 

valid_data size: {valid_data.shape} 

test_data size: {test_data.shape}""")

# Select features

x_train, x_valid, x_test, y_train, y_valid = select_feat(train_data, valid_data, test_data, config['select_all'])

# Print out the number of features.

print(f'number of features: {x_train.shape[1]}')

# initialize datasets with the data

train_dataset, valid_dataset, test_dataset = COVID19Dataset(x_train, y_train), \

                                            COVID19Dataset(x_valid, y_valid), \

                                            COVID19Dataset(x_test)

# Pytorch data loader loads pytorch dataset into batches.

train_loader = DataLoader(train_dataset, batch_size=config['batch_size'], shuffle=True, pin_memory=True)

valid_loader = DataLoader(valid_dataset, batch_size=config['batch_size'], shuffle=True, pin_memory=True)

test_loader = DataLoader(test_dataset, batch_size=config['batch_size'], shuffle=False, pin_memory=True)

device = 'cuda' if torch.cuda.is_available() else 'cpu'

config = {

    'seed': 5201314,      # Your seed number, you can pick your lucky number. :)

    'select_all': True,   # Whether to use all features.

    'valid_ratio': 0.2,   # validation_size = train_size * valid_ratio

    'n_epochs': 3000,     # Number of epochs.            

    'batch_size': 256, 

    'learning_rate': 1e-5,              

    'early_stop': 400,    # If model has not improved for this many consecutive epochs, stop training.     

    'save_path': './models/model.ckpt'  # Your model will be saved here.

}

class My_Model(nn.Module):

    def __init__(self, input_dim): # 定义模型初始化方法

        super(My_Model, self).__init__() # 调用父类的__init__方法

        # TODO: modify model's structure, be aware of dimensions.

        self.layers = nn.Sequential( # Sequential 中前一层输出大小必须与下一层的输入大小一致

            nn.Linear(input_dim, 16), # 定义一个全连接层

            nn.ReLU(), # 使用 ReLU 作为激活函数

            nn.Linear(16, 8), # 该层输入 tensor 为 16，输出 tensor 为 8

            nn.ReLU(),

            nn.Linear(8, 1)

        )

    def forward(self, x): # 定义前向传播算法

        x = self.layers(x) # 将 x 传递给 layers 的各层进行运算，默认写法。

        x = x.squeeze(1)  # (B, 1) -> (B)

        return x

self.layers = nn.Sequential(

            nn.Linear(input_dim, 16),

            nn.ReLU(),

            nn.Linear(16, 8),

            nn.ReLU(),

            nn.Linear(8, 4),

            nn.ReLU(),

            nn.Linear(4, 1)

        )

def select_feat(train_data, valid_data, test_data, select_all=True):

    """Selects useful features to perform regression"""

    y_train, y_valid = train_data[:, -1], valid_data[:, -1]

    raw_x_train, raw_x_valid, raw_x_test = train_data[:, :-1], valid_data[:, :-1], test_data # 分离 tested_positive 列和其他特征列

    if select_all:

        feat_idx = list(range(raw_x_train.shape[1]))

    else:

        feat_idx = [0, 1, 2, 3, 4]  # TODO: Select suitable feature columns.

    return raw_x_train[:, feat_idx], raw_x_valid[:, feat_idx], raw_x_test[:, feat_idx], y_train, y_valid

import pandas as pd

df = pd.read_csv('./data/covid.train.csv')

print(df.corr()['tested_positive'].sort_values(ascending=False)) # 降序排列

# ---- Output ----

tested_positive      1.000000

tested_positive.1    0.985053

tested_positive.2    0.969467

tested_positive.3    0.953463

tested_positive.4    0.935388

                       ...   

public_transit      -0.411916

public_transit.1    -0.415510

public_transit.2    -0.418523

public_transit.3    -0.421868

public_transit.4    -0.424169

feat_idx = list(range(38)) + [

            53, 69, 85, 101,  # tested_positive

            49, 65, 81, 97, 113, # public_transit

            40, 41, 56, 57, 72, 73, 88, 89, 104, 105, # hh_cmnty_cli & nohh_cmnty_cli

            38, 39, 54, 55, 70, 71, 86, 87, 102, 103, # cli & ili

            50, 66, 82, 98, 114 # anxious

        ]  # TODO: Select suitable feature columns.

# --- 测试集 ---

Epoch [2547/3000]: Train loss: 1.8915, Valid loss: 1.6332

# --- 验证集 ---

Loss:  tensor(3.1981, dtype=torch.float64)

def trainer(train_loader, valid_loader, model, config, device):

    criterion = nn.MSELoss(reduction='mean')  # Define your loss function, do not modify this.

    # Define your optimization algorithm.

    # TODO: Please check https://pytorch.org/docs/stable/optim.html to get more available algorithms.

    # TODO: L2 regularization (optimizer(weight decay...) or implement by your self).

    optimizer = torch.optim.SGD(model.parameters(), lr=config['learning_rate'], momentum=0.9)

    writer = SummaryWriter()  # Writer of tensoboard.

    if not os.path.isdir('./models'):

        os.mkdir('./models')  # Create directory of saving models.

    n_epochs, best_loss, step, early_stop_count = config['n_epochs'], math.inf, 0, 0 # initialize some variables

    for epoch in range(n_epochs):

        model.train()  # Set your model to train mode.

        loss_record = []

        # tqdm is a package to visualize your training progress.

        train_pbar = tqdm(train_loader, position=0, leave=True)

        for x, y in train_pbar:

            optimizer.zero_grad()  # Set gradient to zero.

            x, y = x.to(device), y.to(device)  # Move your data to device.

            pred = model(x)

            loss = criterion(pred, y)

            loss.backward()  # Compute gradient(backpropagation).

            optimizer.step()  # Update parameters.

            step += 1

            loss_record.append(loss.detach().item())

            # Display current epoch number and loss on tqdm progress bar.

            train_pbar.set_description(f'Epoch [{epoch + 1}/{n_epochs}]')

            train_pbar.set_postfix({'loss': loss.detach().item()})

        mean_train_loss = sum(loss_record) / len(loss_record)

        writer.add_scalar('Loss/train', mean_train_loss, step)

        model.eval()  # Set your model to evaluation mode.

        loss_record = []

        for x, y in valid_loader:

            x, y = x.to(device), y.to(device)

            with torch.no_grad():

                pred = model(x)

                loss = criterion(pred, y)

            loss_record.append(loss.item())

        mean_valid_loss = sum(loss_record) / len(loss_record)

        tqdm.write(f'Epoch [{epoch + 1}/{n_epochs}]: Train loss: {mean_train_loss:.4f}, Valid loss: {mean_valid_loss:.4f}')

        writer.add_scalar('Loss/valid', mean_valid_loss, step) # 向 tensoboard 添加图表

        if mean_valid_loss < best_loss:

            best_loss = mean_valid_loss

            torch.save(model.state_dict(), config['save_path'])  # Save your best model

            tqdm.write('Saving model with loss {:.3f}...'.format(best_loss))

            early_stop_count = 0

        else:

            early_stop_count += 1

        if early_stop_count >= config['early_stop']:

            tqdm.write('\nModel is not improving, so we halt the training session.')

            return

class My_Model(nn.Module):

    def __init__(self, input_dim):

        super(My_Model, self).__init__()

        # TODO: modify model's structure, be aware of dimensions.

        self.layers = nn.Sequential(

            nn.Linear(input_dim, 32),

            nn.LeakyReLU(0.1),

            nn.Dropout(p=0.2),  # 添加 Dropout，指定丢弃概率

            nn.Linear(32, 16),

            nn.LeakyReLU(0.1),

            nn.Linear(16, 8),

            nn.LeakyReLU(0.1),

            nn.Linear(8, 1)

        )

optimizer = torch.optim.Adam(model.parameters(), lr=config['learning_rate'])

# 调整 超参数

config = {

    'seed': 194343431,

    'select_all': False,

    'valid_ratio': 0.2,

    'n_epochs': 3000,

    'batch_size': 256,

    'learning_rate': 1e-3, # 这里从 1e-5 改成了 1e-3

    'early_stop': 400,

    'save_path': './models/model.ckpt'

}

# --- 测试集 ---

Epoch [498/15000]: Train loss: 1.3171, Valid loss: 5.3677

# --- 验证集 ---

Loss:  tensor(2.2407, dtype=torch.float64)

# 修改 feat 选取

feat_idx = list(range(38)) + [

            53, 69, 85, 101,  # tested_positive

            49, 65, 81, 97, 113, # public_transit

        ]  # TODO: Select suitable feature columns.

# --- 测试集 ---

Epoch [447/3000]: Train loss: 1.6422, Valid loss: 2.8130

# --- 验证集 ---

Loss:  tensor(1.4970, dtype=torch.float64)