Upload 3 files

# Arabic End-of-Utterance (EOU) Classifier

## Overview
This repository contains a custom PyTorch model for **End-of-Utterance (EOU) detection** in Arabic conversational text.
The model predicts whether a given text segment represents the end of a speaker’s turn.

This is a **custom architecture** (not a Hugging Face `AutoModel`) and is intended for research and development use.

---

## Task
Given an input text segment, the model outputs a binary prediction:

- `0` → The speaker is expected to continue speaking
- `1` → The speaker has finished their turn

---

## Model Details
- Framework: PyTorch
- Architecture: Custom `EOUClassifier`
- Task: Binary classification (EOU detection)
- Language: Arabic

---

## Tokenizer
This model uses the tokenizer from:

`Omartificial-Intelligence-Space/SA-BERT-V1`

The tokenizer is **not included** in this repository and must be loaded separately.

---

## Files
- `model.py` — Model architecture (`EOUClassifier`)
- `model.pt` — Trained model weights
- `config.json` — Model configuration
- `README.md` — This file

---

## Loading the Model
```python
import torch
from transformers import AutoTokenizer
from model import EOUClassifier

tokenizer = AutoTokenizer.from_pretrained(
"Omartificial-Intelligence-Space/SA-BERT-V1"
)

model = EOUClassifier()
model.load_state_dict(
torch.load("model.pt", map_location="cpu")
)
model.eval()

examples = ["مقصدي من الموضوع انه", "اتمنى تقدر تساعدني"]


batch = tokenizer(examples, padding=True, truncation=True, return_tensors="pt")
batch.to(device)

out = model(batch["input_ids"], batch["attention_mask"])
```

##Intended Use

- End-of-turn detection

- Streaming conversational agents

- Dialogue systems

- Real-time response timing control

Notes

- This model requires the architecture code (model.py) to run.

- The architecture used at inference must exactly match the one used during training.

##License

MIT License

config.json

@@ -0,0 +1,8 @@
+{
+    "model_name": "EOUClassifier",
+    "task": "end_of_utterance_detection",
+    "num_labels": 2,
+    "language": "ar",
+    "base_tokenizer": "Omartificial-Intelligence-Space/SA-BERT-V1",
+    "framework": "pytorch"
+}

model.pt

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

model.py

@@ -0,0 +1,46 @@
+import torch
+import torch.nn as nn
+from transformers import AutoModel
+
+MODEL_ID = "Omartificial-Intelligence-Space/SA-BERT-V1"
+
+class EOUClassifier(nn.Module):
+    def __init__(self, model_id=MODEL_ID, num_labels=2, use_class_weights=True, pooling="cls"):
+        super().__init__()
+        self.num_labels = num_labels
+        self.pooling = pooling  # "cls" or "mean"
+
+        # Load encoder
+        self.bert = AutoModel.from_pretrained(model_id)
+
+        self.dropout = nn.Dropout(0.15)
+        self.layer_1 = nn.Linear(768, 384)
+        self.act = nn.GELU()
+        self.layer_2 = nn.Linear(384, num_labels)
+
+        
+        self.loss_fn = nn.CrossEntropyLoss()
+
+
+    def forward(self, input_ids, attention_mask, labels=None):
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+
+        if self.pooling == "cls":
+            pooled = outputs.last_hidden_state[:, 0]  # [CLS]
+        else:
+            # Mean pooling
+            hidden = outputs.last_hidden_state
+            mask = attention_mask.unsqueeze(-1)
+            pooled = (hidden * mask).sum(dim=1) / mask.sum(dim=1)
+
+        x = self.dropout(pooled)
+        x = self.layer_1(x)
+        x = self.act(x)
+        x = self.dropout(x)
+        logits = self.layer_2(x)
+
+        if labels is not None:
+            loss = self.loss_fn(logits, labels)
+            return {"loss": loss, "logits": logits}
+
+        return {"logits": logits}