Image Processing with AI: A Complete Guide

Image processing with artificial intelligence has revolutionized computer vision. This guide explores modern techniques and their applications.

1. Fundamentals

Convolutional Neural Networks (CNNs)

# Example implementation of a simple CNN
import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64 * 4 * 4, 512)
        self.fc2 = nn.Linear(512, 10)
        
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = self.pool(torch.relu(self.conv3(x)))
        x = x.view(-1, 64 * 4 * 4)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

Image Preprocessing

# Example of image preprocessing
import cv2
import numpy as np
from torchvision import transforms

def preprocess_image(image_path):
    # Read the image
    image = cv2.imread(image_path)
    
    # Resize
    image = cv2.resize(image, (224, 224))
    
    # Normalization
    image = image.astype(np.float32) / 255.0
    
    # Convert to tensor
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406],
                           std=[0.229, 0.224, 0.225])
    ])
    
    return transform(image)

2. Practical Applications

Image Classification

# Example of image classification with ResNet
from torchvision.models import resnet50
from torchvision import transforms

def classify_image(image_path):
    # Load the pretrained model
    model = resnet50(pretrained=True)
    model.eval()
    
    # Prepare the image
    transform = 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])
    ])
    
    image = transform(Image.open(image_path)).unsqueeze(0)
    
    # Prediction
    with torch.no_grad():
        outputs = model(image)
        _, predicted = torch.max(outputs, 1)
    
    return predicted.item()

Object Detection

# Example of object detection with YOLOv5
from PIL import Image
import torch

def detect_objects(image_path):
    # Load the YOLOv5 model
    model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
    
    # Detection
    results = model(image_path)
    
    # Process the results
    detections = []
    for pred in results.xyxy[0]:
        x1, y1, x2, y2, conf, cls = pred
        detections.append({
            'classe': results.names[int(cls)],
            'confiance': float(conf),
            'boîte': [float(x1), float(y1), float(x2), float(y2)]
        })
    
    return detections

3. Image Segmentation

Semantic Segmentation

# Example of semantic segmentation with U-Net
import torch.nn as nn

class UNet(nn.Module):
    def __init__(self):
        super().__init__()
        # Encoder
        self.enc1 = self.conv_block(3, 64)
        self.enc2 = self.conv_block(64, 128)
        self.enc3 = self.conv_block(128, 256)
        
        # Decoder
        self.dec3 = self.conv_block(256, 128)
        self.dec2 = self.conv_block(128, 64)
        self.dec1 = self.conv_block(64, 32)
        
        # Final layer
        self.final = nn.Conv2d(32, 1, kernel_size=1)
        
    def conv_block(self, in_channels, out_channels):
        return nn.Sequential(
            nn.Conv2d(in_channels, out_channels, 3, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels, 3, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )

Instance Segmentation

# Example of instance segmentation with Mask R-CNN
from torchvision.models.detection import maskrcnn_resnet50_fpn

def instance_segmentation(image_path):
    # Load the model
    model = maskrcnn_resnet50_fpn(pretrained=True)
    model.eval()
    
    # Prepare the image
    image = Image.open(image_path)
    transform = transforms.Compose([
        transforms.ToTensor()
    ])
    image_tensor = transform(image)
    
    # Prediction
    with torch.no_grad():
        prediction = model([image_tensor])
    
    return prediction[0]

4. Advanced Applications

Facial Recognition

# Example of facial recognition with FaceNet
import face_recognition

def face_recognition_system(image_path, known_faces):
    # Load the image
    image = face_recognition.load_image_file(image_path)
    
    # Detect faces
    face_locations = face_recognition.face_locations(image)
    face_encodings = face_recognition.face_encodings(image, face_locations)
    
    # Compare with known faces
    results = []
    for face_encoding in face_encodings:
        matches = face_recognition.compare_faces(known_faces, face_encoding)
        results.append(matches)
    
    return results

Image Generation

# Example of image generation with a GAN
import torch.nn as nn

class Generator(nn.Module):
    def __init__(self, latent_dim):
        super().__init__()
        self.main = nn.Sequential(
            nn.ConvTranspose2d(latent_dim, 512, 4, 1, 0, bias=False),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            nn.ConvTranspose2d(512, 256, 4, 2, 1, bias=False),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            nn.ConvTranspose2d(256, 128, 4, 2, 1, bias=False),
            nn.BatchNorm2d(128),
            nn.ReLU(True),
            nn.ConvTranspose2d(128, 64, 4, 2, 1, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            nn.ConvTranspose2d(64, 3, 4, 2, 1, bias=False),
            nn.Tanh()
        )
    
    def forward(self, x):
        return self.main(x)

5. Optimization and Performance

Model Quantization

# Example of model quantization
import torch.quantization

def quantize_model(model):
    # Prepare for quantization
    model.eval()
    model.qconfig = torch.quantization.get_default_qconfig('fbgemm')
    
    # Quantization
    torch.quantization.prepare(model, inplace=True)
    torch.quantization.convert(model, inplace=True)
    
    return model

Performance Optimization

# Example of performance optimization
def optimize_image_processing(image_path):
    # Load the image
    image = cv2.imread(image_path)
    
    # Optimizations
    image = cv2.resize(image, (224, 224))
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # Normalization
    image = image.astype(np.float32) / 255.0
    
    # Data augmentation
    transform = transforms.Compose([
        transforms.RandomHorizontalFlip(),
        transforms.RandomRotation(10),
        transforms.ColorJitter(brightness=0.2, contrast=0.2)
    ])
    
    return transform(image)

Conclusion

Image processing with AI offers immense possibilities:

• Image classification
• Object detection
• Image segmentation
• Facial recognition
• Image generation

Key takeaways:

• Understand CNN architectures
• Master image preprocessing
• Optimize performance
• Manage memory efficiently
• Follow best practices