Qualität ähnlicher Trainingswortgruppen in unterschiedlichen Intents bewerten

In dieser Anleitung erfahren Sie, wie Sie die Qualität der Trainingswortgruppen analysieren und bewerten können, die den Intents der Dialogflow-Agents bereitgestellt werden. Mit diesen Analysen soll vermieden werden, dass der Agent durch Wortgruppen irregeführt wird, die für die bereitgestellten Intents nicht relevant bzw. für andere Intents relevanter sind.

Der Ansatz besteht darin, semantische Einbettungen der Trainingswortgruppen zu erzeugen. Dazu verwenden Sie das USE-Modul (Universal Sentence Encoder) von TensorFlow Hub (tf.Hub). Anschließend berechnen Sie Messwerte für Kohäsion und Trennung anhand der Ähnlichkeit zwischen Einbettungen, die sich innerhalb eines einzelnen Intents und in unterschiedlichen Intents befinden. In dieser Anleitung werden "irreführende" Trainingswortgruppen bestimmt, die im Einbettungsbereich anderen Intents eher entsprechen als den Intents, für die sie bereitgestellt wurden.

Der Code für diese Anleitung befindet sich im Colab-Notebook. In diesem Artikel werden Grundkenntnisse in Dialogflow vorausgesetzt. Weitere Informationen zu Dialogflow finden Sie in dieser mehrteiligen Anleitung zum Erstellen, Sichern und Skalieren eines Chatbots mithilfe der Dialogflow Enterprise Edition in Google Cloud.

Einleitung

Mit Dialogflow können Sie Ihre Produkte und Dienste um dialogorientierte Schnittstellen ergänzen. Hierzu verwenden Sie eine leistungsfähige NLU-Engine (Natural Language Understanding), um Eingaben in natürlicher Sprache zu verarbeiten und zu verstehen. Anwendungsfälle für Dialogflow:

  • Erstellen von Buchungs- und Reservierungsbots für Fluggesellschaften, Kinos usw.
  • Vereinfachen eines Bestellsystems für einen Fast-Food-Lieferservice
  • Bereitstellen eines effizienten Kundenservices durch teilautomatisierte Call Center

Zur Verarbeitung von Nutzeräußerungen können auch komplexe Unterhaltungsabläufe implementiert werden. Dialogflow führt jedoch im Wesentlichen die folgenden Schritte aus:

  1. Der Nutzer stellt eine Frage wie "Wie hoch ist der Gesamtbetrag meiner Rechnung vom letzten Monat?".
  2. Der Agent parst die Eingabe und ordnet sie einem Intent wie bill_value_inquiry zu.
  3. Der Agent extrahiert außerdem Informationen zu Entitäten wie "letzter Monat".
  4. Je nach Intent der extrahierten Entitäten wird dann eine Auftragsausführung ausgelöst, um auf die Anfrage des Nutzers zu antworten.

In der folgenden Tabelle werden die wesentlichen Konzepte der Dialogflow-Plattform beschrieben.

Begriff Beschreibung
Agent Agents sind NLU-Module, die in Ihr System eingebunden werden können. Ein Agent konvertiert Text oder gesprochene Nutzeranfragen in verwertbare Daten, wenn die Eingabe des Nutzers einem der Intents im Agent zugeordnet werden kann.
Intent In einer Unterhaltung werden Nutzereingaben Antworten zugeordnet. In jedem Intent definieren Sie Beispiele (Wortgruppen) für Nutzeräußerungen, die den Intent auslösen können. Darüber hinaus legen Sie fest, welche Elemente aus der Äußerung extrahiert und welche Antworten zurückgegeben werden sollen.
Entitäten Anhand von Intents kann der Agent die Beweggründe für eine bestimmte Nutzereingabe verstehen. Mithilfe von Entitäten ist er in der Lage, bestimmte Elemente aus diesen Informationen auszuwählen. Dabei kann es sich beispielsweise um Adressen, Produktnamen oder Beträge mit Einheiten handeln, die zur Bearbeitung der Anfrage des Nutzers dienlich sein können.
Auftragsausführung Mit der Auftragsausführung können Sie die vom Agent extrahierten Entitätsinformationen verwenden, um dynamische Antworten zu generieren oder Aktionen im Back-End basierend auf einzelnen Intents auszulösen.

Weitere Informationen zu Dialogflow finden Sie in der Dialogflow-Dokumentation.

Intents bilden die Grundlage eines Dialogflow-Systems, da sie die Nutzeranfrage mit der richtigen Geschäftslogik für die Auftragsausführung verknüpfen. Ein Dialogflow-System für einen Telekommunikationsanbieter kann beispielsweise Intents wie bill_value_inquiry, pay_bill, upgrade_contract, cancel_contract und add_service haben. Damit Nutzeräußerungen (Text oder Sprache) dem richtigen Intent zugeordnet werden, müssen Intents mit einer Reihe relevanter Trainingswortgruppen trainiert werden. Bei einer Wetteranfrage würden für einen Intent beispielsweise folgende Trainingswortgruppen infrage kommen:

  • "Wie ist gerade das Wetter?"
  • "Wie ist morgen die Temperatur in Kairo?"
  • "Muss ich nächste Woche einen Regenschirm nach Zürich mitnehmen?"

Wenn Sie in Ihrem System mehrere Intents erstellen, können einige Wortgruppen, die Sie einem Intent bereitstellen, irreführend sein. Beispielsweise könnte eine Wortgruppe, die für einen anderen Intent relevanter ist, zum Trainieren des falschen Intents verwendet werden. Angenommen, Sie haben einen Dialogflow-Agent, der als zentrale Informationsquelle für eine Vertriebsorganisation dient. Möglicherweise haben Sie zwei Intents zum Abrufen von Ansprechpartnern: einen für die Teams für interne Kunden und einen anderen für den externen Kunden. Sie können diese als get_internal_contacts und get_external_contacts benennen. Typische Trainingswortgruppen für die verschiedenen Intents wären beispielsweise:

  • get_internal_contacts: "Wer ist der Ansprechpartner für Kunde X?"
  • get_external_contacts: "Wie erreiche ich den Kunden X?"

Angenommen, ein Nutzer hat auf der Suche nach externen Ansprechpartnern die folgende Anfrage gestellt: "Ansprechpartner für Kunde X". Durch diese Anfrage wird der Agent möglicherweise irregeführt, da die Wortgruppe beiden Intents zugeordnet werden kann. Eine falsche Intent-Zuordnung führt zu einer Beeinträchtigung des Nutzererlebnisses, da der Nutzer die Anfrage umformulieren muss, was zeitaufwendig und lästig ist.

Achten Sie daher darauf, dass die Wortgruppen für ein und denselben Intent eine hohe Ähnlichkeit und die Wortgruppen für verschiedene Intents eine geringere Ähnlichkeit haben. Im weiteren Verlauf dieser Anleitung wird beschrieben, wie Sie die Qualität der für die verschiedenen Intents bereitgestellten Wortgruppen bewerten und potenziell irreführende Trainingswortgruppen identifizieren.

Ansatz

Der in dieser Anleitung verwendete Ansatz besteht darin, die Ähnlichkeit zwischen zwei Wortgruppen zu bestimmen und durch Erweiterung die Ähnlichkeitsmatrix für alle Trainingswortgruppen zu berechnen. Mit der Matrix können Sie dann Folgendes berechnen:

  • Kohäsion: Der durchschnittliche Ähnlichkeitswert zwischen den einzelnen Wortgruppenpaaren in einem bestimmten Intent. Dieser Wert wird jeweils im Hinblick auf den einzelnen Intent berechnet. Je höher der Kohäsionswert, desto besser die Qualität der Trainingswortgruppen.
  • Trennung: Im Fall von zwei Intents die durchschnittliche Entfernung zwischen den jeweiligen Paaren aus Trainingswortgruppen in beiden Intents.
  • Irreführende Wortgruppen: Trainingswortgruppen, die eine hohe Ähnlichkeit mit Wortgruppen in anderen Intents haben.

Zur Berechnung des Ähnlichkeitswerts zwischen zwei Wortgruppen müssen Sie jede der Wortgruppen in einen Merkmalsvektor mit Realwert konvertieren, der die Semantik der Wortgruppe (Einbettungen) darstellt. Zur Unterstützung dieser Aufgabe wird in der Anleitung TensorFlow Hub (tf.Hub) verwendet, eine Bibliothek, die zur Veröffentlichung, Erkennung und Nutzung wiederverwendbarer Module von ML-Modellen verwendet wird. Diese Module können aus vortrainierten Modellen oder Einbettungen bestehen, die aus Text, Bildern usw. extrahiert werden. Sie können die verfügbaren Texteinbettungen durchsuchen. In dieser Anleitung wird das USL-Modul (Universal Sentence Encoder) (v2) zur Verschlüsselung von Text in 512-dimensionale Vektoren eingesetzt, die für Textklassifizierung, semantische Ähnlichkeit, Clustering und andere NL-Aufgaben verwendet werden können.

In dieser Anleitung verwenden Sie die Kosinusähnlichkeit als Maß für die Annäherung zwischen zwei Einbettungsvektoren. Bei zwei Vektoren mit Realwerten (in unserem Beispiel zwei Einbettungsvektoren, die aus zwei Trainingswortgruppen extrahiert wurden), berechnet die Kosinusähnlichkeit den Kosinus des Winkels zwischen beiden Vektoren. Dazu wird die folgende Formel verwendet:

$$ \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}}} $$

In dieser Formel ist n die Anzahl der Elemente im Vektor. Je kleiner der Winkel zwischen den Vektoren, desto größer der Kosinuswert dieses Winkels, der eine höhere Ähnlichkeit angibt. Der Wert für die Kosinusähnlichkeit zwischen zwei Vektoren liegt immer zwischen 0 and 1.

Abbildung 1 zeigt eine Übersicht dieses Ansatzes:

Übersicht: Kohäsion und Trennung von Intents bewerten

Abbildung 1: Übersicht über die Bewertung von Kohäsion und Trennung bei Intents

Die Abbildung zeigt die folgende Abfolge:

  1. Importieren der Intents und zugehörigen Wortgruppen
  2. Erzeugen von Einbettungen für die Trainingswortgruppen mit dem vortrainierten Universal Sentence Encoder-Modul tf.Hub
  3. Erstellen einer Visualisierung der generierten Einbettungen in einem zweidimensionalen Raum
  4. Berechnen der Matrix für die Kosinusähnlichkeit der Einbettungen mit den Werten der paarweisen Ähnlichkeit zwischen allen Wortgruppen in unterschiedlichen Intents
  5. Berechnen der Messwerte für Kohäsion und Trennung
  6. Bestimmen irreführender Wortgruppen

Ziele

  • Optional: Erstellen eines Dialogflow-Agents
  • Importieren von Intents mit Trainingswortgruppen
  • Ausführen des Colab-Notebooks zur Bewertung der Intent-Qualität

Kosten

In dieser Anleitung werden die folgenden kostenpflichtigen Komponenten von Google Cloud verwendet:

  • Dialogflow: Die Standard Edition ist kostenlos. Die Enterprise Edition bietet kostenpflichtigen Enterprise Support. Beim Erstellen des Dialogflow-Agents können Sie bestimmen, welche Edition Sie verwenden möchten. Ihr Konto kann Agents aus beiden Editionen beinhalten. Weitere Informationen finden Sie auf der Dialogflow-Preisseite.

Vorbereitung

  1. Melden Sie sich bei Ihrem Google-Konto an.

    Wenn Sie noch kein Konto haben, melden Sie sich hier für ein neues Konto an.

  2. Wählen Sie in der Cloud Console auf der Seite für die Projektauswahl ein Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  4. Aktivieren Sie die Dialogflow API.

    Aktivieren Sie die API

  5. Erstellen Sie ein Dienstkonto zum Aufrufen der Dialogflow API.

    Dienstkonto erstellen
  6. Geben Sie im Dialogfeld Service account details den Namen und die Beschreibung des Kontos gemäß dem folgenden Screenshot ein und klicken Sie auf Create:

    Screenshot des Dialogfelds
  7. Legen Sie die Rolle auf Dialogflow API Client fest und klicken Sie auf Continue.

    Screenshot des Dialogfelds

Anleitung im Colab-Notebook fortsetzen

Die folgenden Abschnitte führen Sie durch die im Abschnitt Ansatz erläuterten Schritte zum Berechnen der Messwerte für Kohäsion und Trennung sowie zum Ermitteln von irreführenden Wortgruppen.

Erste Schritte mit dem Colab-Notebook

  1. Rufen Sie das Colab-Notebook auf: https://colab.research.google.com/drive/....

  2. Erstellen Sie eine lokale Kopie Ihres Google Drive-Kontos.

    Notebook in Google Drive kopieren

  3. Installieren Sie in Cloud Shell die Python-Bibliotheken, die für die verbleibenden Schritte der Anleitung erforderlich sind, bevor Sie die erforderlichen Bibliotheken und Module importieren.

    !pip install --quiet --upgrade tensorflow dialogflow scipy tensorflow-hub seaborn
    
  4. Legen Sie die im Abschnitt Vorbereitung erstellte Google Cloud-PROJECT_ID und die SERVICE_ACCOUNT_EMAIL fest.

    Google Cloud-PROJECT_ID und SERVICE_ACCOUNT_EMAIL festlegen

  5. Authentifizieren Sie die Sitzung, um einen Schlüssel für das Dienstkonto zu erstellen.

    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}
    

    Nachdem Sie diese Befehle ausgeführt haben, wird ein Link angezeigt.

  6. Rufen Sie den Link auf, um Ihr Nutzerkonto zu authentifizieren.

  7. Kopieren Sie den Authentifizierungscode von der Webseite und fügen Sie ihn in das Feld Enter verification code im Notebook ein:

    Feld **Enter verification code** im Notebook

Dialogflow-Agent

Wenn Sie bereits einen Dialogflow-Agent haben, den Sie in dieser Anleitung verwenden möchten, können Sie diesen Schritt überspringen. Wenn Sie allerdings keinen Agent haben oder einen neuen einrichten möchten, können Sie eine ZIP-Datei mit dem Inhalt eines exportierten Dialogflow-Agents mit dem Namen intents-healthcheck herunterladen. So importieren Sie diesen Agent in Ihr Dialogflow-Konto:

  1. Laden Sie die ZIP-Datei des importierten Agents herunter:

    gsutil cp gs://dialogflow-intent-health-check/intent-quality-demo.zip .
    
  2. Wechseln Sie zu https://dialogflow.com/.

  3. Klicken Sie oben rechts auf die Schaltfläche Go to Console.

  4. Klicken Sie im linken Menü auf Create new agent.

    Neuen Agent erstellen

  5. Geben Sie den Agent-Namen ein: intents-healthcheck.

  6. Wählen Sie Ihr Google Cloud-Projekt aus der Liste Google Project aus.

    • Ein Google Cloud-Projekt kann nur einen Dialogflow-Agent haben. Wenn Sie Ihr Google Cloud-Projekt also nicht in der Liste finden, ist bereits ein Agent mit Ihrem Projekt verknüpft.
    • Wenn Sie Neues Projekt erstellen auswählen, erstellt Dialogflow ein Google Cloud-Projekt mit demselben Namen wie der Agent.
  7. Klicken Sie auf Erstellen.

    Informationen zum Agent eingeben

  8. Wählen Sie im Menü auf der linken Seite den neuen Agent aus und klicken Sie dann auf das Symbol für die Einstellungen . Wählen Sie dann im Menü weiter unten die Option Export and Import aus.

    Dialogfeld

  9. Klicken Sie auf Restore from zip:

    1. Wählen Sie die in Schritt 1 heruntergeladene Datei agent-backup.zip aus.
    2. Geben Sie im Textfeld unten im Formular den Wert RESTORE ein, um den Vorgang zu bestätigen.
    3. Klicken Sie auf Wiederherstellen.

    Agent von ZIP-Datei wiederherstellen

    Nachdem der Agent wiederhergestellt wurde, erstellt Dialogflow fünf Intents.

  10. Überprüfen Sie die importierten Intents, indem Sie links im Menü die Option Intents auswählen. Folgende Intents werden angezeigt:

    Importierte Intents verifizieren

Diesen wiederhergestellten Agent verwenden Sie für die verbleibenden Schritte dieser Anleitung.

Den Code im Colab-Notebook durchgehen

In den folgenden Abschnitten wird beschrieben, welche Aufgaben der Code im Notebook erledigt, wenn Sie ihn ausführen.

Intents abrufen

Der folgende Code ruft Intents und ihre Trainingswortgruppen mithilfe der Methode fetch_intents_training_phrases aus dem Dialogflow-Agent ab. Diese Methode liefert ein Wörterbuch, in dem die im Dialogflow-Agent genannten Intents die Schlüssel sind. Jeder Wert stellt eine Liste der Wortgruppen in den einzelnen Entitäten dar. Im Code verweist project auf das Projekt, zu dem der Agent gehört, und service_account_file auf die Datei, die Sie zuvor erstellt haben.

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
 

Der folgende Code verifiziert die abgerufenen Intents:

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])))

Die Methode fetch_intents_training_phrases gibt die folgende Auflistung zurück. Dieses Code-Snippet zeigt die Intents im Demo-Agent intents-healthcheck, gefolgt von der Anzahl der Trainingswortgruppen, die im jeweiligen Intent verfügbar sind.

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

Einbettungen für Trainingswortgruppen generieren

Mit dem folgenden Code wird das vortrainierte Universal Sentence Encoder-Modul tf.Hub heruntergeladen:

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

Nach der ersten Verwendung wird das Modul lokal im Cache gespeichert.

Mit dem folgenden Code wird eine Methode implementiert, die eine Liste von Sätzen akzeptiert und eine Liste von Einbettungen auf Basis des Moduls tf.Hub zurückgibt:

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()

Mit dieser Methode wird gewährleistet, dass tf.Session erstellt und das Einbettungsmodul nur einmal geladen wird, also nicht bei jedem Aufruf der Methode.

Der folgende Code generiert Einbettungen für die Trainingswortgruppen in den Intents:

{
    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))

Mit diesem Code-Snippet wird das verschachtelte Wörterbuch training_phrases_with_embeddings erstellt.

Der folgende Code verifiziert die generierten Einbettungen:

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))
 

Das folgende Code-Snippet zeigt die verschiedenen Trainingswortgruppen im Intent start_conversation zusammen mit den ersten fünf Elementen des Einbettungsvektors der jeweiligen Wortgruppe. Universal Sentence Encoder generiert für jede Trainingswortgruppe einen 512-dimensionalen Einbettungsvektor.

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]

Eingebettete Objekte im zweidimensionalen Raum visualisieren

Der folgende Code reduziert die Dimensionalität der Einbettungen von 512 auf 2. Dabei wird die Hauptkomponentenanalyse zur Berechnung der Hauptkomponenten verwendet:

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((only_embeddings, embeddings))

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

Dieses Code-Snippet verwendet die Klasse PCA in sklearn, um eine 2D-Darstellung der Einbettungen der Trainingswortgruppen zu erzeugen.

Der folgende Code generiert eine Visualisierung der Einbettungen der Trainingswortgruppen mit reduzierter Dimensionalität.

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()

Auf der folgenden Abbildung sehen Sie das Visualisierungsergebnis: Einbettungen von Wortgruppen mit reduzierter Dimensionalität visualisieren

Paarweise Ähnlichkeit zwischen Wortgruppen berechnen

Der folgende Code berechnet die paarweise Kosinusähnlichkeit für die Einbettungen von Trainingswortgruppen anhand von sklearn.metrics.pairwise.cosine_similarity. Der Code erstellt das DataFrame similarity_df mit den paarigen Ähnlichkeitswerten.

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"])

Der folgende Code zeigt Beispieldatensätze für Ähnlichkeiten:

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

Das folgende Code-Snippet zeigt die ähnlichsten Wortgruppen, die nicht zum gleichen Intent gehören.

Die ähnlichsten Wortgruppen, die nicht zum gleichen Intent gehören

Wortgruppen in unterschiedlichen Intents mit einem hohen Ähnlichkeitswert können dazu führen, dass der Dialogflow-Agent die Nutzereingabe dem falschen Intent zuordnet.

Kohäsion und Trennung von Intents messen

Der folgende Code berechnet den Kohäsionswert für jeden Intent, wie im Abschnitt "Ansatz" beschrieben.

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

Das Ergebnis ist jeweils ein Kohäsionswert pro Intent:

Kohäsionswert jeweils pro Intent berechnen

Der folgende Code berechnet die paarweise Trennung zwischen Intents, wie im Abschnitt "Ansatz" beschrieben.

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'))

Das Ergebnis ist die in Form von Paaren erfolgende Trennung zwischen Intents:

Trennung zwischen Intents in Form von Paaren berechnen

Weitere Verbesserungen

Zur weiteren Verbesserung der Qualität von Trainingswortgruppen für Intents empfehlen wir die folgenden Ansätze:

  • Bestimmen Sie die Wortgruppen in unterschiedlichen Intents mit einer hohen Ähnlichkeit und ändern oder entfernen Sie sie.
  • Bestimmen Sie die ähnlichsten Wortgruppen, die zu unterschiedlichen Intents gehören.
  • Fügen Sie Intents mit niedriger Kohäsion weitere Trainingswortgruppen hinzu und untersuchen Sie die Trainingswortgruppen in Intents mit niedriger Trennung.

Bereinigen

  1. Wechseln Sie in der Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite "Ressourcen verwalten"

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen .
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Beenden, um das Projekt zu löschen.

Weitere Informationen