Se usó la API de Cloud Translation para traducir esta página.
Switch to English

tf.keras.layers.Layer

TensorFlow 1 versión Ver código fuente en GitHub

Esta es la clase de la que heredan todas las capas.

Hereda de: Module

Una capa es un objeto invocable que toma como una entrada o más tensores y que las salidas de uno o más tensores. Se trata de cálculo, se define en la call() método, y un estado (variables de ponderación), definido ya sea en el constructor __init__() o en el build() método.

Los usuarios simplemente una instancia de una capa y luego tratarlo como un exigible.

trainable Booleano, si las variables de la capa debe ser orientable.
name String nombre de la capa.
dtype El dtype de los cálculos y los pesos de la capa (predeterminado de None medios utilizar tf.keras.backend.floatx en TensorFlow 2, o el tipo de la primera entrada en TensorFlow 1).
dynamic Ponga esto en True si su capa sólo se debe ejecutar con entusiasmo, y no debe ser utilizado para generar un gráfico de cálculo estático. Este sería el caso para un árbol-RNN o una red recursiva, por ejemplo, o en general para cualquier capa que manipula tensores usando flujo de control Python. Si False , se supone que la capa de seguridad se puede utilizar para generar un gráfico de cálculo estático.

Recomendamos que los descendientes de Layer implementar los métodos siguientes:

  • __init__() : Define los atributos de capa personalizada, y crea las variables de estado de capa que no dependen de las formas de entrada, usando add_weight() .
  • build(self, input_shape) : Este método se puede utilizar para crear los pesos que dependen de la forma (s) de la entrada (s), utilizando add_weight() . __call__() va a construir de forma automática la capa (si no se ha construido todavía) llamando build() .
  • call(self, *args, **kwargs) : Llamado __call__ Después de asegurarse de build() ha sido llamado. call() realiza la lógica de la aplicación de la capa a los tensores de entrada (que debe ser pasa como argumento). Dos argumentos de palabras clave reservadas se pueden utilizar opcionalmente en call() son:
    • training (booleano, si la llamada está en modo de inferencia o el modo de entrenamiento)
    • mask (boolean codificación tensor enmascarado timesteps en la entrada, que se utiliza en capas RNN)
  • get_config(self) : Devuelve un diccionario que contiene la configuración utilizada para inicializar esta capa. Si las claves difieren de los argumentos en __init__ , entonces anular from_config(self) también. Este método se utiliza cuando el ahorro de la capa o un modelo que contiene esta capa.

Ejemplos:

Aquí es un ejemplo básico: una capa con dos variables, w y b , que los rendimientos y = w . x + b . Se muestra cómo implementar build() y call() . Variables establecidos como atributos de una capa se realiza un seguimiento como pesos de las capas (en layer.weights ).

 class SimpleDense(Layer):

  def __init__(self, units=32):
      super(SimpleDense, self).__init__()
      self.units = units

  def build(self, input_shape):  # Create the state of the layer (weights)
    w_init = tf.random_normal_initializer()
    self.w = tf.Variable(
        initial_value=w_init(shape=(input_shape[-1], self.units),
                             dtype='float32'),
        trainable=True)
    b_init = tf.zeros_initializer()
    self.b = tf.Variable(
        initial_value=b_init(shape=(self.units,), dtype='float32'),
        trainable=True)

  def call(self, inputs):  # Defines the computation from inputs to outputs
      return tf.matmul(inputs, self.w) + self.b

# Instantiates the layer.
linear_layer = SimpleDense(4)

# This will also call `build(input_shape)` and create the weights.
y = linear_layer(tf.ones((2, 2)))
assert len(linear_layer.weights) == 2

# These weights are trainable, so they're listed in `trainable_weights`:
assert len(linear_layer.trainable_weights) == 2
 

Tenga en cuenta que el método add_weight() ofrece un acceso directo para crear pesos:

 class SimpleDense(Layer):

  def __init__(self, units=32):
      super(SimpleDense, self).__init__()
      self.units = units

  def build(self, input_shape):
      self.w = self.add_weight(shape=(input_shape[-1], self.units),
                               initializer='random_normal',
                               trainable=True)
      self.b = self.add_weight(shape=(self.units,),
                               initializer='random_normal',
                               trainable=True)

  def call(self, inputs):
      return tf.matmul(inputs, self.w) + self.b
 

Además pesos entrenables, actualizados a través de propagación hacia atrás durante el entrenamiento, las capas también pueden tener pesos no entrenables. Estos pesos son para ser actualizado manualmente durante la call() . Aquí hay una capa de ejemplo que calcula la suma acumulada de sus entradas:

 class ComputeSum(Layer):

  def __init__(self, input_dim):
      super(ComputeSum, self).__init__()
      # Create a non-trainable weight.
      self.total = tf.Variable(initial_value=tf.zeros((input_dim,)),
                               trainable=False)

  def call(self, inputs):
      self.total.assign_add(tf.reduce_sum(inputs, axis=0))
      return self.total

my_sum = ComputeSum(2)
x = tf.ones((2, 2))

y = my_sum(x)
print(y.numpy())  # [2. 2.]

y = my_sum(x)
print(y.numpy())  # [4. 4.]

assert my_sum.weights == [my_sum.total]
assert my_sum.non_trainable_weights == [my_sum.total]
assert my_sum.trainable_weights == []
 

Para obtener más información acerca de la creación de capas, consulte la guía de escritura capas y modelos personalizados con Keras

Sobre la capa es dtype atributo:

Cada capa tiene un dtype, que es típicamente la dtype de cálculos y variables de la capa. Dtype de una capa se puede consultar a través de la Layer.dtype propiedad. El dtype se especifica con el dtype argumento del constructor. En TensorFlow 2, los valores por defecto de tipo D a tf.keras.backend.floatx() Si no se pasa dtype. floatx() sí por defecto es "float32". Además, las capas emitirán sus entradas a dtype de la capa en TensorFlow 2. Cuando se utiliza precisión mixto, las capas pueden tener diferentes dtypes de cálculo y variables. Ver tf.keras.mixed_precision.experimental.Policy para obtener detalles sobre dtypes capa.

name El nombre de la capa (cadena).
dtype El dtype de los cálculos y los pesos de la capa. Si la precisión mixta se utiliza con un tf.keras.mixed_precision.experimental.Policy , esto es sólo el lugar dtype de pesos de la capa, ya que los cálculos se realizan en un dtype diferente.
trainable_weights Lista de variables que se incluirán en Backprop.
non_trainable_weights Lista de variables que no deben incluirse en Backprop.
weights La concatenación de los trainable_weights listas y non_trainable_weights (en este orden).
trainable Ya sea que la capa debe ser entrenado (boolean), es decir, si sus pesos potencialmente-entrenables deben ser devueltos como parte de layer.trainable_weights .
input_spec Opcional (lista de) InputSpec objeto (s) que especifica las restricciones en las entradas que pueden ser aceptados por la capa.
activity_regularizer función regularizador opcional para la salida de esta capa.
dynamic Si la capa es dinámico (ansioso-solamente); establecer en el constructor.
input Recupera el tensor de entrada (s) de una capa.

Sólo aplicable si la capa tiene exactamente una entrada, es decir si está conectado a una capa de entrada.

losses Lista de las pérdidas añadió utilizando el add_loss() de la API.

Tensores de regularización variables se crean cuando se accede a esta propiedad, por lo que es seguro ansiosos: el acceso a losses en virtud de un tf.GradientTape se propagará gradientes de nuevo a los variables correspondientes.

class MyLayer(tf.keras.layers.Layer):
  def call(self, inputs):
    self.add_loss(tf.abs(tf.reduce_mean(inputs)))
    return inputs
l = MyLayer()
l(np.ones((10, 1)))
l.losses
[1.0]
inputs = tf.keras.Input(shape=(10,))
x = tf.keras.layers.Dense(10)(inputs)
outputs = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs, outputs)
# Activity regularization.
model.add_loss(tf.abs(tf.reduce_mean(x)))
model.losses
[<tf.Tensor 'Abs:0' shape=() dtype=float32>]
inputs = tf.keras.Input(shape=(10,))
d = tf.keras.layers.Dense(10, kernel_initializer='ones')
x = d(inputs)
outputs = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs, outputs)
# Weight regularization.
model.add_loss(lambda: tf.reduce_mean(d.kernel))
model.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=1.0>]

metrics Lista de métricas añadió utilizando el add_metric() de la API.

input = tf.keras.layers.Input(shape=(3,))
d = tf.keras.layers.Dense(2)
output = d(input)