Multi-Head-Self-Attention

Multi-Head-Attention lässt einen Transformer auf mehrere Dinge gleichzeitig achten. Mit Eingabe X (n Tokens × d Spalten) und Gewichtsmatrizen der Größe d × d:

Q = X × w_q, K = X × w_k, V = X × w_v
Teile die d Spalten in num_heads Heads mit je d_k = d / num_heads aufeinanderfolgenden Spalten (Head h verwendet die Spalten h×d_k bis (h+1)×d_k - 1).
Führe für jeden Head skalierte Skalarprodukt-Attention auf seinen Spalten aus: Für Token i ist score_j = (Q_i · K_j) / √d_k über die Spalten dieses Heads, Softmax über alle n Tokens j und Ausgabe = Σ weight_j × V_j (Spalten dieses Heads).
Setze die Ausgaben der Heads in ihre Spalten zurück (Konkatenation) und multipliziere mit w_o.

Implementiere multi_head_attention(x, w_q, w_k, w_v, w_o, num_heads).

Eingabe

x: n × d-Eingabematrix.

w_q, w_k, w_v, w_o: d × d-Gewichtsmatrizen.

num_heads: Anzahl der Heads (d ist durch sie teilbar).

Ausgabe

Gib die n × d-Ausgabematrix zurück.

Einschränkungen

1 ≤ n ≤ 30, 1 ≤ d ≤ 32, 1 ≤ num_heads ≤ d und d ist durch num_heads teilbar

-5 ≤ jeder Wert ≤ 5

Beispiele

Beispiel 1

Eingabe:
x = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_q = [
    [0.0, 0.0],
    [0.0, 0.0]
]
w_k = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_v = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_o = [
    [1.0, 0.0],
    [0.0, 1.0]
]
num_heads = 1

Erwartete Ausgabe:
[
    [0.5, 0.5],
    [0.5, 0.5]
]

Erläuterung

w_q besteht nur aus Nullen, also sind alle Scores 0 und jedes Token mittelt die Value-Zeilen: V = X, also werden beide Zeilen zu [0.5, 0.5].

Beispiel 2

Eingabe:
x = [
    [2.0, 4.0]
]
w_q = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_k = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_v = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_o = [
    [0.0, 1.0],
    [1.0, 0.0]
]
num_heads = 2

Erwartete Ausgabe:
[
    [4.0, 2.0]
]

Erläuterung

Mit nur einem Token achtet jeder Head nur auf sich selbst, also ist die konkatenierte Ausgabe V = [2, 4]. w_o vertauscht die beiden Spalten: [4, 2].

Referenzen

Führe die Beispieltests aus, um deinen Code zu prüfen, ohne einzureichen.

Beispiel 1 Nicht ausgeführt

Eingabe:

x = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_q = [
    [0.0, 0.0],
    [0.0, 0.0]
]
w_k = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_v = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_o = [
    [1.0, 0.0],
    [0.0, 1.0]
]
num_heads = 1

Erwartete Ausgabe:

[
    [0.5, 0.5],
    [0.5, 0.5]
]

Deine Ausgabe

Beispiel 2 Nicht ausgeführt

Eingabe:

x = [
    [2.0, 4.0]
]
w_q = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_k = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_v = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_o = [
    [0.0, 1.0],
    [1.0, 0.0]
]
num_heads = 2

Erwartete Ausgabe:

[
    [4.0, 2.0]
]

Deine Ausgabe

4 versteckte Tests werden beim Einreichen ebenfalls ausgeführt. Scheitert dein Code an einem, siehst du diesen Test. Löse die Aufgabe, um alle zu sehen.

Online Rust Compiler

Write, compile, run, and debug Rust code online in a full-featured browser IDE. Work with multiple files, save your workspace, and share or collaborate in real time.

Version

Vorinstallierte Bibliotheken

🚀 252,702 Gesamt-Ausführungen (135 diesen Monat)

Ausgabe

Übe Rust mit Coding Challenges

Löse praktische Aufgaben direkt im Editor: Führe die Beispieltests aus, reiche ein und erhalte ein KI-Code-Review.

Alle Rust-Challenges

Einfach

Rechteck-Umfang

Berechne den Umfang eines Rechtecks anhand seiner Seiten.

Du lernst ArithmetikRückgabewerte

BeginnerLearning-pathVariables

Lösungen anzeigen (12)

Einfach

Distance Between Points

Compute the straight-line distance between two points.

Du lernst Satz des PythagorasQuadratwurzeln

BeginnerFunctionsLearning-pathmath

Lösungen anzeigen (7)

Einfach

Days in a Month

Return how many days a month has, including leap years.

Du lernst KalenderregelnHilfsfunktionen

BeginnerConditionsFunctionsLearning-path

Lösungen anzeigen (6)

Einfach

Average of Three

Average three whole numbers.

Du lernst ArithmetikDivision

BeginnerLearning-pathVariables

Lösungen anzeigen (6)

Einfach

Skalarprodukt zweier Vektoren

Multipliziere zwei Vektoren elementweise und addiere die Ergebnisse, die Kernoperation jedes Neurons.

Du lernst VektorenSkalarprodukt

Neuronale Netzeaimaschinelles Lernen

Lösungen anzeigen (4)

Einfach

Das Größte von Drei

Finde die größte von drei Zahlen ohne eingebaute Maximalfunktion.

Du lernst VergleicheBedingungen kombinieren

BeginnerConditionsLearning-path

Lösungen anzeigen (4)

Einfach

Primzahl-Prüfung

Entscheide, ob eine Zahl eine Primzahl ist.

Du lernst TeilbarkeitSchleifen optimieren

BeginnerLoopsNumbersStudent-beginner

Lösungen anzeigen (3)

Einfach

Number Triangle

Build a triangle of increasing numbers.

Du lernst Wachsende ZeilenZähler über Zeilen

BeginnerLearning-pathNested-loopsPatterns

Lösungen anzeigen (3)

Einfach

Armstrong-Zahl

Prüfe, ob eine Zahl gleich der Summe ihrer Ziffern ist, wobei jede Ziffer auf die Anzahl der Ziffern potenziert wird.

Du lernst Ziffern extrahierenPotenzen

BeginnerNumbersStudent-beginner

Lösungen anzeigen (3)

Einfach

Row Sums

Add up every row of a grid.

Du lernst 2D-ListenVerschachtelte Schleifen

BeginnerGridsLearning-path

Lösungen anzeigen (3)

Einfach

Min and Max Together

Find the smallest and largest value in one pass.

Du lernst Ein DurchlaufMehrere Rückgabewerte

ArraysBeginnerFunctionsLearning-path

Lösungen anzeigen (3)

Einfach

Count Pairs With a Sum

Count pairs of positions whose values add up to a target.

Du lernst IndexpaareDoppelzählung vermeiden

ArraysBeginnerLearning-pathNested-loops

Lösungen anzeigen (3)

🦀 Über diesen Rust-Online-Executor

Der CodeUtility Rust Executor ermöglicht es dir, Rust-Code direkt in deinem Browser zu schreiben und auszuführen - keine Installation, kein Toolchain-Setup und keine lokale Umgebung nötig. Er wird von einer sicheren Sandbox betrieben, die echte Rust-Compiler-Versionen 1.70, 1.72, 1.73 und 1.74 unterstützt.

Dieses Tool kompiliert und führt deine Rust-Programme in der Cloud mit einem echten rustc-Compiler aus, was genaue und konsistente Ergebnisse sicherstellt. Du kannst ganz einfach mit Variablen, Ownership, Borrowing, Pattern Matching, Traits, Generics und anderen modernen Rust-Features experimentieren.

Es eignet sich ideal, um die Kernkonzepte von Rust zu lernen - insbesondere Speichersicherheit, Fehlerbehandlung und Nebenläufigkeit - ganz ohne Cargo-Installation oder lokale Einrichtung. Alles läuft in Sekunden direkt in deinem Browser.

Mehr als nur ein Code-Runner

Nutzen Sie im selben Executor einen Editor für mehrere Dateien, ein isoliertes Ausführungsterminal, laufzeitspezifische Bibliotheken, persistente Arbeitsbereiche, Freigaben und Zusammenarbeit in Echtzeit.

Wie verwende ich diesen Executor?

Wählen Sie eine Laufzeit aus, öffnen oder erstellen Sie eine Datei, schreiben Sie Ihren Code und wählen Sie Ausführen. Die Ausgabe erscheint im Terminal. Angemeldete Benutzer können Dateien in einem Arbeitsbereich speichern, Bibliotheken installieren und über Freigaben zusammenarbeiten.

Wählen Sie eine Version aus und bearbeiten Sie die aktuelle Datei oder öffnen Sie eine andere Datei aus dem Arbeitsbereich.
Führen Sie den Code aus, geben Sie bei Aufforderung Daten im Terminal ein und prüfen Sie den gespeicherten Ausführungsverlauf.
Nutzen Sie Bibliotheken, Arbeitsbereichswerkzeuge, Freigaben und den Chat, wenn Ihre Aufgabe mehr als ein einzelnes Codefragment erfordert.

Beginnen Sie mit dem Codieren

VersionWählen Sie vor der Ausführung eine Laufzeit aus.Installierte Bibliotheken gehören zur ausgewählten Sprachversion.
„Offene Dateien“ listet ungeöffnete Textdateien auf.Wählen Sie eine aus, um sie in einer verfügbaren Editor-Registerkarte zu öffnen.
Ausführen führt die aktive Datei aus, wobei ihr Arbeitsbereich für das Programm verfügbar ist.
Stop beendet die aktuelle Ausführung vor ihrem Zeitlimit.
Der erweiterte Modus öffnet das IDE-Layout mit einem Datei-Explorer und einem beweglichen, in der Größe veränderbaren Terminal.

Arbeitsbereich und Bibliotheken

Neue Datei erstellt eine Datei im ausgewählten übergeordneten Verzeichnis und öffnet sie im Editor.
Neuer Ordner erstellt ein Verzeichnis bis zur unterstützten Verschachtelungstiefe.
Dateien hochladen fügt einem Verzeichnis eine oder mehrere sichere Dateien hinzu.
Beim Herunterladen wird eine Datei oder ein ZIP-Verzeichnis auf Ihrem Gerät gespeichert.
Durch Kopieren wird eine Arbeitsbereichsdatei oder ein Arbeitsbereichsverzeichnis dupliziert.
Umbenennen ändert den Namen einer Datei und aktualisiert die geöffnete Registerkarte und den Verlauf.
„Verschieben“ verschiebt ein Element;Dateien und Verzeichnisse können ebenfalls gezogen werden.
Mit „Löschen“ wird ein Element nach der Bestätigung entfernt und die geöffnete Editor-Registerkarte geschlossen.
Vorinstallierte Bibliotheken zeigen Pakete an, die bereits in dieser Laufzeit enthalten sind.
Add Lib installiert ein privates Paket für Ihr Konto und die ausgewählte Laufzeit.

Terminal und Hilfe

Der Ausführungsverlauf öffnet die vorherigen und nächsten gespeicherten Ausgaben.
Ausgabe kopieren kopiert den aktuellen Terminaltext.
„Ausgabe löschen“ entfernt nach der Bestätigung alle gespeicherten Laufausgaben.
Explain fasst den aktiven Code zusammen.
„Neueste“ öffnet aktuelle Erklärungen und Ergebnisse.
Die Einstellungen ändern Schriftarten, Designs und sichtbare Symbolleistenschaltflächen.

Teilen und Zusammenarbeit

Share veröffentlicht die aktuelle Datei, ein Verzeichnis oder den gesamten Arbeitsbereich als Snapshot oder Live-Arbeitsbereich.Sie kontrollieren den Linkzugriff und bestimmen, wer Änderungen speichern darf.
Protokolle zeichnen gespeicherte Mitarbeiteraktionen in einem gemeinsam genutzten Arbeitsbereich auf.
Mit dem Share-Chat können angemeldete Teilnehmer Nachrichten senden, Personen erwähnen, Codeblöcke teilen und Online- oder Tippmitglieder sehen.
Bei der Live-Zusammenarbeit werden die Cursor der Mitwirkenden und gespeicherte Dateiaktualisierungen angezeigt.Nur-Leser-Benutzer können die neueste Version laden oder vorübergehende Änderungen beibehalten.

Quoten und Grenzen

Die Ausführungszeit ist auf 20 Sekunden pro Serverlauf begrenzt.Verwenden Sie Stopp, wenn Sie es früher beenden möchten.
Der Arbeitsbereichsspeicher ermöglicht 100 Dateien, 100 Verzeichnisse und insgesamt 10 MiB für jeden angemeldeten Benutzerarbeitsbereich und jede Sprache.
Dateien und Ordner sind auf 1 MiB pro Datei und 5 verschachtelte Verzeichnisebenen beschränkt.Für von Ihrem Code generierte Dateien gilt dasselbe Kontingent.
Private Bibliotheken sind auf 10 installierte Pakete pro Konto und Laufzeit beschränkt.
Freigabe-Snapshots können bis zu 100 Dateien, 1 MiB pro Datei und insgesamt 2 MiB enthalten.
Freigabeeinladungen unterstützen bis zu 25 Personen pro Freigabe, wobei Zugriffs- und Speicherberechtigungen separat verwaltet werden.
Der Share-Chat erlaubt 2.000 Zeichen pro Nachricht und 10.000 Nachrichten pro Share.
Die Kontingenterzwingung gilt auch während der Codeausführung.Ein Schreibvorgang, der die Dateianzahl, -größe, -speicherung oder -verschachtelungsgrenzen überschreitet, wird sicher abgelehnt.

Gut zu wissen Führen Sie nur Code aus und installieren Sie Pakete, denen Sie vertrauen.Die Ausführung ist isoliert und eingeschränkt, Ihr Programm kann jedoch weiterhin Dateien in einem beschreibbaren Arbeitsbereich bis zu seinem erzwungenen Kontingent ändern.

💡 Rust-Grundlagen & Beispiele, die du oben ausprobieren kannst

1. Variablen und Konstanten deklarieren

Verwende let, um Variablen zu deklarieren. Verwende const für Konstanten und mut für veränderliche Variablen.

let x = 10;
let pi: f64 = 3.14;
let name = "Alice";
let is_active = true;

const MAX_USERS: u32 = 100;

2. Bedingungen (if / match)

Rust verwendet if für Bedingungen und match für Pattern Matching.

let x = 2;
if x == 1 {
    println!("Eins");
} else if x == 2 {
    println!("Zwei");
} else {
    println!("Sonstiges");
}

match x {
    1 => println!("Eins"),
    2 => println!("Zwei"),
    _ => println!("Sonstiges"),
}

3. Schleifen

Rust unterstützt for, while und die unendliche Schleife loop.

for i in 0..3 {
    println!("{}", i);
}

let mut n = 3;
while n > 0 {
    println!("{}", n);
    n -= 1;
}

4. Arrays

Arrays fester Größe in Rust verwenden eckige Klammern. Verwende Slices für Ansichten.

let nums = [10, 20, 30];
println!("{}", nums[1]);

5. Vektoren (dynamische Arrays)

Vec wird für dynamische Arrays verwendet.

let mut fruits = vec!["apple", "banana"];
fruits.push("cherry");
fruits.pop();

for fruit in &fruits {
    println!("{}", fruit);
}

6. Konsolen-Ein-/Ausgabe

Verwende println! für Ausgaben und std::io für Eingaben.

use std::io;

let mut name = String::new();
println!("Gib deinen Namen ein:");
io::stdin().read_line(&mut name).unwrap();
println!("Hallo, {}", name.trim());

7. Funktionen

Funktionen verwenden fn und können mit -> Werte zurückgeben.

fn greet(name: &str) -> String {
    format!("Hallo, {}", name)
}

println!("{}", greet("Alice"));

8. HashMaps

Verwende std::collections::HashMap für Schlüssel-Wert-Daten.

use std::collections::HashMap;

let mut person = HashMap::new();
person.insert("name", "Bob");
println!("{}", person["name"])

9. Fehlerbehandlung

Rust behandelt Fehler mit Result und match oder unwrap().

fn fail() -> Result<(), String> {
    Err("Etwas ist schiefgelaufen".to_string())
}

match fail() {
    Ok(_) => println!("Erfolg"),
    Err(e) => println!("{}", e),
}

10. Datei-Ein-/Ausgabe

Verwende std::fs zum Lesen und Schreiben von Dateien.

use std::fs;

fs::write("file.txt", "Hello File").unwrap();
let content = fs::read_to_string("file.txt").unwrap();
println!("{}", content);

11. String-Verarbeitung

Strings in Rust liegen auf dem Heap und unterstützen viele Methoden.

let mut text = String::from(" Hello Rust ");
println!("{}", text.trim());
println!("{}", text.to_uppercase());
text = text.replace("Hello", "Hi");
println!("{}", text);

12. Structs & Methoden

Rust verwendet struct für Datentypen und impl für Methoden.

struct Person {
    name: String,
}

impl Person {
    fn greet(&self) -> String {
        format!("Hi, ich bin {}", self.name)
    }
}

let p = Person { name: "Alice".to_string() };
println!("{}", p.greet());

13. Referenzen & Borrowing

Rust verwendet & zum Borrowing von Werten und &mut für veränderliche Referenzen.

fn update(x: &mut i32) {
    *x += 1;
}

let mut value = 10;
update(&mut value);
println!("{}", value);