"newcpo"

model.py

@@ -1,5 +1,4 @@
 from typing import Dict
-
 import torch
 import torch.nn as nn
 
@@ -16,14 +15,11 @@ class SeqClassifier(nn.Module):
         num_class: int,
     ) -> None:
         super(SeqClassifier, self).__init__()
+
+        # Word embeddings layer
         self.embed = nn.Embedding.from_pretrained(embeddings, freeze=False)
-        self.hidden_size=hidden_size
-        self.num_layers=num_layers
-        self.dropout=dropout
-        self.bidirectional=bidirectional
-        self.num_class=num_class
 
-        # model architecture
+        # LSTM layer
         self.rnn = nn.LSTM(
             input_size=embeddings.size(1),
             hidden_size=hidden_size,
@@ -32,38 +28,49 @@ class SeqClassifier(nn.Module):
             bidirectional=bidirectional,
             batch_first=True
         )
-        self.dropout_layer = nn.Dropout(p=self.dropout)
+
+        # Dropout layer
+        self.dropout_layer = nn.Dropout(p=dropout)
+
+        # Fully connected layer for classification
         self.fc = nn.Linear(self.encoder_output_size, num_class)
 
+        # Model parameters
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.dropout = dropout
+        self.bidirectional = bidirectional
+        self.num_class = num_class
+
     @property
     def encoder_output_size(self) -> int:
-        # calculate the output dimension of rnn
+        # Calculate the output dimension of the RNN
         if self.bidirectional:
             return self.hidden_size * 2
         else:
             return self.hidden_size
 
     def forward(self, batch) -> torch.Tensor:
-        # 將輸入嵌入到詞嵌入空間，就是把詞索引換成詞向量
+        # Embed the input into the word embedding space
         embedded = self.embed(batch)
 
-        # 過 LSTM 層
+        # Pass through the LSTM layer
         rnn_output, _ = self.rnn(embedded)
         rnn_output = self.dropout_layer(rnn_output)
 
         if not self.training:
-            last_hidden_state_forward = rnn_output[ -1, :self.hidden_size]  # 正向方向的隐藏状态
-            last_hidden_state_backward = rnn_output[ 0, self.hidden_size:]  # 反向方向的隐藏状态
+            last_hidden_state_forward = rnn_output[-1, :self.hidden_size]  # Forward hidden state
+            last_hidden_state_backward = rnn_output[0, self.hidden_size:]  # Backward hidden state
             combined_hidden_state = torch.cat((last_hidden_state_forward, last_hidden_state_backward), dim=0)
 
-            # 通過全連接層
+            # Pass through the fully connected layer
             logits = self.fc(combined_hidden_state)
-            return logits  # 返回預測結果
+            return logits  # Return predictions
 
-        last_hidden_state_forward = rnn_output[:, -1, :self.hidden_size]  # 正向方向的隐藏状态
-        last_hidden_state_backward = rnn_output[:, 0, self.hidden_size:]  # 反向方向的隐藏状态
+        last_hidden_state_forward = rnn_output[:, -1, :self.hidden_size]  # Forward hidden state
+        last_hidden_state_backward = rnn_output[:, 0, self.hidden_size:]  # Backward hidden state
         combined_hidden_state = torch.cat((last_hidden_state_forward, last_hidden_state_backward), dim=1)
 
-        # 通過全連接層
+        # Pass through the fully connected layer
         logits = self.fc(combined_hidden_state)
-        return logits  # 返回預測結果
+        return logits  # Return predictions