LiteRT Next est un nouvel ensemble d'API qui améliore LiteRT, en particulier en termes d'accélération matérielle et de performances pour les applications de ML et d'IA sur l'appareil. Les API sont disponibles en version alpha en Kotlin et en C++.
L'API LiteRT Next Compiled Model s'appuie sur l'API TensorFlow Lite Interpreter et simplifie le processus de chargement et d'exécution du modèle pour le machine learning sur l'appareil. Les nouvelles API offrent une nouvelle méthode simplifiée pour utiliser l'accélération matérielle, ce qui élimine la nécessité de gérer les FlatBuffers de modèle, l'interopérabilité des tampons d'E/S et les délégués. Les API LiteRT Next ne sont pas compatibles avec les API LiteRT. Pour utiliser les fonctionnalités de LiteRT Next, consultez le guide de démarrage.
Pour obtenir des exemples d'implémentations de LiteRT Next, consultez les applications de démonstration suivantes:
Guide de démarrage rapide
Pour exécuter une inférence avec les API LiteRT Next, procédez comme suit:
- Chargez un modèle compatible.
- Allouez les tampons de tensor d'entrée et de sortie.
- Appelez le modèle compilé.
- Lire les inférences dans un tampon de sortie.
Les extraits de code suivants présentent une implémentation de base de l'ensemble du processus en Kotlin et en C++.
C++
// Load model and initialize runtime
LITERT_ASSIGN_OR_RETURN(auto model, Model::CreateFromFile("mymodel.tflite"));
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
CompiledModel::Create(env, model, kLiteRtHwAcceleratorCpu));
// Preallocate input/output buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers, compiled_model.CreateInputBuffers());
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());
// Fill the first input
float input_values[] = { /* your data */ };
input_buffers[0].Write<float>(absl::MakeConstSpan(input_values, /*size*/));
// Invoke
compiled_model.Run(input_buffers, output_buffers);
// Read the output
std::vector<float> data(output_data_size);
output_buffers[0].Read<float>(absl::MakeSpan(data));
Kotlin
// Load model and initialize runtime
val model =
CompiledModel.create(
context.assets,
"mymodel.tflite",
CompiledModel.Options(Accelerator.CPU)
)
// Preallocate input/output buffers
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()
// Fill the first input
inputBuffers[0].writeFloat(FloatArray(data_size) { data_value /* your data */ })
// Invoke
model.run(inputBuffers, outputBuffers)
// Read the output
val outputFloatArray = outputBuffers[0].readFloat()
Pour en savoir plus, consultez les guides Premiers pas avec Kotlin et Premiers pas avec C++.
Principales fonctionnalités
LiteRT Next offre les principaux avantages et fonctionnalités suivants:
- Nouvelle API LiteRT: simplifiez le développement grâce à la sélection automatique de l'accélérateur, à l'exécution asynchrone et à la gestion efficace des tampons d'E/S.
- Performances GPU de pointe: utilisez l'accélération GPU de pointe pour le ML sur l'appareil. La nouvelle interopérabilité des tampons permet la copie zéro et minimise la latence entre les différents types de tampons de GPU.
- Inférence d'IA générative supérieure: permet l'intégration la plus simple avec les meilleures performances pour les modèles d'IA générative.
- Accélération NPU unifiée: offre un accès fluide aux NPU des principaux fournisseurs de chipsets avec une expérience de développement cohérente. L'accélération NPU LiteRT est disponible via un programme en accès anticipé.
Principales améliorations
LiteRT Next (API de modèle compilé) contient les principales améliorations suivantes sur LiteRT (API de l'interprète TensorFlow Lite). Pour obtenir un guide complet sur la configuration de votre application avec LiteRT Next, consultez le guide de démarrage.
- Utilisation de l'accélérateur: l'exécution de modèles sur un GPU avec LiteRT nécessite la création explicite de délégués, les appels de fonction et les modifications de graphiques. Avec LiteRT Next, il vous suffit de spécifier l'accélérateur.
- Interopérabilité des tampons matériels natifs: LiteRT ne fournit pas l'option de tampons et force toutes les données via la mémoire du processeur. Avec LiteRT Next, vous pouvez transmettre des tampons matériels Android (AHWB), des tampons OpenCL, des tampons OpenGL ou d'autres tampons spécialisés.
- Exécution asynchrone: LiteRT Next est fourni avec une API asynchrone repensée, qui fournit un véritable mécanisme asynchrone basé sur des barrières de synchronisation. Cela permet d'accélérer les temps d'exécution globaux grâce à l'utilisation de divers matériels (CPU, GPU, CPU et NPU, par exemple) pour différentes tâches.
- Chargement du modèle: LiteRT Next ne nécessite pas d'étape de compilation distincte lors du chargement d'un modèle.