Machine Learning Academy · leksjon

Hugging Face-tokenizere: Kode tekst for BERT

Deltakere vil laste inn BertTokenizer, tokenisere en gruppe setninger, undersøke input_ids- og attention_mask-tensorene og håndtere trunkering og utfylling.

Leksjon 2 av 413 trinn

Hugging Face-tokenizere: Kode tekst for BERT er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Machine Learning Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hvorfor tokenisering er viktig for BERT

Før BERT kan behandle tekst, må hver tegnsekvens konverteres til numeriske ID-er som modellen forstår. Tokenisering er prosessen med å dele tekst opp i underordsenheter (token) og tilordne dem heltalls-ID-er fra et fast vokabular. Det er avgjørende å få tokeniseringen riktig: feil utfyllingsstrategi, manglende oppmerksomhetsmasker eller feilaktig trunkering kan ubemerket ødelegge modellens inndata og svekke nøyaktigheten.

Installere Hugging Face Transformers

Biblioteket Hugging Face Transformers tilbyr forhåndstrente modeller og tokeniserere for hundrevis av arkitekturer. Installer det sammen med datasets for innlasting av data og torch som backend. Biblioteket følger et enhetlig API: instansier en tokeniserer med from_pretrained, send inn tekst, og motta tensorer som kan brukes direkte.

# 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 av én setning

Når De kaller tokenisereren med en streng, returneres en ordbok som inneholder input_ids (heltalls-ID-er for token), attention_mask (1 for ekte token) og eventuelt token_type_ids (segment-ID-er). Tokenisereren legger automatisk til [CLS] i starten og [SEP] på slutten. Hvis De setter return_tensors='pt', returneres PyTorch-tensorer som er klare for 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-subtokenisering

BERT bruker WordPiece-tokenisering: sjeldne eller ukjente ord deles opp i hyppige underordsenheter fra vokabularet. Et ord som «tokenisation» kan for eksempel bli til ['token', '##isation'], der ## markerer et fortsettelsessubtoken. Dette håndterer ord utenfor vokabularet uten å falle tilbake på et ukjent-token, og bevarer morfologisk informasjon som helordstokenisering mister.

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 utfylling

Ved faktisk trening brukes minibatcher med setninger av ulik lengde. Alternativet padding=True i tokenisereren fyller ut kortere sekvenser med [PAD]-token slik at de får samme lengde som den lengste sekvensen i batchen. attention_mask sørger for at modellen ignorerer disse utfyllingsposisjonene under beregningen av oppmerksomhet. Utfyll alltid til maksimumslengden i batchen, ikke til modellens maksimumslengde, for å unngå 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 av lang tekst

BERT godtar maksimalt 512 token per inndata (inkludert [CLS] og [SEP]). Lengre dokumenter må trunkeres. Ved å sette truncation=True sammen med max_length=512 kuttes teksten ved token-grensen. For oppgaver som dokumentklassifisering er vanlige strategier å bruke bare de første 512 tokenene, de siste 512 tokenene (som ofte er mer informative), eller å dele dokumentet opp i overlappende vinduer og aggregere prediksjonene.

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

Inndata med setningspar for BERT

Oppgaver som spørsmålssvar og inferens i naturlig språk krever at to setninger sendes til BERT samtidig. Tokenisereren godtar to argumenter: tokenizer(sentence_a, sentence_b). Den bygger automatisk inndataene som [CLS] A [SEP] B [SEP] og fyller ut token_type_ids med 0 for tokenene i setning A og 1 for tokenene i setning B, slik at BERT kan skille mellom de to segmentene.

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: leverandøruavhengig innlasting

I stedet for å importere modellspesifikke klasser kan De bruke AutoTokenizer fra Hugging Face. Den velger automatisk riktig tokenisererklasse basert på navnet på modellkontrollpunktet. Dette gjør koden portabel: Hvis De bytter ut 'bert-base-uncased' med 'roberta-base' eller 'distilbert-base-uncased', trenger De bare å endre én streng, mens all tokeniseringslogikk 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')

Dekoding: fra ID-er tilbake til tekst

De kan konvertere token-ID-er tilbake til lesbar tekst med tokenizer.decode(ids). Dette er nyttig ved feilsøking av tokenisering og for sekvens-til-sekvens-oppgaver (oversettelse, oppsummering), der modellen produserer token-ID-er som må dekodes til tekst. Bruk skip_special_tokens=True for å fjerne [CLS], [SEP] og [PAD] fra resultatet.

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

Bygge en DataLoader for finjustering

Under finjustering tokeniseres setninger i batcher ved hjelp av en PyTorch-DataLoader. Et egendefinert Dataset lagrer råtekster og etiketter; tokeniseringen skjer i __getitem__ eller via en collate-funksjon. Tokenisering inne i DataLoader-en muliggjør behandling underveis og unngår at store, forhåndstokeniserte tensorer lagres i minnet for store datasett.

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

Raske tokeniserere og offset-tilordning

Hugging Face tilbyr raske tokeniserere (basert på Rust) som er 10–100 ganger raskere enn de rene Python-versjonene. De støtter også offset-tilordning: for hvert token får De start- og sluttposisjonen i den opprinnelige strengen. Dette er avgjørende for token-nivåoppgaver som navngitt entitetsgjenkjenning og spørsmålssvar, der modellresultatene må knyttes tilbake 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)

Kort kontroll

Test forståelsen Deres av Machine Learning with Python-konseptene fra denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte De at BertTokenizer konverterer råtekst til tensorene input_ids, attention_mask og token_type_ids, at WordPiece-oppsplitting i underordsenheter håndterer ord utenfor vokabularet på en god måte, og at utfylling med oppmerksomhetsmasker samt trunkering til 512 token er nødvendig ved batching av inndata med ulik lengde. Neste steg er å finjustere BertForSequenceClassification på et ekte datasett for sentimentanalyse.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 30
Leksjoner: 120

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Hugging Face-tokenizere: Kode tekst for BERT» gratis?

Ja – hele teksten i «Hugging Face-tokenizere: Kode tekst for BERT» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Machine Learning Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Hugging Face-tokenizere: Kode tekst for BERT»?

Deltakere vil laste inn BertTokenizer, tokenisere en gruppe setninger, undersøke input_ids- og attention_mask-tensorene og håndtere trunkering og utfylling. Du øver på Machine Learning Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Machine Learning Academy?

Ingen tidligere erfaring er nødvendig. Machine Learning Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Hugging Face-tokenizere: Kode tekst for BERT»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Machine Learning Academy-leksjonen?

Ja. Alle Machine Learning Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Transformerarkitektur: Attention, tokens og kontekst
Hugging Face-tokenizere: Kode tekst for BERT
Finjustere BertForSequenceClassification
Evaluering og inferens: Fra logits til predikerte etiketter

← Tilbake til Machine Learning Academy