Contenido Overview 
 
 
 
 
 
 Lámparas de Keras El paso de la construcción Los modelos de Keras Salvar los modelos de Keras Verificación de los modelos de Keras Tenga en cuenta que hasta este punto, no hay mención de Keras. Puede construir su propia API de alto nivel en Y la gente tiene. tf.Module En esta sección, examinarás cómo utiliza Keras Una guía de usuario completa de los modelos de Keras se puede encontrar en el . tf.Module Guía de Keras Las capas y modelos de Keras tienen muchas más características adicionales, incluyendo: 
 
 
 
 
 
 Pérdidas opcionales Apoyo a la metrología Soporte integrado para un argumento de entrenamiento opcional para diferenciar entre el uso de entrenamiento y de inferencia Guardar y restaurar objetos de Python en lugar de sólo funciones de caja negra los métodos get_config y from_config que le permiten almacenar con precisión las configuraciones para permitir la clonación de modelos en Python Estas características permiten modelos mucho más complejos a través de la subclasificación, como un modelo GAN personalizado o un modelo Variational AutoEncoder (VAE). de las capas y los modelos. Guía completa Los modelos Keras también vienen con funcionalidad adicional que los hace fáciles de entrenar, evaluar, cargar, guardar e incluso entrenar en múltiples máquinas. Lámparas de Keras es la clase base de todas las capas de Keras, y es heredada de . tf.keras.layers.Layer tf.Module Puede convertir un módulo en una capa Keras simplemente intercambiando la capa madre y luego cambiando Dos : __call__ call class MyDense(tf.keras.layers.Layer):
  # Adding **kwargs to support base Keras layer arguments
  def __init__(self, in_features, out_features, **kwargs):
    super().__init__(**kwargs)

    # This will soon move to the build step; see below
    self.w = tf.Variable(
      tf.random.normal([in_features, out_features]), name='w')
    self.b = tf.Variable(tf.zeros([out_features]), name='b')
  def call(self, x):
    y = tf.matmul(x, self.w) + self.b
    return tf.nn.relu(y)

simple_layer = MyDense(name="simple", in_features=3, out_features=3)
 Las cucarachas tienen su propia que hace alguna contabilidad descrita en la siguiente sección y luego llama No debe notar ningún cambio en la funcionalidad. __call__ call() simple_layer([[2.0, 2.0, 2.0]])
 <tf.Tensor: shape=(1, 3), dtype=float32, numpy=array([[1.1688161, 0.       , 0.       ]], dtype=float32)>
 El paso build Como se ha señalado, en muchos casos es conveniente esperar a crear variables hasta que esté seguro de la forma de entrada. Las capas de Keras vienen con un paso de ciclo de vida adicional que le permite más flexibilidad en la forma en que define sus capas. Funcionamiento . build se llama exactamente una vez, y se llama con la forma de la entrada. Se utiliza generalmente para crear variables (pesos). build Puedes reescribir la capa superior para ser flexible al tamaño de sus entradas: MyDense class FlexibleDense(tf.keras.layers.Layer):
  # Note the added `**kwargs`, as Keras supports many arguments
  def __init__(self, out_features, **kwargs):
    super().__init__(**kwargs)
    self.out_features = out_features

  def build(self, input_shape):  # Create the state of the layer (weights)
    self.w = tf.Variable(
      tf.random.normal([input_shape[-1], self.out_features]), name='w')
    self.b = tf.Variable(tf.zeros([self.out_features]), name='b')

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

# Create the instance of the layer
flexible_dense = FlexibleDense(out_features=3)
 En este momento, el modelo no ha sido construido, por lo que no hay variables: flexible_dense.variables
 []
 Llamando la función asigna variables de tamaño apropiado: # Call it, with predictably random results
print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0], [3.0, 3.0, 3.0]])))
 Model results: tf.Tensor(
[[-2.531786  -5.5550847 -0.4248762]
 [-3.7976792 -8.332626  -0.6373143]], shape=(2, 3), dtype=float32)
 flexible_dense.variables
 [<tf.Variable 'flexible_dense/w:0' shape=(3, 3) dtype=float32, numpy=
 array([[-0.77719826, -1.9281565 ,  0.82326293],
        [ 0.85628736, -0.31845194,  0.10916236],
        [-1.3449821 , -0.5309338 , -1.1448634 ]], dtype=float32)>,
 <tf.Variable 'flexible_dense/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>]
 Desde sólo se llama una vez, las entradas serán rechazadas si la forma de entrada no es compatible con las variables de la capa: build try:
  print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0, 2.0]])))
except tf.errors.InvalidArgumentError as e:
  print("Failed:", e)
 Failed: Exception encountered when calling layer 'flexible_dense' (type FlexibleDense).

{ {function_node __wrapped__MatMul_device_/job:localhost/replica:0/task:0/device:CPU:0} } Matrix size-incompatible: In[0]: [1,4], In[1]: [3,3] [Op:MatMul] name: 

Call arguments received by layer 'flexible_dense' (type FlexibleDense):
  • inputs=tf.Tensor(shape=(1, 4), dtype=float32)
 Los modelos de Keras Puede definir su modelo como capas de Keras niñadas. Sin embargo, Keras también proporciona una clase de modelos completa llamada Se hereda de , por lo que un modelo Keras se puede usar y anidar de la misma manera que las capas Keras. los modelos Keras vienen con funcionalidad adicional que los hace fáciles de entrenar, evaluar, cargar, guardar e incluso entrenar en múltiples máquinas. tf.keras.Model tf.keras.layers.Layer Puedes definir el de arriba con el código casi idéntico, de nuevo convertiendo Dos Cambiar de padre: SequentialModule __call__ call() @keras.saving.register_keras_serializable()
class MySequentialModel(tf.keras.Model):
  def __init__(self, name=None, **kwargs):
    super().__init__(**kwargs)

    self.dense_1 = FlexibleDense(out_features=3)
    self.dense_2 = FlexibleDense(out_features=2)
  def call(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a Keras model!
my_sequential_model = MySequentialModel(name="the_model")

# Call it on a tensor, with random results
print("Model results:", my_sequential_model(tf.constant([[2.0, 2.0, 2.0]])))
 Model results: tf.Tensor([[ 0.26034355 16.431221  ]], shape=(1, 2), dtype=float32)
 Todas las mismas características están disponibles, incluyendo el seguimiento de variables y submodulos. 
 
 Nota: Un tf.Module crudo niñado dentro de una capa o modelo Keras no obtendrá sus variables recogidas para entrenamiento o ahorro. Nota: Un tf.Module crudo niñado dentro de una capa o modelo Keras no obtendrá sus variables recogidas para entrenamiento o ahorro. my_sequential_model.variables
 [<tf.Variable 'my_sequential_model/flexible_dense_1/w:0' shape=(3, 3) dtype=float32, numpy=
 array([[ 1.4749854 ,  0.16090827,  2.2669017 ],
        [ 1.6850946 ,  1.1545411 ,  0.1707306 ],
        [ 0.8753734 , -0.13549292,  0.08751986]], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_1/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_2/w:0' shape=(3, 2) dtype=float32, numpy=
 array([[-0.8022977 ,  1.9773549 ],
        [-0.76657015, -0.8485579 ],
        [ 1.6919082 ,  0.49000967]], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_2/b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)>]
 my_sequential_model.submodules
 (<__main__.FlexibleDense at 0x7f790c7e0e80>,
 <__main__.FlexibleDense at 0x7f790c7e6940>)
 Supervivencia es un enfoque muy Pythonic para construir modelos de TensorFlow. Si está migrando modelos de otros marcos, esto puede ser muy sencillo. tf.keras.Model Si está construyendo modelos que son ensamblajes simples de capas y entradas existentes, puede ahorrar tiempo y espacio utilizando el , que viene con características adicionales en torno a la reconstrucción del modelo y la arquitectura. Funcionamiento del fuego Aquí está el mismo modelo con la API funcional: inputs = tf.keras.Input(shape=[3,])

x = FlexibleDense(3)(inputs)
x = FlexibleDense(2)(x)

my_functional_model = tf.keras.Model(inputs=inputs, outputs=x)

my_functional_model.summary()
 Model: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_1 (InputLayer)        [(None, 3)]               0         
                                                                 
 flexible_dense_3 (Flexible  (None, 3)                 12        
 Dense)                                                          
                                                                 
 flexible_dense_4 (Flexible  (None, 2)                 8         
 Dense)                                                          
                                                                 
=================================================================
Total params: 20 (80.00 Byte)
Trainable params: 20 (80.00 Byte)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________
 my_functional_model(tf.constant([[2.0, 2.0, 2.0]]))
 <tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[3.4276495, 2.937252 ]], dtype=float32)>
 La principal diferencia aquí es que la forma de entrada se especifica por delante como parte del proceso de construcción funcional. argumento en este caso no tiene que ser completamente especificado; puede dejar algunas dimensiones como . input_shape None 
 
 Nota: No es necesario especificar input_shape o un InputLayer en un modelo subclasificado; estos argumentos y capas se ignorarán. Nota: No es necesario especificar input_shape o un InputLayer en un modelo subclasificado; estos argumentos y capas se ignorarán. Salvar los modelos de Keras Los modelos Keras tienen su propio formato especializado de almacenamiento de archivos zip, marcado por la Extensión: Cuando se llama Añade a Extensión del archivo, por ejemplo: .keras tf.keras.Model.save .keras my_sequential_model.save("exname_of_file.keras")
 Igualmente fácilmente, se pueden cargar de nuevo en: reconstructed_model = tf.keras.models.load_model("exname_of_file.keras")
 Archivo Zip - archivos - también guarda los estados de métrica, pérdida y optimizador. .keras Este modelo reconstruido se puede utilizar y producirá el mismo resultado cuando se llama a los mismos datos: reconstructed_model(tf.constant([[2.0, 2.0, 2.0]]))
 <tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[ 0.26034355, 16.431221  ]], dtype=float32)>
 Verificación de los modelos de Keras Los modelos de Keras también se pueden comprobar, y que se verá lo mismo que . tf.Module Hay más que saber sobre el almacenamiento y la serialización de los modelos Keras, incluyendo el suministro de métodos de configuración para capas personalizadas para el soporte de características. . Guía para ahorrar y serializar ¿Qué es lo siguiente Si desea saber más detalles sobre Keras, puede seguir las guías Keras existentes . Aquí Otro ejemplo de una API de alto nivel construida en es Sonnet de DeepMind, que está cubierto en . tf.module su sitio 
 
 Originalmente publicado en el sitio web de TensorFlow, este artículo aparece aquí bajo un nuevo título y está licenciado bajo CC BY 4.0. Originalmente publicado en la Este artículo aparece aquí bajo un nuevo título y está licenciado bajo CC BY 4.0. TensorFlow TensorFlow

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Este audio es producido en el idioma original de la historia!

Construir, entrenar y guardar modelos usando Keras y tf.Module

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

El modelo Bitcoin UTXO, impulsando un ecosistema único

La fuga rápida del sistema Claude Sonnet 3.5: un análisis forense

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

El modelo Bitcoin UTXO, impulsando un ecosistema único

La fuga rápida del sistema Claude Sonnet 3.5: un análisis forense

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps