Numpy Tingkat Lanjut

Ada beberapa perintah untuk menaikkan skill pemrograman Python Numpy (dan Scipy) ke level lanjut. Jika Anda (termasuk saya) paham dan bisa menginterpretasikan output perintah tersebut, maka kita sudah siap naik ke level Numpy selanjutnya. Beberapa perintah tersebut adalah sebagai berikut.

1. Blok Memory (np.nbytes)

Sering kali kita hanya fokus pada bentuk (shape) array, namun melupakan "berat"nya. Perintah `np.nbytes` menginformasikan berapa banyak memori RAM yang sebenarnya kita pakai.  Seseorang yang paham bahwa mengubah tipe data (dtype) dari float64 ke float32 bisa memangkas konsumsi memori hingga 50%, yang berarti mempercepat proses komputasi secara drastis. Di sini, kita belajar bahwa array bukan sekadar wadah angka, tetapi blok memori yang harus dikelola secara efisien.

Contoh: 

import numpy as np

a = np.zeros((1000, 1000), dtype=np.float64)
print(a.nbytes)
# Karena float64 = 8 byte, maka total memori:
# 1000 x 1000 x 8 byte = 8.000.000 byte (~8 MB)

Konsep penting:

• Ukuran memori = jumlah elemen × ukuran tipe data.
• Mengganti float64 ke float32 langsung mengurangi memori setengahnya.
• Pada skala besar (misalnya deep learning atau audio processing), ini sangat krusial.

Jika kita tidak sadar ukuran memori, kita akan mudah “membunuh” RAM sendiri.

2. Stride

Jika nbytes adalah beratnya, maka stride adalah cara kita melangkah di atas memori tersebut. Stride menentukan berapa byte yang harus "diloncati" komputer untuk menuju ke elemen berikutnya di setiap dimensi. Stride adalah jarak (dalam byte) yang harus dilompati untuk berpindah ke elemen berikutnya pada setiap dimensi. Konsep inilah yang menjawab misteri mengapa operasi transpose pada array besar bisa sangat cepat. Karena Numpy tidak benar-benar memindahkan data di memori; ia hanya mengubah pola langkah (stride) tersebut. Memahami stride berarti memahami bagaimana komputer "melihat" data array secara linear di dalam RAM.

Contoh:

a = np.arange(12).reshape(3, 4)  
print(a.strides)  
# Jika dtype=int64 (8 byte), kemungkinan output:
(32, 8)

Artinya:

• Untuk pindah ke baris berikutnya → lompat 32 byte (4 kolom × 8 byte).
• Untuk pindah ke kolom berikutnya → lompat 8 byte.

Ini penting karena:

• Operasi transpose (a.T) sering tidak membuat copy data, hanya mengubah stride.
• Pemahaman stride membantu kita tahu kapan NumPy membuat copy atau hanya view. 
• Dalam optimasi performa, akses memori yang kontigu jauh lebih cepat. 

Stride adalah jembatan antara konsep matematis array dan realitas fisik memori.

3. Broadcasting

Broadcasting adalah seni "mengada-ada" secara efisien. Broadcasting memungkinkan operasi antara array dengan ukuran yang berbeda tanpa perlu menyalin data secara fisik untuk menyamakan ukurannya. Misalnya, menjumlahkan array (3,3) dengan vektor (3,) secara otomatis. Seorang programmer biasa mungkin akan melakukan looping atau padding manual, tetapi level "Dewa" membiarkan Numpy melakukan broadcasting internal yang jauh lebih cepat karena terjadi di level C. Kita hemat memori, kita hemat waktu.

Contoh:

a = np.array([[1], [2], [3]])
b = np.array([10, 20, 30])

c = a + b

Secara mental:

• a bentuk (3,1)
• b bentuk (3,)
• NumPy “membentangkan” dimensi agar cocok → hasil (3,3)

Tanpa broadcasting, kita harus membuat array besar secara manual. Dengan broadcasting:

• Kode lebih ringkas
• Lebih hemat memori
• Lebih cepat

Kunci memahami broadcasting:

• Dimensi dibandingkan dari kanan ke kiri
• Ukuran cocok jika sama atau salah satunya 1

Kalau ini sudah bisa kita prediksi tanpa menjalankan kode, berarti otak kita sudah mulai “NumPy-native”.

4. Fancy Indexing

Fancy indexing adalah indexing menggunakan array atau list indeks. Berbeda dengan slicing biasa yang menghasilkan view (tampilan tanpa menyalin data), Fancy Indexing selalu menghasilkan copy (data baru). Memahami perbedaan ini krusial agar kita tidak membludakkan memori secara tidak sengaja saat memproses data besar.

Contoh:

a = np.array([10, 20, 30, 40])
idx = [0, 2]
print(a[idx])
[10 30]

Perbedaan penting:

• Slice (a[1:3]) → biasanya view (tidak copy)
• Fancy indexing → selalu membuat copy

Ini sangat penting untuk:

• Mengontrol penggunaan memori
• Menghindari bug akibat modifikasi data yang tidak disengaja

Misalnya:

b = a[idx]
b[0] = 999

Di sini, a tidak akan berubah karena b adalah copy.
Kalau kita tidak memahami ini, kita bisa salah kaprah saat debugging.

5. Vectorization

Vectorization adalah teknik menghilangkan loop eksplisit (perulangan for di Python) dan menggantinya dengan operasi array tunggal. Loop Python lambat karena interpretasi per-baris, namun operasi vektor Numpy terjadi di level kompilasi C/Fortran yang sangat cepat. Ketika kita memahami Broadcasting, Stride, dan Memory, Vectorization menjadi senjata utama untuk membuat kode berjalan 10x hingga 100x lebih kencang.

Berikut contoh penggunaan vektorisasi untuk menggantikan perulangan for.
Perulangan for:

result = []
for x in a:
    result.append(x * 2)

Vektorisasi:

result = a * 2

Kenapa jauh lebih cepat? Loop Python berjalan di level interpreter (lambat). Operasi NumPy berjalan di C (cepat). Akses memori lebih efisien. Vectorization bukan sekadar “gaya”, tapi filosofi berpikir: Berpikir dalam bentuk operasi matriks, bukan iterasi elemen.

 

Perlu diingat, bagian terpenting adalah memahami konsep array dengan perintah di atas pada tataran level otak kita, bukan simulasi komputer. Artinya, kita bisa menebak output dari komputer (simulasi/Python Numpy) dengan otak kita dan memahaminya. Bukan asal mensimulasikan array, meskipun bisa menebak hasilnya. Inilah yang terpenting: ilmu sebelum beramal.

Referensi: 

[1] https://shihchinw.github.io/2019/03/performance-tips-of-numpy-ndarray.html 

[2] https://pythonspeed.com/articles/numpy-memory-footprint/