Contoh Optimasi Terkendala TensorFlow Menggunakan Dataset CelebA

Lihat di TensorFlow.org Jalankan di Google Colab Lihat di GitHub Unduh buku catatan

Notebook ini menunjukkan cara mudah untuk membuat dan mengoptimalkan masalah terbatas menggunakan perpustakaan TFCO. Metode ini dapat berguna dalam meningkatkan model ketika kita menemukan bahwa mereka tidak melakukan sama dengan baik di seluruh irisan yang berbeda dari data kami, yang kami dapat mengidentifikasi menggunakan Keadilan Indikator . Prinsip AI Google yang kedua menyatakan bahwa teknologi kami harus menghindari menciptakan atau memperkuat bias yang tidak adil, dan kami yakin teknik ini dapat membantu meningkatkan keadilan model dalam beberapa situasi. Secara khusus, notebook ini akan:

  • Melatih sederhana, model jaringan saraf tak terbatas untuk mendeteksi senyum seseorang dalam gambar menggunakan tf.keras dan CelebFaces skala besar Atribut ( CelebA ) dataset.
  • Evaluasi kinerja model terhadap metrik keadilan yang umum digunakan di seluruh kelompok usia, menggunakan Indikator Kewajaran.
  • Siapkan masalah pengoptimalan terbatas sederhana untuk mencapai kinerja yang lebih adil di seluruh kelompok usia.
  • Melatih model sekarang dibatasi dan mengevaluasi kinerja lagi, memastikan bahwa yang dipilih keadilan metrik kami telah meningkat.

Terakhir diperbarui: 3/11 Februari 2020

Instalasi

Notebook ini diciptakan pada Colaboratory , terhubung ke Python 3 Mesin Hitung Google backend. Jika Anda ingin menghosting notebook ini di lingkungan yang berbeda, maka Anda tidak akan mengalami masalah besar apa pun asalkan Anda menyertakan semua paket yang diperlukan dalam sel di bawah ini.

Perhatikan bahwa pertama kali Anda menjalankan instalasi pip, Anda mungkin diminta untuk memulai ulang runtime karena paket-paket yang sudah kedaluwarsa. Setelah Anda melakukannya, paket yang benar akan digunakan.

Pemasangan pip

Perhatikan bahwa bergantung pada waktu Anda menjalankan sel di bawah ini, Anda mungkin menerima peringatan tentang versi default TensorFlow di Colab yang akan segera beralih ke TensorFlow 2.X. Anda dapat mengabaikan peringatan tersebut dengan aman karena notebook ini dirancang agar kompatibel dengan TensorFlow 1.X dan 2.X.

Impor Modul

Selain itu, kami menambahkan beberapa impor yang khusus untuk Indikator Kewajaran yang akan kami gunakan untuk mengevaluasi dan memvisualisasikan kinerja model.

Meskipun TFCO kompatibel dengan eksekusi bersemangat dan grafik, notebook ini mengasumsikan bahwa eksekusi bersemangat diaktifkan secara default seperti di TensorFlow 2.x. Untuk memastikan tidak ada yang rusak, eksekusi bersemangat akan diaktifkan di sel di bawah ini.

Aktifkan Eksekusi Bersemangat dan Versi Cetak

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

Kumpulan Data CelebA

CelebA adalah wajah skala besar atribut dataset dengan lebih dari 200.000 gambar selebriti, masing-masing dengan 40 penjelasan atribut (seperti jenis rambut, aksesoris fashion, fitur wajah, dll) dan lokasi 5 tengara (mata, mulut dan posisi hidung). Untuk lebih jelasnya lihat kertas . Dengan izin dari pemilik, kami telah disimpan dataset ini di Google Cloud Storage dan sebagian besar mengaksesnya melalui TensorFlow dataset ( tfds ) .

Dalam buku catatan ini:

  • Model kami akan mencoba untuk mengklasifikasikan apakah subjek gambar tersenyum, yang diwakili oleh "Tersenyum" atribut *.
  • Gambar akan diubah ukurannya dari 218x178 menjadi 28x28 untuk mengurangi waktu eksekusi dan memori saat pelatihan.
  • Performa model kami akan dievaluasi di seluruh kelompok usia, menggunakan atribut biner "Muda". Kami akan menyebutnya "kelompok usia" di buku catatan ini.

* Meskipun ada sedikit informasi yang tersedia tentang metodologi pelabelan untuk dataset ini, kita akan mengasumsikan bahwa "Tersenyum" atribut ditentukan oleh senang, ekspresi baik, atau geli di wajah subjek. Untuk tujuan studi kasus ini, kami akan mengambil label ini sebagai kebenaran dasar.

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

Uji fungsi pembantu set data

Peringatan

Sebelum melangkah maju, ada beberapa pertimbangan yang perlu diingat dalam menggunakan CelebA:

  • Meskipun pada prinsipnya notebook ini dapat menggunakan dataset gambar wajah apa pun, CelebA dipilih karena berisi gambar domain publik dari tokoh masyarakat.
  • Semua anotasi atribut di CelebA dioperasionalkan sebagai kategori biner. Misalnya, atribut "Muda" (sebagaimana ditentukan oleh pemberi label kumpulan data) dilambangkan sebagai ada atau tidak ada dalam gambar.
  • Kategorisasi CelebA tidak mencerminkan keragaman atribut manusia yang sebenarnya.
  • Untuk keperluan notebook ini, fitur yang berisi atribut "Muda" disebut sebagai "kelompok usia", di mana keberadaan atribut "Muda" dalam gambar diberi label sebagai anggota kelompok usia "Muda" dan tidak adanya atribut "Muda" dicap sebagai anggota kelompok usia "Tidak Muda". Ini adalah asumsi yang dibuat karena informasi ini tidak disebutkan dalam kertas asli .
  • Dengan demikian, performa dalam model yang dilatih dalam notebook ini terkait dengan cara atribut dioperasionalkan dan dijelaskan oleh penulis CelebA.
  • Model ini tidak boleh digunakan untuk tujuan komersial yang akan melanggar perjanjian penelitian non-komersial CelebA ini .

Menyiapkan Fungsi Input

Sel-sel berikutnya akan membantu merampingkan saluran input serta memvisualisasikan kinerja.

Pertama kita mendefinisikan beberapa variabel terkait data dan mendefinisikan fungsi pra-pemrosesan yang diperlukan.

Tentukan Variabel

Tentukan Fungsi Prapemrosesan

Kemudian, kita membangun fungsi data yang kita butuhkan di sisa colab.

# 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()

Buat Model DNN sederhana

Karena notebook ini berfokus pada TFCO, kita akan merakit sederhana, tidak dibatasi tf.keras.Sequential Model.

Kami mungkin dapat sangat meningkatkan kinerja model dengan menambahkan beberapa kompleksitas (misalnya, lapisan yang terhubung lebih padat, menjelajahi fungsi aktivasi yang berbeda, meningkatkan ukuran gambar), tetapi itu dapat mengalihkan perhatian dari tujuan untuk menunjukkan betapa mudahnya menerapkan perpustakaan TFCO saat bekerja dengan Keras. Oleh karena itu, modelnya akan tetap sederhana — tetapi merasa terdorong untuk menjelajahi ruang ini.

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

Kami juga mendefinisikan fungsi untuk mengatur benih untuk memastikan hasil yang dapat direproduksi. Perhatikan bahwa colab ini dimaksudkan sebagai alat pendidikan dan tidak memiliki stabilitas jalur produksi yang disetel dengan baik. Menjalankan tanpa menetapkan benih dapat menyebabkan hasil yang bervariasi.

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

Fungsi Pembantu Indikator Keadilan

Sebelum melatih model kami, kami mendefinisikan sejumlah fungsi pembantu yang memungkinkan kami mengevaluasi kinerja model melalui Indikator Kewajaran.

Pertama, kita membuat fungsi pembantu untuk menyimpan model kita setelah kita melatihnya.

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

Selanjutnya, kami mendefinisikan fungsi yang digunakan untuk melakukan praproses data agar dapat meneruskannya dengan benar ke TFMA.

Fungsi Pemrosesan Data untuk

Akhirnya, kami mendefinisikan fungsi yang mengevaluasi hasil di 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)

Latih & Evaluasi Model Tanpa Batas

Dengan model yang sekarang ditentukan dan saluran input, kami sekarang siap untuk melatih model kami. Untuk mengurangi jumlah waktu eksekusi dan memori, kami akan melatih model dengan mengiris data menjadi kumpulan kecil dengan hanya beberapa iterasi berulang.

Catatan bahwa menjalankan notebook ini di TensorFlow <2.0.0 dapat mengakibatkan peringatan bantahan untuk np.where . Aman mengabaikan peringatan ini sebagai TensorFlow alamat ini di 2.x dengan menggunakan tf.where di tempat 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>

Mengevaluasi model pada data uji harus menghasilkan skor akurasi akhir lebih dari 85%. Lumayan untuk model sederhana tanpa fine tuning.

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

Namun, kinerja yang dievaluasi di seluruh kelompok usia dapat mengungkapkan beberapa kekurangan.

Untuk mengeksplorasi ini lebih lanjut, kami mengevaluasi model dengan Indikator Kewajaran (melalui TFMA). Secara khusus, kami tertarik untuk melihat apakah ada kesenjangan yang signifikan dalam kinerja antara kategori "Muda" dan "Tidak Muda" ketika dievaluasi dengan tingkat positif palsu.

Kesalahan positif palsu terjadi ketika model salah memprediksi kelas positif. Dalam konteks ini, hasil positif palsu terjadi ketika kebenaran dasar adalah citra selebriti 'Tidak Tersenyum' dan model memprediksi 'Tersenyum'. Dengan perluasan, tingkat positif palsu, yang digunakan dalam visualisasi di atas, adalah ukuran akurasi untuk tes. Meskipun ini adalah kesalahan yang relatif biasa untuk dilakukan dalam konteks ini, kesalahan positif palsu terkadang dapat menyebabkan perilaku yang lebih bermasalah. Misalnya, kesalahan positif palsu dalam pengklasifikasi spam dapat menyebabkan pengguna melewatkan email penting.

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)`

Seperti disebutkan di atas, kami berkonsentrasi pada tingkat positif palsu. Versi Indikator Kewajaran saat ini (0.1.2) memilih tingkat negatif palsu secara default. Setelah menjalankan baris di bawah ini, batalkan pilihan false_negative_rate dan pilih false_positive_rate untuk melihat metrik yang kami minati.

tfma.addons.fairness.view.widget_view.render_fairness_indicator(eval_results_unconstrained)

FairnessIndicatorViewer(slicingMetrics=[{'sliceValue': 'Young', 'slice': 'Young:Young', 'metrics': {'example_c…

Sebagai hasilnya menunjukkan di atas, kita melihat celah yang tidak proporsional antara "Young" dan "Not Young" kategori.

Di sinilah TFCO dapat membantu dengan membatasi tingkat positif palsu berada dalam kriteria yang lebih dapat diterima.

Pengaturan Model Terbatas

Yang didokumentasikan dalam perpustakaan TFCO ini , ada beberapa pembantu yang akan membuat lebih mudah untuk membatasi masalah:

  1. tfco.rate_context() - Ini adalah apa yang akan digunakan dalam membangun kendala untuk setiap kategori kelompok usia.
  2. tfco.RateMinimizationProblem() - Ekspresi tingkat diminimalkan di sini akan menjadi subjek tingkat positif palsu untuk kelompok usia. Dengan kata lain, kinerja sekarang akan dievaluasi berdasarkan perbedaan antara tingkat positif palsu dari kelompok usia dan kumpulan data keseluruhan. Untuk demonstrasi ini, tingkat positif palsu kurang dari atau sama dengan 5% akan ditetapkan sebagai kendala.
  3. tfco.ProxyLagrangianOptimizerV2() - ini adalah penolong yang benar-benar akan memecahkan masalah tingkat kendala.

Sel di bawah ini akan memanggil helper ini untuk menyiapkan pelatihan model dengan batasan fairness.

# 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())

Model sekarang telah disiapkan dan siap untuk dilatih dengan batasan tingkat positif palsu di seluruh kelompok usia.

Sekarang, karena iterasi terakhir dari model dibatasi belum tentu model terbaik tampil dalam hal kendala yang ditetapkan, perpustakaan TFCO dilengkapi dengan tfco.find_best_candidate_index() yang dapat membantu memilih yang terbaik iterate dari yang ditemukan setelah setiap masa. Pikirkan tfco.find_best_candidate_index() sebagai heuristik menambahkan bahwa peringkat masing-masing hasil berdasarkan akurasi dan keadilan kendala (dalam hal ini, tingkat positif palsu di kelompok usia) secara terpisah sehubungan dengan data training. Dengan begitu, ia dapat mencari trade-off yang lebih baik antara akurasi keseluruhan dan batasan keadilan.

Sel-sel berikut akan memulai pelatihan dengan batasan sambil juga menemukan model berkinerja terbaik per iterasi.

# 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

Setelah menerapkan batasan, kami mengevaluasi hasilnya sekali lagi menggunakan Indikator Kewajaran.

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.

Seperti saat sebelumnya kami menggunakan Indikator Kewajaran, batalkan pilihan false_negative_rate dan pilih false_positive_rate untuk melihat metrik yang kami minati.

Perhatikan bahwa untuk membandingkan dua versi model kami secara adil, penting untuk menggunakan ambang batas yang menetapkan tingkat positif palsu keseluruhan menjadi kira-kira sama. Ini memastikan bahwa kita melihat perubahan aktual sebagai lawan hanya pergeseran model yang setara dengan sekadar memindahkan batas ambang batas. Dalam kasus kami, membandingkan model tanpa kendala pada 0,5 dan model terbatas pada 0,22 memberikan perbandingan yang adil untuk model.

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'…

Dengan kemampuan TFCO untuk mengekspresikan persyaratan yang lebih kompleks sebagai batasan kecepatan, kami membantu model ini mencapai hasil yang lebih diinginkan dengan sedikit dampak pada kinerja keseluruhan. Tentu saja masih ada ruang untuk perbaikan, tetapi setidaknya TFCO mampu menemukan model yang mendekati pemenuhan kendala dan mengurangi disparitas antar kelompok sebanyak mungkin.