Machine Learning Fundamentals Questions

High-level pipeline for a small team:

1. Data ingestion: stream logs to a message bus (Kafka) and store raw events in object storage (S3) with partitioning by date.
2. ETL / Feature engineering: nightly Spark job to parse logs, join user/context tables, compute aggregates, and produce a feature parquet dataset; store feature specs and lineage.
3. Training: use a scheduled job (Airflow) to pull latest features, train a binary classifier (e.g., XGBoost) with cross-validation, log metrics and artifacts to model registry (MLflow).
4. Validation: run holdout evaluation, fairness and calibration checks, and unit tests. Require approval if metrics worsen.
5. Deployment: package model as a REST/gRPC microservice behind feature adapter that computes features online (real-time store + lookups). Use canary rollout and health checks.
6. Monitoring: collect prediction distributions, feature drift, data quality alerts, and business KPIs; log inputs and outputs for debugging.
7. Retraining triggers: automated retrain when (a) data drift exceeds threshold, (b) model performance degrades on recent holdout, or (c) periodic schedule (weekly/monthly). Use CI for retrain with automatic evaluation gating and human review for production promotion.

Direct answer
Classification and regression are both supervised learning tasks; they differ in what kind of thing the model predicts. Classification predicts a category from a fixed set of possible labels (binary, like spam or not-spam, or multi-class, like which of five product categories an item belongs to). Regression predicts a continuous numeric quantity, like a price or a duration, where the space of possible answers is effectively infinite and ordered.

Structured elaboration

• Target variable: classification targets are discrete categories with no inherent numeric ordering (unless you deliberately treat an ordinal target that way); regression targets are continuous numbers where the distance between two predictions is meaningful (predicting $105 when the truth is $100 is a smaller error than predicting $200).
• Preparing the target: for classification, you typically map each category to an integer class index (and to a one-hot or similar representation if the model needs it), and for a binary target that's just 0 or 1. For regression, the target is usually left as its natural numeric scale, though you might apply a transform (like a log transform for a right-skewed target such as price) to make the error distribution better behaved for the model you're using.
• Typical algorithm families: many algorithm families come in both a classification and a regression flavor, because they share the same underlying model structure and just swap the loss function and output layer (linear/logistic regression, decision trees and tree ensembles, k-nearest neighbors, neural networks). The choice of family is mostly independent of classification-versus-regression; it's driven by other factors like data size, interpretability needs, and feature types.
• Evaluation goals differ substantially: classification is usually evaluated on how often the predicted category is right, and on the specific costs of different kinds of mistakes (a false negative and a false positive are rarely equally costly). Regression is evaluated on how far off the numeric predictions are, using an error measure appropriate to how you want to penalize large misses versus small ones.

Worked example
Predicting a customer's lifetime value (a dollar amount) is a natural regression problem: the answer is a continuous quantity, and being off by $50 versus $500 clearly matters differently. But the same business need is sometimes reframed as classification: "will this customer be high-value (above some threshold) or not." That's a legitimate choice when the downstream decision is itself binary (for example, whether to enroll the customer in a premium retention program), because then you only ever act on the threshold anyway. The trade-off is information loss: collapsing a continuous quantity into a binary label throws away the magnitude, and the threshold itself becomes an extra design decision (a customer just below the cutoff is treated identically to one far below it, even though they're not equally "not valuable"). For a business decision that's genuinely a yes/no call, I'd choose the classification framing for simplicity and direct interpretability; if the magnitude itself will be used downstream (for example, to size a marketing budget per customer), I'd keep it as regression and threshold later if needed, rather than throwing away the magnitude up front.

Trade-offs and pitfalls
A common mistake is picking the framing based on which one is easier to model rather than what the business decision actually needs; regression-to-classification-by-thresholding is a one-way door; you can always derive a classification decision from a regression prediction after the fact, but you can't recover the discarded magnitude if you trained a classifier directly. Another pitfall is forgetting that the choice of evaluation metric has to match the framing: reporting classification accuracy on what was really a coarsened regression problem can hide the fact that a model is only good near the decision boundary and badly miscalibrated elsewhere.

Direct answer
Machine learning has three main paradigms, distinguished by what kind of training signal the model gets. Supervised learning learns from labeled examples (input paired with the correct output). Unsupervised learning finds structure in unlabeled data, with no correct-answer signal at all. Reinforcement learning (RL) learns by taking actions in an environment and receiving a reward signal that tells it how good the outcome was, rather than being told the correct action directly.

Structured elaboration

• Supervised learning: every training example is (input, correct output). The model's job is to learn a function that generalizes from those pairs to new inputs. Example: predicting whether an email is spam, given a labeled history of spam and non-spam emails. The deciding factor for choosing supervised learning is label availability: do you have (or can you affordably get) a correct answer for enough examples?
• Unsupervised learning: there is no correct-output label at all. The model looks for structure the data has on its own, such as natural groupings or a lower-dimensional representation that still captures most of the variation. Example: grouping customers into segments based on purchasing behavior, with no predefined "correct" segment for anyone. You reach for unsupervised learning when you don't have labels, or when the goal is exploratory ("what structure is even in this data?") rather than predictive.
• Reinforcement learning: an agent takes actions in an environment and receives a reward signal after the fact, and its goal is to learn a policy (a strategy for choosing actions) that maximizes cumulative reward over time. Example: a system that decides which offer to show a user next, where the reward is whether the user converts, and the effect of an action may only become clear several steps later. The deciding factor is the presence of a reward signal tied to sequential decisions, rather than a single correct label per example.
• Semi-supervised learning sits between supervised and unsupervised: most of the data is unlabeled, but a small labeled subset exists and is used to guide learning on the rest. It's the pragmatic middle ground when full labeling is too expensive but some labels are affordable.

Worked example
Say you're building a system to flag fraudulent transactions. If you have a large history of transactions already labeled fraud or not, that's a supervised classification problem. If you instead wanted to explore what natural clusters of transaction behavior exist, with no fraud labels at all, that's unsupervised clustering. If you were instead building a system that decides, in real time, which of several verification steps to trigger for a given transaction, and only finds out much later (after a chargeback or its absence) whether that sequence of decisions was good, that shifts you toward a reinforcement-learning framing because the signal is a delayed reward tied to a sequence of actions, not a per-example label available up front.

Trade-offs and pitfalls
A common mistake is treating this as a purely academic taxonomy rather than a practical decision: the real question in an interview or on the job is always "what signal do I actually have, and does it match what this paradigm needs." Reaching for reinforcement learning when you actually have per-example labels available is over-engineering: supervised learning is almost always simpler, cheaper to train, and easier to evaluate when labels exist. Conversely, forcing a supervised framing onto a problem that's genuinely sequential and reward-driven (where today's action affects tomorrow's state) tends to ignore the delayed-consequence structure that actually matters. Semi-supervised learning is often glossed over, but it's frequently the realistic answer in production: you rarely have either abundant labels or none at all, you have some.

Definition: Calibration means predicted probabilities reflect true outcome frequencies (e.g., among examples predicted 0.8, ~80% are positive). Miscalibration causes: class imbalance, overfitting, regularization, surrogate losses, model complexity, and dataset shift.
Two post-processing techniques:

1. Platt scaling: fit a sigmoid (logistic regression) on model scores using a held-out calibration set; good when relationship between score and probability is monotonic.
2. Isotonic regression: fit a non-parametric monotonic mapping on calibration set; more flexible, better for complex miscalibration but risks overfitting with small calibration sets.
   Evaluation method:

• Reliability diagram (calibration curve) and Brier score: plot predicted probability bins vs observed frequency; Brier score summarizes squared error of probabilities. Use calibration error metrics (ECE/MCE) and bootstrap for confidence intervals.

Analogy: Model accuracy is like a car’s speedometer (how fast the car reports it's going); business impact is whether that speed helps you arrive on time, save fuel, or increase deliveries. A perfect speed reading doesn't guarantee you reach business goals.
Two examples where small metric changes have large business impact:

1. Fraud detection: a 0.5% increase in true positive rate reduces fraud losses by millions if each prevented transaction saves large cost.
2. Recommendation click-through: a 0.2 percentage-point lift across millions of impressions can yield substantial revenue lift.
   Two examples where big metric changes have small business impact:
3. Improving accuracy on a rare class with low revenue consequence — large relative accuracy gain but negligible business value.
4. Reducing log-loss slightly for internal benchmarking when decisions hinge on thresholded binary outcomes; better calibration may not change conversion or revenue.