Operasi Matriks dengan Numpy
numpy adalah pustaka python yang berguna untuk operasi numerik dan manipulasi data termasuk operasi matriks. Terdapat beragam fungsi dan operator yang mendukung operasi yang melibatkan matriks. Pada tutorial ini kita akan membahas beberapa operasi penting pada matriks. Pembahasan mencakup operasi dasar seperti penjumlahan sampai dengan operasi yang lebih rumit seperti invers matriks dan dekomposisi matriks.
Membuat Matriks
Beberapa fungsi yang digunakan untuk membuat matriks yaitu np.array, np.zeros, np.ones, np.eye. Matriks dapat pula dibuat dengan membangkitkan bilangan acak melalui fungsi-fungsi dari modul np.random.
lihat juga: (Membuat Objek Array Menggunakan Numpy)
Python
import numpy as np
# Matriks 2x2
A = np.array([[1, 2], [3, 4]])
# Matriks 3x4
B = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9,10,11,12]])
# Matriks nol 2x2
C = np.zeros((2, 2))
# Matriks satu 3x3
D = np.ones((3, 3))
# Matriks identitas 4x4
E = np.eye(3, 3)
# Matriks acak 3\nx3
F = np.random.rand(3, 3)
print("\nMatriks A:\n", A)
print("\nMatriks B:\n", B)
print("\nMatriks C:\n", C)
print("\nMatriks D:\n", D)
print("\nMatriks E:\n", E)
print("\nMatriks F:\n", F)# OUTPUT Matriks A: [[1 2] [3 4]] Matriks B: [[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]] Matriks C: [[0. 0.] [0. 0.]] Matriks D: [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]] Matriks E: [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]] Matriks F: [[5.18143908e-01 6.77365580e-01 4.53588072e-04] [9.37355840e-02 2.45214470e-01 8.50072104e-01] [4.61426442e-01 9.50271342e-01 6.78962508e-01]]
Penjumlahan dan Pengurangan
Penjumlahan dan pengurangan matriks dilakukan pada kedua matriks dengan ukuran yang sama. Operasi tersebut menghasilkan matriks baru di mana elemennya merupakan penjumlahan atau pengurangan dari elemen di posisi yang sama.
$\text{Misalkan matriks } A \text{ dan } B \text{ didefinisikan sebagai:}$
$A = \begin{pmatrix} a_{11} & a_{12} \\\ a_{21} & a_{22} \end{pmatrix}$
$B = \begin{pmatrix} b_{11} & b_{12} \\\ b_{21} & b_{22} \end{pmatrix}$
$\text{Penjumlahan matriks } C = A + B \text{ adalah:}$
$A + B = \begin{pmatrix} a_{11} + b_{11} & a_{12} + b_{12} \\\ a_{21} + b_{21} & a_{22} + b_{22} \end{pmatrix}$
Di dalam pustaka numpy, operasi penjumlahan dan pengurangan matriks dapat dilakukan secara langsung mengunakan operator “+” atau “-“. Selain itu dapat juga menggunakan fungsi np.add dan np.subtract untuk tujuan yang sama.
Python
# Matriks 2x3
A = np.array([[4, 5, 6],
[7, 8, 9]])
# Matriks 2x3
B = np.array([[1, 2, 3],
[1, 2, 3]])
A_plus_B = A + B # atau A_plus_B = np.add(A, B)
A_min_B = A - B # atau A_min_B = np.subtract(A, B)
print("\nA + B:\n", A_plus_B)
print("\nA - B:\n", A_min_B)# OUTPUT A + B: [[ 5 7 9] [ 8 10 12]] A - B: [[3 3 3] [6 6 6]]
Perkalian Matriks
Berbeda dengan operasi penjumlahan dan pengurangan, perkalian matriks dapat dilakukan jika jumlah kolom pada matriks pertama sama dengan jumlah baris matriks kedua. Perkalian matriks, misal ukuran 3×2 dengan matriks berukuran 2×3 maka akan menghasilkan matriks baru dengan ukuran 3×3 yaitu sebanyak baris matriks pertama dan kolom matriks kedua.
$\text{Misalkan matriks } A \text{ dan } B \text{ didefinisikan sebagai:}$
$A = \begin{pmatrix} a_{11} & a_{12} \\\ a_{21} & a_{22} \\\ a_{31} & a_{32} \end{pmatrix}$
$B = \begin{pmatrix} b_{11} & b_{12} & b_{13} \\\ b_{21} & b_{22} & b_{23} \end{pmatrix}$
$\text{Perkalian matriks } C = A \times B \text{ adalah:}$
$
C = A \times B = \begin{pmatrix} (a_{11}b_{11} + a_{12}b_{21}) & (a_{11}b_{12} + a_{12}b_{22}) & (a_{11}b_{13} + a_{12}b_{23}) \\\ (a_{21}b_{11} + a_{22}b_{21}) & (a_{21}b_{12} + a_{22}b_{22}) & (a_{21}b_{13} + a_{22}b_{23}) \\\ (a_{31}b_{11} + a_{32}b_{21}) & (a_{31}b_{12} + a_{32}b_{22}) & (a_{31}b_{13} + a_{32}b_{23}) \end{pmatrix}
$
Perkalian matriks dengan numpy dilakukan menggunakan operator “@” atau dapat juga menggunakan fungsi np.matmul atau np.dot (tidak direkomendasikan).
Python
# matriks 3x2
A = np.array([[1, 2],
[3, 4],
[5, 6]])
# matriks 2x3
B = np.array([[10, 12, 12],
[13, 14, 15]])
# matriks 3x3
A_mul_B = A @ B # atau A_mul_B = np.matmul(A, B)
print("\nA * B:\n", A_mul_B)# OUTPUT A * B: [[ 36 40 42] [ 82 92 96] [128 144 150]]
Transpose Matriks
Transpose matriks adalah operas di mana baris dan kolom dari matriks ditukar. Dengan kata lain, elemen yang berada di baris $i$ dan kolom $j$ dari matriks asli akan berada di baris $j$ dan kolom $i$ dari matriks transpos.
Jika $A$ adalah matriks berukuran $m \times n$, maka transpose dari $A$, yang dilambangkan dengan $A^T$ atau $A’$, adalah matriks berukuran $n \times m$. Elemen-elemen dari $A^T$ ditentukan sebagai:
$(A^T)_{ij} = A_{ji}$
Misalkan kita memiliki matriks $A$:
$A = \begin{pmatrix} 1 & 4 \\ 2 & 5 \\ 3 & 6 \end{pmatrix}$
Maka transpose dari matriks $A$ adalah:
$A^T = \begin{pmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{pmatrix}$
Proses transpose matriks pada numpy dilakukan dengan memanggil method transpose dari objek matriks tersebut.
Python
# matriks 3x2
A = np.array([[1, 2],
[3, 4],
[5, 6]])
# matriks 2x3
A_trans = A.transpose()
print("\nA Transpose:\n", A_trans)# OUTPUT A Transpose: [[1 3 5] [2 4 6]]
Determinan Matriks
Determinan matriks adalah nilai skalar yang dapat dihitung dari sebuah matriks persegi. Nilai determinan memberikan informasi tentang sifat-sifat matriks, seperti apakah matriks tersebut invertible (dapat dibalik) atau tidak. Determinan hanya dapat dihitung untuk matriks persegi (matriks dengan jumlah baris dan kolom yang sama).
Misalkan $A$ adalah matriks persegi berukuran $n \times n$. Determinan dari $A$, dilambangkan dengan $\det(A)$ atau $|A|$, adalah suatu nilai skalar yang didefinisikan secara rekursif sebagai berikut:
Untuk matriks berukuran $2 \times 2$:
$A = \begin{pmatrix} a & b \\ c & d \end{pmatrix}$
Determinan $\det(A)$ dihitung sebagai:
$\det(A) = ad – bc$
Untuk matriks berukuran $3 \times 3$:
$A = \begin{pmatrix} a_{11} & a_{12} & a_{13} \\ a_{21} & a_{22} & a_{23} \\ a_{31} & a_{32} & a_{33} \end{pmatrix}$
Determinan $\det(A)$ dihitung sebagai:
$\det(A) = a_{11} \begin{vmatrix} a_{22} & a_{23} \\ a_{32} & a_{33} \end{vmatrix} – a_{12} \begin{vmatrix} a_{21} & a_{23} \\ a_{31} & a_{33} \end{vmatrix} + a_{13} \begin{vmatrix} a_{21} & a_{22} \\ a_{31} & a_{32} \end{vmatrix}$
Untuk matriks ukuran yang lebih besar, proses dilakukan dengan aturan yang sama, namun tentunya dengan kompleksitas yang lebih tinggi.
Dengan menggunakan numpy, nilai determinan dapat dihitung melalui fungsi np.linalg.det seperti contoh di bawah ini. Salah satu sifat determinan adalah sifat linear di mana jika dua baris atau kolom dari suatu matriks adalah identik atau merupakan fungsi linear, maka determinannya adalah nol. Misalkan pada matriks B berikut, baris kedua dapat dibentuk dari fungsi linear baris pertama yaitu dengan $B_2=$B_1+3$. Jika terdapat 1 kondisi saja seperti ini maka sudah pasti determinan matriks tersebut akan bernilai 0.
Python
A = np.array([[5, 0, 1],
[3, 2, 2],
[1, 4, 2]])
B = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
A_det = np.linalg.det(A)
B_det = np.linalg.det(B)
print("\nDeterminan Matriks A:", A_det)
print("\nDeterminan Matriks B:", B_det)# OUTPUT Determinan Matriks A: -9.999999999999998 Determinan Matriks B: 0.0
Invers Matriks
Misalkan $A$ adalah matriks persegi berukuran $n \times n$. Matriks A memiliki invers, yang dilambangkan sebagai $A^{-1}$, jika memenuhi kondisi berikut:
$A \times A^{-1} = A^{-1} \times A = I$
di mana $I$ adalah matriks identitas berukuran $n \times n$.
Matriks $A$ memiliki invers jika dan hanya jika $A$ adalah matriks yang dapat dibalik (invertible), yang berarti determinannya $\det(A)$ tidak nol:
$\det(A) \neq 0$
Pada contoh di bawah ini Matriks A memiliki matriks invers karena merupakan matriks yang invertable. Adapun matriks B tidak memiliki matriks invers karena berdasarkan hasil sebelumnya matriks B memiliki nilai determinan 0. Ketika tidak dapat di-invers, numpy akan menghasilkan error LinAlgError: Singular matrix.
Python
# matriks 3x3 (invertable)
A = np.array([[5, 0, 1],
[3, 2, 2],
[1, 4, 2]])
# matriks 3x3 (singular)
B = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# invers matriks A
A_inv = np.linalg.inv(A)
print("\nA Invers:\n", A_inv)
# invers matriks B
B_inv = np.linalg.inv(B) # akan menghasilkan error
print("\nA Invers:\n", B_inv)# OUTPUT A Invers: [[ 0.4 -0.4 0.2] [ 0.4 -0.9 0.7] [-1. 2. -1. ]] LinAlgError: Singular matrix
Untuk menunjukkan sifat invers matriks, kita dapat mengalikan matriks A dan inversnya dan akan menghasilkan matriks Identitas. Pada hasil di bawah mungkin ada beberapa elemen dimana nilainya tidak persis menghasilkan nilai 0 atau 1. Hal ini murni karena proses komputasi numerik yang melibatkan bilangan pecahan.
Python
print("\nA x A Invers:\n", A @ A_inv)
print("\nA Invers x A:\n", A_inv @ A)# OUTPUT A x A Invers: [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]] A Invers x A: [[ 1.00000000e+00 0.00000000e+00 0.00000000e+00] [ 7.77156117e-16 1.00000000e+00 0.00000000e+00] [-8.88178420e-16 0.00000000e+00 1.00000000e+00]]
Nilai Eigen dan Vektor Eigen
Nilai eigen (eigenvalue) dan vektor eigen (eigenvector) adalah konsep penting dalam aljabar linear yang berkaitan dengan matriks persegi. Mereka memberikan informasi tentang transformasi linear yang diwakili oleh matriks tersebut.
Misalkan $ adalah matriks persegi berukuran $n \times n$. Sebuah vektor non-nol $\mathbf{v}$ dikatakan sebagai vektor eigen dari $A$ jika terdapat skalar $\lambda$ sedemikian rupa sehingga:
$A \mathbf{v} = \lambda \mathbf{v}$
Di mana:
- $\lambda$ adalah nilai eigen yang berhubungan dengan vektor eigen $\mathbf{v}$.
- $\mathbf{v}$ adalah vektor eigen yang berhubungan dengan nilai eigen $\lambda$.
Untuk menemukan nilai-nilai eigen dari sebuah matriks $A$, kita harus menyelesaikan persamaan karakteristik yang diperoleh dari determinan matriks $A – \lambda I$:
$\det(A – \lambda I) = 0$
Di mana $I$ adalah matriks identitas berukuran $n \times n$.
Untuk memperoleh nilai eigen dan vektor eigen pada numpy kita menggunakan fungsi np.linalg.eig. Fungsi ini mengembalikan nilai eigen dan vektor eigen sekaligus, sehingga dapat disimpan ke dalam 2 variabel secara langsung.
Python
# matriks 3x3(invertable)
A = np.array([[5, 0, 1],
[3, 2, 2],
[1, 4, 2]])
# nilai eigen dan vektor eigen
eigenvalues, eigenvectors = np.linalg.eig(A)
print("\nNilai eigen:\n", eigenvalues)
print("\nVektor eigen:\n", eigenvectors)# OUTPUT Nilai eigen: [ 6.42165808 3.08338164 -0.50503972] Vektor eigen: [[-0.4579871 -0.43581562 -0.155174 ] [-0.6052398 0.33518897 -0.49618217] [-0.65110107 0.83529222 0.85423901]]
Singular Value Decomposition (SVD)
Singular Value Decomposition (SVD) adalah salah satu teknik dekomposisi matriks yang paling penting dan serbaguna dalam aljabar linear. SVD memungkinkan kita untuk memecah sebuah matriks menjadi tiga matriks yang lebih sederhana dan memiliki properti tertentu. Teknik ini digunakan secara luas dalam berbagai aplikasi, termasuk analisis data, pengolahan citra, kompresi data, dan pengenalan pola.
Untuk matriks $A$ berukuran $m \times n$ (tidak harus matriks persegi), SVD menyatakan bahwa matriks $A$ dapat didekomposisi menjadi tiga matriks:
$A = U \Sigma V^T$
Di mana:
- $U$ adalah matriks ortogonal berukuran $m \times m$ yang kolom-kolomnya adalah vektor-vektor eigen dari $AA^T$.
- $\Sigma$ adalah matriks diagonal berukuran $m \times n$ yang elemen-elemen diagonalnya adalah singular values dari $A$. Elemen-elemen ini non-negatif dan disusun dalam urutan menurun.
- $V$ adalah matriks ortogonal berukuran $n \times n$ yang kolom-kolomnya adalah vektor-vektor eigen dari $A^T A$.
- $V^T$ adalah transpose dari matriks $V$.
Untuk memperoleh matriks-matriks tersebut pada numpy kita dapat menggunakan fungsi np.linalg.svd yang mengembalikan ketiga matriks tersebut sekaligus. Sebagai catatan matriks S dikembalikan dalam bentuk vektor diagonalnya, kita dapat menggunakan fungsi np.diag untuk menjadikannya matriks diagonal. Hasil ini dapat dicek dengan mengalikan ketiga matriks dan akan menghasilkan matriks semula (matriks A).
Python
A = np.array([[5, 0, 1],
[3, 2, 2],
[1, 4, 2]])
#
U, S, Vt = np.linalg.svd(A)
print("\nMatriks U:\n", U)
print("\nMatriks S:\n", np.diag(S))
print("\nMatriks Vt:\n", Vt)
print("\nMatriks U x S x Vt:\n", U @ np.diag(S) @ Vt)# OUTPUT Matriks U: [[-0.62938681 0.66168823 0.4074812 ] [-0.59450861 -0.0723188 -0.80083051] [-0.50043157 -0.74628324 0.43889585]] Matriks S: [[6.9009922 0. 0. ] [0. 4.03076483 0. ] [0. 0. 0.35950175]] Matriks Vt: [[-0.78697255 -0.46236011 -0.4085307 ] [ 0.58182544 -0.77647064 -0.24201755] [ 0.20531283 0.42815473 -0.88007396]] Matriks U x S x Vt: [[5.0000000e+00 2.3489339e-15 1.0000000e+00] [3.0000000e+00 2.0000000e+00 2.0000000e+00] [1.0000000e+00 4.0000000e+00 2.0000000e+00]]
