Het synthetiseren van statistische en visuele informatie is een cruciale vaardigheid voor het interpreteren van A/B-testresultaten en het doen van bruikbare aanbevelingen. Bij het beoordelen van een overzicht van A/B-testuitkomsten combineer je je begrip van **p-waarden**, **betrouwbaarheidsintervallen** en visuele weergaven zoals **staafdiagrammen** of **foutbalken**. Begin met het onderzoeken van de `p-value`: een waarde onder je vooraf bepaalde drempel (meestal `0.05`) wijst op statistische significantie, maar dit alleen is niet voldoende. Bekijk vervolgens het **betrouwbaarheidsinterval** voor het geschatte effect – als dit niet nul kruist, ondersteunt dit het vinden van een statistisch significant verschil, en het bereik geeft informatie over de mogelijke grootte van het effect. **Visualisaties** helpen om snel patronen, uitschieters of overlappingen tussen groepen te herkennen, wat de cijfers kan bevestigen of juist ter discussie stellen. Door deze elementen te integreren, kun je met vertrouwen interpreteren of het waargenomen verschil betekenisvol is en welke praktische actie daarop moet volgen – zoals het uitrollen van een nieuwe functie, het uitvoeren van verdere tests of het handhaven van de huidige situatie.


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

Beheers de kunst en wetenschap van A/B-testen met Python. Deze cursus behandelt de statistische basisprincipes, het ontwerpen van experimenten en de praktische uitvoering van A/B-tests, met een sterke nadruk op praktische oefeningen en realistische scenario's. Leer resultaten analyseren, veelvoorkomende valkuilen vermijden en bevindingen effectief communiceren.

Ontdek de essentie van A/B-testen — van kernterminologie en de wetenschappelijke methode tot praktische workflows die worden gebruikt in technologie en marketing. Deze sectie biedt een uitgebreide basis, inclusief de historische context, de achterliggende redenen voor experimentatie en de essentiële woordenschat die nodig is voor effectieve communicatie in data-gedreven omgevingen.

Beheers de vaardigheden die nodig zijn om robuuste A/B-tests te ontwerpen: van het formuleren van hypothesen en randomisatie tot het berekenen van de steekproefgrootte en het selecteren van metrics. Deze sectie behandelt het opstellen van hypothesen, randomisatie, het bepalen van de steekproefgrootte en het selecteren van metrics in detail, met praktische voorbeelden en hands-on oefeningen.

Duik in de statistische concepten die ten grondslag liggen aan A/B-testen, waaronder significantie, p-waarden, fouttypes en betrouwbaarheidsintervallen. Deze sectie biedt gedetailleerde uitleg, praktische codevoorbeelden en hands-on oefeningen om je begrip te versterken.

Duik in de basisprincipes van praktische A/B-testanalyse — simuleer gegevens, interpreteer resultaten, maak overtuigende visualisaties en communiceer bevindingen aan belanghebbenden. Leer bevindingen effectief te communiceren, overtuigende visualisaties te maken en veelvoorkomende valkuilen bij interpretatie te vermijden.

Uitdaging: Het Interpreteren van A/B-Testresultaten

Oplossing