Geweldige Verwachtingen Zelfstudie: Gegevens valideren met Python

Handleidingen
Python

Gegevenskwaliteit en consistentie zijn als de fundering van een huis—zonder een solide basis loopt alles wat erbovenop is gebouwd het risico in te storten. Hier speelt gegevensvalidatie een belangrijke rol. Gegevensvalidatie helpt je ervoor te zorgen dat je gegevens accuraat, consistent en betrouwbaar zijn.

Great Expectations is een open-source gegevensvalidatietool die je in staat stelt om gegevensproblemen vroegtijdig te identificeren en ervoor zorgt dat je gegevens voldoen aan de vereiste kwaliteitsnormen.

In deze gids begeleiden we je door het proces van het gebruik van Great Expectations voor gegevensvalidatie, met een praktisch end-to-end voorbeeld om je op weg te helpen!

Wat is Great Expectations?

Great Expectations (GX) is een open-source framework dat populair is geworden voor het beheren en automatiseren van gegevensvalidatie in moderne gegevenspijplijnen.

Zijn op Python gebaseerd framework is ontworpen om datateams te helpen de kwaliteit en consistentie van hun gegevens te waarborgen. Gebruikers kunnen “verwachtingen” definiëren – regels of tests die beschrijven hoe geldige gegevens eruit zouden moeten zien – die automatisch valideren of de gegevens aan deze normen voldoen.

Enkele voordelen van Great Expectations zijn:

  • Geautomatiseerde gegevensvalidatie – Great Expectations automatiseert het proces van het valideren van gegevens, waardoor handmatige inspanningen worden verminderd en het risico op fouten wordt geminimaliseerd. Het zorgt ervoor dat gegevens consistent voldoen aan vooraf gedefinieerde normen.
  • Integratie met gegevenspijplijnen – Het integreert gemakkelijk met verschillende gegevensbronnen en -platforms, waaronder SQL-databases, cloudopslag en ETL-tools, waardoor gegevensvalidatie mogelijk is in verschillende fasen van uw pijplijn.
  • Duidelijke, bruikbare validatieresultaten – De tool biedt transparante validatieresultaten, waardoor het gemakkelijk is om gegevenskwaliteitsproblemen te herkennen en snel aan te pakken.
  • Gegevensdocumentatie – Great Expectations kan gedetailleerde, toegankelijke documentatie genereren van uw gegevensvalidatieprocessen, waarbij teams zich kunnen afstemmen op kwaliteitsnormen en een referentie bieden voor toekomstig gebruik.
  • Schaalbaarheid en flexibiliteit – Als een open-source tool is Great Expectations zeer aanpasbaar en kan het meegroeien met uw behoeften op het gebied van gegevensvalidatie, waarbij flexibiliteit wordt geboden om aan te passen aan verschillende use cases zonder hoge kosten.

Laten we nu eens kijken naar een voorbeeld van begin tot eind!

Instellen van Great Expectations

In deze tutorial leer je hoe je GX Core, de open-source versie van Great Expectations, kunt gebruiken om een Pandas DataFrame te valideren. We zullen door het instellen van een context, het registreren van een Pandas gegevensbron, het definiëren van verwachtingen en het valideren van databatches lopen.

Opmerking: We raden je aan om mee te doen met de DataLab notebook, maar je kunt ook je eigen Python script maken.

Vereisten

  • Python 3.9 tot 3.12 geïnstalleerd.
  • Om conflicten te vermijden, wordt het sterk aanbevolen om Great Expectations binnen een virtuele omgeving te installeren (disclaimer: de installatie van virtuele omgevingen valt buiten de reikwijdte van dit artikel).
  • Een voorbeeld dataset.

Opmerking: Als u de meegeleverde DataLab-notebook gebruikt, zijn deze vereisten al voldaan. U kunt ze gerust overslaan.

Gebruik de volgende opdracht om GX te installeren via pip:

pip install great_expectations

Deze opdracht installeert het kernpakket en alle benodigde afhankelijkheden.

Great Expectations vereist een gegevenscontext om configuraties te beheren. We gebruiken een vluchtige gegevenscontext om configuraties niet permanent op te slaan.

import great_expectations as gx

# Krijg de Vluchtige Gegevenscontext
context = gx.get_context()
assert type(context).__name__ == "EphemeralDataContext"

Het maken van je eerste gegevensvalidatiesuite

Nu GX is ingesteld, laten we een gegevensvalidatiesuite maken.

Een gegevensbron verbindt Great Expectations met uw gegevens, terwijl een gegevensobject een specifieke subset van gegevens vertegenwoordigt (bijv. een tabel, DataFrame of bestand).

In dit geval zullen we alles voorbereiden om verbinding te maken met een DataFrame genaamd inventory_parts_df. De voorbeelddataset is beschikbaar in de verstrekte DataLab en wordt aangemaakt zodra we het SQL-blok uitvoeren:

Als je geen gebruik maakt van DataLab, maak dan je eigen DataFrame aan met voorbeeldgegevens.

Maak nu je gegevensbron en bronobject aan:

# Voeg een Pandas-gegevensbron toe
data_source = context.data_sources.add_pandas(name="inventory_parts")
# Voeg een gegevensobject toe aan de gegevensbron
data_asset = data_source.add_dataframe_asset(name="inventory_parts_asset")

Een batchdefinitie identificeert en organiseert je gegevens voor validatie. Hier voegen we een batchdefinitie toe die de volledige DataFrame bestrijkt:

# Definieer de naam van de Batch Definitie
batch_definition_name = "inventory_parts_batch"
# Voeg de Batch Definitie toe
batch_definition = data_asset.add_batch_definition_whole_dataframe(batch_definition_name)
assert batch_definition.name == batch_definition_name

Een batch is een verzameling gegevens gekoppeld aan een batch definitie. Om gegevens te valideren, moet je de batch ophalen en koppelen aan je DataFrame, in dit geval inventory_parts_df:

# Definieer de Batch Parameters
batch_parameters = {"dataframe": inventory_parts_df}
# Haal de Batch op
batch = batch_definition.get_batch(batch_parameters=batch_parameters)

Verwachtingen zijn regels voor het valideren van gegevens. In dit voorbeeld zullen we de volgende eenvoudige verwachtingen definiëren:

  1. Zorg ervoor dat de waarden van inventory_id niet leeg zijn.
  2. Zorg ervoor dat de waarden van part_num uniek zijn.
# Maak een Verwachtings Suite
expectation_suite_name = "inventory_parts_suite"
suite = gx.ExpectationSuite(name=expectation_suite_name)
# Voeg Verwachtingen Toe
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToNotBeNull(column="inventory_id")
)
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToBeUnique(column="part_num")
)
# Voeg de Verwachtings Suite Toe aan de Context
context.suites.add(suite)

Je kunt alle beschikbare verwachtingen verkennen in de Verwachtings Galerij. We moedigen je aan om er nog een paar toe te voegen!

Na het definiëren van de verwachtingen, geeft GX de configuratie van de verwachtings suite weer:

{
  "name": "inventory_parts_suite",
  "id": "b2de0b69-0869-4163-8dde-6c09884483f7",
  "expectations": [
    {
      "type": "expect_column_values_to_not_be_null",
      "kwargs": {
        "column": "inventory_id"
      },
      "meta": {},
      "id": "53d6c42a-d190-412f-a113-783b706531f4"
    },
    {
      "type": "expect_column_values_to_be_unique",
      "kwargs": {
        "column": "part_num"
      },
      "meta": {},
      "id": "362a2bdc-616d-4b3a-b7f0-c73808caee78"
    }
  ],
  "meta": {
    "great_expectations_version": "1.2.4"
  },
  "notes": null
}

De suite bevat de volgende details:

  1. Naam en ID van de suite: Een unieke naam (inventory_parts_suite) en identificatie om de suite te volgen en beheren.
  2. Verwachtingen:Elke regel specificeert:
    • Het type controle (bijv. controleren of een kolom geen lege waarden of unieke items bevat).
    • Parameters, zoals de te valideren kolom.
    • Metadata en een unieke ID voor elke verwachting, waardoor gemakkelijker bijhouden en aanpassen mogelijk is.
  3. Metadata:Versie-informatie voor Great Expectations, waardoor compatibiliteit met de tool wordt gegarandeerd.
  4. Notities: Een plekhouder voor het toevoegen van beschrijvende opmerkingen over de suite (optioneel).

Deze gestructureerde output dient zowel als documentatie en als herbruikbare configuratie voor het valideren van uw dataset, zodat uw verwachtingen duidelijk gedefinieerd, traceerbaar en klaar voor toekomstig gebruik zijn.

5. Valideren van de data

Tenslotte, valideer de batch tegen de gedefinieerde verwachtingen en evalueer de resultaten.

# Valideer de Data Tegen de Suite
validation_results = batch.validate(suite)
# Evalueer de Resultaten
print(validation_results)

Na het uitvoeren van de validatie, biedt Great Expectations een gedetailleerd rapport over of de dataset voldoet aan de gedefinieerde verwachtingen:

{
  "success": false,
  "results": [
    {
      "success": true,
      "expectation_config": {
        "type": "expect_column_values_to_not_be_null",
        "kwargs": {
          "batch_id": "inventory_parts-inventory_parts_asset",
          "column": "inventory_id"
        },
        "meta": {},
        "id": "53d6c42a-d190-412f-a113-783b706531f4"
      },
      "result": {
        "element_count": 580069,
        "unexpected_count": 0,
        "unexpected_percent": 0.0,
        "partial_unexpected_list": [],
        "partial_unexpected_counts": [],
        "partial_unexpected_index_list": []
      },
      "meta": {},
      "exception_info": {
        "raised_exception": false,
        "exception_traceback": null,
        "exception_message": null
      }
    },
    {
      "success": false,
      "expectation_config": {
        "type": "expect_column_values_to_be_unique",
        "kwargs": {
          "batch_id": "inventory_parts-inventory_parts_asset",
          "column": "part_num"
        },
        "meta": {},
        "id": "362a2bdc-616d-4b3a-b7f0-c73808caee78"
      },
      "result": {
        "element_count": 580069,
        "unexpected_count": 568352,
        "unexpected_percent": 97.98006788847535,
        "partial_unexpected_list": [
          "48379c01",
          "paddle",
          "11816pr0005",
          "2343",
          "3003",
          "30176",
          "3020",
          "3022",
          "3023",
          "30357",
          "3039",
          "3062b",
          "3068b",
          "3069b",
          "3069b",
          "33291",
          "33291",
          "3795",
          "3941",
          "3960"
        ],
        "missing_count": 0,
        "missing_percent": 0.0,
        "unexpected_percent_total": 97.98006788847535,
        "unexpected_percent_nonmissing": 97.98006788847535,
        "partial_unexpected_counts": [
          {
            "value": "3069b",
            "count": 2
          },
          {
            "value": "33291",
            "count": 2
          },
          {
            "value": "11816pr0005",
            "count": 1
          },
          {
            "value": "2343",
            "count": 1
          },
          {
            "value": "3003",
            "count": 1
          },
          {
            "value": "30176",
            "count": 1
          },
          {
            "value": "3020",
            "count": 1
          },
          {
            "value": "3022",
            "count": 1
          },
          {
            "value": "3023",
            "count": 1
          },
          {
            "value": "30357",
            "count": 1
          },
          {
            "value": "3039",
            "count": 1
          },
          {
            "value": "3062b",
            "count": 1
          },
          {
            "value": "3068b",
            "count": 1
          },
          {
            "value": "3795",
            "count": 1
          },
          {
            "value": "3941",
            "count": 1
          },
          {
            "value": "3960",
            "count": 1
          },
          {
            "value": "48379c01",
            "count": 1
          },
          {
            "value": "paddle",
            "count": 1
          }
        ],
        "partial_unexpected_index_list": [
          0,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21
        ]
      },
      "meta": {},
      "exception_info": {
        "raised_exception": false,
        "exception_traceback": null,
        "exception_message": null
      }
    }
  ],
  "suite_name": "inventory_parts_suite",
  "suite_parameters": {},
  "statistics": {
    "evaluated_expectations": 2,
    "successful_expectations": 1,
    "unsuccessful_expectations": 1,
    "success_percent": 50.0
  },
  "meta": {
    "great_expectations_version": "1.2.4",
    "batch_spec": {
      "batch_data": "PandasDataFrame"
    },
    "batch_markers": {
      "ge_load_time": "20241129T122532.416424Z",
      "pandas_data_fingerprint": "84a1e1939091fcf54324910def3b89cd"
    },
    "active_batch_definition": {
      "datasource_name": "inventory_parts",
      "data_connector_name": "fluent",
      "data_asset_name": "inventory_parts_asset",
      "batch_identifiers": {
        "dataframe": "<DATAFRAME>"
      }
    }
  },
  "id": null
}

Deze rapportage geeft de kwaliteit van uw gegevens weer, waarbij successen en mislukkingen worden benadrukt. Hier is een vereenvoudigde uitleg van de resultaten:

Algehele validatie: De validatieresultaat was gedeeltelijk succesvol: 50% van de verwachtingen slaagde en 50% faalde. Een mislukte verwachting duidt op een gegevenskwaliteitsprobleem dat aandacht behoeft. In dit geval voldeed één kolom niet aan de gedefinieerde regel.

Verwachting 1: inventory_id mag geen ontbrekende waarden hebben

  • Result: Geslaagd
  • Uitleg: Elke waarde in de kolom inventory_id is aanwezig, zonder nullen of ontbrekende invoer. Dit duidt op een goede gegevensvolledigheid voor deze kolom.

Verwachting 2: part_num moet unieke waarden hebben

  • Result: Mislukt
  • Verklaring: De kolom part_num bevat 97,98% duplicaatwaarden, wat betekent dat slechts een paar waarden uniek zijn.
  • Hoogtepunten:
    • Enkele voorbeelden van duplicaatwaarden zijn “3069b” en “33291”.
    • De tool toont ook hoe vaak deze duplicaten voorkomen en hun rijposities, waardoor het gemakkelijker wordt om de problemen te lokaliseren en op te lossen.

Natuurlijk, dit is slechts een voorbeelddataset, en we hebben opzettelijk een passerende en een niet passerende verwachting opgenomen zodat je beide validatieresultaten kunt zien.

Dat is het! Je hebt met succes end-to-end datavalidaties uitgevoerd.

Integreren van Great Expectations in Data Pipelines

In een productieomgeving moeten validaties direct in de workflow worden ingebed om de datakwaliteit in elke fase continu te monitoren.

In deze sectie bespreken we hoe je Great Expectations kunt integreren in je datapijplijnen.

Dit zijn voorbeelden om je een idee te geven, en extra configuraties die hier niet zijn opgenomen kunnen nodig zijn. Bekijk de documentatie van elk hulpmiddel voor de meest actuele syntaxis!

Integratie met ETL-tools

Het integreren van Great Expectations met populaire ETL-tools zoals Apache Airflow of Prefect is relatief eenvoudig. Het insluiten van validatiestappen rechtstreeks in de ETL-processen stelt u in staat om gegevensproblemen in realtime aan te pakken voordat ze van invloed zijn op downstream-analyse.

Laten we een eenvoudig voorbeeld doorlopen van het integreren van Great Expectations met Prefect om gegevensvalidatie uit te voeren als onderdeel van een geautomatiseerde ETL-workflow:

from prefect import task, Flow
import great_expectations as ge
# Definieer een taak om Great Expectations-validatie uit te voeren
@task
def validate_data():
    context = ge.data_context.DataContext()
    batch_kwargs = {"path": "path/to/your/datafile.csv", "datasource": "your_datasource"}
    batch = context.get_batch(batch_kwargs, suite_name="your_expectation_suite")
    results = context.run_validation_operator("action_list_operator", assets_to_validate=[batch])
	    
    # Controleer validatieresultaten en geef een waarschuwing als validatie mislukt
    if not results["success"]:
        raise ValueError("Data validation failed!")
# Definieer uw ETL-flow
with Flow("ETL_with_GE_Validation") as flow:
    validation = validate_data()
# Voer de flow uit
flow.run()

In dit voorbeeld definiëren we een Prefect-flow met een taak voor het uitvoeren van Great Expectations-validatie.

De taak validate_data() laadt de Great Expectations-context, haalt de databatch op en past de verwachtingssuite toe.

Als de gegevens niet voldoen aan de validatiecriteria, geeft de taak een waarschuwing, stopt de workflow en voorkomt downstream-fouten.

Continue gegevensvalidatie

U kunt validatietaken plannen met verschillende tools, zoals cron-taken op op Unix gebaseerde systemen of beheerde services zoals Apache Airflow. Voor dit voorbeeld zullen we laten zien hoe u validatieruns kunt plannen met Airflow, dat goed geschikt is voor het orchestreren van datapipelines.

Zo kunt u een Airflow DAG opzetten om dagelijks Great Expectations-validaties uit te voeren:

from airflow import DAG
from airflow.operators.python_operator import PythonOperator
from datetime import datetime
import great_expectations as ge
# Definieer de DAG en stel het schema in om dagelijks uit te voeren
default_args = {
	  'owner': 'airflow',
	  'start_date': datetime(2024, 1, 1),
	  'retries': 1,
}
dag = DAG(
      'great_expectations_validation',
	default_args=default_args,
	schedule_interval='@daily',  # Voert eenmaal per dag uit
)
# Definieer de functie om de validatie uit te voeren
def run_validation():
    context = ge.data_context.DataContext()
    batch = context.get_batch(batch_kwargs, suite_name="your_expectation_suite")
    results = context.run_validation_operator("action_list_operator", assets_to_validate=[batch])
    return results
# Stel de taak in Airflow in
validation_task = PythonOperator(
      task_id='run_great_expectations_validation',
      python_callable=run_validation,
      dag=dag,
)
# Stel de taak in de DAG in
validation_task

In dit voorbeeld definiëren we een DAG die een validatie uitvoert eenmaal per dag (@daily).

De run_validation() functie voert de validatie uit door de Great Expectations-context te laden en de gedefinieerde verwachtingsreeks tegen de gegevens uit te voeren.

Best Practices voor Data Validatie met Great Expectations

Het volgen van best practices wordt altijd aangeraden voor schaalbaarheid en efficiëntie, en dat geldt ook voor data validatie met Great Expectations.

Begin klein en iteratief

Begin met fundamentele controles voor gegevenskwaliteit en breid deze geleidelijk uit. Het is beter om aanvankelijk te focussen op basisverwachtingen, aangezien dit helpt om het proces niet te ingewikkeld te maken, wat zorgt voor een soepelere integratie en gemakkelijker oplossen van problemen. Naarmate je inzicht in de dataset verbetert, kun je meer complexe validaties toevoegen.

Samenwerken tussen teams

Gegevenskwaliteit is niet alleen een technische kwestie. Werk samen met zakelijke teams om verwachtingen te definiëren en ervoor te zorgen dat de geïmplementeerde validatie in lijn is met de onderliggende bedrijfslogica en doelen. Deze interdisciplinaire aanpak garandeert dat gegevens hun beoogde doel dienen en voldoen aan de eisen van alle belanghebbenden.

Automatiseer waar mogelijk

Automatiseer het proces waar mogelijk om gegevensvalidatie te integreren in gegevenspijplijnen. Door geautomatiseerde validatiecontroles te integreren, kun je de gegevenskwaliteit continu monitoren zonder handmatige interventie, wat de efficiëntie aanzienlijk verbetert.

Conclusie

Geweldig werk! Je hebt geleerd hoe je gegevens kunt configureren en valideren in Great Expectations. Deze technieken helpen om de hoge datakwaliteit en transparantie in je workflows te behouden.

Om je vaardigheden verder te ontwikkelen, bekijk deze bronnen:

Source:
https://www.datacamp.com/tutorial/great-expectations-tutorial