Churn prediction is a key application of data science in startups, enabling you to identify which customers are likely to leave and take proactive measures to retain them. By using machine learning models like **logistic regression**, you can analyze patterns in customer data and estimate the likelihood of churn. Equally important is understanding which features—such as `usage frequency`, `account age`, or `support requests`—most strongly influence the model's predictions. This knowledge empowers you to target interventions and optimize your product or service for customer retention.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io
import numpy as np

class TestTask(unittest.TestCase):
    def test_logistic_regression_fitted(self):
        import user_code
        importlib.reload(user_code)
        model = getattr(user_code, 'model', None)
        _dynamic_test(
            self,
            hasattr(model, 'coef_'),
            "Logistic regression model is fitted and has coef_ attribute",
            "Model is not fitted or missing coef_ attribute."
        )

    def test_predictions_variable(self):
        import user_code
        importlib.reload(user_code)
        predictions = getattr(user_code, 'predictions', None)
        _dynamic_test(
            self,
            predictions is not None and isinstance(predictions, (np.ndarray, list)) and len(predictions) == 3,
            "Predictions variable exists and has length 3",
            f"Predictions variable is missing or has incorrect length: {predictions}"
        )
        # Should only contain 0s and 1s
        if predictions is not None:
            for p in predictions:
                _dynamic_test(
                    self,
                    p in [0, 1],
                    "Predictions contain only 0 and 1",
                    f"Prediction contains invalid value: {p}"
                )

    def test_feature_importance_variable(self):
        import user_code
        importlib.reload(user_code)
        feature_importance = getattr(user_code, 'feature_importance', None)
        _dynamic_test(
            self,
            feature_importance is not None and hasattr(feature_importance, 'index') and hasattr(feature_importance, 'values'),
            "feature_importance variable exists and is a pandas Series",
            f"feature_importance variable is missing or not a pandas Series: {feature_importance}"
        )
        # Check that all values are non-negative and sorted descending
        if feature_importance is not None:
            values = list(feature_importance.values)
            _dynamic_test(
                self,
                all(v >= 0 for v in values),
                "All feature_importance values are non-negative",
                f"feature_importance contains negative values: {values}"
            )
            _dynamic_test(
                self,
                all(values[i] >= values[i+1] for i in range(len(values)-1)),
                "feature_importance is sorted in descending order",
                f"feature_importance is not sorted descending: {values}"
            )

    def test_code_runs_without_errors(self):
        # This test ensures the code runs and prints expected output variables
        import user_code
        import importlib
        import sys
        import io
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        try:
            importlib.reload(user_code)
        finally:
            sys.stdout = sys_stdout
        output = f.getvalue()
        _dynamic_test(
            self,
            "churn predictions for new customers:" in output.lower(),
            "Output includes churn predictions for new customers",
            f"Expected churn prediction output not found: {output}"
        )
        _dynamic_test(
            self,
            "feature importance for churn prediction:" in output.lower(),
            "Output includes feature importance for churn prediction",
            f"Expected feature importance output not found: {output}"
        )

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

A practical Python course tailored for startup founders, focusing on leveraging Python to solve real-world business problems, automate tasks, analyze data, and make data-driven decisions. Each section is packed with engaging theory and hands-on challenges inspired by startup scenarios.

Learn how Python can automate and streamline everyday startup operations, from handling customer data to tracking growth metrics.

Harness the power of Python for data analysis and visualization to make informed decisions that drive startup growth.

Apply Python to solve growth, marketing, and customer insight challenges faced by startup founders.

Challenge: Churn Prediction Tool

Ratkaisu

Challenge: Churn Prediction Tool

Ratkaisu