InterpreterApi

interface publique InterpreterApi
Sous-classes indirectes connues

Interface vers l'interpréteur de modèle TensorFlow Lite, à l'exclusion des méthodes expérimentales.

Une instance InterpreterApi encapsule un modèle TensorFlow Lite pré-entraîné, dans lequel sont exécutées pour l'inférence de modèle.

Par exemple, si un modèle n'accepte qu'une seule entrée et ne renvoie qu'une seule sortie: 

try (InterpreterApi interpreter =
     new InterpreterApi.create(file_of_a_tensorflowlite_model)) {
   interpreter.run(input, output);
 }

Si un modèle accepte plusieurs entrées ou sorties: 

Object[] inputs = {input0, input1, ...};
 Map<Integer, Object> map_of_indices_to_outputs = new HashMap<>();
 FloatBuffer ith_output = FloatBuffer.allocateDirect(3 * 2 * 4);  // Float tensor, shape 3x2x4.
 ith_output.order(ByteOrder.nativeOrder());
 map_of_indices_to_outputs.put(i, ith_output);
 try (InterpreterApi interpreter =
     new InterpreterApi.create(file_of_a_tensorflowlite_model)) {
   interpreter.runForMultipleInputsOutputs(inputs, map_of_indices_to_outputs);
 }

Si un modèle accepte ou produit des Tensors de chaîne: 

String[] input = {"foo", "bar"};  // Input tensor shape is [2].
 String[][] output = new String[3][2];  // Output tensor shape is [3, 2].
 try (InterpreterApi interpreter =
     new InterpreterApi.create(file_of_a_tensorflowlite_model)) {
   interpreter.runForMultipleInputsOutputs(input, output);
 }

Notez qu'il existe une distinction entre les formes [] et shape[1]. Pour Tensor de chaîne scalaire résultats: 

String[] input = {"foo"};  // Input tensor shape is [1].
 ByteBuffer outputBuffer = ByteBuffer.allocate(OUTPUT_BYTES_SIZE);  // Output tensor shape is [].
 try (Interpreter interpreter = new Interpreter(file_of_a_tensorflowlite_model)) {
   interpreter.runForMultipleInputsOutputs(input, outputBuffer);
 }
 byte[] outputBytes = new byte[outputBuffer.remaining()];
 outputBuffer.get(outputBytes);
 // Below, the `charset` can be StandardCharsets.UTF_8.
 String output = new String(outputBytes, charset);

L'ordre des entrées et des sorties est déterminé lors de la conversion du modèle TensorFlow en TensorFlow Lite avec Toco, tout comme les formes par défaut des entrées.

Lorsque les entrées sont fournies sous forme de tableaux (multidimensionnels), le ou les Tensors d'entrée correspondants être implicitement redimensionné en fonction de la forme de ce tableau. Lorsque les entrées sont fournies en tant que types Buffer, aucun redimensionnement implicite n'est effectué. l'appelant doit s'assurer que la taille en octets Buffer correspond soit à celle du Tensor correspondant, soit à la première redimensionner le Tensor via resizeInput(int, int[]). Les informations sur la forme et le type de Tensor peuvent obtenu via la classe Tensor, disponible via getInputTensor(int) et getOutputTensor(int).

AVERTISSEMENT:InterpreterApi instances ne sont pas sécurisées.

AVERTISSEMENT:Une instance InterpreterApi possède des ressources qui doivent être explicitement libérées en appelant close()

La bibliothèque TFLite est basée sur l'API 19 du NDK. Cela peut fonctionner pour les niveaux d'API Android inférieurs à 19, mais ce n'est pas garanti.

Classes imbriquées

classe InterpreterApi.Options Classe d'options permettant de contrôler le comportement de l'interpréteur lors de l'exécution.

Méthodes publiques

abstrait vide
allocateTensors()
Met à jour explicitement les allocations pour tous les Tensors, si nécessaire.
abstrait vide
close()
Libérez les ressources associées à l'instance InterpreterApi.
statique InterpreterApi
create(options File modelFile, InterpreterApi.Options)
Construit une instance InterpreterApi à l'aide du modèle et des options spécifiés.
statique InterpreterApi
create(options byteBuffer ByteBuffer, InterpreterApi.Options)
Construit une instance InterpreterApi à l'aide du modèle et des options spécifiés.
abstrait entier
getInputIndex(Chaîne opName)
Récupère l'index d'une entrée en fonction du nom d'opération de l'entrée.
abstrait Tensor
getInputTensor(int inputIndex)
Récupère le Tensor associé à l'index d'entrée fourni.
abstrait entier
getInputTensorCount()
Récupère le nombre de Tensors d'entrée.
abstrait Version longue
getLastNativeInferenceDurationNanoseconds()
Renvoie la durée d'inférence native.
abstrait entier
getOutputIndex(Chaîne opName)
Récupère l'index d'une sortie en fonction du nom d'opération de la sortie.
abstrait Tensor
getOutputTensor(int outputIndex)
Récupère le Tensor associé à l'index de sortie fourni.
abstrait entier
getOutputTensorCount()
Récupère le nombre de Tensors de sortie.
abstrait vide
resizeInput(int idx, int[] dims, boolean strict)
Redimensionne l'entrée IDx-ième du modèle natif en fonction des assombrissements donnés.
abstrait vide
resizeInput(int idx, int[] dims)
Redimensionne l'entrée IDx-ième du modèle natif en fonction des assombrissements donnés.
abstrait vide
run(entrée d'objet, sortie d'objet)
Exécute l'inférence de modèle si le modèle n'accepte qu'une seule entrée et ne fournit qu'une seule sortie.
abstrait vide
runForMultipleInputsOutputs(entrées Object[], Map <Integer, objets> sorties)
Exécute l'inférence de modèle si le modèle accepte plusieurs entrées ou renvoie plusieurs sorties.

Méthodes héritées

Méthodes publiques

<ph type="x-smartling-placeholder"></ph> public abstrait vide allocateTensors ()

Met à jour explicitement les allocations pour tous les Tensors, si nécessaire.

Cela propagera les formes et les allocations de mémoire pour les Tensors dépendants en utilisant l'entrée forme(s) de Tensor telles qu'elles sont fournies.

Remarque: Cet appel est *purement facultatif*. L'allocation de Tensor s'effectue automatiquement si des Tensors d'entrée ont été redimensionnés. Cet appel est particulièrement utile pour déterminer pour tous les Tensors de sortie avant d'exécuter le graphe, par exemple 

 interpreter.resizeInput(0, new int[]{1, 4, 4, 3}));
 interpreter.allocateTensors();
 FloatBuffer input = FloatBuffer.allocate(interpreter.getInputTensor(0).numElements());
 // Populate inputs...
 FloatBuffer output = FloatBuffer.allocate(interpreter.getOutputTensor(0).numElements());
 interpreter.run(input, output)
 // Process outputs...

Remarque: Certains graphiques ont des sorties de forme dynamique. Dans ce cas, il est possible que la forme de sortie se propagent entièrement jusqu'à l'exécution de l'inférence.

Génère
IllegalStateException si les Tensors du graphique n'ont pas pu être alloués.

<ph type="x-smartling-placeholder"></ph> public abstrait vide fermer ()

Libérez les ressources associées à l'instance InterpreterApi.

<ph type="x-smartling-placeholder"></ph> public statique InterpreterApi créer (Fichier modelFile, options InterpreterApi.Options)

Construit une instance InterpreterApi à l'aide du modèle et des options spécifiés. Le modèle sera chargé à partir d'un fichier.

Paramètres
modelFile Fichier contenant un modèle TF Lite pré-entraîné.
options Ensemble d'options permettant de personnaliser le comportement de l'interprète.
Génère
IllegalArgumentException Si modelFile n'encode pas de code TensorFlow Lite valide dans un modèle de ML.

<ph type="x-smartling-placeholder"></ph> public statique InterpreterApi créer (ByteBuffer byteBuffer, options InterpreterApi.Options)

Construit une instance InterpreterApi à l'aide du modèle et des options spécifiés. Le modèle sera lu à partir d'un ByteBuffer.

Paramètres
byteBuffer Un modèle TF Lite pré-entraîné, sous forme sérialisée binaire. La classe ByteBuffer doit ne peut pas être modifié après la construction d'une instance InterpreterApi. Le ByteBuffer peut être soit un MappedByteBuffer qui mappe la mémoire d'un fichier de modèle, soit directe ByteBuffer de nativeOrder(), qui contient le contenu en octets d'un modèle.
options Ensemble d'options permettant de personnaliser le comportement de l'interprète.
Génère
IllegalArgumentException Si byteBuffer n'est pas de type MappedByteBuffer ni de type la valeur ByteBuffer directe de nativeOrder.

<ph type="x-smartling-placeholder"></ph> public abstrait entier getInputIndex (Chaîne opName)

Récupère l'index d'une entrée en fonction du nom d'opération de l'entrée.

Paramètres
opName
Génère
IllegalArgumentException Si opName ne correspond à aucune entrée du modèle utilisé pour initialiser l'interpréteur.

<ph type="x-smartling-placeholder"></ph> public abstrait Tensor getInputTensor (int inputIndex)

Récupère le Tensor associé à l'index d'entrée fourni.

Paramètres
inputIndex
Génère
IllegalArgumentException si la valeur de inputIndex est négative ou n'est pas inférieure à la valeur le nombre d'entrées du modèle.

<ph type="x-smartling-placeholder"></ph> public abstrait entier getInputTensorCount ()

Récupère le nombre de Tensors d'entrée.

<ph type="x-smartling-placeholder"></ph> public abstrait Version longue getLastNativeInferenceDurationNanoseconds ()

Renvoie la durée d'inférence native.

Génère
IllegalArgumentException si le modèle n'est pas initialisé par l'interpréteur.

<ph type="x-smartling-placeholder"></ph> public abstrait entier getOutputIndex (Chaîne opName)

Récupère l'index d'une sortie en fonction du nom d'opération de la sortie.

Paramètres
opName
Génère
IllegalArgumentException Si opName ne correspond à aucune sortie du modèle utilisé pour initialiser l'interpréteur.

<ph type="x-smartling-placeholder"></ph> public abstrait Tensor getOutputTensor (int outputIndex)

Récupère le Tensor associé à l'index de sortie fourni.

Remarque: Les détails du Tensor de sortie (par exemple, la forme) peuvent ne pas être entièrement renseignés avant l'inférence s'exécute. Si vous avez besoin de mettre à jour les détails *avant* d'exécuter l'inférence (par exemple, après avoir redimensionné un Tensor d'entrée, ce qui peut invalider la forme des Tensors de sortie), utilisez allocateTensors() pour déclencher explicitement l'allocation et la propagation des formes. Notez que, pour les graphiques avec des formes de sortie, qui dépendent des *valeurs* d'entrée, il est possible que la forme de sortie ne soit pas entièrement déterminée avant que lors de l'exécution de l'inférence.

Paramètres
outputIndex
Génère
IllegalArgumentException si la valeur de outputIndex est négative ou n'est pas inférieure à la valeur le nombre de sorties du modèle.

<ph type="x-smartling-placeholder"></ph> public abstrait entier getOutputTensorCount ()

Récupère le nombre de Tensors de sortie.

<ph type="x-smartling-placeholder"></ph> public abstrait vide resizeInput (int idx, int[] dims, boolean strict)

Redimensionne l'entrée IDx-ième du modèle natif en fonction des assombrissements donnés.

Lorsque "strict" est défini sur "True", seules les dimensions inconnues peuvent être redimensionnées. Les dimensions inconnues sont indiquée par "-1" dans le tableau renvoyé par "Tensor.shapeSignature()".

Paramètres
IDX
baisse la luminosité
strict
Génère
IllegalArgumentException Si idx est négatif ou n'est pas inférieur au nombre d'entrées du modèle, ou si une erreur se produit lors du redimensionnement de l'entrée "idx-ième". De plus, l'erreur se produit lors d'une tentative de redimensionnement d'un Tensor avec des dimensions fixes lorsque "strict" est défini sur "True".

<ph type="x-smartling-placeholder"></ph> public abstrait vide resizeInput (int idx, int[] dims)

Redimensionne l'entrée IDx-ième du modèle natif en fonction des assombrissements donnés.

Paramètres
IDX
baisse la luminosité
Génère
IllegalArgumentException Si idx est négatif ou n'est pas inférieur au nombre d'entrées du modèle, ou si une erreur se produit lors du redimensionnement de l'entrée "idx-ième".

<ph type="x-smartling-placeholder"></ph> public abstrait vide courir (entrée d'objet, sortie d'objet)

Exécute l'inférence de modèle si le modèle n'accepte qu'une seule entrée et ne fournit qu'une seule sortie.

Avertissement: L'API est plus efficace si un Buffer (de préférence direct, mais non requis) est utilisé comme type de données d'entrée/sortie. Vous pouvez utiliser Buffer pour alimenter et récupérer primitives pour de meilleures performances. Les types Buffer concrets suivants sont compatibles:

  • ByteBuffer : compatible avec n'importe quel type de Tensor primitif sous-jacent.
  • FloatBuffer : compatible avec les Tensors à virgule flottante.
  • IntBuffer : compatible avec les Tensors int32.
  • LongBuffer : compatible avec les Tensors int64.
Notez que les types booléens ne sont acceptés que sous forme de tableaux, pas de valeurs Buffer, ou d'entrées scalaires.

Paramètres
entrée un tableau ou un tableau multidimensionnel, ou une Buffer de types primitifs y compris int, float, long et byte. Buffer est le moyen privilégié pour transmettre des des données d'entrée pour les types primitifs, alors que les types chaîne nécessitent l'utilisation de la méthode chemin d'entrée du tableau. Lorsqu'un Buffer est utilisé, son contenu doit rester inchangé jusqu'à l'inférence de modèle est terminée, et l'appelant doit s'assurer que Buffer se trouve au la position de lecture appropriée. Une valeur null n'est autorisée que si l'appelant utilise un Delegate qui permet l'interopérabilité du handle de tampon, et un tel tampon a été lié au entrée Tensor.
output un tableau multidimensionnel de données de sortie ou une Buffer de types primitifs y compris int, float, long et byte. Lorsqu'un Buffer est utilisé, l'appelant doit s'assurer que la position d'écriture appropriée est définie. Une valeur nulle est autorisée et est utile pour Dans certains cas, par exemple, si l'appelant utilise un Delegate qui autorise le handle de tampon et l'interopérabilité, et ce tampon a été lié à la sortie Tensor (voir aussi Interpreter.Options#setAllowBufferHandleOutput(boolean)). Ou, si le graphe présente des sorties de forme dynamique et que l'appelant doit interroger la forme Tensor de sortie après l'appel de l'inférence, en récupérant les données directement à partir de la sortie Tensor (via Tensor.asReadOnlyBuffer()).
Génère
IllegalArgumentException si input est nul ou vide, ou si une erreur se produit lorsque lors de l'exécution de l'inférence.
IllegalArgumentException (EXPÉRIMENTAL, susceptible d'être modifié) si l'inférence est interrompue par setCancelled(true).

<ph type="x-smartling-placeholder"></ph> public abstrait vide runForMultipleInputsOutputs (entrées Objet[], Carte<Entier, Sorties d'objet>)

Exécute l'inférence de modèle si le modèle accepte plusieurs entrées ou renvoie plusieurs sorties.

Avertissement: L'API est plus efficace si Buffer (de préférence directe, mais non obligatoire) sont utilisés comme types de données d'entrée/sortie. Vous pouvez utiliser Buffer pour alimenter et récupérer primitives pour de meilleures performances. Les types Buffer concrets suivants sont compatibles:

  • ByteBuffer : compatible avec n'importe quel type de Tensor primitif sous-jacent.
  • FloatBuffer : compatible avec les Tensors à virgule flottante.
  • IntBuffer : compatible avec les Tensors int32.
  • LongBuffer : compatible avec les Tensors int64.
Notez que les types booléens ne sont acceptés que sous forme de tableaux, pas de valeurs Buffer, ou d'entrées scalaires.

Remarque: Les valeurs null pour les éléments individuels de inputs et outputs sont autorisé uniquement si l'appelant utilise un Delegate qui autorise l'interopérabilité du gestionnaire de tampon, et un tel tampon a été lié aux Tensor d'entrée ou de sortie correspondants.

Paramètres
cachées un tableau de données d'entrée. Les entrées doivent être dans le même ordre que les entrées de la dans un modèle de ML. Chaque entrée peut être un tableau ou un tableau multidimensionnel, ou une Buffer de types primitifs dont int, float, long et byte. Buffer est l'option à privilégier pour transmettre des données d'entrée volumineuses, alors que les types "string" (chaîne) nécessitent l'utilisation d'un tableau (multidimensionnel). chemin d'entrée. Lorsque Buffer est utilisé, son contenu ne doit pas être modifié jusqu'à ce que le modèle l'inférence est effectuée, et l'appelant doit s'assurer que Buffer se trouve au niveau en lecture seule.
sorties Une carte mappant des index de sortie à des tableaux multidimensionnels de données de sortie ou à des Buffer de types primitifs, y compris int, float, long et byte. Il suffit de garder les entrées des sorties à utiliser. Lorsqu'un Buffer est utilisé, l'appelant doit s'assurer que la position d'écriture appropriée est définie. La carte peut être vide dans les cas où : les poignées de tampon sont utilisées pour les données de Tensor de sortie, ou dans les cas où les sorties sont dynamiquement et l'appelant doit interroger la forme Tensor de sortie une fois l'inférence terminée en récupérant les données directement à partir du Tensor de sortie (via Tensor.asReadOnlyBuffer()).
Génère
IllegalArgumentException Si inputs est nul ou vide, si outputs est ou si une erreur se produit lors de l'exécution de l'inférence.