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

Personnalisation de MinDiffModel

introduction

Dans la plupart des cas, en utilisant MinDiffModel directement comme décrit dans le manuel « L' intégration mindiff avec MinDiffModel » suffit. Cependant, il est possible que vous ayez besoin d'un comportement personnalisé. Les deux principales raisons à cela sont :

  • Le keras.Model que vous utilisez a un comportement personnalisé que vous souhaitez conserver.
  • Vous voulez que le MinDiffModel se comporter différemment de la valeur par défaut.

Dans les deux cas, vous devez la sous - MinDiffModel pour obtenir les résultats souhaités.

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 Dataset for training, sampled at 0.3 for reduced runtimes.
train_df = tutorials_utils.get_uci_data(split='train', sample=0.3)
train_ds = tutorials_utils.df_to_dataset(train_df, batch_size=128)

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

Préservation des personnalisations du modèle d'origine

tf.keras.Model est conçu pour être facilement personnalisé via le sous - classement comme décrit ici . Si votre modèle a personnalisé implémentations que vous souhaitez conserver lors de l' application mindiff, vous aurez besoin de sous - classe MinDiffModel .

Modèle personnalisé d'origine

Pour voir comment vous pouvez conserver les personnalisations, créez un modèle personnalisé qui définit un attribut à True lorsque sa coutume train_step est appelée. Ce n'est pas une personnalisation utile mais servira à illustrer le comportement.

class CustomModel(tf.keras.Model):

  # Customized train_step
  def train_step(self, *args, **kwargs):
    self.used_custom_train_step = True  # Marker that we can check for.
    return super(CustomModel, self).train_step(*args, **kwargs)

La formation d' un tel modèle serait le même aspect que la normale Sequential modèle.

model = tutorials_utils.get_uci_model(model_class=CustomModel)  # Use CustomModel.

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

_ = model.fit(train_ds.take(1), epochs=1, verbose=0)

# Model has used the custom train_step.
print('Model used the custom train_step:')
print(hasattr(model, 'used_custom_train_step'))  # True
Model used the custom train_step:
True

Sous-classement MinDiffModel

Si vous deviez essayer d'utiliser MinDiffModel directement, le modèle ne serait pas utiliser la coutume train_step .

model = tutorials_utils.get_uci_model(model_class=CustomModel)
model = min_diff.keras.MinDiffModel(model, min_diff.losses.MMDLoss())

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

_ = model.fit(train_with_min_diff_ds.take(1), epochs=1, verbose=0)

# Model has not used the custom train_step.
print('Model used the custom train_step:')
print(hasattr(model, 'used_custom_train_step'))  # False
Model used the custom train_step:
False

Pour utiliser la bonne train_step méthode, vous avez besoin d' une classe personnalisée qui sous - classe à la fois MinDiffModel et CustomModel .

class CustomMinDiffModel(min_diff.keras.MinDiffModel, CustomModel):
  pass  # No need for any further implementation.

La formation de ce modèle utilisera la train_step de CustomModel .

model = tutorials_utils.get_uci_model(model_class=CustomModel)

model = CustomMinDiffModel(model, min_diff.losses.MMDLoss())

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

_ = model.fit(train_with_min_diff_ds.take(1), epochs=1, verbose=0)

# Model has used the custom train_step.
print('Model used the custom train_step:')
print(hasattr(model, 'used_custom_train_step'))  # True
Model used the custom train_step:
True

Personnalisation des comportements par défaut de MinDiffModel

Dans d' autres cas, vous pouvez modifier les comportements par défaut spécifiques de MinDiffModel . Le cas le plus d'usage courant est en train de changer le comportement par défaut de déballer pour gérer correctement vos données si vous n'utilisez pas pack_min_diff_data .

Lors de l'emballage des données dans un format personnalisé, cela peut apparaître comme suit.

def _reformat_input(inputs, original_labels):
  min_diff_data = min_diff.keras.utils.unpack_min_diff_data(inputs)
  original_inputs = min_diff.keras.utils.unpack_original_inputs(inputs)

  return ({
      'min_diff_data': min_diff_data,
      'original_inputs': original_inputs}, original_labels)

customized_train_with_min_diff_ds = train_with_min_diff_ds.map(_reformat_input)

Les customized_train_with_min_diff_ds ensemble de données renvoie les lots composés de tuples (x, y)x est un dict contenant min_diff_data et original_inputs et y est le original_labels .

for x, _ in customized_train_with_min_diff_ds.take(1):
  print('Type of x:', type(x))  # dict
  print('Keys of x:', x.keys())  # 'min_diff_data', 'original_inputs'
Type of x: <class 'dict'>
Keys of x: dict_keys(['min_diff_data', 'original_inputs'])

Ce format de données ne sont pas ce que MinDiffModel attend par défaut et en passant customized_train_with_min_diff_ds à elle entraînerait un comportement inattendu. Pour résoudre ce problème, vous devrez créer votre propre sous-classe.

class CustomUnpackingMinDiffModel(min_diff.keras.MinDiffModel):

  def unpack_min_diff_data(self, inputs):
    return inputs['min_diff_data']

  def unpack_original_inputs(self, inputs):
    return inputs['original_inputs']

Avec cette sous-classe, vous pouvez vous entraîner comme avec les autres exemples.

model = tutorials_utils.get_uci_model()
model = CustomUnpackingMinDiffModel(model, min_diff.losses.MMDLoss())

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

_ = model.fit(customized_train_with_min_diff_ds, epochs=1)
77/77 [==============================] - 4s 30ms/step - loss: 0.6690 - min_diff_loss: 0.0395

Limites d'un sur mesure MinDiffModel

Création d' une coutume MinDiffModel offre une énorme quantité de flexibilité pour les cas d'utilisation plus complexes. Cependant, il existe encore des cas extrêmes qu'il ne prendra pas en charge.

Prétraiter ou de validation des entrées avant l' call

La plus grande limitation pour une sous - classe de MinDiffModel est qu'il nécessite le x composant des données d'entrée ( à savoir l'élément premier ou seulement dans la charge renvoyée par le tf.data.Dataset ) pour passer à travers sans pré - traitement ou de validation d' call .

Ceci est simplement parce que le min_diff_data est emballé dans le x composant des données d'entrée. Toute pré - traitement ou de validation ne seront pas attendre la structure supplémentaire contenant min_diff_data et sera probablement briser.

Si le prétraitement ou la validation est facilement personnalisable (par exemple, pris en compte dans sa propre méthode), alors cela est facilement résolu en le remplaçant pour s'assurer qu'il gère correctement la structure supplémentaire.

Un exemple avec validation pourrait ressembler à ceci :

class CustomMinDiffModel(min_diff.keras.MinDiffModel, CustomModel):

  # Override so that it correctly handles additional `min_diff_data`.
  def validate_inputs(self, inputs):
    original_inputs = self.unpack_original_inputs(inputs)
    ...  # Optionally also validate min_diff_data
    # Call original validate method with correct inputs
    return super(CustomMinDiffModel, self).validate(original_inputs)

Si le pré - traitement ou de validation ne sont pas facilement personnalisable, puis en utilisant MinDiffModel peut ne pas fonctionner pour vous et vous aurez besoin d'intégrer mindiff sans comme décrit dans ce guide .

Collisions de nom de méthode

Il est possible que votre modèle a des méthodes dont les noms en conflit avec celles mises en œuvre dans MinDiffModel (voir la liste complète des méthodes publiques dans la documentation de l' API ).

Cela n'est problématique que si ceux-ci sont appelés sur une instance du modèle (plutôt qu'en interne dans une autre méthode). Bien que très improbable, si vous êtes dans cette situation , vous devez soit prioritaire et renommer certaines méthodes ou, à défaut, vous devrez peut - être envisager d' intégrer mindiff sans MinDiffModel comme décrit dans ce guide sur le sujet .

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 .