Inzicht in de structuur van **encoder**- en **decoderblokken** is essentieel om te begrijpen hoe Transformers tekst verwerken en genereren. Elk **encoderblok** in een Transformer is ontworpen om invoersequenties om te zetten in contextrijke representaties, terwijl elk **decoderblok** uitvoersequenties genereert door zowel te letten op eerdere uitgangen als op de representaties van de encoder. Bij sequentie-naar-sequentie teksttaken, zoals vertaling of samenvatting, neemt de encoder de invoertekst en codeert deze in een reeks verborgen toestanden. De decoder gebruikt vervolgens deze verborgen toestanden, samen met zijn eigen zelf-attentie, om stap voor stap de doelsequentie te genereren. Deze interactie tussen encoder- en decoderblokken stelt het model in staat om complexe afhankelijkheden in tekst vast te leggen, waardoor Transformers zeer effectief zijn voor een breed scala aan taken op het gebied van natuurlijke taalverwerking.

De volgende tabel vat de volgorde van bewerkingen in een Transformer encoderblok samen en benadrukt hun belang voor tekstdata:



| 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

Beheers de essentie van Transformer-modellen in Python voor natuurlijke taalverwerking. Ontdek hoe je Transformers bouwt, interpreteert en toepast op tekstgegevens uit de praktijk, met nadruk op praktische vaardigheden en modelinzicht.

Verken de essentie van Transformer-modellen, inclusief self-attention, positionele codering en architectuur. Bouw een sterke conceptuele en praktische basis voor geavanceerde NLP-toepassingen.

Beheers de vaardigheden die nodig zijn om kernonderdelen van Transformers te construeren, waaronder multi-head attention, feed-forward lagen en normalisatie, voor effectieve tekstverwerking.

Ontdek hoe Transformers kunnen worden gebruikt voor praktische NLP-taken, visualiseer aandacht en interpreteer modelvoorspellingen voor een beter tekstbegrip.

Uitdaging: Structureren van Encoder- en Decoderblokken

Oplossing