## Evalueringsmetoder for NLP-oppgaver

Når du har trent en Transformer-modell for NLP, må du måle hvor godt den presterer på oppgaven din. 
For å beregne målene må du finne `TP`, `TN`, `FN` og `FP`.


**TP (True Positive)**: antall positive eksempler korrekt forutsagt som positive.  
**TN (True Negative)**: antall negative eksempler korrekt forutsagt som negative.  
**FP (False Positive)**: antall negative eksempler feilaktig forutsagt som positive.  
**FN (False Negative)**: antall positive eksempler feilaktig forutsagt som negative.

Definisjon


- **Nøyaktighet** er best for balanserte datasett der hver klasse har omtrent like mange eksempler;
- **Presisjon og tilbakekalling** blir viktigere når du har ubalanserte data, som for eksempel spamdeteksjon, der det har ulike kostnader å overse en spam-melding (falsk negativ) eller feilaktig merke en normal melding (falsk positiv);
- **F1-score** kombinerer både presisjon og tilbakekalling i ett enkelt tall, noe som gjør det enklere å sammenligne modeller på ubalanserte oppgaver;
- **BLEU og ROUGE** brukes for oppgaver der utdata er en sekvens, som oversettelse eller oppsummering;
- **Perpleksitet** er mest nyttig for språkmodeller som forutsier neste ord i en sekvens.


## Tolking av evalueringsresultater og forbedring av modellens ytelse

Når du har beregnet evalueringsmetrikker for Transformer-modellen din, er det viktig å forstå hva resultatene betyr og hvordan du kan bruke dem til å forbedre modellen. Høy nøyaktighet viser vanligvis at modellen gir riktige prediksjoner, men hvis dataene dine er ubalanserte, bør du se på **presisjon**, **tilbakekalling** og **F1-score**. For eksempel er en modell med høy presisjon, men lav tilbakekalling, konservativ – den gir kun positive prediksjoner når den er veldig sikker, men går glipp av mange sanne positive. Hvis tilbakekallingen er høy, men presisjonen lav, predikerer modellen flere positive, men inkluderer flere falske alarmer.

Hvis modellens ytelse ikke er tilfredsstillende, vurder følgende måter å forbedre den på:
- Samle inn flere merkede data, spesielt for underrepresenterte klasser;
- Prøv ulike forhåndsbehandlingssteg, som å fjerne støy eller balansere klasser;
- Finjuster hyperparametere, som læringsrate, batch-størrelse eller antall epoker;
- Juster modellarkitekturen, for eksempel ved å legge til attention-heads eller lag;
- Bruk datautvidelsesteknikker for å øke datasettets variasjon;
- Analyser feil for å se om modellen sliter med bestemte typer input.

Ved å velge riktig metrikk og tolke resultatene nøye, kan du diagnostisere modellens svakheter og fokusere forbedringsarbeidet der det har størst effekt.


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

Lær det grunnleggende om Transformer-modeller i Python for naturlig språkprosessering. Oppdag hvordan du bygger, tolker og anvender Transformers på tekstdata fra virkeligheten, med fokus på praktiske ferdigheter og modellforståelse.

Utforsk det grunnleggende ved Transformer-modeller, inkludert selvoppmerksomhet, posisjonell koding og arkitektur. Bygg et solid konseptuelt og praktisk grunnlag for avanserte NLP-applikasjoner.

Behersk ferdighetene som trengs for å konstruere sentrale Transformer-byggesteiner, inkludert multi-head attention, feed-forward-lag og normalisering, for effektiv tekstbehandling.

Utforsk hvordan du kan bruke Transformers til reelle NLP-oppgaver, visualisere oppmerksomhet og tolke modellprediksjoner for bedre tekstforståelse.

Challenge: Evaluering av Transformer-modeller

Evalueringsmetoder for NLP-oppgaver

Tolking av evalueringsresultater og forbedring av modellens ytelse

Løsning