Je travaille dans un environnement dans lequel les ressources de calcul sont partagées, c'est-à-dire que nous avons quelques machines serveurs équipées de quelques GPU Nvidia Titan X chacune.

Pour les modèles de petite à moyenne taille, les 12 Go du Titan X sont généralement suffisants pour que 2 à 3 personnes puissent exécuter la formation simultanément sur le même GPU. Si les modèles sont suffisamment petits pour qu'un seul modèle ne tire pas pleinement parti de toutes les unités de calcul du GPU, cela peut en fait entraîner une accélération par rapport à l'exécution d'un processus de formation après l'autre. Même dans les cas où l'accès simultané au GPU ralentit le temps de formation individuel, il est toujours agréable d'avoir la flexibilité d'avoir plusieurs utilisateurs simultanément formés sur le GPU.

Le problème avec TensorFlow est que, par défaut, il alloue la quantité totale de mémoire GPU disponible lors de son lancement. Même pour un petit réseau neuronal à deux couches, je constate que les 12 Go de mémoire GPU sont utilisés.

Existe-t-il un moyen de faire en sorte que TensorFlow n'alloue que, disons, 4 Go de mémoire GPU, si l'on sait que cela suffit pour un modèle donné?

Vous pouvez définir la fraction de mémoire GPU à allouer lorsque vous construisez un tf.Sessionen passant un tf.GPUOptionsdans le cadre de l' configargument facultatif :

# Assume that you have 12GB of GPU memory and want to allocate ~4GB:
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)

sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))

Les per_process_gpu_memory_fractionagit comme un disque limite supérieure de la quantité de mémoire de GPU qui sera utilisé par le processus sur chaque GPU sur la même machine. Actuellement, cette fraction est appliquée uniformément à tous les GPU sur la même machine; il n'y a aucun moyen de définir cela sur une base par GPU.

config = tf.ConfigProto()
config.gpu_options.allow_growth=True
sess = tf.Session(config=config)

https://github.com/tensorflow/tensorflow/issues/1578

Voici un extrait du livre Deep Learning with TensorFlow

Dans certains cas, il est souhaitable que le processus n'alloue qu'un sous-ensemble de la mémoire disponible ou n'augmente l'utilisation de la mémoire que lorsque le processus en a besoin. TensorFlow fournit deux options de configuration sur la session pour contrôler cela. La première est l' allow_growthoption, qui tente d'allouer uniquement autant de mémoire GPU en fonction des allocations d'exécution, elle commence par allouer très peu de mémoire, et au fur et à mesure que les sessions s'exécutent et que davantage de mémoire GPU est nécessaire, nous étendons la zone de mémoire GPU requise par le TensorFlow processus.

1) Permettre la croissance: (plus flexible)

config = tf.ConfigProto()
config.gpu_options.allow_growth = True
session = tf.Session(config=config, ...)

La deuxième méthode est l' per_process_gpu_memory_fractionoption, qui détermine la fraction de la quantité totale de mémoire que le eachGPU visible doit être alloué. Remarque: Aucune libération de mémoire n'est nécessaire, cela peut même aggraver la fragmentation de la mémoire une fois terminé.

2) Allouer de la mémoire fixe :

Pour allouer uniquement 40%la mémoire totale de chaque GPU par:

config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.4
session = tf.Session(config=config, ...)

Remarque: Cela n'est utile que si vous voulez vraiment lier la quantité de mémoire GPU disponible sur le processus TensorFlow.

Mis à jour pour TensorFlow 2.0 Alpha et au-delà

À partir des documents Alpha 2.0, la réponse est maintenant juste une ligne avant de faire quoi que ce soit avec TensorFlow:

import tensorflow as tf
tf.config.gpu.set_per_process_memory_growth(True)

Toutes les réponses ci-dessus supposent l'exécution avec un sess.run()appel, ce qui devient l'exception plutôt que la règle dans les versions récentes de TensorFlow.

Lorsque vous utilisez le tf.Estimatorframework (TensorFlow 1.4 et supérieur), le moyen de transmettre la fraction à la création implicite MonitoredTrainingSessionest,

opts = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)
conf = tf.ConfigProto(gpu_options=opts)
trainingConfig = tf.estimator.RunConfig(session_config=conf, ...)
tf.estimator.Estimator(model_fn=..., 
                       config=trainingConfig)

De même en mode Désireux (TensorFlow 1.5 et supérieur),

opts = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)
conf = tf.ConfigProto(gpu_options=opts)
tfe.enable_eager_execution(config=conf)

Edit: 11-04-2018 Par exemple, si vous devez utiliser tf.contrib.gan.train, vous pouvez utiliser quelque chose de similaire à ci-dessous:

tf.contrib.gan.gan_train(........, config=conf)

Pour Tensorflow versions 2.0 et 2.1, utilisez l'extrait de code suivant :

 import tensorflow as tf
 gpu_devices = tf.config.experimental.list_physical_devices('GPU')
 tf.config.experimental.set_memory_growth(gpu_devices[0], True)

Pour les versions précédentes , l'extrait suivant fonctionnait pour moi:

import tensorflow as tf
tf_config=tf.ConfigProto()
tf_config.gpu_options.allow_growth=True
sess = tf.Session(config=tf_config)

Tensorflow 2.0 Beta et (probablement) au-delà

L'API a de nouveau changé. Il se trouve maintenant dans:

tf.config.experimental.set_memory_growth(
    device,
    enable
)

Alias:

• tf.compat.v1.config.experimental.set_memory_growth
• tf.compat.v2.config.experimental.set_memory_growth

Références:

• https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/config/experimental/set_memory_growth
• https://www.tensorflow.org/guide/gpu#limiting_gpu_memory_growth

Voir aussi: Tensorflow - Utilisez un GPU : https://www.tensorflow.org/guide/gpu

pour Tensorflow 2.0 Alpha voir: cette réponse

Vous pouvez utiliser

TF_FORCE_GPU_ALLOW_GROWTH=true

dans vos variables d'environnement.

Dans le code tensorflow :

bool GPUBFCAllocator::GetAllowGrowthValue(const GPUOptions& gpu_options) {
  const char* force_allow_growth_string =
      std::getenv("TF_FORCE_GPU_ALLOW_GROWTH");
  if (force_allow_growth_string == nullptr) {
    return gpu_options.allow_growth();
}

Prise sans vergogne: si vous installez le Tensorflow pris en charge par le GPU, la session allouera d'abord tous les GPU, que vous le configuriez pour n'utiliser que le CPU ou le GPU. Je peux ajouter mon conseil que même si vous définissez le graphique pour utiliser uniquement le CPU, vous devez définir la même configuration (comme indiqué ci-dessus :)) pour éviter l'occupation indésirable du GPU.

Et dans une interface interactive comme IPython, vous devez également définir cette configuration, sinon elle allouera toute la mémoire et n'en laissera presque aucune pour les autres. C'est parfois difficile à remarquer.

Pour Tensorflow 2.0, cette solution a fonctionné pour moi. (TF-GPU 2.0, Windows 10, GeForce RTX 2070)

physical_devices = tf.config.experimental.list_physical_devices('GPU')
assert len(physical_devices) > 0, "Not enough GPU hardware devices available"
tf.config.experimental.set_memory_growth(physical_devices[0], True)

Si vous utilisez Tensorflow 2, essayez ce qui suit:

config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
session = tf.compat.v1.Session(config=config)

j'ai essayé de former unet sur le jeu de données voc mais à cause de la taille énorme de l'image, la mémoire se termine. J'ai essayé tous les conseils ci-dessus, même essayé avec une taille de lot == 1, mais sans amélioration. parfois, la version TensorFlow provoque également des problèmes de mémoire. essayez en utilisant

pip install tensorflow-gpu == 1.8.0

Eh bien, je suis nouveau sur tensorflow, j'ai Geforce 740m ou quelque chose de GPU avec 2 Go de RAM, je courais un genre d'exemple manuscrit pour une langue maternelle avec des données de formation contenant 38700 images et 4300 images de test et essayais d'obtenir la précision, rappelez-vous, F1 utilisant le code suivant comme sklearn ne me donnait pas de réponses précises. une fois que j'ai ajouté cela à mon code existant, j'ai commencé à obtenir des erreurs GPU.

TP = tf.count_nonzero(predicted * actual)
TN = tf.count_nonzero((predicted - 1) * (actual - 1))
FP = tf.count_nonzero(predicted * (actual - 1))
FN = tf.count_nonzero((predicted - 1) * actual)

prec = TP / (TP + FP)
recall = TP / (TP + FN)
f1 = 2 * prec * recall / (prec + recall)

De plus, mon modèle était lourd, je suppose, j'obtenais une erreur de mémoire après 147, 148 époques, puis j'ai pensé pourquoi ne pas créer de fonctions pour les tâches, donc je ne sais pas si cela fonctionne de cette façon dans Tensrorflow, mais je me suis demandé si une variable locale était utilisé et lorsqu'il est hors de portée, il peut libérer de la mémoire et j'ai défini les éléments ci-dessus pour la formation et les tests dans les modules, j'ai pu atteindre 10000 époques sans aucun problème, j'espère que cela vous aidera.

# allocate 60% of GPU memory 
from keras.backend.tensorflow_backend import set_session
import tensorflow as tf 
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.6
set_session(tf.Session(config=config))