Advertencia: esta API está obsoleta y se eliminará en una versión futura de TensorFlow una vez que el reemplazo sea estable.
StopGradient
bookmark_borderbookmark
Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
Detiene el cálculo del gradiente.
Cuando se ejecuta en un gráfico, esta operación genera su tensor de entrada tal cual.
Al crear operaciones para calcular gradientes, esta operación evita que se tenga en cuenta la contribución de sus entradas. Normalmente, el generador de gradientes agrega operaciones a un gráfico para calcular las derivadas de una "pérdida" específica al encontrar recursivamente las entradas que contribuyeron a su cálculo. Si inserta esta opción en el gráfico, las entradas se enmascaran del generador de gradiente. No se tienen en cuenta para calcular los gradientes.
Esto es útil cada vez que desea calcular un valor con TensorFlow pero necesita pretender que el valor era una constante. Por ejemplo, la función softmax para un vector x se puede escribir como
def softmax(x):
numerator = tf.exp(x)
denominator = tf.reduce_sum(numerator)
return numerator / denominator
Sin embargo, esto es susceptible de desbordarse si los valores en x son grandes. Una forma alternativa más estable es restar el máximo de x de cada uno de los valores.
def stable_softmax(x):
z = x - tf.reduce_max(x)
numerator = tf.exp(z)
denominator = tf.reduce_sum(numerator)
return numerator / denominator
Sin embargo, cuando hacemos backprop a través del softmax a x, no queremos backprop a través del
tf.reduce_max(x)
(si los valores máximos no son únicos, entonces el gradiente podría fluir a la entrada incorrecta) y tratarlo como una constante. Por lo tanto, deberíamos escribir esto como
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
Algunos otros ejemplos incluyen:
- El algoritmo EM en el que el paso M no debe implicar una retropropagación a través de la salida del paso E.
- Entrenamiento de divergencia contrastiva de máquinas de Boltzmann donde, al diferenciar la función de energía, el entrenamiento no debe propagarse hacia atrás a través del gráfico que generó las muestras del modelo.
- Entrenamiento contradictorio, en el que no debe ocurrir ningún respaldo a través del proceso de generación de ejemplos contradictorios.
Métodos públicos
salida pública <T> como salida ()
Devuelve el identificador simbólico de un tensor.
Las entradas de las operaciones de TensorFlow son salidas de otra operación de TensorFlow. Este método se utiliza para obtener un identificador simbólico que representa el cálculo de la entrada.
Método de fábrica para crear una clase que envuelve una nueva operación StopGradient.
Devoluciones
- una nueva instancia de StopGradient
Salvo que se indique lo contrario, el contenido de esta página está sujeto a la licencia Atribución 4.0 de Creative Commons, y los ejemplos de código están sujetos a la licencia Apache 2.0. Para obtener más información, consulta las políticas del sitio de Google Developers. Java es una marca registrada de Oracle o sus afiliados.
Última actualización: 2022-02-12 (UTC)
[[["Fácil de comprender","easyToUnderstand","thumb-up"],["Resolvió mi problema","solvedMyProblem","thumb-up"],["Otro","otherUp","thumb-up"]],[["Falta la información que necesito","missingTheInformationINeed","thumb-down"],["Muy complicado o demasiados pasos","tooComplicatedTooManySteps","thumb-down"],["Desactualizado","outOfDate","thumb-down"],["Problema de traducción","translationIssue","thumb-down"],["Problema con las muestras o los códigos","samplesCodeIssue","thumb-down"],["Otro","otherDown","thumb-down"]],["Última actualización: 2022-02-12 (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"]]