🚀 Initial deploy of ABSA Space

app.py

@@ -0,0 +1,14 @@
+import gradio as gr
+from ABSA.inference import model, tokenizer, label2id, id2label
+import torch
+
+def predict(text):
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding="max_length", max_length=128)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    preds = outputs["logits"].squeeze(0).tolist()
+    labels = [id2label.get(p, "O") for p in preds]
+    tokens = tokenizer.tokenize(text)
+    return list(zip(tokens, labels))
+
+gr.Interface(fn=predict, inputs="text", outputs="json", title="Arabic ABSA Model").launch()

inference.py

@@ -0,0 +1,21 @@
+import torch
+from ABSA.model import BERT_BiLSTM_CRF  # Same model class you defined
+from transformers import AutoTokenizer, AutoModel
+import json
+
+# Load tokenizer and base model
+model_path = "saved_model"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+base_model = AutoModel.from_pretrained(model_path)
+
+# Load label mappings
+with open(f"{model_path}/label2id.json") as f:
+    label2id = json.load(f)
+with open(f"{model_path}/id2label.json") as f:
+    id2label = {int(k): v for k, v in json.load(f).items()}
+
+# Init and load model
+num_labels = len(label2id)
+model = BERT_BiLSTM_CRF(base_model, num_labels)
+model.load_state_dict(torch.load(f"{model_path}/full_model.pth", map_location="cpu"))
+model.eval()

model.py

@@ -0,0 +1,41 @@
+import torch
+import torch.nn as nn
+from torchcrf import CRF
+
+class BERT_BiLSTM_CRF(nn.Module):
+    def __init__(self, base_model, num_labels, dropout_rate=0.2, rnn_dim=256):
+        super().__init__()
+        self.bert = base_model
+        self.bilstm = nn.LSTM(
+            self.bert.config.hidden_size,
+            rnn_dim,
+            num_layers=2,
+            batch_first=True,
+            bidirectional=True,
+            dropout=0.2
+        )
+        self.dropout = nn.Dropout(dropout_rate)
+        self.classifier = nn.Linear(rnn_dim * 2, num_labels)
+        self.crf = CRF(num_labels, batch_first=True)
+
+    def forward(self, input_ids, attention_mask, token_type_ids=None, labels=None):
+        outputs = self.bert(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids
+        )
+        lstm_out, _ = self.bilstm(self.dropout(outputs.last_hidden_state))
+        emissions = self.classifier(lstm_out)
+        mask = attention_mask.bool()
+
+        if labels is not None:
+            safe_labels = labels.clone()
+            safe_labels[labels == -100] = 0  # Default to "O" index
+            loss = -self.crf(emissions, safe_labels, mask=mask, reduction='mean')
+            return {'loss': loss, 'logits': emissions}
+        else:
+            decoded = self.crf.decode(emissions, mask=mask)
+            max_len = input_ids.shape[1]
+            padded_decoded = [seq + [0] * (max_len - len(seq)) for seq in decoded]
+            logits = torch.tensor(padded_decoded, device=input_ids.device)
+            return {'logits': logits}

requirements.txt

@@ -0,0 +1,5 @@
+torch
+transformers
+gradio
+torchcrf
+peft