Pouvons-nous prédire les légendes d'images en utilisant google-ml-engine?

Question

Les échantillons de recensement et de fleurs montrent comment prédire les étiquettes de classe en utilisant le moteur ml de Google. Pouvons-nous déployer notre propre modèle pour générer une légende d'image?

Si oui, comment fonctionne la prédiction? Quel sera le format de la réponse de prédiction? Pour être plus précis, dans la pièce jointe ci-dessous, le sous-tableau des probabilités donne l'indice et le hasard de chaque classe. Si nous utilisons un modèle de légende d'image, à quoi ressemblera la réponse de prédiction?

Pièce jointe: http://boaloysius.me/sites/default/files/inline-images/predict1_0.png

Answer 1

ML-Cloud Engine permet de déployer presque tous les modèles de tensorflow vous êtes en mesure d'exporter. Pour un tel modèle, vous définissez vos entrées et vos sorties et c'est ce qui dicte la forme des demandes et des réponses.

Je pense qu'il pourrait être utile de comprendre cela en parcourant un exemple. Vous pouvez imaginer l'exportation d'un modèle comme ceci:

def my_model(image_in): 
    # Construct an inference graph for predicting captions 
    # 
    # image_in is a tensor/array with shape=(None,) and dtype=string 
    # Meaning, a batch of raw image bytes. 

    ... Do your interesting stuff here ...  

    # caption_out is a tensor/matrix with shape=(None, MAX_WORDS) and 
    # dtype=tf.string), that is, you will be returning a batch 
    # of captions, one per input image, one word per column with 
    # padding when the number of words to output is < MAX_WORDS 
    return caption_out 

image_in = tf.placeholder(shape=(None,), dtype=tf.string) 
caption_out = my_model(image_in) 

inputs = {"image_bytes": tf.saved_model.utils.build_tensor_info(image_in} 
outputs = {"caption": tf.saved_model.utils.build_tensor_info(caption_out)} 

signature = tf.saved_model.signature_def_utils.build_signature_def(
     inputs=inputs, 
     outputs=outputs, 
     method_name='tensorflow/serving/predict' 
) 

Après avoir exporté ce modèle (cf this post), vous construire une requête JSON comme ceci:

{ 
    "instances": [ 
    { 
     "image_bytes": { 
     "b64": <base64_encoded_image1> 
     } 
    }, 
    { 
     "image_bytes": { 
     "b64": <base64_encoded_image2> 
     } 
    } 
    ] 
} 

Analysons la demande. Premièrement, nous enverrons au service un lot d'images. Toutes les demandes sont un objet JSON avec un attribut de tableau appelé "instances"; chaque entrée dans le tableau est une instance pour alimenter le graphique pour la prédiction. Notez que c'est la raison pour laquelle nous devons définir la dimension la plus externe sur None sur les modèles exportés - ils doivent être capables de gérer des lots de tailles variables.

Chaque entrée de la matrice est elle-même un objet JSON, où les attributs sont les clés du input dict que nous avons défini lors de l'exportation du modèle. Dans ce cas, nous avons seulement défini image_bytes. Parce que image_bytes est une chaîne d'octets, nous devons coder en base64 les données, ce que nous faisons en passant des objets JSON du formulaire {"b64": <data>}. Si nous voulions envoyer plus d'une image au service, nous pourrions ajouter une entrée similaire pour chaque image au tableau instance.

Maintenant, une réponse de l'échantillon de JSON pour cet exemple pourrait ressembler à:

{ 
    "predictions": [ 
    { 
     "caption": [ 
     "the", 
     "quick", 
     "brown", 
     "", 
     "", 
     "" 
     ] 
    }, 
    { 
     "caption": [ 
     "A", 
     "person", 
     "on", 
     "the", 
     "beach", 
     "" 
     ] 
    } 
    ] 
} 

Toutes les réponses sont des objets JSON avec un attribut d'une valeur tableau qu'on appelle « prédictions ». Chaque élément du tableau est la prédiction associée à l'entrée correspondante dans le tableau instances de la requête.

Chaque entrée de la matrice est un objet JSON dont les attributs sont déterminés par les clés du outputs dict que nous avons exportées précédemment. Dans ce cas, nous avons une sortie unique par entrée appelée caption. Notez que le tenseur source de la légende caption_out est en fait une matrice, où le nombre de lignes est égal au nombre d'instances envoyées au service et le nombre de colonnes que nous avons définies comme étant constantes. Cependant, au lieu de renvoyer la matrice, le service renvoie indépendamment chaque ligne de la matrice en tant qu'entrées dans le tableau prediction. La deuxième dimension de la matrice était une certaine constante, et probablement le modèle lui-même tamponnera des mots supplémentaires comme la chaîne vide (comme décrit ci-dessus).

Une note très importante: dans les exemples ci-dessus, j'ai montré les corps de requête/réponse JSON bruts.À partir de votre message, il est évident que vous utilisez le client générique de Google qui analyse la réponse et ajoute une structure autour de lui, en particulier, l'objet que vous imprimez enveloppe les prédictions dans les champs imbriqués [data] puis [modelData:protected].

Ma recommandation personnelle est de ne pas utiliser ce client pour le service et d'utiliser plutôt une bibliothèque de requêtes/réponses générique (avec la bibliothèque d'authentification de Google), mais comme tout fonctionne bien, vous pouvez utiliser tout ce qui fonctionne .