Cette page a été traduite par l'API Cloud Translation.
Switch to English

tf.keras.Model

Tensorflow 1 Version Voir la source sur GitHub

Model couches groupes dans un objet avec des fonctions de formation et d' inférence.

Hérite de: Layer

Utilisé dans les ordinateurs portables

Utilisé dans le guide Utilisé dans les tutoriels

inputs L'entrée (s) du modèle: un keras.Input objet ou une liste de keras.Input objets.
outputs La sortie (s) du modèle. Voir l'exemple de l'API fonctionnelle ci-dessous.
name String, le nom du modèle.

Il y a deux façons d' exécution d'un Model :

1 - Avec la « API fonctionnelle », où vous commencez à partir de l' Input , vous enchaînez les appels de calque pour définir passe en avant du modèle, et enfin vous créez votre modèle à partir des entrées et des sorties:

 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 - Par le sous - classement Model classe: dans ce cas, vous devez définir vos couches en __init__ et vous devez mettre en œuvre passe avant dans le modèle 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 vous sous - classe Model , vous pouvez éventuellement avoir une training argument (booléenne) dans l' call , que vous pouvez utiliser pour spécifier un comportement différent dans la formation et l' inférence:

 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()
 

Une fois le modèle créé, vous pouvez le modèle config avec des pertes et des mesures avec model.compile() , former le modèle avec model.fit() , ou utiliser le modèle pour faire la prédiction avec model.predict() .

distribute_strategy Le tf.distribute.Strategy ce modèle a été créé sous.
layers

metrics_names Renvoie les étiquettes d'affichage du modèle pour toutes les sorties.

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 attribut indiquant si le Programmable modèle devrait fonctionner avec impatience.

Courir signifie avec impatience que votre modèle sera exécuté étape par étape, comme le code Python. Votre modèle pourrait fonctionner plus lentement, mais il devrait être plus facile pour vous de déboguer en entrant dans les appels de couche individuels.

Par défaut, nous tenterons de compiler votre modèle à un graphique statique pour offrir les meilleures performances d'exécution.

méthodes

compile

Voir la source

Configure le modèle de formation.

Arguments
optimizer String (nom de optimiseur) ou une instance d'optimisation. Voir tf.keras.optimizers .
loss String (nom de fonction objectif), fonction objective ou tf.keras.losses.Loss par exemple. Voir tf.keras.losses . Une fonction objective est tout appelable avec la signature loss = fn(y_true, y_pred) , où y_true = valeurs de vérité de sol de forme = [batch_size, d0, .. dN] , à l' exception des fonctions rares de perte , tels que crossentropy catégorique clairsemé , où la forme = [batch_size, d0, .. dN-1] . y_pred = valeurs prédites de forme = [batch_size, d0, .. dN] . Il renvoie un tenseur de flotteur lesté de perte. Si une coutume Loss instance est utilisée et la réduction est réglée sur NONE, la valeur de retour a la forme [batch_size, d0, .. Dn-1] par exemple. par échantillon ou par-timestep des valeurs de perte; sinon, il est un scalaire. Si le modèle a plusieurs sorties, vous pouvez utiliser une perte différente sur chaque sortie par le passage d'un dictionnaire ou d'une liste des pertes. La valeur de la perte qui sera réduite au minimum par le modèle sera alors la somme de toutes les pertes individuelles.
metrics Liste des mesures à évaluer par le modèle lors de la formation et de test. Chacun de cela peut être une chaîne (nom d'une fonction intégrée), la fonction ou une tf.keras.metrics.Metric instance. Voir tf.keras.metrics . En général , vous utiliserez les metrics=['accuracy'] . Une fonction est tout appelable avec la signature result = fn(y_true, y_pred) . Pour spécifier différents paramètres pour différentes sorties d'un modèle multi-sorties, vous pouvez aussi passer un dictionnaire, comme les metrics={'output_a': 'accuracy', 'output_b': ['accuracy', 'mse']} . Vous pouvez également transmettre une liste (len = len (sorties)) des listes de mesures telles que les metrics=[['accuracy'], ['accuracy', 'mse']] ou metrics=['accuracy', ['accuracy', 'mse']] . Lorsque vous passez la précision de la «cordes ou 'acc, nous convertir en l' un des tf.keras.metrics.BinaryAccuracy ,