Scope
Organízate con las colecciones
Guarda y clasifica el contenido según tus preferencias.
Administra grupos de propiedades relacionadas al crear operaciones de Tensorflow, como un prefijo de nombre común.
Un Scope
es un contenedor de propiedades comunes aplicadas a TensorFlow Ops. El código de usuario normal inicializa un Scope
y lo proporciona a las clases de construcción de operaciones. Por ejemplo:
Scope scope = new Scope(graph);
Constant c = Constant.create(scope, 42);
Una clase de construcción de operaciones adquiere un alcance y lo usa para establecer propiedades en las operaciones subyacentes de Tensorflow. Por ejemplo:
// 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()
...
}
}
Jerarquía de alcance:
Un Scope
proporciona varios métodos with()
que crean un nuevo ámbito. En el nuevo ámbito normalmente se cambia una propiedad, mientras que otras propiedades se heredan del ámbito principal.
Un ejemplo usando Constant
implementado como antes:
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, ...);
Los objetos de alcance no son seguros para subprocesos.
Métodos públicos
OperaciónConstructor | |
Entorno de ejecución | entorno () Devuelve el entorno de ejecución utilizado por este ámbito. |
Cadena | makeOpName (nombre predeterminado de cadena) Cree un nombre único para un operador, utilizando un valor predeterminado proporcionado si es necesario. |
Alcance | withControlDependencies (controles Iterable< Operando <?>>) Devuelve un nuevo ámbito donde las operaciones agregadas tendrán las dependencias de control proporcionadas. |
Alcance | conNombre (Cadena opName) Devuelve un nuevo alcance que utiliza el nombre proporcionado para una operación. |
Alcance | withSubScope (cadena childScopeName) Devuelve un nuevo ámbito donde las operaciones agregadas tendrán el prefijo de nombre proporcionado. |
Métodos heredados
De la clase java.lang.Object booleano | es igual (Objeto arg0) |
Clase final<?> | obtenerclase () |
entero | código hash () |
vacío final | notificar () |
vacío final | notificar a todos () |
Cadena | a cadena () |
vacío final | esperar (arg0 largo, int arg1) |
vacío final | espera (arg0 largo) |
vacío final | esperar () |
Constructores Públicos
Ámbito público (entorno de entorno de ejecución )
Cree un nuevo ámbito de nivel superior.
Parámetros
ambiente | El entorno de ejecución utilizado por el alcance. |
---|
Métodos públicos
Agrega cada operando en controlDependencies como entrada de control al generador proporcionado.
Parámetros
constructor | OperationBuilder para agregar entradas de control a |
---|
Devuelve el entorno de ejecución utilizado por este ámbito.
cadena pública makeOpName (cadena nombre predeterminado)
Cree un nombre único para un operador, utilizando un valor predeterminado proporcionado si es necesario.
Normalmente, esto solo lo llaman las clases de construcción de operadores.
Este método genera un nombre único, apropiado para el ámbito del nombre controlado por esta instancia. El código de construcción de operador típico podría verse así
scope.env().opBuilder("Const", scope.makeOpName("Const"))...
Nota: si proporciona una clase de creación de operadores compuesta (es decir, una clase que crea un conjunto de operaciones relacionadas llamando a otro código de creación de operadores), el nombre proporcionado actuará como un subámbito para todos los operadores subyacentes.
Parámetros
nombre predeterminado | nombre del operador subyacente. |
---|
Devoluciones
- nombre único para el operador.
Lanza
Excepción de argumento ilegal | si el nombre predeterminado no es válido. |
---|
Ámbito público con Dependencias de control (controles Iterable < Operando <? >>)
Devuelve un nuevo ámbito donde las operaciones agregadas tendrán las dependencias de control proporcionadas.
Las operaciones creadas con este alcance tendrán una ventaja de control de cada uno de los controles proporcionados. Todas las demás propiedades se heredan del ámbito actual.
Parámetros
controles | controlar las dependencias para las operaciones creadas con el alcance devuelto |
---|
Devoluciones
- un nuevo alcance con las dependencias de control proporcionadas
Ámbito público con nombre (cadena opName)
Devuelve un nuevo alcance que utiliza el nombre proporcionado para una operación.
Las operaciones creadas dentro de este alcance tendrán un nombre con el formato name/opName[_suffix]
. Esto le permite nombrar un operador específico de manera más significativa.
Los nombres deben coincidir con la expresión regular [A-Za-z0-9.][A-Za-z0-9_.\-]*
Parámetros
nombre de operación | nombre de un operador en el ámbito devuelto |
---|
Devoluciones
- un nuevo ámbito que utiliza opName para las operaciones.
Lanza
Excepción de argumento ilegal | si el nombre no es válido |
---|
Ámbito público con SubÁmbito (cadena childScopeName)
Devuelve un nuevo ámbito donde las operaciones agregadas tendrán el prefijo de nombre proporcionado.
Las operaciones creadas con este alcance tendrán name/childScopeName/
como prefijo. El nombre real será único en el ámbito devuelto. Todas las demás propiedades se heredan del ámbito actual.
El nombre del ámbito secundario debe coincidir con la expresión regular [A-Za-z0-9.][A-Za-z0-9_.\-]*
Parámetros
niñoÁmbitoNombre | nombre para el nuevo ámbito secundario |
---|
Lanza
Excepción de argumento ilegal | si el nombre no es válido |
---|
A menos que se indique lo contrario, el contenido de esta página está sujeto a la licencia Reconocimiento 4.0 de Creative Commons y los códigos de ejemplo se rigen por la licencia Apache 2.0. Para obtener más información, consulta las Políticas del Sitio Web de Google Developers. Java es una marca registrada de Oracle o sus entidades asociadas. Parte del contenido está sujeto a la licencia de NumPy.
Última actualización: 2025-07-27 (UTC).
[null,null,["Última actualización: 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|--------------------------|------------------------|"]]