Machine Learning Academy · Lektion

Hugging Face-tokenizere: Kodning af tekst til BERT

De lærende indlæser BertTokenizer, tokeniserer et batch af sætninger, undersøger input_ids- og attention_mask-tensorer og håndterer trunkering og padding.

Lektion 2 af 413 trin

Hugging Face-tokenizere: Kodning af tekst til BERT er en gratis Machine Learning Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Machine Learning Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Machine Learning Academy-kurset indeholder 4 lektioner i alt.

Hvorfor tokenisering er vigtig for BERT

Før BERT kan behandle tekst, skal hver tegnsekvens konverteres til numeriske ID'er, som modellen forstår. Tokenisering er processen, hvor tekst opdeles i subword-enheder (tokens) og knyttes til heltals-ID'er fra et fast ordforråd. Det er afgørende at få tokeniseringen rigtigt: En forkert padding-strategi, manglende attention-masker eller forkert trunkering kan ubemærket ødelægge modellens input og forringe nøjagtigheden.

Installation af Hugging Face Transformers

Biblioteket Hugging Face Transformers indeholder fortrænede modeller og tokenizere til hundredvis af arkitekturer. Installér det sammen med datasets til indlæsning af data og torch som backend. Biblioteket følger en ensartet API: Opret en tokenizer med from_pretrained, giv den tekst, og modtag tensorer, der er klar til brug.

# 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

Tokenisering af en enkelt sætning

Når du kalder tokenizeren på en streng, returnerer den en ordbog med input_ids (heltal for token-ID'er), attention_mask (1 for rigtige tokens) og eventuelt token_type_ids (segment-ID'er). Tokenizeren tilføjer automatisk [CLS] i begyndelsen og [SEP] i slutningen. Hvis du angiver return_tensors='pt', returneres PyTorch-tensorer, der er klar til modellen.

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])

WordPiece-subword-tokenisering

BERT bruger WordPiece-tokenisering: Sjældne eller ukendte ord opdeles i hyppige subword-stykker fra ordforrådet. Et ord som 'tokenisation' kan blive til ['token', '##isation'], hvor ## markerer en fortsættende subword. Det håndterer ord uden for ordforrådet uden et fallback-token for ukendte ord og bevarer morfologisk information, som helordstokenisering går glip af.

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)

Batch-tokenisering med padding

Ved rigtig træning bruges mini-batches med sætninger af forskellig længde. Tokenizerens indstilling padding=True udfylder kortere sekvenser med [PAD]-tokens, så de får samme længde som den længste sekvens i batchen. attention_mask sikrer, at modellen ignorerer disse padding-positioner under beregningen af attention. Udfyld altid til batchens maksimale længde i stedet for modellens maksimale længde, så du undgår unødvendige beregninger.

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'])

Trunkering: Håndtering af lang tekst

BERT accepterer højst 512 tokens pr. input (inklusive [CLS] og [SEP]). Længere dokumenter skal trunkeres. Hvis du angiver truncation=True sammen med max_length=512, afkortes inputtet ved token-grænsen. Til opgaver som dokumentklassifikation kan du for eksempel bruge de første 512 tokens, de sidste 512 tokens (som ofte indeholder mere information) eller opdele dokumentet i overlappende vinduer og samle forudsigelserne.

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 med sætningspar til BERT

Opgaver som besvarelse af spørgsmål og natural language inference kræver, at to sætninger gives til BERT samtidig. Tokenizeren accepterer to argumenter: tokenizer(sentence_a, sentence_b). Den opbygger automatisk inputtet som [CLS] A [SEP] B [SEP] og udfylder token_type_ids med 0 for tokens i sætning A og 1 for tokens i sætning B, så BERT kan skelne mellem de to segmenter.

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: Indlæsning uafhængigt af leverandør

I stedet for at importere modelspecifikke klasser kan du bruge AutoTokenizer fra Hugging Face. Den vælger automatisk den korrekte tokenizer-klasse ud fra navnet på modellens checkpoint. Det gør din kode portabel: Hvis du udskifter 'bert-base-uncased' med 'roberta-base' eller 'distilbert-base-uncased', skal du kun ændre én streng, mens al tokenizer-logik håndteres automatisk.

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')

D worldly?

Du kan konvertere token-ID'er tilbage til tekst, der er læsbar for mennesker, med tokenizer.decode(ids). Det er nyttigt til fejlfinding af tokenisering og til sekvens-til-sekvens-opgaver (oversættelse, opsummering), hvor modellen returnerer token-ID'er, der skal afkodes til tekst. Brug skip_special_tokens=True til at fjerne [CLS], [SEP] og [PAD] fra outputtet.

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]'

Oprettelse af en DataLoader til finjustering

Under finjustering tokeniseres sætninger i batches ved hjælp af en PyTorch-DataLoader. Et brugerdefineret Dataset gemmer rå tekster og labels, mens tokeniseringen sker i __getitem__ eller via en collate-funktion. Tokenisering inde i DataLoaderen muliggør behandling undervejs og undgår at gemme store, forhåndstokeniserede tensorer i hukommelsen for store datasæt.

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)
        }

Hurtige tokenizere og offset-tilknytning

Hugging Face tilbyder hurtige tokenizere (baseret på Rust), som er 10-100 gange hurtigere end versionerne i ren Python. De understøtter også offset-tilknytning: For hver token får du start- og slutpositionen for tegnene i den oprindelige streng. Det er afgørende for token-niveau-opgaver som genkendelse af navngivne entiteter og besvarelse af spørgsmål, hvor modeloutput skal knyttes tilbage til tegnintervaller i kildeteksten.

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)

Hurtigt tjek

Test din forståelse af begreberne inden for Machine Learning med Python fra denne lektion.

Besvar den i den interaktive lektion

Opsummering af lektionen

I denne lektion lærte du, at BertTokenizer konverterer rå tekst til tensorerne input_ids, attention_mask og token_type_ids, at WordPiece-opdeling i subwords håndterer ord uden for ordforrådet på en robust måde, og at padding med attention-masker samt trunkering til 512 tokens er nødvendigt ved batching af input med forskellig længde. Næste gang finjusterer vi BertForSequenceClassification på et rigtigt datasæt med sentimentdata.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 30
Lektioner: 120

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Hugging Face-tokenizere: Kodning af tekst til BERT” gratis?

Ja — hele teksten til “Hugging Face-tokenizere: Kodning af tekst til BERT” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Machine Learning Academy-kurset, skal du opgradere til CoddyKit PRO. Machine Learning Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Hugging Face-tokenizere: Kodning af tekst til BERT”?

De lærende indlæser BertTokenizer, tokeniserer et batch af sætninger, undersøger input_ids- og attention_mask-tensorer og håndterer trunkering og padding. Du øver dig i Machine Learning Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Machine Learning Academy?

Der kræves ingen tidligere erfaring. Machine Learning Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Hugging Face-tokenizere: Kodning af tekst til BERT”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Machine Learning Academy-lektion?

Ja. Alle Machine Learning Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Transformerarkitektur: Attention, tokens og kontekst
Hugging Face-tokenizere: Kodning af tekst til BERT
Finjustering af BertForSequenceClassification
Evaluering og inferens: Fra logits til forudsagte labels

← Tilbage til Machine Learning Academy