Neural Machine Translation (NMT) telah merevolusi cara kita mendekati tugas penerjemahan mesin, beralih dari model statistik tradisional ke pendekatan berbasis deep learning yang mampu menangkap nuansa dan konteks bahasa secara lebih baik. Inti dari banyak model NMT awal dan beberapa sistem modern adalah arsitektur Sequence-to-Sequence (Seq2Seq). Arsitektur ini memetakan satu urutan (kalimat sumber) ke urutan lain (kalimat target) menggunakan jaringan saraf tiruan. Panduan ini akan menjadi tutorial NMT Keras TensorFlow yang lengkap untuk Anda.
Apa Itu Neural Machine Translation (NMT)?
Machine Translation (MT) adalah bidang komputasi linguistik yang berfokus pada penggunaan perangkat lunak untuk menerjemahkan teks atau ucapan dari satu bahasa ke bahasa lain. Pendekatan awal sangat bergantung pada aturan linguistik atau model statistik berbasis frasa. Namun, kemunculan deep learning melahirkan Neural Machine Translation (NMT). NMT menggunakan jaringan saraf tiruan, sering kali berupa Recurrent Neural Networks (RNN) atau Transformer, untuk membangun model tunggal yang dapat dilatih secara end-to-end. Keunggulan utama NMT meliputi kemampuan menghasilkan terjemahan yang lebih lancar, menangani dependensi jarak jauh dalam kalimat, dan memanfaatkan konteks dengan lebih baik dibandingkan metode sebelumnya.
Secara sederhana, Neural Machine Translation (NMT) adalah pendekatan untuk machine translation yang menggunakan arsitektur jaringan saraf tiruan besar untuk memprediksi kemungkinan urutan kata, biasanya memodelkan seluruh kalimat dalam satu model terintegrasi. Model ini belajar memetakan representasi makna dari kalimat sumber ke kalimat target yang sesuai.
Arsitektur Dasar NMT Seq2Seq Encoder-Decoder
Arsitektur Sequence-to-Sequence (Seq2Seq) adalah kerangka kerja umum untuk NMT. Ini terdiri dari dua komponen utama (arsitektur encoder decoder nmt):
- Encoder: Komponen ini membaca dan memproses seluruh kalimat masukan (urutan sumber). Biasanya berupa RNN (seperti LSTM atau GRU), Encoder mengompresi informasi dari urutan masukan menjadi representasi vektor berdimensi tetap yang disebut context vector (atau thought vector). Vektor ini diharapkan menangkap esensi makna dari kalimat sumber.
- Decoder: Komponen ini mengambil context vector yang dihasilkan oleh Encoder dan, langkah demi langkah, menghasilkan urutan keluaran (kalimat target). Decoder juga biasanya berupa RNN yang dilatih untuk memprediksi kata berikutnya dalam urutan target, dengan kondisi pada context vector dan kata-kata yang telah dihasilkan sebelumnya.
Implementasi arsitektur ini sering menggunakan Python, menjadikannya topik populer terkait model seq2seq python.
Tujuan Tutorial Membangun Model NMT Keras TensorFlow
Tutorial ini bertujuan memandu Anda melalui langkah-langkah membangun model nmt keras tensorflow yang sederhana. Kita akan menggunakan arsitektur Encoder-Decoder dasar dengan Long Short-Term Memory (LSTM) di Keras, yang berjalan di atas TensorFlow. Kita akan mencakup seluruh proses, mulai dari persiapan data, pembangunan model, pelatihan, hingga inferensi untuk menerjemahkan kalimat baru. Meskipun model ini sederhana, ia akan memberikan fondasi pemahaman yang kuat tentang cara membuat model nmt sederhana dan cara kerja NMT secara umum.
Prasyarat Mengikuti Tutorial NMT Ini
Sebelum memulai, pastikan Anda memiliki:
- Pengetahuan dasar tentang bahasa pemrograman Python.
- Pemahaman dasar tentang konsep Machine Learning dan Deep Learning (terutama RNN/LSTM).
- Sedikit familiaritas dengan library TensorFlow dan Keras.
- Lingkungan Python (misalnya, melalui Anaconda, venv) tempat Anda dapat menginstal library.
Langkah 1: Persiapan Lingkungan & Dataset NMT
Langkah pertama adalah menyiapkan lingkungan pengembangan Anda dan mendapatkan dataset yang cocok untuk tugas penerjemahan mesin keras tensorflow.
Instalasi Library TensorFlow & Pendukung
Kita akan membutuhkan library tensorflow (yang menyertakan Keras) dan numpy untuk manipulasi numerik. Anda dapat menginstalnya menggunakan pip:
pip install tensorflow numpy
Jika Anda menggunakan scikit-learn untuk membagi data, instal juga:
pip install scikit-learn
Memilih & Mengunduh Dataset Paralel (Inggris-Indonesia)
Model NMT memerlukan dataset paralel, yaitu kumpulan kalimat dalam bahasa sumber yang dipasangkan dengan terjemahannya yang benar dalam bahasa target. Sumber populer termasuk:
- Dataset dari Tatoeba Project (digunakan di Anki): Menyediakan banyak pasangan kalimat untuk berbagai bahasa.
- OPUS (Open Parallel Corpus): Kumpulan besar data paralel dari berbagai sumber.
Untuk tutorial ini, kita akan menggunakan dataset sederhana Inggris-Indonesia. Anda bisa mengunduh file ind.txt dari koleksi data Tatoeba (misalnya, dari http://www.manythings.org/anki/). File ini biasanya berisi pasangan kalimat yang dipisahkan oleh tab (\t), satu pasangan per baris.
Misalkan Anda telah mengunduh dan menyimpan file tersebut sebagai ind.txt di direktori kerja Anda.
Memuat & Memahami Struktur Dataset
Mari kita muat data dari file .txt dan lihat beberapa contoh.
import numpy as np
import tensorflow as tf
import re
import time
# Path ke file dataset
data_path = 'ind.txt' # Ganti dengan path file Anda jika berbeda
# Membaca file dan memisahkan pasangan kalimat
lines = open(data_path, encoding='UTF-8').read().strip().split('\n')
sentence_pairs = []
for line in lines:
parts = line.split('\t')
if len(parts) >= 2: # Pastikan ada setidaknya dua bagian (Eng, Ind)
# Ambil bagian Inggris dan Indonesia saja
sentence_pairs.append((parts[0], parts[1]))
print(f"Jumlah pasangan kalimat: {len(sentence_pairs)}")
# Tampilkan beberapa contoh
for i in range(5):
print(f"Sumber (Eng): {sentence_pairs[i][0]}")
print(f"Target (Ind): {sentence_pairs[i][1]}\n")
# Opsional: Batasi ukuran dataset untuk training cepat (hapus jika ingin menggunakan semua data)
num_samples = 10000 # Misalnya, kita gunakan 10 ribu sampel pertama
sentence_pairs = sentence_pairs[:num_samples]
print(f"Menggunakan {len(sentence_pairs)} sampel untuk tutorial ini.")
Langkah 2: Preprocessing & Persiapan Data NMT
Data teks mentah perlu dibersihkan dan diubah menjadi format numerik yang dapat dipahami oleh model NMT. Tahap persiapan data nmt ini sangat krusial untuk keberhasilan model.
Pembersihan Teks Sumber dan Target
Kita akan melakukan pembersihan dasar: konversi ke huruf kecil dan menghapus karakter yang tidak diinginkan (kecuali spasi, huruf, angka, dan tanda baca dasar yang mungkin relevan).
def preprocess_sentence(sentence):
sentence = sentence.lower().strip()
# Membuat spasi antara kata dan tanda baca seperti ., ! ?
sentence = re.sub(r"([?.!,])", r" \1 ", sentence)
# Mengganti beberapa spasi dengan satu spasi
sentence = re.sub(r'[" "]+', " ", sentence)
# Menghapus karakter selain huruf, angka, spasi, dan tanda baca dasar
# (Sesuaikan regex ini sesuai kebutuhan dataset Anda)
# sentence = re.sub(r"[^a-zA-Z?.!,]+", " ", sentence) # Contoh untuk English
# Untuk Indonesia, mungkin perlu karakter lain atau pendekatan berbeda
sentence = sentence.strip()
# Menambahkan token START dan END (akan dilakukan terpisah untuk target)
return sentence
# Terapkan preprocessing pada pasangan kalimat
input_texts = [preprocess_sentence(pair[0]) for pair in sentence_pairs]
target_texts_raw = [preprocess_sentence(pair[1]) for pair in sentence_pairs]
print("Contoh setelah preprocessing:")
print(f"Input: {input_texts[0]}")
print(f"Target: {target_texts_raw[0]}")
Menyiapkan Pasangan Kalimat Masukan-Keluaran
Pada tahap ini, variabel input_texts berisi daftar kalimat sumber yang sudah dibersihkan, dan target_texts_raw berisi daftar kalimat target yang sudah dibersihkan. Data ini sudah dalam format daftar pasangan yang sesuai untuk model Seq2Seq.
Menambahkan Token START dan END
Untuk proses decoding, kita perlu memberi tahu model kapan harus memulai (START) dan mengakhiri (END) generasi kalimat target. Kita akan menggunakan tab (\t) sebagai token START dan newline (\n) sebagai token END.
# Tambahkan token START dan END ke kalimat target
target_texts = ['\t' + text + '\n' for text in target_texts_raw]
print("\nContoh target dengan token START/END:")
print(target_texts[0])
Tokenisasi & Pembuatan Vocabulary (Masukan & Target)
Setelah pembersihan, kita ubah teks menjadi urutan angka (integer) menggunakan Tokenizer dari Keras. Ini akan membuat kamus kata (vocabulary) untuk bahasa sumber dan target.
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
# Tokenizer untuk bahasa sumber (Inggris)
input_tokenizer = Tokenizer(filters='') # Jangan filter apa pun karena sudah dibersihkan
input_tokenizer.fit_on_texts(input_texts)
input_sequences = input_tokenizer.texts_to_sequences(input_texts)
# Vocabulary sumber
input_word_index = input_tokenizer.word_index
num_encoder_tokens = len(input_word_index) + 1 # Tambah 1 untuk padding (index 0)
# Tokenizer untuk bahasa target (Indonesia)
target_tokenizer = Tokenizer(filters='') # Jangan filter \t dan \n
target_tokenizer.fit_on_texts(target_texts)
target_sequences = target_tokenizer.texts_to_sequences(target_texts)
# Vocabulary target
target_word_index = target_tokenizer.word_index
num_decoder_tokens = len(target_word_index) + 1 # Tambah 1 untuk padding (index 0)
print(f"\nUkuran vocabulary sumber: {num_encoder_tokens}")
print(f"Ukuran vocabulary target: {num_decoder_tokens}")
# Contoh mapping kata ke integer
print("Contoh mapping input:", list(input_word_index.items())[:5])
print("Contoh mapping target:", list(target_word_index.items())[:5])
Padding Sequence Agar Sama Panjang
Model jaringan saraf memerlukan masukan dengan panjang yang seragam dalam satu batch. Kita akan menambahkan padding (biasanya angka 0) di akhir setiap urutan agar semua memiliki panjang yang sama (panjang urutan terpanjang dalam data).
# Tentukan panjang maksimum (bisa dihitung dari data atau ditetapkan)
max_encoder_seq_length = max([len(seq) for seq in input_sequences])
max_decoder_seq_length = max([len(seq) for seq in target_sequences])
print(f"\nPanjang sequence input maks: {max_encoder_seq_length}")
print(f"Panjang sequence output maks: {max_decoder_seq_length}")
# Lakukan padding
encoder_input_data = pad_sequences(input_sequences, maxlen=max_encoder_seq_length, padding='post')
decoder_input_data = pad_sequences(target_sequences, maxlen=max_decoder_seq_length, padding='post')
# Persiapan data target untuk decoder (shifted one step)
# Keluaran decoder harus satu langkah di depan masukan decoder
# Misalnya, jika masukan decoder adalah "\t Mulai kalimat \n", targetnya adalah "Mulai kalimat \n 0"
decoder_target_data = np.zeros_like(decoder_input_data)
for i, seq in enumerate(target_sequences):
for t, token_index in enumerate(seq):
if t > 0: # Mulai dari token kedua
# decoder_target_data[i, t - 1] berisi token pada waktu t
decoder_target_data[i, t - 1] = token_index
print("\nBentuk data setelah padding:")
print("Encoder input shape:", encoder_input_data.shape)
print("Decoder input shape:", decoder_input_data.shape)
print("Decoder target shape:", decoder_target_data.shape)
print("\nContoh data numerik (setelah padding):")
print("Encoder input sample:", encoder_input_data[0][:15])
print("Decoder input sample:", decoder_input_data[0][:15])
print("Decoder target sample:", decoder_target_data[0][:15])
Membagi Data Training dan Validasi
Penting untuk memisahkan sebagian data sebagai set validasi (validation set). Ini digunakan untuk memantau kinerja model selama training dan membantu mencegah overfitting.
from sklearn.model_selection import train_test_split
# Membagi data menjadi training (80%) dan validation (20%)
encoder_input_train, encoder_input_val, \
decoder_input_train, decoder_input_val, \
decoder_target_train, decoder_target_val = train_test_split(
encoder_input_data,
decoder_input_data,
decoder_target_data,
test_size=0.2, # 20% untuk validasi
random_state=42 # Untuk reproduktibilitas
)
print("\nUkuran data training dan validasi:")
print("Train shapes:", encoder_input_train.shape, decoder_input_train.shape, decoder_target_train.shape)
print("Val shapes:", encoder_input_val.shape, decoder_input_val.shape, decoder_target_val.shape)
Langkah 3: Membangun Model NMT Keras TensorFlow (Arsitektur Encoder-Decoder)
Setelah data siap, sekarang kita akan membangun komponen inti dari model neural machine translation kita: Encoder dan Decoder, menggunakan Keras Functional API. Ini adalah bagian kunci dalam membangun model nmt keras tensorflow dan merupakan implementasi dari model seq2seq python.
Tinjauan Arsitektur Model Seq2Seq NMT
Kita akan membangun arsitektur encoder decoder nmt sebagai berikut:
- Encoder: Menerima urutan integer masukan (kalimat sumber), mengubahnya menjadi embedding, lalu memprosesnya dengan LSTM. LSTM akan mengembalikan state akhirnya (hidden state dan cell state).
- Decoder: Menerima urutan integer target (diawali token START), mengubahnya menjadi embedding, dan memprosesnya dengan LSTM lain. LSTM Decoder diinisialisasi dengan state akhir dari Encoder. Di setiap langkah waktu (timestep), keluaran LSTM dilewatkan ke Dense layer dengan aktivasi softmax untuk memprediksi token berikutnya.
Aliran data: Urutan Masukan -> Embedding -> Encoder LSTM -> Context State (h, c) -> Decoder LSTM (dengan initial state dari Encoder) -> Dense Layer -> Probabilitas Urutan Keluaran.
Implementasi Encoder LSTM Keras
from tensorflow.keras.layers import Input, LSTM, Embedding, Dense
from tensorflow.keras.models import Model
# Definisikan dimensi embedding dan unit LSTM
embedding_dim = 256
latent_dim = 512 # Dimensi state LSTM
# --- Encoder ---
# Input layer untuk encoder
encoder_inputs = Input(shape=(max_encoder_seq_length,), name='encoder_input')
# Embedding layer untuk encoder
# mask_zero=True penting jika Anda menggunakan masking, tapi kita padding manual
encoder_embedding = Embedding(num_encoder_tokens, embedding_dim, name='encoder_embedding')(encoder_inputs)
# LSTM layer encoder
# Kita butuh state akhir (h dan c) untuk menginisialisasi decoder
encoder_lstm = LSTM(latent_dim, return_state=True, name='encoder_lstm')
# Tidak butuh output sequence encoder (encoder_outputs), hanya states
_, state_h, state_c = encoder_lstm(encoder_embedding)
# Kita hanya menyimpan state untuk diteruskan ke decoder
encoder_states = [state_h, state_c]
print("\nEncoder dibangun.")
Implementasi Decoder LSTM Keras (Untuk Training)
Decoder untuk fase training sedikit berbeda dari inferensi. Pada fase training, kita memberikan seluruh urutan target yang benar sebagai masukan ke decoder di setiap langkah waktu (teknik ini dikenal sebagai teacher forcing).
# --- Decoder ---
# Input layer untuk decoder (menerima urutan target)
decoder_inputs = Input(shape=(max_decoder_seq_length,), name='decoder_input')
# Embedding layer untuk decoder (menggunakan vocabulary target)
# Ukuran embedding bisa sama atau berbeda dengan encoder
decoder_embedding_layer = Embedding(num_decoder_tokens, embedding_dim, name='decoder_embedding')
decoder_embedding = decoder_embedding_layer(decoder_inputs)
# LSTM layer decoder
# return_sequences=True karena kita butuh output di setiap timestep untuk prediksi
# return_state=True juga diperlukan, meskipun state akhirnya tidak digunakan langsung di training loop ini
decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True, name='decoder_lstm')
# Inisialisasi state decoder dengan state akhir encoder
# Ini adalah kunci menghubungkan encoder dan decoder
decoder_outputs, _, _ = decoder_lstm(decoder_embedding, initial_state=encoder_states)
# Dense layer untuk prediksi token di setiap timestep
# Outputnya adalah probabilitas untuk setiap kata di vocabulary target
decoder_dense = Dense(num_decoder_tokens, activation='softmax', name='decoder_output')
decoder_outputs = decoder_dense(decoder_outputs)
print("Decoder untuk training dibangun.")
Sekilas Tentang Mekanisme Attention (Opsional)
Keterbatasan utama arsitektur Seq2Seq dasar adalah keharusan mengompres seluruh informasi kalimat sumber ke dalam satu context vector berdimensi tetap (encoder_states). Ini bisa menjadi bottleneck, terutama untuk kalimat panjang. Mekanisme Attention mengatasi ini dengan memungkinkan Decoder untuk “melihat kembali” dan secara selektif fokus pada bagian-bagian yang relevan dari seluruh urutan keluaran Encoder pada setiap langkah decoding. Ini secara signifikan meningkatkan kualitas terjemahan. Meskipun tutorial neural machine translation keras ini tidak mengimplementasikan Attention (seperti pada lstm attention keras tutorial) untuk menjaga kesederhanaan, ini adalah peningkatan yang sangat umum dan penting dalam NMT modern.
Menggabungkan Encoder-Decoder Menjadi Model Training
Selanjutnya, kita gabungkan kedua komponen (Encoder dan Decoder) menjadi satu model untuk proses training menggunakan Keras Functional API.
# --- Model Seq2Seq (untuk Training) ---
# Model ini menerima input encoder dan input decoder, dan menghasilkan output decoder
model = Model([encoder_inputs, decoder_inputs], decoder_outputs, name='seq2seq_training_model')
print("Model Seq2Seq untuk training selesai dibangun.")
Kompilasi Model Training NMT
Sebelum training, model perlu dikompilasi dengan menentukan optimizer, fungsi loss, dan metrik evaluasi.
# Kompilasi model
# Optimizer: rmsprop sering bekerja baik untuk RNN, Adam juga pilihan bagus
# Loss: sparse_categorical_crossentropy karena target kita adalah integer (bukan one-hot)
model.compile(optimizer='rmsprop', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# Tampilkan ringkasan model
model.summary()
Langkah 4: Training Model NMT Keras
Dengan model yang sudah dibangun dan data yang sudah diproses, kita siap memulai proses training model nmt keras.
Pengaturan Parameter Training (Epoch, Batch Size)
Kita perlu menentukan beberapa parameter dasar untuk proses training. Nilai-nilai ini adalah titik awal yang umum; Anda mungkin perlu menyesuaikannya berdasarkan dataset dan sumber daya komputasi Anda.
batch_size = 64 # Ukuran batch untuk training
epochs = 30 # Jumlah epoch (iterasi penuh pada dataset)
# Catatan: Untuk hasil yang baik pada dataset nyata, mungkin perlu 50-100 epoch atau lebih.
# Sesuaikan berdasarkan ukuran data dan kompleksitas model.
Menjalankan Proses Training Model NMT
Kita menggunakan metode model.fit() untuk melatih model dengan data training dan memvalidasinya menggunakan data validasi.
# Melatih model
print("\nMemulai training...")
history = model.fit(
[encoder_input_train, decoder_input_train], # Input: list berisi data input encoder & decoder
decoder_target_train, # Target: data target decoder (shifted)
batch_size=batch_size,
epochs=epochs,
validation_data=([encoder_input_val, decoder_input_val], decoder_target_val) # Data validasi
)
print("Training selesai.")
# Anda bisa menyimpan history untuk plot nanti
# import pickle
# with open('training_history.pkl', 'wb') as f:
# pickle.dump(history.history, f)
Menggunakan Callbacks (ModelCheckpoint, EarlyStopping) Opsional
Callbacks adalah alat yang berguna untuk mengontrol proses training. ModelCheckpoint menyimpan model terbaik berdasarkan metrik tertentu, sementara EarlyStopping menghentikan training jika tidak ada kemajuan performa pada data validasi untuk mencegah overfitting.
# from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
# # Callback untuk menyimpan model terbaik berdasarkan val_loss
# checkpoint_filepath = 'nmt_model_best.h5'
# model_checkpoint_callback = ModelCheckpoint(
# filepath=checkpoint_filepath,
# save_weights_only=True, # Simpan bobot saja agar lebih fleksibel
# monitor='val_loss', # Pantau loss validasi
# mode='min', # Kita ingin loss minimal
# save_best_only=True) # Hanya simpan jika membaik
# # Callback untuk menghentikan training jika tidak ada perbaikan
# early_stopping_callback = EarlyStopping(
# monitor='val_loss',
# patience=5, # Jumlah epoch tanpa perbaikan sebelum berhenti (sesuaikan nilainya)
# verbose=1,
# restore_best_weights=True # Kembalikan ke bobot terbaik saat berhenti
# )
# # Melatih model dengan callbacks
# print("\nMemulai training dengan callbacks...")
# history = model.fit(
# [encoder_input_train, decoder_input_train],
# decoder_target_train,
# batch_size=batch_size,
# epochs=100, # Bisa set ke jumlah besar karena ada EarlyStopping
# validation_data=([encoder_input_val, decoder_input_val], decoder_target_val),
# callbacks=[model_checkpoint_callback, early_stopping_callback] # Tambahkan callbacks
# )
# print("Training selesai.")
Menyimpan Bobot Model Hasil Training
Setelah training selesai, sangat penting untuk menyimpan bobot model. Ini memungkinkan kita menggunakan model untuk inferensi nanti tanpa perlu melatih ulang.
# Simpan bobot model setelah training selesai
model_weights_path = 'nmt_model_weights.h5'
model.save_weights(model_weights_path)
print(f"\nBobot model disimpan di {model_weights_path}")
# Jika Anda ingin menyimpan seluruh model (termasuk arsitektur dan optimizer state):
# model.save('nmt_full_model.h5')
Langkah 5: Evaluasi Model Penerjemahan Mesin
Mengevaluasi model penerjemahan mesin tidak hanya melihat akurasi per token. Kita perlu melihat gambaran kualitas terjemahan secara keseluruhan.
Menganalisis Grafik Loss & Accuracy
Objek history yang dikembalikan oleh model.fit() berisi catatan loss dan metrik selama training. Memvisualisasikan data ini membantu memahami bagaimana model belajar dan apakah terjadi overfitting (ketika performa pada data training terus membaik tetapi performa pada data validasi memburuk).
import matplotlib.pyplot as plt
# Cek apakah history.history ada (jika training dijalankan)
if 'history' in locals() and hasattr(history, 'history'):
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs_range = range(1, len(acc) + 1) # Sesuaikan range epoch berdasarkan history
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Acc')
plt.plot(epochs_range, val_acc, label='Validation Acc')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.tight_layout()
plt.show()
else:
print("\nObjek 'history' tidak ditemukan. Lewati plotting.")
# Evaluasi akhir pada validation set (jika tidak menggunakan EarlyStopping restore_best_weights)
# scores = model.evaluate([encoder_input_val, decoder_input_val], decoder_target_val, verbose=0)
# print(f"\nValidation Loss: {scores[0]}")
# print(f"Validation Accuracy: {scores[1]}")
Pengantar Metrik Evaluasi BLEU Score (Opsional)
Akurasi per token bukanlah ukuran ideal untuk kualitas terjemahan. Metrik yang lebih umum digunakan adalah BLEU (Bilingual Evaluation Understudy) score. BLEU membandingkan n-gram (urutan kata berdekatan) dari terjemahan yang dihasilkan mesin dengan satu atau beberapa terjemahan referensi manusia. Semakin banyak kecocokan n-gram, semakin tinggi skornya (biasanya antara 0 dan 1, atau 0 dan 100). Perpustakaan seperti NLTK atau SacreBLEU dapat digunakan untuk menghitung skor ini. Meskipun tidak diimplementasikan di sini, penting untuk mengetahui BLEU sebagai salah satu standar evaluasi NMT yang umum.
Langkah 6: Inferensi/Prediksi dengan Model NMT TensorFlow
Proses inferensi model nmt tensorflow (menerjemahkan kalimat baru yang belum pernah dilihat) berbeda dari proses training. Kita tidak lagi menggunakan *teacher forcing*. Sebaliknya, kita perlu menjalankan decoder langkah demi langkah, menggunakan prediksi dari langkah sebelumnya sebagai masukan untuk langkah berikutnya. Ini adalah contoh implementasi nmt sederhana python dan menyediakan contoh kode nmt keras untuk prediksi.
Membangun Model Encoder & Decoder untuk Inferensi
Kita perlu mendefinisikan ulang model Encoder dan Decoder secara terpisah khusus untuk proses inferensi ini, lalu memuat bobot yang sudah dilatih dari model training.
Model Encoder Inferensi: Tugasnya hanya mengambil urutan masukan dan mengembalikan state akhir (h, c) sebagai *context vector*.
# --- Model Encoder untuk Inferensi ---
# Inputnya sama dengan encoder training
# Outputnya adalah state h dan state c
encoder_inf_model = Model(encoder_inputs, encoder_states, name='encoder_inference')
print("\nModel Encoder untuk inferensi dibangun.")
Model Decoder Inferensi: Model ini akan menerima state dari encoder (pada langkah pertama) atau state dari langkah decoder sebelumnya, serta *satu* token masukan (token START di awal, lalu token yang diprediksi sebelumnya). Model ini akan menghasilkan probabilitas untuk token berikutnya dan state baru (h, c) untuk langkah selanjutnya.
# --- Model Decoder untuk Inferensi ---
# Input state dari langkah sebelumnya (atau dari encoder)
decoder_state_input_h = Input(shape=(latent_dim,), name='decoder_state_h')
decoder_state_input_c = Input(shape=(latent_dim,), name='decoder_state_c')
decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
# Input untuk token pada timestep saat ini (hanya 1 token)
# Bentuknya adalah (batch_size, 1), dalam kasus ini (1, 1)
decoder_inf_inputs = Input(shape=(1,), name='decoder_inf_input') # Input hanya 1 token index
# Embedding layer (gunakan layer yang sama dari training)
decoder_inf_embedding = decoder_embedding_layer(decoder_inf_inputs)
# LSTM layer (gunakan layer yang sama dari training)
# Kita set initial_state dengan input state
decoder_inf_outputs, state_inf_h, state_inf_c = decoder_lstm(
decoder_inf_embedding, initial_state=decoder_states_inputs
)
decoder_inf_states = [state_inf_h, state_inf_c]
# Dense layer (gunakan layer yang sama dari training)
decoder_inf_outputs = decoder_dense(decoder_inf_outputs)
# Model decoder inferensi
decoder_inf_model = Model(
[decoder_inf_inputs] + decoder_states_inputs, # Input: token + states
[decoder_inf_outputs] + decoder_inf_states, # Output: token_probs + states
name='decoder_inference'
)
print("Model Decoder untuk inferensi dibangun.")
# Muat bobot yang sudah dilatih ke model-model inferensi ini
# Penting: Pastikan model training (model) sudah dibuat dan bobotnya sudah disimpan
try:
# Asumsikan bobot disimpan sebelumnya di model_weights_path
# Muat bobot ke model training gabungan dulu agar Keras bisa memetakannya
# ke layer yang sama di model inferensi (berdasarkan nama layer)
model.load_weights(model_weights_path)
# Bobot sekarang dapat ditransfer ke model inferensi
# encoder_inf_model.load_weights(model_weights_path, by_name=True) # Tidak perlu jika 'model' sudah dimuat
# decoder_inf_model.load_weights(model_weights_path, by_name=True) # Tidak perlu jika 'model' sudah dimuat
print(f"Bobot dari '{model_weights_path}' berhasil dimuat ke model komposit, siap untuk inferensi.")
except Exception as e:
print(f"Gagal memuat bobot: {e}. Pastikan path '{model_weights_path}' benar dan model sudah dilatih.")
# Membuat kamus untuk mapping index kembali ke kata
reverse_input_word_index = {v: k for k, v in input_word_index.items()}
reverse_target_word_index = {v: k for k, v in target_word_index.items()}
# Tambahkan token padding jika perlu (index 0 biasanya padding)
if 0 not in reverse_input_word_index: reverse_input_word_index[0] = ''
if 0 not in reverse_target_word_index: reverse_target_word_index[0] = ''
# Mendapatkan token START dan END dari tokenizer target
start_token_index = target_word_index['\t']
end_token_index = target_word_index['\n']
Membuat Fungsi Decoding untuk Terjemahan
Fungsi ini akan mengambil urutan masukan yang sudah diproses, menjalankannya melalui model encoder inferensi untuk mendapatkan state awal, lalu menjalankan model decoder inferensi secara iteratif untuk menghasilkan terjemahan kata per kata.
def decode_sequence(input_seq):
# 1. Encode input sequence menjadi state vectors.
states_value = encoder_inf_model.predict(input_seq)
# 2. Siapkan target sequence awal (hanya token START).
# Bentuknya harus (batch_size, 1) -> (1, 1) karena kita proses 1 kalimat
target_seq = np.zeros((1, 1))
target_seq[0, 0] = start_token_index
# 3. Looping untuk decoding (generasi kata per kata)
stop_condition = False
decoded_sentence = ''
while not stop_condition:
# Jalankan decoder untuk satu timestep
# Masukan: token terakhir + state terakhir
# Keluaran: probabilitas token berikutnya + state baru
output_tokens, h, c = decoder_inf_model.predict(
[target_seq] + states_value, verbose=0 # Set verbose=0 agar tidak print progress bar
)
# Pilih token dengan probabilitas tertinggi (Metode Greedy Search)
sampled_token_index = np.argmax(output_tokens[0, -1, :])
sampled_char = reverse_target_word_index.get(sampled_token_index, '') # Handle jika token tidak dikenal
# Keluar loop jika token END diprediksi atau mencapai panjang maksimum
# Tambahkan pemeriksaan untuk sampled_char != '' untuk keamanan
if sampled_char == '\n' or sampled_char == '' or len(decoded_sentence.split()) > max_decoder_seq_length:
stop_condition = True
continue # Jangan tambahkan token END atau padding ke hasil akhir
# Tambahkan token yang diprediksi ke kalimat hasil
decoded_sentence += ' ' + sampled_char
# Update target sequence untuk langkah berikutnya (token yang baru diprediksi)
target_seq[0, 0] = sampled_token_index
# Update states untuk langkah berikutnya
states_value = [h, c]
return decoded_sentence.strip() # Hapus spasi ekstra di awal/akhir
print("\nFungsi decode_sequence siap digunakan.")
Contoh Penggunaan Menerjemahkan Kalimat Baru
Mari kita coba terjemahkan beberapa kalimat dari set validasi untuk melihat bagaimana model bekerja, atau bahkan kalimat baru (setelah diproses dengan cara yang sama seperti data training).
# Pilih beberapa indeks acak dari validation set untuk diuji
# Pastikan model inferensi sudah dibuat dan bobot sudah dimuat
if 'encoder_inf_model' in locals() and 'decoder_inf_model' in locals():
try:
num_test_samples = 5
indices = np.random.choice(len(encoder_input_val), num_test_samples, replace=False)
print("\n--- Contoh Terjemahan ---")
for i in indices:
input_seq_val = encoder_input_val[i: i + 1] # Ambil satu sampel dengan shape (1, max_len)
decoded_sentence = decode_sequence(input_seq_val)
# Rekonstruksi kalimat input asli (tanpa padding)
input_text_original = ' '.join(
reverse_input_word_index[idx] for idx in input_seq_val[0] if idx != 0
).strip()
# Rekonstruksi kalimat target referensi (tanpa padding dan token START/END)
target_text_original = ' '.join(
reverse_target_word_index[idx] for idx in decoder_input_val[i] if idx != 0 and idx != start_token_index and idx != end_token_index
).strip()
print('-')
print('Input sentence:', input_text_original)
print('Target sentence (Reference):', target_text_original)
print('Decoded sentence (Model):', decoded_sentence)
except NameError as ne:
print(f"\nVariabel yang dibutuhkan belum terdefinisi: {ne}. Pastikan semua langkah sebelumnya dijalankan.")
except Exception as e:
print(f"\nTerjadi error saat mencoba menerjemahkan: {e}. Pastikan bobot ada dan model valid.")
else:
print("\nModel inferensi belum diinisialisasi atau bobot belum dimuat. Lewati contoh terjemahan.")
# Contoh menerjemahkan kalimat baru (harus dipreprocess dulu)
# try:
# new_sentence = "How are you?"
# processed_sentence = preprocess_sentence(new_sentence)
# seq = input_tokenizer.texts_to_sequences([processed_sentence])
# padded_seq = pad_sequences(seq, maxlen=max_encoder_seq_length, padding='post')
# translation = decode_sequence(padded_seq)
# print("\n--- Terjemahan Kalimat Baru ---")
# print("Input:", new_sentence)
# print("Output:", translation)
# except NameError as ne:
# print(f"\nTokenizer atau variabel lain belum terdefinisi: {ne}.")
# except Exception as e:
# print(f"\nTerjadi error saat menerjemahkan kalimat baru: {e}")
Kesimpulan dan Langkah Selanjutnya
Rangkuman Tutorial Membangun Model NMT Sederhana
Dalam tutorial neural machine translation keras tensorflow ini, kita telah berhasil membangun dan melatih model NMT Seq2Seq sederhana dari awal. Prosesnya meliputi:
- Persiapan lingkungan Python dan dataset paralel Inggris-Indonesia.
- Preprocessing data teks: pembersihan, penambahan token khusus, tokenisasi, dan padding sebagai bagian krusial dari
persiapan data nmt. - Membangun arsitektur Encoder-Decoder (
arsitektur encoder decoder nmt) menggunakan layer Embedding dan LSTM di Keras. - Melakukan
training model nmt keras, memantau loss dan akurasi pada data training dan validasi. - Membangun model terpisah untuk
inferensi model nmt tensorflowdan mengimplementasikan loop decoding (greedy search) untuk menerjemahkan kalimat baru, mendemonstrasikancara membuat model nmtyang berfungsi.
Keterbatasan Model NMT Sederhana Ini
Model yang kita bangun merupakan dasar yang baik untuk pemahaman, namun memiliki beberapa keterbatasan:
- Ukuran Dataset: Dataset 10.000 kalimat relatif kecil untuk tugas NMT, membatasi kemampuan generalisasi model ke kalimat yang lebih beragam atau kompleks.
- Arsitektur Sederhana: Tidak menggunakan mekanisme Attention, yang sangat penting untuk menangani kalimat panjang dan meningkatkan kualitas terjemahan secara signifikan.
- Vocabulary Terbatas: Model hanya mengenal kata-kata yang ada di data training. Kata-kata baru (*out-of-vocabulary* atau OOV) tidak dapat diproses dengan baik.
- Decoding Sederhana: Menggunakan *greedy search* (memilih kata terbaik di setiap langkah) mungkin tidak menghasilkan urutan terjemahan keseluruhan yang paling optimal.
- Parameter Tidak Dioptimalkan: Ukuran embedding, unit LSTM, dan parameter training lainnya belum tentu optimal.
Saran Pengembangan Model NMT Lebih Lanjut
Untuk meningkatkan performa dan mengatasi keterbatasan model ini, pertimbangkan langkah-langkah berikut:
- Dataset Lebih Besar: Gunakan data paralel yang jauh lebih besar dan berkualitas tinggi.
- Implementasi Attention: Tambahkan mekanisme Attention (misalnya, menggunakan layer `Attention` atau `AdditiveAttention` dari Keras) antara Encoder dan Decoder.
- Arsitektur Lebih Canggih: Eksplorasi penggunaan GRU (Gated Recurrent Unit), LSTM dua arah (Bi-LSTM), atau arsitektur Transformer yang saat ini menjadi state-of-the-art.
- Hyperparameter Tuning: Lakukan eksperimen sistematis untuk menemukan kombinasi parameter model (ukuran embedding, unit LSTM/GRU, jumlah layer) dan parameter training (learning rate, batch size) yang optimal.
- Beam Search Decoding: Gantikan greedy search dengan *beam search* saat inferensi untuk menjelajahi beberapa kandidat terjemahan dan memilih yang terbaik secara keseluruhan.
- Subword Tokenization: Gunakan teknik seperti Byte Pair Encoding (BPE) atau SentencePiece untuk memecah kata menjadi unit subword, membantu menangani kata-kata langka dan OOV.
- Pre-trained Embeddings: Inisialisasi layer Embedding dengan vektor kata yang sudah dilatih sebelumnya (seperti GloVe atau FastText) untuk menangkap makna semantik awal.
Sumber Belajar NMT TensorFlow Lainnya
Untuk pendalaman lebih lanjut tentang belajar neural machine translation tensorflow dan topik terkait:
- Dokumentasi TensorFlow: Tutorial resmi Neural machine translation with attention memberikan contoh implementasi dengan Attention.
- Keras Examples: Contoh Character-level Recurrent Sequence-to-Sequence model (meskipun level karakter, konsep Seq2Seq-nya relevan) dan contoh NLP lainnya.
- Blog dan Paper: Cari paper asli tentang Seq2Seq oleh Sutskever et al. (2014) dan Attention oleh Bahdanau et al. (2014) serta Vaswani et al. (Transformer, 2017).
Membangun model NMT dari awal memberikan pemahaman mendalam tentang cara kerja teknologi penerjemahan modern. Eksperimen ini adalah langkah awal yang bagus untuk menjelajahi dunia Natural Language Processing yang luas dan menarik. Jika Anda tertarik menerapkan solusi AI canggih untuk kebutuhan bisnis, platform seperti Kirim.ai menawarkan solusi berbasis AI komprehensif, dari NLP hingga pengembangan platform cerdas, untuk mengakselerasi transformasi digital Anda. Pelajari lebih lanjut tentang bagaimana AI dapat mendorong inovasi.
Tanggapan (0 )