Lors de la réalisation d'un test A/B, l'objectif est de déterminer si une nouvelle variante (B) diffère réellement du témoin (A) à partir des données collectées. Cependant, la conclusion peut être incorrecte pour deux raisons principales : il est possible de détecter une différence alors qu'il n'y en a pas (**erreur de type I**, ou « faux positif »), ou de ne pas détecter une différence réelle (**erreur de type II**, ou « faux négatif »). Pour identifier quelle erreur – le cas échéant – s'est produite, il faut comparer la réalité (existence ou non d'un effet réel) avec le résultat du test statistique (détection ou non d'un effet significatif).

Si le test indique un résultat significatif alors qu'aucun effet réel n'existe, il s'agit d'une **erreur de type I**. Si le test ne trouve pas de résultat significatif alors qu'un effet réel existe, il s'agit d'une **erreur de type II**. Si la conclusion correspond à la réalité (détection correcte d'un effet réel ou conclusion correcte de l'absence d'effet), il s'agit d'une **décision correcte**. Comprendre ces scénarios est essentiel pour interpréter les implications pratiques des tests et pour prendre des décisions commerciales éclairées à partir des résultats obtenus.


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

Maîtrisez l'art et la science des tests A/B avec Python. Ce cours couvre les bases statistiques, la conception d'expériences et la mise en œuvre pratique des tests A/B, avec un fort accent sur la pratique et des scénarios réels. Apprenez à analyser les résultats, à éviter les pièges courants et à communiquer efficacement les conclusions.

Explorez les éléments essentiels des tests A/B — de la terminologie de base et de la méthode scientifique aux flux de travail pratiques utilisés dans la technologie et le marketing. Cette section offre une base complète, incluant le contexte historique, la justification de l'expérimentation et le vocabulaire essentiel nécessaire pour une communication efficace dans des environnements axés sur les données.

Maîtrisez les compétences nécessaires pour concevoir des tests A/B robustes : de la formulation d'hypothèses et la randomisation au calcul de la taille de l'échantillon et à la sélection des métriques. Cette section couvre en détail la création d'hypothèses, la randomisation, la détermination de la taille de l'échantillon et la sélection des métriques, avec des exemples pratiques et des exercices interactifs.

Plongez dans les concepts statistiques qui sous-tendent les tests A/B, y compris la signification, les valeurs p, les types d'erreurs et les intervalles de confiance. Cette section propose des explications détaillées, des exemples de code pratiques et des exercices interactifs pour consolider votre compréhension.

Plongez dans les fondamentaux de l'analyse pratique des tests A/B — simulez des données, interprétez les résultats, créez des visualisations percutantes et communiquez les conclusions aux parties prenantes. Apprenez à communiquer efficacement les résultats, à créer des visualisations convaincantes et à éviter les pièges courants lors de l'interprétation.

Défi : Identification du type d'erreur

Solution