Correspondance approximative dans Query Service
Utilisez une correspondance « floue » sur vos données Adobe Experience Platform pour renvoyer les correspondances approximatives les plus probables sans avoir à rechercher des chaînes avec des caractères identiques. Cela permet une recherche beaucoup plus flexible de vos données et rend vos données plus accessibles en économisant du temps et des efforts.
Au lieu d’essayer de reformater les chaînes de recherche pour les faire correspondre, la correspondance floue analyse le rapport de similarité entre deux séquences et renvoie le pourcentage de similarité. FuzzyWuzzy est recommandé pour ce processus, car ses fonctions sont plus adaptées pour faciliter la correspondance de chaînes dans des situations plus complexes que les regex ou les difflib.
L’exemple fourni dans ce cas d’utilisation se concentre sur la correspondance d’attributs similaires provenant d’une recherche de chambre d’hôtel dans deux jeux de données d’agence de voyage différents. Le document montre comment faire correspondre des chaînes en fonction de leur degré de similarité à partir de grandes sources de données distinctes. Dans cet exemple, correspondance floue compare les résultats de recherche pour les caractéristiques d’une chambre des agences de voyages Luma et Acme.
Commencer getting-started
Dans le cadre de ce processus, qui nécessite l’entraînement d’un modèle de machine learning, ce document suppose une connaissance pratique d’un ou de plusieurs environnements de machine learning.
Cet exemple utilise Python et l’environnement de développement Jupyter Notebook. Bien qu’il existe de nombreuses options disponibles, Jupyter Notebook est recommandé, car il s’agit d’une application web open source qui nécessite peu de calculs. Il peut être téléchargé à partir du site officiel de Jupyter.
Avant de commencer, vous devez importer les bibliothèques nécessaires. FuzzyWuzzy est une bibliothèque Python open source construite sur la bibliothèque difflib et utilisée pour faire correspondre des chaînes. Il utilise Levenshtein Distance pour calculer les différences entre les séquences et les motifs. FuzzyWuzzy a les exigences suivantes :
- Python 2.4 (ou version ultérieure)
- Python-Levenshtein
Sur la ligne de commande, utilisez la commande suivante pour installer FuzzyWuzzy :
pip install fuzzywuzzy
Ou utilisez la commande suivante pour installer également Python-Levenshtein :
pip install fuzzywuzzy[speedup]
Vous trouverez plus d’informations techniques sur les Fuzzywuzzy dans leur documentation officielle.
Se connecter à Query Service
Vous devez connecter votre modèle de machine learning à Query Service en fournissant vos informations d’identification de connexion. Des informations d’identification arrivant à expiration et non arrivant à expiration peuvent être fournies. Pour plus d’informations sur l’acquisition des informations d’identification nécessaires🔗 consultez le guide des informations d’identification . Si vous utilisez Jupyter Notebook, veuillez lire le guide complet sur comment se connecter à Query Service.
Veillez également à importer le package numpy dans votre environnement Python pour activer l’algèbre linéaire.
import numpy as np
Les commandes ci-dessous sont nécessaires pour se connecter à Query Service à partir de Jupyter Notebook :
import psycopg2
conn = psycopg2.connect('''
sslmode=require
host=<YOUR_ORGANIZATION_ID>
port=80
dbname=prod:all
user=<YOUR_ADOBE_ID_TO_CONNECT_TO_QUERY_SERVICE>
password=<YOUR_QUERY_SERVICE_PASSWORD>
''')
cur = conn.cursor()
Votre instance Jupyter Notebook est maintenant connectée à Query Service. Si la connexion est établie, aucun message ne s’affiche. Si la connexion a échoué, une erreur s’affiche.
Extraire des données du jeu de données Luma luma-dataset
Les données à analyser sont extraites du premier jeu de données avec les commandes suivantes. Par souci de concision, les exemples ont été limités aux 10 premiers résultats de la colonne.
cur.execute('''SELECT * FROM luma;
''')
luma = np.array([r[0] for r in cur])
luma[:10]
Sélectionnez Sortie pour afficher le tableau renvoyé.
| code language-console |
|---|
|
Extraire des données du jeu de données Acme acme-dataset
Les données à analyser sont désormais extraites du deuxième jeu de données avec les commandes suivantes. Encore une fois, par souci de concision, les exemples ont été limités aux 10 premiers résultats de la colonne.
cur.execute('''SELECT * FROM acme;
''')
acme = np.array([r[0] for r in cur])
acme[:10]
Sélectionnez Sortie pour afficher le tableau renvoyé.
| code language-console |
|---|
|
Créer une fonction de score floue fuzzy-scoring
Ensuite, vous devez importer les fuzz de la bibliothèque FuzzyWuzzy et exécuter une comparaison partielle des proportions des chaînes. La fonction de rapport partiel vous permet d’effectuer une correspondance de sous-chaîne. Cette méthode prend la chaîne la plus courte et la fait correspondre à toutes les sous-chaînes de même longueur. La fonction renvoie un rapport de similarité en pourcentage allant jusqu’à 100 %. Par exemple, la fonction de ratio partiel comparerait les chaînes « Chambre Deluxe », « 1 Lit King » et « Chambre King Deluxe » et renverrait un score de similarité de 69 %.
Dans le cas d’utilisation de la correspondance de chambre d’hôtel, cela se fait à l’aide des commandes suivantes :
from fuzzywuzzy import fuzz
def compute_match_score(x,y):
return fuzz.partial_ratio(x,y)
Importez ensuite les cdist de la bibliothèque SciPy pour calculer la distance entre chaque paire dans les deux collections d’entrées. Il calcule les scores de toutes les paires de chambres d'hôtel fournies par chacune des agences de voyages.
from scipy.spatial.distance import cdist
pairwise_distance = cdist(luma.reshape((-1,1)),acme.reshape((-1,1)),compute_match_score)
Créez des mappages entre les deux colonnes à l’aide du score de jointure approximatif
Maintenant que les colonnes ont été notées en fonction de la distance, vous pouvez indexer les paires et ne conserver que les correspondances qui ont obtenu un score supérieur à un certain pourcentage. Cet exemple conserve uniquement les paires qui correspondent à un score de 70 % ou plus.
matched_pairs = []
for i,c1 in enumerate(luma):
idx = np.where(pairwise_distance[i,:] > 70)[0]
for j in idx:
matched_pairs.append((luma[i].replace("'","''"),acme[j].replace("'","''")))
Les résultats peuvent être affichés avec la commande suivante. Par souci de concision, les résultats sont limités à dix lignes.
matched_pairs[:10]
Sélectionnez Sortie pour afficher les résultats.
| code language-console |
|---|
|
Les résultats sont ensuite mis en correspondance en utilisant SQL avec la commande suivante :
matching_sql = ' OR '.join(["(e.luma = '{}' AND b.acme = '{}')".format(c1,c2) for c1,c2 in matched_pairs])
Appliquer les mappages pour effectuer une jointure floue dans Query Service mappings-for-query-service
Ensuite, les paires correspondantes à score élevé sont jointes à l’aide de SQL pour créer un jeu de données.
:
cur.execute('''
SELECT * FROM luma e
CROSS JOIN acme b
WHERE
{}
'''.format(matching_sql))
[r for r in cur]
Sélectionnez Sortie pour afficher les résultats de cette jointure.
| code language-console |
|---|
|
Enregistrer les résultats des correspondances approximatives dans Experience Platform save-to-platform
Enfin, les résultats de la correspondance approximative peuvent être enregistrés en tant que jeu de données à utiliser dans Adobe Experience Platform avec SQL.
cur.execute('''
Create table luma_acme_join
AS
(SELECT * FROM luma e
CROSS JOIN acme b
WHERE
{})
'''.format(matching_sql))