MinDiff डेटा तैयारी

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

परिचय

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

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

MinDiff प्रदर्शित करने के लिए, इस गाइड का उपयोग करता यूसीआई आय डाटासेट । मॉडल कार्य विभिन्न व्यक्तिगत विशेषताओं के आधार पर भविष्यवाणी करना है कि किसी व्यक्ति की आय $ 50k से अधिक है या नहीं। इस गाइड मान लिया गया एफ एन आर में एक समस्याग्रस्त अंतराल (झूठी नकारात्मक दर) के बीच है "Male" और "Female" स्लाइस और मॉडल का स्वामी (आप) मुद्दे का समाधान करने MinDiff लागू करने के लिए फैसला किया है। परिदृश्यों जिसमें एक MinDiff लागू करने के लिए चुन सकते हैं के बारे में अधिक जानकारी के लिए, आवश्यकताओं पेज ।

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

सेट अप

pip install -q --upgrade tensorflow-model-remediation

import tensorflow as tf
from tensorflow_model_remediation import min_diff
from tensorflow_model_remediation.tools.tutorials_utils import uci as tutorials_utils

मूल डेटा

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

# Sampled at 0.3 for reduced runtimes.
train = tutorials_utils.get_uci_data(split='train', sample=0.3)

print(len(train), 'train examples')

9768 train examples

में कनवर्ट कर रहा tf.data.Dataset

MinDiffModel कि इनपुट एक हो की आवश्यकता है tf.data.Dataset । यदि आप MinDiff को एकीकृत करने से पहले इनपुट के किसी भिन्न प्रारूप का उपयोग कर रहे थे, तो आपको अपना इनपुट डेटा परिवर्तित करना होगा।

उपयोग tf.data.Dataset.from_tensor_slices कन्वर्ट करने के लिए tf.data.Dataset ।

dataset = tf.data.Dataset.from_tensor_slices((x, y, weights))
dataset.shuffle(...)  # Optional.
dataset.batch(batch_size)

देखें Model.fit इनपुट के दो तरीके के बीच equivalences पर जानकारी के लिए प्रलेखन।

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

# Function to convert a DataFrame into a tf.data.Dataset.
def df_to_dataset(dataframe, shuffle=True):
  dataframe = dataframe.copy()
  labels = dataframe.pop('target')
  ds = tf.data.Dataset.from_tensor_slices((dict(dataframe), labels))
  if shuffle:
    ds = ds.shuffle(buffer_size=5000)  # Reasonable but arbitrary buffer_size.
  return ds

# Convert the train DataFrame into a Dataset.
original_train_ds = df_to_dataset(train)

MinDiff डेटा बनाना

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

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

सबसे पहले, मौजूद डेटा की जांच करें।

female_pos = train[(train['sex'] == ' Female') & (train['target'] == 1)]
male_pos = train[(train['sex'] == ' Male') & (train['target'] == 1)]
print(len(female_pos), 'positively labeled female examples')
print(len(male_pos), 'positively labeled male examples')

385 positively labeled female examples
2063 positively labeled male examples

मूल डेटासेट के सबसेट से MinDiff डेटासेट बनाना पूरी तरह से स्वीकार्य है।

जबकि वहाँ 5000 या अधिक सकारात्मक नहीं हैं "Male" उदाहरण के रूप में में सिफारिश की आवश्यकताओं मार्गदर्शन , वहाँ पर 2,000 हैं और इसे और अधिक डेटा इकट्ठा करने से पहले यह है कि कई के साथ प्रयास करने के लिए उचित है।

min_diff_male_ds = df_to_dataset(male_pos)

सकारात्मक "Female" उदाहरण है, तथापि, बहुत ही अधिक दुर्लभ 385 पर यह शायद अच्छे प्रदर्शन के लिए बहुत छोटा है और इसलिए अतिरिक्त उदाहरण में खींच की आवश्यकता होगी रहे हैं।

full_uci_train = tutorials_utils.get_uci_data(split='train')
augmented_female_pos = full_uci_train[((full_uci_train['sex'] == ' Female') &
                                       (full_uci_train['target'] == 1))]
print(len(augmented_female_pos), 'positively labeled female examples')

1179 positively labeled female examples

पूर्ण डेटासेट का उपयोग करने से उन उदाहरणों की संख्या तिगुनी से अधिक हो गई है जिनका उपयोग MinDiff के लिए किया जा सकता है। यह अभी भी कम है लेकिन पहले पास के रूप में प्रयास करने के लिए पर्याप्त है।

min_diff_female_ds = df_to_dataset(augmented_female_pos)

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

का उपयोग करते हुए tf.data.Dataset.filter

वैकल्पिक रूप से, आप परिवर्तित मूल से सीधे दो MinDiff डेटासेट बना सकते हैं Dataset ।

# Male
def male_predicate(x, y):
  return tf.equal(x['sex'], b' Male') and tf.equal(y, 0)

alternate_min_diff_male_ds = original_train_ds.filter(male_predicate).cache()

# Female
def female_predicate(x, y):
  return tf.equal(x['sex'], b' Female') and tf.equal(y, 0)

full_uci_train_ds = df_to_dataset(full_uci_train)
alternate_min_diff_female_ds = full_uci_train_ds.filter(female_predicate).cache()

जिसके परिणामस्वरूप alternate_min_diff_male_ds और alternate_min_diff_female_ds के उत्पादन में बराबर होगी min_diff_male_ds और min_diff_female_ds क्रमशः।

अपने प्रशिक्षण डेटासेट का निर्माण

अंतिम चरण के रूप में, तीन डेटासेट (दो नए बनाए गए और मूल) को एक एकल डेटासेट में मर्ज करने की आवश्यकता होती है जिसे मॉडल में पारित किया जा सकता है।

डेटासेट की बैचिंग

मर्ज करने से पहले, डेटासेट को बैच करना होगा।

  • मूल डेटासेट उसी बैचिंग का उपयोग कर सकता है जिसका उपयोग MinDiff को एकीकृत करने से पहले किया गया था।
  • MinDiff डेटासेट को मूल डेटासेट के समान बैच आकार की आवश्यकता नहीं है। सभी संभावना में, एक छोटा व्यक्ति भी उतना ही अच्छा प्रदर्शन करेगा। जबकि उन्हें एक दूसरे के समान बैच आकार की भी आवश्यकता नहीं है, सर्वोत्तम प्रदर्शन के लिए ऐसा करने की अनुशंसा की जाती है।

जबकि सख्ती से आवश्यक नहीं है, यह उपयोग करने के लिए सिफारिश की है drop_remainder=True यह के रूप में दो MinDiff डेटासेट के लिए यह सुनिश्चित करना होगा कि वे लगातार बैच आकार है।

original_train_ds = original_train_ds.batch(128)  # Same as before MinDiff.

# The MinDiff datasets can have a different batch_size from original_train_ds
min_diff_female_ds = min_diff_female_ds.batch(32, drop_remainder=True)
# Ideally we use the same batch size for both MinDiff datasets.
min_diff_male_ds = min_diff_male_ds.batch(32, drop_remainder=True)

पैकिंग के साथ डेटासेट pack_min_diff_data

एक बार डेटासेट तैयार हो जाने के बाद, उन्हें एक एकल डेटासेट में पैक करें जिसे बाद में मॉडल के साथ पास किया जाएगा। परिणामी डेटासेट के एक बैच में आपके द्वारा पहले तैयार किए गए तीन डेटासेट में से प्रत्येक से एक बैच होगा।

आपके द्वारा दी गई उपयोग करके ऐसा कर सकते हैं utils में समारोह tensorflow_model_remediation पैकेज:

train_with_min_diff_ds = min_diff.keras.utils.pack_min_diff_data(
    original_dataset=original_train_ds,
    sensitive_group_dataset=min_diff_female_ds,
    nonsensitive_group_dataset=min_diff_male_ds)

और बस! आप अन्य उपयोग करने के लिए सक्षम हो जाएगा util यदि आवश्यक हो तो खोल व्यक्ति बैचों के लिए पैकेज में कार्य करता है।

for inputs, original_labels in train_with_min_diff_ds.take(1):
  # Unpacking min_diff_data
  min_diff_data = min_diff.keras.utils.unpack_min_diff_data(inputs)
  min_diff_examples, min_diff_membership = min_diff_data
  # Unpacking original data
  original_inputs = min_diff.keras.utils.unpack_original_inputs(inputs)

अपने नवगठित डेटा के साथ, अब आप अपने मॉडल में MinDiff लागू करने के लिए तैयार हैं! यह कैसे किया जाता जानने के लिए कृपया के साथ शुरू अन्य गाइड पर एक नज़र डालें MinDiffModel साथ MinDiff का घालमेल ।

कस्टम पैकिंग प्रारूप का उपयोग करना (वैकल्पिक)

आप जिस भी तरीके से चुनते हैं, आप तीन डेटासेट को एक साथ पैक करने का निर्णय ले सकते हैं। केवल आवश्यकता यह है कि आपको यह सुनिश्चित करने की आवश्यकता होगी कि मॉडल डेटा की व्याख्या करना जानता है। के डिफ़ॉल्ट कार्यान्वयन MinDiffModel मानता है कि डेटा का उपयोग कर भरा हुआ था min_diff.keras.utils.pack_min_diff_data ।

एक आसान तरीका के रूप में आप चाहते हैं अपने इनपुट फ़ॉर्मेट करने के लिए आप का इस्तेमाल किया है के बाद एक अंतिम कदम के रूप में डेटा को बदलने के लिए है min_diff.keras.utils.pack_min_diff_data ।

# Reformat input to be a dict.
def _reformat_input(inputs, original_labels):
  unpacked_min_diff_data = min_diff.keras.utils.unpack_min_diff_data(inputs)
  unpacked_original_inputs = min_diff.keras.utils.unpack_original_inputs(inputs)

  return {
      'min_diff_data': unpacked_min_diff_data,
      'original_data': (unpacked_original_inputs, original_labels)}

customized_train_with_min_diff_ds = train_with_min_diff_ds.map(_reformat_input)

आपका मॉडल पता करने के लिए के रूप में में विस्तृत यह कैसे अनुकूलित इनपुट को पढ़ने के लिए की आवश्यकता होगी अनुकूलित MinDiffModel गाइड ।

for batch in customized_train_with_min_diff_ds.take(1):
  # Customized unpacking of min_diff_data
  min_diff_data = batch['min_diff_data']
  # Customized unpacking of original_data
  original_data = batch['original_data']

अतिरिक्त संसाधन

यह मार्गदर्शिका उस प्रक्रिया और निर्णय लेने की रूपरेखा बताती है जिसे आप MinDiff को लागू करते समय अपना सकते हैं। बाकी गाइड इस ढांचे का निर्माण करते हैं। इसे आसान बनाने के लिए, इस गाइड में पाए गए तर्क को सहायक कार्यों में शामिल किया गया है:

  • get_uci_data : इस समारोह को पहले से ही इस गाइड में प्रयोग किया जाता है। यह एक रिटर्न DataFrame संकेत विभाजन से यूसीआई आय डेटा जो कुछ भी दर (100% अगर अनिर्दिष्ट) इंगित किया गया है पर नमूना हैं।
  • df_to_dataset : यह समारोह एक धर्मान्तरित DataFrame एक में tf.data.Dataset एक पैरामीटर के रूप batch_size पारित करने के लिए सक्षम होने के अतिरिक्त कार्यक्षमता के साथ इस मार्गदर्शिका में वर्णित के रूप में।
  • get_uci_with_min_diff_dataset : इस समारोह रिटर्न एक tf.data.Dataset दोनों मूल डेटा और MinDiff डेटा वाली एक साथ इस मार्गदर्शिका में बताए अनुसार कार्यों util मॉडल उपचार लाइब्रेरी का उपयोग पैक।

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