LLM තර්කනයේ දියුණුව: තාක්ෂණික ගැඹුරු කිමිදීමක්

හැඳින්වීම

Large Language Models (LLMs) මෑත වසරවලදී ස්වභාවික භාෂා සැකසුම් (NLP) ක්ෂේත්රයේ විප්ලවීය වෙනසක් සිදු කර ඇත. භාෂා පරිවර්තනය, පෙළ සාරාංශ කිරීම සහ ප්‍රශ්නවලට පිළිතුරු සැපයීම ඇතුළු විවිධ NLP කාර්යයන්හි මෙම ආකෘති නවීන ප්‍රතිඵල අත්කර ගෙන ඇත. කෙසේ වෙතත්, LLM හි සැබෑ විභවය පවතින්නේ සංකල්ප අතර සංකීර්ණ සම්බන්ධතා තර්ක කිරීමට සහ තේරුම් ගැනීමට ඇති හැකියාව තුළ ය. මෙම ලිපියෙන් අපි LLM තර්කනයේ දියුණුව, යටින් පවතින ශිල්පීය ක්‍රම, ගෘහ නිර්මාණ ශිල්පය සහ අභියෝග ගවේෂණය කරමු.

පසුබිම

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

ට්‍රාන්ස්ෆෝමර් ගෘහ නිර්මාණ ශිල්පය

වාස්වානි සහ වෙනත් අය විසින් "අවධානය ඔබට අවශ්‍ය සියල්ල" යන පත්‍රිකාවේ හඳුන්වා දුන් ට්‍රාන්ස්ෆෝමර් ගෘහ නිර්මාණ ශිල්පය. (2017), LLMs සඳහා තථ්‍ය ප්‍රමිතිය බවට පත්ව ඇත. ට්‍රාන්ස්ෆෝමරය එන්කෝඩරයකින් සහ විකේතකයකින් සමන්විත වන අතර, ඒ සෑම එකක්ම බහු ස්ථර වලින් සමන්විත වේ. සෑම ස්ථරයක්ම උප-ස්ථර දෙකකින් සමන්විත වේ: ස්වයං-අවධානය යාන්ත්‍රණයක් සහ සම්පුර්ණයෙන්ම සම්බන්ධිත පෝෂක-ඉදිරිපත් ජාලයක් (FFNN).

පන්දම ආනයනය කරන්න
nn ලෙස torch.nn ආනයනය කරන්න

class TransformerLayer(nn.Module):
    def __init__(self, d_model, n_heads, d_ff):
        super(TransformerLayer, self).__init__()
        self.self_attn = nn.MultiHeadAttention(d_model, n_heads)
        self.ffnn = nn.Linear(d_model, d_ff)
        self.dropout = nn.Dropout(0.1)
        self.layer_norm = nn.LayerNorm(d_model)

    ඉදිරියට යන්න (ස්වයං, x):
        # ස්වයං අවධානය යාන්ත්‍රණය
        x_attn = self.self_attn(x, x)
        x_attn = self.dropout(x_attn)
        x_attn = x + x_attn

        # FFNN
        x_ffnn = self.ffnn(x_attn)
        x_ffnn = self.dropout(x_ffnn)
        x_ffnn = self.layer_norm(x_ffnn + x_attn)

        ආපසු x_ffnn

LLM තර්කනයේ දියුණුව

සංකල්ප අතර සංකීර්ණ සම්බන්ධතා තර්ක කිරීම සහ අවබෝධ කර ගැනීම සඳහා LLMs සැලකිය යුතු ප්‍රගතියක් ලබා ඇත. සමහර ප්‍රධාන දියුණුවට ඇතුළත් වන්නේ:

1. ප්‍රස්තාර මත පදනම් වූ තර්කනය

ප්‍රස්ථාර මත පදනම් වූ තර්කයට දැනුම ප්‍රස්ථාරයක් ලෙස නිරූපණය කිරීම ඇතුළත් වේ, එහිදී නෝඩ් සංකල්ප නියෝජනය කරන අතර දාර ඒවා අතර සම්බන්ධතා නියෝජනය කරයි. මෙම ප්‍රස්ථාර ගැන තර්ක කිරීමට, නෝඩ් අතර සම්බන්ධතා ගැන පුරෝකථනය කිරීමට LLMs පුහුණු කළ හැක.

'''' මලකඩ ප්‍රස්තාරය භාවිතා කරන්න :: Graph; neural_network භාවිතා කරන්න::NeuralNetwork;

fn graph_reasoning(graph: & Graph, query: &str) -> String { embedding ඉඩ දෙන්න = neural_network.query(graph, query); ප්රතිඵලය ඉඩ දෙන්න = neural_network.reason(ප්රස්තාරය, කාවැද්දීම); result.to_string() }

### 2. බහු කාර්ය ඉගෙනීම

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

``` යන්න
ප්රධාන පැකේජය

ආනයනය (
	"fmt"
	"gonum.org/v1/gonum/mat"
)

මාදිලියේ ව්‍යුහය {
	*nn.රේඛීය
	*nn.රේඛීය
}

func (m *Model) Forward(x *mat.Dense) *mat.Dense {
	// ඉදිරි ගමන් බලපත්‍රය
	z := m.රේඛීය(x)
	z = m.Linear(z)
	ආපසු z
}

3. අවධානය යොමු කිරීමේ යාන්ත්‍රණ

අවධානය යොමු කිරීමේ යාන්ත්‍රණය මඟින් ප්‍රතිදානය උත්පාදනය කිරීමේදී ආදාන පෙළෙහි නිශ්චිත කොටස් කෙරෙහි අවධානය යොමු කිරීමට LLM වලට ඉඩ ලබා දේ. මෙම ප්‍රවේශය තර්ක කිරීම සහ සංකීර්ණ සම්බන්ධතා අවබෝධ කර ගැනීම ඇතුළු විවිධ කාර්යයන් සඳහා LLM වල කාර්ය සාධනය වැඩිදියුණු කිරීමට පෙන්වා දී ඇත.

පන්දම ආනයනය කරන්න
nn ලෙස torch.nn ආනයනය කරන්න

පන්තියේ අවධානය යාන්ත්‍රණය(nn.Module):
    def __init__(ස්වයං, d_model, n_heads):
        සුපිරි (අවධානය යාන්ත්‍රණය, ස්වයං).__init__()
        self.query = nn.Linear(d_model, d_model)
        self.key = nn.Linear(d_model, d_model)
        self.value = nn.Linear(d_model, d_model)
        self.dropout = nn.Dropout(0.1)
        self.layer_norm = nn.LayerNorm(d_model)

    ඉදිරියට යන්න (ස්වයං, x):
        # විමසුම, යතුර සහ වටිනාකම
        q = self.query(x)
        k = self.key(x)
        v = self.value(x)

        # අවධානය බර
        බර = torch.matmul(q, k.T) / math.sqrt(q.shape[1])
        බර = self.dropout(බර)
        බර = පන්දම.softmax(බර, dim=-1)

        # සන්දර්භය දෛශිකය
        සන්දර්භය = torch.matmul(බර, v)

        ආපසු සන්දර්භය

දෘශ්‍යකරණය

විවිධ කාර්යයන් සඳහා LLM වල ක්‍රියාකාරිත්වය දෘශ්‍යමාන කිරීමට, දී ඇති කාර්යයක් මත විවිධ මාදිලිවල නිරවද්‍යතාවය සංසන්දනය කිරීමට අපට ප්‍රස්ථාරයක් භාවිතා කළ හැකිය. මෙන්න Chart.js භාවිතා කරන ප්‍රස්ථාරයක උදාහරණයක්:

'''' ජේසන් { "වර්ගය": "බාර්", "දත්ත": { "ලේබල්": ["කාර්යය 1", "කාර්යය 2", "කාර්යය 3"], "දත්ත කට්ටල": [ { "ලේබලය": "ආදර්ශ 1", "දත්ත": [0.8, 0.7, 0.9], "backgroundColor": "rgba(255, 99, 132, 0.2)", "borderColor": "rgba(255, 99, 132, 1)", "දේශසීමා පළල": 1 }, { "ලේබලය": "ආකෘතිය 2", "දත්ත": [0.9, 0.8, 0.7], "backgroundColor": "rgba(54, 162, 235, 0.2)", "borderColor": "rgba(54, 162, 235, 1)", "දේශසීමා පළල": 1 } ] }, "විකල්ප": { "මාතෘකාව": { "දර්ශණය": ඇත්ත, "text": "විවිධ කාර්යයන් මත විවිධ මාදිලිවල නිරවද්‍යතාවය" }, "පරිමාණ": { "yAxes": [ { "කිනිතුල්ලන්": { "beginAtZero": ඇත්ත } } ] } } }

## නිගමනය

මෙම ලිපියෙන්, අපි ප්‍රස්ථාර මත පදනම් වූ තර්කනය, බහු කාර්ය ඉගෙනීම සහ අවධානය යොමු කිරීමේ යාන්ත්‍රණ ඇතුළුව LLM තර්කනයේ දියුණුව ගවේෂණය කර ඇත. මෙම සංකල්ප නිදර්ශනය කිරීම සඳහා අපි Python, Rust සහ Go හි කේත උදාහරණ ද සපයා ඇත. අවසාන වශයෙන්, අපි විවිධ කාර්යයන් සඳහා LLM වල කාර්ය සාධනය දෘශ්‍යමාන කිරීමට ප්‍රස්ථාරයක් භාවිතා කර ඇත. මෙම දියුණුවට NLP ක්ෂේත්‍රයේ විප්ලවීය වෙනසක් කිරීමට හැකියාව ඇත, සංකල්ප අතර සංකීර්ණ සම්බන්ධතා තර්ක කිරීමට සහ තේරුම් ගැනීමට LLM වලට හැකියාව ලැබේ.

## යොමු

* වාස්වානි සහ අල්. (2017) ඔබට අවශ්‍ය වන්නේ අවධානය පමණි. arXiv පූර්ව මුද්‍රණය arXiv:1706.03762.
* ඩෙව්ලින් සහ අල්. (2018) BERT: භාෂා අවබෝධය සඳහා ගැඹුරු ද්විපාර්ශ්වික ට්‍රාන්ස්ෆෝමර් පූර්ව පුහුණු කිරීම. arXiv පූර්ව මුද්‍රණය arXiv:1810.04805.
* Radford et al. (2019) භාෂා ආකෘති යනු අධීක්ෂණය නොකළ බහු කාර්ය ඉගෙන ගන්නන් ය. arXiv පූර්ව මුද්‍රණය arXiv:1906.08237.