Update utils/models.py

utils/models.py

@@ -1,7 +1,4 @@
 import os
-# Keep Dynamo error suppression
-import torch._dynamo
-torch._dynamo.config.suppress_errors = True
 
 os.environ["MKL_THREADING_LAYER"] = "GNU"
 import spaces
@@ -17,8 +14,7 @@ from transformers import (
     BitNetForCausalLM
 )
 from .prompts import format_rag_prompt
-# Remove interrupt import
-# from .shared import generation_interrupt
+from .shared import generation_interrupt
 
 models = {
     "Qwen2.5-1.5b-Instruct": "qwen/qwen2.5-1.5b-instruct",
@@ -48,13 +44,13 @@ tokenizer_cache = {}
 model_names = list(models.keys())
 
 
-# Remove interrupt criteria class since we're not using it
-# class InterruptCriteria(StoppingCriteria):
-#     def __init__(self, interrupt_event):
-#         self.interrupt_event = interrupt_event
-# 
-#     def __call__(self, input_ids, scores, **kwargs):
-#         return self.interrupt_event.is_set()
+# Custom stopping criteria that checks the interrupt flag
+class InterruptCriteria(StoppingCriteria):
+    def __init__(self, interrupt_event):
+        self.interrupt_event = interrupt_event
+
+    def __call__(self, input_ids, scores, **kwargs):
+        return self.interrupt_event.is_set()
 
 
 @spaces.GPU
@@ -62,7 +58,9 @@ def generate_summaries(example, model_a_name, model_b_name):
     """
     Generates summaries for the given example using the assigned models sequentially.
     """
-    # Remove interrupt checks
+    if generation_interrupt.is_set():
+        return "", ""
+
     context_text = ""
     context_parts = []
 
@@ -90,15 +88,18 @@ def generate_summaries(example, model_a_name, model_b_name):
 
     question = example.get("question", "")
 
-    print(f"Starting inference for Model A: {model_a_name}")
+    if generation_interrupt.is_set():
+        return "", ""
+
     # Run model A
     summary_a = run_inference(models[model_a_name], context_text, question)
 
-    print(f"Starting inference for Model B: {model_b_name}")
+    if generation_interrupt.is_set():
+        return summary_a, ""
+
     # Run model B
     summary_b = run_inference(models[model_b_name], context_text, question)
 
-    print("Both models completed successfully")
     return summary_a, summary_b
 
 
@@ -106,8 +107,12 @@ def generate_summaries(example, model_a_name, model_b_name):
 def run_inference(model_name, context, question):
     """
     Run inference using the specified model.
-    Returns the generated text.
+    Returns the generated text or empty string if interrupted.
     """
+    # Check interrupt at the beginning
+    if generation_interrupt.is_set():
+        return ""
+
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     result = ""
     tokenizer_kwargs = {
@@ -145,18 +150,25 @@ def run_inference(model_name, context, question):
         if tokenizer.pad_token is None:
             tokenizer.pad_token = tokenizer.eos_token
 
+        # Check interrupt before loading the model
+        if generation_interrupt.is_set():
+            return ""
+
         print("REACHED HERE BEFORE pipe")
         print(f"Loading model {model_name}...")
-            
         if "bitnet" in model_name.lower():
             bitnet_model = BitNetForCausalLM.from_pretrained(
                 model_name,
+                #device_map="auto",
                 torch_dtype=torch.bfloat16,
+                #trust_remote_code=True,
             )
             pipe = pipeline(
                 "text-generation",
                 model=bitnet_model,
                 tokenizer=tokenizer,
+                #device_map="auto",
+                #trust_remote_code=True,
                 torch_dtype=torch.bfloat16,
                 model_kwargs={
                     "attn_implementation": "eager",
@@ -189,14 +201,12 @@ def run_inference(model_name, context, question):
             )
 
         text_input = format_rag_prompt(question, context, accepts_sys)
-        
-        print(f"Starting generation for {model_name}")
         if "Gemma-3".lower() in model_name.lower():
             print("REACHED HERE BEFORE GEN")
             result = pipe(
                 text_input,
                 max_new_tokens=512,
-                generation_kwargs={"skip_special_tokens": True}
+                generation_kwargs={"skip_special_tokens": True},
             )[0]["generated_text"]
 
             result = result[-1]["content"]
@@ -211,6 +221,7 @@ def run_inference(model_name, context, question):
                 **tokenizer_kwargs, 
             )
 
+
             model_inputs = model_inputs.to(model.device)
 
             input_ids = model_inputs.input_ids
@@ -219,12 +230,16 @@ def run_inference(model_name, context, question):
             prompt_tokens_length = input_ids.shape[1] 
 
             with torch.inference_mode():
+                # Check interrupt before generation
+                if generation_interrupt.is_set():
+                    return ""
+                
                 output_sequences = model.generate(
                     input_ids=input_ids,
                     attention_mask=attention_mask,
                     max_new_tokens=512,
                     eos_token_id=tokenizer.eos_token_id, 
-                    pad_token_id=tokenizer.pad_token_id
+                    pad_token_id=tokenizer.pad_token_id  # Addresses the warning
                 )
             
             generated_token_ids = output_sequences[0][prompt_tokens_length:]
@@ -238,10 +253,14 @@ def run_inference(model_name, context, question):
         #         **tokenizer_kwargs,
         #     ).to(bitnet_model.device)
         #     with torch.inference_mode():
+        #         # Check interrupt before generation
+        #         if generation_interrupt.is_set():
+        #             return ""
         #         output_sequences = bitnet_model.generate(
         #             **formatted,
         #             max_new_tokens=512,
         #         )
+
         #         result = tokenizer.decode(output_sequences[0][formatted['input_ids'].shape[-1]:], skip_special_tokens=True)
         else:  # For other models
             formatted = pipe.tokenizer.apply_chat_template(
@@ -251,16 +270,16 @@ def run_inference(model_name, context, question):
             )
 
             input_length = len(formatted)
+            # Check interrupt before generation
 
             outputs = pipe(
                 formatted,
                 max_new_tokens=512,
-                generation_kwargs={"skip_special_tokens": True}
+                generation_kwargs={"skip_special_tokens": True},
             )
+            # print(outputs[0]['generated_text'])
             result = outputs[0]["generated_text"][input_length:]
 
-        print(f"Generation completed for {model_name}")
-
     except Exception as e:
         print(f"Error in inference for {model_name}: {e}")
         print(traceback.format_exc())