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)

Sinusoidal positionel kodning gør det muligt for transformer-modellen at opfatte rækkefølgen og positionen af ord, selvom den ikke anvender rekursive eller sekvensbevidste lag. Hver position repræsenteres af et unikt mønster af sinus- og cosinusværdier fordelt over embedding-dimensionerne.

Herunder ses et eksempel på koden.

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)



Koden til generering af **sinusoidal positionel kodning** kan forstås trin for trin:

### 1. Opret positions-array
```python
position = np.arange(seq_length)[:, np.newaxis]
```

- Dette opretter en kolonnevektor, hvor hver række repræsenterer en position i inputsekvensen, startende fra 0.
- Hvis sekvensen har seks tokens, vil dette array se ud som `[0, 1, 2, 3, 4, 5]` som en kolonne.


### 2. Beregn frekvensskaleringsfaktoren
```python
div_term = np.exp(
    np.arange(0, embed_dim, 2) * -(np.log(10000.0) / embed_dim)
)
```
- Dette beregner en skaleringsfaktor for hver lige embedding-dimension.
- Skaleringen sikrer, at hver dimension har en forskellig frekvens, hvilket gør det muligt for kodningen at opfange både kort- og langtrækkende positionsmønstre.
- Brug af `10000.0` spreder frekvenserne ud, så ændringer i position påvirker hver dimension forskelligt.

### 3. Initialiser den positionelle kodningsmatrix
```python
pe = np.zeros((seq_length, embed_dim))
```
- Dette opretter en matrix fyldt med nuller, med én række for hver position og én kolonne for hver embedding-dimension.

### 4. Udfyld matricen med sinus- og cosinusværdier
```python
pe[:, 0::2] = np.sin(position * div_term)
pe[:, 1::2] = np.cos(position * div_term)
```
- For lige kolonner udfyldes med sinus til `position * div_term`.
- For ulige kolonner udfyldes med cosinus til `position * div_term`.
- Denne vekslen betyder, at hver position får en unik kombination af værdier, og mønsteret ændrer sig glidende på tværs af positioner og dimensioner.

### 5. Returnér den positionelle kodning
```python
return pe
```
- Den resulterende matrix giver en unik kodning for hver position i sekvensen.
- Denne kodning kan lægges til word embeddings, så transformer-modellen kender rækkefølgen af tokens.




Hvilke af følgende udsagn om sinusoidal positionel kodning er sande?

Behersk de grundlæggende elementer i Transformer-modeller i Python til naturlig sprogbehandling. Lær at opbygge, fortolke og anvende Transformers på tekstdata fra virkeligheden med fokus på praktiske færdigheder og modelforståelse.

Udforsk det grundlæggende i Transformer-modeller, herunder self-attention, positionskodning og arkitektur. Opbyg et solidt konceptuelt og praktisk fundament for avancerede NLP-applikationer.

Opnå færdighederne til at konstruere centrale Transformer-byggesten, herunder multi-head attention, feed-forward lag og normalisering, for effektiv tekstbehandling.

Opdag, hvordan man bruger transformers til virkelige NLP-opgaver, visualiserer attention og fortolker modelprediktioner for bedre tekstforståelse.

Hvordan Man Genererer Sinusformet Positionskodning

1. Opret positions-array

2. Beregn frekvensskaleringsfaktoren

3. Initialiser den positionelle kodningsmatrix

4. Udfyld matricen med sinus- og cosinusværdier

5. Returnér den positionelle kodning