Abrufen ähnlicher Datensätze mit Funktionen höherer Reihenfolge

Verwenden Sie Data Distiller-Funktionen in höherer Reihenfolge, um eine Vielzahl gängiger Anwendungsfälle zu lösen. Um ähnliche oder verwandte Datensätze aus einem oder mehreren Datensätzen zu identifizieren und abzurufen, verwenden Sie die Filter-, Transform- und Reduzierungsfunktionen, wie in diesem Handbuch beschrieben. Informationen dazu, wie Funktionen mit höherer Reihenfolge zur Verarbeitung komplexer Datentypen verwendet werden können, finden Sie in der Dokumentation zum Verwalten von Array- und Zuordnungsdatentypen 🔗.

Verwenden Sie dieses Handbuch, um Produkte aus verschiedenen Datensätzen zu identifizieren, die eine signifikante Ähnlichkeit in ihren Eigenschaften oder Attributen aufweisen. Diese Methode bietet u. a. Lösungen für Datendeduplizierung, Datensatzverknüpfung, Empfehlungssysteme, Informationsabruf und Textanalyse.

In diesem Dokument wird die Implementierung eines Ähnlichkeitsjoin beschrieben, bei dem dann die Data Distiller-Funktionen in höherer Reihenfolge verwendet werden, um die Ähnlichkeit zwischen Datensätzen zu berechnen und sie anhand ausgewählter Attribute zu filtern. Für jeden Schritt des Prozesses werden SQL-Code-Snippets und Erklärungen bereitgestellt. Der Workflow implementiert Ähnlichkeitsverbindungen mithilfe der Jaccard-Ähnlichkeitsmessung und -Tokenisierung mithilfe von Data Distiller-Funktionen höherer Reihenfolge. Diese Methoden werden dann verwendet, um ähnliche oder verwandte Datensätze basierend auf einer Ähnlichkeitsmetrik aus einem oder mehreren Datensätzen zu identifizieren und abzurufen. Zu den wichtigsten Abschnitten des Prozesses gehören: Tokenisierung mit Funktionen höherer Reihenfolge, der Kreuzjoin der eindeutigen Elemente, die Berechnung der Ähnlichkeit von Jaccard und die schwellenbasierte Filterung.

Voraussetzungen

Bevor Sie mit diesem Dokument fortfahren, sollten Sie mit den folgenden Konzepten vertraut sein:

Erste Schritte

Die Data Distiller-SKU ist erforderlich, um die Funktionen mit höherer Reihenfolge für Ihre Adobe Experience Platform-Daten auszuführen. Wenn Sie nicht über die Data Distiller-SKU verfügen, wenden Sie sich für weitere Informationen an Ihren Adobe-Kundenbetreuer.

Ähnlichkeit feststellen establish-similarity

Dieser Anwendungsfall erfordert eine Kennzahl zur Ähnlichkeit von Textzeichenfolgen, die später verwendet werden können, um einen Schwellenwert für die Filterung festzulegen. In diesem Beispiel stellen die Produkte in Satz A und Satz B die Wörter in zwei Dokumenten dar.

Die Jaccard-Ähnlichkeitsmessung kann auf eine Vielzahl von Datentypen angewendet werden, einschließlich Textdaten, kategorischen Daten und Binärdaten. Sie eignet sich auch für die Echtzeit- oder Batch-Verarbeitung, da die Berechnung für große Datensätze rechnereffizient erfolgen kann.

Produktsatz A und Satz B enthalten die Testdaten für diesen Workflow.

Um die Jaccard-Ähnlichkeit zwischen den Produktsätzen A und B zu berechnen, suchen Sie zunächst die Schnittmenge (gemeinsame Elemente) der Produktsätze. In diesem Fall {iPhone, iPad}. Suchen Sie als Nächstes die Vereinigung (alle eindeutigen Elemente) beider Produktsätze. In diesem Beispiel {iPhone, iPad, iWatch, iPad Mini, Macbook Pro}.

Verwenden Sie abschließend die Jaccard-Ähnlichkeitsformel: J(A,B) = A∪B / A∩B , um die Ähnlichkeit zu berechnen.

J = Jaccard-Entfernung
A = Satz 1
B = Satz 2

Die Jaccard-Ähnlichkeit zwischen den Produktsätzen A und B beträgt 0,4. Dies weist auf eine mäßige Ähnlichkeit zwischen den in den beiden Dokumenten verwendeten Wörtern hin. Diese Ähnlichkeit zwischen den beiden Sätzen definiert die Spalten in der Ähnlichkeitsverknüpfung. Diese Spalten stellen Informationen oder mit den Daten verknüpfte Eigenschaften dar, die in einer Tabelle gespeichert sind und zur Durchführung der Ähnlichkeitsberechnungen verwendet werden.

Paarweise Jaccard-Berechnung mit Zeichenfolgenähnlichkeit pairwise-similarity

Um die Ähnlichkeiten zwischen Zeichenfolgen genauer zu vergleichen, muss die paarweise Ähnlichkeit berechnet werden. Die paarweise Ähnlichkeit teilt hochdimensionale Objekte zu kleineren dimensionalen Objekten zum Vergleich und zur Analyse auf. Dazu wird eine Textzeichenfolge in kleinere Teile oder Einheiten (Token) unterteilt. Dabei kann es sich um einzelne Briefe, Gruppen von Briefen (wie Silben) oder ganze Wörter handeln. Die Ähnlichkeit wird für jedes Token-Paar zwischen jedem Element in Satz A mit jedem Element in Satz B berechnet. Diese Tokenisierung bietet eine Grundlage für analytische und berechnete Vergleiche, Beziehungen und Erkenntnisse, die aus den Daten gezogen werden können.

Für die paarweise Berechnung der Ähnlichkeit verwendet dieses Beispiel Zeichen in bi-Gramm (zwei Zeichen-Token), um eine Ähnlichkeitsübereinstimmung zwischen den Textzeichenfolgen der Produkte in Satz A und Satz B zu vergleichen. Ein Bikro ist eine Folge von zwei Elementen oder Elementen in einer bestimmten Sequenz oder einem bestimmten Text. Sie können dies zu n Gramm verallgemeinern.

In diesem Beispiel wird davon ausgegangen, dass die Groß-/Kleinschreibung keine Rolle spielt und Leerzeichen nicht berücksichtigt werden sollten. Gemäß diesen Kriterien haben Set A und Set B die folgenden bi-Gramm:

Produktsatz A bi-Gramm:

Produktsatz B bi-Gramm:

Als Nächstes berechnen Sie den Jaccard-Ähnlichkeitskoeffizienten für jedes Paar:

Testdaten mit SQL erstellen create-test-data

Verwenden Sie die Anweisung SQL CREATE TABLE , um manuell eine Testtabelle für die Produktsätze zu erstellen.

CREATE TABLE featurevector1 AS SELECT *
FROM (
    SELECT 'iPad' AS ProductName
    UNION ALL
    SELECT 'iPhone'
    UNION ALL
    SELECT 'iWatch'
     UNION ALL
    SELECT 'iPad Mini'
);
SELECT * FROM featurevector1;

Die folgenden Beschreibungen enthalten eine Aufschlüsselung des obigen SQL-Codeblocks:

Die SQL-Anweisung erstellt eine Tabelle wie unten dargestellt:

Verwenden Sie die folgende SQL-Anweisung, um den zweiten Funktionsvektor zu erstellen:

CREATE TABLE featurevector2 AS SELECT *
FROM (
    SELECT 'iPad' AS ProductName
    UNION ALL
    SELECT 'iPhone'
    UNION ALL
    SELECT 'Macbook Pro'
);
SELECT * FROM featurevector2;

Datenumwandlungen data-transformation

In diesem Beispiel müssen mehrere Aktionen durchgeführt werden, um die Sets genau zu vergleichen. Zunächst werden alle Leerzeichen aus den Funktionsvektoren entfernt, da davon ausgegangen wird, dass sie nicht zur Ähnlichkeitsmessung beitragen. Anschließend werden alle im Funktionsvektor vorhandenen Duplikate entfernt, da sie die Rechenverarbeitung verschwenden. Als Nächstes werden Token mit zwei Zeichen (in Gramm) aus den Funktionsvektoren extrahiert. In diesem Beispiel wird davon ausgegangen, dass sie sich überschneiden.

Die folgenden Abschnitte veranschaulichen die erforderlichen Datenumwandlungen wie Deduplizierung, Entfernen von Leerzeichen und Konvertierung in Kleinbuchstaben, bevor der Tokenisierungsprozess gestartet wird.

Deduplizierung deduplication

Verwenden Sie als Nächstes die DISTINCT -Klausel, um Duplikate zu entfernen. In diesem Beispiel gibt es keine Duplikate. Es ist jedoch ein wichtiger Schritt, die Genauigkeit von Vergleichen zu verbessern. Die erforderliche SQL-Anweisung wird unten angezeigt:

SELECT DISTINCT(ProductName) AS featurevector1_distinct FROM featurevector1
SELECT DISTINCT(ProductName) AS featurevector2_distinct FROM featurevector2

Entfernen von Leerzeichen whitespace-removal

In der folgenden SQL-Anweisung werden die Leerzeichen aus den Feature Vectors entfernt. Der Teil replace(ProductName, ' ', '') AS featurevector1_nospaces der Abfrage nimmt die Spalte ProductName aus der Tabelle featurevector1 und verwendet die Funktion replace(). Die Funktion REPLACE ersetzt alle Vorkommnisse eines Leerzeichens (' ') durch eine leere Zeichenfolge (''). Dadurch werden alle Leerzeichen aus den ProductName -Werten entfernt. Das Ergebnis wird als featurevector1_nospaces Alias angezeigt.

SELECT DISTINCT(ProductName) AS featurevector1_distinct, replace(ProductName, ' ', '') AS featurevector1_nospaces FROM featurevector1

Die Ergebnisse sind in der folgenden Tabelle dargestellt:

Die SQL-Anweisung und ihre Ergebnisse für den zweiten Funktionsvektor sind unten dargestellt:

SELECT DISTINCT(ProductName) AS featurevector2_distinct, replace(ProductName, ' ', '') AS featurevector2_nospaces FROM featurevector2

In Kleinbuchstaben konvertieren lowercase-conversion

Anschließend wird die SQL dahingehend verbessert, dass die Produktnamen in Kleinbuchstaben konvertiert und alle Leerzeichen entfernt werden. Die untere Funktion (lower(...)) wird auf das Ergebnis der Funktion replace() angewendet. Die untere Funktion konvertiert alle Zeichen in den geänderten ProductName -Werten in Kleinbuchstaben. Dadurch wird sichergestellt, dass die Werte unabhängig von der Originalschreibweise in Kleinbuchstaben geschrieben werden.

SELECT DISTINCT(ProductName) AS featurevector1_distinct, lower(replace(ProductName, ' ', '')) AS featurevector1_transform FROM featurevector1;

Das Ergebnis dieser Aussage ist:

Die SQL-Anweisung und ihre Ergebnisse für den zweiten Funktionsvektor sind unten dargestellt:

SELECT DISTINCT(ProductName) AS featurevector2_distinct, lower(replace(ProductName, ' ', '')) AS featurevector2_transform FROM featurevector2

Token mit SQL extrahieren tokenization

Der nächste Schritt ist die Tokenisierung oder Textaufteilung. Tokenisierung ist der Prozess, Text in einzelne Begriffe zu unterteilen. In der Regel besteht dies darin, Sätze in Wörter zu unterteilen. In diesem Beispiel werden Zeichenfolgen in bi-Gramm (und in Gramm höherer Ordnung) aufgeteilt, indem Token mit SQL-Funktionen wie regexp_extract_all extrahiert werden. Für eine wirksame Tokenisierung müssen überschneidende bi-Gramm generiert werden.

Die SQL wurde weiter verbessert und verwendet nun regexp_extract_all. regexp_extract_all(lower(replace(ProductName, ' ', '')), '.{2}', 0) AS tokens: Dieser Teil der Abfrage verarbeitet die geänderten ProductName -Werte weiter, die im vorherigen Schritt erstellt wurden. Es verwendet die Funktion regexp_extract_all() , um alle nicht überlappenden Teilzeichenfolgen von ein bis zwei Zeichen aus den geänderten und kleingeschriebenen ProductName -Werten zu extrahieren. Das Muster für reguläre Ausdrücke .{2} entspricht Teilzeichenfolgen von zwei Zeichen in der Länge. Der Teil regexp_extract_all(..., '.{2}', 0) der Funktion extrahiert dann alle übereinstimmenden Unterzeichenfolgen aus dem Eingabetext.

SELECT DISTINCT(ProductName) AS featurevector1_distinct, lower(replace(ProductName, ' ', '')) AS featurevector1_transform,
regexp_extract_all(lower(replace(ProductName, ' ', '')) , '.{2}', 0) AS tokens
FROM featurevector1;

Die Ergebnisse sind in der folgenden Tabelle dargestellt:

Um die Genauigkeit weiter zu verbessern, muss SQL zur Erstellung überlappender Token verwendet werden. Beispielsweise fehlt in der obigen Zeichenfolge "iPad"das Token "pa". Um dies zu beheben, verschieben Sie den Lookahead-Operator (mit substring) um einen Schritt und generieren Sie die bi-Gramm.

Ähnlich wie im vorherigen Schritt extrahiert regexp_extract_all(lower(replace(substring(ProductName, 2), ' ', '')), '.{2}', 0): aus dem modifizierten Produktnamen aus zwei Zeichen, beginnt jedoch mit dem zweiten Zeichen mit der substring -Methode, um überlappende Token zu erstellen. Anschließend kombiniert die Funktion array_union() in den Zeilen 3-7 (array_union(...) AS tokens) die Arrays von zweistelligen Sequenzen, die von den beiden Extraktionen des regulären Ausdrucks erhalten werden. Dadurch wird sichergestellt, dass das Ergebnis eindeutige Token aus nicht überlappenden und überlappenden Sequenzen enthält.

SELECT DISTINCT(ProductName) AS featurevector1_distinct,
       lower(replace(ProductName, ' ', '')) AS featurevector1_transform,
       array_union(
           regexp_extract_all(lower(replace(ProductName, ' ', '')), '.{2}', 0),
           regexp_extract_all(lower(replace(substring(ProductName, 2), ' ', '')), '.{2}', 0)
       ) AS tokens
FROM featurevector1;

Die Ergebnisse sind in der folgenden Tabelle dargestellt:

Die Verwendung von substring als Lösung des Problems hat jedoch Einschränkungen. Wenn Sie Token aus dem Text basierend auf Tri-Gramm (drei Zeichen) erstellen würden, würde die Verwendung von zwei substrings erforderlich sein, um zweimal nach vorne zu suchen, um die erforderlichen Verschiebungen zu erhalten. Für 10 Gramm benötigen Sie neun substring Ausdrücke. Dies würde den Code aufblasen und unhaltbar machen. Die Verwendung von einfachen regulären Ausdrücken ist nicht geeignet. Es bedarf eines neuen Ansatzes.

Anpassen der Länge des Produktnamens length-adjustment

Das SQl kann mit der Sequenz- und Längenfunktion verbessert werden. Im folgenden Beispiel generiert sequence(1, length(lower(replace(ProductName, ' ', ''))) - 3) eine Zahlenfolge von eins bis zur Länge des modifizierten Produktnamen abzüglich drei. Wenn der geänderte Produktname beispielsweise "ipadmini"mit einer Zeichenlänge von acht Zeichen ist, werden Zahlen von einem bis fünf (acht bis drei) generiert.

Die nachstehende Anweisung extrahiert eindeutige Produktnamen und unterteilt jeden Namen in Zeichenfolgen (Token) mit einer Länge von vier Zeichen, ohne Leerzeichen, und stellt sie in zwei Spalten dar. Eine Spalte zeigt die eindeutigen Produktnamen und die andere Spalte die generierten Token.

SELECT
   DISTINCT(ProductName) AS featurevector1_distinct,
  transform(
    sequence(1, length(lower(replace(ProductName, ' ', ''))) - 3),
    i -> substring(lower(replace(ProductName, ' ', '')), i, 4)
  ) AS tokens
FROM
  featurevector1;

Die Ergebnisse sind in der folgenden Tabelle dargestellt:

Festlegen der Token-Länge ensure-set-token-length

Der Anweisung können zusätzliche Bedingungen hinzugefügt werden, um sicherzustellen, dass die erzeugten Sequenzen eine bestimmte Länge aufweisen. Die folgende SQL-Anweisung erweitert die Logik der Tokenerstellung, indem die Funktion transform komplexer wird. Die Anweisung verwendet die Funktion filter innerhalb von transform, um sicherzustellen, dass die generierten Sequenzen eine Länge von sechs Zeichen haben. Sie behandelt die Fälle, in denen dies nicht möglich ist, indem sie diesen Positionen NULL-Werte zuweist.

SELECT
  DISTINCT(ProductName) AS featurevector1_distinct,
  transform(
    filter(
      sequence(1, length(lower(replace(ProductName, ' ', ''))) - 5),
      i -> i + 5 <= length(lower(replace(ProductName, ' ', '')))
    ),
    i -> CASE WHEN length(substring(lower(replace(ProductName, ' ', '')), i, 6)) = 6
               THEN substring(lower(replace(ProductName, ' ', '')), i, 6)
               ELSE NULL
          END
  ) AS tokens
FROM
  featurevector1;

Die Ergebnisse sind in der folgenden Tabelle dargestellt:

Lösungen mit Data Distiller-Funktionen in höherer Reihenfolge durchsuchen higher-order-function-solutions

Funktionen mit höherer Reihenfolge sind leistungsstarke Konstrukte, mit denen Sie "Programmierung"wie Syntax in Data Distiller implementieren können. Sie können verwendet werden, um eine Funktion über mehrere Werte in einem Array zu iterieren.

Im Kontext von Data Distiller eignen sich Funktionen mit höherer Reihenfolge ideal zum Erstellen von n Gramm und Iterieren von Zeichensatzsequenzen.

Die Funktion "reduce", insbesondere wenn sie in durch transform generierten Sequenzen verwendet wird, bietet eine Möglichkeit, kumulative Werte oder Aggregate abzuleiten, die in verschiedenen Analyse- und Planungsprozessen ausschlaggebend sein können.

In der unten stehenden SQl-Anweisung aggregiert die Funktion reduce() beispielsweise Elemente in einem Array mithilfe eines benutzerdefinierten Aggregators. Es simuliert eine for -Schleife, um die kumulativen Summen aller Ganzzahlen zu erstellen, die von 1 bis 5. 2.1, 1+2, 1+2+3, 1+2+3+4, 1+2+3+4

SELECT transform(
    sequence(1, 5),
    x -> reduce(
        sequence(1, x),
        0,  -- Initial accumulator value
        (acc, y) -> acc + y  -- Higher-order function to add numbers
    )
) AS sum_result;

Im Folgenden finden Sie eine Analyse der SQL-Anweisung:

Zusammenfassend lässt sich sagen, dass diese Funktion mit höherer Reihenfolge zwei Parameter (acc und y) akzeptiert und den auszuführenden Vorgang definiert, in diesem Fall also y zum Akkumulator acc hinzufügt. Diese Funktion in höherer Reihenfolge wird für jedes Element in der Sequenz während des Reduzierungsprozesses ausgeführt.

Die Ausgabe dieser Anweisung ist eine einzelne Spalte (sum_result), die die kumulativen Summen der Zahlen von einer bis fünf enthält.

Der Wert von Funktionen mit höherer Reihenfolge value-of-higher-order-functions

In diesem Abschnitt wird eine reduzierte Version einer tri-Gramm-SQL-Anweisung analysiert, um den Wert von Funktionen mit höherer Reihenfolge in Data Distiller besser zu verstehen, um n-Gramm effizienter zu erstellen.

Die folgende Anweisung arbeitet mit der Spalte ProductName in der Tabelle featurevector1. Es wird ein Satz aus dreistelligen Unterzeichenfolgen erzeugt, die aus den modifizierten Produktnamen in der Tabelle abgeleitet werden, wobei Positionen aus der erzeugten Sequenz verwendet werden.

SELECT
  transform(
    sequence(1, length(lower(replace(ProductName, ' ', ''))) - 2),
    i -> substring(lower(replace(ProductName, ' ', '')), i, 3)
  )
FROM
  featurevector1

Im Folgenden finden Sie eine Analyse der SQL-Anweisung:

Die Ausgabe ist eine Liste von Teilzeichenfolgen mit einer Länge von drei Zeichen, die aus den modifizierten Produktnamen extrahiert werden, basierend auf den in der Sequenz angegebenen Positionen.

Ergebnisse filtern filter-results

Die Funktion filter mit nachfolgenden Datenumwandlungen ermöglicht eine verfeinerte und präzisere Extraktion relevanter Informationen aus Textdaten. Auf diese Weise können Sie Einblicke gewinnen, die Datenqualität verbessern und bessere Entscheidungsprozesse erleichtern.

Die Funktion filter in der folgenden SQL-Anweisung dient dazu, die Reihenfolge der Positionen innerhalb der Zeichenfolge, aus der Unterzeichenfolgen mithilfe der nachfolgenden Transformationsfunktion extrahiert werden, zu verfeinern und zu begrenzen.

SELECT
  transform(
    filter(
      sequence(1, length(lower(replace(ProductName, ' ', ''))) - 6),
      i -> i + 6 <= length(lower(replace(ProductName, ' ', '')))
    ),
    i -> CASE WHEN length(substring(lower(replace(ProductName, ' ', '')), i, 7)) = 7
               THEN substring(lower(replace(ProductName, ' ', '')), i, 7)
               ELSE NULL
          END
  )
FROM
  featurevector1;

Die Funktion filter generiert eine Sequenz gültiger Startpositionen innerhalb des modifizierten ProductName und extrahiert Teilzeichenfolgen einer bestimmten Länge. Es sind nur Startpositionen zulässig, die die Extraktion einer siebenstelligen Unterzeichenfolge ermöglichen.

Die Bedingung i -> i + 6 <= length(lower(replace(ProductName, ' ', ''))) stellt sicher, dass die Startposition i plus 6 (die Länge der gewünschten siebenstelligen Unterzeichenfolge minus 1) nicht die Länge der modifizierten ProductName überschreitet.

Die Anweisung CASE wird verwendet, um Unterzeichenfolgen basierend auf ihrer Länge bedingt ein- oder auszuschließen. Es sind nur siebenstellige Unterzeichenfolgen enthalten, andere werden durch NULL ersetzt. Diese Unterzeichenfolgen werden dann von der Funktion transform verwendet, um eine Sequenz von Unterzeichenfolgen aus der Spalte ProductName in der Tabelle featurevector1 zu erstellen.

Berechnen der Cross-Join-Funktion für eindeutige Elemente über zwei Funktionsvektoren hinweg cross-join-unique-elements

Die Identifizierung der Unterschiede oder Diskrepanzen zwischen den beiden Datensätzen basierend auf einer spezifischen Datenumwandlung ist ein gängiger Prozess, um die Datengenauigkeit zu wahren, die Datenqualität zu verbessern und die Konsistenz über Datensätze hinweg sicherzustellen.

Diese SQL-Anweisung unten extrahiert die eindeutigen Produktnamen, die in "featurevector2", aber nicht in "featurevector1"vorhanden sind, nachdem die Transformationen angewendet wurden.

SELECT lower(replace(ProductName, ' ', '')) FROM featurevector2
EXCEPT
SELECT lower(replace(ProductName, ' ', '')) FROM featurevector1;

Die Ergebnisse sind in der folgenden Tabelle dargestellt:

Führen Sie als Nächstes einen Join durch, um Elemente aus den beiden Funktionsvektoren zu kombinieren und so Elementpaare zum Vergleich zu erstellen. Der erste Schritt in diesem Prozess besteht darin, einen tokenisierten Vektor zu erstellen.

Ein tokenisierter Vektor ist eine strukturierte Darstellung von Textdaten, bei der jedes Wort, jeder Satz oder jede Einheit der Bedeutung (Token) in ein numerisches Format konvertiert wird. Diese Konvertierung ermöglicht es den Algorithmen zur Verarbeitung natürlicher Sprachen, Textinformationen zu verstehen und zu analysieren.

Der nachstehende SQl erstellt einen tokenisierten Vektor.

CREATE TABLE featurevector1tokenized AS SELECT
  DISTINCT(ProductName) AS featurevector1_distinct,
  transform(
    filter(
      sequence(1, length(lower(replace(ProductName, ' ', ''))) - 1),
      i -> i + 1 <= length(lower(replace(ProductName, ' ', '')))
    ),
    i -> CASE WHEN length(substring(lower(replace(ProductName, ' ', '')), i, 2)) = 2
               THEN substring(lower(replace(ProductName, ' ', '')), i, 2)
               ELSE NULL
          END
  ) AS tokens
FROM
  (SELECT lower(replace(ProductName, ' ', '')) AS ProductName FROM featurevector1);
SELECT * FROM featurevector1tokenized;

Die Ergebnisse sind in der folgenden Tabelle dargestellt:

Wiederholen Sie dann den Prozess für featurevector2:

CREATE TABLE featurevector2tokenized AS
SELECT
  DISTINCT(ProductName) AS featurevector2_distinct,
  transform(
    filter(
      sequence(1, length(lower(replace(ProductName, ' ', ''))) - 1),
      i -> i + 1 <= length(lower(replace(ProductName, ' ', '')))
    ),
    i -> CASE WHEN length(substring(lower(replace(ProductName, ' ', '')), i, 2)) = 2
               THEN substring(lower(replace(ProductName, ' ', '')), i, 2)
               ELSE NULL
          END
  ) AS tokens
FROM
(SELECT lower(replace(ProductName, ' ', '')) AS ProductName FROM featurevector2
);
SELECT * FROM featurevector2tokenized;

Die Ergebnisse sind in der folgenden Tabelle dargestellt:

Nachdem beide tokenisierten Vektoren abgeschlossen sind, können Sie nun den Cross-Join erstellen. Dies wird in der folgenden SQL angezeigt:

SELECT
    A.featurevector1_distinct AS SetA_ProductNames,
    B.featurevector2_distinct AS SetB_ProductNames,
    A.tokens AS SetA_tokens1,
    B.tokens AS SetB_tokens2
FROM
    featurevector1tokenized A
CROSS JOIN
    featurevector2tokenized B;

Im Folgenden finden Sie eine Zusammenfassung des SQl, das zum Erstellen des Joins verwendet wird:

Die Ergebnisse sind in der folgenden Tabelle dargestellt:

Berechnung der Jaccard-Ähnlichkeitsmessung compute-the-jaccard-similarity-measure

Als Nächstes berechnen Sie den Jaccard-Ähnlichkeitskoeffizienten, um eine Ähnlichkeitsanalyse zwischen den beiden Sätzen von Produktnamen durchzuführen, indem Sie deren tokenisierte Darstellungen vergleichen. Die Ausgabe des unten stehenden SQL-Skripts liefert Folgendes: Produktnamen aus beiden Sets, ihre tokenisierten Darstellungen, die Anzahl der gemeinsamen und gesamten eindeutigen Token und den berechneten Jaccard-Ähnlichkeitskoeffizienten für jedes Paar von Datensätzen.

SELECT
    SetA_ProductNames,
    SetB_ProductNames,
    SetA_tokens1,
    SetB_tokens2,
    size(array_intersect(SetA_tokens1, SetB_tokens2)) AS token_intersect_count,
    size(array_union(SetA_tokens1, SetB_tokens2)) AS token_union_count,
    ROUND(
        CAST(size(array_intersect(SetA_tokens1, SetB_tokens2)) AS DOUBLE) /    size(array_union(SetA_tokens1, SetB_tokens2)), 2) AS jaccard_similarity
FROM
    (SELECT
        A.featurevector1_distinct AS SetA_ProductNames,
        B.featurevector2_distinct AS SetB_ProductNames,
        A.tokens AS SetA_tokens1,
        B.tokens AS SetB_tokens2
    FROM
        featurevector1tokenized A
    CROSS JOIN
        featurevector2tokenized B
    );

Im Folgenden finden Sie eine Zusammenfassung der SQL, die zur Berechnung des Jaccard-Ähnlichkeitskoeffizienten verwendet wird:

Die Ergebnisse sind in der folgenden Tabelle dargestellt:

Filtern von Ergebnissen basierend auf dem Jaccard-Schwellenwert für Ähnlichkeit similarity-threshold-filter

Filtern Sie schließlich die Ergebnisse anhand eines vordefinierten Schwellenwerts, um nur die Paare auszuwählen, die den Ähnlichkeitskriterien entsprechen. Die folgende SQL-Anweisung filtert die Produkte mit einem Jaccard-Ähnlichkeitskoeffizienten von mindestens 0,4. Dadurch werden die Ergebnisse auf Paare reduziert, die einen erheblichen Grad an Ähnlichkeit aufweisen.

SELECT
    SetA_ProductNames,
    SetB_ProductNames
FROM
(SELECT
    SetA_ProductNames,
    SetB_ProductNames,
    SetA_tokens1,
    SetB_tokens2,
    size(array_intersect(SetA_tokens1, SetB_tokens2)) AS token_intersect_count,
    size(array_union(SetA_tokens1, SetB_tokens2)) AS token_union_count,
    ROUND(
        CAST(size(array_intersect(SetA_tokens1, SetB_tokens2)) AS DOUBLE) / size(array_union(SetA_tokens1, SetB_tokens2)),
        2
    ) AS jaccard_similarity
FROM
    (SELECT
        A.featurevector1_distinct AS SetA_ProductNames,
        B.featurevector2_distinct AS SetB_ProductNames,
        A.tokens AS SetA_tokens1,
        B.tokens AS SetB_tokens2
    FROM
        featurevector1tokenized A
    CROSS JOIN
        featurevector2tokenized B
    )
)
WHERE jaccard_similarity>=0.4

Die Ergebnisse dieser Abfrage geben die Spalten für die Ähnlichkeitsverknüpfung an, wie unten dargestellt: