diff --git "a/notebooks/weather_classification.ipynb" "b/notebooks/weather_classification.ipynb"
new file mode 100755--- /dev/null
+++ "b/notebooks/weather_classification.ipynb"
@@ -0,0 +1,10562 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 136,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "import seaborn as sns\n",
+ "import plotly.express as px\n",
+ "import plotly.graph_objects as go\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.preprocessing import MinMaxScaler, OrdinalEncoder\n",
+ "from sklearn.metrics import mean_squared_error\n",
+ "from sklearn.ensemble import RandomForestClassifier\n",
+ "import torch\n",
+ "import torch.nn as nn\n",
+ "import math, time, pickle\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " date | \n",
+ " precipitation | \n",
+ " temp_max | \n",
+ " temp_min | \n",
+ " wind | \n",
+ " weather | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 | \n",
+ " 2012-01-01 | \n",
+ " 0.0 | \n",
+ " 12.8 | \n",
+ " 5.0 | \n",
+ " 4.7 | \n",
+ " drizzle | \n",
+ "
\n",
+ " \n",
+ " 1 | \n",
+ " 2012-01-02 | \n",
+ " 10.9 | \n",
+ " 10.6 | \n",
+ " 2.8 | \n",
+ " 4.5 | \n",
+ " rain | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 2012-01-03 | \n",
+ " 0.8 | \n",
+ " 11.7 | \n",
+ " 7.2 | \n",
+ " 2.3 | \n",
+ " rain | \n",
+ "
\n",
+ " \n",
+ " 3 | \n",
+ " 2012-01-04 | \n",
+ " 20.3 | \n",
+ " 12.2 | \n",
+ " 5.6 | \n",
+ " 4.7 | \n",
+ " rain | \n",
+ "
\n",
+ " \n",
+ " 4 | \n",
+ " 2012-01-05 | \n",
+ " 1.3 | \n",
+ " 8.9 | \n",
+ " 2.8 | \n",
+ " 6.1 | \n",
+ " rain | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " date precipitation temp_max temp_min wind weather\n",
+ "0 2012-01-01 0.0 12.8 5.0 4.7 drizzle\n",
+ "1 2012-01-02 10.9 10.6 2.8 4.5 rain\n",
+ "2 2012-01-03 0.8 11.7 7.2 2.3 rain\n",
+ "3 2012-01-04 20.3 12.2 5.6 4.7 rain\n",
+ "4 2012-01-05 1.3 8.9 2.8 6.1 rain"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df = pd.read_csv(\"./data/seattle-weather.csv\")\n",
+ "df = df.sort_values('date')\n",
+ "df.head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Number of columns with NaNs: 0\n",
+ "Weather Outcomes: ['drizzle' 'rain' 'sun' 'snow' 'fog']\n",
+ "Outcome Distribution: \n",
+ "weather\n",
+ "rain 641\n",
+ "sun 640\n",
+ "fog 101\n",
+ "drizzle 53\n",
+ "snow 26\n",
+ "Name: count, dtype: int64\n"
+ ]
+ }
+ ],
+ "source": [
+ "nans = df.isnull().sum()\n",
+ "print(f\"Number of columns with NaNs: {len(nans[nans > 0])}\")\n",
+ "print(f\"Weather Outcomes: {df['weather'].unique()}\")\n",
+ "print(f\"Outcome Distribution: \\n{df['weather'].value_counts()}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " precipitation temp_max temp_min wind\n",
+ "precipitation 1.000000 -0.228555 -0.072684 0.328045\n",
+ "temp_max -0.228555 1.000000 0.875687 -0.164857\n",
+ "temp_min -0.072684 0.875687 1.000000 -0.074185\n",
+ "wind 0.328045 -0.164857 -0.074185 1.000000\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Now calculate the correlation matrix\n",
+ "corr = df.corr(numeric_only = True)\n",
+ "print(corr)\n",
+ "\n",
+ "# plt.figure(figsize =(15, 12))\n",
+ "# sns.heatmap(corr)\n",
+ "# plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "count 1461.000000\n",
+ "mean 3.029432\n",
+ "std 6.680194\n",
+ "min 0.000000\n",
+ "25% 0.000000\n",
+ "50% 0.000000\n",
+ "75% 2.800000\n",
+ "max 55.900000\n",
+ "Name: precipitation, dtype: float64"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df['precipitation'].describe()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "count 1461.000000\n",
+ "mean 8.234771\n",
+ "std 5.023004\n",
+ "min -7.100000\n",
+ "25% 4.400000\n",
+ "50% 8.300000\n",
+ "75% 12.200000\n",
+ "max 18.300000\n",
+ "Name: temp_min, dtype: float64"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df['temp_min'].describe()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "count 1461.000000\n",
+ "mean 16.439083\n",
+ "std 7.349758\n",
+ "min -1.600000\n",
+ "25% 10.600000\n",
+ "50% 15.600000\n",
+ "75% 22.200000\n",
+ "max 35.600000\n",
+ "Name: temp_max, dtype: float64"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df['temp_max'].describe()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "count 1461.000000\n",
+ "mean 3.241136\n",
+ "std 1.437825\n",
+ "min 0.400000\n",
+ "25% 2.200000\n",
+ "50% 3.000000\n",
+ "75% 4.000000\n",
+ "max 9.500000\n",
+ "Name: wind, dtype: float64"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df['wind'].describe()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sns.set_style(\"darkgrid\")\n",
+ "plt.figure(figsize = (15,9))\n",
+ "plt.plot(df['temp_max'], label = 'Temp Max')\n",
+ "plt.plot(df['temp_min'], label = 'Temp Min')\n",
+ "plt.xticks(range(0,df.shape[0],500),df['date'].loc[::500],rotation=45)\n",
+ "plt.title(\"Historical Temperature\",fontsize=18, fontweight='bold')\n",
+ "plt.xlabel('Date',fontsize=18)\n",
+ "plt.ylabel('Temperature (C)',fontsize=18)\n",
+ "plt.legend()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sns.set_style(\"darkgrid\")\n",
+ "plt.figure(figsize = (15,9))\n",
+ "plt.plot(df['precipitation'])\n",
+ "plt.xticks(range(0,df.shape[0],500),df['date'].loc[::500],rotation=45)\n",
+ "plt.title(\"Historical Precipitation\",fontsize=18, fontweight='bold')\n",
+ "plt.xlabel('Date',fontsize=18)\n",
+ "plt.ylabel('Precipitation (mm)',fontsize=18)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sns.set_style(\"darkgrid\")\n",
+ "plt.figure(figsize = (15,9))\n",
+ "plt.plot(df['wind'])\n",
+ "plt.xticks(range(0,df.shape[0],500),df['date'].loc[::500],rotation=45)\n",
+ "plt.title(\"Historical Wind\",fontsize=18, fontweight='bold')\n",
+ "plt.xlabel('Date',fontsize=18)\n",
+ "plt.ylabel('Wind (m/s)',fontsize=18)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(1168, 4) (293, 4)\n",
+ "(1168,) (293,)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Target variable and train set\n",
+ "oe = OrdinalEncoder()\n",
+ "oe.fit(df[['weather']])\n",
+ "df['weather_ordinal'] = oe.transform(df[['weather']])\n",
+ "\n",
+ "y = df['weather_ordinal'].copy()\n",
+ "X = df.copy().drop('weather_ordinal', axis = 1)\n",
+ "X = X.drop('weather', axis = 1)\n",
+ "X = X.drop('date', axis = 1)\n",
+ "\n",
+ "# Create and fit MinMaxScaler\n",
+ "mmscaler = MinMaxScaler()\n",
+ "sc = mmscaler.fit(X)\n",
+ "\n",
+ "# Scale input features\n",
+ "X = sc.transform(X)\n",
+ "\n",
+ "# Split test and train data \n",
+ "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)\n",
+ "print(X_train.shape, X_test.shape)\n",
+ "print(y_train.shape, y_test.shape)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "n_estimators = 10, Train accuracy = 0.9914383561643836, Test accuracy = 0.78839590443686\n",
+ "n_estimators = 15, Train accuracy = 0.9914383561643836, Test accuracy = 0.8156996587030717\n",
+ "n_estimators = 20, Train accuracy = 0.9931506849315068, Test accuracy = 0.8156996587030717\n",
+ "n_estimators = 25, Train accuracy = 0.9931506849315068, Test accuracy = 0.825938566552901\n",
+ "n_estimators = 30, Train accuracy = 0.9948630136986302, Test accuracy = 0.8191126279863481\n",
+ "n_estimators = 35, Train accuracy = 0.9965753424657534, Test accuracy = 0.825938566552901\n",
+ "n_estimators = 40, Train accuracy = 0.9957191780821918, Test accuracy = 0.8191126279863481\n",
+ "n_estimators = 45, Train accuracy = 0.9965753424657534, Test accuracy = 0.8293515358361775\n",
+ "n_estimators = 50, Train accuracy = 0.9965753424657534, Test accuracy = 0.8225255972696246\n",
+ "n_estimators = 55, Train accuracy = 0.9965753424657534, Test accuracy = 0.8225255972696246\n",
+ "n_estimators = 60, Train accuracy = 0.9965753424657534, Test accuracy = 0.825938566552901\n",
+ "n_estimators = 65, Train accuracy = 0.997431506849315, Test accuracy = 0.8225255972696246\n",
+ "n_estimators = 70, Train accuracy = 0.997431506849315, Test accuracy = 0.8191126279863481\n",
+ "n_estimators = 75, Train accuracy = 0.997431506849315, Test accuracy = 0.825938566552901\n",
+ "n_estimators = 80, Train accuracy = 0.997431506849315, Test accuracy = 0.8191126279863481\n",
+ "n_estimators = 85, Train accuracy = 0.997431506849315, Test accuracy = 0.8191126279863481\n",
+ "n_estimators = 90, Train accuracy = 0.997431506849315, Test accuracy = 0.8191126279863481\n",
+ "n_estimators = 95, Train accuracy = 0.997431506849315, Test accuracy = 0.8122866894197952\n",
+ "n_estimators = 100, Train accuracy = 0.997431506849315, Test accuracy = 0.8156996587030717\n"
+ ]
+ }
+ ],
+ "source": [
+ "for n in range(10, 105, 5):\n",
+ " r = RandomForestClassifier(n_estimators = n, random_state = 42)\n",
+ " r.fit(X_train, y_train)\n",
+ " train_score = r.score(X_train, y_train)\n",
+ " test_score = r.score(X_test, y_test)\n",
+ " print(f\"n_estimators = {n}, Train accuracy = {train_score}, Test accuracy = {test_score}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Train score is: 0.9965753424657534\n",
+ "Test score is: 0.8293515358361775\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Random Forest\n",
+ "rfc = RandomForestClassifier(n_estimators = 45, random_state = 42)\n",
+ "rfc.fit(X_train, y_train)\n",
+ "print(f\"Train score is: {rfc.score(X_train, y_train)}\")\n",
+ "print(f\"Test score is: {rfc.score(X_test, y_test)}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[0.06, 0.6, 0.94, 0.1]\n",
+ "[2.]\n",
+ "['rain']\n"
+ ]
+ }
+ ],
+ "source": [
+ "# These values are close to the prediction for rain\n",
+ "X_new = [[0.06, 0.6, 0.94, 0.1]]\n",
+ "y_new = [rfc.predict(X_new)]\n",
+ "print(X_new[0])\n",
+ "print(y_new[0])\n",
+ "print(oe.inverse_transform(y_new)[0])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Create lookup for weather\n",
+ "images = {'drizzle': 'assets/drizzle.png', 'rain': 'assets/rain.png', 'sun': 'assets/sun.png', 'snow': 'assets/snow.png', 'fog': 'assets/fog.png'}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Save Model\n",
+ "model_file = open('weather_prediction_model.pkl', 'wb')\n",
+ "pickle.dump(rfc, model_file)\n",
+ "pickle.dump(oe, model_file)\n",
+ "pickle.dump(sc, model_file)\n",
+ "pickle.dump(images, model_file)\n",
+ "model_file.close()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# GRU Model Class\n",
+ "class GRU(nn.Module):\n",
+ " def __init__(self, input_dim, hidden_dim, num_layers, output_dim):\n",
+ " super(GRU, self).__init__()\n",
+ " self.hidden_dim = hidden_dim\n",
+ " self.num_layers = num_layers\n",
+ " \n",
+ " self.gru = nn.GRU(input_dim, hidden_dim, num_layers, batch_first=True)\n",
+ " self.fc = nn.Linear(hidden_dim, output_dim)\n",
+ "\n",
+ " def forward(self, x):\n",
+ " h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_dim).requires_grad_()\n",
+ " out, (hn) = self.gru(x, (h0.detach()))\n",
+ " out = self.fc(out[:, -1, :]) \n",
+ " return out"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def split_data(stock, lookback):\n",
+ " data_raw = np.array(stock) # convert to numpy array\n",
+ " data = []\n",
+ " \n",
+ " # create all possible sequences of length seq_len\n",
+ " for index in range(len(data_raw) - lookback): \n",
+ " data.append(data_raw[index: index + lookback])\n",
+ " \n",
+ " data = np.array(data);\n",
+ " test_set_size = int(np.round(0.2*data.shape[0]));\n",
+ " train_set_size = data.shape[0] - (test_set_size);\n",
+ " \n",
+ " X_train = data[:train_set_size,:-1,:]\n",
+ " y_train = data[:train_set_size,-1,:]\n",
+ " \n",
+ " X_test = data[train_set_size:,:-1]\n",
+ " y_test = data[train_set_size:,-1,:]\n",
+ " \n",
+ " return [X_train, y_train, X_test, y_test]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 146,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "precipitation = df['precipitation']\n",
+ "precip_scaler = MinMaxScaler(feature_range=(0, 1))\n",
+ "precipitation = precip_scaler.fit_transform(precipitation.values.reshape(-1,1))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_max = df['temp_max']\n",
+ "temp_max_scaler = MinMaxScaler(feature_range=(0, 1))\n",
+ "temp_max = temp_max_scaler.fit_transform(temp_max.values.reshape(-1,1))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_min = df['temp_min']\n",
+ "temp_min_scaler = MinMaxScaler(feature_range=(0, 1))\n",
+ "temp_min = temp_min_scaler.fit_transform(temp_min.values.reshape(-1,1))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "wind = df['wind']\n",
+ "wind_scaler = MinMaxScaler(feature_range=(0, 1))\n",
+ "wind = wind_scaler.fit_transform(wind.values.reshape(-1,1))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 158,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "X_train.shape = (1163, 6, 1)\n",
+ "y_train.shape = (1163, 1)\n",
+ "X_test.shape = (291, 6, 1)\n",
+ "y_test.shape = (291, 1)\n"
+ ]
+ }
+ ],
+ "source": [
+ "lookback = 7 # choose sequence length\n",
+ "X_train, y_train, X_test, y_test = split_data(precipitation, lookback)\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)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 159,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "X_train = torch.from_numpy(X_train).type(torch.Tensor)\n",
+ "X_test = torch.from_numpy(X_test).type(torch.Tensor)\n",
+ "y_train_gru = torch.from_numpy(y_train).type(torch.Tensor)\n",
+ "y_test_gru = torch.from_numpy(y_test).type(torch.Tensor)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 160,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "input_dim = 1\n",
+ "hidden_dim = 32\n",
+ "num_layers = 4\n",
+ "output_dim = 1\n",
+ "num_epochs = 1000"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "GRU does not appear to model precipitation properly, may have to consider a different approach\n",
+ "- Verify if it works for other properties (i.e. Temperature and Wind)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 161,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model = GRU(input_dim = input_dim, hidden_dim = hidden_dim, output_dim = output_dim, num_layers = num_layers)\n",
+ "criterion = torch.nn.MSELoss(reduction = 'mean')\n",
+ "optimiser = torch.optim.Adam(model.parameters(), lr = 0.001)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 162,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "MSE: 0.043952811509370804\n",
+ "Training time: 29.618263006210327\n"
+ ]
+ }
+ ],
+ "source": [
+ "hist = np.zeros(num_epochs)\n",
+ "start_time = time.time()\n",
+ "gru = []\n",
+ "\n",
+ "for t in range(num_epochs):\n",
+ " y_train_pred = model(X_train)\n",
+ "\n",
+ " loss = criterion(y_train_pred, y_train_gru)\n",
+ " # print(f\"Epoch {t}, MSE: {loss.item()}\")\n",
+ " hist[t] = loss.item()\n",
+ "\n",
+ " optimiser.zero_grad()\n",
+ " loss.backward()\n",
+ " optimiser.step()\n",
+ "\n",
+ "training_time = time.time() - start_time \n",
+ "print(f\"MSE: {hist[-1]}\")\n",
+ "print(f\"Training time: {training_time}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 163,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "predict = pd.DataFrame(precip_scaler.inverse_transform(y_train_pred.detach().numpy()))\n",
+ "original = pd.DataFrame(precip_scaler.inverse_transform(y_train_gru.detach().numpy()))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 164,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "