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

tf.keras.Model

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

Model grupos capas en un objeto con funciones de entrenamiento y de inferencia.

Hereda de: Layer

Se utiliza en los cuadernos

Se utiliza en la guía Se utiliza en los tutoriales

inputs La entrada (s) del modelo: a keras.Input objeto o una lista de keras.Input objetos.
outputs La salida (s) del modelo. Véase el ejemplo de la API funcional a continuación.
name Cadena, el nombre del modelo.

Existen dos formas de ejecutar un Model :

1 - Con el "API funcional", donde se inicia a partir de Input , se encadenan llamadas de capa para especificar pase hacia adelante del modelo, y finalmente se crea el modelo de las entradas y salidas:

 import tensorflow as tf

inputs = tf.keras.Input(shape=(3,))
x = tf.keras.layers.Dense(4, activation=tf.nn.relu)(inputs)
outputs = tf.keras.layers.Dense(5, activation=tf.nn.softmax)(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs)
 

2 - Por la subclasificación del Model de clases: en ese caso, debe definir sus capas en __init__ y se debe implementar pase hacia adelante del modelo en call .

 import tensorflow as tf

class MyModel(tf.keras.Model):

  def __init__(self):
    super(MyModel, self).__init__()
    self.dense1 = tf.keras.layers.Dense(4, activation=tf.nn.relu)
    self.dense2 = tf.keras.layers.Dense(5, activation=tf.nn.softmax)

  def call(self, inputs):
    x = self.dense1(inputs)
    return self.dense2(x)

model = MyModel()
 

Si subclase Model , puede tener opcionalmente un training argumento (booleano) en la call , que se puede utilizar para especificar un comportamiento diferente en el entrenamiento y la inferencia:

 import tensorflow as tf

class MyModel(tf.keras.Model):

  def __init__(self):
    super(MyModel, self).__init__()
    self.dense1 = tf.keras.layers.Dense(4, activation=tf.nn.relu)
    self.dense2 = tf.keras.layers.Dense(5, activation=tf.nn.softmax)
    self.dropout = tf.keras.layers.Dropout(0.5)

  def call(self, inputs, training=False):
    x = self.dense1(inputs)
    if training:
      x = self.dropout(x, training=training)
    return self.dense2(x)

model = MyModel()
 

Una vez creado el modelo, puede config el modelo con las pérdidas y las métricas con model.compile() , entrenar el modelo con model.fit() , o utilizar el modelo para hacer predicciones con model.predict() .

distribute_strategy El tf.distribute.Strategy este modelo fue creado bajo.
layers

metrics_names Devuelve etiquetas de visualización del modelo para todas las salidas.

inputs = tf.keras.layers.Input(shape=(3,))
outputs = tf.keras.layers.Dense(2)(inputs)
model = tf.keras.models.Model(inputs=inputs, outputs=outputs)
model.compile(optimizer="Adam", loss="mse", metrics=["mae"])
model.metrics_names
[]
x = np.random.random((2, 3))
y = np.random.randint(0, 2, (2, 2))
model.fit(x, y)
model.metrics_names
['loss', 'mae']
inputs = tf.keras.layers.Input(shape=(3,))
d = tf.keras.layers.Dense(2, name='out')
output_1 = d(inputs)
output_2 = d(inputs)
model = tf.keras.models.Model(
   inputs=inputs, outputs=[output_1, output_2])
model.compile(optimizer="Adam", loss="mse", metrics=["mae", "acc"])
model.fit(x, (y, y))
model.metrics_names
['loss', 'out_loss', 'out_1_loss', 'out_mae', 'out_acc', 'out_1_mae',
'out_1_acc']

run_eagerly atributo configurable que indica si el modelo debe funcionar con impaciencia.

Correr con impaciencia significa que su modelo se llevará a cabo paso a paso, al igual que el código Python. Su modelo podría correr más lento, pero debería ser más fácil para usted para depurarlo por entrar en las llamadas capas individuales.

Por defecto, vamos a tratar de compilar el modelo de un gráfico estático para ofrecer el mejor rendimiento de ejecución.

Métodos

compile

Ver fuente

Configura el modelo de formación.

argumentos
optimizer String (nombre del optimizador) o instancia optimizador. Ver tf.keras.optimizers .
loss String (nombre de la función objetivo), la función objetiva o tf.keras.losses.Loss ejemplo. Ver tf.keras.losses . Una función objetivo es cualquier exigible con la firma loss = fn(y_true, y_pred) , donde y_true = valores de verdad suelo con forma = [batch_size, d0, .. dN] , excepto las funciones de pérdida dispersos tales como crossentropy categórica escasa donde forma = [batch_size, d0, .. dN-1] . y_pred = valores predichos con forma = [batch_size, d0, .. dN] . Devuelve un tensor flotante pérdida ponderada. Si una costumbre Loss se utiliza ejemplo y la reducción se ajusta a NINGUNO, valor de retorno tiene la forma [batch_size, d0, .. dN-1], es decir. por muestra o per-timestep valores de pérdida; de lo contrario, es un escalar. Si el modelo tiene varias salidas, se puede utilizar una pérdida distinta en cada salida, pasando un diccionario o una lista de las pérdidas. El valor de la pérdida que será minimizado por el modelo será entonces la suma de todas las pérdidas individuales.
metrics Lista de métricas para ser evaluado por el modelo durante el entrenamiento y prueba. Cada uno de esto puede ser una cadena (nombre de una función incorporada), función o un tf.keras.metrics.Metric ejemplo. Ver tf.keras.metrics . Por lo general va a utilizar metrics=['accuracy'] . Una función es cualquier exigible con la firma result = fn(y_true, y_pred) . Para especificar diferentes métricas para diferentes salidas de un modelo de múltiples salidas, también se puede pasar a un diccionario, como metrics={'output_a': 'accuracy', 'output_b': ['accuracy', 'mse']} . También puede pasar una lista (len = len (salidas)) de las listas de métricas tales como metrics=[['accuracy'], ['accuracy', 'mse']] o metrics=['accuracy', ['accuracy', 'mse']] . Cuando se pasa las cadenas 'exactitud' o 'ACC', convertimos esto a uno de tf.keras.metrics.BinaryAccuracy , tf.keras.metrics.CategoricalAccuracy , tf.keras.metrics.SparseCategoricalAccuracy basado en la función de pérdida utilizada y la forma de salida del modelo. Hacemos una conversión similar para las cadenas 'crossentropy' y 'ce' también.
loss_weights lista opcional o coeficientes escalares especificando diccionario Python (flota) para ponderar las contribuciones de pérdida de los diferentes resultados de los modelos. El valor de pérdida que se reduce al mínimo por el modelo será entonces la suma ponderada de todas las pérdidas individuales, ponderado por los loss_weights coeficientes. Si una lista, que se espera que tenga una relación 1: 1 asignación a las salidas del modelo. Si un diccionario, se espera para asignar nombres de salida (cadenas) a coeficientes escalares.
weighted_metrics Lista de métricas para ser evaluado y ponderado por sample_weight o class_weight durante el entrenamiento y prueba.
run_eagerly Bool. El valor predeterminado es False . Si True , este Model de lógica 's no será envuelto en una tf.function . Recomienda dejar esto como None menos que su Model no se puede ejecutar dentro de un tf.function .
**kwargs Ningún argumento adicional. Los argumentos soportados:

  • experimental_steps_per_execution : Int. El número de lotes para ejecutar durante cada tf.function llamada. La ejecución de varios lotes dentro de una sola tf.function llamada puede mejorar en gran medida el rendimiento de TPU o pequeños modelos con una gran