Tensorflow tf.keras.mixed_precision.Policy

Una política dtype para una capa de Keras.

tf.keras.mixed_precision.Policy(
    name
)

Una política de tipos determina el cálculo de una capa y los tipos de variables. Cada capa tiene una política. Las pólizas se pueden pasar al dtype argumento de los constructores de capa, o se puede establecer una política global con tf.keras.mixed_precision.set_global_policy.

Por lo general, solo necesita interactuar con las políticas dtype cuando usa mixed precision, que es el uso de float16 o bfloat16 para cálculos y float32 para variables. Por eso el término mixed_precision aparece en el nombre de la API. La precisión mixta se puede habilitar pasando 'mixed_float16' o 'mixed_bfloat16' para tf.keras.mixed_precision.set_global_policy. Ver los mixed guía de precisión para obtener más información sobre cómo utilizar mixed precisión.

tf.keras.mixed_precision.set_global_policy('mixed_float16')
layer1 = tf.keras.layers.Dense(10)
layer1.dtype_policy  # `layer1` will automatically use mixed precision<Policy "mixed_float16"># Can optionally override layer to use float32 instead of mixed precision.
layer2 = tf.keras.layers.Dense(10, dtype='float32')
layer2.dtype_policy
<Policy "float32"># Set policy back to initial float32 for future examples.
tf.keras.mixed_precision.set_global_policy('float32')

En el ejemplo anterior, pasando dtype='float32' a la capa es equivalente a pasar dtype=tf.keras.mixed_precision.Policy('float32'). En general, pasar un dtype a una capa equivale a pasar la política correspondiente, por lo que nunca es necesario construir explícitamente una Policy objeto.

Nota:Model.compile envolverá automáticamente un optimizador con un tf.keras.mixed_precision.LossScaleOptimizer si usa el 'mixed_float16' política. Si usa un ciclo de entrenamiento personalizado en lugar de llamar Model.compile, debe utilizar explícitamente un tf.keras.mixed_precision.LossScaleOptimizer para evitar el subdesbordamiento numérico con float16.

Cómo utiliza una capa el tipo de cálculo de su política

Una capa convierte sus entradas en su tipo de cálculo. Esto hace que los cálculos y la salida de la capa también estén en el tipo de cálculo. Por ejemplo:

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.compute_dtype  # Equivalent to layer.dtype_policy.compute_dtype'float32'# `layer` casts it's inputs to its compute dtype and does computations in# that dtype.
y = layer(x)
y.dtype
tf.float32

Tenga en cuenta que la base tf.keras.layers.Layer clase inserta los moldes. Si subclasifica su propia capa, no tiene que insertar ningún molde.

Actualmente, solo los tensores en el primer argumento de la capa call se emiten el método (aunque es probable que esto se cambie en una versión menor futura). Por ejemplo:

classMyLayer(tf.keras.layers.Layer):# Bug! `b` will not be casted.defcall(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 escribe su propia capa con múltiples entradas, debe lanzar explícitamente otros tensores a self.compute_dtype en call o acepte todos los tensores en el primer argumento como una lista.

La transmisión solo ocurre en TensorFlow 2. Si tf.compat.v1.disable_v2_behavior() se ha llamado, puede habilitar el comportamiento de transmisión con tf.compat.v1.keras.layers.enable_v2_dtype_behavior().

Cómo una capa usa el tipo de variable de su política

El tipo predeterminado de variables creadas por tf.keras.layers.Layer.add_weight es el tipo de variable de la política de la capa.

Si los tipos de cálculo y de variable de una capa difieren, add_weight envolverá las variables de punto flotante con un envoltorio especial llamado AutoCastVariable. AutoCastVariable es idéntica a la variable original, excepto que se convierte a sí misma en el tipo de cálculo de la capa cuando se usa dentro de Layer.call. Esto significa que si está escribiendo una capa, no tiene que convertir explícitamente las variables al tipo de cálculo de la capa. Por ejemplo:

classSimpleDense(tf.keras.layers.Layer):defbuild(self, input_shape):# With mixed precision, self.kernel is a float32 AutoCastVariable
    self.kernel = self.add_weight('kernel',(input_shape[-1],10))defcall(self, inputs):# With mixed precision, self.kernel will be casted to float16return tf.linalg.matmul(inputs, self.kernel)

dtype_policy = tf.keras.mixed_precision.Policy('mixed_float16')
layer = SimpleDense(dtype=dtype_policy)
y = layer(tf.ones((10,10)))
y.dtype
tf.float16
layer.kernel.dtype
tf.float32

Un autor de capa puede evitar que una variable se ajuste con un AutoCastVariable pasando experimental_autocast=False para add_weight, que es útil si se debe acceder al valor float32 de la variable dentro de la capa.

Cómo escribir una capa que admita mixed precisión y float64.

En su mayor parte, las capas admitirán automáticamente mixed precision y float64 sin ningún trabajo adicional, debido al hecho de que la capa base arroja automáticamente las entradas, crea variables del tipo correcto y, en el caso de mixed precisión, envuelve variables con AutoCastVariables.

El caso principal en el que necesita trabajo adicional para respaldar mixed precisión o float64 es cuando creas un nuevo tensor, como con tf.ones o tf.random.normal, En tales casos, debe crear el tensor del tipo d correcto. Por ejemplo, si llamas tf.random.normal, debe pasar el compute dtype, que es el dtype al que se han convertido las entradas:

classAddRandom(tf.keras.layers.Layer):defcall(self, inputs):# We must pass `dtype=inputs.dtype`, otherwise a TypeError may# occur when adding `inputs` to `rand`.
    rand = tf.random.normal(shape=inputs.shape, dtype=inputs.dtype)return inputs + rand

dtype_policy = tf.keras.mixed_precision.Policy('mixed_float16')
layer = AddRandom(dtype=dtype_policy)
y = layer(x)
y.dtype
tf.float16

Si no pasaste dtype=inputs.dtype para tf.random.normal, a TypeError hubiera ocurrido. Esto se debe a que tf.random.normalEl tipo de dtype predeterminado es "float32", pero el tipo de entrada es float16. No puede agregar un tensor float32 con un tensor float16.

Métodos

from_config

Ver fuente

@classmethod
from_config(
    config, custom_objects=None)

get_config

Ver fuente

get_config()