Pendahuluan

Mendefinisikan kelas model BERT khusus melibatkan pembuatan arsitektur jaringan saraf baru yang menggunakan model BERT yang sudah dilatih sebelumnya sebagai basis. Hal ini memungkinkan penambahan lapisan yang khusus untuk tugas tertentu yang dapat menyesuaikan model untuk tugas Pemrosesan Bahasa Alami (NLP) yang spesifik.

Kelas model BERT khusus dapat didefinisikan menggunakan kerangka pembelajaran mesin seperti PyTorch, dan prosesnya melibatkan menentukan dimensi masukan dan keluaran, arsitektur model BERT, dan lapisan tugas khusus. Kelas ini kemudian dapat digunakan untuk penyetelan ulang model BERT yang sudah dilatih sebelumnya pada dataset tugas spesifik.

Mendefinisikan Model BERT Khusus

Berikut adalah panduan langkah demi langkah dengan contoh kode untuk mendefinisikan kelas model BERT khusus menggunakan PyTorch.

Langkah 1: Impor pustaka yang diperlukan

import torch
from transformers import BertModel
from torch import nn

Anda perlu mengimpor pustaka PyTorch dan Transformers untuk mendefinisikan model BERT khusus Anda.

Langkah 2: Tentukan arsitektur model BERT khusus

class CustomBERTModel(nn.Module):
    def __init__(self, num_classes):
        super(CustomBERTModel, self).__init__()
        self.bert = BertModel.from_pretrained('bert-base-uncased')
        self.dropout = nn.Dropout(0.3)
        self.linear = nn.Linear(768, num_classes)

Anda perlu menentukan arsitektur dari model BERT khusus Anda dengan membuat subclass dari kelas nn.Module dan menyesuaikannya sesuai kebutuhan Anda. Dalam contoh ini, kita menentukan kelas CustomBERTModel yang mengambil argumen num_classes yang menentukan jumlah kelas output untuk lapisan linear.

Metode __init__ menginisialisasi model BERT dari model BERT yang telah dilatih sebelumnya di pustaka Transformers, menambahkan lapisan dropout dengan dropout rate 0,3, dan lapisan linear untuk output.

Langkah 3: Tentukan proses forward

    def forward(self, input_ids, attention_mask):
        output = self.bert(input_ids=input_ids, attention_mask=attention_mask)
        output = output[1] # take the pooled output
        output = self.dropout(output)
        output = self.linear(output)
        return output

Dalam proses forward model Anda, Anda perlu menentukan bagaimana teks input akan diproses dan diubah oleh model BERT. Anda dapat menggunakan kelas BertModel dari pustaka Transformers untuk ini.

Kita melewatkan input_ids dan attention_mask ke model BERT, dan mengambil output kedua yang merupakan output terpool dari lapisan terakhir model BERT. Kemudian, kita menerapkan dropout dan lapisan linear ke output terpool untuk mendapatkan output akhir.

Langkah 4: Gunakan model BERT khusus Anda

model = CustomBERTModel(num_classes=2)
input_ids = torch.tensor([[1, 2, 3, 0, 0], [4, 5, 6, 7, 0]])
attention_mask = torch.tensor([[1, 1, 1, 0, 0], [1, 1, 1, 1, 0]])
output = model(input_ids, attention_mask)

Anda dapat membuat sebuah instansi dari kelas CustomBERTModel dan memberikan argumen num_classes untuk menentukan jumlah kelas output untuk lapisan linear.

Anda kemudian dapat melewatkan teks input sebagai tensor input_ids dan attention_mask ke model untuk mendapatkan prediksi output.

Berikut adalah contoh kode keseluruhan.

import torch
from transformers import BertModel
from torch import nn

class CustomBERTModel(nn.Module):
    def __init__(self, num_classes):
        super(CustomBERTModel, self).__init__()
        self.bert = BertModel.from_pretrained('bert-base-uncased')
        self.dropout = nn.Dropout(0.3)
        self.linear = nn.Linear(768, num_classes)

    def forward(self, input_ids, attention_mask):
        output = self.bert(input_ids=input_ids, attention_mask=attention_mask)
        output = output[1] # take the pooled output
        output = self.dropout(output)
        output = self.linear(output)
        return output

model = CustomBERTModel(num_classes=2)
input_ids = torch.tensor([[1, 2, 3, 0, 0], [4, 5, 6, 7, 0]])
attention_mask = torch.tensor([[1, 1, 1, 0, 0], [1, 1, 1, 1, 0]])
output = model(input_ids, attention_mask)

Contoh Model BERT Kustom

Berikut beberapa contoh kelas model BERT kustom dengan penjelasannya.

Fine-tuning BERT untuk Analisis Sentimen

class SentimentClassifier(nn.Module):
    def __init__(self, num_classes):
        super(SentimentClassifier, self).__init__()
        self.bert = BertModel.from_pretrained('bert-base-uncased')
        self.dropout = nn.Dropout(0.1)
        self.linear = nn.Linear(768, num_classes)

    def forward(self, input_ids, attention_mask):
        output = self.bert(input_ids=input_ids, attention_mask=attention_mask)
        output = output[1] # take the pooled output
        output = self.dropout(output)
        output = self.linear(output)
        return output

Pada contoh ini, kita mendefinisikan kelas model BERT kustom SentimentClassifier untuk analisis sentimen.

Arsitektur model ini sama dengan contoh pada jawaban sebelumnya. Kita menginisialisasi model BERT dari model BERT yang telah dilatih sebelumnya di perpustakaan Transformers, menambahkan lapisan dropout dengan tingkat dropout 0,1, dan lapisan linear untuk output.

Pada proses maju, kita meneruskan input_ids dan attention_mask ke model BERT dan mengambil output kedua yang merupakan output dipool terakhir dari model BERT. Kemudian, kita menerapkan dropout dan lapisan linear pada output dipool untuk mendapatkan output akhir.

Fine-tuning BERT untuk Pengenalan Entitas Bernama

class NERClassifier(nn.Module):
    def __init__(self, num_classes):
        super(NERClassifier, self).__init__()
        self.bert = BertModel.from_pretrained('bert-base-uncased')
        self.dropout = nn.Dropout(0.1)
        self.classifier = nn.Linear(768, num_classes)

    def forward(self, input_ids, attention_mask):
        output = self.bert(input_ids=input_ids, attention_mask=attention_mask)
        output = output.last_hidden_state
        output = self.dropout(output)
        output = self.classifier(output)
        return output

Dalam contoh ini, kita mendefinisikan kelas model BERT khusus NERClassifier untuk pengenalan entitas bernama (NER).

Arsitektur model ini mirip dengan contoh sebelumnya, dengan tambahan lapisan linear untuk klasifikasi.

Dalam proses maju, kita meneruskan input_ids dan attention_mask ke model BERT dan mengambil status tersembunyi terakhir dari lapisan terakhir model BERT. Kemudian kita menerapkan dropout dan lapisan linear ke status tersembunyi untuk mendapatkan output akhir.

Fine-tuning BERT untuk Pertanyaan dan Jawaban

class QAClassifier(nn.Module):
    def __init__(self, num_classes):
        super(QAClassifier, self).__init__()
        self.bert = BertModel.from_pretrained('bert-base-uncased')
        self.qa_outputs = nn.Linear(768, num_classes)

    def forward(self, input_ids, attention_mask):
        outputs = self.bert(input_ids, attention_mask=attention_mask)
        sequence_output = outputs.last_hidden_state
        logits = self.qa_outputs(sequence_output)
        start_logits, end_logits = logits.split(1, dim=-1)
        start_logits = start_logits.squeeze(-1)
        end_logits = end_logits.squeeze(-1)
        return start_logits, end_logits

Dalam contoh ini, kita mendefinisikan kelas model BERT khusus QAClassifier untuk pertanyaan dan jawaban.

Arsitektur model ini mirip dengan contoh sebelumnya, dengan tambahan lapisan linear untuk pertanyaan dan jawaban.

Dalam proses maju, kita meneruskan input_ids dan attention_mask ke model BERT dan mengambil status tersembunyi terakhir dari lapisan terakhir model BERT. Kemudian kita menerapkan lapisan linear ke status tersembunyi untuk mendapatkan logit. Kita memisahkan logit menjadi dua bagian untuk posisi awal dan akhir jawaban menggunakan metode split. Kemudian kita menyempitkan dimensi terakhir dari logit dan mengembalikan logit awal dan akhir secara terpisah.

Menyimpan dan Berbagi Model BERT Kustom Anda

Menyimpan dan berbagi model BERT PyTorch kustom melibatkan beberapa langkah sederhana.

Menyimpan model

Setelah melatih model BERT kustom, ia dapat disimpan ke file menggunakan metode torch.save(). Metode ini menyimpan kamus status model, yang mencakup arsitektur dan bobot.

torch.save(model.state_dict(), 'my_bert_model.pth')

Ini akan menyimpan kamus status model ke file bernama my_bert_model.pth.

Zip file model yang disimpan

Untuk berbagi file model yang disimpan dengan orang lain, file model yang disimpan dapat di-zip menjadi satu file.

$ zip my_bert_model.zip my_bert_model.pth

Ini akan membuat file ZIP bernama my_bert_model.zip yang berisi file model yang disimpan.

Berbagi file ZIP

File ZIP dapat dibagikan dengan orang lain melalui email, layanan penyimpanan cloud, atau cara lain.

Memuat model yang disimpan

Untuk memuat model yang disimpan di skrip atau aplikasi lain, arsitektur model harus didefinisikan terlebih dahulu, dan kemudian kamus status yang disimpan dapat dimuat menggunakan metode load_state_dict().

from transformers import BertModel

model = BertModel.from_pretrained('bert-base-uncased')
model.load_state_dict(torch.load('my_bert_model.pth'))

Ini akan memuat kamus status yang disimpan ke dalam model BERT yang telah dilatih sebelumnya, menciptakan objek model PyTorch baru yang dapat digunakan untuk membuat prediksi pada data baru.