The ML Workflow Overview

The Doctor Analogy

Imagine a doctor seeing a patient for the first time. They do not glance at the patient, guess "appendicitis," and reach for a scalpel. They follow a process. They ask about symptoms and medical history — that is data collection. They note which symptoms seem most relevant — that is feature selection. They compare the symptom pattern to diseases they have seen before — that is model inference. They order tests to confirm their confidence level — that is evaluation.

Machine learning follows the exact same disciplined process. Skip a step and you risk the equivalent of misdiagnosis. Follow it carefully and your model will be reliable, explainable, and ready for production.

The 7-Step ML Workflow

Step 1 — Define the Problem

Before writing a single line of code, answer two questions:

• What are we predicting? A number (regression) or a category (classification)?
• What data do we have? How many rows, how many features, are labels available?

A clear problem definition saves hours of wasted effort. "Predict customer churn" is vague. "Predict whether a subscription customer will cancel within the next 30 days, given their last 90 days of usage data" is actionable.

Step 2 — Collect and Clean Data

Real-world data is messy. Values are missing, entries are duplicated, timestamps are in different formats, and outliers exist from data entry errors. This step transforms raw data into a usable state. Most working data scientists report spending 60–80% of their time here.

Step 3 — Exploratory Data Analysis (EDA)

Before modeling, understand your data. Plot distributions. Check correlations. Look for class imbalance. Find which features have the most variance. EDA prevents surprises later and often reveals the most impactful features before any model is trained.

Step 4 — Feature Engineering

Raw columns are rarely the best input for a model. Feature engineering creates new, more informative variables from existing ones. Extracting "day of week" from a timestamp, computing "price per square foot" from price and area, or log-transforming a skewed column are all feature engineering.

Step 5 — Choose and Train the Model

Select an algorithm appropriate for your problem type and data size. Train it on your training set. This is usually the shortest step — often just a few lines of code.

Step 6 — Evaluate and Tune

Check performance on data the model has never seen. Use metrics appropriate to your problem (accuracy, F1 score, RMSE, AUC). If performance is insufficient, tune hyperparameters, try different algorithms, or go back and engineer better features.

Step 7 — Deploy and Monitor

A model that lives only in a Jupyter notebook helps no one. Deploy it as an API, a batch job, or an embedded component. Then monitor it — real-world data drifts over time, and a model accurate today may degrade in six months.

The Python ML Stack

These five libraries handle 90% of classical ML work. Install them once:

pip install pandas numpy scikit-learn matplotlib seaborn

Your First Complete ML Program

The Iris dataset contains 150 measurements of flower petals and sepals from three species. It is the "Hello World" of ML. Here is the full workflow — all seven steps — in 12 lines of code:

# Step 1: Import tools
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Step 2: Load data (already clean — 150 rows, 4 features, 3 classes)
X, y = load_iris(return_X_y=True)

# Step 3: Split into training set (80%) and test set (20%)
# random_state=42 ensures the same split every run (reproducibility)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Step 4: Choose a model and train it on training data
model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train)  # Model learns from 120 examples

# Step 5: Make predictions on the 30 test examples the model never saw
predictions = model.predict(X_test)

# Step 6: Measure accuracy
print(f"Training samples: {len(X_train)}")
print(f"Test samples:     {len(X_test)}")
print(f"Accuracy:         {accuracy_score(y_test, predictions):.2%}")

Output:

Training samples: 120
Test samples:     30
Accuracy:         100.00%

The Iris dataset is clean and well-separated, so 100% accuracy is normal for this dataset. In real projects you will rarely see this — and that is expected.

Breaking Down Each Line

Why Split Data at All?

This is the most important concept in practical ML.

If you test the model on the same data you trained it on, you are asking a student to take the same test they studied from — with the same questions. Of course they will score 100%. That tells you nothing about whether they understood the material.

All Data (150 rows)
├── Training Set (120 rows)  ← Model learns from this
└── Test Set (30 rows)       ← Model is evaluated on this
                               (never seen during training)

The test set simulates real-world deployment: new data the model has never encountered.

The Workflow Is Iterative, Not Linear

In practice, you cycle back. EDA reveals a data quality issue, so you return to Step 2. Evaluation shows poor performance, so you return to Step 4 to engineer better features. Deployment reveals distribution shift, so you collect new data and retrain.

Problem Definition
       |
       v
  Collect Data  <----------+
       |                   |
       v                   |
      EDA                  |
       |                   |
       v                   |
Feature Engineering         |
       |                   |
       v                   |
   Train Model             |
       |                   |
       v                   |
    Evaluate -----(poor)---+
       |
     (good)
       v
    Deploy
       |
       v
    Monitor -----(drift)---> Collect Data

Key Takeaways

• Every ML project follows the same 7-step workflow regardless of domain
• Data cleaning and EDA consume the majority of real project time
• Always split data into training and test sets before evaluating any model
• The workflow is a loop, not a straight line — expect to iterate
• Five Python libraries handle nearly all classical ML work: pandas, NumPy, scikit-learn, matplotlib, seaborn