Große Erwartungen Tutorial: Validierung von Daten mit Python

Große Erwartungen wecken

In diesem Lernprogramm lernst du, wie du mit GX Core, der Open-Source-Version von Great Expectations, einen Pandas DataFrame validieren kannst. Wir gehen durch das Einrichten eines Kontexts, das Registrieren einer Pandas-Datenquelle, das Definieren von Erwartungen und das Validieren von Datenbatches.

Hinweis: Wir empfehlen dir, mit dem DataLab-Notebook zu arbeiten, aber du kannst auch dein eigenes Python-Skript erstellen.

1. Installation von Great Expectations

Voraussetzungen

• Python 3.9 bis 3.12 installiert.
• Um Konflikte zu vermeiden, wird dringend empfohlen, dass du Great Expectations in einer virtuellen Umgebung installierst (Haftungsausschluss: Die Einrichtung von virtuellen Umgebungen geht über den Rahmen dieses Artikels hinaus).
• Ein Beispiel-Datensatz.

Hinweis: Wenn du das mitgelieferte DataLab-Notebook verwendest, sind diese Voraussetzungen bereits erfüllt. Du kannst sie gerne auslassen.

Verwende den folgenden Befehl, um GX über pip zu installieren:

pip install great_expectations

Mit diesem Befehl werden das Kernpaket und alle notwendigen Abhängigkeiten installiert.

2. Initialisierung des Datenkontexts

Great Expectations benötigt einen Datenkontext, um Konfigurationen zu verwalten. Wir verwenden einen ephemeren Datenkontext, um zu vermeiden, dass Konfigurationen bestehen bleiben.

import great_expectations as gx

# Get the Ephemeral Data Context
context = gx.get_context()
assert type(context).__name__ == "EphemeralDataContext"

Erstellen deiner ersten Datenvalidierungssuite

Jetzt, wo GX eingerichtet ist, können wir eine Datenvalidierungssuite erstellen.

1. Verbinden mit einer Datenquelle und Erstellen eines Datenassets

Eine Datenquelle verbindet Great Expectations mit deinen Daten, während ein Daten-Asset eine bestimmte Teilmenge von Daten darstellt (z. B. eine Tabelle, ein DataFrame oder eine Datei).

In diesem Fall werden wir alles vorbereiten, um eine Verbindung zu einem DataFrame namens inventory_parts_df herzustellen. Der Beispieldatensatz ist im mitgelieferten DataLab verfügbar und wird erstellt, sobald wir den SQL-Block ausführen:

Wenn du nicht mit DataLab arbeitest, erstelle deinen eigenen DataFrame mit Beispieldaten.

Jetzt erstellst du deine Datenquelle und dein Asset:

# Add a Pandas Data Source
data_source = context.data_sources.add_pandas(name="inventory_parts")
# Add a Data Asset to the Data Source
data_asset = data_source.add_dataframe_asset(name="inventory_parts_asset")

2. Hinzufügen einer Chargendefinition

Eine Stapeldefinition identifiziert und organisiert deine Daten für die Validierung. Hier fügen wir eine Stapeldefinition hinzu, die den gesamten DataFrame umfasst:

# Define the Batch Definition name
batch_definition_name = "inventory_parts_batch"
# Add the Batch Definition
batch_definition = data_asset.add_batch_definition_whole_dataframe(batch_definition_name)
assert batch_definition.name == batch_definition_name

3. Abrufen einer Charge

Ein Batch ist eine Sammlung von Daten, die an eine Batch-Definition gebunden ist. Um die Daten zu validieren, musst du den Batch abrufen und mit deinem DataFrame verknüpfen, in diesem Fall inventory_parts_df:

# Define the Batch Parameters
batch_parameters = {"dataframe": inventory_parts_df}
# Retrieve the Batch
batch = batch_definition.get_batch(batch_parameters=batch_parameters)

4. Eine Suite erstellen und Erwartungen definieren

Erwartungen sind Regeln für die Validierung von Daten. In diesem Beispiel werden wir die folgenden einfachen Erwartungen definieren:

1. Achte darauf, dass die Werte von inventory_id nicht null sind.
2. Stelle sicher, dass die Werte von part_num eindeutig sind.

# Create an Expectation Suite
expectation_suite_name = "inventory_parts_suite"
suite = gx.ExpectationSuite(name=expectation_suite_name)
# Add Expectations
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToNotBeNull(column="inventory_id")
)
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToBeUnique(column="part_num")
)
# Add the Expectation Suite to the Context
context.suites.add(suite)

Du kannst alle verfügbaren Erwartungen in der Erwartungsgalerie erkunden. Wir ermutigen dich, noch ein paar mehr hinzuzufügen!

Nachdem du die Erwartungen definiert hast, gibt GX die Konfiguration der Erwartungssuite aus:

{
  "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
}

Die Suite umfasst die folgenden Details:

1. Name und ID der Suite: Ein eindeutiger Name (inventory_parts_suite) und eine Kennung, um die Suite zu verfolgen und zu verwalten.
2. Erwartungen: Jede Regel legt fest:
• Die Art der Prüfung (z. B. ob eine Spalte keine Nullwerte oder eindeutige Einträge hat).
• Parameter, wie z. B. die zu prüfende Spalte.
• Metadaten und eine eindeutige ID für jede Erwartung, die eine einfachere Nachverfolgung und Anpassung ermöglicht.
3. Metadaten: Versionsinformationen für Great Expectations, um die Kompatibilität mit dem Tool sicherzustellen.
4. Anmerkungen: Ein Platzhalter, um beschreibende Kommentare zur Suite hinzuzufügen (optional).

Diese strukturierte Ausgabe dient sowohl als Dokumentation als auch als wiederverwendbare Konfiguration für die Validierung deines Datensatzes, damit deine Erwartungen klar definiert, nachvollziehbar und für die zukünftige Nutzung bereit sind.

5. Validierung der Daten

Schließlich validierst du die Charge anhand der festgelegten Erwartungen und wertest die Ergebnisse aus.

# Validate the Data Against the Suite
validation_results = batch.validate(suite)
# Evaluate the Results
print(validation_results)

Nach der Validierung liefert Great Expectations einen detaillierten Bericht darüber, ob der Datensatz die definierten Erwartungen erfüllt:

{
  "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
}

Dieser Bericht gibt Aufschluss über die Qualität deiner Daten und zeigt Erfolge und Misserfolge auf. Hier ist eine vereinfachte Erklärung der Ergebnisse:

Gesamtvalidierung: Das Ergebnis der Validierung war teilweise erfolgreich: 50 % der Erwartungen wurden erfüllt, 50 % nicht. Eine fehlgeschlagene Erwartung weist auf ein Problem mit der Datenqualität hin, das behoben werden muss. In diesem Fall entsprach eine Spalte nicht der festgelegten Regel.

Erwartung 1: inventory_id sollte keine fehlenden Werte haben

• Ergebnis: Bestanden
• Erläuterung: Jeder Wert in der Spalte inventory_id ist vorhanden, es gibt keine leeren oder fehlenden Einträge. Das deutet auf eine gute Datenvollständigkeit für diese Spalte hin.

Erwartung 2: part_num sollte eindeutige Werte haben

• Ergebnis: Gescheitert
• Erläuterung: Die Spalte part_num enthält 97,98% doppelte Werte, d.h. nur wenige Werte sind eindeutig.
• Highlights:
• Beispiele für doppelte Werte sind "3069b" und "33291".
• Das Tool zeigt auch an, wie häufig diese Duplikate auftreten und wo sie sich in den Zeilen befinden, damit du die Probleme leichter finden und beheben kannst.

Natürlich ist dies nur ein Beispieldatensatz, und wir haben absichtlich eine positive und eine negative Erwartung aufgenommen, damit du beide Validierungsergebnisse sehen kannst.

Das war's! Du hast die End-to-End-Datenvalidierung erfolgreich durchgeführt.

Große Erwartungen in Datenpipelines integrieren

In einer Produktionsumgebung müssen Validierungen direkt in den Workflow eingebettet werden, um die Datenqualität in jeder Phase kontinuierlich zu überwachen. 

In diesem Abschnitt erfahren wir, wie du Great Expectations in deine Datenpipelines integrieren kannst.

Diese Beispiele sollen dir eine Vorstellung davon geben, welche zusätzlichen Konfigurationen erforderlich sein können, die hier nicht aufgeführt sind. Die aktuelle Syntax findest du in der Dokumentation des jeweiligen Tools!

Integration mit ETL-Tools

Die Integration von Great Expectations mit gängigen ETL-Tools wie Apache Airflow oder Prefect ist relativ einfach. Wenn du Validierungsschritte direkt in die ETL-Prozesse einbaust, kannst du Datenprobleme in Echtzeit erkennen und beheben, bevor sie die nachgelagerte Analyse beeinträchtigen.

Lass uns ein einfaches Beispiel für die Integration von Great Expectations mit Prefect durchgehen, um die Datenvalidierung als Teil eines automatisierten ETL-Workflows durchzuführen:

from prefect import task, Flow
import great_expectations as ge
# Define a task to run Great Expectations validation
@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])
	    
    # Check validation results and raise an alert if validation fails
    if not results["success"]:
        raise ValueError("Data validation failed!")
# Define your ETL flow
with Flow("ETL_with_GE_Validation") as flow:
    validation = validate_data()
# Execute the flow
flow.run()

In diesem Beispiel definieren wir einen Prefect-Flow mit einer Aufgabe für die Validierung von Great Expectations.

Die Aufgabe validate_data() lädt den Great Expectations-Kontext, ruft den Datenstapel ab und wendet die Expectation Suite an. 

Wenn die Daten die Validierungskriterien nicht erfüllen, löst die Aufgabe eine Warnung aus, die den Workflow anhält und nachgelagerte Fehler verhindert.

Kontinuierliche Datenvalidierung

Du kannst Validierungsaufträge mit verschiedenen Tools planen, z. B. mit Cron-Jobs auf Unix-basierten Systemen oder mit verwalteten Diensten wie Apache Airflow. In diesem Beispiel zeigen wir dir, wie du Validierungsläufe mit Airflow planst, das sich gut für die Orchestrierung von Datenpipelines eignet.

Hier erfährst du, wie du einen Airflow DAG(Directed Acyclic Graph) einrichten kannst, um Great Expectations täglich zu validieren:

from airflow import DAG
from airflow.operators.python_operator import PythonOperator
from datetime import datetime
import great_expectations as ge
# Define the DAG and set the schedule to run daily
default_args = {
	  'owner': 'airflow',
	  'start_date': datetime(2024, 1, 1),
	  'retries': 1,
}
dag = DAG(
      'great_expectations_validation',
	default_args=default_args,
	schedule_interval='@daily',  # Runs once a day
)
# Define the function to run the validation
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
# Set up the task in Airflow
validation_task = PythonOperator(
      task_id='run_great_expectations_validation',
      python_callable=run_validation,
      dag=dag,
)
# Set the task in the DAG
validation_task

In diesem Beispiel definieren wir eine DAG, die einmal am Tag einen Validierungslauf plant (@daily). 

Die Funktion run_validation() führt die Validierung durch, indem sie den Great Expectations-Kontext lädt und die definierte Expectation Suite auf die Daten anwendet.

Best Practices für die Datenvalidierung mit großen Erwartungen

Für Skalierbarkeit und Effizienz ist es immer ratsam, die besten Praktiken zu befolgen, und das ist bei der Datenvalidierung mit Great Expectations nicht anders.

Klein anfangen und iterieren

Beginne mit grundlegenden Datenqualitätsprüfungen und erweitere sie schrittweise. Es ist besser, sich anfangs auf die grundlegenden Erwartungen zu konzentrieren, um den Prozess nicht zu sehr zu verkomplizieren, was eine reibungslosere Integration und eine einfachere Fehlerbehebung ermöglicht. Je besser du den Datensatz verstehst, desto komplexere Validierungen kannst du hinzufügen.

Teamübergreifend zusammenarbeiten

Datenqualität ist nicht nur ein technisches Problem. Arbeite mit anderen Teams zusammen, um Erwartungen zu definieren und sicherzustellen, dass die implementierte Validierung mit der zugrunde liegenden Geschäftslogik und den Zielen übereinstimmt. Dieser funktionsübergreifende Ansatz garantiert, dass die Daten ihren Zweck erfüllen und den Anforderungen aller Beteiligten gerecht werden.

Automatisiere wo möglich

Automatisiere den Prozess, wo immer es möglich ist, um die Datenvalidierung in die Datenpipelines zu integrieren. Die Integration von automatisierten Validierungsprüfungen ermöglicht eine kontinuierliche Überwachung der Datenqualität ohne manuelle Eingriffe, was die Effizienz deutlich verbessert.

Fazit

Tolle Arbeit! Du hast gelernt, wie man Daten in Great Expectations konfiguriert und validiert. Diese Techniken helfen dir, eine hohe Datenqualität und Transparenz in deinen Arbeitsabläufen zu erhalten.

Um deine Fähigkeiten weiter auszubauen, schau dir diese Ressourcen an:

• ETL und ELT in Python: Lerne, wie du Daten effektiv umwandeln und verschieben kannst.
• Einführung in die Datenqualität: Lerne die Grundlagen des Datenqualitätsmanagements kennen.
• Datenbereinigung in Python: Stammdatenbereinigungstechniken, um Genauigkeit und Konsistenz zu gewährleisten.
• Spickzettel für die Dimensionen der Datenqualität: Ein praktischer Leitfaden zu den Dimensionen der Datenqualität.