Update app/src/cross_encoder.py

app/src/cross_encoder.py

@@ -1,3 +1,5 @@
+import os
+import shutil
 from sentence_transformers import CrossEncoder
 from nltk import sent_tokenize
 import numpy as np
@@ -5,19 +7,37 @@ import numpy as np
 class CrossEncoderSimilarity:
     """
     Uses a cross‑encoder to compute deep semantic similarity between mark and goods.
-    Supports sentence‑level segmentation and returns attention weights for explainability.
+    Supports sentence‑level segmentation and lazy model loading with auto cache clearing.
     """
 
     def __init__(self, model_name='cross-encoder/stsb-roberta-large'):
-        self.model = CrossEncoder(model_name, num_labels=1)  # regression output
-        # We'll store the last attention scores if needed (for explainability)
-        self.last_attention = None
+        self.model_name = model_name
+        self._model = None
+
+    @property
+    def model(self):
+        """Lazy load the cross-encoder model, with retry and cache clearing on failure."""
+        if self._model is None:
+            try:
+                print(f"Loading cross-encoder model: {self.model_name}")
+                self._model = CrossEncoder(self.model_name, num_labels=1)
+            except Exception as e:
+                print(f"❌ Error loading model: {e}. Attempting to clear cache and retry...")
+                # Determine cache directory for this model
+                cache_dir = os.path.join(
+                    os.environ.get("HF_HOME", "/tmp/.cache/huggingface"),
+                    "models",
+                    self.model_name.replace("/", "--")
+                )
+                if os.path.exists(cache_dir):
+                    print(f"Removing corrupted cache: {cache_dir}")
+                    shutil.rmtree(cache_dir)
+                print("Retrying model load...")
+                self._model = CrossEncoder(self.model_name, num_labels=1)
+                print("✅ Cross-encoder model loaded successfully after cache clear.")
+        return self._model
 
     def similarity(self, mark, goods, return_segments=False):
-        """
-        Returns a score between 0 and 1. If return_segments=True, also returns
-        the maximum segment score and the segment text.
-        """
         if not goods:
             return 0.0 if not return_segments else (0.0, None)
         sentences = sent_tokenize(goods)
@@ -26,8 +46,7 @@ class CrossEncoderSimilarity:
 
         pairs = [(mark, sent) for sent in sentences]
         scores = self.model.predict(pairs)
-        # Normalize: assume model output range roughly 0-5 (for stsb models)
-        # If using a different model, adjust normalization accordingly.
+        # Normalize (assuming stsb model output range 0-5)
         scores_norm = [min(1.0, max(0.0, s / 5.0)) for s in scores]
         max_score = max(scores_norm)
         max_idx = int(np.argmax(scores_norm))
@@ -37,11 +56,6 @@ class CrossEncoderSimilarity:
         return max_score
 
     def similarity_with_explanation(self, mark, goods):
-        """
-        Returns score and the most relevant sentence from goods, plus optionally attention.
-        For attention, we'd need a model that returns cross‑attention; not all do.
-        This method provides a simple explanation.
-        """
         max_score, best_sentence = self.similarity(mark, goods, return_segments=True)
         explanation = f"Highest similarity with segment: '{best_sentence}' (score: {max_score:.2f})"
         return max_score, explanation