Aller au contenu
English

Travail final

  • Après les études de cas
  • environ 5 h

Où nous en sommes

Chaque module a ajouté une partie de l'appariement et l'a mesurée : normalisation, blocage, attribution de scores, regroupement, révision et confidentialité. Dans ce travail, vous les utilisez toutes pour fusionner les clients de Larkfield avec la liste d'une deuxième entreprise.

Ce que vous saurez faire

Appliquez chaque module du cours à une nouvelle liste. Livrez un dossier d’appariement qu’Omar, Ivana et Amira peuvent utiliser. La nouvelle liste a ses propres colonnes et ses propres habitudes. Personne ne vous donne les vrais clients. Vous mesurez donc chaque choix à nouveau, sur ces données. Vous prévoyez aussi les erreurs que vous ne pouvez pas voir.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 300 minutes
  • Vous avez terminé les modules 1 à 8. Chaque partie ci-dessous nomme les leçons qu’elle utilise.
  • Le certificat exige aussi au moins une étude de cas : Apparier des produits entre deux boutiques, Relier des notices bibliographiques ou Trouver des personnes et des entreprises en double. Elles vous préparent bien à ce travail, mais vous n’en avez pas besoin pour le faire.
  • Votre dossier larkfield-match fonctionne à la fin du module 8 : python -m pytest -q affiche 42 passed (42 tests réussis), comme dans De nouveaux enregistrements chaque jour. Les données du cours sont dans larkfield-match/data. Le dossier nextia-learning-labs est à côté de larkfield-match, comme dans Découvrir les enregistrements.
  • Environ 4 à 6 heures. Vous passerez surtout ce temps à lire des enregistrements et à consigner des décisions. Aucune étape ne prend longtemps à exécuter. Lors de l’exécution de l’auteur, le pipeline complet a pris environ 2 minutes. Il a utilisé environ 5,4 Go de mémoire au maximum.
  • Aucun modèle de langage ni aucune clé ne sont nécessaires.
  • Testé sur macOS avec Python 3.12.13 et les versions fixées des paquets du projet. Les commandes Windows sont fournies, mais elles n’ont pas été exécutées.

La situation : Larkfield achète une chaîne de quincailleries

Section intitulée « La situation : Larkfield achète une chaîne de quincailleries »

Larkfield a acheté Fernhollow Home & Hardware, une chaîne de quincailleries dans quatre provinces. Fernhollow a sa propre liste de clients, issue de son propre système de caisse. Certains de ses clients magasinent déjà chez Larkfield. Certains apparaissent deux fois dans la liste de Fernhollow.

L’équipe a des questions, comme dans le cours :

  • Omar, le gestionnaire de produit, veut connaître le nombre réel de clients après la fusion. Il se souvient des coûts : une fusion erronée coûte environ 150 $, et une correspondance manquée environ 3 $ par année. Ce sont deux hypothèses dans data/costs.json.
  • Ivana, la responsable des données clients, révisera les paires incertaines. Elle peut vérifier environ 300 paires par jour (une hypothèse). Elle demande combien de jours la fusion lui prendra.
  • Amira, la développeuse, est responsable de la tâche d’appariement. Elle veut consigner chaque fusion et pouvoir l’annuler.
  • Tomás, l’ingénieur en IA, a une idée : « Nous avons ajusté l’apparieur sur Larkfield. Exécutons-le simplement sur Fernhollow. »

Priya vous demande de leur répondre avec des preuves.

Soyez honnête au sujet des données. Les enregistrements de Fernhollow sont synthétiques. Le code du cours les a créés à partir de personnes inventées, avec le même modèle d’erreurs que les enregistrements de Larkfield. Fernhollow est une entreprise inventée. Les données contiennent des problèmes d’exercice que nous avons créés volontairement. Certains ressemblent à ceux de Larkfield, et d’autres sont nouveaux. L’équipe du cours les connaît, mais pas vous. Présentez vos chiffres comme des résultats « sur nos enregistrements synthétiques ».

Un flux de gauche à droite. Les 10 773 enregistrements de Fernhollow sont préparés selon les colonnes du projet. Avec les 60 108 enregistrements de Larkfield, ils passent au blocage : paires contenant un enregistrement de Fernhollow. Attribution de scores avec des règles et trois autres familles de méthodes. Puis trois sorties : apparier, faire réviser par Ivana ou créer un nouveau client. Les trois mènent aux entités, avec vérifications, fiches de référence, historique et annulation. Lignes pointillées : les 600 paires étiquetées mesurent l'exhaustivité des paires et le rappel; vos propres étiquettes mesurent la précision de chaque zone.
Le travail en une image. Les paires étiquetées servent à choisir et à tester votre apparieur. Vos propres étiquettes mesurent ce que les paires étiquetées ne peuvent pas mesurer.
Description textuelle du diagramme

Un flux de gauche à droite. Fernhollow, avec 10 773 enregistrements selon un nouveau schéma, passe à « préparer » : les colonnes du projet. Puis à « bloquer », avec les 60 108 enregistrements de Larkfield et vos entités du cours : seulement les paires contenant un enregistrement de Fernhollow. Puis à « attribuer un score » : règles et trois autres familles de méthodes. Trois flèches partent de cette étape. « Apparier » : l’enregistrement rejoint un client. « Réviser » : Ivana vérifie la paire, à raison de 300 paires par jour. « Nouveau client ». Les trois mènent à « entités » : vérifications, fiches de référence, historique et annulation. Une flèche pointillée relie labelled_pairs.csv (600 paires : choisir sur la validation, tester une fois) à « attribuer un score », pour l’exhaustivité des paires et le rappel. Une autre flèche pointillée relie « vos propres étiquettes » (au moins 100 de vos correspondances et paires à réviser) à « apparier », pour la précision de chaque zone.

Les fichiers se trouvent dans le dépôt des exercices, dans C39/final/. Les données du cours, dans C39/data/, restent inchangées.

Fichier Lignes Ce que représente une ligne
fernhollow_customers.csv 10 773 Un compte client dans le système de caisse de Fernhollow : record_id, customer_name, phone, email, street, town, province, postal_code, birth_year
labelled_pairs.csv 600 Une paire contenant au moins un enregistrement de Fernhollow, étiquetée par l’équipe du cours : record_id_l, record_id_r, label (1 = même client), why_sampled, split
check_submission.py Vérifie la structure de votre dossier. Ne connaît aucune réponse et ne donne aucune note

Le dossier contient aussi README.md, dataset-card.md et SHA256SUMS. Il fait environ 1,3 Mo.

Récupérez les fichiers, vérifiez-les et examinez-les. Exécutez ceci dans votre dossier larkfield-match, avec .venv actif :

Fenêtre de terminal
git -C ../nextia-learning-labs pull
F=../nextia-learning-labs/C39/final
(cd "$F" && shasum -a 256 -c SHA256SUMS | grep -vc ': OK$')
python -c "
import pandas as pd
fh = pd.read_csv('$F/fernhollow_customers.csv', dtype=str, keep_default_na=False)
lab = pd.read_csv('$F/labelled_pairs.csv', dtype=str)
print(len(fh), 'Fernhollow records;', len(lab), 'labelled pairs')
print(lab.groupby(['split', 'why_sampled']).size().to_string())
print(fh.head(3).to_string(index=False))
"

Le premier nombre indique le nombre de fichiers incorrects. Il doit être 0. Vous voyez ensuite :

0
10773 Fernhollow records; 600 labelled pairs
split why_sampled
test random 23
same surname and region 139
true pair 116
validation random 37
same surname and region 161
true pair 124
record_id customer_name phone email street town province postal_code birth_year
FH-000001 Girard Sophie 819-555-2733 SOPHIEGIRARD@EXAMPLE.NET 2144 rang de la Colline Sainte-Odile-sur-Mer QC G2B 9W6 1949
FH-000002 Bergeron Alexandre ALEXANDREBERGERON@POST.EXAMPLE 8949, rang Sainte-Cécile #3 Saint-Ambroise-des-Monts QC H1G 7C0 1977
FH-000003 Okafor Leila 819-555-9234 LEILA.OKAFOR55@EXAMPLE.COM 114, r. de l'Église Lac-aux-Grives QC G3C 1T7

Ce que les paires étiquetées peuvent et ne peuvent pas vous dire

Section intitulée « Ce que les paires étiquetées peuvent et ne peuvent pas vous dire »

Les 600 paires ont été choisies comme les 3 000 paires étiquetées de Larkfield, dans Un classificateur de paires supervisé :

  • 240 vraies paires, tirées au hasard parmi toutes les vraies paires contenant un enregistrement de Fernhollow. Elles forment un échantillon représentatif des paires que vous devez trouver. La proportion que votre blocage conserve estime donc l’exhaustivité des paires (pair completeness). La proportion que votre apparieur trouve estime le rappel.
  • 300 paires avec le même début de nom de famille et la même région de code postal, et 60 paires aléatoires. Presque toutes représentent deux personnes différentes.

split place chaque paire dans validation (validation) ou test (test). Choisissez votre blocage, votre apparieur et vos seuils sur les données de validation. Présentez les résultats sur les données de test une seule fois, à la fin. Un enregistrement de Fernhollow ne se trouve jamais dans les deux partitions.

Les paires étiquetées ne peuvent pas vous donner la précision de vos correspondances. Ici, quatre paires sur dix sont de vraies paires. Parmi vos paires candidates, les vraies paires sont rares. Les paires difficiles de personnes différentes ne sont pas dans cet échantillon. La précision mesurée ici est donc beaucoup trop élevée. Vous mesurez vous-même la précision dans la Partie 6.

L’équipe du cours conserve le vrai client de chaque enregistrement de Fernhollow. Elle évalue vos correspondances et vos entités par rapport à ces clients. Vous ne pouvez pas ajuster votre système à partir d’eux, et vous n’en avez pas besoin.

Créez un dossier match-pack/ dans votre dossier larkfield-match. Placez-y tous les fichiers du travail. Quoi remettre présente la liste des fichiers.

Séparez les sorties du travail de celles du cours. Définissez deux variables dans chaque terminal que vous utilisez pour le travail :

Fenêtre de terminal
export LARKFIELD_OUTPUTS=outputs-final LARKFIELD_DUCKDB_TEMP=outputs-final/duckdb_tmp

Le projet limite toujours DuckDB à 4 Go de mémoire et à 4 Go de fichiers temporaires, comme dans La mise à l’échelle.

Le dossier suit les règles de réussite du cours : une partie pour chaque élément exigé.

Un encadré en haut : match-pack/REPORT.md avec les décisions, les chiffres et les commandes. En dessous, sept encadrés : 1 Préparer, 2 Bloquer, 3 Comparer, 4 Décider, 5 Entités, 6 Vos étiquettes, 7 Confidentialité, chacun avec ses fichiers.
Les sept parties du dossier d'appariement et les fichiers à remettre pour chacune.
Description textuelle du diagramme

Un encadré en haut : match-pack/REPORT.md, avec les décisions, les chiffres et les commandes qui les produisent. En dessous, sept encadrés. 1 Préparer : fernhollow.py, avec les vérifications de l’analyse et des valeurs. 2 Bloquer : exhaustivité des paires et taux de réduction. 3 Comparer : comparison.csv, avec les règles et trois autres familles, et leur coût. 4 Décider : links.csv, avec les seuils, la zone de révision et les jours de révision. 5 Entités : entities.csv, golden.csv, history.jsonl et une annulation. 6 Vos étiquettes : my_labels.csv, avec la précision de chaque zone. 7 Confidentialité : les champs utilisés, la conservation et la suppression.

Vous écrivez vous-même le code dans un ou plusieurs scripts de match-pack/. Le projet est votre bibliothèque. Chaque étape ci-dessous nomme les fonctions de larkfield_match qui font le travail. larkfield_match/incremental.py, qui exécute match daily, a la même structure que ce travail : nouveaux enregistrements, clés, vecteurs, modèle, seuils et jointures. Lisez-le d’abord.

Partie 1 : préparer les enregistrements de Fernhollow

Section intitulée « Partie 1 : préparer les enregistrements de Fernhollow »

Utilise Normaliser et Découper en parties.

  1. Examinez les données avant de les analyser. Affichez 30 lignes aléatoires. Pour chaque colonne, notez ce que vous voyez : ordre des mots, majuscules, espaces, texte supplémentaire et valeurs vides. Comptez aussi les valeurs les plus fréquentes de phone, email et street. Une valeur présente dans beaucoup d’enregistrements est un avertissement. C’était le cas du numéro de téléphone des jardineries dans Regrouper les paires.

  2. Écrivez match-pack/fernhollow.py. Ajoutez une fonction qui transforme les lignes de Fernhollow en colonnes préparées du projet : record_id, source, first, last, full, email, phone, number, street, unit, town, province, postcode, dob, created, parse_ok. Utilisez larkfield_match.normalise et larkfield_match.parse. prepare_source() dans larkfield_match/prepared.py montre le modèle pour les trois sources de Larkfield.

  3. Décidez quoi faire de birth_year. Le projet compare des dates de naissance complètes. Une année n’est pas une date. Ne placez pas une année là où le projet attend une date : réfléchissez à ce que dob_eq indiquerait alors. Conservez l’année dans sa propre colonne et utilisez-la dans une vérification plus tard.

  4. Vérifiez votre analyseur sur les lignes que vous avez notées à l’étape 1, une à une. Mesurez ensuite la proportion d’enregistrements analysés avec succès. Mesurez aussi la proportion ayant un courriel, un téléphone et un code postal valides.

  5. Réunissez les deux listes : les enregistrements préparés de Larkfield provenant de prepared.customers(), et les vôtres.

Utilise Pourquoi comparer toutes les paires est impossible, Clés de blocage et voisinage trié et Ce que le blocage fait perdre.

Vous avez seulement besoin des paires contenant au moins un enregistrement de Fernhollow : Fernhollow contre Larkfield et Fernhollow contre Fernhollow. Le cours a déjà traité les propres paires de Larkfield.

  1. Comptez toutes les paires possibles contenant un enregistrement de Fernhollow. Le taux de réduction utilise ce nombre comme dénominateur.

  2. Créez des paires candidates avec les clés du projet sur la table combinée. Conservez les paires contenant un enregistrement de Fernhollow :

    from larkfield_match import blocking
    keys = blocking.customer_keys(both) # both: Larkfield's and Fernhollow's prepared records
    cand = blocking.key_pairs(keys, ["postcode", "email", "phone", "surname4", "dob"])
    fh = set(fernhollow.record_id)
    cand = cand[cand.record_id_l.isin(fh) | cand.record_id_r.isin(fh)]
  3. Estimez l’exhaustivité des paires sur les vraies paires de la partition de validation : la proportion présente dans cand. Essayez au moins trois blocages. Par exemple : le code postal seul, les clés du cours et les clés avec une clé supplémentaire. Présentez le nombre de candidats, le taux de réduction et l’exhaustivité des paires pour chacun.

  4. Donnez la taille de l’échantillon avec l’estimation. 124 vraies paires, c’est un petit échantillon. Si votre blocage les conserve toutes, cela ne prouve pas une exhaustivité des paires de 1,0. Avec 124 sur 124, une limite inférieure à 95 % est d’environ 0,976. Estimer l’incertitude dans Mathématiques et statistiques essentielles pour l’IA explique les intervalles de confiance.

  5. Choisissez un blocage sur les données de validation. Expliquez pourquoi et combien de paires candidates il produit. Vérifiez-le ensuite une seule fois sur la partition de test.

Utilise Appariement exact et par règles, Comparer champ par champ, puis combiner, Apprendre les poids sans étiquettes, Un classificateur de paires supervisé et Un modèle de langage pour les paires incertaines.

  1. Créez les vecteurs de comparaison de vos candidats. customer_vectors accepte la table à lire :

    from larkfield_match.vectors import customer_vectors
    v = customer_vectors(cand, both)
  2. Une référence de base par règles. Utilisez les quatre règles du cours (larkfield_match/runs/rules.py) sur vos candidats. Une règle ne trouve rien dans les enregistrements de Fernhollow : dites laquelle et pourquoi.

  3. Au moins trois autres familles. Une famille correspond à une idée. Exemples : le score pondéré à la main (runs/weighted.py); Splink sans étiquettes (splinkmodel.train(both[["record_id"] + splinkmodel.COLUMNS])); un classificateur (classifier.labelled_training_set(), classifier.fit(), classifier.predict()). Deux réglages d’une même famille comptent comme une seule famille. Les classificateurs apprennent sur les 3 000 paires étiquetées de Larkfield. Si vous les entraînez aussi sur les paires de validation de Fernhollow, dites-le et excluez les paires de test.

  4. Évaluez chaque méthode sur les mêmes paires étiquetées. Une paire étiquetée perdue par le blocage compte comme « non trouvée », comme dans le tableau comparatif du cours. Présentez la précision, le rappel et le score F1 sur les données de validation, avec le nombre de paires.

  5. Donnez le coût par 1 000 paires de chaque méthode. Chronométrez-la sur vos candidats. Utilisez le prix du processeur du cours : 0,17 $ US l’heure (une hypothèse dans data/costs.json).

  6. Choisissez votre apparieur sur les données de validation. Exécutez-le ensuite une seule fois sur les paires de test, sans modification. Écrivez le tableau dans match-pack/comparison.csv : une ligne par méthode, avec son seuil, le nombre de correspondances produites, les mesures de validation et de test, et son coût.

Un modèle de langage est facultatif. Les réponses enregistrées du cours couvrent seulement les paires de Larkfield. Il n’y en a donc aucune pour Fernhollow. Vous pouvez utiliser un modèle avec votre propre clé, comme dans Un modèle de langage pour les paires incertaines. Utilisez-le alors seulement dans la zone incertaine. Consignez chaque réponse et son coût. Faites vérifier ses réponses « même client » par une personne avant toute fusion.

Utilise Des poids à une décision et La révision humaine.

  1. Transformez vos scores en probabilités qui reflètent la réalité. Le cours étalonne LightGBM sur les paires de validation de Larkfield : calibrate.fit(pairs.get("lgbm")). La première fois, cette fonction entraîne le modèle du cours dans outputs-final/. Expliquez pourquoi un étalonnage fait sur les enregistrements de Larkfield pourrait ne pas convenir à ceux de Fernhollow.

  2. Choisissez deux seuils : un seuil supérieur (apparier) et un seuil inférieur (réviser). La zone de révision se trouve entre les deux. Essayez au moins trois zones. Pour chacune, donnez le nombre de correspondances, le nombre de paires à réviser et les jours d’Ivana à 300 paires par jour. Donnez aussi le rappel sur les vraies paires de validation, avec et sans révision parfaite.

  3. Décidez en fonction des coûts. Une fusion erronée coûte environ 150 $, et une correspondance manquée environ 3 $ par année. Une révision prend environ 1,2 minute à 40 $ l’heure. Ce sont trois hypothèses. Indiquez le coût du temps d’Ivana et combien de fusions erronées il doit éviter pour être rentable.

  4. Ajoutez les vérifications que les nouvelles données exigent, avant tout appariement. Un exemple : deux enregistrements ayant des années de naissance différentes. Mesurez combien de correspondances chaque vérification retire.

  5. Écrivez match-pack/links.csv : une ligne pour chaque paire contenant un enregistrement de Fernhollow que vous appariez ou envoyez en révision. Colonnes : record_id_l, record_id_r, score, decision (link (apparier) ou review (réviser)).

  6. Expliquez comment les décisions de révision sont réintégrées. Une décision « même client » entraîne une fusion. Une décision « clients différents » va dans cannot_link.csv, comme dans Les décisions deviennent des étiquettes. Le module 8 a mesuré l’effet du réentraînement sur les étiquettes de révision. Dites si vous réentraîneriez le modèle sur les étiquettes d’Ivana.

Partie 5 : entités, fiches de référence et annulation

Section intitulée « Partie 5 : entités, fiches de référence et annulation »

Utilise Regrouper les paires, Un regroupement plus sûr, Mesures de groupes, La fiche de référence et De nouveaux enregistrements chaque jour.

  1. Partez des entités de Larkfield. Exécutez match golden une fois (dans outputs-final/). Son fichier entities.csv donne un identifiant d’entité à chaque enregistrement de Larkfield. Un enregistrement de Fernhollow que vous liez à un enregistrement de Larkfield rejoint l’entité de cet enregistrement.

  2. Regroupez vos liens. Vérifiez ensuite chaque groupe avant de l’accepter. Au minimum : aucun groupe avec deux clients différents de Larkfield, aucun groupe dépassant la limite du cours, aucune année de naissance différente dans un groupe. Un nouvel enregistrement ne doit pas fusionner à lui seul deux anciens clients, comme dans le module 8. Coupez le lien le plus faible jusqu’à ce que le groupe respecte les critères, comme le fait larkfield_match/safecluster.py. Envoyez chaque lien coupé en révision.

  3. Examinez vos plus grands groupes à la main et donnez la taille des cinq plus grands. Un groupe géant indique une mauvaise valeur ou un mauvais lien.

  4. Mesures de groupes. Vous ne connaissez pas la vérité pour tous les enregistrements. Faites donc les mesures sur les paires de test étiquetées. Donnez la proportion de vraies paires qui aboutissent dans une même entité. Donnez aussi la proportion de paires différentes qui aboutissent dans une même entité. Indiquez aussi le nombre de clients après la fusion et le nombre d’enregistrements de Fernhollow qui ont rejoint un client de Larkfield.

  5. Écrivez match-pack/entities.csv : record_id et entity_id pour chaque enregistrement, de Larkfield et de Fernhollow. Conservez les identifiants d’entité de Larkfield fournis par match golden. Un enregistrement de Fernhollow qui crée un nouveau client reçoit LK- suivi de son propre identifiant d’enregistrement, comme dans l’exécution quotidienne.

  6. Fiches de référence. Utilisez les règles de fusion de La fiche de référence. Décidez où placer Fernhollow dans l’ordre de confiance. golden.build(entities, records=both, trust=...) les construit à partir de votre table combinée, selon votre ordre de confiance. Écrivez match-pack/golden.csv : une ligne par entité, avec l’enregistrement source de chaque valeur (name_from, email_from …).

  7. Historique et annulation. Écrivez une ligne dans match-pack/history.jsonl pour chaque enregistrement de Fernhollow : l’entité rejointe, ou la création d’une nouvelle entité. Montrez ensuite une annulation, comme dans Annuler une fusion. Retirez un enregistrement de Fernhollow de son entité avec golden.undo(). Collez la ligne d’historique et la ligne de cannot_link.csv que cette fonction écrit.

Utilise Mesurer un apparieur et Ce que la réviseuse voit.

Cette partie mesure ce que les paires étiquetées ne permettent pas de mesurer : la précision de vos liens.

  1. Tirez au hasard au moins 50 paires parmi vos liens et 50 dans votre zone de révision. Utilisez une graine fixe et indiquez laquelle.

  2. Masquez le score et la zone pendant l’étiquetage. Montrez seulement les deux enregistrements, comme le fait l’écran d’Ivana.

  3. Étiquetez chaque paire « 1 » (même personne), « 0 » (personnes différentes) ou « unsure » (incertain). Ajoutez une courte note en cas d’incertitude. Écrivez match-pack/my_labels.csv avec les colonnes record_id_l, record_id_r, band, my_label et note.

  4. Estimez la précision de chaque zone, avec son intervalle. Par exemple : 49 « même personne » sur 50 liens. Comptez les « unsure » séparément. Estimer l’incertitude, dans Mathématiques et statistiques essentielles pour l’IA, calcule un intervalle pour une proportion.

  5. Donnez un chiffre à Omar : le nombre attendu de fusions erronées parmi tous vos liens et leur coût selon les hypothèses du cours.

  6. Dites à quel point vous faites confiance à vos propres étiquettes. Vous lisez les mêmes champs que l’apparieur. Quelles paires étaient difficiles pour vous, et pourquoi?

Utilise Confidentialité et appariement. Le cours Sécurité de l’IA, vie privée et conception responsable traite plus largement des données personnelles.

Écrivez match-pack/REPORT.md avec ces sections :

# Matching pack: Fernhollow joins Larkfield
## Data checks (files, checksums, what you saw in the columns, values on many records)
## Prepare (Part 1: your parser, parse and value checks)
## Blocking (Part 2: the blockings tried, pair completeness with the sample size)
## Comparison (Part 3: the table, the cost per 1,000 pairs, the choice and the one test run)
## Decision (Part 4: thresholds, the review band, Ivana's days, the checks, the costs)
## Entities (Part 5: clusters, checks, largest clusters, golden records, undo)
## Your labels (Part 6: precision of each band with intervals, expected false merges)
## Privacy (fields used, fields left out, retention, a deletion request on a merged entity)
## Answers (Omar's count, Ivana's days, Amira's undo, and Tomás's idea)
## Limits (what your numbers cannot see)
## How to reproduce (commands, versions, run times, a fresh environment)

La section sur la confidentialité répond à quatre questions :

  1. Champs utilisés. Quels champs votre apparieur lit-il, et pourquoi a-t-il besoin de chacun?
  2. Champs exclus. Quels champs n’avez-vous pas utilisés, et quel a été le coût de leur exclusion? Le module 8 a mesuré la valeur de chaque champ.
  3. Conservation. Combien de temps conservez-vous les enregistrements bruts de Fernhollow, les paires candidates, les vecteurs et la file de révision? Qui peut les lire?
  4. Une demande de suppression sur une entité fusionnée. Un client présent dans les deux listes demande à Larkfield de supprimer ses données. Quels enregistrements, valeurs de référence, lignes d’historique et paires faut-il supprimer, et que reste-t-il? Utilisez Une demande de suppression pour un client fusionné et montrez-la sur une entité de votre dossier.

Ce n’est pas un avis juridique. Indiquez les règles que vous avez supposées applicables.

Le dossier match-pack/ dans votre dossier larkfield-match :

match-pack/
REPORT.md Parts 1 to 7, with the commands that make every number
fernhollow.py Part 1: your parser
comparison.csv Part 3: one row per method
links.csv Part 4: every pair you link or send to review
entities.csv Part 5: an entity for every Larkfield and Fernhollow record
golden.csv Part 5: one golden record per entity, with the source of each value
history.jsonl Part 5: one event per Fernhollow record, and your undo
my_labels.csv Part 6: your own labels
*.py every other script
requirements.txt exact versions (pip freeze)

Vérifiez la structure avant de le remettre :

Fenêtre de terminal
python ../nextia-learning-labs/C39/final/check_submission.py match-pack

Avec le dossier de l’auteur, la commande a affiché :

links: 7,229 pairs to link, 1,426 pairs to review = 4.8 days for one reviewer at 300 pairs a day
entities: 44,912 customers from 70,881 records; 4,469 of 10,773 Fernhollow records are in an entity with a Larkfield record
largest entities: LK-G-001224 (6 records), LK-G-002621 (6 records), LK-G-002066 (6 records)
your labelled sample: 100 pairs; by band: review 50, link 50
history: 10,775 events
The pack has the right shape. This check gives no score: the reviewer grades the content.

Quand il manque quelque chose, elle se termine par Not ready yet: (pas encore prêt) et une liste. Par exemple : my_labels.csv is missing (le fichier my_labels.csv manque). Vos chiffres seront différents de ceux de l’auteur.

Un réviseur note chaque élément démontré, partiellement démontré ou pas encore démontré, avec une raison concrète. Sans réviseur, appliquez le tableau à votre propre dossier ou demandez à un collègue. Le cours est terminé seulement quand les sept éléments sont démontrés. Vous pouvez améliorer un élément et le soumettre de nouveau. Un réviseur exécute aussi vos scripts dans un environnement neuf. REPORT.md doit donc expliquer comment faire.

Élément requis Démontré si Partiellement démontré, par exemple Pas encore démontré, par exemple
1. Préparer (module 2) Un analyseur pour les colonnes de Fernhollow, vérifié à la main sur des lignes identifiées. Le taux d’analyse et la proportion de courriels, téléphones et codes postaux valides. Les valeurs présentes dans de nombreux enregistrements sont repérées et traitées. Un analyseur fonctionnel, sans vérification de l’ordre des noms ni des valeurs fréquentes. Les enregistrements de Fernhollow sont lus avec l’analyseur de Larkfield, sans vérification.
2. Bloquer (module 3) Au moins trois blocages, avec les candidats, le taux de réduction, l’exhaustivité des paires sur les vraies paires de validation et la taille de l’échantillon. Un blocage choisi sur la validation, vérifié une fois sur le test. L’exhaustivité des paires sans taille d’échantillon, ou un seul blocage. Aucune exhaustivité des paires, ou une exhaustivité mesurée sur les paires produites par le blocage.
3. Comparer (modules 2, 4, 5 et 6) Les règles et trois autres familles sur les mêmes paires étiquetées, avec un décompte des paires perdues. Le coût par 1 000 paires. Un apparieur choisi sur la validation et exécuté une fois sur le test. Deux autres familles, ou aucun coût. Aucune référence de base par règles, ou un choix fait sur les paires de test.
4. Décider (modules 5 et 8) Deux seuils et une zone de révision, avec le nombre de paires à réviser et de jours pour Ivana. Au moins trois zones comparées, avec les coûts utilisés pour choisir. Les nouvelles vérifications mesurées. links.csv, et la façon de réintégrer les étiquettes de révision. Une zone sans nombre de jours, ou des seuils sans justification. Un seul seuil et aucune zone de révision.
5. Entités (modules 7 et 8) Groupes vérifiés (pas deux clients de Larkfield, limite de taille, années de naissance). Les plus grands groupes examinés, les mesures de groupes sur les paires de test et le nombre de clients. Des fiches de référence avec les règles de fusion et la source de chaque valeur. Un historique et une annulation montrée. Des fiches de référence sans colonnes sources, ou une annulation décrite mais non exécutée. Aucune vérification des groupes géants, ou aucun moyen d’annuler une fusion.
6. Vos étiquettes (modules 2 et 8) Au moins 50 liens et 50 paires de révision, tirés au hasard et étiquetés à l’aveugle. La précision de chaque zone avec un intervalle. Le nombre attendu de fusions erronées et leur coût. Moins de paires, ou aucun intervalle. Une précision provenant seulement de labelled_pairs.csv.
7. Rapport et confidentialité (module 8) Chaque section de REPORT.md. Les quatre réponses sur la confidentialité, avec une suppression montrée sur une entité fusionnée. Des réponses à Omar, Ivana, Amira et Tomás. Une note sur la confidentialité sans suppression sur une entité fusionnée. Aucune note sur la confidentialité.

Non accepté, quels que soient les autres résultats (l’élément est « pas encore démontré ») :

  • Ajustement sur les paires de test : vous avez changé un blocage, un apparieur, un seuil ou une vérification après l’exécution du test. Ou vous avez utilisé les paires de test pour choisir. (Éléments 2, 3 et 4.)
  • Aucune zone de révision : chaque paire est soit liée, soit écartée. (Élément 4.)
  • Aucune vérification des composantes géantes dans les groupes : les plus grands groupes ne sont pas examinés. Aucune vérification n’empêche un mauvais lien de réunir de nombreuses personnes. (Élément 5.)
  • Aucun moyen d’annuler une fusion : aucun historique, ou une fusion qui modifie ou supprime les enregistrements sources. (Élément 5.)
  • Résultats par paire sans résultats par groupe : de bonnes paires prouvent peu de choses sur les entités. (Élément 5.)
  • Un modèle de langage qui décide des fusions sans vérification. (Éléments 3 et 4.)

Un bon dossier est honnête avant d’être impressionnant. Il contient trois choses :

  • Des chiffres avec leurs tailles d’échantillon. Chaque estimation indique de quelles paires elle provient, et combien il y en a.
  • Une référence de base simple dans chaque comparaison. Si les règles font aussi bien que le classificateur selon une mesure, le dossier le dit.
  • Une décision avec son coût. Par exemple : « Nous lions les paires à ce seuil. Nos propres étiquettes indiquent qu’environ ce nombre de liens sont erronés, pour un coût d’environ ce montant. Ivana a besoin de ce nombre de jours pour la zone de révision. Nous l’acceptons parce que… »

L’auteur a réalisé le travail une fois, avec seulement les fichiers publics et le code du cours. L’équipe du cours a ensuite évalué son dossier à partir des vrais clients. Les résultats ci-dessous proviennent de cette exécution. Votre conception peut être différente. Comparez la méthode et l’ordre de grandeur de chaque résultat, pas le chiffre exact.

Les études de cas ont obtenu certains résultats semblables sur des données réelles. Lisez-les en parallèle avec cette liste : Apparier des produits entre deux boutiques et Relier des notices bibliographiques.

  • L’analyse a été le choix individuel le plus important. L’auteur a aussi exécuté le même apparieur en lisant les noms de Fernhollow comme le cours lit ceux de Larkfield. Il n’a alors trouvé qu’environ 6 vraies paires sur 10. Avec le bon ordre des mots, il en a trouvé environ 8 sur 10.
  • Il était facile de réussir le blocage. Les clés du cours, avec une clé supplémentaire sur la rue, ont produit environ 430 000 paires candidates sur environ 706 millions. Cela donne un taux de réduction d’environ 0,9994. Elles ont conservé toutes les vraies paires de validation et de test. Le code postal seul en a conservé environ 84 %.
  • Sur les paires étiquetées, chaque méthode apprise semblait presque parfaite. Splink, la régression logistique et LightGBM avaient une précision et un rappel de validation entre environ 0,99 et 1,0. L’échantillon ne permettait pas de bien les départager.
  • Les règles étaient la référence de base honnête. Elles n’avaient aucun lien erroné parmi les paires étiquetées non plus. Selon l’évaluation, environ 96 % de leurs liens étaient corrects, et elles trouvaient environ 93 % des vraies paires. Mais elles produisaient environ trois fois plus de fusions erronées que la conception de l’auteur : environ 360 contre environ 110. À 150 $ par fusion erronée, elles coûtaient bien plus que les 3 $ par année de chaque correspondance manquée que les règles retrouvaient.
  • L’auteur a choisi LightGBM avec deux nouvelles vérifications : un conflit d’année de naissance ou de Jr / Sr indique « pas la même personne ». Ces vérifications ont retiré seulement environ 60 liens, dont environ 8 sur 10 étaient erronés.
  • L’auteur a lié les paires à une probabilité bien étalonnée de 0,9 et les a envoyées en révision à partir de 0,2. Après les vérifications des groupes, la file de révision contenait environ 1 430 paires : environ 5 jours pour Ivana.
  • Selon l’évaluation : environ 98 % des liens étaient corrects. Ils retrouvaient environ 82 % des vraies paires. Avec une révision parfaite, ils en retrouveraient environ 93 %.
  • Les vérifications des groupes ont coupé environ 140 liens. La plupart auraient réuni deux clients de Larkfield par un seul enregistrement de Fernhollow. Aucun groupe ne comptait plus de 6 enregistrements.
  • Selon l’évaluation : une précision B-cubed d’environ 0,99 et un rappel d’environ 0,96 sur les enregistrements de Fernhollow. La fusion n’a ajouté aucune entité contenant deux personnes différentes de Larkfield.
  • La zone de liaison : l’auteur a étiqueté 49 liens sur 50 « même personne » et un « unsure ». L’évaluation confirmait ce résultat : environ 98 % des liens étaient corrects.
  • La zone de révision était plus difficile qu’elle semblait. L’auteur a indiqué « même personne » pour 39 des 42 paires de révision qui n’étaient pas « unsure ». L’évaluation a montré que seulement environ 8 sur 10 correspondaient à la même personne. Chaque paire « unsure » représentait deux personnes. Une personne lit les mêmes champs que l’apparieur, et les mêmes choses les trompent. Ici, il s’agissait surtout de deux membres d’une famille ayant le même nom et la même adresse. Leur courriel et leur téléphone étaient différents. Voilà pourquoi les décisions d’Ivana ont besoin de leur propre test, comme dans La révision humaine.
  • Le pipeline complet a pris environ 2 minutes sur l’ordinateur portable de l’auteur. Le blocage a pris moins de 1 seconde, les vecteurs environ 1 seconde et l’entraînement de Splink environ 3 secondes. Chaque méthode coûtait beaucoup moins d’un cent par 1 000 paires au tarif de processeur du cours.

Erreur courante

Un seuil qui crée plus d'un quart de million de liens

Symptôme : vous choisissez le seuil qui donne le meilleur score F1 sur les paires de validation. Le seuil de LightGBM est proche de 0. Les paires étiquetées montrent une précision proche de 1,0. Mais votre apparieur relie environ 280 000 paires pour 10 773 enregistrements.

Cause : les paires étiquetées ne contiennent aucune paire difficile de personnes différentes. Presque chaque paire « différente » présente un nom de famille ou une région différents. Un seuil très bas ne fait donc perdre aucune précision sur ces paires. Sur l’ensemble des candidats, il relie la plupart des paires. Dans l’exécution évaluée de l’auteur, seulement 3 % environ de ces liens étaient corrects. Une entité comptait environ 50 000 enregistrements.

Solution : comptez vos liens avant de vous fier à un seuil. Choisissez le seuil selon des probabilités bien étalonnées et la capacité d’Ivana. Mesurez ensuite la précision sur votre propre échantillon aléatoire de liens, comme dans la partie 6.

Conséquence pour le travail en IA : un jeu de test qui ne ressemble pas aux entrées réelles donne un seuil qui échoue en production. Vérifiez comment votre jeu de test a été échantillonné.

Erreur courante

Des noms dans le mauvais ordre

Symptôme : votre blocage conserve presque toutes les vraies paires. Mais votre apparieur en trouve beaucoup moins que dans les enregistrements de Larkfield.

Cause : votre analyseur prend le mauvais mot comme nom de famille. Les clés de courriel, de téléphone et de code postal trouvent encore beaucoup de paires. Le blocage semble donc correct. Mais les caractéristiques de nom du vecteur comparent maintenant un prénom à un nom de famille.

Solution : lisez 30 lignes et déterminez quel mot est le nom de famille. Vérifiez ensuite l’analyse sur des enregistrements où vous pouvez distinguer le prénom du nom de famille.

Conséquence pour le travail en IA : un pipeline qui s’exécute sans erreur peut quand même lire chaque valeur incorrectement. Vérifiez les données, pas seulement le code.

  • Appliquer l’idée de Tomás telle quelle. Le modèle de Larkfield fonctionne sur Fernhollow. Mais ses variables de date de naissance y sont toujours manquantes, et la nouvelle liste a ses propres problèmes. Mesurez ses résultats sur les paires de Fernhollow.
  • Une année dans le champ de date. Le projet compare 1979 à 1979-05-20 et conclut « différent ». Gardez l’année à part et utilisez-la dans une vérification.
  • Même nom, même adresse, même téléphone. Il ne s’agit pas toujours d’une seule personne. Les frères dans Des poids à une décision étaient deux personnes. Examinez les noms, les années de naissance et tout ce que deux personnes d’une même famille ne partagent pas.
  • Une valeur dans de nombreux enregistrements. Comptez les téléphones et courriels les plus fréquents avant de vous y fier. Une seule valeur partagée peut créer un groupe géant.
  • Deux anciens clients fusionnés par un seul nouvel enregistrement. Un enregistrement de Fernhollow lié à deux clients différents de Larkfield ne doit pas, à lui seul, les fusionner. Envoyez ces liens en révision.
  • Une précision tirée des paires étiquetées. Elle est trop élevée. Rapportez plutôt celle de votre propre échantillon.
  • Une exécution de test utilisée deux fois. Exécutez les paires de test une seule fois. Si vous changez quoi que ce soit ensuite, dites-le. Précisez que votre test sert maintenant de deuxième validation.
Afficher les valeurs de vérification publiques

Ouvrez ceci seulement après avoir obtenu vos propres chiffres. Ces valeurs proviennent des fichiers publics, donc vous pouvez les vérifier. Ce ne sont pas les réponses au travail.

  • Fichiers : 10 773 enregistrements de Fernhollow. 600 paires étiquetées : 322 en validation (124 vraies paires) et 278 en test (116 vraies paires). Chaque fichier dans SHA256SUMS est correct.
  • Toutes les paires possibles avec un enregistrement de Fernhollow : 705 566 862. Cela représente 10 773 × 60 108 paires avec Larkfield, plus les paires à l’intérieur de Fernhollow.
  • Les clés du cours (code postal, courriel, téléphone, début du nom de famille, date de naissance) sur la table combinée, avec les noms de Fernhollow dans le bon ordre : 421 383 paires candidates avec un enregistrement de Fernhollow. Elles conservent les 124 vraies paires de validation.
  • Vitesse sur le portable de l’auteur (Apple M4, un fil d’exécution pour scikit-learn et LightGBM) : le pipeline complet, avec match golden, a pris environ 2 minutes. La mémoire maximale utilisée était d’environ 5,4 Go.

Récapitulatif

Vous pouvez maintenant fusionner une nouvelle liste de clients avec une liste existante et justifier le résultat. Vous lisez un nouveau schéma avant de l’analyser. Vous bloquez en estimant l’exhaustivité des paires sur un échantillon représentatif de vraies paires. Vous comparez une référence de base par règles à trois autres familles sur les mêmes paires. Vous savez ce que les paires étiquetées peuvent et ne peuvent pas vous dire. Vous fixez des seuils avec une zone de révision qu’une personne peut traiter au complet. Vous vérifiez les groupes avant qu’ils deviennent des clients. Vous créez des fiches de référence avec leurs sources et leur historique, et vous annulez une fusion. Vous mesurez la précision sur vos propres étiquettes, et vous savez qu’elles peuvent être erronées. Enfin, vous consignez les données personnelles utilisées, leur durée de conservation et la façon de les supprimer d’un client fusionné.