Pêşveçûn di Ragihandina LLM de: Kevirek Kûr a Teknîkî

Destpêk

Modelên Zimanên Mezin (LLM) di salên dawî de şoreşek li qada pêvajoyek zimanê xwezayî (NLP) kirine. Van modelan di karên cihêreng ên NLP de, di nav de wergera ziman, kurtkirina nivîsê, û bersiva pirsê, encamên herî nûjen bi dest xistine. Lêbelê, potansiyela rastîn a LLM-an di kapasîteya wan de ye ku sedem bikin û têkiliyên tevlihev di navbera têgînan de fam bikin. Di vê gotarê de, em ê li pêşkeftinên di ramana LLM de bigerin, teknîkên bingehîn, mîmarî û dijwariyan vekolînin.

Paşnav

LLM celebek torê neuralî ye ku li ser gelek daneyên nivîsê têne perwerde kirin da ku nimûne û têkiliyên di navbera peyv û têgehan de fêr bibin. Van modelan bi gelemperî ji enkoder û dekoderek pêk tên, ku kodder nivîsa têketinê dişoxilîne û dekoder metna derhanînê çêdike. Encoder bi gelemperî mîmariyek-based veguherîner e, ku bi taybetî ji bo daneyên rêzdar ên mîna nivîsê xweş e.

Mîmariya Transformer

Mîmariya veguherîner, ku di kaxezê de "Tiştê ku hûn hewce ne baldarî" ji hêla Vaswani et al. (2017), ji bo LLM-an bûye standarda de facto. Transformer ji enkoder û dekoderek pêk tê, ku her yek ji çend qatan pêk tê. Her qatek ji du bin-qatan pêk tê: mekanîzmayek xwe-baldariyê û tevnek pêve-pêşverû ya bi tevahî ve girêdayî (FFNN).

`` python meşaleya import împort torch.nn wek nn

class TransformerLayer (nn.Module): def destpêk(xwe, d_model, n_serî, d_ff): super(TransformerLayer, xwe).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 pêş (xwe, x):
    # Mekanîzmaya xwe-baldariyê
    x_attn = xwe.self_attn(x, x)
    x_attn = self.dropout(x_attn)
    x_attn = x + x_attn

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

    vegerin x_ffnn


## Di Reasoning LLM de pêş dikeve

LLM-an di aqilkirin û têgihiştina têkiliyên tevlihev ên di navbera têgînan de pêşkeftinek girîng çêkiriye. Hin pêşveçûnên sereke hene:

### 1. Reasoning-based Graph

Aqil-based grafik temsîla zanînê wekî grafiyekê vedihewîne, li wir girêkan têgînan û qerax têkiliyên di navbera wan de temsîl dikin. LLM dikarin werin perwerde kirin ku li ser van grafîkan bifikirin, pêşbîniyên li ser têkiliyên di navbera girêkan de çêbikin.

`` rust
grafik bikar bînin::Graph;
neural_network::NeuralNetwork;

fn graph_reasoning(grafîk: &Graph, pirs: &str) -> String {
    bila embedding = neural_network.query(graph, query);
    bila encam = neural_network.reason(graph, embedding);
    result.to_string()
}

2. Fêrbûna Pir-Task

Fêrbûna pir-peywirî bi hevdemî perwerdekirina modelek yekane li ser gelek peywiran pêk tîne. Ev nêzîkatî hate destnîşan kirin ku performansa LLM-an li ser karên cihêreng, di nav de raman û têgihîştina têkiliyên tevlihev, baştir dike.

`` herin pakêta sereke

import ( "fmt" "gonum.org/v1/gonum/mat" )

cureyê Model struct { *nn.Xetî *nn.Xetî }

func (m *Model) Pêş(x *mat.Dense) *mat.Dense { // Pêşveçûn z := m.Xetî(x) z = m.Xetî(z) vegere z }


### 3. Mekanîzmayên Baldarî

Mekanîzmayên baldariyê dihêle ku LLM dema ku hilberan çêdike balê bikişîne ser beşên taybetî yên nivîsa têketinê. Ev nêzîkatî hate destnîşan kirin ku performansa LLM-an li ser karên cihêreng, di nav de raman û têgihîştina têkiliyên tevlihev, baştir dike.

`` python
meşaleya import
împort torch.nn wek nn

class AttentionMechanism(nn.Module):
    def __destpêk__(xwe, d_model, n_ser):
        super(Mekanîzmaya Baldarî, bixwe).__destpêk__()
        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 pêş (xwe, x):
        # Pirs, key, û nirx
        q = self.query(x)
        k = xwe.key(x)
        v = self.value(x)

        # Giraniyên baldarî
        giran = torch.matmul(q, k.T) / math.sqrt(q.shape[1])
        giranî = xwe.dropout(giran)
        giran = torch.softmax(giran, dim=-1)

        # Vektora hevokê
        kontekst = torch.matmul(giran, v)

        vegere çarçoveya

Visualization

Ji bo dîtina performansa LLM-an li ser peywirên cihêreng, em dikarin nexşeyek bikar bînin da ku rastbûna modelên cihêreng li ser peywirek diyar bidin berhev. Li vir mînakek nexşeyek e ku Chart.js bikar tîne:

{
  "type": "bar",
  "dane": {
    "labels": ["Erka 1", "Erka 2", "Erka 3"],
    "daneyên": [
      {
        "label": "Model 1",
        "dane": [0.8, 0.7, 0.9],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "Berfirehiya sînor": 1
      },
      {
        "label": "Model 2",
        "dane": [0.9, 0.8, 0.7],
        "backgroundColor": "rgba(54, 162, 235, 0.2)",
        "borderColor": "rgba(54, 162, 235, 1)",
        "Berfirehiya sînor": 1
      }
    ]
  },
  "vebijark": {
    "sernav": {
      "nîşandan": rast,
      "text": "Rastbûna Modelên Cûda li ser Karên Cûda"
    },
    "pîvan": {
      "yAxes": [
        {
          "tik": {
            "beginAtZero": rast
          }
        }
      ]
    }
  }
}

Encam

Di vê gotarê de, me pêşkeftinên di ramana LLM de, di nav de ramana-based grafik, fêrbûna pir-peywiran, û mekanîzmayên baldariyê lêkolîn kir. Me di Python, Rust, û Go de jî mînakên kodê peyda kirine da ku van têgehan ronî bikin. Di dawiyê de, me nexşeyek bikar anî da ku performansa LLM-an li ser karên cihêreng xuyang bikin. Van pêşkeftinan xwedan potansiyela şoreşa qada NLP-yê ne, rê dide LLM-an ku têkiliyên tevlihev ên di navbera têgînan de aqil bikin û fêm bikin.

Çavkanî

Vaswani et al. (2017). Baldarî Hemû Te Need e. arXiv berî çapkirinê arXiv:1706.03762.
Devlin et al. (2018). BERT: Ji bo Têgihîştina Ziman Pêş-perwerdeya Veguhererên Dualî yên Kûr. arXiv berî çapkirinê arXiv:1810.04805.
Radford et al. (2019). Modelên Ziman Xwendevanên Pirjimarî yên Bêçavdêr in. arXiv berî çapkirinê arXiv:1906.08237.