Forståelse af strukturen af **encoder**- og **decoder-blokke** er afgørende for at mestre, hvordan Transformers behandler og genererer tekst. Hver **encoder-blok** i en Transformer er designet til at omdanne inputsekvenser til kontekst-rige repræsentationer, mens hver **decoder-blok** genererer outputsekvenser ved at tage højde for både tidligere outputs og encoderens repræsentationer. Ved sekvens-til-sekvens tekstopgaver, såsom oversættelse eller opsummering, tager encoderen inputteksten og koder den til en række skjulte tilstande. Decoderen bruger derefter disse skjulte tilstande sammen med sin egen selvopmærksomhed til trin for trin at generere målsekvensen. Denne interaktion mellem encoder- og decoder-blokke gør det muligt for modellen at opfange komplekse afhængigheder i tekst, hvilket gør Transformers meget effektive til en bred vifte af opgaver inden for naturlig sprogbehandling.

Følgende tabel opsummerer rækkefølgen af operationer i en Transformer encoder-blok og fremhæver deres betydning for 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

Behersk de grundlæggende elementer i Transformer-modeller i Python til naturlig sprogbehandling. Lær at opbygge, fortolke og anvende Transformers på tekstdata fra virkeligheden med fokus på praktiske færdigheder og modelforståelse.

Udforsk det grundlæggende i Transformer-modeller, herunder self-attention, positionskodning og arkitektur. Opbyg et solidt konceptuelt og praktisk fundament for avancerede NLP-applikationer.

Opnå færdighederne til at konstruere centrale Transformer-byggesten, herunder multi-head attention, feed-forward lag og normalisering, for effektiv tekstbehandling.

Opdag, hvordan man bruger transformers til virkelige NLP-opgaver, visualiserer attention og fortolker modelprediktioner for bedre tekstforståelse.

Challenge: Strukturering af Encoder- og Decoder-blokke

Løsning