Aljabar Linear untuk Robotika

Aljabar linear adalah bahasa universal robotika. Setiap posisi lengan robot, orientasi sensor, kecepatan end-effector, dan sinyal kontrol dinyatakan dalam bentuk vektor dan matriks. Pemahaman mendalam tentang struktur matematika ini adalah prasyarat mutlak sebelum mempelajari kinematika, dinamika, SLAM, maupun kontrol optimal.

Notasi Standar

Sistem Koordinat dalam Robotika

Robot menggunakan multiple frames of reference secara simultan. Konvensi standar industri:

Definisi Vektor

Vektor adalah elemen dari ruang vektor \(\mathbb{R}^n\). Dalam robotika 3D, posisi dinyatakan sebagai vektor kolom:

Operasi Dasar Vektor

Penjumlahan dan Skalar

Aplikasi robotika: Superposisi kecepatan, penggabungan gaya/momen, interpolasi lintasan.

Dot Product (Produk Dalam)

Cross Product (Produk Silang)

Cross product menghasilkan vektor tegak lurus terhadap bidang \(\mathbf{u}\) dan \(\mathbf{v}\), dengan besar \(\|\mathbf{u}\|\|\mathbf{v}\|\sin\theta\).

Norma Vektor

Vektor unit: \(\hat{\mathbf{v}} = \dfrac{\mathbf{v}}{\|\mathbf{v}\|_2}\). Digunakan untuk menyatakan arah murni tanpa magnitude (sumbu rotasi, normal permukaan).

Kebebasan Linear & Basis

Set vektor \(\{\mathbf{v}_1, \ldots, \mathbf{v}_k\}\) bebas linear jika:

Basis standar \(\mathbb{R}^3\): \(\mathbf{e}_1 = [1,0,0]^T\), \(\mathbf{e}_2 = [0,1,0]^T\), \(\mathbf{e}_3 = [0,0,1]^T\). Sumbu X, Y, Z dalam koordinat robot.

Proyeksi Ortogonal

Aplikasi: Dekomposisi kecepatan end-effector menjadi komponen tangensial dan normal terhadap constraint surface.

Definisi Matriks

Matriks \(\mathbf{A} \in \mathbb{R}^{m \times n}\) adalah array bilangan dengan \(m\) baris dan \(n\) kolom:

Perkalian Matriks

Untuk \(\mathbf{A} \in \mathbb{R}^{m \times k}\) dan \(\mathbf{B} \in \mathbb{R}^{k \times n}\), hasil \(\mathbf{C} = \mathbf{A}\mathbf{B} \in \mathbb{R}^{m \times n}\):

Jenis-Jenis Matriks Penting dalam Robotika

Matriks Skew-Symmetric (Cross Product Matrix)

Sangat penting dalam robotika untuk menyatakan angular velocity dan cross product sebagai operasi matriks:

Transpose

Kritis: Untuk matriks rotasi ortogonal, \(\mathbf{R}^{-1} = \mathbf{R}^T\) — invers gratis tanpa Gauss-Jordan!

Determinan

Determinan adalah skalar yang mengukur "faktor skala volume" dari transformasi linear:

Invers Matriks

di mana \(M_{ji}\) adalah minor (determinan submatriks dengan baris \(j\) dan kolom \(i\) dihapus).

Dalam praktik komputasi, invers dihitung via dekomposisi LU (jauh lebih efisien dari formula analitik).

Pseudo-Inverse (Moore-Penrose)

Untuk matriks non-persegi (matriks Jacobian robot sering \(6 \times n\) dengan \(n \neq 6\)):

Definisi Formal

Fungsi \(T: \mathbb{R}^n \to \mathbb{R}^m\) adalah transformasi linear jika:

Setiap transformasi linear dapat dinyatakan sebagai perkalian matriks: \(T(\mathbf{x}) = \mathbf{A}\mathbf{x}\).

Empat Ruang Fundamental (Four Fundamental Subspaces)

Untuk matriks \(\mathbf{A} \in \mathbb{R}^{m \times n}\) dengan \(\text{rank}(A) = r\):

Rotasi 2D

Rotasi 3D — Sumbu Koordinat

Rotasi Sumbu Arbitrer (Rodrigues' Rotation Formula)

Rotasi sebesar \(\theta\) di sekitar sumbu satuan \(\hat{\mathbf{k}} = [k_x, k_y, k_z]^T\):

di mana \([\hat{\mathbf{k}}]_\times\) adalah matriks skew-symmetric dari \(\hat{\mathbf{k}}\).

Properti Matriks Rotasi

\(SO(3)\) adalah Special Orthogonal Group — grup Lie yang menjadi fondasi orientasi 3D dalam robotika. Setiap orientasi 3D valid adalah elemen \(SO(3)\).

Motivasi

Rotasi adalah transformasi linear (bisa dinyatakan sebagai matriks). Namun translasi bukan transformasi linear — ia tidak bisa dinyatakan sebagai perkalian matriks \(3 \times 3\). Solusi: augment ke dimensi-4 menggunakan koordinat homogen.

Koordinat Homogen

Komponen keempat \(w=1\) untuk titik (terpengaruh translasi), \(w=0\) untuk vektor (tidak terpengaruh translasi) — elegan secara matematis!

Matriks Transformasi Homogen (HTM)

\(SE(3)\) adalah Special Euclidean Group — grup transformasi rigid body 3D (rotasi + translasi).

Contoh: Transformasi Frame Kamera → Robot

Kolom 1–3 adalah matriks rotasi \(\mathbf{R}\), kolom 4 adalah posisi origin kamera dalam frame world \([0.5, 0.3, 1.2]^T\) meter.

Komposisi Transformasi

Sudut Euler ZYX (Yaw-Pitch-Roll)

Representasi orientasi paling umum dalam robotika dan drone. Tiga rotasi berurutan:

di mana \(c_\alpha = \cos\alpha\), \(s_\alpha = \sin\alpha\).

Invers: Matriks Rotasi → Sudut Euler

Selalu gunakan atan2(y, x) (dua argumen) bukan atan(y/x) untuk mendapatkan kuadran yang benar.

Konvensi Lain

Definisi

Quaternion adalah ekstensi bilangan kompleks ke dimensi-4, diperkenalkan Hamilton (1843). Dalam robotika, unit quaternion merepresentasikan rotasi 3D tanpa gimbal lock:

Aturan perkalian basis: \(\mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{ijk} = -1\), \(\mathbf{ij} = \mathbf{k}\), \(\mathbf{jk} = \mathbf{i}\), \(\mathbf{ki} = \mathbf{j}\).

Quaternion ↔ Axis-Angle

Perkalian Quaternion

Rotasi Vektor dengan Quaternion

Quaternion → Matriks Rotasi

SLERP — Spherical Linear Interpolation

Interpolasi rotasi yang smooth di permukaan unit sphere \(S^3\):

Definisi

Vektor \(\mathbf{v} \neq \mathbf{0}\) adalah eigenvector dari \(\mathbf{A}\) dengan eigenvalue \(\lambda\) jika:

Dekomposisi Eigen (Eigendecomposition)

Untuk matriks simetris \(\mathbf{A} = \mathbf{A}^T\): eigenvalue selalu real, eigenvectors saling ortogonal → \(\mathbf{A} = \mathbf{Q}\boldsymbol{\Lambda}\mathbf{Q}^T\) (spectral theorem).

Aplikasi dalam Robotika

Teorema SVD

Setiap matriks \(\mathbf{A} \in \mathbb{R}^{m \times n}\) dapat didekomposisi:

\(\sigma_i\) adalah singular values. Kolom \(\mathbf{U}\) adalah left singular vectors, kolom \(\mathbf{V}\) adalah right singular vectors.

Interpretasi Geometri

SVD mendekomposisi transformasi linear sembarang menjadi: rotasi (\(\mathbf{V}^T\)) → stretching (\(\boldsymbol{\Sigma}\)) → rotasi (\(\mathbf{U}\)). Ini cara paling fundamental memahami apa yang dilakukan sebuah transformasi.

Low-Rank Approximation

Kondisi Matriks & Singularitas Robot

Manipulability ellipsoid robot: sumbu-sumbu ellipsoid adalah singular vectors \(\mathbf{U}\), panjang sumbu adalah singular values \(\boldsymbol{\sigma}\). Robot mendekati singularitas ketika \(\sigma_{\min} \to 0\) (kondisi \(\kappa \to \infty\)).

Definisi Jacobian

Jacobian \(\mathbf{J}(\mathbf{q}) \in \mathbb{R}^{6 \times n}\) memetakan kecepatan sendi ke kecepatan end-effector:

Jacobian Geometrik

Dihitung dari forward kinematics. Untuk setiap joint \(j\):

di mana \(\hat{\mathbf{z}}_j\) adalah sumbu rotasi joint ke-\(j\) dan \(\mathbf{p}_e - \mathbf{p}_j\) adalah vektor dari joint \(j\) ke end-effector.

Static Force/Torque Duality

Prinsip virtual work: torsi sendi yang diperlukan untuk melawan gaya eksternal di end-effector = transpose Jacobian kali gaya. Ini fondasi torque control dan impedance control.

Analisis Singularitas via Jacobian

Denavit-Hartenberg (DH) Parameters

Konvensi standar untuk parameterisasi rantai kinematika. Setiap joint ke-\(i\) didefinisikan oleh 4 parameter:

DH Transformation Matrix

Forward Kinematics (FK)

FK selalu unik dan efisien (\(\mathcal{O}(n)\) HTM perkalian). Hasil: pose end-effector \(\mathbf{T} = [\mathbf{R} | \mathbf{p}]\) dalam frame base.

Inverse Kinematics (IK)

Diberikan pose target \(\mathbf{T}_d\), cari konfigurasi sendi \(\mathbf{q}\) yang memenuhi \(FK(\mathbf{q}) = \mathbf{T}_d\). Jauh lebih sulit dari FK!

Solusi Numerik: Jacobian Iteratif

Dengan error pose \(\mathbf{e}_k \in \mathbb{R}^6\) (translasi + rotasi). Konvergen saat \(\|\mathbf{e}_k\| < \epsilon\).

IK Analitik (untuk robot standar)

Robot 6-DOF dengan pergelangan spherical (3 joint terakhir berpotongan di satu titik) memiliki solusi IK tertutup. Contoh: PUMA 560, UR5/UR10 — maksimum 8 konfigurasi berbeda.

Least Squares Problem

Minimasi residual untuk sistem overdetermined \(\mathbf{A}\mathbf{x} = \mathbf{b}\) (lebih banyak persamaan dari variabel):

Normal equations: \(\mathbf{A}^T\mathbf{A}\mathbf{x} = \mathbf{A}^T\mathbf{b}\).

Weighted Least Squares

Regularisasi Tikhonov (Ridge Regression)

Regularisasi \(\lambda > 0\) mencegah solusi blow-up saat \(\mathbf{A}\) near-singular. Ini basis Damped Least Squares IK.

Aplikasi: Robot Calibration

Kalibrasi kinematika robot: diberikan \(N\) pengukuran pose, cari koreksi parameter DH \(\Delta\mathbf{p}\) yang meminimasi error:

Representasi State Space

Model sistem dinamis robot yang dilinearisasi di sekitar titik kerja:

Controllability & Observability

LQR — Linear Quadratic Regulator

Optimal control: minimasi cost function quadratic:

CARE = Continuous Algebraic Riccati Equation. Solusinya \(\mathbf{P}\) adalah SPD matrix — memberikan gain kontrol optimal \(\mathbf{K}\).

Kalman Filter

Kalman filter = estimator linier optimal (minimum variance). Esensial untuk sensor fusion IMU+GPS, odometry, SLAM.

Forward Pass sebagai Operasi Matriks

Batch forward pass untuk \(N\) sampel sekaligus: \(\mathbf{Z} = \mathbf{W}\mathbf{A} + \mathbf{b}\mathbf{1}^T\) — satu operasi GEMM (General Matrix-Matrix Multiply) yang dioptimalkan di GPU.

Backpropagation & Jacobian

Attention Mechanism (Transformer)

Sepenuhnya operasi matriks: \(\mathbf{Q}\mathbf{K}^T\) adalah dot-product similarity, \(\sqrt{d_k}\) adalah normalisasi untuk stabilitas numerik, softmax adalah normalisasi baris, dikali \(\mathbf{V}\) untuk weighted sum.

Konvolusi sebagai Matriks Toeplitz

Konvolusi 1D \((f * g)[n]\) ekivalen dengan perkalian matriks Toeplitz (banded). Konvolusi 2D (CNN) ekivalen dengan doubly block circulant matrix multiplication — ini mengapa CNN dapat diimplementasikan via FFT.

Tensorisasi dalam Robotics ML

Setup & Dasar

Pythonimport numpy as np
import scipy.linalg as la
from scipy.spatial.transform import Rotation

# Vektor dan matriks dasar
v = np.array([1.0, 2.0, 3.0])
A = np.array([[1,2,3],[4,5,6],[7,8,9]])

# Operasi dasar
dot   = np.dot(v, v)          # dot product: 14.0
cross = np.cross(v, v)       # cross product: [0,0,0]
norm  = np.linalg.norm(v)    # norm: 3.742
vhat  = v / norm              # unit vector

# Matriks perkalian
B = np.eye(3)
C = A @ B                    # matrix multiply (prefer @)

# Eigendecomposition
eigvals, eigvecs = np.linalg.eig(A)

# SVD
U, sigma, Vt = np.linalg.svd(A, full_matrices=False)

Rotasi dengan scipy

Pythonfrom scipy.spatial.transform import Rotation as R

# Buat rotasi dari berbagai representasi
r_euler = R.from_euler('ZYX', [30, 45, 60], degrees=True)
r_quat  = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
r_rotvec= R.from_rotvec(np.pi/2 * np.array([0, 0, 1]))
r_matrix= R.from_matrix(np.eye(3))

# Konversi antar representasi
matrix = r_euler.as_matrix()     # → 3x3 rotation matrix
quat   = r_euler.as_quat()       # → [x,y,z,w] (scipy convention)
euler  = r_quat.as_euler('ZYX', degrees=True)

# Komposisi rotasi
r_total = r_euler * r_quat        # Hamilton product

# SLERP interpolasi
r0, r1 = R.from_euler('z', 0), R.from_euler('z', 90, degrees=True)
times = np.linspace(0, 1, 10)
from scipy.spatial.transform import Slerp
slerp = Slerp([0, 1], R.concatenate([r0, r1]))
interp = slerp(times)

Transformasi Homogen

Pythondef make_htm(R, t):
    """Buat Homogeneous Transformation Matrix dari R dan t."""
    T = np.eye(4)
    T[:3, :3] = R
    T[:3,  3] = t
    return T

def htm_inv(T):
    """Invers HTM yang efisien (tidak pakai np.linalg.inv)."""
    R = T[:3, :3]
    t = T[:3,  3]
    T_inv = np.eye(4)
    T_inv[:3, :3] = R.T
    T_inv[:3,  3] = -R.T @ t
    return T_inv

# Contoh penggunaan
Rz90 = R.from_euler('z', 90, degrees=True).as_matrix()
t    = np.array([0.5, 0.3, 1.0])
T    = make_htm(Rz90, t)

# Transformasi titik
p_local = np.array([1, 0, 0, 1])  # homogeneous
p_world = T @ p_local

Jacobian & Pseudo-Inverse IK

Pythondef jacobian_numerical(fk_func, q, eps=1e-6):
    """Jacobian numerik via finite differences."""
    n = len(q)
    x0 = fk_func(q)
    m = len(x0)
    J = np.zeros((m, n))
    for i in range(n):
        q_plus = q.copy(); q_plus[i] += eps
        J[:, i] = (fk_func(q_plus) - x0) / eps
    return J

def ik_jacobian(fk_func, x_target, q_init, 
               max_iter=200, tol=1e-6, lam=0.01):
    """IK via Damped Least Squares Jacobian."""
    q = q_init.copy()
    for _ in range(max_iter):
        x_cur = fk_func(q)
        e = x_target - x_cur
        if np.linalg.norm(e) < tol:
            break
        J    = jacobian_numerical(fk_func, q)
        # Damped Least Squares: J^T (JJ^T + λ²I)^{-1}
        JJt  = J @ J.T
        dq   = J.T @ np.linalg.solve(JJt + lam**2*np.eye(JJt.shape[0]), e)
        q   += dq
    return q

Kalman Filter Sederhana

Pythonclass KalmanFilter:
    def __init__(self, A, C, Q, R_noise, x0, P0):
        self.A, self.C   = A, C
        self.Q, self.R   = Q, R_noise
        self.x, self.P   = x0, P0
        self.n           = A.shape[0]

    def predict(self):
        self.x = self.A @ self.x
        self.P = self.A @ self.P @ self.A.T + self.Q

    def update(self, y):
        S  = self.C @ self.P @ self.C.T + self.R
        K  = self.P @ self.C.T @ np.linalg.inv(S)
        self.x += K @ (y - self.C @ self.x)
        self.P  = (np.eye(self.n) - K @ self.C) @ self.P

# Usage: estimasi posisi robot 2D
A  = np.array([[1,0,0.1,0],[0,1,0,0.1],[0,0,1,0],[0,0,0,1]])
C  = np.eye(2, 4)  # observasi posisi saja (x, y)
kf = KalmanFilter(A, C, 0.01*np.eye(4), 0.1*np.eye(2),
                  np.zeros(4), np.eye(4))