Avertissement : Cette API est obsolète et sera supprimée dans une future version de TensorFlow une fois que le remplacement sera stable.
EagerSession.ResourceCleanupStrategy
Restez organisé à l'aide des collections
Enregistrez et classez les contenus selon vos préférences.
Contrôle la façon dont les ressources TensorFlow sont nettoyées lorsqu'elles ne sont plus nécessaires.
Toutes les ressources allouées lors d'une EagerSession sont supprimées à la fermeture de la session. Pour éviter les erreurs de mémoire insuffisante, il est également fortement suggéré de nettoyer ces ressources pendant la session. Par exemple, exécuter n opérations dans une boucle de m itérations allouera un minimum de n*m ressources alors que dans la plupart des cas, seules les ressources de la dernière itération sont encore utilisées.
Les instances EagerSession peuvent être notifiées de différentes manières lorsque les objets TensorFlow ne sont plus référencés, afin qu'elles puissent procéder au nettoyage de toutes les ressources qu'elles possédaient.
Méthodes héritées
De la classe java.lang.Enum | entier final | comparerÀ (E arg0) |
| int | comparerTo (Objet arg0) |
| booléen final | est égal à (Objet arg0) |
| Classe finale<E> | getDeclaringClass () |
| entier final | Code de hachage () |
| Chaîne finale | nom () |
| entier final | ordinal () |
| Chaîne | àChaîne () |
| statique <T étend Enum<T>> T | valueOf (Class<T> arg0, Chaîne arg1) |
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 () |
Depuis l'interface java.lang.Comparable | abstrait entier | compareTo (E étend Enum<E> arg0) |
Valeurs d'énumération
public statique final EagerSession.ResourceCleanupStrategy IN_BACKGROUND
Surveillez et supprimez les ressources inutilisées d’un nouveau thread exécuté en arrière-plan.
Il s'agit de l'approche la plus fiable pour nettoyer les ressources TensorFlow, au prix du démarrage et de l'exécution d'un thread supplémentaire dédié à cette tâche. Chaque instance EagerSession possède son propre thread, qui est arrêté uniquement à la fermeture de la session.
Cette stratégie est utilisée par défaut.
public statique final EagerSession.ResourceCleanupStrategy ON_SAFE_POINTS
Surveillez et supprimez les ressources inutilisées des threads existants, avant ou après qu'ils aient terminé une autre tâche.
Les ressources inutilisées sont libérées lorsqu'un appel à la bibliothèque TensorFlow atteint un point sûr pour le nettoyage. Cela se fait de manière synchrone et peut bloquer pendant une courte période le thread qui a déclenché cet appel.
Cette stratégie ne doit être utilisée que si, pour certaines raisons, aucun thread supplémentaire ne doit être alloué pour le nettoyage. Sinon, IN_BACKGROUND doit être préféré.
public statique final EagerSession.ResourceCleanupStrategy ON_SESSION_CLOSE
Supprimez les ressources uniquement lorsque la session est fermée.
Toutes les ressources allouées pendant la session resteront en mémoire jusqu'à ce que la session soit explicitement fermée (ou via la technique traditionnelle « try-with-resource »). Aucune tâche supplémentaire de nettoyage des ressources ne sera tentée.
Cette stratégie peut entraîner des erreurs de mémoire insuffisante et son utilisation n'est pas recommandée, à moins que la portée de la session ne soit limitée à l'exécution d'un petit nombre d'opérations.
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.
Dernière mise à jour le 2025/07/25 (UTC).
[null,null,["Dernière mise à jour le 2025/07/25 (UTC)."],[],[],null,["# EagerSession.ResourceCleanupStrategy\n\npublic static final enum **EagerSession.ResourceCleanupStrategy** \nControls how TensorFlow resources are cleaned up when they are no longer needed.\n\nAll resources allocated during an `EagerSession` are deleted when the session is\nclosed. To prevent out-of-memory errors, it is also strongly suggest to cleanup those resources\nduring the session. For example, executing n operations in a loop of m iterations will allocate\na minimum of n\\*m resources while in most cases, only resources of the last iteration are still\nbeing used.\n\n`EagerSession` instances can be notified in different ways when TensorFlow objects are\nno longer being referred, so they can proceed to the cleanup of any resources they owned.\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n### Inherited Methods\n\nFrom class java.lang.Enum \n\n|----------------------------------|---------------------------------------|\n| final int | compareTo(E arg0) |\n| int | compareTo(Object arg0) |\n| final boolean | equals(Object arg0) |\n| final Class\\\u003cE\\\u003e | getDeclaringClass() |\n| final int | hashCode() |\n| final String | name() |\n| final int | ordinal() |\n| String | toString() |\n| static \\\u003cT extends Enum\\\u003cT\\\u003e\\\u003e T | valueOf(Class\\\u003cT\\\u003e arg0, String arg1) |\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 java.lang.Comparable \n\n|--------------|-------------------------------------|\n| abstract int | compareTo(E extends Enum\\\u003cE\\\u003e arg0) |\n\nEnum Values\n-----------\n\n#### public static final EagerSession.ResourceCleanupStrategy\n**IN_BACKGROUND**\n\nMonitor and delete unused resources from a new thread running in background.\n\nThis is the most reliable approach to cleanup TensorFlow resources, at the cost of\nstarting and running an additional thread dedicated to this task. Each `EagerSession`\ninstance has its own thread, which is stopped only when the session is closed.\n\nThis strategy is used by default.\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n#### public static final EagerSession.ResourceCleanupStrategy\n**ON_SAFE_POINTS**\n\nMonitor and delete unused resources from existing threads, before or after they complete\nanother task.\n\nUnused resources are released when a call to the TensorFlow library reaches a safe point\nfor cleanup. This is done synchronously and might block for a short period of time the thread\nwho triggered that call.\n\nThis strategy should be used only if, for some reasons, no additional thread should be\nallocated for cleanup. Otherwise, [IN_BACKGROUND](/api_docs/java/org/tensorflow/EagerSession.ResourceCleanupStrategy#IN_BACKGROUND) should be preferred.\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n#### public static final EagerSession.ResourceCleanupStrategy\n**ON_SESSION_CLOSE**\n\nOnly delete resources when the session is closed.\n\nAll resources allocated during the session will remained in memory until the session is\nexplicitly closed (or via the traditional \\`try-with-resource\\` technique). No extra task for\nresource cleanup will be attempted.\n\nThis strategy can lead up to out-of-memory errors and its usage is not recommended, unless\nthe scope of the session is limited to execute only a small amount of operations.\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e"]]
