Att förstå strukturen hos **encoder**- och **decoderblock** är avgörande för att bemästra hur Transformers bearbetar och genererar text. Varje **encoderblock** i en Transformer är utformat för att omvandla inmatningssekvenser till kontextuellt rika representationer, medan varje **decoderblock** genererar utmatningssekvenser genom att uppmärksamma både tidigare utmatningar och encoderns representationer. Vid sekvens-till-sekvens-textuppgifter, såsom översättning eller sammanfattning, tar encodern inmatningstexten och kodar den till en serie dolda tillstånd. Decodern använder sedan dessa dolda tillstånd, tillsammans med sin egen självuppmärksamhet, för att stegvis generera målsekvensen. Denna interaktion mellan encoder- och decoderblock gör det möjligt för modellen att fånga komplexa beroenden i text, vilket gör Transformers mycket effektiva för en mängd olika uppgifter inom naturlig språkbehandling.

Följande tabell sammanfattar sekvensen av operationer i ett Transformer-encoderblock och belyser deras betydelse för textdata:



| 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

Behärska grunderna i Transformer-modeller i Python för naturlig språkbehandling. Upptäck hur man bygger, tolkar och tillämpar Transformers på verkliga textdata, med fokus på praktiska färdigheter och modellförståelse.

Utforska grunderna i Transformer-modeller, inklusive självuppmärksamhet, positionskodning och arkitektur. Bygg en stark konceptuell och praktisk grund för avancerade NLP-applikationer.

Behärska de färdigheter som krävs för att konstruera centrala Transformer-byggblock, inklusive multi-head attention, feed-forward-lager och normalisering, för effektiv textbearbetning.

Upptäck hur man använder transformers för verkliga NLP-uppgifter, visualiserar attention och tolkar modellens prediktioner för bättre textförståelse.

Utmaning: Strukturering av encoder- och decoderblock

Lösning