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 evolusi besar dari framework deep learning paling populer di dunia. Dengan arsitekt...

By Ruby Abdullah · · tutorial
KerasDeep LearningTensorFlowJAXPyTorch

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/

│ └── modelconfig.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:

  • Multi-Backend: Satu kode untuk TensorFlow, JAX, dan PyTorch
  • keras.ops: Operasi numerik portable yang konsisten
  • Custom Layer dan Model: Fleksibilitas tinggi untuk arsitektur kustom
  • Transfer Learning: Akses mudah ke model pretrained
  • Mixed Precision: Training lebih cepat dengan presisi campuran
  • Callback System: Monitoring dan kontrol training yang matang
  • 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.

    Artikel Terkait

    TorchServe: Panduan Lengkap Deployment Model PyTorch ke Production

    TorchServe: Panduan Lengkap Deployment Model PyTorch ke Production Penulis: Ruby Abdullah Kategori: Tutorial Tags: PyTor...

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

    Tutorial PyTorch Geometric: Graph Neural Network dengan PyTorch

    Memulai dengan PyTorch Geometric: Graph Neural Network di PyTorch Sebagian besar machine learning bekerja pada grid (gam...

    Tutorial Lengkap Flower (flwr): Framework Federated Learning dengan Python

    Tutorial Lengkap Flower (flwr): Framework Federated Learning dengan Python Federated learning adalah paradigma machine l...