Google I/O में ट्यूनिंग के लिए धन्यवाद। मांग पर सभी सत्र देखें मांग पर देखें

CelebA डेटासेट का उपयोग करके TensorFlow विवश अनुकूलन उदाहरण

TensorFlow.org पर देखें Google Colab में चलाएं गिटहब पर देखें नोटबुक डाउनलोड करें

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

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

अंतिम अद्यतन: 3/11 फ़रवरी 2020

इंस्टालेशन

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

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

पिप इंस्टाल

ध्यान दें कि जब आप नीचे सेल चलाते हैं, तो आपको कोलाब में TensorFlow के डिफ़ॉल्ट संस्करण के बारे में जल्द ही TensorFlow 2.X पर स्विच करने के बारे में एक चेतावनी प्राप्त हो सकती है। आप उस चेतावनी को सुरक्षित रूप से अनदेखा कर सकते हैं क्योंकि इस नोटबुक को TensorFlow 1.X और 2.X के साथ संगत होने के लिए डिज़ाइन किया गया था।

आयात मॉड्यूल

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

हालांकि TFCO उत्सुक और ग्राफ निष्पादन के साथ संगत है, यह नोटबुक मानता है कि उत्सुक निष्पादन डिफ़ॉल्ट रूप से सक्षम है क्योंकि यह TensorFlow 2.x में है। यह सुनिश्चित करने के लिए कि कुछ भी टूट न जाए, नीचे दिए गए सेल में उत्सुक निष्पादन सक्षम किया जाएगा।

उत्सुक निष्पादन और प्रिंट संस्करण सक्षम करें

Eager execution enabled by default.
TensorFlow 2.8.0-rc0
TFMA 0.36.0
TFDS 4.4.0
FI 0.36.0

सेलेबा डेटासेट

CelebA एक बड़े पैमाने पर चेहरे 200,000 से अधिक सेलिब्रिटी छवियों, 40 विशेषता एनोटेशन और 5 मील का पत्थर स्थानों (आंख, मुंह और नाक पदों) (जैसे बाल प्रकार, फैशन के सामान, चेहरे की विशेषताओं, आदि) के साथ एक साथ डाटासेट गुण है। अधिक जानकारी के लिए पर एक नज़र डालें कागज । मालिकों की अनुमति के साथ, हम Google क्लाउड मेमोरी पर इस डेटासेट संग्रहीत किया है और ज्यादातर द्वारा ही पहुंच TensorFlow डेटासेट ( tfds )

इस नोटबुक में:

  • के रूप में "मुस्कुरा" विशेषता * द्वारा प्रतिनिधित्व हमारे मॉडल, वर्गीकृत करने के लिए छवि के विषय मुस्कुरा रहा है कि क्या प्रयास करेंगे।
  • प्रशिक्षण के दौरान निष्पादन समय और स्मृति को कम करने के लिए छवियों को 218x178 से 28x28 तक आकार दिया जाएगा।
  • बाइनरी "यंग" विशेषता का उपयोग करते हुए, हमारे मॉडल के प्रदर्शन का मूल्यांकन सभी आयु समूहों में किया जाएगा। हम इस "आयु वर्ग" को इस नोटबुक में बुलाएंगे।

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

gcs_base_dir = "gs://celeb_a_dataset/"
celeb_a_builder = tfds.builder("celeb_a", data_dir=gcs_base_dir, version='2.0.0')

celeb_a_builder.download_and_prepare()

num_test_shards_dict = {'0.3.0': 4, '2.0.0': 2} # Used because we download the test dataset separately
version = str(celeb_a_builder.info.version)
print('Celeb_A dataset version: %s' % version)
Celeb_A dataset version: 2.0.0

परीक्षण डेटासेट सहायक कार्य

चेतावनियां

आगे बढ़ने से पहले, CelebA का उपयोग करते समय कई बातों को ध्यान में रखना चाहिए:

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

इनपुट फ़ंक्शंस सेट करना

बाद के सेल इनपुट पाइपलाइन को सुव्यवस्थित करने के साथ-साथ प्रदर्शन की कल्पना करने में मदद करेंगे।

पहले हम कुछ डेटा-संबंधित चर परिभाषित करते हैं और एक अपेक्षित प्रीप्रोसेसिंग फ़ंक्शन को परिभाषित करते हैं।

चर परिभाषित करें

प्रीप्रोसेसिंग कार्यों को परिभाषित करें

फिर, हम बाकी कोलाब में आवश्यक डेटा फ़ंक्शन तैयार करते हैं।

# Train data returning either 2 or 3 elements (the third element being the group)
def celeb_a_train_data_wo_group(batch_size):
  celeb_a_train_data = celeb_a_builder.as_dataset(split='train').shuffle(1024).repeat().batch(batch_size).map(preprocess_input_dict)
  return celeb_a_train_data.map(get_image_and_label)
def celeb_a_train_data_w_group(batch_size):
  celeb_a_train_data = celeb_a_builder.as_dataset(split='train').shuffle(1024).repeat().batch(batch_size).map(preprocess_input_dict)
  return celeb_a_train_data.map(get_image_label_and_group)

# Test data for the overall evaluation
celeb_a_test_data = celeb_a_builder.as_dataset(split='test').batch(1).map(preprocess_input_dict).map(get_image_label_and_group)
# Copy test data locally to be able to read it into tfma
copy_test_files_to_local()

एक साधारण डीएनएन मॉडल बनाएं

क्योंकि इस नोटबुक TFCO पर केंद्रित है, हम एक सरल, स्वेच्छापूर्ण इकट्ठा होगा tf.keras.Sequential मॉडल।

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

def create_model():
  # For this notebook, accuracy will be used to evaluate performance.
  METRICS = [
    tf.keras.metrics.BinaryAccuracy(name='accuracy')
  ]

  # The model consists of:
  # 1. An input layer that represents the 28x28x3 image flatten.
  # 2. A fully connected layer with 64 units activated by a ReLU function.
  # 3. A single-unit readout layer to output real-scores instead of probabilities.
  model = keras.Sequential([
      keras.layers.Flatten(input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3), name='image'),
      keras.layers.Dense(64, activation='relu'),
      keras.layers.Dense(1, activation=None)
  ])

  # TFCO by default uses hinge loss — and that will also be used in the model.
  model.compile(
      optimizer=tf.keras.optimizers.Adam(0.001),
      loss='hinge',
      metrics=METRICS)
  return model

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

def set_seeds():
  np.random.seed(121212)
  tf.compat.v1.set_random_seed(212121)

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

अपने मॉडल को प्रशिक्षित करने से पहले, हम कई सहायक कार्यों को परिभाषित करते हैं जो हमें निष्पक्षता संकेतकों के माध्यम से मॉडल के प्रदर्शन का मूल्यांकन करने की अनुमति देंगे।

सबसे पहले, हम अपने मॉडल को प्रशिक्षित करने के बाद उसे बचाने के लिए एक सहायक फ़ंक्शन बनाते हैं।

def save_model(model, subdir):
  base_dir = tempfile.mkdtemp(prefix='saved_models')
  model_location = os.path.join(base_dir, subdir)
  model.save(model_location, save_format='tf')
  return model_location

इसके बाद, हम डेटा को प्रीप्रोसेस करने के लिए उपयोग किए जाने वाले कार्यों को परिभाषित करते हैं ताकि इसे टीएफएमए के माध्यम से सही ढंग से पारित किया जा सके।

के लिए डेटा प्रीप्रोसेसिंग कार्य

अंत में, हम एक फ़ंक्शन को परिभाषित करते हैं जो TFMA में परिणामों का मूल्यांकन करता है।

def get_eval_results(model_location, eval_subdir):
  base_dir = tempfile.mkdtemp(prefix='saved_eval_results')
  tfma_eval_result_path = os.path.join(base_dir, eval_subdir)

  eval_config_pbtxt = """
        model_specs {
          label_key: "%s"
        }
        metrics_specs {
          metrics {
            class_name: "FairnessIndicators"
            config: '{ "thresholds": [0.22, 0.5, 0.75] }'
          }
          metrics {
            class_name: "ExampleCount"
          }
        }
        slicing_specs {}
        slicing_specs { feature_keys: "%s" }
        options {
          compute_confidence_intervals { value: False }
          disabled_outputs{values: "analysis"}
        }
      """ % (LABEL_KEY, GROUP_KEY)

  eval_config = text_format.Parse(eval_config_pbtxt, tfma.EvalConfig())

  eval_shared_model = tfma.default_eval_shared_model(
        eval_saved_model_path=model_location, tags=[tf.saved_model.SERVING])

  schema_pbtxt = """
        tensor_representation_group {
          key: ""
          value {
            tensor_representation {
              key: "%s"
              value {
                dense_tensor {
                  column_name: "%s"
                  shape {
                    dim { size: 28 }
                    dim { size: 28 }
                    dim { size: 3 }
                  }
                }
              }
            }
          }
        }
        feature {
          name: "%s"
          type: FLOAT
        }
        feature {
          name: "%s"
          type: FLOAT
        }
        feature {
          name: "%s"
          type: BYTES
        }
        """ % (IMAGE_KEY, IMAGE_KEY, IMAGE_KEY, LABEL_KEY, GROUP_KEY)
  schema = text_format.Parse(schema_pbtxt, schema_pb2.Schema())
  coder = tf_example_record.TFExampleBeamRecord(
      physical_format='inmem', schema=schema,
      raw_record_column_name=tfma.ARROW_INPUT_COLUMN)
  tensor_adapter_config = tensor_adapter.TensorAdapterConfig(
    arrow_schema=coder.ArrowSchema(),
    tensor_representations=coder.TensorRepresentations())
  # Run the fairness evaluation.
  with beam.Pipeline() as pipeline:
    _ = (
          tfds_as_pcollection(pipeline, 'celeb_a', 'test')
          | 'ExamplesToRecordBatch' >> coder.BeamSource()
          | 'ExtractEvaluateAndWriteResults' >>
          tfma.ExtractEvaluateAndWriteResults(
              eval_config=eval_config,
              eval_shared_model=eval_shared_model,
              output_path=tfma_eval_result_path,
              tensor_adapter_config=tensor_adapter_config)
    )
  return tfma.load_eval_result(output_path=tfma_eval_result_path)

ट्रेन और मूल्यांकन अप्रतिबंधित मॉडल

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

ध्यान दें कि TensorFlow में इस नोटबुक <2.0.0 चलाने के लिए एक प्रतिवाद चेतावनी में हो सकता है np.where । सुरक्षित रूप से इस चेतावनी को अनदेखा रूप TensorFlow का उपयोग करके 2.x में इस पते, tf.where के स्थान पर np.where

BATCH_SIZE = 32

# Set seeds to get reproducible results
set_seeds()

model_unconstrained = create_model()
model_unconstrained.fit(celeb_a_train_data_wo_group(BATCH_SIZE), epochs=5, steps_per_epoch=1000)
Epoch 1/5
1000/1000 [==============================] - 12s 6ms/step - loss: 0.5038 - accuracy: 0.7733
Epoch 2/5
1000/1000 [==============================] - 7s 7ms/step - loss: 0.3800 - accuracy: 0.8301
Epoch 3/5
1000/1000 [==============================] - 6s 6ms/step - loss: 0.3598 - accuracy: 0.8427
Epoch 4/5
1000/1000 [==============================] - 25s 25ms/step - loss: 0.3435 - accuracy: 0.8474
Epoch 5/5
1000/1000 [==============================] - 5s 5ms/step - loss: 0.3402 - accuracy: 0.8479
<keras.callbacks.History at 0x7f0f5c476350>

परीक्षण डेटा पर मॉडल का मूल्यांकन करने से अंतिम सटीकता स्कोर केवल 85% से अधिक होना चाहिए। बिना फाइन ट्यूनिंग वाले साधारण मॉडल के लिए बुरा नहीं है।

print('Overall Results, Unconstrained')
celeb_a_test_data = celeb_a_builder.as_dataset(split='test').batch(1).map(preprocess_input_dict).map(get_image_label_and_group)
results = model_unconstrained.evaluate(celeb_a_test_data)
Overall Results, Unconstrained
19962/19962 [==============================] - 50s 2ms/step - loss: 0.2125 - accuracy: 0.8636

हालांकि, विभिन्न आयु समूहों के प्रदर्शन का मूल्यांकन कुछ कमियों को प्रकट कर सकता है।

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

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

model_location = save_model(model_unconstrained, 'model_export_unconstrained')
eval_results_unconstrained = get_eval_results(model_location, 'eval_results_unconstrained')
2022-01-07 18:46:05.881112: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: /tmp/saved_modelswhxcqdry/model_export_unconstrained/assets
INFO:tensorflow:Assets written to: /tmp/saved_modelswhxcqdry/model_export_unconstrained/assets
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:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
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:107: 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:107: 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)`

जैसा कि ऊपर उल्लेख किया गया है, हम झूठी सकारात्मक दर पर ध्यान केंद्रित कर रहे हैं। निष्पक्षता संकेतकों का वर्तमान संस्करण (0.1.2) डिफ़ॉल्ट रूप से झूठी नकारात्मक दर का चयन करता है। नीचे दी गई लाइन को चलाने के बाद, हम जिस मीट्रिक में रुचि रखते हैं उसे देखने के लिए false_negative_rate को अचयनित करें और false_positive_rate को चुनें।

tfma.addons.fairness.view.widget_view.render_fairness_indicator(eval_results_unconstrained)
FairnessIndicatorViewer(slicingMetrics=[{'sliceValue': 'Young', 'slice': 'Young:Young', 'metrics': {'example_c…

परिणामों में दिखाया रूप में, हम "युवा" और "नहीं यंग" श्रेणियों के बीच की खाई को आय से अधिक दिख रहा है।

यह वह जगह है जहां टीएफसीओ झूठी सकारात्मक दर को अधिक स्वीकार्य मानदंड के भीतर रखने में मदद कर सकता है।

विवश मॉडल सेट अप

के रूप में में दर्ज TFCO के पुस्तकालय , वहाँ कई सहायकों कि यह आसान समस्या विवश करने के लिए कर देगा कर रहे हैं:

  1. tfco.rate_context() - यह क्या हर आयु वर्ग श्रेणी के लिए एक बाधा के निर्माण में इस्तेमाल किया जाएगा।
  2. tfco.RateMinimizationProblem() - दर अभिव्यक्ति यहाँ कम से कम करने के आयु वर्ग के लिए झूठी सकारात्मक दर अधीन होगा। दूसरे शब्दों में, अब प्रदर्शन का मूल्यांकन आयु समूह की झूठी सकारात्मक दरों और समग्र डेटासेट के अंतर के आधार पर किया जाएगा। इस प्रदर्शन के लिए, 5% से कम या उसके बराबर की झूठी सकारात्मक दर को बाधा के रूप में निर्धारित किया जाएगा।
  3. tfco.ProxyLagrangianOptimizerV2() - यह सहायक है कि वास्तव में दर बाधा समस्या का समाधान होगा है।

नीचे दिया गया सेल निष्पक्षता की कमी के साथ मॉडल प्रशिक्षण स्थापित करने के लिए इन सहायकों को बुलाएगा।

# The batch size is needed to create the input, labels and group tensors.
# These tensors are initialized with all 0's. They will eventually be assigned
# the batch content to them. A large batch size is chosen so that there are
# enough number of "Young" and "Not Young" examples in each batch.
set_seeds()
model_constrained = create_model()
BATCH_SIZE = 32

# Create input tensor.
input_tensor = tf.Variable(
    np.zeros((BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 3), dtype="float32"),
    name="input")

# Create labels and group tensors (assuming both labels and groups are binary).
labels_tensor = tf.Variable(
    np.zeros(BATCH_SIZE, dtype="float32"), name="labels")
groups_tensor = tf.Variable(
    np.zeros(BATCH_SIZE, dtype="float32"), name="groups")

# Create a function that returns the applied 'model' to the input tensor
# and generates constrained predictions.
def predictions():
  return model_constrained(input_tensor)

# Create overall context and subsetted context.
# The subsetted context contains subset of examples where group attribute < 1
# (i.e. the subset of "Not Young" celebrity images).
# "groups_tensor < 1" is used instead of "groups_tensor == 0" as the former
# would be a comparison on the tensor value, while the latter would be a
# comparison on the Tensor object.
context = tfco.rate_context(predictions, labels=lambda:labels_tensor)
context_subset = context.subset(lambda:groups_tensor < 1)

# Setup list of constraints.
# In this notebook, the constraint will just be: FPR to less or equal to 5%.
constraints = [tfco.false_positive_rate(context_subset) <= 0.05]

# Setup rate minimization problem: minimize overall error rate s.t. constraints.
problem = tfco.RateMinimizationProblem(tfco.error_rate(context), constraints)

# Create constrained optimizer and obtain train_op.
# Separate optimizers are specified for the objective and constraints
optimizer = tfco.ProxyLagrangianOptimizerV2(
      optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
      constraint_optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
      num_constraints=problem.num_constraints)

# A list of all trainable variables is also needed to use TFCO.
var_list = (model_constrained.trainable_weights + list(problem.trainable_variables) +
            optimizer.trainable_variables())

मॉडल अब स्थापित किया गया है और पूरे आयु वर्ग में झूठी सकारात्मक दर की कमी के साथ प्रशिक्षित होने के लिए तैयार है।

अब, क्योंकि कंस्ट्रेन्ड मॉडल के अंतिम यात्रा जरूरी परिभाषित बाधा के मामले में सबसे अच्छा प्रदर्शन मॉडल नहीं हो सकता है, TFCO पुस्तकालय से सुसज्जित है tfco.find_best_candidate_index() कि कर सकते हैं मदद के लिए सबसे अच्छा पुनरावृति लोगों में से चुनने के प्रत्येक के बाद पाया युग के बारे में सोचो tfco.find_best_candidate_index() एक अतिरिक्त अनुमानी कि अलग से प्रशिक्षण डेटा के संबंध में सटीकता और निष्पक्षता बाधा (इस मामले में, आयु वर्ग के पार झूठी सकारात्मक दर) के आधार पर परिणामों में से प्रत्येक में शुमार है के रूप में। इस तरह, यह समग्र सटीकता और निष्पक्षता बाधा के बीच बेहतर व्यापार-बंद की खोज कर सकता है।

निम्नलिखित सेल बाधाओं के साथ प्रशिक्षण शुरू करेंगे जबकि प्रति पुनरावृत्ति सर्वश्रेष्ठ प्रदर्शन करने वाले मॉडल को भी ढूंढेंगे।

# Obtain train set batches.

NUM_ITERATIONS = 100  # Number of training iterations.
SKIP_ITERATIONS = 10  # Print training stats once in this many iterations.

# Create temp directory for saving snapshots of models.
temp_directory = tempfile.mktemp()
os.mkdir(temp_directory)

# List of objective and constraints across iterations.
objective_list = []
violations_list = []

# Training iterations.
iteration_count = 0
for (image, label, group) in celeb_a_train_data_w_group(BATCH_SIZE):
  # Assign current batch to input, labels and groups tensors.
  input_tensor.assign(image)
  labels_tensor.assign(label)
  groups_tensor.assign(group)

  # Run gradient update.
  optimizer.minimize(problem, var_list=var_list)

  # Record objective and violations.
  objective = problem.objective()
  violations = problem.constraints()

  sys.stdout.write(
      "\r Iteration %d: Hinge Loss = %.3f, Max. Constraint Violation = %.3f"
      % (iteration_count + 1, objective, max(violations)))

  # Snapshot model once in SKIP_ITERATIONS iterations.
  if iteration_count % SKIP_ITERATIONS == 0:
    objective_list.append(objective)
    violations_list.append(violations)

    # Save snapshot of model weights.
    model_constrained.save_weights(
        temp_directory + "/celeb_a_constrained_" +
        str(iteration_count / SKIP_ITERATIONS) + ".h5")

  iteration_count += 1
  if iteration_count >= NUM_ITERATIONS:
    break

# Choose best model from recorded iterates and load that model.
best_index = tfco.find_best_candidate_index(
    np.array(objective_list), np.array(violations_list))

model_constrained.load_weights(
    temp_directory + "/celeb_a_constrained_" + str(best_index) + ".0.h5")

# Remove temp directory.
os.system("rm -r " + temp_directory)
Iteration 100: Hinge Loss = 0.614, Max. Constraint Violation = 0.268
0

बाधा लागू करने के बाद, हम निष्पक्षता संकेतकों का उपयोग करके एक बार फिर परिणामों का मूल्यांकन करते हैं।

model_location = save_model(model_constrained, 'model_export_constrained')
eval_result_constrained = get_eval_results(model_location, 'eval_results_constrained')
INFO:tensorflow:Assets written to: /tmp/saved_modelsbztxt9fy/model_export_constrained/assets
INFO:tensorflow:Assets written to: /tmp/saved_modelsbztxt9fy/model_export_constrained/assets
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.

पिछली बार की तरह हमने फेयरनेस इंडिकेटर का इस्तेमाल किया, जिस मीट्रिक में हम रुचि रखते हैं उसे देखने के लिए false_negative_rate को अचयनित करें और false_positive_rate का चयन करें।

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

eval_results_dict = {
    'constrained': eval_result_constrained,
    'unconstrained': eval_results_unconstrained,
}
tfma.addons.fairness.view.widget_view.render_fairness_indicator(multi_eval_results=eval_results_dict)
FairnessIndicatorViewer(evalName='constrained', evalNameCompare='unconstrained', slicingMetrics=[{'sliceValue'…

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