Framfarir í LLM rökstuðningi: Tæknileg djúpköf

Inngangur

Stór tungumálalíkön (LLM) hafa gjörbylt sviði náttúrulegrar málvinnslu (NLP) á undanförnum árum. Þessi líkön hafa náð nýjustu árangri í ýmsum NLP verkefnum, þar á meðal tungumálaþýðingu, textasamantekt og spurningasvörun. Hins vegar liggur raunverulegur möguleiki LLMs í getu þeirra til að rökræða og skilja flókin tengsl milli hugtaka. Í þessari grein munum við kafa ofan í framfarir í LLM rökhugsun, kanna undirliggjandi tækni, arkitektúr og áskoranir.

Bakgrunnur

LLM eru tegund taugakerfis sem er þjálfuð á miklu magni textagagna til að læra mynstur og tengsl milli orða og hugtaka. Þessar gerðir samanstanda venjulega af kóðara og afkóðara, þar sem kóðarinn vinnur inntakstextann og afkóðarinn býr til úttakstextann. Kóðarinn er venjulega arkitektúr sem byggir á spenni, sem hentar sérstaklega vel fyrir röð gagna eins og texta.

Transformer arkitektúr

Spenniarkitektúrinn, kynntur í greininni "Attention is All You Need" eftir Vaswani o.fl. (2017), er orðinn raunverulegur staðall fyrir háskólanám. Spennirinn samanstendur af kóðara og afkóðara, sem hvert er samsett úr mörgum lögum. Hvert lag samanstendur af tveimur undirlögum: sjálfseftirlitskerfi og fullkomlega tengt straumkerfi (FFNN).

innflutnings blys
flytja kyndil.nn sem nn

flokkur TransformerLayer(nn.Module):
    def __init__(sjálf, d_módel, n_heads, d_ff):
        super(TransformerLayer, sjálf).__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 áfram(sjálf, x):
        # Sjálfsathygliskerfi
        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)

        skila x_ffnn

Framfarir í rökstuðningi LLM

LLM hafa náð miklum framförum í rökhugsun og skilningi á flóknum tengslum hugtaka. Sumar helstu framfarirnar eru:

1. Rök-undirstaða röksemdafærslu

Rök sem byggja á línuriti felur í sér að tákna þekkingu sem línurit, þar sem hnútar tákna hugtök og brúnir tákna tengsl þeirra á milli. Hægt er að þjálfa LLM í að rökræða um þessi línurit, gera spár um tengsl milli hnúta.

notaðu graf::Graf;
nota neural_network :: NeuralNetwork;

fn graph_reasoning(graf: &Graf, fyrirspurn: &str) -> String {
    let embedding = neural_network.query(graf, fyrirspurn);
    let result = neural_network.reason(graf, innfelling);
    result.to_string()
}

2. Fjölverkefnisnám

Fjölverkanám felur í sér að þjálfa eitt líkan á mörgum verkefnum samtímis. Sýnt hefur verið fram á að þessi nálgun bætir árangur LLM í ýmsum verkefnum, þar á meðal rökhugsun og skilning á flóknum samböndum.

aðalpakki

flytja inn (
	"fmt"
	"gonum.org/v1/gonum/mat"
)

gerð Model struct {
	*nn.Línuleg
	*nn.Línuleg
}

func (m *Módel) Áfram(x *mat.Dense) *mat.Dense {
	// Áfram pass
	z := m.Línuleg(x)
	z = m.Línulegt(z)
	skila z
}

3. Athygliskerfi

Athygliskerfi leyfa LLM að einbeita sér að ákveðnum hlutum inntakstextans þegar þeir búa til úttakið. Sýnt hefur verið fram á að þessi nálgun bætir árangur LLM í ýmsum verkefnum, þar á meðal rökhugsun og skilning á flóknum samböndum.

innflutnings blys
flytja kyndil.nn sem nn

Class Attention Mechanism(nn.Module):
    def __init__(sjálf, d_módel, n_hausar):
        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 áfram(sjálf, x):
        # Fyrirspurn, lykill og gildi
        q = self.query(x)
        k = sjálf.lykill(x)
        v = sjálfsvirði(x)

        # Athyglisþyngd
        lóð = kyndill.matmul(q, k.T) / math.sqrt(q.shape[1])
        lóð = self.dropout(weights)
        lóð = kyndill.softmax(þyngd, dimm=-1)

        # Samhengisvektor
        samhengi = kyndill.matmul(þyngd, v)

        skila samhengi

Sjónræn

Til að sjá frammistöðu LLM í ýmsum verkefnum getum við notað töflu til að bera saman nákvæmni mismunandi líkana á tilteknu verkefni. Hér er dæmi um töflu sem notar Chart.js:

{
  "type": "bar",
  "gögn": {
    "labels": ["Verk 1", "Verk 2", "Verk 3"],
    "gagnasett": [
      {
        "label": "Módel 1",
        "gögn": [0.8, 0.7, 0.9],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "borderWidth": 1
      },
      {
        "label": "Módel 2",
        "gögn": [0.9, 0.8, 0.7],
        "backgroundColor": "rgba(54, 162, 235, 0.2)",
        "borderColor": "rgba(54, 162, 235, 1)",
        "borderWidth": 1
      }
    ]
  },
  "valkostir": {
    "titill": {
      "skjá": satt,
      "text": "Nákvæmni mismunandi gerða við ýmis verkefni"
    },
    "vog": {
      "yAxes": [
        {
          "tikkar": {
            "beginAtZero": satt
          }
        }
      ]
    }
  }
}

Niðurstaða

Í þessari grein höfum við kannað framfarirnar í LLM rökhugsun, þar á meðal rökhugsun sem byggir á línuritum, fjölverkefnanámi og athyglisaðferðum. Við höfum einnig veitt kóðadæmi í Python, Rust og Go til að sýna þessi hugtök. Að lokum höfum við notað töflu til að sjá frammistöðu LLM í ýmsum verkefnum. Þessar framfarir hafa tilhneigingu til að gjörbylta sviði NLP, sem gerir LLMs kleift að rökræða og skilja flókin tengsl milli hugtaka.

Tilvísanir

Vaswani o.fl. (2017). Athygli er allt sem þú þarft. arXiv forprentun arXiv:1706.03762.
Devlin o.fl. (2018). BERT: Forþjálfun djúpra tvíátta umbreyta fyrir tungumálaskilning. arXiv forprentun arXiv:1810.04805.
Radford o.fl. (2019). Tungumálalíkön eru eftirlitslausir fjölverkanemarar. arXiv forprentun arXiv:1906.08237.