मॉडल उपचारात्मक केस स्टडी

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

इस नोटबुक में, हम लिखित सामग्री की पहचान करने के लिए एक टेक्स्ट क्लासिफायरियर को प्रशिक्षित करेंगे जिसे विषाक्त या हानिकारक माना जा सकता है, और कुछ निष्पक्षता संबंधी चिंताओं को दूर करने के लिए MinDiff लागू करेंगे। हमारे वर्कफ़्लो में, हम करेंगे:

  1. संवेदनशील समूहों के संदर्भ वाले टेक्स्ट पर हमारे बेसलाइन मॉडल के प्रदर्शन का मूल्यांकन करें।
  2. MinDiff के साथ प्रशिक्षण द्वारा किसी भी खराब प्रदर्शन करने वाले समूहों के प्रदर्शन में सुधार करें।
  3. हमारे चुने हुए मीट्रिक पर नए मॉडल के प्रदर्शन का मूल्यांकन करें।

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

सेट अप

हम निष्पक्षता संकेतक और TensorFlow मॉडल उपचार स्थापित करके शुरू करते हैं।

इंस्टॉल

मूल्यांकन के लिए MinDiff और Fairness Indicators सहित सभी आवश्यक घटकों को आयात करें।

आयात

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

# We use a helper utility to preprocessed data for convenience and speed.
data_train, data_validate, validate_tfrecord_file, labels_train, labels_validate = min_diff_keras_utils.download_and_process_civil_comments_data()
Downloading data from https://storage.googleapis.com/civil_comments_dataset/train_df_processed.csv
345702400/345699197 [==============================] - 8s 0us/step
Downloading data from https://storage.googleapis.com/civil_comments_dataset/validate_df_processed.csv
229974016/229970098 [==============================] - 5s 0us/step
Downloading data from https://storage.googleapis.com/civil_comments_dataset/validate_tf_processed.tfrecord
324943872/324941336 [==============================] - 9s 0us/step

हम कुछ उपयोगी स्थिरांक परिभाषित करते हैं। हम पर मॉडल को प्रशिक्षित करेंगे 'comment_text' सुविधा, के रूप में हमारा लक्ष्य लेबल के साथ 'toxicity' । ध्यान दें कि यहां बैच का आकार मनमाने ढंग से चुना गया है, लेकिन उत्पादन सेटिंग में आपको इसे सर्वश्रेष्ठ प्रदर्शन के लिए ट्यून करना होगा।

TEXT_FEATURE = 'comment_text'
LABEL = 'toxicity'
BATCH_SIZE = 512

यादृच्छिक बीज सेट करें। (ध्यान दें कि यह परिणामों को पूरी तरह से स्थिर नहीं करता है।)

बीज

आधारभूत मॉडल को परिभाषित और प्रशिक्षित करें

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

use_pretrained_model = True

if use_pretrained_model:
  URL = 'https://storage.googleapis.com/civil_comments_model/baseline_model.zip'
  BASE_PATH = tempfile.mkdtemp()
  ZIP_PATH = os.path.join(BASE_PATH, 'baseline_model.zip')
  MODEL_PATH = os.path.join(BASE_PATH, 'tmp/baseline_model')

  r = requests.get(URL, allow_redirects=True)
  open(ZIP_PATH, 'wb').write(r.content)

  with zipfile.ZipFile(ZIP_PATH, 'r') as zip_ref:
    zip_ref.extractall(BASE_PATH)
  baseline_model = tf.keras.models.load_model(
      MODEL_PATH, custom_objects={'KerasLayer' : hub.KerasLayer})
else:
  optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
  loss = tf.keras.losses.BinaryCrossentropy()

  baseline_model = min_diff_keras_utils.create_keras_sequential_model()

  baseline_model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])

  baseline_model.fit(x=data_train[TEXT_FEATURE],
                     y=labels_train,
                     batch_size=BATCH_SIZE,
                     epochs=20)

हम आदेश का उपयोग कर मूल्यांकन करने के मॉडल को बचाने निष्पक्षता संकेतक

base_dir = tempfile.mkdtemp(prefix='saved_models')
baseline_model_location = os.path.join(base_dir, 'model_export_baseline')
baseline_model.save(baseline_model_location, save_format='tf')
INFO:tensorflow:Assets written to: /tmp/saved_models867b8d74/model_export_baseline/assets
INFO:tensorflow:Assets written to: /tmp/saved_models867b8d74/model_export_baseline/assets

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

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

# We use a helper utility to hide the evaluation logic for readability.
base_dir = tempfile.mkdtemp(prefix='eval')
eval_dir = os.path.join(base_dir, 'tfma_eval_result')
eval_result = fi_util.get_eval_results(
    baseline_model_location, eval_dir, validate_tfrecord_file)
WARNING:absl:Tensorflow version (2.5.0) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:apache_beam.runners.interactive.interactive_environment:Dependencies required for Interactive Beam PCollection visualization are not available, please use: `pip install apache-beam[interactive]` to install necessary dependencies to enable all data visualization features.
WARNING:apache_beam.io.tfrecordio:Couldn't find python-snappy so the implementation of _TFRecordUtil._masked_crc32c is not as fast as it could be.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:113: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:113: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`

मूल्यांकन परिणाम प्रस्तुत करना

widget_view.render_fairness_indicator(eval_result)
FairnessIndicatorViewer(slicingMetrics=[{'sliceValue': 'Overall', 'slice': 'Overall', 'metrics': {'accuracy': …

आइए मूल्यांकन के परिणामों को देखें। 0.450 की सीमा के साथ मेट्रिक झूठी सकारात्मक दर (FPR) का चयन करने का प्रयास करें। हम देख सकते हैं कि मॉडल कुछ धार्मिक समूहों के लिए उतना अच्छा प्रदर्शन नहीं करता है जितना कि दूसरों के लिए, बहुत अधिक एफपीआर प्रदर्शित करता है। कुछ समूहों पर व्यापक विश्वास अंतरालों पर ध्यान दें क्योंकि उनके पास बहुत कम उदाहरण हैं। इससे निश्चित रूप से यह कहना मुश्किल हो जाता है कि इन स्लाइस के प्रदर्शन में महत्वपूर्ण अंतर है। हम इस मुद्दे को हल करने के लिए और उदाहरण एकत्र करना चाह सकते हैं। हालाँकि, हम उन दो समूहों के लिए MinDiff लागू करने का प्रयास कर सकते हैं, जिनके बारे में हमें विश्वास है कि वे कमज़ोर प्रदर्शन कर रहे हैं।

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

मिनडिफ मॉडल को परिभाषित और प्रशिक्षित करें

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

  • खराब प्रदर्शन करने वाले समूहों के लिए बेहतर प्रदर्शन
  • अन्य समूहों और समग्र प्रदर्शन के लिए सीमित गिरावट

अपना डेटा तैयार करें

MinDiff का उपयोग करने के लिए, हम दो अतिरिक्त डेटा विभाजन बनाते हैं:

  • अल्पसंख्यक समूहों को संदर्भित करने वाले गैर-विषैले उदाहरणों के लिए एक विभाजन: हमारे मामले में, इसमें हमारी कम प्रदर्शन करने वाली पहचान शर्तों के संदर्भ में टिप्पणियां शामिल होंगी। हम कुछ समूहों को शामिल नहीं करते हैं क्योंकि बहुत कम उदाहरण हैं, जो व्यापक आत्मविश्वास अंतराल के साथ उच्च अनिश्चितता की ओर ले जाते हैं।
  • बहुसंख्यक समूह को संदर्भित करने वाले गैर विषैले उदाहरणों के लिए एक विभाजन।

खराब प्रदर्शन करने वाले वर्गों से संबंधित पर्याप्त उदाहरण होना महत्वपूर्ण है। आपके मॉडल आर्किटेक्चर, डेटा वितरण और मिनडिफ़ कॉन्फ़िगरेशन के आधार पर, आवश्यक डेटा की मात्रा में काफी भिन्नता हो सकती है। पिछले अनुप्रयोगों में, हमने प्रत्येक डेटा विभाजन में 5,000 उदाहरणों के साथ MinDiff को अच्छी तरह से काम करते देखा है।

हमारे मामले में, अल्पसंख्यक विभाजन के समूहों में उदाहरण मात्रा 9,688 और 3,906 है। डेटासेट में वर्ग असंतुलन पर ध्यान दें; व्यवहार में, यह चिंता का कारण हो सकता है, लेकिन हम उन्हें इस नोटबुक में संबोधित करने की कोशिश नहीं करेंगे क्योंकि हमारा इरादा केवल MinDiff को प्रदर्शित करना है।

हम इन समूहों के लिए केवल नकारात्मक उदाहरणों का चयन करते हैं, ताकि MinDiff इन उदाहरणों को सही तरीके से प्राप्त करने पर अनुकूलित कर सके। यह जमीनी सच्चाई नकारात्मक उदाहरण के सेट बाहर उत्कीर्ण अगर हम मुख्य रूप से झूठी सकारात्मक दर में असमानताओं के साथ संबंध रहे हैं, लेकिन याद रखें कि एक झूठी सकारात्मक भविष्यवाणी एक जमीनी सच्चाई नकारात्मक उदाहरण है कि गलत तरीके से सकारात्मक रूप में वर्गीकृत किया गया है, जो इस मुद्दे को हम है counterintuitive लग सकता है संबोधित करने की कोशिश कर रहे हैं।

मिनडिफ डेटाफ्रेम बनाएं

# Create masks for the sensitive and nonsensitive groups
minority_mask = data_train.religion.apply(
    lambda x: any(religion in x for religion in ('jewish', 'muslim')))
majority_mask = data_train.religion.apply(lambda x: x == "['christian']")

# Select nontoxic examples, so MinDiff will be able to reduce sensitive FP rate.
true_negative_mask = data_train['toxicity'] == 0

data_train_main = copy.copy(data_train)
data_train_sensitive = data_train[minority_mask & true_negative_mask]
data_train_nonsensitive = data_train[majority_mask & true_negative_mask]

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

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

मिनडिफ डेटासेट बनाएं

# Convert the pandas DataFrames to Datasets.
dataset_train_main = tf.data.Dataset.from_tensor_slices(
    (data_train_main['comment_text'].values, 
     data_train_main.pop(LABEL).values.reshape(-1,1) * 1.0)).batch(BATCH_SIZE)
dataset_train_sensitive = tf.data.Dataset.from_tensor_slices(
    (data_train_sensitive['comment_text'].values, 
     data_train_sensitive.pop(LABEL).values.reshape(-1,1) * 1.0)).batch(BATCH_SIZE)
dataset_train_nonsensitive = tf.data.Dataset.from_tensor_slices(
    (data_train_nonsensitive['comment_text'].values, 
     data_train_nonsensitive.pop(LABEL).values.reshape(-1,1) * 1.0)).batch(BATCH_SIZE)

मॉडल को प्रशिक्षित और मूल्यांकन करें

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

फिर हम मॉडल को सामान्य रूप से संकलित करते हैं (नियमित गैर-मिनडिफ नुकसान का उपयोग करके) और प्रशिक्षित करने के लिए फिट होते हैं।

ट्रेन मिनडिफमॉडल

use_pretrained_model = True

base_dir = tempfile.mkdtemp(prefix='saved_models')
min_diff_model_location = os.path.join(base_dir, 'model_export_min_diff')

if use_pretrained_model:
  BASE_MIN_DIFF_PATH = tempfile.mkdtemp()
  MIN_DIFF_URL = 'https://storage.googleapis.com/civil_comments_model/min_diff_model.zip'
  ZIP_PATH = os.path.join(BASE_PATH, 'min_diff_model.zip')
  MIN_DIFF_MODEL_PATH = os.path.join(BASE_MIN_DIFF_PATH, 'tmp/min_diff_model')
  DIRPATH = '/tmp/min_diff_model'

  r = requests.get(MIN_DIFF_URL, allow_redirects=True)
  open(ZIP_PATH, 'wb').write(r.content)

  with zipfile.ZipFile(ZIP_PATH, 'r') as zip_ref:
    zip_ref.extractall(BASE_MIN_DIFF_PATH)
  min_diff_model = tf.keras.models.load_model(
      MIN_DIFF_MODEL_PATH, custom_objects={'KerasLayer' : hub.KerasLayer})

  min_diff_model.save(min_diff_model_location, save_format='tf')

else:
  min_diff_weight = 1.5

  # Create the dataset that will be passed to the MinDiffModel during training.
  dataset = md.keras.utils.input_utils.pack_min_diff_data(
      dataset_train_main, dataset_train_sensitive, dataset_train_nonsensitive)

  # Create the original model.
  original_model = min_diff_keras_utils.create_keras_sequential_model()

  # Wrap the original model in a MinDiffModel, passing in one of the MinDiff
  # losses and using the set loss_weight.
  min_diff_loss = md.losses.MMDLoss()
  min_diff_model = md.keras.MinDiffModel(original_model,
                                         min_diff_loss,
                                         min_diff_weight)

  # Compile the model normally after wrapping the original model.  Note that
  # this means we use the baseline's model's loss here.
  optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
  loss = tf.keras.losses.BinaryCrossentropy()
  min_diff_model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])

  min_diff_model.fit(dataset, epochs=20)

  min_diff_model.save_original_model(min_diff_model_location, save_format='tf')
INFO:tensorflow:Assets written to: /tmp/saved_modelsb3zkcos_/model_export_min_diff/assets
INFO:tensorflow:Assets written to: /tmp/saved_modelsb3zkcos_/model_export_min_diff/assets

आगे हम परिणामों का मूल्यांकन करते हैं।

min_diff_eval_subdir = os.path.join(base_dir, 'tfma_eval_result')
min_diff_eval_result = fi_util.get_eval_results(
    min_diff_model_location,
    min_diff_eval_subdir,
    validate_tfrecord_file,
    slice_selection='religion')
WARNING:absl:Tensorflow version (2.5.0) found. Note that TFMA support for TF 2.0 is currently in beta

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

widget_view.render_fairness_indicator(min_diff_eval_result)
FairnessIndicatorViewer(slicingMetrics=[{'sliceValue': 'Overall', 'slice': 'Overall', 'metrics': {'accuracy': …

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