Correspondance floue dans Query Service
Utilisez une correspondance approximative sur vos données Adobe Experience Platform pour renvoyer les correspondances les plus probables et les plus approximatives 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 gagnant du temps et en faisant des efforts.
Au lieu d’essayer de reformater les chaînes de recherche afin de les faire correspondre, la correspondance approximative 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 à la correspondance de chaînes dans des situations plus complexes que regex ou difflib.
L’exemple fourni dans ce cas d’utilisation se concentre sur la mise en correspondance d’attributs similaires à partir d’une recherche de chambre d’hôtel dans deux jeux de données d’agence de voyages différents. Le document indique comment faire correspondre des chaînes en fonction de leur degré de similarité à partir de sources de données distinctes volumineuses. Dans cet exemple, une correspondance approximative compare les résultats de recherche des fonctionnalités d’une pièce des agences de voyage Luma et Acme.
Prise en main getting-started
Dans le cadre de ce processus, vous devez entraîner un modèle d’apprentissage automatique. Ce document suppose une connaissance pratique d’un ou de plusieurs environnements d’apprentissage automatique.
Cet exemple utilise Python et le Jupyter Notebook environnement de développement. Bien qu’il existe de nombreuses options disponibles, Jupyter Notebook est recommandé, car il s’agit d’une application web open source qui a de faibles exigences de calcul. Il peut être téléchargé à partir de le site officiel de Jupyter.
Avant de commencer, vous devez importer les bibliothèques nécessaires. FuzzyWuzzy est un site open-source Python bibliothèque créée au-dessus de difflib et utilisée pour faire correspondre des chaînes. Elle utilise Levenshtein Distance pour calculer les différences entre les séquences et les motifs. FuzzyWuzzy présente les exigences suivantes :
- Python 2.4 (ou version ultérieure)
- Python-Levenshtein
A partir de la ligne de commande, utilisez la commande suivante pour installer : FuzzyWuzzy:
pip install fuzzywuzzy
Ou utilisez la commande suivante pour installer Python-Levenshtein ainsi que :
pip install fuzzywuzzy[speedup]
Informations techniques supplémentaires sur Fuzzywuzzy se trouvent dans leur documentation officielle.
Connecter à Query Service
Vous devez connecter votre modèle d’apprentissage automatique à Query Service en fournissant vos informations d’identification de connexion. Les informations d’identification arrivant à expiration et non arrivant à expiration peuvent être fournies. Veuillez consulter la guide des informations d’identification pour plus d’informations sur la manière d’acquérir les informations d’identification nécessaires. Si vous utilisez Jupyter Notebook, veuillez lire le guide complet sur Comment se connecter à Query Service.
Veillez également à importer la variable numpy dans votre 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 Jupyter Notebook est désormais connectée à Query Service. Si la connexion est établie, aucun message ne s’affiche. Si la connexion a échoué, une erreur s’affiche.
Dessin de données à partir du jeu de données Luma luma-dataset
Les données à analyser sont extraites du premier jeu de données avec les commandes suivantes. Pour plus de concision, les exemples se sont 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électionner Sortie pour afficher le tableau renvoyé.
| code language-console |
|---|
|
Dessin de données à partir 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. Pour être plus concis, les exemples se sont 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électionner Sortie pour afficher le tableau renvoyé.
| code language-console |
|---|
|
Création d’une fonction de notation floue fuzzy-scoring
Ensuite, vous devez importer fuzz à partir de la bibliothèque FuzzyWuzzy et effectuez une comparaison des proportions partielle des chaînes. La fonction de rapport partiel vous permet d’effectuer une correspondance sous-chaîne. Cette chaîne prend la chaîne la plus courte et correspond à toutes les sous-chaînes de même longueur. La fonction renvoie un pourcentage de similarité allant jusqu’à 100 %. Par exemple, la fonction de rapport partiel compare les chaînes suivantes "chambre de luxe", "lit de roi" et "chambre de roi de luxe" et renvoie 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)
Importer ensuite cdist de la SciPy pour calculer la distance entre chaque paire dans les deux collections d’entrées. Cela calcule les scores parmi toutes les paires de chambres d’hôtel fournies par chacune des agences de voyage.
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 flou.
Maintenant que les colonnes ont été notées en fonction de la distance, vous pouvez indexer les paires et ne conserver que les correspondances ayant obtenu un score supérieur à un certain pourcentage. Cet exemple conserve uniquement les paires qui correspondent avec 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. Pour plus de concision, les résultats sont limités à dix lignes.
matched_pairs[:10]
Sélectionner Sortie pour voir les résultats.
| code language-console |
|---|
|
Les résultats sont ensuite mis en correspondance à l’aide de SQL avec la commande suivante :
matching_sql = ' OR '.join(["(e.luma = '{}' AND b.acme = '{}')".format(c1,c2) for c1,c2 in matched_pairs])
Appliquez les mappages pour effectuer une jointure floue dans Query Service. mappings-for-query-service
Ensuite, les paires de correspondance à score élevé sont unies à l’aide de SQL pour créer un nouveau jeu de données.
:
cur.execute('''
SELECT * FROM luma e
CROSS JOIN acme b
WHERE
{}
'''.format(matching_sql))
[r for r in cur]
Sélectionner Sortie pour voir les résultats de cette jointure.
| code language-console |
|---|
|
Enregistrer les résultats de correspondance approximative dans 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 à l’aide de SQL.
cur.execute('''
Create table luma_acme_join
AS
(SELECT * FROM luma e
CROSS JOIN acme b
WHERE
{})
'''.format(matching_sql))