Operasi pada Array dengan NumPy

Broadcasting adalah sistem aturan NumPy untuk menggabungkan array yang shape-nya berbeda tetapi kompatibel. Dimensi berukuran satu diperluas secara konseptual tanpa menyalin nilainya ke array yang lebih besar. Panduan broadcasting NumPy memuat contoh tambahan.

Vektorisasi memungkinkan satu ekspresi bekerja pada seluruh array. NumPy menjalankan loop di baliknya dalam kode terkompilasi yang telah dioptimalkan, sehingga sering lebih cepat daripada loop Python eksplisit.

vectorization_example.py

import numpy as np

# Membuat dua array
a = np.array([0, 1, 2])
b = np.array([2, 2, 2])

# Operasi vektorisasi (elemen per elemen)
hasil = a + b
print(hasil)
# Output: [2 3 4]

Pada contoh di atas, NumPy menjumlahkan elemen-elemen pada posisi yang bersesuaian. Kita cukup menyatakan operasinya sekali tanpa mengindeks setiap elemen dalam loop Python.

Aturan $1$ : Jika rank berbeda, perlakukan shape dengan rank lebih rendah seolah-olah memiliki tambahan dimensi berukuran $1$ di sebelah kiri
Aturan $2$ : Dua dimensi yang sejajar kompatibel jika ukurannya sama atau salah satunya berukuran $1$ ; dimensi berukuran satu diperluas secara virtual ke ukuran pasangannya
Aturan $3$ : Jika ada pasangan dimensi yang tidak kompatibel, NumPy menghasilkan ValueError

broadcasting_1d_scalar.py

import numpy as np

# Array 1D dengan skalar
a = np.arange(3)  # [0, 1, 2]
b = 5

hasil = a + b
print(f"Array a: {a}")
print(f"Skalar b: {b}")
print(f"Hasil a + b: {hasil}")

# Penjelasan bentuk:
# a memiliki bentuk (3,)
# b memiliki bentuk () - skalar
# Setelah broadcasting: b menjadi [5, 5, 5]
# Output: [5 6 7]

Ketika kamu bekerja dengan array yang memiliki dimensi berbeda, NumPy akan mencoba menyesuaikan bentuknya secara otomatis. Proses ini sangat berguna saat kamu ingin menerapkan operasi yang sama pada setiap baris atau kolom dari matriks.

broadcasting_2d_1d.py

import numpy as np

# Array 2D dengan array 1D
a = np.ones((3, 3))  # Matriks 3x3 berisi angka 1
b = np.arange(3)     # [0, 1, 2]

hasil = a + b
print("Array a (3x3):")
print(a)
print(f"Array b (1D): {b}")
print("Hasil a + b:")
print(hasil)

# Broadcasting terjadi:
# a: bentuk (3, 3)
# b: bentuk (3,) -> diperluas menjadi (1, 3) -> (3, 3)
# b ditambahkan ke setiap baris dari a

broadcasting_error.py

import numpy as np

try:
  # Array dengan bentuk yang tidak kompatibel
  a = np.arange(6).reshape(2, 3)  # bentuk (2, 3)
  b = np.arange(2)                # bentuk (2,)

  print(f"Array a bentuk: {a.shape}")
  print(f"Array b bentuk: {b.shape}")

  # Ini akan menghasilkan error
  hasil = a + b
except ValueError as e:
  print(f"Error: {e}")
  print("Bentuk array tidak kompatibel untuk broadcasting")

arithmetic_scalar.py

import numpy as np

a = np.array([0, 1, 2, 3, 4])

# Penjumlahan dengan skalar
print("Penjumlahan:")
print(f"a + 1 = {a + 1}")
# Output: [1 2 3 4 5]

# Perkalian dengan skalar
print("Perkalian:")
a *= 2
print(f"a *= 2: {a}")
# Output: [0 2 4 6 8]

# Pangkat
print("Pangkat:")
print(f"2**a = {2**a}")
# Output: [  1   4  16  64 256]

arithmetic_arrays.py

import numpy as np

a = np.array([0, 1, 2, 3, 4])
b = np.array([4, 3, 2, 1, 0])

# Pengurangan elemen per elemen
print("Pengurangan:")
print(f"a - b = {a - b}")
# Output: [-4 -2  0  2  4]

# Perkalian elemen per elemen
print("Perkalian elemen per elemen:")
print(f"a * b = {a * b}")
# Output: [0 3 4 3 0]

# Perkalian matriks (dot product)
print("Perkalian matriks:")
print(f"a @ b = {a @ b}")
# Output: 10 (hasil dot product)

Penting untuk memahami perbedaan antara perkalian elemen per elemen (*) dan perkalian matriks (@ atau np.dot()). Perkalian elemen per elemen mengalikan elemen pada posisi yang sama, sedangkan perkalian matriks mengikuti aturan aljabar linear.

comparison_logical.py

import numpy as np

a = np.array([0, 1, 2, 3, 4])
b = np.array([0, 0, 2, 4, 4])

# Operasi perbandingan
print("Perbandingan lebih besar:")
print(f"a > 2: {a > 2}")
# Output: [False False False  True  True]

print("Perbandingan sama dengan:")
print(f"a == b: {a == b}")
# Output: [ True False  True False  True]

# Operasi logika
print("Operasi logika OR:")
print(f"(a > 2) | (a == b): {(a > 2) | (a == b)}")
# Output: [ True False  True  True  True]

Untuk logika boolean elemen per elemen, gunakan ~ untuk NOT, & untuk AND, dan | untuk OR, atau fungsi np.logical_* yang sesuai. Beri tanda kurung pada setiap perbandingan karena prioritas operatornya berbeda. Operator skalar Python not, and, dan or tidak menjalankan logika array secara elemen per elemen.

Fungsi reduksi menggabungkan banyak elemen menjadi lebih sedikit nilai. Tanpa axis, seluruh array dapat direduksi menjadi satu nilai. Dengan axis, hanya dimensi tersebut yang direduksi. Pada tabel nilai ujian, hasilnya dapat berupa rata-rata per mata pelajaran atau per siswa.

basic_statistics.py

import numpy as np

# Membuat array 2D untuk contoh
data = np.array([[3, 0, -1, 1],
               [2, -1, -2, 4],
               [1, 7, 0, 4]])

print("Data array:")
print(data)

# Statistik pada seluruh array
print(f"Jumlah total: {np.sum(data)}")
print(f"Rata-rata: {np.mean(data):.2f}")
print(f"Nilai minimum: {np.min(data)}")
print(f"Nilai maksimum: {np.max(data)}")
print(f"Standar deviasi: {np.std(data):.2f}")
# Output:
# Jumlah total: 18
# Rata-rata: 1.50
# Nilai minimum: -2
# Nilai maksimum: 7
# Standar deviasi: 2.50

Pada array dua dimensi, axis=0 mereduksi dimensi baris dan menghasilkan satu nilai per kolom. axis=1 mereduksi dimensi kolom dan menghasilkan satu nilai per baris.

Pemahaman tentang sumbu ini membantu kamu mengontrol bagaimana fungsi statistik bekerja pada data multidimensi. Misalnya, jika kamu punya data penjualan per bulan untuk berbagai produk, kamu bisa menghitung total penjualan per produk atau per bulan.

axis_operations.py

import numpy as np

data = np.array([[3, 0, -1, 1],
               [2, -1, -2, 4],
               [1, 7, 0, 4]])

# Operasi sepanjang axis=0 (untuk setiap kolom)
print("Maksimum setiap kolom (axis=0):")
print(f"max(axis=0): {np.max(data, axis=0)}")
# Output: [3 7 0 4]

print("Indeks maksimum setiap kolom:")
print(f"argmax(axis=0): {np.argmax(data, axis=0)}")
# Output: [0 2 2 1]

# Operasi sepanjang axis=1 (untuk setiap baris)
print("Maksimum setiap baris (axis=1):")
print(f"max(axis=1): {np.max(data, axis=1)}")
# Output: [3 4 7]

print("Indeks maksimum setiap baris:")
print(f"argmax(axis=1): {np.argmax(data, axis=1)}")
# Output: [0 3 1]

Array NumPy baru biasanya C-contiguous, sehingga indeks terakhir berubah paling cepat di memori. View hasil slicing atau transpose dapat memiliki stride berbeda, jadi array tidak selalu tersimpan dalam satu tata letak row-major sederhana. Aturan order dan stride penting ketika melakukan reshape atau flatten.

internal_storage.py

import numpy as np

# Membuat array 2D
a = np.array([[0, 1], [2, 3]])
print("Array 2D:")
print(a)
print(f"Bentuk: {a.shape}")

# Melihat bagaimana disimpan dalam memori
print(f"Disimpan dalam memori sebagai: {a.ravel()}")
# Output: [0 1 2 3] (row-major order)

flatten() dan ravel() sama-sama menghasilkan array satu dimensi. flatten() selalu membuat salinan, sedangkan ravel() mengembalikan view jika memungkinkan dan salinan jika tata letak memorinya mengharuskan demikian.

flatten_ravel.py

import numpy as np

# Membuat array diagonal
a = np.diag([1, 2, 3])
print("Array diagonal:")
print(a)

# Flatten - membuat salinan independen
b_flatten = a.flatten()
print(f"Hasil flatten: {b_flatten}")

# Mengubah nilai flatten tidak mempengaruhi array asli
b_flatten[0] = 9
print(f"Setelah mengubah flatten: {b_flatten}")
print("Array asli tetap sama:")
print(a)

print()

# Ravel - mencoba membuat view (lebih efisien)
b_ravel = a.ravel()
print(f"Hasil ravel: {b_ravel}")

# Mengubah nilai ravel mempengaruhi array asli
b_ravel[0] = 9
print(f"Setelah mengubah ravel: {b_ravel}")
print("Array asli berubah:")
print(a)

reshape() mengubah shape selama jumlah elemennya tetap sama dan mengembalikan view jika memungkinkan. Method ndarray.resize() yang digunakan di bawah mengubah array asli secara langsung.

reshape_resize.py

import numpy as np

# Membuat array diagonal dan flatten
a = np.diag([1, 2, 3])
a_flat = a.flatten()
print(f"Array flat: {a_flat}")

# Reshape - mengubah bentuk dengan jumlah elemen yang sama
b = a_flat.reshape(3, 3)
print("Hasil reshape ke (3,3):")
print(b)

# Mengubah nilai dalam reshape
b[0, 0] = 9
print("Setelah mengubah nilai:")
print(b)
print(f"Array flat asli: {a_flat}")  # Berubah karena reshape membuat view

# Resize - mengubah bentuk in-place (tanpa return value)
a_flat.resize(3, 3)
print("Setelah resize:")
print(a_flat)  # Sekarang a_flat sudah menjadi 2D

Transpose menukar urutan axis array. Pada array dua dimensi, baris dan kolom saling bertukar. NumPy menyediakan method transpose() dan atribut .T yang lebih singkat.

transpose.py

import numpy as np

# Membuat array 2x4
a = np.linspace(1, 8, 8).reshape(2, 4)
print("Array asli (2x4):")
print(a)

# Transpose menggunakan method
b = a.transpose()
print("Hasil transpose (4x2):")
print(b)

# Transpose menggunakan atribut .T (lebih singkat)
c = a.T
print("Menggunakan .T:")
print(c)

# Memverifikasi bahwa transpose adalah view
print("Apakah transpose adalah view?", np.shares_memory(a, b))

Standardisasi skor Z memusatkan setiap fitur pada rata-rata $0$ dan menskalakannya ke standar deviasi $1$ . Operasi ini hanya terdefinisi untuk fitur dengan standar deviasi tak nol dan membuat skala numerik fitur dapat dibandingkan.

$X$ adalah matriks fitur berukuran $n \times k$
$n$ adalah jumlah observasi (baris)
$k$ adalah jumlah fitur (kolom)
$\mu$ adalah vektor rata-rata untuk setiap kolom
$\sigma$ adalah vektor standar deviasi untuk setiap kolom

z_transform.py

import numpy as np

# Membuat data contoh (5 observasi, 3 fitur)
np.random.seed(42)
X = np.random.randn(5, 3) * 10 + 50  # Data dengan mean~50, std~10

print("Data asli:")
print(X)
print(f"Bentuk data: {X.shape}")

# Menghitung rata-rata dan standar deviasi setiap kolom
mu = np.mean(X, axis=0)  # Rata-rata setiap kolom
sigma = np.std(X, axis=0)  # Standar deviasi setiap kolom

print(f"Rata-rata setiap fitur: {mu}")
print(f"Standar deviasi setiap fitur: {sigma}")

# Melakukan Z-Transform
Z = (X - mu) / sigma

print("Data setelah Z-Transform:")
print(Z)

# Verifikasi hasil standardisasi
print("Verifikasi standardisasi:")
print(f"Rata-rata baru: {np.mean(Z, axis=0)}")  # Harus mendekati 0
print(f"Standar deviasi baru: {np.std(Z, axis=0)}")  # Harus mendekati 1
# Output rata-rata baru: [ 1.24344979e-15  8.88178420e-17 -1.77635684e-16] (mendekati 0)
# Output standar deviasi baru: [1. 1. 1.]

Standardisasi mencegah perbedaan satuan saja menciptakan selisih skala yang besar. Namun, standardisasi tidak menjamin setiap fitur sama penting atau sama berpengaruh karena hal itu tetap ditentukan oleh model dan datanya. Misalnya, tinggi dalam sentimeter dan berat dalam kilogram menjadi sebanding secara numerik setelah distandardisasi.

Operasi pada Array dengan NumPy

Broadcasting dalam NumPy

Operasi pada Array dengan NumPy

Broadcasting dalam NumPy

Aturan Broadcasting

Array dengan Skalar

Array Dua Dimensi dengan Array Satu Dimensi

Kasus Broadcasting Gagal

Operasi Aritmetika Array

Operasi Antar Array

Perbandingan dan Logika

Fungsi Statistik dan Reduksi

Operasi dengan Sumbu

Manipulasi Bentuk Array

Flatten dan Ravel

Reshape dan Resize

Transpose

Standardisasi Data dengan Z-Transform