វឌ្ឍនភាពនៅក្នុងហេតុផល LLM: ការជ្រមុជទឹកជ្រៅបច្ចេកទេស

សេចក្តីផ្តើម

គំរូភាសាធំ (LLMs) បានបដិវត្តវិស័យដំណើរការភាសាធម្មជាតិ (NLP) ក្នុងប៉ុន្មានឆ្នាំថ្មីៗនេះ។ គំរូទាំងនេះសម្រេចបាននូវលទ្ធផលទាន់សម័យក្នុងកិច្ចការ NLP ផ្សេងៗ រួមទាំងការបកប្រែភាសា ការសង្ខេបអត្ថបទ និងការឆ្លើយសំណួរ។ ទោះជាយ៉ាងណាក៏ដោយ សក្ដានុពលពិតប្រាកដនៃ LLMs ស្ថិតនៅក្នុងសមត្ថភាពរបស់ពួកគេក្នុងការវែកញែក និងយល់ពីទំនាក់ទំនងដ៏ស្មុគស្មាញរវាងគំនិត។ នៅក្នុងអត្ថបទនេះ យើងនឹងស្វែងយល់ពីភាពជឿនលឿននៅក្នុង LLM ហេតុផល ស្វែងយល់ពីបច្ចេកទេសមូលដ្ឋាន ស្ថាបត្យកម្ម និងបញ្ហាប្រឈម។

ផ្ទៃខាងក្រោយ

LLMs គឺជាបណ្តាញសរសៃប្រសាទមួយប្រភេទដែលត្រូវបានបណ្តុះបណ្តាលលើទិន្នន័យអត្ថបទដ៏ច្រើន ដើម្បីសិក្សាពីគំរូ និងទំនាក់ទំនងរវាងពាក្យ និងគោលគំនិត។ គំរូទាំងនេះជាធម្មតាមានឧបករណ៍បំលែងកូដ និងឧបករណ៍ឌិកូដ ដែលឧបករណ៍បំប្លែងកូដដំណើរការអត្ថបទបញ្ចូល ហើយឧបករណ៍ឌិកូដបង្កើតអត្ថបទលទ្ធផល។ ឧបករណ៍បំប្លែងកូដជាធម្មតាជាស្ថាបត្យកម្មដែលមានមូលដ្ឋានលើប្លែង ដែលស័ក្តិសមជាពិសេសសម្រាប់ទិន្នន័យបន្តបន្ទាប់គ្នាដូចជាអត្ថបទជាដើម។

ស្ថាបត្យកម្ម Transformer

ស្ថាបត្យកម្មប្លែងដែលបានណែនាំនៅក្នុងក្រដាស "ការយកចិត្តទុកដាក់គឺទាំងអស់ដែលអ្នកត្រូវការ" ដោយ Vaswani et al ។ (2017) បានក្លាយជាស្តង់ដារជាក់ស្តែងសម្រាប់ LLMs ។ Transformer មានឧបករណ៍បំលែងកូដ និងឧបករណ៍ឌិកូដ ដែលនីមួយៗមានស្រទាប់ជាច្រើន។ ស្រទាប់នីមួយៗមានស្រទាប់រងពីរ៖ យន្តការយកចិត្តទុកដាក់ដោយខ្លួនឯង និងបណ្តាញបញ្ជូនបន្តដែលភ្ជាប់យ៉ាងពេញលេញ (FFNN)។

``ពស់ថ្លាន់ នាំចូលពិល នាំចូល torch.nn ជា nn

ថ្នាក់ TransformerLayer(nn.Module)៖ def init(ខ្លួនឯង, d_model, n_heads, d_ff): super(TransformerLayer, ខ្លួនឯង)។ 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)

def ទៅមុខ (ខ្លួនឯង x)៖
    # យន្តការយកចិត្តទុកដាក់
    x_attn = self.self_attn(x, x)
    x_attn = self.dropout(x_attn)
    x_attn = x + x_attn

    # FFNN
    x_ffnn = ខ្លួនឯង.ffnn(x_attn)
    x_ffnn = self.dropout(x_ffnn)
    x_ffnn = self.layer_norm(x_ffnn + x_attn)

    ត្រឡប់ x_ffnn

## វឌ្ឍនភាពនៅក្នុងហេតុផល LLM

LLMs មានការរីកចម្រើនគួរឱ្យកត់សម្គាល់ក្នុងការវែកញែក និងការយល់ដឹងពីទំនាក់ទំនងស្មុគ្រស្មាញរវាងគំនិត។ វឌ្ឍនភាពសំខាន់ៗមួយចំនួនរួមមានៈ

### 1. ហេតុផលផ្អែកលើក្រាហ្វ

ហេតុផលផ្អែកលើក្រាហ្វពាក់ព័ន្ធនឹងការតំណាងឱ្យចំណេះដឹងជាក្រាហ្វ ដែលថ្នាំងតំណាងឱ្យគំនិត និងគែមតំណាងឱ្យទំនាក់ទំនងរវាងពួកវា។ LLMs អាចត្រូវបានបណ្តុះបណ្តាលឱ្យវែកញែកអំពីក្រាហ្វទាំងនេះ ដោយធ្វើការព្យាករណ៍អំពីទំនាក់ទំនងរវាងថ្នាំង។

``ច្រេះ
ប្រើក្រាហ្វ៖:ក្រាហ្វ;
ប្រើ neural_network::NeuralNetwork;

fn graph_reasoning(ក្រាហ្វ៖ &ក្រាហ្វ, សំណួរ៖ &str) -> ខ្សែអក្សរ {
    អនុញ្ញាតឱ្យបង្កប់ = neural_network.query(ក្រាហ្វ, សំណួរ);
    អនុញ្ញាតឱ្យលទ្ធផល = neural_network.reason(ក្រាហ្វ ការបង្កប់);
    result.to_string()
}

2. Multi-Task Learning

ការរៀនពហុកិច្ចការពាក់ព័ន្ធនឹងការបណ្តុះបណ្តាលគំរូតែមួយលើកិច្ចការច្រើនក្នុងពេលដំណាលគ្នា។ វិធីសាស្រ្តនេះត្រូវបានបង្ហាញដើម្បីកែលម្អការអនុវត្តរបស់ LLMs លើកិច្ចការផ្សេងៗ រួមទាំងការវែកញែក និងការយល់ដឹងពីទំនាក់ទំនងស្មុគ្រស្មាញ។

``ទៅ កញ្ចប់ចម្បង

នាំចូល ( "fmt" "gonum.org/v1/gonum/mat" )

ប្រភេទ រចនាសម្ព័ន្ធ គំរូ { * nn. លីនេអ៊ែរ * nn. លីនេអ៊ែរ }

func (m *Model) ទៅមុខ(x *mat.Dense) *mat.Dense { // បញ្ជូនបន្ត z := m.Linear(x) z = m.Linear(z) ត្រឡប់ z }

### 3. យន្តការយកចិត្តទុកដាក់

យន្តការយកចិត្តទុកដាក់អនុញ្ញាតឱ្យ LLMs ផ្តោតលើផ្នែកជាក់លាក់នៃអត្ថបទបញ្ចូលនៅពេលបង្កើតលទ្ធផល។ វិធីសាស្រ្តនេះត្រូវបានបង្ហាញដើម្បីកែលម្អការអនុវត្តរបស់ LLMs លើកិច្ចការផ្សេងៗ រួមទាំងការវែកញែក និងការយល់ដឹងពីទំនាក់ទំនងស្មុគ្រស្មាញ។

``ពស់ថ្លាន់
នាំចូលពិល
នាំចូល torch.nn ជា nn

class AttentionMechanism(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)

    def ទៅមុខ (ខ្លួនឯង x)៖
        # សំណួរ គន្លឹះ និងតម្លៃ
        q = self.query(x)
        k = self.key(x)
        v = self.value(x)

        # ទម្ងន់យកចិត្តទុកដាក់
        ទម្ងន់ = torch.matmul(q, k.T) / math.sqrt(q.shape[1])
        weights = self.dropout(ទម្ងន់)
        weights = torch.softmax(weights, dim=-1)

        # វ៉ិចទ័របរិបទ
        បរិបទ = torch.matmul(weights, v)

        ត្រឡប់បរិបទ

ការមើលឃើញ

ដើម្បីស្រមៃមើលការអនុវត្តរបស់ LLMs លើកិច្ចការផ្សេងៗ យើងអាចប្រើតារាងដើម្បីប្រៀបធៀបភាពត្រឹមត្រូវនៃគំរូផ្សេងៗគ្នាលើកិច្ចការដែលបានផ្តល់ឱ្យ។ នេះគឺជាឧទាហរណ៍នៃគំនូសតាងដោយប្រើ Chart.js៖

{
  "type": "របារ",
  "ទិន្នន័យ"៖ {
    "labels": ["កិច្ចការទី 1", "កិច្ចការទី 2", "កិច្ចការទី 3"],
    "សំណុំទិន្នន័យ": [
      {
        "label": "ម៉ូដែល 1",
        "ទិន្នន័យ"៖ [0.8, 0.7, 0.9],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "ទទឹងព្រំដែន"៖ ១
      },
      {
        "label": "ម៉ូដែល 2",
        "ទិន្នន័យ"៖ [0.9, 0.8, 0.7],
        "backgroundColor": "rgba(54, 162, 235, 0.2)",
        "borderColor": "rgba(54, 162, 235, 1)",
        "ទទឹងព្រំដែន"៖ ១
      }
    ]
  },
  "ជម្រើស"៖ {
    "ចំណងជើង"៖ {
      "បង្ហាញ": ពិត,
      "text": "ភាពត្រឹមត្រូវនៃគំរូផ្សេងៗគ្នាលើកិច្ចការផ្សេងៗ"
    },
    "មាត្រដ្ឋាន"៖ {
      "yAxes": [
        {
          "ធីក"៖ {
            "beginAtZero"៖ ពិត
          }
        }
      ]
    }
  }
}

សេចក្តីសន្និដ្ឋាន

នៅក្នុងអត្ថបទនេះ យើងបានស្វែងយល់ពីភាពជឿនលឿននៃហេតុផល LLM រួមទាំងការវែកញែកផ្អែកលើក្រាហ្វ ការរៀនកិច្ចការច្រើន និងយន្តការយកចិត្តទុកដាក់។ យើងក៏បានផ្តល់ឧទាហរណ៍កូដនៅក្នុង Python, Rust និង Go ដើម្បីបង្ហាញពីគោលគំនិតទាំងនេះ។ ជាចុងក្រោយ យើងបានប្រើតារាងដើម្បីស្រមៃមើលការអនុវត្តរបស់ LLMs លើកិច្ចការផ្សេងៗ។ ភាពជឿនលឿនទាំងនេះមានសក្តានុពលក្នុងការធ្វើបដិវត្តន៍វិស័យ NLP ដែលអនុញ្ញាតឱ្យ LLMs វែកញែក និងយល់ពីទំនាក់ទំនងដ៏ស្មុគស្មាញរវាងគំនិត។

ឯកសារយោង

• Vaswani et al ។ (2017)។ ការយកចិត្តទុកដាក់គឺជាអ្វីដែលអ្នកត្រូវការ។ arXiv បោះពុម្ពជាមុន arXiv: 1706.03762 ។
• Devlin et al ។ (2018)។ BERT: ការបណ្តុះបណ្តាលជាមុននៃ Deep Bidirectional Transformers សម្រាប់ការយល់ដឹងភាសា។ arXiv បោះពុម្ពជាមុន arXiv: 1810.04805 ។
• Radford et al ។ (2019)។ គំរូភាសាគឺជាអ្នកសិក្សាពហុកិច្ចការដែលមិនមានការត្រួតពិនិត្យ។ arXiv បោះពុម្ពជាមុន arXiv: 1906.08237 ។