Évaluer la qualité des phrases d'entraînement des intents Dialogflow

Ce tutoriel explique comment analyser et évaluer la qualité des phrases d'entraînement fournies aux intents de votre agent Dialogflow. Le but de cette analyse est d'éviter d'induire l'agent en erreur avec des phrases sans rapport avec les intents fournis ou plus pertinentes avec d'autres intents.

Vous allez utiliser une approche consistant à générer des représentations vectorielles continues sémantiques des phrases d'entraînement à l'aide du module Universal Sentence Encoder de TensorFlow Hub (tf.Hub). Vous allez ensuite calculer les métriques de cohésion et de séparation en fonction de la similarité entre les représentations vectorielles continues au sein d'un même intent et de différents intents. Le tutoriel identifie également les phrases d'entraînement prêtant à confusion, qui s'avèrent plus proches (dans l'espace de représentation vectorielle) d'intents autres que ceux fournis.

Le code de ce tutoriel est disponible dans ce notebook Colab. L'article suppose que vous maîtrisez les principes de base de Dialogflow. Pour en savoir plus sur Dialogflow, consultez ce tutoriel en plusieurs parties qui explique comment créer, sécuriser et procéder au scaling d'un chatbot à l'aide de Dialogflow Enterprise Edition sur Google Cloud.

Présentation

Dialogflow vous permet de créer des interfaces de conversation sur vos produits et services grâce à un puissant moteur de compréhension du langage naturel (NLU) afin de traiter et de comprendre les entrées en langage naturel. Voici quelques cas d'utilisation courants de Dialogflow :

  • Créer des bots de réservation pour les compagnies aériennes, les cinémas, etc.
  • Simplifier un système de commande de fast-food à domicile
  • Fournir un service client efficace grâce à des centres d'appels semi-automatisés

Bien que vous puissiez mettre en œuvre des flux de conversation complexes pour traiter un énoncé utilisateur, Dialogflow effectue fondamentalement les étapes suivantes :

  1. L'utilisateur pose des questions telles que "Quel est le montant total de ma facture pour le mois dernier ?".
  2. L'agent analyse l'entrée et la fait correspondre à un intent, tel que bill_value_inquiry.
  3. L'agent extrait également des informations sur les entités, comme "mois dernier".
  4. À l'aide de l'intent des entités extraites, l'agent appelle ensuite un fulfillment pour répondre à la requête de l'utilisateur.

Le tableau suivant décrit les concepts clés de la plate-forme Dialogflow.

Terme Description
agent Les agents peuvent être décrits comme des modules NLU intégrables à votre système. Lorsqu'une entrée utilisateur correspond à un intent de votre agent, celui-ci convertit les requêtes textuelles ou vocales des utilisateurs en données exploitables.
intent Lors d'une conversation, l'intent fait correspondre les entrées utilisateur à des réponses. Dans chaque intent, vous définissez des exemples d'énoncés utilisateur (phrases d'entraînement) pouvant le déclencher, les éléments à extraire de l'énoncé et la manière d'y répondre.
entités Bien que les intents permettent à l'agent de comprendre la motivation derrière une entrée utilisateur particulière, les entités servent à repérer des informations spécifiques que les utilisateurs mentionnent. Il est par exemple possible d'exploiter des adresses postales, des noms de produits ou des montants associés à des unités pour répondre à la requête de l'utilisateur.
fulfillment Le fulfillment vous permet d'utiliser les informations d'entité extraites par l'agent pour générer des réponses dynamiques ou déclencher des actions sur votre backend, intent par intent.

Pour en savoir plus sur les concepts de Dialogflow, consultez la documentation de Dialogflow.

Les intents s'avèrent indispensables dans un système Dialogflow, car ils associent la requête utilisateur à la logique métier appropriée afin d'y répondre. Par exemple, un système Dialogflow pour un fournisseur de services de télécommunications peut disposer d'intents tels que bill_value_inquiry, pay_bill, upgrade_contract, cancel_contract et add_service. Toutefois, pour que l'énoncé utilisateur (qu'il soit textuel ou vocal) soit mis en correspondance avec le bon intent, vous devez entraîner les intents à l'aide d'un ensemble de phrases d'entraînement pertinentes. Par exemple, pour un intent concernant la météo, vous pouvez utiliser des phrases d'entraînement telles que les suivantes :

  • "Comment est la météo actuellement ?"
  • "Quelle température fera-t-il au Caire demain ?"
  • "Dois-je emporter un parapluie avec moi à Zurich la semaine prochaine ?"

Lorsque vous créez plusieurs intents dans votre système, certaines phrases que vous fournissez peuvent prêter l'agent à confusion ou l'induire en erreur. Par exemple, une phrase qui s'avère plus pertinente pour un autre intent peut servir à entraîner le mauvais intent. Par exemple, supposons que vous possédiez un agent Dialogflow qui serve de source fiable à une société de vente. Vous pouvez avoir deux intents pour la récupération des contacts : un pour les équipes de gestion des comptes internes et un autre pour le client. Vous pouvez les appeler get_internal_contacts et get_external_contacts. Voici une phrase d'entraînement typique pour chaque intent :

  • get_internal_contacts : "Qui est le point de contact du client X ?"
  • get_external_contacts : "Comment entrer en contact avec le client X ?"

Supposons que vos utilisateurs aient envoyé la requête suivante lorsqu'ils recherchaient les contacts externes : "Contacts du client X". Cette requête peut perturber l'agent Dialogflow, car la phrase peut correspondre aux deux intents. Si le mauvais intent est mis en correspondance, les utilisateurs vivront une mauvaise expérience, car ils devront modifier la formulation de leur requête, ce qui se révèle à la fois long et fastidieux.

Par conséquent, vous voudrez vous assurer que les phrases d'un même intent présentent davantage de similarités entre elles, et que les phrases d'intents distincts en présentent moins. La suite du tutoriel explique comment évaluer la qualité de la phrase d'entraînement fournie à chaque intent et comment identifier des phrases d'entraînement pouvant prêter à confusion.

Méthode

L'approche utilisée dans le cadre de ce tutoriel consiste à calculer la similarité entre deux phrases et, par extension, à calculer la matrice de similarité pour toutes les phrases d'entraînement. Une fois que vous disposez de cette matrice, vous pouvez calculer les éléments suivants :

  • Cohésion : valeur de similarité moyenne entre chaque paire de phrases d'un même intent. Cette valeur est calculée pour chaque intent. Plus la valeur de cohésion de l'intent est élevée, plus les phrases d'entraînement de l'intent sont performantes.
  • Séparation : pour deux intents, distance moyenne entre chaque paire de phrases d'entraînement des deux intents.
  • Phrases prêtant à confusion : phrases d'entraînement très semblables aux phrases d'autres intents.

Pour calculer une valeur de similarité entre deux phrases, vous devez convertir chacune d'elles en un vecteur de caractéristiques à valeur réelle, qui représente la sémantique de la phrase (représentations vectorielles continues). Pour vous aider dans cette tâche, le tutoriel exploite TensorFlow Hub (tf.Hub), une bibliothèque employée pour la publication, la détection et la consommation de modules réutilisables de modèles de machine learning. Il peut s'agir de modèles pré-entraînés ou de représentations vectorielles continues extraites de textes, d'images et d'autres sources. Vous pouvez parcourir les représentations vectorielles continues de texte disponibles. Le tutoriel exploite également le module Universal Sentence Encoder (v2), qui permet d'encoder du texte en 512 vecteurs dimensionnels pouvant être utilisés pour la classification de texte, la similarité sémantique, le clustering et d'autres tâches en langage naturel.

Dans ce tutoriel, vous allez employer la similarité cosinus en tant que métrique de proximité entre deux vecteurs de représentation vectorielle continue. Avec deux vecteurs à valeur réelle (dans notre exemple, deux vecteurs de représentation vectorielle continue extraits de deux phrases d'entraînement), la similarité cosinus calcule le cosinus de l'angle entre ceux-ci à l'aide de la formule suivante :

$$ \cos(A,B) = \frac{\sum_{i=1}^{n}A_iB_i}{\sqrt{\sum_{i=1}^{n}{A_i^2}}\sqrt{\sum_{i=1}^{n}{B_i^2}}} $$

Dans cette formule, n est le nombre d'éléments dans le vecteur. Plus l'angle entre les vecteurs est faible, plus la valeur du cosinus de cet angle est élevée, ce qui indique une plus forte similarité. La valeur de la similarité cosinus entre deux vecteurs est toujours comprise entre 0 et 1.

La figure 1 présente une vue d'ensemble de cette approche :

Vue d'ensemble de l'évaluation de la cohésion et de la séparation des intents

Figure 1 : Vue d'ensemble de l'évaluation de la cohésion et de la séparation des intents

La figure illustre la séquence suivante :

  1. Importation d'intents et de leurs phrases d'entraînement
  2. Création de représentations vectorielles continues pour les phrases d'entraînement à l'aide du module pré-entraîné Universal Sentence Encoder tf.Hub.
  3. Création d'une visualisation des représentations vectorielles continues générées dans un espace à deux dimensions
  4. Calcul de la matrice de similarité cosinus des représentations vectorielles continues, qui contient les valeurs de similarité par paire entre toutes les phrases d'entraînement d'intents distincts
  5. Calcul des métriques de cohésion et de séparation
  6. Identification des phrases prêtant à confusion

Objectifs

  • (Facultatif) Créer un agent Dialogflow
  • Importer des intents avec des phrases d'entraînement
  • Exécuter le notebook Colab pour évaluer la qualité des intents

Coûts

Ce tutoriel utilise les composants facturables Google Cloud suivants :

  • Dialogflow : l'utilisation de Dialogflow Standard Edition est gratuite, tandis que Dialogflow Enterprise Edition propose une assistance payante aux entreprises. Vous pouvez choisir votre édition lors de la création de l'agent Dialogflow. Votre compte peut inclure des agents des deux éditions. Pour en savoir plus, consultez la page des tarifs de Dialogflow.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder à la page de sélection du projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activez l'API Dialogflow.

    Activer l'API

  5. Créez un compte de service pour appeler l'API Dialogflow.

    Créer un compte de service
  6. Dans la boîte de dialogue Service account details (Détails du compte de service), saisissez le nom du compte et sa description, comme indiqué dans la capture d'écran suivante, puis cliquez sur Create (Créer) :

    Capture d'écran de la boîte de dialogue affichant les détails du compte de service
  7. Définissez le rôle sur Dialogflow API Client (Client de l'API Dialogflow) et cliquez sur Continue (Continuer).

    Capture d'écran de la boîte de dialogue affichant les autorisations du compte de service

Exécuter le tutoriel dans le notebook Colab

Les sections ci-dessous présentent les étapes décrites dans la section Approche qui permettent de calculer les métriques de cohésion et de séparation et d'identifier les phrases prêtant à confusion.

Premiers pas avec le notebook Colab

  1. Accédez au notebook Colab : https://colab.research.google.com/drive/....

  2. Créez une copie locale de votre Google Drive.

    Copier le notebook sur votre Google Drive

  3. Dans Cloud Shell, installez les bibliothèques Python nécessaires pour la suite du tutoriel, puis importez les bibliothèques et les modules requis.

    !pip install --quiet --upgrade tensorflow dialogflow scipy tensorflow-hub seaborn
    
  4. Définissez l'ID du projet Google Cloud (PROJECT_ID) et l'adresse e-mail du compte de service (SERVICE_ACCOUNT_EMAIL) que vous avez créé dans la section Avant de commencer.

    Définir l'ID du projet Google Cloud (PROJECT_ID) et l'adresse e-mail du compte de service (SERVICE_ACCOUNT_EMAIL)

  5. Authentifiez votre session pour créer une clé pour votre compte de service :

    auth.authenticate_user()
    !gcloud config set project {PROJECT_ID}
    !gcloud iam service-accounts keys create sa-key.json \
        --iam-account={SERVICE_ACCOUNT_EMAIL} --project={PROJECT_ID}
    

    Une fois ces commandes exécutées, un lien s'affiche.

  6. Cliquez sur le lien pour authentifier votre compte utilisateur.

  7. Copiez le code d'authentification de la page Web, puis collez-le dans le champ Enter verification code (Saisissez le code de validation) du notebook :

    Champ **Enter verification code** (Saisissez le code de validation) du notebook

Configurer un agent Dialogflow

Si vous disposez déjà d'un agent Dialogflow que vous souhaitez utiliser dans ce tutoriel, vous pouvez ignorer cette étape. Toutefois, si vous ne possédez pas d'agent ou si vous souhaitez en créer un, vous pouvez télécharger un fichier ZIP incluant le contenu d'un agent Dialogflow exporté, intitulé intents-healthcheck. Pour importer cet agent dans votre compte Dialogflow, procédez comme suit :

  1. Téléchargez le fichier ZIP de l'agent importé :

    gsutil cp gs://dialogflow-intent-health-check/intent-quality-demo.zip .
    
  2. Accédez à la page https://dialogflow.com/.

  3. Cliquez sur le bouton Go to Console (Accéder à la console) en haut à droite.

  4. Dans le menu de gauche, cliquez sur Create new agent (Créer un agent).

    Créer un agent

  5. Saisissez le nom de l'agent : intents-healthcheck.

  6. Sélectionnez votre projet Google Cloud dans la liste des projets Google.

    • Un projet Google Cloud ne peut comporter qu'un seul agent Dialogflow. Si votre projet Google Cloud n'apparaît pas dans la liste, cela signifie qu'il est déjà associé à un agent.
    • Si vous sélectionnez Créer un projet, Dialogflow crée un projet Google Cloud portant le même nom que l'agent.
  7. Cliquez sur Create (Créer).

    Saisir les informations sur l'agent

  8. Dans le menu de gauche, sélectionnez le nouvel agent et cliquez sur l'icône des paramètres . Dans le menu situé au milieu de la page, cliquez ensuite sur Export and Import (Exporter et importer).

    Boîte de dialogue "Export and Import" (Exporter et importer)

  9. Cliquez sur Restore from zip (Restaurer depuis un fichier ZIP) :

    1. Sélectionnez le fichier agent-backup.zip que vous avez téléchargé à l'étape 1.
    2. Saisissez RESTORE dans la zone de texte en bas de la page pour confirmer.
    3. Cliquez sur Restaurer.

    Restaurer l'agent depuis un fichier ZIP

    Une fois l'agent restauré, Dialogflow crée cinq intents.

  10. Vérifiez les intents importés en sélectionnant la section Intents dans le menu de gauche. Vous pouvez voir les intents suivants :

    Vérifier les intents importés

Vous allez utiliser cet agent restauré dans le reste du tutoriel.

Parcourir le code dans le notebook Colab

Les sections ci-dessous décrivent les opérations effectuées par le code du notebook lors de son exécution.

Extraire les intents

Le code suivant extrait les intents et leurs phrases d'entraînement de l'agent Dialogflow à l'aide de la méthode fetch_intents_training_phrases. Cette méthode renvoie un dictionnaire dans lequel les clés correspondent aux intents nommés de votre agent Dialogflow, et où chaque valeur est une liste des phrases d'entraînement de chaque entité. Dans le code, project fait référence au projet auquel votre agent appartient, et service_account_file au fichier que vous avez créé précédemment.

def get_intents(service_account_file, project):

    dialogflow_entity_client =  dialogflow.EntityTypesClient.from_service_account_file(service_account_file)
    parent = dialogflow_entity_client.project_agent_path(project)
    entities = list(dialogflow_entity_client.list_entity_types(parent))

    dialogflow_intents_client = dialogflow.IntentsClient.from_service_account_file(service_account_file)
    parent = dialogflow_intents_client.project_agent_path(project)
    intents = list(dialogflow_intents_client.list_intents(
        parent=parent,
        intent_view=dialogflow.enums.IntentView.INTENT_VIEW_FULL))

    entities_name_to_value = {}
    for intent in intents:
        entities_used = {entity.display_name
            for entity in intent.parameters}

        for entity in entities:
            if entity.display_name in entities_used \
                    and entity.display_name not in entities_name_to_value:
                entities_name_to_value[entity.display_name] = np.random.choice(
                    np.random.choice(entity.entities).synonyms, replace=False)

    intent_to_training_phrases = defaultdict(list)
    for intent in intents:
        for training_phrase in intent.training_phrases:
            parts = [entities_name_to_value[part.alias] if part.entity_type else part.text
                for part in training_phrase.parts]
            intent_to_training_phrases[intent.display_name].append("".join(parts))
        # Remove intents with no training phrases
        if not intent_to_training_phrases[intent.display_name]:
            del intent_to_training_phrases[intent.display_name]
    return intent_to_training_phrases
 

Le code suivant vérifie les intents extraits :

intent_training_phrases = fetch_intents_training_phrases("sa-key.json", project_id)
for intent in intent_training_phrases:
    print("{}:{}".format(intent, len(intent_training_phrases[intent])))

La méthode fetch_intents_training_phrases renvoie la liste suivante. Cet extrait de code affiche les intents dans l'agent de démonstration intents-healthcheck, puis le nombre de phrases d'entraînement disponibles dans chaque intent.

start_conversation:4
close_conversation:5
get_internal_contacts:17
request_help:7
get_external_contacts:6

Générer des représentations vectorielles continues pour les phrases d'entraînement

Le code suivant télécharge le module pré-entraîné Universal Sentence Encoder tf.Hub :

embed_module = hub.Module("https://tfhub.dev/google/universal-sentence-encoder/2")

Après la première utilisation, le module est mis en cache localement.

Le code suivant met en œuvre une méthode qui accepte une liste de phrases et renvoie une liste de représentations vectorielles continues basées sur le module tf.Hub :

def make_embeddings_fn():
    placeholder = tf.placeholder(dtype=tf.string)
    embed = embed_module(placeholder)
    session = tf.Session()
    session.run([tf.global_variables_initializer(), tf.tables_initializer()])
    def _embeddings_fn(sentences):
        computed_embeddings = session.run(
            embed, feed_dict={placeholder: sentences})
        return computed_embeddings
    return _embeddings_fn

generate_embeddings = make_embeddings_fn()

Cette méthode garantit que la session tf.Session est bien créée et que le module de représentation vectorielle continue n'est chargé qu'une fois, et non à chaque appel de la méthode.

Le code suivant génère des représentations vectorielles continues pour les phrases d'entraînement de l'intent :

{
    intent: {
        training_phrase': [embedding_array]
    }
}

training_phrases_with_embeddings = defaultdict(list)
for intent_name, training_phrases_list in intent_training_phrases.items():
    computed_embeddings = generate_embeddings(training_phrases_list)
    training_phrases_with_embeddings[intent_name] = dict(zip(training_phrases_list, computed_embeddings))

Cet extrait de code crée le dictionnaire imbriqué training_phrases_with_embeddings.

Le code suivant vérifie les représentations vectorielles continues générées :

training_phrases_with_embeddings = defaultdict(list)
for intent_name, training_phrases_list in intent_training_phrases.items():
    computed_embeddings = generate_embeddings(training_phrases_list)
    training_phrases_with_embeddings[intent_name] = dict(zip(training_phrases_list, computed_embeddings))
 

L'extrait de code suivant affiche chaque phrase d'entraînement de l'intent start_conversation, ainsi que les cinq premiers éléments du vecteur de représentation vectorielle continue de chaque phrase. Universal Sentence Encoder génère un vecteur de représentation vectorielle continue en 512 dimensions pour chaque phrase d'entraînement.

Ciao!:[-0.03649221  0.02498418 -0.03456857  0.02827227  0.00471277]
Howdy!:[-0.02732556 -0.00821852 -0.00794602  0.06356855 -0.03726532]
Hello!:[-0.0255452   0.00690543 -0.00611844  0.05633081 -0.0142823 ]
Hi!:[-0.03227544 -0.00985429 -0.01329378  0.06012927 -0.03646606]

Visualiser les représentations vectorielles continues dans un espace à deux dimensions

Le code suivant réduit la dimensionnalité des représentations vectorielles continues de 512 à 2 en calculant les composants principaux à l'aide de l'analyse en composantes principales :

from sklearn.decomposition import PCA
embedding_vectors = None

for intent in training_phrases_with_embeddings:
    embeddings = list(training_phrases_with_embeddings[intent].values())
    if embedding_vectors is None:
        embedding_vectors = embeddings
    else:
        embedding_vectors = np.concatenate((embedding_vectors, embeddings))

pca = PCA(n_components=3)
pca.fit(embedding_vectors)

Cet extrait de code utilise la classe PCA de sklearn pour générer une représentation 2D des représentations vectorielles continues des phrases d'entraînement.

Le code suivant génère une visualisation des représentations vectorielles continues des phrases avec la dimensionnalité réduite :

import matplotlib.pyplot as plt

fig = plt.figure(figsize=(15,10))
ax = fig.add_subplot(111)

legend = []

for color, intent in enumerate(training_phrases_with_embeddings):
    phrases = list(training_phrases_with_embeddings[intent].keys())
    embeddings = list(training_phrases_with_embeddings[intent].values())
    points = pca.transform(embeddings)
    xs = points[:,0]
    ys = points[:,1]
    ax.scatter(xs, ys, marker='o', s=100, c="C"+str(color))
    for i, phrase in enumerate(phrases):
        ax.annotate(phrase, (xs[i], ys[i]))
    legend.append(intent)

ax.legend(legend)
plt.show()

La figure ci-dessous illustre la visualisation obtenue : Visualiser les représentations vectorielles continues des phrases avec la dimensionnalité réduite

Calculer la similarité par paire entre les phrases

Le code suivant calcule la similarité cosinus par paire pour les représentations vectorielles continues des phrases d'entraînement à l'aide de sklearn.metrics.pairwise.cosine_similarity. Le code crée un Dataframe, similarity_df, avec les valeurs de similarité par paire.

from sklearn.metrics.pairwise import cosine_similarity

flatten = []
for intent in training_phrases_with_embeddings:
        for phrase in training_phrases_with_embeddings[intent]:
            flatten.append((intent, phrase, training_phrases_with_embeddings[intent][phrase]))

data = []
for i in range(len(flatten)):
    for j in range(i+1, len(flatten)):
        intent_1 = flatten[i][0]
        phrase_1 = flatten[i][1]
        embedd_1 = flatten[i][2]
        intent_2 = flatten[j][0]
        phrase_2 = flatten[j][1]
        embedd_2 = flatten[j][2]
        similarity = cosine_similarity([embedd_1], [embedd_2])[0][0]
        record = [intent_1, phrase_1, intent_2, phrase_2, similarity]
        data.append(record)

similarity_df = pd.DataFrame(data,
    columns=["Intent A", "Phrase A", "Intent B", "Phrase B", "Similarity"])

Le code suivant affiche des exemples d'enregistrements de similarité :

different_intent = similarity_df['Intent A'] != similarity_df['Intent B']
display(similarity_df[different_intent].sort_values('Similarity',
ascending=False).head(5))

L'extrait de code suivant affiche les phrases d'entraînement les plus semblables qui n'appartiennent pas au même intent :

Phrases d'entraînement les plus semblables qui n'appartiennent pas au même intent

Les phrases de différents intents ayant une valeur de similarité élevée peuvent perturber l'agent Dialogflow et entraîner une correspondance de l'entrée utilisateur avec le mauvais intent.

Mesurer la cohésion et la séparation des intents

Le code suivant calcule une valeur de cohésion pour chaque intent, comme décrit dans la section Approche.

same_intent = similarity_df['Intent A'] == similarity_df['Intent B']
cohesion_df = pd.DataFrame(similarity_df[same_intent].groupby('Intent A', as_index=False)['Similarity'].mean())
cohesion_df.columns = ['Intent', 'Cohesion']
display(cohesion_df)

Le résultat est une valeur de cohésion pour chaque intent :

Calculer une valeur de cohésion pour chaque intent

Le code suivant calcule la séparation par paire entre les intents, comme décrit dans la section Approche.

different_intent = similarity_df['Intent A'] != similarity_df['Intent B']
separation_df = pd.DataFrame(similarity_df[different_intent].groupby(['Intent A', 'Intent B'], as_index=False)['Similarity'].mean())
separation_df['Separation'] = 1 - separation_df['Similarity']
del separation_df['Similarity']
display(separation_df.sort_values('Separation'))

Le résultat est la séparation par paire entre les intents :

Calculer la séparation par paire entre les intents

Autres améliorations

Pour améliorer la qualité des phrases d'entraînement de vos intents, envisagez les approches suivantes :

  • Identifiez les phrases d'autres intents qui présentent de fortes similarités, puis modifiez-les ou supprimez-les.
  • Identifiez les phrases les plus semblables à d'autres phrases qui appartiennent à des intents distincts.
  • Ajoutez des phrases d'entraînement aux intents à faible cohésion et examinez les phrases des intents à faible séparation.

Effectuer un nettoyage

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étape suivante