Syntese af statistiske og visuelle oplysninger er en afgørende færdighed for at fortolke A/B-testresultater og udarbejde handlingsorienterede anbefalinger. Ved gennemgang af et gitter med A/B-testresultater bør du kombinere din forståelse af **p-værdier**, **konfidensintervaller** og visuelle repræsentationer såsom **søjlediagrammer** eller **fejllinjer**. Start med at undersøge `p-value`: en værdi under din forudbestemte grænse (typisk `0.05`) indikerer statistisk signifikans, men dette alene er ikke tilstrækkeligt. Gennemgå derefter **konfidensintervallet** for den estimerede effekt – hvis det ikke krydser nul, understøtter det fundet af en statistisk signifikant forskel, og intervallet fortæller dig om den mulige størrelsesorden af effekten. **Visualiseringer** hjælper dig med hurtigt at identificere mønstre, outliers eller overlap mellem grupper, hvilket kan bekræfte eller udfordre det, tallene antyder. Ved at integrere disse elementer kan du sikkert vurdere, om den observerede forskel er meningsfuld, og hvilken praktisk handling der bør følge – såsom at implementere en ny funktion, udføre yderligere tests eller fastholde status quo.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import pandas as pd
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        self.user_code = importlib.import_module("user_code")

    def test_recommendation_column_added(self):
        results_data = {
            "test_scenario": ["A", "B"],
            "p_value": [0.01, 0.2],
            "confidence_interval": [(0.05, 0.10), (-0.01, 0.03)],
            "mean_difference": [0.08, 0.01]
        }
        df = pd.DataFrame(results_data)
        df_out = self.user_code.interpret_ab_results(df)
        has_column = "recommendation" in df_out.columns
        correct_length = len(df_out["recommendation"]) == len(df_out)
        _dynamic_test(self,
            has_column and correct_length,
            "Adds 'recommendation' column with one entry per scenario.",
            f"Recommendation column missing or wrong length. Columns: {df_out.columns}, length: {len(df_out['recommendation']) if has_column else 'N/A'}"
        )

    def test_recommend_rollout(self):
        results_data = {
            "test_scenario": ["C"],
            "p_value": [0.01],
            "confidence_interval": [(0.01, 0.05)],
            "mean_difference": [0.03]
        }
        df = pd.DataFrame(results_data)
        df_out = self.user_code.interpret_ab_results(df)
        rec = df_out["recommendation"][0]
        _dynamic_test(self,
            "rollout" in rec.lower() and "improvement" in rec.lower(),
            "Recommends rollout when p < 0.05 and CI above zero.",
            f"Expected rollout recommendation, got: {rec}"
        )

    def test_recommend_do_not_rollout(self):
        results_data = {
            "test_scenario": ["D"],
            "p_value": [0.01],
            "confidence_interval": [(-0.08, -0.01)],
            "mean_difference": [-0.05]
        }
        df = pd.DataFrame(results_data)
        df_out = self.user_code.interpret_ab_results(df)
        rec = df_out["recommendation"][0]
        _dynamic_test(self,
            "do not rollout" in rec.lower() or ("not rollout" in rec.lower()),
            "Recommends not rolling out when p < 0.05 and CI below zero.",
            f"Expected do not rollout recommendation, got: {rec}"
        )

    def test_recommend_investigate_further(self):
        results_data = {
            "test_scenario": ["E"],
            "p_value": [0.01],
            "confidence_interval": [(-0.02, 0.03)],
            "mean_difference": [0.00]
        }
        df = pd.DataFrame(results_data)
        df_out = self.user_code.interpret_ab_results(df)
        rec = df_out["recommendation"][0]
        _dynamic_test(self,
            "investigate" in rec.lower(),
            "Recommends to investigate further when p < 0.05 and CI crosses zero.",
            f"Expected investigate further recommendation, got: {rec}"
        )

    def test_recommend_maintain(self):
        results_data = {
            "test_scenario": ["F"],
            "p_value": [0.2],
            "confidence_interval": [(-0.01, 0.03)],
            "mean_difference": [0.01]
        }
        df = pd.DataFrame(results_data)
        df_out = self.user_code.interpret_ab_results(df)
        rec = df_out["recommendation"][0]
        _dynamic_test(self,
            "maintain" in rec.lower() or "no statistically significant difference" in rec.lower(),
            "Recommends maintaining current version when p >= 0.05.",
            f"Expected maintain recommendation, got: {rec}"
        )

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: Fortolkning af A/B-Testresultater

Løsning