Al realizar una prueba A/B, el objetivo es determinar si una nueva variante (B) es realmente diferente del control (A) según los datos recopilados. Sin embargo, la conclusión puede ser incorrecta por dos razones principales: se puede detectar una diferencia cuando en realidad no existe (**error de Tipo I**, o "falso positivo"), o se puede pasar por alto una diferencia real (**error de Tipo II**, o "falso negativo"). Para identificar qué error, si es que ocurre alguno, ha sucedido, es necesario comparar la verdad del mundo real (si existe un efecto real) con el resultado de la prueba estadística (si se declaró un efecto significativo).

Si la prueba encuentra un resultado significativo cuando no existe un efecto real, se ha cometido un **error de Tipo I**. Si la prueba no encuentra un resultado significativo cuando sí existe un efecto real, se ha cometido un **error de Tipo II**. Si la conclusión coincide con la realidad (ya sea detectando correctamente un efecto real o concluyendo correctamente que no existe), se ha tomado una **decisión correcta**. Comprender estos escenarios es fundamental para interpretar las implicaciones prácticas de las pruebas y para tomar decisiones empresariales informadas basadas en los resultados.


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

Domina el arte y la ciencia de las pruebas A/B utilizando Python. Este curso abarca los fundamentos estadísticos, el diseño experimental y la implementación práctica de pruebas A/B, con un fuerte énfasis en la práctica y escenarios del mundo real. Aprende a analizar resultados, evitar errores comunes y comunicar hallazgos de manera efectiva.

Explora los aspectos esenciales de las pruebas A/B: desde la terminología básica y el método científico hasta los flujos de trabajo prácticos utilizados en tecnología y marketing. Esta sección proporciona una base integral, incluyendo el contexto histórico, la justificación de la experimentación y el vocabulario esencial necesario para una comunicación efectiva en entornos orientados a los datos.

Domina las habilidades necesarias para diseñar pruebas A/B robustas: desde la formulación de hipótesis y la aleatorización hasta el cálculo del tamaño de la muestra y la selección de métricas. Esta sección cubre en detalle la creación de hipótesis, la aleatorización, la determinación del tamaño de la muestra y la selección de métricas, con ejemplos prácticos y ejercicios interactivos.

Sumérgete en los conceptos estadísticos que sustentan las pruebas A/B, incluyendo significancia, valores p, tipos de error e intervalos de confianza. Esta sección ofrece explicaciones detalladas, ejemplos prácticos de código y ejercicios prácticos para consolidar tu comprensión.

Sumérgete en los fundamentos del análisis práctico de pruebas A/B: simula datos, interpreta resultados, crea visualizaciones atractivas y comunica hallazgos a las partes interesadas. Aprende a comunicar hallazgos de manera efectiva, crear visualizaciones impactantes y evitar errores comunes en la interpretación.

Desafío: Identificación de Tipos de Error

Solución