Tutoriel Great Expectations : Validation des données avec Python

Tutoriels

Python

La qualité des données et la cohérence sont comme les fondations d’une maison—sans une base solide, tout ce qui est construit au-dessus risque de s’effondrer. C’est là que la validation des données joue un rôle important. La validation des données vous aide à vous assurer que vos données sont précises, cohérentes et fiables.

Great Expectations est un outil de validation des données open-source qui vous permet d’identifier les problèmes de données tôt et garantit que vos données répondent aux normes de qualité requises.

Dans ce guide, nous vous accompagnerons dans le processus d’utilisation de Great Expectations pour la validation des données, avec un exemple pratique de bout en bout pour vous aider à démarrer !

Qu’est-ce que Great Expectations ?

Great Expectations (GX) est un cadre open-source qui est devenu populaire pour gérer et automatiser la validation des données dans des pipelines de données modernes.

Son cadre basé sur Python est conçu pour aider les équipes de données à garantir la qualité et la cohérence de leurs données. Les utilisateurs peuvent définir des « attentes » – des règles ou des tests qui décrivent à quoi les données valides devraient ressembler – qui valident automatiquement si les données répondent à ces normes.

Quelques avantages de Great Expectations incluent:

Validation automatique des données – Great Expectations automatise le processus de validation des données, réduisant les efforts manuels et minimisant le risque d’erreurs. Il garantit que les données respectent systématiquement les normes prédéfinies.
Intégration avec les pipelines de données – Il s’intègre facilement avec différentes sources de données et plateformes, y compris les bases de données SQL, le stockage cloud, et les outils ETL, permettant la validation des données à travers les différentes étapes de votre pipeline.
Résultats de validation clairs et exploitables – L’outil fournit des résultats de validation transparents, facilitant ainsi la détection des problèmes de qualité des données et leur résolution rapide.
Documentation des données – Great Expectations peut générer une documentation détaillée et accessible de vos processus de validation des données, aidant les équipes à se mettre d’accord sur les normes de qualité et fournissant une référence pour une utilisation future.
Scalabilité et flexibilité – En tant qu’outil open source, Great Expectations est hautement personnalisable et peut s’adapter à vos besoins en matière de validation des données, offrant la flexibilité de s’ajuster à divers cas d’utilisation sans coûts élevés.

Maintenant, regardons un exemple de bout en bout!

Mise en place de Great Expectations

Dans ce tutoriel, vous apprendrez à utiliser GX Core, la version open-source de Great Expectations, pour valider un DataFrame Pandas. Nous allons vous guider pour configurer un context, enregistrer une source de données Pandas, définir des attentes et valider les lots de données.

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

1. Installation de 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.

Note: Si vous utilisez le notebook DataLab fourni, ces prérequis ont déjà été satisfaits. Vous pouvez les ignorer.

Utilisez la commande suivante pour installer GX via pip :

pip install great_expectations

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

2. Initialisation du contexte de données

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

import great_expectations as gx

# Obtenir le Contexte de Données Éphémère
context = gx.get_context()
assert type(context).__name__ == "EphemeralDataContext"

Création de votre première suite de validation de données

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

1. Connexion à une source de données et création d’un asset de données

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

Dans ce cas, nous allons préparer tout pour se connecter à un DataFrame appelé inventory_parts_df. Le jeu de données d’exemple est disponible dans le DataLab fourni, et il est créé une fois que nous exécutons le bloc SQL :

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

Maintenant, créez votre source de données et votre actif :

# Ajouter une source de données Pandas
data_source = context.data_sources.add_pandas(name="inventory_parts")
# Ajouter un actif de données à la source de données
data_asset = data_source.add_dataframe_asset(name="inventory_parts_asset")

2. Ajout d’une définition de lot

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

# Définir le nom de la définition de lot
batch_definition_name = "inventory_parts_batch"
# Ajouter la définition de lot
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 une collection de données liée à une définition de lot. Pour valider les données, vous devrez récupérer et lier le lot à votre DataFrame, dans ce cas inventory_parts_df :

# Définir les paramètres du lot
batch_parameters = {"dataframe": inventory_parts_df}
# Récupérer le lot
batch = batch_definition.get_batch(batch_parameters=batch_parameters)

4. Créer une suite et définir des attentes

Les attentes sont des règles pour valider les données. Dans cet exemple, nous allons définir les attentes simples suivantes :

Assurez-vous que les valeurs inventory_id ne sont pas nulles.
Assurez-vous que les valeurs part_num sont uniques.

# Créer une suite d'attentes
expectation_suite_name = "inventory_parts_suite"
suite = gx.ExpectationSuite(name=expectation_suite_name)
# Ajouter des attentes
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToNotBeNull(column="inventory_id")
)
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToBeUnique(column="part_num")
)
# Ajouter la suite d'attentes au contexte
context.suites.add(suite)

Vous pouvez explorer toutes les attentes disponibles dans la Galerie des attentes. Nous vous encourageons à en ajouter quelques-unes de plus!

Après avoir défini les attentes, GX génère la configuration de la suite d’attentes:

{
  "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 inclut les détails suivants:

Nom et ID de la suite: Un nom unique (inventory_parts_suite) et un identifiant pour suivre et gérer la suite.
Attentes : Chaque règle spécifie :

Le type de vérification (par exemple, s’assurer qu’une colonne n’a pas de valeurs nulles ou d’entrées uniques).
Les paramètres, tels que la colonne à valider.
Des métadonnées et un identifiant unique pour chaque attente, permettant un suivi et une personnalisation plus faciles.

Métadonnées : Informations sur la version de Great Expectations, assurant la compatibilité avec l’outil.
Notes : Un espace réservé pour ajouter des commentaires descriptifs sur la suite (facultatif).

Cette sortie structurée sert à la fois de documentation et de configuration réutilisable pour valider votre ensemble de données afin que vos attentes soient clairement définies, traçables et prêtes pour une utilisation future.

5. Validation des données

Enfin, validez le lot par rapport aux attentes définies et évaluez les résultats.

# Valider les données par rapport à la suite
validation_results = batch.validate(suite)
# Évaluer les résultats
print(validation_results)

Après avoir exécuté la validation, Great Expectations fournit un rapport détaillé sur la conformité de l’ensemble de données aux attentes 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, mettant en évidence les succès et les échecs. Voici une explication simplifiée des résultats :

Validation globale : Le résultat de la validation était partiellement réussi : 50 % des attentes ont été satisfaites, et 50 % ont échoué. Un échec d’attente indique un problème de qualité des données qui nécessite une attention particulière. Dans ce cas, une colonne n’a pas respecté la règle définie.

Attente 1 : inventory_id ne doit pas avoir de valeurs manquantes

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.

Attente 2 : part_num doit avoir des valeurs uniques

Résultat :Échec
Explication :La colonne part_num contient 97,98% de valeurs en double, ce qui signifie qu’il n’y a que quelques valeurs uniques.
Points saillants :

Des exemples de valeurs en double incluent « 3069b » et « 33291 ».
L’outil montre également à quelle fréquence ces doublons apparaissent et leurs positions de ligne, ce qui facilite la localisation et la résolution des problèmes.

Bien sûr, il ne s’agit que d’un ensemble de données d’exemple, et nous avons délibérément inclus une attente réussie et une attente échouée afin que vous puissiez voir les deux résultats de validation.

C’est tout ! Vous avez réussi à exécuter des validations de données de bout en bout.

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

Dans un environnement de production, les validations doivent être intégrées directement dans le flux de travail pour surveiller en continu la qualité des données à chaque étape.

Dans cette section, nous allons discuter de la manière dont vous pouvez intégrer Great Expectations dans vos pipelines de données.

Ce sont des exemples pour vous donner une idée, et des configurations supplémentaires non incluses ici peuvent être nécessaires. Consultez la documentation de chaque outil pour une syntaxe à jour !

Intégration avec des outils ETL

L’intégration de Great Expectations avec des outils ETL populaires tels qu’ Apache Airflow ou Prefect est relativement simple. Incorporer des étapes de validation directement dans les processus ETL vous permettra de détecter et de résoudre les problèmes de données en temps réel avant qu’ils n’affectent l’analyse en aval.

Explorons un exemple simple d’intégration de Great Expectations avec Prefect pour exécuter une validation des données dans le cadre d’un flux de travail ETL automatisé :

from prefect import task, Flow
import great_expectations as ge
# Définir une tâche pour exécuter la validation de Great Expectations
@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])
	    
    # Vérifier les résultats de la validation et déclencher une alerte en cas d'échec de validation
    if not results["success"]:
        raise ValueError("Data validation failed!")
# Définir votre flux ETL
with Flow("ETL_with_GE_Validation") as flow:
    validation = validate_data()
# Exécuter le flux
flow.run()

Dans cet exemple, nous définissons un flux Prefect avec une tâche pour exécuter la validation de Great Expectations.

La tâche validate_data() charge le contexte de Great Expectations, récupère le lot de données et applique le jeu d’attentes.

Si les données ne respectent pas les critères de validation, la tâche déclenche une alerte, arrête le flux de travail et évite les erreurs en aval.

Vérification continue des données

Vous pouvez planifier des tâches de validation en utilisant différents outils, tels que des tâches cron sur les systèmes Unix ou des services gérés comme Apache Airflow. Pour cet exemple, nous allons vous montrer comment planifier des exécutions de validation en utilisant Airflow, qui est bien adapté pour orchestrer des pipelines de données.

Voici comment vous pouvez 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
# Définir le DAG et définir la planification pour s'exécuter quotidiennement
default_args = {
	  'owner': 'airflow',
	  'start_date': datetime(2024, 1, 1),
	  'retries': 1,
}
dag = DAG(
      'great_expectations_validation',
	default_args=default_args,
	schedule_interval='@daily',  # S'exécute une fois par jour
)
# Définir la fonction pour exécuter la 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
# Configurer la tâche dans Airflow
validation_task = PythonOperator(
      task_id='run_great_expectations_validation',
      python_callable=run_validation,
      dag=dag,
)
# Définir la tâche dans le DAG
validation_task

Dans cet exemple, nous définissons un DAG qui planifie une exécution de validation une fois par jour (@daily).

La fonction run_validation() exécute la validation en chargeant le contexte Great Expectations et en exécutant la suite d’attentes définie sur les données.

Meilleures pratiques pour la validation des données avec Great Expectations

Il est toujours conseillé de suivre les meilleures pratiques pour la scalabilité et l’efficacité, et il en va de même pour la validation des données avec Great Expectations.

Commencez petit et itérez

Commencez par des vérifications de base sur la qualité des données et élargissez progressivement. Il est préférable de se concentrer sur les attentes de base initialement, car cela aide à éviter de compliquer le processus, ce qui facilite l’intégration et la résolution des problèmes. À mesure que votre compréhension de l’ensemble de données s’améliore, vous pouvez ajouter des validations plus complexes.

Collaborez entre équipes

La qualité des données n’est pas seulement une préoccupation technique. Collaborez avec les équipes métier pour définir les attentes et veiller à ce que la validation mise en place soit conforme à la logique métier sous-jacente et aux objectifs. Cette approche interfonctionnelle garantit que les données servent leur objectif initial et répondent aux exigences de toutes les parties prenantes.

Automatisez lorsque c’est possible

Automatisez le processus chaque fois que c’est possible pour intégrer la validation des données dans les pipelines de données. L’intégration de contrôles de validation automatisés permet une surveillance continue de la qualité des données sans intervention manuelle, ce qui améliore considérablement l’efficacité.

Conclusion

Excellent travail ! Vous avez appris comment configurer et valider des données dans Great Expectations. Ces techniques vous aideront à maintenir une haute qualité de données et une transparence dans vos flux de travail.

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

ETL et ELT en Python : Apprenez à transformer et déplacer des données de manière efficace.
Introduction à la Qualité des Données : Explorez les fondamentaux de la gestion de la qualité des données.
Nettoyage des Données en Python : Maîtrisez les techniques de nettoyage des données pour garantir l’exactitude et la cohérence.
Feuille de triche sur les Dimensions de la Qualité des Données : Un guide pratique sur les dimensions de la qualité des données.

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