Scope
Restez organisé à l'aide des collections
Enregistrez et classez les contenus selon vos préférences.
Gère les groupes de propriétés associées lors de la création d'opérations Tensorflow, telles qu'un préfixe de nom commun.
Un Scope
est un conteneur de propriétés communes appliquées à TensorFlow Ops. Le code utilisateur normal initialise une Scope
et la fournit aux classes de création d'opérations. Par exemple:
Scope scope = new Scope(graph);
Constant c = Constant.create(scope, 42);
Une classe de création d'opérations acquiert une portée et l'utilise pour définir les propriétés des opérations Tensorflow sous-jacentes. Par exemple:
// 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()
...
}
}
Hiérarchie de portée :
Un Scope
fournit diverses méthodes with()
qui créent une nouvelle portée. La nouvelle portée a généralement une propriété modifiée tandis que les autres propriétés sont héritées de la portée parent.
Un exemple utilisant Constant
implémenté comme auparavant :
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, ...);
Les objets Scope ne sont pas thread-safe.
Méthodes publiques
OpérationBuilder | |
Environnement d'exécution | env () Renvoie l'environnement d'exécution utilisé par cette étendue. |
Chaîne | makeOpName (String defaultName) Créez un nom unique pour un opérateur, en utilisant un nom par défaut fourni si nécessaire. |
Portée | withControlDependencies (contrôles Iterable< Operand <?>>) Renvoie une nouvelle portée dans laquelle les opérations ajoutées auront les dépendances de contrôle fournies. |
Portée | withName (String opName) Renvoie une nouvelle portée qui utilise le nom fourni pour une opération. |
Portée | withSubScope (Chaîne childScopeName) Renvoie une nouvelle portée dans laquelle les opérations ajoutées auront le préfixe de nom fourni. |
Méthodes héritées
De la classe java.lang.Object booléen | est égal à (Objet arg0) |
Classe finale<?> | obtenirClasse () |
int | Code de hachage () |
vide final | notifier () |
vide final | notifierTous () |
Chaîne | àChaîne () |
vide final | attendre (long arg0, int arg1) |
vide final | attendez (long arg0) |
vide final | attendez () |
Constructeurs Publics
Créez une nouvelle étendue de niveau supérieur.
Paramètres
env | L’environnement d’exécution utilisé par la portée. |
---|
Méthodes publiques
Ajoute chaque opérande dans controlDependencies en tant qu'entrée de contrôle au générateur fourni.
Paramètres
constructeur | OperationBuilder pour ajouter des entrées de contrôle à |
---|
Renvoie l'environnement d'exécution utilisé par cette étendue.
public String makeOpName (String defaultName)
Créez un nom unique pour un opérateur, en utilisant un nom par défaut fourni si nécessaire.
Ceci est normalement appelé uniquement par les classes de construction d'opérateurs.
Cette méthode génère un nom unique, approprié pour la portée de nom contrôlée par cette instance. Le code du bâtiment typique d'un opérateur pourrait ressembler à
scope.env().opBuilder("Const", scope.makeOpName("Const"))...
Remarque : si vous fournissez une classe de création d'opérateurs composites (c'est-à-dire une classe qui crée un ensemble d'opérations associées en appelant le code de création d'un autre opérateur), le nom fourni fera office de sous-portée pour tous les opérateurs sous-jacents.
Paramètres
Nom par défaut | nom de l’opérateur sous-jacent. |
---|
Retours
- nom unique de l'opérateur.
Jetés
IllegalArgumentException | si le nom par défaut n'est pas valide. |
---|
Portée publique avec ControlDependencies (contrôles Iterable < Operand <?>>)
Renvoie une nouvelle portée dans laquelle les opérations ajoutées auront les dépendances de contrôle fournies.
Les opérations créées avec cette portée auront un avantage de contrôle pour chacun des contrôles fournis. Toutes les autres propriétés sont héritées de la portée actuelle.
Paramètres
contrôles | contrôler les dépendances pour les opérations créées avec la portée renvoyée |
---|
Retours
- une nouvelle portée avec les dépendances de contrôle fournies
Portée publique withName (String opName)
Renvoie une nouvelle portée qui utilise le nom fourni pour une opération.
Les opérations créées dans cette portée auront un nom de la forme name/opName[_suffix]
. Cela vous permet de nommer un opérateur spécifique de manière plus significative.
Les noms doivent correspondre à l'expression régulière [A-Za-z0-9.][A-Za-z0-9_.\-]*
Paramètres
NomOp | nom d'un opérateur dans la portée renvoyée |
---|
Retours
- une nouvelle portée qui utilise opName pour les opérations.
Jetés
IllegalArgumentException | si le nom n'est pas valide |
---|
Portée publique avec SubScope (String childScopeName)
Renvoie une nouvelle portée dans laquelle les opérations ajoutées auront le préfixe de nom fourni.
Les opérations créées avec cette étendue auront name/childScopeName/
comme préfixe. Le nom réel sera unique dans la portée renvoyée. Toutes les autres propriétés sont héritées de la portée actuelle.
Le nom de la portée enfant doit correspondre à l'expression régulière [A-Za-z0-9.][A-Za-z0-9_.\-]*
Paramètres
nomEnfantScopeName | nom de la nouvelle portée enfant |
---|
Jetés
IllegalArgumentException | si le nom n'est pas valide |
---|
Sauf indication contraire, le contenu de cette page est régi par une licence Creative Commons Attribution 4.0, et les échantillons de code sont régis par une licence Apache 2.0. Pour en savoir plus, consultez les Règles du site Google Developers. Java est une marque déposée d'Oracle et/ou de ses sociétés affiliées. Une partie du contenu fait l'objet d'une licence Numpy.
Dernière mise à jour le 2025/07/26 (UTC).
[null,null,["Dernière mise à jour le 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|--------------------------|------------------------|"]]