【机器学习】一文搞懂算法模型之：LSTM

* **遗忘门** ：控制是否遗忘上一层的隐藏细胞状态，以一定的概率决定哪些信息需要保留。
* **输入门** ：负责处理当前序列位置的输入，并更新细胞状态。它包含两部分： 
  * 一部分使用sigmoid激活函数计算输入门的值，
  * 另一部分使用tanh激活函数计算候选记忆单元的值。

* **输出门** ：根据更新后的细胞状态，计算并输出当前时间步的隐藏状态。

    # -*- coding:utf-8 -*-
    # @Time   : 2024-03-16
    # @Author : Carl_DJ
    '''
    实现功能：
    PyTorch 和 torchtext 库来加载 IMDB 电影评论数据集，并训练一个 LSTM 模型来预测评论的情感（正面或负面）
    
    '''
    import torch  
    import torch.nn as nn  
    import torch.optim as optim  
    from torchtext.legacy import data, datasets  
      
    # 定义字段处理器  
    TEXT = data.Field(tokenize='spacy', tokenizer_language='en_core_web_sm')  
    LABEL = data.LabelField(dtype=torch.float)  
      
    # 定义数据集和迭代器  
    train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)  
    train_iterator, test_iterator = data.BucketIterator.splits(  
    (train_data, test_data),   
    batch_size=64,   
    device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')  
    )  
      
    # 定义 LSTM 模型  
    class LSTMClassifier(nn.Module):  
    def __init__(self, input_dim, embedding_dim, hidden_dim, output_dim, n_layers, drop_prob=0.5):  
        super().__init__()  
        self.embedding = nn.Embedding(input_dim, embedding_dim)  
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, n_layers, dropout=drop_prob, batch_first=True)  
        self.fc = nn.Linear(hidden_dim, output_dim)  
        self.drop = nn.Dropout(drop_prob)  
          
    def forward(self, text):  
        embedded = self.embedding(text)  
        lstm_out, _ = self.lstm(embedded)  
        lstm_out = self.drop(lstm_out)  
        return self.fc(lstm_out[:, -1, :])  
      
    # 超参数  
    INPUT_DIM = len(TEXT.vocab)  
    EMBEDDING_DIM = 100  
    HIDDEN_DIM = 32  
    OUTPUT_DIM = 1  
    N_LAYERS = 2  
    DROP_PROB = 0.5  
      
    # 实例化模型、损失函数和优化器  
    model = LSTMClassifier(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM, N_LAYERS, DROP_PROB)  
    criterion = nn.BCEWithLogitsLoss()  
    optimizer = optim.Adam(model.parameters())  
      
    # 将模型移动到 GPU（如果可用）  
    model = model.to(device)  
    criterion = criterion.to(device)  
      
    # 训练模型  
    N_EPOCHS = 5  
      
    for epoch in range(N_EPOCHS):  
    for batch in train_iterator:  
        optimizer.zero_grad()  
          
        predictions = model(batch.text).squeeze(1)  
        loss = criterion(predictions, batch.label.float())  
          
        loss.backward()  
        optimizer.step()  
      
    print(f'Epoch: {epoch+1:02}, Loss: {loss.item():.6f}')  
      
    # 测试模型  
    model.eval()  
    with torch.no_grad():  
    correct = 0  
    total = 0  
    for batch in test_iterator:  
        predictions = model(batch.text).squeeze(1) > 0.5  
        correct += (predictions == batch.label).sum().item()  
        total += batch.batch_size  
      
    print(f'Accuracy: {100 * correct / total:.2f}%')
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读