282

मैं ऐसे वातावरण में काम करता हूं जिसमें कम्प्यूटेशनल संसाधन साझा किए जाते हैं, यानी, हमारे पास कुछ सर्वर मशीनें हैं जो कुछ एनवीडिया टाइटन एक्स जीपीयू से लैस हैं।

छोटे से मध्यम आकार के मॉडल के लिए, टाइटन एक्स के 12 जीबी आमतौर पर 2-3 लोगों के लिए समान GPU पर समवर्ती प्रशिक्षण चलाने के लिए पर्याप्त हैं। यदि मॉडल इतने छोटे होते हैं कि एक एकल मॉडल GPU की सभी कम्प्यूटेशनल इकाइयों का पूरा लाभ नहीं उठाता है, तो यह वास्तव में एक के बाद एक प्रशिक्षण प्रक्रिया चलाने की तुलना में स्पीडअप हो सकता है। यहां तक कि ऐसे मामलों में जहां GPU का समवर्ती उपयोग अलग-अलग प्रशिक्षण समय को धीमा कर देता है, फिर भी कई उपयोगकर्ताओं को एक साथ GPU पर प्रशिक्षित करने की लचीलापन होना अच्छा है।

TensorFlow के साथ समस्या यह है कि डिफ़ॉल्ट रूप से, यह लॉन्च होने पर उपलब्ध GPU मेमोरी की पूरी राशि आवंटित करता है। यहां तक कि एक छोटे से दो-परत तंत्रिका नेटवर्क के लिए, मैं देखता हूं कि सभी 12 जीबी जीपीयू मेमोरी का उपयोग किया जाता है।

क्या TensorFlow को केवल आवंटित करने का एक तरीका है, कहें, 4 GB GPU मेमोरी, यदि कोई जानता है कि यह किसी दिए गए मॉडल के लिए पर्याप्त है?

python tensorflow nvidia-titan

— फेबियन सी।
स्रोत

292

जब आप वैकल्पिक तर्क के भाग के रूप में tf.Sessionपास करके निर्माण की जाने वाली GPU मेमोरी का अंश सेट कर सकते हैं :tf.GPUOptionsconfig

# 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))

per_process_gpu_memory_fractionएक मुश्किल के रूप में कार्य ऊपरी कि एक ही मशीन पर प्रत्येक GPU पर प्रक्रिया द्वारा उपयोग किया जाएगा GPU स्मृति की मात्रा पर बाध्य। वर्तमान में, यह अंश समान मशीन पर सभी GPU के लिए समान रूप से लागू किया जाता है; प्रति-GPU के आधार पर इसे सेट करने का कोई तरीका नहीं है।

— mrry
स्रोत

3

आपका बहुत बहुत धन्यवाद। वर्तमान डॉक में यह जानकारी काफी छिपी हुई है। मैं इसे अपने आप से कभी नहीं मिला :-) अगर आप जवाब दे सकते हैं, तो मैं दो अतिरिक्त infos के लिए पूछना चाहूंगा: 1- क्या यह सीमा कभी उपयोग की गई मेमोरी, या बस शुरू में आवंटित की गई मेमोरी है? (यानी? क्या यह अभी भी अधिक मेमोरी आवंटित करेगा यदि गणना ग्राफ द्वारा इसके लिए कोई आवश्यकता है) 2- क्या प्रति-GPU के आधार पर इसे सेट करने का कोई तरीका है?

— फाबिएन सी।

15

संबंधित नोट: TensorFlow को सीमित करने के लिए CUDA_VISIBLE_DEVICES सेट करना मेरे लिए एक ही GPU काम करता है। देखें acceleware.com/blog/cudavisibledevices-masking-gpus

— rd11

2

ऐसा लगता है कि मेमोरी आवंटन अनुरोध पर थोड़ा अधिक हो जाता है, ई..गैस मैंने 24443MiB gpu पर per_process_gpu_memory_fraction = 0.0909 का अनुरोध किया और 2627MiB

— emy jeremy_rutman

2

मैं एक में काम करने के लिए इसे पाने के लिए नहीं कर पा रहेMonitoredTrainingSession

— अंजुम सईद

2

@jeremy_rutman मेरा मानना है कि यह cudnn और cublas संदर्भ आरंभीकरण के कारण है। यह तभी प्रासंगिक है जब आप उन गुठली का उपयोग कर रहे हैं जो उन कामों का उपयोग करते हैं।

— डैनियल

186

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

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

— सर्गेई डेमिसानोव
स्रोत

13

यह वही है जो मैं चाहता हूं क्योंकि बहु-उपयोगकर्ता वातावरण में, कोड में ही आरक्षित करने के लिए जीपीयू मेमोरी की सटीक मात्रा निर्दिष्ट करना बहुत असुविधाजनक है।

— xuancong84

4

इसके अलावा, अगर आप एक TF बैकएंड साथ Keras उपयोग कर रहे हैं, तो आप इस का उपयोग करें और चला सकते हैं from keras import backend as Kऔर K.set_session(sess)से बचने के स्मृति सीमाओं के

— ओलिवर

50

यहाँ पुस्तक से एक अंश है Deep Learning with TensorFlow

कुछ मामलों में यह प्रक्रिया के लिए उपलब्ध स्मृति का एक सबसेट आवंटित करने के लिए वांछनीय है, या केवल स्मृति के उपयोग को बढ़ने के लिए जैसा कि प्रक्रिया द्वारा आवश्यक है। TensorFlow इसे नियंत्रित करने के लिए सत्र पर दो कॉन्फ़िगरेशन विकल्प प्रदान करता है । पहला allow_growthविकल्प है, जो रनटाइम आवंटन के आधार पर केवल GPU मेमोरी के रूप में आवंटित करने का प्रयास करता है, यह बहुत कम मेमोरी आवंटित करना शुरू करता है, और जैसे-जैसे सत्र चलता है और अधिक GPU मेमोरी की आवश्यकता होती है, हम Tensorio.lo द्वारा आवश्यक GPU मेमोरी क्षेत्र का विस्तार करते हैं प्रक्रिया।

1) विकास की अनुमति दें: (अधिक लचीला)

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

दूसरा तरीका per_process_gpu_memory_fractionविकल्प है, जो मेमोरी की समग्र मात्रा के अंश को निर्धारित करता है कि eachदृश्यमान जीपीयू को आवंटित किया जाना चाहिए। नोट: आवश्यक मेमोरी की कोई रिलीज़ नहीं, यह हो जाने पर मेमोरी फ़्रेग्मेंटेशन को भी खराब कर सकता है।

2) निर्धारित स्मृति आवंटित करें :

40%प्रत्येक GPU की कुल मेमोरी को केवल :

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

नोट: यह केवल तभी उपयोगी है जब आप सही मायने में TensorFlow प्रक्रिया पर उपलब्ध GPU मेमोरी की मात्रा को बांधना चाहते हैं।

— user1767754
स्रोत

जहाँ तक आपके प्रश्न का संबंध है, विकल्प 2 आपके लिए उपयोगी हो सकता है। सामान्य तौर पर यदि आपके पास GPU और गतिशील नेटवर्क पर कई एप्लिकेशन नहीं चल रहे हैं, तो यह 'अनुमति दें' विकल्प का उपयोग करने के लिए समझ में आता है।

— अनिकेत

25

TensorFlow 2.0 अल्फा और परे के लिए अद्यतन किया गया

2.0 अल्फा डॉक्स से, TensorFlow के साथ कुछ भी करने से पहले जवाब अब सिर्फ एक लाइन है:

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

— थियो
स्रोत

1

@ अक्षय अक्षय न केवल टीएफ़ 2.0 और इसके बाद के संस्करण के लिए है। यहाँ अन्य उत्तर 1.13 और पूर्व के लिए ठीक काम करेंगे।

— थियो

19

उपरोक्त सभी उत्तर sess.run()कॉल के साथ निष्पादन को मानते हैं, जो TensorFlow के हाल के संस्करणों में नियम के बजाय अपवाद बन रहा है।

tf.Estimatorफ्रेमवर्क का उपयोग करते समय (टेंसोरफ्लो १.४ और उससे अधिक) अंश को अंतर्निहित रूप से पास करने का तरीका MonitoredTrainingSessionहै,

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)

इसी तरह ईगर मोड (TensorFlow 1.5 और इसके बाद के संस्करण) में,

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

संपादित करें: 11-04-2018 एक उदाहरण के रूप में, यदि आप उपयोग करना चाहते हैं tf.contrib.gan.train, तो आप कुछ समान उपयोग कर सकते हैं:

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

— उर्स
स्रोत

16

Tensorflow संस्करण 2.0 और 2.1 के लिए निम्नलिखित स्निपेट का उपयोग करें :

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

पूर्व संस्करणों के लिए , निम्नलिखित स्निपेट मेरे लिए काम करते थे:

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

— अनुराग
स्रोत

10

Tensorflow 2.0 बीटा और (शायद) से परे

एपीआई फिर से बदल गया। अब इसमें पाया जा सकता है:

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

उपनाम:

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

संदर्भ:

इसे भी देखें: Tensorflow - एक GPU का उपयोग करें : https://www.tensorflow.org/guide/gpu

Tensorflow 2.0 अल्फा के लिए देखें: यह उत्तर

— mx_muc
स्रोत

8

आप उपयोग कर सकते हैं

TF_FORCE_GPU_ALLOW_GROWTH=true

अपने पर्यावरण चर में।

में 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();
}

— मे खलीली
स्रोत

5

बेशर्म प्लग: यदि आप GPU समर्थित Tensorflow को स्थापित करते हैं, तो सत्र पहले सभी GPU को आवंटित करेगा, चाहे आप इसे केवल CPU या GPU का उपयोग करने के लिए सेट करें। मैं अपने टिप को जोड़ सकता हूं कि यहां तक कि आप सीपीयू का उपयोग करने के लिए ग्राफ़ सेट करें केवल अवांछित जीपीयू कब्जे को रोकने के लिए आपको उसी कॉन्फ़िगरेशन (जैसा कि ऊपर :)) में सेट करना चाहिए।

और IPython जैसे इंटरैक्टिव इंटरफ़ेस में आपको उस कॉन्फ़िगर को भी सेट करना चाहिए, अन्यथा यह सभी मेमोरी को आवंटित करेगा और दूसरों के लिए लगभग कोई भी नहीं छोड़ देगा। यह कभी-कभी नोटिस करना कठिन होता है।

— लर्नर झांग
स्रोत

3

के लिए Tensorflow 2.0 यह इस समाधान मेरे लिए काम किया। (TF-GPU 2.0, विंडोज 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)

— Sunsetquest
स्रोत

1

मैं TF-GPU 2.0, Ubuntu 16.04.6, Tesla K80 का उपयोग कर रहा हूं।

— अजार

@ नज़र - साझा करने के लिए धन्यवाद। यह उबंटू और विंडोज दोनों पर एक ही मुद्दा दिलचस्प है। किसी तरह, मैं हमेशा सोचता हूं कि हार्डवेयर के करीब होने पर मुद्दे अलग हैं। शायद यह कम होता जा रहा है इसलिए समय बीतता जा रहा है - शायद एक अच्छी बात।

— सूर्यास्तक्विस्ट

3

यदि आप Tensorflow 2 का उपयोग कर रहे हैं, तो निम्नलिखित प्रयास करें:

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

— Moosefeather
स्रोत

Tensorflow 2 के लिए काम करते

— alhassan मोबिन

1

मैंने वोक डेटा सेट पर यूनेट को प्रशिक्षित करने की कोशिश की, लेकिन विशाल छवि आकार, मेमोरी फ़िनिश के कारण। मैंने उपरोक्त सभी युक्तियों की कोशिश की, यहां तक कि बैच आकार == 1 के साथ भी प्रयास किया, फिर भी कोई सुधार नहीं हुआ। कभी-कभी TensorFlow संस्करण भी स्मृति समस्याओं का कारण बनता है। प्रयोग करके देखें

पाइप स्थापित टेंसरफ़्लो-जीपीयू == 1.8.0

— खान
स्रोत

1

वैसे मैं टेंसोफ़्लो में नया हूं, मेरे पास 2 जीबी रैम के साथ जीईएफएस 740 एम या कुछ जीपीयू है, मैं मूल भाषा के लिए 38700 छवियों और 4300 परीक्षण छवियों वाले प्रशिक्षण डेटा के साथ उदाहरण के लिए हस्तलिखित लिख रहा था और सटीक, याद करने की कोशिश कर रहा था। Sklearn के रूप में निम्नलिखित कोड का उपयोग करते हुए F1 मुझे सटीक पुनरावृत्ति नहीं दे रहा था। एक बार जब मैंने इसे अपने मौजूदा कोड में जोड़ा तो मुझे 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)

इसके अलावा मेरा मॉडल भारी था, मुझे लगता है कि मुझे 147, 148 युगों के बाद मेमोरी की त्रुटि हो रही थी, और फिर मैंने सोचा कि क्यों न कार्यों के लिए कार्य बनाया जाए, इसलिए मुझे नहीं पता कि क्या यह इस तरह से टेंसरफ़्लो में काम करता है, लेकिन मुझे लगा कि अगर एक स्थानीय चर है उपयोग किया जाता है और जब स्कोप से यह मेमोरी रिलीज़ हो सकती है और मैंने मॉड्यूल में प्रशिक्षण और परीक्षण के लिए उपरोक्त तत्वों को परिभाषित किया है, तो मैं बिना किसी मुद्दे के 10000 युगों को प्राप्त करने में सक्षम था, मुझे उम्मीद है कि इससे मदद मिलेगी ।।

— इमरान उद दीन
स्रोत

मैं TF की उपयोगिता पर आश्चर्यचकित हूं, लेकिन यह स्मृति उपयोग द्वारा भी है। CPU python पर TF उदाहरणों में उपयोग किए जाने वाले फूल डेटासेट पर प्रशिक्षण कार्य के लिए 30GB या तो आवंटित किया जा सकता है। पागल।

— एरिक एम

1

# 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))

— DSBLR
स्रोत

प्रदान किए गए उत्तर को निम्न गुणवत्ता पोस्ट के रूप में समीक्षा के लिए चिह्नित किया गया था। यहाँ मैं कैसे एक अच्छा जवाब लिखने के लिए कुछ दिशानिर्देश हैं ? । यह प्रदान किया गया उत्तर सही हो सकता है, लेकिन यह एक स्पष्टीकरण से लाभान्वित हो सकता है। कोड केवल उत्तरों को "अच्छा" उत्तर नहीं माना जाता है। से समीक्षा ।

— ट्रेंटन मैककिनी

एक GPU मेमोरी की समग्रता को आवंटित करने से टेंसरफ्लो को कैसे रोकें?

TensorFlow 2.0 अल्फा और परे के लिए अद्यतन किया गया

Tensorflow 2.0 बीटा और (शायद) से परे