Mengintegrasikan MinDiff dengan MinDiffModel

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

pengantar

Ada dua langkah untuk mengintegrasikan MinDiff ke dalam model Anda:

  1. Menyiapkan data (tercakup dalam panduan persiapan masukan ).

  2. Ubah atau buat model yang akan mengintegrasikan MinDiff selama pelatihan.

Panduan ini akan mencakup cara paling sederhana untuk menyelesaikan langkah kedua: menggunakan MinDiffModel .

Mempersiapkan

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

Pertama, unduh datanya. Untuk kekompakan, logika persiapan input telah diperhitungkan keluar ke fungsi pembantu seperti yang dijelaskan dalam panduan persiapan masukan . Anda dapat membaca panduan lengkap untuk detail tentang proses ini.

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

Model Asli

Panduan ini menggunakan dasar, yg tak disetel keras.Model menggunakan API Fungsional untuk menyorot menggunakan MinDiff. Dalam aplikasi dunia nyata, Anda akan dengan hati-hati memilih arsitektur model dan menggunakan penyetelan untuk meningkatkan kualitas model sebelum mencoba mengatasi masalah keadilan apa pun.

Sejak MinDiffModel dirancang untuk bekerja dengan sebagian Keras Model kelas, kami telah keluar faktor logika membangun model ke fungsi pembantu: get_uci_model .

Pelatihan dengan Pandas DataFrame

Panduan ini melatih lebih dari satu zaman untuk kecepatan, tetapi dapat dengan mudah meningkatkan kinerja model dengan meningkatkan jumlah zaman.

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

Pelatihan dengan tf.data.Dataset

Setara pelatihan dengan tf.data.Dataset akan terlihat sangat mirip (meskipun inisialisasi dan masukan keacakan dapat menghasilkan hasil yang sedikit berbeda).

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

Mengintegrasikan MinDiff untuk pelatihan

Setelah data disiapkan, terapkan MinDiff ke model Anda dengan langkah-langkah berikut:

  1. Buat model asli seperti yang Anda lakukan tanpa MinDiff.
original_model = tutorials_utils.get_uci_model()
  1. Bungkus dalam MinDiffModel .
min_diff_model = min_diff.keras.MinDiffModel(
    original_model=original_model,
    loss=min_diff.losses.MMDLoss(),
    loss_weight=1)
  1. Kompilasi seperti yang Anda lakukan tanpa MinDiff.
min_diff_model.compile(optimizer='adam', loss='binary_crossentropy')
  1. Melatihnya dengan dataset MinDiff ( train_with_min_diff_ds dalam hal ini).
_ = min_diff_model.fit(train_with_min_diff_ds, epochs=1)

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

Evaluasi dan Prediksi dengan MinDiffModel

Kedua mengevaluasi dan memprediksi dengan MinDiffModel mirip dengan melakukannya dengan model asli.

Saat memanggil evaluate Anda dapat lulus baik dalam dataset asli atau yang berisi data MinDiff. Jika Anda memilih yang terakhir, Anda juga akan mendapatkan min_diff_loss metrik tambahan dari setiap metrik lainnya yang diukur loss juga akan mencakup min_diff_loss .

Saat memanggil evaluate Anda dapat lulus baik dalam dataset asli atau yang berisi data MinDiff. Jika Anda menyertakan MinDiff dalam panggilan untuk mengevaluasi, dua hal akan berbeda:

  • Metrik tambahan yang disebut min_diff_loss akan hadir di output.
  • Nilai loss metrik akan menjadi jumlah asli loss metrik (tidak ditampilkan dalam output) dan 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

Saat memanggil predict Anda secara teknis bisa juga lulus dalam dataset dengan data MinDiff tetapi akan diabaikan dan tidak mempengaruhi output.

_ = 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.

Keterbatasan menggunakan MinDiffModel langsung

Bila menggunakan MinDiffModel seperti dijelaskan di atas, metode yang paling akan menggunakan implementasi default tf.keras.Model (pengecualian tercantum dalam dokumentasi 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

Untuk keras.Sequential atau keras.Model , ini baik-baik saja karena mereka menggunakan fungsi yang sama.

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

Namun, jika model Anda adalah subclass dari keras.Model , membungkusnya dengan MinDiffModel efektif akan kehilangan kustomisasi.

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

Jika ini adalah kasus penggunaan Anda, Anda tidak harus menggunakan MinDiffModel langsung. Sebaliknya, Anda akan perlu subclass itu seperti yang dijelaskan dalam panduan kustomisasi .

Sumber daya tambahan