Récupération d’enregistrements similaires avec des fonctions d’ordre supérieur

Utilisez les fonctions d’ordre supérieur de Data Distiller pour résoudre divers cas d’utilisation courants. Pour identifier et récupérer des enregistrements similaires ou associés d’un ou plusieurs jeux de données, utilisez le filtre, la transformation et la réduction des fonctions comme décrit dans ce guide. Pour savoir comment utiliser des fonctions d’ordre supérieur pour traiter des types de données complexes, consultez la documentation sur la gestion des types de données de tableau et de mappage.

Utilisez ce guide pour identifier les produits provenant de différents jeux de données présentant une similarité significative de leurs caractéristiques ou attributs. Cette méthodologie fournit des solutions pour : déduplication des données, liaison d’enregistrements, systèmes de recommandation, récupération d’informations et analyse de texte, entre autres.

Le document décrit le processus d’implémentation d’une jointure par analogie, qui utilise ensuite les fonctions d’ordre supérieur de Data Distiller pour calculer la similarité entre des jeux de données et les filtrer selon des attributs sélectionnés. Des fragments de code SQL et des explications sont fournis pour chaque étape du processus. Le workflow met en oeuvre des jointures par similarité à l’aide de la mesure de similarité Jaccard et de la segmentation en jetons à l’aide des fonctions d’ordre supérieur de Data Distiller. Ces méthodes sont ensuite utilisées pour identifier et récupérer des enregistrements similaires ou associés d’un ou plusieurs jeux de données basés sur une mesure de similarité. Les sections clés du processus incluent : segmentation en unités lexicales à l’aide de fonctions d’ordre supérieur, la ​ jointure croisée d’éléments uniques, le calcul de similarité Jaccard et le }filtrage basé sur les seuils.

Conditions préalables

Avant de poursuivre ce document, vous devez connaître les concepts suivants :

Commencer

Le SKU de Data Distiller est nécessaire pour exécuter les fonctions d’ordre supérieur sur vos données Adobe Experience Platform. Si vous ne possédez pas le SKU de Data Distiller, contactez votre représentant du service client Adobe pour plus d’informations.

Établir une similarité establish-similarity

Ce cas pratique nécessite une mesure de similarité entre des chaînes de texte qui peuvent être utilisées ultérieurement pour établir un seuil de filtrage. Dans cet exemple, les produits des jeux A et B représentent les mots de deux documents.

La mesure de similarité Jaccard peut être appliquée à un large éventail de types de données, y compris des données texte, des données catégoriques et des données binaires. Il est également adapté au traitement en temps réel ou par lots, car il peut être efficace sur le plan du calcul pour calculer les jeux de données volumineux.

Les ensembles de produits A et B contiennent les données de test pour ce workflow.

Pour calculer la similarité Jaccard entre les ensembles de produits A et B, recherchez d’abord l’ intersection (éléments communs) des ensembles de produits. Dans ce cas, {iPhone, iPad}. Recherchez ensuite l’ union (tous les éléments uniques) des deux ensembles de produits. Dans cet exemple, {iPhone, iPad, iWatch, iPad Mini, Macbook Pro}.

Enfin, utilisez la formule de similarité Jaccard : J(A,B) = A∪B / A∩B pour calculer la similarité.

J = distance de Jaccard
A = définie 1
B = définie 2

La similitude Jaccard entre les ensembles de produits A et B est 0.4. Cela indique un degré modéré de similitude entre les mots utilisés dans les deux documents. Cette similarité entre les deux ensembles définit les colonnes de la jointure par similarité. Ces colonnes représentent des informations, ou des caractéristiques associées aux données, qui sont stockées dans un tableau et utilisées pour effectuer des calculs de similarité.

Calcul de la carte par paires avec similarité de chaînes pairwise-similarity

Pour comparer plus précisément les similitudes entre les chaînes, la similarité au niveau des paires doit être calculée. La similarité par paires divise les objets hautement dimensionnels en objets dimensionnels plus petits pour la comparaison et l’analyse. Pour ce faire, une chaîne de texte est divisée en unités ou en parties plus petites (jetons). Il peut s’agir de lettres individuelles, de groupes de lettres (comme des syllabes) ou de mots entiers. La similarité est calculée pour chaque paire de jetons entre chaque élément du jeu A et chaque élément du jeu B. Cette segmentation fournit une base pour les comparaisons analytiques et computationnelles, les relations et les informations à tirer des données.

Pour le calcul des similarités au niveau des paires, cet exemple utilise des bigrammes de caractères (jetons de deux caractères) pour comparer une correspondance de similarité entre les chaînes de texte des produits des jeux A et B. Un bi-gramme est une séquence consécutive de deux éléments ou éléments dans une séquence ou un texte donné. Vous pouvez généraliser ceci en n-grammes.

Cet exemple suppose que la casse n’a pas d’importance et que les espaces ne doivent pas être pris en compte. Selon ces critères, les ensembles A et B présentent les deux grammes suivants :

Jeu de produits A bi-grammes :

bi-grammes de la visionneuse de produits B :

Ensuite, calculez le coefficient de similarité Jaccard pour chaque paire :

Création des données de test avec SQL create-test-data

Pour créer manuellement un tableau de test pour les ensembles de produits, utilisez l’instruction SQL CREATE TABLE .

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;

Les descriptions suivantes fournissent une ventilation du bloc de code SQL ci-dessus :

L’instruction SQL crée un tableau comme illustré ci-dessous :

Pour créer le second vecteur de fonctionnalité, utilisez l’instruction SQL suivante :

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

Conversion des données data-transformation

Dans cet exemple, plusieurs actions doivent être effectuées pour comparer précisément les visionneuses. Tout d’abord, les espaces blancs sont supprimés des vecteurs de fonctionnalités, puisqu’il est supposé qu’ils ne contribuent pas à la mesure de similarité. Ensuite, tous les doublons présents dans le vecteur de fonctionnalité sont supprimés lorsqu’ils perdent le traitement informatique. Ensuite, les jetons de deux caractères (bi-grammes) sont extraits des vecteurs de fonctionnalités. Dans cet exemple, elles se chevauchent.

Les sections suivantes illustrent les transformations de données prérequises telles que le dédoublonnage, la suppression d’espaces et la conversion en minuscules avant de lancer le processus de segmentation en unités lexicales.

Déduplication deduplication

Ensuite, utilisez la clause DISTINCT pour supprimer les doublons. Il n’existe aucun doublon dans cet exemple, mais il s’agit d’une étape importante pour améliorer la précision de toute comparaison. Le code SQL nécessaire est affiché ci-dessous :

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

Suppression des espaces blancs whitespace-removal

Dans l’instruction SQL suivante, les espaces sont supprimés des vecteurs de fonctionnalités. La partie replace(ProductName, ' ', '') AS featurevector1_nospaces de la requête extrait la colonne ProductName de la table featurevector1 et utilise la fonction replace(). La fonction REPLACE remplace toutes les occurrences d’un espace (’ ’) par une chaîne vide (’). Cela supprime effectivement tous les espaces des valeurs ProductName. Le résultat comporte un alias featurevector1_nospaces.

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

Les résultats sont présentés dans le tableau ci-dessous :

L’instruction SQL et ses résultats sur le deuxième vecteur de fonctionnalité sont présentés ci-dessous :

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

Convertir en minuscules lowercase-conversion

Ensuite, le code SQL est amélioré pour convertir les noms de produits en minuscules et supprimer les espaces. La fonction inférieure (lower(...)) est appliquée au résultat de la fonction replace(). La fonction lower convertit en minuscules tous les caractères des valeurs ProductName modifiées. Cela garantit que les valeurs sont en minuscules, quelle que soit leur casse d’origine.

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

Le résultat de cette instruction est le suivant :

L’instruction SQL et ses résultats sur le deuxième vecteur de fonctionnalité sont présentés ci-dessous :

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

Extraction de jetons à l’aide de SQL tokenization

L’étape suivante est la segmentation en unités lexicales ou le fractionnement de texte. La Tokenization est le processus consistant à prendre du texte et à le diviser en termes individuels. Cela implique généralement de diviser des phrases en mots. Dans cet exemple, les chaînes sont ventilées en bi-grammes (et n-grammes de plus grand ordre) en extrayant des jetons à l’aide de fonctions SQL telles que regexp_extract_all. Les doublons doivent être générés pour une segmentation efficace.

Le code SQL a été amélioré de manière à utiliser regexp_extract_all. regexp_extract_all(lower(replace(ProductName, ' ', '')), '.{2}', 0) AS tokens: Cette partie de la requête traite davantage les valeurs ProductName modifiées créées à l’étape précédente. Elle utilise la fonction regexp_extract_all() pour extraire toutes les sous-chaînes qui ne se chevauchent pas de un à deux caractères des valeurs ProductName modifiées et en minuscules. Le modèle d’expression régulière .{2} correspond à des sous-chaînes de deux caractères de longueur. La partie regexp_extract_all(..., '.{2}', 0) de la fonction extrait ensuite toutes les sous-chaînes correspondantes du texte d’entrée.

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

Les résultats sont présentés dans le tableau ci-dessous :

Pour améliorer davantage la précision, le code SQL doit être utilisé pour créer des jetons qui se chevauchent. Par exemple, la chaîne "iPad" ci-dessus ne contient pas le jeton "pa". Pour corriger ce problème, déplacez l’opérateur de recherche en amont (à l’aide de substring) d’une étape et générez les bigrammes.

Tout comme l’étape précédente, regexp_extract_all(lower(replace(substring(ProductName, 2), ' ', '')), '.{2}', 0): extrait des séquences de deux caractères du nom du produit modifié, mais commence par le deuxième caractère à l’aide de la méthode substring pour créer des jetons qui se chevauchent. Ensuite, dans les lignes 3 à 7 (array_union(...) AS tokens), la fonction array_union() combine les tableaux de séquences de deux caractères obtenus par les deux extractions d’expression régulière. Cela permet de s’assurer que le résultat contient des jetons uniques provenant de séquences qui ne se chevauchent pas et qui se chevauchent.

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;

Les résultats sont présentés dans le tableau ci-dessous :

Cependant, l’utilisation de substring comme solution au problème présente des limites. Si vous deviez créer des jetons à partir du texte en fonction de trois grammes (trois caractères), il faudrait utiliser deux substrings pour effectuer deux recherches en amont afin d’obtenir les décalages requis. Pour produire 10 grammes, vous avez besoin de neuf expressions substring. Cela ferait gonfler le code et cela deviendrait intenable. L’utilisation d’expressions régulières simples n’est pas appropriée. Une nouvelle approche est nécessaire.

Ajuster à la longueur du nom du produit length-adjustment

Le SQl peut être amélioré grâce aux fonctions de séquence et de longueur. Dans l’exemple suivant, sequence(1, length(lower(replace(ProductName, ' ', ''))) - 3) génère une séquence de nombres de un à la longueur du nom de produit modifié moins trois. Par exemple, si le nom du produit modifié est "ipadmini" avec une longueur de huit caractères, il génère des nombres de un à cinq (huit à trois).

L’instruction ci-dessous extrait des noms de produits uniques, puis décompose chaque nom en séquences de caractères (jetons) de quatre longueurs de caractères, à l’exclusion des espaces et les présente sous la forme de deux colonnes. Une colonne affiche les noms uniques des produits et l’autre les jetons générés.

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;

Les résultats sont présentés dans le tableau ci-dessous :

Vérification de la longueur du jeton définie ensure-set-token-length

Des conditions supplémentaires peuvent être ajoutées à l’instruction pour s’assurer que les séquences générées ont une longueur spécifique. L’instruction SQL suivante développe la logique de génération de jeton en rendant la fonction transform plus complexe. L’instruction utilise la fonction filter dans transform pour s’assurer que les séquences générées ont une longueur de six caractères. Il gère les cas où cela n’est pas possible en attribuant des valeurs NULL à ces positions.

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;

Les résultats sont présentés dans le tableau ci-dessous :

Exploration des solutions à l’aide des fonctions d’ordre supérieur de Data Distiller higher-order-function-solutions

Les fonctions d’ordre supérieur sont des constructions puissantes qui vous permettent de mettre en oeuvre une "programmation" comme la syntaxe dans Data Distiller. Ils peuvent être utilisés pour itérer une fonction sur plusieurs valeurs d’un tableau.

Dans le contexte de Data Distiller, les fonctions d’ordre supérieur sont idéales pour créer des n-grammes et itérer sur des séquences de caractères.

La fonction reduce, en particulier lorsqu’elle est utilisée dans des séquences générées par transform, permet d’obtenir des valeurs cumulatives ou des agrégats, qui peuvent être essentiels dans divers processus d’analyse et de planification.

Par exemple, dans l’instruction SQl ci-dessous, la fonction reduce() agrège des éléments dans un tableau à l’aide d’un agrégateur personnalisé. Il simule une boucle for pour créer les sommes cumulées de tous les nombres entiers de un à cinq. 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;

Voici une analyse de l’instruction SQL :

Pour résumer, cette fonction d’ordre supérieur prend deux paramètres (acc et y) et définit l’opération à effectuer, qui dans ce cas ajoute y à l’accumulateur acc. Cette fonction d’ordre supérieur est exécutée pour chaque élément de la séquence pendant le processus de réduction.

La sortie de cette instruction est une seule colonne (sum_result) qui contient les sommes cumulées de nombres comprises entre 1 et 5.

La valeur des fonctions d’ordre supérieur value-of-higher-order-functions

Cette section analyse une version abrégée d’une instruction SQL à trois grammes afin de mieux comprendre la valeur des fonctions d’ordre supérieur dans Data Distiller pour créer des n-grammes plus efficacement.

L’instruction ci-dessous fonctionne sur la colonne ProductName de la table featurevector1. Elle produit un ensemble de sous-chaînes de trois caractères dérivées des noms de produits modifiés dans le tableau, à l’aide de positions obtenues à partir de la séquence générée.

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

Voici une analyse de l’instruction SQL :

La sortie est une liste de sous-chaînes de trois caractères, extraites des noms de produits modifiés, en fonction des positions spécifiées dans la séquence.

Filtrer les résultats filter-results

La fonction filter, avec les transformations de données suivantes, permet une extraction plus précise et plus affinée des informations pertinentes à partir des données de texte. Cela vous permet d’obtenir des informations, d’améliorer la qualité des données et de faciliter de meilleurs processus de prise de décision.

La fonction filter de l’instruction SQL suivante sert à affiner et à limiter la séquence de positions dans la chaîne à partir de laquelle les sous-chaînes sont extraites à l’aide de la fonction de transformation suivante.

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;

La fonction filter génère une séquence de positions de départ valides dans le ProductName modifié et extrait les sous-chaînes d’une longueur spécifique. Seules les positions de départ permettant d’extraire une sous-chaîne de sept caractères sont autorisées.

La condition i -> i + 6 <= length(lower(replace(ProductName, ' ', ''))) garantit que la position de départ i plus 6 (la longueur de la sous-chaîne de sept caractères souhaitée moins une) ne dépasse pas la longueur du ProductName modifié.

L’instruction CASE est utilisée pour inclure ou exclure de manière conditionnelle des sous-chaînes en fonction de leur longueur. Seules les sous-chaînes de sept caractères sont incluses ; les autres sont remplacées par NULL. Ces sous-chaînes sont ensuite utilisées par la fonction transform pour créer une séquence de sous-chaînes à partir de la colonne ProductName de la table featurevector1.

Calcul de la jointure croisée d’éléments uniques sur deux vecteurs de fonctionnalités cross-join-unique-elements

Identifier les différences ou les incohérences entre les deux jeux de données en fonction d’une transformation spécifique des données est un processus courant pour maintenir la précision des données, améliorer la qualité des données et assurer la cohérence entre les jeux de données.

Cette instruction SQL ci-dessous extrait les noms de produits uniques présents dans featurevector2, mais pas dans featurevector1 après avoir appliqué les transformations.

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

Les résultats sont présentés dans le tableau ci-dessous :

Effectuez ensuite une jointure croisée pour combiner les éléments des deux vecteurs de fonctionnalités afin de créer des paires d’éléments à des fins de comparaison. La première étape de ce processus est de créer un vecteur à jetons.

Un vecteur à jetons est une représentation structurée de données de texte dans laquelle chaque mot, expression ou unité de signification (jeton) est converti en un format numérique. Cette conversion permet aux algorithmes de traitement de langage naturel de comprendre et d’analyser les informations textuelles.

Le SQl ci-dessous crée un vecteur à jetons.

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;

Les résultats sont présentés dans le tableau ci-dessous :

Répétez ensuite le processus pour 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;

Les résultats sont présentés dans le tableau ci-dessous :

Une fois les deux vecteurs segmentés en unités terminées, vous pouvez désormais créer la jointure croisée. Ceci est illustré dans le SQL ci-dessous :

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;

Voici un résumé de l’interface utilisateur graphique utilisée pour créer la jointure croisée :

Les résultats sont présentés dans le tableau ci-dessous :

Calculez la mesure de similarité Jaccard compute-the-jaccard-similarity-measure

Ensuite, calculez l’utilisation du coefficient de similarité Jaccard pour effectuer une analyse des similarités entre les deux ensembles de noms de produits en comparant leurs représentations segmentées en unités lexicales. La sortie du script SQL ci-dessous fournit les éléments suivants : noms de produits des deux ensembles, leurs représentations en unités lexicales, le nombre de jetons uniques communs et totaux et le coefficient de similarité Jaccard calculé pour chaque paire de jeux de données.

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

Voici un résumé du SQL utilisé pour calculer le coefficient de similarité Jaccard :

Les résultats sont présentés dans le tableau ci-dessous :

Filtrage des résultats selon le seuil de similarité de parcours similarity-threshold-filter

Enfin, filtrez les résultats selon un seuil prédéfini afin de sélectionner uniquement les paires répondant aux critères de similarité. L’instruction SQL ci-dessous filtre les produits avec un coefficient de similarité Jaccard d’au moins 0,4. Cela réduit les résultats en paires présentant un degré substantiel de similarité.

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

Les résultats de cette requête donnent les colonnes pour la jointure par analogie, comme illustré ci-dessous :