Processamento de Imagens com IA: Guia Completo

O processamento de imagens com Inteligência Artificial revolucionou a visão computacional. Este guia explora as técnicas modernas e suas aplicações.

1. Princípios Fundamentais

Redes Neurais Convolucionais (CNN)

# Exemplo de implementação de uma CNN simples
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é-processamento de Imagens

# Exemplo de pré-processamento de imagens
import cv2
import numpy as np
from torchvision import transforms

def preprocess_image(image_path):
    # Leitura da imagem
    image = cv2.imread(image_path)
    
    # Redimensionamento
    image = cv2.resize(image, (224, 224))
    
    # Normalização
    image = image.astype(np.float32) / 255.0
    
    # Transformação em 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. Aplicações Práticas

Classificação de Imagens

# Exemplo de classificação de imagens com ResNet
from torchvision.models import resnet50
from torchvision import transforms

def classify_image(image_path):
    # Carregamento do modelo pré-treinado
    model = resnet50(pretrained=True)
    model.eval()
    
    # Preparação da imagem
    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)
    
    # Predição
    with torch.no_grad():
        outputs = model(image)
        _, predicted = torch.max(outputs, 1)
    
    return predicted.item()

Detecção de Objetos

# Exemplo de detecção de objetos com YOLOv5
from PIL import Image
import torch

def detect_objects(image_path):
    # Carregamento do modelo YOLOv5
    model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
    
    # Detecção
    results = model(image_path)
    
    # Processamento dos resultados
    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. Segmentação de Imagens

Segmentação Semântica

# Exemplo de segmentação semântica com 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)
        
        # Camada final
        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)
        )

Segmentação de Instâncias

# Exemplo de segmentação de instâncias com Mask R-CNN
from torchvision.models.detection import maskrcnn_resnet50_fpn

def instance_segmentation(image_path):
    # Carregamento do modelo
    model = maskrcnn_resnet50_fpn(pretrained=True)
    model.eval()
    
    # Preparação da imagem
    image = Image.open(image_path)
    transform = transforms.Compose([
        transforms.ToTensor()
    ])
    image_tensor = transform(image)
    
    # Predição
    with torch.no_grad():
        prediction = model([image_tensor])
    
    return prediction[0]

4. Aplicações Avançadas

Reconhecimento Facial

# Exemplo de reconhecimento facial com FaceNet
import face_recognition

def face_recognition_system(image_path, known_faces):
    # Carregamento da imagem
    image = face_recognition.load_image_file(image_path)
    
    # Detecção dos rostos
    face_locations = face_recognition.face_locations(image)
    face_encodings = face_recognition.face_encodings(image, face_locations)
    
    # Comparação com os rostos conhecidos
    results = []
    for face_encoding in face_encodings:
        matches = face_recognition.compare_faces(known_faces, face_encoding)
        results.append(matches)
    
    return results

Geração de Imagens

# Exemplo de geração de imagens com 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. Otimização e Desempenho

Quantização do Modelo

# Exemplo de quantização de modelo
import torch.quantization

def quantize_model(model):
    # Preparação para a quantização
    model.eval()
    model.qconfig = torch.quantization.get_default_qconfig('fbgemm')
    
    # Quantização
    torch.quantization.prepare(model, inplace=True)
    torch.quantization.convert(model, inplace=True)
    
    return model

Otimização de Desempenho

# Exemplo de otimização de desempenho
def optimize_image_processing(image_path):
    # Carregamento da imagem
    image = cv2.imread(image_path)
    
    # Otimizações
    image = cv2.resize(image, (224, 224))
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # Normalização
    image = image.astype(np.float32) / 255.0
    
    # Aumento de dados
    transform = transforms.Compose([
        transforms.RandomHorizontalFlip(),
        transforms.RandomRotation(10),
        transforms.ColorJitter(brightness=0.2, contrast=0.2)
    ])
    
    return transform(image)

Conclusão

O processamento de imagens com IA oferece possibilidades imensas:

• Classificação de imagens
• Detecção de objetos
• Segmentação de imagens
• Reconhecimento facial
• Geração de imagens

Pontos-chave a reter:

• Compreender as arquiteturas de CNN
• Dominar o pré-processamento de imagens
• Otimizar o desempenho
• Gerenciar a memória de forma eficiente
• Seguir as boas práticas