create project

.gitignore

@@ -0,0 +1,5 @@
+.venv
+.venv/
+env/
+venv/
+ENV/

README.md

@@ -1,13 +1,40 @@
 ---
-title: PrototypeAITechLaw
-emoji: 🚀
-colorFrom: red
+title: Assistive Diagnostic Framework for Copyright
+emoji: ⚖️
+colorFrom: gray
 colorTo: blue
 sdk: gradio
-sdk_version: 6.14.0
-python_version: '3.13'
+sdk_version: 4.19.0
 app_file: app.py
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Assistive Diagnostic Framework for Copyright Infringement
+
+This prototype application is an "Explainable AI" dashboard designed to assist in evaluating potential visual copyright infringement. Rather than outputting a single, opaque similarity score, this tool processes two images through a multi-model computer vision pipeline to map technical parameters to established legal criteria.
+
+## 🧠 The Architecture
+
+The pipeline divides the visual comparison into three distinct legal dimensions, optimized to run within standard memory constraints (e.g., Hugging Face Free Tier).
+
+1. **Semantic Match (The "Idea" Filter)**
+   * **Model:** CLIP (`openai/clip-vit-base-patch32`)
+   * **Function:** Compares the overarching semantic concept of the images. This acts as a threshold mechanism to determine if the images share the same unprotected subject matter or "referent" before analyzing specific expressions.
+
+2. **Structural Layout (Substantial Similarity)**
+   * **Model:** OpenCV Canny Edge Detection
+   * **Function:** Strips away style, texture, and color to compare only the fundamental structural outlines. Calculates the Intersection over Union (IoU) of the edge pixels to assess compositional overlap.
+
+3. **Patch Match (Fragmented Literal Similarity)**
+   * **Model:** DINOv2 (`facebook/dinov2-base`)
+   * **Function:** Identifies "scattered literal copying." By extracting and normalizing local patch features, the model uses a Mutual Nearest Neighbors algorithm to map identical or near-identical fragments between the two images, regardless of their spatial location.
+
+## 🚀 Running Locally
+
+To run this application on your local machine, ensure you have Python 3.9+ installed.
+
+1. Clone the repository:
+   ```bash
+   git clone <your-repo-url>
+   cd <your-repo-directory>

app.py

@@ -0,0 +1,214 @@
+import gradio as gr
+import torch
+import torch.nn.functional as F
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw
+from transformers import AutoImageProcessor, AutoModel, CLIPProcessor, CLIPModel
+
+# ==============================================================================
+# 1. Global Initialization & Memory Management
+# ==============================================================================
+# We load models globally so they cache in memory on startup, not on every click.
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+print("Loading DINOv2...")
+dino_processor = AutoImageProcessor.from_pretrained("facebook/dinov2-base")
+dino_model = AutoModel.from_pretrained("facebook/dinov2-base").to(device)
+dino_model.eval() # Prevent gradient tracking
+
+print("Loading CLIP...")
+clip_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+clip_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32").to(device)
+clip_model.eval() # Prevent gradient tracking
+
+# ==============================================================================
+# 2. Pipeline Functions
+# ==============================================================================
+
+def compute_semantic_similarity(img_a: Image.Image, img_b: Image.Image) -> float:
+    """
+    Model: CLIP
+    Legal Concept: The "Idea" / Semantic Referent
+    """
+    inputs = clip_processor(images=[img_a, img_b], return_tensors="pt").to(device)
+    
+    with torch.no_grad():
+        image_features = clip_model.get_image_features(**inputs)
+        
+    # Normalize and compute cosine similarity
+    image_features = F.normalize(image_features, p=2, dim=-1)
+    score = F.cosine_similarity(image_features[0].unsqueeze(0), image_features[1].unsqueeze(0))
+    
+    return round(score.item(), 4)
+
+def compute_structural_similarity(img_a: Image.Image, img_b: Image.Image):
+    """
+    Model: OpenCV Canny
+    Legal Concept: "Substantial Similarity" (Layout / Composition)
+    """
+    # Convert to grayscale numpy arrays
+    arr_a = np.array(img_a.convert('L'))
+    arr_b = np.array(img_b.convert('L'))
+    
+    # Extract structural edges
+    edges_a = cv2.Canny(arr_a, 100, 200)
+    edges_b = cv2.Canny(arr_b, 100, 200)
+    
+    # Calculate structural overlap using Intersection over Union (IoU) of edges
+    # We resize edges_b to match edges_a to ensure matrix math works
+    edges_b_resized = cv2.resize(edges_b, (edges_a.shape[1], edges_a.shape[0]))
+    
+    intersection = np.logical_and(edges_a > 0, edges_b_resized > 0).sum()
+    union = np.logical_or(edges_a > 0, edges_b_resized > 0).sum()
+    
+    iou_score = intersection / union if union != 0 else 0.0
+    
+    return round(iou_score, 4), Image.fromarray(edges_a), Image.fromarray(edges_b)
+
+def compute_patch_similarity(img_a: Image.Image, img_b: Image.Image):
+    """
+    Model: DINOv2
+    Legal Concept: "Fragmented Literal Similarity" (Scattered Literal Copying)
+    """
+    # Resize to a fixed multiple of patch size (14) so we have a known grid
+    # 224x224 gives us a 16x16 grid of patches (256 total patches)
+    target_size = (224, 224)
+    img_a_resized = img_a.resize(target_size)
+    img_b_resized = img_b.resize(target_size)
+    
+    inputs_a = dino_processor(images=img_a_resized, return_tensors="pt").to(device)
+    inputs_b = dino_processor(images=img_b_resized, return_tensors="pt").to(device)
+    
+    with torch.no_grad():
+        out_a = dino_model(**inputs_a)
+        out_b = dino_model(**inputs_b)
+        
+    # Isolate patches (skip CLS token) and normalize. Shape: (256, 768)
+    emb_a = F.normalize(out_a.last_hidden_state[:, 1:, :].squeeze(0), p=2, dim=-1)
+    emb_b = F.normalize(out_b.last_hidden_state[:, 1:, :].squeeze(0), p=2, dim=-1)
+    
+    # Compute N x M similarity matrix using dot product
+    sim_matrix = torch.matmul(emb_a, emb_b.T) # Shape: (256, 256)
+    
+    # Mutual Nearest Neighbors logic to filter out noise
+    best_b_for_a = torch.argmax(sim_matrix, dim=1)
+    best_a_for_b = torch.argmax(sim_matrix, dim=0)
+    
+    matches = []
+    # Threshold for what we consider "copied" (adjust based on testing)
+    SIMILARITY_THRESHOLD = 0.85 
+    
+    for a_idx in range(len(best_b_for_a)):
+        b_idx = best_b_for_a[a_idx]
+        if best_a_for_b[b_idx] == a_idx: # It's a mutual match
+            score = sim_matrix[a_idx, b_idx].item()
+            if score >= SIMILARITY_THRESHOLD:
+                matches.append((a_idx, b_idx, score))
+                
+    # Calculate overall patch score based on percentage of matching patches
+    patch_score = len(matches) / 256.0
+    
+    # --- Visual Evidence Generation ---
+    combined_vis = Image.new('RGB', (target_size[0] * 2, target_size[1]))
+    combined_vis.paste(img_a_resized, (0, 0))
+    combined_vis.paste(img_b_resized, (target_size[0], 0))
+    draw = ImageDraw.Draw(combined_vis)
+    
+    grid_size = 16
+    patch_size = 14
+    
+    for a_idx, b_idx, score in matches:
+        # Image A coordinates
+        ay = (a_idx // grid_size) * patch_size
+        ax = (a_idx % grid_size) * patch_size
+        
+        # Image B coordinates (shifted X by the width of Image A)
+        by = (b_idx // grid_size) * patch_size
+        bx = (b_idx % grid_size) * patch_size + target_size[0]
+        
+        # Draw bounding boxes
+        draw.rectangle([ax, ay, ax + patch_size, ay + patch_size], outline="red", width=2)
+        draw.rectangle([bx, by, bx + patch_size, by + patch_size], outline="red", width=2)
+        
+        # Draw connecting line
+        center_a = (ax + patch_size // 2, ay + patch_size // 2)
+        center_b = (bx + patch_size // 2, by + patch_size // 2)
+        draw.line([center_a, center_b], fill="lime", width=1)
+        
+    return round(patch_score, 4), combined_vis
+
+# ==============================================================================
+# 3. Main Orchestration Function
+# ==============================================================================
+
+def analyze_images(image_a, image_b):
+    if image_a is None or image_b is None:
+        raise gr.Error("Please upload both images.")
+
+    # 1. Semantic Match
+    semantic_score = compute_semantic_similarity(image_a, image_b)
+    
+    # 2. Structural Match
+    struct_score, edge_a, edge_b = compute_structural_similarity(image_a, image_b)
+    
+    # 3. Patch Match
+    patch_score, patch_vis = compute_patch_similarity(image_a, image_b)
+    
+    return (
+        semantic_score, 
+        struct_score, 
+        patch_score, 
+        patch_vis,
+        edge_a, 
+        edge_b
+    )
+
+# ==============================================================================
+# 4. Gradio UI / UX
+# ==============================================================================
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# Assistive Diagnostic Framework for Copyright Infringement")
+    gr.Markdown("Upload two images to compare them across semantic, structural, and literal fragment dimensions.")
+    
+    with gr.Row():
+        with gr.Column():
+            img_in_a = gr.Image(type="pil", label="Image A (Original)")
+        with gr.Column():
+            img_in_b = gr.Image(type="pil", label="Image B (Suspected Copy)")
+            
+    btn_analyze = gr.Button("Analyze Similarity", variant="primary")
+    
+    gr.Markdown("### Assessment Metrics")
+    with gr.Row():
+        score_semantic = gr.Number(label="Semantic Match (CLIP) - Idea", show_label=True)
+        score_struct = gr.Number(label="Structural Match (Edge IoU) - Layout", show_label=True)
+        score_patch = gr.Number(label="Patch Match (DINOv2) - Fragmented Literal", show_label=True)
+        
+    gr.Markdown("### Visual Evidence")
+    with gr.Tabs():
+        with gr.TabItem("Fragmented Literal Similarity (DINOv2)"):
+            gr.Markdown("**Red boxes and green lines indicate mutually correlating local patches (Similarity > 0.85)**")
+            vis_patch = gr.Image(label="Patch Mapping Visualization", type="pil")
+            
+        with gr.TabItem("Substantial Similarity (Edge Detection)"):
+            with gr.Row():
+                vis_edge_a = gr.Image(label="Image A Edges", type="pil")
+                vis_edge_b = gr.Image(label="Image B Edges", type="pil")
+
+    btn_analyze.click(
+        fn=analyze_images,
+        inputs=[img_in_a, img_in_b],
+        outputs=[
+            score_semantic, 
+            score_struct, 
+            score_patch, 
+            vis_patch,
+            vis_edge_a, 
+            vis_edge_b 
+        ]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=4.0.0
+torch>=2.0.0
+torchvision
+transformers>=4.33.0
+opencv-python-headless
+numpy
+Pillow