Summary  
This chapter explains how to implement sinusoidal positional encoding by constructing position and frequency arrays and filling an embedding matrix with alternating sine and cosine values using vectorized NumPy operations.

General domain of usage  
Natural language processing (transformer models)

Sinusförmige Positionskodierung ermöglicht es dem Transformer-Modell, die Wortreihenfolge und Position zu erfassen, obwohl es keine rekurrenten oder sequenzbewussten Schichten verwendet. Jede Position wird durch ein einzigartiges Muster von Sinus- und Kosinuswerten dargestellt, die sich über die Einbettungsdimensionen verteilen.

Im Folgenden betrachten wir den Code dazu.

import numpy as np

def get_sinusoidal_positional_encoding(seq_length, embed_dim):
    position = np.arange(seq_length)[:, np.newaxis]
    div_term = np.exp(
        np.arange(0, embed_dim, 2) * -(np.log(10000.0) / embed_dim)
    )
    pe = np.zeros((seq_length, embed_dim))
    pe[:, 0::2] = np.sin(position * div_term)
    pe[:, 1::2] = np.cos(position * div_term)
    return pe

# Example usage:
seq_length = 6
embed_dim = 8
encoding = get_sinusoidal_positional_encoding(seq_length, embed_dim)
print(encoding)



Der Code zur Erzeugung der **sinusförmigen Positionskodierung** lässt sich Schritt für Schritt nachvollziehen:

### 1. Erstellen des Positionsarrays
```python
position = np.arange(seq_length)[:, np.newaxis]
```

- Erstellt einen Spaltenvektor, bei dem jede Zeile eine Position in der Eingabesequenz darstellt, beginnend bei 0.
- Bei einer Sequenz mit sechs Tokens sieht dieses Array als Spalte wie folgt aus: `[0, 1, 2, 3, 4, 5]`.


### 2. Berechnung des Frequenzskalierungsfaktors
```python
div_term = np.exp(
    np.arange(0, embed_dim, 2) * -(np.log(10000.0) / embed_dim)
)
```
- Berechnet einen Skalierungsfaktor für jede gerade Einbettungsdimension.
- Die Skalierung sorgt dafür, dass jede Dimension eine andere Frequenz erhält, sodass die Kodierung sowohl kurz- als auch langfristige Positionsmuster erfassen kann.
- Die Verwendung von `10000.0` verteilt die Frequenzen, sodass Positionsänderungen jede Dimension unterschiedlich beeinflussen.

### 3. Initialisierung der Positionskodierungsmatrix
```python
pe = np.zeros((seq_length, embed_dim))
```
- Erstellt eine mit Nullen gefüllte Matrix mit einer Zeile pro Position und einer Spalte pro Einbettungsdimension.

### 4. Befüllen der Matrix mit Sinus- und Kosinuswerten
```python
pe[:, 0::2] = np.sin(position * div_term)
pe[:, 1::2] = np.cos(position * div_term)
```
- Für gerade Spalten wird der Sinus von `position * div_term` eingetragen.
- Für ungerade Spalten wird der Kosinus von `position * div_term` eingetragen.
- Durch diesen Wechsel erhält jede Position eine einzigartige Kombination von Werten, und das Muster verändert sich gleichmäßig über Positionen und Dimensionen hinweg.

### 5. Rückgabe der Positionskodierung
```python
return pe
```
- Die resultierende Matrix liefert eine eindeutige Kodierung für jede Position in der Sequenz.
- Diese Kodierung kann zu den Wort-Embeddings addiert werden, sodass das Transformer-Modell die Reihenfolge der Tokens erkennt.




Welche der folgenden Aussagen zur sinusförmigen Positionskodierung sind zutreffend?

Beherrschen Sie die Grundlagen von Transformer-Modellen in Python für die Verarbeitung natürlicher Sprache. Entdecken Sie, wie man Transformer-Modelle erstellt, interpretiert und auf reale Textdaten anwendet, mit Fokus auf praktische Fähigkeiten und Modellverständnis.

Erkunden Sie die Grundlagen von Transformer-Modellen, einschließlich Self-Attention, Positionskodierung und Architektur. Aufbau eines soliden konzeptionellen und praktischen Fundaments für fortgeschrittene NLP-Anwendungen.

Beherrschung der Fähigkeiten zum Aufbau zentraler Transformer-Bausteine, einschließlich Multi-Head-Attention, Feed-Forward-Schichten und Normalisierung, für eine effektive Textverarbeitung.

Erfahren Sie, wie Transformer für reale NLP-Aufgaben eingesetzt werden, wie man Aufmerksamkeit visualisiert und Modellvorhersagen interpretiert, um ein besseres Textverständnis zu erreichen.

How to Generate Sinusförmiges Positions-Encoding

1. Erstellen des Positionsarrays

2. Berechnung des Frequenzskalierungsfaktors

3. Initialisierung der Positionskodierungsmatrix

4. Befüllen der Matrix mit Sinus- und Kosinuswerten

5. Rückgabe der Positionskodierung