Jupyter Lab कंप्यूटर को रैम से बाहर निकाल देता है - इसे कैसे रोका जाए?

Question

मैंने हाल ही में जुपिटर लैब का उपयोग करना शुरू किया है और मेरी समस्या यह है कि मैं काफी बड़े डेटासेट्स के साथ काम करता हूं (आमतौर पर डेटासेट ही लगभग होता है। मेरे कंप्यूटर रैम का 1/4)। कुछ परिवर्तनों के बाद, नए पायथन ऑब्जेक्ट्स के रूप में सहेजे गए, मैं स्मृति से बाहर भागने की प्रवृत्ति रखता हूं। मुद्दा यह है कि जब मैं उपलब्ध रैम सीमा के करीब पहुंचता हूं और कोई भी ऑपरेशन करता हूं जिसे दूसरे रैम स्पेस की जरूरत होती है तो मेरा कंप्यूटर फ्रीज हो जाता है और इसे ठीक करने का एकमात्र तरीका इसे फिर से चालू करना है। क्या यह जुपिटर लैब / नोटबुक में एक डिफ़ॉल्ट व्यवहार है या क्या यह कुछ सेटिंग्स है जो मुझे सेट करनी चाहिए? आम तौर पर, मैं प्रोग्राम को क्रैश करने की उम्मीद करूंगा (उदाहरण के लिए RStudio में), पूरे कंप्यूटर पर नहीं

Comments

मुझे पहले भी यही समस्या थी, यह वास्तव में बुरा है। मुझे ज्यूपिटर के मुद्दों पर त्वरित नज़र थी और कुछ नहीं मिला। क्या यह तब भी होता है जब आप आईपीथॉन (सादा अजगर नहीं) कंसोल के माध्यम से चलते हैं?

— बज़ज़

आपने कौन सा पैकेज / मॉड्यूल इस्तेमाल किया? ओएस क्या है? क्या आपने स्वैप किया है? Jupyter Lab का क्या संस्करण है? यदि यह लिनक्स कर्नेल संस्करण था?

— निज़ाम मोहम्मद

यह ज्यादातर पंडों का है, लेकिन मुझे नहीं लगता कि यह पैकेज से संबंधित है। OS उबंटू 16.04.6 LTS है और कर्नेल संस्करण 4.15.0-65-जेनेरिक है। जुपिटर लैब संस्करण 1.0.2 है। मेरे पास 12 जीबी (2 फ़ाइलों को सौंपा) के लिए एक SWAP सेट है जो मेरी रैम से 1.5 है।

— जेक्स

Answer 1

इस समस्या का सबसे मजबूत समाधान डॉकर कंटेनरों का उपयोग करना होगा। आप यह बता सकते हैं कि जुपिटर को कितनी मेमोरी आवंटित की जानी है, और यदि कंटेनर मेमोरी से बाहर निकलता है तो यह केवल एक बड़ी बात नहीं है (बस अक्सर बचाने के लिए याद रखें, लेकिन यह बिना कहे चला जाता है)।

यह ब्लॉग आपको वहां सबसे ज्यादा मिलेगा। स्वतंत्र रूप से उपलब्ध में से एक, आधिकारिक तौर पर बनाए रखा गया, जुपिटर छवियों में से एक से जयुपर लैब स्थापित करने के कुछ सभ्य निर्देश भी हैं:

https://medium.com/fundbox-engineering/overview-d3759e83969c

और फिर आप docker runट्यूटोरियल में वर्णित कमांड को संशोधित कर सकते हैं (जैसे 3 जीबी के लिए):

docker run --memory 3g <other docker run args from tutorial here>

डॉकटर मेमोरी विकल्पों पर सिंटैक्स के लिए, यह प्रश्न देखें:

क्या इकाई docker चलाती है "--ememory" विकल्प की उम्मीद है?

Answer 2

यदि आप उबंटू का उपयोग कर रहे हैं, तो ओओएम हत्यारों की जांच करें, आप यहां से जानकारी प्राप्त कर सकते हैं

आप शुरुआती का उपयोग कर सकते हैं । यह आपकी इच्छानुसार कॉन्फ़िगर किया जा सकता है, जैसे earlyoom -s 90 -m 15शुरू होगा earlyoomऔर जब स्वैप का आकार% 90 से कम है और मेमोरी 15% से कम है, तो यह उस प्रक्रिया को मार देगा जो OOM का कारण बनता है और पूरे सिस्टम को फ्रीज करने से रोकता है। आप प्रक्रियाओं की प्राथमिकता को भी कॉन्फ़िगर कर सकते हैं।

Answer 3

मैं Jupyter Lab पर बहुत बड़े डेटासेट्स (3GB) के साथ भी काम करता हूं और लैब्स पर भी यही समस्या रही है। यह स्पष्ट नहीं है कि यदि आपको पूर्व-परिवर्तित डेटा तक पहुंच बनाए रखने की आवश्यकता है, यदि नहीं, तो मैंने delअप्रयुक्त बड़े डेटाफ़्रेम चर का उपयोग करना शुरू कर दिया है यदि मुझे उनकी आवश्यकता नहीं है। delआपकी स्मृति से चर निकालता है। संपादित करें **: मेरे सामने आ रही समस्या के लिए कई संभावनाएं हैं। जब मैं एक दूरस्थ ज्यूपिटर उदाहरण का उपयोग कर रहा हूं, और जब मैं बड़े परिवर्तनों को पूरा कर रहा हूं, तो स्पाईडर में भी इसका सामना करता हूं।

जैसे

df = pd.read('some_giant_dataframe') # or whatever your import is
new_df = my_transform(df)
del df # if unneeded.

जेक आप बड़े डेटा वर्कफ़्लोज़ पर इस थ्रेड को उपयोगी पा सकते हैं। मैं मेमोरी स्टोरेज में मदद करने के लिए Dask में देख रहा हूं ।

मैंने स्पाइडर और ज्यूपिटर में देखा है कि फ़्रीज़अप आमतौर पर तब होता है जब दूसरे कंसोल में काम करते हुए बड़ी मेमोरी कंसोल चलती है। क्योंकि यह दुर्घटनाग्रस्त होने के बजाय सिर्फ जमा देता है, मुझे लगता है कि इस कर्नेल के साथ कुछ करना है। IPython github में कुछ मेमोरी इश्यू खुले हैं - # 10082 और # 10117 सबसे अधिक प्रासंगिक लगते हैं। यहां एक उपयोगकर्ता सुझाव देता है कि jediजेडी को टैब पूरा करने या अपडेट करने में अक्षम करें ।

10117 में उन्होंने इसके उत्पादन की जाँच करने का प्रस्ताव रखा get_ipython().history_manager.db_log_output। मेरे पास समान मुद्दे हैं और मेरी सेटिंग सही है, लेकिन यह जांचने लायक है

Answer 4

आप क्लाउड में भी नोटबुक का उपयोग कर सकते हैं, जैसे कि यहां Google Colab । उन्होंने अनुशंसित RAM के लिए सुविधा प्रदान की है और Jupyter नोटबुक के लिए समर्थन डिफ़ॉल्ट रूप से है।

Answer 5

मुझे लगता है कि आपको विखंडू का उपयोग करना चाहिए। उसके जैसा:

df_chunk = pd.read_csv(r'../input/data.csv', chunksize=1000000)
chunk_list = []  # append each chunk df here 

# Each chunk is in df format
for chunk in df_chunk:  
    # perform data filtering 
    chunk_filter = chunk_preprocessing(chunk)

    # Once the data filtering is done, append the chunk to list
    chunk_list.append(chunk_filter)

# concat the list into dataframe 
df_concat = pd.concat(chunk_list)

अधिक जानकारी के लिए इसे देखें : https://towardsdatascience.com/why-and-how-to-use-pandas-with-large-data-9594dda2ea4c

मेरा सुझाव है कि फिर से एक सूची संलग्न न करें (शायद रैम फिर से अधिभार करेगी)। आप पाश के लिए अपना काम खत्म करना चाहिए।

Comments

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

— बज़ज़

Answer 6

मैं निम्नलिखित प्रश्न का उत्तर संक्षेप में देने जा रहा हूं । आप अपने प्रोग्राम की मेमोरी उपयोग को सीमित कर सकते हैं। निम्नलिखित में यह फ़ंक्शन होगा ram_intense_foo()। फोन करने से पहले आपको फ़ंक्शन को कॉल करने की आवश्यकता हैlimit_memory(10)

import resource
import platform
import sys
import numpy as np 

def memory_limit(percent_of_free):
    soft, hard = resource.getrlimit(resource.RLIMIT_AS)
    resource.setrlimit(resource.RLIMIT_AS, (get_memory() * 1024 * percent_of_free / 100, hard))

def get_memory():
    with open('/proc/meminfo', 'r') as mem:
        free_memory = 0
        for i in mem:
            sline = i.split()
            if str(sline[0]) == 'MemAvailable:':
                free_memory = int(sline[1])
                break
    return free_memory

def ram_intense_foo(a,b):
    A = np.random.rand(a,b)
    return A.T@A

if __name__ == '__main__':
    memory_limit(95)
    try:
        temp = ram_intense_foo(4000,10000)
        print(temp.shape)
    except MemoryError:
        sys.stderr.write('\n\nERROR: Memory Exception\n')
        sys.exit(1)

Answer 7

बड़े डेटाफ़्रेम के संपूर्ण आउटपुट को देखने का कोई कारण नहीं है। बड़े डेटाफ़्रेम को देखना या हेरफेर करना आपके कंप्यूटर संसाधनों की बड़ी मात्रा का अनावश्यक रूप से उपयोग करेगा।

जो भी आप कर रहे हैं वह लघु में किया जा सकता है। डेटा फ़्रेम छोटा होने पर डेटा को कोडिंग और मैनिप्युलेट करना बहुत आसान है। बड़े डेटा के साथ काम करने का सबसे अच्छा तरीका एक नया डेटा फ्रेम बनाना है जो केवल छोटे हिस्से या बड़े डेटा फ़्रेम का छोटा नमूना लेता है। फिर आप डेटा का पता लगा सकते हैं और छोटे डेटा फ्रेम पर अपनी कोडिंग कर सकते हैं। एक बार जब आप डेटा का पता लगा लेते हैं और अपना कोड काम कर लेते हैं, तो बस उस कोड का उपयोग बड़े डेटा फ्रेम पर करें।

सबसे आसान तरीका केवल सिर, () फ़ंक्शन का उपयोग करके डेटा फ्रेम से पहली पंक्तियों की संख्या, पहले n को लेना है। सिर फ़ंक्शन केवल n, प्रिंट की संख्या को प्रिंट करता है। आप बड़े डेटा फ़्रेम पर हेड फ़ंक्शन का उपयोग करके एक मिनी डेटा फ़्रेम बना सकते हैं। नीचे मैंने पहली 50 पंक्तियों का चयन करने और छोटे मान के लिए उनके मान को चुना है। यह मानता है कि बिगडाटा एक डेटा फ़ाइल है जो इस प्रोजेक्ट के लिए खोली गई लाइब्रेरी से आती है।

library(namedPackage) 

df <- data.frame(BigData)                #  Assign big data to df
small_df <- head(df, 50)         #  Assign the first 50 rows to small_df

यह ज्यादातर समय काम करेगा, लेकिन कभी-कभी बड़े डेटा फ्रेम में प्रीसेटेड वेरिएबल्स या पहले से ग्रुप किए गए वेरिएबल्स आते हैं। यदि बड़ा डेटा ऐसा है, तो आपको बड़े डेटा से पंक्तियों का एक यादृच्छिक नमूना लेना होगा। फिर निम्न कोड का उपयोग करें:

df <- data.frame(BigData)

set.seed(1016)                                          # set your own seed

df_small <- df[sample(nrow(df),replace=F,size=.03*nrow(df)),]     # samples 3% rows
df_small                                                         # much smaller df