Aprenda Desafio: Implementando Redes Feed-Forward | Construindo Componentes de Transformers

Seção 2. Capítulo 3

single

Deslize para mostrar o menu

Ao explorar a arquitetura Transformer para processamento de linguagem natural, você encontra um componente crucial dentro de cada bloco Transformer: a rede feed-forward posição a posição (FFN). Após o mecanismo de autoatenção processar as representações de entrada, a FFN transforma ainda mais essas representações em cada posição da sequência, de forma independente das demais posições. Isso significa que, para cada token em uma sentença, a mesma pequena rede neural é aplicada, permitindo ao modelo introduzir mais não linearidade e aprender padrões mais complexos a partir do texto. A FFN é essencial para capturar relações e refinar as informações codificadas pela autoatenção, especialmente ao lidar com as sutilezas e ambiguidades da linguagem humana.


              123456789101112131415161718192021222324252627282930313233
            
import numpy as np

def relu(x):
    return np.maximum(0, x)

class PositionWiseFeedForward:
    def __init__(self, d_model, d_ff):
        # Initialize weights and biases for two linear layers
        self.W1 = np.random.randn(d_model, d_ff) * 0.01
        self.b1 = np.zeros((1, d_ff))
        self.W2 = np.random.randn(d_ff, d_model) * 0.01
        self.b2 = np.zeros((1, d_model))
    
    def __call__(self, x):
        # x shape: (batch_size, seq_len, d_model)
        # Apply first linear layer and ReLU activation
        out1 = relu(np.matmul(x, self.W1) + self.b1)
        # Apply second linear layer
        out2 = np.matmul(out1, self.W2) + self.b2
        return out2

# Example usage:
batch_size = 2
seq_len = 4
d_model = 8
d_ff = 16

# Example input: random tensor simulating text representations
x = np.random.randn(batch_size, seq_len, d_model)

ffn = PositionWiseFeedForward(d_model, d_ff)
output = ffn(x)
print("Output shape:", output.shape)

No código acima, é apresentada uma implementação simples de uma rede feed-forward posição a posição utilizando numpy. A rede consiste em duas transformações lineares (multiplicações de matrizes), separadas por uma função de ativação ReLU.

Definição

Função de ativação ReLU: A ativação ReLU (Unidade Linear Retificada) é definida como relu(x) = max(0, x). Ela define todos os valores negativos como zero e mantém os valores positivos inalterados. A ReLU é utilizada na rede feed-forward para introduzir não linearidade, permitindo que a rede aprenda padrões mais complexos a partir dos dados.

A primeira camada linear projeta a entrada das dimensões d_model (o tamanho do embedding de cada token) para um espaço de dimensão superior d_ff, permitindo que o modelo capture características mais complexas. A segunda camada linear projeta o resultado de volta para o tamanho original d_model. Observe que essa rede é aplicada independentemente a cada posição na sequência, o que significa que a transformação de um token não afeta diretamente os outros. Essa independência ajuda o modelo a processar a representação de cada token em paralelo, tornando os Transformers altamente eficientes para dados de texto.

Tarefa

Deslize para começar a programar

Implemente uma função de rede feed-forward posição a posição utilizando numpy.

Defina uma função position_wise_ffn(x, W1, b1, W2, b2) que recebe: