Traitement des Images avec l’IA : Guide Complet

Le traitement des images avec l’Intelligence Artificielle a révolutionné la vision par ordinateur. Ce guide explore les techniques modernes et leurs applications.

1. Principes Fondamentaux

Réseaux de Neurones Convolutifs (CNN)

# Exemple d'implémentation d'un CNN simple
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

Prétraitement des Images

# Exemple de prétraitement d'images
import cv2
import numpy as np
from torchvision import transforms

def preprocess_image(image_path):
    # Lecture de l'image
    image = cv2.imread(image_path)
    
    # Redimensionnement
    image = cv2.resize(image, (224, 224))
    
    # Normalisation
    image = image.astype(np.float32) / 255.0
    
    # Transformation en tenseur
    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. Applications Pratiques

Classification d’Images

# Exemple de classification d'images avec ResNet
from torchvision.models import resnet50
from torchvision import transforms

def classify_image(image_path):
    # Chargement du modèle pré-entraîné
    model = resnet50(pretrained=True)
    model.eval()
    
    # Préparation de l'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)
    
    # Prédiction
    with torch.no_grad():
        outputs = model(image)
        _, predicted = torch.max(outputs, 1)
    
    return predicted.item()

Détection d’Objets

# Exemple de détection d'objets avec YOLOv5
from PIL import Image
import torch

def detect_objects(image_path):
    # Chargement du modèle YOLOv5
    model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
    
    # Détection
    results = model(image_path)
    
    # Traitement des résultats
    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. Segmentation d’Images

Segmentation Sémantique

# Exemple de segmentation sémantique avec 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)
        
        # Couche finale
        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)
        )

Segmentation d’Instance

# Exemple de segmentation d'instance avec Mask R-CNN
from torchvision.models.detection import maskrcnn_resnet50_fpn

def instance_segmentation(image_path):
    # Chargement du modèle
    model = maskrcnn_resnet50_fpn(pretrained=True)
    model.eval()
    
    # Préparation de l'image
    image = Image.open(image_path)
    transform = transforms.Compose([
        transforms.ToTensor()
    ])
    image_tensor = transform(image)
    
    # Prédiction
    with torch.no_grad():
        prediction = model([image_tensor])
    
    return prediction[0]

4. Applications Avancées

Reconnaissance Faciale

# Exemple de reconnaissance faciale avec FaceNet
import face_recognition

def face_recognition_system(image_path, known_faces):
    # Chargement de l'image
    image = face_recognition.load_image_file(image_path)
    
    # Détection des visages
    face_locations = face_recognition.face_locations(image)
    face_encodings = face_recognition.face_encodings(image, face_locations)
    
    # Comparaison avec les visages connus
    results = []
    for face_encoding in face_encodings:
        matches = face_recognition.compare_faces(known_faces, face_encoding)
        results.append(matches)
    
    return results

Génération d’Images

# Exemple de génération d'images avec 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. Optimisation et Performance

Quantification du Modèle

# Exemple de quantification de modèle
import torch.quantization

def quantize_model(model):
    # Préparation pour la quantification
    model.eval()
    model.qconfig = torch.quantization.get_default_qconfig('fbgemm')
    
    # Quantification
    torch.quantization.prepare(model, inplace=True)
    torch.quantization.convert(model, inplace=True)
    
    return model

Optimisation des Performances

# Exemple d'optimisation des performances
def optimize_image_processing(image_path):
    # Chargement de l'image
    image = cv2.imread(image_path)
    
    # Optimisations
    image = cv2.resize(image, (224, 224))
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # Normalisation
    image = image.astype(np.float32) / 255.0
    
    # Augmentation des données
    transform = transforms.Compose([
        transforms.RandomHorizontalFlip(),
        transforms.RandomRotation(10),
        transforms.ColorJitter(brightness=0.2, contrast=0.2)
    ])
    
    return transform(image)

Conclusion

Le traitement des images avec l’IA offre des possibilités immenses :

• Classification d’images
• Détection d’objets
• Segmentation d’images
• Reconnaissance faciale
• Génération d’images

Points clés à retenir :

• Comprendre les architectures CNN
• Maîtriser le prétraitement des images
• Optimiser les performances
• Gérer la mémoire efficacement
• Suivre les bonnes pratiques