Upload 2 files

benchmark_efficiency.py

@@ -0,0 +1,55 @@
+import torch
+import time
+from cnn1 import UNet  # Importing your UNet from your files
+from thop import profile
+import numpy as np
+
+def benchmark(device="cpu"):
+    print(f"--- Benchmarking on {device.upper()} ---")
+    
+    # 1. Setup Model
+    model = UNet(text_dim=512).to(device)
+    model.eval()
+    
+    # 2. Setup Dummy Inputs (Standard 512x512 image + CLIP embedding)
+    dummy_image = torch.randn(1, 3, 512, 512).to(device)
+    dummy_text = torch.randn(1, 512).to(device) # Normalized text embedding
+    
+    # --- METRIC 1: FLOPs & Parameters ---
+    if device == "cpu": # Only need to calc this once
+        print("Calculating FLOPs and Params...")
+        macs, params = profile(model, inputs=(dummy_image, dummy_text), verbose=False)
+        print(f"Parameters: {params / 1e6:.2f} M")
+        print(f"GFLOPs:     {macs / 1e9:.2f} G")
+    
+    # --- METRIC 2: Inference Time ---
+    print("Measuring Inference Speed...")
+    
+    # Warmup (get cache ready)
+    for _ in range(5):
+        with torch.no_grad():
+            _ = model(dummy_image, dummy_text)
+            
+    # Measure
+    latencies = []
+    with torch.no_grad():
+        for _ in range(50): # Run 50 times
+            start = time.time()
+            _ = model(dummy_image, dummy_text)
+            if device == "cuda":
+                torch.cuda.synchronize() # Wait for GPU to finish
+            end = time.time()
+            latencies.append(end - start)
+            
+    avg_time = np.mean(latencies)
+    print(f"Avg Inference Time: {avg_time:.4f} seconds")
+    print(f"FPS: {1/avg_time:.2f}")
+    print("-" * 30)
+
+if __name__ == "__main__":
+    # Run on CPU (Crucial for your "Lightweight" claim)
+    benchmark("cpu")
+    
+    # Run on GPU (If available, for comparison)
+    if torch.cuda.is_available():
+        benchmark("cuda")

measure_recall.py

@@ -0,0 +1,89 @@
+import torch
+import clip
+import deeplake
+from tqdm import tqdm
+from tabulate import tabulate
+
+# --- SETTINGS ---
+EMBEDDINGS_PATH = "flickr_embeddings.pt"
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+BATCH_SIZE = 32
+# ----------------
+
+def calculate_recall():
+    print(f"Loading CLIP on {DEVICE}...")
+    model, _ = clip.load("ViT-B/32", device=DEVICE)
+    
+    print(f"Loading Image Index from {EMBEDDINGS_PATH}...")
+    try:
+        # Load embeddings and force them to the correct device
+        image_embeds = torch.load(EMBEDDINGS_PATH, map_location=DEVICE)
+    except FileNotFoundError:
+        print(f"ERROR: Could not find '{EMBEDDINGS_PATH}'. Run indexer.py first.")
+        return
+
+    num_images = len(image_embeds)
+    print(f"Loaded {num_images} image fingerprints.")
+
+    print("Connecting to Deep Lake to fetch captions...")
+    # Ensure this matches the dataset used in indexer.py
+    ds = deeplake.load('hub://activeloop/flickr30k', access_method="stream")
+    
+    text_embeds = []
+    
+    print("Encoding Captions (this acts as the 'Search Query')...")
+    with torch.no_grad():
+        for i in tqdm(range(0, num_images, BATCH_SIZE)):
+            batch_captions = []
+            end_idx = min(i + BATCH_SIZE, num_images)
+            
+            # Fetch batch of captions
+            for idx in range(i, end_idx):
+                try:
+                    # Robust text extraction
+                    txt = ds[idx].caption_0.text().numpy().item()
+                except AttributeError:
+                    txt = ds[idx].caption_0.numpy().item()
+                except Exception:
+                    txt = "unknown"
+                
+                batch_captions.append(str(txt))
+            
+            # Tokenize and Encode
+            text_tokens = clip.tokenize(batch_captions, truncate=True).to(DEVICE)
+            batch_features = model.encode_text(text_tokens)
+            
+            # Normalize
+            batch_features /= batch_features.norm(dim=-1, keepdim=True)
+            text_embeds.append(batch_features)
+
+    text_embeds = torch.cat(text_embeds)
+
+    print("\nCalculating Similarity Matrix...")
+    
+    # --- FIX: Force both to float32 to avoid mismatched types (Half vs Float) ---
+    image_embeds = image_embeds.float()
+    text_embeds = text_embeds.float()
+    
+    # Cosine similarity
+    similarity = text_embeds @ image_embeds.t()
+    
+    print("Computing Recall Metrics...")
+    results = {}
+    k_values = [1, 5, 10]
+    
+    _, top_indices = similarity.topk(max(k_values), dim=1)
+    
+    for k in k_values:
+        correct_count = 0
+        for i in range(num_images):
+            # Check if the correct index 'i' is in the top 'k' predictions
+            if i in top_indices[i, :k]:
+                correct_count += 1
+        results[f"R@{k}"] = (correct_count / num_images) * 100
+
+    print("\n--- RETRIEVAL RESULTS (Zero-Shot) ---")
+    print(tabulate([[k, f"{v:.2f}%"] for k, v in results.items()], headers=["Metric", "Score"]))
+
+if __name__ == "__main__":
+    calculate_recall()