🌐 Introduction to Data Science, Machine Learning & AI

Traditional Programming:
  Rules + Data  →  Computer  →  Output

  Example: IF invoice > 90 days AND amount > NPR 5L THEN flag as overdue
  Problem: What about 85 days and NPR 4.9L? You need endless rules.

Machine Learning:
  Data + Output  →  Computer  →  Rules (automatically learned)

  Example: Show 10,000 past invoices (paid / unpaid). 
           The model learns which patterns predict non-payment.
  Result:  It handles edge cases you never explicitly wrote.

        Statistics
           /\
          /  \
         / DS \
        /______\
  Programming  Domain Knowledge
  (Python, SQL) (Accounting, Finance, Business)

┌─────────────────────────────────────────────────────┐
│                 ARTIFICIAL INTELLIGENCE              │
│   (any technique that makes machines seem smart)     │
│                                                      │
│   ┌──────────────────────────────────────────────┐  │
│   │              MACHINE LEARNING                 │  │
│   │   (machines learn from data, not hard rules)  │  │
│   │                                               │  │
│   │   ┌─────────────────────────────────────┐    │  │
│   │   │           DEEP LEARNING              │    │  │
│   │   │  (multi-layer neural networks —      │    │  │
│   │   │   powers ChatGPT, image recognition) │    │  │
│   │   └─────────────────────────────────────┘    │  │
│   └──────────────────────────────────────────────┘  │
│                                                      │
│   DATA SCIENCE overlaps AI/ML + Statistics + Coding  │
│   DATA ANALYTICS focuses on insight from data        │
└─────────────────────────────────────────────────────┘

Training phase:
  Past Invoices + [ Late? YES / NO ]  →  Model learns the pattern

Prediction phase:
  New Invoice (no label yet)  →  Model predicts: 72% chance of being late

Input:
  200 clients with: payment history, invoice size, tenure, credit days
  (no labels — you haven't categorised them)

Output (discovered automatically):
  Group A: 52 clients — fast payers, large invoices, long tenure
  Group B: 71 clients — occasional delays, medium invoices
  Group C: 38 clients — frequent late payments, short tenure
  Group D: 37 clients — very high risk, inconsistent

Agent (e.g., a trading bot)
     ↓  takes action (buy / sell / hold)
Environment (stock market)
     ↓  gives reward (+profit) or penalty (-loss)
Agent updates its strategy
     ↓  repeat thousands of times
Result: agent learns optimal strategy over time

Do you have labelled data (known outcomes)?
     |
    YES ──→ SUPERVISED
     |         ├── Predict a number?  → Regression
     |         └── Predict a class?   → Classification
     |
    NO  ──→ UNSUPERVISED
               ├── Find groups?         → Clustering (K-Means)
               ├── Find outliers?       → Anomaly Detection
               └── Simplify features?  → Dimensionality Reduction (PCA)

1. DEFINE THE PROBLEM
   └── "Which of our 200 debtors are at risk of not paying next month?"

2. COLLECT THE DATA
   └── Export from Tally / ERP: invoice dates, amounts, payment history

3. CLEAN THE DATA          ← Module 07
   └── Fix missing values, duplicates, wrong dates, currency format errors

4. EXPLORE THE DATA        ← Modules 03, 04, 05
   └── Charts, pivot tables, summary statistics — understand the data

5. ENGINEER FEATURES       ← Module 08
   └── Create new columns: days_overdue, late_rate, invoice_vs_industry_avg

6. BUILD THE MODEL         ← Modules 09, 10
   └── Train Logistic Regression / Random Forest / K-Means

7. EVALUATE
   └── Accuracy, silhouette score, ROC-AUC — is the model good enough?

8. ACT ON INSIGHTS
   └── Export to Excel, share with collection team, update credit policy

Python  ──┬──  NumPy    (numbers and maths)
          ├──  Pandas   (tables of data)
          ├──  Matplotlib / Seaborn  (charts)
          └──  scikit-learn  (machine learning)
               ├── Preprocessing (StandardScaler, LabelEncoder)
               ├── Models (LogisticRegression, RandomForest, KMeans)
               └── Evaluation (accuracy_score, roc_auc_score, silhouette_score)

pip install numpy pandas matplotlib seaborn scikit-learn jupyterlab openpyxl

import pandas as pd
from sklearn.tree import DecisionTreeClassifier

# --- 10 past invoices (our training data) ---
# Features: [Days overdue last time, Invoice amount (NPR 000s), Credit days]
# Label:    1 = was paid LATE,  0 = paid ON TIME
past_data = pd.DataFrame({
    'prev_delay_days': [0,  5,  0, 45, 30,  0, 60, 10,  0, 90],
    'invoice_NPR_000': [50, 80, 30,200,150, 20,500, 90, 45,800],
    'credit_days':     [30, 45, 30, 60, 60, 30, 90, 45, 30, 90],
    'was_late':        [ 0,  0,  0,  1,  1,  0,  1,  0,  0,  1],  # label
})

# --- Train the model ---
X_train = past_data[['prev_delay_days', 'invoice_NPR_000', 'credit_days']]
y_train = past_data['was_late']

model = DecisionTreeClassifier(max_depth=3, random_state=42)
model.fit(X_train, y_train)

# --- Predict for 3 new invoices ---
new_invoices = pd.DataFrame({
    'Client':           ['Himalayan Trading', 'Everest Pharma', 'Kathmandu Builders'],
    'prev_delay_days':  [0,                   35,                70],
    'invoice_NPR_000':  [40,                  180,               600],
    'credit_days':      [30,                  60,                90],
})
X_new = new_invoices[['prev_delay_days', 'invoice_NPR_000', 'credit_days']]

new_invoices['Prediction'] = model.predict(X_new)
new_invoices['Prediction'] = new_invoices['Prediction'].map({0: 'On Time ✓', 1: 'LATE ✗'})

print('=== Supervised Learning: Late Payment Prediction ===')
print(new_invoices[['Client', 'prev_delay_days', 'invoice_NPR_000', 'Prediction']]
      .to_string(index=False))
print()
print('The model learned this pattern from 10 past invoices.')
print('In Module 09, we train on 900 invoices for much higher accuracy.')

=== Supervised Learning: Late Payment Prediction ===
            Client  prev_delay_days  invoice_NPR_000 Prediction
 Himalayan Trading                0               40  On Time ✓
    Everest Pharma               35              180     LATE ✗
Kathmandu Builders               70              600     LATE ✗

The model learned this pattern from 10 past invoices.
In Module 09, we train on 900 invoices for much higher accuracy.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# 8 clients: [avg days late, fraction of invoices paid late]
clients = pd.DataFrame({
    'Client':         ['Himalayan Trd', 'NMB Leasing', 'Everest Pharma',
                       'Pokhara Retail', 'Ncell Reseller', 'Kathmandu Builders',
                       'Birgunj Imports', 'Janakpur Mills'],
    'avg_delay_days': [2,   5,  3,  35, 40,  70, 80,  90],
    'late_rate':      [0.05,0.08,0.05,0.40,0.50,0.75,0.80,0.90],
})

X = StandardScaler().fit_transform(clients[['avg_delay_days', 'late_rate']])

# K-Means finds 3 groups automatically
km = KMeans(n_clusters=3, random_state=42, n_init=10)
clients['Group'] = km.fit_predict(X)

GROUP_NAMES = {0: 'Reliable', 1: 'Monitor', 2: 'High Risk'}
GROUP_COLORS = {'Reliable': 'green', 'Monitor': 'orange', 'High Risk': 'red'}

clients['Segment'] = clients['Group'].map(lambda g: GROUP_NAMES.get(g, f'Group {g}'))

print('=== Unsupervised Learning: Client Segmentation ===')
print('No labels were given — the model found these groups on its own:\n')
for seg in clients['Segment'].unique():
    members = clients[clients['Segment'] == seg]['Client'].tolist()
    avg_d = clients[clients['Segment'] == seg]['avg_delay_days'].mean()
    avg_r = clients[clients['Segment'] == seg]['late_rate'].mean()
    print(f'  {seg:12s}: {members}')
    print(f'               avg delay={avg_d:.0f}d, late rate={avg_r:.0%}')
    print()

# Plot
fig, ax = plt.subplots(figsize=(9, 6))
for seg in clients['Segment'].unique():
    mask = clients['Segment'] == seg
    ax.scatter(
        clients.loc[mask, 'avg_delay_days'],
        clients.loc[mask, 'late_rate'] * 100,
        c=GROUP_COLORS.get(seg, 'blue'), s=120, label=seg,
        edgecolors='white', linewidth=1.2, zorder=3
    )
    for _, row in clients[mask].iterrows():
        ax.annotate(row['Client'],
                    (row['avg_delay_days'], row['late_rate']*100),
                    textcoords='offset points', xytext=(6, 4), fontsize=8)

ax.set_xlabel('Average Days Late', fontsize=12)
ax.set_ylabel('% Invoices Paid Late', fontsize=12)
ax.set_title('K-Means Automatically Found 3 Client Groups\n'
             '(No Labels Required)', fontsize=13, fontweight='bold')
ax.legend(fontsize=11)
ax.grid(True, alpha=0.3)
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f'{x:.0f}%'))
plt.tight_layout()
plt.savefig('intro_clustering_demo.png', dpi=120, bbox_inches='tight')
plt.show()
print('In Module 10, we do this with 200 real clients and 6 features.')

=== Unsupervised Learning: Client Segmentation ===
No labels were given — the model found these groups on its own:

  Reliable    : ['Himalayan Trd', 'NMB Leasing', 'Everest Pharma']
               avg delay=3d, late rate=6%

  High Risk   : ['Pokhara Retail', 'Ncell Reseller']
               avg delay=38d, late rate=45%

  Monitor     : ['Kathmandu Builders', 'Birgunj Imports', 'Janakpur Mills']
               avg delay=80d, late rate=82%

In Module 10, we do this with 200 real clients and 6 features.