Mga Pag-uswag sa LLM Reasoning: Usa ka Teknikal nga Deep Dive | B4N1

Mga Pag-uswag sa LLM Reasoning: Usa ka Teknikal nga Deep Dive

9 months ago · b4n1 Read time: 4 min

Pasiuna

Gibag-o sa Large Language Models (LLMs) ang natad sa pagproseso sa natural nga pinulongan (NLP) sa bag-ohay nga mga tuig. Kini nga mga modelo nakab-ot ang state-of-the-art nga mga resulta sa lain-laing mga buluhaton sa NLP, lakip ang paghubad sa pinulongan, pagsumaryo sa teksto, ug pagtubag sa pangutana. Bisan pa, ang tinuud nga potensyal sa mga LLM naa sa ilang abilidad sa pagpangatarungan ug pagsabut sa mga komplikado nga relasyon tali sa mga konsepto. Niini nga artikulo, atong susihon ang mga pag-uswag sa pangatarungan sa LLM, pagsuhid sa mga nagpahiping mga teknik, arkitektura, ug mga hagit.

Background

Ang mga LLM usa ka matang sa neural network nga gibansay sa daghang mga datos sa teksto aron mahibal-an ang mga sumbanan ug relasyon tali sa mga pulong ug konsepto. Kini nga mga modelo kasagaran naglangkob sa usa ka encoder ug usa ka decoder, diin ang encoder nagproseso sa input text ug ang decoder nagmugna sa output text. Ang encoder kasagaran usa ka arkitektura nga nakabase sa transformer, nga labi nga haum alang sa sunud-sunod nga datos sama sa teksto.

Arkitektura sa Transformer

Ang arkitektura sa transformer, gipaila sa papel nga "Attention is All You Need" ni Vaswani et al. (2017), nahimong de facto nga sumbanan alang sa mga LLM. Ang transformer naglangkob sa usa ka encoder ug usa ka decoder, ang matag usa gilangkuban sa daghang mga sapaw. Ang matag layer naglangkob sa duha ka sub-layer: usa ka mekanismo sa kaugalingon nga pagtagad ug usa ka hingpit nga konektado nga feed-forward network (FFNN).

import nga sulo
import torch.nn ingon nn

klase TransformerLayer(nn.Module):
    def __init__(kaugalingon, d_model, n_heads, d_ff):
        super(TransformerLayer, kaugalingon).__init__()
        self.self_attn = nn.MultiHeadAttention(d_model, n_heads)
        kaugalingon.ffnn = nn.Linear(d_model, d_ff)
        self.dropout = nn.Dropout(0.1)
        self.layer_norm = nn.LayerNorm(d_model)

    def sa unahan(kaugalingon, x):
        # Mekanismo sa pagtagad sa kaugalingon
        x_attn = kaugalingon.kaugalingon_attn(x, x)
        x_attn = kaugalingon.dropout(x_attn)
        x_attn = x + x_attn

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

        balik x_ffnn

Mga Pag-uswag sa LLM Reasoning

Ang mga LLM nakahimog mahinungdanong pag-uswag sa pangatarungan ug pagsabot sa komplikadong mga relasyon tali sa mga konsepto. Ang pipila sa mga nag-unang pag-uswag naglakip sa:

1. Graph-Based Reasoning

Ang graph-based nga pangatarungan naglakip sa pagrepresentar sa kahibalo isip usa ka graph, diin ang mga node nagrepresentar sa mga konsepto ug ang mga kilid nagrepresentar sa mga relasyon tali kanila. Ang mga LLM mahimong mabansay sa pagpangatarungan bahin sa kini nga mga graph, paghimo mga panagna bahin sa mga relasyon tali sa mga node.

gamita ang graph::Graph;
gamita ang neural_network::NeuralNetwork;

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

2. Multi-Task nga Pagkat-on

Ang pagkat-on sa multi-task naglakip sa pagbansay sa usa ka modelo sa daghang mga buluhaton nga dungan. Gipakita kini nga pamaagi aron mapaayo ang pasundayag sa mga LLM sa lainlaing mga buluhaton, lakip ang pangatarungan ug pagsabut sa mga komplikado nga relasyon.

punoan nga pakete

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

type Model struct {
	*nn.Linear
	*nn.Linear
}

func (m *Modelo) Ipasa(x *mat.Dense) *mat.Dense {
	// Pagpasa sa unahan
	z := m.Linear(x)
	z = m.Linear(z)
	balik z
}

3. Mga Mekanismo sa Pagtagad

Gitugotan sa mga mekanismo sa atensyon ang mga LLM nga mag-focus sa piho nga mga bahin sa input text kung maghimo sa output. Gipakita kini nga pamaagi aron mapaayo ang pasundayag sa mga LLM sa lainlaing mga buluhaton, lakip ang pangatarungan ug pagsabut sa mga komplikado nga relasyon.

import nga sulo
import torch.nn ingon nn

klase nga AttentionMechanism(nn.Module):
    def __init__(kaugalingon, 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 sa unahan(kaugalingon, x):
        # Pangutana, yawe, ug kantidad
        q = self.query(x)
        k = kaugalingon.key(x)
        v = kaugalingon.bili(x)

        # Mga gibug-aton sa atensyon
        gibug-aton = torch.matmul(q, k.T) / math.sqrt(q.shape[1])
        gibug-aton = self.dropout(weights)
        gibug-aton = torch.softmax(mga gibug-aton, dim=-1)

        # Vektor sa konteksto
        konteksto = torch.matmul(mga gibug-aton, v)

        ibalik ang konteksto

Pagtan-aw

Aron mahanduraw ang pasundayag sa mga LLM sa lain-laing mga buluhaton, mahimo natong gamiton ang usa ka tsart aron itandi ang katukma sa lain-laing mga modelo sa usa ka buluhaton. Ania ang usa ka pananglitan sa usa ka tsart gamit ang Chart.js:

{
  "type": "bar",
  "data": {
    "labels": ["Buluhaton 1", "Buluhaton 2", "Buluhaton 3"],
    "mga dataset": [
      {
        "label": "Modelo 1",
        "data": [0.8, 0.7, 0.9],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "BorderWidth": 1
      },
      {
        "label": "Modelo 2",
        "data": [0.9, 0.8, 0.7],
        "backgroundColor": "rgba(54, 162, 235, 0.2)",
        "borderColor": "rgba(54, 162, 235, 1)",
        "BorderWidth": 1
      }
    ]
  },
  "mga kapilian": {
    "titulo": {
      "display": tinuod,
      "text": "Katukma sa Nagkalain-laing Modelo sa Lainlaing Buluhaton"
    },
    "mga timbangan": {
      "yAxes": [
        {
          "tikang": {
            "beginAtZero": tinuod
          }
        }
      ]
    }
  }
}

Konklusyon

Niini nga artikulo, among gisusi ang mga pag-uswag sa LLM nga pangatarungan, lakip ang graph-based nga pangatarungan, multi-task nga pagkat-on, ug mga mekanismo sa atensyon. Naghatag usab kami mga pananglitan sa code sa Python, Rust, ug Go aron ihulagway kini nga mga konsepto. Sa katapusan, migamit kami ug tsart aron mahanduraw ang pasundayag sa mga LLM sa lainlaing mga buluhaton. Kini nga mga pag-uswag adunay potensyal nga mabag-o ang natad sa NLP, nga makapahimo sa mga LLM sa pagpangatarungan ug pagsabut sa mga komplikado nga relasyon tali sa mga konsepto.

Mga pakisayran

  • Vaswani et al. (2017). Atensyon ra ang Imong Gikinahanglan. arXiv preprint arXiv:1706.03762.
  • Devlin ug uban pa. (2018). BERT: Pre-training sa Deep Bidirectional Transformers para sa Pagsabot sa Pinulongan. arXiv preprint arXiv:1810.04805.
  • Radford ug uban pa. (2019). Ang mga Modelo sa Pinulongan mao ang mga Unsupervised Multitask Learners. arXiv preprint arXiv:1906.08237.

Have Questions?

Let's Talk

Contact me on LinkedIn