add model

config.json

@@ -0,0 +1,41 @@
+{
+  "_name_or_path": "multilabel_bert_base_uncased",
+  "architectures": [
+    "MultiLabelClassifierModel"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration.MultiLabelClassifierConfig",
+    "AutoModelForSequenceClassification": "model.MultiLabelClassifierModel"
+  },
+  "bidirectional": true,
+  "dropout": 0.3,
+  "embedding_dim": 768,
+  "hidden_dim": 256,
+  "id2label": {
+    "0": "Amusing",
+    "1": "Emotional",
+    "2": "Suspenseful",
+    "3": "Dark",
+    "4": "Thrilling"
+  },
+  "label2id": {
+    "Amusing": 0,
+    "Dark": 3,
+    "Emotional": 1,
+    "Suspenseful": 2,
+    "Thrilling": 4
+  },
+  "labels": [
+    "Amusing",
+    "Emotional",
+    "Suspenseful",
+    "Dark",
+    "Thrilling"
+  ],
+  "model_type": "multi_label_classification",
+  "num_classes": 5,
+  "num_layers": 2,
+  "torch_dtype": "float32",
+  "transformer_name": "bert-base-uncased",
+  "transformers_version": "4.21.1"
+}

configuration.py

@@ -0,0 +1,34 @@
+import torch
+from transformers import PretrainedConfig
+from typing import List
+from pdb import set_trace 
+
+class MultiLabelClassifierConfig(PretrainedConfig):
+    model_type = "multi_label_classification"
+    problem_type = "multi_label_classification"
+
+    def __init__(
+        self,
+        embedding_dim: int=768,
+        labels: List[str]=[],
+        transformer_name: str = "bert-base-uncased",
+        hidden_dim: int = 256,
+        num_layers: int = 2,
+        bidirectional: bool = True,
+        dropout: float =.3,
+        **kwargs,
+    ):
+        self.transformer_name = transformer_name 
+        self.hidden_dim = hidden_dim 
+        self.labels = labels
+        self.num_layers = num_layers 
+        self.bidirectional = bidirectional 
+        self.dropout = dropout 
+        self.num_classes = len(labels)
+        self.embedding_dim = embedding_dim
+
+        #self.nlp_config = config.to_dict()
+        if 'id2label' not in kwargs: kwargs['id2label'] = {idx:label for idx, label in enumerate(labels)}
+        if 'label2id' not in kwargs: kwargs['label2id'] = {label:idx for idx, label in enumerate(labels)}
+        super().__init__(**kwargs)
+        

model.py

@@ -0,0 +1,58 @@
+import torch
+import torch.nn as nn
+from transformers import PreTrainedModel
+from collections import OrderedDict 
+from transformers.modeling_outputs import SequenceClassifierOutput
+from typing import List, Optional, Tuple, Union
+from .configuration import MultiLabelClassifierConfig
+
+class MultiLabelClassifierModel(PreTrainedModel):
+    config_class = MultiLabelClassifierConfig    
+
+    def __init__(self, config):
+        super().__init__(config)
+        
+        self.nlp_model = torch.hub.load('huggingface/pytorch-transformers', 'model', config.transformer_name)
+        self.rnn = nn.GRU(config.embedding_dim, 
+                      config.hidden_dim,
+                      num_layers = config.num_layers,
+                      bidirectional = config.bidirectional,
+                      batch_first = True,
+                      dropout = 0 if config.num_layers < 2 else config.dropout)
+        self.dropout = nn.Dropout(config.dropout)
+        self.out = nn.Linear(config.hidden_dim * 2 if config.bidirectional else config.hidden_dim, config.num_classes)
+
+    def forward(self, 
+                input_ids: Optional[torch.Tensor] = None,
+                attention_mask: Optional[torch.Tensor] = None,
+                token_type_ids: Optional[torch.Tensor] = None,
+                position_ids: Optional[torch.Tensor] = None,
+                head_mask: Optional[torch.Tensor] = None,
+                inputs_embeds: Optional[torch.Tensor] = None,
+                output_attentions: Optional[bool] = None,
+                output_hidden_states: Optional[bool] = None,
+                return_dict: Optional[bool] = None,
+        )-> Union[Tuple[torch.Tensor], SequenceClassifierOutput]:
+        output = self.nlp_model(
+          input_ids=input_ids,
+          attention_mask=attention_mask,
+          token_type_ids=token_type_ids,
+          position_ids=position_ids,
+          head_mask=head_mask,
+          inputs_embeds=inputs_embeds,
+          output_attentions=output_attentions,
+          output_hidden_states=output_hidden_states,
+          return_dict=return_dict,
+        )
+        _, hidden = self.rnn(output['last_hidden_state'])
+        if self.rnn.bidirectional:
+            hidden = self.dropout(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim = 1))
+        else:
+            hidden = self.dropout(hidden[-1,:,:])
+
+        logits = self.out(hidden)
+        return SequenceClassifierOutput(
+            logits=logits,
+            hidden_states=output.hidden_states,
+            attentions=output.attentions,
+        )

pytorch_model.bin

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