beach_lstm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR: Could not find a version that satisfies the requirement tensorflow-gpu==2.10 (from versions: 2.12.0)\n",
      "ERROR: No matching distribution found for tensorflow-gpu==2.10\n"
     ]
    }
   ],
   "source": [
    "conda install -c conda-forge cudatoolkit=11.2 cudnn=8.1.0\n",
    "# Anything above 2.10 is not supported on the GPU on Windows Native\n",
    "python -m pip install \"tensorflow<2.11\"\n",
    "# Verify the installation:\n",
    "python -c \"import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'keras'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\24\\Desktop\\Scraper\\scuba_scrapper\\beach_lstm.ipynb Cell 4\u001b[0m line \u001b[0;36m9\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/24/Desktop/Scraper/scuba_scrapper/beach_lstm.ipynb#W2sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mfunctions\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mchecks_and_preprocessing\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mlagging_and_splitting\u001b[39;00m \u001b[39mimport\u001b[39;00m split_dataframe, sliding_window\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/24/Desktop/Scraper/scuba_scrapper/beach_lstm.ipynb#W2sZmlsZQ%3D%3D?line=7'>8</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mfunctions\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmodels\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mbaseline_models\u001b[39;00m \u001b[39mimport\u001b[39;00m persistence_with_lag_model, vecm_baseline_model\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/24/Desktop/Scraper/scuba_scrapper/beach_lstm.ipynb#W2sZmlsZQ%3D%3D?line=8'>9</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mfunctions\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmodels\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mbuild_test_model\u001b[39;00m \u001b[39mimport\u001b[39;00m generate_models, train_model, get_best_model\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/24/Desktop/Scraper/scuba_scrapper/beach_lstm.ipynb#W2sZmlsZQ%3D%3D?line=9'>10</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mfunctions\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmodels\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39msave_load_model\u001b[39;00m \u001b[39mimport\u001b[39;00m save_models\u001b[39m#, load_models\u001b[39;00m\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/24/Desktop/Scraper/scuba_scrapper/beach_lstm.ipynb#W2sZmlsZQ%3D%3D?line=10'>11</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mfunctions\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdata_load_and_transform\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39msql_connections\u001b[39;00m \u001b[39mimport\u001b[39;00m get_database_connector, get_beach_data\n",
      "File \u001b[1;32mc:\\Users\\24\\Desktop\\Scraper\\scuba_scrapper\\functions\\models\\build_test_model.py:5\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mtime\u001b[39;00m\n\u001b[0;32m      3\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtyping\u001b[39;00m \u001b[39mimport\u001b[39;00m Dict, Any\n\u001b[1;32m----> 5\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mkeras\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcallbacks\u001b[39;00m \u001b[39mimport\u001b[39;00m EarlyStopping, History, TensorBoard, ReduceLROnPlateau\n\u001b[0;32m      6\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mfunctions\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmodels\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mlstm_model\u001b[39;00m \u001b[39mimport\u001b[39;00m create_multiple_LSTM\n\u001b[0;32m      7\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mkeras\u001b[39;00m \u001b[39mimport\u001b[39;00m Model, backend \u001b[39mas\u001b[39;00m K\n",
      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'keras'"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pprint\n",
    "\n",
    "\n",
    "from functions.checks_and_preprocessing.lagging_and_splitting import split_dataframe, sliding_window\n",
    "from functions.models.baseline_models import persistence_with_lag_model, vecm_baseline_model\n",
    "from functions.models.build_test_model import generate_models, train_model, get_best_model\n",
    "from functions.models.save_load_model import save_models#, load_models\n",
    "from functions.data_load_and_transform.sql_connections import get_database_connector, get_beach_data\n",
    "from functions.plotting.forecast_plot import plot_forecast, plot_predictions\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.metrics import mean_squared_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale_data(train: np.ndarray, valid: np.ndarray, test: np.ndarray, scaler_type: str) -> tuple:\n",
    "    \"\"\"\n",
    "    Function to scale data using either MinMaxScaler or StandardScaler.\n",
    "\n",
    "    Parameters:\n",
    "    train (np.ndarray): Training data to be scaled.\n",
    "    valid (np.ndarray): Validation data to be scaled.\n",
    "    test (np.ndarray): Test data to be scaled.\n",
    "    scaler_type (str): Type of scaler to use. Choose either 'minmax' or 'standard'.\n",
    "\n",
    "    Returns:\n",
    "    tuple: Scaled training, validation and test data as numpy np.ndarray, and the fitted scaler.\n",
    "    \"\"\"\n",
    "    \n",
    "    if scaler_type == 'minmax':\n",
    "        scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "    elif scaler_type == 'standard':\n",
    "        scaler = StandardScaler()\n",
    "    else:\n",
    "        return \"Invalid scaler type. Choose either 'minmax' or 'standard'.\" # type: ignore\n",
    "\n",
    "    train_scaled = scaler.fit_transform(train)\n",
    "    valid_scaled = scaler.transform(valid)\n",
    "    test_scaled = scaler.transform(test)\n",
    "\n",
    "    return train_scaled, valid_scaled, test_scaled, scaler \n",
    "\n",
    "def inverse_scale_data(scaler, *arrays):\n",
    "    \"\"\"\n",
    "    Function to inverse scale data using a fitted scaler.\n",
    "\n",
    "    Parameters:\n",
    "    scaler: The fitted scaler used for the original scaling.\n",
    "    *arrays (np.ndarray): Scaled data arrays to be inverse transformed.\n",
    "\n",
    "    Returns:\n",
    "    tuple: Original unscaled data as numpy np.ndarray.\n",
    "    \"\"\"\n",
    "    \n",
    "    return tuple(scaler.inverse_transform(array) for array in arrays)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "single_beach_data, _ = get_beach_data(get_database_connector())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the data in appropriate time format\n",
    "single_beach_data_h = single_beach_data.resample(\"D\").mean()\n",
    "column_names = list(single_beach_data_h.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train, valid, test, test_index = split_dataframe(single_beach_data_h)\n",
    "features = len(single_beach_data_h.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_scaled, valid_scaled, test_scaled, scaler = scale_data(train, valid, test, 'minmax')\n",
    "#train_scaled, valid_scaled, test_scaled = scale_data(train, valid, test, 'standard')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "window_size = 365\n",
    "\n",
    "trainX, trainY = sliding_window(train_scaled, window_size)\n",
    "valX, valY = sliding_window(valid_scaled, window_size)\n",
    "testX, testY = sliding_window(test_scaled, window_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "persistance_rmse_dict, persistance_rmse_total, persistance_valid_predictions= persistence_with_lag_model(dataset=valid_scaled, window_size=window_size, lag=1, column_names=column_names)\n",
    "np.set_printoptions(precision=3, suppress=True)\n",
    "print(f'Validation RMSE for each feature:')\n",
    "pprint.pprint(persistance_rmse_dict, width=1)\n",
    "print(f'\\nTotal Validation RMSE: {persistance_rmse_total}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The plot will always be a lagged version of the validation data\n",
    "plot_predictions(valid_scaled, persistance_valid_predictions, column_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vecm_rmse_dict, total_vecm_rmse, vecm_valid_predictions = vecm_baseline_model(trainX, valX, column_names)\n",
    "np.set_printoptions(precision=3, suppress=True)\n",
    "print(f'Validation RMSE for each feature:')\n",
    "pprint.pprint(vecm_rmse_dict, width=1)\n",
    "print(f'\\nTotal Validation RMSE: {total_vecm_rmse}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_predictions(valid_scaled, vecm_valid_predictions, column_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def optimize_bayesian(window_size, layers, units, dropout):\n",
    "#     # Ensure the parameters are integers\n",
    "#     window_size = int(round(window_size))\n",
    "#     layers = int(round(layers))\n",
    "#     units = int(round(units))\n",
    "\n",
    "#     # Recreate the datasets with the new window size\n",
    "#     trainX, trainY = sliding_window(train_scaled, window_size)\n",
    "#     valX, valY = sliding_window(valid_scaled, window_size)\n",
    "\n",
    "#     # Generate models\n",
    "#     models = generate_models([layers], [units], window_size, features, [dropout])\n",
    "\n",
    "#     # Train models and get validation loss\n",
    "#     val_loss = []\n",
    "#     for model_info in models.values():\n",
    "#         history = train_model(model=model_info['model'], trainX=trainX, trainY=trainY, valX=valX, valY=valY, patience=5, use_tensorboard=True)\n",
    "#         val_loss.append(history.history['val_loss'][-1])\n",
    "\n",
    "#     # Return negative, because BO maximazise\n",
    "#     return -np.mean(val_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from bayes_opt import BayesianOptimization\n",
    "\n",
    "# # include +-0.5 per pbound to account for rounding errors\n",
    "# pbounds = {'window_size': (364.5, 365.5), 'layers': (2.5, 3.5), 'units': (256, 512), 'dropout': (0.1, 0.1)}\n",
    "\n",
    "# optimizer = BayesianOptimization(\n",
    "#     f=optimize_bayesian,\n",
    "#     pbounds=pbounds,\n",
    "#     random_state=24,\n",
    "# )\n",
    "\n",
    "# optimizer.maximize(\n",
    "#     init_points=5,\n",
    "#     n_iter=3,\n",
    "# )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#optimizer.max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print({k: int(round(v)) for k, v in optimizer.max['params'].items()})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# window_size = 365\n",
    "\n",
    "# trainX, trainY = sliding_window(train_scaled, window_size)\n",
    "# valX, valY = sliding_window(valid_scaled, window_size)\n",
    "# testX, testY = sliding_window(test_scaled, window_size)\n",
    "\n",
    "layers = [1]\n",
    "units = [512]\n",
    "dropout = [0.1]\n",
    "\n",
    "\n",
    "models = generate_models(layers=layers, units=units, window=window_size, features=features, dropout=dropout, use_attention=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for model_info in models.values():\n",
    "    model_info['history'] = train_model(model=model_info['model'], trainX=trainX, trainY=trainY, valX=valX, valY=valY, patience=5, use_tensorboard=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_model = get_best_model(models, metric='root_mean_squared_error')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_models(models, 'model_history/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_forecast(best_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_model = next(iter(best_model.values()))['model']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load_models(r'C:\\Users\\24\\Desktop\\Scraper\\scuba_scrapper\\model_history')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valX_predictions = selected_model.predict(valX)\n",
    "rmse_per_feature_val = np.sqrt(mean_squared_error(valY, valX_predictions, multioutput='raw_values'))\n",
    "basic_lstm_total_rmse_val = np.sqrt(mean_squared_error(valY, valX_predictions))\n",
    "basic_lstm_rmse_dict = dict(zip(column_names, rmse_per_feature_val))\n",
    "np.set_printoptions(precision=3, suppress=True)\n",
    "\n",
    "print('Validation RMSE for each feature:')\n",
    "pprint.pprint(basic_lstm_rmse_dict, width=1)\n",
    "print('\\nTotal Validation RMSE:')\n",
    "print(basic_lstm_total_rmse_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_rmse_difference(baseline_dict, test_dict, total_rmse_baseline, total_rmse_test):\n",
    "    \"\"\"\n",
    "    Calculates the RMSE difference between each feature and the total RMSE.\n",
    "\n",
    "    Parameters:\n",
    "    baseline_dict (Dict[str, float]): The first dictionary with the RMSE for each feature.\n",
    "    test_dict (Dict[str, float]): The second dictionary with the RMSE for each feature.\n",
    "    total_rmse_baseline (float): The total RMSE of the baseline model.\n",
    "    total_rmse_test (float): The total RMSE of the test model.\n",
    "\n",
    "    Returns:\n",
    "    Dict[str, float], float: A dictionary with the RMSE difference for each feature and the total RMSE difference.\n",
    "    \"\"\"\n",
    "\n",
    "    rmse_difference_dict = {}\n",
    "    \n",
    "    # Calculate the RMSE difference for each feature\n",
    "    for key in baseline_dict.keys():\n",
    "        rmse_difference_dict[key] = baseline_dict[key] - test_dict[key]\n",
    "    \n",
    "    # Calculate the total RMSE difference\n",
    "    total_difference = total_rmse_baseline - total_rmse_test\n",
    "\n",
    "    return rmse_difference_dict, total_difference\n",
    "\n",
    "rmse_difference_dict, total_difference = calculate_rmse_difference(persistance_rmse_dict, basic_lstm_rmse_dict, persistance_rmse_total, basic_lstm_total_rmse_val)\n",
    "\n",
    "print('RMSE difference for each feature:')\n",
    "pprint.pprint(rmse_difference_dict, width=1)\n",
    "\n",
    "# Print overall RMSE for each model and their difference\n",
    "print(f'RMSE for baseline model: {persistance_rmse_total}')\n",
    "print(f'RMSE for test model: {basic_lstm_total_rmse_val}')\n",
    "print(f'Difference in overall RMSE: {total_difference}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the file path\n",
    "file_path = 'C:\\\\Users\\\\24\\\\Desktop\\\\Scraper\\\\scuba_scrapper\\\\model_history\\\\model_options.csv'\n",
    "\n",
    "# Check if the file exists\n",
    "if not os.path.exists(file_path):\n",
    "    # If the file doesn't exist, create it with the column headers\n",
    "    df = pd.DataFrame(columns=['model_arch', 'RMSE for baseline model',\n",
    "                      'RMSE for test model', 'Difference in overall RMSE'])\n",
    "    df.to_csv(file_path, index=False)\n",
    "\n",
    "# Get the name of the best model\n",
    "best_model_dict = get_best_model(models)\n",
    "# This is the full model name, including the dropout value\n",
    "best_model_name = list(best_model_dict.keys())[0]\n",
    "\n",
    "# Create a new DataFrame with the RMSE values\n",
    "new_data = pd.DataFrame({\n",
    "    'model_arch': [best_model_name + \", \" + str(f'dropout {dropout}')],\n",
    "    'window_size': [window_size],\n",
    "    'RMSE for baseline model': [persistance_rmse_total],\n",
    "    'RMSE for test model': [basic_lstm_total_rmse_val],\n",
    "    'Difference in overall RMSE': [total_difference]\n",
    "})\n",
    "\n",
    "# Append the new data to the file\n",
    "new_data.to_csv(file_path, mode='a', header=False, index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valY_rescaled, valX_predictions_rescaled = inverse_scale_data(scaler, valY, valX_predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_predictions(valY_rescaled, valX_predictions_rescaled, column_names)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "scuba_map",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}