Uploaded infrastructure and model files

config.json

@@ -0,0 +1,26 @@
+{
+  "architectures": [
+    "RobertaForQuestionAnswering"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 514,
+  "model_type": "roberta",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 1,
+  "position_embedding_type": "absolute",
+  "transformers_version": "4.57.1",
+  "type_vocab_size": 1,
+  "use_cache": true,
+  "vocab_size": 50265
+}

handler.py

@@ -0,0 +1,287 @@
+import torch
+import logging
+import re
+from typing import Dict, List, Any
+from simpletransformers.question_answering import QuestionAnsweringModel
+
+# Configure logging (no file I/O for serverless environment)
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class EndpointHandler:
+    def __init__(self, path=""):
+        """
+        Initialize the RECCON emotional trigger extraction model.
+
+        Args:
+            path: Path to model directory (provided by HuggingFace Inference Endpoints)
+        """
+        logger.info("Initializing RECCON Trigger Extraction endpoint...")
+
+        # Detect device (CUDA/CPU)
+        cuda_available = torch.cuda.is_available()
+        if not cuda_available:
+            logger.warning("GPU not detected. Running on CPU. Inference will be slower.")
+        self.device = torch.device("cuda" if cuda_available else "cpu")
+        cuda_device = 0 if cuda_available else -1
+
+        # Determine model path
+        if not path or path == ".":
+            model_path = "."
+        else:
+            model_path = path
+
+        logger.info(f"Loading model from {model_path}...")
+
+        # Load the QuestionAnsweringModel using simpletransformers
+        try:
+            self.model = QuestionAnsweringModel(
+                "roberta",
+                model_path,
+                args={
+                    "silent_tf_logger": True,
+                    "eval_batch_size": 8,
+                    "device_map": None,
+                    "max_seq_length": 512,
+                    "max_answer_length": 200,
+                    "n_best_size": 20,
+                    "doc_stride": 512
+                },
+                use_cuda=cuda_available,
+                cuda_device=cuda_device
+            )
+            logger.info("Model loaded successfully.")
+        except Exception as e:
+            logger.error(f"Failed to load model: {e}")
+            raise
+
+        # Question template (must match training)
+        self.question_template = (
+            "Extract the exact short phrase (<= 8 words) from the target "
+            "utterance that most strongly signals the emotion {emotion}. "
+            "Return only a substring of the target utterance."
+        )
+
+    def __call__(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        Process inference request.
+
+        Args:
+            data: Request data with structure:
+                {
+                    "inputs": [
+                        {"utterance": "text", "emotion": "happiness"},
+                        ...
+                    ]
+                }
+
+        Returns:
+            List of results:
+                [
+                    {
+                        "utterance": "text",
+                        "emotion": "happiness",
+                        "triggers": ["trigger phrase 1", "trigger phrase 2"]
+                    },
+                    ...
+                ]
+        """
+        # Extract inputs
+        inputs = data.pop("inputs", data)
+
+        # Normalize to list format (handle single dict)
+        if isinstance(inputs, dict):
+            inputs = [inputs]
+
+        if not inputs:
+            return [{"error": "No inputs provided", "triggers": []}]
+
+        # Validate and format inputs
+        qa_inputs = []
+        valid_indices = []
+
+        for i, item in enumerate(inputs):
+            utterance = item.get("utterance", "").strip()
+            emotion = item.get("emotion", "")
+
+            if not utterance:
+                logger.warning(f"Empty utterance at index {i}")
+                continue
+
+            # Format as QA task
+            question = self.question_template.format(emotion=emotion)
+            qa_inputs.append({
+                'context': utterance,
+                'qas': [{
+                    'id': f'temp_id_{i}',
+                    'question': question
+                }]
+            })
+            valid_indices.append(i)
+
+        # Run prediction
+        results = []
+
+        if not qa_inputs:
+            # All inputs were invalid
+            for item in inputs:
+                results.append({
+                    "utterance": item.get("utterance", ""),
+                    "emotion": item.get("emotion", ""),
+                    "error": "Missing or empty utterance",
+                    "triggers": []
+                })
+            return results
+
+        try:
+            predictions, _ = self.model.predict(qa_inputs)
+            logger.debug(f"Raw predictions: {predictions}")
+
+            # Post-process results
+            result_idx = 0
+            for i, item in enumerate(inputs):
+                utterance = item.get("utterance", "").strip()
+                emotion = item.get("emotion", "")
+
+                if i not in valid_indices:
+                    # Invalid input
+                    results.append({
+                        "utterance": utterance,
+                        "emotion": emotion,
+                        "error": "Missing or empty utterance",
+                        "triggers": []
+                    })
+                else:
+                    # Valid input - process prediction
+                    prediction = predictions[result_idx]
+                    answer = prediction.get('answer')
+
+                    # Extract and clean spans
+                    if isinstance(answer, list) and len(answer) > 0:
+                        non_empty_answers = [a for a in answer if a]
+                        triggers = self._clean_spans(non_empty_answers, utterance)
+                    elif isinstance(answer, str):
+                        triggers = self._clean_spans([answer], utterance)
+                    else:
+                        triggers = []
+
+                    results.append({
+                        "utterance": utterance,
+                        "emotion": emotion,
+                        "triggers": triggers
+                    })
+                    result_idx += 1
+
+            logger.debug(f"Cleaned results: {results}")
+            return results
+
+        except Exception as e:
+            logger.error(f"Model prediction failed: {e}")
+            # Return error for all inputs
+            return [{
+                "utterance": item.get("utterance", ""),
+                "emotion": item.get("emotion", ""),
+                "error": str(e),
+                "triggers": []
+            } for item in inputs]
+
+    def _clean_spans(self, spans: List[str], target_text: str) -> List[str]:
+        """
+        Clean and filter extracted trigger spans.
+
+        This function preserves all the post-processing logic from predict_trigger.py
+        (lines 78-153) including stopword filtering, length constraints, deduplication,
+        and n-gram fallback.
+
+        Args:
+            spans: Raw spans extracted by the model
+            target_text: Original utterance text
+
+        Returns:
+            List of up to 3 cleaned trigger phrases
+        """
+        target_text = target_text or ""
+        target_lower = target_text.lower()
+
+        def _norm(s: str) -> str:
+            """Normalize a string: strip, lowercase, remove extra spaces and punctuation."""
+            s = (s or "").strip().lower()
+            s = re.sub(r"\s+", " ", s)
+            s = re.sub(r"^[^\w]+|[^\w]+$", "", s)
+            return s
+
+        def _extract_from_target(target: str, phrase_lower: str) -> str:
+            """Extract phrase from target with original casing."""
+            idx = target.lower().find(phrase_lower)
+            if idx >= 0:
+                return target[idx:idx+len(phrase_lower)]
+            return phrase_lower
+
+        # Stopwords to filter out
+        STOP = {
+            "a", "an", "the", "and", "or", "but", "so", "to", "of", "in", "on", "at",
+            "with", "for", "from", "is", "am", "are", "was", "were", "be", "been",
+            "being", "i", "you", "he", "she", "it", "we", "they", "my", "your", "his",
+            "her", "their", "our", "me", "him", "her", "them", "this", "that", "these",
+            "those"
+        }
+
+        # Collect candidate spans that are substrings of target and reasonable length
+        candidates = []
+        for s in spans:
+            s = (s or "").strip()
+            if not s:
+                continue
+            s_norm = _norm(s)
+            if not s_norm:
+                continue
+            if target_text and s_norm not in target_lower:
+                continue
+            tokens = s_norm.split()
+            if len(tokens) > 8 or len(s_norm) > 80:
+                continue
+            if len(tokens) == 1 and (tokens[0] in STOP or len(tokens[0]) <= 2):
+                continue
+            candidates.append({
+                "norm": s_norm,
+                "tokens": tokens,
+                "tok_len": len(tokens),
+                "char_len": len(s_norm)
+            })
+
+        # Prefer longer phrases; remove subsumed/duplicate fragments
+        candidates.sort(key=lambda x: (x["tok_len"], x["char_len"]), reverse=True)
+        kept_norms = []
+        for c in list(candidates):
+            n = c["norm"]
+            if any(n in kn or kn in n for kn in kept_norms):
+                continue
+            kept_norms.append(n)
+
+        cleaned = [_extract_from_target(target_text, n) for n in kept_norms]
+
+        if not cleaned and spans:
+            # Fallback: try to salvage a sub-span that actually exists
+            # in the target utterance by scanning n-grams up to 8 words
+            tt_tokens = target_lower.split()
+            best = None
+            for s in spans:
+                words = [w for w in (s or '').lower().strip().split() if w]
+                for L in range(min(8, len(words)), 0, -1):
+                    for i in range(len(words) - L + 1):
+                        phrase = words[i:i+L]
+                        # contiguous n-gram match on token boundaries
+                        for j in range(len(tt_tokens) - L + 1):
+                            if tt_tokens[j:j+L] == phrase:
+                                cand = " ".join(phrase)
+                                best = cand
+                                break
+                        if best:
+                            break
+                    if best:
+                        break
+            if best:
+                return [_extract_from_target(target_text, best)]
+
+        return cleaned[:3]

model.safetensors

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

requirements.txt

@@ -0,0 +1,3 @@
+transformers>=4.30.0,<5.0.0
+torch>=2.0.0
+simpletransformers>=0.64.0

special_tokens_map.json

@@ -0,0 +1,51 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "<mask>",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<pad>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer_config.json

@@ -0,0 +1,58 @@
+{
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<pad>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "50264": {
+      "content": "<mask>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "<s>",
+  "do_lower_case": false,
+  "eos_token": "</s>",
+  "errors": "replace",
+  "extra_special_tokens": {},
+  "mask_token": "<mask>",
+  "model_max_length": 512,
+  "pad_token": "<pad>",
+  "sep_token": "</s>",
+  "tokenizer_class": "RobertaTokenizer",
+  "unk_token": "<unk>"
+}