updated beam search parameter

app.py

@@ -18,7 +18,7 @@ from transformers import (
     CLIPModel, CLIPProcessor, BitsAndBytesConfig
 )
 
-app = FastAPI(title="XAI Auditor: Symmetrical Deterministic Ensemble")
+app = FastAPI(title="XAI Auditor: Pure Greedy Fast Ensemble")
 
 app.add_middleware(
     CORSMiddleware,
@@ -56,7 +56,7 @@ async def startup_event():
         "processor": BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-large")
     }
 
-    # 2. Load Compressed ViT Track (Fixed Shape Mappings)
+    # 2. Load Compressed ViT Track
     MODELS["vit"] = {
         "model": AutoModelForCausalLM.from_pretrained(
             os.path.join(local_dir, "vit"),
@@ -77,19 +77,19 @@ async def startup_event():
         "processor": CLIPProcessor.from_pretrained(os.path.join(local_dir, "clip/clip_processor"))
     }
     
-    print("All system weights safely pinned. Matrix crash protections active.")
+    print("All system weights safely pinned. Pure greedy acceleration paths ready.")
 
-# --- High-Speed Fixed Matrix Execution Engine ---
+# --- Ultra-Fast Pure Greedy Generation Engine ---
 
 def _generate_balanced_4_track(image, max_len=15):
     """
-    Generates exactly 4 captions (2 BLIP, 2 ViT) using safe, high-speed 
-    deterministic decoding loops that eliminate padding math overhead.
+    Generates exactly 4 captions using clean, single-pass greedy tracks 
+    with a repetition penalty to guarantee speed and output variation.
     """
     captions = []
     
     with torch.inference_mode():
-        # Track A: Batched BLIP Pass (2 Parallel Paths)
+        # Track A: Fast Greedy BLIP Pass (2 parallel unique streams)
         b_data = MODELS["blip"]
         b_inputs = b_data["processor"](images=image, return_tensors="pt")
         b_pixels = b_inputs.pixel_values.to(DEVICE)
@@ -98,15 +98,16 @@ def _generate_balanced_4_track(image, max_len=15):
         b_ids = b_data["model"].generate(
             pixel_values=batched_b_pixels,
             max_new_tokens=max_len,
-            do_sample=False,          # Purely deterministic execution
-            num_beams=2,              # 2 separate beams for internal diversity split
-            early_stopping=True,      # Break out the millisecond end token drops
-            use_cache=True            # Leverage cached keys to prevent recomputation
+            do_sample=False,              # Pure deterministic greedy path
+            num_beams=1,                  # Completely eliminate branching tree overhead
+            repetition_penalty=1.2,       # Forces variation across the two streams
+            early_stopping=True,
+            use_cache=True
         )
         b_caps = b_data["processor"].batch_decode(b_ids, skip_special_tokens=True)
         captions.extend([cap.strip() for cap in b_caps])
 
-        # Track B: Batched ViT Pass (2 Parallel Paths - Safe Matrix Sizing)
+        # Track B: Fast Greedy ViT Pass (2 parallel unique streams)
         v_data = MODELS["vit"]
         i_proc, t_proc = v_data["processor"]
         v_inputs = i_proc(images=image, return_tensors="pt")
@@ -122,8 +123,9 @@ def _generate_balanced_4_track(image, max_len=15):
             pixel_values=batched_v_pixels,
             attention_mask=batched_mask,
             max_new_tokens=max_len,
-            do_sample=False,          # Swapped off sample/contrastive to prevent shape mismatch
-            num_beams=2,              # Safe, standardized beam expansion tracking
+            do_sample=False,              # Pure deterministic greedy path
+            num_beams=1,                  # Completely eliminate branching tree overhead
+            repetition_penalty=1.2,       # Forces variation across the two streams
             early_stopping=True,
             use_cache=True
         )
@@ -140,7 +142,7 @@ async def generate_captions(file: UploadFile = File(...)):
     start_time = time.perf_counter()
     image = Image.open(file.file).convert("RGB")
     
-    # Fire off the optimized, crash-safe execution matrix
+    # Run the accelerated greedy pipeline
     captions = await asyncio.to_thread(_generate_balanced_4_track, image, 15)
     
     elapsed_time = time.perf_counter() - start_time
@@ -197,4 +199,36 @@ async def internal_debate_audit(file: UploadFile = File(...), user_prompt: str =
     image_bytes = await file.read()
     image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
     
-    # Extract
+    blip_caption = (await asyncio.to_thread(_generate_balanced_4_track, image, 15))[0]
+    
+    clip_m = MODELS["clip"]["model"]
+    clip_p = MODELS["clip"]["processor"]
+    clip_dtype = torch.float16 if DEVICE == "cuda" else torch.float32
+    
+    image_inputs = clip_p(images=image, return_tensors="pt")
+    text_inputs = clip_p(text=[user_prompt, blip_caption], return_tensors="pt", padding=True)
+    
+    with torch.inference_mode():
+        img_pixels = image_inputs.pixel_values.to(device=DEVICE, dtype=clip_dtype)
+        txt_ids = text_inputs.input_ids.to(DEVICE)
+        txt_mask = text_inputs.attention_mask.to(DEVICE)
+        
+        image_features = clip_m.get_image_features(pixel_values=img_pixels)
+        image_features = image_features / image_features.norm(dim=-1, keepdim=True)
+        
+        text_features = clip_m.get_text_features(input_ids=txt_ids, attention_mask=txt_mask)
+        text_features = text_features / text_features.norm(dim=-1, keepdim=True)
+        
+        logits_per_image = (image_features @ text_features.T) * clip_m.logit_scale.exp()
+        probs = F.softmax(logits_per_image, dim=-1).cpu().to(torch.float32).numpy()[0]
+    
+    u_score, m_score = float(probs[0]), float(probs[1])
+    verdict = "Model Bias Detected." if abs(u_score - m_score) >= 0.15 else "Consensus: High Alignment."
+    if u_score < 0.35: verdict = "Perspective Divergence: Intent not grounded in image."
+
+    return {
+        "perspectives": {"user": user_prompt, "ai": blip_caption},
+        "audit_scores": {"intent_grounding": round(u_score, 4), "ai_grounding": round(m_score, 4)},
+        "verdict": verdict,
+        "metadata": {"processing_time_sec": round(time.perf_counter() - start_time, 4)}
+    }