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)

A codificação posicional senoidal permite que o modelo transformer perceba a ordem e a posição das palavras, mesmo sem utilizar recorrência ou camadas sensíveis à sequência. Cada posição é representada por um padrão distinto de valores de seno e cosseno distribuídos entre as dimensões do embedding.

Veja o código a seguir.

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)



O código para gerar a **codificação posicional senoidal** pode ser compreendido passo a passo:

### 1. Criar o array de posições
```python
position = np.arange(seq_length)[:, np.newaxis]
```

- Cria um vetor coluna onde cada linha representa uma posição na sequência de entrada, começando do 0.
- Se a sequência tiver seis tokens, esse array será semelhante a `[0, 1, 2, 3, 4, 5]` como uma coluna.


### 2. Calcular o termo de escala de frequência
```python
div_term = np.exp(
    np.arange(0, embed_dim, 2) * -(np.log(10000.0) / embed_dim)
)
```
- Calcula um fator de escala para cada dimensão par do embedding.
- A escala garante que cada dimensão tenha uma frequência diferente, permitindo que a codificação capture padrões de posição de curto e longo alcance.
- O uso de `10000.0` espalha as frequências, de modo que mudanças na posição afetam cada dimensão de forma diferente.

### 3. Inicializar a matriz de codificação posicional
```python
pe = np.zeros((seq_length, embed_dim))
```
- Cria uma matriz preenchida com zeros, com uma linha para cada posição e uma coluna para cada dimensão do embedding.

### 4. Preencher a matriz com valores de seno e cosseno
```python
pe[:, 0::2] = np.sin(position * div_term)
pe[:, 1::2] = np.cos(position * div_term)
```
- Para as colunas pares, preenche com o seno de `position * div_term`.
- Para as colunas ímpares, preenche com o cosseno de `position * div_term`.
- Essa alternância faz com que cada posição receba uma combinação única de valores, e o padrão muda suavemente entre posições e dimensões.

### 5. Retornar a codificação posicional
```python
return pe
```
- A matriz resultante fornece uma codificação única para cada posição na sequência.
- Essa codificação pode ser somada aos embeddings das palavras para que o modelo transformer reconheça a ordem dos tokens.




Quais das seguintes afirmações sobre a codificação posicional senoidal são verdadeiras?

Domine os fundamentos dos modelos Transformer em Python para processamento de linguagem natural. Descubra como construir, interpretar e aplicar Transformers a dados textuais do mundo real, com foco em habilidades práticas e compreensão do modelo.

Explore os fundamentos essenciais dos modelos Transformer, incluindo self-attention, codificação posicional e arquitetura. Construção de uma base conceitual e prática sólida para aplicações avançadas de PLN.

Domínio das habilidades necessárias para construir blocos fundamentais de Transformers, incluindo atenção multi-cabeça, camadas feed-forward e normalização, para processamento de texto eficaz.

Descubra como utilizar Transformers em tarefas reais de PLN, visualizar a atenção e interpretar as previsões do modelo para uma melhor compreensão de textos.

Como Gerar Codificação Posicional Senoidal

1. Criar o array de posições

2. Calcular o termo de escala de frequência

3. Inicializar a matriz de codificação posicional

4. Preencher a matriz com valores de seno e cosseno

5. Retornar a codificação posicional