Une introduction aux outils de Data Quality en Python

Introduction

Recently, I worked on a Data Engineering project to build a Data Warehouse architecture, ingesting CSV data from multiple sources. We had the opportunity to implement Data Quality controls in multiple ETL pipelines. There are several Python-based data quality tools available to achieve this goal.

In this article, I want to review fundamental Data Quality concepts and share two of these tools, specifically Great Expectations and PyDeequ, which we considered for implementing controls. I’ll show some advantages and disadvantages we observed in each one, to help you if it’s the first time you’re implementing this functionality.

Pourquoi la Data Quality ?

Negliger la qualite des donnees peut entrainer une serie de consequences negatives qui affectent les performances, la reputation et la competitivite de votre organisation. S’il n’y a pas de donnees de bonne qualite, les analyses et decisions risquent d’etre inexactes. Les parties prenantes pourraient prendre des decisions basees sur des informations obsoletes ou erronees, ce qui pourrait mener a des erreurs potentiellement couteuses. Il est inevitable que, quand on identifie la source d’erreurs dans les donnees, la confiance envers les donnees et les equipes responsables s’erode. De plus, si les donnees sont partagees en dehors de l’organisation et qu’il y a des problemes de Data Quality, les utilisateurs peuvent aussi perdre confiance, ce qui nuit a la reputation de l’organisation.

Par ailleurs, travailler avec des donnees de mauvaise qualite peut mener a des perceptions incorrectes et a une perte de focus sur la vraie valeur de l’information, poussant les equipes data a perdre du temps a chercher la source des erreurs. Vu positivement : assurer la qualite des donnees signifie que les decisions de votre organisation seront bien informees et a jour, evitant les couts lies aux mauvaises decisions et ameliorant la competitivite de votre entreprise.

Quels sont les aspects de Data Quality qu’on evalue habituellement ?

• Exactitude (Accuracy) : L’exactitude des donnees mesure a quel point les donnees refletent les entites du monde reel qu’elles representent. Des donnees precises sont exemptes d’erreurs et d’inconsistances.

• Completude (Completeness) : La completude evalue si toutes les donnees necessaires sont presentes. Elle garantit qu’aucune information critique ne manque dans les jeux de donnees.

• Ponctualite (Timeliness) : La ponctualite fait reference a la fraicheur des donnees. Elle mesure a quel point les donnees sont a jour et si elles respectent les delais requis pour l’analyse et la prise de decision.

• Unicite (Uniqueness) : L’unicite garantit qu’il n’y a pas d’enregistrements dupliques dans le jeu de donnees.

• Validite (Validity) : La validite verifie si les donnees respectent des regles et contraintes predefinies ; elle s’assure que les donnees sont dans le format attendu et respectent les standards de qualite.

• Coherence (Consistency) : La coherence evalue l’uniformite des donnees a travers differentes sources et systemes. Des donnees inconsistantes peuvent mener a des confusions et des inexactitudes.

• Adequation a l’usage (Fitness for Purpose) : Les donnees doivent etre adaptees a leur usage prevu. Cela signifie que les donnees doivent etre pertinentes et appropriees pour des taches et analyses specifiques.

Principales caracteristiques des outils de Data Quality

Voici quelques-unes des caracteristiques cles des outils de Data Quality qui peuvent vous aider a choisir le plus adapte :

• Validation des donnees : Un element essentiel des outils de qualite des donnees est la capacite de verifier que certaines “regles” sont respectees dans les donnees qu’on veut analyser. Cela inclut la verification que les valeurs des colonnes sont dans des plages specifiques, qu’il n’y a pas de valeurs nulles dans une colonne, que les valeurs statistiques comme les moyennes et ecarts-types sont dans des limites predefinies, entre autres validations.

• Profiling / Suggestion automatique de regles de validation : Une autre caracteristique importante est la capacite de realiser une analyse automatique d’un echantillon des donnees qu’on veut traiter. Cela permet d’extraire les caracteristiques generales des donnees, d’identifier les plages dans lesquelles se trouvent les variables, de determiner les types de variables, de detecter les valeurs manquantes et d’identifier les patterns de distribution. Sur la base de cette information (profilage), les outils peuvent suggerer des validations de Data Quality et des regles applicables.

• Detection d’anomalies : En se basant sur le profil ou le comportement des colonnes de notre dataset, ces outils peuvent proposer des alertes qui detectent si une metrique liee aux donnees, comme la moyenne ou l’ecart-type, sort de limites predefinies et s’ecarte significativement de ce qui est attendu. Cette fonction est essentielle pour identifier des donnees atypiques qui pourraient indiquer des problemes de qualite ou des problemes dans le processus d’acquisition des donnees.

• Generation de rapports : Certains outils de Data Quality peuvent generer des visualisations interactives, des rapports detailles ou des resumes executifs qui synthetisent les resultats de l’analyse du dataset et des validations appliquees. Ces rapports aident les utilisateurs a comprendre la qualite des donnees et les conclusions cles de maniere claire et concise, facilitant la prise de decisions eclairees et la communication des resultats aux parties prenantes.

• Recuperation des enregistrements echoues : En cas de non-respect des validations, certains outils de Data Quality permettent aux developpeurs d’identifier les enregistrements specifiques contenant des erreurs, qui peuvent etre marques et priorises pour examen et action. Cela aide a maintenir l’integrite des donnees et garantit que les problemes sont traites en temps voulu.

• Integrations : Beaucoup d’outils de Data Quality offrent diverses options pour se connecter a d’autres sources de donnees, systemes d’orchestration ou pour envoyer les resultats vers differentes destinations. Ces integrations facilitent l’automatisation du workflow, l’incorporation de donnees externes et la distribution efficace des resultats d’analyse a travers differents canaux et systemes, ameliorant l’efficacite des operations liees a la qualite des donnees.

PyDeequ

Description

PyDeequ est une bibliotheque de validation de donnees originellement concue en Scala puis adaptee pour Python. Cet outil fournit des capacites de detection d’anomalies, profiling et suggestion de controles de Data Quality. PyDeequ s’integre a l’ecosysteme Spark, ce qui permet la gestion efficace de datasets de grande taille.

Dans PyDeequ, la fonctionnalite de suggestion de regles (constraint suggestion) permet d’analyser un echantillon des donnees pour obtenir rapidement des conditions de Data Quality qui seront appliquees a chaque colonne. Ces contraintes peuvent ensuite etre copiees et incorporees dans un ensemble de verifications chainees pour les utiliser sur le reste des donnees a traiter. Les constraints permettent aussi de specifier un seuil en pourcentage auquel une erreur ou un avertissement doit etre declenche via des fonctions lambda. On peut aussi specifier des indices ou hints pour identifier rapidement les constraints lors de la restitution des resultats.

De plus, PyDeequ fournit plusieurs analyseurs qui servent de mesures de caracteristiques specifiques du dataset, comme la taille du dataset, l’ecart-type, le pourcentage de valeurs uniques, le matching de patterns definis par des expressions regulieres, etc. Ces analyseurs peuvent etre utilises pour detecter des anomalies basees sur un dataset de reference en etablissant des seuils. Si les valeurs de l’analyseur varient entre datasets au-dela d’une certaine proportion definie par les seuils, ce phenomene est signale.

Guide de demarrage rapide

1. Generez un dataset d’exemple (vous pouvez executer ce code dans le repertoire de travail et les donnees seront generees dans Example_Data/Batches/Example_batch0.csv) :

from faker import Faker
import pandas as pd
import random

fake = Faker(seed=123)

num_rows = 1000

data = {
    "Name": [fake.name() for _ in range(num_rows)],
    "Email": [fake.email() for _ in range(num_rows)],
    "Phone": [fake.phone_number() for _ in range(num_rows)],
    "Address": [fake.address() for _ in range(num_rows)],
    "Date of Birth": [fake.date_of_birth(minimum_age=18, maximum_age=80).strftime("%Y-%m-%d") for _ in range(num_rows)],
    "Salary": [fake.random_int(min=30000, max=100000) for _ in range(num_rows)],
    "Department": [fake.random_element(elements=("HR", "IT", "Finance", "Sales", "Marketing")) for _ in range(num_rows)],
    "Hire Date": [fake.date_this_century().strftime("%Y-%m-%d") for _ in range(num_rows)],
    "Employee ID": [fake.unique.random_number() for _ in range(num_rows)],
    "Vacation_Days": [fake.random_int(min=0, max=30) if random.random() > 0.1 else None for _ in range(num_rows)]
}

# Introduce null values in some columns
for i in range(100):
    data["Email"][random.randint(0, num_rows - 1)] = None
    data["Salary"][random.randint(0, num_rows - 1)] = None

# Replace some values in the "Department" column with rare values
for i in range(50):
    data["Department"][random.randint(0, num_rows - 1)] = fake.random_element(
        elements=("Legal", "R&D", "Customer Support")
    )

df = pd.DataFrame(data) # Create a DataFrame from the generated data

output_folder = "Example_Data/Batches/"
os.makedirs(output_folder, exist_ok=True)

split_dfs = np.array_split(df, 3)  # Split the DataFrame

for i, split_df in enumerate(split_dfs):
    file_name = f"{output_folder}Example_batch{i}.csv"
    split_df.to_csv(file_name, sep=",", index=False)

2. Chargez le dataset d’exemple et creez une session Spark.

import pandas as pd
from pyspark.sql import SparkSession
import sagemaker_pyspark
import pydeequ

df = pd.read_csv('Example_Data/Batches/Example_batch0.csv')

classpath = ":".join(sagemaker_pyspark.classpath_jars())

spark = (SparkSession.builder
	.config("spark.driver.extraClassPath", classpath)
	.config("spark.jars.packages", pydeequ.deequ_maven_coord)
	.config("spark.jars.excludes", pydeequ.f2j_maven_coord)
	.getOrCreate()
	)

3. Lancez la commande qui suggere les constraints.

from pydeequ.suggestions import *

suggestionResult = ConstraintSuggestionRunner(spark) \
	.onData(df) \
	.addConstraintRule(DEFAULT()) \
	.run()

4. Vous pouvez afficher les constraints suggeres :

for sugg in suggestionResult['constraint_suggestions']:
	print(f"Constraint suggestion for '{sugg['column_name']}': {sugg['description']}")

for sugg in suggestionResult['constraint_suggestions']:
	print(f"{sugg['code_for_constraint']}")

5. Chargez un nouveau batch de donnees :

df = pd.read_csv('Example_Data/Batches/Example_batch1.csv')
df.columns

6. Creez un check :

from pydeequ.checks import *
from pydeequ.verification import *

check = Check(spark, CheckLevel.Error, "Integrity checks")

7. Ajoutez les constraints suggeres au check, formant une “verification suite”, et executez :

checkResult = VerificationSuite(spark) \
.onData(df) \
.addCheck(
check.hasSize(lambda x: x <= 300_000) \
	.isContainedIn("Department", ["Marketing", "HR", "Finance", "IT", "Sales"])
	.isComplete("Department")
	.isComplete("Name")
	.isUnique("Name")
	.isComplete("Address")
	.isUnique("Address")
	.isComplete("Hire_Date")
	.isUnique("Hire_Date")
	.isComplete("Vacation_Days")
	.isNonNegative("Vacation_Days")
	.isComplete("Date_of_Birth")
	.isComplete("Email")
	.isUnique("Email")
	.isComplete("Phone")
	.isComplete("Salary")
	.isNonNegative("Salary")
	.isComplete("Employee_ID")
	.isNonNegative("Employee_ID")
	.isUnique("Employee_ID")
).run()

8. Convertissez les resultats en dataframe Pandas et affichez-les :

checkResult_df = VerificationResult.checkResultsAsDataFrame(spark, checkResult)
checkResult_df.toPandas().head(10)

Attention a ne pas utiliser d’espaces dans les noms de colonnes ni a avoir des fautes de frappe, car cela peut generer des messages d’erreur dans de nombreuses conditions. Montrons cette erreur en executant a nouveau la “verification suite”, mais en supprimant le tiret bas de “Employee_ID” dans la ligne qui contient le check .isNonNegative(“Employee_ID”). Le resultat est :

Commentaires supplementaires :

• Une caracteristique unique de PyDeequ est le constraint “satisfies”, qui permet de definir des conditions en langage SQL pour les colonnes. C’est particulierement utile pour valider que les donnees respectent des conditions logiques composees de plusieurs conditions plus simples.

• Il est important de noter que, contrairement a certains autres outils, PyDeequ ne genere pas de rapports ; il livre les resultats dans un dataframe, et c’est a l’utilisateur d’implementer la fonctionnalite pour acceder aux donnees et les incorporer dans un rapport.

Great Expectations

Description :

Great Expectations est un outil open source base sur Python qui beneficie du soutien d’une grande communaute. Ce projet s’est integre avec succes a une large variete de sources et d’outils de donnees, ce qui en fait un choix polyvalent pour la gestion de la Data Quality.

Dans Great Expectations, les regles de Data Quality sont structurees comme des “expectations”. Ces expectations sont definies “de maniere positive”, ce qui signifie qu’elles specifient les conditions que les donnees doivent remplir. Si les donnees ne respectent pas ces conditions, l’expectation renvoie une alerte, signalant un probleme potentiel de Data Quality.

Cette approche permet aux professionnels de la data d’articuler et de faire respecter les exigences de qualite des donnees de maniere claire et pratique. Par exemple, on peut etablir des expectations indiquant que les colonnes de donnees doivent respecter des types de donnees specifiques, des plages ou des contraintes de valeurs. Si les donnees s’ecartent de ces attentes, Great Expectations generera les alertes correspondantes.

De plus, Great Expectations offre d’autres fonctionnalites incluant le profiling de donnees, la validation automatique, le monitoring continu et l’integration avec diverses plateformes de donnees. Il se distingue notamment en fournissant une bonne documentation des donnees, offrant des informations precieuses sur les distributions de donnees et les statistiques resumees. Cette documentation ameliore non seulement la transparence des donnees, mais facilite aussi la collaboration entre equipes data.

Bien que Great Expectations offre de nombreux avantages, les utilisateurs doivent garder un oeil attentif sur sa documentation, car les mises a jour frequentes peuvent generer des changements et variations entre versions. De plus, exprimer des conditions logiques complexes directement via des expectations peut devenir assez complexe. Cependant, l’outil offre la flexibilite de travailler avec des “row conditions” pour gerer une logique plus elaborate.

Voyons quelques commandes pour comprendre les fonctionnalites cles de cet outil.

Guide de demarrage rapide

Pour commencer, dans un environnement Conda avec Python, vous pouvez installer Great Expectations avec pip :

pip install great_expectations
pip install great_expectations_experimental

Personnellement, je recommande de commencer en utilisant l’interface en ligne de commande (CLI) de Great Expectations pour effectuer les configurations initiales de notre projet. Cet outil nous guide pas a pas dans la definition des sources de donnees et des validations qu’on veut effectuer, et cree automatiquement des notebooks avec le code necessaire pour les implementer. Avec ce code, on peut ensuite faire des modifications pour determiner completement les operations et obtenir les resultats de validation dans le format attendu.

Pour developper un projet avec la CLI, il faut creer un repertoire vide et activer l’environnement Conda ou Great Expectations a ete installe. A partir de la, utiliser les commandes suivantes.

great_expectations init

great_expectations init cree une structure de repertoires pour Great Expectations, ou seront stockes les sources de donnees (datasources) qui pointent vers les donnees qu’on veut traiter, les regles de validation qui seront appliquees, les notebooks generes par l’assistant et les rapports HTML resultant des analyses.

Ensuite, en executant great_expectations datasource new, on specifie d’ou proviendra le dataset a traiter. Parmi les options, on peut choisir File System et un serveur SQL. Si on selectionne File System, il faut determiner si le moteur utilise est Spark ou Pandas et specifier le repertoire ou se trouvent les fichiers a traiter (tout cela est montre dans l’image ci-dessous).

Une fois les etapes precedentes confirmees, l’assistant ouvrira un notebook Jupyter qui doit etre execute entierement pour que les configurations s’appliquent au projet. Le notebook se trouve dans le repertoire du projet et on peut choisir de le supprimer ou de le garder pour effectuer des modifications de configuration ulterieurement.

Dans le notebook Jupyter, il faut verifier le string yaml de la configuration du Datasource. Dans le champ “data_connectors”, les premieres lignes devraient contenir des informations comme :

La commande suivante est great_expectations suite new, avec laquelle on cree une nouvelle suite d’expectations. L’assistant propose 3 options :

• Creer la suite manuellement

• Creer la suite a partir d’un data asset

• Creer la suite avec l’assistant.

Si c’est la premiere fois que vous utilisez Great Expectations, on recommande l’option 3, car les 2 premieres necessitent une connaissance des expectations disponibles et une expertise metier pour determiner quelles validations sont necessaires pour nos donnees. Si vous avez selectionne l’option 3, vous pouvez choisir un fichier dans le repertoire de donnees configure precedemment, pour inferer le schema des tables et les validations qui pourraient s’appliquer.

Quand vous selectionnez le fichier choisi pour inferer le schema, on vous demandera d’attribuer un nom a la nouvelle suite et de confirmer la selection finale. Apres cela, un notebook s’ouvre qu’il faut executer pour que Great Expectations suggere les expectations applicables au dataset specifie. Il faut executer toutes les cellules du notebook, et un nouvel onglet s’ouvrira dans le navigateur avec un rapport HTML decrivant les expectations generees pour la suite.

Ces expectations se trouvent dans le repertoire du projet dans great_expectations/expectations/<nom_de_la_suite>.json. On peut modifier ce fichier en ajoutant ou supprimant des expectations. Le catalogue des expectations disponibles, ainsi que leur etat de developpement, se trouve sur https://greatexpectations.io/expectations/.

Executer great_expectations checkpoint new <nom_du_checkpoint> ouvre un notebook qui permet de configurer le checkpoint. Dans ce notebook, de nombreuses configurations sont listees basees sur le datasource et la suite d’expectations configurees aux etapes precedentes. Il permet aussi d’etablir des configurations supplementaires. Par exemple, on peut choisir un fichier different de l’original sur lequel appliquer les expectations. De plus, avec du code supplementaire, on peut specifier que les expectations s’appliquent a plusieurs fichiers dont les noms correspondent a une certaine expression reguliere (multi-batch request).

La derniere cellule du notebook contient des lignes de code commentees qui, une fois executees, appliquent le checkpoint et affichent les resultats dans un rapport HTML dans un nouvel onglet du navigateur. Si on utilise un batch de donnees sans une des colonnes et avec des lignes manquantes, on devrait voir un rapport comme celui montre ci-dessous :

Les checkpoints crees restent dans le repertoire du projet dans : great_expectations/checkpoints/<nom_du_checkpoint>.yml

Les resultats des checkpoints se trouvent dans le repertoire du projet au format JSON dans :

great_expectations/uncommitted/validations/<nom_de_la_suite>/<time_stamp>/<time_stamp>/<random_hash_name>.json

ou bien comme rapports au format HTML dans :

great_expectations/uncommitted/data_docs/local_site/validations/<nom_de_la_suite>/<time_stamp>/<time_stamp>/<random_hash_name>.HTML

Enfin, avec great_expectations checkpoint run <nom_du_checkpoint> on peut appliquer le checkpoint via la CLI.

Commentaires supplementaires :

• On recommande de regarder le workflow de multi-batch requests.

• Parmi les integrations disponibles dans Great Expectations, voici celles qu’on souhaite souligner :

  • Connexion a des bases de donnees SQL
  • Connexion au stockage cloud (S3, GCS, Azure Blob Storage)
  • Orchestration avec Airflow

Conclusion

Dans cet article, on a pu voir les fondamentaux de la qualite des donnees et presenter deux outils bases sur Python pour realiser des analyses dans ce domaine. PyDeequ adopte une approche un peu plus simple et directe pour appliquer des controles, tandis que Great Expectations offre des fonctionnalites tres utiles pour des projets de plus grande envergure. Si vous voulez en savoir plus sur ces outils, laissez vos questions en commentaires.