TinyML & Edge AI

import tensorflow as tf

# 1. Cargar modelo preentrenado Keras / SavedModel
model = tf.keras.models.load_model('tinyml_resnet_model.h5')

# 2. Definir un Representative Dataset para calibración de activaciones INT8
def representative_data_gen():
    for input_value in test_ds.take(100):
        yield [tf.cast(input_value, tf.float32)]

# 3. Configurar TFLiteConverter para cuantización INT8 estricta
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_data_gen
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8

# 4. Convertir y guardar binario .tflite cuantizado
tflite_quant_model = converter.convert()
with open('model_int8.tflite', 'wb') as f:
    f.write(tflite_quant_model)
print("[+] Modelo cuantizado INT8 exportado exitosamente.")

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

# 1. Definir una red convolucional sencilla
model = nn.Sequential(
    nn.Conv2d(1, 32, kernel_size=3),
    nn.ReLU(),
    nn.Linear(32 * 26 * 26, 10)
)

# 2. Aplicar poda L1 del 50% de los pesos en la primera capa convolucional
prune.l1_unstructured(model[0], name='weight', amount=0.50)

# 3. Imprimir el porcentaje de ceros (sparsity) logrado
weight_tensor = model[0].weight
sparsity = float(torch.sum(weight_tensor == 0)) / float(weight_tensor.nelement())
print(f"[+] Sparsity en Conv2d: {sparsity * 100:.2f}%")

# 4. Hacer la poda permanente eliminando la máscara
prune.remove(model[0], 'weight')

#include <TensorFlowLite_ESP32.h>
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "model_data.h" // Arreglo C++ const unsigned char g_model[]

constexpr int kTensorArenaSize = 64 * 1024; // 64 KB Tensor Arena
alignas(16) uint8_t tensor_arena[kTensorArenaSize];

void setup_tinyml() {
    // 1. Obtener puntero al modelo FlatBuffer en memoria Flash
    const tflite::Model* model = tflite::GetModel(g_model);
    
    // 2. Instanciar Resolvedor de Operaciones
    static tflite::AllOpsResolver resolver;
    
    // 3. Crear Intérprete apuntando al Tensor Arena estático
    static tflite::MicroInterpreter interpreter(
        model, resolver, tensor_arena, kTensorArenaSize);
        
    interpreter.AllocateTensors();
    
    // 4. Configurar búferes de entrada
    TfLiteTensor* input = interpreter.input(0);
    input->data.int8[0] = 42; // Valor cuantizado de sensor
    
    // 5. Ejecutar Inferencia Local
    TfLiteStatus invoke_status = interpreter.Invoke();
    if (invoke_status == kTfLiteOk) {
        TfLiteTensor* output = interpreter.output(0);
        printf("Inferencia Exitosa! Score: %d\n", output->data.int8[0]);
    }
}

# 1. Exportar modelo PyTorch a ONNX
python3 -m ultralytics export model=yolov8n.pt format=onnx int8=True

# 2. Compilar motor de TensorRT ultra-optimizado en INT8 en la Jetson Nano
trtexec --onnx=yolov8n.onnx \
        --saveEngine=yolov8n_int8.engine \
        --int8 \
        --calib=calibration.cache \
        --workspace=1024