Aide à protéger la Grande barrière de corail avec tensorflow sur Kaggle Rejoignez Défi

Intégration de MinDiff avec MinDiffModel

introduction

Il y a deux étapes pour intégrer MinDiff dans votre modèle :

  1. Préparer les données (couvert dans le guide de préparation d'entrée ).

  2. Modifiez ou créez un modèle qui intégrera MinDiff pendant la formation.

Ce guide couvrira la plus simple façon de terminer la deuxième étape: à l' aide MinDiffModel .

Installer

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

Tout d'abord, téléchargez les données. Pour la concision, la logique de préparation d'entrée a été pris en compte dans des fonctions auxiliaires , comme décrit dans le guide de préparation d'entrée . Vous pouvez lire le guide complet pour plus de détails sur ce processus.

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

Modèle d'origine

Ce guide utilise une base, désaccordé keras.Model en utilisant l' API fonctionnelle pour mettre en évidence à l' aide mindiff. Dans une application du monde réel, vous choisiriez soigneusement l'architecture du modèle et utiliseriez le réglage pour améliorer la qualité du modèle avant d'essayer de résoudre les problèmes d'équité.

Depuis MinDiffModel est conçu pour fonctionner avec la plupart des Keras Model des classes, nous avons pris en compte la logique de la construction du modèle en fonction d'assistance: get_uci_model .

Entraînement avec un DataFrame Pandas

Ce guide s'entraîne sur une seule époque pour la vitesse, mais pourrait facilement améliorer les performances du modèle en augmentant le nombre d'époques.

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

Formation avec un tf.data.Dataset

La formation équivalente avec un tf.data.Dataset serait très similaire (bien que l' initialisation et le caractère aléatoire d'entrée peuvent donner des résultats légèrement différents).

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

Intégration de MinDiff pour la formation

Une fois les données préparées, appliquez MinDiff à votre modèle en procédant comme suit :

  1. Créez le modèle original comme vous le feriez sans MinDiff.
original_model = tutorials_utils.get_uci_model()
  1. Enveloppez - le dans un MinDiffModel .
min_diff_model = min_diff.keras.MinDiffModel(
    original_model=original_model,
    loss=min_diff.losses.MMDLoss(),
    loss_weight=1)
  1. Compilez-le comme vous le feriez sans MinDiff.
min_diff_model.compile(optimizer='adam', loss='binary_crossentropy')
  1. Former avec l'ensemble de données (mindiff train_with_min_diff_ds dans ce cas).
_ = min_diff_model.fit(train_with_min_diff_ds, epochs=1)
77/77 [==============================] - 6s 31ms/step - loss: 0.7883 - min_diff_loss: 0.0379

Évaluation et prévision avec MinDiffModel

Les deux évaluation et la prévision d'un MinDiffModel sont semblables à le faire avec le modèle original.

Lors de l' appel d' evaluate vous pouvez passer soit dans l'ensemble de données d' origine ou celui contenant des données mindiff. Si vous choisissez ce dernier, vous aurez également la min_diff_loss métrique en plus des autres paramètres mesurés loss comprendra également la min_diff_loss .

Lors de l' appel d' evaluate vous pouvez passer soit dans l'ensemble de données d' origine ou celui contenant des données mindiff. Si vous incluez MinDiff dans l'appel à évaluer, deux choses seront différentes :

  • Une mesure supplémentaire appelée min_diff_loss sera présent dans la sortie.
  • La valeur de la loss métrique sera la somme de l'original loss métrique (non représenté sur la sortie) et le 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

Lorsque vous appelez predict techniquement , vous pouvez passer aussi dans l'ensemble de données avec les données mindiff mais il sera ignoré et ne pas affecter la sortie.

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

Limites de l' utilisation MinDiffModel directement

Lors de l' utilisation MinDiffModel comme décrit ci - dessus, la plupart des méthodes utiliseront les implémentations par défaut de tf.keras.Model (exceptions énumérées dans la documentation de l' 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

Pour keras.Sequential ou keras.Model , cela est parfaitement bien car ils utilisent les mêmes fonctions.

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

Cependant, si votre modèle est une sous - MinDiffModel classe de keras.Model , l' enveloppant avec MinDiffModel va perdre efficacement la personnalisation.

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

Si tel est votre cas d'utilisation, vous ne devriez pas utiliser MinDiffModel directement. Au lieu de cela, vous aurez besoin de sous - classe comme décrit dans le guide de personnalisation .

Ressources additionnelles

  • Pour une discussion approfondie sur l' évaluation de l' équité voir les conseils indicateurs d' équité
  • Pour des informations générales sur l' assainissement et mindiff, consultez la liste de remise en état .
  • Pour plus de détails sur les exigences entourant mindiff voir ce guide .
  • Pour voir un tutoriel de bout en bout sur l' utilisation mindiff dans Keras, consultez ce tutoriel .