SKILL.md

Computer Vision

Name: computer-vision
Author: aj-geddes

Overview

Computer vision enables machines to understand visual information from images and videos, powering applications like autonomous driving, medical imaging, and surveillance.

When to Use

Image classification and object recognition tasks

Object detection and localization in images

Semantic or instance segmentation projects

Pose estimation and human activity recognition

Face recognition and biometric systems

Medical imaging analysis and diagnostics

Computer Vision Tasks

Image Classification: Categorizing images into classes

Object Detection: Locating and classifying objects in images

Semantic Segmentation: Pixel-level classification

Instance Segmentation: Detecting individual object instances

Pose Estimation: Identifying human body joints

Face Recognition: Identifying individuals in images

Popular Architectures

Classification: ResNet, VGG, EfficientNet, Vision Transformer

Detection: YOLO, Faster R-CNN, SSD, RetinaNet

Segmentation: U-Net, DeepLab, Mask R-CNN

Pose: OpenPose, PoseNet, HRNet

Python Implementation

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import matplotlib.patches as patches

from PIL import Image, ImageDraw

import torch

import torch.nn as nn

from torch.utils.data import DataLoader, TensorDataset

from torchvision import transforms, models, datasets

import tensorflow as tf

from tensorflow import keras

from tensorflow.keras import layers

import cv2

from sklearn.metrics import accuracy_score, confusion_matrix

import seaborn as sns

import warnings

warnings.filterwarnings('ignore')

print("=== 1. Image Classification CNN ===")

# Define image classification model

class ImageClassifierCNN(nn.Module):

    def __init__(self, num_classes=10):

        super().__init__()

        self.features = nn.Sequential(

            nn.Conv2d(3, 32, kernel_size=3, padding=1),

            nn.ReLU(inplace=True),

            nn.BatchNorm2d(32),

            nn.MaxPool2d(2, 2),

            nn.Conv2d(32, 64, kernel_size=3, padding=1),

            nn.ReLU(inplace=True),

            nn.BatchNorm2d(64),

            nn.MaxPool2d(2, 2),

            nn.Conv2d(64, 128, kernel_size=3, padding=1),

            nn.ReLU(inplace=True),

            nn.BatchNorm2d(128),

            nn.MaxPool2d(2, 2),

        )

        self.classifier = nn.Sequential(

            nn.Linear(128 * 4 * 4, 256),

            nn.ReLU(inplace=True),

            nn.Dropout(0.5),

            nn.Linear(256, num_classes)

        )

    def forward(self, x):

        x = self.features(x)

        x = x.view(x.size(0), -1)

        x = self.classifier(x)

        return x

model = ImageClassifierCNN(num_classes=10)

print(f"Model parameters: {sum(p.numel() for p in model.parameters()):,}")

# 2. Object Detection setup

print("\n=== 2. Object Detection Framework ===")

class ObjectDetector(nn.Module):

    def __init__(self):

        super().__init__()

        # Backbone

        self.backbone = nn.Sequential(

            nn.Conv2d(3, 32, 3, padding=1),

            nn.ReLU(),

            nn.MaxPool2d(2, 2),

            nn.Conv2d(32, 64, 3, padding=1),

            nn.ReLU(),

            nn.MaxPool2d(2, 2),

        )

        # Bounding box regression

        self.bbox_head = nn.Sequential(

            nn.Linear(64 * 8 * 8, 128),

            nn.ReLU(),

            nn.Linear(128, 4)  # x, y, w, h

        )

        # Class prediction

        self.class_head = nn.Sequential(

            nn.Linear(64 * 8 * 8, 128),

            nn.ReLU(),

            nn.Linear(128, 10)  # 10 classes

        )

    def forward(self, x):

        features = self.backbone(x)

        features_flat = features.view(features.size(0), -1)

        bboxes = self.bbox_head(features_flat)

        classes = self.class_head(features_flat)

        return bboxes, classes

detector = ObjectDetector()

print(f"Detector parameters: {sum(p.numel() for p in detector.parameters()):,}")

# 3. Semantic Segmentation

print("\n=== 3. Semantic Segmentation U-Net ===")

class UNet(nn.Module):

    def __init__(self, num_classes=5):

        super().__init__()

        # Encoder

        self.enc1 = self._conv_block(3, 32)

        self.pool1 = nn.MaxPool2d(2, 2)

        self.enc2 = self._conv_block(32, 64)

        self.pool2 = nn.MaxPool2d(2, 2)

        # Bottleneck

        self.bottleneck = self._conv_block(64, 128)

        # Decoder

        self.upconv2 = nn.ConvTranspose2d(128, 64, 2, stride=2)

        self.dec2 = self._conv_block(128, 64)

        self.upconv1 = nn.ConvTranspose2d(64, 32, 2, stride=2)

        self.dec1 = self._conv_block(64, 32)

        # Final output

        self.out = nn.Conv2d(32, num_classes, 1)

    def _conv_block(self, in_channels, out_channels):

        return nn.Sequential(

            nn.Conv2d(in_channels, out_channels, 3, padding=1),

            nn.ReLU(inplace=True),

            nn.Conv2d(out_channels, out_channels, 3, padding=1),

            nn.ReLU(inplace=True)

        )

    def forward(self, x):

        enc1 = self.enc1(x)

        enc2 = self.enc2(self.pool1(enc1))

        bottleneck = self.bottleneck(self.pool2(enc2))

        dec2 = self.dec2(torch.cat([self.upconv2(bottleneck), enc2], 1))

        dec1 = self.dec1(torch.cat([self.upconv1(dec2), enc1], 1))

        return self.out(dec1)

unet = UNet(num_classes=5)

print(f"U-Net parameters: {sum(p.numel() for p in unet.parameters()):,}")

# 4. Transfer Learning

print("\n=== 4. Transfer Learning with Pre-trained Models ===")

try:

    # Load pre-trained ResNet18

    pretrained_model = models.resnet18(pretrained=True)

    num_ftrs = pretrained_model.fc.in_features

    pretrained_model.fc = nn.Linear(num_ftrs, 10)

    print(f"Pre-trained ResNet18 adapted for 10 classes")

    print(f"Parameters: {sum(p.numel() for p in pretrained_model.parameters()):,}")

except:

    print("Pre-trained models not available")

# 5. Image preprocessing and augmentation

print("\n=== 5. Image Preprocessing and Augmentation ===")

transform_basic = transforms.Compose([

    transforms.Resize((224, 224)),

    transforms.ToTensor(),

    transforms.Normalize(mean=[0.485, 0.456, 0.406],

                        std=[0.229, 0.224, 0.225])

])

transform_augmented = transforms.Compose([

    transforms.RandomRotation(20),

    transforms.RandomHorizontalFlip(),

    transforms.ColorJitter(brightness=0.2, contrast=0.2),

    transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),

    transforms.Resize((224, 224)),

    transforms.ToTensor(),

    transforms.Normalize(mean=[0.485, 0.456, 0.406],

                        std=[0.229, 0.224, 0.225])

])

print("Augmentation transforms defined")

# 6. Synthetic image data

print("\n=== 6. Synthetic Image Data Creation ===")

def create_synthetic_images(num_images=100, img_size=32):

    """Create synthetic images with shapes"""

    images = []

    labels = []

    for _ in range(num_images):

        img = np.ones((img_size, img_size, 3)) * 255

        # Randomly draw shapes

        shape_type = np.random.randint(0, 3)

        if shape_type == 0:  # Circle

            center = (np.random.randint(5, img_size-5), np.random.randint(5, img_size-5))

            radius = np.random.randint(3, 10)

            cv2.circle(img, center, radius, (0, 0, 0), -1)

            labels.append(0)

        elif shape_type == 1:  # Rectangle

            pt1 = (np.random.randint(0, img_size-10), np.random.randint(0, img_size-10))

            pt2 = (pt1[0] + np.random.randint(5, 15), pt1[1] + np.random.randint(5, 15))

            cv2.rectangle(img, pt1, pt2, (0, 0, 0), -1)

            labels.append(1)

        else:  # Triangle

            pts = np.array([[np.random.randint(0, img_size), np.random.randint(0, img_size)],

                           [np.random.randint(0, img_size), np.random.randint(0, img_size)],

                           [np.random.randint(0, img_size), np.random.randint(0, img_size)]])

            cv2.drawContours(img, [pts], 0, (0, 0, 0), -1)

            labels.append(2)

        images.append(img.astype(np.float32) / 255.0)

    return np.array(images), np.array(labels)

X_images, y_labels = create_synthetic_images(num_images=300, img_size=32)

print(f"Synthetic dataset: {X_images.shape}, Labels: {y_labels.shape}")

print(f"Class distribution: {np.bincount(y_labels)}")

# 7. Visualization

print("\n=== 7. Visualization ===")

fig, axes = plt.subplots(3, 3, figsize=(12, 10))

# Display synthetic images

for i in range(9):

    idx = i % len(X_images)

    axes[i // 3, i % 3].imshow(X_images[idx])

    axes[i // 3, i % 3].set_title(f"Class {y_labels[idx]}")

    axes[i // 3, i % 3].axis('off')

plt.suptitle("Synthetic Image Dataset", fontsize=14, fontweight='bold')

plt.tight_layout()

plt.savefig('synthetic_images.png', dpi=100, bbox_inches='tight')

print("Synthetic images saved as 'synthetic_images.png'")

# 8. Model architectures comparison

print("\n=== 8. Architecture Comparison ===")

architectures_info = {

    'CNN': ImageClassifierCNN(),

    'ObjectDetector': ObjectDetector(),

    'U-Net': UNet(),

}

arch_data = {

    'Architecture': list(architectures_info.keys()),

    'Parameters': [sum(p.numel() for p in m.parameters()) for m in architectures_info.values()],

    'Use Case': ['Classification', 'Object Detection', 'Segmentation']

}

arch_df = pd.DataFrame(arch_data)

print("\nArchitecture Comparison:")

print(arch_df.to_string(index=False))

# Visualization

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# Parameters comparison

axes[0].barh(arch_df['Architecture'], arch_df['Parameters'], color='steelblue')

axes[0].set_xlabel('Number of Parameters')

axes[0].set_title('Model Complexity Comparison')

axes[0].set_xscale('log')

# Use cases

use_cases = ['Classification', 'Detection', 'Segmentation',

            'Classification', 'Detection', 'Segmentation']

colors_map = {'Classification': 'green', 'Detection': 'orange', 'Segmentation': 'red'}

bar_colors = [colors_map[uc] for uc in arch_df['Use Case']]

axes[1].bar(arch_df['Architecture'], [1, 1, 1], color=bar_colors, alpha=0.7)

axes[1].set_ylabel('Primary Task')

axes[1].set_title('Architecture Use Cases')

axes[1].set_ylim([0, 1.5])

plt.tight_layout()

plt.savefig('cv_architecture_comparison.png', dpi=100, bbox_inches='tight')

print("\nArchitecture comparison saved as 'cv_architecture_comparison.png'")

# 9. Bounding box visualization

print("\n=== 9. Bounding Box Visualization ===")

fig, ax = plt.subplots(figsize=(10, 8))

ax.imshow(X_images[0])

# Draw sample bounding boxes

bboxes = [

    (5, 5, 15, 15),   # x1, y1, x2, y2

    (18, 10, 28, 20),

    (8, 20, 18, 28)

]

for bbox in bboxes:

    rect = patches.Rectangle((bbox[0], bbox[1]), bbox[2]-bbox[0], bbox[3]-bbox[1],

                            linewidth=2, edgecolor='red', facecolor='none')

    ax.add_patch(rect)

ax.set_title('Bounding Box Detection Example')

ax.axis('off')

plt.savefig('bounding_boxes.png', dpi=100, bbox_inches='tight')

print("Bounding box visualization saved as 'bounding_boxes.png'")

print("\nComputer vision setup completed!")

Common CV Architectures

Classification: ResNet, EfficientNet, Vision Transformer

Detection: YOLO v5, Faster R-CNN, RetinaNet

Segmentation: U-Net, DeepLab v3, Mask R-CNN

Tracking: SORT, DeepSORT, ByteTrack

Image Preprocessing

Resizing to standard dimensions

Normalization with ImageNet stats

Data augmentation (rotation, flip, crop)

Color space conversion

Evaluation Metrics

Classification: Accuracy, Precision, Recall, F1

Detection: mAP (mean Average Precision), IoU

Segmentation: IoU, Dice coefficient, Hausdorff distance

Deliverables

Trained vision model

Inference pipeline

Performance evaluation

Visualization results

Model optimization report

Deployment guide

computer-vision