समापन

Great Expectations के साथ Data Quality परिचय

Davina Moossazadeh

Data Scientist

अध्याय 1: डेटा से कनेक्ट करना

Data Context बनाएँ

context = gx.get_context()

अध्याय 1: डेटा से कनेक्ट करना

डेटा से कनेक्ट करें

Data Context से Data Source बनाएँ:

data_source = context.data_sources.add_pandas(
    name: str
)

Data Source से Data Asset बनाएँ:

data_asset = data_source.add_dataframe_asset(
    name: str
)

अध्याय 1: डेटा से कनेक्ट करना

बैच में डेटा पढ़ें

Data Asset से Batch Definition बनाएँ:

batch_definition = data_asset. \
add_batch_definition_whole_dataframe(
  name: str
)

Batch Definition से Batch बनाएँ:

batch = batch_definition.get_batch(
  batch_parameters={"dataframe": dataframe}
)

Batch DataFrame की पंक्तियाँ देखें:

batch.head(fetch_all: bool)

Batch DataFrame के कॉलम देखें:

batch.columns()

अध्याय 2: Expectations तय करना

Expectations बनाएँ

एक Expectation बनाएँ: gx.expectations.Expect...(...)

Row count Expectation बनाएँ:

expectation = gx.expectations. \
ExpectTableRowCountToEqual(
    value: int
)

Expectation वैलिडेट करें:

validation_results = batch.validate(
    expect=expectation
)

Validation Results जाँचें:

validation_results.describe()
validation_results.success
validation_results.result

अध्याय 2: Expectations तय करना

Schema Expectations

Shape Expectations:

ExpectTableRowCountToEqual(value: int)
ExpectTableRowCountToBeBetween(
    min_value: int, max_value: int
)
ExpectTableColumnCountToEqual(
    value: int
)
ExpectTableColumnCountToBeBetween(
    min_value: int, max_value: int
)

कॉलम नाम Expectations:

ExpectTableColumnsToMatchSet(
    column_set: set
)
ExpectColumnToExist(column: str)

अध्याय 2: Expectations तय करना

Expectations का Suite बनाएँ

Expectation Suite बनाएँ:

suite = gx.ExpectationSuite(name: str)

Suite में Expectation जोड़ें:

suite.add_expectation(expectation)

Suite की Expectations देखें:

suite.expectations

Expectation Suite वैलिडेट करें:

validation_results = batch.validate(
    expect=suite
)

Validation Results जाँचें:

validation_results.success
validation_results.describe()

अध्याय 2: Expectations तय करना

Expectation Suites वैलिडेट करें

Expectation Suite को Data Context में जोड़ें:

context.suites.add(suite)

Validation Definition बनाएँ:

validation_definition = \
gx.ValidationDefinition(
  name: str, 
  data=batch_definition, 
  suite=suite
)

Validation चलाएँ:

validation_results = \
validation_definition.run(
  batch_parameters={"dataframe": dataframe}
)

Validation Results जाँचें:

validation_results.success
validation_results.describe()

अध्याय 3: GX का अभ्यास

Validation Definitions डिप्लॉय करें

Validation Definition को Data Context में जोड़ें:

context.validation_definitions.add(
    validation_definition
)

Checkpoint बनाएँ:

checkpoint = gx.Checkpoint(
    name: str, 
    validation_definitions: list,
)

Checkpoint चलाएँ:

checkpoint_results = checkpoint.run(
    batch_parameters={
        "dataframe": dataframe
    }
)

Checkpoint Results जाँचें:

checkpoint_results.success

अध्याय 3: GX का अभ्यास

Expectation Suites अपडेट करें

Expectation कॉपी करें:

expectation_copy = expectation.copy()
expectation_copy.id = None

जाँचें कि Expectation Suite में है या नहीं:

expectation in suite.expectations

Expectation डिलीट करें:

suite.delete_expectation(expectation)

Expectation का value अपडेट करें:

expectation.value = new_value

Expectation में किए बदलाव सेव करें:

expectation.save()

Expectation Suite में किए बदलाव सेव करें:

suite.save()

अध्याय 3: GX का अभ्यास

Components मैनेज करें

Data Context में कोई component जोड़ें:

context.data_sources.add(data_source)

context.suites.add(suite)

context.validation_definitions.add(
    validation_definition
)

context.checkpoints.add(checkpoint)

Component प्राप्त करें:

.get(name: str)

Components सूचीबद्ध करें:

.all()

Component डिलीट करें:

.delete(name: str)

अध्याय 4: Expectations की पूरी जानकारी

बेसिक कॉलम Expectations

Row-level Expectations:

ExpectColumnValuesToNotBeNull(
    column: str
)
ExpectColumnValuesToBeOfType(
    column: str, type_: str
)

Aggregate-level Expectations:

ExpectColumnDistinctValuesToEqualSet(
    column: str, value_set: set
)
ExpectColumnUniqueValueCountToBeBetween(
    column: str, 
    min_value: int, max_value: int
)
ExpectColumnValuesToBeUnique(column: str)
ExpectColumnMostCommonValueToBeInSet(
    column: str, value_set: set
)

अध्याय 4: Expectations की पूरी जानकारी

टाइप-विशिष्ट Expectations

न्यूमेरिक Expectations:

ExpectColumn<METRIC>ToBeBetween(
  column: str, min_value: int, max_value: int
)
# <METRIC> in 
# {"Mean", "Median", "Stdev", "Sum"}

ExpectColumnValuesToBeBetween(
  column: str, min_value: int, max_value: int
)
ExpectColumnValuesToBeIncreasing(column: str)
ExpectColumnValuesToBeDecreasing(column: str)

स्ट्रिंग Expectations:

ExpectColumnValueLengthsToEqual(
  column: str, value: int
)
ExpectColumnValuesToMatchRegex(
  column: str, regex: str
)
ExpectColumnValuesToMatchRegexList(
  column: str, regex_list: list
)
ExpectColumnValuesToBe{Dateutil,Json}Parseable(
  column: str
)

अध्याय 4: Expectations की पूरी जानकारी

Conditional Expectations

expectation = gx.expectations.Expect...(
    expetation_parameters,
    ...,
    condition_parser='pandas',
    row_condition: str,
)

अंतिम शब्द

Resources:

https://docs.greatexpectations.io/docs/core/introduction

https://docs.greatexpectations.io/docs/reference

Expectation Gallery:

www.greatexpectations.io/expectations

बधाई हो!

Great Expectations के साथ Data Quality परिचय