Cette page a été traduite par l'API Cloud Translation.
Switch to English

tf.keras.mixed_precision.experimental.Policy

Tensorflow 1 Version Voir la source sur GitHub

Une politique de DTYPE pour une couche Keras.

Utilisé dans les ordinateurs portables

Utilisé dans le guide

Une politique de DTYPE détermine les aspects liés DTYPE-d'une couche, telles que son calcul et dtypes variables. Chaque couche a une politique. Les politiques peuvent être transmises à l' dtype l' argument des constructeurs de couche, ou une politique globale peut être réglée avec tf.keras.mixed_precision.experimental.set_policy . Une couche par défaut à la politique mondiale si aucune politique est passée au constructeur de lui.

Pour de nombreux modèles, la politique de chaque couche aura le même calcul DTYPE et DTYPE variable, qui sera généralement float32. Dans ce cas, on se réfère au DTYPE singulier comme DTYPE de la couche, qui peut être interrogé par la propriété tf.keras.layers.Layer.dtype .

Lorsque la formation mixte de précision est utilisé, la plupart des couches seront plutôt un float16 ou bfloat16 Compute DTYPE et une variable float32 DTYPE, et ainsi la couche ne dispose pas d'un seul DTYPE. Lorsque la DTYPE variable ne correspond pas à la DTYPE de calcul, les variables seront automatiquement casté en Compute DTYPE à des erreurs de type éviter. Dans ce cas, tf.keras.layers.Layer.dtype fait référence à la DTYPE variable, pas le DTYPE de calcul. Voir le guide mixte de précision pour plus d' informations sur la façon d'utiliser la précision mixte.

Certaines politiques ont aussi un tf.mixed_precision.experimental.LossScale exemple, qui est utilisé par tf.keras.Model s à l' échelle de perte de performance. mise à l'échelle de perte est une technique utilisée avec une précision mixte pour éviter underflow numérique dans float16 gradients. Mise à l' échelle de perte ne se fait par les modèles à Model.fit , Model.train_on_batch et des méthodes similaires. Les couches qui ne sont pas des modèles ignorent l'ampleur de la perte.

Les stratégies sont construites en faisant passer une chaîne au constructeur, par exemple tf.keras.mixed_precision.experimental.Policy('float32') . La chaîne détermine le calcul et dtypes variables. Il peut être l'un des éléments suivants:

  • Tout nom de DTYPE, comme « float32 » ou « float64 ». Les deux variables et calcul dtypes seront que DTYPE. Pas de mise à l'échelle de la perte est fait par défaut.
  • 'Mixed_float16' ou 'mixed_bfloat16': Le DTYPE de calcul est float16 ou bfloat16, tandis que la variable DTYPE est float32. Ces politiques sont utilisés pour la formation mixte de précision. Avec « mixed_float16 », une échelle de perte de dynamique est utilisé par défaut. « Mixed_bfloat16 » ne pas mise à l'échelle de perte par défaut, comme mise à l'échelle de la perte est inutile avec bfloat16.

Comment utiliser la précision mixte dans un modèle Keras

Pour utiliser une précision mixte dans un modèle Keras, les 'mixed_float16' ou 'mixed_bfloat16' politique peut être utilisée. tf.keras.mixed_precision.experimental.set_policy peut être utilisé pour définir la stratégie par défaut pour les couches si aucune politique est passée à eux. Par exemple:

tf.keras.mixed_precision.experimental.set_policy('mixed_float16')
model = tf.keras.models.Sequential([
    tf.keras.layers.Input((100,)),
    # Dense layers use global policy of 'mixed_float16', which does
    # computations in float16 while keeping variables in float32.
    tf.keras.layers.Dense(10),
    tf.keras.layers.Dense(10),
    # Softmax should be done in float32 for numeric stability. We pass
    # dtype='float32' to use float32 instead of the global policy.
    tf.keras.layers.Activation('softmax', dtype='float32')
])

Sinon, la politique peut être transmise aux couches individuelles au lieu de fixer la politique globale avec set_policy :

policy = tf.keras.mixed_precision.experimental.Policy('mixed_float16')
model = tf.keras.models.Sequential([
    tf.keras.layers.Input((100,)),
    tf.keras.layers.Dense(10, dtype=policy),
    tf.keras.layers.Dense(10, dtype=policy),
    # Softmax should be done in float32 for numeric stability.
    tf.keras.layers.Activation('softmax', dtype='float32')
])

Notez le 'mixed_float16' politique s'appliquera mise à l' échelle de la perte par défaut dans Model.fit , Model.train_on_batch , et d' autres méthodes de formation. Si aucune méthode est utilisée (par exemple, une boucle de formation sur mesure est utilisé) et 'mixed_float16' est utilisé, l'échelle de la perte doit être appliquée manuellement. Voir tf.keras.mixed_precision.experimental.LossScaleOptimizer pour plus de détails. Pour 'mixed_bfloat16' , pas de mise à l' échelle de la perte est fait et mise à l' échelle de la perte ne doit jamais être appliquée manuellement.

Voir le guide mixte de précision pour plus d' informations sur l' utilisation de précision mixte

Comment utiliser float64 dans un modèle Keras

L'utilisation float64 est similaire à la précision mixte. Soit la politique globale peut être définie sur float64 ou dtype='float64' peut être transmis à des couches individuelles. Par exemple, pour définir la politique globale:

tf.keras.mixed_precision.experimental.set_policy('float64')
model = tf.keras.models.Sequential([
    tf.keras.layers.Input((100,)),
    # All layers use global policy of 'float64', which does computations
    # and creates variables in float64.
    tf.keras.layers.Dense(10),
    tf.keras.layers.Dense(10),
    tf.keras.layers.Activation('softmax')
])
# Optionaly set policy back to float32 if any other models use float32
tf.keras.mixed_precision.experimental.set_policy('float32')

Comment une couche utilise DTYPE compute de sa politique

Une couche projettera ses entrées à son calcul DTYPE dans tensorflow 2. Par exemple:

x = tf.ones((4, 4, 4, 4), dtype='float64')
# `layer`'s policy defaults to float32.
layer = tf.keras.layers.Conv2D(filters=4, kernel_size=2)
# `layer` casts it's inputs to its compute dtype, which is float32, and
# does computations in float32.
y = layer(x)
y.dtype
tf.float32

Notez que la base tf.keras.layers.Layer classe insère les moulages. Si votre propre couche sous-classement, vous ne devez pas insérer des moulages.

À l' heure actuelle, seulement tenseurs dans le premier argument de la couche call de la méthode sont casted. Par exemple:

class MyLayer(tf.keras.layers.Layer):
  # Bug! `b` will not be casted.
  def call(self, a, b):
    return a + 1., b + 1.
a = tf.constant(1., dtype="float32")
b = tf.constant(1., dtype="float32")
layer = MyLayer(dtype="float64")
x, y = layer(a, b)
x.dtype
tf.float64
y.dtype
tf.float32

Si vous écrivez votre propre couche, il est recommandé d'accepter tenseurs que dans le premier argument. De cette façon, tous les tenseurs sont casté au DTYPE de calcul de la couche. MyLayer devrait donc être écrit:

class MyLayer(tf.keras.layers.Layer):
  # Now, all tensor inputs will be casted.
  def call(self, inputs):
    a, b = inputs
    return a + 1., b + 1.
a = tf.constant(1., dtype="float32")
b = tf.constant(1., dtype="float32")
layer = MyLayer(dtype="float64")
x, y = layer((a, b))
x.dtype
tf.float64
y.dtype
tf.float64

D'autres arguments ne sont pas automatiquement casted pour des raisons techniques, mais cela pourrait changer dans une version future mineur.

La coulée ne se produit que dans tensorflow 2, mais peut être activé si tf.compat.v1.disable_v2_behavior() a été appelé avec tf.compat.v1.keras.layers.enable_v2_dtype_behavior() .

Une sous - classe de la couche peut empêcher ses entrées d'être autocasted par passage autocast=False au constructeur de la couche. Par exemple:

class NonAutoCastingLayer(tf.keras.layers.Layer):
  def __init__(self, **kwargs):
    kwargs['autocast'] = False
    super(NonAutoCastingLayer, self).__init__(**kwargs)
  def call(self, inp):
    return inp
x = tf.ones((4, 4, 4, 4), dtype='float32')
layer = NonAutoCastingLayer(dtype='float64')
y = layer(x)  # Will not cast inputs to it's compute dtype of float64
y.dtype
tf.float32

Comment une couche utilise DTYPE variable sa politique

Le DTYPE par défaut des variables créées par tf.keras.layers.Layer.add_weight est DTYPE variable politique de la couche.

Si une couche de dtypes de calcul et de variables diffèrent, add_weight enveloppera les variables à virgule flottante avec une enveloppe spéciale appelée AutoCastVariable . Cette enveloppe est identique à la variable d' origine , sauf qu'elle se jette à la DTYPE de calcul de la couche lorsqu'elle est utilisée dans les Layer.call . En dehors Layer.call , la variable n'est pas casté.

Un auteur de couche peut empêcher une variable d'être enveloppé avec un AutoCastVariable par passage experimental_autocast=False à add_weight :

class MyLayer(tf.keras.layers.Layer):
 def build(self, input_shape):
   self.x = self.add_weight('x')
   self.y = self.add_weight('y', experimental_autocast=False)
policy = tf.keras.mixed_precision.experimental.Policy('mixed_float16')
layer = MyLayer(dtype=policy)
layer.build((2, 2))
layer.x
<AutoCastVariable 'x:0' shape=() dtype=float32 true_dtype=float32, numpy=...>
layer.y
<tf.Variable 'y:0' shape=() dtype=float32, numpy=...>

En passant experimental_autocast=False est utile pour les couches qui peuvent faire quelques calculs en interne dans la variable DTYPE au lieu du DTYPE de calcul. Par exemple, vous pouvez calculer les statistiques variables, telles que la moyenne et la variance, dans la DTYPE variable.

Comment écrire une couche qui prend en charge la précision et float64 mixtes.

Pour en raison du fait de la couche de base jette automatiquement les entrées, crée des variables de type correct, et dans le cas de précision mixte, enveloppements variables avec la plupart, des couches soutiendront automatiquement la précision mixte et float64 sans travail supplémentaire, AutoCastVariables .

Par exemple, cette couche simple dense ne nécessite pas de travail supplémentaire pour soutenir la précision ou float64 mixte. Keras automatiquement les entrées jette et variable à la DTYPE appropriée.

class MyDense(tf.keras.layers.Layer):