Sasniegumi LLM spriešanas jomā: tehniska dziļa niršana

Ievads

Lielie valodu modeļi (LLM) pēdējos gados ir mainījuši dabiskās valodas apstrādes (NLP) jomu. Šie modeļi ir sasnieguši vismodernākos rezultātus dažādos NLP uzdevumos, tostarp valodas tulkošanā, teksta apkopošanā un atbildē uz jautājumiem. Tomēr LLM patiesais potenciāls slēpjas viņu spējā pamatot un izprast sarežģītas attiecības starp jēdzieniem. Šajā rakstā mēs iedziļināsimies LLM argumentācijas sasniegumos, izpētot pamatā esošās metodes, arhitektūru un izaicinājumus.

Fons

LLM ir neironu tīkla veids, kas tiek apmācīts, izmantojot lielu teksta datu apjomu, lai uzzinātu modeļus un attiecības starp vārdiem un jēdzieniem. Šie modeļi parasti sastāv no kodētāja un dekodētāja, kur kodētājs apstrādā ievades tekstu un dekodētājs ģenerē izvades tekstu. Kodētājs parasti ir uz transformatoru balstīta arhitektūra, kas ir īpaši piemērota secīgiem datiem, piemēram, tekstam.

Transformatoru arhitektūra

Transformatora arhitektūra, ko iepazīstināja Vaswani et al. (2017), ir kļuvis par LLM de facto standartu. Transformators sastāv no kodētāja un dekodētāja, katrs sastāv no vairākiem slāņiem. Katrs slānis sastāv no diviem apakšslāņiem: pašapziņas mehānisma un pilnībā savienota padeves tīkla (FFNN).

importa lāpa
importēt lāpu.nn kā nn

klase 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.Lineārs(d_modelis, d_ff)
        self.dropout = nn.Dropout(0.1)
        self.layer_norm = nn.LayerNorm(d_model)

    def uz priekšu (sevis, x):
        # Pašuzmanības mehānisms
        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)

        atgriezt x_ffnn

Sasniegumi LLM argumentācijā

LLM ir guvuši ievērojamu progresu, spriežot un izprotot sarežģītas attiecības starp jēdzieniem. Daži no galvenajiem sasniegumiem ietver:

1. Grafikos balstīta argumentācija

Grafikā balstīta spriešana ietver zināšanu attēlošanu kā grafu, kur mezgli attēlo jēdzienus un malas attēlo attiecības starp tiem. LLM var apmācīt pamatot šos grafikus, prognozējot attiecības starp mezgliem.

izmantot grafiku::Grafiks;
izmantot neural_network::NeuralNetwork;

fn graph_reasoning(graph: &Graph, vaicājums: &str) -> String {
    let embedding = neironu_tīkls.query(grafiks, vaicājums);
    let rezultāts = neironu_tīkls.reason(grafiks, iegulšana);
    result.to_string()
}

2. Vairāku uzdevumu mācīšanās

Vairāku uzdevumu mācīšanās ietver viena modeļa apmācību vairākiem uzdevumiem vienlaikus. Ir pierādīts, ka šī pieeja uzlabo LLM veiktspēju dažādos uzdevumos, tostarp argumentācijā un sarežģītu attiecību izpratnē.

galvenā pakete

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

type Model struct {
	*nn.Lineārs
	*nn.Lineārs
}

func (m *Modelis) Uz priekšu (x *mat.Blīvs) *mat.Blīvs {
	// Piespēle uz priekšu
	z := m.Lineārs(x)
	z = m. Lineārs(z)
	atgriezt z
}

3. Uzmanības mehānismi

Uzmanības mehānismi ļauj LLM koncentrēties uz noteiktām ievades teksta daļām, ģenerējot izvadi. Ir pierādīts, ka šī pieeja uzlabo LLM veiktspēju dažādos uzdevumos, tostarp argumentācijā un sarežģītu attiecību izpratnē.

importa lāpa
importēt lāpu.nn kā nn

klases Uzmanības mehānisms (nn. modulis):
    def __init__(self, d_model, n_heads):
        super(uzmanības mehānisms, self).__init__()
        self.query = nn.Lineārs(d_modelis, d_modelis)
        self.key = nn.Lineārs(d_modelis, d_modelis)
        self.value = nn.Lineārs(d_modelis, d_modelis)
        self.dropout = nn.Dropout(0.1)
        self.layer_norm = nn.LayerNorm(d_model)

    def uz priekšu (sevis, x):
        # Vaicājums, atslēga un vērtība
        q = self.query(x)
        k = self.key(x)
        v = pašvērtība(x)

        # Uzmanības svari
        svari = torch.matmul(q, k.T) / math.sqrt(q.shape[1])
        svari = self.dropout(svari)
        svari = deglis.softmax(svari, dim=-1)

        # Konteksta vektors
        konteksts = torch.matmul(svari, v)

        atgriezt kontekstu

Vizualizācija

Lai vizualizētu LLM veiktspēju dažādos uzdevumos, mēs varam izmantot diagrammu, lai salīdzinātu dažādu modeļu precizitāti noteiktā uzdevumā. Tālāk ir sniegts diagrammas piemērs, izmantojot Chart.js:

{
  "tips": "josla",
  "dati": {
    "etiķetes": ["1. uzdevums", "2. uzdevums", "3. uzdevums"],
    "datu kopas": [
      {
        "etiķete": "1. modelis",
        "dati": [0,8, 0,7, 0,9],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "borderWidth": 1
      },
      {
        "etiķete": "2. modelis",
        "dati": [0,9, 0,8, 0,7],
        "backgroundColor": "rgba(54, 162, 235, 0.2)",
        "borderColor": "rgba(54, 162, 235, 1)",
        "borderWidth": 1
      }
    ]
  },
  "opcijas": {
    "title": {
      "displejs": patiess,
      "text": "Dažādu modeļu precizitāte dažādos uzdevumos"
    },
    "svari": {
      "yAxes": [
        {
          "ērces": {
            "beginAtZero": taisnība
          }
        }
      ]
    }
  }
}

Secinājums

Šajā rakstā mēs esam izpētījuši LLM spriešanas sasniegumus, tostarp uz grafiku balstītu spriešanu, vairāku uzdevumu mācīšanos un uzmanības mehānismus. Mēs esam snieguši arī kodu piemērus Python, Rust un Go, lai ilustrētu šos jēdzienus. Visbeidzot, mēs esam izmantojuši diagrammu, lai vizualizētu LLM veiktspēju dažādos uzdevumos. Šie sasniegumi var mainīt NLP jomu, ļaujot LLM pamatot un izprast sarežģītas attiecības starp jēdzieniem.

Atsauces

Vaswani et al. (2017). Uzmanība ir viss, kas jums nepieciešams. arXiv preprint arXiv:1706.03762.
Devlins et al. (2018). BERT: dziļo divvirzienu transformatoru iepriekšēja apmācība valodas izpratnei. arXiv preprint arXiv:1810.04805.
Radfords u.c. (2019). Valodu modeļi ir bez uzraudzības daudzuzdevumu apguvēji. arXiv preprint arXiv:1906.08237.