Når du gjennomfører en A/B-test, er målet å avgjøre om en ny variant (B) faktisk er forskjellig fra kontrollen (A) basert på dataene du samler inn. Konklusjonen din kan imidlertid være feil av to hovedgrunner: du kan oppdage en forskjell når det egentlig ikke er noen (**Type I-feil**, eller "falsk positiv"), eller du kan overse en reell forskjell (**Type II-feil**, eller "falsk negativ"). For å identifisere hvilken feil – hvis noen – som har oppstått, må du sammenligne den faktiske virkeligheten (om det finnes en reell effekt) med resultatet av din statistiske test (om du har erklært en signifikant effekt).

Hvis testen din finner et signifikant resultat når det ikke finnes noen reell effekt, har du gjort en **Type I-feil**. Hvis testen din ikke finner et signifikant resultat når det faktisk finnes en reell effekt, har du gjort en **Type II-feil**. Hvis konklusjonen din samsvarer med virkeligheten (enten ved å korrekt oppdage en reell effekt eller korrekt konkludere med at det ikke er noen), har du tatt en **korrekt beslutning**. Å forstå disse scenarioene er avgjørende for å tolke de praktiske konsekvensene av testene dine og for å ta informerte forretningsbeslutninger basert på funnene dine.


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

Bli ekspert på kunsten og vitenskapen bak A/B-testing med Python. Dette kurset dekker de statistiske grunnprinsippene, eksperimentdesign og praktisk gjennomføring av A/B-tester, med sterk vekt på praktiske øvelser og virkelige scenarioer. Lær å analysere resultater, unngå vanlige fallgruver og kommunisere funn på en effektiv måte.

Utforsk det grunnleggende innen A/B-testing – fra sentrale begreper og den vitenskapelige metode til praktiske arbeidsflyter brukt innen teknologi og markedsføring. Denne delen gir et omfattende grunnlag, inkludert historisk kontekst, begrunnelsen for eksperimentering og det essensielle vokabularet som trengs for effektiv kommunikasjon i datadrevne miljøer.

Behersk ferdighetene som trengs for å designe robuste A/B-tester: fra hypoteseformulering og randomisering til utregning av utvalgsstørrelse og valg av målemetrikker. Denne delen dekker hypoteseopprettelse, randomisering, bestemmelse av utvalgsstørrelse og valg av metrikker i detalj, med praktiske eksempler og praktiske øvelser.

Fordyp deg i de statistiske konseptene som ligger til grunn for A/B-testing, inkludert signifikans, p-verdier, feiltyper og konfidensintervaller. Denne delen gir detaljerte forklaringer, praktiske kodeeksempler og praktiske øvelser for å styrke din forståelse.

Fordyp deg i grunnleggende praktisk analyse av A/B-tester — simuler data, tolk resultater, lag overbevisende visualiseringer og kommuniser funn til interessenter. Lær å formidle funn effektivt, lage overbevisende visualiseringer og unngå vanlige fallgruver i tolkningen.

Challenge: Identifisering av Feiltyper

Løsning