Scope
Tetap teratur dengan koleksi
Simpan dan kategorikan konten berdasarkan preferensi Anda.
Mengelola grup properti terkait saat membuat Operasi Tensorflow, seperti awalan nama umum.
Scope
adalah wadah untuk properti umum yang diterapkan pada Operasi TensorFlow. Kode pengguna normal menginisialisasi Scope
dan menyediakannya ke kelas bangunan Operasi. Misalnya:
Scope scope = new Scope(graph);
Constant c = Constant.create(scope, 42);
Kelas bangunan Operasi memperoleh Cakupan, dan menggunakannya untuk mengatur properti pada operasi Tensorflow yang mendasarinya. Misalnya:
// An operator class that adds a constant.
public class Constant {
public static Constant create(Scope scope, ...) {
scope.graph().opBuilder(
"Const", scope.makeOpName("Const"))
.setAttr(...)
.build()
...
}
}
Hirarki cakupan:
Scope
menyediakan berbagai metode with()
yang membuat cakupan baru. Cakupan baru biasanya memiliki satu properti yang diubah sementara properti lainnya diwarisi dari cakupan induk.
Contoh penggunaan Constant
yang diimplementasikan seperti sebelumnya:
Scope root = new Scope(graph);
// The linear subscope will generate names like linear/...
Scope linear = Scope.withSubScope("linear");
// This op name will be "linear/W"
Constant.create(linear.withName("W"), ...);
// This op will be "linear/Const", using the default
// name provided by Constant
Constant.create(linear, ...);
// This op will be "linear/Const_1", using the default
// name provided by Constant and making it unique within
// this scope
Constant.create(linear, ...);
Objek cakupan tidak aman untuk thread.
Metode Publik
Pembangun Operasi | |
Lingkungan Eksekusi | env () Mengembalikan lingkungan eksekusi yang digunakan oleh cakupan ini. |
Rangkaian | makeOpName (String nama default) Buat nama unik untuk operator, gunakan nama default yang disediakan jika perlu. |
Cakupan | withControlDependencies (kontrol< Operand <?>> yang dapat diubah) Mengembalikan cakupan baru di mana operasi yang ditambahkan akan memiliki dependensi kontrol yang disediakan. |
Cakupan | denganNama (String opName) Mengembalikan cakupan baru yang menggunakan nama yang diberikan untuk sebuah operasi. |
Cakupan | denganSubScope (String childScopeName) Mengembalikan cakupan baru di mana operasi yang ditambahkan akan memiliki awalan nama yang disediakan. |
Metode Warisan
Dari kelas java.lang.Object boolean | sama dengan (Objek arg0) |
Kelas terakhir<?> | dapatkan Kelas () |
ke dalam | Kode hash () |
kekosongan terakhir | beri tahu () |
kekosongan terakhir | beri tahuSemua () |
Rangkaian | keString () |
kekosongan terakhir | tunggu (arg0 panjang, int arg1) |
kekosongan terakhir | tunggu (argumen panjang0) |
kekosongan terakhir | Tunggu () |
Konstruktor Publik
Lingkup publik (Environment ExecutionEnv )
Buat cakupan tingkat atas baru.
Parameter
env | Lingkungan eksekusi yang digunakan oleh ruang lingkup. |
---|
Metode Publik
Menambahkan setiap Operan di controlDependencies sebagai input kontrol ke pembuat yang disediakan.
Parameter
pembangun | OperationBuilder untuk menambahkan input kontrol |
---|
Lingkungan Eksekusi publik ()
Mengembalikan lingkungan eksekusi yang digunakan oleh cakupan ini.
String publik makeOpName (String nama default)
Buat nama unik untuk operator, gunakan nama default yang disediakan jika perlu.
Ini biasanya hanya dipanggil oleh kelas gedung operator.
Metode ini menghasilkan nama unik, sesuai dengan lingkup nama yang dikontrol oleh instance ini. Kode bangunan operator pada umumnya mungkin terlihat seperti ini
scope.env().opBuilder("Const", scope.makeOpName("Const"))...
Catatan: jika Anda menyediakan kelas pembangun operator gabungan (yaitu, kelas yang membuat serangkaian operasi terkait dengan memanggil kode bangunan operator lain), nama yang diberikan akan bertindak sebagai sublingkup untuk semua operator yang mendasarinya.
Parameter
Nama default | nama untuk operator yang mendasarinya. |
---|
Kembali
- nama unik untuk operator.
Melempar
Pengecualian Argumen Ilegal | jika nama default tidak valid. |
---|
Lingkup publik denganControlDependencies (kontrol< Operand <?>> yang dapat diubah)
Mengembalikan cakupan baru di mana operasi yang ditambahkan akan memiliki dependensi kontrol yang disediakan.
Operasi yang dibuat dengan cakupan ini akan memiliki keunggulan kendali dari setiap kontrol yang disediakan. Semua properti lainnya diwarisi dari cakupan saat ini.
Parameter
kontrol | mengontrol dependensi untuk operasi yang dibuat dengan cakupan yang dikembalikan |
---|
Kembali
- cakupan baru dengan dependensi kontrol yang disediakan
Lingkup publik dengan Nama (String opName)
Mengembalikan cakupan baru yang menggunakan nama yang diberikan untuk sebuah operasi.
Operasi yang dibuat dalam lingkup ini akan memiliki nama dalam bentuk name/opName[_suffix]
. Hal ini memungkinkan Anda memberi nama operator tertentu dengan lebih bermakna.
Nama harus cocok dengan ekspresi reguler [A-Za-z0-9.][A-Za-z0-9_.\-]*
Parameter
nama op | nama untuk operator dalam cakupan yang dikembalikan |
---|
Kembali
- Cakupan baru yang menggunakan opName untuk operasi.
Melempar
Pengecualian Argumen Ilegal | jika namanya tidak valid |
---|
Lingkup publik denganSubScope (String childScopeName)
Mengembalikan cakupan baru di mana operasi yang ditambahkan akan memiliki awalan nama yang disediakan.
Operasi yang dibuat dengan cakupan ini akan memiliki name/childScopeName/
sebagai awalan. Nama sebenarnya akan unik dalam cakupan yang dikembalikan. Semua properti lainnya diwarisi dari cakupan saat ini.
Nama cakupan anak harus cocok dengan ekspresi reguler [A-Za-z0-9.][A-Za-z0-9_.\-]*
Parameter
nama lingkup anak | nama untuk cakupan anak baru |
---|
Melempar
Pengecualian Argumen Ilegal | jika namanya tidak valid |
---|
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, baca Kebijakan Situs Google Developers. Java adalah merek dagang terdaftar dari Oracle dan/atau afiliasinya. Beberapa konten dilisensikan berdasarkan lisensi numpy.
Terakhir diperbarui pada 2025-07-27 UTC.
[null,null,["Terakhir diperbarui pada 2025-07-27 UTC."],[],[],null,["# Scope\n\npublic final class **Scope** \nManages groups of related properties when creating Tensorflow Operations, such as a common name\nprefix.\n\nA `Scope` is a container for common properties applied to TensorFlow Ops. Normal user\ncode initializes a `Scope` and provides it to Operation building classes. For example:\n\n Scope scope = new Scope(graph);\n Constant c = Constant.create(scope, 42);\n \nAn Operation building class acquires a Scope, and uses it to set properties on the underlying\nTensorflow ops. For example:\n\n // An operator class that adds a constant.\n public class Constant {\n public static Constant create(Scope scope, ...) {\n scope.graph().opBuilder(\n \"Const\", scope.makeOpName(\"Const\"))\n .setAttr(...)\n .build()\n ...\n }\n }\n \n**Scope hierarchy:**\n\nA `Scope` provides various `with()` methods that create a new scope. The new scope\ntypically has one property changed while other properties are inherited from the parent scope.\n\nAn example using `Constant` implemented as before:\n\n Scope root = new Scope(graph);\n\n // The linear subscope will generate names like linear/...\n Scope linear = Scope.withSubScope(\"linear\");\n\n // This op name will be \"linear/W\"\n Constant.create(linear.withName(\"W\"), ...);\n\n // This op will be \"linear/Const\", using the default\n // name provided by Constant\n Constant.create(linear, ...);\n\n // This op will be \"linear/Const_1\", using the default\n // name provided by Constant and making it unique within\n // this scope\n Constant.create(linear, ...);\n \nScope objects are **not** thread-safe.\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n### Public Constructors\n\n|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| | [Scope](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope#Scope(org.tensorflow.ExecutionEnvironment))([ExecutionEnvironment](/versions/r2.14/api_docs/java/org/tensorflow/ExecutionEnvironment) env) Create a new top-level scope. |\n\n### Public Methods\n\n|-------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| [OperationBuilder](/versions/r2.14/api_docs/java/org/tensorflow/OperationBuilder) | [applyControlDependencies](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope#applyControlDependencies(org.tensorflow.OperationBuilder))([OperationBuilder](/versions/r2.14/api_docs/java/org/tensorflow/OperationBuilder) builder) Adds each Operand in controlDependencies as a control input to the provided builder. |\n| [ExecutionEnvironment](/versions/r2.14/api_docs/java/org/tensorflow/ExecutionEnvironment) | [env](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope#env())() Returns the execution environment used by this scope. |\n| String | [makeOpName](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope#makeOpName(java.lang.String))(String defaultName) Create a unique name for an operator, using a provided default if necessary. |\n| [Scope](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope) | [withControlDependencies](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope#withControlDependencies(java.lang.Iterable\u003corg.tensorflow.Operand\u003c?\u003e\u003e))(Iterable\\\u003c[Operand](/versions/r2.14/api_docs/java/org/tensorflow/Operand)\\\u003c?\\\u003e\\\u003e controls) Returns a new scope where added operations will have the provided control dependencies. |\n| [Scope](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope) | [withName](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope#withName(java.lang.String))(String opName) Return a new scope that uses the provided name for an op. |\n| [Scope](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope) | [withSubScope](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope#withSubScope(java.lang.String))(String childScopeName) Returns a new scope where added operations will have the provided name prefix. |\n\n### Inherited Methods\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\nPublic Constructors\n-------------------\n\n#### public\n**Scope**\n([ExecutionEnvironment](/versions/r2.14/api_docs/java/org/tensorflow/ExecutionEnvironment) env)\n\nCreate a new top-level scope. \n\n##### Parameters\n\n| env | The execution environment used by the scope. |\n|-----|----------------------------------------------|\n\nPublic Methods\n--------------\n\n#### public [OperationBuilder](/versions/r2.14/api_docs/java/org/tensorflow/OperationBuilder)\n**applyControlDependencies**\n([OperationBuilder](/versions/r2.14/api_docs/java/org/tensorflow/OperationBuilder) builder)\n\nAdds each Operand in controlDependencies as a control input to the provided builder. \n\n##### Parameters\n\n| builder | OperationBuilder to add control inputs to |\n|---------|-------------------------------------------|\n\n#### public [ExecutionEnvironment](/versions/r2.14/api_docs/java/org/tensorflow/ExecutionEnvironment)\n**env**\n()\n\nReturns the execution environment used by this scope. \n\n#### public String\n**makeOpName**\n(String defaultName)\n\nCreate a unique name for an operator, using a provided default if necessary.\n\nThis is normally called only by operator building classes.\n\nThis method generates a unique name, appropriate for the name scope controlled by this\ninstance. Typical operator building code might look like\n\n scope.env().opBuilder(\"Const\", scope.makeOpName(\"Const\"))...\n \n**Note:** if you provide a composite operator building class (i.e, a class that creates a\nset of related operations by calling other operator building code), the provided name will act\nas a subscope to all underlying operators.\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n##### Parameters\n\n| defaultName | name for the underlying operator. |\n|-------------|-----------------------------------|\n\n##### Returns\n\n- unique name for the operator. \n\n##### Throws\n\n| IllegalArgumentException | if the default name is invalid. |\n|--------------------------|---------------------------------|\n\n#### public [Scope](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope)\n**withControlDependencies**\n(Iterable\\\u003c[Operand](/versions/r2.14/api_docs/java/org/tensorflow/Operand)\\\u003c?\\\u003e\\\u003e controls)\n\nReturns a new scope where added operations will have the provided control dependencies.\n\nOps created with this scope will have a control edge from each of the provided controls. All\nother properties are inherited from the current scope.\n\n\u003cbr /\u003e\n\n##### Parameters\n\n| controls | control dependencies for ops created with the returned scope |\n|----------|--------------------------------------------------------------|\n\n##### Returns\n\n- a new scope with the provided control dependencies \n\n#### public [Scope](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope)\n**withName**\n(String opName)\n\nReturn a new scope that uses the provided name for an op.\n\nOperations created within this scope will have a name of the form `name/opName[_suffix]`. This lets you name a specific operator more meaningfully.\n\nNames must match the regular expression `[A-Za-z0-9.][A-Za-z0-9_.\\-]*`\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n##### Parameters\n\n| opName | name for an operator in the returned scope |\n|--------|--------------------------------------------|\n\n##### Returns\n\n- a new Scope that uses opName for operations. \n\n##### Throws\n\n| IllegalArgumentException | if the name is invalid |\n|--------------------------|------------------------|\n\n#### public [Scope](/versions/r2.14/api_docs/java/org/tensorflow/op/Scope)\n**withSubScope**\n(String childScopeName)\n\nReturns a new scope where added operations will have the provided name prefix.\n\nOps created with this scope will have `name/childScopeName/` as the prefix. The actual\nname will be unique in the returned scope. All other properties are inherited from the current\nscope.\n\nThe child scope name must match the regular expression `[A-Za-z0-9.][A-Za-z0-9_.\\-]*`\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n##### Parameters\n\n| childScopeName | name for the new child scope |\n|----------------|------------------------------|\n\n##### Returns\n\n- a new subscope \n\n##### Throws\n\n| IllegalArgumentException | if the name is invalid |\n|--------------------------|------------------------|"]]