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.

La dernière version 2.x de LiteRT introduit l'API CompiledModel, une interface d'exécution moderne conçue pour maximiser l'accélération matérielle. Bien que l'API Interpreter (anciennement TensorFlow Lite) reste disponible pour la rétrocompatibilité, l'API CompiledModel est le choix recommandé pour les développeurs qui recherchent des performances de pointe dans les applications d'IA sur l'appareil.

Principales fonctionnalités de LiteRT

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. Gestion efficace des tampons d'E/S et exécution asynchrone pour des performances supérieures. Consultez la documentation sur l'inférence sur l'appareil.

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. Consultez la documentation sur l'accélération 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. Consultez la documentation sur l'accélération NPU.

Assistance LLM supérieure

LiteRT permet de déployer des modèles d'IA générative hautes performances sur les plates-formes mobiles, de bureau et Web. Consultez la documentation sur le déploiement de l'IA générative.

Compatibilité avec de nombreux frameworks de ML

LiteRT permet de convertir facilement les frameworks PyTorch, TensorFlow et JAX au format .tflite ou .litertlm. Consultez la documentation sur la conversion de modèles.

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 en savoir plus, consultez la documentation sur AI Edge Quantizer.

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

LiteRT vous permet d'exécuter des modèles de ML entièrement sur l'appareil avec des performances élevées sur les plates-formes Android, iOS, Web, Desktop et IoT.

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

Les extraits de code suivants montrent une implémentation de base en Kotlin et en C++.

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

// Preallocate input/output buffers
val inputBuffers = compiledModel.createInputBuffers()
val outputBuffers = compiledModel.createOutputBuffers()

// Fill the input buffer
inputBuffers.get(0).writeFloat(input0)
inputBuffers.get(1).writeFloat(input1)

// Invoke
compiledModel.run(inputBuffers, outputBuffers)

// Read the output
val output = outputBuffers.get(0).readFloat()

// Load model and initialize runtime
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));

// Preallocate input/output buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers,compiled_model.CreateInputBuffers(signature_index));
LITERT_ASSIGN_OR_RETURN(auto output_buffers,compiled_model.CreateOutputBuffers(signature_index));

// Fill the input buffer
LITERT_ABORT_IF_ERROR(input_buffers[0].Write(input0));
LITERT_ABORT_IF_ERROR(input_buffers[1].Write(input1));

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

// Read the output
LITERT_ABORT_IF_ERROR(output_buffers[0].Read(output0));

Choisir un accélérateur matériel

Le moyen le plus simple d'intégrer des backends dans LiteRT consiste à s'appuyer sur l'intelligence intégrée du runtime. Avec l'API CompiledModel, LiteRT simplifie considérablement la configuration en permettant de spécifier le backend cible en tant qu'option. Pour en savoir plus, consultez le guide sur l'inférence sur l'appareil.

Documentation et assistance supplémentaires

• Consultez le dépôt GitHub LiteRT-Samples pour découvrir d'autres exemples d'applications LiteRT.

• Si vous utilisez déjà TensorFlow Lite, consultez le guide de migration.

• La page Outils LiteRT pour les performances, le profilage, les rapports d'erreurs, etc.