Når du udfører en A/B-test, er målet at afgøre, om en ny variant (B) reelt adskiller sig fra kontrollen (A) baseret på de indsamlede data. Din konklusion kan dog være forkert af to hovedårsager: du kan opdage en forskel, når der ikke er nogen (**Type I-fejl**, eller "falsk positiv"), eller du kan overse en reel forskel (**Type II-fejl**, eller "falsk negativ"). For at identificere hvilken fejl – hvis nogen – der er opstået, skal du sammenligne den faktiske sandhed (om der eksisterer en reel effekt) med resultatet af din statistiske test (om du har erklæret en signifikant effekt).

Hvis din test finder et signifikant resultat, når der ikke eksisterer en reel effekt, har du begået en **Type I-fejl**. Hvis din test ikke finder et signifikant resultat, når der faktisk eksisterer en reel effekt, har du begået en **Type II-fejl**. Hvis din konklusion stemmer overens med virkeligheden (enten ved korrekt at opdage en reel effekt eller korrekt at konkludere, at der ikke er nogen), har du truffet en **korrekt beslutning**. Forståelse af disse scenarier er afgørende for at kunne tolke de praktiske implikationer af dine tests og for at træffe informerede forretningsbeslutninger baseret på dine resultater.


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

class TestTask(unittest.TestCase):
    def test_correct_decision_true_effect_significant(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.classify_ab_test_outcome(True, True)
        _dynamic_test(
            self,
            result == "Correct Decision",
            'Returns "Correct Decision" for (True, True)',
            f'Expected "Correct Decision" for (True, True), got {result}'
        )

    def test_correct_decision_no_effect_not_significant(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.classify_ab_test_outcome(False, False)
        _dynamic_test(
            self,
            result == "Correct Decision",
            'Returns "Correct Decision" for (False, False)',
            f'Expected "Correct Decision" for (False, False), got {result}'
        )

    def test_type_i_error(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.classify_ab_test_outcome(False, True)
        _dynamic_test(
            self,
            result == "Type I Error",
            'Returns "Type I Error" for (False, True)',
            f'Expected "Type I Error" for (False, True), got {result}'
        )

    def test_type_ii_error(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.classify_ab_test_outcome(True, False)
        _dynamic_test(
            self,
            result == "Type II Error",
            'Returns "Type II Error" for (True, False)',
            f'Expected "Type II Error" for (True, False), got {result}'
        )

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 kunsten og videnskaben bag A/B-testning med Python. Dette kursus dækker de statistiske grundlag, eksperimentdesign og praktisk implementering af A/B-tests med stor vægt på praktiske øvelser og virkelighedsnære scenarier. Lær at analysere resultater, undgå almindelige faldgruber og kommunikere fund effektivt.

Udforsk det grundlæggende i A/B-testning — fra centrale begreber og den videnskabelige metode til praktiske arbejdsgange anvendt inden for teknologi og marketing. Dette afsnit giver et omfattende fundament, herunder den historiske kontekst, begrundelsen for eksperimentering og det nødvendige ordforråd til effektiv kommunikation i datadrevne miljøer.

Behersk de nødvendige færdigheder til at designe robuste A/B-tests: fra hypoteseformulering og randomisering til beregning af stikprøvestørrelse og valg af metrikker. Dette afsnit dækker hypoteseopstilling, randomisering, bestemmelse af stikprøvestørrelse og valg af metrikker i detaljer, med praktiske eksempler og øvelser.

Dyk ned i de statistiske begreber, der ligger til grund for A/B-testning, herunder signifikans, p-værdier, fejttyper og konfidensintervaller. Dette afsnit giver detaljerede forklaringer, praktiske kodeeksempler og interaktive øvelser for at styrke din forståelse.

Dyk ned i grundlæggende praktisk A/B-testanalyse — simuler data, fortolk resultater, opret overbevisende visualiseringer, og formidl resultater til interessenter. Lær at formidle resultater effektivt, skabe overbevisende visualiseringer og undgå almindelige faldgruber i fortolkningen.

Challenge: Identifikation af Fejltype

Løsning