Tutorial Lengkap JAX: Framework Machine Learning Berkinerja Tinggi dari Google
JAX adalah library open-source dari Google yang menggabungkan NumPy dengan kemampuan diferensiasi otomatis (automatic differentiation) dan akselerasi hardware melalui XLA (Accelerated Linear Algebra). JAX memungkinkan Anda menulis kode numerik dengan sintaks yang familiar seperti NumPy, namun dengan performa yang jauh lebih tinggi berkat kompilasi JIT dan dukungan native untuk GPU dan TPU.
Dalam tutorial ini, kita akan mempelajari JAX dari dasar hingga penggunaan lanjutan, termasuk transformasi fungsi, neural network training, dan optimasi performa untuk workload machine learning skala besar.
Mengapa JAX?
JAX menjadi pilihan utama bagi banyak tim riset dan produksi ML karena beberapa alasan:
- Kompatibilitas NumPy: API
jax.numpyhampir identik dengan NumPy, sehingga kurva belajarnya sangat rendah bagi pengguna Python yang sudah familiar dengan ekosistem ilmiah. - Diferensiasi Otomatis: Fungsi
jax.gradmemungkinkan diferensiasi otomatis terhadap fungsi Python biasa, mendukung forward-mode dan reverse-mode differentiation. - Kompilasi JIT: Melalui
jax.jit, fungsi Python dikompilasi menjadi kode XLA yang dioptimasi untuk hardware target (CPU, GPU, atau TPU). - Vektorisasi Otomatis:
jax.vmapmemungkinkan vektorisasi otomatis fungsi tanpa menulis loop manual. - Paralelisasi:
jax.pmapmenyediakan paralelisasi multi-device secara transparan. - Ekosistem yang Kaya: Library seperti Flax, Optax, dan Orbax menyediakan abstraksi tingkat tinggi untuk neural network, optimizer, dan checkpointing.
Instalasi
Instalasi Dasar (CPU)
pip install jax
Instalasi dengan Dukungan GPU (CUDA 12)
pip install jax[cuda12]
Instalasi dengan Dukungan TPU
pip install jax[tpu] -f https://storage.googleapis.com/jax-releases/libtpureleases.html
Verifikasi Instalasi
import jax
import jax.numpy as jnp
print(f"JAX version: {jax.version}")
print(f"Available devices: {jax.devices()}")
print(f"Default backend: {jax.defaultbackend()}")
Test sederhana
x = jnp.array([1.0, 2.0, 3.0])
print(f"Array: {x}")
print(f"Device: {x.devices()}")
Output yang diharapkan:
JAX version: 0.4.x
Available devices: [CpuDevice(id=0)]
Default backend: cpu
Array: [1. 2. 3.]
Penggunaan Dasar
JAX NumPy: Array dan Operasi Dasar
JAX menyediakan jax.numpy sebagai pengganti NumPy dengan API yang hampir identik:
import jax.numpy as jnp
Membuat array
a = jnp.array([1.0, 2.0, 3.0, 4.0])
b = jnp.ones((3, 3))
c = jnp.zeros((2, 4))
d = jnp.linspace(0, 1, 5)
Operasi matematika
result = jnp.dot(a, a)
print(f"Dot product: {result}")
Operasi matriks
matrix = jnp.array([[1, 2], [3, 4]])
eigenvalues = jnp.linalg.eigvalsh(matrix)
print(f"Eigenvalues: {eigenvalues}")
Statistik
data = jnp.array([1.0, 2.0, 3.0, 4.0, 5.0])
print(f"Mean: {jnp.mean(data)}")
print(f"Std: {jnp.std(data)}")
Perbedaan Penting: Immutability
Berbeda dengan NumPy, array JAX bersifat immutable. Anda tidak bisa mengubah elemen secara langsung:
import jax.numpy as jnp
x = jnp.array([1, 2, 3, 4, 5])
NumPy style (TIDAK BISA di JAX):
x[0] = 10 # Error!
JAX style menggunakan .at[].set():
xupdated = x.at[0].set(10)
print(f"Original: {x}") # [1, 2, 3, 4, 5]
print(f"Updated: {xupdated}") # [10, 2, 3, 4, 5]
Operasi .at lainnya:
xadd = x.at[1].add(100) # Tambah 100 ke index 1
xmul = x.at[2].multiply(3) # Kalikan index 2 dengan 3
print(f"After add: {xadd}")
print(f"After multiply: {xmul}")
Random Number Generation
JAX menggunakan sistem PRNG (Pseudo-Random Number Generator) yang eksplisit dan reproducible:
import jax
import jax.numpy as jnp
Membuat key PRNG
key = jax.random.PRNGKey(42)
Setiap operasi random membutuhkan key terpisah
key1, key2, key3 = jax.random.split(key, 3)
Generate random numbers
uniform = jax.random.uniform(key1, shape=(3,))
normal = jax.random.normal(key2, shape=(3,))
integers = jax.random.randint(key3, shape=(5,), minval=0, maxval=10)
print(f"Uniform: {uniform}")
print(f"Normal: {normal}")
print(f"Integers: {integers}")
Pattern umum: split key di setiap iterasi
key = jax.random.PRNGKey(0)
for i in range(3):
key, subkey = jax.random.split(key)
sample = jax.random.normal(subkey, shape=(2,))
print(f"Iteration {i}: {sample}")
Transformasi Fungsi
Kekuatan utama JAX terletak pada kemampuannya mentransformasi fungsi Python biasa. Ada empat transformasi utama: grad, jit, vmap, dan pmap.
Automatic Differentiation dengan jax.grad
import jax
import jax.numpy as jnp
Fungsi sederhana
def f(x):
return jnp.sin(x) 2 + jnp.cos(x)
Gradient (turunan pertama)
df = jax.grad(f)
print(f"f(1.0) = {f(1.0):.4f}")
print(f"f'(1.0) = {df(1.0):.4f}")
Turunan kedua
d2f = jax.grad(jax.grad(f))
print(f"f''(1.0) = {d2f(1.0):.4f}")
Gradient untuk fungsi multi-variabel
def g(x, y):
return x 2 y + jnp.exp(y)
Gradient terhadap argumen pertama (default)
dgdx = jax.grad(g, argnums=0)
print(f"dg/dx(2.0, 1.0) = {dgdx(2.0, 1.0):.4f}")
Gradient terhadap kedua argumen
dgboth = jax.grad(g, argnums=(0, 1))
grads = dgboth(2.0, 1.0)
print(f"dg/dx = {grads[0]:.4f}, dg/dy = {grads[1]:.4f}")
Gradient untuk Loss Function ML
import jax
import jax.numpy as jnp
def mseloss(params, X, y):
"""Mean Squared Error loss untuk linear regression."""
w, b = params
predictions = X @ w + b
return jnp.mean((predictions - y) 2)
Data dummy
key = jax.random.PRNGKey(42)
X = jax.random.normal(key, (100, 3))
truew = jnp.array([1.0, -2.0, 0.5])
trueb = 1.0
y = X @ truew + trueb
Inisialisasi parameter
key, subkey = jax.random.split(key)
w = jax.random.normal(subkey, (3,))
b = jnp.array(0.0)
params = (w, b)
Hitung gradient
gradfn = jax.grad(mseloss)
grads = gradfn(params, X, y)
print(f"Gradient w: {grads[0]}")
print(f"Gradient b: {grads[1]}")
Value dan gradient sekaligus
lossandgrad = jax.valueandgrad(mseloss)
lossval, grads = lossandgrad(params, X, y)
print(f"Loss: {lossval:.4f}")
Just-In-Time Compilation dengan jax.jit
jax.jit mengkompilasi fungsi Python menjadi kode XLA yang dioptimasi:
import jax
import jax.numpy as jnp
import time
def slowfunction(x):
"""Fungsi dengan banyak operasi."""
for in range(100):
x = jnp.sin(x) + jnp.cos(x) 0.1
return x
Versi JIT-compiled
fastfunction = jax.jit(slowfunction)
x = jnp.ones((1000, 1000))
Warmup (kompilasi pertama kali)
= fastfunction(x).blockuntilready()
Benchmark tanpa JIT
start = time.time()
= slowfunction(x).blockuntilready()
nojittime = time.time() - start
Benchmark dengan JIT
start = time.time()
= fastfunction(x).blockuntilready()
jittime = time.time() - start
print(f"Tanpa JIT: {nojittime:.4f}s")
print(f"Dengan JIT: {jittime:.4f}s")
print(f"Speedup: {nojittime / jittime:.1f}x")
Vektorisasi Otomatis dengan jax.vmap
jax.vmap memungkinkan Anda menulis fungsi untuk satu sampel, lalu otomatis memvektorisasinya untuk batch:
import jax
import jax.numpy as jnp
Fungsi untuk satu sampel
def predictsingle(params, x):
w, b = params
return jnp.dot(w, x) + b
Data
key = jax.random.PRNGKey(42)
w = jax.random.normal(key, (5,))
b = jnp.array(0.0)
params = (w, b)
Satu input
xsingle = jnp.ones(5)
print(f"Single prediction: {predictsingle(params, xsingle)}")
Batch input menggunakan vmap
predictbatch = jax.vmap(predictsingle, inaxes=(None, 0))
Xbatch = jax.random.normal(key, (10, 5))
predictions = predictbatch(params, Xbatch)
print(f"Batch predictions shape: {predictions.shape}")
print(f"Batch predictions: {predictions}")
vmap untuk menghitung Jacobian
def f(x):
return jnp.array([x[0] * 2 + x[1], jnp.sin(x[0]) x[1]])
Jacobian menggunakan vmap + grad
jacobian = jax.jacobian(f)
x = jnp.array([1.0, 2.0])
J = jacobian(x)
print(f"Jacobian:\n{J}")
Penggunaan Lanjutan
Training Neural Network dari Scratch
Berikut contoh lengkap training neural network sederhana menggunakan JAX murni:
import jax
import jax.numpy as jnp
from typing import List, Tuple
def initmlp(layersizes: List[int], key):
"""Inisialisasi parameter MLP dengan Xavier initialization."""
params = []
for i in range(len(layersizes) - 1):
key, wkey, bkey = jax.random.split(key, 3)
scale = jnp.sqrt(2.0 / layersizes[i])
w = jax.random.normal(wkey, (layersizes[i], layersizes[i + 1])) scale
b = jnp.zeros(layersizes[i + 1])
params.append((w, b))
return params
def forward(params, x):
"""Forward pass MLP dengan ReLU activation."""
for w, b in params[:-1]:
x = jnp.maximum(0, x @ w + b) # ReLU
w, b = params[-1]
return x @ w + b # Output layer tanpa activation
def crossentropyloss(params, X, y):
"""Cross-entropy loss untuk klasifikasi."""
logits = forward(params, X)
logprobs = jax.nn.logsoftmax(logits)
onehot = jax.nn.onehot(y, logits.shape[-1])
return -jnp.mean(jnp.sum(onehot logprobs, axis=-1))
def accuracy(params, X, y):
"""Hitung akurasi prediksi."""
logits = forward(params, X)
predicted = jnp.argmax(logits, axis=-1)
return jnp.mean(predicted == y)
@jax.jit
def trainstep(params, X, y, lr):
"""Satu step training dengan gradient descent."""
loss, grads = jax.valueandgrad(crossentropyloss)(params, X, y)
params = jax.tree.map(lambda p, g: p - lr g, params, grads)
return params, loss
Generate synthetic dataset
key = jax.random.PRNGKey(42)
nsamples = 1000
nfeatures = 20
nclasses = 3
key, datakey = jax.random.split(key)
X = jax.random.normal(datakey, (nsamples, nfeatures))
truew = jax.random.normal(key, (nfeatures, nclasses))
logits = X @ truew
y = jnp.argmax(logits, axis=-1)
Split data
Xtrain, Xtest = X[:800], X[800:]
ytrain, ytest = y[:800], y[800:]
Inisialisasi model
key = jax.random.PRNGKey(0)
params = initmlp([nfeatures, 64, 32, nclasses], key)
Training loop
lr = 0.01
for epoch in range(100):
params, loss = trainstep(params, Xtrain, ytrain, lr)
if (epoch + 1) % 20 == 0:
trainacc = accuracy(params, Xtrain, ytrain)
testacc = accuracy(params, Xtest, ytest)
print(f"Epoch {epoch+1}: loss={loss:.4f}, "
f"trainacc={trainacc:.4f}, testacc={testacc:.4f}")
Menggunakan JAX dengan Flax dan Optax
Untuk proyek yang lebih besar, gunakan Flax (neural network library) dan Optax (optimizer library):
import jax
import jax.numpy as jnp
import flax.linen as nn
import optax
from flax.training import trainstate
class CNN(nn.Module):
"""Convolutional Neural Network sederhana."""
numclasses: int = 10
@nn.compact
def call(self, x, training: bool = True):
x = nn.Conv(features=32, kernelsize=(3, 3))(x)
x = nn.relu(x)
x = nn.maxpool(x, windowshape=(2, 2), strides=(2, 2))
x = nn.Conv(features=64, kernelsize=(3, 3))(x)
x = nn.relu(x)
x = nn.maxpool(x, windowshape=(2, 2), strides=(2, 2))
x = x.reshape((x.shape[0], -1)) # Flatten
x = nn.Dense(features=256)(x)
x = nn.relu(x)
x = nn.Dropout(rate=0.5)(x, deterministic=not training)
x = nn.Dense(features=self.numclasses)(x)
return x
def createtrainstate(key, learningrate, model):
"""Inisialisasi training state."""
dummyinput = jnp.ones([1, 28, 28, 1])
variables = model.init(key, dummyinput)
tx = optax.adam(learningrate)
return trainstate.TrainState.create(
applyfn=model.apply,
params=variables['params'],
tx=tx
)
@jax.jit
def trainstep(state, batch, dropoutkey):
"""Training step dengan Flax dan Optax."""
images, labels = batch
def lossfn(params):
logits = state.applyfn(
{'params': params},
images,
training=True,
rngs={'dropout': dropoutkey}
)
onehot = jax.nn.onehot(labels, 10)
loss = optax.softmaxcrossentropy(logits, onehot).mean()
return loss, logits
gradfn = jax.valueandgrad(lossfn, hasaux=True)
(loss, logits), grads = gradfn(state.params)
state = state.applygradients(grads=grads)
accuracy = jnp.mean(jnp.argmax(logits, axis=-1) == labels)
return state, loss, accuracy
@jax.jit
def evalstep(state, batch):
"""Evaluation step."""
images, labels = batch
logits = state.applyfn(
{'params': state.params},
images,
training=False
)
accuracy = jnp.mean(jnp.argmax(logits, axis=-1) == labels)
return accuracy
Setup
model = CNN(numclasses=10)
key = jax.random.PRNGKey(42)
state = createtrainstate(key, learningrate=1e-3, model=model)
print(f"Model parameters: {sum(p.size for p in jax.tree.leaves(state.params)):,}")
Custom Gradient dan Checkpointing
Untuk model yang sangat besar, Anda bisa menggunakan gradient checkpointing untuk menghemat memori:
import jax
import jax.numpy as jnp
from jax import checkpoint
def heavycomputation(x):
"""Fungsi dengan banyak intermediate values."""
for in range(10):
x = jnp.tanh(x @ jnp.ones((x.shape[-1], x.shape[-1])) 0.1)
return jnp.sum(x * 2)
Dengan checkpointing (hemat memori, sedikit lebih lambat)
checkpointedfn = checkpoint(heavycomputation)
key = jax.random.PRNGKey(0)
x = jax.random.normal(key, (100, 100))
gradnormal = jax.grad(heavycomputation)(x)
gradcheckpointed = jax.grad(checkpointedfn)(x)
print(f"Gradients match: {jnp.allclose(gradnormal, gradcheckpointed)}")
Custom JVP dan VJP
JAX memungkinkan Anda mendefinisikan custom forward-mode (JVP) dan reverse-mode (VJP) differentiation rules:
import jax
import jax.numpy as jnp
from jax import customjvp
@customjvp
def safelog(x):
"""Logaritma yang aman secara numerik."""
return jnp.log(x)
@safelog.defjvp
def safelogjvp(primals, tangents):
x, = primals
t, = tangents
# Clamp gradient untuk menghindari exploding gradients
safex = jnp.maximum(x, 1e-7)
return jnp.log(safex), t / safex
Test
x = jnp.array(0.0001)
print(f"safelog(x) = {safelog(x)}")
print(f"grad safelog(x) = {jax.grad(safelog)(x)}")
PyTree dan Nested Structures
JAX bekerja secara native dengan struktur data nested (pytrees):
import jax
import jax.numpy as jnp
Parameter model sebagai nested dict
params = {
'layer1': {
'weights': jnp.ones((3, 4)),
'bias': jnp.zeros(4)
},
'layer2': {
'weights': jnp.ones((4, 2)),
'bias': jnp.zeros(2)
}
}
treemap: apply fungsi ke semua leaves
scaledparams = jax.tree.map(lambda x: x 0.1, params)
print(f"Scaled weights: {scaledparams['layer1']['weights'][0]}")
treemap dengan multiple trees
grads = jax.tree.map(jnp.oneslike, params) # Dummy gradients
lr = 0.01
updatedparams = jax.tree.map(
lambda p, g: p - lr g,
params, grads
)
Informasi tentang tree structure
leaves = jax.tree.leaves(params)
print(f"Number of parameter arrays: {len(leaves)}")
totalparams = sum(l.size for l in leaves)
print(f"Total parameters: {totalparams}")
Scan: Efficient Loops
jax.lax.scan menggantikan Python loop dengan operasi yang bisa dikompilasi JIT:
import jax
import jax.numpy as jnp
RNN-style computation menggunakan scan
def rnnstep(carry, x):
"""Satu step RNN."""
h = carry
Wh, Wx, b = jnp.split(jnp.ones(15), [5, 10]) # Simplified
hnew = jnp.tanh(h 0.5 + x 0.3 + 0.1)
return hnew, hnew # (newcarry, output)
Inisialisasi
h0 = jnp.zeros(5)
xs = jax.random.normal(jax.random.PRNGKey(0), (20, 5)) # Sequence length 20
Jalankan scan
finalh, allh = jax.lax.scan(rnnstep, h0, xs)
print(f"Final hidden state shape: {finalh.shape}")
print(f"All hidden states shape: {allh.shape}")
Cumulative sum menggunakan scan
def cumsumstep(carry, x):
newcarry = carry + x
return newcarry, newcarry
, cumulative = jax.lax.scan(cumsumstep, 0.0, jnp.array([1., 2., 3., 4., 5.]))
print(f"Cumulative sum: {cumulative}")
Best Practices
1. Gunakan jax.jit untuk Fungsi yang Dipanggil Berulang
# Baik: JIT pada level yang tepat
@jax.jit
def trainstep(params, batch):
loss, grads = jax.valueandgrad(lossfn)(params, batch)
return updateparams(params, grads), loss
Kurang baik: JIT terlalu granular
def trainstep(params, batch):
loss = jax.jit(lossfn)(params, batch) # Overhead kompilasi tiap call
grads = jax.jit(jax.grad(lossfn))(params, batch)
return updateparams(params, grads), loss
2. Hindari Python Control Flow di Dalam JIT
# Buruk: Python if di dalam jit
@jax.jit
def badfn(x):
if x > 0: # Error! x adalah traced value
return x
return -x
Baik: Gunakan jnp.where
@jax.jit
def goodfn(x):
return jnp.where(x > 0, x, -x)
Atau gunakan lax.cond untuk conditional yang kompleks
@jax.jit
def complexcond(x):
return jax.lax.cond(
x > 0,
lambda x: jnp.sin(x),
lambda x: jnp.cos(x),
x
)
3. Kelola PRNG Key dengan Benar
# Buruk: Reuse key yang sama
key = jax.random.PRNGKey(0)
a = jax.random.normal(key, (3,))
b = jax.random.normal(key, (3,)) # Sama dengan a!
Baik: Split key setiap kali
key = jax.random.PRNGKey(0)
key, k1, k2 = jax.random.split(key, 3)
a = jax.random.normal(k1, (3,))
b = jax.random.normal(k2, (3,)) # Berbeda dari a
4. Gunakan donateargnums untuk Menghemat Memori
@jax.jit
def update(params, grads):
return jax.tree.map(lambda p, g: p - 0.01 g, params, grads)
Dengan donate: buffer input di-reuse untuk output
updatedonated = jax.jit(update, donateargnums=(0,))
5. Profile dan Debug
# Cek apakah fungsi sudah ter-compile
from jax import makejaxpr
def myfn(x, y):
return jnp.dot(x, y) + jnp.sin(x)
Lihat representasi intermediate (jaxpr)
x = jnp.ones((3, 3))
y = jnp.ones((3, 3))
print(jax.makejaxpr(myfn)(x, y))
Profiling dengan jax.profiler
jax.profiler.starttrace("/tmp/jax-trace")
... run code ...
jax.profiler.stoptrace()
6. Batching Data dengan jax.vmap
# Daripada loop manual:
def processone(x):
return jnp.sum(x 2)
Vmap lebih efisien dan bisa di-JIT
processbatch = jax.vmap(processone)
batch = jax.random.normal(jax.random.PRNGKey(0), (100, 10))
results = processbatch(batch)
Tips Performa
.blockuntilready() saat benchmarking karena JAX menggunakan asynchronous dispatch.jnp.float32 sebagai default. Gunakan jnp.bfloat16 untuk training yang lebih cepat di TPU.jax.lax.scan daripada Python loop untuk sequence processing.Perbandingan JAX vs PyTorch vs TensorFlow
| Aspek | JAX | PyTorch | TensorFlow |
|-------|-----|---------|------------|
| Paradigma | Functional | Imperative (OOP) | Graph-based / Eager |
| Auto-diff | jax.grad (functional) | loss.backward() | tf.GradientTape |
| Compilation | jax.jit (XLA) | torch.compile | tf.function (XLA) |
| GPU Support | Native via XLA | Native CUDA | Native via XLA |
| TPU Support | Native | Limited | Native |
| Learning Curve | Medium | Low | Medium-High |
| Ekosistem | Flax, Optax, Orbax | torchvision, HuggingFace | Keras, TF Hub |
Kesimpulan
JAX memberikan kombinasi unik antara kemudahan penggunaan (API NumPy yang familiar), performa tinggi (kompilasi XLA), dan fleksibilitas (transformasi fungsi composable). Beberapa poin penting yang perlu diingat:
jax.numpy sebagai pengganti NumPy untuk mendapatkan akselerasi hardware secara gratis.jax.grad untuk diferensiasi otomatis yang bersih dan composable.jax.jit pada fungsi yang dipanggil berulang kali untuk speedup signifikan.jax.vmap untuk menghindari loop manual dan memvektorisasi komputasi.JAX sangat cocok untuk riset ML, training model besar, dan komputasi ilmiah yang membutuhkan performa tinggi. Dengan ekosistem yang terus berkembang, JAX menjadi salah satu pilihan framework ML paling kuat di industri saat ini.