| from abc import ABCMeta |
| import torch |
| from transformers.pytorch_utils import nn |
| import torch.nn.functional as F |
| from transformers import AlbertModel, AlbertForSequenceClassification, PreTrainedModel |
| from transformers.modeling_outputs import SequenceClassifierOutput |
| from transformers import AlbertConfig |
| from transformers import PretrainedConfig |
|
|
| class AlbertLSTMConfig(PretrainedConfig): |
| model_type = "albertLSTMForSequenceClassification" |
|
|
| def __init__(self, |
| num_classes=2, |
| embed_dim=768, |
| num_layers=12, |
| hidden_dim_lstm=256, |
| dropout_rate=0.1, |
| **kwargs): |
| super().__init__(**kwargs) |
| self.num_classes = num_classes |
| self.embed_dim = embed_dim |
| self.num_layers = num_layers |
| self.hidden_dim_lstm = hidden_dim_lstm |
| self.dropout_rate = dropout_rate |
| self.id2label = { |
| 0: "fake", |
| 1: "true", |
| } |
| self.label2id = { |
| "fake": 0, |
| "true": 1, |
| } |
|
|
| |
| class AlbertLSTMForSequenceClassification(PreTrainedModel, metaclass=ABCMeta): |
| config_class = AlbertLSTMConfig |
|
|
| def __init__(self, config): |
| super(AlbertLSTMForSequenceClassification, self).__init__(config) |
| self.num_classes = config.num_classes |
| self.embed_dim = config.embed_dim |
| self.num_layers = config.num_layers |
| self.hidden_dim_lstm = config.hidden_dim_lstm |
| self.dropout = nn.Dropout(config.dropout_rate) |
| self.albert = AlbertModel.from_pretrained('albert-base-v2', |
| output_hidden_states=True, |
| output_attentions=False) |
| print("ALBERT Model Loaded") |
| self.lstm = nn.LSTM(self.embed_dim, self.hidden_dim_lstm, batch_first=True, num_layers=3) |
| self.fc = nn.Linear(self.hidden_dim_lstm, self.num_classes) |
|
|
| def forward(self, input_ids, attention_mask, token_type_ids, labels=None): |
| albert_output = self.albert(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids) |
| hidden_states = albert_output["hidden_states"] |
|
|
| hidden_states = torch.stack([hidden_states[layer_i][:, 0].squeeze() |
| for layer_i in range(0, self.num_layers)], dim=-1) |
| hidden_states = hidden_states.view(-1, self.num_layers, self.embed_dim) |
| out, _ = self.lstm(hidden_states, None) |
| out = self.dropout(out[:, -1, :]) |
| logits = self.fc(out) |
| loss = None |
| if labels is not None: |
| loss = F.cross_entropy(logits, labels) |
| out = SequenceClassifierOutput( |
| loss=loss, |
| logits=logits, |
| hidden_states=albert_output.hidden_states, |
| attentions=albert_output.attentions, |
| ) |
| return out |
