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 posisjonskoding gjør at transformer-modellen kan oppfatte ordrekkefølge og posisjon, selv om den ikke bruker rekurrens eller sekvensbevisste lag. Hver posisjon representeres av et unikt mønster av sinus- og cosinusverdier fordelt over de ulike dimensjonene i embedding-vektoren.

La oss se nærmere på koden nedenfor.

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 for å generere **sinusoidal posisjonskoding** kan forstås steg for steg:

### 1. Opprett posisjonsarray
```python
position = np.arange(seq_length)[:, np.newaxis]
```

- Dette lager en kolonnevektor hvor hver rad representerer en posisjon i inndata-sekvensen, med start fra 0.
- Hvis sekvensen har seks tokens, vil denne arrayen se ut 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 partalls embedding-dimensjon.
- Skaleringen sørger for at hver dimensjon har ulik frekvens, slik at kodingen fanger opp både kort- og langdistansemønstre for posisjon.
- Bruken av `10000.0` sprer frekvensene, slik at endringer i posisjon påvirker hver dimensjon forskjellig.

### 3. Initialiser posisjonskodingsmatrisen
```python
pe = np.zeros((seq_length, embed_dim))
```
- Dette lager en matrise fylt med nuller, med én rad for hver posisjon og én kolonne for hver embedding-dimensjon.

### 4. Fyll matrisen med sinus- og cosinusverdier
```python
pe[:, 0::2] = np.sin(position * div_term)
pe[:, 1::2] = np.cos(position * div_term)
```
- For partallskolonner fylles det inn sinus til `position * div_term`.
- For oddetallskolonner fylles det inn cosinus til `position * div_term`.
- Denne vekslingen gir hver posisjon en unik kombinasjon av verdier, og mønsteret endres jevnt over posisjoner og dimensjoner.

### 5. Returner posisjonskodingen
```python
return pe
```
- Den resulterende matrisen gir en unik koding for hver posisjon i sekvensen.
- Denne kodingen kan legges til ord-embeddingene slik at transformer-modellen får informasjon om rekkefølgen på tokens.




Hvilke av følgende påstander om sinusoidal posisjonskoding er sanne?

Lær det grunnleggende om Transformer-modeller i Python for naturlig språkprosessering. Oppdag hvordan du bygger, tolker og anvender Transformers på tekstdata fra virkeligheten, med fokus på praktiske ferdigheter og modellforståelse.

Utforsk det grunnleggende ved Transformer-modeller, inkludert selvoppmerksomhet, posisjonell koding og arkitektur. Bygg et solid konseptuelt og praktisk grunnlag for avanserte NLP-applikasjoner.

Behersk ferdighetene som trengs for å konstruere sentrale Transformer-byggesteiner, inkludert multi-head attention, feed-forward-lag og normalisering, for effektiv tekstbehandling.

Utforsk hvordan du kan bruke Transformers til reelle NLP-oppgaver, visualisere oppmerksomhet og tolke modellprediksjoner for bedre tekstforståelse.

Hvordan Generere Sinusformet Posisjonskoding

1. Opprett posisjonsarray

2. Beregn frekvensskaleringsfaktoren

3. Initialiser posisjonskodingsmatrisen

4. Fyll matrisen med sinus- og cosinusverdier

5. Returner posisjonskodingen