පෙර කොටසේදී, අපි සරලම භාවිත අවස්ථා ගවේෂණය කළෙමු: කුඩා දිගක තනි අනුපිළිවෙලක් මත අනුමාන කිරීම. කෙසේ වෙතත්, සමහර ප්රශ්න දැනටමත් මතු වී ඇත:
මෙම ප්රශ්න මතු කරන්නේ කුමන ආකාරයේ ගැටළුද සහ 🤗 පරිවර්තක 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)
sequence = "I've been waiting for a HuggingFace course my whole life."
tokens = tokenizer.tokenize(sequence)
ids = tokenizer.convert_tokens_to_ids(tokens)
input_ids = torch.tensor(ids)
# This line will fail.
model(input_ids)
IndexError: Dimension out of range (expected to be in range of [-1, 0], but got 1)
මෙය අසාර්ථක වූයේ ඇයි? “අපි 2 කොටසේ pipeline යේ පියවර අනුගමනය කළෙමු”.
ගැටළුව වන්නේ අපි ආකෘතියට තනි අනුපිළිවෙලක් යැවීමයි, නමුත් 🤗 පරිවර්තක ආකෘති පෙරනිමියෙන් වාක්ය කිහිපයක් බලාපොරොත්තු වේ. මෙහිදී අපි එය ‘අනුපිළිවෙලකට’ යොදන විට ටෝකනකාරක තිරය පිටුපස කළ සියල්ල කිරීමට උත්සාහ කළෙමු. නමුත් ඔබ සමීපව බැලුවහොත්, ටෝකනකාරක ආදාන හැඳුනුම්පත් ලැයිස්තුව ආතානකයක් බවට පරිවර්තනය පමණක් නොකළ බව ඔබට පෙනෙනු ඇත, එය ඊට ඉහළින් මානයක් ද එක් කළේය:
tokenized_inputs = tokenizer(sequence, return_tensors="pt")
print(tokenized_inputs["input_ids"])
tensor([[ 101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172,
2607, 2026, 2878, 2166, 1012, 102]])
අපි නැවත උත්සාහ කර නව මානයක් එක් කරමු:
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)
sequence = "I've been waiting for a HuggingFace course my whole life."
tokens = tokenizer.tokenize(sequence)
ids = tokenizer.convert_tokens_to_ids(tokens)
input_ids = torch.tensor([ids])
print("Input IDs:", input_ids)
output = model(input_ids)
print("Logits:", output.logits)
අපි ආදාන හැඳුනුම්පත් මෙන්ම ලැබෙන ලඝුකය මුද්රණය කරන්නෙමු - මේ ප්රතිදානය මගින්:
Input IDs: [[ 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012]]
Logits: [[-2.7276, 2.8789]]
කාණ්ඩකරණය යනු ආකෘතිය හරහා වාක්ය කිහිපයක් එකවර යැවීමේ ක්රියාවයි. ඔබට ඇත්තේ එක් වාක්යයක් පමණක් නම්, ඔබට තනි අනුපිළිවෙලක් සහිත කාණ්ඩයක් සෑදිය හැක:
batched_ids = [ids, ids]
මෙය සමාන අනුපිළිවෙල දෙකක කාණ්ඩයකි!
✏️ උත්සාහ කරන්න! මෙම batched_ids
ලැයිස්තුව ආතානකයක් බවට පරිවර්තනය කර එය ඔබේ ආකෘතිය හරහා යවන්න. ඔබ පෙර මෙන් ම ලඝුකය ලබා ගන්නේ දැයි පරීක්ෂා කරන්න (නමුත් දෙවරක්)!
ඔබ එයට වාක්ය කිහිපයක් පෝෂණය කරන විට කාණ්ඩකරණය, ආකෘතියට ක්රියා කිරීමට ඉඩ සලසයි. බහු අනුපිළිවෙලක් භාවිතා කිරීම තනි අනුපිළිවෙලක් සහිත කාණ්ඩයක් ගොඩනැගීම තරම් ම සරල ය. කෙසේ වෙතත්, තවත් ප්රශ්නයක් තිබේ. ඔබ වාක්ය දෙකක් (හෝ වැඩි ගණනක්) එකට එකතු කිරීමට උත්සාහ කරන විට, ඒවා විවිධ දිග විය හැක. ඔබ මීට පෙර කවදා හෝ ආතානක සමඟ වැඩ කර ඇත්නම්, ඒවා සෘජුකෝණාස්රාකාර හැඩයක් තිබිය යුතු බව ඔබ දන්නවා ඇත, එබැවින් ඔබට ආදාන හැඳුනුම්පත් ලැයිස්තුව සෘජුවම ආතානකයක් බවට පරිවර්තනය කිරීමට නොහැකි වනු ඇත. මෙම ගැටලුව විසඳීමට, අපි සාමාන්යයෙන් ආදාන උපධාන කරන්නෙමු.
පහත ලැයිස්තු ලැයිස්තුව ආතානකයක් බවට පරිවර්තනය කළ නොහැක:
batched_ids = [
[200, 200, 200],
[200, 200]
]
මෙය මග හරවා ගැනීම සඳහා, අපගේ ආතානක ඍජුකෝණාස්රාකාර හැඩයක් ඇති කිරීමට අපි උපධාන භාවිතා කරන්නෙමු. අඩු අගයන් සහිත වාක්යවලට උපධාන ටෝකන් නමින් විශේෂ වචනයක් එක් කිරීමෙන් අපගේ සියලුම වාක්යවල දිග සමාන බව උපධානයක් කරයි. උදාහරණයක් ලෙස, ඔබට වචන 10ක් සහිත වාක්ය 10ක් සහ වචන 20ක් සහිත වාක්ය 1ක් තිබේ නම්, උපධාන මගින් සියලුම වාක්යවල වචන 20ක් ඇති බව සහතික කරයි. අපගේ උදාහරණයේ, ලැබෙන ආතානකය මේ ආකාරයෙන් පෙනෙයි:
padding_id = 100
batched_ids = [
[200, 200, 200],
[200, 200, padding_id],
]
උපධාන ටෝකන් හැඳුනුම්පත tokenizer.pad_token_id
හි සොයා ගත හැක. අපි එය භාවිතා කර අපගේ වාක්ය දෙක තනි තනිව ආකෘතිය හරහා යවමු:
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
sequence1_ids = [[200, 200, 200]]
sequence2_ids = [[200, 200]]
batched_ids = [
[200, 200, 200],
[200, 200, tokenizer.pad_token_id],
]
print(model(torch.tensor(sequence1_ids)).logits)
print(model(torch.tensor(sequence2_ids)).logits)
print(model(torch.tensor(batched_ids)).logits)
tensor([[ 1.5694, -1.3895]], grad_fn=<AddmmBackward>)
tensor([[ 0.5803, -0.4125]], grad_fn=<AddmmBackward>)
tensor([[ 1.5694, -1.3895],
[ 1.3373, -1.2163]], grad_fn=<AddmmBackward>)
අපගේ කාණ්ඩගත අනාවැකිවල ලඝුකය වල යම් දෝෂයක් ඇත: දෙවන පේළිය දෙවන වාක්යයේ ලඝුකය හා සමාන විය යුතුය, නමුත් අපට සම්පූර්ණයෙන්ම වෙනස් අගයන් ඇත!
මක්නිසාද යත්, පරිවර්තක ආකෘතිවල ප්රධාන ලක්ෂණය වන්නේ එක් එක් ටෝකනයසන්දර්භීයකරණය කරන අවධානය ස්ථර වීමයි. මේවා අනුපිළිවෙලක සියලුම ටෝකන වලට සහභාගී වන බැවින් උපධාන ටෝකන සැලකිල්ලට ගනී. මාදිලිය හරහා විවිධ දිග තනි වාක්ය සම්මත කිරීමේදී එම ප්රතිඵලය ලබා ගැනීමට හෝ එම වාක්ය සහ උපධාන යෙදූ කාණ්ඩයක් පසු කරන විට, අපි එම අවධානය ස්ථරවලට උපධාන ටෝකන් නොසලකා හරින ලෙස පැවසිය යුතුය. මෙය සිදු කරනු ලබන්නේ අවධාන ආවරණයක් භාවිතා කිරීමෙනි.
අවධාන ආවරණ යනු 0s සහ 1s වලින් පුරවා ඇති ආදාන හැඳුනුම්පත ආතානකයට සමාන හැඩයක් ඇති ආතානක ය: 1s මඟින් අනුරූප ටෝකනවලට සහභාගී විය යුතු බව ද 0s මඟින් අනුරූප ටෝකනවලට සහභාගී නොවිය යුතු බව ද දක්වයි (එනම්, ඒවා ආකෘතියේ අවධානය ස්ථර නොසලකා හැරිය යුතුය).
අවධාන ආවරණයකින් පෙර උදාහරණය සම්පූර්ණ කරමු:
batched_ids = [
[200, 200, 200],
[200, 200, tokenizer.pad_token_id],
]
attention_mask = [
[1, 1, 1],
[1, 1, 0],
]
outputs = model(torch.tensor(batched_ids), attention_mask=torch.tensor(attention_mask))
print(outputs.logits)
tensor([[ 1.5694, -1.3895],
[ 0.5803, -0.4125]], grad_fn=<AddmmBackward>)
දැන් අපිට කාණ්ඩයේ දෙවෙනි වාක්යයටත් ඒ ලඝුකය ලැබෙනු ඇත.
අවධාන ආවරණයේ 0 අගයක් වන, දෙවන අනුපිළිවෙලෙහි අවසාන අගය පිරවුම් හැඳුනුම්පතක් වන ආකාරය සැලකිල්ලට ගන්න.
✏️ උත්සාහ කරන්න! 2 වන කොටසේ භාවිතා කර ඇති වාක්ය දෙකෙහි ටෝකනීකරණය අතින් යොදන්න (“I’ve been waiting for a HuggingFace course my whole life.” සහ “I hate this so much!”). ඒවා ආකෘතිය හරහා ගොස් 2 වැනි කොටසේ ඇති ලඝුකය ඔබට ලැබෙන බව පරීක්ෂා කරන්න. දැන් උපධාන ටෝකනය භාවිතයෙන් ඒවා එකට එකතු කරන්න, ඉන්පසු නිසි අවධාන ආවරණයක් සාදන්න. ආකෘතිය හරහා යන විට ඔබට සමාන ප්රතිපල ලබා ගත හැකිදැයි පරීක්ෂා කරන්න!
පරිවර්තක ආකෘති සමඟ, අපට ආකෘති යෙදිය කළ හැකි අනුක්රමවල දිගට සීමාවක් තිබේ. බොහෝ ආකෘති ටෝකන 512 හෝ 1024 දක්වා අනුපිළිවෙල හසුරුවන අතර දිගු අනුපිළිවෙලක් සැකසීමට ඉල්ලා සිටින විට බිඳ වැටේ. මෙම ගැටලුවට විසඳුම් දෙකක් තිබේ:
ආකෘතීන්ට විවිධ සහය දක්වන අනුපිළිවෙල දිග ඇති අතර සමහරක් ඉතා දිගු අනුපිළිවෙල හැසිරවීමට විශේෂත්වයක් දරයි. Longformer එක් උදාහරණයක් වන අතර තවත් උදාහරණයක් වන්නේ LED. ඔබ ඉතා දිගු අනුපිළිවෙලක් අවශ්ය කාර්යයක් මත වැඩ කරන්නේ නම්, එම ආකෘති දෙස බැලීමට අපි ඔබට නිර්දේශ කරමු.
එසේ නොමැතිනම්, max_sequence_length
පරාමිතිය සඳහන් කිරීමෙන් ඔබේ අනුපිළිවෙලවල් කප්පාදු කිරීමට අපි නිර්දේශ කරමු:
sequence = sequence[:max_sequence_length]