add model

config.json

@@ -0,0 +1,28 @@
+{
+  "architectures": [
+    "BertLSTMForSequenceClassification"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration.BertABSAConfig",
+    "AutoModelForSequenceClassification": "model.BertLSTMForSequenceClassification"
+  },
+  "dropout_rate": 0.1,
+  "embed_dim": 768,
+  "fc_hidden": 256,
+  "hidden_dim_lstm": 128,
+  "id2label": {
+    "0": "negative",
+    "1": "positive",
+    "2": "neutral"
+  },
+  "label2id": {
+    "negative": 0,
+    "neutral": 2,
+    "positive": 1
+  },
+  "model_type": "BertABSAForSequenceClassification",
+  "num_classes": 3,
+  "num_layers": 12,
+  "torch_dtype": "float32",
+  "transformers_version": "4.20.1"
+}

configuration.py

@@ -0,0 +1,31 @@
+from transformers import PretrainedConfig
+
+
+class BertABSAConfig(PretrainedConfig):
+    model_type = "BertABSAForSequenceClassification"
+
+    def __init__(self,
+                 num_classes=3,
+                 embed_dim=768,
+                 num_layers=12,
+                 dropout_rate=0.1,
+                 fc_hidden=256,
+                 hidden_dim_lstm=128,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.num_classes = num_classes
+        self.embed_dim = embed_dim
+        self.num_layers = num_layers
+        self.dropout_rate = dropout_rate
+        self.fc_hidden = fc_hidden
+        self.hidden_dim_lstm = hidden_dim_lstm
+        self.id2label = {
+            0: "negative",
+            1: "positive",
+            2: "neutral",
+        }
+        self.label2id = {
+            "negative": 0,
+            "positive": 1,
+            "neutral": 2,
+        }

model.py

@@ -0,0 +1,121 @@
+from abc import ABCMeta
+import numpy as np
+import torch
+from transformers.pytorch_utils import nn
+import torch.nn.functional as F
+from src.configuration import BertABSAConfig
+from transformers import BertModel, BertForSequenceClassification, PreTrainedModel
+from transformers.modeling_outputs import SequenceClassifierOutput
+
+
+class BertBaseForSequenceClassification(PreTrainedModel, metaclass=ABCMeta):
+    config_class = BertABSAConfig
+
+    def __init__(self, config):
+        super(BertBaseForSequenceClassification, self).__init__(config)
+        self.num_classes = config.num_classes
+        self.embed_dim = config.embed_dim
+        self.dropout = nn.Dropout(config.dropout_rate)
+
+        self.bert = BertForSequenceClassification.from_pretrained('bert-base-uncased',  # noqa
+                                                                  output_hidden_states=False,  # noqa
+                                                                  output_attentions=False,  # noqa
+                                                                  num_labels=self.num_classes)  # noqa
+        print("BERT Model Loaded")
+
+    def forward(self, input_ids, attention_mask, token_type_ids, labels=None):
+        out = self.bert(input_ids=input_ids, attention_mask=attention_mask,
+                        token_type_ids=token_type_ids, labels=labels)
+        return out
+
+
+class BertLSTMForSequenceClassification(PreTrainedModel, metaclass=ABCMeta):
+    config_class = BertABSAConfig
+
+    def __init__(self, config):
+        super(BertLSTMForSequenceClassification, 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.bert = BertModel.from_pretrained('bert-base-uncased',
+                                              output_hidden_states=True,
+                                              output_attentions=False)
+        print("BERT Model Loaded")
+        self.lstm = nn.LSTM(self.embed_dim, self.hidden_dim_lstm, batch_first=True)  # noqa
+        self.fc = nn.Linear(self.hidden_dim_lstm, self.num_classes)
+
+    def forward(self, input_ids, attention_mask, token_type_ids, labels=None):
+        bert_output = self.bert(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
+        hidden_states = bert_output["hidden_states"]
+
+        hidden_states = torch.stack([hidden_states[layer_i][:, 0].squeeze()
+                                     for layer_i in range(0, self.num_layers)], dim=-1)  # noqa
+        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=bert_output.hidden_states,
+            attentions=bert_output.attentions,
+        )
+        return out
+
+
+class BertAttentionForSequenceClassification(PreTrainedModel, metaclass=ABCMeta):
+    config_class = BertABSAConfig
+
+    def __init__(self, config):
+        super(BertAttentionForSequenceClassification, self).__init__(config)
+        self.num_classes = config.num_classes
+        self.embed_dim = config.embed_dim
+        self.num_layers = config.num_layers
+        self.fc_hidden = config.fc_hidden
+        self.dropout = nn.Dropout(config.dropout_rate)
+
+        self.bert = BertModel.from_pretrained('bert-base-uncased',
+                                              output_hidden_states=True,
+                                              output_attentions=False)
+        print("BERT Model Loaded")
+
+        q_t = np.random.normal(loc=0.0, scale=0.1, size=(1, self.embed_dim))
+        self.q = nn.Parameter(torch.from_numpy(q_t)).float().to(self.device)
+        w_ht = np.random.normal(loc=0.0, scale=0.1, size=(self.embed_dim, self.fc_hidden))  # noqa
+        self.w_h = nn.Parameter(torch.from_numpy(w_ht)).float().to(self.device)
+
+        self.fc = nn.Linear(self.fc_hidden, self.num_classes)
+
+    def forward(self, input_ids, attention_mask, token_type_ids, labels=None):
+        bert_output = self.bert(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
+        hidden_states = bert_output["hidden_states"]
+
+        hidden_states = torch.stack([hidden_states[layer_i][:, 0].squeeze()
+                                     for layer_i in range(0, self.num_layers)], dim=-1)  # noqa
+        hidden_states = hidden_states.view(-1, self.num_layers, self.embed_dim)
+        out = self.attention(hidden_states)
+        out = self.dropout(out)
+        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=bert_output.hidden_states,
+            attentions=bert_output.attentions,
+        )
+        return out
+
+    def attention(self, h):
+        v = torch.matmul(self.q, h.transpose(-2, -1)).squeeze(1)
+        v = F.softmax(v, -1)
+        v_temp = torch.matmul(v.unsqueeze(1), h).transpose(-2, -1)
+        v = torch.matmul(self.w_h.transpose(1, 0), v_temp).squeeze(2)
+        return v

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb67cfc95d551bc3ae74ba297ab0c59e62d3c9ee53154999601576a856cfa9f2
+size 439841259