Peringatan: API ini tidak digunakan lagi dan akan dihapus di TensorFlow versi mendatang setelah penggantian stabil.
StopGradient
bookmark_borderbookmark
Tetap teratur dengan koleksi
Simpan dan kategorikan konten berdasarkan preferensi Anda.
Menghentikan perhitungan gradien.
Saat dijalankan dalam grafik, operasi ini menampilkan tensor masukannya apa adanya.
Saat membangun operasi untuk menghitung gradien, operasi ini mencegah kontribusi masukannya diperhitungkan. Biasanya, generator gradien menambahkan operasi ke grafik untuk menghitung turunan dari 'kerugian' tertentu dengan mencari masukan yang berkontribusi pada penghitungannya secara rekursif. Jika Anda memasukkan operasi ini ke dalam grafik, inputnya akan disembunyikan dari generator gradien. Mereka tidak diperhitungkan untuk menghitung gradien.
Ini berguna kapan pun Anda ingin menghitung nilai dengan TensorFlow tetapi harus berpura-pura bahwa nilainya adalah sebuah konstanta. Misalnya, fungsi softmax untuk vektor x dapat ditulis sebagai
def softmax(x):
numerator = tf.exp(x)
denominator = tf.reduce_sum(numerator)
return numerator / denominator
Namun hal ini rentan meluap jika nilai dalam x besar. Cara alternatif yang lebih stabil adalah dengan mengurangi x maksimum dari masing-masing nilai.
def stable_softmax(x):
z = x - tf.reduce_max(x)
numerator = tf.exp(z)
denominator = tf.reduce_sum(numerator)
return numerator / denominator
Namun, ketika kita melakukan backprop melalui softmax ke x, kita tidak ingin melakukan backprop melalui perhitungan
tf.reduce_max(x) (jika nilai max tidak unik maka gradien dapat mengalir ke input yang salah) dan memperlakukannya sebagai konstanta. Oleh karena itu, kita harus menuliskannya sebagai
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
Beberapa contoh lainnya meliputi:
- Algoritma EM dimana M-step tidak boleh melibatkan backpropagation melalui output dari E-step .
- Pelatihan divergensi kontrastif pada mesin Boltzmann dimana, ketika membedakan fungsi energi, pelatihan tidak boleh melakukan propagasi mundur melalui grafik yang menghasilkan sampel dari model.
- Pelatihan permusuhan, di mana tidak ada backprop yang terjadi melalui proses pembuatan contoh permusuhan.
Metode Publik
Keluaran publik <T> sebagai Keluaran ()
Mengembalikan pegangan simbolik tensor.
Masukan ke operasi TensorFlow adalah keluaran dari operasi TensorFlow lainnya. Metode ini digunakan untuk mendapatkan pegangan simbolis yang mewakili perhitungan input.
Metode pabrik untuk membuat kelas yang membungkus operasi StopGradient baru.
Parameter
| cakupan | ruang lingkup saat ini |
|---|
Kecuali dinyatakan lain, konten di halaman ini dilisensikan berdasarkan Lisensi Creative Commons Attribution 4.0, sedangkan contoh kode dilisensikan berdasarkan Lisensi Apache 2.0. Untuk mengetahui informasi selengkapnya, lihat Kebijakan Situs Google Developers. Java adalah merek dagang terdaftar dari Oracle dan/atau afiliasinya.
Terakhir diperbarui pada 2025-07-25 UTC.
[[["Mudah dipahami","easyToUnderstand","thumb-up"],["Memecahkan masalah saya","solvedMyProblem","thumb-up"],["Lainnya","otherUp","thumb-up"]],[["Informasi yang saya butuhkan tidak ada","missingTheInformationINeed","thumb-down"],["Terlalu rumit/langkahnya terlalu banyak","tooComplicatedTooManySteps","thumb-down"],["Sudah usang","outOfDate","thumb-down"],["Masalah terjemahan","translationIssue","thumb-down"],["Masalah kode / contoh","samplesCodeIssue","thumb-down"],["Lainnya","otherDown","thumb-down"]],["Terakhir diperbarui pada 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"]]
