Initial commit with model files tracked via Git LFS

.gitattributes

@@ -0,0 +1,3 @@
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 NeuralNest05
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,85 @@
+# emo-detector
+
+**emo-detector** is a multi-label emotion detection model for text. It predicts one or more emotions from the following labels:
+
+- anger
+- fear
+- joy
+- sadness
+- surprise
+
+## Model Details
+
+- **Architecture:** Pretrained DeBERTa + custom FFNN classifier  
+- **Task:** Multi-label text classification    
+- **Tokenizer:** DeBERTa tokenizer (`microsoft/deberta-v3-base`) 
+- **Output:** Probabilities → Thresholded to 0/1
+
+## Custom Model Class
+
+This model uses a custom architecture implemented in `model.py`, specifically the class:
+```
+BERT_FFNN
+```
+If you want to load this model locally or fine-tune it further, make sure you have `model.py` in your working directory or import it correctly.
+
+## Installation
+```bash
+pip install torch transformers
+```
+
+## Usage
+
+```python
+from transformers import AutoTokenizer
+import torch
+from model import BERT_FFNN 
+
+# Load tokenizer
+tokenizer = AutoTokenizer.from_pretrained("NeuralNest05/emo-detector")
+
+# Load model
+config = {
+    "bert_model_name": "microsoft/deberta-v3-base",
+    "hidden_dims": [192, 96],
+    "output_dim": 5,
+    "dropout": 0.2,
+    "pooling": "attention",
+    "freeze_bert": False,
+    "freeze_layers": 0,
+    "use_layer_norm": True
+}
+model = BERT_FFNN(**config)
+model.load_state_dict(torch.load("pytorch_model.bin", map_location="cpu"))
+model.eval()
+
+# Example prediction
+texts = ["I am very happy today!", "This is scary..."]
+encodings = tokenizer(texts, truncation=True, padding=True, return_tensors="pt")
+with torch.no_grad():
+    logits = model(**encodings)
+    probs = torch.sigmoid(logits)
+    threshold = 0.5
+    preds = (probs > threshold).int()
+
+print(preds)
+```
+
+## Output Format 
+Each prediction corresponds to the five emotion labels in this order:
+```
+["anger", "fear", "joy", "sadness", "surprise"]
+```
+Output is a multi-hot vector, e.g.:
+```
+[0, 0, 1, 0, 0] → joy
+```
+
+## License
+MIT License
+
+## Acknowledgements
+
+- Microsoft DeBERTa-v3
+- Hugging Face Transformers
+- PyTorch

added_tokens.json

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

config.json

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

model.py

@@ -0,0 +1,88 @@
+import torch.nn as nn
+import torch
+from transformers import AutoModel
+
+class BERT_FFNN(nn.Module):
+    """
+    BERT_FFNN: BERT + feed-forward network for text classification tasks.
+    """
+    def __init__(
+        self,
+        bert_model_name= "microsoft/deberta-v3-base",
+        hidden_dims=[192, 96],
+        output_dim=5,
+        dropout=0.2,
+        pooling='attention',
+        freeze_bert=False,
+        freeze_layers=0,
+        use_layer_norm=True
+    ):
+        super().__init__()
+        
+        # Load pretrained BERT
+        self.bert = AutoModel.from_pretrained(bert_model_name)
+        self.use_layer_norm = use_layer_norm
+        self.pooling = pooling
+        
+        if pooling == 'attention':
+            self.attention_pool = AttentionPooling(self.bert.config.hidden_size)
+                
+        if freeze_bert:
+            for param in self.bert.parameters():
+                param.requires_grad = False
+        elif freeze_layers > 0:
+            for layer in self.bert.encoder.layer[:freeze_layers]:
+                for param in layer.parameters():
+                    param.requires_grad = False
+
+        # Build FFNN layers
+        fc_input_dim = self.bert.config.hidden_size
+        layers = []
+        in_dim = fc_input_dim
+        for h_dim in hidden_dims:
+            layers.append(nn.Linear(in_dim, h_dim))
+            layers.append(nn.ReLU())
+            if use_layer_norm:
+                layers.append(nn.LayerNorm(h_dim))
+            layers.append(nn.Dropout(dropout))
+            in_dim = h_dim
+        layers.append(nn.Linear(in_dim, output_dim))
+        self.classifier = nn.Sequential(*layers)
+    
+    def forward(self, input_ids, attention_mask):
+        # BERT forward
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        
+        if self.pooling == 'mean':
+            mask = attention_mask.unsqueeze(-1).float()
+            sum_emb = (outputs.last_hidden_state * mask).sum(1)
+            features = sum_emb / mask.sum(1).clamp(min=1e-9)
+        elif self.pooling == 'max':
+            mask = attention_mask.unsqueeze(-1).float()
+            masked_emb = outputs.last_hidden_state.masked_fill(mask == 0, float('-inf'))
+            features, _ = masked_emb.max(dim=1)
+        elif self.pooling == 'attention':
+            features = self.attention_pool(outputs.last_hidden_state, attention_mask)
+        else:
+            # CLS pooling
+            features = outputs.pooler_output if getattr(outputs, 'pooler_output', None) is not None else outputs.last_hidden_state[:, 0]        
+        
+        logits = self.classifier(features)
+        return logits
+
+class AttentionPooling(nn.Module):
+    def __init__(self, hidden_size):
+        super().__init__()
+        self.attention = nn.Linear(hidden_size, 1)
+
+    def forward(self, hidden_states, attention_mask):
+        # hidden_states: [batch, seq_len, hidden]
+        # attention_mask: [batch, seq_len]
+
+        scores = self.attention(hidden_states).squeeze(-1)  # [batch, seq_len]
+        scores = scores.masked_fill(attention_mask == 0, -1e9)
+        weights = torch.softmax(scores, dim=-1)  # [batch, seq_len]
+
+        weighted_sum = torch.sum(hidden_states * weights.unsqueeze(-1), dim=1)
+        return weighted_sum
+

pytorch_model.bin

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

special_tokens_map.json

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

spm.model

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

tokenizer.json

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

tokenizer_config.json

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