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

tf.keras.optimizers.SGD

plus par

Tensorflow 1 Version Voir la source sur GitHub

optimiseur descente de gradient (avec élan).

Hérite de: Optimizer

Utilisé dans les ordinateurs portables

Utilisé dans le guide Utilisé dans les tutoriels

Règle de mise à jour pour le paramètre w avec gradient g lorsque la momentum est 0:

 w = w - learning_rate * g
 

Mettre à jour la règle lorsque la momentum est supérieure à 0:

 velocity = momentum * velocity - learning_rate * g
w = w * velocity
 

Lorsque nesterov=False , cette règle devient:

 velocity = momentum * velocity - learning_rate * g
w = w + momentum * velocity - learning_rate * g
 

learning_rate A Tensor , valeur à virgule flottante, ou un horaire qui est un tf.keras.optimizers.schedules.LearningRateSchedule , ou un appelable qui ne prend aucun argument et retourne la valeur réelle de l' utilisation. Le taux d'apprentissage. La valeur par défaut de 0,01.
momentum flotteur hyperparamètres> = 0 qui permet d'accélérer la descente de gradient dans les oscillations de direction et amortit pertinents. Par défaut, 0, par exemple, descente de gradient de vanille.
nesterov booléen. Que ce soit pour appliquer l'élan Nesterov. Par défaut False .
name préfixe du nom facultatif pour les opérations créé lors de l'application des gradients. La valeur par défaut "SGD" .
**kwargs arguments de mots-clés. Autorisé à être l' un des "clipnorm" ou "clipvalue" . "clipnorm" clips (float) gradients par la norme; "clipvalue" clips (float) gradients par valeur.

Usage:

opt = tf.keras.optimizers.SGD(learning_rate=0.1)
var = tf.Variable(1.0)
loss = lambda: (var ** 2)/2.0         # d(loss)/d(var1) = var1
step_count = opt.minimize(loss, [var]).numpy()
# Step is `- learning_rate * grad`
var.numpy()
0.9
opt = tf.keras.optimizers.SGD(learning_rate=0.1, momentum=0.9)
var = tf.Variable(1.0)
val0 = var.value()
loss = lambda: (var ** 2)/2.0         # d(loss)/d(var1) = var1
# First step is `- learning_rate * grad`
step_count = opt.minimize(loss, [var]).numpy()
val1 = var.value()
(val0 - val1).numpy()
0.1
# On later steps, step-size increases because of momentum
step_count = opt.minimize(loss, [var]).numpy()
val2 = var.value()
(val1 - val2).numpy()
0.18

Référence:

name Une chaîne non vide. Le nom à utiliser pour les accumulateurs créés pour l'optimiseur.
**kwargs arguments mot-clé. Autorisé à être { clipnorm , clipvalue , lr , decay }. clipnorm est gradients de clip par la norme; clipvalue est gradients de clip en valeur, la decay est inclus pour assurer la compatibilité en arrière pour permettre la décomposition inverse de la période de taux d' apprentissage. lr est la compatibilité ascendante, recommandé d'utiliser learning_rate à la place.

ValueError Si le nom est malformé.

iterations Variable. Le nombre de formations étapes ce Optimizer a été exécuté.
weights variables retours de ce Optimizer en fonction de l'ordre créé.

méthodes

add_slot

Voir la source

Ajouter une nouvelle variable slot pour var .

add_weight

Voir la source

apply_gradients

Voir la source

Appliquer des gradients variables.

Ceci est la deuxième partie de minimize() . Il renvoie une Operation qui applique des gradients.

La méthode résume les gradients de toutes les répliques en présence de tf.distribute.Strategy par défaut. Vous pouvez regrouper vous gradients en passant experimental_aggregate_gradients=False .

Exemple:

 grads = tape.gradient(loss, vars)
grads = tf.distribute.get_replica_context().all_reduce('sum', grads)
# Processing aggregated gradients.
optimizer.apply_gradients(zip(grads, vars),
    experimental_aggregate_gradients=False)

 

args
grads_and_vars Liste des paires (gradient, variable).
name Nom facultatif pour l'opération de retour. Par défaut le nom est passé à l' Optimizer constructeur.
experimental_aggregate_gradients Que ce soit pour additionner des gradients de différentes répliques dans le presense de tf.distribute.Strategy . Si elle est fausse, il la responsabilité de l'utilisateur d'agréger les gradients. Par défaut True.

Retour
Une Operation qui applique les gradients déterminés. Les iterations seront automatiquement augmentées par 1.

relances
TypeError Si grads_and_vars est malformé.
ValueError Si aucune des variables ont des gradients.

from_config

Voir la source

Crée un optimiseur de sa configuration.

Cette méthode est l'inverse de get_config , capable d'instancier le même optimiseur à partir du dictionnaire de configuration.

Arguments
config Un dictionnaire Python, généralement la sortie de get_config.
custom_objects Un nom de mappage Python dictionnaire Python supplémentaire des objets utilisés pour créer cette optimiseur, comme une fonction utilisée pour une hyperparam'etre.

Retour
Un exemple d'optimisation.

get_config

Voir la source

Retourne la configuration de l'optimiseur.

Une configuration d'optimisation est un dictionnaire Python (de serializable) contenant la configuration d'un optimiseur. Le même optimiseur peut être reinstantiated plus tard (sans état enregistré) de cette configuration.

Retour
dictionnaire Python.

get_gradients

Voir la source

Renvoie des gradients de loss par rapport à params .

Arguments
loss tenseur perte.
params Liste des variables.

Retour
Liste des tenseurs gradient.

relances
ValueError Dans le cas où un gradient ne peut être calculée (par exemple, si la fonction de gradient non mise en œuvre).

get_slot

Voir la source