Training a machine learning model isn't just about running code.

It's a systematic process with multiple stages. Let's walk through each step using a real example.

Our Example Problem: Predicting Customer Churn

Imagine you work for a telecom company. Customers are leaving (churning), and you want to predict which customers are likely to leave next month so you can offer them special deals to stay.

This is a classic supervised learning problem:

• Input: Customer data (usage, billing, complaints, etc.)
• Output: Will churn (yes/no)

Step 1: Gather and Understand Your Data

Before any machine learning happens, you need data. For our churn prediction:

Customer records might include:

• Monthly charges: $50
• Contract length: 12 months
• Total spend: $600
• Customer service calls: 3
• Has dependents: Yes
• Churned: No (this is our label — what we're trying to predict)

Key questions to ask:

• Do I have enough data? (Generally, thousands of examples minimum)
• Is my data representative? (Covers all scenarios you'll encounter)
• Is it balanced? (Similar number of churners vs. non-churners)

💡 Common pitfall: Garbage in, garbage out.
If your data is biased or incomplete, your model will learn the wrong patterns.

Step 2: Prepare Your Data

Raw data is messy. You need to clean and prepare it.

Handle Missing Values

Example:

• Monthly charges: $50
• Contract length: [MISSING]
• Total spend: $600

Options:

• Fill with average value
• Remove the record entirely
• Use a special “unknown” category

Encode Categories
Machine learning models need numbers, not text.

Before:

• Contract type: “Month-to-month”
• Payment method: “Credit card”

After:

• Contract type: 1 (where 1=month-to-month, 2=one-year, 3=two-year)
• Payment method: 2 (where 1=bank transfer, 2=credit card, 3=electronic check)

Scale Features

Different features have different ranges:

• Monthly charges: $20–$100
• Customer service calls: 0–10
• Total spend: $50–$5000

After scaling:

• Monthly charges: 0.2–1.0
• Customer service calls: 0.0–1.0
• Total spend: 0.01–1.0

This helps the model learn more effectively.

Step 3: Split Your Data

Never test on data you trained on! That’s like studying with the exact test questions.

Split your data:

• Training set: 70% (model learns from this)
• Validation set: 15% (tune model parameters)
• Test set: 15% (final evaluation on unseen data)

Example with 10,000 customers:

• 7,000 for training
• 1,500 for validation
• 1,500 for testing

The model never sees the test set until the very end.

Step 4: Choose a Model Type

For supervised learning, common choices include:

Logistic Regression

• Simple, interpretable
• Good for: Binary classification (yes/no)
• Fast to train
• ✅ Our pick for churn prediction (start simple!)

Decision Trees

• Easy to visualize and explain
• Good for: Both classification and regression
• Can capture complex patterns

Random Forests

• Multiple decision trees working together
• More accurate than single trees
• Harder to interpret

Neural Networks

• Can learn very complex patterns
• Need lots of data
• Harder to train and interpret

💡 Rule of thumb: Start simple (logistic regression), then try more complex models if needed.

Step 5: Train the Model

Now the actual learning happens!

For our logistic regression on churn:

1. Initialize: Start with random weights
2. Iterate through training data:
   • For each customer:
     1. Make prediction (will they churn?)
     2. Compare to actual outcome (did they churn?)
     3. Calculate error
     4. Adjust weights to reduce error
3. Repeat for multiple epochs (passes through data)

In code:

model = LogisticRegression()
model.fit(X_train, y_train)

Those two lines hide thousands of calculations happening under the hood!

Training might take:

• Seconds for simple models on small data
• Hours for complex models on large data
• Days for deep learning on massive datasets

Step 6: Evaluate Performance

How well does your model predict churn?

Accuracy alone isn't enough. Consider:

Confusion Matrix:

Predicted: No Churn

Predicted: Churn

Actual: No Churn

850

150

Actual: Churn

200

300

This tells us:

• True Negatives (850): Correctly predicted no churn
• False Positives (150): Predicted churn, but they didn’t
• False Negatives (200): Predicted no churn, but they did (missed!)
• True Positives (300): Correctly predicted churn

Key metrics:

• Accuracy: 77% ((850+300)/1500)
• Precision: 67% (of predicted churners, 67% actually churned)
• Recall: 60% (caught 60% of actual churners)

Which metric matters depends on your business goal:

• High recall: Catch most churners (even if some false alarms)
• High precision: Only target likely churners (fewer false alarms)

Step 7: Tune and Improve

Your first model is rarely perfect. Improve it by:

Hyperparameter Tuning
Adjust model settings:

• Learning rate (how fast it learns)
• Regularization (prevents overfitting)
• Tree depth (for decision trees)
• Number of layers (for neural networks)

Feature Engineering
Create new features from existing ones:

• Average monthly charge = total spend / months
• Complaint rate = complaints / months
• Payment consistency = missed payments / total payments

Sometimes these derived features help the model learn better.

Try Different Models
If logistic regression gives 77% accuracy, try:

• Random Forest → maybe 82%
• Gradient Boosting → maybe 85%
• Neural Network → maybe 87%

⚖️ Balance complexity vs. improvement:
An 85% model that runs in 1 second might be better than an 87% model that takes 10 seconds.

Step 8: Final Test and Deploy

Once satisfied with validation performance:

1. Run on the test set (the data it’s never seen)
2. If performance matches validation → ✅ Great! Your model generalizes.
3. If performance drops → ⚠️ You might have overfit to training/validation data

Deployment considerations:

• How will new data be fed in?
• How often should the model re-train? (Monthly? Quarterly?)
• Who monitors for performance degradation?
• What’s the backup if predictions fail?

🚀 Deployment is where ML meets the real world.

The Full Pipeline Summary

Data Collection → Data Cleaning → Feature Engineering → Train/Val/Test Split → Model Selection → Training → Evaluation → Tuning → Testing → Deployment

Each step is crucial — skipping steps leads to poor models.

What’s Next

In the next lesson, we'll explore what can go wrong during training and how to fix it.