Batch Processing

Pekerjaan satu jam masih manusiawi; pekerjaan delapan jam menuntut rencana bertahan hidup. Listrik bisa padam di menit ke-230, memori bisa habis bila seluruh data dipeluk sekaligus, dan satu batch rusak tidak boleh meruntuhkan sembilan lainnya. Batch processing menjawab ketiganya: data dipartisi menjadi potongan (chunk) yang diproses satu per satu, state pekerjaan disimpan berkala (checkpoint) agar bisa dilanjutkan, dan tiap batch yang gagal dicatat lalu dilewati. Chapter ini membangun pola tersebut dengan 1000 baris data terpartisi menjadi 10 batch. Cakupan kita:

• partisi ceil(n/chunkSize) batch dengan indeks blok
• loop batch dengan hasil per batch dan laporan progres persen
• checkpoint save/load + demonstrasi resume
• memori per batch (clear chunk) dan penanganan batch gagal

Partisi Data Menjadi Batch #

Aturannya: data besar tidak diproses sekaligus, melainkan diiris per potongan berukuran tetap. Mekanisme di balik layar: nBatch = ceil(nData/chunkSize) menghitung jumlah potongan — pembulatan ke atas memastikan baris sisa (misalnya 1000 baris dengan chunk 300 → 4 batch, batch terakhir hanya 100 baris) ikut terproses. Rentang baris batch ke-b dihitung dari aritmetika indeks murni:

nData = 1000;
chunkSize = 100;
nBatch = ceil(nData / chunkSize);           % 10 batch
dataPendapatan = 100 + 3*(1:nData)';        % deterministik: 103 .. 3097
dataPendapatan(650) = NaN;                  % satu nilai hilang -> batch 7 gagal
fprintf('data %d baris, chunk %d baris -> %d batch\n', nData, chunkSize, nBatch);

state = struct('total', zeros(nBatch,1), ...
    'n', zeros(nBatch,1), 'gagal', false(nBatch,1));

Output yang Dihasilkan:

data 1000 baris, chunk 100 baris -> 10 batch

State pekerjaan disimpan dalam satu struct: total (jumlah nilai per batch), n (jumlah baris per batch), dan gagal (mask logis batch yang bermasalah). Satu struct untuk seluruh state membuat checkpoint tinggal menyimpan satu nama variabel.

Loop Batch dengan Hasil per Batch #

Fungsi prosesBatch (berkas prosesBatch.m) memproses satu rentang batch dan mengembalikan state yang diperbarui. Rentang — bukan seluruh loop — menjadi parameter karena inilah kunci resume: sesi berikutnya tinggal meminta rentang lanjutan:

function state = prosesBatch(data, chunkSize, state, bAwal, bAkhir)
nBatch = numel(state.total);
for b = bAwal:bAkhir
    idx   = (b-1)*chunkSize + 1 : min(b*chunkSize, numel(data));
    chunk = data(idx);
    if any(isnan(chunk))
        state.gagal(b) = true;
        fprintf('batch %2d GAGAL (data tidak lengkap) - dilewati\n', b);
    else
        state.total(b) = sum(chunk);
        state.n(b)     = numel(chunk);
    end
    clear chunk
    fprintf('progres: %3d%% (%d/%d batch selesai)\n', ...
        round(100*b/nBatch), b, nBatch);
end
end

Mari kita bedah baris-baris kode di atas:

1. Baris 4 (idx = ... min(b*chunkSize, numel(data))): batas atas min menangani chunk terakhir yang bisa lebih pendek — batch ke-4 dari 1000/300 hanya berisi 100 baris, bukan 300.
2. Baris 7 (any(isnan(chunk))): satu nilai NaN saja menandai batch tidak sehat; kebijakan kita melewatkannya dan mencatat di state.gagal (log + lanjut, bukan berhenti).
3. Baris 12 (clear chunk): chunk dihapus di akhir iterasi — pada data besar, memori yang dipakai per iterasi hanya seukuran satu potongan, bukan seluruh data.
4. Baris 13-14 (fprintf progres): laporan persen round(100*b/nBatch) memberi kita gambaran laju pekerjaan pada pekerjaan berjam-jam; format %3d%% merata-kanan tiga digit plus tanda persen literal.

Checkpoint dan Resume #

Aturan checkpoint: simpan state cukup sering agar pekerjaan yang hilang terbatas, cukup jarang agar penulisan disk tidak memperlambat. Mekanisme di balik layar: save membekukan seluruh variabel yang diperlukan — data, state, ukuran chunk, dan nomor batch terakhir — ke berkas .mat; proses berikutnya memuatnya dengan load dan melanjutkan dari batchSelesai+1. Sesi pertama kita sengaja berhenti di batch 3:

K = 3;
fprintf('\n== sesi 1: batch 1 sampai %d ==\n', K);
state = prosesBatch(dataPendapatan, chunkSize, state, 1, K);
batchSelesai = K;
save('checkpoint.mat', 'dataPendapatan', 'state', 'batchSelesai', 'chunkSize');
fprintf('CHECKPOINT: state setelah batch %d disimpan ke checkpoint.mat\n', ...
    batchSelesai);

Sesi kedua mensimulasikan proses yang mati — variabel dihapus dari workspace — lalu bangkit dari checkpoint:

clear dataPendapatan state chunkSize batchSelesai
fprintf('\n== sesi 2: resume dari checkpoint ==\n');
S = load('checkpoint.mat');
state = prosesBatch(S.dataPendapatan, S.chunkSize, S.state, ...
    S.batchSelesai+1, nBatch);
fprintf('RESUME: seluruh %d batch selesai\n', nBatch);

Output yang Dihasilkan (keseluruhan contoh.m: dua sesi + verifikasi + ringkasan):

data 1000 baris, chunk 100 baris -> 10 batch

== sesi 1: batch 1 sampai 3 ==
progres:  10% (1/10 batch selesai)
progres:  20% (2/10 batch selesai)
progres:  30% (3/10 batch selesai)
CHECKPOINT: state setelah batch 3 disimpan ke checkpoint.mat

== sesi 2: resume dari checkpoint ==
progres:  40% (4/10 batch selesai)
progres:  50% (5/10 batch selesai)
progres:  60% (6/10 batch selesai)
batch  7 GAGAL (data tidak lengkap) - dilewati
progres:  70% (7/10 batch selesai)
progres:  80% (8/10 batch selesai)
progres:  90% (9/10 batch selesai)
progres: 100% (10/10 batch selesai)
RESUME: seluruh 10 batch selesai
VERIFIKASI: resume identik dengan run penuh (isequal = YA)
batch sukses: 9/10 (batch gagal dilewati)
total nilai terproses: 1396350

BERSIH: checkpoint.mat dihapus, contoh selesai

Verifikasi di akhir contoh.m menghitung ulang seluruh total per batch tanpa jeda, lalu membandingkan dengan assert(isequal(state.total, refTotal)) — hasil resume terbukti identik dengan run penuh, termasuk perlakuan batch 7 yang sama-sama dilewati. Total nilai terproses 1396350 adalah jumlah seluruh data dikurangi jumlah batch 7 yang dibuang.

Ringkasan #

Rantai batch processing kita: ceil(nData/chunkSize) mempartisi 1000 baris menjadi 10 batch, fungsi prosesBatch memproses rentang batch dengan memori per potongan (clear chunk), progres tercetak dalam persen, batch 7 yang mengandung NaN gagal dengan tercatat dan dilewati, serta checkpoint .mat setiap 3 batch memungkinkan resume. assert(isequal(...)) membuktikan hasil dua sesi berpisah identik dengan run penuh — properti yang membuat pekerjaan delapan jam jadi aman dijalankan semalam tanpa pengawasan.