معالجة الصور باستخدام الذكاء الاصطناعي: دليل شامل

أحدثت معالجة الصور باستخدام الذكاء الاصطناعي ثورة في الرؤية الحاسوبية. يستعرض هذا الدليل التقنيات الحديثة وتطبيقاتها.

1. المبادئ الأساسية

الشبكات العصبية الالتفافية (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

المعالجة المسبقة للصور

# 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. التطبيقات العملية

تصنيف الصور

# 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()

اكتشاف الكائنات

# 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. تجزئة الصور

التجزئة الدلالية

# 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)
        )

تجزئة الكائنات (Instance Segmentation)

# 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. التطبيقات المتقدمة

التعرف على الوجوه

# 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

توليد الصور

# 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. التحسين والأداء

تكميم النموذج (Quantization)

# 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

تحسين الأداء

# 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)

الخاتمة

توفر معالجة الصور باستخدام الذكاء الاصطناعي إمكانات هائلة:

• تصنيف الصور
• اكتشاف الكائنات
• تجزئة الصور
• التعرف على الوجوه
• توليد الصور

أهم النقاط التي ينبغي تذكرها:

• فهم معماريات CNN
• إتقان المعالجة المسبقة للصور
• تحسين الأداء
• إدارة الذاكرة بكفاءة
• اتباع أفضل الممارسات