Course Overview

18-hour comprehensive program on computer vision for business

Course Sessions

Course Learning Objectives

What you'll be able to do after completing this course

Session 1: Learning Objectives

By the end of this session, you will be able to:

Session 1 Structure

3-hour journey through computer vision foundations

What is Computer Vision?

Enabling computers to derive meaningful information from visual inputs

Human vs. Machine Vision

Understanding the differences

The Visual Processing Pipeline

How computers process visual information, step by step

Preprocessing & Feature Extraction

Preparing images for analysis

Digital Image Representation

At the lowest level, an image is just a matrix of numbers

Image as a 3D Tensor

Understanding the data structure

Color Image (Height x Width x 3 channels)

┌─────────────────────────────────────┐
│  Red Channel    [255] [128] [64]    │
│  Green Channel  [100] [150] [200]   │
│  Blue Channel   [ 50] [ 75] [100]   │
└─────────────────────────────────────┘

Each pixel = 3 values (R, G, B)

Image as a Matrix

Grayscale and RGB representations

A grayscale image is a 2D matrix of pixel intensities (0=black, 255=white):

[[  0,  50, 100, 150, 200, 255],
 [ 25,  75, 125, 175, 225, 255],
 [ 50, 100, 150, 200, 250, 255],
 [ 75, 125, 175, 225, 255, 255]]  # 4×6 grayscale image

An RGB color image is a 3D tensor with 3 channels:

# Red Channel:    Green Channel:   Blue Channel:
[[255, 0, 0],   [[0, 255, 0],    [[0, 0, 255],
 [128, 0, 0]]    [0, 128, 0]]     [0, 0, 128]]

# Combined: Shape = (2, 3, 3) → 2×3 RGB image

Computer Vision Task Types

Different tasks answer different questions about images

CV Task: Image Classification

Assigning a label to an entire image

CV Task: Object Detection

Locating and classifying multiple objects using bounding boxes

Output for each detected object:

{
  "class": "person",
  "confidence": 0.95,
  "bbox": {"x": 120, "y": 80, "width": 150, "height": 320}
}

CV Task: Segmentation

Classifying pixels into categories

CV Tasks Comparison

CV Task: Pose Estimation

Detecting key points on objects to understand posture and movement

CV Task: Optical Character Recognition

Extracting text from images

Challenges:

CV Task: Face Analysis

Specialized detection and analysis of human faces

Evolution of Computer Vision

From hand-crafted features to learned representations

Classical Computer Vision (Pre-2012)

Before deep learning, CV relied on hand-crafted features

Common Techniques:

The Deep Learning Revolution (2012)

AlexNet's victory in ImageNet 2012 changed everything

Key Enablers:

Convolutional Neural Networks (CNNs)

The architecture that powers modern computer vision

Why CNNs Work:

Hierarchical Feature Learning

CNNs learn progressively complex features

Key Deep Learning Architectures

Vision Transformers (ViT) - 2020

Applying the Transformer architecture from NLP to computer vision

Advantages:

Foundation Models Era (2021-Present)

Large pre-trained models that work across many tasks

Zero-Shot and Few-Shot Learning

Foundation models can perform tasks they weren't explicitly trained for

Zero-Shot Classification with CLIP:

import clip

# No training on these specific classes!
classes = ["a photo of a dog", "a photo of a cat", "a photo of a bird"]

# CLIP compares image embedding with text embeddings
image_features = model.encode_image(image)
text_features = model.encode_text(clip.tokenize(classes))

# Similarity determines classification
similarities = image_features @ text_features.T
prediction = classes[similarities.argmax()]
# Result: "a photo of a dog" with 94% confidence

Part 2: Live Demonstrations

Seeing CV in action with real code examples

Demo 1: Understanding Images as Data

import numpy as np
from PIL import Image

# Load and explore an image
img = Image.open("sample.jpg")
img_array = np.array(img)

# Examine the data structure
print(f"Shape: {img_array.shape}")       # (height, width, channels)
print(f"Data type: {img_array.dtype}")   # uint8 (0-255)
print(f"Min value: {img_array.min()}")   # 0 (black)
print(f"Max value: {img_array.max()}")   # 255 (white)
print(f"Total pixels: {img_array.size}") # h × w × c

# Access individual pixels
pixel = img_array[100, 150]  # Row 100, Column 150
print(f"Pixel RGB: {pixel}")  # e.g., [128, 64, 200]

Demo 2: Pre-trained Classification

import torch
from torchvision import models, transforms
from PIL import Image

# Load pre-trained ResNet-50 (ImageNet: 1000 classes)
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V2)
model.eval()

# Standard ImageNet preprocessing
preprocess = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

# Inference
img = Image.open("golden_retriever.jpg")
input_tensor = preprocess(img).unsqueeze(0)
with torch.no_grad():
    output = model(input_tensor)
# Output: "golden retriever" with 92% confidence

Demo 3: Object Detection with YOLO

from ultralytics import YOLO

# Load YOLOv8 (You Only Look Once)
model = YOLO('yolov8n.pt')  # 'n' = nano, fast

# Run inference
results = model('street_scene.jpg')

# Process detections
for result in results:
    for box in result.boxes:
        class_id = int(box.cls[0])
        class_name = model.names[class_id]
        confidence = float(box.conf[0])
        x1, y1, x2, y2 = box.xyxy[0].tolist()

        print(f"Detected: {class_name} ({confidence:.1%})")
        print(f"  Location: ({x1:.0f}, {y1:.0f}) to ({x2:.0f}, {y2:.0f})")

# YOLO detects 80+ classes: person, car, bicycle, dog...

Demo 4: Vision-Language Understanding

import anthropic
import base64

def analyze_image(image_path: str, question: str) -> str:
    """Use Claude Vision to understand images."""
    client = anthropic.Anthropic()

    with open(image_path, "rb") as f:
        image_data = base64.standard_b64encode(f.read()).decode()

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

# Example: Complex reasoning
result = analyze_image("shelf.jpg", "What products are low on stock?")

Comparing CV Approaches

Self-Practice Assignment 1

Duration: 1 hour | Deadline: Before Session 2

Session 1 Summary

Key Takeaways

Resources