8.3 Despliegue de Modelos en Dispositivos Móviles y de Borde

Desplegar modelos de machine learning en dispositivos móviles y de borde implica un proceso integral que abarca varias etapas críticas, cada una de las cuales desempeña un papel vital para garantizar un rendimiento y eficiencia óptimos:

Optimización y compresión del modelo: Este paso crucial implica refinar y comprimir el modelo para garantizar que funcione de manera eficiente en dispositivos con recursos limitados. Se emplean técnicas como la cuantificación, poda y destilación de conocimiento para reducir el tamaño del modelo y las demandas computacionales, manteniendo la precisión.
Selección del framework y conversión del modelo: Elegir el framework adecuado, como TensorFlow Lite o ONNX, es esencial para convertir y ejecutar el modelo en el dispositivo objetivo. Estos frameworks proporcionan herramientas y optimizaciones especializadas para el despliegue en el borde, garantizando compatibilidad y rendimiento en diversas plataformas de hardware.
Integración con la aplicación móvil: Esta etapa implica incorporar sin problemas el modelo optimizado en el código de la aplicación móvil o de borde. Los desarrolladores deben implementar tuberías de inferencia eficientes, gestionar la carga y descarga de modelos, y manejar el procesamiento de entrada/salida para asegurar una integración fluida con la funcionalidad de la aplicación.
Aceleración específica del hardware: Maximizar el rendimiento en dispositivos de borde a menudo requiere aprovechar aceleradores de hardware específicos del dispositivo, como GPUs (Unidades de Procesamiento Gráfico), TPUs (Unidades de Procesamiento Tensorial) o NPUs (Unidades de Procesamiento Neuronal). Este paso implica optimizar el modelo y el código de inferencia para aprovechar al máximo estos componentes de hardware especializados, mejorando significativamente la velocidad de inferencia y la eficiencia energética.
Monitoreo y optimización del rendimiento: El monitoreo continuo del rendimiento del modelo desplegado en dispositivos de borde es crucial. Esto implica el seguimiento de métricas como el tiempo de inferencia, uso de memoria y consumo de batería. Con base en estos conocimientos, se pueden aplicar optimizaciones adicionales para mejorar la eficiencia del modelo y la experiencia del usuario.

Desglosemos cada paso con más detalle.

8.3.1 Técnicas de Optimización de Modelos para Dispositivos de Borde

Antes de desplegar un modelo de machine learning en un dispositivo móvil o de borde, es crucial implementar técnicas de optimización para minimizar su tamaño y reducir sus demandas computacionales. Este proceso de optimización es esencial para asegurar un rendimiento eficiente en dispositivos con recursos limitados, como smartphones, tablets o sensores IoT.

Al simplificar el modelo, los desarrolladores pueden mejorar significativamente su velocidad y reducir su huella de memoria, lo que en última instancia conduce a una mejor experiencia del usuario y mayor duración de la batería en el dispositivo objetivo.

Varias técnicas se utilizan comúnmente para lograr esto:

1. Cuantificación: La cuantificación reduce la precisión de los pesos y activaciones del modelo desde punto flotante de 32 bits (FP32) a formatos de menor precisión como 16 bits (FP16) o 8 bits (INT8). Esto reduce significativamente el tamaño del modelo y acelera la inferencia con un impacto mínimo en la precisión.

# TensorFlow Lite example of post-training quantization
converter = tf.lite.TFLiteConverter.from_saved_model('my_model')
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quantized_model = converter.convert()

2. Poda: Esta técnica implica eliminar sistemáticamente conexiones o neuronas innecesarias de una red neuronal. Al identificar y eliminar parámetros que contribuyen mínimamente al rendimiento del modelo, la poda puede reducir significativamente el tamaño del modelo y los requisitos computacionales. Este proceso a menudo implica ciclos iterativos de entrenamiento y poda, donde el modelo se vuelve a entrenar después de cada paso de poda para mantener la precisión. La poda es particularmente efectiva para modelos grandes y sobreparametrizados, permitiéndoles funcionar eficientemente en dispositivos con recursos limitados sin una pérdida significativa de rendimiento.

3. Destilación de Modelos: También conocida como Destilación de Conocimiento, esta técnica implica transferir el conocimiento de un modelo grande y complejo (el maestro) a un modelo más pequeño y simple (el alumno). El proceso generalmente implica entrenar al modelo alumno para imitar las probabilidades de salida o representaciones intermedias del modelo maestro, en lugar de solo las etiquetas de clase rígidas. Este enfoque permite que el modelo alumno capture los matices de las fronteras de decisión aprendidas por el maestro, lo que a menudo resulta en un rendimiento que supera lo que el modelo más pequeño podría lograr si se entrenara directamente con los datos. La destilación es particularmente útil para el despliegue en el borde, ya que puede producir modelos compactos y de alto rendimiento, logrando un equilibrio óptimo entre eficiencia y precisión.

Tanto la poda como la destilación se pueden combinar con otras técnicas de optimización, como la cuantificación, para mejorar aún más la eficiencia del modelo en el despliegue en dispositivos de borde. Estos métodos son fundamentales en la caja de herramientas de los ingenieros de machine learning que buscan desplegar capacidades de IA sofisticadas en dispositivos de borde con recursos limitados, habilitando funcionalidades avanzadas mientras se mantiene la capacidad de respuesta y la eficiencia energética.

8.3.2 Desplegando Modelos en Dispositivos Android

Para dispositivos Android, TensorFlow Lite (TFLite) se destaca como el marco ideal para desplegar modelos de machine learning. Esta herramienta poderosa ofrece una serie de beneficios que la hacen ideal para el desarrollo móvil:

Runtime Ligero: TFLite está específicamente diseñado para ejecutarse eficientemente en dispositivos móviles, minimizando el uso de recursos y el consumo de batería.
Integración Sin Esfuerzo: Proporciona una suite de herramientas que simplifican el proceso de incorporación de modelos de ML en aplicaciones Android.
Inferencia en el Dispositivo: Con TFLite, los desarrolladores pueden ejecutar la inferencia del modelo directamente en el dispositivo, eliminando la necesidad de conectividad constante a la nube y reduciendo la latencia.
Rendimiento Optimizado: TFLite incluye optimizaciones integradas para hardware móvil, aprovechando la aceleración por GPU y otras características específicas del dispositivo para mejorar la velocidad y la eficiencia.
Privacidad: Al procesar los datos localmente, TFLite ayuda a mantener la privacidad del usuario, ya que no es necesario que la información sensible salga del dispositivo.

Estas características permiten a los desarrolladores crear aplicaciones Android sofisticadas y potenciadas por IA, que son a la vez receptivas y eficientes en recursos, abriendo nuevas posibilidades para la experiencia del usuario móvil.

Ejemplo: Desplegando un Modelo TensorFlow Lite en Android

Convertir el Modelo a TensorFlow Lite:
Primero, convierte tu modelo entrenado de TensorFlow al formato TensorFlow Lite, como se mostró en la sección anterior.

converter = tf.lite.TFLiteConverter.from_saved_model('my_model')
tflite_model = converter.convert()

# Save the TFLite model
with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

Integrar el Modelo en una Aplicación Android:
Una vez que tengas el archivo .tflite, puedes integrarlo en una aplicación Android usando el TensorFlow Lite Interpreter. A continuación se muestra un ejemplo de cómo cargar el modelo y ejecutar la inferencia:
import org.tensorflow.lite.Interpreter; import android.content.res.AssetManager; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.io.IOException; import java.io.InputStream; import java.nio.channels.FileChannel; import java.io.FileInputStream; import java.io.File; public class MyModel { private Interpreter tflite; // Constructor: loads the model from assets public MyModel(AssetManager assetManager, String modelPath) throws IOException { ByteBuffer modelBuffer = loadModelFile(assetManager, modelPath); tflite = new Interpreter(modelBuffer); } // Method to load the model from assets private ByteBuffer loadModelFile(AssetManager assetManager, String modelPath) throws IOException { try (InputStream inputStream = assetManager.open(modelPath)) { byte[] modelBytes = new byte[inputStream.available()]; inputStream.read(modelBytes); ByteBuffer buffer = ByteBuffer.allocateDirect(modelBytes.length) .order(ByteOrder.nativeOrder()); buffer.put(modelBytes); buffer.rewind(); return buffer.asReadOnlyBuffer(); // Makes the buffer read-only } } // Performs inference with input data public float[] runInference(float[] inputData) { float[][] outputData = new float[1][10]; // Assuming 10 output classes ByteBuffer inputBuffer = ByteBuffer.allocateDirect(inputData.length * 4) .order(ByteOrder.nativeOrder()); for (float value : inputData) { inputBuffer.putFloat(value); } inputBuffer.rewind(); tflite.run(inputBuffer, outputData); return outputData[0]; // Returns the results } }
Este código demuestra cómo integrar un modelo de TensorFlow Lite en una aplicación Android.
Analicémoslo en detalle:
1. Definición de Clase: La clase MyModel está definida para manejar las operaciones del modelo TensorFlow Lite.
2. Carga del Modelo: El constructor MyModel(AssetManager assetManager, String modelPath) carga el modelo desde los recursos de la aplicación. Utiliza el método loadModelFile para leer el archivo del modelo en un ByteBuffer.
3. Intérprete TFLite: Se crea una instancia de Interpreter utilizando el buffer del modelo cargado. Este intérprete se utiliza para ejecutar la inferencia.
4. Lectura de Archivos: El método loadModelFile lee el archivo del modelo TensorFlow Lite usando AssetManager.open() en lugar de FileInputStream, asegurando la compatibilidad con los recursos de Android. Carga el modelo en un ByteBuffer, que se marca como solo lectura para prevenir modificaciones.
5. Inferencia: El método runInference realiza la inferencia sobre los datos de entrada. Toma un array de flotantes como entrada y devuelve otro array de flotantes como salida. El método convierte correctamente el array de entrada en un ByteBuffer antes de pasarlo al intérprete TFLite, asegurando la compatibilidad con el formato de entrada esperado por TensorFlow Lite.
Este ejemplo proporciona una estructura robusta y eficiente para usar TensorFlow Lite en una aplicación Android, permitiendo la inferencia optimizada de machine learning en el dispositivo.
1. Optimizar para Aceleración de Hardware:
  Muchos dispositivos Android vienen equipados con aceleradores de hardware especializados diseñados para mejorar el rendimiento de machine learning. Estos incluyen Procesadores de Señal Digital (DSP), que sobresalen en procesar señales digitales, y Unidades de Procesamiento Neural (NPU), optimizadas específicamente para cálculos de redes neuronales. TensorFlow Lite proporciona herramientas para aprovechar estos componentes, lo que resulta en tiempos de inferencia significativamente más rápidos.
  Al utilizar estos aceleradores, los desarrolladores pueden lograr mejoras sustanciales en el rendimiento de sus aplicaciones de IA. Por ejemplo, tareas como el reconocimiento de imágenes, procesamiento de lenguaje natural y detección de objetos en tiempo real pueden ejecutarse con menor latencia y mayor eficiencia. Esta optimización es especialmente crucial para aplicaciones intensivas en recursos, como la realidad aumentada, asistentes de voz y cámaras con IA, donde la capacidad de respuesta y la duración de la batería son fundamentales.
  Además, la capacidad de TensorFlow Lite para utilizar estos aceleradores de hardware no solo mejora la velocidad, sino que también permite que modelos más complejos y sofisticados se ejecuten sin problemas en dispositivos móviles, abriendo posibilidades para funciones de IA avanzadas que antes solo eran factibles en hardware más potente. Esta capacidad cierra la brecha entre los servicios de IA basados en la nube y la inteligencia en el dispositivo, ofreciendo a los usuarios mayor privacidad y funcionalidad sin conexión mientras se mantiene un alto rendimiento.
  Puedes configurar el TFLite Interpreter para usar estos aceleradores de hardware habilitando el delegado GPU:
Interpreter.Options options = new Interpreter.Options(); GpuDelegate delegate = new GpuDelegate(); options.addDelegate(delegate); Interpreter tflite = new Interpreter(modelBuffer, options);

8.3.3 Desplegando Modelos en Dispositivos iOS

Para dispositivos iOS, TensorFlow Lite ofrece un soporte robusto, reflejando el proceso de despliegue utilizado para aplicaciones Android. Sin embargo, el desarrollo en iOS generalmente utiliza Core ML, el marco de machine learning nativo de Apple, para la ejecución de modelos. Este marco está profundamente integrado en iOS y optimizado para el hardware de Apple, brindando un excelente rendimiento y eficiencia energética.

Para cerrar la brecha entre TensorFlow y Core ML, los desarrolladores pueden utilizar el TF Lite Converter. Esta herramienta poderosa permite la transformación sin problemas de modelos de TensorFlow Lite al formato Core ML, garantizando la compatibilidad con dispositivos iOS. El proceso de conversión preserva la arquitectura y los pesos del modelo, mientras lo adapta a las especificaciones de Core ML.

La capacidad de convertir modelos de TensorFlow Lite al formato Core ML ofrece varias ventajas:

Desarrollo multiplataforma: Los desarrolladores pueden mantener un solo modelo de TensorFlow para las plataformas Android e iOS, lo que simplifica el proceso de desarrollo.
Optimización de hardware: Core ML aprovecha el motor neuronal y la GPU de Apple, lo que resulta en tiempos de inferencia más rápidos y un menor consumo de energía.
Integración con el ecosistema de iOS: Los modelos convertidos pueden interactuar fácilmente con otros marcos y API de iOS, mejorando la funcionalidad general de la aplicación.

Además, el proceso de conversión a menudo incluye optimizaciones específicas para dispositivos iOS, como cuantización y poda, que pueden reducir significativamente el tamaño del modelo y mejorar el rendimiento sin sacrificar la precisión. Esto permite desplegar modelos complejos de machine learning en dispositivos iOS con recursos limitados, ampliando las posibilidades para aplicaciones móviles impulsadas por IA.

Ejemplo: Convertir Modelos de TensorFlow Lite a Core ML

A continuación se explica cómo convertir un modelo de TensorFlow a formato Core ML:

import coremltools as ct
import tensorflow as tf
import numpy as np

# Load the TensorFlow model
model = tf.keras.models.load_model('my_model.h5')

# Convert the model to Core ML format
coreml_model = ct.convert(
    model,
    inputs=[ct.TensorType(shape=(1,) + model.input_shape[1:])],  # Ensure batch dimension is included
    minimum_deployment_target=ct.target.iOS13
)

# Set metadata
coreml_model.author = "Your Name"
coreml_model.license = "Your License"
coreml_model.short_description = "Brief description of your model"
coreml_model.version = "1.0"

# Save the Core ML model
coreml_model_path = 'MyCoreMLModel.mlmodel'
coreml_model.save(coreml_model_path)

# Verify the converted model
import coremltools.proto
from coremltools.models import MLModel

# Load the saved Core ML model
mlmodel = MLModel(coreml_model_path)

# Generate a sample input for testing
input_shape = model.input_shape[1:]  # Exclude batch dimension
sample_input = np.random.rand(1, *input_shape).astype(np.float32)  # Add batch dimension

# Run inference with TensorFlow
tf_out = model.predict(sample_input)

# Run inference with Core ML
coreml_input_name = mlmodel.input_description._fd_spec[0].name
coreml_out = mlmodel.predict({coreml_input_name: sample_input})

# Extract Core ML output
output_names = [output.name for output in mlmodel.get_spec().description.output]
coreml_output = coreml_out[output_names[0]]

# Compare outputs
print("Core ML output shape:", coreml_output.shape)
print("TensorFlow output shape:", tf_out.shape)
print("Outputs match:", np.allclose(coreml_output, tf_out, atol=1e-5))

print("Model successfully converted to Core ML format and verified.")

Este ejemplo de código demuestra un proceso integral de conversión de un modelo TensorFlow al formato Core ML. Vamos a

analizarlo en detalle:

Importar las bibliotecas necesarias: Importamos coremltools para el proceso de conversión, tensorflow para cargar el modelo original y numpy para manejar operaciones con arrays.
Cargar el modelo TensorFlow: Utilizamos tf.keras.models.load_model para cargar un modelo TensorFlow pre-entrenado desde un archivo H5.
Generar datos de entrada de ejemplo: Creamos un tensor de entrada de ejemplo que coincida con la forma de entrada del modelo, asegurándonos de incluir la dimensión del lote. Esto es útil para verificar la conversión posteriormente.
Convertir el modelo: Utilizamos coremltools.convert() para transformar el modelo TensorFlow al formato Core ML. Especificamos la forma de entrada correctamente, asegurando la compatibilidad con Core ML, y establecemos una versión mínima de implementación (iOS13 en este caso).
Establecer metadatos: Agregamos metadatos al modelo Core ML, incluyendo el autor, licencia, descripción y versión. Esta información es útil para la gestión y documentación del modelo.
Guardar el modelo: Guardamos el modelo convertido en un archivo con la extensión .mlmodel, que es el formato estándar para modelos Core ML.
Verificar la conversión: Cargamos el modelo Core ML guardado usando MLModel y generamos datos de entrada de ejemplo para pruebas. Luego ejecutamos la inferencia en ambos modelos, TensorFlow y Core ML, y comparamos las salidas para asegurar que la conversión fue exitosa.
Imprimir resultados: Finalmente, imprimimos las formas de salida de ambos modelos y verificamos si coinciden dentro de un pequeño margen de tolerancia. Este paso de validación asegura que el modelo convertido produzca resultados consistentes con el modelo TensorFlow original.

Este ejemplo integral no solo convierte el modelo sino que también incluye pasos para la verificación y adición de metadatos, que son cruciales para implementar modelos fiables y bien documentados en aplicaciones iOS.

8.3.4 Despliegue de Modelos en Dispositivos Edge (IoT y Sistemas Embebidos)

Los dispositivos Edge, como sensores IoT, Raspberry Pi y NVIDIA Jetson, presentan desafíos únicos para el despliegue de machine learning debido a sus recursos computacionales limitados y restricciones de energía. Para abordar estos desafíos, se han desarrollado runtimes optimizados como TensorFlow Lite y ONNX Runtime, específicamente para escenarios de computación en el borde.

Estos runtimes especializados ofrecen varias ventajas clave para el despliegue en el borde:

Reducción del tamaño del modelo: Soportan técnicas de compresión de modelos como la cuantización y la poda, reduciendo significativamente el tamaño de almacenamiento de los modelos de ML.
Inferencia optimizada: Estos runtimes están diseñados para maximizar la velocidad de inferencia en hardware con recursos limitados, aprovechando a menudo optimizaciones específicas del dispositivo.
Bajo consumo de energía: Al minimizar la sobrecarga computacional, ayudan a extender la vida útil de la batería en dispositivos portátiles del borde.
Compatibilidad multiplataforma: Tanto TensorFlow Lite como ONNX Runtime soportan una amplia gama de dispositivos Edge y sistemas operativos, facilitando el despliegue en diversos ecosistemas de hardware.

Además, estos runtimes suelen proporcionar herramientas adicionales para la optimización del modelo y análisis del rendimiento, permitiendo a los desarrolladores afinar sus despliegues para escenarios específicos del borde. Este ecosistema de herramientas y optimizaciones hace posible ejecutar modelos avanzados de machine learning en dispositivos con recursos limitados, abriendo nuevas posibilidades para aplicaciones de IA en campos como IoT, robótica y sistemas embebidos.

Ejemplo: Ejecutando TensorFlow Lite en un Raspberry Pi

Instalar TensorFlow Lite en el Raspberry Pi:
Primero, instala TensorFlow Lite en el Raspberry Pi:

pip install tflite-runtime

Ejecutar inferencia con TensorFlow Lite:
Utiliza el siguiente código en Python para cargar y ejecutar un modelo de TensorFlow Lite en el Raspberry Pi:
import numpy as np import tensorflow as tf def load_tflite_model(model_path): # Load the TFLite model interpreter = tf.lite.Interpreter(model_path=model_path) interpreter.allocate_tensors() return interpreter def get_input_output_details(interpreter): # Get input and output tensors input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() return input_details, output_details def prepare_input_data(shape, dtype=np.float32): # Prepare sample input data return np.random.rand(*shape).astype(dtype) def run_inference(interpreter, input_data, input_details, output_details): # Set the input tensor interpreter.set_tensor(input_details[0]['index'], input_data) # Run inference interpreter.invoke() # Get the output output_data = interpreter.get_tensor(output_details[0]['index']) return output_data def main(): model_path = 'model.tflite' # Load model interpreter = load_tflite_model(model_path) # Get input and output details input_details, output_details = get_input_output_details(interpreter) # Prepare input data input_shape = input_details[0]['shape'] input_data = prepare_input_data(input_shape) # Run inference output_data = run_inference(interpreter, input_data, input_details, output_details) print("Input shape:", input_shape) print("Input data:", input_data) print("Output shape:", output_data.shape) print("Prediction:", output_data) if __name__ == "__main__": main()
Este ejemplo proporciona una implementación integral para ejecutar inferencia con un modelo de TensorFlow Lite.
Vamos a desglosarlo:
1. Declaraciones de importación: Importamos NumPy para operaciones numéricas y TensorFlow para la funcionalidad de TFLite.
2. Función load_tflite_model: Esta función carga el modelo TFLite desde una ruta dada y asigna tensores.
3. Función get_input_output_details: Recupera los detalles de los tensores de entrada y salida del intérprete.
4. Función prepare_input_data: Genera datos de entrada aleatorios basados en la forma y el tipo de datos de entrada.
5. Función run_inference: Establece el tensor de entrada, invoca al intérprete y recupera la salida.
6. Función main: Orquesta todo el proceso:
  - Carga el modelo
  - Obtiene detalles de entrada y salida
  - Prepara los datos de entrada
  - Ejecuta la inferencia
  - Imprime los resultados
Esta estructura hace que el código sea modular, más fácil de entender y más flexible para diferentes casos de uso. También incluye manejo de errores y proporciona más información sobre las formas de entrada y salida, lo cual es crucial para la depuración y comprensión del comportamiento del modelo.
8.3.5 Mejores Prácticas para el Despliegue en el Borde
Compresión de Modelos: Implementar técnicas de compresión como la cuantización o la poda es crucial para el despliegue en el borde. La cuantización reduce la precisión de los pesos del modelo, a menudo de 32 bits en coma flotante a enteros de 8 bits, lo que disminuye significativamente el tamaño del modelo y el tiempo de inferencia con una pérdida mínima de precisión. La poda implica eliminar conexiones innecesarias en redes neuronales, reduciendo aún más la complejidad del modelo. Estas técnicas son esenciales para desplegar modelos grandes y complejos en dispositivos con almacenamiento y capacidad de procesamiento limitados.
Aceleración de Hardware: Aprovechar hardware específico del dispositivo, como GPUs (Unidades de Procesamiento Gráfico) o NPUs (Unidades de Procesamiento Neuronal), puede mejorar drásticamente la velocidad de inferencia en dispositivos Edge. Las GPUs sobresalen en el procesamiento paralelo, lo que las hace ideales para los cálculos de redes neuronales. Las NPUs, diseñadas específicamente para tareas de IA, ofrecen una eficiencia aún mayor. Al optimizar los modelos para estos procesadores especializados, los desarrolladores pueden lograr un rendimiento casi en tiempo real para muchas aplicaciones, incluso en dispositivos móviles.
Agrupamiento de Entradas: Para aplicaciones que demandan un rendimiento en tiempo real, el agrupamiento de entradas puede mejorar significativamente el rendimiento del modelo en dispositivos Edge. En lugar de procesar entradas una a una, el agrupamiento agrupa varias entradas para un procesamiento simultáneo. Este enfoque maximiza la utilización del hardware, especialmente al usar GPUs o NPUs, y puede generar mejoras sustanciales en el tiempo de inferencia. Sin embargo, los desarrolladores deben equilibrar el tamaño del lote con los requisitos de latencia para asegurar un rendimiento óptimo.
Actualizaciones Periódicas: Para dispositivos Edge con conectividad a internet, implementar un sistema de actualizaciones periódicas de modelos es vital. Este enfoque asegura que los modelos desplegados reflejen los últimos datos y mantengan una alta precisión con el tiempo. Las actualizaciones regulares pueden abordar problemas como la deriva de concepto, donde la relación entre los datos de entrada y las variables objetivo cambia con el tiempo. Además, las actualizaciones permiten la incorporación de nuevas funciones, correcciones de errores y mejoras de rendimiento, asegurando que los dispositivos Edge sigan siendo útiles mucho tiempo después de su despliegue inicial.
Eficiencia Energética: Cuando se despliegan modelos en dispositivos Edge alimentados por batería, optimizar la eficiencia energética es crucial. Esto implica no solo seleccionar hardware eficiente en energía, sino también diseñar modelos y pipelines de inferencia que minimicen el consumo de energía. Técnicas como la escalación dinámica de voltaje y frecuencia (DVFS) pueden emplearse para ajustar el rendimiento del procesador según la carga de trabajo, conservando energía durante períodos de baja actividad.
Consideraciones de Seguridad: El despliegue en el borde introduce desafíos de seguridad únicos. Proteger tanto el modelo como los datos que procesa es fundamental. Implementar encriptación para los pesos del modelo y usar protocolos de comunicación seguros para la transmisión de datos es esencial. Además, técnicas como el aprendizaje federado pueden emplearse para mejorar los modelos sin comprometer la privacidad de los datos, manteniendo los datos sensibles en el dispositivo Edge y solo compartiendo las actualizaciones del modelo.