Semantische Ähnlichkeit von Texten mit TensorFlow Hub und Dataflow analysieren

Dieser Artikel ist der zweite Teil einer mehrteiligen Reihe, die Ihnen zeigt, wie sich durch Texteinbettungen semantische Ähnlichkeiten in Dokumenten ermitteln lassen. Die Einbettungen werden mithilfe des Universal Sentence Encoder-Moduls tf.Hub in einer skalierbaren Verarbeitungspipeline mit Dataflow und tf.Transform extrahiert. Die extrahierten Einbettungen werden dann in BigQuery gespeichert, wo zwischen diesen Einbettungen eine Kosinus-Ähnlichkeit berechnet wird, um die semantisch ähnlichsten Dokumente zu finden. Der Implementierungscode befindet sich im zugehörigen GitHub-Repository. Hinweis: Ein Großteil der in diesem Dokument verlinkten Seiten steht nur auf Englisch zur Verfügung.

Einzelheiten zu Einbettungskonzepten und Anwendungsfällen finden Sie unter Merkmalseinbettungen für maschinelles Lernen extrahieren und bereitstellen.

Einführung

Sie können beim Abruf von Informationen verschiedene Ansätze verwenden, um zugehörige Dokumente in einer Sammlung zu finden. Ein Ansatz besteht darin, Schlüsselwörter zu extrahieren und Dokumente basierend auf der Anzahl von Begriffen, die die Dokumente gemeinsam haben, miteinander abzugleichen. Dieser Ansatz erfasst jedoch keine Dokumente, die ähnliche, aber nicht identische Begriffe verwenden.

Ein weiterer Ansatz ist die Analyse semantischer Ähnlichkeiten, mit der sich dieser Artikel befasst. Mit der Textähnlichkeitsanalyse können Sie relevante Dokumente auch ohne entsprechende Suchbegriffe finden. Artikel, Bücher, Berichte und Kundenfeedback lassen sich nämlich auch durch Durchsuchen repräsentativer Dokumente finden.

In diesem Artikel geht es hauptsächlich um die auf Einbettungen basierende Ähnlichkeitsanalyse von Texten. Sie können einen ähnlichen Ansatz aber auch bei anderen Inhaltstypen verwenden, z. B. bei Bild-, Audio- und Videodateien, sofern sich diese Inhalte in Einbettungen konvertieren lassen.

Dieser Artikel behandelt die folgenden Themen:

  • Mit Apache Beam und tf.Transform Textdateien verarbeiten
  • Mit dem Universal Sentence Encoder-Modul von TensorFlow Hub (tf.Hub) Texteinbettungen aus Titeln und Artikelinhalten extrahieren
  • Mit Cloud Dataflow skalierte Textverarbeitungspipelines ausführen
  • Verarbeitete Artikel und zugehörige Einbettungen in BigQuery speichern
  • Mit einem SQL-Skript für Kosinus-Ähnlichkeit ähnliche Artikel in BigQuery finden

Lösungsarchitektur

In Abbildung 1 ist die Lösungsarchitektur der Textähnlichkeitsanalyse im Überblick dargestellt. Für die Textdaten verwendet die Lösung Reuters-21578, eine Sammlung öffentlich verfügbarer Artikel. Das Dataset wird weiter unten in diesem Artikel unter Reuters-Dataset beschrieben. Die Beispieldokumente werden in Cloud Storage geladen. Die Verarbeitungspipeline wird mit Apache Beam und tf.Transform implementiert und im großen Maßstab in Dataflow ausgeführt.

Gesamtlösungsarchitektur der Textähnlichkeitsanalyse
Abbildung 1. Gesamtlösungsarchitektur der Textähnlichkeitsanalyse

In der Pipeline werden Dokumente verarbeitet, um aus jedem Artikel den Titel ("Title"), die Themen ("Topics") und den Inhalt ("Content") zu extrahieren. Die Verarbeitungspipeline verwendet das Universal Sentence Encoder-Modul in tf.Hub, um Texteinbettungen sowohl für den Titel als auch für den Inhalt der Artikel zu extrahieren. Diese Werte werden zusammen mit den extrahierten Einbettungen in BigQuery gespeichert. Nachdem Sie die Artikel und die dazugehörigen Einbettungen in BigQuery gespeichert haben, lassen sich mithilfe des Messwerts für die Kosinus-Ähnlichkeit der jeweiligen Titel- und Inhaltseinbettungen ähnliche Artikel finden.

Wichtige Konzepte

In der folgenden Liste werden die in Abbildung 1 dargestellten Konzepte erläutert.

Cloud Storage
Mit Cloud Storage können Sie beliebige Datenmengen jederzeit weltweit speichern und abrufen. Sie können Cloud Storage für eine Reihe von Aufgaben verwenden, einschließlich des Verteilens großer Dateien für die Verarbeitung und Analyse. Bei dieser Lösung werden die Quellartikeldokumente in einem Cloud Storage-Bucket gespeichert, der als Data Lake für die Rohdokumente betrachtet werden kann. Außerdem wird eine Version der verarbeiteten Daten (d. h. die Sammlung extrahierter Einbettungen) als eine Reihe von TFRecord-Dateien in Cloud Storage gespeichert. Diese können später für das Trainieren von ML-Modellen verwendet werden.
Apache Beam
Apache Beam ist ein einheitliches Open-Source-Programmiermodell, mit dem sowohl Streaming- als auch Batchdatenverarbeitungsjobs ausgeführt werden können. Diese Lösung verwendet Apache Beam, um eine ETL-Pipeline (Extract, Transform, Load) zu implementieren: 1) Rohdaten aus Cloud Storage lesen, 2) Artikel verarbeiten und Einbettungen extrahieren sowie 3) Artikel und Einbettungen in BigQuery speichern.
tf.Transform
TensorFlow Transform ist eine Bibliothek zur Vorverarbeitung von Daten mit TensorFlow. Bei dieser Lösung wird tf.Transform als Kontext verwendet, um das Modul tf.Hub zum Extrahieren der Texteinbettung aufzurufen.
Dataflow
Dataflow ist ein vollständig verwalteter, serverloser, zuverlässiger Dienst zum Ausführen umfangreicher Apache Beam-Pipelines in Google Cloud. Mit Dataflow wird die Verarbeitung des Eingabetexts und der extrahierten Einbettungen skaliert, um diese in BigQuery zu speichern.
Texteinbettungen
Beim maschinellen Lernen (ML) ist eine Texteinbettung ein Featurevektor mit reellen Werten, der die Semantik eines Wortes (z. B. durch Verwendung von Word2vec) oder eines Satzes (z. B. durch Verwendung des Universal Sentence Encoder) darstellt. Mit Einbettungen können ML-Modelle entweder in allgemeinen Kontexten vortrainiert oder gezielt für bestimmte Aufgaben trainiert werden. Texteinbettungen werden verwendet, um für ML-Modelle Texteingabemerkmale wie Klassifizierung, Regression und Clustering darzustellen.
tf.Hub
TensorFlow Hub ist eine Bibliothek wiederverwendbarer ML-Module. Bei diesen Modulen kann es sich um vortrainierte Modelle oder um Einbettungen handeln, die aus Text, Bildern usw. extrahiert wurden. Diese Lösung verwendet das vortrainierte Texteinbettungsmodul des Universal Sentence Encoder, um jeden Artikeltitel und -inhalt in einen numerischen Merkmalsvektor (Einbettung) zu konvertieren. Dieser Merkmalsvektor kann dann verwendet werden, um die Ähnlichkeit zwischen verschiedenen Artikeln zu berechnen.
BigQuery
BigQuery ist das vollständig verwaltete, kostengünstige Data Warehouse von Google für Analysen im Petabyte-Bereich. Diese Lösung speichert die Artikel und die dazugehörigen extrahierten Einbettungen in BigQuery, damit sie später abgefragt werden können.
Kosinus-Ähnlichkeit
Die Kosinus-Ähnlichkeit ist ein Maß für die Ähnlichkeit zwischen zwei Nicht-Null-Vektoren eines Prähilbertraums, basierend auf dem Kosinus des Winkels zwischen ihnen. In dieser Lösung wird sie verwendet, um die Ähnlichkeit zwischen zwei Artikeln zu berechnen oder einen Artikel mithilfe einer Suchanfrage auf der Grundlage der extrahierten Einbettungen zu finden. Wenn zwei Vektoren der Texteinbettungen ähnlich sind, ergibt die Kosinus-Ähnlichkeit einen Wert nahe 1.

Reuters-Dataset

Die in diesem Artikel beschriebene Lösung verwendet Reuters-21587, Distribution 1.0, eine Sammlung öffentlich verfügbarer Nachrichtenartikel. Die Artikel in diesem Dataset wurden von der Nachrichtenagentur Reuters veröffentlicht und stammen aus dem Jahr 1987. Sie wurden 1987 von Mitarbeitern von Reuters Ltd. und der Carnegie Group, Inc. zusammengestellt und kategorisiert. 1990 wurden die Dokumente von Reuters und CGI zu Forschungszwecken dem Information Retrieval Laboratory der Abteilung Computer- und Informationswissenschaft der University of Massachusetts in Amherst zur Verfügung gestellt.

Die vollständige Beschreibung des Datasets finden Sie in der Datei readme.txt der Sammlung. Die wichtigsten Attribute des Datasets sind folgende:

  • Gesamtzahl der Artikel: 21.578
  • Anzahl der Dateien: 22
  • Dateiformat: Standard Generalized Markup Language (SGML) in .sgm-Dateien
  • Anzahl der Artikel pro Datei: 1.000, außer der letzten Datei, diese enthält 578 Artikel

Die Lösung extrahiert Folgendes aus den verschiedenen Tags jedes Artikels:

  • Titel: Der Titel des Artikels
  • Inhalt: Der vollständige Textinhalt des Artikels
  • Themen: Eine oder mehrere Kategorien, zu denen der Artikel gehört

ETL-Pipeline mit Apache Beam erstellen

Der Code für die Pipeline befindet sich im Python-Modul pipeline.py im GitHub-Repository dieser Lösung. Die ETL-Pipeline besteht aus den folgenden übergeordneten Schritten, die in den folgenden Abschnitten beschrieben werden:

  1. Quelldateien aus Cloud Storage lesen
  2. Artikelobjekte aus Dateien extrahieren
  3. Jedes Artikelobjekt parsen, um Titel, Inhalt und Themen zu generieren
  4. Einbettungsvektor für den Titel des Artikels generieren
  5. Einbettungsvektor für den Inhalt des Artikels generieren
  6. Ausgabe jedes Artikels in BigQuery schreiben

Artikeldateien lesen und parsen

Wie bereits erwähnt, bestehen die Quelldaten aus mehreren Dateien vom Typ .sgm, von denen jede zahlreiche Artikel enthält. Die erste Aufgabe besteht darin, diese Dateien zu lesen, den SGML-Inhalt zu parsen und die Artikelobjekte zu extrahieren. Der folgende Code zeigt die ersten drei Schritte der Beam-Pipeline:

pipeline = beam.Pipeline(options=pipeline_options)

with impl.Context(known_args.transform_temp_dir):
    articles = (
        pipeline
        | 'Get Paths' >> beam.Create(get_paths(known_args.file_pattern))
        | 'Get Articles' >> beam.Map(get_articles)
        | 'Get Article' >> beam.FlatMap(lambda x: x)
    )

Die Methode get_articles akzeptiert einen Dateipfad und gibt eine PCollection von Artikeln zurück. Mit der nachfolgenden Methode FlatMap wird die zurückgegebene Artikelsammlung vereinfacht. Wie bereits erwähnt, besteht das Ziel der Methode get_articles darin, eine Datei vom Typ .sgm zu parsen und ein Artikelobjekt (genauer gesagt ein Wörterbuch) zurückzugeben, das Titel, Themen (durch Kommas getrennt) und Inhalt enthält. Dies wird im folgenden Code gezeigt:

def get_articles(file_path):
  import bs4
  import tensorflow as tf

  data = tf.gfile.GFile(file_path).read()
  soup = bs4.BeautifulSoup(data, "html.parser")
  articles = []
  for raw_article in soup.find_all('reuters'):
    article = {
        'title': get_title(raw_article),
        'content': get_content(raw_article),
        'topics': get_topics(raw_article),
    }
    if None not in article.values():
      if [] not in article.values():
        articles.append(article)
  return articles

Diese Lösung verwendet zum Parsen der Dateien vom Typ .sgm die Python-Bibliothek Beautiful Soup (bs4).

preprocess_fn-Methode implementieren

Nachdem die Artikel gelesen, geparst und extrahiert wurden, besteht der nächste Schritt in der Beam-ETL-Pipeline darin, Texteinbettungen für Titel und Inhalt aller Artikel zu erstellen. In dieser Lösung ist die Transformationslogik in der Methode preprocess_fn implementiert. Diese Methode wird in der Beam-Pipeline mit tf.Transform APIs mithilfe der Methode AnalyzeAndTransformDataset aufgerufen. Dies ist im folgenden Code dargestellt:

dataset = (articles, get_metadata())

transformed_dataset, transform_fn = (
    dataset
    | 'Analyse & Transform dataset' >> impl.AnalyzeAndTransformDataset(preprocess_fn)
)

Die Methode preprocess_fn verwendet ein Wörterbuch mit Eingabefeatures. Dies sind TensorFlow-Tensoren, die aus den im vorherigen Schritt erstellten Dataset-Feldern erstellt wurden. Als Eingabefeatures werden in diesem Beispiel title, topics und content verwendet. Bei dieser Methode werden Einbettungen für den Titel und den Inhalt durch Aufrufen der Methoden get_embed_title und get_embed_content erstellt. Dies ist im folgenden Code dargestellt:

def preprocess_fn(input_features):
  import tensorflow_transform as tft

  title_embed = tft.apply_function(get_embed_title, input_features['title'])
  content_embed = tft.apply_function(get_embed_content, input_features['content'])
  output_features = {
      'topics': input_features['topics'],
      'title': input_features['title'],
      'content': input_features['content'],
      'title_embed': title_embed,
      'content_embed': content_embed,
  }
  return output_features

Die Methoden vom Typ get_embed_* erstellen Einbettungen mit tf.Hub. Dieser Schritt wird im nächsten Abschnitt näher erläutert. Die Methode preprocess_fn gibt die Eingabefeatures zusammen mit title_embed und content_embed aus. Beides sind reellwertige Featurevektoren.

tf.Transform hat beim Implementieren der Transformation in dieser Apache Beam-Pipeline für die Textverarbeitung folgende Vorteile:

  • Einfachheit: Zum Aufrufen des Texteinbettungsmoduls tf.Hub, das im folgenden Abschnitt ausführlicher erläutert wird, ist TensorFlow-Kontext erforderlich. Sie müssten somit ein Objekt vom Typ tf.Graph erstellen, Tensoren vom Typ tf.placeholder hinzufügen, Objekte vom Typ tf.session erstellen usw., um das Modul tf.Hub aufzurufen. In tf.Transform funktioniert die Funktion preprocess_fn jedoch in einem impliziten TensorFlow-Kontext, in dem Sie beliebige TensorFlow-Vorgänge – unter anderem das Modul tf.Hub – ohne all diese Schritte aufrufen können.

  • Erweiterbarkeit. Die Lösung verwendet Texteinbettungen als Merkmalrepräsentationen des Textes zur Durchführung der Ähnlichkeitsanalyse zwischen Artikeln. Für die Aufbereitung der Textdaten für andere Aufgaben, einschließlich der Klassifizierung von Text und dem Mining von Themen, können jedoch andere Featurerepräsentationen nützlich sein, einschließlich N-Gramme für Bag-of-Words (BOW), term frequency (TF) und term frequency-inverse document frequency (TF-IDF). (Weitere Informationen finden Sie in den Anleitungen zum maschinellen Lernen von Google unter Wie präsentieren wir die Textdaten einem Algorithmus, der numerische Eingaben erwartet?) Diese Arten von Repräsentationen erfordern Dataset-Transformationen mit vollständigem Durchlauf. Hierfür dient tf.Transform. Die Bibliothek tf.Transform enthält eine Implementierung dieser und anderer Transformationen. Wenn Sie diese ETL-Pipeline um weitere Transformationen mit vollständigem Durchlauf erweitern möchten, können Sie sie einfach der Funktion preprocess_fn hinzufügen.

Weitere Informationen zur Datenvorverarbeitung und zu TensorFlow Transform finden Sie in der Google Cloud-Dokumentation unter Datenvorverarbeitung für maschinelles Lernen: Optionen und Empfehlungen und Datenvorverarbeitung für maschinelles Lernen mit TensorFlow Transform.

Einbettungen mit TensorFlow Hub erstellen

Wie bereits im Abschnitt Wichtige Konzepte erläutert, enthält tf.Hub eine Reihe vortrainierter TensorFlow-Modelle, mit denen Sie für Text und Bilder reellwertige Featurevektoren (Einbettungen) erstellen können. Bei dieser Lösung wird das Texteinbettungsmodul Universal Sentence Encoder verwendet. Das Modul akzeptiert einen Satz und gibt einen numerischen Vektor mit 512 Dimensionen zurück, der die Einbettung für einen bestimmten Satz darstellt.

Der folgende Code für die Methode get_embed_title zeigt, wie ein Vektor für den Titel eines Artikels erstellt und eingebettet wird.

def get_embed_title(title,
    module_url='https://tfhub.dev/google/universal-sentence-encoder/2'):

  import tensorflow as tf
  import tensorflow_hub as hub

  module = hub.Module(module_url)
  embed = module(title)
  return embed

Zum Erstellen eines Einbettungsvektors für den Inhalt eines bestimmten Artikels führt der Code folgende Schritte aus:

  1. Der Artikel wird in Sätze geteilt.
  2. Mit dem Satz-Encoder-Modul wird für jeden Satz die Einbettung erzeugt.
  3. Der Durchschnitt der generierten Einbettungen aller Sätze wird berechnet.

Der Code erzeugt einen einzelnen Merkmalsvektor, um die Einbettung für einen bestimmten Inhalt darzustellen, unabhängig davon, wie viele Sätze im Inhalt eines Artikels enthalten sind. Dies wird im folgenden Code für die Funktion get_embed_content dargestellt.

def get_embed_content(content, delimiter='\n',
    module_url='https://tfhub.dev/google/universal-sentence-encoder/2'):

  import tensorflow as tf
  import tensorflow_hub as hub

  module = hub.Module(module_url)

  def _map_fn(t):
    t = tf.cast(t, tf.string)
    t = tf.string_split([t], delimiter).values
    e = module(t)
    e = tf.reduce_mean(e, axis=0)
    return tf.squeeze(e)

  embed = tf.map_fn(_map_fn, content, dtype=tf.float32)
  return embed

Ausgabe in BigQuery schreiben

Der letzte Schritt in der Beam-ETL-Pipeline besteht darin, die Ausgabe des vorherigen Verarbeitungsschritts in eine BigQuery-Tabelle zu schreiben. Dies wird im folgenden Code gezeigt:

transformed_data, transformed_metadata = transformed_dataset
(
        transformed_data
        | 'Convert to Insertable data' >> beam.Map(to_bq_row)
        | 'Write to BigQuery table' >> beam.io.WriteToBigQuery(
            project=known_args.bq_project,
            dataset=known_args.bq_dataset,
            table=known_args.bq_table,
            schema=get_bigquery_schema(),
            create_disposition=beam.io.BigQueryDisposition.CREATE_IF_NEEDED,
            write_disposition=beam.io.BigQueryDisposition.WRITE_TRUNCATE)
)

Die Pipeline erstellt die Tabelle, wenn sie nicht vorhanden ist, und schneidet die Tabelle ab, wenn die Tabelle vorherige Daten enthält. Sie können dieses Verhalten mithilfe der Parameter beam.io.BigQueryDisposition ändern.

Zum Erstellen der BigQuery-Tabelle benötigt die Lösung ein Objekt vom Typ TableSchema. In diesem Beispiel sieht das Schema der Ausgabedaten so aus:

  • title: String, Nullwerte zulässig
  • content: String, Nullwerte zulässig
  • topics: String, Nullwerte zulässig
  • title_embed: Float, wiederholt (weil es ein Array von 512 Elementen ist)
  • content_embed: Float, wiederholt (weil es ein Array von 512 Elementen ist)

Der folgende Code zeigt, wie Sie das Objekt TableSchema für BigQuery erstellen.

def get_bigquery_schema():

  from apache_beam.io.gcp.internal.clients import bigquery

  table_schema = bigquery.TableSchema()
  columns = (('topics', 'string', 'nullable'),
             ('title', 'string', 'nullable'),
             ('content', 'string', 'nullable'),
             ('title_embed', 'float', 'repeated'),
             ('content_embed', 'float', 'repeated'))

  for column in columns:
    column_schema = bigquery.TableFieldSchema()
    column_schema.name = column[0]
    column_schema.type = column[1]
    column_schema.mode = column[2]
    table_schema.fields.append(column_schema)

  return table_schema

Pipeline in Dataflow ausführen

Für die Beam ETL-Pipeline brauchen Sie nur das Modul main.py mit den erforderlichen Argumenten auszuführen und das Argument --runner auf DataflowRunner zu setzen. Das Hauptprogramm führt die Methode run_pipeline im Modul pipeline.py aus. Ein Skript im GitHub-Repository zeigt, wie die Konfiguration (z. B. Umgebungsvariablen) festgelegt und wie die Pipeline ausgeführt wird. Diese Auflistung zeigt einen typischen Befehl zum Ausführen der Pipeline:

python main.py \
  --file_pattern=$FILE_PATTERN \
  --bq_project=$PROJECT \
  --bq_dataset=$DATASET \
  --bq_table=$TABLE \
  --transform_temp_dir=$TRANSFORM_TEMP_DIR \
  --transform_export_dir=$TRANSFORM_EXPORT_DIR \
  --enable_tfrecord \
  --tfrecord_export_dir $TFRECORD_EXPORT_DIR \
  --enable_debug \
  --debug_output_prefix=$DEBUG_OUTPUT_PREFIX \
  --project=$PROJECT \
  --runner=$RUNNER \
  --region=$REGION \
  --staging_location=$STAGING_LOCATION \
  --temp_location=$TEMP_LOCATION \
  --setup_file=$(pwd)/setup.py \
  --job_name=$JOB_NAME \
  --worker_machine_type=n1-highmem-2

Abbildung 2 zeigt die Ausführung der Dataflow-Pipeline in der Cloud Console.

Dataflow-Ausführungsdiagramm der Pipeline
Abbildung 2. Dataflow-Ausführungsdiagramm der Pipeline tf.Transform

Ähnliche Artikel in BigQuery finden

Nachdem Sie die Pipeline ausgeführt und die Ausgaben der Reuters-Artikelverarbeitung geladen haben, finden Sie in BigQuery ein Dataset namens reuters und eine dazugehörige Tabelle namens embeddings. Wie Sie sehen können, werden die Titeleinbettung und die Inhaltseinbettung als Float-Arrays (wiederholte Felder) in der Tabelle gespeichert. Wenn Sie die Einbettungen sehen möchten, können Sie folgende Abfrage ausführen:

#standardSQL

SELECT
  title,
  content,
  title_embed,
  content_embed
FROM
  reuters.embeddings
LIMIT 1

Abbildung 3 zeigt ein Beispiel einer Ausgabe, die Sie beim Ausführen dieser SQL-Anweisung erhalten.

Beispielausgabe der BigQuery-Tabelle
Abbildung 3. Beispielausgabe der BigQuery-Tabelle reuters.embeddings

Bei zwei Einbettungsvektoren, A und B, (zwei Arrays vom Typ title_embed oder content_embed) wird die Kosinus-Ähnlichkeit zwischen A und B so berechnet:

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

n ist hier die Anzahl der Elemente im Vektor. (In dem Beispiel hat der Einbettungsvektor 512 Dimensionen.) Diese Formel für die Kosinus-Ähnlichkeit kann in einem BigQuery-SQL-Skript implementiert werden, um den Artikel zu finden, der einem bestimmten anderen Artikel am ähnlichsten ist. Nehmen wir an, Sie möchten die Artikel von Reuters finden, die dem Artikel mit dem Titel "High Winds Keep Vessels Trapped in Baltic Ice" am ähnlichsten sind. Mithilfe der folgenden Abfrage finden Sie anhand des Felds mit den Titeleinbettungen (title_embed) die zehn ähnlichsten Artikel:

#standardSQL

SELECT
  c.k1 as input_article_title,
  c.k2 as similar_article_title,
  SUM(vv1*vv2) / (SQRT(SUM(POW(vv1,2))) * SQRT(SUM(POW(vv2,2)))) AS similarity
FROM
(
  SELECT
    a.key k1, a.val v1, b.key k2, b.val v2
  FROM
  (
    SELECT title key, title_embed val
    FROM reuters.embeddings
    WHERE title LIKE "HIGH WINDS KEEP VESSELS TRAPPED IN BALTIC ICE"
    LIMIT 1

   ) a
  CROSS JOIN
  (
    SELECT title key, title_embed val
    FROM reuters.embeddings
  ) b
) c
, UNNEST(c.v1) vv1 with offset ind1 JOIN UNNEST(c.v2) vv2 with offset ind2 ON (ind1=ind2)
GROUP BY c.k1, c.k2
ORDER BY similarity DESC
LIMIT 10

Die Ergebnisse der Auflistung sollten wie in Abbildung 4 aussehen.

Abfrageergebnisse bei Verwendung von Titeleinbettungen für den Ähnlichkeitsvergleich
Abbildung 4. Abfrageergebnisse bei Verwendung von Titeleinbettungen für den Ähnlichkeitsvergleich

Wenn Sie content_embed anstelle von title_embed verwenden, werden die zehn ähnlichsten Artikel anhand von eingebetteten Inhalten und nicht anhand der Titel ermittelt. Abbildung 5 zeigt die Ergebnisse.

Abfrageergebnisse bei Verwendung von Inhaltseinbettungen für den Ähnlichkeitsvergleich
Abbildung 5. Abfrageergebnisse bei Verwendung von Inhaltseinbettungen für den Ähnlichkeitsvergleich

Wie Sie sehen können, bekommen wir als Ergebnis Artikel, die Schiffe und Unfälle thematisieren, obwohl der Titel des Ursprungsartikels nicht die Wörter "ship" oder "storm" enthält. Der Grund hierfür ist, dass diese Artikel einen semantischen Bezug zu "high winds", "vessels" und "trapped" haben.

Weitere Informationen