Introduction to Machine Learning

What Is Machine Learning?

Machine Learning is a branch of Artificial Intelligence where computers learn to make decisions or predictions from data — without being explicitly programmed with rules. Instead of a programmer writing "if price > 50 and location = Mumbai then rent is high", the machine discovers those rules itself by studying thousands of examples of prices, locations, and rents.

The key word is learn. Traditional programming is a recipe — you give the computer ingredients (data) and instructions (code), and it produces a dish (output). Machine learning flips the script — you give the computer ingredients (data) and the dish (output), and it figures out the recipe (rules) on its own.

Traditional Programming vs Machine Learning

Three Types of Machine Learning

All machine learning algorithms fall into one of three fundamental categories based on how they learn — specifically, whether they are given labelled examples, unlabelled examples, or learn through trial and error. Understanding which category a problem belongs to determines the entire solution strategy.

Supervised Learning — Learning from Labelled Data

Supervised learning is the most common and commercially important type of machine learning. Every labelled dataset — emails tagged as spam/not-spam, house sales with recorded prices, patient records with diagnoses — is a training set for supervised learning. The two main tasks are classification (predict a category) and regression (predict a number).

from sklearn.ensemble      import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics       import classification_report
import pandas as pd

# ── Load labelled data ─────────────────────────────────────
df = pd.read_csv('transactions.csv')
X  = df.drop('is_fraud', axis=1)   # features
y  = df['is_fraud']                 # labels (0=legit, 1=fraud)

# ── Split into train and test ──────────────────────────────
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=42, stratify=y
)

# ── Train the supervised model ─────────────────────────────
model = RandomForestClassifier(n_estimators=200, random_state=42)
model.fit(X_train, y_train)

# ── Evaluate on held-out test data ────────────────────────
y_pred = model.predict(X_test)
print(classification_report(y_test, y_pred))

Unsupervised Learning — Finding Hidden Patterns

Unsupervised learning tackles the most common situation in real business data — you have plenty of data but no labels. No one has tagged every customer with their "type". No one has marked every transaction as "anomalous". Unsupervised algorithms discover structure that exists in the data without being told what to look for.

from sklearn.cluster      import KMeans
from sklearn.preprocessing import StandardScaler
import pandas as pd

# ── No labels needed — just features ──────────────────────
X = df[['purchase_freq', 'avg_spend', 'return_rate',
        'session_hour', 'category_diversity']]

# ── Scale features (K-Means is distance-based) ─────────────
scaler   = StandardScaler()
X_scaled = scaler.fit_transform(X)

# ── Fit K-Means — 7 clusters discovered ───────────────────
kmeans = KMeans(n_clusters=7, random_state=42, n_init=10)
kmeans.fit(X_scaled)

df['cluster'] = kmeans.labels_
print(df.groupby('cluster')['customer_id'].count())
print(df.groupby('cluster')[['avg_spend', 'purchase_freq']].mean())

The Machine Learning Workflow

Every successful ML project follows the same sequence of steps. Skipping or rushing any step creates problems that compound downstream — garbage data in produces garbage predictions out, and a model deployed without proper evaluation will fail silently in production. Understanding the workflow is as important as understanding the algorithms.

Overfitting & Underfitting — The Central Challenge

The most fundamental challenge in machine learning is not choosing the right algorithm — it is getting the model to generalise well to new data. A model that is too simple ignores real patterns (underfitting). A model that is too complex memorises the training data instead of learning from it (overfitting). The goal is the middle ground: a model complex enough to capture the signal but not so complex it captures the noise.

Detecting Overfitting: Training vs Validation Curves

Fixes for Overfitting and Underfitting

The Bias-Variance Tradeoff

Bias and variance are the two sources of prediction error in machine learning. They pull in opposite directions — reducing one tends to increase the other. Understanding this tradeoff is the foundation of all model selection and regularisation decisions.

Model Evaluation — Choosing the Right Metric

Accuracy is the most natural metric but often the most misleading. On a dataset with 99% class 0 and 1% class 1, a model that predicts class 0 for everything achieves 99% accuracy while catching zero minority examples. Every problem has a metric that aligns with its real cost of errors.

Common ML Algorithms — When to Use Which

Complete ML Pipeline in Python

The following code implements a complete, production-ready machine learning pipeline from raw data to final evaluation — including preprocessing, cross-validation, hyperparameter tuning, and model persistence. This is the template for any supervised ML project.

from sklearn.pipeline       import Pipeline
from sklearn.compose        import ColumnTransformer
from sklearn.preprocessing  import StandardScaler, OneHotEncoder
from sklearn.impute          import SimpleImputer
from sklearn.ensemble        import GradientBoostingClassifier
from sklearn.model_selection import StratifiedKFold, GridSearchCV, cross_val_score
from sklearn.metrics         import classification_report, roc_auc_score
import joblib

# ── 1. Define column types ─────────────────────────────────
num_cols = ['age', 'income', 'credit_score', 'balance']
cat_cols = ['city', 'gender', 'product_type']

# ── 2. Preprocessing sub-pipelines ───────────────────────
num_pipe = Pipeline([
    ('imp', SimpleImputer(strategy='median')),
    ('sc',  StandardScaler())
])
cat_pipe = Pipeline([
    ('imp', SimpleImputer(strategy='most_frequent')),
    ('ohe', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])
preprocessor = ColumnTransformer([
    ('num', num_pipe, num_cols),
    ('cat', cat_pipe, cat_cols)
])

# ── 3. Full ML pipeline ───────────────────────────────────
full_pipe = Pipeline([
    ('prep',  preprocessor),
    ('model', GradientBoostingClassifier(random_state=42))
])

# ── 4. Hyperparameter tuning ──────────────────────────────
param_grid = {
    'model__n_estimators':  [100, 300],
    'model__learning_rate': [0.05, 0.1],
    'model__max_depth':     [3, 5]
}

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
gs = GridSearchCV(full_pipe, param_grid, cv=cv,
                  scoring='roc_auc', n_jobs=-1, verbose=1)
gs.fit(X_train, y_train)

print(f"Best AUC-ROC : {gs.best_score_:.4f}")
print(f"Best params  : {gs.best_params_}")

# ── 5. Final evaluation on test set ──────────────────────
best = gs.best_estimator_
y_pred = best.predict(X_test)
y_prob = best.predict_proba(X_test)[:, 1]

print(classification_report(y_test, y_pred))
print(f"Test AUC-ROC : {roc_auc_score(y_test, y_prob):.4f}")

# ── 6. Save pipeline ──────────────────────────────────────
joblib.dump(best, 'ml_pipeline.pkl')

Golden Rules of Machine Learning