Menguasai Pengoptimuman Memori Python: Teknik untuk Sains Data dan Pembelajaran Mesin

Sebagai pengarang yang prolifik, saya menjemput anda untuk meneroka koleksi buku Amazon saya. Ingat untuk mengikuti saya di Medium untuk mendapatkan kemas kini dan tunjukkan sokongan anda! Dorongan anda amat dihargai!

Python yang semakin menonjol dalam sains data dan pembelajaran mesin memerlukan pengurusan memori yang cekap untuk projek berskala besar. Saiz set data yang berkembang dan permintaan pengiraan yang semakin meningkat menjadikan penggunaan memori yang dioptimumkan menjadi kritikal. Pengalaman saya dengan aplikasi Python intensif memori telah menghasilkan beberapa strategi pengoptimuman yang berkesan, yang akan saya kongsikan di sini.

Kita akan mulakan dengan NumPy, perpustakaan asas untuk pengiraan berangka. Tatasusunan NumPy menawarkan kelebihan memori yang besar berbanding senarai Python, terutamanya untuk set data yang luas. Peruntukan memori bersebelahan mereka dan penaipan statik meminimumkan overhed.

Pertimbangkan perbandingan ini:

<code class="language-python">import numpy as np
import sys

# Creating a list and a NumPy array with 1 million integers
py_list = list(range(1000000))
np_array = np.arange(1000000)

# Comparing memory usage
print(f"Python list size: {sys.getsizeof(py_list) / 1e6:.2f} MB")
print(f"NumPy array size: {np_array.nbytes / 1e6:.2f} MB")</code>

Jejak memori tatasusunan NumPy yang lebih kecil akan dapat dilihat dengan jelas. Perbezaan ini menjadi lebih ketara dengan set data yang lebih besar.

NumPy juga menyediakan operasi yang cekap ingatan. Daripada menjana tatasusunan baharu untuk setiap operasi, ia sering mengubah suai tatasusunan di tempat:

<code class="language-python"># In-place operations
np_array += 1  # Modifies the original array directly</code>

Beralih kepada Panda, jenis data kategori adalah kunci kepada pengoptimuman memori. Untuk lajur rentetan dengan nilai unik terhad, menukar kepada jenis kategori secara drastik mengurangkan penggunaan memori:

<code class="language-python">import pandas as pd

# DataFrame with repeated string values
df = pd.DataFrame({'category': ['A', 'B', 'C'] * 1000000})

# Memory usage check
print(f"Original memory usage: {df.memory_usage(deep=True).sum() / 1e6:.2f} MB")

# Conversion to categorical
df['category'] = pd.Categorical(df['category'])

# Post-conversion memory usage
print(f"Memory usage after conversion: {df.memory_usage(deep=True).sum() / 1e6:.2f} MB")</code>

Penjimatan memori boleh menjadi besar, terutamanya dengan set data besar yang mengandungi rentetan berulang.

Untuk set data yang jarang, Pandas menawarkan struktur data yang jarang, hanya menyimpan nilai bukan nol, menghasilkan penjimatan memori yang ketara untuk set data dengan banyak nilai nol atau sifar:

<code class="language-python"># Creating a sparse series
sparse_series = pd.Series([0, 0, 1, 0, 2, 0, 0, 3], dtype="Sparse[int]")

print(f"Memory usage: {sparse_series.memory_usage(deep=True) / 1e3:.2f} KB")</code>

Apabila set data melebihi RAM yang tersedia, fail yang dipetakan memori adalah transformatif. Mereka membenarkan bekerja dengan fail besar seolah-olah ia berada dalam ingatan, tanpa memuatkan keseluruhan fail:

<code class="language-python">import mmap
import os

# Creating a large file
with open('large_file.bin', 'wb') as f:
    f.write(b'0' * 1000000000)  # 1 GB file

# Memory-mapping the file
with open('large_file.bin', 'r+b') as f:
    mmapped_file = mmap.mmap(f.fileno(), 0)

# Reading from the memory-mapped file
print(mmapped_file[1000000:1000010])

# Cleaning up
mmapped_file.close()
os.remove('large_file.bin')</code>

Ini amat berguna untuk akses rawak pada fail besar tanpa memuatkannya sepenuhnya ke dalam memori.

Ekspresi penjana dan itertools berkuasa untuk pemprosesan data yang cekap memori. Mereka membenarkan memproses set data yang besar tanpa memuatkan semuanya ke dalam memori serentak:

<code class="language-python">import itertools

# Generator expression
sum_squares = sum(x*x for x in range(1000000))

# Using itertools for memory-efficient operations
evens = itertools.islice(itertools.count(0, 2), 1000000)
sum_evens = sum(evens)

print(f"Sum of squares: {sum_squares}")
print(f"Sum of even numbers: {sum_evens}")</code>

Teknik ini meminimumkan overhed memori semasa memproses set data yang besar.

Untuk bahagian kod yang kritikal prestasi, Cython menawarkan potensi pengoptimuman yang ketara. Menyusun kod Python kepada C menghasilkan peningkatan kelajuan yang ketara dan potensi pengurangan memori:

<code class="language-cython">def sum_squares_cython(int n):
    cdef int i
    cdef long long result = 0
    for i in range(n):
        result += i * i
    return result

# Usage
result = sum_squares_cython(1000000)
print(f"Sum of squares: {result}")</code>

Fungsi Cython ini akan mengatasi rakan Python tulennya, terutamanya untuk nilai n yang besar.

PyPy, pengkompil Just-In-Time, menawarkan pengoptimuman memori automatik. Ia amat berfaedah untuk program yang berjalan lama, selalunya mengurangkan penggunaan memori dengan ketara:

<code class="language-python">import numpy as np
import sys

# Creating a list and a NumPy array with 1 million integers
py_list = list(range(1000000))
np_array = np.arange(1000000)

# Comparing memory usage
print(f"Python list size: {sys.getsizeof(py_list) / 1e6:.2f} MB")
print(f"NumPy array size: {np_array.nbytes / 1e6:.2f} MB")</code>

PyPy boleh membawa kepada kecekapan dan kelajuan memori yang lebih baik berbanding CPython standard.

Profil memori adalah penting untuk mengenal pasti peluang pengoptimuman. Pustaka memory_profiler ialah alat yang berharga:

<code class="language-python"># In-place operations
np_array += 1  # Modifies the original array directly</code>

Gunakan mprof run script.py dan mprof plot untuk menggambarkan penggunaan memori.

Mengatasi kebocoran memori adalah penting. Modul tracemalloc (Python 3.4 ) membantu mengenal pasti sumber peruntukan memori:

<code class="language-python">import pandas as pd

# DataFrame with repeated string values
df = pd.DataFrame({'category': ['A', 'B', 'C'] * 1000000})

# Memory usage check
print(f"Original memory usage: {df.memory_usage(deep=True).sum() / 1e6:.2f} MB")

# Conversion to categorical
df['category'] = pd.Categorical(df['category'])

# Post-conversion memory usage
print(f"Memory usage after conversion: {df.memory_usage(deep=True).sum() / 1e6:.2f} MB")</code>

Ini menentukan bahagian kod intensif memori.

Untuk aplikasi yang sangat intensif memori, pengurusan memori tersuai mungkin diperlukan. Ini mungkin melibatkan kumpulan objek untuk kegunaan semula objek atau cache tersuai:

<code class="language-python"># Creating a sparse series
sparse_series = pd.Series([0, 0, 1, 0, 2, 0, 0, 3], dtype="Sparse[int]")

print(f"Memory usage: {sparse_series.memory_usage(deep=True) / 1e3:.2f} KB")</code>

Ini meminimumkan penciptaan/pemusnahan objek di atas kepala.

Untuk set data yang sangat besar, pertimbangkan pustaka pengiraan luar teras seperti Dask:

<code class="language-python">import mmap
import os

# Creating a large file
with open('large_file.bin', 'wb') as f:
    f.write(b'0' * 1000000000)  # 1 GB file

# Memory-mapping the file
with open('large_file.bin', 'r+b') as f:
    mmapped_file = mmap.mmap(f.fileno(), 0)

# Reading from the memory-mapped file
print(mmapped_file[1000000:1000010])

# Cleaning up
mmapped_file.close()
os.remove('large_file.bin')</code>

Dask mengendalikan set data yang lebih besar daripada RAM yang tersedia dengan membahagikan pengiraan kepada bahagian yang lebih kecil.

Pengoptimuman algoritma juga penting. Memilih algoritma yang cekap boleh mengurangkan penggunaan memori dengan ketara:

<code class="language-python">import itertools

# Generator expression
sum_squares = sum(x*x for x in range(1000000))

# Using itertools for memory-efficient operations
evens = itertools.islice(itertools.count(0, 2), 1000000)
sum_evens = sum(evens)

print(f"Sum of squares: {sum_squares}")
print(f"Sum of even numbers: {sum_evens}")</code>

Fungsi Fibonacci yang dioptimumkan ini menggunakan ingatan berterusan, tidak seperti pelaksanaan rekursif yang naif.

Ringkasnya, pengoptimuman memori Python yang berkesan menggabungkan struktur data yang cekap, perpustakaan khusus, pengekodan cekap memori dan algoritma yang sesuai. Teknik ini mengurangkan jejak memori, membolehkan pengendalian set data yang lebih besar dan pengiraan yang lebih kompleks. Jangan lupa untuk memprofilkan kod anda untuk mengenal pasti kesesakan dan memfokuskan usaha pengoptimuman di mana ia akan memberi impak yang paling besar.

---

101 Buku

101 Buku, sebuah rumah penerbitan berkuasa AI yang diasaskan bersama oleh pengarang Aarav Joshi, memanfaatkan AI untuk meminimumkan kos penerbitan, menjadikan pengetahuan berkualiti boleh diakses (sesetengah buku adalah serendah $4!).

Cari buku Kod Bersih Golang kami di Amazon.

Untuk kemas kini dan lebih banyak tajuk, cari Aarav Joshi di Amazon. Diskaun istimewa boleh didapati melalui [pautan].

Ciptaan Kami

Terokai ciptaan kami:

Pusat Pelabur | Pelabur Central Spanish | Pelabur Jerman Tengah | Hidup Pintar | Epos & Gema | Misteri Membingungkan | Hindutva | Pembangunan Elit | Sekolah JS

---

Kami berada di Sederhana

Tech Koala Insights | Dunia Epok & Gema | Medium Pusat Pelabur | Medium Misteri Membingungkan | Sains & Zaman Sederhana | Hindutva Moden

Atas ialah kandungan terperinci Menguasai Pengoptimuman Memori Python: Teknik untuk Sains Data dan Pembelajaran Mesin. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!