La synthèse des informations statistiques et visuelles constitue une compétence essentielle pour interpréter les résultats d’un test A/B et formuler des recommandations exploitables. Lors de l’examen d’une grille de résultats de tests A/B, il convient de combiner la compréhension des **valeurs p**, des **intervalles de confiance** et des représentations visuelles telles que les **diagrammes en barres** ou les **barres d’erreur**. Commencer par examiner la `p-value` : une valeur inférieure au seuil prédéfini (généralement `0.05`) indique une signification statistique, mais cela ne suffit pas à lui seul. Ensuite, analyser l’**intervalle de confiance** de l’effet estimé : s’il ne croise pas zéro, cela confirme l’existence d’une différence statistiquement significative, et l’étendue renseigne sur la taille possible de l’effet. Les **visualisations** permettent d’identifier rapidement des tendances, des valeurs aberrantes ou des recouvrements entre groupes, ce qui peut renforcer ou remettre en question l’interprétation des données numériques. En intégrant ces éléments, il est possible d’interpréter avec assurance si la différence observée est significative et quelles actions concrètes en découlent : déploiement d’une nouvelle fonctionnalité, réalisation de tests supplémentaires ou maintien de la situation actuelle.


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

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.

Challenge: Interprétation des Résultats des Tests A/B

Solution