Fonctionnalités avancées de l’interface

Maintenant que nous pouvons construire et partager une interface de base, explorons quelques fonctionnalités plus avancées comme l’état, l’interprétation et l’authentification.

Utilisation de l’état pour faire persister les données

Gradio supporte l’état de session où les données persistent à travers plusieurs soumissions dans un chargement de page. L’état de session est utile pour construire des démos où vous souhaitez faire persister les données au fur et à mesure que l’utilisateur interagit avec le modèle (par exemple des chatbots). Notez que l’état de session ne partage pas les données entre les différents utilisateurs de votre modèle.

Pour stocker des données dans un état de session, vous devez faire trois choses :

• Passez un paramètre supplémentaire dans votre fonction, qui représente l’état de l’interface.
• A la fin de la fonction, renvoyer la valeur mise à jour de l’état comme une valeur de retour supplémentaire.
• Ajoutez les composants “state” input et “state” output lors de la création de votre Interface.

Voir l’exemple de chatbot ci-dessous :

import random

import gradio as gr


def chat(message, history):
    history = history or []
    if message.startswith("How many"):
        response = random.randint(1, 10)
    elif message.startswith("How"):
        response = random.choice(["Great", "Good", "Okay", "Bad"])
    elif message.startswith("Where"):
        response = random.choice(["Here", "There", "Somewhere"])
    else:
        response = "I don't know"
    history.append((message, response))
    return history, history


iface = gr.Interface(
    chat,
    ["text", "state"],
    ["chatbot", "state"],
    allow_screenshot=False,
    allow_flagging="never",
)
iface.launch()

Utilisation de l’interprétation pour comprendre les prédictions

La plupart des modèles d’apprentissage automatique sont des boîtes noires et la logique interne de la fonction est cachée à l’utilisateur final. Pour encourager la transparence, nous avons fait en sorte qu’il soit très facile d’ajouter l’interprétation à votre modèle en définissant simplement le mot-clé interprétation dans la classe Interface par défaut. Cela permet à vos utilisateurs de comprendre quelles parties de l’entrée sont responsables de la sortie. Jetez un coup d’œil à l’interface simple ci-dessous qui montre un classifieur d’images incluant l’interprétation :

import requests
import tensorflow as tf

import gradio as gr

inception_net = tf.keras.applications.MobileNetV2()  # charger le modèle

# Télécharger des étiquettes lisibles par l'homme pour ImageNet
response = requests.get("https://git.io/JJkYN")
labels = response.text.split("\n")


def classify_image(inp):
    inp = inp.reshape((-1, 224, 224, 3))
    inp = tf.keras.applications.mobilenet_v2.preprocess_input(inp)
    prediction = inception_net.predict(inp).flatten()
    return {labels[i]: float(prediction[i]) for i in range(1000)}


image = gr.Image(shape=(224, 224))
label = gr.Label(num_top_classes=3)

title = "Gradio Image Classifiction + Interpretation Example"
gr.Interface(
    fn=classify_image, inputs=image, outputs=label, interpretation="default", title=title
).launch()

Testez la fonction d’interprétation en soumettant une entrée puis en cliquant sur « Interpréter » sous le composant de sortie.

En plus de la méthode d’interprétation par défaut fournie par Gradio, vous pouvez également spécifier shap pour le paramètre interpretation et définir le paramètre num_shap. Ceci utilise l’interprétation basée sur Shapley, dont vous pouvez lire plus sur ici. Enfin, vous pouvez aussi passer votre propre fonction d’interprétation dans le paramètre interpretation. Vous trouverez un exemple dans la page de démarrage de Gradio ici.

Ajouter l’authentification

Vous pouvez vouloir ajouter une authentification à votre interface Gradio afin de contrôler qui peut accéder et utiliser votre démo.

L’authentification peut être ajoutée en fournissant une liste de tuples de nom d’utilisateur/mot de passe au paramètre auth de la méthode launch(). Pour une gestion plus complexe de l’authentification, vous pouvez passer une fonction qui prend un nom d’utilisateur et un mot de passe comme arguments, et retourne True pour permettre l’authentification, False sinon.

Prenons la démo de classification d’images ci-dessus et ajoutons l’authentification :

import requests
import tensorflow as tf

import gradio as gr

inception_net = tf.keras.applications.MobileNetV2()  # charger le modèle

# Télécharger des étiquettes lisibles par l'homme pour ImageNet
response = requests.get("https://git.io/JJkYN")
labels = response.text.split("\n")


def classify_image(inp):
    inp = inp.reshape((-1, 224, 224, 3))
    inp = tf.keras.applications.mobilenet_v2.preprocess_input(inp)
    prediction = inception_net.predict(inp).flatten()
    return {labels[i]: float(prediction[i]) for i in range(1000)}


image = gr.Image(shape=(224, 224))
label = gr.Label(num_top_classes=3)

title = "Gradio Image Classifiction + Interpretation Example"
gr.Interface(
    fn=classify_image, inputs=image, outputs=label, interpretation="default", title=title
).launch(auth=("admin", "pass1234"))

Ceci conclut notre plongée dans la classe Interface de Gradio. Comme nous l’avons vu, cette classe permet de créer facilement des démos d’apprentissage automatique en quelques lignes de code Python. Cependant, vous voudrez parfois personnaliser votre démo en changeant la mise en page ou en enchaînant plusieurs fonctions de prédiction. Ne serait-il pas agréable de pouvoir diviser l’interface en blocs personnalisables ? Heureusement, c’est possible ! C’est le sujet de la dernière section.