फ़ेयरनेस इंडिकेटर

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

निष्पक्षता संकेतक क्या है?

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

विशेष रूप से, निष्पक्षता संकेतक में निम्न करने की क्षमता शामिल है:

• डेटासेट के वितरण का मूल्यांकन करें
• उपयोगकर्ताओं के परिभाषित समूहों में विभाजित मॉडल प्रदर्शन का मूल्यांकन करें
  • आत्मविश्वास अंतराल के साथ अपने परिणामों के बारे में आश्वस्त महसूस करें और कई थ्रेसहोल्ड पर evals करें
• मूल कारणों और सुधार के अवसरों का पता लगाने के लिए अलग-अलग स्लाइस में गहराई से उतरें

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

पाइप पैकेज डाउनलोड में शामिल हैं:

• Tensorflow डेटा सत्यापन (TFDV)
• Tensorflow मॉडल विश्लेषण (TFMA)
  • निष्पक्षता संकेतक
• व्हाट-इफ टूल (WIT)

Tensorflow मॉडल के साथ निष्पक्षता संकेतक का उपयोग करना

जानकारी

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

नमूना

आप अपना मॉडल बनाने के लिए Tensorflow Estimator वर्ग का उपयोग कर सकते हैं। केरस मॉडल के लिए समर्थन जल्द ही टीएफएमए में आ रहा है। यदि आप TFMA को Keras मॉडल पर चलाना चाहते हैं, तो कृपया नीचे "मॉडल-अज्ञेयवादी TFMA" अनुभाग देखें।

आपके अनुमानक के प्रशिक्षित होने के बाद, आपको मूल्यांकन उद्देश्यों के लिए एक सहेजे गए मॉडल को निर्यात करने की आवश्यकता होगी। अधिक जानने के लिए, TFMA गाइड देखें।

स्लाइस को कॉन्फ़िगर करना

इसके बाद, उन स्लाइसों को परिभाषित करें जिन पर आप मूल्यांकन करना चाहते हैं:

slice_spec = [
  tfma.slicer.SingleSliceSpec(columns=[‘fur color’])
]

यदि आप इंटरसेक्शनल स्लाइस (उदाहरण के लिए, फर रंग और ऊंचाई दोनों) का मूल्यांकन करना चाहते हैं, तो आप निम्न सेट कर सकते हैं:

slice_spec = [
  tfma.slicer.SingleSliceSpec(columns=[‘fur_color’, ‘height’])
]`

कंप्यूट फेयरनेस मेट्रिक्स

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

from tensorflow_model_analysis.addons.fairness.post_export_metrics import fairness_indicators

# Build the fairness metrics. Besides the thresholds, you also can config the example_weight_key, labels_key here. For more details, please check the api.
metrics_callbacks = \
    [tfma.post_export_metrics.fairness_indicators(thresholds=[0.1, 0.3,
     0.5, 0.7, 0.9])]

eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path=tfma_export_dir,
    add_metrics_callbacks=metrics_callbacks)

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

compute_confidence_intervals = True

TFMA मूल्यांकन पाइपलाइन चलाएँ:

validate_dataset = tf.data.TFRecordDataset(filenames=[validate_tf_file])

# Run the fairness evaluation.
with beam.Pipeline() as pipeline:
  _ = (
      pipeline
      | beam.Create([v.numpy() for v in validate_dataset])
      | 'ExtractEvaluateAndWriteResults' >>
       tfma.ExtractEvaluateAndWriteResults(
                 eval_shared_model=eval_shared_model,
                 slice_spec=slice_spec,
                 compute_confidence_intervals=compute_confidence_intervals,
                 output_path=tfma_eval_result_path)
  )
eval_result = tfma.load_eval_result(output_path=tfma_eval_result_path)

निष्पक्षता संकेतक प्रस्तुत करें

from tensorflow_model_analysis.addons.fairness.view import widget_view

widget_view.render_fairness_indicator(eval_result=eval_result)

निष्पक्षता संकेतकों का उपयोग करने के लिए युक्तियाँ:

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

एकाधिक मॉडलों के लिए निष्पक्षता संकेतक प्रदान करना

मॉडलों की तुलना करने के लिए निष्पक्षता संकेतकों का भी उपयोग किया जा सकता है। एक एकल eval_result में पास करने के बजाय, एक multi_eval_results ऑब्जेक्ट में पास करें, जो एक शब्दकोश है जो दो मॉडल नामों को eval_result ऑब्जेक्ट्स में मैप करता है।

from tensorflow_model_analysis.addons.fairness.view import widget_view

eval_result1 = tfma.load_eval_result(...)
eval_result2 = tfma.load_eval_result(...)
multi_eval_results = {"MyFirstModel": eval_result1, "MySecondModel": eval_result2}

widget_view.render_fairness_indicator(multi_eval_results=multi_eval_results)

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

गैर-टेन्सरफ्लो मॉडल के साथ निष्पक्षता संकेतक का उपयोग करना

अलग-अलग मॉडल और कार्यप्रवाह वाले ग्राहकों का बेहतर समर्थन करने के लिए, हमने एक मूल्यांकन पुस्तकालय विकसित किया है जो मूल्यांकन किए जा रहे मॉडल के लिए अज्ञेयवादी है।

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

जानकारी

यह चरण वह डेटासेट प्रदान करने के लिए है जिस पर आप मूल्यांकन चलाना चाहते हैं। यह tf.Example proto फ़ॉर्मैट में होना चाहिए जिसमें लेबल, भविष्यवाणियाँ और अन्य सुविधाएँ हों जिन पर आप स्लाइस करना चाहें।

tf.Example {
    features {
        feature {
          key: "fur_color" value { bytes_list { value: "gray" } }
        }
        feature {
          key: "height" value { bytes_list { value: "tall" } }
        }
        feature {
          key: "prediction" value { float_list { value: 0.9 } }
        }
        feature {
          key: "label" value { float_list { value: 1.0 } }
        }
    }
}

नमूना

एक मॉडल को निर्दिष्ट करने के बजाय, आप एक मॉडल अज्ञेयवादी eval config और एक्सट्रैक्टर बनाते हैं जो डेटा को पार्स करने और प्रदान करने के लिए TFMA को मेट्रिक्स की गणना करने की आवश्यकता होती है। ModelAgnosticConfig spec इनपुट उदाहरणों से उपयोग की जाने वाली सुविधाओं, भविष्यवाणियों और लेबल को परिभाषित करता है।

इसके लिए, एक फीचर मैप बनाएं, जिसमें लेबल और प्रेडिक्शन कीज और फीचर के डेटा प्रकार का प्रतिनिधित्व करने वाले मूल्यों सहित सभी सुविधाओं का प्रतिनिधित्व करने वाली कुंजियाँ हों।

feature_map[label_key] = tf.FixedLenFeature([], tf.float32, default_value=[0])

लेबल कुंजियों, पूर्वानुमान कुंजियों और फ़ीचर मैप का उपयोग करके एक मॉडल अज्ञेयवादी कॉन्फ़िगरेशन बनाएं।

model_agnostic_config = model_agnostic_predict.ModelAgnosticConfig(
    label_keys=list(ground_truth_labels),
    prediction_keys=list(predition_labels),
    feature_spec=feature_map)

मॉडल अज्ञेय चिमटा सेट करें

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

model_agnostic_extractors = [
    model_agnostic_extractor.ModelAgnosticExtractor(
        model_agnostic_config=model_agnostic_config, desired_batch_size=3),
    slice_key_extractor.SliceKeyExtractor([
        slicer.SingleSliceSpec(),
        slicer.SingleSliceSpec(columns=[‘height’]),
    ])
]

कंप्यूट फेयरनेस मेट्रिक्स

EvalSharedModel के हिस्से के रूप में, आप वे सभी मीट्रिक प्रदान कर सकते हैं जिन पर आप अपने मॉडल का मूल्यांकन करना चाहते हैं। मेट्रिक्स कॉलबैक के रूप में प्रदान किए जाते हैं जैसे पोस्ट_एक्सपोर्ट_मेट्रिक्स या फेयरनेस_इंडिकेटर में परिभाषित।

metrics_callbacks.append(
    post_export_metrics.fairness_indicators(
        thresholds=[0.5, 0.9],
        target_prediction_keys=[prediction_key],
        labels_key=label_key))

यह एक construct_fn भी लेता है जिसका उपयोग मूल्यांकन करने के लिए टेंसरफ़्लो ग्राफ़ बनाने के लिए किया जाता है।

eval_shared_model = types.EvalSharedModel(
    add_metrics_callbacks=metrics_callbacks,
    construct_fn=model_agnostic_evaluate_graph.make_construct_fn(
        add_metrics_callbacks=metrics_callbacks,
        fpl_feed_config=model_agnostic_extractor
        .ModelAgnosticGetFPLFeedConfig(model_agnostic_config)))

एक बार सब कुछ सेट हो जाने के बाद, मॉडल का मूल्यांकन करने के लिए model_eval_lib द्वारा प्रदान किए गए ExtractEvaluate या ExtractEvaluateAndWriteResults फ़ंक्शंस में से किसी एक का उपयोग करें।

_ = (
    examples |
    'ExtractEvaluateAndWriteResults' >>
        model_eval_lib.ExtractEvaluateAndWriteResults(
        eval_shared_model=eval_shared_model,
        output_path=output_path,
        extractors=model_agnostic_extractors))

eval_result = tensorflow_model_analysis.load_eval_result(output_path=tfma_eval_result_path)

अंत में, ऊपर दिए गए "रेंडर फेयरनेस इंडिकेटर" अनुभाग के निर्देशों का उपयोग करते हुए फेयरनेस इंडिकेटर्स को रेंडर करें।

और ज्यादा उदाहरण

निष्पक्षता संकेतक उदाहरण निर्देशिका में कई उदाहरण हैं:

• Fairness_Indicators_Example_Colab.ipynb TensorFlow मॉडल विश्लेषण में निष्पक्षता संकेतकों का अवलोकन देता है और वास्तविक डेटासेट के साथ इसका उपयोग कैसे करें। यह नोटबुक TensorFlow Data Validation और What-If Tool पर भी जाती है, TensorFlow मॉडल का विश्लेषण करने के लिए दो टूल जो फेयरनेस इंडिकेटर्स के साथ पैक किए गए हैं।
• Fairness_Indicators_on_TF_Hub.ipynb प्रदर्शित करता है कि विभिन्न टेक्स्ट एम्बेडिंग पर प्रशिक्षित मॉडलों की तुलना करने के लिए फेयरनेस इंडिकेटर्स का उपयोग कैसे करें। यह नोटबुक मॉडल घटकों को प्रकाशित करने, खोजने और पुन: उपयोग करने के लिए TensorFlow हब , TensorFlow की लाइब्रेरी से टेक्स्ट एम्बेडिंग का उपयोग करता है।
• Fairness_Indicators_TensorBoard_Plugin_Example_Colab.ipynb प्रदर्शित करता है कि TensorBoard में निष्पक्षता संकेतकों की कल्पना कैसे की जाती है।