MinDiffModel के साथ MinDiff को एकीकृत करना

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

परिचय

आपके मॉडल में MinDiff को एकीकृत करने के दो चरण हैं:

  1. डेटा (में शामिल तैयार इनपुट तैयारी गाइड )।

  2. प्रशिक्षण के दौरान MinDiff को एकीकृत करने वाला मॉडल बदलें या बनाएं।

का उपयोग करते हुए: इस गाइड दूसरा चरण पूरा करने के लिए सबसे आसान तरीका है को कवर किया जाएगा MinDiffModel ।

सेट अप

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

import tensorflow as tf
tf.get_logger().setLevel('ERROR')  # Avoid TF warnings.
from tensorflow_model_remediation import min_diff
from tensorflow_model_remediation.tools.tutorials_utils import uci as tutorials_utils

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

# Original DataFrame for training, sampled at 0.3 for reduced runtimes.
train_df = tutorials_utils.get_uci_data(split='train', sample=0.3)

# Dataset needed to train with MinDiff.
train_with_min_diff_ds = (
    tutorials_utils.get_uci_with_min_diff_dataset(split='train', sample=0.3))

मूल मॉडल

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

चूंकि MinDiffModel सबसे Keras साथ काम करने के लिए डिज़ाइन किया गया है Model : कक्षाएं, हम एक सहायक समारोह में मॉडल के निर्माण के तर्क बाहर कारक है get_uci_model ।

पंडों के डेटाफ़्रेम के साथ प्रशिक्षण

यह मार्गदर्शिका गति के लिए एकल युग में प्रशिक्षण देती है, लेकिन युगों की संख्या में वृद्धि करके मॉडल के प्रदर्शन में आसानी से सुधार कर सकती है।

model = tutorials_utils.get_uci_model()

model.compile(optimizer='adam', loss='binary_crossentropy')

df_without_target = train_df.drop(['target'], axis=1)  # Drop 'target' for x.
_ = model.fit(
    x=dict(df_without_target),  # The model expects a dictionary of features.
    y=train_df['target'],
    batch_size=128,
    epochs=1)

77/77 [==============================] - 3s 23ms/step - loss: 0.8589

एक साथ प्रशिक्षण tf.data.Dataset

एक साथ बराबर प्रशिक्षण tf.data.Dataset बहुत समान विचार करेंगे (हालांकि प्रारंभ और इनपुट अनियमितता थोड़ा अलग परिणाम हो सकते हैं)।

model = tutorials_utils.get_uci_model()

model.compile(optimizer='adam', loss='binary_crossentropy')

_ = model.fit(
    tutorials_utils.df_to_dataset(train_df, batch_size=128),  # Converted to Dataset.
    epochs=1)

77/77 [==============================] - 3s 23ms/step - loss: 0.6416

प्रशिक्षण के लिए मिनडिफ को एकीकृत करना

डेटा तैयार हो जाने के बाद, निम्न चरणों के साथ अपने मॉडल पर MinDiff लागू करें:

  1. मूल मॉडल बनाएं जैसा कि आप MinDiff के बिना करेंगे।
original_model = tutorials_utils.get_uci_model()
  1. एक में लपेट MinDiffModel ।
min_diff_model = min_diff.keras.MinDiffModel(
    original_model=original_model,
    loss=min_diff.losses.MMDLoss(),
    loss_weight=1)
  1. इसे वैसे ही संकलित करें जैसे आप MinDiff के बिना करेंगे।
min_diff_model.compile(optimizer='adam', loss='binary_crossentropy')
  1. MinDiff डाटासेट (साथ यह ट्रेन train_with_min_diff_ds इस मामले में)।
_ = min_diff_model.fit(train_with_min_diff_ds, epochs=1)

77/77 [==============================] - 6s 31ms/step - loss: 0.7883 - min_diff_loss: 0.0379

मूल्यांकन और साथ भविष्यवाणी MinDiffModel

मूल्यांकन और एक साथ की भविष्यवाणी दोनों MinDiffModel मूल मॉडल के साथ ऐसा करने के समान हैं।

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

जब बुला evaluate आप या तो मूल डाटासेट या MinDiff डेटा वाली एक में पारित कर सकते हैं। यदि आप मूल्यांकन करने के लिए कॉल में MinDiff को शामिल करते हैं, तो दो चीज़ें भिन्न होंगी:

  • एक अतिरिक्त नामक मीट्रिक min_diff_loss उत्पादन में मौजूद रहेंगे।
  • का मान loss मीट्रिक मूल का योग होगा loss मीट्रिक (उत्पादन में नहीं दिखाया गया है) और min_diff_loss ।
_ = min_diff_model.evaluate(
    tutorials_utils.df_to_dataset(train_df, batch_size=128))
# Calling with MinDiff data will include min_diff_loss in metrics.
_ = min_diff_model.evaluate(train_with_min_diff_ds)

77/77 [==============================] - 2s 22ms/step - loss: 0.4638
77/77 [==============================] - 3s 32ms/step - loss: 0.5087 - min_diff_loss: 0.0451

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

_ = min_diff_model.predict(
    tutorials_utils.df_to_dataset(train_df, batch_size=128))
_ = min_diff_model.predict(train_with_min_diff_ds)  # Identical to results above.

का उपयोग कर की सीमाएं MinDiffModel सीधे

का उपयोग करते समय MinDiffModel जैसा कि ऊपर वर्णित है, सबसे अधिक तरीकों में से डिफ़ॉल्ट कार्यान्वयन का उपयोग करेगा tf.keras.Model (में सूचीबद्ध अपवाद API दस्तावेज़ )।

print('MinDiffModel.fit == keras.Model.fit')
print(min_diff.keras.MinDiffModel.fit == tf.keras.Model.fit)
print('MinDiffModel.train_step == keras.Model.train_step')
print(min_diff.keras.MinDiffModel.train_step == tf.keras.Model.train_step)

MinDiffModel.fit == keras.Model.fit
True
MinDiffModel.train_step == keras.Model.train_step
True

के लिए keras.Sequential या keras.Model , इस बिल्कुल ठीक है क्योंकि वे एक ही कार्यों का उपयोग है।

print('Sequential.fit == keras.Model.fit')
print(tf.keras.Sequential.fit == tf.keras.Model.fit)
print('tf.keras.Sequential.train_step == keras.Model.train_step')
print(tf.keras.Sequential.train_step == tf.keras.Model.train_step)

Sequential.fit == keras.Model.fit
True
tf.keras.Sequential.train_step == keras.Model.train_step
True

हालांकि, अगर आपका मॉडल एक है के उपवर्ग keras.Model , के साथ लपेटकर MinDiffModel प्रभावी रूप से अनुकूलन खो देंगे।

class CustomModel(tf.keras.Model):

  def train_step(self, **kwargs):
    pass  # Custom implementation.

print('CustomModel.train_step == keras.Model.train_step')
print(CustomModel.train_step == tf.keras.Model.train_step)

CustomModel.train_step == keras.Model.train_step
False

इस आपके उपयोग के मामले है, तो आप उपयोग नहीं करना चाहिए MinDiffModel सीधे। इसके बजाय, आप में वर्णित के रूप में यह उपवर्ग करने की आवश्यकता होगी अनुकूलन गाइड ।

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