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)

Sinusoïdale positionele codering stelt het transformermodel in staat om woordvolgorde en positie te herkennen, ook al maakt het geen gebruik van recursie of volgorde-bewuste lagen. Elke positie wordt weergegeven door een uniek patroon van sinus- en cosinuswaarden verspreid over de embedding-dimensies.

Bekijk de onderstaande code.

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)



De code voor het genereren van **sinusoïdale positionele codering** kan stap voor stap worden begrepen:

### 1. Maak de positie-array
```python
position = np.arange(seq_length)[:, np.newaxis]
```

- Dit maakt een kolomvector waarbij elke rij een positie in de invoersequentie weergeeft, beginnend bij 0.
- Als de sequentie zes tokens bevat, ziet deze array eruit als `[0, 1, 2, 3, 4, 5]` als kolom.


### 2. Bereken de frequentieschaalterm
```python
div_term = np.exp(
    np.arange(0, embed_dim, 2) * -(np.log(10000.0) / embed_dim)
)
```
- Dit berekent een schaalfactor voor elke even embedding-dimensie.
- De schaal zorgt ervoor dat elke dimensie een andere frequentie heeft, waardoor de codering zowel korte- als langeafstandspositiepatronen kan vastleggen.
- Het gebruik van `10000.0` spreidt de frequenties, zodat veranderingen in positie elke dimensie anders beïnvloeden.

### 3. Initialiseer de positionele coderingmatrix
```python
pe = np.zeros((seq_length, embed_dim))
```
- Dit maakt een matrix gevuld met nullen, met één rij voor elke positie en één kolom voor elke embedding-dimensie.

### 4. Vul de matrix met sinus- en cosinuswaarden
```python
pe[:, 0::2] = np.sin(position * div_term)
pe[:, 1::2] = np.cos(position * div_term)
```
- Voor even kolommen vullen met de sinus van `position * div_term`.
- Voor oneven kolommen vullen met de cosinus van `position * div_term`.
- Door deze afwisseling krijgt elke positie een unieke combinatie van waarden, en verandert het patroon geleidelijk over posities en dimensies.

### 5. Retourneer de positionele codering
```python
return pe
```
- De resulterende matrix geeft een unieke codering voor elke positie in de sequentie.
- Deze codering kan worden opgeteld bij de woordembeddings zodat het transformermodel de volgorde van de tokens kent.




Welke van de volgende uitspraken over sinusoïdale positionele codering zijn waar?

Beheers de essentie van Transformer-modellen in Python voor natuurlijke taalverwerking. Ontdek hoe je Transformers bouwt, interpreteert en toepast op tekstgegevens uit de praktijk, met nadruk op praktische vaardigheden en modelinzicht.

Verken de essentie van Transformer-modellen, inclusief self-attention, positionele codering en architectuur. Bouw een sterke conceptuele en praktische basis voor geavanceerde NLP-toepassingen.

Beheers de vaardigheden die nodig zijn om kernonderdelen van Transformers te construeren, waaronder multi-head attention, feed-forward lagen en normalisatie, voor effectieve tekstverwerking.

Ontdek hoe Transformers kunnen worden gebruikt voor praktische NLP-taken, visualiseer aandacht en interpreteer modelvoorspellingen voor een beter tekstbegrip.

Hoe Sinusvormige Positionele Codering te Genereren

1. Maak de positie-array

2. Bereken de frequentieschaalterm

3. Initialiseer de positionele coderingmatrix

4. Vul de matrix met sinus- en cosinuswaarden

5. Retourneer de positionele codering