Kun suoritat A/B-testin, tavoitteena on selvittää, onko uusi vaihtoehto (B) todella erilainen kuin kontrolli (A) keräämäsi datan perusteella. Johtopäätöksesi voi kuitenkin olla virheellinen kahdesta pääsyystä: saatat havaita eron, vaikka sitä ei todellisuudessa ole (**tyypin I virhe** eli "väärä positiivinen"), tai saatat olla havaitsematta todellista eroa (**tyypin II virhe** eli "väärä negatiivinen"). Selvittääksesi, kumpi virhe – jos mikään – on tapahtunut, sinun täytyy verrata todellista tilannetta (onko todellinen vaikutus olemassa) tilastollisen testisi tulokseen (onko merkittävä vaikutus havaittu).

Jos testisi löytää merkittävän tuloksen, vaikka todellista vaikutusta ei ole, olet tehnyt **tyypin I virheen**. Jos testisi ei löydä merkittävää tulosta, vaikka todellinen vaikutus on olemassa, olet tehnyt **tyypin II virheen**. Jos johtopäätöksesi vastaa todellisuutta (havaitset oikein todellisen vaikutuksen tai päätät oikein, ettei vaikutusta ole), olet tehnyt **oikean päätöksen**. Näiden tilanteiden ymmärtäminen on olennaista, jotta voit tulkita testiesi käytännön merkitystä ja tehdä perusteltuja liiketoimintapäätöksiä löydöstesi pohjalta.


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

Hallitse A/B-testauksen taidot ja tieteelliset perusteet Pythonilla. Tämä kurssi kattaa tilastolliset perusteet, kokeiden suunnittelun ja A/B-testien käytännön toteutuksen, painottaen vahvasti käytännön harjoittelua ja todellisia esimerkkitilanteita. Opit analysoimaan tuloksia, välttämään yleisiä sudenkuoppia ja viestimään löydökset tehokkaasti.

Tutustu A/B-testauksen perusteisiin – ydinterminologiasta ja tieteellisestä menetelmästä käytännön työnkulkuihin, joita hyödynnetään teknologiassa ja markkinoinnissa. Tämä osio tarjoaa kattavan perustan, mukaan lukien historiallinen tausta, kokeilujen perustelut sekä olennaiset käsitteet, joita tarvitaan tehokkaaseen viestintään dataohjatuissa ympäristöissä.

Hallitse taidot, joita tarvitaan vankkojen A/B-testien suunnitteluun: hypoteesin muodostamisesta ja satunnaistamisesta otoskoon laskentaan ja mittarien valintaan. Tässä osiossa käsitellään yksityiskohtaisesti hypoteesin luomista, satunnaistamista, otoskoon määrittämistä ja mittarien valintaa käytännön esimerkkien ja harjoitusten avulla.

Sukella A/B-testauksen taustalla oleviin tilastollisiin käsitteisiin, kuten merkitsevyys, p-arvot, virhetyypit ja luottamusvälit. Tämä osio tarjoaa yksityiskohtaisia selityksiä, käytännön koodiesimerkkejä ja käytännön harjoituksia ymmärryksen vahvistamiseksi.

Sukella käytännön A/B-testianalyysin perusteisiin — simuloit tietoja, tulkitset tuloksia, luot vaikuttavia visualisointeja ja viestit löydökset sidosryhmille. Opit viestimään löydökset tehokkaasti, luomaan vaikuttavia visualisointeja ja välttämään yleisiä tulkintavirheitä.

Challenge: Virhetyyppien Tunnistaminen

Ratkaisu