Visión artificial

from PIL import Image
import numpy as np
import torch
from torchvision import transforms

img = Image.open("foto.jpg").convert("RGB")
print(img.size)                      # (ancho, alto)
arr = np.asarray(img)
print(arr.shape, arr.dtype, arr.min(), arr.max())   # (H, W, 3) uint8

# Pipeline estándar para un modelo preentrenado
preprocesar = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),                       # HWC uint8 -> CHW float [0,1]
    transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
])

tensor = preprocesar(img)
print(tensor.shape, tensor.dtype, tensor.min().item(), tensor.max().item())

# Añadir dimensión de batch: (3,224,224) -> (1,3,224,224)
batch = tensor.unsqueeze(0)
print(batch.shape)

import torch
import torch.nn as nn

# batch=1, canales=3, alto=32, ancho=32
x = torch.randn(1, 3, 32, 32)

conv = nn.Conv2d(
    in_channels=3,
    out_channels=16,
    kernel_size=3,
    stride=1,
    padding=1,          # "same"
    bias=True
)
print(conv(x).shape)     # torch.Size([1, 16, 32, 32])

conv_stride = nn.Conv2d(3, 16, kernel_size=3, stride=2, padding=1)
print(conv_stride(x).shape)  # torch.Size([1, 16, 16, 16])

pool = nn.MaxPool2d(kernel_size=2, stride=2)
print(pool(x).shape)     # torch.Size([1, 3, 16, 16])

# Número de parámetros de una convolución
pesos = 3 * 16 * 3 * 3
sesgos = 16
print("parámetros:", pesos + sesgos)   # 448

# Campo receptivo: dos conv 3x3 equivalen a una 5x5
def campo_receptivo(k, s=1, n=1):
    return 1 + sum((k - 1) * (s ** i) for i in range(n))
print(campo_receptivo(3, 1, 2))   # 5
print(campo_receptivo(3, 1, 3))   # 7

import torch
import torch.nn as nn

class BloqueResidual(nn.Module):
    def __init__(self, canales):
        super().__init__()
        self.conv1 = nn.Conv2d(canales, canales, 3, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(canales)
        self.conv2 = nn.Conv2d(canales, canales, 3, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(canales)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        identidad = x
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        return self.relu(out + identidad)

class MiniResNet(nn.Module):
    def __init__(self, n_classes=10):
        super().__init__()
        self.stem = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1, bias=False),
            nn.BatchNorm2d(32), nn.ReLU(inplace=True)
        )
        self.bloques = nn.Sequential(
            BloqueResidual(32),
            nn.MaxPool2d(2),
            BloqueResidual(32),
            nn.MaxPool2d(2),
            BloqueResidual(32)
        )
        self.pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Linear(32, n_classes)

    def forward(self, x):
        x = self.bloques(self.stem(x))
        x = self.pool(x).flatten(1)
        return self.fc(x)

modelo = MiniResNet()
print(sum(p.numel() for p in modelo.parameters()), "parámetros")

import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms, models

train_tf = transforms.Compose([
    transforms.RandomResizedCrop(224, scale=(0.7, 1.0)),
    transforms.RandomHorizontalFlip(),
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.1),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

val_tf = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

train_ds = datasets.ImageFolder("datos/train", transform=train_tf)
val_ds = datasets.ImageFolder("datos/val", transform=val_tf)

train_loader = DataLoader(train_ds, batch_size=32, shuffle=True, num_workers=4)
val_loader = DataLoader(val_ds, batch_size=64, shuffle=False, num_workers=4)

# Transfer learning
modelo = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
for p in modelo.parameters():
    p.requires_grad = False
modelo.fc = nn.Linear(modelo.fc.in_features, len(train_ds.classes))

device = "cuda" if torch.cuda.is_available() else "cpu"
modelo = modelo.to(device)

criterio = nn.CrossEntropyLoss(label_smoothing=0.1)
optimizador = torch.optim.AdamW(modelo.fc.parameters(), lr=1e-3)

mejor_f1 = 0.0
for epoch in range(10):
    modelo.train()
    for xb, yb in train_loader:
        xb, yb = xb.to(device), yb.to(device)
        optimizador.zero_grad()
        loss = criterio(modelo(xb), yb)
        loss.backward()
        optimizador.step()

    # Validación (omitida para brevedad: calcula F1 y guarda el mejor estado)
    print(f"epoch {epoch} terminada")

import torch
import torch.nn as nn
from torchvision import models

def crear_modelo(n_clases, congelar=True):
    modelo = models.efficientnet_b0(weights=models.EfficientNet_B0_Weights.DEFAULT)
    if congelar:
        for p in modelo.features.parameters():
            p.requires_grad = False
    en_features = modelo.classifier[1].in_features
    modelo.classifier[1] = nn.Linear(en_features, n_clases)
    return modelo

modelo = crear_modelo(n_clases=5)

# Dos fases: cabeza primero, fine-tuning después
fase1 = torch.optim.AdamW(modelo.classifier.parameters(), lr=1e-3)

# Tras 3-5 épocas, descongelar el último bloque
for p in modelo.features[-2:].parameters():
    p.requires_grad = True
fase2 = torch.optim.AdamW([
    {"params": modelo.features[-2:].parameters(), "lr": 1e-5},
    {"params": modelo.classifier.parameters(), "lr": 1e-4}
])

# Evaluación: matriz de confusión y métricas por clase
from sklearn.metrics import confusion_matrix, classification_report
modelo.eval()
with torch.no_grad():
    logits = modelo(X_test_tensor)
    preds = logits.argmax(dim=1).cpu().numpy()

print(classification_report(y_test, preds, target_names=clases, digits=3))
print(confusion_matrix(y_test, preds))

import torch
from torchvision import models, transforms
from PIL import Image, ImageDraw

pesos = models.detection.FasterRCNN_ResNet50_FPN_V2_Weights.DEFAULT
modelo = models.detection.fasterrcnn_resnet50_fpn_v2(weights=pesos).eval()

preprocesar = transforms.Compose([transforms.ToTensor()])
img = Image.open("calle.jpg").convert("RGB")
tensor = preprocesar(img)

with torch.no_grad():
    salida = modelo([tensor])[0]

# Filtrar por confianza
umbral = 0.6
dibujo = ImageDraw.Draw(img)
for caja, etiqueta, score in zip(
    salida["boxes"], salida["labels"], salida["scores"]
):
    if score < umbral:
        continue
    x1, y1, x2, y2 = caja.tolist()
    dibujo.rectangle([x1, y1, x2, y2], outline="red", width=3)
    dibujo.text((x1 + 4, y1 + 4), f"{pesos.meta['categories'][etiqueta]} {score:.2f}")

img.save("detecciones.jpg")

import torch
import torch.nn as nn

class Bloque(nn.Module):
    def __init__(self, entrada, salida):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(entrada, salida, 3, padding=1, bias=False),
            nn.BatchNorm2d(salida), nn.ReLU(inplace=True),
            nn.Conv2d(salida, salida, 3, padding=1, bias=False),
            nn.BatchNorm2d(salida), nn.ReLU(inplace=True)
        )

    def forward(self, x):
        return self.conv(x)

class UNet(nn.Module):
    def __init__(self, n_clases=2):
        super().__init__()
        self.enc1 = Bloque(3, 64)
        self.enc2 = Bloque(64, 128)
        self.enc3 = Bloque(128, 256)
        self.pool = nn.MaxPool2d(2)
        self.up2 = nn.ConvTranspose2d(256, 128, 2, stride=2)
        self.dec2 = Bloque(256, 128)
        self.up1 = nn.ConvTranspose2d(128, 64, 2, stride=2)
        self.dec1 = Bloque(128, 64)
        self.salida = nn.Conv2d(64, n_clases, 1)

    def forward(self, x):
        e1 = self.enc1(x)              # 64
        e2 = self.enc2(self.pool(e1))  # 128, 1/2
        e3 = self.enc3(self.pool(e2))  # 256, 1/4
        d2 = self.dec2(torch.cat([self.up2(e3), e2], dim=1))
        d1 = self.dec1(torch.cat([self.up1(d2), e1], dim=1))
        return self.salida(d1)

modelo = UNet(n_clases=2)
print(modelo(torch.randn(1, 3, 256, 256)).shape)   # (1,2,256,256)

import torch

modelo.eval()
ejemplo = torch.randn(1, 3, 224, 224)

torch.onnx.export(
    modelo,
    ejemplo,
    "modelo.onnx",
    input_names=["imagen"],
    output_names=["logits"],
    dynamic_axes={"imagen": {0: "batch"}, "logits": {0: "batch"}},
    opset_version=17
)

# Verificar que ONNX produce la misma salida
import onnxruntime as ort
import numpy as np

sesion = ort.InferenceSession("modelo.onnx", providers=["CPUExecutionProvider"])
salida_onnx = sesion.run(None, {"imagen": ejemplo.numpy()})[0]
with torch.no_grad():
    salida_torch = modelo(ejemplo).numpy()

print("diferencia máxima:", np.abs(salida_onnx - salida_torch).max())

# Cuantización dinámica (reduce tamaño ~4x)
modelo_cuantizado = torch.quantization.quantize_dynamic(
    modelo, {torch.nn.Linear, torch.nn.Conv2d}, dtype=torch.qint8
)
torch.save(modelo_cuantizado.state_dict(), "modelo_int8.pt")