AttentionGrid
0.0.22
Aufmerksamkeitsgrid wird Ihnen von Agora gebracht. Wir sind eine brandneue Open-Source-Multi-Modal-AI-Forschungsorganisation, die sich der Weiterentwicklung der Menschheit widmet.
Besuchen Sie uns hier, um zu diesem Projekt beizutragen oder Unterstützung zu erhalten!
Aufmerksamkeitsgrid ist ein modernster Rahmen, der die Einbeziehung fortgeschrittener Aufmerksamkeitsmechanismen in KI-Modelle demokratisieren soll. Mit den neuesten Entwicklungen in aufmerksamkeitsbasierten Transformatormodellen wird Aufmerksamkeitsgrid die Welt der Aufmerksamkeitsmechanismen für Praktiker, Forscher und Enthusiasten für maschinelles Lernen gleichermaßen eröffnet.
Um mit Aufmerksamkeit mit Aufmerksamkeit abzublasen, installieren Sie das Paket mit PIP:
pip install AttentionGridDas Implementieren eines Aufmerksamkeitsmechanismus oder eines Transformatormodells mit Aufmerksamkeitsgrad ist so einfach wie:
from AttentionGrid import BlockwiseParallelJax
import jax . numpy as jnp
# Initialize the class
bpjax = BlockwiseParallelJax (
q_chunk_size = 64 ,
k_chunk_size = 64 ,
hidden_size = 768 ,
num_heads = 12 ,
rotary_dim = 32 ,
intermediate_size = 3072
)
# Suppose we have hidden_states, attention_mask, and position_ids as input data
hidden_states = jnp . random . rand ( 1 , 100 , 768 )
attention_mask = jnp . random . rand ( 1 , 1 , 100 , 100 )
position_ids = jnp . arange ( 100 ). reshape ( 1 , 100 )
# You can now apply the attention mechanism to your input data
output = bpjax . forward ( hidden_states , attention_mask , position_ids )Wir ermutigen Sie, Aufmerksamkeit mit Ihrer Community aufmerksam zu machen! Hier finden Sie Quick Share -Links für mehrere Social -Media -Plattformen:
Auf Twitter teilen
Teilen auf linkedIn
Auf Facebook teilen
Teilen auf reddit
Teilen auf WhatsApp
Vielen Dank, dass Sie die Aufmerksamkeit unterstützt und zur Demokratisierung von KI beigetragen haben! Zusammen können wir die Grenzen dessen überschreiten, was möglich ist.
In der riesigen Landschaft der KI haben Aufmerksamkeitsmechanismen unsere Fähigkeit revolutioniert, leistungsstarke Modelle zu erstellen, die die Feinheiten in Daten erkennen, sich auf wichtige Aspekte konzentrieren und die Gesamtleistung verbessern. Unsere Vision mit Aufmerksamkeit besteht darin, die Lücke zwischen diesen hochmodernen Mechanismen und ihren praktischen Anwendungen zu schließen und ein Tool bereitzustellen, mit dem diese Techniken in verschiedenen AI-Anwendungen zugänglich und einfach zugänglich sind.
Aufmerksamkeitsgrid wurde mit einer intuitiven und flexiblen Architektur ausgelegt, die in vier Hauptkomponenten unterteilt ist:
Kern : Dies ist das Fundament unseres Frameworks, in dem abstrakten Unterrichtsklassen untergebracht sind, die die Grundstruktur für Aufmerksamkeitsmechanismen und Transformatormodelle leiten.
Aufmerksamkeit ?: Das Verzeichnis, das verschiedenen Aufmerksamkeitsmechanismen gewidmet ist. Jeder Aufmerksamkeitsmechanismus wird basierend auf dem im Kern bereitgestellten Entwurf implementiert.
Transformers ?: Hier werden Transformatormodelle zum Leben erweckt, wobei jede nach dem im Kern definierten Design geformt wird.
Utils : Eine Toolbox, die mit Helferklassen für wesentliche Aufgaben wie Modellbelastung, Datenvorverarbeitung und mehr gefüllt ist.
Beispiele : Entwirrung der Implementierung mit praktischen Beispielen und Nutzungsszenarien.
Modulare Struktur : Mischen und übereinstimmen unterschiedliche Aufmerksamkeitsmechanismen mit einer Vielzahl von Transformatormodellen.
Benutzerfreundlich : Dokumentation und Beispiele klaren, damit Sie schnell loslegen können.
Open Source : Offen für Beiträge und Aufmerksamkeitsgrid lebt von kollektivem Wissen und gemeinsamen Fortschritten.
Ausführlichere Beispiele finden Sie im Ordner "Beispiele" in unserem Repository.
Wir laden offen Beiträge zur Aufmerksamkeit ein! Unabhängig davon, ob Sie einen neuen Feature -Vorschlag, einen Fehlerbericht haben oder zu unserem Code hinzufügen möchten, können Sie eine Ausgabe öffnen oder eine Pull -Anfrage senden.
RecitGrid ist stolz auf Open-Source-Software, die unter der Apache-Lizenz lizenziert ist.
Aufmerksamkeitsmechanismen haben die KI transformiert, wodurch Maschinen sich auf signifikante Teile von Eingabedaten konzentrieren können. Mit Aufmerksamkeitsweiter wollen wir den Zugang zu diesen leistungsstarken Tools demokratisieren. Wir glauben, dass die Zukunft der KI in der Kraft der Aufmerksamkeit liegt, und wir hoffen, diese Reise durch Aufmerksamkeit zu beschleunigen. Erkunden Sie unser Repository, schließen Sie sich unserer Sache an und navigieren Sie gemeinsam in dieser aufregenden Landschaft!
"Die Details sind nicht die Details. Sie machen das Design." - Charles Eames
Integrieren Sie Flash -Aufmerksamkeit und Varianten
Aufmerksamkeit integrieren
Blockweise parallele Aufmerksamkeit integrieren
Integrieren Sie dynamische spärliche Flash -Aufmerksamkeit
Integrieren Sie die Aufmerksamkeit der Kreuzung von ImageBind
Colt-5-Aufmerksamkeit integrieren
Multi-Quer-Aufmerksamkeit integrieren
Integrieren Sie Wrapper aus lucid regen x_transformers, decoder, achtgefügt, codierer, Transformatorverpackung
| Mechanismus | Aufrufmethode | Beispielimport |
|---|---|---|
| Selbstbeziehung | from AttentionGrid import SelfAttention | from AttentionGrid import SelfAttention |
| Globale Aufmerksamkeit | from AttentionGrid import GlobalAttention | from AttentionGrid import GlobalAttention |
| Lokale Aufmerksamkeit | from AttentionGrid import LocalAttention | from AttentionGrid import LocalAttention |
| Hierarchische Aufmerksamkeit | from AttentionGrid import HierarchicalAttention | from AttentionGrid import HierarchicalAttention |
| Dynamische spärliche Aufmerksamkeit | from AttentionGrid import dynamic_sparse_attention | from AttentionGrid import dynamic_sparse_attention |
| Kompaktfunktion | from AttentionGrid import compact | from AttentionGrid import compact |
| PAD -Indexfunktion | from AttentionGrid import pad_index | from AttentionGrid import pad_index |
| Blockweise parallele Aufmerksamkeit | from AttentionGrid import BlockwiseParallelJax | from AttentionGrid import BlockwiseParallelJax |
| Flash -Aufmerksamkeit | from AttentionGrid import FlashAttention | from AttentionGrid import FlashAttention |
| Wahrzeichen Aufmerksamkeit | from AttentionGrid import LandmarkAttention | from AttentionGrid import LandmarkAttention |
| Colt-5 Aufmerksamkeit | from AttentionGrid import Colt5Attention | from AttentionGrid import Colt5Attention |
| Multi-Quer-Aufmerksamkeit | from AttentionGrid import MultiQueryAttention | from AttentionGrid import MultiQueryAttention |
| Erweiterte Aufmerksamkeit | from AttentionGrid import DilatedAttention | from AttentionGrid import DilatedAttention |
Die dynamic_sparse_attention -Funktion von Agora ermöglicht die Flexibilität, zwischen der Hash-Parse-Implementierung und der Implementierung von QK-Sparse zu wählen. Das Ziel dieser Funktion ist es, den spärlichen Aufmerksamkeitsmechanismus dynamisch auf der Grundlage des ausgewählten sparsity_mode zu lenken.
Die Funktionsparameter sind wie folgt:
q : Abfragebildsor (Batch, N_CTX_Q, H, D_HEAD)k : Schlüsselzensor der Form (Batch, N_CTX_KV, H, D_HEAD)v : Wertzensor der Form (Batch, N_CTX_KV, H, D_HEAD)q_idx & k_idx : Stellen Sie entweder den Bucket Index dar, wenn Sparsity_Mode 'Hash' ist oder ob ein bestimmter Kopf beibehält, wenn Sparsity_Mode 'qk' ist. Die Tensorformen sind (Batch, N_CTX_Q, H) und (Batch, N_CTX_KV, H).sm_scale : Normalisierungskonstante, 1/sqrt (d_head), sofern nicht angegeben.sparsity_mode : 'Hash', um die Hash-Parse-Implementierung und 'QK' für die Implementierung von Qk-Sparse auszuwählen. Die sm_scale wird standardmäßig berechnet, wenn nicht angegeben, und wenn ein unbekannter sparsity_mode angegeben ist, wirft es einen SchlüsselError aus.
Die Funktion überprüft dann den sparsity_mode und ruft basierend auf ihrem Wert entweder hash_sparse_attention oder qk_sparse_attention auf.
Die compact erstellt eine kompakte Darstellung des Eingangstensors x unter Verwendung der Informationen von keep_tensor .
Die Funktionsparameter sind:
x : Eingabezensor in kompakt mit Form (Batch, N_CTX, H, D_HEAD).keep_tensor : Float -Tensor der Form (Batch, N_CTX, H), das eine 1 enthält, wenn der Kopf aufbewahrt wird, und ansonsten 0. Die Funktion berechnet zunächst den indices_per_head , der die Anzahl der nicht getöteten Elemente pro Kopf berechnet. Es sortiert den keep_tensor in einer absteigenden Reihenfolge, während die Reihenfolge der gleichen Elemente (stabil = true) erhalten bleibt. Anschließend versammelt es die Elemente von x basierend auf dem Indexzensor. Das Ergebnis ist eine kompakte Darstellung von x zusammen mit dem Indexzensor und des Tensors, der die Anzahl der nicht verkauften Elemente pro Kopf darstellt.
Der pad_index -Funktion padelt den Indexzensor, um den Kernel einzuhalten. Es dauert die folgenden Parameter:
index : Originalindexzensor von compact , mit Form (Batch, Buffer_size, H). Für jede Charge und jeden Zeitschritt repräsentiert es den Kopfindex, aus dem er stammt.indices_per_head : Für jeden Kopf enthält, wie viele Indizes nicht fallen gelassen wurden. Es erstellt eine Kopie des Indexzensors und erstellt eine Maske basierend auf der Größe von indices_per_head . Anschließend ändert es die Indizes in der Kopie, die True in der Maske entsprechen, um gleich pad_idx zu sein.
Die Funktion qk_sparse_attention ist Teil des dynamischen spärlichen Aufmerksamkeitsmechanismus. Es wird verwendet, wenn sparsity_mode auf 'Qk' gesetzt ist. Diese Funktion implementiert den qk-sparse-Aufmerksamkeitsmechanismus und erfordert, dass die Parameter q_keep und k_keep vom Typ Float sind.
Es erstellt zunächst kompakte Darstellungen der Abfrage-, Schlüssel- und Wert -Tensoren unter Verwendung der compact . Anschließend padelt die Index -Tensoren mit der Funktion pad_index . Die Tensoren werden dann wegen Kompatibilität mit dem Kernel umgesetzt. Schließlich ruft die Funktion die Funktion qk_sparse_attention_kernel auf und streuert den resultierenden Tensor zurück in den ursprünglichen Dimensionsraum.
Die Funktion hash_sparse_attention ist Teil des dynamischen spärlichen Aufmerksamkeitsmechanismus. Es wird verwendet, wenn sparsity_mode auf "Hash" eingestellt ist. Diese Funktion implementiert den Aufmerksamkeitsmechanismus für Hash-Parse.
Die Funktion nimmt die gleichen Eingabeparameter wie qk_sparse_attention an. Anstelle von q_keep und k_keep -Parametern erfordert die Funktion hash_sparse_attention q_bucket_idx und k_bucket_idx , die Bucket -Indizes für Abfragen bzw. Tasten darstellen.
Die Funktion hash_sparse_attention sortiert zunächst die Abfrage-, Schlüssel- und Wert -Tensoren basierend auf den Bucket -Indizes mit der Funktion sort_bucketed_attention . Anschließend erstellt es kompakte Darstellungen der sortierten Abfrage-, Schlüssel- und Wert -Tensoren unter Verwendung der compact . Anschließend padelt die Index -Tensoren mit der Funktion pad_index .
Die Tensoren werden dann wegen Kompatibilität mit dem Kernel umgesetzt. Die Funktion ruft dann die Funktion von hash_sparse_attention_kernel auf und streuert den resultierenden Tensor zurück in den ursprünglichen Dimensionsraum.
Die Funktion sort_bucketed_attention ist eine Helferfunktion, die in hash_sparse_attention verwendet wird. Es sortiert die Eingangstensoren basierend auf den angegebenen Eimerindizes.
Die Funktionsparameter sind:
qkv : Abfrage, Schlüssel, Wert -Tensoren der Form (Batch, N_CTX, H, D_head)qkv_bucket_idx : Bucket -Indizes für Abfragen, Tasten und Formwerte (Batch, N_CTX, H) Die Funktion sortiert zuerst den qkv_bucket_idx -Tensor und erhält die sortierten Indizes. Dann sortiert es die qkv -Tensoren mit den sortierten Indizes. Es erweitert auch qkv_bucket_idx in die gleiche Form wie qkv für die Kompatibilität.
Die Funktion qk_sparse_attention_kernel ist eine Kernelfunktion, die in qk_sparse_attention verwendet wird. Es berechnet die gewichtete Wertesumme basierend auf dem Softmax der Abfrage und des Schlüsselprodukts.
Die Funktionsparameter sind:
q : Abfragebildsor (Batch, N_CTX_Q, H, D_HEAD)k : Schlüsselzensor der Form (Batch, N_CTX_KV, H, D_HEAD)v : Wertzensor der Form (Batch, N_CTX_KV, H, D_HEAD)sm_scale : Normalisierungskonstante, 1/sqrt (d_head), sofern nicht angegeben. Die Funktion hash_sparse_attention_kernel ist eine Kernelfunktion, die in hash_sparse_attention verwendet wird. Es funktioniert ähnlich wie qk_sparse_attention_kernel , kümmert sich aber mit Bucketing für die Aufmerksamkeit von Hash-Sparse.
Die Funktionsparameter entsprechen denen von qk_sparse_attention_kernel . q , k und v wurden jedoch basierend auf den Eimerindizes sortiert und verdichtet.
Der Kernel berechnet das Produkt der Abfrage und des Schlüssels, skaliert es nach sm_scale , wendet Softmax an, um die Gewichte zu erhalten, und berechnet dann die gewichtete Summe der Werte.
Bitte beachten Sie, dass dies eine allgemeine Interpretation der Dokumentation ist und das Verständnis und Ändern dieser Funktionen in der Praxis möglicherweise eingehendes Wissen über spärliche Aufmerksamkeitsmechanismen und tiefe Lernprinzipien erfordern.
Blockwise_compute_attn -Funktion:
Die Funktion blockwise_compute_attn ist ein wichtiger Teil der BlockwiseParallelJax -Klasse und wird verwendet, um den Aufmerksamkeitsmechanismus des Modells blockiistisch zu berechnen.
Parameter:
query , key , value : Diese Parameter sind die Haupteingänge für die Aufmerksamkeitsberechnung, die Abfragen, Tasten bzw. Werte darstellt.bias : Optionaler Parameter, mit dem vor Softmax eine Verzerrung zu den Aufmerksamkeitswerten hinzufügt.deterministic : Eine booleale Flagge, mit der entscheidet, ob ein Tropfen angewendet werden soll oder nicht.dropout_rng : Der Zufallszahlengenerator für den Dropout.attn_pdrop : Die Wahrscheinlichkeit des Ausfalls für Aufmerksamkeit.causal_mask : Eine boolesche Flagge dafür, ob eine kausale Aufmerksamkeitsmaske verwendet werden soll oder nicht.query_chunk_size , key_chunk_size : Die Größe jeder Abfrage bzw. dem Schlüsselbein.dtype : Der Datentyp der Berechnung. Es ist Standard ist jnp.float32 .policy : Dieser Parameter definiert die Richtlinie für Gradientenprüfung.precision : Dieser Parameter wird verwendet, um die Genauigkeit für die Berechnung festzulegen. Der Standardwert ist lax.Precision.HIGHEST .prevent_cse : Eine booleale Flagge, die zur Verhinderung der häufigen Eliminierung der Suberpression verwendet wird.Blockwise_compute_ffn -Funktion:
Die Funktion blockwise_compute_ffn wird verwendet, um das Feed-Forward-Netzwerk des Modells blockweise zu berechnen.
Parameter:
cell : Die Zelle im Netzwerk, auf die die Funktion angewendet wird.inputs : Die Eingabedaten für das Feed-Forward-Netzwerk.chunk_size : Die Größe jedes Stücks für die blockweise Berechnung.deterministic : Eine booleale Flagge, mit der entscheidet, ob ein Tropfen angewendet werden soll oder nicht.policy : Dieser Parameter definiert die Richtlinie für Gradientenprüfung.prevent_cse : Eine booleale Flagge, die zur Verhinderung der häufigen Eliminierung der Suberpression verwendet wird.Blockwise_lm_head Klasse:
Die Blockwise_LM_Head -Klasse ist ein Modul, das eine lineare Transformation anwendet, gefolgt von einer Softmax -Funktion, um eine Verteilung über dem Wortschatz für jede Position in der Eingabe zu erzeugen.
vocab_size : Die Größe des Wortschatzes, das auch die Größe der Ausgangsdimension der linearen Transformation ist.chunk_size : Die Größe jedes Stücks für die blockweise Berechnung.policy : Dieser Parameter definiert die Richtlinie für Gradientenprüfung.dtype : Der Datentyp der Berechnung. Es ist Standard ist jnp.float32 .prevent_cse : Eine booleale Flagge, die zur Verhinderung der häufigen Eliminierung der Suberpression verwendet wird.Blockwise_cross_entropy -Funktion:
Die blockwise_cross_entropy -Funktion berechnet den Querentropieverlust für die Vorhersagen des Modells blockweise.
Parameter:
logits : Die Ausgangsvorhersagen des Modells.tokens : Die wahren Etiketten.valid : Eine Maske, die die gültigen Positionen in der Eingabe angibt.chunk_size : Die Größe jedes Stücks für die blockweise Berechnung.policy : Dieser Parameter definiert die Richtlinie für Gradientenprüfung.prevent_cse : Eine booleale Flagge, die zur Verhinderung der häufigen Eliminierung der Suberpression verwendet wird.BlockWiseParalleljax -Klasse:
BlockwiseParallelJax ( q_chunk_size , k_chunk_size , hidden_size , num_heads , rotary_dim , intermediate_size , layer_norm_epsilon = 1e-5 , activation_function = "gelu" , attn_pdrop = 0.0 , resid_pdrop = 0.0 , max_position_embeddings = 1024 , dtype = jnp . float32 , causal = True , policy = 'nothing_saveable' , prevent_cse = False , float32_logits = False )Parameter
q_chunk_size : Ganzzahl. Chunk-Größe für die Selbstbekämpfung.k_chunk_size : Ganzzahl. Chunk-Größe für den Schlüssel in der Selbstbekämpfung.hidden_size : Ganzzahl. Dimensionalität der versteckten Schicht im Transformator.num_heads : Ganzzahl. Anzahl der Aufmerksamkeitsköpfe im Selbstbekämpfungsmechanismus.rotary_dim : Ganzzahl oder keine. Anzahl der Abmessungen, die für die Rotationspositionskodierung verwendet werden sollen.intermediate_size : Ganzzahl. Größe der Zwischenschicht im Feed-Forward-Netzwerk.layer_norm_epsilon : Float. Kleine Konstante, um die Aufteilung durch Null in der Normalisierung der Schicht zu verhindern. Standard ist 1e-5 .activation_function : String. Aktivierungsfunktion, die im Feed-Forward-Netzwerk verwendet werden soll. Standard ist 'gelu' .attn_pdrop : float. Ausfallwahrscheinlichkeit für den Aufmerksamkeitsmechanismus. Standard ist 0.0 .resid_pdrop : float. Ausfallwahrscheinlichkeit für die verbleibenden Verbindungen. Standard ist 0.0 .max_position_embeddings : Ganzzahl. Maximale Anzahl der zu verwendenden Positionsbettungen. Standard ist 1024 .dtype : jnp.dtype. Datentyp für die Berechnung. Standard ist jnp.float32 .causal : boolean. Ob Sie den kausalen (automatischen) Modus verwenden oder nicht. Standard ist True .policy : String. Richtlinien für Checkpoining -Gradienten. Standard ist 'nothing_saveable' .prevent_cse : Boolean. Ob Sie eine gemeinsame Unterexpressionsimination (CSE) verhindern. Standard ist False .float32_logits : boolean. Ob Sie Float32 für die Logits -Berechnung verwenden möchten. Standard ist False .Methoden
Die Hauptmethode der BlockwiseParallelJax -Klasse ist die forward , die den Vorwärtspass des Transformatorblocks ausführt.
forward ( hidden_states , attention_mask , position_ids , deterministic = True , init_cache = False )hidden_states : jnp.ndarray. Der Eingangspfehlungszensor zum Transformatorblock. Es sollte Form haben (batch_size, sequence_length, hidden_size) .attention_mask : jnp.ndarray. Die Aufmerksamkeitsmaske für den Selbstbekämpfungsmechanismus. Es sollte Form haben (batch_size, 1, 1, sequence_length) .position_ids : Jnp.ndarray. Die Positions -IDs für die Positionscodierung. Es sollte Form haben (1, sequence_length) .deterministic : Boolean. Ob Sie den deterministischen Modus verwenden (kein Tropfen) oder nicht. Standard ist True .init_cache : Boolean. Ob initialisieren Sie den Cache für schnelle Dekodierung. Standard ist False . Diese Methode gibt den Ausgangs -Tensor des Transformatorblocks zurück, der die gleiche Form wie hidden_states hat.
Beispiel Verwendung
Das folgende Beispiel zeigt, wie die BlockwiseParallelJax -Klasse verwendet wird.
# Initialize
from jax import random
import jax . numpy as jnp
from AttentionGrid import BlockwiseParallelJax
# Initialize transformer block
block = BlockwiseParallelJax (
q_chunk_size = 64 ,
k_chunk_size = 64 ,
hidden_size = 768 ,
num_heads = 12 ,
rotary_dim = 64 ,
intermediate_size = 3072 ,
)
# Create a batch of input tensors
key = random . PRNGKey ( 0 )
batch_size = 8
sequence_length = 128
hidden_states = random . normal ( key , ( batch_size , sequence_length , block . hidden_size ))
# Create attention mask
attention_mask = jnp . ones (( batch_size , 1 , 1 , sequence_length ))
# Create position ids
position_ids = jnp . arange ( sequence_length )[ None , :]
# Forward pass
output = block . forward ( hidden_states , attention_mask , position_ids )
print ( output . shape ) # prints: (8, 128, 768) FusedLandmarkAttention Dies ist eine Pytorch Function , die die Vorwärts- und Rückwärtsfunktionen des aufmerksamkeitsstarken Aufmerksamkeitsmechanismus in den Fusionen zusammenfasst.
forward(ctx, q, k, v, n_prefix_q, sm_scale, block_size)Diese Funktion führt den Vorwärtspass der geschmolzenen Wahrzeichen auf.
ctx : Ein Objekt, dem wir Variablen für die Verwendung im Rückwärtspass speichern können. Bereitgestellt durch das Autograd -System von Pytorch.q : Der Tensor der Abfragen. Es wird angenommen, dass es angrenzend ist, und seine Form sollte sein (Batch, Nheads, Seqlen_Q, D).k : Der Tensor der Schlüssel. Es wird angenommen, dass es angrenzend ist, und seine Form sollte die Form von Q übereinstimmen, dh (Batch, Nheads, Seqlen_k, D).v : Die Werte Tensor. Es wird angenommen, dass es angrenzend ist, und seine Form sollte die Formen von Q und K übereinstimmen, dh (Batch, Nheads, Seqlen_K, D).n_prefix_q : Die Anzahl der Präfixe in den Abfragen.sm_scale : Der im Softmax -Vorgang verwendete Skalierungsfaktor.block_size : Die Blockgröße für die blockbezogenen Operationen. o : Der Ausgangspartentensor aus dem Vorwärtspass des geschmolzenen Wahrzeichens Aufmerksamkeitsmechanismus. backward(ctx, do)Diese Funktion führt den Rückwärtspass der geschmolzenen Aufmerksamkeit durch, dh die Gradienten berechnet.
ctx : Ein Objekt, aus dem wir Variablen abrufen können, die im Vorwärtspass gespeichert sind. Bereitgestellt durch das Autograd -System von Pytorch.do : Der Gradient des Verlusts in Bezug auf die Ausgabe der Vorwärtsfunktion. None .fused_landmark_attention(q, k, v, is_mem, sm_scale=None, block_size=64) Diese Funktion ist eine bequeme Wrapper für die FusedLandmarkAttention -Klasse.
q : Der Tensor der Abfragen.k : Der Tensor der Schlüssel.v : Die Werte Tensor.is_mem : Ein boolescher Tensor, der angibt, ob jedes Schlüsselwertpaar als Speicher behandelt werden sollte. Es sollte die gleiche Länge wie die Sequenzlänge der Schlüssel haben.sm_scale : Der im Softmax -Vorgang verwendete Skalierungsfaktor. Wenn None , wird es auf 1.0 / sqrt(d) eingestellt.block_size : Die Blockgröße für die blockbezogenen Operationen. Hier ist ein grundlegendes Beispiel für die Verwendung von fused_landmark_attention -Funktion.
import torch
from AttentionGrid import fused_landmark_attention
# Initialize some tensors
batch = 8
nheads = 12
seqlen = 128
d = 64
q = torch . randn ( batch , nheads , seqlen , d )
k = torch . randn ( batch , nheads , seqlen , d )
v = torch . randn ( batch , nheads , seqlen , d )
is_mem = torch . zeros ( seqlen , dtype = torch . bool )
# Call the function
output = fused_landmark_attention ( q , k , v , is_mem )
print ( output . shape ) # prints: (8, 12, 128, 64)Dieses Beispiel initialisiert zunächst einige Tensoren, um als Abfragen, Schlüssel zu dienen
und Werte. Dann ruft es die Funktion fused_landmark_attention auf und druckt die Form des Ausgangs -Tensors.
import torch
import torch . nn as nn
from AttentionGrid import DilatedAttention
# Replace this with your correct GPU device
device = "cuda:0"
dtype = torch . float16
# Create an instance of DilatedAttention
d_model = 512
num_heads = 8
dilation_rate = 2
segment_size = 64
dropout = 0.2 # Specify the dropout rate
attention = DilatedAttention (
d_model = d_model ,
num_heads = num_heads ,
dilation_rate = dilation_rate ,
segment_size = segment_size ,
dropout = dropout ,
). to ( device , dtype = dtype )
# Create some dummy input data
batch_size = 16
seq_len = 128
input_dim = d_model
inputs = torch . randn ( batch_size , seq_len , input_dim , device = device , dtype = dtype )
# Forward pass
outputs = attention ( inputs )
# Print the output shape
print ( outputs . shape ) # Expected: [batch_size, seq_len, d_model] Im obigen Beispiel erstellen wir eine Instanz der DilatedAttention -Klasse mit den angegebenen Hyperparametern. Wir erzeugen dann einige Dummy -Eingangsdaten und übergeben sie durch den Aufmerksamkeitsmechanismus, um die Ausgänge zu erhalten. Schließlich drucken wir die Form des Ausgangs -Tensors.
Die DilatedAttention -Klasse setzt die Aufmerksamkeit der erweiterten Aufmerksamkeit aus, die das aufmerksame Feld exponentiell erweitert, wenn der Abstand zwischen Token wächst. Es erbt von torch.nn.Module und kann als Drop-In-Ersatz für Standard-Aufmerksamkeitsmechanismen in Transformatormodellen verwendet werden.
d_model (int): Die Dimensionalität der Eingangs- und Ausgangsbettendings.num_heads (int): Die Anzahl der Aufmerksamkeitsköpfe.dilation_rate (int): Die Dilatationsrate für die Sparisierung der Eingangssequenz.segment_size (int): Die Größe jedes Segments nach der Sparsifikation.dropout (float, optional): Die Ausfallwahrscheinlichkeit für die Aufmerksamkeitsausgabe. Standard: 0.0 (kein Tropfen).x (Tensor): Der Eingangs -Formsor der Form (batch_size, seq_len, d_model) .output (Tensor): Der Ausgangs -Formsor der Form (batch_size, seq_len, d_model) . Bitte beachten Sie, dass sich der Eingabetensor auf dem richtigen Gerät (z. B. GPU) befinden und über den entsprechenden Datentyp ( dtype ) verfügt.
