---
# System prepended metadata

title: 'Modul 4: Preprocessing and Finetuning'

---

# Modul 4: Preprocessing and Finetuning
## Objektif
Setelah menyelesaikan modul ini, peserta diharapkan dapat:
1. Memahami keseluruhan process dari tahap preprocessing yang dilakukan dalam suatu pipeline
2. Memahami konsep pre-trained model dan transfer learning
3. Memahami peran finetuning dalam finalisasi model
4. Mampu menerapkan preprocessing pipeline dan finetuning secara sederhana dalam workflow LLM menggunakan library Python

## Preprocessing

*Note: Dalam modul ini, preprocessing yang dibahas adalah preprocessing secara spesifik untuk transformer. Preprocessing pada metode NLP klasik (non transformer) memiliki beberapa metode yang berbeda seperti stemming, stop word removal, dll yang jarang digunakan pada transformer*

Secara umum, model pembelajaran mesin hanya dapat memproses data dalam bentuk numerik. Oleh karena itu, setiap elemen teks baik huruf, kata, maupun token harus diubah menjadi representasi vektor agar dapat dipahami oleh model. Proses mengubah dan menyiapkan data mentah agar sesuai dengan format yang dibutuhkan model ini disebut *preprocessing*.

Secara umum, tahapan pada preprocessing untuk model LLM sebagai berikut:
| Tahap                                       | Deskripsi                                                                                                                                                                                                                                  |
| ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Normalization**                           | Membersihkan dan menstandarisasi teks → misalnya menghapus aksen, handling Unicode, mengatur case (lowercasing) sesuai tipe model (cased / uncased).                                                                                                        |
| **Pre-tokenization**                        | Pembagian awal teks menjadi potongan kasar sebelum subword encoding → misalnya pemecahan berdasarkan whitespace, punctuation, offset mapping.                                                                                                                 |
| **Tokenization (Subword Tokenizer)**        | Mengubah teks menjadi token / subtoken menggunakan algoritma seperti BPE, WordPiece, SentencePiece. Setelah tokenisasi, token tersebut diubah menjadi ID numerik berdasarkan vocabulary dari model pra-latih.                                                 |
| **Penambahan Special Tokens**               | Menyisipkan token khusus seperti `[CLS]`, `[SEP]`, atau `</s>` tergantung model – biasanya secara otomatis oleh tokenizer yang sesuai dengan konfigurasi model.                                                                                              |
| **Padding dan Truncation**                  | Menyelaraskan panjang urutan (sequence length) agar batch bisa diolah bersama: <br> • *Padding* → menambahkan token pad agar semua input dalam batch sama panjang. <br> • *Truncation* → memotong urutan bila terlalu panjang untuk model.  |                                 |
| **Membuat Attention Mask / Token Type IDs** | Selain `input_ids`, tokenizer menghasilkan juga `attention_mask` (menunjukkan token mana yang valid vs padding) dan kadang `token_type_ids` jika model menggunakan segment labeling (misalnya input gabungan dua kalimat).                                |

## Tahapan Preprocessing in Detail

### Jenis Tokenization
#### 1. Word-level Tokenization

Pada pendekatan ini, teks dipecah berdasarkan kata. Setiap kata dianggap sebagai satu token yang berdiri sendiri.
Contoh:

Teks: “Saya suka belajar NLP.”
Token: [“Saya”, “suka”, “belajar”, “NLP”]

Kelebihannya adalah sederhana dan mudah dipahami. Namun, pendekatan ini memiliki kelemahan besar, yaitu vocabulary explosion, yaitu jumlah kata yang digunakan bisa sangat banyak, termasuk variasi seperti “belajar”, “belajarlah”, “belajarnya”, yang semuanya dianggap token berbeda. Hal ini menyebabkan model sulit menangani kata baru.

#### 2. Character-level Tokenization

Pendekatan ini memecah teks berdasarkan setiap karakter.
Contoh:

Teks: “Belajar”
Token: [“B”, “e”, “l”, “a”, “j”, “a”, “r”]

Keunggulannya adalah model dapat mengenali semua kemungkinan kombinasi huruf, sehingga tidak ada masalah OOV (Out of Vocabulary) sehingga bisa mengenal kata-kata baru. Namun, kelemahannya adalah urutan token menjadi sangat panjang, dan model perlu mempelajari hubungan antar-karakter dari awal, yang membuat pelatihan menjadi lebih sulit dan tidak efisien.

#### 3. Subword-level Tokenization (Standar pada LLM)

Pendekatan ini merupakan kompromi antara dua metode sebelumnya. Teks dipecah menjadi potongan-potongan kata kecil (subword units), di mana kata umum disimpan utuh, sedangkan kata langka dipecah menjadi beberapa bagian. Metode ini digunakan oleh sebagian besar model bahasa modern seperti BERT, GPT, dan T5

Contoh:
Teks: “unbelievable”
Token: [“un”, “believ”, “able”]

### Special Tokens
Dalam model berbasis Transformer, special tokens adalah token khusus yang ditambahkan oleh tokenizer untuk memberikan informasi struktural tambahan kepada model. Token-token ini tidak berasal langsung dari teks asli, tetapi berfungsi untuk membantu model memahami konteks, posisi, maupun batas kalimat dalam sebuah urutan input.

Special tokens sangat penting karena model seperti BERT, RoBERTa, dan GPT menggunakan struktur input yang berbeda-beda sesuai dengan tujuan pretraining-nya.

| **Token** | **Contoh Penggunaan**                     | **Tujuan / Fungsi**                                                                             |
| --------- | ----------------------------------------- | ----------------------------------------------------------------------------------------------- |
| `[CLS]`   | `[CLS] saya lapar [SEP]`                  | Menandai awal kalimat; digunakan untuk representasi keseluruhan kalimat pada tugas klasifikasi. |
| `[SEP]`   | `[CLS] saya lapar [SEP] saya makan [SEP]` | Memisahkan dua segmen teks atau menandai akhir kalimat.                                         |
| `[PAD]`   | `[CLS] saya makan [SEP] [PAD] [PAD]`      | Menyamakan panjang input dalam satu batch; tidak memiliki makna semantik.                       |
| `[MASK]`  | `[CLS] saya [MASK] nasi [SEP]`            | Menyembunyikan token agar model belajar menebak kata yang hilang (*Masked Language Modeling*).  |
| `<s>`     | `<s> saya makan nasi </s>`                | Menandai awal kalimat (setara `[CLS]` pada model seperti RoBERTa atau BART).                    |
| `</s>`    | `<s> saya makan nasi </s>`                | Menandai akhir kalimat (setara `[SEP]`).                                                        |
| `[UNK]`   | `[CLS] saya [UNK] nasi [SEP]`             | Digunakan ketika ada kata yang tidak dikenali oleh tokenizer.                                   |

### Token-Integer Mapping

Setelah teks diubah menjadi  token, setiap token perlu dikonversi menjadi integer agar dapat diproses oleh model.
Proses ini disebut token-to-ID mapping, yaitu pemberian nomor unik untuk setiap token berdasarkan kosakata (vocabulary) yang telah dimiliki model.

Sebagai contoh:
```
"makan" → 3205
"saya"  → 2103
"nasi"  → 4502
```

Setiap token yang dihasilkan dari proses tokenisasi diubah menjadi integer berdasarkan daftar kosakata (vocabulary) yang dimiliki model.

Kosakata ini adalah hasil pelatihan awal (pretraining) tokenizer pada korpus besar, dan berisi pemetaan tetap antara token dan ID-nya.

Biasanya, penetapan ID token dalam kosakata dilakukan berdasarkan:

- Frekuensi kemunculan token dalam korpus pelatihan (token yang lebih sering muncul mendapat ID lebih kecil),
- Urutan pembentukan token dalam algoritma seperti Byte Pair Encoding (BPE) atau WordPiece,
- Probabilitas token dalam model Unigram, atau
- Penetapan manual untuk special tokens seperti [PAD], [CLS], [SEP], dan [MASK]
### Padding & Truncation

#### Padding
Dalam model Transformer, panjang setiap urutan (sequence length) harus seragam agar dapat diproses secara paralel dalam bentuk batch. Dua teknik yang digunakan untuk menyesuaikan panjang urutan tersebut adalah padding dan truncation.

Padding adalah proses menambahkan token khusus, biasanya [PAD], pada akhir urutan yang lebih pendek agar seluruh input memiliki panjang yang sama. Token [PAD] tidak memiliki makna semantik; fungsinya hanya sebagai pengisi agar model dapat melakukan komputasi secara efisien dan sejajar untuk semua data dalam satu batch.

Agar model tidak menganggap token [PAD] sebagai bagian penting dari kalimat, sistem juga menyertakan attention mask, yaitu penanda yang menunjukkan token mana yang valid dan mana yang hanya padding. Dengan demikian, model akan mengabaikan token [PAD] selama proses perhatian (attention mechanism).

#### Truncation

Sebaliknya, truncation dilakukan dengan memotong urutan yang terlalu panjang agar tidak melebihi panjang maksimum (maximum sequence length) yang telah ditentukan. Hal ini mencegah model terbebani oleh teks yang terlalu panjang dan membantu mengurangi kebutuhan komputasi.

Pemilihan panjang maksimum perlu menjaga keseimbangan antara mempertahankan informasi penting dalam teks dan menjaga efisiensi pemrosesan.

#### Attention Mask

Dalam model Transformer, attention mask digunakan untuk memberi tahu model token mana yang perlu diperhatikan (attend to) dan token mana yang harus diabaikan, yang umumnya berasal dari hasil dari padding.

Oleh karena itu, diperlukan attention mask, yaitu vektor biner (berisi angka 1 dan 0) dengan panjang yang sama seperti urutan input:

- 1 menunjukkan token valid (harus diperhatikan oleh model)
- 0 menunjukkan token padding (harus diabaikan oleh model)

Selama perhitungan attention, model akan menggunakan mask ini untuk menonaktifkan kontribusi token [PAD], sehingga bobot perhatian (attention weights) hanya dihitung pada token yang relevan.

#### Contoh Penggunaan

Diberikan Kalimat:
```
"Saya makan nasi"
"Saya sedang makan"
"Saya makan nasi goreng pedas"
```

Tokenize menjadi
| Kalimat | Token Sequence                                               |
| ------- | ------------------------------------------------------------ |
| 1       | `[CLS]`, `saya`, `makan`, `nasi`, `[SEP]`                    |
| 2       | `[CLS]`, `saya`, `sedang`, `makan`, `[SEP]`                  |
| 3       | `[CLS]`, `saya`, `makan`, `nasi`, `goreng`, `pedas`, `[SEP]` |

ID yang Diperoleh:
```
Input IDs:
[101 2103 3205 4502 102 0]
[101 2103 6789 3205 102 0]
[101 2103 3205 4502 5678 102]
```
0 Pada 2 column matrix terakhir merupakan [PAD] sehingga 2 kalimat pertama memiliki ukuran yang sama dengan kalimat ke tiga.

```
Attention Mask:
[1 1 1 1 1 0]
[1 1 1 1 1 0]
[1 1 1 1 1 1]
```

Dalam hal ini, attention mask berperan untuk memberi tahu model posisi token mana yang harus diperhatikan (1) dan mana yang harus diabaikan (0), sehingga token [PAD] tidak ikut diproses dan tidak memengaruhi hasil perhitungan model.

### Vektorisasi Token

Setelah setiap token diubah menjadi integer (token ID), langkah selanjutnya adalah token vectorization, yaitu mengonversi ID tersebut menjadi representasi vektor berdimensi tinggi yang dapat diproses oleh model Transformer.

Proses ini dilakukan melalui embedding layer, yaitu tabel besar yang menyimpan representasi vektor untuk setiap token dalam kosakata.
Setiap token ID digunakan untuk mengambil baris vektor yang sesuai dari tabel tersebut.


```
Token IDs: [101, 2103, 3205, 4502, 102]
↓
Embedding Lookup:
[[0.12, -0.45, 0.87, ...],
 [0.33,  0.11, -0.21, ...],
 [0.07,  0.59,  0.02, ...],
 [0.65, -0.32,  0.14, ...],
 [0.04,  0.25, -0.55, ...]]
```

Hasilnya adalah matriks representasi token berukuran (panjang urutan × dimensi embedding).
Vektor-vektor inilah yang kemudian menjadi input utama untuk lapisan Attention dan MLP (Feed Forward Network) pada arsitektur Transformer.

Dengan cara ini, model dapat menangkap:
- Hubungan semantik antar-token melalui kesamaan vektor embedding, dan
- Konteks urutan kata setelah diproses oleh mekanisme Self-Attention.
## Finetuning
### Pretrained Model
Pretrained model adalah model yang sudah dilatih sebelumnya pada korpus besar untuk memahami bahasa secara umum atau melakukan tugas generatif.
Contohnya: BERT, GPT, RoBERTa, dan T5.

Model ini sangat mahal dan sulit untuk dilatih dari awal karena membutuhkan:
- Dataset yang sangat besar (miliaran token)
- Parameter model yang banyak (jutaan hingga miliaran bobot)
- Waktu pelatihan selama minggu atau bulan menggunakan GPU/TPU kelas atas

### Transfer Learning
Transfer learning adalah teknik dalam pembelajaran mesin di mana pengetahuan yang diperoleh dari satu tugas digunakan kembali untuk tugas lain yang berbeda namun terkait.

Dibanding melatih model dari awal, training dapat memanfaatkan model atau representasi yang sudah dilatih sebelumnya.

Manfaat dari transfer learning diantaranya untuk mengurangi kebutuhan data, waktu pelatihan, dan sumber daya komputasi.

Contoh sederhana:

Model pretrained untuk pemahaman bahasa umum (misal BERT) dapat digunakan untuk:

- Analisis sentimen di dataset film
- Deteksi topik dalam berita
- Identifikasi entitas di dokumen medis

### Fine Tuning
Fine-tuning adalah salah satu metode praktis untuk menerapkan transfer learning, khususnya di bidang NLP, dimana proses ini mengambil model pretrained yang sudah memiliki bobot hasil pelatihan pada korpus besar, lalu menyesuaikan bobot tersebut dengan dataset dan tugas spesifik. Dengan kata lain, semua bobot model pretrained digunakan sebagai titik awal, dan kemudian model "diadaptasi" agar optimal untuk tugas baru.

Sebagai contoh, bayangkan kita ingin membuat model klasifikasi sentimen pada ulasan produk secara umum. 
Dengan transfer learning, kita memanfaatkan model pretrained, misalnya BERT, yang sudah memahami bahasa secara umum. 

Melalui fine-tuning, kita menambahkan  layer khusus untuk klasifikasi sentimen dan melatih model menggunakan dataset ulasan produk. 

Selama proses ini, bobot pretrained disesuaikan agar model dapat mengenali pola sentimen dalam konteks ulasan, sambil tetap mempertahankan pengetahuan bahasa umum yang sudah dipelajari. Dari ini, fine tuning diimplementasikan dapat menfokuskan tugas dari pretrained model yang digunakan.

## Practice Time
Demikian bagian teori dari modul ini, selanjutnya kalian akan mencoba mengamati dan menerapkan konsep yang dibahas dalam modul ini memanfaatkan library transfomer dalam python.

Untuk itu, silahkan akses link Google Colab berikut ini (Silahkan make a copy bila ingin mencoba dan memodifikasinya).

Link : {%preview https://colab.research.google.com/drive/1YuEQ5OoYqX830Vgh8l8NiuCUT7XjNIMa?usp=sharing %}

Untuk informasi lebih lanjut saat practice silahkan gunakan referensi berikut:
- [Hugging Face Tokenizers](https://huggingface.co/docs/transformers/v4.37.0/main_classes/tokenizer)
- [Hugging Face FineTuning](https://huggingface.co/docs/transformers/v4.37.0/training)
