Große Erwartungen Tutorial: Datenvalidierung mit Python

Einrichten von Great Expectations

In diesem Tutorial erfahren Sie, wie Sie GX Core, die Open-Source-Version von Great Expectations, verwenden, um ein Pandas DataFrame zu validieren. Wir werden durch das Einrichten eines Kontexts, das Registrieren einer Pandas-Datenquelle, das Definieren von Erwartungen und das Validieren von Datenbatches gehen.

Hinweis: Wir empfehlen, dass Sie dem DataLab-Notebook folgen, aber Sie können auch Ihr eigenes Python-Skript erstellen.

1. Great Expectations installieren

Voraussetzungen

• Python 3.9 bis 3.12 installiert.
• Zur Vermeidung von Konflikten wird dringend empfohlen, Great Expectations in einer virtuellen Umgebung zu installieren (Haftungsausschluss: Die Einrichtung virtueller Umgebungen fällt nicht in den Rahmen dieses Artikels).
• Ein Beispieldatensatz.

Hinweis: Wenn Sie das bereitgestellte DataLab-Notebook verwenden, wurden diese Voraussetzungen bereits erfüllt. Sie können sie überspringen.

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

pip install great_expectations

Dieser Befehl installiert das Kernpaket und alle erforderlichen Abhängigkeiten.

2. Initialisierung des Datenkontexts

Great Expectations erfordert einen Datenkontext zur Verwaltung von Konfigurationen. Wir verwenden einen ephemeren Datenkontext, um Konfigurationen nicht zu speichern.

import great_expectations as gx

# Den ephemeren Datenkontext abrufen
context = gx.get_context()
assert type(context).__name__ == "EphemeralDataContext"

Erstellen Ihres ersten Datenvalidierungssatzes

Jetzt, da GX eingerichtet ist, erstellen wir einen Datenvalidierungssatz.

1. Verbindung zu einer Datenquelle herstellen und ein Datenobjekt erstellen

Eine Datenquelle verbindet Great Expectations mit Ihren Daten, während ein Datenobjekt eine spezifische Datenmenge darstellt (z. B. eine Tabelle, DataFrame oder Datei).

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

Wenn Sie DataLab nicht verwenden, erstellen Sie Ihr eigenes DataFrame mit Beispieldaten.

Erstellen Sie nun Ihre Datenquelle und Ihr Asset:

# Fügen Sie eine Pandas-Datenquelle hinzu
data_source = context.data_sources.add_pandas(name="inventory_parts")
# Fügen Sie ein Daten-Asset zur Datenquelle hinzu
data_asset = data_source.add_dataframe_asset(name="inventory_parts_asset")

2. Hinzufügen einer Batch-Definition

Eine Batch-Definition identifiziert und organisiert Ihre Daten für die Validierung. Hier fügen wir eine Batch-Definition hinzu, die das gesamte DataFrame abdeckt:

# Definieren Sie den Namen der Batch-Definition
batch_definition_name = "inventory_parts_batch"
# Fügen Sie die Batch-Definition hinzu
batch_definition = data_asset.add_batch_definition_whole_dataframe(batch_definition_name)
assert batch_definition.name == batch_definition_name

3. Abrufen eines Batches

Ein Batch ist eine Sammlung von Daten, die mit einer Batch-Definition verknüpft sind. Um Daten zu validieren, müssen Sie den Batch abrufen und mit Ihrem DataFrame verknüpfen, in diesem Fall inventory_parts_df:

# Definieren Sie die Batch-Parameter
batch_parameters = {"dataframe": inventory_parts_df}
# Batch abrufen
batch = batch_definition.get_batch(batch_parameters=batch_parameters)

4. Erstellen einer Suite und Definition von Erwartungen

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

1. Stellen Sie sicher, dass die Werte von inventory_id nicht null sind.
2. Stellen Sie sicher, dass die Werte von part_num eindeutig sind.

# Erstellen Sie ein Erwartungssuite
expectation_suite_name = "inventory_parts_suite"
suite = gx.ExpectationSuite(name=expectation_suite_name)
# Erwartungen hinzufügen
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToNotBeNull(column="inventory_id")
)
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToBeUnique(column="part_num")
)
# Fügen Sie die Erwartungssuite dem Kontext hinzu
context.suites.add(suite)

Sie können alle verfügbaren Erwartungen in der Erwartungsgalerie erkunden. Wir ermutigen Sie, noch ein paar mehr hinzuzufügen!

Nachdem Sie die Erwartungen definiert haben, 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 enthält folgende Details:

1. Suitenname und ID: Ein eindeutiger Name (inventory_parts_suite) und Kennung zur Verfolgung und Verwaltung der Suite.
2. Erwartungen: Jede Regel spezifiziert:
• Den Typ der Überprüfung (z. B. sicherstellen, dass eine Spalte keine Nullwerte oder eindeutige Einträge hat).
• Parameter wie die zu validierende Spalte.
• Metadaten und eine eindeutige ID für jede Erwartung, die ein einfacheres Tracking und Anpassung ermöglicht.
3. Metadaten: Versionsinformationen für Great Expectations, die die Kompatibilität mit dem Tool gewährleisten.
4. Hinweise: Ein Platzhalter für das Hinzufügen von beschreibenden Kommentaren zur Suite (optional).

Diese strukturierte Ausgabe dient sowohl als Dokumentation als auch als wiederverwendbare Konfiguration zur Validierung Ihres Datensatzes, sodass Ihre Erwartungen klar definiert, nachvollziehbar und bereit für zukünftige Verwendung sind.

5. Validierung der Daten

Schließlich validieren Sie den Batch gegen die definierten Erwartungen und bewerten die Ergebnisse.

# Daten gegen die Suite validieren
validation_results = batch.validate(suite)
# Ergebnisse bewerten
print(validation_results)

Nach der Durchführung der Validierung bietet 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 Auskunft über die Qualität Ihrer Daten und hebt Erfolge sowie Misserfolge hervor. Hier ist eine vereinfachte Erklärung der Ergebnisse:

Gesamte Validierung: Das Validierungsergebnis war teilweise erfolgreich: 50% der Erwartungen wurden erfüllt und 50% nicht. Ein nicht erfüllte Erwartung weist auf ein Datenqualitätsproblem hin, das beachtet werden muss. In diesem Fall erfüllte eine Spalte die definierte Regel nicht.

Erwartung 1: inventory_id sollte keine fehlenden Werte haben

• Ergebnis: Erfolgreich
• Erklärung: Jeder Wert in der Spalte inventory_id ist vorhanden, ohne leere oder fehlende Einträge. Dies deutet auf eine gute Datenkomplettierung für diese Spalte hin.

Erwartung 2: part_num sollte eindeutige Werte haben

• Ergebnis: Fehlgeschlagen
• Erklärung: Die part_num-Spalte enthält 97,98 % doppelte Werte, was bedeutet, dass nur wenige Werte einzigartig sind.
• Höhepunkte:
• Beispielhafte doppelte Werte sind „3069b“ und „33291“.
• Das Tool zeigt auch, wie häufig diese Duplikate erscheinen und ihre Zeilenpositionen, was es einfacher macht, die Probleme zu lokalisieren und zu beheben.

Natürlich handelt es sich hier nur um einen Beispieldatensatz, und wir haben absichtlich eine positive und eine negative Erwartung eingeschlossen, damit Sie beide Validierungsergebnisse sehen können.

Das war’s! Sie haben erfolgreich End-to-End-Datenvalidierungen durchgeführt.

Integration von Great Expectations in Datenpipelines

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 werden wir besprechen, wie Sie Great Expectations in Ihre Datenpipelines integrieren können.

Dies sind Beispiele, um Ihnen eine Vorstellung zu geben, und zusätzliche Konfigurationen, die hier nicht enthalten sind, können erforderlich sein. Schauen Sie sich die Dokumentation jedes Tools für eine aktuelle Syntax an!

Integration mit ETL-Tools

Die Integration von Great Expectations mit beliebten ETL-Tools wie Apache Airflow oder Prefect ist relativ unkompliziert. Durch Einbetten von Validierungsschritten direkt in die ETL-Prozesse können Datenprobleme in Echtzeit erkannt und behoben werden, bevor sie sich auf die nachgelagerte Analyse auswirken.

Lassen Sie uns anhand eines einfachen Beispiels durchgehen, wie Great Expectations mit Prefect integriert wird, um die Datenvalidierung als Teil eines automatisierten ETL-Workflows auszuführen:

from prefect import task, Flow
import great_expectations as ge
# Definieren einer Aufgabe zur Ausführung der Great Expectations-Validierung
@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])
	    
    # Überprüfen der Validierungsergebnisse und Auslösen eines Alarms bei Validierungsfehlern
    if not results["success"]:
        raise ValueError("Data validation failed!")
# Definition Ihres ETL-Flusses
with Flow("ETL_with_GE_Validation") as flow:
    validation = validate_data()
# Ausführen des Flusses
flow.run()

In diesem Beispiel definieren wir einen Prefect-Fluss mit einer Aufgabe zur Ausführung der Great Expectations-Validierung.

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

Wenn die Daten die Validierungskriterien nicht erfüllen, löst die Aufgabe einen Alarm aus, stoppt den Workflow und verhindert nachgelagerte Fehler.

Kontinuierliche Datenvalidierung

Sie können Validierungsaufträge mit verschiedenen Tools planen, wie z. B. Cron-Jobs auf Unix-basierten Systemen oder verwalteten Diensten wie Apache Airflow. In diesem Beispiel zeigen wir, wie Validierungsläufe mit Airflow geplant werden können, das sich gut für die Orchestrierung von Datenpipelines eignet.

So richten Sie einen Airflow-DAG (Directed Acyclic Graph) ein, um Great Expectations-Validierungen täglich durchzuführen:

from airflow import DAG
from airflow.operators.python_operator import PythonOperator
from datetime import datetime
import great_expectations as ge
# Definieren Sie den DAG und legen Sie den Zeitplan auf täglich fest
default_args = {
	  'owner': 'airflow',
	  'start_date': datetime(2024, 1, 1),
	  'retries': 1,
}
dag = DAG(
      'great_expectations_validation',
	default_args=default_args,
	schedule_interval='@daily',  # Führt einmal täglich aus
)
# Definieren Sie die Funktion zur Durchführung der Validierung
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
# Richten Sie die Aufgabe in Airflow ein
validation_task = PythonOperator(
      task_id='run_great_expectations_validation',
      python_callable=run_validation,
      dag=dag,
)
# Setzen Sie die Aufgabe im DAG
validation_task

In diesem Beispiel definieren wir einen DAG, der eine Validierung einmal täglich plant (@täglich).

Die Funktion run_validation() führt die Validierung aus, indem sie den Great Expectations-Kontext lädt und die definierte Erwartungssuite gegen die Daten ausführt.

Best Practices für die Datenvalidierung mit Great Expectations

Es wird immer empfohlen, bewährte Verfahren für Skalierbarkeit und Effizienz zu befolgen, und das gilt auch für die Datenvalidierung mit Great Expectations.

Fangen Sie klein an und iterieren Sie

Beginnen Sie mit grundlegenden Datenqualitätsprüfungen und erweitern Sie sie allmählich. Es ist besser, sich zunächst auf grundlegende Erwartungen zu konzentrieren, da dies dazu beiträgt, den Prozess nicht zu überkomplizieren, was zu einer reibungsloseren Integration und einfacheren Fehlerbehebung führt. Wenn Ihr Verständnis des Datensatzes zunimmt, können Sie komplexere Validierungen hinzufügen.

Kollaboration zwischen Teams

Datenqualität ist nicht nur eine technische Angelegenheit. Arbeiten Sie mit Geschäftsteams zusammen, um Erwartungen zu definieren und sicherzustellen, dass die implementierte Validierung mit der zugrunde liegenden Geschäftslogik und den Zielen übereinstimmt. Dieser interdisziplinäre Ansatz garantiert, dass Daten ihren beabsichtigten Zweck erfüllen und die Anforderungen aller Interessengruppen erfüllen.

Automatisieren, wo möglich

Automatisieren Sie den Prozess, wo immer möglich, um die Datenvalidierung in die Datenpipelines zu integrieren. Die Integration automatisierter Validierungsprüfungen ermöglicht eine kontinuierliche Überwachung der Datenqualität ohne manuelle Eingriffe, was die Effizienz erheblich verbessert.

Abschluss

Tolle Arbeit! Sie haben gelernt, wie Sie Daten in Great Expectations konfigurieren und validieren. Diese Techniken helfen dabei, die hohe Datenqualität und Transparenz in Ihren Workflows aufrechtzuerhalten.

Um Ihre Fähigkeiten weiter auszubauen, schauen Sie sich diese Ressourcen an:

• ETL und ELT in Python: Erfahren Sie, wie Sie Daten effektiv transformieren und verschieben können.
• Einführung in die Datenqualität: Erkunden Sie die Grundlagen des Datenqualitätsmanagements.
• Datenbereinigung in Python: Meistern Sie Techniken zur Datenbereinigung, um Genauigkeit und Konsistenz sicherzustellen.
• Spickzettel zu Datenqualitätsdimensionen: Ein praktischer Leitfaden zu Datenqualitätsdimensionen.