{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "9bJE2poMZa7d"
},
"outputs": [],
"source": [
"!pip install keras-tuner --upgrade"
]
},
{
"cell_type": "code",
"source": [
"import tensorflow as tf\n",
"tf.test.gpu_device_name()"
],
"metadata": {
"id": "_8J9yh7CZetf"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Importing the necessary libraries\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import pandas as pd\n",
"import seaborn as sns\n",
"from pylab import rcParams\n",
"from pandas.plotting import register_matplotlib_converters\n",
"register_matplotlib_converters()\n",
"sns.set(style='whitegrid', palette='muted', font_scale=1.5)\n",
"plt.rcParams['figure.figsize'] = [20, 6]\n",
"\n",
"import random\n",
"\n",
"# Set random seed for reproducibility\n",
"np.random.seed(42)\n",
"random.seed(42)\n",
"tf.random.set_seed(42)"
],
"metadata": {
"id": "xKu9txjSZg0V"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Importing the dataset\n",
"df= pd.read_csv('dataset.csv', encoding='latin1')\n",
"df"
],
"metadata": {
"id": "fLnYqpSMZjuR"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"df.info()"
],
"metadata": {
"id": "awEvf1TDZqZc"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"df = df.drop(['numer_sta', 'lat', 'lon', 'storm name', 'Storm'], axis=1)\n",
"df.head()"
],
"metadata": {
"id": "AXrrSjXlZq7k"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"df['date'] = pd.to_datetime(df['date'])\n",
"df = df.set_index(\"date\")"
],
"metadata": {
"id": "NiQwIExVZvJW"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Dealing with missing values\n",
"print(df.isnull().sum())"
],
"metadata": {
"id": "_z0z5Tf-Zylr"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"from sklearn.impute import SimpleImputer\n",
"\n",
"# Create an imputer object using median as the strategy\n",
"imputer = SimpleImputer(missing_values=np.nan, strategy='median')\n",
"\n",
"# Define the columns where you want to apply the imputation\n",
"columns_to_impute = ['Temperature',\t'Humidity',\t'Wind speed',\t'Pressure', 'Wave height', 'Wave period']\n",
"\n",
"# Apply the imputer to the selected columns of the DataFrame\n",
"df[columns_to_impute] = imputer.fit_transform(df[columns_to_impute])\n",
"\n",
"# Checking the DataFrame to ensure no more missing values\n",
"df.isnull().values.any()"
],
"metadata": {
"id": "33HxdNSoZ1uX"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"num_variables = len(df.columns)\n",
"fig, axes = plt.subplots(nrows=num_variables, ncols=1, figsize=(20, 5 * num_variables))\n",
"\n",
"# Plot each variable on its own subplot\n",
"for i, column in enumerate(df.columns):\n",
" axes[i].plot(df.index, df[column], label=f'{column}', color=plt.cm.tab10(i))\n",
" axes[i].set_title(f'Time Series of {column}', fontsize=16)\n",
" axes[i].legend(loc='upper right')\n",
" axes[i].set_ylabel(column)\n",
" axes[i].tick_params(labelsize=12)\n",
"\n",
"# Set common labels\n",
"plt.xlabel(\"Index (Time)\", fontsize=14)\n",
"plt.xticks(fontsize=14)\n",
"plt.tight_layout()\n",
"plt.show()"
],
"metadata": {
"id": "Jc0uL3FVZ5Df"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"from statsmodels.graphics.tsaplots import plot_acf\n",
"\n",
"wave_height = df['Wave height']\n",
"\n",
"# Plot the ACF\n",
"plt.figure(figsize=(14,7))\n",
"plot_acf(wave_height, lags=100, alpha=0.05)\n",
"plt.title('Autocorrelation of Wave Height')\n",
"plt.show()\n",
"\n",
"wave_period = df['Wave period']\n",
"\n",
"# Plot the ACF\n",
"plt.figure(figsize=(14,7))\n",
"plot_acf(wave_period, lags=100, alpha=0.05)\n",
"plt.title('Autocorrelation of Wave Period')\n",
"plt.show()\n",
"\n",
"\n",
"Wind_speed = df['Wind speed']\n",
"\n",
"# Plot the ACF\n",
"plt.figure(figsize=(14,7))\n",
"plot_acf(Wind_speed, lags=100, alpha=0.05)\n",
"plt.title('Autocorrelation of Wind Speed')\n",
"plt.show()\n",
"\n",
"temperature = df['Temperature']\n",
"# Plot the ACF\n",
"plt.figure(figsize=(14,7))\n",
"plot_acf(temperature, lags=100, alpha=0.05)\n",
"plt.title('Autocorrelation of Temperature')\n",
"plt.show()\n",
"\n",
"humidity = df['Humidity']\n",
"# Plot the ACF\n",
"plt.figure(figsize=(14,7))\n",
"plot_acf(humidity, lags=100, alpha=0.05)\n",
"plt.title('Autocorrelation of Humidity')\n",
"plt.show()\n",
"\n",
"pressure = df['Pressure']\n",
"# Plot the ACF\n",
"plt.figure(figsize=(14,7))\n",
"plot_acf(pressure, lags=100, alpha=0.05)\n",
"plt.title('Autocorrelation of Pressure')\n",
"plt.show()"
],
"metadata": {
"id": "n9juG2xiZ8Iy"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Data Formating/ Preparing the input shape\n",
"\n",
"def df_to_X_y(df_1, window_size=30):\n",
" df_as_np = df_1.to_numpy()\n",
" X = []\n",
" y = []\n",
" for i in range(len(df_as_np)-window_size):\n",
" row = [r for r in df_as_np[i:i+window_size]]\n",
" X.append(row)\n",
" label = [df_as_np[i+window_size][0], df_as_np[i+window_size][1], df_as_np[i+window_size][2], df_as_np[i+window_size][3], df_as_np[i+window_size][4], df_as_np[i+window_size][5]]\n",
" y.append(label)\n",
" return np.array(X), np.array(y)"
],
"metadata": {
"id": "ro9WjX9eaBAy"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"X, y = df_to_X_y(df)\n",
"print(f\"Shape of X: {X.shape}\")\n",
"print(f\"Shape of y: {y.shape}\")"
],
"metadata": {
"id": "pqadgGiOaG8N"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Define the size of the training set\n",
"train_size = int(len(X) * 0.80) # Using 80% of data for training and 20% for testing\n",
"\n",
"# Split the data into training and test sets by slicing\n",
"X_train, y_train = X[:train_size], y[:train_size]\n",
"X_test, y_test = X[train_size:], y[train_size:]\n",
"\n",
"# Print the shapes to verify the split\n",
"print(\"X_train shape:\", X_train.shape)\n",
"print(\"y_train shape:\", y_train.shape)\n",
"print(\"X_test shape:\", X_test.shape)\n",
"print(\"y_test shape:\", y_test.shape)"
],
"metadata": {
"id": "SLlvBE7xaHqc"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Normalization\n",
"temp_training_mean = np.mean(X_train[:, :, 0])\n",
"temp_training_std = np.std(X_train[:, :, 0])\n",
"\n",
"hum_training_mean = np.mean(X_train[:, :, 1])\n",
"hum_training_std = np.std(X_train[:, :, 1])\n",
"\n",
"wind_training_mean = np.mean(X_train[:, :, 2])\n",
"wind_training_std = np.std(X_train[:, :, 2])\n",
"\n",
"pres_training_mean = np.mean(X_train[:, :, 3])\n",
"pres_training_std = np.std(X_train[:, :, 3])\n",
"\n",
"waveH_training_mean = np.mean(X_train[:, :, 4])\n",
"waveH_training_std = np.std(X_train[:, :, 4])\n",
"\n",
"waveP_training_mean = np.mean(X_train[:, :, 5])\n",
"waveP_training_std = np.std(X_train[:, :, 5])\n",
"\n",
"def preprocess(X):\n",
" X[:, :, 0] = (X[:, :, 0] - temp_training_mean) / temp_training_std\n",
" X[:, :, 1] = (X[:, :, 1] - hum_training_mean) / hum_training_std\n",
" X[:, :, 2] = (X[:, :, 2] - wind_training_mean) / wind_training_std\n",
" X[:, :, 3] = (X[:, :, 3] - pres_training_mean) / pres_training_std\n",
" X[:, :, 4] = (X[:, :, 4] - waveH_training_mean) / waveH_training_std\n",
" X[:, :, 5] = (X[:, :, 5] - waveP_training_mean) / waveP_training_std\n",
"\n",
"def preprocess_output(y):\n",
" y[:, 0] = (y[:, 0] - temp_training_mean) / temp_training_std\n",
" y[:, 1] = (y[:, 1] - hum_training_mean) / hum_training_std\n",
" y[:, 2] = (y[:, 2] - wind_training_mean) / wind_training_std\n",
" y[:, 3] = (y[:, 3] - pres_training_mean) / pres_training_std\n",
" y[:, 4] = (y[:, 4] - waveH_training_mean) / waveH_training_std\n",
" y[:, 5] = (y[:, 5] - waveP_training_mean) / waveP_training_std\n",
" return y"
],
"metadata": {
"id": "xx_gh9StaQrI"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"preprocess(X_train)\n",
"preprocess(X_test)"
],
"metadata": {
"id": "hNIY2T5WaRQ0"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"preprocess_output(y_train)\n",
"preprocess_output(y_test)"
],
"metadata": {
"id": "btq-jnqcaUOX"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"import tensorflow as tf\n",
"from tensorflow import keras\n",
"from tensorflow.keras import layers\n",
"from keras_tuner import BayesianOptimization, Objective\n",
"from sklearn.model_selection import KFold\n",
"from tensorflow.keras.callbacks import EarlyStopping\n",
"import keras_tuner as kt\n",
"from tensorflow.keras.layers import LSTM, Dense, Dropout\n",
"from sklearn.model_selection import TimeSeriesSplit\n",
"\n",
"\n",
"\n",
"class MyHyperModel(kt.HyperModel):\n",
" def build(self, hp):\n",
" model = keras.Sequential()\n",
" model.add(LSTM(hp.Int('input_unit',min_value=32,max_value=512,step=32),return_sequences=True, input_shape=(30,6)))\n",
" for i in range(hp.Int('n_layers', 1, 4)):\n",
" model.add(LSTM(hp.Int(f'lstm_{i}_units',min_value=32,max_value=512,step=32),return_sequences=True))\n",
" model.add(LSTM(hp.Int('layer_2_neurons',min_value=32,max_value=512,step=32)))\n",
" model.add(Dropout(hp.Float('Dropout_rate',min_value=0,max_value=0.5,step=0.1)))\n",
" model.add(Dense(6, activation='linear'))\n",
" model.compile(\n",
" optimizer=keras.optimizers.Adam(\n",
" hp.Choice('learning_rate', [1e-2, 1e-3, 1e-4])),\n",
" loss='mean_absolute_error',\n",
" metrics=['mean_absolute_error'])\n",
" return model\n",
"\n",
" def fit(self, hp, model, *args, **kwargs):\n",
" return model.fit(\n",
" *args,\n",
" batch_size=hp.Choice(\"batch_size\", [16, 32, 64, 128]),\n",
" **kwargs,\n",
" )\n",
"\n",
"tuner = kt.BayesianOptimization(\n",
" MyHyperModel(),\n",
" objective=\"val_mean_absolute_error\",\n",
" max_trials=10,\n",
" executions_per_trial=2,\n",
" overwrite=True,\n",
" directory=\"my_dir\",\n",
" project_name=\"tune_hypermodel\",\n",
")\n",
"\n",
"early_stopping_monitor = EarlyStopping(\n",
" monitor='val_mean_absolute_error',\n",
" patience=40,\n",
" min_delta=0.001,\n",
" restore_best_weights=True,\n",
" verbose=1\n",
")\n",
"\n",
"\n",
"def cross_validate(X, y, n_splits=3):\n",
" tscv = TimeSeriesSplit(n_splits=n_splits)\n",
" for train_index, val_index in tscv.split(X):\n",
" X_train_fold, X_val_fold = X[train_index], X[val_index]\n",
" y_train_fold, y_val_fold = y[train_index], y[val_index]\n",
" tuner.search(\n",
" X_train_fold, y_train_fold, epochs=100,\n",
" validation_data=(X_val_fold, y_val_fold),\n",
" callbacks=[early_stopping_monitor]\n",
" )\n",
"\n",
"\n",
"# Call to perform cross-validation\n",
"cross_validate(X_train, y_train, n_splits=3)"
],
"metadata": {
"id": "5w9dcLPYaWRh"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Get the best hyperparameters\n",
"best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]\n",
"\n",
"# Print the best hyperparameters\n",
"print(\"The best hyperparameters are:\")\n",
"print(f\"Input LSTM units: {best_hps.get('input_unit')}\")\n",
"print(f\"Number of LSTM layers: {best_hps.get('n_layers') + 2}\") # includes input and final LSTM layers\n",
"for i in range(best_hps.get('n_layers')):\n",
" print(f\"LSTM units in layer {i+1}: {best_hps.get(f'lstm_{i}_units')}\")\n",
"print(f\"Final LSTM layer units: {best_hps.get('layer_2_neurons')}\")\n",
"print(f\"Dropout rate: {best_hps.get('Dropout_rate')}\")\n",
"print(f\"Learning rate: {best_hps.get('learning_rate')}\")\n",
"print(f\"Batch size: {best_hps.get('batch_size')}\")"
],
"metadata": {
"id": "nDF_CsN0anZU"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Build the model with the best hyperparameters\n",
"model = tuner.hypermodel.build(best_hps)\n",
"\n",
"# Training the model with the full training dataset\n",
"history = model.fit(\n",
" X_train, y_train,\n",
" epochs=100,\n",
" batch_size=best_hps.get('batch_size'),\n",
" callbacks=[early_stopping_monitor]\n",
")"
],
"metadata": {
"id": "8J4cZ1Ljavb1"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Predicting on unseen data\n",
"predictions = model.predict(X_test)"
],
"metadata": {
"id": "egcURJ9gax6T"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"temp_preds, hum_preds, wind_preds, pres_preds, waveH_preds, waveP_preds = predictions[:, 0], predictions[:, 1], predictions[:, 2], predictions[:, 3], predictions[:, 4], predictions[:, 5]\n",
"temp_actuals, hum_actuals, wind_actuals, pres_actuals, waveH_actuals, waveP_actuals = y_test[:, 0], y_test[:, 1], y_test[:, 2], y_test[:, 3], y_test[:, 4], y_test[:, 5]\n",
"\n",
"df_prediction = pd.DataFrame(data={'Temperature Predictions': temp_preds, 'Temperature Actuals':temp_actuals,\n",
" 'Humidity Predictions': hum_preds, 'Humidity Actuals':hum_actuals,\n",
" 'Wind speed Predictions': wind_preds, 'Wind speed Actuals': wind_actuals,\n",
" 'Pressure Predictions': pres_preds, 'Pressure Actuals': pres_actuals,\n",
" 'Wave height Predictions': waveH_preds, 'Wave height Actuals': waveH_actuals,\n",
" 'Wave period Predictions': waveP_preds, 'Wave period Actuals': waveP_actuals,\n",
"\n",
" })"
],
"metadata": {
"id": "kM9LC1Yya1O3"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"df_prediction.head()"
],
"metadata": {
"id": "-3BnA6wDa5fR"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"def postprocess_temp(arr):\n",
" arr = (arr*temp_training_std) + temp_training_mean\n",
" return arr\n",
"\n",
"def postprocess_hum(arr):\n",
" arr = (arr*hum_training_std) + hum_training_mean\n",
" return arr\n",
"\n",
"def postprocess_wind(arr):\n",
" arr = (arr*wind_training_std) + wind_training_mean\n",
" return arr\n",
"\n",
"def postprocess_pres(arr):\n",
" arr = (arr*pres_training_std) + pres_training_mean\n",
" return arr\n",
"\n",
"def postprocess_waveH(arr):\n",
" arr = (arr*waveH_training_std) + waveH_training_mean\n",
" return arr\n",
"\n",
"def postprocess_waveP(arr):\n",
" arr = (arr*waveP_training_std) + waveP_training_mean\n",
" return arr"
],
"metadata": {
"id": "eumTKioMa8jv"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"temp_preds1, hum_preds1, wind_preds1, pres_preds1, waveH_preds1, waveP_preds1 = postprocess_temp(predictions[:, 0]), postprocess_hum(predictions[:, 1]), postprocess_wind(predictions[:, 2]), postprocess_pres(predictions[:, 3]), postprocess_waveH(predictions[:, 4]), postprocess_waveP(predictions[:, 5])\n",
"\n",
"temp_actuals1, hum_actuals1, wind_actuals1, pres_actuals1, waveH_actuals1, waveP_actuals1 = postprocess_temp(y_test[:, 0]), postprocess_hum(y_test[:, 1]), postprocess_wind(y_test[:, 2]), postprocess_pres(y_test[:, 3]), postprocess_waveH(y_test[:, 4]), postprocess_waveP(y_test[:, 5])\n",
"\n",
"\n",
"df_prediction1 = pd.DataFrame(data={'Temperature Predictions': temp_preds1, 'Temperature Actuals':temp_actuals1,\n",
" 'Humidity Predictions': hum_preds1, 'Humidity Actuals':hum_actuals1,\n",
" 'Wind speed Predictions': wind_preds1, 'Wind speed Actuals': wind_actuals1,\n",
" 'Pressure Predictions': pres_preds1, 'Pressure Actuals': pres_actuals1,\n",
" 'Wave height Predictions': waveH_preds1, 'Wave height Actuals': waveH_actuals1,\n",
" 'Wave period Predictions': waveP_preds1, 'Wave period Actuals': waveP_actuals1\n",
" })"
],
"metadata": {
"id": "Kddls-51bA8a"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"df_prediction1"
],
"metadata": {
"id": "FYka8inTbE6o"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Temperature prediction\n",
"plt.figure(figsize=(20, 8))\n",
"plt.plot(df[7311:].index, df_prediction1['Temperature Actuals'], label=\"Actual Temperature\")\n",
"plt.plot(df[7311:].index, df_prediction1['Temperature Predictions'], label=\"Prediction\")\n",
"plt.legend(loc='best', fontsize='large')\n",
"plt.xticks(fontsize=18)\n",
"plt.yticks(fontsize=16)\n",
"plt.xlabel(\"Date time\")\n",
"plt.ylabel(\"Temperature\")\n",
"plt.show()"
],
"metadata": {
"id": "9reHq2oubIgz"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Wave height prediction\n",
"plt.figure(figsize=(20, 8))\n",
"plt.plot(df[7311:].index, df_prediction1['Wave height Actuals'], label=\"Actual Wave height\")\n",
"plt.plot(df[7311:].index, df_prediction1['Wave height Predictions'], label=\"Prediction\")\n",
"plt.legend(loc='best', fontsize='large')\n",
"plt.xticks(fontsize=18)\n",
"plt.yticks(fontsize=16)\n",
"plt.xlabel(\"Date time\")\n",
"plt.ylabel(\"Wave height\")\n",
"plt.show()"
],
"metadata": {
"id": "HHdYpjgobMBb"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Waind speed prediction\n",
"plt.figure(figsize=(20, 8))\n",
"plt.plot(df[7311:].index, df_prediction1['Wind speed Actuals'], label=\"Actual Wind speed\")\n",
"plt.plot(df[7311:].index, df_prediction1['Wind speed Predictions'], label=\"Prediction\")\n",
"plt.legend(loc='best', fontsize='large')\n",
"plt.xticks(fontsize=18)\n",
"plt.yticks(fontsize=16)\n",
"plt.xlabel(\"Date time\")\n",
"plt.ylabel(\"Wind speed\")\n",
"plt.show()"
],
"metadata": {
"id": "IbzM6Grfby-w"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Pressure prediction\n",
"plt.figure(figsize=(20, 8))\n",
"plt.plot(df[7311:].index, df_prediction1['Pressure Actuals'], label=\"Actual Pressure\")\n",
"plt.plot(df[7311:].index, df_prediction1['Pressure Predictions'], label=\"Prediction\")\n",
"plt.legend(loc='best', fontsize='large')\n",
"plt.xticks(fontsize=18)\n",
"plt.yticks(fontsize=16)\n",
"plt.xlabel(\"Date time\")\n",
"plt.ylabel(\"Pressure\")\n",
"plt.show()"
],
"metadata": {
"id": "nIpoIK5zbz1t"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Humidity prediction\n",
"plt.figure(figsize=(20, 8))\n",
"plt.plot(df[7311:].index, df_prediction1['Humidity Actuals'], label=\"Actual Humidity\")\n",
"plt.plot(df[7311:].index, df_prediction1['Humidity Predictions'], label=\"Prediction\")\n",
"plt.legend(loc='best', fontsize='large')\n",
"plt.xticks(fontsize=18)\n",
"plt.yticks(fontsize=16)\n",
"plt.xlabel(\"Date time\")\n",
"plt.ylabel(\"Humidity\")\n",
"plt.show()"
],
"metadata": {
"id": "H7e0_3Dob3EA"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Wave period prediction\n",
"plt.figure(figsize=(20, 8))\n",
"plt.plot(df[7311:].index, df_prediction1['Wave period Actuals'], label=\"Actual Wave period\")\n",
"plt.plot(df[7311:].index, df_prediction1['Wave period Predictions'], label=\"Prediction\")\n",
"plt.legend(loc='best', fontsize='large')\n",
"plt.xticks(fontsize=18)\n",
"plt.yticks(fontsize=16)\n",
"plt.xlabel(\"Date time\")\n",
"plt.ylabel(\"Wave period\")\n",
"plt.show()"
],
"metadata": {
"id": "zlqGG3UPb6Nq"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score\n",
"from scipy import stats\n",
"\n",
"# Function to calculate Mean Absolute Percentage Error\n",
"def mean_absolute_percentage_error(y_true, y_pred):\n",
" y_true, y_pred = np.array(y_true), np.array(y_pred)\n",
" return np.mean(np.abs((y_true - y_pred) / y_true)) * 100\n",
"\n",
"# Calculate performance metrics\n",
"def calculate_metrics(y_true, y_pred, variable_name):\n",
" mae = mean_absolute_error(y_true, y_pred)\n",
" mse = mean_squared_error(y_true, y_pred)\n",
" rmse = np.sqrt(mse)\n",
" mape = mean_absolute_percentage_error(y_true, y_pred)\n",
" r2 = r2_score(y_true, y_pred)\n",
" correlation, p_value = stats.pearsonr(y_true, y_pred)\n",
"\n",
" print(f'{variable_name} Metrics:')\n",
" print(f'Mean Absolute Error: {mae:.4f}')\n",
" print(f'Mean Squared Error: {mse:.4f}')\n",
" print(f'Root Mean Squared Error: {rmse:.4f}')\n",
" print(f'Mean Absolute Percentage Error: {mape:.2f}%')\n",
" print(f'R2 Score (Coefficient of Determination): {r2:.4f}')\n",
" print(f'Pearson Correlation Coefficient: {correlation:.4f}')\n",
" print(f'P-value of Correlation Coefficient: {p_value:.4g}')\n",
" print(\"\\n\")\n",
"\n",
"# Extract the relevant columns\n",
"predicted_temperature = df_prediction1['Temperature Predictions']\n",
"actual_temperature = df_prediction1['Temperature Actuals']\n",
"\n",
"predicted_humidity = df_prediction1['Humidity Predictions']\n",
"actual_humidity = df_prediction1['Humidity Actuals']\n",
"\n",
"predicted_wind_speed = df_prediction1['Wind speed Predictions']\n",
"actual_wind_speed = df_prediction1['Wind speed Actuals']\n",
"\n",
"predicted_pressure = df_prediction1['Pressure Predictions']\n",
"actual_pressure = df_prediction1['Pressure Actuals']\n",
"\n",
"predicted_wave_height = df_prediction1['Wave height Predictions']\n",
"actual_wave_height = df_prediction1['Wave height Actuals']\n",
"\n",
"predicted_period = df_prediction1['Wave period Predictions']\n",
"actual_period = df_prediction1['Wave period Actuals']\n",
"\n",
"# Calculate metrics for temperature\n",
"calculate_metrics(actual_temperature, predicted_temperature, 'Temperature')\n",
"\n",
"# Calculate metrics for Humidity\n",
"calculate_metrics(actual_humidity, predicted_humidity, 'Humidity')\n",
"\n",
"# Calculate metrics for Wind speed\n",
"calculate_metrics(actual_wind_speed, predicted_wind_speed, 'Wind Speed')\n",
"\n",
"# Calculate metrics for Pressure\n",
"calculate_metrics(actual_pressure, predicted_pressure, 'Pressure')\n",
"\n",
"# Calculate metrics for Wave height\n",
"calculate_metrics(actual_wave_height, predicted_wave_height, 'Wave Height')\n",
"\n",
"# Calculate metrics for Wave period\n",
"calculate_metrics(actual_period, predicted_period, 'Wave Period')"
],
"metadata": {
"id": "Gcdxlm7Xb_Mj"
},
"execution_count": null,
"outputs": []
}
]
}