Bekerja dengan Dataset Besar

Log sensor setiap detik, hasil export database, citra satelit — dataset nyata dengan mudah melewati ukuran RAM laptop. Memuat semuanya ke workspace lalu berharap analysis-nya selesai bukan strategi; MATLAB menyediakan tangga strategi dari yang termurah (merapatkan tipe) sampai yang paling skalabel (tall array). Chapter ini menutup section Import dan Export Data dengan strategi tersebut:

• Audit pemakaian memori dengan whos dan merapatkan tipe ke single/int32
• Membaca berkas besar sepotong-sepotong (chunked reading) dengan fread dan textscan
• tall array, datastore, matfile, dan memmapfile di MATLAB
• Peta strategi memilih pendekatan

Audit Memori dengan whos #

Aturannya: sebelum mengoptimalkan apa pun, ukur dulu — variabel mana yang rakus memori. Mekanismenya: whos('namaVariabel') mengembalikan struct berisi .class, .size, dan .bytes; versi tanpa argumen (perintah whos) menampilkan seluruh workspace. Kita uji dengan satu juta elemen yang sama disimpan dalam tiga tipe:

n  = 1000;
Ad = ones(n, 'double');     % 8 byte per elemen
As = single(Ad);            % 4 byte per elemen
Ai = int32(Ad);             % 4 byte per elemen

s = whos('Ad');
fprintf('Ad: tipe %s, %d byte\n', s.class, s.bytes);
s = whos('As');
fprintf('As: tipe %s, %d byte\n', s.class, s.bytes);
s = whos('Ai');
fprintf('Ai: tipe %s, %d byte\n', s.class, s.bytes);
fprintf('hemat memori single vs double: %d%%\n', ...
        round((1 - whos('As').bytes / whos('Ad').bytes) * 100));

Output yang Dihasilkan:

Ad: tipe double, 8000000 byte
As: tipe single, 4000000 byte
Ai: tipe int32, 4000000 byte
hemat memori single vs double: 50%

Mari kita bedah baris-baris kode di atas:

1. Baris 2-4 (ones/single/int32): data yang identik menempati 8 MB, 4 MB, dan 4 MB — tipe, bukan jumlah elemen, yang menentukan tagihan memori.
2. Baris 6-12 (whos + fprintf): audit per variabel memberi angka pasti; single menanggung ~7 digit presisi — cukup untuk data sensor, setengah harga memorinya.
3. Implikasi: konversi ke single/int32 sebaiknya dilakukan di titik baca (presisi fread 'single'), bukan setelah double raksasa sudah terlanjur dibuat.

Membaca Bertahap: Chunked Reading #

Masalah nyatanya: berkas 5 GB tidak perlu berada di memori sekaligus bila kita hanya mengagregasi (jumlah, rata-rata, filter). Mekanismenya: baca N elemen per iterasi, olah, buang, ulangi — memori yang terpakai hanya sebesar satu potongan. Untuk berkas biner, fread(fid, jumlah, presisi) membaca persis jumlah elemen lalu berhenti:

nTotal = 100;
fid = fopen('besar.bin', 'wb');
fwrite(fid, single((1:nTotal) .* 0.5), 'single');
fclose(fid);
fprintf('besar.bin: %d byte\n', dir('besar.bin').bytes);

fid = fopen('besar.bin', 'rb');
total = 0; nBaca = 0; potongan = 0;
while ~feof(fid)
  chunk = fread(fid, 30, 'single');
  if isempty(chunk), break; end
  total = total + sum(chunk);
  nBaca = nBaca + numel(chunk);
  potongan = potongan + 1;
  fprintf('potongan %d: %d elemen\n', potongan, numel(chunk));
end
fclose(fid);
fprintf('total %d elemen, jumlah %.1f\n', nBaca, total);

Output yang Dihasilkan:

besar.bin: 400 byte
potongan 1: 30 elemen
potongan 2: 30 elemen
potongan 3: 30 elemen
potongan 4: 10 elemen
total 100 elemen, jumlah 2525.0

Mari kita bedah baris-baris kode di atas:

1. Baris 11 (while ~feof(fid)): loop berjalan sampai penanda akhir-berkas menyala; iterasi kelima menemukan chunk kosong dan keluar lewat isempty.
2. Baris 12 (fread(fid, 30, 'single')): hanya 30 elemen (120 byte) yang hidup di memori per iterasi — dengan berkas 5 GB asli, pola yang sama berjalan dengan memori tetap kecil.
3. Baris 13-15 (sum, numel): agregasi berjalan per potongan; total di akhir identik dengan menjumlahkan seluruh berkas sekaligus (0.5 × 1..100 = 2525).

Berkas teks memakai teknik serupa dengan textscan: setiap panggilan melanjutkan dari posisi baca terakhir, dan argumen jumlahnya membatasi baris yang dibaca:

fid = fopen('angka.txt', 'w');
fprintf(fid, '%d\n', 1:50);
fclose(fid);
fid = fopen('angka.txt', 'r');
totalTeks = 0; nAngka = 0; pass = 0;
while ~feof(fid)
  C = textscan(fid, '%d', 25);
  if isempty(C{1}), break; end
  totalTeks = totalTeks + sum(C{1});
  nAngka = nAngka + numel(C{1});
  pass = pass + 1;
  fprintf('pass %d: %d angka\n', pass, numel(C{1}));
end
fclose(fid);
fprintf('teks total %d angka, jumlah %d\n', nAngka, totalTeks);

Output yang Dihasilkan:

pass 1: 25 angka
pass 2: 25 angka
teks total 50 angka, jumlah 1275

Dua panggilan textscan masing-masing menyerap 25 angka tanpa perlu fseek — posisi baca file identifier bergerak maju dengan sendirinya.

Tall Array dan datastore (MATLAB) #

Chunked reading manual bekerja untuk agregasi sederhana; MATLAB menyediakan otomatisasinya bernama tall array (R2016b+). Mekanismenya: tall membungkus datastore — penunjuk kumpulan berkas — menjadi array yang “belum dibaca”; operasi seperti mean hanya dicatat (deferred), dan gather mengeksekusi seluruh rangkaian dalam potongan-potongan internal:

% MATLAB-only di Octave: tall array di atas datastore (R2016b+)
ds = tabularTextDatastore('sensor_*.csv', 'TreatAsMissing', 'NA');
T = tall(ds);                        % tall table — data tidak dimuat
rata2 = mean(T.nilai, 'omitnan');    % perhitungan ditunda (deferred)
hasil = gather(rata2);               % eksekusi sekarang, hasil masuk memori

Baris pertama membangun datastore atas banyak berkas sekaligus (sensor_*.csv); baris kedua tidak memuat satu byte data pun — tampilan tall table di Command Window bahkan menulis ukuran M×N dengan M belum diketahui (?); gather di baris terakhir yang memicu pembacaan bertahap dan mengembalikan hasil akhirnya ke memori. Keunggulan utamanya: kode yang sama bisa berjalan di Parallel Computing Toolbox atau cluster tanpa perubahan.

tabularTextDatastore sendiri adalah mesin berdiri-sendiri: read(ds) mengambil satu potongan, readall(ds) seluruhnya, plus properti SelectedVariableNames untuk memilih kolom — paduan ideal dengan import options dari chapter sebelumnya.

matfile dan memmapfile (MATLAB) #

Dua alat lain mengurus kasus khusus. Mekanismenya matfile: objek yang mengakses variabel di dalam berkas .mat tanpa memuatnya — indeks seperti m.suhu(1:1000) membaca hanya elemen yang disebut (versi 7.3):

% MATLAB-only di Octave: akses parsial variabel .mat (versi 7.3)
m = matfile('sensor.mat');           % objek — isi tidak dimuat
bagian = m.suhu(1:1000);             % baca hanya sebagian variabel
m.suhu(1001:2000) = nilaiBaru;       % tulis sebagian tanpa load penuh

Sedangkan memmapfile memetakan berkas biner langsung ke alamat memori sistem operasi — pembacaan akses acak menjadi hampir secepat akses array:

% MATLAB-only di Octave: memory-mapped file (pola dari dokumentasi resmi)
m = memmapfile('records.dat');       % default: uint8, seluruh berkas
dua  = double(m.Data(2));            % akses byte seperti elemen array

Properti m.Data berperilaku seperti array MATLAB yang tinggal di disk; setiap indeks yang kita baca diterjemahkan menjadi akses memori oleh sistem operasi, tanpa salinan eksplisit.

Peta Strategi #

Urutannya dari bawah ke atas: mulai dari merapatkan tipe (gratis), lalu chunked reading (sedikit kode), dan naik ke tall array baru ketika kompleksitas analisisnya benar-benar membutuhkannya. contoh.m pada bagian bawah halaman mendemonstrasikan dua anak tangga pertama secara utuh — audit whos, konversi tipe, dan pembacaan bertahap biner maupun teks — dengan berkas demo yang dibersihkan di akhir.

Ringkasan #

whos mengaudit siapa yang memakan memori; single/int32 memotong tagihan hingga separuhnya; chunked reading dengan fread(fid, N) dan textscan(fid, format, N) memproses berkas raksasa dengan memori sebesar satu potongan; tall array + datastore (R2016b+) mengotomatiskan pola itu dan menskalakannya ke cluster; matfile mengakses sebagian variabel .mat; memmapfile memetakan berkas biner ke memori. Seluruh section Import dan Export Data kini lengkap — dari teks, CSV, Excel, JSON, XML, biner, manajemen berkas, sampai data yang lebih besar dari RAM.