Try to fix inference.py

backend/runner/inference.py

@@ -169,12 +169,10 @@ def _initialize_pipeline():
         # Check if we're using streaming
         if embeddings_data.get("streaming", False):
             print("✅ Using streaming embeddings - will load on-demand")
-            # For streaming, we'll load embeddings as needed during inference
-            return {
-                "streaming": True,
-                "dataset": embeddings_data["dataset"],
-                "repo_id": embeddings_data["repo_id"]
-            }
+            # For streaming, we need to handle this differently
+            # We'll return the components but mark embeddings as streaming
+            # The calling code will need to handle this case
+            return processor, model, "STREAMING", "STREAMING", "STREAMING", device
         else:
             # Old code path for non-streaming
             if MODEL_TYPE == "clip":
@@ -314,6 +312,21 @@ def run_inference(
         )
         print(f"✅ Pipeline components loaded successfully")
 
+        # Check if we're in streaming mode
+        if embeddings == "STREAMING":
+            print("✅ Streaming mode detected - using streaming embeddings")
+            return run_inference_streaming(
+                image_path=image_path,
+                filter_topics=filter_topics,
+                filter_creators=filter_creators,
+                model_type=model_type,
+                top_k=top_k,
+                processor=processor,
+                model=model,
+                device=device
+            )
+
+        # Non-streaming mode - continue with existing logic
         # Get valid sentence IDs based on filters
         if filter_topics or filter_creators:
             print(f"🔍 Applying filters...")
@@ -619,3 +632,124 @@ def process_embedding_batch(batch: List[Dict], query_embedding: torch.Tensor, mo
             continue
     
     return similarities
+
+def run_inference_streaming(
+    image_path: str,
+    filter_topics: List[str] = None,
+    filter_creators: List[str] = None,
+    model_type: str = "CLIP",
+    top_k: int = 10,
+    processor=None,
+    model=None,
+    device=None
+) -> List[Dict[str, Any]]:
+    """Run inference using streaming embeddings"""
+    try:
+        print(f"🔍 Running streaming inference for {image_path}")
+        
+        # Load and preprocess the image
+        print(f"🔍 Loading and preprocessing image: {image_path}")
+        image = Image.open(image_path).convert("RGB")
+        print(f"✅ Image loaded successfully, size: {image.size}")
+
+        # Compute image embedding
+        inputs = processor(images=image, return_tensors="pt")
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+
+        with torch.no_grad():
+            image_features = model.get_image_features(**inputs)
+            image_embedding = F.normalize(image_features.squeeze(0), dim=-1)
+
+        # Get streaming dataset
+        if not EMBEDDINGS_DATASETS or not EMBEDDINGS_DATASETS.get('use_streaming', False):
+            raise ValueError("Streaming embeddings not available")
+            
+        dataset = EMBEDDINGS_DATASETS['streaming_dataset']
+        
+        # Process embeddings in streaming mode
+        results = []
+        batch_size = 1000
+        batch = []
+        
+        print(f"🔍 Processing streaming embeddings...")
+        
+        for item in dataset:
+            batch.append(item)
+            
+            if len(batch) >= batch_size:
+                # Process batch
+                batch_results = process_embedding_batch_streaming(
+                    batch, image_embedding, model_type, device
+                )
+                results.extend(batch_results)
+                batch = []
+                
+                # Keep only top-k so far
+                results.sort(key=lambda x: x["score"], reverse=True)
+                results = results[:top_k]
+                
+                print(f"🔍 Processed batch, current top score: {results[0]['score'] if results else 'N/A'}")
+        
+        # Process remaining items
+        if batch:
+            batch_results = process_embedding_batch_streaming(
+                batch, image_embedding, model_type, device
+            )
+            results.extend(batch_results)
+            results.sort(key=lambda x: x["score"], reverse=True)
+            results = results[:top_k]
+        
+        print(f"✅ Streaming inference completed, returning {len(results)} results")
+        return results
+        
+    except Exception as e:
+        print(f"❌ Error in streaming inference: {e}")
+        raise
+
+def process_embedding_batch_streaming(
+    batch: List[Dict], 
+    image_embedding: torch.Tensor, 
+    model_type: str, 
+    device: torch.device
+) -> List[Dict[str, Any]]:
+    """Process a batch of streaming embeddings"""
+    results = []
+    
+    for item in batch:
+        try:
+            sentence_id = item.get('sentence_id', '')
+            
+            # Get the appropriate embedding
+            if model_type == "CLIP" and 'clip_embedding' in item:
+                embedding = torch.tensor(item['clip_embedding'])
+            elif model_type == "PaintingCLIP" and 'paintingclip_embedding' in item:
+                embedding = torch.tensor(item['paintingclip_embedding'])
+            else:
+                continue
+            
+            # Calculate similarity
+            embedding = embedding.to(device)
+            similarity = F.cosine_similarity(
+                image_embedding.unsqueeze(0), 
+                embedding.unsqueeze(0), 
+                dim=1
+            ).item()
+            
+            # Get sentence metadata
+            sentences_data = _load_sentences_metadata()
+            sentence_data = sentences_data.get(sentence_id, {})
+            work_id = sentence_id.split("_")[0]
+            
+            results.append({
+                "id": sentence_id,
+                "score": similarity,
+                "english_original": sentence_data.get("English Original", "N/A"),
+                "work": work_id,
+                "rank": len(results) + 1,
+            })
+            
+        except Exception as e:
+            print(f"⚠️  Error processing item in streaming batch: {e}")
+            continue
+    
+    return results