ग्रेट एक्सपेक्टेशंस ट्यूटोरियल: Python के साथ डेटा वैलिडेशन

ग्रेट एक्सपेक्टेशंस सेट अप करना

इस ट्यूटोरियल में, आप GX Core—ग्रेट एक्सपेक्टेशंस का ओपन-सोर्स संस्करण—का उपयोग करके एक Pandas DataFrame को वैलिडेट करना सीखेंगे। हम कॉन्टेक्स्ट सेट करना, Pandas डेटा सोर्स रजिस्टर करना, एक्सपेक्टेशंस परिभाषित करना, और डेटा बैचों को वैलिडेट करना सीखेंगे।

नोट: हम सुझाव देते हैं कि आप DataLab नोटबुक के साथ साथ चलें, लेकिन आप अपना Python स्क्रिप्ट भी बना सकते हैं।

1. ग्रेट एक्सपेक्टेशंस इंस्टॉल करना

पूर्वापेक्षाएँ

• Python 3.9 से 3.12 इंस्टॉल होना चाहिए।
• कॉनफ्लिक्ट से बचने के लिए, यह अत्यधिक अनुशंसित है कि आप ग्रेट एक्सपेक्टेशंस को एक वर्चुअल एनवायरनमेंट के भीतर इंस्टॉल करें (अस्वीकरण: वर्चुअल एनवायरनमेंट की सेटअप इस लेख के दायरे से बाहर है)।
• एक सैंपल डेटासेट।

नोट: यदि आप दिए गए DataLab नोटबुक का उपयोग कर रहे हैं, तो ये पूर्वापेक्षाएँ पहले से पूरी हैं। आप इन्हें छोड़ सकते हैं।

pip के माध्यम से GX इंस्टॉल करने के लिए निम्न कमांड का उपयोग करें:

pip install great_expectations

यह कमांड कोर पैकेज और सभी आवश्यक निर्भरताएँ इंस्टॉल करती है।

2. डेटा कॉन्टेक्स्ट को इनिशियलाइज़ करना

ग्रेट एक्सपेक्टेशंस को कॉन्फ़िगरेशन प्रबंधित करने के लिए डेटा कॉन्टेक्स्ट की आवश्यकता होती है। हम कॉन्फ़िगरेशन को स्थायी रूप से सहेजने से बचने के लिए एक इफेमरल डेटा कॉन्टेक्स्ट का उपयोग करते हैं।

import great_expectations as gx

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

अपना पहला डेटा वैलिडेशन सूट बनाना

अब जब GX सेट हो चुका है, तो एक डेटा वैलिडेशन सूट बनाते हैं।

1. डेटा सोर्स से कनेक्ट करना और डेटा एसेट बनाना

डेटा सोर्स ग्रेट एक्सपेक्टेशंस को आपके डेटा से जोड़ता है, जबकि डेटा एसेट डेटा के किसी विशिष्ट सबसेट (जैसे टेबल, DataFrame, या फ़ाइल) का प्रतिनिधित्व करता है।

इस मामले में, हम inventory_parts_df नामक DataFrame से कनेक्ट करने के लिए सब कुछ तैयार करेंगे। सैंपल डेटासेट दिए गए DataLab में उपलब्ध है, और SQL ब्लॉक चलाने पर यह बन जाता है:

यदि आप DataLab का उपयोग नहीं कर रहे हैं, तो सैंपल डेटा के साथ अपना DataFrame बनाएं।

अब, अपना डेटा सोर्स और एसेट बनाएं:

# 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. बैच डेफिनिशन जोड़ना

बैच डेफिनिशन वैलिडेशन के लिए आपके डेटा की पहचान और संगठन करता है। यहाँ, हम पूरे 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. बैच प्राप्त करना

बैच एक बैच डेफिनिशन से जुड़ा डेटा संग्रह है। डेटा को वैलिडेट करने के लिए, आपको बैच को प्राप्त करना होगा और अपने DataFrame (यहाँ 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. सूट बनाना और एक्सपेक्टेशंस परिभाषित करना

एक्सपेक्टेशंस डेटा वैलिडेशन के नियम होते हैं। इस उदाहरण में, हम निम्न सरल एक्सपेक्टेशंस परिभाषित करेंगे:

1. सुनिश्चित करें कि inventory_id मान नल नहीं हैं।
2. सुनिश्चित करें कि part_num मान अद्वितीय हों।

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

आप सभी उपलब्ध एक्सपेक्टेशंस को Expectation Gallery में देख सकते हैं। हम आपको कुछ और जोड़ने के लिए प्रोत्साहित करते हैं!

एक्सपेक्टेशंस परिभाषित करने के बाद, GX एक्सपेक्टेशन सूट कॉन्फ़िगरेशन आउटपुट करता है:

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

सूट में निम्न विवरण शामिल हैं:

1. सूट का नाम और ID: सूट को ट्रैक और प्रबंधित करने के लिए एक अद्वितीय नाम (inventory_parts_suite) और पहचानकर्ता।
2. एक्सपेक्टेशंस: प्रत्येक नियम यह निर्दिष्ट करता है:
• जाँच का प्रकार (जैसे, यह सुनिश्चित करना कि किसी कॉलम में नल मान न हों या प्रविष्टियाँ अद्वितीय हों)।
• पैरामीटर्स, जैसे कि वैलिडेट किया जा रहा कॉलम।
• हर एक्सपेक्टेशन के लिए मेटाडेटा और एक यूनिक ID, जिससे ट्रैकिंग और कस्टमाइज़ेशन आसान हो जाता है।
3. मेटाडेटा: ग्रेट एक्सपेक्टेशंस का वर्ज़न संबंधी जानकारी, जिससे टूल के साथ संगतता सुनिश्चित होती है।
4. नोट्स: सूट के बारे में वर्णनात्मक टिप्पणियाँ जोड़ने के लिए प्लेसहोल्डर (वैकल्पिक)।

यह संरचित आउटपुट आपके डेटासेट के वैलिडेशन के लिए एक प्रलेखन और पुन: उपयोग योग्य कॉन्फ़िगरेशन दोनों के रूप में कार्य करता है ताकि आपकी एक्सपेक्टेशंस स्पष्ट रूप से परिभाषित, ट्रेस करने योग्य और भविष्य के उपयोग के लिए तैयार रहें।

5. डेटा को वैलिडेट करना

अंत में, परिभाषित एक्सपेक्टेशंस के विरुद्ध बैच को वैलिडेट करें और परिणामों का आकलन करें।

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

वैलिडेशन चलाने के बाद, ग्रेट एक्सपेक्टेशंस यह विस्तृत रिपोर्ट देता है कि क्या डेटासेट परिभाषित एक्सपेक्टेशंस को पूरा करता है:

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

यह रिपोर्ट आपके डेटा की गुणवत्ता का विवरण देती है, सफलताओं और विफलताओं को उजागर करती है। यहाँ परिणामों का एक सरल स्पष्टीकरण है:

समग्र वैलिडेशन: वैलिडेशन परिणाम आंशिक रूप से सफल रहा: 50% एक्सपेक्टेशंस पास हुए और 50% फेल हुए। असफल एक्सपेक्टेशन एक ऐसी डेटा गुणवत्ता समस्या को दर्शाता है जिस पर ध्यान देने की आवश्यकता है। इस मामले में, एक कॉलम परिभाषित नियम को पूरा नहीं कर पाया।

एक्सपेक्टेशन 1: inventory_id में कोई मिसिंग मान नहीं होना चाहिए

• परिणाम: पास
• व्याख्या: inventory_id कॉलम में हर मान मौजूद है, कोई नल या मिसिंग एंट्री नहीं है। यह इस कॉलम के लिए अच्छी डेटा पूर्णता को दर्शाता है।

एक्सपेक्टेशन 2: part_num के मान अद्वितीय होने चाहिए

• परिणाम: फेल
• व्याख्या: part_num कॉलम में 97.98% डुप्लिकेट मान हैं, यानी केवल कुछ ही मान अद्वितीय हैं।
• मुख्य बिंदु:
• उदाहरण डुप्लिकेट मानों में "3069b" और "33291" शामिल हैं।
• टूल यह भी दिखाता है कि ये डुप्लिकेट कितनी बार आते हैं और उनकी पंक्ति स्थितियाँ क्या हैं, जिससे समस्याओं का पता लगाना और ठीक करना आसान हो जाता है।

बेशक, यह सिर्फ एक सैंपल डेटासेट है, और हमने जानबूझकर एक पास और एक फेल होने वाला एक्सपेक्टेशन शामिल किया है ताकि आप दोनों प्रकार के वैलिडेशन परिणाम देख सकें।

बस इतना ही! आपने सफलतापूर्वक एंड-टू-एंड डेटा वैलिडेशन चलाया है।

डेटा पाइपलाइनों में ग्रेट एक्सपेक्टेशंस का एकीकरण

प्रोडक्शन सेटिंग में, हर चरण पर डेटा गुणवत्ता की निरंतर निगरानी के लिए वैलिडेशन को सीधे वर्कफ़्लो में एम्बेड करना आवश्यक है। 

इस खंड में, हम चर्चा करेंगे कि आप डेटा पाइपलाइनों में ग्रेट एक्सपेक्टेशंस को कैसे इंटीग्रेट कर सकते हैं।

ये केवल उदाहरण हैं ताकि आपको आइडिया मिल सके, और यहाँ शामिल नहीं की गई अतिरिक्त कॉन्फ़िगरेशन की आवश्यकता हो सकती है। अद्यतन सिंटैक्स के लिए प्रत्येक टूल के प्रलेखन को देखें!

ETL टूल्स के साथ एकीकरण

ग्रेट एक्सपेक्टेशंस को लोकप्रिय ETL टूल्स जैसे Apache Airflow या Prefect के साथ इंटीग्रेट करना अपेक्षाकृत सीधा है। वैलिडेशन स्टेप्स को सीधे ETL प्रक्रियाओं में एम्बेड करने से आप वास्तविक समय में डेटा समस्याओं को पकड़ और संबोधित कर सकते हैं, इससे पहले कि वे डाउनस्ट्रीम विश्लेषण को प्रभावित करें।

आइए Prefect के साथ ग्रेट एक्सपेक्टेशंस को इंटीग्रेट करने का एक सरल उदाहरण देखें ताकि एक स्वचालित ETL वर्कफ़्लो के हिस्से के रूप में डेटा वैलिडेशन चलाया जा सके:

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

इस उदाहरण में, हम Prefect फ़्लो परिभाषित करते हैं जिसमें ग्रेट एक्सपेक्टेशंस वैलिडेशन चलाने का एक टास्क होता है।

फ़ंक्शन validate_data() ग्रेट एक्सपेक्टेशंस कॉन्टेक्स्ट लोड करता है, डेटा बैच प्राप्त करता है, और एक्सपेक्टेशन सूट लागू करता है। 

यदि डेटा वैलिडेशन मानदंडों को पूरा नहीं करता, तो टास्क एक अलर्ट उठाता है, वर्कफ़्लो को रोक देता है, और डाउनस्ट्रीम त्रुटियों को रोकता है।

निरंतर डेटा वैलिडेशन

आप विभिन्न टूल्स का उपयोग करके वैलिडेशन जॉब्स को शेड्यूल कर सकते हैं, जैसे Unix-आधारित सिस्टम पर क्रॉन जॉब्स या Apache Airflow जैसी मैनेज्ड सेवाएँ। इस उदाहरण के लिए, हम Airflow का उपयोग करके वैलिडेशन रन को शेड्यूल करना दिखाएँगे, जो डेटा पाइपलाइनों के ऑर्केस्ट्रेशन के लिए उपयुक्त है।

यहाँ बताया गया है कि आप Airflow DAG (Directed Acyclic Graph) कैसे सेट कर सकते हैं ताकि ग्रेट एक्सपेक्टेशंस वैलिडेशन प्रतिदिन चलें:

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

इस उदाहरण में, हम एक DAG परिभाषित करते हैं जो दिन में एक बार (@daily) वैलिडेशन रन शेड्यूल करता है। 

फ़ंक्शन run_validation() ग्रेट एक्सपेक्टेशंस कॉन्टेक्स्ट लोड करके और परिभाषित एक्सपेक्टेशन सूट को डेटा पर चलाकर वैलिडेशन निष्पादित करता है।

ग्रेट एक्सपेक्टेशंस के साथ डेटा वैलिडेशन के लिए सर्वोत्तम प्रथाएँ

स्केलेबिलिटी और दक्षता के लिए सर्वोत्तम प्रथाओं का पालन करना हमेशा उचित रहता है, और ग्रेट एक्सपेक्टेशंस के साथ डेटा वैलिडेशन में भी यह अलग नहीं है।

छोटे से शुरू करें और क्रमिक रूप से बढ़ाएँ

मूलभूत डेटा गुणवत्ता जाँच से शुरुआत करें और धीरे-धीरे विस्तार करें। शुरू में बुनियादी एक्सपेक्टेशंस पर ध्यान केंद्रित करना बेहतर है, क्योंकि इससे प्रक्रिया को अत्यधिक जटिल होने से बचाया जा सकता है, जो सहज इंटीग्रेशन और आसान समस्या निवारण में मदद करता है। जैसे-जैसे आपके डेटासेट की समझ बढ़ती है, आप अधिक जटिल वैलिडेशन जोड़ सकते हैं।

टीमों के बीच सहयोग करें

डेटा गुणवत्ता केवल तकनीकी चिंता का विषय नहीं है। बिज़नेस टीमों के साथ मिलकर एक्सपेक्टेशंस परिभाषित करें और सुनिश्चित करें कि लागू वैलिडेशन अंतर्निहित व्यावसायिक तर्क और उद्देश्यों के अनुरूप हों। यह क्रॉस-फ़ंक्शनल दृष्टिकोण सुनिश्चित करता है कि डेटा अपने उद्देश्य की पूर्ति करे और सभी हितधारकों की आवश्यकताओं को पूरा करे।

जहाँ संभव हो स्वचालन करें

जहाँ भी संभव हो, प्रक्रिया को स्वचालित करें ताकि डेटा वैलिडेशन को डेटा पाइपलाइनों में एकीकृत किया जा सके। स्वचालित वैलिडेशन जाँच को एकीकृत करने से बिना मैन्युअल हस्तक्षेप के डेटा गुणवत्ता की निरंतर निगरानी संभव होती है, जिससे दक्षता में उल्लेखनीय सुधार होता है।

निष्कर्ष

शानदार काम! आपने ग्रेट एक्सपेक्टेशंस में डेटा को कॉन्फ़िगर और वैलिडेट करना सीख लिया है। ये तकनीकें आपके वर्कफ़्लोज़ में उच्च डेटा गुणवत्ता और पारदर्शिता बनाए रखने में मदद करेंगी।

अपनी क्षमताओं को आगे बढ़ाने के लिए, इन संसाधनों को देखें:

• ETL और ELT इन Python: डेटा को प्रभावी ढंग से रूपांतरित और स्थानांतरित करना सीखें।
• इंट्रोडक्शन टू डेटा क्वालिटी: डेटा गुणवत्ता प्रबंधन की बुनियादों का अन्वेषण करें।
• क्लीनिंग डेटा इन Python: सटीकता और स्थिरता सुनिश्चित करने के लिए डेटा सफाई तकनीकों में महारत हासिल करें।
• डेटा क्वालिटी डाइमेंशंस चीट शीट: डेटा गुणवत्ता आयामों के लिए एक सुविधाजनक गाइड।