Machine Learning Academy · Pelajaran

Tokenizer Hugging Face: Mengekod Teks untuk BERT

Pelajar akan memuatkan BertTokenizer, menokenkan sekumpulan ayat, memeriksa tensor input_ids dan attention_mask, serta mengendalikan pemotongan dan penambahan padding.

Pelajaran 2 daripada 413 langkah

Tokenizer Hugging Face: Mengekod Teks untuk BERT ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Machine Learning Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.

Mengapa Pembahagian Token Penting untuk BERT

Sebelum BERT dapat memproses teks, setiap jujukan aksara mesti ditukar kepada ID berangka yang difahami oleh model. Pembahagian token ialah proses memecahkan teks kepada unit subperkataan (token) dan memetakannya kepada ID integer daripada perbendaharaan kata tetap. Pembahagian token yang tepat amat penting: strategi padding yang salah, topeng perhatian yang tiada atau pemotongan yang tidak betul boleh merosakkan input model secara senyap dan menjejaskan ketepatan.

Memasang Hugging Face Transformers

Pustaka Hugging Face Transformers menyediakan model dan penanda token terlatih untuk ratusan seni bina. Pasang pustaka ini bersama-sama datasets untuk pemuatan data dan torch sebagai bahagian belakang. Pustaka ini mengikut API yang konsisten: bina penanda token menggunakan from_pretrained, berikan teks kepadanya dan terima tensor yang sedia digunakan.

# Install dependencies
# pip install transformers datasets torch

from transformers import BertTokenizer
import torch

# Load the pre-trained BERT tokenizer (downloads ~200 KB vocab file)
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
print('Vocabulary size:', tokenizer.vocab_size)  # 30522
print('Max length:', tokenizer.model_max_length)  # 512

Membahagikan Token bagi Satu Ayat

Memanggil penanda token pada rentetan mengembalikan kamus yang mengandungi input_ids (ID token integer), attention_mask (1 untuk token sebenar) dan, secara pilihan, token_type_ids (ID segmen). Penanda token menambahkan [CLS] secara automatik pada permulaan dan [SEP] pada penghujung. Menetapkan return_tensors='pt' mengembalikan tensor PyTorch yang sedia digunakan oleh model.

from transformers import BertTokenizer

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

text = 'Machine learning is transforming the world.'
encoding = tokenizer(
    text,
    return_tensors='pt',
    truncation=True,
    max_length=128
)

print('input_ids:', encoding['input_ids'])
print('attention_mask:', encoding['attention_mask'])
print('Token count:', encoding['input_ids'].shape[1])

Pembahagian Subperkataan WordPiece

BERT menggunakan pembahagian token WordPiece: perkataan yang jarang atau tidak diketahui dipecahkan kepada cebisan subperkataan yang kerap muncul daripada perbendaharaan kata. Perkataan seperti 'tokenisation' mungkin menjadi ['token', '##isation'], dengan ## menandakan subperkataan sambungan. Kaedah ini mengendalikan perkataan di luar perbendaharaan kata tanpa sandaran token tidak diketahui, sambil mengekalkan maklumat morfologi yang hilang melalui pembahagian seluruh perkataan.

from transformers import BertTokenizer

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

# Inspect raw tokens before converting to IDs
word = 'tokenisation'
pieces = tokenizer.tokenize(word)
print('WordPiece pieces:', pieces)  # ['token', '##isation']

ids = tokenizer.convert_tokens_to_ids(pieces)
print('IDs:', ids)

# Decode back to text
decoded = tokenizer.decode(ids)
print('Decoded:', decoded)

Pembahagian Token Kelompok dengan Padding

Latihan sebenar menggunakan kelompok mini yang mengandungi ayat dengan panjang berbeza. Pilihan padding=True bagi penanda token mengisi jujukan yang lebih pendek dengan token [PAD] supaya sepadan dengan jujukan terpanjang dalam kelompok. attention_mask memastikan model mengabaikan kedudukan padding ini semasa pengiraan perhatian. Sentiasa lakukan padding sehingga panjang maksimum kelompok, bukannya panjang maksimum model, untuk mengelakkan pembaziran pengiraan.

from transformers import BertTokenizer

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

sentences = [
    'Short.',
    'This is a much longer sentence for demonstration purposes.'
]

encoded = tokenizer(
    sentences,
    padding=True,        # pad to longest in batch
    truncation=True,
    max_length=64,
    return_tensors='pt'
)
print('input_ids shape:', encoded['input_ids'].shape)
print('attention_mask:', encoded['attention_mask'])

Pemotongan: Mengendalikan Teks Panjang

BERT menerima paling banyak 512 token bagi setiap input (termasuk [CLS] dan [SEP]). Dokumen yang lebih panjang mesti dipotong. Menetapkan truncation=True bersama max_length=512 akan memotong pada had token. Untuk tugasan seperti pengelasan dokumen, strategi lazim termasuk menggunakan hanya 512 token pertama, 512 token terakhir (yang selalunya lebih bermaklumat), atau memecahkan dokumen kepada tetingkap bertindih lalu menggabungkan ramalan.

from transformers import BertTokenizer

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

long_text = 'word ' * 600  # 600 words -- too long for BERT

# Strategy 1: truncate to first 512 tokens
encoded_first = tokenizer(long_text, truncation=True, max_length=512)
print('First 512 length:', len(encoded_first['input_ids']))

# Strategy 2: only take the last 510 tokens + [CLS] + [SEP]
tokens = tokenizer.tokenize(long_text)[-510:]
encoded_last = [tokenizer.cls_token] + tokens + [tokenizer.sep_token]
print('Last-window length:', len(encoded_last))

Input Pasangan Ayat untuk BERT

Tugasan seperti menjawab soalan dan penaakulan bahasa semula jadi memerlukan dua ayat diberikan kepada BERT secara serentak. Penanda token menerima dua argumen: tokenizer(sentence_a, sentence_b). Ia membina input secara automatik sebagai [CLS] A [SEP] B [SEP] dan mengisi token_type_ids dengan 0 untuk token ayat A dan 1 untuk token ayat B, supaya BERT dapat membezakan kedua-dua segmen.

from transformers import BertTokenizer

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

question = 'Where was Marie Curie born?'
context = 'Marie Curie was born in Warsaw, Poland in 1867.'

encoded = tokenizer(
    question,
    context,
    truncation=True,
    max_length=128,
    return_tensors='pt'
)

print('token_type_ids:', encoded['token_type_ids'])
# 0 = question tokens, 1 = context tokens

AutoTokenizer: Pemuatan Tanpa Bergantung pada Pembekal

Daripada mengimport kelas khusus model, gunakan AutoTokenizer daripada Hugging Face. Ia memilih kelas penanda token yang betul secara automatik berdasarkan nama titik semak model. Hal ini menjadikan kod anda mudah alih: menukar 'bert-base-uncased' kepada 'roberta-base' atau 'distilbert-base-uncased' hanya memerlukan perubahan pada satu rentetan, manakala semua logik penanda token dikendalikan secara automatik.

from transformers import AutoTokenizer

# Works for BERT, RoBERTa, DistilBERT, GPT-2, and more
tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')

# Exact same API regardless of model family
text = 'Transfer learning is powerful.'
encoded = tokenizer(text, return_tensors='pt')
print(encoded['input_ids'])

# Switching models is trivial:
# tokenizer = AutoTokenizer.from_pretrained('roberta-base')

Penyahkodan: ID Kembali kepada Teks

Anda boleh menukar ID token kembali kepada teks yang boleh dibaca manusia menggunakan tokenizer.decode(ids). Ini berguna untuk menyahpepijat pembahagian token dan untuk tugasan jujukan kepada jujukan (penterjemahan, peringkasan), apabila model menghasilkan ID token yang mesti dinyahkodkan kepada teks. Gunakan skip_special_tokens=True untuk membuang [CLS], [SEP] dan [PAD] daripada output.

from transformers import BertTokenizer

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

text = 'Hello, world!'
ids = tokenizer.encode(text)
print('Encoded IDs:', ids)  # includes [CLS]=101 and [SEP]=102

decoded = tokenizer.decode(ids, skip_special_tokens=True)
print('Decoded text:', decoded)  # 'hello, world!'

decoded_with_special = tokenizer.decode(ids)
print('With special tokens:', decoded_with_special)  # '[CLS] hello, world! [SEP]'

Membina DataLoader untuk Penalaan Halus

Semasa penalaan halus, ayat dibahagikan kepada token dalam kelompok menggunakan DataLoader PyTorch. Dataset tersuai menyimpan teks mentah dan label; pembahagian token berlaku dalam __getitem__ atau melalui fungsi penggabungan. Membahagikan token dalam DataLoader membolehkan pemprosesan secara langsung dan mengelakkan penyimpanan tensor besar yang telah dibahagikan kepada token dalam memori untuk set data besar.

import torch
from torch.utils.data import Dataset, DataLoader
from transformers import BertTokenizer

class SentimentDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_len=128):
        self.texts = texts
        self.labels = labels
        self.tokenizer = tokenizer
        self.max_len = max_len

    def __len__(self):
        return len(self.texts)

    def __getitem__(self, idx):
        enc = self.tokenizer(
            self.texts[idx],
            truncation=True, padding='max_length',
            max_length=self.max_len, return_tensors='pt'
        )
        return {
            'input_ids': enc['input_ids'].squeeze(),
            'attention_mask': enc['attention_mask'].squeeze(),
            'label': torch.tensor(self.labels[idx], dtype=torch.long)
        }

Penanda Token Pantas dan Pemetaan Offset

Hugging Face menyediakan penanda token pantas (disokong oleh Rust) yang 10 hingga 100 kali lebih pantas berbanding versi Python tulen. Penanda token ini turut menyokong pemetaan offset: bagi setiap token, anda mendapat kedudukan mula dan akhir aksara dalam rentetan asal. Ini penting untuk tugasan pada peringkat token seperti pengecaman entiti bernama dan menjawab soalan, apabila anda perlu memetakan output model kembali kepada rentang aksara dalam teks sumber.

from transformers import BertTokenizerFast

tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')

text = 'Paris is lovely.'
encoded = tokenizer(text, return_offsets_mapping=True)

for token_id, offset in zip(encoded['input_ids'], encoded['offset_mapping']):
    token = tokenizer.convert_ids_to_tokens([token_id])[0]
    print(f'{token:15s} -> chars {offset}')
# paris           -> chars (0, 5)
# is              -> chars (6, 8)

Semakan Pantas

Uji pemahaman anda tentang konsep Pembelajaran Mesin dengan Python daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Rumusan Pelajaran

Dalam pelajaran ini, anda mempelajari bahawa: BertTokenizer menukar teks mentah kepada tensor input_ids, attention_mask dan token_type_ids, pembahagian subperkataan WordPiece mengendalikan perkataan di luar perbendaharaan kata dengan baik, dan padding dengan topeng perhatian serta pemotongan kepada 512 token diperlukan apabila mengelompokkan input yang panjangnya berbeza. Seterusnya, kita akan menala halus BertForSequenceClassification pada set data sentimen sebenar.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Tokenizer Hugging Face: Mengekod Teks untuk BERT” percuma?

Ya — teks penuh “Tokenizer Hugging Face: Mengekod Teks untuk BERT” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Machine Learning Academy, tingkat taraf kepada CoddyKit PRO. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Tokenizer Hugging Face: Mengekod Teks untuk BERT”?

Pelajar akan memuatkan BertTokenizer, menokenkan sekumpulan ayat, memeriksa tensor input_ids dan attention_mask, serta mengendalikan pemotongan dan penambahan padding. Anda berlatih Machine Learning Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Machine Learning Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Machine Learning Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Tokenizer Hugging Face: Mengekod Teks untuk BERT” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Machine Learning Academy ini?

Ya. Setiap pelajaran Machine Learning Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Seni Bina Transformer: Perhatian, Token dan Konteks
Tokenizer Hugging Face: Mengekod Teks untuk BERT
Penalaan Halus BertForSequenceClassification
Penilaian dan Inferens: daripada Logit kepada Label Ramalan

← Kembali ke Machine Learning Academy