Will Tomorrow's Air Be Poor?

# ---------------------------------------------------------------------------
# air_quality_alert.py
#
# AI project on Statistical Data: warning a day ahead when the air is going
# to be "Poor" or worse, from today's readings at a city monitoring station.
#
# CBSE Class X, Artificial Intelligence (417), Part C project work.
# SDG 11 (Sustainable Cities) and SDG 3 (Good Health and Well-being).
#
# The model is a PERCEPTRON - the single artificial neuron of Unit 2. It
# multiplies each input by a weight, adds a bias, and says "Poor tomorrow"
# if the total is above 0. In Unit 2 the weights were given. Here the
# perceptron finds them itself: every time it gets a training day wrong, it
# nudges its weights a little towards the right answer, and it goes through
# the training days again and again.
#
# Libraries: pandas (the data), numpy (the arithmetic), matplotlib (charts).
# ---------------------------------------------------------------------------

# %% Stage 1 - Problem scoping
print("=" * 60)
print("WILL TOMORROW'S AIR BE POOR?")
print("=" * 60)
print("Who   : schools, parents, and people with asthma")
print("What  : bad-air days are announced on the day, too late to plan")
print("Where : a city with one air-quality monitoring station")
print("Why   : a day's warning lets people protect themselves")
print()

# %% Stage 2 - Data acquisition
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

pd.set_option("display.width", 120)
pd.set_option("display.max_columns", 20)

data = pd.read_csv("air_quality.csv", parse_dates=["date"])

print("--- Stage 2: Data acquisition ---")
print("Rows read    :", len(data))
print("First day    :", data["date"].min().date())
print("Last day     :", data["date"].max().date())
print()
print("The first 10 rows:")
print(data.head(10))
print()

# %% Stage 3 - Data exploration
print("--- Stage 3: Data exploration ---")

# PM2.5 above 90 is "Poor" or worse on India's air quality scale.
# The label is about TOMORROW, so each day is given the next day's PM2.5.
# This must be done BEFORE any rows are removed, or a gap in the data would
# pair a day with the wrong "tomorrow".
data["pm25_tomorrow"] = data["pm25"].shift(-1)
data["poor_tomorrow"] = np.where(data["pm25_tomorrow"] > 90, 1, 0)

# A day is unusable if today's or tomorrow's reading is missing (the
# sensor was offline). The last day has no tomorrow at all.
unusable = data["pm25"].isnull() | data["pm25_tomorrow"].isnull()
print("Days with a missing reading today or tomorrow :", unusable.sum(), "(removed)")
data = data[~unusable]
print("Days left                                     :", len(data))
print()

print("PM2.5 - mean   :", round(np.mean(data["pm25"]), 1))
print("PM2.5 - median :", np.median(data["pm25"]))
print("Days followed by a Poor day :", data["poor_tomorrow"].sum(), "of", len(data))
print()

monthly = data.groupby(data["date"].dt.month)["pm25"].mean().round(1)
print("Average PM2.5 in each month (both years together):")
print(monthly.to_string())
print()

# Chart 1: PM2.5 every day for two years.
plt.figure(figsize=(9, 4))
plt.plot(data["date"], data["pm25"], color="#8c6d31", linewidth=0.9)
plt.axhline(90, color="#e15759", linestyle="--", label="90: the start of Poor")
plt.title("PM2.5 every day for two years")
plt.xlabel("Date")
plt.ylabel("PM2.5 (micrograms per cubic metre)")
plt.legend()
plt.tight_layout()
plt.savefig("chart1_pm25_daily.png")
plt.close()

# Chart 2: today's PM2.5 and tomorrow's wind forecast.
poor = data[data["poor_tomorrow"] == 1]
fine = data[data["poor_tomorrow"] == 0]
plt.figure(figsize=(7, 5))
plt.scatter(fine["pm25"], fine["wind_forecast_kmph"], color="#59a14f", alpha=0.5, s=14, label="Tomorrow not Poor")
plt.scatter(poor["pm25"], poor["wind_forecast_kmph"], color="#e15759", alpha=0.6, s=14, label="Tomorrow Poor")
plt.title("Today's PM2.5, tomorrow's wind forecast, and what tomorrow brought")
plt.xlabel("PM2.5 today")
plt.ylabel("Wind forecast for tomorrow (km/h)")
plt.legend()
plt.grid(True, linestyle="--", alpha=0.4)
plt.tight_layout()
plt.savefig("chart2_today_tomorrow.png")
plt.close()

# %% Stage 4 - Modelling
print("--- Stage 4: Modelling ---")
# Today's PM2.5, humidity and temperature, plus the weather office's
# FORECAST of tomorrow's wind - real air-quality forecasts use weather
# forecasts too, because wind is what clears the air.
features = ["pm25", "wind_forecast_kmph", "humidity_pct", "temp_c"]

# For a forecast the rows must NOT be shuffled. The model learns from the
# first year and is tested on the second - exactly how it would be used:
# trained on the past, judged on a future it has not seen.
train = data[data["date"].dt.year == 2024]
test = data[data["date"].dt.year == 2025]
print("Training days (2024) :", len(train))
print("Testing days (2025)  :", len(test))
print()

low = train[features].min()
high = train[features].max()
X_train = ((train[features] - low) / (high - low)).values
X_test = ((test[features] - low) / (high - low)).values
y_train = train["poor_tomorrow"].values
y_test = test["poor_tomorrow"].values

# The perceptron starts knowing nothing: every weight and the bias are 0.
weights = np.zeros(len(features))
bias = 0.0
rate = 0.1          # how big each nudge is
passes = 30         # how many times it goes through the training days

# The days are visited in a shuffled order on every pass. In date order,
# every pass would end on December's long run of Poor days, and that last
# streak would drag all the weights towards "always Poor".
shuffle = np.random.default_rng(1)

mistakes_each_pass = []
for p in range(passes):
    mistakes = 0
    for i in shuffle.permutation(len(X_train)):
        total = np.dot(X_train[i], weights) + bias
        if total > 0:
            output = 1
        else:
            output = 0
        error = y_train[i] - output          # +1, 0 or -1
        if error != 0:
            # Wrong: move every weight a little towards the right answer.
            weights = weights + rate * error * X_train[i]
            bias = bias + rate * error
            mistakes = mistakes + 1
    mistakes_each_pass.append(mistakes)

print("Mistakes in the first pass :", mistakes_each_pass[0])
print("Mistakes in the last pass  :", mistakes_each_pass[-1])
print()
print("Weights the perceptron learned:")
for i in range(len(features)):
    print("  " + features[i].ljust(20), round(weights[i], 3))
print("  " + "bias".ljust(20), round(bias, 3))
print()

# Chart 3: the perceptron learning.
plt.figure(figsize=(7, 4))
plt.plot(range(1, passes + 1), mistakes_each_pass, marker="o", color="#4e79a7", markersize=4)
plt.title("The perceptron learning: mistakes in each pass")
plt.xlabel("Pass through the training days")
plt.ylabel("Mistakes")
plt.grid(True, linestyle="--", alpha=0.4)
plt.tight_layout()
plt.savefig("chart3_learning.png")
plt.close()

# Chart 4: the weights it learned.
plt.figure(figsize=(7, 4))
colours = []
for w in weights:
    if w > 0:
        colours.append("#e15759")
    else:
        colours.append("#59a14f")
plt.barh(features, weights, color=colours)
plt.axvline(0, color="#999999")
plt.title("What the perceptron learned (red pushes towards Poor)")
plt.xlabel("Weight")
plt.tight_layout()
plt.savefig("chart4_weights.png")
plt.close()

# %% Stage 5 - Evaluation
print("--- Stage 5: Evaluation ---")
perceptron = []
for i in range(len(X_test)):
    if np.dot(X_test[i], weights) + bias > 0:
        perceptron.append(1)
    else:
        perceptron.append(0)

# A simple baseline to beat: "tomorrow will be like today".
same_as_today = []
for v in test["pm25"]:
    if v > 90:
        same_as_today.append(1)
    else:
        same_as_today.append(0)

results = []
for name, predicted in [["Same as today", same_as_today], ["Perceptron", perceptron]]:
    tp = fn = fp = tn = 0
    for i in range(len(y_test)):
        if y_test[i] == 1 and predicted[i] == 1:
            tp = tp + 1
        elif y_test[i] == 1:
            fn = fn + 1
        elif predicted[i] == 1:
            fp = fp + 1
        else:
            tn = tn + 1
    accuracy = (tp + tn) / len(y_test) * 100
    precision = 0
    if tp + fp > 0:
        precision = tp / (tp + fp) * 100
    recall = 0
    if tp + fn > 0:
        recall = tp / (tp + fn) * 100
    f1 = 0
    if precision + recall > 0:
        f1 = 2 * precision * recall / (precision + recall)
    results.append([name, accuracy, precision, recall, f1])
    print(name)
    print("  " + name + " TP, FN, FP, TN :", tp, fn, fp, tn)
    print("  " + name + " accuracy  :", round(accuracy, 1), "%")
    print("  " + name + " precision :", round(precision, 1), "%")
    print("  " + name + " recall    :", round(recall, 1), "%")
    print("  " + name + " F1 score  :", round(f1, 1), "%")
    print()

# Chart 5: perceptron against the baseline.
x = np.arange(4)
plt.figure(figsize=(8, 4.5))
plt.bar(x - 0.2, results[0][1:5], width=0.4, label="Same as today", color="#9c9c9c")
plt.bar(x + 0.2, results[1][1:5], width=0.4, label="Perceptron", color="#4e79a7")
plt.xticks(x, ["Accuracy", "Precision", "Recall", "F1 score"])
plt.ylim(0, 100)
plt.ylabel("Percent (2025, unseen)")
plt.title("Forecasting Poor air one day ahead")
plt.legend()
plt.tight_layout()
plt.savefig("chart5_compared.png")
plt.close()

# %% Stage 6 - Deployment
print("--- Stage 6: Deployment ---")
today = pd.DataFrame({
    "pm25":               [78, 120, 85],
    "wind_forecast_kmph": [3.0, 18.0, 9.0],
    "humidity_pct": [72, 45, 60],
    "temp_c":       [15.0, 24.0, 19.0],
})
scaled = ((today - low) / (high - low)).values
for i in range(len(today)):
    total = np.dot(scaled[i], weights) + bias
    if total > 0:
        alert = "ALERT: Poor air likely tomorrow - plan indoor activities"
    else:
        alert = "No alert"
    t = today.iloc[i]
    print("PM2.5", int(t["pm25"]), " wind forecast", t["wind_forecast_kmph"], "km/h  humidity", int(t["humidity_pct"]),
          "%  ->", alert)

============================================================
WILL TOMORROW'S AIR BE POOR?
============================================================
Who   : schools, parents, and people with asthma
What  : bad-air days are announced on the day, too late to plan
Where : a city with one air-quality monitoring station
Why   : a day's warning lets people protect themselves

--- Stage 2: Data acquisition ---
Rows read    : 731
First day    : 2024-01-01
Last day     : 2025-12-31

The first 10 rows:
        date   pm25  wind_kmph  wind_forecast_kmph  humidity_pct  temp_c
0 2024-01-01  159.0        3.3                12.3          55.0    16.3
1 2024-01-02   96.0       11.2                10.0          57.0    18.9
2 2024-01-03  106.0        8.5                17.5          75.0    18.6
3 2024-01-04   68.0       13.3                11.1          68.0    15.1
4 2024-01-05   80.0        9.8                13.7          46.0    15.5
5 2024-01-06   71.0       10.8                13.8          61.0    15.1
6 2024-01-07   35.0       12.7                12.6          59.0    17.2
7 2024-01-08   25.0       13.3                 4.6          59.0    16.0
8 2024-01-09   99.0        3.7                 8.2          56.0    17.5
9 2024-01-10   95.0       10.2                 8.1          48.0    12.3

--- Stage 3: Data exploration ---
Days with a missing reading today or tomorrow : 10 (removed)
Days left                                     : 721

PM2.5 - mean   : 56.6
PM2.5 - median : 36.0
Days followed by a Poor day : 182 of 721

Average PM2.5 in each month (both years together):
date
1      96.6
2      71.2
3      39.5
4      17.6
5      13.5
6      17.2
7      16.0
8      22.8
9      42.8
10    108.3
11    128.5
12    108.9

--- Stage 4: Modelling ---
Training days (2024) : 361
Testing days (2025)  : 360

Mistakes in the first pass : 74
Mistakes in the last pass  : 46

Weights the perceptron learned:
  pm25                 0.645
  wind_forecast_kmph   -0.82
  humidity_pct         -0.068
  temp_c               -0.136
  bias                 0.0

--- Stage 5: Evaluation ---
Same as today
  Same as today TP, FN, FP, TN : 66 26 26 242
  Same as today accuracy  : 85.6 %
  Same as today precision : 71.7 %
  Same as today recall    : 71.7 %
  Same as today F1 score  : 71.7 %

Perceptron
  Perceptron TP, FN, FP, TN : 73 19 19 249
  Perceptron accuracy  : 89.4 %
  Perceptron precision : 79.3 %
  Perceptron recall    : 79.3 %
  Perceptron F1 score  : 79.3 %

--- Stage 6: Deployment ---
PM2.5 78  wind forecast 3.0 km/h  humidity 72 %  -> ALERT: Poor air likely tomorrow - plan indoor activities
PM2.5 120  wind forecast 18.0 km/h  humidity 45 %  -> No alert
PM2.5 85  wind forecast 9.0 km/h  humidity 60 %  -> No alert