Avertissement : Cette API est obsolète et sera supprimée dans une future version de TensorFlow une fois que le remplacement sera stable.
StopGradient
bookmark_borderbookmark
Restez organisé à l'aide des collections
Enregistrez et classez les contenus selon vos préférences.
Arrête le calcul du gradient.
Lorsqu'elle est exécutée dans un graphique, cette opération génère son tenseur d'entrée tel quel.
Lors de la construction d'opérations pour calculer des gradients, cette opération empêche la prise en compte de la contribution de ses entrées. Normalement, le générateur de gradient ajoute des opérations à un graphique pour calculer les dérivées d'une « perte » spécifiée en recherchant de manière récursive les entrées qui ont contribué à son calcul. Si vous insérez cette opération dans le graphique, ses entrées sont masquées par le générateur de dégradé. Ils ne sont pas pris en compte pour le calcul des gradients.
Ceci est utile chaque fois que vous souhaitez calculer une valeur avec TensorFlow mais que vous devez prétendre que la valeur était une constante. Par exemple, la fonction softmax pour un vecteur x peut s'écrire
def softmax(x):
numerator = tf.exp(x)
denominator = tf.reduce_sum(numerator)
return numerator / denominator
Ceci est cependant susceptible de déborder si les valeurs de x sont grandes. Une autre manière plus stable consiste à soustraire le maximum de x de chacune des valeurs.
def stable_softmax(x):
z = x - tf.reduce_max(x)
numerator = tf.exp(z)
denominator = tf.reduce_sum(numerator)
return numerator / denominator
Cependant, lorsque nous effectuons une rétropropagation via le softmax vers x, nous ne voulons pas effectuer une rétropropagation via le calcul
tf.reduce_max(x)
(si les valeurs maximales ne sont pas uniques, le gradient pourrait se diriger vers la mauvaise entrée) et traiter cela comme une constante. Par conséquent, nous devrions écrire cela comme
def stable_softmax(x):
z = x - tf.stop_gradient(tf.reduce_max(x))
numerator = tf.exp(z)
denominator = tf.reduce_sum(numerator)
return numerator / denominator
Voici quelques autres exemples :
- L'algorithme EM où l' étape M ne devrait pas impliquer de rétropropagation via la sortie de l' étape E.
- Entraînement à divergence contrastée des machines Boltzmann où, lors de la différenciation de la fonction énergétique, l'entraînement ne doit pas se propager à travers le graphique qui a généré les échantillons à partir du modèle.
- Formation contradictoire, où aucun retour en arrière ne devrait se produire via le processus de génération d'exemples contradictoires.
Méthodes publiques
sortie publique <T> asOutput ()
Renvoie le handle symbolique d'un tenseur.
Les entrées des opérations TensorFlow sont les sorties d'une autre opération TensorFlow. Cette méthode est utilisée pour obtenir un handle symbolique qui représente le calcul de l’entrée.
Méthode d'usine pour créer une classe encapsulant une nouvelle opération StopGradient.
Retours
- une nouvelle instance de StopGradient
Sauf indication contraire, le contenu de cette page est régi par une licence Creative Commons Attribution 4.0, et les échantillons de code sont régis par une licence Apache 2.0. Pour en savoir plus, consultez les Règles du site Google Developers. Java est une marque déposée d'Oracle et/ou de ses sociétés affiliées.
Dernière mise à jour le 2025/07/25 (UTC).
[[["Facile à comprendre","easyToUnderstand","thumb-up"],["J'ai pu résoudre mon problème","solvedMyProblem","thumb-up"],["Autre","otherUp","thumb-up"]],[["Il n'y a pas l'information dont j'ai besoin","missingTheInformationINeed","thumb-down"],["Trop compliqué/Trop d'étapes","tooComplicatedTooManySteps","thumb-down"],["Obsolète","outOfDate","thumb-down"],["Problème de traduction","translationIssue","thumb-down"],["Mauvais exemple/Erreur de code","samplesCodeIssue","thumb-down"],["Autre","otherDown","thumb-down"]],["Dernière mise à jour le 2025/07/25 (UTC)."],[],[],null,["# StopGradient\n\npublic final class **StopGradient** \nStops gradient computation.\n\n\nWhen executed in a graph, this op outputs its input tensor as-is.\n\n\nWhen building ops to compute gradients, this op prevents the contribution of\nits inputs to be taken into account. Normally, the gradient generator adds ops\nto a graph to compute the derivatives of a specified 'loss' by recursively\nfinding out inputs that contributed to its computation. If you insert this op\nin the graph it inputs are masked from the gradient generator. They are not\ntaken into account for computing gradients.\n\n\nThis is useful any time you want to compute a value with TensorFlow but need\nto pretend that the value was a constant. For example, the softmax function\nfor a vector x can be written as \n\n def softmax(x):\n numerator = tf.exp(x)\n denominator = tf.reduce_sum(numerator)\n return numerator / denominator\n \nThis however is susceptible to overflow if the values in x are large. An alternative more stable way is to subtract the maximum of x from each of the values. \n\n def stable_softmax(x):\n z = x - tf.reduce_max(x)\n numerator = tf.exp(z)\n denominator = tf.reduce_sum(numerator)\n return numerator / denominator\n \nHowever, when we backprop through the softmax to x, we dont want to backprop through the [`tf.reduce_max(x)`](https://www.tensorflow.org/api_docs/python/tf/math/reduce_max) (if the max values are not unique then the gradient could flow to the wrong input) calculation and treat that as a constant. Therefore, we should write this out as \n\n def stable_softmax(x):\n z = x - tf.stop_gradient(tf.reduce_max(x))\n numerator = tf.exp(z)\n denominator = tf.reduce_sum(numerator)\n return numerator / denominator\n \nSome other examples include:\n\n- The *EM* algorithm where the *M-step* should not involve backpropagation through the output of the *E-step*.\n- Contrastive divergence training of Boltzmann machines where, when differentiating the energy function, the training must not backpropagate through the graph that generated the samples from the model.\n- Adversarial training, where no backprop should happen through the adversarial example generation process.\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n### Public Methods\n\n|--------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| [Output](/api_docs/java/org/tensorflow/Output)\\\u003cT\\\u003e | [asOutput](/api_docs/java/org/tensorflow/op/core/StopGradient#asOutput())() Returns the symbolic handle of a tensor. |\n| static \\\u003cT\\\u003e [StopGradient](/api_docs/java/org/tensorflow/op/core/StopGradient)\\\u003cT\\\u003e | [create](/api_docs/java/org/tensorflow/op/core/StopGradient#create(org.tensorflow.op.Scope,%20org.tensorflow.Operand\u003cT\u003e))([Scope](/api_docs/java/org/tensorflow/op/Scope) scope, [Operand](/api_docs/java/org/tensorflow/Operand)\\\u003cT\\\u003e input) Factory method to create a class wrapping a new StopGradient operation. |\n| [Output](/api_docs/java/org/tensorflow/Output)\\\u003cT\\\u003e | [output](/api_docs/java/org/tensorflow/op/core/StopGradient#output())() |\n\n### Inherited Methods\n\nFrom class [org.tensorflow.op.PrimitiveOp](/api_docs/java/org/tensorflow/op/PrimitiveOp) \n\n|------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|\n| final boolean | [equals](/api_docs/java/org/tensorflow/op/PrimitiveOp#equals(java.lang.Object))(Object obj) |\n| final int | [hashCode](/api_docs/java/org/tensorflow/op/PrimitiveOp#hashCode())() |\n| [Operation](/api_docs/java/org/tensorflow/Operation) | [op](/api_docs/java/org/tensorflow/op/PrimitiveOp#op())() Returns the underlying [Operation](/api_docs/java/org/tensorflow/Operation) |\n| final String | [toString](/api_docs/java/org/tensorflow/op/PrimitiveOp#toString())() |\n\nFrom class java.lang.Object \n\n|------------------|---------------------------|\n| boolean | equals(Object arg0) |\n| final Class\\\u003c?\\\u003e | getClass() |\n| int | hashCode() |\n| final void | notify() |\n| final void | notifyAll() |\n| String | toString() |\n| final void | wait(long arg0, int arg1) |\n| final void | wait(long arg0) |\n| final void | wait() |\n\nFrom interface [org.tensorflow.Operand](/api_docs/java/org/tensorflow/Operand) \n\n|--------------------------------------------------------------|---------------------------------------------------------------------------------------------------------|\n| abstract [Output](/api_docs/java/org/tensorflow/Output)\\\u003cT\\\u003e | [asOutput](/api_docs/java/org/tensorflow/Operand#asOutput())() Returns the symbolic handle of a tensor. |\n\nPublic Methods\n--------------\n\n#### public [Output](/api_docs/java/org/tensorflow/Output)\\\u003cT\\\u003e\n**asOutput**\n()\n\nReturns the symbolic handle of a tensor.\n\nInputs to TensorFlow operations are outputs of another TensorFlow operation. This method is\nused to obtain a symbolic handle that represents the computation of the input.\n\n\u003cbr /\u003e\n\n#### public static [StopGradient](/api_docs/java/org/tensorflow/op/core/StopGradient)\\\u003cT\\\u003e\n**create**\n([Scope](/api_docs/java/org/tensorflow/op/Scope) scope, [Operand](/api_docs/java/org/tensorflow/Operand)\\\u003cT\\\u003e input)\n\nFactory method to create a class wrapping a new StopGradient operation. \n\n##### Parameters\n\n| scope | current scope |\n|-------|---------------|\n\n##### Returns\n\n- a new instance of StopGradient \n\n#### public [Output](/api_docs/java/org/tensorflow/Output)\\\u003cT\\\u003e\n**output**\n()\n\n\u003cbr /\u003e"]]