सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

Tensorflow डेटा सत्यापन के साथ आरंभ करें

Tensorflow डेटा सत्यापन (TFDV) प्रशिक्षण और डेटा की सेवा का विश्लेषण कर सकता है:

कोर एपीआई कार्यक्षमता के प्रत्येक टुकड़े का समर्थन करता है, सुविधा विधियों के साथ जो शीर्ष पर निर्मित होते हैं और नोटबुक के संदर्भ में कहे जा सकते हैं।

वर्णनात्मक डेटा आँकड़ों की गणना

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

उदाहरण के लिए, कि लगता है path में एक फाइल करने के लिए अंक TFRecord प्रारूप (जो प्रकार का रिकॉर्ड रखती है tensorflow.Example )। निम्नलिखित स्निपेट TFDV का उपयोग करके आँकड़ों की गणना को दर्शाता है:

    stats = tfdv.generate_statistics_from_tfrecord(data_location=path)

वापस लौटाया गया मान है DatasetFeatureStatisticsList प्रोटोकॉल बफ़र। उदाहरण नोटबुक का उपयोग कर आंकड़ों का एक दृश्य शामिल पहलुओं अवलोकन :

    tfdv.visualize_statistics(stats)

सांख्यिकी विज़ुअलाइज़ेशन का स्क्रीनशॉट

पिछले उदाहरण मानता है कि डेटा एक में संग्रहित है TFRecord फ़ाइल। TFDV अन्य सामान्य स्वरूपों के लिए एक्स्टेंसिबिलिटी के साथ CSV इनपुट प्रारूप का भी समर्थन करता है। आप उपलब्ध आंकड़ों डिकोडर पा सकते हैं यहाँ । इसके अलावा, TFDV प्रदान करता है tfdv.generate_statistics_from_dataframe एक पांडा DataFrame के रूप में प्रतिनिधित्व में स्मृति डेटा के साथ उपयोगकर्ताओं के लिए उपयोगिता कार्य करते हैं।

डेटा आँकड़ों के एक डिफ़ॉल्ट सेट की गणना के अलावा, TFDV सिमेंटिक डोमेन (जैसे, चित्र, पाठ) के लिए आँकड़ों की गणना भी कर सकता है। अर्थ डोमेन आंकड़े की गणना को सक्षम करने के लिए एक से पारित tfdv.StatsOptions के साथ वस्तु enable_semantic_domain_stats को सही पर सेट tfdv.generate_statistics_from_tfrecord

Google क्लाउड पर चल रहा है

आंतरिक रूप से, TFDV का उपयोग करता अपाचे बीम बड़े डेटासेट से अधिक आंकड़े की गणना पैमाने पर करने के डेटा-समानांतर प्रसंस्करण ढांचा। अनुप्रयोग जो TFDV के साथ गहरा एकीकृत करने के लिए इच्छा के लिए (एक डेटा पीढ़ी पाइपलाइन के अंत में संलग्न आंकड़े पीढ़ी, जैसे कस्टम प्रारूप में डेटा के लिए आँकड़े उत्पन्न ), एपीआई भी आंकड़े पीढ़ी के लिए एक बीम PTransform उजागर करता है।

Google क्लाउड पर TFDV चलाने के लिए, TFDV व्हील फ़ाइल को डाउनलोड किया जाना चाहिए और डेटाफ़्लो कर्मचारियों को प्रदान किया जाना चाहिए। व्हील फ़ाइल को वर्तमान निर्देशिका में निम्नानुसार डाउनलोड करें:

pip download tensorflow_data_validation \
  --no-deps \
  --platform manylinux1_x86_64 \
  --only-binary=:all:

निम्नलिखित स्निपेट Google क्लाउड पर TFDV के उपयोग का एक उदाहरण दिखाता है:


import tensorflow_data_validation as tfdv
from apache_beam.options.pipeline_options import PipelineOptions, GoogleCloudOptions, StandardOptions, SetupOptions

PROJECT_ID = ''
JOB_NAME = ''
GCS_STAGING_LOCATION = ''
GCS_TMP_LOCATION = ''
GCS_DATA_LOCATION = ''
# GCS_STATS_OUTPUT_PATH is the file path to which to output the data statistics
# result.
GCS_STATS_OUTPUT_PATH = ''

PATH_TO_WHL_FILE = ''


# Create and set your PipelineOptions.
options = PipelineOptions()

# For Cloud execution, set the Cloud Platform project, job_name,
# staging location, temp_location and specify DataflowRunner.
google_cloud_options = options.view_as(GoogleCloudOptions)
google_cloud_options.project = PROJECT_ID
google_cloud_options.job_name = JOB_NAME
google_cloud_options.staging_location = GCS_STAGING_LOCATION
google_cloud_options.temp_location = GCS_TMP_LOCATION
options.view_as(StandardOptions).runner = 'DataflowRunner'

setup_options = options.view_as(SetupOptions)
# PATH_TO_WHL_FILE should point to the downloaded tfdv wheel file.
setup_options.extra_packages = [PATH_TO_WHL_FILE]

tfdv.generate_statistics_from_tfrecord(GCS_DATA_LOCATION,
                                       output_path=GCS_STATS_OUTPUT_PATH,
                                       pipeline_options=options)

इस मामले में, से उत्पन्न आंकड़ों आद्य के लिए लिखा एक TFRecord फ़ाइल में संग्रहीत किया जाता GCS_STATS_OUTPUT_PATH

नोट जब से किसी को बुला tfdv.generate_statistics_... कार्यों (जैसे, tfdv.generate_statistics_from_tfrecord Google मेघ पर), आप एक प्रदान करनी चाहिए output_path । कोई नहीं निर्दिष्ट करने से त्रुटि हो सकती है।

डेटा पर एक स्कीमा का उल्लेख करना

स्कीमा डेटा की उम्मीद गुण वर्णन करता है। इनमें से कुछ गुण हैं:

  • कौन सी विशेषताएं मौजूद होने की उम्मीद है
  • उनका प्रकार
  • प्रत्येक उदाहरण में किसी सुविधा के लिए मानों की संख्या
  • सभी उदाहरणों में प्रत्येक विशेषता की उपस्थिति
  • सुविधाओं के अपेक्षित डोमेन।

संक्षेप में, स्कीमा "सही" डेटा की अपेक्षाओं का वर्णन करती है और इस प्रकार डेटा में त्रुटियों का पता लगाने के लिए इसका उपयोग किया जा सकता है (नीचे वर्णित)। इसके अलावा, एक ही स्कीमा स्थापित करने के लिए इस्तेमाल किया जा सकता Tensorflow रूपांतरण डेटा परिवर्तनों के लिए। ध्यान दें कि स्कीमा काफी स्थिर होने की उम्मीद है, उदाहरण के लिए, कई डेटासेट एक ही स्कीमा के अनुरूप हो सकते हैं, जबकि आंकड़े (ऊपर वर्णित) प्रति डेटासेट भिन्न हो सकते हैं।

चूंकि एक स्कीमा लिखना एक कठिन काम हो सकता है, विशेष रूप से बहुत सारी विशेषताओं वाले डेटासेट के लिए, टीएफडीवी वर्णनात्मक आंकड़ों के आधार पर स्कीमा का प्रारंभिक संस्करण उत्पन्न करने के लिए एक विधि प्रदान करता है:

    schema = tfdv.infer_schema(stats)

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

डिफ़ॉल्ट रूप से, tfdv.infer_schema infers प्रत्येक आवश्यक सुविधा के आकार, अगर value_count.min के बराबर होती है value_count.max सुविधा के लिए। सेट infer_feature_shape अक्षम आकार अनुमान को गलत पर बहस।

स्कीमा अपने आप में एक के रूप में संग्रहीत किया जाता है स्कीमा प्रोटोकॉल बफर और इस तरह अद्यतन किया जा सकता / मानक प्रोटोकॉल-बफर एपीआई का उपयोग कर संपादित। TFDV भी एक प्रदान करता है कुछ उपयोगिता तरीकों ये अद्यतन आसान बनाने के लिए। उदाहरण के लिए, मान लीजिए कि स्कीमा निम्नलिखित श्लोक एक आवश्यक स्ट्रिंग सुविधा का वर्णन करने के शामिल payment_type है कि एक ही मूल्य लेता है:

feature {
  name: "payment_type"
  value_count {
    min: 1
    max: 1
  }
  type: BYTES
  domain: "payment_type"
  presence {
    min_fraction: 1.0
    min_count: 1
  }
}

यह चिह्नित करने के लिए कि सुविधा कम से कम 50% उदाहरणों में आबाद होनी चाहिए:

    tfdv.get_feature(schema, 'payment_type').presence.min_fraction = 0.5

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

स्कीमा विज़ुअलाइज़ेशन का स्क्रीनशॉट

त्रुटियों के लिए डेटा की जाँच करना

एक स्कीमा को देखते हुए यह उम्मीदों स्कीमा में या स्थापित करने के लिए एक डाटासेट अनुरूप वहाँ मौजूद है कि क्या किसी भी जांच करने के लिए संभव है डेटा विसंगतियों । आप त्रुटियों के लिए अपने डेटा की जांच कर सकते हैं (ए) स्कीमा के खिलाफ डेटासेट के आंकड़ों का मिलान करके पूरे डेटासेट में कुल मिलाकर, या (बी) प्रति-उदाहरण के आधार पर त्रुटियों की जांच करके।

किसी स्कीमा के विरुद्ध डेटासेट के आँकड़ों का मिलान करना

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

    # Assume that other_path points to another TFRecord file
    other_stats = tfdv.generate_statistics_from_tfrecord(data_location=other_path)
    anomalies = tfdv.validate_statistics(statistics=other_stats, schema=schema)

परिणाम का एक उदाहरण है विसंगतियां प्रोटोकॉल बफर और किसी भी त्रुटि जहां आंकड़े स्कीमा से सहमत नहीं है वर्णन करता है। उदाहरण के लिए, मान लीजिए कि पर डेटा other_path सुविधा के लिए मूल्यों के साथ उदाहरण दिए गए हैं payment_type डोमेन स्कीमा में वर्णित के बाहर।

यह एक विसंगति पैदा करता है

   payment_type  Unexpected string values  Examples contain values missing from the schema: Prcard (<1%).

यह दर्शाता है कि आँकड़ों में एक आउट ऑफ डोमेन वैल्यू फीचर वैल्यू के <1% में पाया गया था।

यदि यह अपेक्षित था, तो स्कीमा को निम्नानुसार अद्यतन किया जा सकता है:

   tfdv.get_domain(schema, 'payment_type').value.append('Prcard')

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

विभिन्न विसंगति प्रकार है कि इस मॉड्यूल के द्वारा पता लगाया जा सकता सूचीबद्ध हैं यहां

उदाहरण नोटबुक सुविधाओं जहां त्रुटियों का पता चला रहे हैं और प्रत्येक त्रुटि का एक संक्षिप्त विवरण लिस्टिंग, एक तालिका के रूप विसंगतियों का एक सरल दृश्य शामिल हैं।

विसंगतियों का स्क्रीनशॉट

प्रति-उदाहरण के आधार पर त्रुटियों की जाँच करना

TFDV, स्कीमा के विरुद्ध डेटासेट-वाइड आँकड़ों की तुलना करने के बजाय, प्रति-उदाहरण के आधार पर डेटा को मान्य करने का विकल्प भी प्रदान करता है। TFDV प्रति-उदाहरण के आधार पर डेटा को मान्य करने और फिर पाए गए विषम उदाहरणों के लिए सारांश आँकड़े तैयार करने के लिए कार्य प्रदान करता है। उदाहरण के लिए:

   options = tfdv.StatsOptions(schema=schema)
   anomalous_example_stats = tfdv.validate_examples_in_tfrecord(
       data_location=input, stats_options=options)

anomalous_example_stats कि validate_examples_in_tfrecord रिटर्न एक है DatasetFeatureStatisticsList प्रोटोकॉल बफ़र जिसमें प्रत्येक डाटासेट है कि एक विशेष विसंगति दिखा रहे हैं उदाहरण के सेट के होते हैं। आप इसका उपयोग अपने डेटासेट में उदाहरणों की संख्या निर्धारित करने के लिए कर सकते हैं जो किसी दिए गए विसंगति और उन उदाहरणों की विशेषताओं को प्रदर्शित करते हैं।

TFDV भी प्रदान करता है validate_instance की पहचान एक व्यक्ति उदाहरण विसंगतियों दर्शाती है कि जब कोई स्कीमा के प्रति मिलान के लिए कार्य करते हैं। इस फ़ंक्शन का उपयोग करने के लिए, उदाहरण एक तानाशाही मानचित्रण फीचर नाम होना चाहिए जो फीचर वैल्यू के numpy arrays के लिए हो। आप उपयोग कर सकते हैं विकोडक में tfx_bsl को डिकोड धारावाहिक tf.train.Example इस प्रारूप में है। उदाहरण के लिए:

   import tensorflow_data_validation as tfdv
   import tfx_bsl
   import pyarrow as pa
   decoder = tfx_bsl.coders.example_coder.ExamplesToRecordBatchDecoder()
   example = decoder.DecodeBatch([serialized_tfexample])
   options = tfdv.StatsOptions(schema=schema)
   anomalies = tfdv.validate_instance(example, options)

साथ के रूप में validate_statistics , परिणाम का एक उदाहरण है विसंगतियां प्रोटोकॉल बफ़र कि किसी भी त्रुटि जहां उदाहरण निर्दिष्ट स्कीमा से सहमत नहीं है वर्णन करता है।

स्कीमा वातावरण

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

वातावरण ऐसी जरूरतों को व्यक्त करने के लिए इस्तेमाल किया जा सकता है। विशेष रूप से, स्कीमा में सुविधाओं को default_environment, in_environment और not_in_environment का उपयोग करके परिवेशों के एक सेट के साथ जोड़ा जा सकता है।

उदाहरण के लिए, यदि सुझावों सेवा विशेषता डेटा में प्रशिक्षण में लेबल के रूप में इस्तेमाल किया जा रहा है, लेकिन लापता। निर्दिष्ट परिवेश के बिना, यह एक विसंगति के रूप में दिखाई देगा।

    serving_stats = tfdv.generate_statistics_from_tfrecord(data_location=serving_data_path)
    serving_anomalies = tfdv.validate_statistics(serving_stats, schema)

सर्विंग विसंगतियों का स्क्रीनशॉट

इसे ठीक करने के लिए, हमें सभी सुविधाओं के लिए 'ट्रेनिंग' और 'सर्विंग' दोनों के लिए डिफ़ॉल्ट वातावरण सेट करना होगा, और 'टिप्स' फीचर को सर्विंग वातावरण से बाहर करना होगा।

    # All features are by default in both TRAINING and SERVING environments.
    schema.default_environment.append('TRAINING')
    schema.default_environment.append('SERVING')

    # Specify that 'tips' feature is not in SERVING environment.
    tfdv.get_feature(schema, 'tips').not_in_environment.append('SERVING')

    serving_anomalies_with_env = tfdv.validate_statistics(
        serving_stats, schema, environment='SERVING')

डेटा तिरछा और बहाव की जाँच करना

यह जांचने के अलावा कि क्या डेटासेट स्कीमा में निर्धारित अपेक्षाओं के अनुरूप है, TFDV यह पता लगाने के लिए कार्यात्मकता भी प्रदान करता है:

  • प्रशिक्षण और सेवा डेटा के बीच विषमता
  • प्रशिक्षण डेटा के विभिन्न दिनों के बीच बहाव

TFDV स्कीमा में निर्दिष्ट ड्रिफ्ट/स्क्यू तुलनित्र के आधार पर विभिन्न डेटासेट के आँकड़ों की तुलना करके यह जाँच करता है। उदाहरण के लिए, यह जांचने के लिए कि प्रशिक्षण और सेवा डेटासेट के भीतर 'Payment_type' सुविधा के बीच कोई विषमता है या नहीं:

    # Assume we have already generated the statistics of training dataset, and
    # inferred a schema from it.
    serving_stats = tfdv.generate_statistics_from_tfrecord(data_location=serving_data_path)
    # Add a skew comparator to schema for 'payment_type' and set the threshold
    # of L-infinity norm for triggering skew anomaly to be 0.01.
    tfdv.get_feature(schema, 'payment_type').skew_comparator.infinity_norm.threshold = 0.01
    skew_anomalies = tfdv.validate_statistics(
        statistics=train_stats, schema=schema, serving_statistics=serving_stats)

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

   payment_type  High L-infinity distance between serving and training  The L-infinity distance between serving and training is 0.0435984 (up to six significant digits), above the threshold 0.01. The feature value with maximum difference is: Cash

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

उदाहरण नोटबुक तिरछा आधारित विसंगतियों के लिए जाँच का एक सरल उदाहरण में शामिल है।

विभिन्न दिनों के प्रशिक्षण डेटा के बीच बहाव का पता लगाना इसी तरह से किया जा सकता है

    # Assume we have already generated the statistics of training dataset for
    # day 2, and inferred a schema from it.
    train_day1_stats = tfdv.generate_statistics_from_tfrecord(data_location=train_day1_data_path)
    # Add a drift comparator to schema for 'payment_type' and set the threshold
    # of L-infinity norm for triggering drift anomaly to be 0.01.
    tfdv.get_feature(schema, 'payment_type').drift_comparator.infinity_norm.threshold = 0.01
    drift_anomalies = tfdv.validate_statistics(
        statistics=train_day2_stats, schema=schema, previous_statistics=train_day1_stats)

कस्टम डेटा कनेक्टर लिखना

गणना डेटा आँकड़े करने के लिए, TFDV कई प्रदान करता है सुविधाजनक तरीकों विभिन्न प्रारूपों में इनपुट डेटा से निपटने के लिए (जैसे TFRecord की tf.train.Example आदि, सीएसवी,)। यदि आपका डेटा प्रारूप इस सूची में नहीं है, तो आपको इनपुट डेटा पढ़ने के लिए एक कस्टम डेटा कनेक्टर लिखना होगा, और डेटा आंकड़ों की गणना के लिए इसे TFDV कोर API से कनेक्ट करना होगा।

TFDV डेटा आंकड़ों की गणना के लिए कोर एपीआई एक है बीम PTransform कि इनपुट उदाहरण के बैच के एक PCollection (इनपुट उदाहरण के एक बैच एक के रूप में प्रस्तुत किया जाता है लेता तीर RecordBatch), और एक PCollection एक एकल युक्त आउटपुट DatasetFeatureStatisticsList प्रोटोकॉल बफ़र।

एक बार जब आप कस्टम डेटा कनेक्टर को लागू किया है बैचों एक तीर RecordBatch में अपने इनपुट उदाहरण के लिए, आप के साथ कनेक्ट करने की आवश्यकता है कि tfdv.GenerateStatistics डेटा आंकड़ों की गणना के लिए एपीआई। लो TFRecord की tf.train.Example 'उदाहरण के लिए है। हम प्रदान करते हैं DecodeTFExample डेटा कनेक्टर, और नीचे कैसे साथ यह कनेक्ट करने के लिए का एक उदाहरण है tfdv.GenerateStatistics एपीआई।

import tensorflow_data_validation as tfdv
import apache_beam as beam
from tensorflow_metadata.proto.v0 import statistics_pb2

DATA_LOCATION = ''
OUTPUT_LOCATION = ''

with beam.Pipeline() as p:
    _ = (
    p
    # 1. Read out the examples from input files.
    | 'ReadData' >> beam.io.ReadFromTFRecord(file_pattern=DATA_LOCATION)
    # 2. Convert examples to Arrow RecordBatches, which represent example
    #    batches.
    | 'DecodeData' >> tf_example_decoder.DecodeTFExample()
    # 3. Invoke TFDV `GenerateStatistics` API to compute the data statistics.
    | 'GenerateStatistics' >> tfdv.GenerateStatistics()
    # 4. Materialize the generated data statistics.
    | 'WriteStatsOutput' >> WriteStatisticsToTFRecord(OUTPUT_LOCATION))

डेटा के स्लाइस पर आँकड़ों की गणना

TFDV को डेटा के स्लाइस पर आँकड़ों की गणना करने के लिए कॉन्फ़िगर किया जा सकता है। टुकड़ा करने की क्रिया टुकड़ा करने की क्रिया कार्य करता है जो एक तीर में उपलब्ध कराने के द्वारा सक्रिय किया जा सकता RecordBatch और उत्पादन फार्म की tuples के एक दृश्य (slice key, record batch) । TFDV लिए एक आसान तरीका प्रदान करता है सुविधा मूल्य आधारित टुकड़ा करने की क्रिया कार्यों उत्पन्न जो के हिस्से के रूप प्रदान किया जा सकता tfdv.StatsOptions आंकड़ों की गणना करते समय।

जब टुकड़ा करने की क्रिया सक्षम किया गया है, उत्पादन DatasetFeatureStatisticsList आद्य कई हों DatasetFeatureStatistics protos, प्रत्येक टुकड़ा के लिए एक। प्रत्येक टुकड़ा एक अनूठा नाम है जो के रूप में सेट किया गया है द्वारा पहचाना जाता है DatasetFeatureStatistics आद्य में डाटासेट नाम । डिफ़ॉल्ट रूप से TFDV कॉन्फ़िगर किए गए स्लाइस के अलावा समग्र डेटासेट के लिए आँकड़ों की गणना करता है।

import tensorflow_data_validation as tfdv
from tensorflow_data_validation.utils import slicing_util

# Slice on country feature (i.e., every unique value of the feature).
slice_fn1 = slicing_util.get_feature_value_slicer(features={'country': None})

# Slice on the cross of country and state feature (i.e., every unique pair of
# values of the cross).
slice_fn2 = slicing_util.get_feature_value_slicer(
    features={'country': None, 'state': None})

# Slice on specific values of a feature.
slice_fn3 = slicing_util.get_feature_value_slicer(
    features={'age': [10, 50, 70]})

stats_options = tfdv.StatsOptions(
    slice_functions=[slice_fn1, slice_fn2, slice_fn3])