Towards Practical Benchmarking of Data Cleaning Techniques: On Generating Authentic Errors via Large Language Models

Dit paper introduceert TableEG, een framework dat gebruikmaakt van fijngefineerde grote taalmodellen om authentieke fouten in tabulaire data te genereren, waardoor een robuust en betrouwbaar benchmark voor het evalueren van data-cleaning technieken wordt gecreëerd.

De kern

Stel je voor dat je een enorme bibliotheek hebt vol met perfecte boeken (data). Maar soms, door een vergissing van een bibliothecaris of een beschadigde pagina, staan er fouten in: een naam is verkeerd gespeld, een jaartal ontbreekt, of er staat een verhaal dat niet bij de auteur hoort.

Om te leren hoe je deze fouten kunt vinden en repareren, hebben computerwetenschappers een "trainingscentrum" nodig. Ze hebben duizenden boeken nodig die opzettelijk fouten bevatten, zodat hun software (de "reparateurs") kan oefenen.

Het probleem? Het handmatig fouten maken in duizenden boeken is extreem saai, duur en vaak niet realistisch. De oude methodes maakten fouten alsof een robot een toetsenbord had geraakt: "Interstellar" werd "InterstellaR" of "142 minuten" werd "142 mix". Dat ziet er niet echt uit als een fout die een mens maakt.

Hier komt TableEG in het spel.

Wat is TableEG?

TableEG is een slimme computerprogramma (een "Large Language Model" of LLM) dat is getraind om echte, menselijke fouten te maken in tabellen. Het is alsof je een zeer ervaren bibliothecaris hebt die niet alleen fouten maakt, maar precies weet hoe mensen fouten maken.

Hoe werkt het? (De Analogie van de Acteurs)

Stel je voor dat je een film wilt draaien over een bibliotheek met fouten.

1. De Oude Methode (BART):
   Dit is als een regisseur die zegt: "Maak een fout!" en dan een robot een willekeurige letter laat vervangen.

   • Resultaat: De titel "Forrest Gump" wordt "Forrest GumX". Dat is raar. Niemand maakt die fout. Het is te voorspelbaar en saai.

2. De Nieuwe Methode (TableEG):
   Dit is als een regisseur die een getrainde acteur heeft. Deze acteur heeft duizenden echte films gekeken en weet precies hoe mensen fouten maken.

   • Resultaat: De acteur zegt: "Ah, ik zie dat mensen vaak de naam van een film verwarren met een andere film die ze net hebben gezien." Dus verandert "Forrest Gump" in "The Truman Show". Of hij zegt: "Mensen vergeten soms een cijfer in een telefoonnummer."
   • Waarom is dit beter? Omdat de fout eruitziet als iets dat een echt mens zou doen. Het is niet zomaar een willekeurige letter; het heeft een logische (maar verkeerde) reden.

De Drie Trucs van TableEG

Om deze acteur zo goed mogelijk te maken, hebben de onderzoekers drie dingen gedaan:

1. De "Spelregels" (Triplet Representatie):
   Ze hebben de computer niet zomaar laten gissen. Ze hebben een strakke structuur gebruikt: Opdracht (I) + Tabel (T) + Antwoord (O).

   • Voorbeeld: "Hier is een schone lijst met films (T). Maak hier een fout in (O), zoals een ontbrekende datum." De computer leert zo precies wat er van hem verwacht wordt.

2. De "Oefeningen" (Instruction Fine-Tuning):
   In plaats van alleen te vragen om fouten te maken, hebben ze de computer ook laten oefenen in het opsporen en repareren van fouten.

   • Analogie: Het is alsof je een detective niet alleen laat zien waar de moordenaar is, maar hem ook laat oefenen in het vinden van de moordenaar én het reconstrueren van het misdrijf. Door dit te doen, begrijpt de computer de "patronen" van fouten veel beter.

3. De "Werkplaats" (Diverse Data):
   Ze hebben de computer getraind op 12 verschillende soorten tabellen: van films en restaurants tot ziekenhuizen en vliegtickets.

   • Waarom? Als je alleen leert fouten maken in een restaurantmenu, weet je niet hoe je een fout moet maken in een medisch dossier. Door alles te leren, wordt de computer een echte expert in elk soort tabel.

Waarom is dit belangrijk?

Vroeger testten wetenschappers hun foutopsporingssoftware met die "robotische" fouten (zoals "142 mix"). Dat was als het testen van een brandblusser op een kaarsje dat je met een lucifer hebt aangestoken. Het werkt, maar het is niet echt.

Met TableEG testen ze hun software nu met fouten die eruitzien als een echte brand die door een mens is veroorzaakt.

• Als de software deze nieuwe, realistische fouten goed kan vinden, betekent dat dat hij ook echt goed werkt in de echte wereld.
• Het zorgt ervoor dat de software die we gebruiken voor bankzaken, gezondheidszorg of wetenschap, betrouwbaarder wordt.

Samenvatting in één zin

TableEG is een slimme AI die is getraind om fouten te maken die eruitzien alsof ze door een mens zijn gemaakt, zodat we onze computers beter kunnen leren hoe ze die fouten moeten vinden en repareren in de echte wereld.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het artikel "Towards Practical Benchmarking of Data Cleaning Techniques: On Generating Authentic Errors via Large Language Models" in het Nederlands.

Titel: Naar Praktische Benchmarking van Data Cleaning Technieken: Het Genereren van Authentieke Fouten via Grootte Taalmodellen (LLM's)

Auteurs: Xinyuan Liu et al. (Nankai University, HIT Shenzhen, Tsinghua University, Beihang University)
Publicatie: PVLDB (Proceedings of the VLDB Endowment)

---

1. Het Probleem

De kwaliteit van data is een fundamentele uitdaging in datagedreven systemen. Fouten in tabulaire data (zoals missende waarden, typefouten of schendingen van integriteitsregels) kunnen de prestaties van downstream-analyses en machine learning-modellen ernstig compromitteren.

Hoewel er veel algoritmen zijn ontwikkeld voor het detecteren van fouten, ontbreekt het aan diverse, realistische datasets voor een uitgebreide evaluatie.

• Manuele annotatie: Het handmatig labelen van fouten is tijdrovend, duur en vaak inconsistent.
• Bestaande synthetische methoden (BART): De huidige standaard, BART, gebruikt regels (zoals functionele afhankelijkheden) om fouten te genereren. Dit leidt echter tot beperkte diversiteit. De gegenereerde fouten zijn vaak te voorspelbaar (bijv. willekeurige karakters vervangen) en missen de complexe, semantische inconsistenties die voorkomen in echte werelddata. Ze kunnen bijvoorbeeld geen realistische "missing values" of domeinspecifieke semantische fouten genereren.

Er is dus een dringende behoefte aan een methode om authentieke synthetische fouten te genereren die de statistische verdeling en patronen van echte data-corruptie nauwkeurig nabootsen.

2. Methodologie: TableEG

De auteurs stellen TableEG voor, een framework dat Large Language Models (LLM's) gebruikt om realistische fouten te genereren. De aanpak bestaat uit een instructie-gefine-tuned LLM die is getraind op een gestructureerde manier om de tweedimensionale aard van tabellen te begrijpen.

Kerncomponenten:

1. Triplet Representatie $(I, T, O)$:
   In plaats van LLM's direct te laten genereren, modelleren ze taken als een triplet:

   • $I$ (Instruction): Een instructie die de taak en het type fout beschrijft.
   • $T$ (Table): Een steekproef van de invoertabel (context).
   • $O$ (Output): De verwachte gestructureerde output (bijv. de locatie van de fout en de nieuwe waarde).

2. Instructie Fine-Tuning:
   Het model (gebaseerd op LLaMA 3.1-8B) wordt gefine-tuned met LoRA (Low-Rank Adaptation). De trainingdata bestaat uit handmatig gelabelde fouten uit 12 real-world datasets over 10 domeinen (zoals financiën, gezondheid, entertainment).

   • Trainingstaken: Het model leert niet alleen fouten genereren, maar ook fouten detecteren en corrigeren. Deze drie taken zijn gekoppeld: het begrijpen van hoe een fout eruitziet (detectie) en hoe deze opgelost moet worden (correctie) verbetert de kwaliteit van het genereren van nieuwe fouten.
   • Structuurbewustzijn: Door taken zoals rij/kolom-swapping en header-matching toe te voegen, leert het model de tweedimensionale structuur en afhankelijkheden tussen cellen beter te respecteren dan standaard LLM's.

3. Foutgeneratie Proces:

   • De gebruiker specificeert een schone tabel en parameters voor het foutpercentage en de verdeling van fouttypes (outliers, missende waarden, regelschendingen, patroonfouten).
   • Het framework selecteert subtabellen, construeert een prompt en gebruikt het gefine-tuned model om specifieke cellen te wijzigen met realistische waarden (bijv. het vervangen van een filmtitel door een andere echte filmtitel in plaats van willekeurige karakters).

3. Belangrijkste Bijdragen

1. TableEG Framework: Een nieuw framework dat LLM's inzet voor het genereren van authentieke tabulaire fouten, gebaseerd op een gestructureerde triplet-representatie en fine-tuning.
2. Diverse Training: Het gebruik van 12 real-world datasets met handmatig gelabelde fouten, wat zorgt voor een breed scala aan fouttypes en semantische contexten.
3. Uitgebreide Evaluatiestrategie: Een nieuwe reeks metrieken om de kwaliteit van gegenereerde fouten te meten, zowel op patroonniveau als op distributieniveau.
4. Empirisch Bewijs: Uitgebreide experimenten die aantonen dat TableEG superieur is aan bestaande methoden (BART en niet-gefine-tunde GPT-3.5).

4. Resultaten

De auteurs hebben TableEG geëvalueerd op zowel "geziene" (tijdens training gebruikte) als "ongezien" datasets en vergeleken met BART en GPT-3.5 (Turbo).

• Patroon Alignement ($S_{EPA}$): TableEG behaalde een gemiddelde score van 77,76% op de Error Pattern Alignment Similarity Score, aanzienlijk hoger dan BART (49,36%) en GPT-3.5 (50,45%). Dit betekent dat de gegenereerde fouten semantisch en structureel veel meer lijken op echte fouten.
• Distributie Alignement:
  • Weighted Jaccard Similarity ($J^w_{col}$): TableEG toonde een veel hogere overeenkomst in de verdeling van fouten over kolommen (bijv. 82,3 vs 34,69 voor BART op de Flight-dataset).
  • Jensen-Shannon Divergentie ($D_{JS}$): TableEG had de laagste divergentie, wat aangeeft dat de verdeling van fouttypes (missende waarden vs. outliers) het meest overeenkomt met realiteit.
• Impact op Detectie-algoritmen:
  • Wanneer bestaande foutdetectie-algoritmen (zoals Raha, Holistic, Horizon) werden getest op datasets met TableEG-fouten versus echte datasets, waren de prestaties (Precision, Recall, F1-score) bijna identiek.
  • Dit bewijst dat TableEG-fouten dezelfde "uitdagingen" bieden als echte data-corruptie, waardoor ze ideaal zijn voor het trainen en testen van data cleaning tools.

5. Betekenis en Conclusie

Deze paper lost een cruciaal gat op in de datakwaliteitsresearch: het gebrek aan realistische, schaalbare benchmarks voor het testen van data cleaning technieken.

• Overbrugt de kloof: TableEG overbrugt de kloof tussen synthetische en real-world fouten. De gegenereerde data is niet langer "kunstmatig" in de zin van onrealistische patronen, maar reflecteert de complexiteit van echte data-integratieproblemen.
• Toekomstige toepassing: Het framework stelt onderzoekers en praktici in staat om robuuste benchmarks te creëren zonder afhankelijk te zijn van kostbare manuele annotatie.
• Generalisatie: Het model toont sterke generalisatievermogen, zelfs op datasets die niet tijdens de training zijn gezien, wat aantoont dat het de onderliggende principes van data-corruptie heeft geleerd en niet alleen de trainingdata heeft gememoriseerd.

Kortom, TableEG biedt een nieuwe, praktische standaard voor het evalueren van data cleaning systemen door het gebruik van instructie-gefine-tunde LLM's om authentieke, semantisch betekenisvolle fouten te synthetiseren.