Scope
Zadbaj o dobrą organizację dzięki kolekcji
Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.
Zarządza grupami powiązanych właściwości podczas tworzenia operacji Tensorflow, takich jak przedrostek nazwy pospolitej.
Scope
to kontener dla typowych właściwości stosowanych w operacjach TensorFlow. Normalny kod użytkownika inicjuje Scope
i udostępnia go klasom budowania operacji. Na przykład:
Scope scope = new Scope(graph);
Constant c = Constant.create(scope, 42);
Klasa budowania Operacji nabywa zakres i używa go do ustawiania właściwości bazowych operacji Tensorflow. Na przykład:
// 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()
...
}
}
Hierarchia zakresu:
Scope
udostępnia różne metody with()
, które tworzą nowy zakres. W nowym zakresie zazwyczaj zmieniana jest jedna właściwość, podczas gdy inne właściwości są dziedziczone z zakresu nadrzędnego.
Przykład użycia Constant
zaimplementowanego jak poprzednio:
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, ...);
Obiekty zakresu nie są bezpieczne dla wątków.
Metody dziedziczone
Z klasy java.lang.Object wartość logiczna | równa się (Obiekt arg0) |
ostatnia klasa<?> | pobierzKlasę () |
wew | hashCode () |
ostateczna pustka | powiadomić () |
ostateczna pustka | powiadom wszystkich () |
Smyczkowy | doString () |
ostateczna pustka | czekaj (długi arg0, int arg1) |
ostateczna pustka | czekaj (długi arg0) |
ostateczna pustka | Czekać () |
Konstruktorzy publiczni
Utwórz nowy zakres najwyższego poziomu.
Parametry
śr | Środowisko wykonawcze używane przez zakres. |
---|
Metody publiczne
Dodaje każdy operand w controlDependency jako dane wejściowe sterujące do dostarczonego konstruktora.
Parametry
budowniczy | OperationBuilder, do którego chcesz dodać wejścia sterujące |
---|
Zwraca środowisko wykonawcze używane przez ten zakres.
public String makeOpName (String defaultName)
Utwórz unikalną nazwę dla operatora, korzystając w razie potrzeby z podanej wartości domyślnej.
Jest to zwykle wywoływane tylko przez klasy budujące operatory.
Ta metoda generuje unikalną nazwę, odpowiednią dla zakresu nazw kontrolowanego przez tę instancję. Może wyglądać typowy kod budowania operatora
scope.env().opBuilder("Const", scope.makeOpName("Const"))...
Uwaga: jeśli podasz klasę budowania operatorów złożonych (tzn. klasę, która tworzy zestaw powiązanych operacji poprzez wywołanie kodu budowania innego operatora), podana nazwa będzie działać jako podzakres dla wszystkich operatorów bazowych.
Parametry
nazwa domyślna | nazwa operatora bazowego. |
---|
Powroty
- unikalna nazwa operatora.
Rzuca
Wyjątek IllegalArgument | jeśli domyślna nazwa jest nieprawidłowa. |
---|
zakres publiczny z zależnościami kontrolnymi (kontrolki Iterable< Operand <?>>)
Zwraca nowy zakres, w którym dodane operacje będą miały podane zależności kontrolne.
Operacje utworzone przy użyciu tego zakresu będą miały przewagę kontrolną dzięki każdemu z dostępnych elementów sterujących. Wszystkie pozostałe właściwości są dziedziczone z bieżącego zakresu.
Parametry
sterownica | zależności kontrolne dla operacji utworzonych przy użyciu zwróconego zakresu |
---|
Powroty
- nowy zakres z dostarczonymi zależnościami kontrolnymi
Zakres publiczny o nazwie (String opName)
Zwróć nowy zakres, który używa podanej nazwy dla operacji.
Operacje utworzone w tym zakresie będą miały nazwę w postaci name/opName[_suffix]
. Dzięki temu możesz nadać konkretnemu operatorowi bardziej znaczącą nazwę.
Nazwy muszą pasować do wyrażenia regularnego [A-Za-z0-9.][A-Za-z0-9_.\-]*
Parametry
nazwa op | nazwa operatora w zwróconym zakresie |
---|
Powroty
- nowy zakres, który używa opName do operacji.
Rzuca
Wyjątek IllegalArgument | jeśli nazwa jest nieprawidłowa |
---|
Zakres publiczny withSubScope (String childScopeName)
Zwraca nowy zakres, w którym dodane operacje będą miały podany przedrostek nazwy.
Operacje utworzone przy użyciu tego zakresu będą miały przedrostek name/childScopeName/
. Rzeczywista nazwa będzie unikalna w zwróconym zakresie. Wszystkie pozostałe właściwości są dziedziczone z bieżącego zakresu.
Nazwa zakresu podrzędnego musi pasować do wyrażenia regularnego [A-Za-z0-9.][A-Za-z0-9_.\-]*
Parametry
nazwazakresu podrzędnego | nazwa nowego zakresu podrzędnego |
---|
Rzuca
Wyjątek IllegalArgument | jeśli nazwa jest nieprawidłowa |
---|
O ile nie stwierdzono inaczej, treść tej strony jest objęta licencją Creative Commons – uznanie autorstwa 4.0, a fragmenty kodu są dostępne na licencji Apache 2.0. Szczegółowe informacje na ten temat zawierają zasady dotyczące witryny Google Developers. Java jest zastrzeżonym znakiem towarowym firmy Oracle i jej podmiotów stowarzyszonych. Część treści jest objęta licencją numpy.
Ostatnia aktualizacja: 2025-07-26 UTC.
[null,null,["Ostatnia aktualizacja: 2025-07-26 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.11/api_docs/java/org/tensorflow/op/Scope#Scope(org.tensorflow.ExecutionEnvironment))([ExecutionEnvironment](/versions/r2.11/api_docs/java/org/tensorflow/ExecutionEnvironment) env) Create a new top-level scope. |\n\n### Public Methods\n\n|-------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| [OperationBuilder](/versions/r2.11/api_docs/java/org/tensorflow/OperationBuilder) | [applyControlDependencies](/versions/r2.11/api_docs/java/org/tensorflow/op/Scope#applyControlDependencies(org.tensorflow.OperationBuilder))([OperationBuilder](/versions/r2.11/api_docs/java/org/tensorflow/OperationBuilder) builder) Adds each Operand in controlDependencies as a control input to the provided builder. |\n| [ExecutionEnvironment](/versions/r2.11/api_docs/java/org/tensorflow/ExecutionEnvironment) | [env](/versions/r2.11/api_docs/java/org/tensorflow/op/Scope#env())() Returns the execution environment used by this scope. |\n| String | [makeOpName](/versions/r2.11/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.11/api_docs/java/org/tensorflow/op/Scope) | [withControlDependencies](/versions/r2.11/api_docs/java/org/tensorflow/op/Scope#withControlDependencies(java.lang.Iterable\u003corg.tensorflow.Operand\u003c?\u003e\u003e))(Iterable\\\u003c[Operand](/versions/r2.11/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.11/api_docs/java/org/tensorflow/op/Scope) | [withName](/versions/r2.11/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.11/api_docs/java/org/tensorflow/op/Scope) | [withSubScope](/versions/r2.11/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.11/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.11/api_docs/java/org/tensorflow/OperationBuilder)\n**applyControlDependencies**\n([OperationBuilder](/versions/r2.11/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.11/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.11/api_docs/java/org/tensorflow/op/Scope)\n**withControlDependencies**\n(Iterable\\\u003c[Operand](/versions/r2.11/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.11/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.11/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|--------------------------|------------------------|"]]