Tilastollisen ja visuaalisen tiedon yhdistäminen on keskeinen taito A/B-testitulosten tulkinnassa ja toimenpidesuositusten laatimisessa. Kun tarkastelet A/B-testitulosten ruudukkoa, yhdistä ymmärryksesi **p-arvoista**, **luottamusväleistä** ja visuaalisista esityksistä, kuten **pylväskaavioista** tai **virhepalkkeista**. Aloita tarkastelemalla `p-value`: arvo, joka alittaa ennalta määritetyn rajan (yleensä `0.05`), viittaa tilastolliseen merkitsevyyteen, mutta tämä ei yksin riitä. Seuraavaksi tarkista arvioidun vaikutuksen **luottamusväli** – jos se ei ylitä nollaa, tämä tukee tilastollisesti merkitsevän eron löytymistä, ja välin laajuus kertoo mahdollisen vaikutuksen koosta. **Visualisoinnit** auttavat havaitsemaan nopeasti kuvioita, poikkeamia tai ryhmien päällekkäisyyksiä, vahvistaen tai kyseenalaistaen numeeristen arvojen viestit. Yhdistämällä nämä elementit voit luotettavasti tulkita, onko havaittu ero merkityksellinen ja mitä käytännön toimenpiteitä tulisi seurata – kuten uuden ominaisuuden käyttöönotto, lisätestien suorittaminen tai nykytilan säilyttäminen.


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

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: Interpreting A/B Test Results

Ratkaisu