Jupyter Lab membekukan komputer saat kehabisan RAM - bagaimana cara mencegahnya?

Saya baru-baru ini mulai menggunakan Jupyter Lab dan masalah saya adalah saya bekerja dengan dataset yang cukup besar (biasanya dataset itu sendiri kira-kira 1/4 dari RAM komputer saya). Setelah beberapa transformasi, disimpan sebagai objek Python baru, saya cenderung kehabisan memori. Masalahnya adalah ketika saya mendekati batas RAM yang tersedia dan melakukan operasi apa pun yang membutuhkan ruang RAM lain, komputer saya macet dan satu-satunya cara untuk memperbaikinya adalah dengan menyalakannya kembali. Apakah ini perilaku default di Jupyter Lab / Notebook atau itu beberapa pengaturan yang harus saya atur? Biasanya, saya berharap program crash (seperti di RStudio misalnya), bukan seluruh komputer

Tentu saja solusi paling kuat untuk masalah ini adalah dengan menggunakan wadah Docker. Anda dapat menentukan berapa banyak memori yang dialokasikan untuk Jupyter, dan jika wadah kehabisan memori itu bukan masalah besar (hanya ingat untuk menabung sering, tapi itu tidak perlu dikatakan).

Blog ini akan membuat Anda mendapatkan sebagian besar perjalanan ke sana. Ada juga beberapa instruksi yang layak untuk mengatur Jupyter Lab dari salah satu gambar Jupyter yang tersedia secara bebas di sini:

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

dan kemudian Anda dapat memodifikasi docker runperintah seperti yang dijelaskan dalam tutorial sebagai (misalnya untuk 3GB):

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

Untuk sintaks pada opsi memori buruh pelabuhan, lihat pertanyaan ini:

Unit apa yang diharapkan oleh buruh pelabuhan menjalankan opsi "- memori"?

Jika Anda menggunakan Ubuntu, periksa pembunuh OOM, Anda bisa mendapatkan informasi dari sini

Anda bisa menggunakan earlyoom . Ini dapat dikonfigurasi sesuai keinginan, misalnya earlyoom -s 90 -m 15akan memulai earlyoomdan ketika ukuran swap kurang dari% 90 dan memori kurang dari% 15, itu akan mematikan proses yang menyebabkan OOM dan mencegah seluruh sistem membeku. Anda juga dapat mengkonfigurasi prioritas proses.

Saya juga bekerja dengan dataset sangat besar (3GB) di Jupyter Lab dan telah mengalami masalah yang sama di Labs. Tidak jelas apakah Anda perlu mempertahankan akses ke data pra-transformasi, jika tidak, saya sudah mulai menggunakan delvariabel dataframe besar yang tidak digunakan jika saya tidak membutuhkannya. delmenghapus variabel dari memori Anda. Sunting **: ada beberapa kemungkinan untuk masalah yang saya temui. Saya menemukan ini lebih sering ketika saya menggunakan contoh jupyter jarak jauh, dan di mata-mata juga ketika saya melakukan transformasi besar.

misalnya

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

Jakes Anda juga dapat menemukan utas ini pada alur kerja data besar . Saya sudah mencari ke Dask untuk membantu dengan penyimpanan memori.

Saya perhatikan di spyder dan jupyter bahwa freezeup biasanya akan terjadi ketika bekerja di konsol lain sementara konsol memori besar berjalan. Mengenai mengapa ia macet dan bukannya macet, saya pikir ini ada hubungannya dengan kernel. Ada beberapa masalah memori yang terbuka di IPython github - # 10082 dan # 10117 tampaknya paling relevan. Satu pengguna di sini menyarankan untuk menonaktifkan penyelesaian tab di jediatau memperbarui jedi.

Pada 10117 mereka mengusulkan memeriksa output get_ipython().history_manager.db_log_output. Saya memiliki masalah yang sama dan pengaturan saya benar, tetapi perlu diperiksa

Anda juga dapat menggunakan buku catatan di cloud, seperti Google Colab di sini . Mereka telah menyediakan fasilitas untuk RAM yang direkomendasikan dan dukungan untuk notebook Jupyter secara default.

Saya pikir Anda harus menggunakan bongkahan. Seperti itu:

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)

Untuk informasi lebih lanjut, periksa: https://towardsdatascience.com/why-and-how-to-use-pandas-with-large-data-9594dda2ea4c

Saya sarankan jangan menambahkan daftar lagi (mungkin RAM akan kelebihan beban lagi). Anda harus menyelesaikan pekerjaan Anda dalam lingkaran itu.

Saya akan meringkas jawaban dari pertanyaan berikut . Anda dapat membatasi penggunaan memori program Anda. Berikut ini adalah fungsinya ram_intense_foo(). Sebelum memanggil Anda perlu memanggil fungsilimit_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)

Tidak ada alasan untuk melihat seluruh output dari kerangka data yang besar. Melihat atau memanipulasi dataframe besar tidak perlu menggunakan sumber daya komputer Anda dalam jumlah besar.

Apa pun yang Anda lakukan dapat dilakukan dalam bentuk mini. Jauh lebih mudah bekerja pada pengkodean dan memanipulasi data ketika bingkai data kecil. Cara terbaik untuk bekerja dengan data besar adalah membuat bingkai data baru yang hanya mengambil sebagian kecil atau sampel kecil dari bingkai data besar. Kemudian Anda dapat menjelajahi data dan melakukan pengkodean pada bingkai data yang lebih kecil. Setelah Anda menjelajahi data dan membuat kode Anda berfungsi, maka gunakan saja kode itu pada bingkai data yang lebih besar.

Cara termudah adalah dengan mengambil n pertama, jumlah baris pertama dari bingkai data menggunakan fungsi head (). Fungsi kepala hanya mencetak n, jumlah baris. Anda dapat membuat bingkai data mini dengan menggunakan fungsi kepala pada bingkai data besar. Di bawah ini saya memilih untuk memilih 50 baris pertama dan meneruskan nilainya ke small_df. Ini mengasumsikan BigData adalah file data yang berasal dari perpustakaan yang Anda buka untuk proyek ini.

library(namedPackage) 

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

Ini akan bekerja sebagian besar waktu, tetapi kadang-kadang bingkai data besar datang dengan variabel yang sudah ditentukan atau dengan variabel yang sudah dikelompokkan. Jika big data seperti ini, maka Anda perlu mengambil sampel acak dari baris dari big data. Kemudian gunakan kode yang berikut:

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