Image Similarity Search - Vector Panda Use Cases

Implementation Guide

Build visual search with state-of-the-art models

1. Generate Image Embeddings

Use pre-trained vision models to convert images into embeddings. Vector Panda handles storage and retrieval at any scale.

Pythonimport veep
import torch
from transformers import CLIPModel, CLIPProcessor
# Initialize Vector Panda and CLIP
panda = veep.Client("your-api-key")
images = panda.collection("product-images")
model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
# Process and index images
def index_image(image_path, product_data):
    # Load and process image
    image = Image.open(image_path)
    inputs = processor(images=image, return_tensors="pt")
    
    # Generate embedding
    with torch.no_grad():
        image_features = model.get_image_features(**inputs)
        embedding = image_features.squeeze().numpy()
    
    # Store in Vector Panda
    images.upsert(
        id=product_data["id"],
        vector=embedding,
        metadata={
            "url": product_data["image_url"],
            "title": product_data["title"],
            "category": product_data["category"],
            "price": product_data["price"],
            "color": product_data["primary_color"],
            "style": product_data["style"]
        }
    )

2. Build Visual Search API

Create an API that accepts image uploads and returns visually similar items. Add filters for refined searching.

Pythonfrom fastapi import FastAPI, UploadFile
from typing import Optional, List
app = FastAPI()
@app.post("/search/image")
async def search_by_image(
    file: UploadFile,
    limit: int = 20,
    category: Optional[str] = None,
    min_similarity: float = 0.7
):
    # Process uploaded image
    image = Image.open(file.file)
    inputs = processor(images=image, return_tensors="pt")
    
    # Generate query embedding
    with torch.no_grad():
        features = model.get_image_features(**inputs)
        query_embedding = features.squeeze().numpy()
    
    # Search with optional filters
    filters = {}
    if category:
        filters["category"] = category
    
    results = images.search(
        vector=query_embedding,
        k=limit,
        filters=filters,
        score_threshold=min_similarity,
        include_metadata=True
    )
    
    # Format response
    return {
        "results": [{
            "id": r.id,
            "similarity": float(r.score),
            "image_url": r.metadata["url"],
            "title": r.metadata["title"],
            "price": r.metadata["price"]
        } for r in results],
        "query_time_ms": results.query_time
    }

3. Advanced Features

Implement multi-modal search, style transfer recommendations, and batch processing for large catalogs.

Python# Multi-modal search (text + image)
@app.post("/search/multimodal")
async def multimodal_search(
    text_query: str,
    file: Optional[UploadFile] = None,
    weight_text: float = 0.5
):
    embeddings = []
    
    # Text embedding
    text_inputs = processor(text=text_query, return_tensors="pt")
    text_features = model.get_text_features(**text_inputs)
    embeddings.append(text_features.squeeze().numpy())
    
    # Image embedding if provided
    if file:
        image = Image.open(file.file)
        img_inputs = processor(images=image, return_tensors="pt")
        img_features = model.get_image_features(**img_inputs)
        embeddings.append(img_features.squeeze().numpy())
    
    # Combine embeddings
    if len(embeddings) == 2:
        combined = weight_text * embeddings[0] + \
                  (1 - weight_text) * embeddings[1]
    else:
        combined = embeddings[0]
    
    # Search and return results
    results = images.search(vector=combined, k=20)
    return format_results(results)
# Batch similarity for outfit recommendations
def find_matching_outfit(item_id: str):
    # Get item embedding and metadata
    item = images.get(item_id)
    
    # Find complementary items
    outfit = {}
    for category in ["tops", "bottoms", "shoes", "accessories"]:
        if category != item.metadata["category"]:
            matches = images.search(
                vector=item.vector,
                k=5,
                filters={"category": category,
                        "style": item.metadata["style"]}
            )
            outfit[category] = matches[0] if matches else None
    
    return outfit

4. Scale and Optimize

Handle millions of images efficiently with batch processing and smart storage tiering based on popularity.

Python# Batch index images efficiently
async def batch_index_images(image_batch: List[dict]):
    embeddings = []
    metadata_list = []
    
    # Process in batches for efficiency
    for batch in chunks(image_batch, 32):
        images_batch = [Image.open(item["path"]) for item in batch]
        inputs = processor(images=images_batch, return_tensors="pt")
        
        with torch.no_grad():
            features = model.get_image_features(**inputs)
            embeddings.extend(features.numpy())
        
        metadata_list.extend([item["metadata"] for item in batch])
    
    # Bulk upsert to Vector Panda
    images.upsert_batch(
        ids=[m["id"] for m in metadata_list],
        vectors=embeddings,
        metadata=metadata_list
    )
    
# Monitor and optimize storage
async def optimize_image_storage():
    stats = images.stats()
    
    # Move popular items to hot storage
    popular_items = get_popular_items(days=7)
    images.move_to_tier(
        ids=popular_items,
        tier="hot"
    )
    
    # Archive old items to cold storage
    old_items = get_items_older_than(days=365)
    images.move_to_tier(
        ids=old_items,
        tier="cold"
    )

Applications

Visual search powers modern experiences

🛍️

E-commerce

Let shoppers find products by uploading photos. "Find similar" buttons that actually work at scale.

Visual product discovery
Style matching
Outfit recommendations
Inventory deduplication

📱

Social Media

Content moderation, duplicate detection, and visual trends analysis across billions of images.

Duplicate content detection
Visual content moderation
Trend identification
Meme tracking

🏭

Manufacturing

Quality control and defect detection. Compare products against reference images in real-time.

Defect detection
Part identification
Quality assurance
Assembly verification

🏥

Healthcare

Medical image analysis and similar case retrieval. Find relevant cases from vast medical databases.

Similar case retrieval
Anomaly detection
Treatment planning
Research matching

🏡

Real Estate

Find properties by visual preferences. Match interior design styles and architectural features.

Style matching
Similar properties
Interior design
Virtual staging

🎨

Digital Assets

Manage large media libraries. Find stock photos, detect copyright infringement, organize collections.

Asset management
Copyright detection
Collection organization
Style consistency

Visual Image Similarity Search

Visual Search Demo

Similar Images