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)

La codifica posizionale sinusoidale permette al modello transformer di percepire l’ordine e la posizione delle parole, anche se non utilizza ricorrenza o livelli sensibili alla sequenza. Ogni posizione è rappresentata da uno schema distinto di valori di seno e coseno distribuiti tra le dimensioni dell’embedding.

Vediamo il codice qui sotto.

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)



Il codice per generare la **codifica posizionale sinusoidale** può essere compreso passo dopo passo:

### 1. Creazione dell’array delle posizioni
```python
position = np.arange(seq_length)[:, np.newaxis]
```

- Crea un vettore colonna in cui ogni riga rappresenta una posizione nella sequenza di input, a partire da 0.
- Se la sequenza contiene sei token, questo array apparirà come `[0, 1, 2, 3, 4, 5]` come colonna.


### 2. Calcolo del termine di scala delle frequenze
```python
div_term = np.exp(
    np.arange(0, embed_dim, 2) * -(np.log(10000.0) / embed_dim)
)
```
- Calcola un fattore di scala per ogni dimensione di embedding pari.
- La scala garantisce che ogni dimensione abbia una frequenza diversa, permettendo alla codifica di catturare pattern di posizione sia a breve che a lungo raggio.
- L’uso di `10000.0` distribuisce le frequenze, così che i cambiamenti di posizione influenzino ogni dimensione in modo diverso.

### 3. Inizializzazione della matrice di codifica posizionale
```python
pe = np.zeros((seq_length, embed_dim))
```
- Crea una matrice riempita di zeri, con una riga per ogni posizione e una colonna per ogni dimensione dell’embedding.

### 4. Riempimento della matrice con valori di seno e coseno
```python
pe[:, 0::2] = np.sin(position * div_term)
pe[:, 1::2] = np.cos(position * div_term)
```
- Per le colonne pari, riempie con il seno di `position * div_term`.
- Per le colonne dispari, riempie con il coseno di `position * div_term`.
- Questa alternanza fa sì che ogni posizione abbia una combinazione unica di valori e che lo schema cambi in modo graduale tra posizioni e dimensioni.

### 5. Restituzione della codifica posizionale
```python
return pe
```
- La matrice risultante fornisce una codifica unica per ogni posizione nella sequenza.
- Questa codifica può essere sommata agli embedding delle parole affinché il modello transformer riconosca l’ordine dei token.




Quali delle seguenti affermazioni sulla codifica posizionale sinusoidale sono vere?

Apprendere le basi essenziali dei modelli Transformer in Python per l'elaborazione del linguaggio naturale. Scoprire come costruire, interpretare e applicare i Transformer a dati testuali reali, con un focus sulle competenze pratiche e sulla comprensione dei modelli.

Esplora gli elementi essenziali dei modelli Transformer, inclusi self-attention, positional encoding e architettura. Costruisci una solida base concettuale e pratica per applicazioni NLP avanzate.

Padroneggiare le competenze necessarie per costruire i componenti fondamentali dei Transformer, inclusi multi-head attention, layer feed-forward e normalizzazione, per un'elaborazione efficace del testo.

Scopri come utilizzare i Transformers per compiti NLP reali, visualizzare l'attenzione e interpretare le predizioni del modello per una migliore comprensione del testo.

How to Generate Sinusoidal Positional Encoding

1. Creazione dell’array delle posizioni

2. Calcolo del termine di scala delle frequenze

3. Inizializzazione della matrice di codifica posizionale

4. Riempimento della matrice con valori di seno e coseno

5. Restituzione della codifica posizionale