Edge Computing para IA

import torch
import torch.nn.utils.prune as prune

model = torch.hub.load('pytorch/vision', 'resnet18', pretrained=True)

# Pruning no-estructurado: eliminar 40% de pesos por magnitud
for name, module in model.named_modules():
    if isinstance(module, torch.nn.Conv2d):
        prune.l1_unstructured(module, name='weight', amount=0.4)

# Hacer permanente (eliminar el hook de pruning)
for name, module in model.named_modules():
    if isinstance(module, torch.nn.Conv2d):
        prune.remove(module, 'weight')

# Verificar sparsity
total = sum(p.numel() for p in model.parameters())
zeros = sum((p == 0).sum().item() for p in model.parameters())
print(f"Sparsity: {zeros/total*100:.1f}%")

# Pruning ESTRUCTURADO: eliminar 30% de filtros por norma L2
for name, module in model.named_modules():
    if isinstance(module, torch.nn.Conv2d):
        prune.ln_structured(module, name='weight', amount=0.3, n=2, dim=0)

import torch
from torch.quantization import quantize_dynamic, quantize

# ═══════════════════════════════════════════════
# 1. Dynamic Quantization (sin dataset de calibración)
# ═══════════════════════════════════════════════
model_fp32 = ...  # tu modelo entrenado

model_int8 = quantize_dynamic(
    model_fp32,
    {torch.nn.Linear, torch.nn.LSTM},  # capas a cuantizar
    dtype=torch.qint8
)

# Comparar tamaños
import os
torch.save(model_fp32.state_dict(), "model_fp32.pt")
torch.save(model_int8.state_dict(), "model_int8.pt")
print(f"FP32: {os.path.getsize('model_fp32.pt')/1e6:.1f} MB")
print(f"INT8: {os.path.getsize('model_int8.pt')/1e6:.1f} MB")

# ═══════════════════════════════════════════════
# 2. Static Quantization (con calibración)
# ═══════════════════════════════════════════════
model_fp32.eval()
model_fp32.qconfig = torch.quantization.get_default_qconfig('x86')
model_prepared = torch.quantization.prepare(model_fp32)

# Calibrar con datos representativos
with torch.no_grad():
    for images, _ in calibration_loader:  # ~100-1000 batches
        model_prepared(images)

# Convertir a INT8
model_quantized = torch.quantization.convert(model_prepared)

import tensorflow as tf

# Cargar modelo entrenado
model = tf.keras.models.load_model('my_model.h5')

# ═══════════════════════════════════════════════
# 1. Post-Training INT8 Quantization
# ═══════════════════════════════════════════════
def representative_dataset():
    """Dataset de calibración (~100-1000 muestras)"""
    for images, _ in calibration_ds.take(200):
        yield [tf.cast(images, tf.float32)]

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8

tflite_quant_model = converter.convert()

# Guardar
with open('model_int8.tflite', 'wb') as f:
    f.write(tflite_quant_model)

print(f"Tamaño: {len(tflite_quant_model) / 1e6:.1f} MB")

# ═══════════════════════════════════════════════
# 2. Quantization-Aware Training (QAT)
# ═══════════════════════════════════════════════
import tensorflow_model_optimization as tfmot

qat_model = tfmot.quantization.keras.quantize_model(model)
qat_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
qat_model.fit(train_ds, epochs=3)  # Fine-tune con QAT

# Convertir a TFLite INT8
converter = tf.lite.TFLiteConverter.from_keras_model(qat_model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_qat = converter.convert()

import torch
import tensorrt as trt

# 1. Exportar a ONNX
model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)
model.eval()
dummy = torch.randn(1, 3, 640, 640)
torch.onnx.export(model, dummy, "yolov5s.onnx",
                  opset_version=13,
                  input_names=['images'],
                  output_names=['output'],
                  dynamic_axes={'images': {0: 'batch'}})

# 2. Compilar con TensorRT (trtexec CLI)
# $ trtexec --onnx=yolov5s.onnx \
#           --saveEngine=yolov5s.engine \
#           --fp16 \                    # o --int8 --calib=calib.cache
#           --workspace=1024 \
#           --batch=1

# 3. Inferencia con TensorRT en Python
import pycuda.driver as cuda
import pycuda.autoinit
import numpy as np

logger = trt.Logger(trt.Logger.WARNING)
with open("yolov5s.engine", "rb") as f:
    engine = trt.Runtime(logger).deserialize_cuda_engine(f.read())

context = engine.create_execution_context()
# ... allocate buffers, run inference, postprocess ...

import onnxruntime as ort
import numpy as np

# Crear sesión con TensorRT EP (Jetson) o CPU fallback
providers = ['TensorrtExecutionProvider',
             'CUDAExecutionProvider',
             'CPUExecutionProvider']

session = ort.InferenceSession("model.onnx", providers=providers)

# Ver qué EP se está usando
print(f"Using: {session.get_providers()}")

# Inferencia
input_name = session.get_inputs()[0].name
result = session.run(None, {input_name: np.random.randn(1, 3, 224, 224).astype(np.float32)})
print(f"Output shape: {result[0].shape}")

# ═══════════════════════════════════════════════
# 1. Cuantización con Vitis AI (PyTorch)
# ═══════════════════════════════════════════════
from pytorch_nndct.apis import torch_quantizer

model = load_my_model()  # Modelo PyTorch entrenado
model.eval()

# Crear quantizer
quantizer = torch_quantizer(
    quant_mode='calib',       # Modo calibración
    module=model,
    input_args=torch.randn(1, 3, 224, 224),
    output_dir='quantized/',
    bitwidth=8                # INT8
)

quant_model = quantizer.quant_model

# Calibrar con datos representativos
with torch.no_grad():
    for images, _ in calib_loader:
        quant_model(images)

quantizer.export_quant_config()

# ═══════════════════════════════════════════════
# 2. Compilar para DPU (terminal)
# ═══════════════════════════════════════════════
# $ vai_c_xir \
#     -x quantized/model_int.xmodel \
#     -a /opt/vitis_ai/compiler/arch/DPUCZDX8G/KV260/arch.json \
#     -o compiled/ \
#     -n my_model

# ═══════════════════════════════════════════════
# 3. Inferencia con VART en la FPGA
# ═══════════════════════════════════════════════
import xir
import vart
import numpy as np

# Cargar modelo compilado
graph = xir.Graph.deserialize("compiled/my_model.xmodel")
subgraphs = graph.get_root_subgraph().toposort_child_subgraph()
dpu_subgraph = [s for s in subgraphs if s.has_attr("device") and s.get_attr("device") == "DPU"]

runner = vart.Runner.create_runner(dpu_subgraph[0], "run")

# Preparar buffers
input_tensors = runner.get_input_tensors()
output_tensors = runner.get_output_tensors()

# Ejecutar inferencia
input_data = preprocess(image)  # Preprocesado del input
job_id = runner.execute_async([input_data], [output_buffer])
runner.wait(job_id)

import hls4ml
import tensorflow as tf
from tensorflow import keras

# 1. Definir modelo pequeño (trigger LHC)
model = keras.Sequential([
    keras.layers.Dense(64, activation='relu', input_shape=(16,)),
    keras.layers.Dense(32, activation='relu'),
    keras.layers.Dense(32, activation='relu'),
    keras.layers.Dense(5, activation='softmax')
])
model.compile(optimizer='adam', loss='categorical_crossentropy')
model.fit(X_train, y_train, epochs=50)

# 2. Configurar hls4ml
config = hls4ml.utils.config_from_keras_model(model, granularity='name')

# Ajustar precisión por capa
for layer in config['LayerName']:
    config['LayerName'][layer]['Precision']['weight'] = 'ap_fixed<16,6>'
    config['LayerName'][layer]['Precision']['bias']   = 'ap_fixed<16,6>'
    config['LayerName'][layer]['Precision']['result'] = 'ap_fixed<16,6>'
    config['LayerName'][layer]['ReuseFactor'] = 1  # Full parallel

# 3. Convertir a HLS
hls_model = hls4ml.converters.convert_from_keras_model(
    model, hls_config=config,
    output_dir='hls_output/',
    backend='VivadoAccelerator',  # o 'Vitis'
    board='kria-kv260'
)

# 4. Compilar y sintetizar
hls_model.compile()
hls_model.build(csim=True, synth=True)  # Simular + sintetizar

# Ver recursos
hls4ml.report.read_vivado_report('hls_output/')
# → Latencia: ~50 ns, LUTs: 15%, DSPs: 8%, BRAMs: 3%