පහුගිය කොටස් කීපය තුළ අපි අපේ උපරිමයෙන් උත්සාහ කළේ බොහෝ වැඩ අතින් කිරීමටයි. අපි ටෝකනකාරක ක්රියා කරන ආකාරය ගවේෂණය කර ඇති අතර ටෝකනීකරණය, ආදාන හැඳුනුම්පත් බවට පරිවර්තනය කිරීම, උපධාන, කප්පාදුව සහ අවධාන ආවරණ දෙස බැලුවෙමු.
කෙසේ වෙතත්, අපි 2 කොටසේ දුටු පරිදි, 🤗 පරිවර්තක API ට ඉහළ මට්ටමේ කාර්යයක් සමඟින් අප වෙනුවෙන් මේ සියල්ල හැසිරවිය හැක. ඒ ගැන මෙහිදී සලකා බලමු. ඔබ ඔබේ tokenizer
වාක්යයට කෙලින්ම යෙදු විට, ඔබට ඔබේ ආකෘතිය හරහා යාමට සුදානම් වූ ආදාන නැවත ලැබේ:
from transformers import AutoTokenizer
checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
sequence = "I've been waiting for a HuggingFace course my whole life."
model_inputs = tokenizer(sequence)
මෙහිදී, model_inputs
විචල්යයේ ආකෘතියක් හොඳින් ක්රියාත්මක වීමට අවශ්ය සියල්ල අඩංගු වේ. DistilBERT සඳහා, එයට ආදාන හැඳුනුම්පත් මෙන්ම අවධාන ආවරණයද ඇතුළත් වේ. අමතර ආදාන පිළිගන්නා අනෙකුත් ආකෘතියවල ද එම ප්රතිදානය tokenizer
වස්තුව මගින් ඇත.
පහත උදාහරණ කිහිපයකින් අපි දකින පරිදි, මෙම ක්රමය ඉතා බලවත් වේ. පළමුව, එය තනි අනුපිළිවෙලක් ටෝකනිකරණය කළ හැකිය:
sequence = "I've been waiting for a HuggingFace course my whole life."
model_inputs = tokenizer(sequence)
එය API හි කිසිදු වෙනසක් නොමැතිව වරකට බහු අනුපිළිවෙලවල් හසුරුවයි:
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
model_inputs = tokenizer(sequences)
එය අරමුණු කිහිපයක් අනුව උපධාන කළ හැකිය:
# Will pad the sequences up to the maximum sequence length
model_inputs = tokenizer(sequences, padding="longest")
# Will pad the sequences up to the model max length
# (512 for BERT or DistilBERT)
model_inputs = tokenizer(sequences, padding="max_length")
# Will pad the sequences up to the specified max length
model_inputs = tokenizer(sequences, padding="max_length", max_length=8)
එයට අනුපිළිවෙලවල් කප්පාදු කිරීමට ද හැකිය:
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
# Will truncate the sequences that are longer than the model max length
# (512 for BERT or DistilBERT)
model_inputs = tokenizer(sequences, truncation=True)
# Will truncate the sequences that are longer than the specified max length
model_inputs = tokenizer(sequences, max_length=8, truncation=True)
tokenizer
වස්තුවට නිශ්චිත රාමු ආතානක වෙත පරිවර්තනය හැසිරවිය හැක, පසුව එය සෘජුවම ආකෘතිය වෙත යැවිය හැක. උදාහරණයක් ලෙස, පහත කේත නියැදියේ අපි විවිධ රාමු වලින් ආතානක ආපසු ලබා දීමට ටෝකනකාරක පොළඹවමු - "pt"
PyTorch ආතානක ලබා දෙයි, "tf"
TensorFlow ආතානක ලබා දෙයි, සහ "np"
NumPy අරා ලබා දෙයි:
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
# Returns PyTorch tensors
model_inputs = tokenizer(sequences, padding=True, return_tensors="pt")
# Returns TensorFlow tensors
model_inputs = tokenizer(sequences, padding=True, return_tensors="tf")
# Returns NumPy arrays
model_inputs = tokenizer(sequences, padding=True, return_tensors="np")
අපි ටෝකනකාරක මඟින් ආපසු ලබා දෙන ආදාන හැඳුනුම්පත් දෙස බැලුවහොත්, ඒවා අප කලින් තිබූ ඒවාට වඩා කුඩා වෙනසක් ඇති බව අපට පෙනෙනු ඇත:
sequence = "I've been waiting for a HuggingFace course my whole life."
model_inputs = tokenizer(sequence)
print(model_inputs["input_ids"])
tokens = tokenizer.tokenize(sequence)
ids = tokenizer.convert_tokens_to_ids(tokens)
print(ids)
[101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102]
[1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012]
ආරම්භයේදී එක් සංකේත හැඳුනුම්පතක් එකතු කරන ලද අතර අවසානයේ එකක් එකතු කරන ලදී. මෙය කුමක් දැයි බැලීමට ඉහත හැඳුනුම්පත් අනුපිළිවෙල දෙක විකේතනය කරමු:
print(tokenizer.decode(model_inputs["input_ids"]))
print(tokenizer.decode(ids))
"[CLS] i've been waiting for a huggingface course my whole life. [SEP]"
"i've been waiting for a huggingface course my whole life."
ටෝකනකාරක ආරම්භයේදී විශේෂ වචනය [CLS]
සහ අවසානයේ [SEP]
විශේෂ වචනය එක් කළේය. මක්නිසාද යත්, ආකෘතිය ඒවා සමඟ පූර්ව පුහුණු කර ඇති නිසා, අනුමාන සඳහා සමාන ප්රතිඵල ලබා ගැනීමට අප ඒවා ද එකතු කළ යුතුය. සමහර ආකෘතීන් විශේෂ වචන එකතු නොකරන බව සලකන්න, හෝ වෙනස් ඒවා එකතු නොකරයි; ආකෘති වලට මෙම විශේෂ වචන එකතු කළ හැක්කේ මුලදී හෝ අවසානයේ පමණි. ඕනෑම අවස්ථාවක, ටෝකනකාරක බලාපොරොත්තු වන්නේ කුමන ඒවාදැයි දන්නා අතර ඔබ වෙනුවෙන් මෙය සිදු කරනු ඇත.
දැන් අපි tokenizer
වස්තුව පාඨ මත යොදන විට භාවිතා කරන සියලුම පියවරයන් දැක ඇති බැවින්, එය බහු අනුපිළිවෙලවල් (උපධාන!), ඉතා දිගු අනුපිළිවෙලවල් (කප්පාදු කිරීම!) සහ එහි ප්රධාන API සමඟ විවිධ වර්ගවල ආතානක හැසිරවිය හැකි ආකාරය අපි අවසන් වරට බලමු:
import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification
checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
tokens = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt")
output = model(**tokens)