Pandas & NumPy Academy · Pelajaran

Agregasi Bertahap di Seluruh Potongan

Akumulasikan jumlah, total, dan nilai min/maks berjalan di seluruh potongan tanpa menyimpan seluruh file dalam memori.

Agregasi Bertahap di Seluruh Potongan adalah pelajaran Pandas & NumPy Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Pandas & NumPy Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Pandas & NumPy Academy mencakup 4 pelajaran total.

Mengapa Agregasi Bertahap?

Agregasi bertahap adalah kunci untuk menganalisis dataset yang lebih besar daripada RAM tanpa mendistribusikan komputasi ke beberapa mesin. Alih-alih memuat semua data untuk menghitung statistik akhir, Anda mempertahankan akumulator berjalan — jumlah parsial, banyaknya data, nilai min/maks — dan memperbaruinya pada setiap bagian. Hasil akhir disusun dari akumulator ringan ini setelah seluruh file dipindai. Pola ini dapat menangani file berukuran terabita pada satu laptop.

Menghitung Baris dan Mean

Menghitung mean di seluruh bagian memerlukan pelacakan jumlah berjalan dan banyaknya data secara terpisah. Anda tidak dapat sekadar merata-ratakan mean per bagian karena ukuran setiap bagian mungkin berbeda. Rumus yang benar adalah total_sum / total_count. Pola ini berlaku untuk kuantitas apa pun yang dapat diuraikan: varians, korelasi, dan histogram semuanya memiliki rumus bertahap.

import pandas as pd

total_sum = 0.0
total_count = 0

for chunk in pd.read_csv('transactions.csv', chunksize=100000):
    total_sum += chunk['amount'].sum()
    total_count += chunk['amount'].notna().sum()

grand_mean = total_sum / total_count
print(f'Rows processed: {total_count:,}')
print(f'Grand mean: {grand_mean:.4f}')

Min dan Maks Bertahap

Melacak nilai minimum dan maksimum global di seluruh bagian cukup sederhana: inisialisasikan dengan float('inf') dan float('-inf') milik Python, lalu perbarui menggunakan min/maks dari setiap bagian. Cara ini menghindari penyimpanan sementara apa pun. Pola ini dapat diperluas ke min/maks per grup dengan mempertahankan kamus yang kuncinya adalah pengenal grup.

import pandas as pd

global_min = float('inf')
global_max = float('-inf')

for chunk in pd.read_csv('prices.csv', chunksize=50000):
    chunk_min = chunk['price'].min()
    chunk_max = chunk['price'].max()
    if chunk_min < global_min:
        global_min = chunk_min
    if chunk_max > global_max:
        global_max = chunk_max

print(f'Price range: {global_min} to {global_max}')

Menghitung Frekuensi Secara Bertahap

Untuk kolom kategorikal, pertahankan kamus frekuensi berjalan dengan menambahkan hasil value_counts() dari setiap bagian ke akumulator Series Pandas. Karena penjumlahan Series Pandas menyelaraskan label indeks, kategori yang belum dikenal pada bagian berikutnya akan otomatis disertakan. Setelah semua bagian selesai, urutkan berdasarkan jumlah untuk melihat kategori teratas di seluruh dataset.

import pandas as pd

freq = pd.Series(dtype='int64')

for chunk in pd.read_csv('orders.csv',
                         chunksize=100000,
                         usecols=['category']):
    chunk_counts = chunk['category'].value_counts()
    freq = freq.add(chunk_counts, fill_value=0)

# Final sorted frequency table
print(freq.sort_values(ascending=False).head(10))

Agregasi GroupBy Bertahap

Untuk menghitung jumlah atau banyaknya data dengan groupby di seluruh bagian, terapkan groupby().agg() dalam setiap bagian dan simpan Series atau DataFrame yang dihasilkan. Setelah perulangan selesai, gabungkan semua hasil parsial dan terapkan groupby kedua untuk menggabungkannya. Pendekatan dua tahap ini menangani grup yang muncul di beberapa bagian dengan benar, yang umum terjadi saat data diurutkan berdasarkan tanggal, bukan berdasarkan grup.

import pandas as pd

partials = []
for chunk in pd.read_csv('sales.csv',
                         chunksize=100000,
                         usecols=['region', 'product', 'revenue']):
    p = chunk.groupby(['region', 'product'])['revenue'].sum()
    partials.append(p)

final = (
    pd.concat(partials)
    .groupby(level=['region', 'product'])
    .sum()
    .sort_values(ascending=False)
)
print(final.head(10))

Menghitung Varians Secara Bertahap (Metode Welford)

Menghitung varians di seluruh bagian lebih rumit daripada menghitung mean. Rumus naif E[X²] - E[X]² mengalami pembatalan besar-besaran untuk mean yang besar. Algoritme daring Welford mempertahankan mean berjalan dan jumlah penyimpangan kuadrat, lalu memperbaruinya pada setiap nilai baru dengan cara yang stabil secara numerik. Meskipun SciPy mengimplementasikan metode ini, memahami polanya memungkinkan Anda memperluasnya ke varians berbobot dan kovarians.

import pandas as pd
import numpy as np

# Simple two-pass approach using stored chunk stats
chunk_stats = []
for chunk in pd.read_csv('data.csv',
                         chunksize=100000,
                         usecols=['value']):
    n = chunk['value'].count()
    mean = chunk['value'].mean()
    var = chunk['value'].var(ddof=1)
    chunk_stats.append((n, mean, var))

# Combine: use pooled variance formula
total_n = sum(s[0] for s in chunk_stats)
total_mean = sum(s[0]*s[1] for s in chunk_stats) / total_n
pooled_var = sum((s[0]-1)*s[2] + s[0]*(s[1]-total_mean)**2
                 for s in chunk_stats) / (total_n - 1)
print(f'Grand variance: {pooled_var:.4f}')

Membangun Histogram Bertahap

Menghitung distribusi sebuah kolom di seluruh file yang terlalu besar untuk RAM memerlukan histogram bertahap. Tetapkan batas bin terlebih dahulu berdasarkan sampel kecil atau pengetahuan domain, lalu gunakan np.histogram(chunk_values, bins=edges) dalam setiap bagian dan kumpulkan jumlahnya. Pada akhir proses, gambarkan jumlah gabungan tersebut sebagai diagram batang. Begitulah sistem streaming seperti Kafka Streams dan Flink menghitung histogram perkiraan.

import pandas as pd
import numpy as np

# Decide bin edges from a sample
sample = pd.read_csv('amounts.csv', nrows=5000)
bins = np.linspace(sample['amount'].min(),
                   sample['amount'].max(), 21)
counts = np.zeros(len(bins) - 1, dtype='int64')

for chunk in pd.read_csv('amounts.csv',
                         chunksize=100000,
                         usecols=['amount']):
    chunk_counts, _ = np.histogram(
        chunk['amount'].dropna(), bins=bins
    )
    counts += chunk_counts

print('Histogram counts:', counts[:5], '...')

Melacak Nilai Unik Secara Perkiraan

Menghitung nilai berbeda secara tepat di seluruh bagian memerlukan penyimpanan semua nilai unik — yang jumlahnya dapat mencapai jutaan. Untuk jumlah perkiraan dalam skala besar, gunakan sketsa HyperLogLog, yang tersedia di Python melalui pustaka hyperloglog. Sebagai alternatif, lacak nilai unik per bagian menggunakan set lalu ambil gabungannya, tetapi cara ini terus membutuhkan lebih banyak penyimpanan. Untuk perkiraan yang murah, gunakan pd.Series.nunique() per bagian dan laporkan rata-ratanya — hasilnya tidak tepat, tetapi sering kali cukup untuk pembuatan profil data.

import pandas as pd

unique_ids = set()
for chunk in pd.read_csv('events.csv',
                         chunksize=100000,
                         usecols=['user_id']):
    unique_ids.update(chunk['user_id'].dropna().unique())

print(f'Distinct user IDs: {len(unique_ids):,}')
# Warning: the set may grow large for high-cardinality columns

Melaporkan Kemajuan Selama Proses Panjang

Memproses file berukuran beberapa gigabita dapat memerlukan waktu beberapa menit. Tambahkan pelaporan kemajuan agar Anda mengetahui bahwa pipeline masih berjalan dan dapat memperkirakan waktu yang tersisa. Hitung byte atau baris yang telah diproses, lalu bandingkan dengan ukuran file. Pustaka tqdm membuatnya mudah melalui pembungkus tqdm(reader). Bahkan tanpa tqdm, mencetak satu baris status setiap 10 bagian memberikan informasi berharga selama pekerjaan batch yang panjang.

import pandas as pd
import time

chunksize = 100000
start = time.time()
rows_processed = 0

for i, chunk in enumerate(pd.read_csv('big.csv',
                                       chunksize=chunksize)):
    rows_processed += len(chunk)
    # Report every 10 chunks
    if (i + 1) % 10 == 0:
        elapsed = time.time() - start
        rate = rows_processed / elapsed
        print(f'Chunk {i+1}: {rows_processed:,} rows '
              f'@ {rate/1000:.0f}k rows/sec')

print(f'Total: {rows_processed:,} rows in {time.time()-start:.1f}s')

Menyaring Sebelum Melakukan Agregasi

Terapkan penyaringan dalam setiap bagian sebelum melakukan agregasi agar data yang tidak diinginkan tidak ikut terkumpul. Misalnya, jika Anda hanya memperhatikan pesanan tahun 2024, saring kolom tanggal pada bagian tersebut sebelum melakukan groupby. Cara ini mengurangi memori yang diperlukan untuk hasil parsial dan mempercepat langkah penggabungan akhir. Selalu terapkan penyaringan sedini mungkin dalam pipeline — ini merupakan prinsip dasar pemrosesan data yang efisien.

import pandas as pd

partials = []
for chunk in pd.read_csv('orders.csv',
                         chunksize=100000,
                         parse_dates=['order_date']):
    # Filter early: only 2024 orders
    mask = chunk['order_date'].dt.year == 2024
    filtered = chunk.loc[mask, ['category', 'revenue']]

    if len(filtered) > 0:
        p = filtered.groupby('category')['revenue'].sum()
        partials.append(p)

if partials:
    result = pd.concat(partials).groupby(level=0).sum()
    print(result)

Menyimpan Hasil Sementara

Untuk pekerjaan yang berjalan sangat lama, simpan hasil sementara secara berkala agar Anda dapat melanjutkan dari titik pemeriksaan jika proses terhenti. Tulis agregat per potongan ke file Parquet atau CSV setiap N potongan. Jika pekerjaan gagal pada potongan ke-800 dari 1.000, Anda dapat memuat kembali agregat yang tersimpan dan melanjutkan dari posisi terakhir, alih-alih memproses ulang seluruh file. Pola ketahanan ini sangat penting dalam alur data produksi.

import pandas as pd
import os

CHECKPOINT = 'checkpoint.csv'
running_total = 0.0
running_count = 0

# Resume from checkpoint if it exists
if os.path.exists(CHECKPOINT):
    ckpt = pd.read_csv(CHECKPOINT)
    running_total = ckpt['total'].iloc[0]
    running_count = int(ckpt['count'].iloc[0])
    print(f'Resuming from checkpoint: {running_count:,} rows')

for chunk in pd.read_csv('huge.csv', chunksize=100000):
    running_total += chunk['value'].sum()
    running_count += len(chunk)

# Save checkpoint
pd.DataFrame({'total': [running_total],
              'count': [running_count]}).to_csv(CHECKPOINT, index=False)
print(f'Final mean: {running_total / running_count:.4f}')

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep Analisis Data dari pelajaran ini.

Rangkuman Pelajaran

Dalam pelajaran ini, Anda telah mempelajari bahwa akumulator berjalan (sum, count, min/max, Series frekuensi) memungkinkan agregasi dengan penggunaan memori konstan pada file berukuran besar, groupby dua tahap (groupby sebagian per potongan, lalu concat dan pengelompokan ulang) menangani kelompok lintas potongan dengan benar, dan pemfilteran lebih awal dalam setiap potongan mengurangi biaya tahap akumulasi. Selanjutnya, kita akan membahas Dask DataFrames sebagai pengganti paralel untuk Pandas pada dataset berukuran besar.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Agregasi Bertahap di Seluruh Potongan” gratis?

Ya — teks lengkap “Agregasi Bertahap di Seluruh Potongan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Pandas & NumPy Academy, upgrade ke CoddyKit PRO. Kursus Pandas & NumPy Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Agregasi Bertahap di Seluruh Potongan”?

Akumulasikan jumlah, total, dan nilai min/maks berjalan di seluruh potongan tanpa menyimpan seluruh file dalam memori. Kamu berlatih Pandas & NumPy Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Pandas & NumPy Academy?

Tidak diperlukan pengalaman sebelumnya. Pandas & NumPy Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Agregasi Bertahap di Seluruh Potongan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Pandas & NumPy Academy ini?

Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Pandas & NumPy Academy