Datawhale AI 夏令营 第三期 物质科学方向 学习笔记3

本期主要学习了 Transformer 模型的相关知识，使用该模型的 Encoder 部分结构对SMILES表达式进行编码，用全连接层处理编码后的输出向量作为预测结果。并了解了部分基础的调参方式。以下为对部分代码的简单分析。

Smiles_tokenizer 部分

这部分的功能和实现与 Task2 中基本相同，仅在对未出现在已有vocab中的新词处理上有小区别。

Transformer Encoder 模型部分

关于 Transformer 的学习，个人推荐看文章： 史上最小白之Transformer详解-CSDN博客，理解起来相对清楚容易。以下说明创建该 Transformer Encoder Model 的各方法：

初始化函数部分：

创建embedding层，将原始输入映射到d_model维度，该参数设定影响多头注意力层的设计；

创建layernorm层，用于归一化；

创建Transformer编码器层，包含自注意力机制和前馈神经网络，后将其进行多层堆叠，与嵌入层和归一化层组合，创建为Transformer编码器；

创建dropout层减小过拟合影响；

创建线性层，将输出映射为单值；

 def __init__(self, input_dim, d_model, num_heads, fnn_dim, num_layers, dropout):
        super().__init__()
        self.embedding = nn.Embedding(input_dim, d_model)
        self.layerNorm = nn.LayerNorm(d_model)
        self.encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, 
                                                        nhead=num_heads, 
                                                        dim_feedforward=fnn_dim,
                                                        dropout=dropout,
                                                        batch_first=True,
                                                        norm_first=True # pre-layernorm
                                                        )
        self.transformer_encoder = nn.TransformerEncoder(self.encoder_layer, 
                                                         num_layers=num_layers,
                                                         norm=self.layerNorm)
        self.dropout = nn.Dropout(dropout)
        self.lc = nn.Sequential(nn.Linear(d_model, 256),
                                nn.Sigmoid(),
                                nn.Linear(256, 96),
                                nn.Sigmoid(),
                                nn.Linear(96, 1))

前向传播方法：描述数据在网络中的传递方式。

原始输入经过embedding层和dropout层处理，输入编码器，输出向量取特定位置传入线性层处理，压缩多余维度后输出结果。

def forward(self, src):
        embedded = self.dropout(self.embedding(src))
        outputs = self.transformer_encoder(embedded)
        z = outputs[:,0,:]
        outputs = self.lc(z)
        return outputs.squeeze(-1)

训练模型部分

动态调整学习率：根据训练轮次减小学习率，实时传入优化器参数

def adjust_learning_rate(optimizer, epoch, start_lr):
    lr = start_lr * (0.1 ** (epoch // 3))
    for param_group in optimizer.param_groups:
        param_group['lr'] = lr

•  初始化最佳验证损失值为 10。这个值会在训练过程中持续更新为最好的验证损失值

• 对每个epoch进行训练循环：

  •  初始化当前epoch的总损失为 0。

  • 对训练数据加载器中的每个batch进行迭代：

    • batch开始时清零优化器梯度

    • 输入数据传入模型，用设定的损失函数（MSE）计算输出与真实值的loss

    • 反向传播，计算梯度。

    • 梯度裁剪，防止梯度爆炸。

    •  使用优化器更新模型参数并累积loss值

  • 计算当前epoch的平均损失，并依此更新学习率调度器

  •     best_valid_loss = 10
        for epoch in range(N_EPOCHS):
            epoch_loss = 0
            for i, (src, y) in enumerate(train_loader):
                src, y = src.to(device), y.to(device)
                optimizer.zero_grad()
                output = model(src)
                loss = criterion(output, y)
                loss.backward()
                torch.nn.utils.clip_grad_norm_(model.parameters(), CLIP)
                optimizer.step()
                epoch_loss += loss.detach().item()
                
                if i % 50 == 0:
                    print(f'Step: {i} | Train Loss: {epoch_loss:.4f}')
                    
            loss_in_a_epoch = epoch_loss / len(train_loader)
            scheduler.step(loss_in_a_epoch)