Tutorial Lengkap Keras 3: Framework Deep Learning Multi-Backend untuk TensorFlow, JAX, dan PyTorch
Keras 3 adalah evolusi besar dari framework deep learning paling populer di dunia. Dengan arsitektur multi-backend yang baru, Keras 3 memungkinkan Anda menulis kode sekali dan menjalankannya di atas TensorFlow, JAX, atau PyTorch tanpa perubahan. Tutorial ini akan memandu Anda dari instalasi hingga penggunaan lanjutan Keras 3 untuk membangun, melatih, dan men-deploy model deep learning.
Mengapa Keras 3?
Sebelum Keras 3, developer harus memilih satu framework dan terikat dengan ekosistemnya. Keras 3 mengubah paradigma ini dengan menawarkan beberapa keunggulan utama:
- Multi-Backend: Tulis model sekali, jalankan di TensorFlow, JAX, atau PyTorch
- API Konsisten: Satu API yang sama untuk semua backend, mengurangi learning curve
- Performa Optimal: Manfaatkan optimasi spesifik dari setiap backend
- Interoperabilitas: Gunakan komponen dari ekosistem backend manapun
- Backward Compatible: Kode Keras 2 sebagian besar tetap berjalan di Keras 3
Keras 3 sangat cocok untuk tim yang bekerja lintas framework, peneliti yang ingin membandingkan performa antar backend, dan engineer yang ingin menulis kode portable.
Instalasi
Persyaratan Sistem
- Python 3.9 atau lebih baru
- pip (package manager Python)
- GPU dengan CUDA support (opsional, untuk akselerasi training)
Instalasi Keras 3 dengan Berbagai Backend
# Instalasi Keras 3 core
pip install keras
Instalasi dengan backend TensorFlow
pip install keras tensorflow
Instalasi dengan backend JAX (CPU)
pip install keras jax jaxlib
Instalasi dengan backend JAX (GPU CUDA 12)
pip install keras "jax[cuda12]"
Instalasi dengan backend PyTorch
pip install keras torch torchvision
Konfigurasi Backend
Anda bisa mengatur backend default melalui environment variable atau file konfigurasi.
Metode 1: Environment Variable# Gunakan JAX sebagai backend
export KERASBACKEND=jax
Gunakan PyTorch sebagai backend
export KERASBACKEND=torch
Gunakan TensorFlow sebagai backend (default)
export KERASBACKEND=tensorflow
Metode 2: File Konfigurasi
Buat atau edit file ~/.keras/keras.json:
{
"backend": "jax",
"floatx": "float32",
"epsilon": 1e-07,
"imagedataformat": "channelslast"
}
Metode 3: Programmatic (di awal script)
import os
os.environ["KERASBACKEND"] = "jax"
import keras
print(f"Backend aktif: {keras.backend.backend()}")
Verifikasi Instalasi
import keras
print(f"Keras version: {keras.version}")
print(f"Backend: {keras.backend.backend()}")
Test sederhana
import keras.ops as ops
x = ops.ones((2, 3))
print(f"Tensor shape: {x.shape}")
print(f"Tensor:\n{x}")
Penggunaan Dasar
Membangun Model dengan Sequential API
Sequential API adalah cara paling sederhana untuk membangun model neural network layer-by-layer.
import keras
from keras import layers
model = keras.Sequential([
layers.Input(shape=(784,)),
layers.Dense(256, activation="relu"),
layers.Dropout(0.3),
layers.Dense(128, activation="relu"),
layers.Dropout(0.2),
layers.Dense(10, activation="softmax")
])
model.summary()
Membangun Model dengan Functional API
Functional API memberikan fleksibilitas lebih untuk arsitektur model yang kompleks, termasuk model dengan multiple input/output dan skip connections.
import keras
from keras import layers
Definisikan input
inputs = keras.Input(shape=(784,))
Hidden layers
x = layers.Dense(256, activation="relu")(inputs)
x = layers.BatchNormalization()(x)
x = layers.Dropout(0.3)(x)
x = layers.Dense(128, activation="relu")(x)
x = layers.BatchNormalization()(x)
x = layers.Dropout(0.2)(x)
Output layer
outputs = layers.Dense(10, activation="softmax")(x)
Buat model
model = keras.Model(inputs=inputs, outputs=outputs, name="mnistclassifier")
model.summary()
Compile dan Training Model
import keras
from keras import layers
import numpy as np
Buat model sederhana
model = keras.Sequential([
layers.Input(shape=(784,)),
layers.Dense(128, activation="relu"),
layers.Dense(10, activation="softmax")
])
Compile model
model.compile(
optimizer=keras.optimizers.Adam(learningrate=0.001),
loss="categoricalcrossentropy",
metrics=["accuracy"]
)
Buat data dummy untuk demonstrasi
xtrain = np.random.random((1000, 784)).astype("float32")
ytrain = keras.utils.tocategorical(
np.random.randint(10, size=(1000,)), numclasses=10
)
xval = np.random.random((200, 784)).astype("float32")
yval = keras.utils.tocategorical(
np.random.randint(10, size=(200,)), numclasses=10
)
Training
history = model.fit(
xtrain, ytrain,
batchsize=32,
epochs=10,
validationdata=(xval, yval),
verbose=1
)
Klasifikasi Gambar dengan MNIST
Contoh lengkap klasifikasi digit MNIST menggunakan Convolutional Neural Network:
import keras
from keras import layers
import numpy as np
Load dataset MNIST
(xtrain, ytrain), (xtest, ytest) = keras.datasets.mnist.loaddata()
Preprocessing
xtrain = xtrain.astype("float32") / 255.0
xtest = xtest.astype("float32") / 255.0
Tambahkan dimensi channel
xtrain = np.expanddims(xtrain, -1)
xtest = np.expanddims(xtest, -1)
One-hot encode labels
ytrain = keras.utils.tocategorical(ytrain, 10)
ytest = keras.utils.tocategorical(ytest, 10)
print(f"Training data shape: {xtrain.shape}")
print(f"Test data shape: {xtest.shape}")
Buat model CNN
model = keras.Sequential([
layers.Input(shape=(28, 28, 1)),
layers.Conv2D(32, kernelsize=(3, 3), activation="relu"),
layers.MaxPooling2D(poolsize=(2, 2)),
layers.Conv2D(64, kernelsize=(3, 3), activation="relu"),
layers.MaxPooling2D(poolsize=(2, 2)),
layers.Flatten(),
layers.Dropout(0.5),
layers.Dense(10, activation="softmax")
])
model.compile(
optimizer="adam",
loss="categoricalcrossentropy",
metrics=["accuracy"]
)
Training
history = model.fit(
xtrain, ytrain,
batchsize=128,
epochs=5,
validationsplit=0.1
)
Evaluasi
testloss, testacc = model.evaluate(xtest, ytest, verbose=0)
print(f"\nTest accuracy: {testacc:.4f}")
Penggunaan Lanjutan
Custom Training Loop dengan keras.ops
Keras 3 memperkenalkan keras.ops, modul operasi numerik yang bekerja di semua backend. Ini memungkinkan Anda menulis custom training loop yang portable.
import keras
from keras import layers, ops
model = keras.Sequential([
layers.Input(shape=(784,)),
layers.Dense(128, activation="relu"),
layers.Dense(10, activation="softmax")
])
optimizer = keras.optimizers.Adam(learningrate=0.001)
lossfn = keras.losses.CategoricalCrossentropy()
Custom training step
def trainstep(model, x, y):
# Forward pass dengan gradient tracking
with keras.backend.GradientTape() as tape:
predictions = model(x, training=True)
loss = lossfn(y, predictions)
# Backward pass
gradients = tape.gradient(loss, model.trainableweights)
optimizer.apply(gradients, model.trainableweights)
return loss
Custom training loop
import numpy as np
xtrain = np.random.random((1000, 784)).astype("float32")
ytrain = keras.utils.tocategorical(
np.random.randint(10, size=(1000,)), numclasses=10
)
batchsize = 32
epochs = 5
for epoch in range(epochs):
epochloss = 0
numbatches = 0
for i in range(0, len(xtrain), batchsize):
xbatch = xtrain[i:i + batchsize]
ybatch = ytrain[i:i + batchsize]
loss = trainstep(model, xbatch, ybatch)
epochloss += float(loss)
numbatches += 1
avgloss = epochloss / numbatches
print(f"Epoch {epoch + 1}/{epochs}, Loss: {avgloss:.4f}")
Custom Layer
Anda bisa membuat layer kustom dengan mewarisi keras.layers.Layer:
import keras
from keras import layers, ops
class AttentionLayer(keras.layers.Layer):
def init(self, units, kwargs):
super().init(kwargs)
self.units = units
def build(self, inputshape):
self.W = self.addweight(
shape=(inputshape[-1], self.units),
initializer="glorotuniform",
trainable=True,
name="attentionweight"
)
self.b = self.addweight(
shape=(self.units,),
initializer="zeros",
trainable=True,
name="attentionbias"
)
self.u = self.addweight(
shape=(self.units,),
initializer="glorotuniform",
trainable=True,
name="contextvector"
)
def call(self, inputs):
# inputs shape: (batchsize, seqlen, features)
score = ops.tanh(ops.matmul(inputs, self.W) + self.b)
attentionweights = ops.softmax(
ops.matmul(score, ops.expanddims(self.u, axis=-1)),
axis=1
)
contextvector = ops.sum(inputs attentionweights, axis=1)
return contextvector
def getconfig(self):
config = super().getconfig()
config.update({"units": self.units})
return config
Gunakan custom layer dalam model
model = keras.Sequential([
layers.Input(shape=(50, 128)),
AttentionLayer(64),
layers.Dense(32, activation="relu"),
layers.Dense(1, activation="sigmoid")
])
model.summary()
Custom Model dengan Subclassing
Untuk kontrol penuh, Anda bisa membuat model dengan subclassing:
import keras
from keras import layers, ops
class VariationalAutoEncoder(keras.Model):
def init(self, latentdim, kwargs):
super().init(kwargs)
self.latentdim = latentdim
# Encoder
self.encoderdense1 = layers.Dense(256, activation="relu")
self.encoderdense2 = layers.Dense(128, activation="relu")
self.zmeanlayer = layers.Dense(latentdim)
self.zlogvarlayer = layers.Dense(latentdim)
# Decoder
self.decoderdense1 = layers.Dense(128, activation="relu")
self.decoderdense2 = layers.Dense(256, activation="relu")
self.decoderoutput = layers.Dense(784, activation="sigmoid")
def encode(self, x):
x = self.encoderdense1(x)
x = self.encoderdense2(x)
zmean = self.zmeanlayer(x)
zlogvar = self.zlogvarlayer(x)
return zmean, zlogvar
def reparameterize(self, zmean, zlogvar):
epsilon = keras.random.normal(shape=ops.shape(zmean))
return zmean + ops.exp(0.5 zlogvar) epsilon
def decode(self, z):
x = self.decoderdense1(z)
x = self.decoderdense2(x)
return self.decoderoutput(x)
def call(self, inputs):
zmean, zlogvar = self.encode(inputs)
z = self.reparameterize(zmean, zlogvar)
reconstructed = self.decode(z)
# KL divergence loss
klloss = -0.5 ops.mean(
1 + zlogvar - ops.square(zmean) - ops.exp(zlogvar)
)
self.addloss(klloss)
return reconstructed
Buat dan compile VAE
vae = VariationalAutoEncoder(latentdim=32)
vae.compile(
optimizer="adam",
loss="binarycrossentropy"
)
Menggunakan keras.ops untuk Operasi Portable
keras.ops adalah modul kunci di Keras 3 yang menyediakan operasi numerik portable:
import keras
from keras import ops
Operasi dasar
a = ops.array([1.0, 2.0, 3.0])
b = ops.array([4.0, 5.0, 6.0])
print(f"Penjumlahan: {ops.add(a, b)}")
print(f"Dot product: {ops.dot(a, b)}")
print(f"Mean: {ops.mean(a)}")
print(f"Std: {ops.std(a)}")
Operasi matriks
matrix = ops.array([[1.0, 2.0], [3.0, 4.0]])
print(f"Transpose:\n{ops.transpose(matrix)}")
print(f"Determinant: {ops.linalg.det(matrix)}")
Operasi neural network
logits = ops.array([2.0, 1.0, 0.1])
print(f"Softmax: {ops.softmax(logits)}")
print(f"ReLU: {ops.relu(ops.array([-1.0, 0.0, 1.0, 2.0]))}")
Operasi random (seeded untuk reproducibility)
keras.utils.setrandomseed(42)
randomtensor = keras.random.normal(shape=(3, 3))
print(f"Random tensor:\n{randomtensor}")
Transfer Learning dengan Pretrained Models
Keras 3 menyediakan banyak model pretrained melalui keras.applications:
import keras
from keras import layers
import numpy as np
Load pretrained model (tanpa top layer)
basemodel = keras.applications.EfficientNetV2B0(
weights="imagenet",
includetop=False,
inputshape=(224, 224, 3)
)
Freeze base model
basemodel.trainable = False
Buat model baru untuk fine-tuning
model = keras.Sequential([
basemodel,
layers.GlobalAveragePooling2D(),
layers.Dropout(0.3),
layers.Dense(256, activation="relu"),
layers.Dropout(0.2),
layers.Dense(5, activation="softmax")
])
model.compile(
optimizer=keras.optimizers.Adam(learningrate=0.001),
loss="categoricalcrossentropy",
metrics=["accuracy"]
)
model.summary()
Fine-tuning: unfreeze beberapa layer terakhir
basemodel.trainable = True
for layer in basemodel.layers[:-20]:
layer.trainable = False
Re-compile dengan learning rate lebih kecil
model.compile(
optimizer=keras.optimizers.Adam(learningrate=1e-5),
loss="categoricalcrossentropy",
metrics=["accuracy"]
)
Callbacks dan Monitoring
Keras 3 menyediakan berbagai callback untuk monitoring dan kontrol training:
import keras
from keras import layers
import numpy as np
model = keras.Sequential([
layers.Input(shape=(784,)),
layers.Dense(128, activation="relu"),
layers.Dense(10, activation="softmax")
])
model.compile(
optimizer="adam",
loss="categoricalcrossentropy",
metrics=["accuracy"]
)
Definisikan callbacks
callbacks = [
keras.callbacks.EarlyStopping(
monitor="valloss",
patience=5,
restorebestweights=True,
verbose=1
),
keras.callbacks.ReduceLROnPlateau(
monitor="valloss",
factor=0.5,
patience=3,
minlr=1e-7,
verbose=1
),
keras.callbacks.ModelCheckpoint(
filepath="bestmodel.keras",
monitor="valaccuracy",
savebestonly=True,
verbose=1
),
keras.callbacks.TensorBoard(
logdir="./logs",
histogramfreq=1
)
]
Training dengan data dummy
xtrain = np.random.random((1000, 784)).astype("float32")
ytrain = keras.utils.tocategorical(
np.random.randint(10, size=(1000,)), numclasses=10
)
history = model.fit(
xtrain, ytrain,
batchsize=32,
epochs=50,
validationsplit=0.2,
callbacks=callbacks
)
Multi-Backend Benchmarking
Salah satu fitur paling powerful dari Keras 3 adalah kemampuan untuk membandingkan performa model di berbagai backend:
import os
import time
import numpy as np
def benchmarkbackend(backendname, epochs=5):
os.environ["KERASBACKEND"] = backendname
# Reload keras dengan backend baru
import importlib
import keras
importlib.reload(keras)
from keras import layers
# Buat model
model = keras.Sequential([
layers.Input(shape=(28, 28, 1)),
layers.Conv2D(32, (3, 3), activation="relu"),
layers.MaxPooling2D((2, 2)),
layers.Conv2D(64, (3, 3), activation="relu"),
layers.MaxPooling2D((2, 2)),
layers.Flatten(),
layers.Dense(64, activation="relu"),
layers.Dense(10, activation="softmax")
])
model.compile(
optimizer="adam",
loss="categoricalcrossentropy",
metrics=["accuracy"]
)
# Generate data
x = np.random.random((5000, 28, 28, 1)).astype("float32")
y = keras.utils.tocategorical(
np.random.randint(10, size=(5000,)), numclasses=10
)
# Benchmark
starttime = time.time()
model.fit(x, y, batchsize=64, epochs=epochs, verbose=0)
elapsed = time.time() - starttime
print(f"{backendname}: {elapsed:.2f} detik untuk {epochs} epochs")
return elapsed
Jalankan benchmark (uncomment backend yang terinstall)
benchmarkbackend("tensorflow")
benchmarkbackend("jax")
benchmarkbackend("torch")
Menyimpan dan Memuat Model
Keras 3 mendukung beberapa format penyimpanan:
import keras
Format Keras native (direkomendasikan)
model.save("mymodel.keras")
loadedmodel = keras.saving.loadmodel("mymodel.keras")
Export ke format SavedModel (TensorFlow serving)
Hanya tersedia dengan backend TensorFlow
model.export("savedmodeldir", format="tfsavedmodel")
Simpan hanya weights
model.saveweights("modelweights.weights.h5")
model.loadweights("modelweights.weights.h5")
Simpan dan load arsitektur saja (JSON)
jsonconfig = model.tojson()
newmodel = keras.models.modelfromjson(jsonconfig)
Data Pipeline dengan keras.utils
import keras
from keras import layers
import numpy as np
Image data augmentation
dataaugmentation = keras.Sequential([
layers.RandomFlip("horizontal"),
layers.RandomRotation(0.1),
layers.RandomZoom(0.1),
layers.RandomContrast(0.1),
])
Preprocessing layer
preprocessing = keras.Sequential([
layers.Rescaling(1.0 / 255),
layers.Resizing(224, 224),
])
Gabungkan dalam model
model = keras.Sequential([
layers.Input(shape=(None, None, 3)),
dataaugmentation,
preprocessing,
keras.applications.MobileNetV3Small(
weights="imagenet",
includetop=False
),
layers.GlobalAveragePooling2D(),
layers.Dense(128, activation="relu"),
layers.Dense(10, activation="softmax")
])
Best Practices
1. Pemilihan Backend
Setiap backend memiliki kekuatan masing-masing:
| Backend | Kelebihan | Cocok Untuk |
|---------|-----------|-------------|
| TensorFlow | Ekosistem deployment matang (TFLite, TF Serving) | Production deployment, mobile |
| JAX | Performa JIT compilation tinggi, auto-differentiation | Riset, training skala besar |
| PyTorch | Debugging mudah, eager execution, komunitas riset besar | Prototyping, riset |
2. Gunakan keras.ops untuk Portabilitas
Selalu gunakan keras.ops sebagai pengganti operasi backend-specific:
# Baik - portable antar backend
import keras.ops as ops
result = ops.matmul(a, b)
Hindari - terikat pada satu backend
import torch
result = torch.matmul(a, b)
3. Mixed Precision Training
import keras
Aktifkan mixed precision untuk training lebih cepat
keras.mixedprecision.setglobalpolicy("mixedfloat16")
model = keras.Sequential([
keras.layers.Input(shape=(784,)),
keras.layers.Dense(256, activation="relu"),
keras.layers.Dense(10, activation="softmax",
dtype="float32") # Output tetap float32
])
4. Seed untuk Reproducibility
import keras
keras.utils.setrandomseed(42)
Untuk JAX backend, pastikan juga:
export XLAFLAGS=--xlagpudeterministicops=true
5. Profiling dan Optimasi
import keras
import time
Gunakan keras.utils.Progbar untuk monitoring manual
progbar = keras.utils.Progbar(target=100)
for i in range(100):
time.sleep(0.01)
progbar.update(i + 1, values=[("loss", 0.5 - i * 0.005)])
6. Struktur Proyek yang Direkomendasikan
myproject/
├── configs/
│ └── model
config.py
├── data/
│ └── preprocessing.py
├── models/
│ ├── init.py
│ ├── basemodel.py
│ └── customlayers.py
├── training/
│ ├── train.py
│ └── callbacks.py
├── evaluation/
│ └── evaluate.py
├── requirements.txt
└── README.md
Migrasi dari Keras 2 ke Keras 3
Jika Anda memiliki kode Keras 2, berikut perubahan utama yang perlu diperhatikan:
# Keras 2 (lama)
from tensorflow import keras
from tensorflow.keras import layers
Keras 3 (baru)
import keras
from keras import layers
Keras 2: tf.keras.backend.xxx
import tensorflow.keras.backend as K
result = K.sum(x)
Keras 3: keras.ops.xxx
from keras import ops
result = ops.sum(x)
Keras 2: model.save("model.h5")
Keras 3: model.save("model.keras") # format baru
Kesimpulan
Keras 3 adalah lompatan besar dalam ekosistem deep learning. Dengan arsitektur multi-backend, Anda mendapatkan fleksibilitas untuk memilih backend terbaik sesuai kebutuhan tanpa harus menulis ulang kode. Fitur-fitur utama yang membuat Keras 3 layak dipelajari:
Keras 3 cocok untuk semua level developer, mulai dari pemula yang baru belajar deep learning hingga engineer yang membangun sistem production. Dengan ekosistem yang terus berkembang dan komunitas yang aktif, Keras 3 adalah pilihan yang solid untuk proyek deep learning Anda berikutnya.
Untuk informasi lebih lanjut, kunjungi dokumentasi resmi Keras di keras.io dan eksplorasi contoh-contoh model di repository GitHub resmi Keras.