Apa itu Last Hidden State dalam Model BERT

BERT (Bidirectional Encoder Representations from Transformers) adalah model bahasa state-of-the-art yang digunakan untuk menghasilkan embedding kata yang terkontekstualisasi. Last hidden state dalam BERT adalah vektor yang mewakili makna terkontekstualisasi dari teks masukan.

Dalam model BERT, setiap token masukan direpresentasikan sebagai vektor, yang diperoleh dengan melewatkan token tersebut melalui beberapa lapisan dari jaringan saraf dalam. Last hidden state merupakan keluaran dari lapisan terakhir dari jaringan saraf tersebut, yang menangkap informasi kontekstual dari teks masukan.

Last hidden state dihitung menggunakan proses yang disebut multi-head attention, yang melibatkan perhitungan kesamaan antara setiap token masukan dengan semua token lain dalam urutan. Hal ini memungkinkan BERT untuk menangkap konteks lokal dan global dari teks masukan, yang sangat penting untuk banyak tugas pemrosesan bahasa alami seperti analisis sentimen, menjawab pertanyaan, dan terjemahan bahasa.

Last hidden state dalam BERT digunakan sebagai dasar untuk banyak tugas turunan, di mana ia disesuaikan dengan tugas tertentu dengan menambahkan lapisan khusus tugas di atas model BERT. Penyesuaian terakhir state memungkinkan model untuk mempelajari nuansa khusus dari tugas, seperti mengenali entitas bernama atau mengidentifikasi sentimen dari sebuah kalimat.

Bagaimana Last Hidden State Dihitung dalam BERT

Last hidden state dalam BERT dihitung menggunakan proses yang disebut multi-head attention, yang melibatkan beberapa langkah:

1. Pengkodean Masukan
   Teks masukan pertama-tama dibuat menjadi token terpisah, dan setiap token diubah menjadi vektor menggunakan lapisan embedding. Embedding tersebut kemudian melewati beberapa lapisan jaringan saraf dalam.

2. Transformator Encoder
   Transformator Encoder adalah komponen kunci dari BERT yang memungkinkannya menangkap konteks lokal dan global dari teks masukan. Ini terdiri dari beberapa lapisan, masing-masing termasuk multi-head attention dan jaringan saraf feed-forward.

3. Multi-Head Attention
   Multi-head attention adalah proses yang memungkinkan BERT menangkap hubungan antara setiap token dalam urutan masukan. Ini melibatkan menghitung kesamaan antara setiap token dan semua token lain dalam urutan. Proses ini diulang beberapa kali dengan menggunakan set berat yang berbeda, sehingga model dapat menangkap berbagai jenis hubungan.

4. Normalisasi Lapisan
   Setelah setiap lapisan multi-head attention, keluarannya dinormalisasi menggunakan proses yang disebut normalisasi lapisan. Ini membantu mencegah nilai-nilai dari menjadi terlalu besar atau terlalu kecil, yang dapat menyebabkan masalah selama pelatihan.

5. Jaringan Feed-Forward
   Setelah langkah normalisasi lapisan, keluaran dari setiap lapisan melewati jaringan saraf feed-forward. Ini membantu menangkap interaksi kompleks antara token dalam urutan input.

6. Last Hidden State
   Last hidden state adalah keluaran dari lapisan terakhir dari encoder transformer. Ini mewakili makna yang terkontekstualisasi dari teks input dan digunakan sebagai dasar untuk banyak tugas turunan.

Cara Mendapatkan Lsat Hidden State

Untuk mendapatkan last hidden state dalam model BERT, Anda dapat menggunakan pustaka transformers di Python. Berikut adalah contoh potongan kode yang menunjukkan cara melakukannya:

import torch
from transformers import BertTokenizer, BertModel

# Load the pre-trained BERT model and tokenizer
model_name = 'bert-base-uncased'
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertModel.from_pretrained(model_name)

# Define the input text
text = "This is a sample input sentence."

# Tokenize the input text and convert it to a tensor
tokens = tokenizer.encode(text, add_special_tokens=True)
input_tensor = torch.tensor([tokens])

# Get the last hidden state from the model
with torch.no_grad():
    outputs = model(input_tensor)
    last_hidden_state = outputs[0][:, -1, :]

Dalam kode ini, pertama-tama kita memuat model BERT dan tokenizer yang telah dilatih sebelumnya menggunakan metode from_pretrained. Kemudian kita mendefinisikan teks input dan menerjemahkannya menggunakan metode encode tokenizer. Kita menambahkan token khusus [CLS] dan [SEP] untuk menandai awal dan akhir dari urutan input.

Selanjutnya, kita mengonversi input yang diterjemahkan ke tensor dan meneruskannya melalui model BERT menggunakan objek model. Variabel outputs berisi tuple tensor output dari model, di mana elemen pertama adalah last hidden state.

Akhirnya, kita mengekstrak last hidden state dari tensor output menggunakan indeks. Last hidden state merepresentasikan makna kontekstual dari teks input dan dapat digunakan untuk tugas NLP yang lebih lanjut atau analisis.

Perlu diperhatikan bahwa kita membungkus langkah maju model dalam blok torch.no_grad() untuk menonaktifkan perhitungan gradien, karena kita hanya tertarik pada output dan tidak memperbarui parameter model.

Fein-Tuning Last Hidden State dalam BERT

Fein-tuning last hidden state dalam BERT adalah langkah penting dalam menggunakan model untuk tugas downstream tertentu. Berikut adalah langkah-langkah yang terlibat dalam fein-tuning last hidden state dalam BERT:

Instal Library yang Dibutuhkan

Untuk memulai, instal library yang dibutuhkan: PyTorch, transformers, dan scikit-learn. Anda dapat menginstalnya menggunakan pip:

$ pip install torch
$ pip install transformers
$ pip install scikit-learn

Muat Model BERT Pre-Trained

Selanjutnya, muat model BERT pre-trained dari pustaka transformers. Misalnya, untuk memuat model BERT-base pre-trained, gunakan kode berikut:

from transformers import BertTokenizer, BertForSequenceClassification

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')

Muat dan Pra-Proses Data

Muat dan pra-proses data untuk tugas downstream. Misalnya, jika tugasnya adalah analisis sentimen, muat dataset analisis sentimen dan pra-proses data menggunakan tokenizer.

import pandas as pd

df = pd.read_csv('sentiment_analysis_dataset.csv')
texts = df['text'].values
labels = df['label'].values

inputs = tokenizer(texts.tolist(), padding=True, truncation=True, return_tensors="pt")
inputs['labels'] = torch.tensor(labels)

Fein-Tuning BERT

Fein-tune model BERT pre-trained untuk tugas downstream. Ini melibatkan menambahkan lapisan yang khusus untuk tugas di atas BERT dan melatih model menggunakan data yang telah di pra-proses.

optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)

for epoch in range(3):
    model.train()
    outputs = model(**inputs)
    loss = outputs.loss
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

Evaluasi Model

Evaluasi model yang telah dilatih pada set validasi untuk mengevaluasi kinerjanya pada tugas downstream.

model.eval()
outputs = model(**inputs)

predictions = outputs.logits.argmax(dim=-1).numpy()
true_labels = inputs['labels'].numpy()

from sklearn.metrics import accuracy_score

accuracy = accuracy_score(true_labels, predictions)
print("Accuracy:", accuracy)