Alle Herausforderungen
Mittel 0 gelöst 0% Erfolgsquote

Kausale (maskierte) Self-Attention

Implementiere die maskierte Attention von GPT-Modellen, bei der jedes Token nur sich selbst und frühere Tokens sehen kann.

Das lernst du

  • Zukünftige Tokens mit einer kausalen Maske verbergen
  • Softmax nur über erlaubte Positionen anwenden
  • Verstehen, wie Sprachmodelle Text erzeugen

Problem

Ein Sprachmodell darf nicht in zukünftige Wörter schauen. Kausale Attention maskiert die Zukunft: Query-Zeile i darf nur auf die Key-Zeilen 0 bis i achten.

Für jede Zeile i (queries, keys und values haben alle n Zeilen):

  1. Bewerte jeden erlaubten Key j ≤ i: score = (queries[i] · keys[j]) / √d, wobei d die Anzahl der Spalten von keys ist.
  2. Wende Softmax nur auf diese erlaubten Scores an (ziehe den größten ab, bevor du e^x berechnest).
  3. Ausgabezeile i = Σ weight_j × values[j] über j ≤ i.

Implementiere causal_attention(queries, keys, values).

Eingabe

queries, keys: n Zeilen mit je d Zahlen.

values: n Zeilen mit je v Zahlen.

Ausgabe

Gib die n × v-Ausgabematrix zurück.

Einschränkungen

1 ≤ n ≤ 50, 1 ≤ d, v ≤ 32

-10 ≤ jeder Wert ≤ 10

Beispiele

Beispiel 1
Eingabe:
queries = [
    [0.0],
    [0.0],
    [0.0]
]
keys = [
    [1.0],
    [2.0],
    [3.0]
]
values = [
    [3.0],
    [6.0],
    [9.0]
]

Erwartete Ausgabe:
expected = [
    [3.0],
    [4.5],
    [6.0]
]
Eingabe:
std::vector<std::vector<double>> queries = {
    {0.0},
    {0.0},
    {0.0}
};
std::vector<std::vector<double>> keys = {
    {1.0},
    {2.0},
    {3.0}
};
std::vector<std::vector<double>> values = {
    {3.0},
    {6.0},
    {9.0}
};

Erwartete Ausgabe:
std::vector<std::vector<double>> expected = {
    {3.0},
    {4.5},
    {6.0}
};
Eingabe:
double[][] queries = new double[][] {
    new double[] {0.0},
    new double[] {0.0},
    new double[] {0.0}
};
double[][] keys = new double[][] {
    new double[] {1.0},
    new double[] {2.0},
    new double[] {3.0}
};
double[][] values = new double[][] {
    new double[] {3.0},
    new double[] {6.0},
    new double[] {9.0}
};

Erwartete Ausgabe:
double[][] expected = new double[][] {
    new double[] {3.0},
    new double[] {4.5},
    new double[] {6.0}
};

Erläuterung

Alle Scores sind 0, also mittelt jede Zeile die Werte, die sie sehen darf: Zeile 0 sieht nur 3, Zeile 1 mittelt 3 und 6 (4.5), Zeile 2 mittelt alle drei (6).

Beispiel 2
Eingabe:
queries = [
    [1.0, 0.0],
    [1.0, 0.0]
]
keys = [
    [1.0, 0.0],
    [1.0, 0.0]
]
values = [
    [1.0, 2.0],
    [3.0, 4.0]
]

Erwartete Ausgabe:
expected = [
    [1.0, 2.0],
    [2.0, 3.0]
]
Eingabe:
std::vector<std::vector<double>> queries = {
    {1.0, 0.0},
    {1.0, 0.0}
};
std::vector<std::vector<double>> keys = {
    {1.0, 0.0},
    {1.0, 0.0}
};
std::vector<std::vector<double>> values = {
    {1.0, 2.0},
    {3.0, 4.0}
};

Erwartete Ausgabe:
std::vector<std::vector<double>> expected = {
    {1.0, 2.0},
    {2.0, 3.0}
};
Eingabe:
double[][] queries = new double[][] {
    new double[] {1.0, 0.0},
    new double[] {1.0, 0.0}
};
double[][] keys = new double[][] {
    new double[] {1.0, 0.0},
    new double[] {1.0, 0.0}
};
double[][] values = new double[][] {
    new double[] {1.0, 2.0},
    new double[] {3.0, 4.0}
};

Erwartete Ausgabe:
double[][] expected = new double[][] {
    new double[] {1.0, 2.0},
    new double[] {2.0, 3.0}
};

Erläuterung

Zeile 0 sieht nur sich selbst und kopiert values[0] = [1, 2]. Zeile 1 gibt beiden Keys denselben Score und mittelt sie: [2, 3].

So gehst du vor

Versuch es zuerst allein und öffne dann einen Hinweis nach dem anderen.

Hinweis 1

Jede Ausgabereihe darf nur Keys und Values aus der aktuellen und allen früheren Reihen verwenden.

Hinweis 2

Berechne die Skalarprodukte, skaliere sie mit der Wurzel der Key-Dimension und wende dann eine stabile Softmax nur auf die erlaubten Reihen an.

Hinweis 3

Vergiss nicht, jede Query-Zeile separat zu normalisieren, und behandle die erste Zeile mit nur einem erlaubten Key.

Erwartete Komplexität

Zeit O(n^2 * (d + v)), zusätzlicher Speicher O(n * v)

Referenzen

Diese Aufgabe wurde für CodeUtility angepasst. Beachte die oben genannten Vorgaben und Einschränkungen.

Die beste bestandene Lösung jedes Coders. Schnellere, sparsamere und besser bewertete Lösungen stehen weiter oben.

Noch keine bestandene Lösung. Löse sie und hol dir Platz eins.

Von anderen lernen

Community-Lösungen

Noch keine veröffentlichten Lösungen. Löse die Aufgabe und teile als Erster eine Lösung.