Pokroky v uvažovaní LLM: technický hlboký ponor

Úvod

Veľké jazykové modely (LLM) spôsobili v posledných rokoch revolúciu v oblasti spracovania prirodzeného jazyka (NLP). Tieto modely dosiahli najmodernejšie výsledky v rôznych úlohách NLP, vrátane jazykového prekladu, sumarizácie textu a odpovedí na otázky. Skutočný potenciál LLM však spočíva v ich schopnosti uvažovať a chápať zložité vzťahy medzi konceptmi. V tomto článku sa ponoríme do pokroku v uvažovaní LLM a preskúmame základné techniky, architektúry a výzvy.

Pozadie

LLM sú typom neurónovej siete, ktorá je trénovaná na veľkom množstve textových údajov, aby sa naučila vzorce a vzťahy medzi slovami a pojmami. Tieto modely sa zvyčajne skladajú z kodéra a dekodéra, kde kodér spracováva vstupný text a dekodér generuje výstupný text. Kódovač je zvyčajne architektúra založená na transformátore, ktorá je obzvlášť vhodná pre sekvenčné údaje, ako je text.

Architektúra transformátora

Architektúra transformátora, predstavená v článku „Attention is All You Need“ od Vaswaniho a kol. (2017), sa stal de facto štandardom pre LLM. Transformátor sa skladá z kodéra a dekodéra, pričom každý pozostáva z viacerých vrstiev. Každá vrstva sa skladá z dvoch podvrstiev: samoobslužného mechanizmu a plne prepojenej doprednej siete (FFNN).

dovozová baterka
importovať pochodeň.nn ako nn

class TransformerLayer(nn.Modul):
    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)

    def forward(self, x):
        # Mechanizmus sebapozornosti
        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)

        návrat x_ffnn

Pokroky v uvažovaní LLM

LLM dosiahli významný pokrok v uvažovaní a chápaní zložitých vzťahov medzi pojmami. Niektoré z kľúčových vylepšení zahŕňajú:

1. Uvažovanie na základe grafov

Uvažovanie založené na grafe zahŕňa reprezentáciu vedomostí ako graf, kde uzly predstavujú pojmy a hrany predstavujú vzťahy medzi nimi. LLM môžu byť trénované, aby uvažovali o týchto grafoch a robili predpovede o vzťahoch medzi uzlami.

použiť graf::Graf;
použite neural_network::NeuralNetwork;

fn graph_reasoning(graph: &Graph, query: &str) -> String {
    nech embedding = neural_network.query(graph, query);
    nech vysledok = neural_network.reason(graph, embedding);
    result.to_string()
}

2. Viacúlohové učenie

Viacúlohové učenie zahŕňa tréning jedného modelu na viacerých úlohách súčasne. Ukázalo sa, že tento prístup zlepšuje výkon LLM pri rôznych úlohách vrátane uvažovania a pochopenia zložitých vzťahov.

hlavný balík

importovať (
	"fmt"
	"gonum.org/v1/gonum/mat"
)

type Model struct {
	*nn.Lineárne
	*nn.Lineárne
}

func (m *Model) Forward(x *mat.Dense) *mat.Dense {
	// Prechod dopredu
	z := m.Linear(x)
	z = m.Lineárne(z)
	vrátiť z
}

3. Mechanizmy pozornosti

Mechanizmy pozornosti umožňujú LLM zamerať sa na špecifické časti vstupného textu pri generovaní výstupu. Ukázalo sa, že tento prístup zlepšuje výkon LLM pri rôznych úlohách vrátane uvažovania a pochopenia zložitých vzťahov.

dovozová baterka
importovať pochodeň.nn ako nn

class AttentionMechanism(nn.Modul):
    def __init__(self, d_model, n_heads):
        super(AttentionMechanism, self).__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 forward(self, x):
        # Dopyt, kľúč a hodnota
        q = self.query(x)
        k = self.key(x)
        v = vlastná hodnota(x)

        # Pozor váhy
        váhy = pochodeň.matmul(q, k.T) / math.sqrt(q.shape[1])
        váhy = self.dropout(weights)
        hmotnosti = baterka.softmax(hmotnosti, dim=-1)

        # Kontextový vektor
        kontext = pochodeň.matmul(váhy, v)

        návratový kontext

Vizualizácia

Na vizualizáciu výkonu LLM pri rôznych úlohách môžeme použiť graf na porovnanie presnosti rôznych modelov pri danej úlohe. Tu je príklad grafu pomocou Chart.js:

{
  "type": "bar",
  "data": {
    "labels": ["Úloha 1", "Úloha 2", "Úloha 3"],
    "datasets": [
      {
        "label": "Model 1",
        "údaje": [0,8, 0,7, 0,9],
        "backgroundColor": "rgba(255, 99, 132, 0,2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "šírka okraja": 1
      },
      {
        "label": "Model 2",
        "údaje": [0,9, 0,8, 0,7],
        "backgroundColor": "rgba(54, 162, 235, 0,2)",
        "borderColor": "rgba(54, 162, 235, 1)",
        "šírka okraja": 1
      }
    ]
  },
  "možnosti": {
    "title": {
      "zobraziť": pravda,
      "text": "Presnosť rôznych modelov pri rôznych úlohách"
    },
    "váhy": {
      "yAxes": [
        {
          "ticks": {
            "beginAtZero": pravda
          }
        }
      ]
    }
  }
}

Záver

V tomto článku sme preskúmali pokroky v uvažovaní LLM vrátane uvažovania založeného na grafoch, učenia sa viacerými úlohami a mechanizmov pozornosti. Na ilustráciu týchto konceptov sme poskytli aj príklady kódu v jazykoch Python, Rust a Go. Nakoniec sme použili graf na vizualizáciu výkonu LLM pri rôznych úlohách. Tieto pokroky majú potenciál spôsobiť revolúciu v oblasti NLP a umožňujú LLM uvažovať a chápať zložité vzťahy medzi konceptmi.

Referencie

Vaswani a kol. (2017). Všetko, čo potrebujete, je pozornosť. arXiv predtlač arXiv:1706.03762.
Devlin a kol. (2018). BERT: Predškolenie hlbokých obojsmerných transformátorov na porozumenie jazyka. arXiv predtlač arXiv:1810.04805. *Radford a kol. (2019). Jazykové modely sú multitaskingoví študenti bez dozoru. arXiv predtlač arXiv:1906.08237.