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)

Sinusoidell positionskodning gör att transformer-modellen kan uppfatta ordningsföljd och position för ord, även om den inte använder rekurrens eller sekvensmedvetna lager. Varje position representeras av ett unikt mönster av sinus- och cosinusvärden fördelade över inbäddningsdimensionerna.

Vi tittar närmare på koden nedan.

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 för att generera **sinusoidell positionskodning** kan förstås steg för steg:

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

- Detta skapar en kolumnvektor där varje rad representerar en position i din inmatningssekvens, med start från 0.
- Om din sekvens har sex token kommer denna array att se ut som `[0, 1, 2, 3, 4, 5]` som en kolumn.


### 2. Beräkna frekvensskalningstermen
```python
div_term = np.exp(
    np.arange(0, embed_dim, 2) * -(np.log(10000.0) / embed_dim)
)
```
- Detta beräknar en skalningsfaktor för varje jämn inbäddningsdimension.
- Skalningen säkerställer att varje dimension har en unik frekvens, vilket gör att kodningen kan fånga både kort- och långdistansmönster för position.
- Användningen av `10000.0` sprider ut frekvenserna så att positionsförändringar påverkar varje dimension olika.

### 3. Initiera positionskodningsmatrisen
```python
pe = np.zeros((seq_length, embed_dim))
```
- Detta skapar en matris fylld med nollor, med en rad för varje position och en kolumn för varje inbäddningsdimension.

### 4. Fyll matrisen med sinus- och cosinusvärden
```python
pe[:, 0::2] = np.sin(position * div_term)
pe[:, 1::2] = np.cos(position * div_term)
```
- För jämna kolumner, fyll med sinus av `position * div_term`.
- För udda kolumner, fyll med cosinus av `position * div_term`.
- Denna växling innebär att varje position får en unik kombination av värden, och mönstret förändras mjukt över positioner och dimensioner.

### 5. Returnera positionskodningen
```python
return pe
```
- Den resulterande matrisen ger en unik kodning för varje position i din sekvens.
- Denna kodning kan adderas till dina ordbäddningar så att transformer-modellen känner till ordningsföljden för token.




Vilka av följande påståenden om sinusoidal positionskodning är sanna?

Behärska grunderna i Transformer-modeller i Python för naturlig språkbehandling. Upptäck hur man bygger, tolkar och tillämpar Transformers på verkliga textdata, med fokus på praktiska färdigheter och modellförståelse.

Utforska grunderna i Transformer-modeller, inklusive självuppmärksamhet, positionskodning och arkitektur. Bygg en stark konceptuell och praktisk grund för avancerade NLP-applikationer.

Behärska de färdigheter som krävs för att konstruera centrala Transformer-byggblock, inklusive multi-head attention, feed-forward-lager och normalisering, för effektiv textbearbetning.

Upptäck hur man använder transformers för verkliga NLP-uppgifter, visualiserar attention och tolkar modellens prediktioner för bättre textförståelse.

Hur man genererar sinusformad positionskodning

1. Skapa positionsarrayen

2. Beräkna frekvensskalningstermen

3. Initiera positionskodningsmatrisen

4. Fyll matrisen med sinus- och cosinusvärden

5. Returnera positionskodningen