## Evalueringsmetrikker for NLP-opgaver

Når du har afsluttet træningen af en Transformer-model til NLP, skal du måle, hvor godt den klarer sig på din opgave. 
For at beregne metrikkerne skal du beregne `TP`, `TN`, `FN` og `FP`.


**TP (True Positive)**: antal positive prøver korrekt forudsagt som positive.  
**TN (True Negative)**: antal negative prøver korrekt forudsagt som negative.  
**FP (False Positive)**: antal negative prøver fejlagtigt forudsagt som positive.  
**FN (False Negative)**: antal positive prøver fejlagtigt forudsagt som negative.

Definition


- **Nøjagtighed** er bedst til balancerede datasæt, hvor hver klasse har omtrent samme antal eksempler;
- **Præcision og recall** bliver vigtigere ved ubalancerede data, såsom spamdetektion, hvor det har forskellige omkostninger at overse en spammeddelelse (falsk negativ) eller fejlagtigt markere en normal besked (falsk positiv);
- **F1-score** kombinerer både præcision og recall i ét tal, hvilket gør det lettere at sammenligne modeller på ubalancerede opgaver;
- **BLEU og ROUGE** bruges til opgaver, hvor outputtet er en sekvens, såsom oversættelse eller opsummering;
- **Perpleksitet** er mest nyttig for sprogmodeller, der forudsiger det næste ord i en sekvens.


## Fortolkning af evalueringsresultater og forbedring af modelpræstation

Når du har beregnet evalueringsmetrikker for din Transformer-model, er det vigtigt at forstå, hvad resultaterne betyder, og hvordan du kan bruge dem til at forbedre din model. Høj nøjagtighed viser generelt, at din model laver korrekte forudsigelser, men hvis dine data er ubalancerede, bør du se på **præcision**, **recall** og **F1-score**. For eksempel er en model med høj præcision, men lav recall, konservativ – den laver kun positive forudsigelser, når den er meget sikker, men overser mange sande positive. Hvis recall er høj, men præcisionen lav, forudsiger modellen flere positive, men inkluderer flere falske alarmer.

Hvis din models præstation ikke er tilfredsstillende, kan du overveje følgende måder at forbedre den på:
- Indsamle flere mærkede data, især for underrepræsenterede klasser;
- Prøve forskellige forbehandlingsskridt, såsom at fjerne støj eller balancere klasser;
- Finjustere hyperparametre, såsom læringsrate, batchstørrelse eller antal epoker;
- Justere modelarkitekturen, f.eks. ved at tilføje attention-heads eller lag;
- Bruge dataforøgelsesteknikker for at øge datasættets diversitet;
- Analysere fejl for at se, om modellen har problemer med bestemte typer input.

Ved omhyggeligt at vælge den rigtige metrik og fortolke resultaterne kan du diagnosticere modellens svagheder og fokusere dine forbedringsindsatser, hvor de har størst betydning.


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

class TestTask(unittest.TestCase):
    def test_accuracy_value(self):
        import user_code
        importlib.reload(user_code)
        accuracy = getattr(user_code, 'accuracy', None)
        _dynamic_test(
            self,
            isinstance(accuracy, float) and round(accuracy, 2) == 0.7,
            "Accuracy is correctly calculated and rounded to 0.7",
            f"Expected accuracy 0.7, got {accuracy}",
        )

    def test_precision_value(self):
        import user_code
        importlib.reload(user_code)
        precision = getattr(user_code, 'precision', None)
        _dynamic_test(
            self,
            isinstance(precision, float) and round(precision, 2) == 0.8,
            "Precision is correctly calculated and rounded to 0.8",
            f"Expected precision 0.8, got {precision}",
        )

    def test_recall_value(self):
        import user_code
        importlib.reload(user_code)
        recall = getattr(user_code, 'recall', None)
        _dynamic_test(
            self,
            isinstance(recall, float) and round(recall, 2) == 0.67,
            "Recall is correctly calculated and rounded to 0.67",
            f"Expected recall 0.67, got {recall}",
        )

    def test_f1_score_value(self):
        import user_code
        importlib.reload(user_code)
        f1_score = getattr(user_code, 'f1_score', None)
        _dynamic_test(
            self,
            isinstance(f1_score, float) and round(f1_score, 2) == 0.73,
            "F1 score is correctly calculated and rounded to 0.73",
            f"Expected F1 score 0.73, got {f1_score}",
        )

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: Evaluering af Transformer-Modeller

Evalueringsmetrikker for NLP-opgaver

Fortolkning af evalueringsresultater og forbedring af modelpræstation

Løsning