Project: Predicting Temperature in London

import sys
print(f"The current python version being used is {sys.version}")

!pip install --upgrade pip

# Run this cell to install mlflow
!pip install -q ydata-profiling mlflow scipy graphviz

from importlib.metadata import version

pkgs = [
    "pandas",
    "numpy",
    "mlflow",
    "matplotlib",
    "scikit-learn",
    "seaborn",
    "ydata-profiling",
    "scipy",
    "graphviz"
]

for p in pkgs:
    print(f"{p} version: {version(p)}")

# Run this cell to import the modules you require
import pandas as pd
import numpy as np
import mlflow
import mlflow.sklearn
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split, RandomizedSearchCV
from sklearn.metrics import mean_squared_error
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from ydata_profiling import ProfileReport
from scipy.stats import boxcox, yeojohnson
from sklearn.impute import KNNImputer


# Read in the data
weather = pd.read_csv("london_weather.csv")

# Start coding here
# Use as many cells as you like
print("Concise summary of the data")
weather.info()
print("=" * 100)
print("sample head and tail")
print(weather.head().transpose())
print("tail")
print(weather.tail().transpose())

# explore the dataset with pandas profiling
profile = ProfileReport(weather, title="Profiling Report")
profile.to_file("weather_dataset.html")
profile

# impute the snow_depth with binary mask: 1 if snow_depth is not null, 0 otherwise
weather["snow_depth_mask"] = weather["snow_depth"].notnull().astype(int)

# get approximate values to fill in the missing values using KNN
# imputer = KNNImputer(n_neighbors=5)
# weather["snow_depth_imputed"] = imputer.fit_transform(weather[["snow_depth"]])
weather["snow_depth_imputed"] = weather["snow_depth"].fillna(0)

# boxcox transformation
# weather["snow_depth_boxcox"], _ = boxcox(weather["snow_depth_imputed"] + 1)
# yeo-johnson transformation
weather["snow_depth_yeojohnson"], _ = yeojohnson(weather["snow_depth_imputed"] + 1)

print(weather["snow_depth_mask"].value_counts())
print("#" * 100)
# see skewness of the original, boxcox and yeo-johnson transformed snow_depth
print("The original skew value:" + "\n")
print(weather["snow_depth"].skew())
# print(f"After boxcox transformation: {weather["snow_depth_boxcox"].skew()}")
print("After yeojohnson transformation: " + "\n")
print(weather["snow_depth_yeojohnson"].skew())

# Extract seasonal features from the date (month, day of year, season)
weather["date"] = pd.to_datetime(weather["date"])

# extract month, day of year and season
weather["month"] = weather["date"].dt.month
weather["dayofyear"] = weather["date"].dt.dayofyear
weather["year"] = weather["date"].dt.year

# seasons in london are defined as follows: 
# Spring: March 1 to May 31
# Summer: June 1 to August 31
# Fall: September 1 to November 30
# Winter: December 1 to February 28
weather["season"] = weather["date"].dt.month.apply(
    lambda x: "Spring" if 3 <= x <= 5
    else "Summer" if 6 <= x <= 8
    else "Fall" if 9 <= x <= 11
    else "Winter"
)

# drop the original date column
weather.drop("date", axis=1, inplace=True)

# resultant columns
print(weather[["month", "dayofyear", "season", "year"]].head())
print("=" * 100)
print(weather[["month", "dayofyear", "season", "year"]].tail())

# Create interaction features: sunshine and global_radiation
weather["sunshine_global_radiation"] = weather["sunshine"] * weather["global_radiation"]

# max temperature and min temperature interaction
weather["max_min_temperature"] = weather["max_temp"] * weather["min_temp"]

# pressure and precipitation interaction
weather["pressure_precipitation"] = weather["pressure"] * weather["precipitation"]

# resultant columns
print(weather[["sunshine_global_radiation", "max_min_temperature", "pressure_precipitation"]].head())

# resultant columns
print(weather[["sunshine_global_radiation", "max_min_temperature", "pressure_precipitation"]].tail())

# drop the original columns
weather.drop(["sunshine", "global_radiation", "max_temp", "min_temp", "pressure", "precipitation", "snow_depth_imputed", "snow_depth"], axis=1, inplace=True)

# missing values percentage
missing_values = weather.isnull().mean() * 100

print(missing_values)
print("not too bad we don't have a lot of missing values now. It would be unrealistic to leave out some since some weather metrics are needed for accurate prediction")

# Preprocess data
imputer = SimpleImputer(strategy='median')

# One hot encode categorical features
weather = pd.get_dummies(weather, drop_first=True)

X = weather.drop(columns=['mean_temp'])
y = weather['mean_temp']

# Impute missing values in X and y
X = imputer.fit_transform(X)
y = imputer.fit_transform(y.values.reshape(-1, 1)).ravel()

# Split data into training, validation, and testing sets
X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.4, random_state=42)
X_valid, X_test, y_valid, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=42)

# Function to train and evaluate models
def train_and_log_model(model, model_name, params, input_example):
    with mlflow.start_run() as run:
        model.fit(X_train, y_train)
        predictions = model.predict(X_train)
        rmse = np.sqrt(mean_squared_error(y_train, predictions))
        
        mlflow.log_params(params)
        mlflow.log_metric("rmse", rmse)
        mlflow.sklearn.log_model(model, model_name, input_example=input_example)
        
        return run.info.experiment_id, run.info.run_id, rmse, model

# Train and log Linear Regression model
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_valid_scaled = scaler.transform(X_valid)

lr = LinearRegression()
lr_params = {}
lr_input_example = pd.DataFrame(X_train_scaled[:1], columns=weather.drop(columns=['mean_temp']).columns)
lr_experiment_id, lr_run_id, lr_rmse, lr_model = train_and_log_model(lr, "LinearRegression", lr_params, lr_input_example)

# Hyperparameter tuning for Decision Tree
dt = DecisionTreeRegressor(random_state=42)
dt_param_dist = {
    "max_depth": [3, 4, None],
    "min_samples_split": [2, 10, 25],
    "min_samples_leaf": [1, 5, 10],
    #"criterion": ["mse", "mae"]
}
dt_random_search = RandomizedSearchCV(dt, param_distributions=dt_param_dist, n_iter=10, cv=5, random_state=42)
dt_random_search.fit(X_train, y_train)
dt_best_params = dt_random_search.best_params_

dt_input_example = pd.DataFrame(X_train[:1], columns=weather.drop(columns=['mean_temp']).columns)
dt_experiment_id, dt_run_id, dt_rmse, dt_model = train_and_log_model(dt_random_search.best_estimator_, "DecisionTreeRegressor", dt_best_params, dt_input_example)

# Hyperparameter tuning for Random Forest
rf = RandomForestRegressor(random_state=42)
rf_param_dist = {
    "n_estimators": [10, 50, 100],
    "max_depth": [3, 4, None],
    "min_samples_split": [2, 10, 25],
    "min_samples_leaf": [1, 5, 10],
    "bootstrap": [True, False]
}
rf_random_search = RandomizedSearchCV(rf, param_distributions=rf_param_dist, n_iter=10, cv=5, random_state=42)
rf_random_search.fit(X_train, y_train)
rf_best_params = rf_random_search.best_params_

rf_input_example = pd.DataFrame(X_train[:1], columns=weather.drop(columns=['mean_temp']).columns)
rf_experiment_id, rf_run_id, rf_rmse, rf_model = train_and_log_model(rf_random_search.best_estimator_, "RandomForestRegressor", rf_best_params, rf_input_example)

# Determine the model with the lowest RMSE
models_rmse = {
    "LinearRegression": (lr_rmse, lr_model),
    "DecisionTreeRegressor": (dt_rmse, dt_model),
    "RandomForestRegressor": (rf_rmse, rf_model)
}

best_model_name, (best_rmse, best_model) = min(models_rmse.items(), key=lambda item: item[1][0])

#print(f"The best model is {best_model_name} with an RMSE of {best_rmse}")
#print(models_rmse)

# Search all MLflow runs and store the results
#experiment_id = rf_experiment_id  # Assuming all runs are in the same experiment
experiment_results = mlflow.search_runs(filter_string="metrics.rmse < 3", search_all_experiments=True)
#experiment_results = mlflow.search_runs(experiment_ids=[experiment_id], filter_string="metrics.rmse <= 3")


print(experiment_results)