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 this challenge, you will apply your knowledge of cohort analysis by generating a retention matrix and interpreting the results to extract actionable business insights. Begin by creating a cohort retention matrix using your prepared cohort data. Visualize the matrix to clearly display retention rates over time for each cohort, using appropriate Python libraries. After generating the visualization, analyze the patterns and summarize the most important business insights you observe - such as trends in user retention, periods of churn, or differences between cohorts. Your summary should highlight at least two actionable recommendations that a business could implement based on the cohort retention trends displayed in your matrix.


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()


Challenge: Cohort Visualization and Insights

Lösung