Introduction to Predictive Analytics

From Hindsight to Foresight

Predictive Analytics is the art of using historical data to forecast the future. For **Netflix**, this means answering the billion-dollar question: *"Will this user cancel their subscription next month?"* For **Walmart**, it's predicting demand spikes before they happen. And for **Visa**, it's flagging a fraudulent transaction before it clears.

In this chapter, we lay the groundwork for Machine Learning: the difference between **Supervised** and **Unsupervised** learning, **Feature Engineering** (turning raw data into prediction-ready inputs), and the critical concept of **Train/Test Splits** to avoid overfitting.

Supervised vs. Unsupervised Learning

In **Supervised Learning**, we give the model labeled examples: "This transaction WAS fraud" or "This user DID churn." The model learns the pattern. In **Unsupervised Learning**, we give the model unlabeled data and ask it to find hidden groups. **Netflix** uses supervised learning to predict churn and unsupervised learning to discover new "taste clusters."

PythonRuns entirely in your browser — nothing is sent to a server.

# Netflix: Supervised vs. Unsupervised Paradigm
class LearningParadigm:
    def __init__(self, data, labels=None):
        self.data = data
        self.labels = labels

    def classify(self):
        if self.labels:
            print("MODE: Supervised Learning (Labels provided)")
            for i, point in enumerate(self.data):
                print(" - User {0}: Features={1}, Label='{2}'".format(i+1, point, self.labels[i]))
        else:
            print("MODE: Unsupervised Learning (No labels)")
            print(" - Finding hidden clusters in {0} data points...".format(len(self.data)))
            print(" - Cluster A: {0}".format(self.data[:2]))
            print(" - Cluster B: {0}".format(self.data[2:]))

# Scenario 1: Predicting churn (Supervised)
features = [[45, 3], [90, 12], [10, 1]]
labels = ["Active", "Active", "Churned"]
supervised = LearningParadigm(features, labels)
supervised.classify()

print("---")

# Scenario 2: Discovering taste clusters (Unsupervised)
unsupervised = LearningParadigm([[45, 3], [48, 4], [10, 1], [12, 2]])
unsupervised.classify()

# Netflix: Supervised vs. Unsupervised Paradigm
class LearningParadigm:
    def __init__(self, data, labels=None):
        self.data = data
        self.labels = labels

    def classify(self):
        if self.labels:
            print("MODE: Supervised Learning (Labels provided)")
            for i, point in enumerate(self.data):
                print(" - User {0}: Features={1}, Label='{2}'".format(i+1, point, self.labels[i]))
        else:
            print("MODE: Unsupervised Learning (No labels)")
            print(" - Finding hidden clusters in {0} data points...".format(len(self.data)))
            print(" - Cluster A: {0}".format(self.data[:2]))
            print(" - Cluster B: {0}".format(self.data[2:]))

# Scenario 1: Predicting churn (Supervised)
features = [[45, 3], [90, 12], [10, 1]]
labels = ["Active", "Active", "Churned"]
supervised = LearningParadigm(features, labels)
supervised.classify()

print("---")

# Scenario 2: Discovering taste clusters (Unsupervised)
unsupervised = LearningParadigm([[45, 3], [48, 4], [10, 1], [12, 2]])
unsupervised.classify()

Feature Engineering: The Secret Weapon

Raw data is rarely model-ready. **Feature Engineering** transforms it into powerful predictive signals. For **Netflix**, the raw data is "User watched Stranger Things for 45 minutes." The engineered feature is "User's average binge ratio is 0.85 (they finish 85% of what they start)." This single number is far more predictive of churn than raw watch time.

PythonRuns entirely in your browser — nothing is sent to a server.

# Netflix Churn Prediction: Feature Engineering
class FeatureEngineer:
    def __init__(self, user_logs):
        self.logs = user_logs # List of (title, watched_min, total_min)

    def build_features(self):
        print("FEATURE ENGINEERING: Transforming raw logs into model inputs...")
        total_watched = sum(w for _, w, _ in self.logs)
        total_possible = sum(t for _, _, t in self.logs)
        binge_ratio = total_watched / total_possible if total_possible else 0
        
        num_titles = len(self.logs)
        avg_session = total_watched / num_titles if num_titles else 0
        
        print(" - Raw Logs: {0} titles watched".format(num_titles))
        print(" - Engineered Feature 1: Binge Ratio = {0:.2f}".format(binge_ratio))
        print(" - Engineered Feature 2: Avg Session = {0:.1f} mins".format(avg_session))
        print(" - Prediction Input Vector: [{0:.2f}, {1:.1f}, {2}]".format(binge_ratio, avg_session, num_titles))

# Scenario: Building features for User U-2049
logs = [("Stranger Things", 45, 50), ("The Crown", 30, 60), ("Narcos", 55, 55)]
engineer = FeatureEngineer(logs)
engineer.build_features()

# Netflix Churn Prediction: Feature Engineering
class FeatureEngineer:
    def __init__(self, user_logs):
        self.logs = user_logs # List of (title, watched_min, total_min)

    def build_features(self):
        print("FEATURE ENGINEERING: Transforming raw logs into model inputs...")
        total_watched = sum(w for _, w, _ in self.logs)
        total_possible = sum(t for _, _, t in self.logs)
        binge_ratio = total_watched / total_possible if total_possible else 0
        
        num_titles = len(self.logs)
        avg_session = total_watched / num_titles if num_titles else 0
        
        print(" - Raw Logs: {0} titles watched".format(num_titles))
        print(" - Engineered Feature 1: Binge Ratio = {0:.2f}".format(binge_ratio))
        print(" - Engineered Feature 2: Avg Session = {0:.1f} mins".format(avg_session))
        print(" - Prediction Input Vector: [{0:.2f}, {1:.1f}, {2}]".format(binge_ratio, avg_session, num_titles))

# Scenario: Building features for User U-2049
logs = [("Stranger Things", 45, 50), ("The Crown", 30, 60), ("Narcos", 55, 55)]
engineer = FeatureEngineer(logs)
engineer.build_features()

Train/Test Split: Avoiding the Illusion of Accuracy

A model that memorizes the training data scores 100% on that data but fails on new, unseen data. This is **Overfitting**. To combat this, we split our dataset: 80% for **Training** and 20% for **Testing**. For **Visa**, this means training the fraud model on historical transactions and testing it on a held-out set it has never seen.

PythonRuns entirely in your browser — nothing is sent to a server.

# Visa Fraud Model: Train/Test Split Simulation
class DataSplitter:
    def __init__(self, dataset):
        self.data = dataset

    def split(self, train_ratio=0.8):
        split_idx = int(len(self.data) * train_ratio)
        train = self.data[:split_idx]
        test = self.data[split_idx:]
        
        print("DATASET SIZE: {0} transactions".format(len(self.data)))
        print("TRAIN SET: {0} records ({1}%)".format(len(train), int(train_ratio * 100)))
        print("TEST SET : {0} records ({1}%)".format(len(test), int((1 - train_ratio) * 100)))
        print("\nWHY: The model NEVER sees the test set during training.")
        print("This ensures the accuracy score reflects real-world performance.")
        return train, test

# Scenario: Splitting Visa's transaction history
all_transactions = ["tx_{0}".format(i) for i in range(10)]
splitter = DataSplitter(all_transactions)
train, test = splitter.split()

# Visa Fraud Model: Train/Test Split Simulation
class DataSplitter:
    def __init__(self, dataset):
        self.data = dataset

    def split(self, train_ratio=0.8):
        split_idx = int(len(self.data) * train_ratio)
        train = self.data[:split_idx]
        test = self.data[split_idx:]
        
        print("DATASET SIZE: {0} transactions".format(len(self.data)))
        print("TRAIN SET: {0} records ({1}%)".format(len(train), int(train_ratio * 100)))
        print("TEST SET : {0} records ({1}%)".format(len(test), int((1 - train_ratio) * 100)))
        print("\nWHY: The model NEVER sees the test set during training.")
        print("This ensures the accuracy score reflects real-world performance.")
        return train, test

# Scenario: Splitting Visa's transaction history
all_transactions = ["tx_{0}".format(i) for i in range(10)]
splitter = DataSplitter(all_transactions)
train, test = splitter.split()

Practice Questions

Question 1

Why is 'Binge Ratio' a better feature than raw 'Watch Time' for predicting Netflix churn?

It is a shorter number
It normalizes behavior relative to content length, making it comparable across users who watch different amounts of content
It is easier to spell
Netflix doesn't use watch time at all

Question 2

What is the primary risk of NOT using a Train/Test split?

The model will be too slow
The model will overfit to the training data and perform poorly on new, unseen data
The database will run out of space
Python will throw an error