Bienvenue dans la présentation de LiteRT

LiteRT est le framework Google sur l'appareil pour le déploiement de ML et d'IA générative hautes performances sur les plates-formes Edge, à l'aide d'une conversion, d'un environnement d'exécution et d'une optimisation efficaces.

LiteRT 2.x contient l'API d'exécution la plus récente, l'API CompiledModel, qui améliore l'API Interpreter (également appelée API TensorFlow Lite), notamment grâce à l'accélération matérielle et aux performances globales pour les applications de ML et d'IA sur l'appareil. L'API CompiledModel est disponible en version bêta, à la fois en Kotlin et en C++.

Principales fonctionnalités de LiteRT

Modèles compatibles

LiteRT permet de convertir facilement les frameworks Pytorch, TensorFlow et JAX au format .tflite ou .litertlm.

Simplifier le développement avec LiteRT

Sélection automatique de l'accélérateur par rapport à la création explicite de délégués. Distribution simple de l'exécution et des modèles NPU. Gestion efficace des tampons d'E/S et exécution asynchrone pour des performances supérieures.

Performances GPU exceptionnelles

Optimisé par ML Drift, qui prend désormais en charge les modèles de ML et d'IA générative sur les API GPU.

Accélération NPU unifiée

Accélérez votre modèle grâce à un accès simplifié au NPU des principaux fournisseurs de chipsets.

Prise en charge simplifiée des LLM avec LiteRT

Vous pouvez utiliser LiteRT-LM, qui est optimisé par LiteRT. LiteRT-LM est compatible avec les derniers LLM et des fonctionnalités utiles telles que la multimodalité, le décodage contraint, etc.

Workflow de développement

LiteRT exécute des inférences entièrement sur l'appareil (Android, iOS, Web, IoT, ordinateur de bureau/portable). Quel que soit l'appareil, le workflow le plus courant est le suivant. Vous trouverez des liens vers des instructions plus détaillées.

Identifier la solution la plus adaptée au défi de ML

LiteRT offre aux utilisateurs un haut niveau de flexibilité et de personnalisation pour résoudre les problèmes de machine learning. Il convient donc aux utilisateurs qui ont besoin d'un modèle spécifique ou d'une implémentation spécialisée. Les utilisateurs qui recherchent des solutions prêtes à l'emploi peuvent préférer MediaPipe Tasks, qui fournit des solutions prêtes à l'emploi pour les tâches courantes de machine learning, comme la détection d'objets, la classification de texte et l'inférence LLM.

Obtenir et préparer le modèle

Un modèle LiteRT est représenté dans un format portable efficace appelé FlatBuffers, qui utilise l'extension de fichier .tflite.

Vous pouvez obtenir un modèle LiteRT de plusieurs manières :

• Obtenez un modèle pré-entraîné pour les charges de travail de ML populaires telles que la segmentation d'images, la détection d'objets, etc.

  L'approche la plus simple consiste à utiliser un modèle LiteRT déjà au format .tflite. Ces modèles ne nécessitent aucune étape de conversion supplémentaire.

  Type de modèle	Source du modèle pré-entraîné
  ML classique (format .tflite)	Consultez Kaggle ou HuggingFace , par exemple Modèles de segmentation d'images et Exemple d'application.
  IA générative (format .litertlm)	Page Hugging Face de LiteRT , par exemple Gemma Family

• Convertissez le modèle PyTorch, TensorFlow ou JAX de votre choix en modèle LiteRT si vous choisissez de ne pas utiliser de modèle pré-entraîné. [PRO USER]

  Framework de modèle	Exemples de modèles	Outil de conversion
  PyTorch	Hugging Face Torchvision	Lien
  TensorFlow	Modèles Kaggle Hugging Face	Lien
  Jax	Visage faisant un câlin	Lien

• Créez votre LLM pour l'optimiser davantage à l'aide de l'API Generative [UTILISATEUR PRO]

  Notre bibliothèque d'API génératives fournit des blocs de construction PyTorch intégrés pour composer des modèles Transformer tels que Gemma, TinyLlama et d'autres à l'aide d'abstractions adaptées aux mobiles, grâce auxquelles nous pouvons garantir la conversion et l'exécution performante sur notre environnement d'exécution mobile, LiteRT. Consultez la documentation de l'API Generative.

Quantification [UTILISATEUR PRO]

AI Edge Quantizer pour les développeurs avancés est un outil permettant de quantifier les modèles LiteRT convertis. Il vise à aider les utilisateurs avancés à obtenir des performances optimales sur les modèles gourmands en ressources (par exemple, d'IA générative).

Pour les modèles de machine learning et d'IA générative, consultez la documentation sur la quantification Ai-Edge.

Conditions préalables pour commencer

• Python 3.10 à 3.12
• Fichier de modèle .tflite
• Pour en savoir plus, consultez la section de la plate-forme concernée.

Intégrer le modèle à votre application sur les plates-formes Edge

Vous pouvez implémenter vos modèles LiteRT pour exécuter des inférences entièrement sur l'appareil sur les appareils Android, iOS, Web, IoT et de bureau. LiteRT contient des API pour Python, Java et Kotlin pour Android, Swift pour iOS et C++ pour les micro-appareils.

Utilisez les guides suivants pour implémenter un modèle LiteRT sur la plate-forme de votre choix :

*Bientôt disponible

Exemple de code Kotlin

// Load model and initialize runtime
val compiledModel = CompiledModel.create("/path/to/mymodel.tflite", CompiledModel.Options(Accelerator.CPU))

// Prepare I/O buffers and fill in the data
val inputBuffers = compiledModel.createInputBuffers()
inputBuffers.get(0).writeFloat(input0)
inputBuffers.get(1).writeFloat(input1)

val outputBuffers = compiledModel.createOutputBuffers()

// Execute model
compiledModel.run(inputBuffers, outputBuffers)

// Access model output
val output = outputBuffers.get(0).readFloat()

inputBuffers.forEach { it.close() }
outputBuffers.forEach { it.close() }
compiledModel.close()

Exemple de code C++

LITERT_ASSIGN_OR_RETURN(auto env, GetEnvironment());
LITERT_ASSIGN_OR_RETURN(auto options, GetOptions());
LITERT_ASSIGN_OR_RETURN(
      auto compiled_model,
      CompiledModel::Create(env, "/path/to/mymodel.tflite", options));
LITERT_ASSIGN_OR_RETURN(auto input_buffers,compiled_model.CreateInputBuffers(signature_index));
LITERT_ASSIGN_OR_RETURN(auto output_buffers,compiled_model.CreateOutputBuffers(signature_index));
LITERT_ABORT_IF_ERROR(input_buffers[0].Write(input0));
LITERT_ABORT_IF_ERROR(input_buffers[1].Write(input1));

LITERT_ABORT_IF_ERROR(compiled_model.Run(signature_index, input_buffers, output_buffers));

LITERT_ABORT_IF_ERROR(output_buffers[0].Read(output0));

Choisir un backend

Le moyen le plus simple d'intégrer des backends dans LiteRT consiste à s'appuyer sur l'intelligence intégrée du runtime. Avec les dernières modifications, LiteRT simplifie considérablement la configuration en permettant de spécifier le backend cible en tant qu'option.

L'objet CompiledModel est au cœur de LiteRT v2.x. Lorsque vous chargez un modèle, LiteRT utilise le matériel disponible du système et la logique de priorité interne pour sélectionner le backend optimal sans configuration manuelle. Pour en savoir plus, consultez le backend.

Documentation et assistance supplémentaires

Application exemple LiteRT v2.x Consultez l'application exemple de segmentation d'images LiteRT.

Pour les utilisateurs existants de TensorFlow Lite Consultez le guide de migration.

Couverture Ops Opérateurs compatibles

Modèles LLM compatibles LiteRT Hugging Face et API Gen : exemples

Outils Page des outils LiteRT : performances, profilage, rapports d'erreurs, etc.