Wprowadzenie
Modele dużego języka (LLM) zrewolucjonizowały w ostatnich latach dziedzinę przetwarzania języka naturalnego (NLP). Modele te osiągnęły najnowocześniejsze wyniki w różnych zadaniach NLP, w tym w tłumaczeniu języka, podsumowywaniu tekstu i odpowiadaniu na pytania. Jednak prawdziwy potencjał LLM leży w ich zdolności do rozumowania i rozumienia złożonych relacji między pojęciami. W tym artykule zagłębimy się w postępy w rozumowaniu LLM, badając leżące u ich podstaw techniki, architektury i wyzwania.
Tło
LLM to rodzaj sieci neuronowej trenowanej na ogromnych ilościach danych tekstowych w celu uczenia się wzorców i relacji między słowami i pojęciami. Modele te zazwyczaj składają się z kodera i dekodera, przy czym koder przetwarza tekst wejściowy, a dekoder generuje tekst wyjściowy. Koder ma zwykle architekturę opartą na transformatorze, która szczególnie dobrze nadaje się do danych sekwencyjnych, takich jak tekst.
Architektura transformatorowa
Architektura transformatora, przedstawiona w artykule „Attention is All You Need” autorstwa Vaswani i in. (2017) stała się de facto standardem dla LLM. Transformator składa się z kodera i dekodera, każdy złożony z wielu warstw. Każda warstwa składa się z dwóch podwarstw: mechanizmu samouważności i w pełni połączonej sieci wyprzedzającej (FFNN).
importuj pochodnię
importuj plik palnika.nn jako nn
klasa 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.Linear(d_model, d_ff)
self.dropout = nn.Dropout(0.1)
self.layer_norm = nn.LayerNorm(d_model)
def forward(self, x):
# Mechanizm samouwagi
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)
zwróć x_ffnn
Postępy w rozumowaniu LLM
LLM poczyniły znaczne postępy w rozumowaniu i rozumieniu złożonych relacji między pojęciami. Niektóre z kluczowych osiągnięć obejmują:
1. Rozumowanie oparte na wykresach
Rozumowanie oparte na grafach polega na przedstawianiu wiedzy w postaci wykresu, gdzie węzły reprezentują pojęcia, a krawędzie relacje między nimi. LLM można przeszkolić w zakresie wnioskowania na temat tych wykresów i przewidywania relacji między węzłami.
„rdza”. użyj wykresu::Wykres; użyj sieci neuronowej::NeuralNetwork;
fn graph_reasoning(wykres: &wykres, zapytanie: &str) -> Ciąg { niech osadzanie = sieć_neuralna.query(wykres, zapytanie); niech wynik = sieć_neuralna.powód(wykres, osadzanie); wynik.to_string() }
### 2. Uczenie się wielozadaniowe
Uczenie się wielozadaniowe polega na szkoleniu jednego modelu w zakresie wielu zadań jednocześnie. Wykazano, że takie podejście poprawia wydajność LLM w zakresie różnych zadań, w tym rozumowania i rozumienia złożonych relacji.
idź
pakiet główny
importować (
„fm”
„gonum.org/v1/gonum/mat”
)
wpisz strukturę modelu {
*nn.Liniowy
*nn.Liniowy
}
func (m *Model) Do przodu(x *mat.Dense) *mat.Dense {
// Podanie w przód
z := m.Liniowy(x)
z = m.Liniowy(z)
zwrócić z
}
3. Mechanizmy uwagi
Mechanizmy uwagi pozwalają LLM skupić się na określonych częściach tekstu wejściowego podczas generowania danych wyjściowych. Wykazano, że takie podejście poprawia wydajność LLM w zakresie różnych zadań, w tym rozumowania i rozumienia złożonych relacji.
importuj pochodnię
importuj plik palnika.nn jako nn
klasa AttentionMechanism(nn.Module):
def __init__(self, d_model, n_heads):
super(Mechanizm uwagi, 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):
# Zapytanie, klucz i wartość
q = self.query(x)
k = klucz własny(x)
v = wartość własna(x)
# Uwaga, wagi
wagi = torch.matmul(q, k.T) / math.sqrt(q.shape[1])
wagi = self.dropout(wagi)
wagi = torch.softmax(wagi, dim=-1)
# Wektor kontekstowy
kontekst = latarka.matmul(wagi, v)
zwróć kontekst
Wizualizacja
Aby zwizualizować wydajność LLM w różnych zadaniach, możemy użyć wykresu porównującego dokładność różnych modeli w danym zadaniu. Oto przykład wykresu wykorzystującego Chart.js:
{
"typ": "pasek",
„dane”: {
"etykiety": ["Zadanie 1", "Zadanie 2", "Zadanie 3"],
„zestawy danych”: [
{
"etykieta": "Model 1",
„dane”: [0,8, 0,7, 0,9],
"backgroundColor": "rgba(255, 99, 132, 0.2)",
"borderColor": "rgba(255, 99, 132, 1)",
„Szerokość obramowania”: 1
},
{
"etykieta": "Model 2",
„dane”: [0,9, 0,8, 0,7],
"backgroundColor": "rgba(54, 162, 235, 0.2)",
"borderColor": "rgba(54, 162, 235, 1)",
„Szerokość obramowania”: 1
}
]
},
„opcje”: {
"tytuł": {
"wyświetlacz": prawda,
"text": "Dokładność różnych modeli przy różnych zadaniach"
},
„skale”: {
„Osie y”: [
{
„tyknięcia”: {
„beginAtZero”: prawda
}
}
]
}
}
}
Wniosek
W tym artykule zbadaliśmy postępy w rozumowaniu LLM, w tym rozumowanie oparte na grafach, uczenie się wielozadaniowe i mechanizmy uwagi. Aby zilustrować te koncepcje, udostępniliśmy także przykłady kodu w językach Python, Rust i Go. Na koniec użyliśmy wykresu do wizualizacji wydajności LLM w różnych zadaniach. Postępy te mogą zrewolucjonizować dziedzinę NLP, umożliwiając osobom LLM rozumowanie i zrozumienie złożonych relacji między koncepcjami.
Referencje
- Vaswani i in. (2017). Uwaga jest wszystkim, czego potrzebujesz. Przedruk arXiv arXiv:1706.03762.
- Devlin i in. (2018). BERT: Wstępne szkolenie głębokich transformatorów dwukierunkowych w zakresie rozumienia języka. Przedruk arXiv arXiv:1810.04805.
- Radford i in. (2019). Modele językowe to osoby uczące się wielozadaniowo bez nadzoru. Przedruk arXiv arXiv:1906.08237.