This video provides a walkthrough of the challenge requirements for this chapter. You will learn how to create a cohort retention matrix using Python and visualize it to reveal user retention patterns over time. The video also guides you through interpreting the matrix and summarizing key business insights that can be derived from your analysis, helping you translate cohort data into actionable recommendations for business strategy.

In deze uitdaging pas je je kennis van cohortanalyse toe door een retentiematrix te genereren en de resultaten te interpreteren om bruikbare zakelijke inzichten te verkrijgen. Begin met het maken van een cohortretentiematrix met behulp van je voorbereide cohortgegevens. Visualiseer de matrix om de retentiepercentages in de tijd voor elke cohort duidelijk weer te geven, met geschikte Python-bibliotheken. Analyseer na het genereren van de visualisatie de patronen en vat de belangrijkste zakelijke inzichten samen die je waarneemt – zoals trends in gebruikersretentie, perioden van uitval of verschillen tussen cohorten. De samenvatting moet minimaal twee bruikbare aanbevelingen bevatten die een bedrijf kan implementeren op basis van de cohortretentietrends die in je matrix worden weergegeven.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import pandas as pd
import numpy as np
import importlib
import sys
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            'user_id': [1,1,2,2,3,4,5,6,7,7,8,9],
            'cohort_month': ['2023-01','2023-02','2023-01','2023-02','2023-02','2023-02','2023-03','2023-03','2023-03','2023-03','2023-03','2023-03'],
            'activity_month': ['2023-01','2023-02','2023-02','2023-03','2023-02','2023-03','2023-03','2023-04','2023-03','2023-04','2023-04','2023-04']
        }
        self.df = pd.DataFrame(self.data)

    def test_generate_retention_matrix_structure_and_values(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'generate_retention_matrix', None)
        _dynamic_test(
            self,
            callable(func),
            'generate_retention_matrix is defined',
            'generate_retention_matrix is not defined',
        )
        retention = func(self.df)
        _dynamic_test(
            self,
            isinstance(retention, pd.DataFrame),
            'generate_retention_matrix returns a DataFrame',
            f'generate_retention_matrix did not return a DataFrame, got {type(retention)}',
        )
        # Check that all values are between 0 and 1
        all_values = retention.values.flatten()
        _dynamic_test(
            self,
            np.all((all_values >= 0) & (all_values <= 1)),
            'All retention rates are between 0 and 1',
            f'Some retention rates are outside [0,1]: {all_values}',
        )

    def test_plot_retention_matrix_heatmap(self):
        import user_code
        importlib.reload(user_code)
        func_matrix = getattr(user_code, 'generate_retention_matrix', None)
        func_plot = getattr(user_code, 'plot_retention_matrix', None)
        retention = func_matrix(self.df)
        _dynamic_test(
            self,
            callable(func_plot),
            'plot_retention_matrix is defined',
            'plot_retention_matrix is not defined',
        )
        # Suppress actual plot display for testing
        import matplotlib
        matplotlib.use('Agg')
        try:
            func_plot(retention)
            _dynamic_test(
                self,
                True,
                'plot_retention_matrix runs without error',
                'plot_retention_matrix raised an error',
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                '',
                f'plot_retention_matrix raised an exception: {e}',
            )

    

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

Beheers cohortanalyse-technieken met behulp van Python. Deze cursus behandelt het structureren van cohortgegevens, geavanceerde segmentatie, retentie-analyses en toepasbare zakelijke inzichten, met praktische uitdagingen in elke sectie.

Leer hoe u gegevens kunt structureren, preprocessen en voorbereiden voor geavanceerde cohortanalyse, inclusief cohorttoewijzing en feature engineering.

Duik in geavanceerde segmentatiestrategieën en berekeningen van retentiemetingen om diepgaandere inzichten uit cohortgegevens te verkrijgen.

Visualiseer cohortgegevens en haal bruikbare zakelijke inzichten uit met behulp van geavanceerde plot- en interpretatietechnieken.

Challenge: Cohortvisualisatie en Inzichten

Oplossing