Tutorial Lengkap JAX: Framework Machine Learning Berkinerja Tinggi dari Google

# 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...

By Ruby Abdullah · · tutorial
JAXMachine LearningGoogleXLADeep Learning

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.numpy hampir identik dengan NumPy, sehingga kurva belajarnya sangat rendah bagi pengguna Python yang sudah familiar dengan ekosistem ilmiah.
  • Diferensiasi Otomatis: Fungsi jax.grad memungkinkan 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.vmap memungkinkan vektorisasi otomatis fungsi tanpa menulis loop manual.
  • Paralelisasi: jax.pmap menyediakan 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

  • Selalu panggil .blockuntilready() saat benchmarking karena JAX menggunakan asynchronous dispatch.
  • Hindari transfer data berulang antara host (CPU) dan device (GPU/TPU). Lakukan semua komputasi di device.
  • Gunakan jnp.float32 sebagai default. Gunakan jnp.bfloat16 untuk training yang lebih cepat di TPU.
  • Batch operasi kecil menjadi satu operasi besar untuk memaksimalkan throughput GPU/TPU.
  • Gunakan 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:

  • Mulai dengan jax.numpy sebagai pengganti NumPy untuk mendapatkan akselerasi hardware secara gratis.
  • Gunakan jax.grad untuk diferensiasi otomatis yang bersih dan composable.
  • Terapkan jax.jit pada fungsi yang dipanggil berulang kali untuk speedup signifikan.
  • Manfaatkan jax.vmap untuk menghindari loop manual dan memvektorisasi komputasi.
  • Gunakan Flax + Optax untuk proyek neural network yang lebih terstruktur.
  • Perhatikan immutability** dan PRNG key management sebagai dua perbedaan utama dari NumPy.
  • 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.

    Artikel Terkait

    Tutorial Lengkap Keras 3: Framework Deep Learning Multi-Backend untuk TensorFlow, JAX, dan PyTorch

    Tutorial Lengkap Keras 3: Framework Deep Learning Multi-Backend untuk TensorFlow, JAX, dan PyTorch Keras 3 adalah evolus...

    Panduan Lengkap PyTorch Lightning: Deep Learning Made Simple

    Panduan Lengkap PyTorch Lightning: Deep Learning Made Simple PyTorch Lightning adalah framework high-level untuk PyTorch...

    AutoGluon: Tutorial Lengkap Library AutoML dari AWS untuk Machine Learning Otomatis

    Tutorial Lengkap AutoGluon: Library AutoML dari AWS untuk Machine Learning Otomatis AutoGluon adalah library open-source...

    Tutorial Lengkap LM Evaluation Harness: Framework Standar untuk Evaluasi Model Bahasa Besar

    Tutorial Lengkap LM Evaluation Harness: Framework Standar untuk Evaluasi Model Bahasa Besar Evaluasi model bahasa besar ...