Pytorch TensorFlow

Pipeline හි අභ්‍යන්තරය

Ask a Question Open In Colab Open In Studio Lab
පළමු කොටස ඔබ PyTorch හෝ TensorFlow භාවිතා කිරීම මත පදනම්ව තරමක් වෙනස් වේ. ඔබ කැමති ක්‍රමය තෝරා ගැනීමට මාතෘකාවට ඉහළින් ඇති ස්විචය ටොගල් කරන්න.

අපි සම්පූර්ණ උදාහරණයකින් පරිච්ඡේදය 1 හි පහත කේතය ක්‍රියාත්මක කළ විට තිරය පිටුපස සිදු වූ දේ දෙස බලා පටන් ගනිමු:

from transformers import pipeline

classifier = pipeline("sentiment-analysis")
classifier(
    [
        "I've been waiting for a HuggingFace course my whole life.",
        "I hate this so much!",
    ]
)

ලබා ගත් දේ:

[{'label': 'POSITIVE', 'score': 0.9598047137260437},
 {'label': 'NEGATIVE', 'score': 0.9994558095932007}]

අපි පරිච්ඡේදය 1 හි දුටු පරිදි, මෙම pipeline පියවර තුනක් එකට කාණ්ඩගත කරයි: පූර්ව සැකසීම, ආදාන ආදර්ශය හරහා යැවීම සහ පසු සැකසුම්:

The full NLP pipeline: tokenization of text, conversion to IDs, and inference through the Transformer model and the model head.

අපි මේ සෑම එකක් ගැනම දල අදහසක් ගනිමු.

ටෝකනකාරක සමඟ පෙර සැකසීම

අනෙකුත් ස්නායුක ජාල මෙන්, පරිවර්තක ආකෘති වලට අමු අකුරු සෘජුවම සැකසිය නොහැක, එබැවින් අපගේ pipeline යේ පළමු පියවර වන්නේ පාඨ ආදානයන් ආකෘතියට තේරුම් ගත හැකි සංඛ්‍යා බවට පරිවර්තනය කිරීමයි. අපි මෙය සිදු කිරීම සඳහා වගකිව යුතු, ටෝකනකාරක භාවිතා කරමු.

මෙම සියලු පූර්ව සැකසුම් හරියටම ආකෘතිය පෙර පුහුණු කළ ආකාරයටම සිදු කළ යුතුය, එබැවින් අපි මුලින්ම එම තොරතුරු ආකෘති කේන්ද්‍රය වෙතින් බාගත කළ යුතුය. මෙය සිදු කිරීම සඳහා, අපි ‘AutoTokenizer’ පන්තිය සහ එහි ‘from_pretrained()’ ක්‍රමය භාවිතා කරමු. අපගේ ආකෘතියේ මුරපොල නම භාවිතා කරමින්, එය ස්වයංක්‍රීයව ආකෘතියේ ටෝකනකාරක හා සම්බන්ධ දත්ත ලබාගෙන එය හැඹිලිගත කරයි (එබැවින් එය බාගත වන්නේ ඔබ පහත කේතය ධාවනය කරන පළමු වතාවට පමණි).

‘හැඟීම්-විශ්ලේෂණය’ pipeline යේ පෙරනිමි මුරපොල ‘distilbert-base-uncased-finetuned-sst-2-english’ බැවින් (ඔබට එහි ආදර්ශ කාඩ්පත මෙතැනින්), අපි පහත සඳහන් දේ ක්‍රියාත්මක කරමු:

from transformers import AutoTokenizer

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)

අපි ටෝකනකාරක ලබා ගත් පසු, අපට අපගේ වාක්‍ය කෙලින්ම එයට යොමු කළ හැකි අතර අපගේ ආකෘතියට පෝෂණය කිරීමට සූදානම් ශබ්ද කෝෂයක් අපට නැවත ලැබෙනු ඇත! අපට කිරීමට ඉතිරිව ඇත්තේ ආදාන හැඳුනුම්පත් ලැයිස්තුව ආතානක බවට පරිවර්තනය කිරීම පමණි.

ඔබට 🤗 පරිවර්තක භාවිතා කළ හැක්කේ කුමන ML රාමුව පසුතලයක් ලෙස භාවිතා කරමින් ද යන්න ගැන කරදර නොවී; එය සමහර ආකෘති සඳහා PyTorch හෝ TensorFlow හෝ Flax විය හැක. කෙසේ වෙතත්, පරිවර්තක ආකෘති ලෙස පිළිගන්නේ ආතානක පමණි. ආතානක ගැන ඔබ අසන පළමු අවස්ථාව මෙය නම්, ඒ වෙනුවට ඔබට ඒවා NumPy අරා ලෙස සිතිය හැක. NumPy අරාවක් පරිමාණයක් (0D), දෛශිකයක් (1D), න්‍යාසයක් (2D) හෝ වැඩි මානයන් තිබිය හැක. ඒවා ඵලදායී ලෙස ආතානකයකි; අනෙකුත් ML රාමු වල ආතානක සමාන ලෙස හැසිරෙන අතර, සාමාන්‍යයෙන් NumPy අරාවන් මෙන් සරලව ක්ෂණික කිරීමට හැකිවේ.

අපට ආපසු ලබා ගැනීමට අවශ්‍ය ආතානක වර්ගය සඳහන් කිරීමට (PyTorch, TensorFlow, හෝ plain NumPy), අපි return_tensors විස්තාරය භාවිතා කරමු:

raw_inputs = [
    "I've been waiting for a HuggingFace course my whole life.",
    "I hate this so much!",
]
inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="pt")
print(inputs)

තවමත් පිරවුම සහ කප්පාදුව ගැන කරදර නොවන්න; අපි ඒවා පසුව පැහැදිලි කරන්නෙමු. මෙහිදී මතක තබා ගත යුතු ප්‍රධාන කරුණු නම්, ඔබට එක් වාක්‍යයක් හෝ වාක්‍ය ලැයිස්තුවක් ලබාදිය හැකි අතර, ඔබට ආපසු ලබා ගැනීමට අවශ්‍ය ආතානක වර්ගය සඳහන් කිරීම (කිසිදු වර්ගයක් ලබාදී නොමැති නම්, ප්‍රතිඵලයක් ලෙස ඔබට ලැයිස්තු ලැයිස්තුවක් ලැබෙනු ඇත) .

මෙහි ප්‍රතිඵල PyTorch ආතානක ලෙස පෙනෙන්නේ කෙසේද යන්නයි:

{
    'input_ids': tensor([
        [  101,  1045,  1005,  2310,  2042,  3403,  2005,  1037, 17662, 12172, 2607,  2026,  2878,  2166,  1012,   102],
        [  101,  1045,  5223,  2023,  2061,  2172,   999,   102,     0,     0,     0,     0,     0,     0,     0,     0]
    ]),
    'attention_mask': tensor([
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
    ])
}

ප්‍රතිදානය යනු input_ids සහ attention_mask යන යතුරු දෙකක් අඩංගු අකාරාදි දත්ත ආකාරය කි. input_ids හි නිඛිල පේළි දෙකක් (එක් එක් වාක්‍යයකට එකක්) එක් එක් වාක්‍යයේ ටෝකනවල අනන්‍ය හඳුනාගැනීම් වේ. අපි attention_mask යනු කුමක්දැයි පසුව මෙම පරිච්ඡේදයෙන් පැහැදිලි කරන්නෙමු.

ආකෘතිය හරහා ගමන් කිරීම

අපගේ ටෝකනකාරක සමඟ අප කළ ආකාරයටම අපගේ පූර්ව පුහුණු ආකෘතිය බාගත කළ හැකිය. 🤗 පරිවර්තක මඟින් from_pretrained() ක්‍රමයක් ද ඇති AutoModel පන්තියක් සපයයි:

from transformers import AutoModel

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
model = AutoModel.from_pretrained(checkpoint)

මෙම කේත කොටසෙහි, අපි මීට පෙර අපගේ pipeline යේ භාවිතා කළ මුරපොලම බාගත කර ඇත (එය ඇත්ත වශයෙන්ම දැනටමත් හැඹිලිගත කර තිබිය යුතුය) සහ එය සමඟ ආකෘතියක් ක්ෂණිකව ලබා දී ඇත.

මෙම නිර්මිතයේ අඩංගු වන්නේ මූලික පරිවර්තක මාතිකාව පමණි: සමහර යෙදවුම් ලබා දී ඇති අතර, එය අප විසින් සැඟවුණු අවස්ථා ලෙස හඳුන්වන දේ ප්‍රතිදානය කරයි, එය ලක්ෂණ ලෙසද හැඳින්වේ. එක් එක් ආදර්ශ ආදානය සඳහා, අපි පරිවර්තක ආකෘතියෙන් එම ආදානය පිළිබඳ සන්දර්භ අවබෝධය නියෝජනය කරන අධි-මාන දෛශිකයක් ලබා ගනිමු.

මෙය තේරුමක් නැති නම්, ඒ ගැන කරදර නොවන්න. අපි ඒ සියල්ල පසුව පැහැදිලි කරන්නෙමු.

මෙම සැඟවුණු තත්වයන් තමන්ටම ප්‍රයෝජනවත් විය හැකි අතර, ඒවා සාමාන්‍යයෙන් හිස ලෙස හැඳින්වෙන ආකෘතියේ වෙනත් කොටසකට යෙදවුම් වේ. පළමු පරිච්ඡේදය, විවිධ කාර්යයන් එකම නිර්මිතය සමඟ සිදු කළ හැකිව තිබුණත්, මෙම එක් එක් කාර්යයට ඒ හා සම්බන්ධ වෙනස් හිසක් ඇත.

අධි-මාන දෛශිකයක්?

පරිවර්තක මාතිකාව මගින් දෛශික ප්‍රතිදානය සාමාන්‍යයෙන් විශාල වේ. එය සාමාන්‍යයෙන් මාන තුනක් ඇත:

අවසාන අගය නිසා එය “ඉහළ මානය” යැයි කියනු ලැබේ. සැඟවුණු ප්‍රමාණය ඉතා විශාල විය හැක (768 කුඩා ආකෘති සඳහා පොදු වන අතර විශාල ආකෘති වල මෙය 3072 හෝ ඊට වැඩි විය හැක).

අපි පෙර සැකසූ යෙදවුම් අපගේ ආකෘතියට පෝෂණය කළහොත් අපට මෙය දැකිය හැකිය:

outputs = model(**inputs)
print(outputs.last_hidden_state.shape)
torch.Size([2, 16, 768])

🤗 පරිවර්තක ආකෘති වල ප්‍රතිදානයන් namedtuple හෝ අකාරාදි දත්ත ආකාර ලෙස හැසිරෙන බව සලකන්න. ඔබට මූලද්‍රව්‍ය වෙත උපලක්ෂණ මගින් ප්‍රවේශ විය හැක (අපි කළාක් මෙන්) හෝ යතුර (outputs["last_hidden_state"]), හෝ ඔබ සොයන දෙය හරියටම කොතැනදැයි ඔබ දන්නේ නම් සුචිය මගින් (outputs[0]) .

ආකෘති ශිර්ෂ: ඉලක්කම් වලින් අර්ථයක් ලබාගැනීම

ආකෘති ශිර්ෂ, සැඟවුණු අවස්ථා වල අධිමාන දෛශිකය ආදානය ලෙස ගෙන ඒවා වෙනත් මානයකට ප්‍රක්ෂේපණය කරයි. ඒවා සාමාන්‍යයෙන් රේඛීය ස්ථර එකකින් හෝ කිහිපයකින් සමන්විත වේ:

A Transformer network alongside its head.

පරිවර්තක ආකෘතියේ ප්‍රතිදානය සැකසීමට ආකෘති ශිර්ෂ වෙත කෙලින්ම යවනු ලැබේ.

මෙම රූප සටහනෙහි, ආකෘතිය එහි කාවැද්දීම් ස්ථරය සහ පසුව ඇති ස්ථර මගින් නිරූපණය කෙරේ. කාවැද්දීමේ ස්ථරය ටෝකනීකරණය කරන ලද ආදානයේ එක් එක් ආදාන හැඳුනුම්පත සම්බන්ධිත ටෝකනය නියෝජනය කරන දෛශිකයක් බවට පරිවර්තනය කරයි. වාක්‍යවල අවසාන නිරූපණය නිපදවීමට අවධානය යොමු කිරීමේ යාන්ත්‍රණය භාවිතා කරමින් පසුකාලීන ස්ථර එම දෛශික හසුරුවයි.

🤗 පරිවර්තක වල විවිධ නිර්මිත රාශියක් ඇත, ඒ සෑම එකක්ම නිශ්චිත කාර්යයකට මුහුණ දීම වටා නිර්මාණය කර ඇත. මෙන්න සම්පූර්ණ නොවන ලැයිස්තුවක්:

අපගේ උදාහරණය සඳහා, අපට අනුක්‍රමික වර්ගීකරණ හිසක් සහිත ආකෘතියක් අවශ්‍ය වනු ඇත (වාක්‍ය ධන හෝ සෘණ ලෙස වර්ගීකරණය කිරීමට හැකි වීම සඳහා). එබැවින්, අපි ඇත්ත වශයෙන්ම AutoModel පන්තිය භාවිතා නොකරමු, නමුත් AutoModelForSequenceClassification:

from transformers import AutoModelForSequenceClassification

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
outputs = model(**inputs)

දැන් අපි අපේ ප්‍රතිදාන වල හැඩය දෙස බැලුවහොත්, මානය බොහෝ අඩු වනු ඇත: ආකෘති ශිර්ෂ අප පෙර දුටු අධි-මාන දෛශික ආදානය ලෙස ගන්නා අතර අගයන් දෙකක් අඩංගු දෛශික ප්‍රතිදානය කරයි (ලේබලයකට එකක්):

print(outputs.logits.shape)
torch.Size([2, 2])

අපට ඇත්තේ වාක්‍ය දෙකක් සහ ලේබල් දෙකක් පමණක් බැවින්, අපගේ ආකෘතියෙන් අපට ලැබෙන ප්‍රතිඵලයේ හැඩය 2 x 2 වේ.

ප්‍රතිදානය පසු සැකසීම

අපගේ ආකෘතියෙන් ප්‍රතිදානය ලෙස අපට ලැබෙන අගයන් අවශ්‍යයෙන්ම තමන් විසින්ම අර්ථවත් නොවේ. අපි බලමු:

print(outputs.logits)
tensor([[-1.5607,  1.6123],
        [ 4.1692, -3.3464]], grad_fn=<AddmmBackward>)

අපගේ ආකෘතිය පළමු වාක්‍යයට [-1.5607, 1.6123] සහ දෙවැන්න සඳහා [ 4.1692, -3.3464] පුරෝකථනය කරන ලදී. ඒවා සම්භාවිතාවන් නොව ලඝුකය, ආකෘතියේ අවසාන ස්ථරය මඟින් ප්‍රතිදානය කරන ලද අමු, අසාමාන්‍ය ලකුණු වේ. සම්භාවිතාවන් බවට පරිවර්තනය කිරීම සඳහා, ඔවුන් SoftMax ස්ථරයක් හරහා යා යුතුය (සියලු 🤗 පරිවර්තක ආකෘති ලඝුකය ප්‍රතිදානය කරයි. මන්ද, පුහුණුව සඳහා වන පාඩු ශ්‍රිතය සාමාන්‍යයෙන් හරස් එන්ට්‍රොපිය වැනි සත්‍ය අලාභ ශ්‍රිතය සමඟ SoftMax වැනි අවසාන සක්‍රීය කිරීමේ ශ්‍රිතය විලයනය කරයි.):

import torch

predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
print(predictions)
tensor([[4.0195e-02, 9.5980e-01],
        [9.9946e-01, 5.4418e-04]], grad_fn=<SoftmaxBackward>)

දැන් අපට පෙනෙන්නේ ආකෘතිය පළමු වාක්‍යයට [0.0402, 0.9598] සහ දෙවැන්න සඳහා [0.9995, 0.0005] ලෙස පුරෝකථනය කර ඇති බවයි. මේවා හඳුනාගත හැකි සම්භාවිතා ලකුණු වේ.

එක් එක් ස්ථානයට අනුරූප ලේබල ලබා ගැනීම සඳහා, අපට ආකෘති වින්‍යාසයෙහි id2label ගුණාංගය පරීක්ෂා කළ හැක (මේ ගැන වැඩි විස්තර ඊළඟ කොටසේ):

model.config.id2label
{0: 'NEGATIVE', 1: 'POSITIVE'}

දැන් අපට නිගමනය කළ හැක්කේ ආකෘතිය පහත සඳහන් දේ පුරෝකථනය කළ බවයි:

අපි pipeline යේ පියවර තුන සාර්ථකව ප්‍රතිනිෂ්පාදනය කර ඇත: ටෝකනකාරක සමඟ පෙර සැකසුම්, ආකෘතිය හරහා යෙදවුම් යැවීම සහ පසු සැකසුම්! දැන් අපි ඒ සෑම පියවරකටම ගැඹුරට කිමිදීමට යම් කාලයක් ගත කරමු.

✏️ උත්සාහ කරන්න! ඔබේම පාඨ දෙකක් (හෝ වැඩි ගණනක්) තෝරා ඒවා sentiment-analysis pipeline හරහා ධාවනය කරන්න. ඉන්පසු ඔබ මෙහි දැක ඇති පියවර ඔබම අනුකරණය කර ඔබට එම ප්‍රතිඵල ලබා ගැනීමට හැකි දැයි පරීක්ෂා කරන්න!