Geekly articles weekly

Revisión de Keras para TensorFlow



Traducción de la guía general de Tensorflow.org. Esta guía le dará los conceptos básicos para comenzar a usar Keras. La lectura lleva 10 minutos.

Importar tf.keras


tf.keras es una implementación de la especificación API TensorFlow Keras. Esta es una API de alto nivel para construir y entrenar modelos que incluye soporte de primera clase para funcionalidades específicas de TensorFlow como ejecución ansiosa , tuberías de datos tf.data y estimadores . tf.keras facilita el uso de TensorFlow sin sacrificar la flexibilidad y el rendimiento.

Para comenzar, importe tf.keras como parte de su configuración de TensorFlow:

 from __future__ import absolute_import, division, print_function, unicode_literals import tensorflow as tf from tensorflow import keras

tf.keras puede ejecutar cualquier código compatible con Keras, pero tenga en cuenta:

  • La versión de tf.keras en la última versión de TensorFlow puede ser diferente de la última versión de keras en PyPI. Echa un vistazo a tf.keras.__version__ .
  • Cuando guarda los pesos del modelo, tf.keras hace de manera predeterminada en formato de punto de control. Pase el save_format='h5' para usar HDF5 (o agregue la extensión .h5 al .h5 del archivo).

Construye un modelo simple


Modelo secuencial


En Keras, recolecta capas para construir modelos . Un modelo es un gráfico de capa (generalmente). El tipo de modelo más común es la pila de capas: tf.keras.Sequential . Modelo tf.keras.Sequential .

Construimos una red simple totalmente conectada (es decir, un perceptrón multicapa):

 from tensorflow.keras import layers model = tf.keras.Sequential() #       64 : model.add(layers.Dense(64, activation='relu')) #   : model.add(layers.Dense(64, activation='relu')) #   softmax  10 : model.add(layers.Dense(10, activation='softmax'))

Personaliza capas


Muchas variedades de capas tf.keras.layers están tf.keras.layers . La mayoría de ellos usa un constructor de argumento común:

  • activation : establece la función de activación para la capa. Este parámetro especifica el nombre de la función incorporada o el objeto llamado. El parámetro no tiene valor predeterminado.
  • kernel_initializer y bias_initializer : esquemas de inicialización que crean pesos de capa (núcleo y desplazamiento). Este parámetro puede ser el nombre o el objeto llamado. El inicializador predeterminado es "Glorot uniform" .
  • kernel_regularizer y bias_regularizer : esquemas de regularización agregados a los pesos de capa (núcleo y desplazamiento), como la regularización L1 o L2. Por defecto, la regularización no está establecida.

Los siguientes ejemplos de instancias de las capas `tf.keras.layers.Dense` usan argumentos de constructor:

 #    : layers.Dense(64, activation='sigmoid') # : layers.Dense(64, activation=tf.keras.activations.sigmoid) #     L1   0.01    : layers.Dense(64, kernel_regularizer=tf.keras.regularizers.l1(0.01)) #     L2   0.01    : layers.Dense(64, bias_regularizer=tf.keras.regularizers.l2(0.01)) #        : layers.Dense(64, kernel_initializer='orthogonal') #        2.0: layers.Dense(64, bias_initializer=tf.keras.initializers.Constant(2.0))

Entrenamiento y evaluación


Configuración de entrenamiento


Después de construir el modelo, configure el proceso de aprendizaje llamando al método de compile :

 model = tf.keras.Sequential([ #     64   : layers.Dense(64, activation='relu', input_shape=(32,)), #  : layers.Dense(64, activation='relu'), #   softmax  10 : layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='categorical_crossentropy', metrics=['accuracy'])

tf.keras.Model.compile acepta tres argumentos importantes:

  • optimizer : Este objeto define el procedimiento de entrenamiento. Pase instancias de optimizador desde el módulo tf.keras.optimizers , como tf.keras.optimizers.Adam o tf.keras.optimizers.SGD . Si solo desea utilizar las opciones predeterminadas, también puede especificar optimizadores con palabras clave como 'adam' o 'sgd' .
  • loss : esta es una función que se minimiza en el proceso de aprendizaje. Entre las variaciones comunes están el error estándar ( mse ), categorical_crossentropy , binary_crossentropy . Las funciones de pérdida se especifican por nombre o pasando el objeto llamado desde el módulo tf.keras.losses .
  • metrics : se utilizan para monitorear la capacitación. Estos son nombres de cadenas u objetos llamados del módulo tf.keras.metrics .
  • Además, para asegurarse de que el modelo esté entrenado y evaluado con entusiasmo, verifique que pase el parámetro run_eagerly=True al compilador

A continuación, veremos algunos ejemplos de configuración de modelos para capacitación:

 #       . model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='mse', # mean squared error metrics=['mae']) # mean absolute error #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.01), loss=tf.keras.losses.CategoricalCrossentropy(), metrics=[tf.keras.metrics.CategoricalAccuracy()])

Aprendiendo de los datos de NumPy


Para conjuntos de datos más pequeños, use las matrices de memoria de NumPy para capacitación y evaluación de modelos. El modelo está "entrenado" en datos de entrenamiento utilizando el método `fit`:

 import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.fit(data, labels, epochs=10, batch_size=32)

tf.keras.Model.fit toma tres argumentos importantes:

  • epochs : el aprendizaje se divide en * era *. La era es una iteración sobre todos los datos de entrada (esto se hace en pequeños lotes).
  • batch_size : al transmitir datos NumPy, el modelo divide los datos en bloques más pequeños (lotes) e itera sobre estos bloques durante el entrenamiento. Este número indica el tamaño de cada bloque de datos. Recuerde que el último bloque puede ser más pequeño si el número total de registros no se divide por el tamaño del lote.
  • validation_data : al crear prototipos de un modelo, desea realizar un seguimiento fácil de su rendimiento en los datos de validación. Al pasar una tupla de datos de entrada y etiquetas con este argumento, el modelo puede mostrar los valores de la función de pérdida y las métricas en modo de salida para los datos que se transmiten al final de cada era.

Aquí hay un ejemplo usando validation_data :

 import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) val_data = np.random.random((100, 32)) val_labels = np.random.random((100, 10)) model.fit(data, labels, epochs=10, batch_size=32, validation_data=(val_data, val_labels))

Entrenamiento usando conjuntos de datos tf.data


Use la API de conjuntos de datos para escalar grandes bases de datos o capacitación en múltiples dispositivos. Pase la instancia de `tf.data.Dataset` al método de fit :

 #    : dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.fit(dataset, epochs=10)

Dado que Dataset proporciona datos en lotes, este código no requiere el argumento batch_size .

Los conjuntos de datos también se pueden usar para validar:

 dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels)) val_dataset = val_dataset.batch(32) model.fit(dataset, epochs=10, validation_data=val_dataset)

Valoración y predicción


Los tf.keras.Model.predict tf.keras.Model.evaluate y tf.keras.Model.predict pueden usar los tf.data.Dataset NumPy y tf.data.Dataset .

Así es como puede estimar las pérdidas en el modo de salida y las métricas para los datos proporcionados:

 #   Numpy data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.evaluate(data, labels, batch_size=32) #   dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.evaluate(dataset)

Y aquí está cómo predecir la salida del último nivel en modo de salida para los datos proporcionados en forma de una matriz NumPy:

Construyendo modelos complejos


La API funcional


El modelo tf.keras.Sequential es una pila de capas simple con la que no puede imaginar un modelo arbitrario. Utilice la API funcional de Keras para crear topologías de modelos complejos, como:

  • Múltiples modelos de entrada
  • Modelos con múltiples salidas,
  • Modelos con capas comunes (la misma capa se llama varias veces),
  • Modelos con flujos de datos inconsistentes (por ejemplo, relaciones residuales).

La construcción de un modelo con una API funcional funciona de la siguiente manera:

  1. La instancia de capa es invocable y devuelve un tensor.
  2. Los tensores de entrada y salida se utilizan para determinar la instancia de tf.keras.Model
  3. Este modelo está entrenado como el modelo 'secuencial'.

El siguiente ejemplo usa la API funcional para construir una red simple y completamente conectada:

 inputs = tf.keras.Input(shape=(32,)) #    #        . x = layers.Dense(64, activation='relu')(inputs) x = layers.Dense(64, activation='relu')(x) predictions = layers.Dense(10, activation='softmax')(x)

Cree una instancia del modelo con estas entradas y salidas.

 model = tf.keras.Model(inputs=inputs, outputs=predictions) #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5  model.fit(data, labels, batch_size=32, epochs=5)

Modelos de subclases


Cree un modelo totalmente personalizable utilizando la subclase tf.keras.Model y definiendo su propia distribución directa. Cree capas en el método __init__ y __init__ como atributos de la instancia de clase. Definir propagación directa en el método de call .

Subclasificar un modelo es especialmente útil cuando se habilita la ejecución ansiosa, ya que le permite escribir la distribución directa de manera imperativa.

Nota: si desea que su modelo se ejecute siempre imperativamente, puede establecer dynamic=True cuando llame al super .
Punto clave: utilice la API correcta para trabajar. Si bien la subclasificación de un modelo proporciona flexibilidad, debe pagarlo con mayor complejidad y mayor potencial de errores personalizados. Si es posible, elija la API funcional.
El siguiente ejemplo muestra un modelo subclases tf.keras.Model que usa distribución directa personalizada, que no es obligatorio que sea obligatorio:

 class MyModel(tf.keras.Model): def __init__(self, num_classes=10): super(MyModel, self).__init__(name='my_model') self.num_classes = num_classes #    . self.dense_1 = layers.Dense(32, activation='relu') self.dense_2 = layers.Dense(num_classes, activation='sigmoid') def call(self, inputs): #     , #      ( `__init__`). x = self.dense_1(inputs) return self.dense_2(x)

Cree una instancia de la nueva clase de modelo:

 model = MyModel(num_classes=10) #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5 . model.fit(data, labels, batch_size=32, epochs=5)

Capas personalizadas


Cree una capa personalizada subclasificando tf.keras.layers.Layer e implementando los siguientes métodos:

  • __init__ : opcionalmente, especifique las subcapas que se utilizarán en esta capa.
  • * build : crear pesos de capa. Agregue pesos utilizando el método add_weight
  • call : Definir distribución directa.
  • Opcionalmente, la capa se puede serializar implementando el método get_config y el from_config clase from_config .

A continuación se muestra un ejemplo de una capa de usuario que multiplica la matriz ( matmul ) presentada con la entrada de matriz del núcleo:

 class MyLayer(layers.Layer): def __init__(self, output_dim, **kwargs): self.output_dim = output_dim super(MyLayer, self).__init__(**kwargs) def build(self, input_shape): #       . self.kernel = self.add_weight(name='kernel', shape=(input_shape[1], self.output_dim), initializer='uniform', trainable=True) def call(self, inputs): return tf.matmul(inputs, self.kernel) def get_config(self): base_config = super(MyLayer, self).get_config() base_config['output_dim'] = self.output_dim return base_config @classmethod def from_config(cls, config): return cls(**config)

Crea un modelo usando tu capa personalizada:

 model = tf.keras.Sequential([ MyLayer(10), layers.Activation('softmax')]) #      model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5 . model.fit(data, labels, batch_size=32, epochs=5)

Kolbeki


Kolbek es un objeto transferido al modelo para personalizar y expandir su comportamiento durante el entrenamiento. Puede escribir su propia devolución de llamada personalizada o usar el tf.keras.callbacks que incluye:

tf.keras.callbacks.ModelCheckpoint : guardar puntos de interrupción del modelo a intervalos regulares.
tf.keras.callbacks.LearningRateScheduler : cambia dinámicamente el paso de aprendizaje.
tf.keras.callbacks.EarlyStopping : detiene el entrenamiento cuando el resultado de la validación deja de mejorar.
tf.keras.callbacks.TensorBoard: monitorizar el comportamiento del modelo mediante
Tensorboard

Para usar tf.keras.callbacks.Callback , tf.keras.callbacks.Callback al método de fit modelo:

 callbacks = [ #    `val_loss`     2  tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'), #   TensorBoard   `./logs` directory tf.keras.callbacks.TensorBoard(log_dir='./logs') ] model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks, validation_data=(val_data, val_labels))

Guardar y Restaurar


Guardar solo valores de peso


Guarde y cargue pesos de modelos utilizando tf.keras.Model.save_weights :

 model = tf.keras.Sequential([ layers.Dense(64, activation='relu', input_shape=(32,)), layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='categorical_crossentropy', metrics=['accuracy']) 

 #     TensorFlow Checkpoint model.save_weights('./weights/my_model') #    #        . model.load_weights('./weights/my_model')

Por defecto, los pesos del modelo se guardan en el formato de punto de control TensorFlow. Los pesos también se pueden guardar en formato Keras HDF5 (valor predeterminado para la implementación universal de Keras):

 #     HDF5 model.save_weights('my_model.h5', save_format='h5') #    model.load_weights('my_model.h5')

Guardar solo la configuración del modelo


La configuración del modelo se puede guardar; esto serializa la arquitectura del modelo sin ningún peso. Una configuración guardada puede restaurar e inicializar el mismo modelo, incluso sin código que defina el modelo original. Keras admite formatos de serialización JSON y YAML:

 #     JSON json_string = model.to_json() json_string 

 import json import pprint pprint.pprint(json.loads(json_string))

Restaurar un modelo (reinicializado) desde JSON:

 fresh_model = tf.keras.models.model_from_json(json_string)

Serializar el modelo a YAML requiere la instalación de `pyyaml` antes de importar TensorFlow :

 yaml_string = model.to_yaml() print(yaml_string)

Restaurando un modelo de YAML:

 fresh_model = tf.keras.models.model_from_yaml(yaml_string)

Nota: los modelos subclasificados no son serializables, porque su arquitectura está definida por el código Python en el cuerpo del método `call`.

Guardar todo el modelo en un archivo


Todo el modelo se puede guardar en un archivo que contiene los valores de los pesos, la configuración del modelo e incluso la configuración del optimizador. Esto le permitirá establecer un punto de interrupción del modelo y continuar entrenando más tarde desde exactamente la misma posición, incluso sin acceso al código fuente.

 #    model = tf.keras.Sequential([ layers.Dense(10, activation='softmax', input_shape=(32,)), layers.Dense(10, activation='softmax') ]) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(data, labels, batch_size=32, epochs=5) #      HDF5 model.save('my_model.h5') #         . model = tf.keras.models.load_model('my_model.h5')

Ansiosa ejecución


La ejecución ansiosa es un entorno de programación imperativo que realiza operaciones de inmediato. Esto no es necesario para Keras, pero es compatible con tf.keras y es útil para verificar su programa y depurar.

Todos los modelos de construcción de la API `tf.keras` son compatibles con la ejecución ansiosa. Aunque se pueden usar las API `secuenciales` y funcionales, la ejecución ansiosa es especialmente útil cuando se subclasifica un modelo y se crean capas personalizadas ; estas API requieren que escriba una distribución directa en forma de código (en lugar de las API que crean modelos ensamblando capas existentes).

Distribución


Múltiples GPU


tf.keras modelos tf.keras se pueden ejecutar en múltiples GPU usando tf.distribute.Strategy . Esta API proporciona aprendizaje distribuido en múltiples GPU con poco o ningún cambio en el código existente.

Actualmente, tf.distribute.MirroredStrategy única estrategia de distribución compatible. MirroredStrategy replica gráficos con
Aprendizaje sincrónico con All-Reduce en una máquina. Para usar ' distribute.Strategy . Strategy ', anide la instalación del optimizador, el diseño y la compilación del modelo en ` Strategy .

El siguiente ejemplo distribuye tf.keras.Model entre múltiples GPU en la misma máquina.

Primero, definimos un modelo dentro del área de una estrategia distribuida:

 strategy = tf.distribute.MirroredStrategy() with strategy.scope(): model = tf.keras.Sequential() model.add(layers.Dense(16, activation='relu', input_shape=(10,))) model.add(layers.Dense(1, activation='sigmoid')) optimizer = tf.keras.optimizers.SGD(0.2) model.compile(loss='binary_crossentropy', optimizer=optimizer) model.summary()

Luego entrenamos el modelo en los datos como de costumbre:

 x = np.random.random((1024, 10)) y = np.random.randint(2, size=(1024, 1)) x = tf.cast(x, tf.float32) dataset = tf.data.Dataset.from_tensor_slices((x, y)) dataset = dataset.shuffle(buffer_size=1024).batch(32) model.fit(dataset, epochs=1)

Después de la verificación, la traducción también aparecerá en Tensorflow.org. Si desea participar en la traducción de la documentación del sitio web de Tensorflow.org al ruso, comuníquese personalmente o envíe sus comentarios. Cualquier corrección o comentario son apreciados.

Source: https://habr.com/ru/post/482126/

More articles:


All Articles