Comprender la estructura de los **bloques codificadores** y **bloques decodificadores** es fundamental para dominar cómo los Transformers procesan y generan texto. Cada **bloque codificador** en un Transformer está diseñado para transformar secuencias de entrada en representaciones ricas en contexto, mientras que cada **bloque decodificador** genera secuencias de salida atendiendo tanto a las salidas previas como a las representaciones del codificador. En tareas de texto de secuencia a secuencia, como traducción o resumen, el codificador toma el texto de entrada y lo codifica en una serie de estados ocultos. El decodificador utiliza estos estados ocultos, junto con su propia autoatención, para generar la secuencia objetivo paso a paso. Esta interacción entre los bloques codificador y decodificador permite que el modelo capture dependencias complejas en el texto, haciendo que los Transformers sean altamente efectivos para una amplia gama de tareas de procesamiento de lenguaje natural.

La siguiente tabla resume la secuencia de operaciones en un bloque codificador de Transformer y destaca su importancia para los datos de texto:



| Step | Operation                      | Purpose for Text Data                                   |
|------|-------------------------------|---------------------------------------------------------|
| 1    | **Multi-head self-attention**     | Captures relationships between all tokens in the input. |
| 2    | **Add & Normalize**               | Stabilizes training and preserves information.          |
| 3    | **Feed-forward network**          | Applies non-linear transformations to each token.       |
| 4    | **Add & Normalize**               | Further stabilizes and enables deep stacking.           |


Each operation ensures that the encoder builds increasingly abstract and context-aware representations of the input text, which are essential for downstream sequence-to-sequence tasks.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_attention_and_ffn_instances(self):
        import user_code
        importlib.reload(user_code)
        block = user_code.TransformerEncoderBlock(64)
        attn = getattr(block, 'attention', None)
        ffn = getattr(block, 'ffn', None)
        _dynamic_test(
            self,
            attn is not None and hasattr(attn, '__call__') and attn.__class__.__name__ == 'MultiHeadAttention',
            "Self-attention layer is correctly initialized as MultiHeadAttention.",
            f"Expected 'MultiHeadAttention', got '{attn.__class__.__name__ if attn else attn}'",
        )
        _dynamic_test(
            self,
            ffn is not None and hasattr(ffn, '__call__') and ffn.__class__.__name__ == 'FeedForward',
            "Feed-forward layer is correctly initialized as FeedForward.",
            f"Expected 'FeedForward', got '{ffn.__class__.__name__ if ffn else ffn}'",
        )

    def test_forward_pass_identity(self):
        import user_code
        importlib.reload(user_code)
        block = user_code.TransformerEncoderBlock(32)
        input_data = [[1,2,3],[4,5,6]]
        output = block.forward(input_data)
        _dynamic_test(
            self,
            output == input_data,
            "Forward method returns correct output when dummy layers are used.",
            f"Expected output {input_data}, got {output}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Domina los conceptos esenciales de los modelos Transformer en Python para el procesamiento de lenguaje natural. Descubre cómo construir, interpretar y aplicar Transformers a datos de texto del mundo real, con énfasis en habilidades prácticas y comprensión del modelo.

Explora los conceptos esenciales de los modelos Transformer, incluyendo la auto-atención, la codificación posicional y la arquitectura. Construye una base conceptual y práctica sólida para aplicaciones avanzadas de PLN.

Domina las habilidades necesarias para construir los bloques fundamentales de los Transformers, incluyendo la atención multi-cabeza, capas feed-forward y normalización, para un procesamiento de texto efectivo.

Descubra cómo utilizar Transformers para tareas reales de PLN, visualizar la atención e interpretar las predicciones del modelo para una mejor comprensión del texto.

Desafío: Estructuración de Bloques de Codificador y Decodificador

Solución