Aprende Challenge: Implementación de Redes Feed-Forward | Construcción de Componentes de Transformers

Sección 2. Capítulo 3

single

Desliza para mostrar el menú

Al explorar la arquitectura Transformer para el procesamiento de lenguaje natural, se encuentra un componente crucial dentro de cada bloque Transformer: la red feed-forward por posición (FFN). Después de que el mecanismo de auto-atención procesa las representaciones de entrada, la FFN transforma aún más estas representaciones en cada posición de la secuencia, de manera independiente de las demás posiciones. Esto significa que para cada token en una oración, se aplica la misma pequeña red neuronal, lo que permite al modelo introducir mayor no linealidad y aprender patrones más complejos a partir del texto. La FFN es esencial para capturar relaciones y refinar la información codificada por la auto-atención, especialmente al tratar con las sutilezas y ambigüedades del lenguaje humano.


              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)

En el código anterior, se observa una implementación sencilla de una red feed-forward por posición utilizando numpy. La red consta de dos transformaciones lineales (multiplicaciones de matrices), separadas por una función de activación ReLU.

Definición

Función de activación ReLU: La activación ReLU (Unidad Lineal Rectificada) se define como relu(x) = max(0, x). Establece todos los valores negativos en cero y mantiene los valores positivos sin cambios. ReLU se utiliza en la red feed-forward para introducir no linealidad, permitiendo que la red aprenda patrones más complejos a partir de los datos.

La primera capa lineal proyecta la entrada desde las dimensiones d_model (el tamaño de la incrustación de cada token) a un espacio de mayor dimensión d_ff, lo que permite al modelo capturar características más complejas. La segunda capa lineal proyecta el resultado de nuevo al tamaño original d_model. Observa que esta red se aplica de manera independiente a cada posición en la secuencia, lo que significa que la transformación de un token no afecta directamente a los demás. Esta independencia ayuda al modelo a procesar la representación de cada token en paralelo, haciendo que los Transformers sean altamente eficientes para datos de texto.

Tarea

Desliza para comenzar a programar

Implementación de una función de red feed-forward por posición utilizando numpy.

Definir una función position_wise_ffn(x, W1, b1, W2, b2) que reciba: