Տեխնիկական խորը սուզում

Ներածություն

Լեզուների խոշոր մոդելները (LLM) վերջին տարիներին հեղափոխություն են կատարել բնական լեզվի մշակման (NLP) ոլորտում: Այս մոդելները հասել են ժամանակակից արդյունքների NLP-ի տարբեր առաջադրանքներում, ներառյալ լեզվի թարգմանությունը, տեքստի ամփոփումը և հարցերի պատասխանները: Այնուամենայնիվ, LLM-ների իրական ներուժը կայանում է նրանում, որ նրանք կարող են տրամաբանել և հասկանալ հասկացությունների միջև բարդ հարաբերությունները: Այս հոդվածում մենք կխորանանք LLM հիմնավորման առաջընթացների մեջ՝ ուսումնասիրելով հիմքում ընկած տեխնիկան, ճարտարապետությունը և մարտահրավերները:

Նախապատմություն

LLM-ները նեյրոնային ցանցի մի տեսակ են, որը վերապատրաստվում է հսկայական քանակությամբ տեքստային տվյալների վրա՝ սովորելու բառերի և հասկացությունների միջև օրինաչափություններ և հարաբերություններ: Այս մոդելները սովորաբար բաղկացած են կոդավորիչից և ապակոդավորիչից, որտեղ կոդավորիչը մշակում է մուտքային տեքստը, իսկ ապակոդավորիչը՝ ելքային տեքստը: Կոդավորիչը սովորաբար տրանսֆորմատորի վրա հիմնված ճարտարապետություն է, որը հատկապես հարմար է հաջորդական տվյալների համար, ինչպիսին է տեքստը:

Տրանսֆորմատորային ճարտարապետություն

Տրանսֆորմատորային ճարտարապետությունը, որը ներկայացված է Վասվանիի և այլոց «Ուշադրությունն այն ամենն է, ինչ ձեզ հարկավոր է» թղթում: (2017), դարձել է դե ֆակտո ստանդարտ LLM-ների համար: Տրանսֆորմատորը բաղկացած է կոդավորիչից և ապակոդավորիչից, որոնցից յուրաքանչյուրը բաղկացած է մի քանի շերտերից: Յուրաքանչյուր շերտ բաղկացած է երկու ենթաշերտից՝ ինքնաուշադրության մեխանիզմից և ամբողջությամբ միացված սնուցման ցանցից (FFNN):

«Պիթոն». ներմուծման ջահ ներմուծել torch.nn որպես nn

class 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.Գծային (d_model, d_ff) self.dropout = nn.Dropout(0.1) self.layer_norm = nn.LayerNorm(d_model)

def առաջ (ես, x):
    # Ինքն ուշադրության մեխանիզմ
    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)

    վերադարձնել x_ffnn

## Առաջընթացներ LLM հիմնավորման մեջ

LLM-ները զգալի առաջընթաց են գրանցել հասկացությունների միջև բարդ հարաբերությունները հիմնավորելու և հասկանալու հարցում: Հիմնական առաջընթացներից մի քանիսը ներառում են.

### 1. Գրաֆիկի վրա հիմնված պատճառաբանություն

Գրաֆիկի վրա հիմնված դատողությունը ներառում է գիտելիքը որպես գրաֆիկ ներկայացնելը, որտեղ հանգույցները ներկայացնում են հասկացությունները, իսկ եզրերը ներկայացնում են նրանց միջև հարաբերությունները: LLM-ները կարող են վերապատրաստվել տրամաբանելու այս գրաֆիկների մասին՝ կանխատեսումներ անելով հանգույցների միջև փոխհարաբերությունների վերաբերյալ:

`` ժանգ
օգտագործել graph::Graph;
օգտագործել neural_network::NeuralNetwork;

fn graph_reasoning (գրաֆիկ՝ &Գրաֆիկ, հարցում՝ &str) -> Տող {
    թող ներկառուցում = neural_network.query (գրաֆիկ, հարցում);
    թող արդյունք = neural_network.reason (գրաֆիկ, ներդրում);
    result.to_string()
}

2. Բազմաֆունկցիոնալ ուսուցում

Բազմ առաջադրանքների ուսուցումը ներառում է մի մոդելի ուսուցում միաժամանակ մի քանի առաջադրանքների վրա: Ապացուցված է, որ այս մոտեցումը բարելավում է LLM-ների կատարողականը տարբեր խնդիրների, ներառյալ հիմնավորումը և բարդ հարաբերությունները հասկանալը:

``գնացեք փաթեթի հիմնական

ներմուծում ( «fmt» «gonum.org/v1/gonum/mat» )

մուտքագրել Model struct { *nn.Գծային *nn.Գծային }

func (m *Model) Forward(x *mat.Dense) *mat.Dense { // Առաջ փոխանցում z := m. Գծային (x) z = m. Գծային (z) վերադարձնել z }

### 3. Ուշադրության մեխանիզմներ

Ուշադրության մեխանիզմները թույլ են տալիս LLM-ներին ելք ստեղծելիս կենտրոնանալ մուտքագրված տեքստի որոշակի մասերի վրա: Ապացուցված է, որ այս մոտեցումը բարելավում է LLM-ների կատարողականը տարբեր խնդիրների, ներառյալ հիմնավորումը և բարդ հարաբերությունները հասկանալը:

«Պիթոն».
ներմուծման ջահ
ներմուծել torch.nn որպես nn

դասի ուշադրության մեխանիզմ (nn.Module):
    def __init__(self, d_model, n_heads):
        սուպեր(Ուշադրության մեխանիզմ, ինքնուրույն):__սկզբում__()
        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 առաջ (ես, x):
        # Հարցում, բանալի և արժեք
        q = self.query(x)
        k = self.key(x)
        v = self.value(x)

        # Ուշադրություն կշիռներ
        կշիռներ = torch.matmul(q, k.T) / math.sqrt(q.shape[1])
        weights = self.dropout(weights)
        կշիռներ = torch.softmax (կշիռներ, dim=-1)

        # Համատեքստային վեկտոր
        համատեքստ = torch.matmul (կշիռներ, v)

        վերադարձի համատեքստ

Վիզուալիզացիա

Տարբեր առաջադրանքների վրա LLM-ների կատարումը պատկերացնելու համար մենք կարող ենք օգտագործել գծապատկեր՝ տվյալ առաջադրանքի տարբեր մոդելների ճշգրտությունը համեմատելու համար: Ահա Chart.js-ի օգտագործմամբ գծապատկերի օրինակ.

{
  «տեսակ»՝ «բար»,
  "տվյալներ": {
    «պիտակներ»՝ [«Առաջադրանք 1», «Առաջադրանք 2», «Առաջադրանք 3»],
    «տվյալների հավաքածուներ»:
      {
        «պիտակ»: «Մոդել 1»,
        «տվյալներ»՝ [0.8, 0.7, 0.9],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        «սահմանի լայնություն»՝ 1
      },
      {
        "պիտակ": "Model 2",
        «տվյալներ»: [0.9, 0.8, 0.7],
        "backgroundColor": "rgba(54, 162, 235, 0.2)",
        "borderColor": "rgba(54, 162, 235, 1)",
        «սահմանի լայնություն»՝ 1
      }
    ]
  },
  «Ընտրանքներ»: {
    «վերնագիր»: {
      «ցուցադրում»՝ ճշմարիտ,
      "text": "Տարբեր մոդելների ճշգրտությունը տարբեր առաջադրանքների վրա"
    },
    «կշեռքներ»: {
      «yAxes»:
        {
          "ticks": {
            «beginAtZero»: ճիշտ է
          }
        }
      ]
    }
  }
}

Եզրակացություն

Այս հոդվածում մենք ուսումնասիրել ենք LLM հիմնավորման առաջընթացը, ներառյալ գրաֆիկի վրա հիմնված հիմնավորումը, բազմաբնույթ առաջադրանքների ուսուցումը և ուշադրության մեխանիզմները: Մենք տրամադրել ենք նաև կոդերի օրինակներ Python-ում, Rust-ում և Go-ում՝ այս հասկացությունները լուսաբանելու համար: Վերջապես, մենք օգտագործել ենք գծապատկեր՝ տարբեր առաջադրանքներում LLM-ների կատարողականը պատկերացնելու համար: Այս առաջընթացները կարող են հեղափոխել NLP-ի ոլորտը՝ թույլ տալով LLM-ներին տրամաբանել և հասկանալ հասկացությունների միջև բարդ հարաբերությունները:

Հղումներ

• Վասվանին և այլք: (2017). Ուշադրությունն այն ամենն է, ինչ ձեզ հարկավոր է: arXiv նախատպել arXiv:1706.03762.
• Devlin et al. (2018). BERT. Խորը երկկողմանի տրանսֆորմատորների նախնական ուսուցում լեզվի ըմբռնման համար: arXiv նախնական տպագրություն arXiv:1810.04805.
• Radford et al. (2019): Լեզուների մոդելները չվերահսկվող բազմաբնույթ առաջադրանք սովորողներ են: arXiv նախատպել arXiv:1906.08237.