Computer Vision for Business

Session 3: Learning Objectives

Today's goals (3 hours)

Session 3 Roadmap

Our journey today

Why Use Cloud Vision APIs?

Benefits over building from scratch

How Cloud Vision APIs Work

The request-response cycle

The Cloud Vision Landscape

Major players in the ecosystem

Google Cloud Vision

Comprehensive traditional CV API

Amazon Rekognition

AWS's computer vision service

Azure Computer Vision

Microsoft's vision intelligence

Multimodal LLMs for Vision

The new generation: Claude, GPT-4V, Gemini

Provider Comparison

Side-by-side comparison

Choosing the Right Service

Match your needs to the right API

Use Case to Service Mapping

Real-world applications matched to APIs

Hands-on Labs Overview

What we'll build today

Lab Setup

Environment preparation

# Install required packages
# pip install anthropic pillow requests

import os
from pathlib import Path
import base64

# Create working directory
WORK_DIR = Path("cv_workshop")
WORK_DIR.mkdir(exist_ok=True)

# Sample images for testing
SAMPLE_IMAGES = [
    "receipt.jpg",      # For OCR
    "products.jpg",     # For object detection
    "storefront.jpg",   # For scene analysis
    "document.pdf"      # For document processing
]

Image Encoding Helper

Converting images to Base64 for APIs

def encode_image(image_path: str) -> str:
    """Encode image to base64 string for API calls."""
    with open(image_path, "rb") as image_file:
        return base64.standard_b64encode(
            image_file.read()
        ).decode("utf-8")

# Usage
image_data = encode_image("receipt.jpg")
# Returns: "/9j/4AAQSkZJRg..." (base64 string)

Lab 1: Document Processing with OCR

Extract structured data from receipts

Lab 1: OCR Function Setup

import anthropic
from pathlib import Path

def extract_receipt_data(image_path: str) -> dict:
    """Extract structured data from a receipt image."""
    client = anthropic.Anthropic()

    # Determine media type from extension
    ext = Path(image_path).suffix.lower()
    media_types = {
        '.jpg': 'image/jpeg',
        '.jpeg': 'image/jpeg',
        '.png': 'image/png',
        '.webp': 'image/webp'
    }
    media_type = media_types.get(ext, 'image/jpeg')

    # Encode image to base64
    image_data = encode_image(image_path)

Lab 1: Making the API Call

    # Call Claude Vision API
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": media_type,
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "..."  # Prompt on next slide
                }
            ]
        }]
    )

Lab 1: The OCR Prompt

Structured prompts get structured results

# The prompt that extracts structured data
prompt = """
Analyze this receipt and extract as JSON:
{
    "vendor_name": "",
    "date": "",
    "items": [
        {"name": "", "price": 0.00}
    ],
    "subtotal": 0.00,
    "tax": 0.00,
    "total": 0.00
}
Return only valid JSON, no additional text.
If any field is unclear, use null.
"""

Lab 1: Sample Output

What Claude returns from a restaurant receipt

{
    "vendor_name": "Café de Flore",
    "date": "2024-03-15",
    "items": [
        {"name": "Espresso", "price": 4.50},
        {"name": "Croissant", "price": 3.20},
        {"name": "Orange Juice", "price": 5.00}
    ],
    "subtotal": 12.70,
    "tax": 1.27,
    "total": 13.97
}

Lab 2: Product Analysis & Cataloging

Automate e-commerce product metadata

Lab 2: Product Analysis Code

def analyze_product(image_path: str) -> dict:
    """Analyze a product image for e-commerce cataloging."""
    client = anthropic.Anthropic()
    image_data = encode_image(image_path)

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1500,
        messages=[{
            "role": "user",
            "content": [
                {"type": "image", "source": {
                    "type": "base64",
                    "media_type": "image/jpeg",
                    "data": image_data
                }},
                {"type": "text", "text": """..."""}  # Next slide
            ]
        }]
    )
    return response.content[0].text

Lab 2: Product Analysis Prompt

prompt = """
Analyze this product for e-commerce listing.
Return JSON with:

{
    "category": "Main category",
    "subcategory": "Specific subcategory",
    "attributes": {
        "colors": [],
        "materials": [],
        "size_estimate": ""
    },
    "marketing_title": "Max 10 words, compelling",
    "description": "2-3 sentences, benefit-focused",
    "search_keywords": ["10", "relevant", "keywords"]
}

Be accurate about visible attributes.
Don't guess what you can't see clearly.
"""

Lab 2: Sample Product Output

{
    "category": "Fashion",
    "subcategory": "Women's Handbags",
    "attributes": {
        "colors": ["cognac brown", "gold accents"],
        "materials": ["leather", "metal hardware"],
        "size_estimate": "medium, ~30cm width"
    },
    "marketing_title": "Elegant Cognac Leather Tote with Gold Hardware",
    "description": "A sophisticated everyday tote crafted from
    premium cognac leather. Features secure zip closure and
    elegant gold-tone hardware for timeless style.",
    "search_keywords": ["leather tote", "brown handbag",
    "cognac bag", "gold hardware", "women's purse", ...]
}

Lab 2: Batch Product Processing

Process entire catalogs efficiently

def process_product_catalog(image_folder: str) -> list:
    """Process all product images in a folder."""
    results = []
    image_extensions = {'.jpg', '.jpeg', '.png', '.webp'}

    for image_path in Path(image_folder).iterdir():
        if image_path.suffix.lower() in image_extensions:
            print(f"Processing: {image_path.name}")
            analysis = analyze_product(str(image_path))
            results.append({
                "filename": image_path.name,
                "analysis": analysis
            })
    return results

Lab 3: Scene Understanding

Analyze retail environments for business insights

Lab 3: Scene Analysis Code

def analyze_retail_scene(image_path: str) -> dict:
    """Analyze a retail environment for insights."""
    client = anthropic.Anthropic()
    image_data = encode_image(image_path)

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2000,
        messages=[{
            "role": "user",
            "content": [
                {"type": "image", "source": {
                    "type": "base64",
                    "media_type": "image/jpeg",
                    "data": image_data
                }},
                {"type": "text", "text": """..."""}
            ]
        }]
    )
    return response.content[0].text

Lab 3: Scene Analysis Prompt

prompt = """
Analyze this retail environment comprehensively:

1. SCENE: Store type, estimated size, time of day,
   overall ambiance

2. CUSTOMERS: Approximate count, visible demographics,
   current activities and behaviors

3. MERCHANDISING: Display quality, signage effectiveness,
   product visibility, promotional materials

4. OPERATIONS: Cleanliness score (1-10), safety hazards,
   staff visibility, queue management

5. RECOMMENDATIONS: List 3 specific, actionable
   improvements with expected business impact

Be specific, quantitative where possible, and
business-focused in your analysis.
"""

Lab 3: Business Applications

How retail scene analysis drives value

Lab 4: Building a Complete Application

ExpenseTracker: CV-powered expense management

Lab 4: ExpenseTracker Architecture

Class-based design for maintainability

Lab 4: ExpenseTracker Class

import json
from datetime import datetime

class ExpenseTracker:
    """Expense tracking using computer vision."""

    def __init__(self):
        self.expenses = []
        self.client = anthropic.Anthropic()

    def add_receipt(self, image_path: str,
                    category: str = None) -> dict:
        """Process a receipt and add to expenses."""
        # Extract data using CV
        extracted = self._extract_receipt(image_path)

        # Parse JSON response
        try:
            receipt_data = json.loads(extracted)
        except json.JSONDecodeError:
            receipt_data = {"raw": extracted, "error": True}

Lab 4: Adding Receipts

        # Create expense record
        expense = {
            "id": len(self.expenses) + 1,
            "timestamp": datetime.now().isoformat(),
            "image_path": image_path,
            "category": category or self._categorize(receipt_data),
            "data": receipt_data
        }
        self.expenses.append(expense)
        return expense

    def _extract_receipt(self, image_path: str) -> str:
        """Use CV to extract receipt data."""
        # Reuse our extract_receipt_data function
        return extract_receipt_data(image_path)

Lab 4: Auto-Categorization

Keyword-based category assignment

    def _categorize(self, data: dict) -> str:
        """Auto-categorize based on vendor name."""
        vendor = data.get("vendor_name", "").lower()

        categories = {
            "restaurant": ["restaurant", "cafe", "pizza",
                          "burger", "sushi", "bistro"],
            "grocery": ["supermarket", "grocery", "carrefour",
                       "auchan", "monoprix"],
            "transport": ["uber", "taxi", "sncf", "ratp"],
            "office": ["staples", "office", "amazon"],
        }

        for cat, keywords in categories.items():
            if any(kw in vendor for kw in keywords):
                return cat
        return "other"

Lab 4: Generating Summaries

    def get_summary(self) -> dict:
        """Generate expense summary by category."""
        by_category = {}

        for expense in self.expenses:
            cat = expense["category"]
            total = expense["data"].get("total", 0) or 0

            if cat not in by_category:
                by_category[cat] = {"count": 0, "total": 0}

            by_category[cat]["count"] += 1
            by_category[cat]["total"] += float(total)

        return {
            "total_expenses": len(self.expenses),
            "by_category": by_category,
            "grand_total": sum(
                c["total"] for c in by_category.values()
            )
        }

Lab 4: Using ExpenseTracker

# Initialize tracker
tracker = ExpenseTracker()

# Add receipts
tracker.add_receipt("lunch_receipt.jpg")
tracker.add_receipt("office_supplies.jpg")
tracker.add_receipt("taxi_receipt.jpg")

# Get summary
summary = tracker.get_summary()
print(f"Total expenses: {summary['total_expenses']}")
print(f"Grand total: €{summary['grand_total']:.2f}")

# Output:
# Total expenses: 3
# Grand total: €127.45
# By category:
#   restaurant: 1 expense, €23.50
#   office: 1 expense, €89.95
#   transport: 1 expense, €14.00

API Performance Comparison

Measuring and comparing API performance

API Benchmarking Framework

import time
from typing import Callable

def benchmark_api(
    api_function: Callable,
    test_images: list,
    runs: int = 3
) -> dict:
    """Benchmark an API across multiple images."""
    results = {
        "timings": [], "successes": 0, "failures": 0
    }

    for image in test_images:
        for _ in range(runs):
            start = time.time()
            try:
                api_function(image)
                results["successes"] += 1
            except Exception as e:
                results["failures"] += 1
            results["timings"].append(time.time() - start)

    results["avg_time"] = sum(results["timings"]) / len(results["timings"])
    return results

Cost Optimization Strategies

Reducing API costs at scale

Cost Optimization Techniques

Practical strategies for production

Tiered Processing Strategy

Use cheap APIs for filtering, premium for analysis

Image Preprocessing for Cost Savings

from PIL import Image
import io

def optimize_image(image_path: str,
                   max_size: int = 1024,
                   quality: int = 85) -> bytes:
    """Optimize image size before API call."""
    with Image.open(image_path) as img:
        # Resize if too large
        if max(img.size) > max_size:
            ratio = max_size / max(img.size)
            new_size = tuple(int(d * ratio) for d in img.size)
            img = img.resize(new_size, Image.LANCZOS)

        # Convert to RGB if needed
        if img.mode in ('RGBA', 'P'):
            img = img.convert('RGB')

        # Save to bytes with compression
        buffer = io.BytesIO()
        img.save(buffer, format='JPEG', quality=quality)
        return buffer.getvalue()

# Can reduce file size by 70-90% while maintaining quality

Simple Result Caching

import hashlib
import json
from pathlib import Path

CACHE_DIR = Path("api_cache")
CACHE_DIR.mkdir(exist_ok=True)

def get_cached_or_call(image_path: str, api_func) -> dict:
    """Check cache before calling API."""
    # Generate hash of image content
    with open(image_path, "rb") as f:
        image_hash = hashlib.md5(f.read()).hexdigest()

    cache_file = CACHE_DIR / f"{image_hash}.json"

    # Return cached if exists
    if cache_file.exists():
        return json.loads(cache_file.read_text())

    # Call API and cache result
    result = api_func(image_path)
    cache_file.write_text(json.dumps(result))
    return result

Robust Error Handling

Production-ready API calls

import time
from typing import Optional

def call_api_with_retry(
    func,
    max_retries: int = 3,
    base_delay: float = 1.0
) -> Optional[dict]:
    """Call API with exponential backoff retry."""
    for attempt in range(max_retries):
        try:
            return func()
        except anthropic.RateLimitError:
            delay = base_delay * (2 ** attempt)
            print(f"Rate limited. Waiting {delay}s...")
            time.sleep(delay)
        except anthropic.APIError as e:
            print(f"API error: {e}")
            if attempt == max_retries - 1:
                raise
    return None

Security Best Practices

Protecting your API integration

Self-Practice Assignment 3

Duration: 1.5 hours | Deadline: Before Session 4

Deliverable: GitHub repository or zip file with code and documentation

Assignment Project Ideas

Inspiration for your CV application

Session 3 Summary

Key takeaways from today

Looking Ahead: Session 4

Custom Models & Transfer Learning