Added handler

config.json

@@ -0,0 +1,4 @@
+{
+  "task": "text-classification",
+  "custom_handler": "handler.py"
+}

cross_scorer_model.py

@@ -10,7 +10,6 @@ from transformers import BertForMaskedLM
 
 import torch.nn.functional as F
 
-import spacy
 import transformers
 import torch.nn as nn
 

handler.py

@@ -0,0 +1,60 @@
+import torch
+import importlib.util
+import sys
+import pathlib
+from transformers import AutoModel, AutoTokenizer
+
+class InferenceHandler:
+    def __init__(self):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Import custom model definition from local file
+        model_path = "cross_scorer_model.py"
+        spec = importlib.util.spec_from_file_location("cross_scorer_model", model_path)
+        mod = importlib.util.module_from_spec(spec)
+        sys.modules["cross_scorer_model"] = mod
+        spec.loader.exec_module(mod)
+        
+        # Initialize encoder and custom model
+        encoder = AutoModel.from_pretrained("roberta-base", add_pooling_layer=False)
+        self.model = mod.CrossScorerCrossEncoder(encoder).to(self.device)
+        
+        # Load weights
+        weights_path = "reflection_scorer_weight.pt"
+        state = torch.load(weights_path, map_location=self.device)
+        sd = state.get("model_state_dict", state)
+        self.model.load_state_dict(sd, strict=False)
+        
+        self.model.eval()
+        
+        # Initialize tokenizer
+        self.tokenizer = AutoTokenizer.from_pretrained("roberta-base")
+
+    def handle(self, inputs: list) -> list:
+        results = []
+        for item in inputs:
+            prompt = item.get("prompt")
+            response = item.get("response")
+            
+            if not prompt or not response:
+                # Handle missing keys gracefully, though instructions imply strict format
+                results.append({"error": "Missing prompt or response"})
+                continue
+
+            # Preprocessing
+            batch = self.tokenizer(
+                prompt, 
+                response, 
+                padding="longest", 
+                truncation=True, 
+                return_tensors="pt"
+            ).to(self.device)
+            
+            # Inference
+            with torch.no_grad():
+                # score_forward returns raw logits (based on README/code usage), we need sigmoid
+                score = self.model.score_forward(**batch).sigmoid().item()
+            
+            results.append({"score": round(score, 4)})
+            
+        return results

requirements.txt

@@ -0,0 +1,2 @@
+transformers
+torch