Belajar Math - Matrix (Matriks)
Matriks R×C, penjumlahan, perkalian skalar, dan perkalian matriks (row × column) adalah fondasi untuk image processing (kernel convolution), transformasi geometri, data tables, dan weighted connections — dari implementasi manual hingga NumPy.
#Pendahuluan
Setelah di episode 16 kita mempelajari vektor — operasi 1D pada array angka — pada episode ini kita naik ke matriks: struktur data 2D (baris × kolom) yang menjadi fondasi dari image processing, transformasi geometri, dan data tables. Matriks adalah generalisasi vektor — jika vektor adalah satu baris angka, matriks adalah kumpulan baris yang membentuk tabel.
Mengapa matriks penting? Karena dalam dunia nyata, data sering berbentuk 2D: tabel database adalah matriks, gambar adalah matriks pixel, dataset CSV adalah matriks baris×kolom. Operasi matriks — terutama perkalian — adalah alat utama untuk transformasi, filtering, dan komputasi dalam machine learning dan graphics.
#Matriks Dasar
#Representasi
# Matriks 2×3 (2 baris, 3 kolom)
A = [
[1, 2, 3],
[4, 5, 6],
]
# Matriks 3×3
B = [
[1, 0, 0],
[0, 1, 0],
[0, 0, 1], # identity matrix
]
def show_matrix(M, name="M"):
print(f"{name} ({len(M)}×{len(M[0])}):")
for row in M:
print(f" {[f'{x:>6.2f}' for x in row]}")
show_matrix(A, "A")
show_matrix(B, "B")#Penjumlahan Matriks
def matrix_add(A, B):
"""Penjumlahan matriks — element-wise."""
rows, cols = len(A), len(A[0])
return [[A[i][j] + B[i][j] for j in range(cols)] for i in range(rows)]
A = [[1, 2], [3, 4]]
B = [[5, 6], [7, 8]]
C = matrix_add(A, B)
show_matrix(C, "A + B")
# [[6, 8], [10, 12]]#Perkalian Skalar
def scalar_multiply(matrix, scalar):
"""Kalikan setiap elemen dengan skalar."""
return [[x * scalar for x in row] for row in matrix]
A = [[1, 2], [3, 4]]
result = scalar_multiply(A, 3)
show_matrix(result, "3 × A")
# [[3, 6], [9, 12]]#Perkalian Matriks
#Aturan
Matriks A (m×n) bisa dikalikan dengan B (n×p) menghasilkan C (m×p). Setiap elemen C[i][j] = dot product baris i dari A dengan kolom j dari B:
def matrix_multiply(A, B):
"""Perkalian matriks: (m×n) × (n×p) = (m×p)."""
m, n = len(A), len(A[0])
n2, p = len(B), len(B[0])
assert n == n2, f"Incompatible: {m}×{n} × {n2}×{p}"
C = [[0] * p for _ in range(m)]
for i in range(m):
for j in range(p):
for k in range(n):
C[i][j] += A[i][k] * B[k][j]
return C
# Contoh: 2×3 × 3×2 = 2×2
A = [
[1, 2, 3],
[4, 5, 6],
]
B = [
[7, 8],
[9, 10],
[11, 12],
]
C = matrix_multiply(A, B)
show_matrix(A, "A (2×3)")
show_matrix(B, "B (3×2)")
show_matrix(C, "C = A × B (2×2)")#Visualisasi Perkalian
C[0][0] = A[0][0]×B[0][0] + A[0][1]×B[1][0] + A[0][2]×B[2][0]
= 1×7 + 2×9 + 3×11
= 7 + 18 + 33 = 58
C[0][1] = A[0][0]×B[0][1] + A[0][1]×B[1][1] + A[0][2]×B[2][1]
= 1×8 + 2×10 + 3×12
= 8 + 20 + 36 = 64#Identity Matrix
Matriks identitas I: diagonal = 1, lainnya = 0. A × I = A (tidak mengubah):
def identity(n):
"""Matriks identitas n×n."""
return [[1 if i == j else 0 for j in range(n)] for i in range(n)]
I = identity(3)
show_matrix(I, "I (3×3)")
A = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
C = matrix_multiply(A, I)
show_matrix(C, "A × I")
# Sama dengan A!#Perbandingan dengan NumPy
import time
# Buat matriks besar 200×200
import random
n = 200
A = [[random.random() for _ in range(n)] for _ in range(n)]
B = [[random.random() for _ in range(n)] for _ in range(n)]
# Manual
start = time.perf_counter()
C_manual = matrix_multiply(A, B)
t_manual = time.perf_counter() - start
# NumPy
import numpy as np
A_np = np.array(A)
B_np = np.array(B)
start = time.perf_counter()
C_numpy = np.matmul(A_np, B_np)
t_numpy = time.perf_counter() - start
print(f"Matrix multiply {n}×{n}:")
print(f" Manual: {t_manual:.4f}s")
print(f" NumPy: {t_numpy:.6f}s")
print(f" NumPy {t_manual/t_numpy:.0f}x lebih cepat!")#Aplikasi
#Image Processing — Kernel Convolution
Gambar grayscale adalah matriks pixel. Kernel convolution = perkalian matriks untuk edge detection, blur, sharpen:
import numpy as np
# Gambar 5×5 (grayscale)
image = np.array([
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 255, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
], dtype=float)
# Kernel edge detection
kernel = np.array([
[-1, -1, -1],
[-1, 8, -1],
[-1, -1, -1],
], dtype=float)
# Simple convolution (tanpa padding/stride)
def simple_convolve(img, kern):
h, w = img.shape
kh, kw = kern.shape
out_h, out_w = h - kh + 1, w - kw + 1
output = np.zeros((out_h, out_w))
for i in range(out_h):
for j in range(out_w):
region = img[i:i+kh, j:j+kw]
output[i][j] = np.sum(region * kern)
return output
result = simple_convolve(image, kernel)
print("Edge detection result:")
print(result.astype(int))#Data Tables sebagai Matriks
# Dataset: [usia, gaji, jumlah_pembelian]
data = [
[25, 5000, 10],
[30, 7000, 25],
[35, 9000, 40],
[40, 12000, 55],
]
# Bobot normalisasi (min-max scaling)
def normalize_column(matrix, col):
values = [row[col] for row in matrix]
min_val, max_val = min(values), max(values)
for row in matrix:
row[col] = (row[col] - min_val) / (max_val - min_val) if max_val != min_val else 0
data_copy = [row[:] for row in data]
for col in range(3):
normalize_column(data_copy, col)
print("Normalized dataset:")
for row in data_copy:
print(f" [{row[0]:.2f}, {row[1]:.2f}, {row[2]:.2f}]")#Weighted Connections
# Social network: adjacency matrix dengan bobot
# Bobot = frekuensi interaksi
users = ["Alice", "Bob", "Charlie", "Diana"]
weights = [
[0, 5, 3, 0], # Alice: 5 interaksi dengan Bob, 3 dengan Charlie
[5, 0, 2, 4], # Bob: 5 dengan Alice, 2 dengan Charlie, 4 dengan Diana
[3, 2, 0, 1], # Charlie: 3 dengan Alice, 2 dengan Bob, 1 dengan Diana
[0, 4, 1, 0], # Diana: 4 dengan Bob, 1 dengan Charlie
]
# Friendship score = dot product dari dua user's weight vectors
def friendship_score(u1_idx, u2_idx, weights):
return sum(weights[u1_idx][k] * weights[u2_idx][k] for k in range(len(users)))
# Alice vs Bob: high score (lots of mutual connections)
score = friendship_score(0, 1, weights)
print(f"Alice-Bob friendship score: {score}")
# = 5×5 + 3×2 + 0×4 = 25+6+0 = 31Note
Perkalian matriks memiliki kompleksitas O(n³) untuk matriks n×n — cukup mahal untuk ukuran besar. NumPy menggunakan optimasi BLAS/LAPACK yang bisa O(n^2.37) atau lebih baik. Gunakan NumPy untuk matriks production, manual hanya untuk pemahaman konsep.
#Penutup
Inti yang harus dibawa pulang:
- Matriks adalah struktur data 2D (baris × kolom); representasi dari tabel data, gambar, dan koneksi.
- Penjumlahan matriks = element-wise; perkalian skalar = rescaling semua elemen.
- Perkalian matriks (m×n) × (n×p) = (m×p): setiap elemen = dot product baris × kolom.
- Identity matrix
I:A × I = A— tidak mengubah matriks. - Matriks muncul di image processing (kernel convolution), data tables, dan weighted connections.
Di episode 18 selanjutnya kita akan mempelajari determinant, inverse, dan sistem persamaan linear — bagaimana menentukan apakah matriks bisa dibalik (invertible), menghitung area/volume transformasi, dan menyelesaikan sistem persamaan linear Ax = b dengan Gaussian elimination!