What is Machine Learning? A Complete Beginner-Friendly Guide | Part 1

Traditional Programming:
Data + Rules → Computer → Output

Machine Learning:
Data + Output → Computer → Rules (it learns them itself!)

# Simple example: Student data
data = [
    {"marks": 85, "attendance": 90, "passed": True},
    {"marks": 45, "attendance": 50, "passed": False},
    {"marks": 72, "attendance": 80, "passed": True},
]

# In the example above:
# Features = marks, attendance
# Target   = passed (True/False)

features = ["marks", "attendance"]  # Input
target   = "passed"                 # Output (what we want to predict)

Machine Learning
├── 1. Supervised Learning    (Teacher present)
├── 2. Unsupervised Learning  (No teacher)
└── 3. Reinforcement Learning (Trial & Error)

Supervised Learning
├── Classification  → Predict a category  (Yes/No, Cat/Dog)
└── Regression      → Predict a number    (Price, Temperature)

import pandas as pd

data = [
    {"marks": 85, "attendance": 90, "passed": True},
    {"marks": 45, "attendance": 50, "passed": False},
    {"marks": 72, "attendance": 80, "passed": True},
]

df = pd.DataFrame(data)

# Features & Labels
X = df.drop(columns="passed")
y = df["passed"]
columns = X.columns

# ================= Random Forest =================
from sklearn.ensemble import RandomForestClassifier

rf_model = RandomForestClassifier()
rf_model.fit(X, y)

new_data = pd.DataFrame([[70, 60]], columns=columns)

rf_pred = rf_model.predict(new_data)
print("Random Forest Prediction:", rf_pred)


# ================= Logistic Regression =================
from sklearn.linear_model import LogisticRegression

lr_model = LogisticRegression()
lr_model.fit(X, y)

new_data = pd.DataFrame([[70, 60]], columns=columns)

lr_pred = lr_model.predict(new_data)
print("Logistic Regression Prediction:", lr_pred)

# Simple Supervised Learning Example
from sklearn.linear_model import LogisticRegression
import numpy as np

# Training data
X_train = np.array([[85, 90], [45, 50], [72, 80], [30, 40], [95, 95]])
y_train = np.array([1, 0, 1, 0, 1])  # 1=Pass, 0=Fail

# Create model
model = LogisticRegression()

# Train it
model.fit(X_train, y_train)

# Predict
new_student = np.array([[70, 75]])
prediction = model.predict(new_student)
print(f"Student will pass: {bool(prediction[0])}")
# Output: Student will pass: True

# Simple Clustering Example
from sklearn.cluster import KMeans
import numpy as np

# Customer data: [age, spending_score]
customers = np.array([
    [25, 80], [30, 75], [35, 85],   # Young, high spenders
    [55, 20], [60, 15], [50, 25],   # Older, low spenders
    [40, 50], [45, 55],              # Middle group
])

# Cluster into 3 groups
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(customers)

print("Customer Groups:", kmeans.labels_)
# Output: Customer Groups: [0 0 0 1 1 1 2 2] (example)

# RL concept illustrated (pseudocode style)
# For real RL: pip install gymnasium stable-baselines3

"""
Agent       = AI player
Environment = Game/World
State       = Current situation
Action      = What to do next?
Reward      = How good was that action?

Loop:
  1. Observe the current state
  2. Take an action
  3. Receive reward/penalty
  4. Learn and improve
"""

# Simple Q-Learning concept
Q_table = {}  # Stores State-Action values

def get_action(state, epsilon=0.1):
    """Explore (random) or Exploit (best known action)"""
    import random
    if random.random() < epsilon:
        return random.choice(['left', 'right', 'up', 'down'])  # Explore
    else:
        return max(Q_table.get(state, {}), default='left')      # Exploit

Step 1:  Define the Problem
    ↓
Step 2:  Collect Data
    ↓
Step 3:  Clean Data (Preprocessing)
    ↓
Step 4:  Select / Engineer Features
    ↓
Step 5:  Choose a Model
    ↓
Step 6:  Train the Model
    ↓
Step 7:  Evaluate the Model
    ↓
Step 8:  Tune the Model (Hyperparameter Tuning)
    ↓
Step 9:  Deploy
    ↓
Step 10: Monitor

# Problem Statement:
# "Will this customer churn next month?"
# Type: Binary Classification (Yes/No)
# Metric: Accuracy, Precision, Recall
# Business Goal: 85%+ accuracy required

import pandas as pd

# Load from CSV
df = pd.read_csv('customers.csv')

# Load from a database
import sqlite3
conn = sqlite3.connect('company.db')
df = pd.read_sql("SELECT * FROM customers", conn)

# Load from an API
import requests
response = requests.get('https://api.example.com/data')
data = response.json()

import pandas as pd
import numpy as np

df = pd.read_csv('customers.csv')

# 1. Check for missing values
print(df.isnull().sum())

# 2. Fill missing values
df['age'].fillna(df['age'].median(), inplace=True)     # Numeric: use median
df['city'].fillna('Unknown', inplace=True)               # Categorical: placeholder

# 3. Remove duplicates
df.drop_duplicates(inplace=True)

# 4. Handle outliers using IQR
Q1 = df['salary'].quantile(0.25)
Q3 = df['salary'].quantile(0.75)
IQR = Q3 - Q1
df = df[(df['salary'] >= Q1 - 1.5*IQR) & (df['salary'] <= Q3 + 1.5*IQR)]

# 5. Fix data types
df['join_date'] = pd.to_datetime(df['join_date'])
df['is_premium'] = df['is_premium'].astype(bool)

print("Clean data shape:", df.shape)

# Create new meaningful features
df['tenure_months'] = (pd.Timestamp.now() - df['join_date']).dt.days // 30
df['avg_monthly_spend'] = df['total_spend'] / df['tenure_months']
df['spend_per_transaction'] = df['total_spend'] / df['total_transactions']

# Encode categorical variables
df = pd.get_dummies(df, columns=['city', 'plan_type'], drop_first=True)

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# Split features and target
X = df.drop('churned', axis=1)
y = df['churned']

# Train-Test split (80% train, 20% test)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Choose and train the model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Predict
y_pred = model.predict(X_test)

# Evaluate
print(f"Accuracy: {accuracy_score(y_test, y_pred):.2%}")
print("\nDetailed Report:")
print(classification_report(y_test, y_pred))

"""
Problem: Is this transaction fraudulent?
Type: Binary Classification
Features: Amount, Location, Time, Merchant, User History
Challenge: Imbalanced data (fraud cases are rare)
"""

from sklearn.ensemble import IsolationForest
import pandas as pd

transactions = pd.read_csv('transactions.csv')

# Isolation Forest for anomaly detection
fraud_detector = IsolationForest(contamination=0.01, random_state=42)
# contamination=0.01 means we expect ~1% of transactions to be fraud

transactions['fraud_score'] = fraud_detector.fit_predict(
    transactions[['amount', 'hour', 'merchant_category']]
)

# -1 = suspicious, 1 = normal
fraud_cases = transactions[transactions['fraud_score'] == -1]
print(f"Suspicious transactions flagged: {len(fraud_cases)}")

"""
Problem: Does this patient have diabetes?
Type: Binary Classification
Dataset: Pima Indians Diabetes Dataset (famous benchmark)
"""

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.preprocessing import StandardScaler
import pandas as pd

url = "https://raw.githubusercontent.com/plotly/datasets/master/diabetes.csv"
df = pd.read_csv(url)

X = df.drop('Outcome', axis=1)  # Features
y = df['Outcome']               # 0=No Diabetes, 1=Diabetes

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2)

model = GradientBoostingClassifier(n_estimators=200, learning_rate=0.1)
model.fit(X_train, y_train)

accuracy = model.score(X_test, y_test)
print(f"Diabetes Prediction Accuracy: {accuracy:.2%}")

"""
Problem: Predict house price
Type: Regression
Features: Area, Bedrooms, Location, Age, Amenities
"""

from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error, r2_score
import pandas as pd
import numpy as np

np.random.seed(42)
n = 1000

df = pd.DataFrame({
    'area_sqft': np.random.randint(500, 5000, n),
    'bedrooms': np.random.randint(1, 6, n),
    'age_years': np.random.randint(0, 50, n),
    'distance_metro_km': np.random.uniform(0.1, 10, n),
    'floor': np.random.randint(1, 20, n),
})

# Simulate realistic prices
df['price_lakhs'] = (
    df['area_sqft'] * 4.5 +
    df['bedrooms'] * 50000 -
    df['age_years'] * 20000 -
    df['distance_metro_km'] * 100000 +
    df['floor'] * 15000 +
    np.random.normal(0, 50000, n)
) / 100000

from sklearn.model_selection import train_test_split
X = df.drop('price_lakhs', axis=1)
y = df['price_lakhs']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
print(f"MAE: {mean_absolute_error(y_test, y_pred):.2f} Lakhs")
print(f"R² Score: {r2_score(y_test, y_pred):.4f}")

# ============================================================
# COMPLETE ML PIPELINE — IRIS FLOWER CLASSIFICATION
# ============================================================
# Problem: Predict the species of a flower (Setosa/Versicolor/Virginica)
# Type: Multi-class Classification
# Dataset: Iris (built into sklearn)
# ============================================================

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (
    accuracy_score, classification_report, ConfusionMatrixDisplay
)
import warnings
warnings.filterwarnings('ignore')

# ─────────────────────────────────────────────
# Step 1: Load Data
# ─────────────────────────────────────────────
iris = load_iris()

df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['species'] = iris.target
df['species_name'] = df['species'].map({
    0: 'Setosa', 1: 'Versicolor', 2: 'Virginica'
})

print("📦 Data Shape:", df.shape)
print("\n📊 Species Distribution:")
print(df['species_name'].value_counts())

# ─────────────────────────────────────────────
# Step 2: Exploratory Data Analysis
# ─────────────────────────────────────────────
print("\n📈 Basic Statistics:")
print(df.describe().round(2))
print("\n❓ Missing Values:", df.isnull().sum().sum())

# ─────────────────────────────────────────────
# Step 3: Separate Features and Target
# ─────────────────────────────────────────────
X = df[iris.feature_names]   # 4 features (input)
y = df['species']             # Target (output: 0, 1, or 2)

# ─────────────────────────────────────────────
# Step 4: Train-Test Split
# ─────────────────────────────────────────────
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,    # 20% test data
    random_state=42,  # For reproducibility
    stratify=y        # Maintain class proportions
)

print(f"\n🔀 Train size: {X_train.shape[0]}")
print(f"🔀 Test size: {X_test.shape[0]}")

# ─────────────────────────────────────────────
# Step 5: Feature Scaling
# ─────────────────────────────────────────────
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)   # Fit on train, transform train
X_test_scaled  = scaler.transform(X_test)         # Only transform test!
# ⚠️ IMPORTANT: NEVER fit the scaler on test data — causes data leakage!

# ─────────────────────────────────────────────
# Step 6: Train the Model
# ─────────────────────────────────────────────
model = RandomForestClassifier(
    n_estimators=100,    # 100 decision trees
    max_depth=None,
    random_state=42
)
model.fit(X_train_scaled, y_train)
print("\n✅ Model training complete!")

# ─────────────────────────────────────────────
# Step 7: Predictions
# ─────────────────────────────────────────────
y_pred = model.predict(X_test_scaled)
y_prob = model.predict_proba(X_test_scaled)

print("\n🎯 Sample Predictions:")
for i in range(5):
    actual    = iris.target_names[y_test.iloc[i]]
    predicted = iris.target_names[y_pred[i]]
    confidence = y_prob[i].max() * 100
    status = "✅" if actual == predicted else "❌"
    print(f"  {status} Actual: {actual:12} | Predicted: {predicted:12} | Confidence: {confidence:.1f}%")

# ─────────────────────────────────────────────
# Step 8: Evaluation
# ─────────────────────────────────────────────
accuracy = accuracy_score(y_test, y_pred)
print(f"\n📊 Test Accuracy: {accuracy:.2%}")

cv_scores = cross_val_score(model, X_train_scaled, y_train, cv=5)
print(f"📊 Cross-Validation Accuracy: {cv_scores.mean():.2%} (±{cv_scores.std():.2%})")

print("\n📋 Detailed Classification Report:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

# ─────────────────────────────────────────────
# Step 9: Feature Importance
# ─────────────────────────────────────────────
feature_importance = pd.DataFrame({
    'Feature': iris.feature_names,
    'Importance': model.feature_importances_
}).sort_values('Importance', ascending=False)

print("\n🔑 Feature Importance:")
print(feature_importance.to_string(index=False))

# ─────────────────────────────────────────────
# Step 10: Predict a New Flower
# ─────────────────────────────────────────────
new_flower = np.array([[5.1, 3.5, 1.4, 0.2]])
new_flower_scaled = scaler.transform(new_flower)

prediction  = model.predict(new_flower_scaled)
confidence  = model.predict_proba(new_flower_scaled).max()
species     = iris.target_names[prediction[0]]

print(f"\n🌸 New flower species: {species}")
print(f"🎯 Confidence: {confidence:.2%}")

📦 Data Shape: (150, 6)

📊 Species Distribution:
Setosa        50
Versicolor    50
Virginica     50

📊 Test Accuracy: 96.67%
📊 Cross-Validation Accuracy: 96.67% (±2.11%)

🔑 Feature Importance:
            Feature  Importance
petal length (cm)      0.4421
 petal width (cm)      0.4089
sepal length (cm)      0.0987
 sepal width (cm)      0.0503

🌸 New flower species: setosa
🎯 Confidence: 100.00%

# ❌ WRONG — Data Leakage!
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # Fit on entire data
X_train, X_test = train_test_split(X_scaled, test_size=0.2)

# ✅ CORRECT — No Leakage
X_train, X_test = train_test_split(X, test_size=0.2)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)  # Fit only on train
X_test  = scaler.transform(X_test)       # Only transform test

# Detect overfitting
train_score = model.score(X_train, y_train)
test_score  = model.score(X_test, y_test)

print(f"Train Score: {train_score:.2%}")
print(f"Test Score:  {test_score:.2%}")

# If train >> test → Overfitting!
# Example: Train: 99%, Test: 72% → Overfit!

# Fix: Regularization, cross-validation, simpler model, more data
model = RandomForestClassifier(
    max_depth=5,
    min_samples_leaf=5,
    n_estimators=50
)

# ❌ Wrong: Training directly on imbalanced data
# 990 Non-fraud + 10 Fraud → Model learns "always say non-fraud" → 99% accuracy but useless!

# ✅ Fix: Resampling or class_weight
from sklearn.utils import resample

fraud_upsampled = resample(
    fraud_df,
    replace=True,
    n_samples=len(normal_df),
    random_state=42
)

# Or use class_weight
model = RandomForestClassifier(class_weight='balanced')

# ❌ Wrong: Using accuracy on imbalanced data
# 99% accuracy sounds great but may be completely useless

# ✅ Use the right metric for your problem:

# Classification (balanced):    Accuracy
# Classification (imbalanced):  F1-Score, AUC-ROC, Precision-Recall
# Regression:                   MAE, RMSE, R²
# Medical / safety-critical:    Recall — missing a positive case is costly

from sklearn.metrics import f1_score, roc_auc_score

f1  = f1_score(y_test, y_pred, average='weighted')
auc = roc_auc_score(y_test, y_prob[:, 1])
print(f"F1 Score: {f1:.4f}")
print(f"AUC-ROC:  {auc:.4f}")

# ❌ Wrong: Distance-based models without scaling
# KNN, SVM, Neural Networks are sensitive to feature scale

# ✅ Fix:
from sklearn.preprocessing import StandardScaler, MinMaxScaler

# StandardScaler: Mean=0, Std=1 (great for normally distributed data)
scaler = StandardScaler()

# MinMaxScaler: Scales to 0–1 range (great for neural networks)
scaler = MinMaxScaler()

X_scaled = scaler.fit_transform(X_train)

# 1. Always set random_state for reproducibility
model = RandomForestClassifier(random_state=42)
X_train, X_test = train_test_split(X, y, random_state=42)

# 2. Use Pipelines — clean and leak-proof
from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', RandomForestClassifier(random_state=42))
])
pipeline.fit(X_train, y_train)
score = pipeline.score(X_test, y_test)

# 3. Always use cross-validation
from sklearn.model_selection import cross_val_score
scores = cross_val_score(pipeline, X, y, cv=5, scoring='accuracy')
print(f"CV Mean: {scores.mean():.4f}, Std: {scores.std():.4f}")

# 4. Save your model
import joblib
joblib.dump(pipeline, 'model_v1.pkl')
model = joblib.load('model_v1.pkl')

# 5. Log your experiments
experiment = {
    'model': 'RandomForest',
    'n_estimators': 100,
    'accuracy': 0.9667,
    'date': '2024-01-15',
    'notes': 'Baseline model'
}
import json
with open('experiment_log.json', 'a') as f:
    json.dump(experiment, f)
    f.write('\n')

# 1. n_jobs=-1 — use all CPU cores
model = RandomForestClassifier(n_jobs=-1, random_state=42)

# 2. GridSearchCV for hyperparameter tuning
from sklearn.model_selection import GridSearchCV

param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 5, 10],
    'min_samples_leaf': [1, 5, 10]
}

grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1,
    verbose=1
)
grid_search.fit(X_train, y_train)
print("Best params:", grid_search.best_params_)
print("Best score:", grid_search.best_score_)

# Clear rules exist → Traditional Programming
def calculate_tax(income):
    if income < 250000:
        return 0
    elif income < 500000:
        return income * 0.05
    else:
        return income * 0.20

# Rules are complex or unknown → Machine Learning
# Spam detection, image recognition, etc.

import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

# Mixed data (numeric + categorical)
data = pd.DataFrame({
    'age':    [25, 30, 35, 40, 50],
    'salary': [30000, 50000, 70000, 90000, 120000],
    'city':   ['Mumbai', 'Delhi', 'Mumbai', 'Bangalore', 'Delhi'],
    'plan':   ['Basic', 'Premium', 'Premium', 'Basic', 'Premium'],
    'churned':[0, 0, 1, 1, 0]
})

X = data.drop('churned', axis=1)
y = data['churned']

numeric_features     = ['age', 'salary']
categorical_features = ['city', 'plan']

preprocessor = ColumnTransformer([
    ('num', StandardScaler(), numeric_features),
    ('cat', OneHotEncoder(drop='first'), categorical_features)
])

full_pipeline = Pipeline([
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier(random_state=42))
])

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
full_pipeline.fit(X_train, y_train)
print("Pipeline accuracy:", full_pipeline.score(X_test, y_test))

import joblib
import numpy as np
from flask import Flask, request, jsonify

app = Flask(__name__)
model  = joblib.load('customer_churn_model.pkl')
scaler = joblib.load('scaler.pkl')

@app.route('/predict', methods=['POST'])
def predict():
    """Predict customer churn"""
    try:
        data = request.json

        required_fields = ['age', 'salary', 'tenure_months']
        for field in required_fields:
            if field not in data:
                return jsonify({'error': f'Missing field: {field}'}), 400

        features = np.array([[data['age'], data['salary'], data['tenure_months']]])
        features_scaled = scaler.transform(features)

        prediction  = model.predict(features_scaled)[0]
        probability = model.predict_proba(features_scaled)[0].max()

        return jsonify({
            'will_churn': bool(prediction),
            'confidence': float(probability),
            'action': 'Send retention offer' if prediction else 'No action needed'
        })

    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(debug=True, port=5000)

High Bias     = Underfitting (model too simple)
High Variance = Overfitting  (model too complex)
Goal          = Low Bias + Low Variance (a balance)

Underfitting  → Add more features or use a more complex model
Overfitting   → Use regularization, more data, or a simpler model

Precision = TP / (TP + FP)  → "Of all positives predicted, how many were actually positive?"
Recall    = TP / (TP + FN)  → "Of all actual positives, how many did we catch?"

Medical:  High Recall needed (never miss a patient)
Spam:     High Precision needed (don't block legitimate email)

from sklearn.linear_model import Lasso, Ridge

# L1 (Lasso): Performs feature selection — some weights → 0
lasso = Lasso(alpha=0.01)

# L2 (Ridge): Keeps weights small but non-zero
ridge = Ridge(alpha=0.01)

# L1 + L2 (ElasticNet): Combines both
from sklearn.linear_model import ElasticNet
elastic = ElasticNet(alpha=0.01, l1_ratio=0.5)

Part 2:  Linear Regression — Complete Deep Dive
Part 3:  Logistic Regression — Classification Mastery
Part 4:  Decision Trees & Random Forests
Part 5:  Support Vector Machines (SVM)
Part 6:  K-Means Clustering
Part 7:  Neural Networks & Deep Learning
Part 8:  Natural Language Processing (NLP)
Part 9:  Model Deployment with Flask/FastAPI
Part 10: MLOps — Production ML Systems