Tutoriel Great Expectations : valider des données avec Python

Configurer Great Expectations

Dans ce tutoriel, vous apprendrez à utiliser GX Core, la version open source de Great Expectations, pour valider un DataFrame Pandas. Nous verrons comment créer un contexte, enregistrer une source de données Pandas, définir des expectations et valider des lots de données.

Remarque : nous vous recommandons de suivre avec le notebook DataLab, mais vous pouvez également créer votre propre script Python.

1. Installer Great Expectations

Prérequis

• Python 3.9 à 3.12 installé.
• Pour éviter les conflits, il est fortement recommandé d'installer Great Expectations dans un environnement virtuel (avertissement : la configuration des environnements virtuels dépasse le cadre de cet article).
• Un jeu de données d'exemple.

Remarque : si vous utilisez le notebook DataLab fourni, ces prérequis sont déjà remplis. Vous pouvez les passer.

Utilisez la commande suivante pour installer GX via pip :

pip install great_expectations

Cette commande installe le package principal et toutes les dépendances nécessaires.

2. Initialiser le contexte de données

Great Expectations requiert un contexte de données pour gérer les configurations. Nous utilisons ici un contexte éphémère pour éviter de persister les configurations.

import great_expectations as gx

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

Créer votre première suite de validation

Maintenant que GX est configuré, créons une suite de validation.

1. Se connecter à une source de données et créer un asset

Une source de données relie Great Expectations à vos données, tandis qu'un asset représente un sous-ensemble spécifique (par ex. : une table, un DataFrame ou un fichier).

Dans notre cas, nous allons tout préparer pour nous connecter à un DataFrame appelé inventory_parts_df. Le jeu de données d'exemple est disponible dans le DataLab fourni et est créé lorsque nous exécutons le bloc SQL :

Si vous n'utilisez pas DataLab, créez votre propre DataFrame avec des données d'exemple.

Créez maintenant votre source et votre 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. Ajouter une définition de lot (batch)

Une définition de lot identifie et organise vos données pour la validation. Ici, nous ajoutons une définition qui couvre l'intégralité du DataFrame :

# 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. Récupérer un lot

Un lot est un ensemble de données lié à une définition de lot. Pour valider, vous devez récupérer le lot et le lier à votre DataFrame, ici 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. Créer une suite et définir des expectations

Les expectations sont des règles de validation. Dans cet exemple, nous allons définir deux expectations simples :

1. S'assurer que les valeurs de inventory_id ne sont pas nulles.
2. S'assurer que les valeurs de part_num sont uniques.

# 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)

Vous pouvez explorer toutes les expectations disponibles dans la galerie d'expectations. N'hésitez pas à en ajouter d'autres !

Après la définition, GX génère la configuration de la suite :

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

La suite comprend les éléments suivants :

1. Nom et ID de la suite : un nom unique (inventory_parts_suite) et un identifiant pour suivre et gérer la suite.
2. Expectations : chaque règle précise :
• Le type de contrôle (par ex. : absence de valeurs nulles ou unicité des entrées).
• Les paramètres, comme la colonne validée.
• Des métadonnées et un ID unique pour faciliter le suivi et la personnalisation.
3. Métadonnées : informations de version de Great Expectations pour assurer la compatibilité.
4. Notes : un emplacement pour ajouter des commentaires descriptifs sur la suite (optionnel).

Cette sortie structurée sert à la fois de documentation et de configuration réutilisable pour valider votre jeu de données : vos expectations sont définies clairement, traçables et prêtes pour un usage futur.

5. Valider les données

Validez enfin le lot par rapport aux expectations définies et évaluez les résultats.

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

Après l'exécution, Great Expectations fournit un rapport détaillé indiquant si le jeu de données respecte les expectations définies :

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

Ce rapport détaille la qualité de vos données, en mettant en évidence les succès et les échecs. Voici une lecture simplifiée des résultats :

Validation globale : le résultat est partiellement réussi : 50 % des expectations sont validées, 50 % échouent. Un échec indique un problème de qualité à corriger. Ici, une colonne ne respecte pas la règle définie.

Expectation 1 : inventory_id ne doit comporter aucune valeur manquante

• Résultat : réussi
• Explication : chaque valeur de la colonne inventory_id est présente, sans entrées nulles ou manquantes. Cela indique une bonne complétude des données pour cette colonne.

Expectation 2 : part_num doit contenir des valeurs uniques

• Résultat : échec
• Explication : la colonne part_num contient 97,98 % de valeurs dupliquées, ce qui signifie que très peu de valeurs sont uniques.
• Points saillants :
• Exemples de doublons : « 3069b » et « 33291 ».
• L'outil indique aussi leur fréquence et leurs positions, ce qui facilite la localisation et la correction.

Bien sûr, il s'agit d'un jeu d'exemple, et nous avons inclus volontairement une expectation réussie et une échouée pour illustrer les deux cas.

Et voilà ! Vous avez exécuté une validation de données de bout en bout.

Intégrer Great Expectations dans les pipelines de données

En production, les validations doivent être intégrées directement au workflow pour surveiller en continu la qualité des données à chaque étape.

Dans cette section, nous voyons comment intégrer Great Expectations à vos pipelines de données.

Ces exemples visent à vous donner une idée ; des configurations supplémentaires peuvent être nécessaires. Consultez la documentation de chaque outil pour une syntaxe à jour !

Intégration avec des outils ETL

Intégrer Great Expectations avec des outils ETL populaires comme Apache Airflow ou Prefect est relativement simple. En plaçant des étapes de validation directement dans les processus ETL, vous décelez et corrigez les problèmes en temps réel avant qu'ils n'affectent les analyses en aval.

Voyons un exemple simple d'intégration de Great Expectations avec Prefect pour exécuter une validation dans le cadre d'un ETL automatisé :

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()

Dans cet exemple, nous définissons un flow Prefect avec une tâche qui exécute la validation Great Expectations.

La tâche validate_data() charge le contexte, récupère le lot de données et applique la suite d'expectations.

Si les données ne respectent pas les critères, la tâche lève une alerte, stoppe le workflow et évite les erreurs en aval.

Validation continue des données

Vous pouvez planifier des validations avec différents outils, comme cron sur les systèmes Unix, ou des services managés comme Apache Airflow. Ci-dessous, un exemple de planification avec Airflow, idéal pour orchestrer des pipelines.

Voici comment configurer un DAG Airflow (Directed Acyclic Graph) pour exécuter quotidiennement des validations Great Expectations :

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

Dans cet exemple, nous définissons un DAG qui planifie une exécution quotidienne (@daily).

La fonction run_validation() charge le contexte Great Expectations et exécute la suite d'expectations sur les données.

Bonnes pratiques pour la validation avec Great Expectations

Suivre les bonnes pratiques est essentiel pour la scalabilité et l'efficacité ; c'est aussi vrai pour la validation des données avec Great Expectations.

Commencez petit et itérez

Démarrez par des contrôles fondamentaux puis étendez progressivement. Il vaut mieux se concentrer d'abord sur des expectations basiques pour éviter de complexifier inutilement : l'intégration sera plus fluide et le dépannage plus simple. Au fur et à mesure que vous comprenez mieux le jeu de données, ajoutez des validations plus avancées.

Collaborez entre équipes

La qualité des données n'est pas qu'un sujet technique. Collaborez avec les équipes métier pour définir les expectations et garantir qu'elles reflètent la logique et les objectifs business. Cette approche transverse assure que les données servent leur finalité et répondent aux besoins de toutes les parties prenantes.

Automatisez dès que possible

Automatisez la validation dans vos pipelines autant que possible. Des contrôles automatisés permettent une surveillance continue de la qualité, sans intervention manuelle, et améliorent significativement l'efficacité.

Conclusion

Bravo ! Vous savez désormais configurer et valider des données avec Great Expectations. Ces techniques vous aideront à maintenir une haute qualité et une transparence accrue dans vos workflows.

Pour continuer à développer vos compétences, consultez ces ressources :

• ETL and ELT in Python : apprenez à transformer et déplacer les données efficacement.
• Introduction to Data Quality : découvrez les fondamentaux de la gestion de la qualité des données.
• Cleaning Data in Python : maîtrisez les techniques de nettoyage pour garantir l'exactitude et la cohérence.
• Data Quality Dimensions Cheat Sheet : un aide-mémoire des dimensions de la qualité des données.