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)

L'encodage positionnel sinusoïdal permet au modèle transformer de percevoir l'ordre et la position des mots, même s'il n'utilise pas de récurrence ni de couches sensibles à la séquence. Chaque position est représentée par un motif distinct de valeurs de sinus et de cosinus réparties sur les dimensions d'embedding.

Examinons le code ci-dessous.

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)



Le code pour générer un **encodage positionnel sinusoïdal** peut être compris étape par étape :

### 1. Créer le tableau des positions
```python
position = np.arange(seq_length)[:, np.newaxis]
```

- Cela crée un vecteur colonne où chaque ligne représente une position dans votre séquence d'entrée, en commençant par 0.
- Si votre séquence contient six tokens, ce tableau ressemblera à `[0, 1, 2, 3, 4, 5]` sous forme de colonne.


### 2. Calculer le terme d'échelle de fréquence
```python
div_term = np.exp(
    np.arange(0, embed_dim, 2) * -(np.log(10000.0) / embed_dim)
)
```
- Cela calcule un facteur d'échelle pour chaque dimension d'embedding paire.
- L'échelle garantit que chaque dimension possède une fréquence différente, permettant à l'encodage de capturer à la fois les motifs de position à courte et longue portée.
- L'utilisation de `10000.0` répartit les fréquences, de sorte que les changements de position affectent chaque dimension différemment.

### 3. Initialiser la matrice d'encodage positionnel
```python
pe = np.zeros((seq_length, embed_dim))
```
- Cela crée une matrice remplie de zéros, avec une ligne pour chaque position et une colonne pour chaque dimension d'embedding.

### 4. Remplir la matrice avec les valeurs de sinus et de cosinus
```python
pe[:, 0::2] = np.sin(position * div_term)
pe[:, 1::2] = np.cos(position * div_term)
```
- Pour les colonnes paires, remplir avec le sinus de `position * div_term`.
- Pour les colonnes impaires, remplir avec le cosinus de `position * div_term`.
- Cette alternance signifie que chaque position reçoit une combinaison unique de valeurs, et le motif évolue de manière fluide selon les positions et les dimensions.

### 5. Retourner l'encodage positionnel
```python
return pe
```
- La matrice résultante fournit un encodage unique pour chaque position de votre séquence.
- Cet encodage peut être ajouté à vos embeddings de mots afin que le modèle transformer connaisse l'ordre des tokens.




Lesquelles des affirmations suivantes concernant le codage positionnel sinusoïdal sont vraies ?

Maîtriser les bases des modèles Transformer en Python pour le traitement du langage naturel. Découvrir comment construire, interpréter et appliquer les Transformers à des données textuelles réelles, en mettant l'accent sur les compétences pratiques et la compréhension des modèles.

Explorez les éléments essentiels des modèles Transformer, y compris l'auto-attention, l'encodage positionnel et l'architecture. Acquérez une base conceptuelle et pratique solide pour des applications avancées de NLP.

Maîtriser les compétences nécessaires pour construire les blocs fondamentaux des Transformers, y compris l'attention multi-tête, les couches feed-forward et la normalisation, pour un traitement efficace du texte.

Découvrez comment utiliser les Transformers pour des tâches NLP réelles, visualiser l'attention et interpréter les prédictions du modèle pour une meilleure compréhension du texte.

Comment Générer un Encodage Positionnel Sinusoïdal

1. Créer le tableau des positions

2. Calculer le terme d'échelle de fréquence

3. Initialiser la matrice d'encodage positionnel

4. Remplir la matrice avec les valeurs de sinus et de cosinus

5. Retourner l'encodage positionnel