2022美赛C题M奖论文和代码分享

我们组很幸运地获得2022美赛C题M奖，主要采用LSTM和XGBoost策略。现在把论文和代码分享出来，论文代码地址见文末。
论文的流程图如下：
​

文件架构如下：
​

以下是部分论文:
​

class LSTM(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden_layer_size = HIDDEN_LAYER_SIZE
        self.lstm = nn.LSTM(input_size=SEQUENCE_LENGTH,
                            hidden_size=self.hidden_layer_size,
                            num_layers=2,
                            dropout=0.5,
                            batch_first=True)
        # equivalent to Dense in keras
        self.linear1 = nn.Linear(self.hidden_layer_size, self.hidden_layer_size)
        self.linear2 = nn.Linear(self.hidden_layer_size, 1)

        self.dropout = nn.Dropout(0.5)

        self.hidden_cell = (torch.zeros(2, BATCH_SIZE, self.hidden_layer_size).
                            cuda(),
                            torch.zeros(2, BATCH_SIZE, self.hidden_layer_size).cuda())

    def forward(self, input_seq):
        _, (hn, _) = self.lstm(input_seq.view(
            len(input_seq), 1, -1), self.hidden_cell)
        # lstm_out, self.hidden_cell = self.lstm(input_seq, self.hidden_cell)
        # predictions = self.linear(lstm_out.view(len(input_seq), -1))
        predictions = self.dropout(self.linear2(hn[-1]))
        # predictions = self.dropout(self.linear2(predictions))
        return predictions

def train(model, data_loader, optimizer, criterion):

    epoch_loss = 0

    model.train()

    batch_num = 0

    for X, y in data_loader:

        # print('Training batch', batch_num)

        optimizer.zero_grad()

        model.hidden_cell = (torch.zeros(2, X.shape[0], model.hidden_layer_size).cuda(
        ), torch.zeros(2, X.shape[0], model.hidden_layer_size).cuda())

        predictions = model(X)

        # print(predictions.shape, y.shape)

        loss = criterion(predictions, y)

        loss.backward()

        optimizer.step()

        epoch_loss += loss.item()

        batch_num += 1

    return epoch_loss / len(data_loader)

N_EPOCHS = 100

best_valid_loss = float('inf')

for epoch in range(N_EPOCHS):
    # print('training...')

    start_time = time.time()

    train_loss = train(model, train_loader, optimizer, loss_function)
    valid_loss = evaluate(model, test_loader, loss_function)

    end_time = time.time()

    epoch_mins, epoch_secs = epoch_time(start_time, end_time)

    if valid_loss < best_valid_loss:
        best_valid_loss = valid_loss
        torch.save(model.state_dict(), 'tut2-model.pt')

    print(f'Epoch: {epoch+1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s')
    print(f'tTrain Loss: {train_loss:.10f}')
    print(f't Val. Loss: {valid_loss:.10f}')

XGboost：

def get_model():

    xgbparams = {
        'eta': 0.01,
        'booster': 'gbtree',
        'subsample': 0.76,
        'colsample_bytree': 0.6,
        'min_child_weight': 1,
        'n_estimators': 1000,
        'lambda': 3,
        'alpha': 0,
        'gamma': 0,
        'max_depth': 6,
        'booster': 'gbtree',
        'tree_method': 'gpu_hist',
        'objective': 'reg:squarederror',
    }

    model = xgb.XGBRegressor(**xgbparams)

    return model

全部论文及代码如下：https://mianbaoduo.com/o/bread/YpqblZdv