GDP_Forecast.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a29ee1b-e284-4ae1-b1af-9006d58f638d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ab167f2c-6443-4eef-889d-f02ca5104bda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            Nominal GDP prices (Ksh Million)  Annual GDP growth (%)  \\\n",
      "Year                                                                  \n",
      "2022-01-01                        13483003.0                    4.8   \n",
      "2021-01-01                        12027662.0                    7.6   \n",
      "2020-01-01                        10715070.0                   -0.3   \n",
      "2019-01-01                        10237727.0                    5.1   \n",
      "2018-01-01                         9340307.0                    5.6   \n",
      "2017-01-01                         8483396.0                    3.8   \n",
      "2016-01-01                         7594064.0                    4.2   \n",
      "2015-01-01                         6884317.0                    5.0   \n",
      "2014-01-01                         6003835.0                    5.0   \n",
      "2013-01-01                         5311322.0                    3.8   \n",
      "2012-01-01                         4767191.0                    4.6   \n",
      "2011-01-01                         4162514.0                    5.1   \n",
      "2010-01-01                         3597630.0                    8.1   \n",
      "2009-01-01                         3275642.0                    2.7   \n",
      "2008-01-01                         2107589.0                    1.5   \n",
      "2007-01-01                         1833511.0                    6.9   \n",
      "2006-01-01                         1622565.0                    6.5   \n",
      "2005-01-01                         1415823.0                    5.7   \n",
      "2004-01-01                         1274328.0                    5.1   \n",
      "2003-01-01                         1131783.0                    2.9   \n",
      "2002-01-01                         1035374.0                    0.5   \n",
      "2001-01-01                         1020022.0                    3.8   \n",
      "2000-01-01                          967838.0                    0.0   \n",
      "\n",
      "            Real GDP prices (Ksh Million)  \n",
      "Year                                       \n",
      "2022-01-01                      9851329.0  \n",
      "2021-01-01                      9395942.0  \n",
      "2020-01-01                      8733060.0  \n",
      "2019-01-01                      8756946.0  \n",
      "2018-01-01                      8330891.0  \n",
      "2017-01-01                      7885521.0  \n",
      "2016-01-01                      7594064.0  \n",
      "2015-01-01                      7287024.0  \n",
      "2014-01-01                      6942157.0  \n",
      "2013-01-01                      6610312.0  \n",
      "2012-01-01                      6368448.0  \n",
      "2011-01-01                      6090206.0  \n",
      "2010-01-01                      5793514.0  \n",
      "2009-01-01                      5361462.0  \n",
      "2008-01-01                      1357262.0  \n",
      "2007-01-01                      1336849.0  \n",
      "2006-01-01                      1249470.0  \n",
      "2005-01-01                      1172784.0  \n",
      "2004-01-01                      1109338.0  \n",
      "2003-01-01                      1055658.0  \n",
      "2002-01-01                      1025583.0  \n",
      "2001-01-01                      1020111.0  \n",
      "2000-01-01                       982855.0  \n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Load the dataset\n",
    "df = pd.read_csv('annual_gdp.csv')\n",
    "\n",
    "# Remove the last row with all zeros\n",
    "df = df[:-1]\n",
    "\n",
    "# Convert the GDP columns to numeric format\n",
    "df['Nominal GDP prices (Ksh Million)'] = df['Nominal GDP prices (Ksh Million)'].str.replace(',', '').astype(float)\n",
    "df['Real GDP prices (Ksh Million)'] = df['Real GDP prices (Ksh Million)'].str.replace(',', '').astype(float)\n",
    "\n",
    "# Convert the Year column to datetime format\n",
    "df['Year'] = pd.to_datetime(df['Year'], format='%Y')\n",
    "\n",
    "# Set the Year column as the index\n",
    "df.set_index('Year', inplace=True)\n",
    "\n",
    "# Display the dataset\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1b24987d-1e0d-4607-adf2-29688cc67728",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            Forecast         Lower         Upper\n",
      "2001-12-31       NaN -1.001972e+06  2.161457e+06\n",
      "2002-12-31       NaN -2.060253e+06  2.413513e+06\n",
      "2003-12-31       NaN -2.966093e+06  2.513128e+06\n",
      "2004-12-31       NaN -3.793025e+06  2.533835e+06\n",
      "2005-12-31       NaN -4.569529e+06  2.504115e+06\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ivy\\anaconda3\\Lib\\site-packages\\statsmodels\\tsa\\base\\tsa_model.py:836: ValueWarning: No supported index is available. Prediction results will be given with an integer index beginning at `start`.\n",
      "  return get_prediction_index(\n",
      "C:\\Users\\ivy\\anaconda3\\Lib\\site-packages\\statsmodels\\tsa\\base\\tsa_model.py:836: FutureWarning: No supported index is available. In the next version, calling this method in a model without a supported index will result in an exception.\n",
      "  return get_prediction_index(\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from pmdarima import auto_arima\n",
    "\n",
    "# Load the dataset\n",
    "df = pd.read_csv('annual_gdp.csv')\n",
    "\n",
    "# Remove the last row with all zeros\n",
    "df = df[:-1]\n",
    "\n",
    "# Convert the GDP columns to numeric format\n",
    "df['Nominal GDP prices (Ksh Million)'] = df['Nominal GDP prices (Ksh Million)'].str.replace(',', '').astype(float)\n",
    "df['Real GDP prices (Ksh Million)'] = df['Real GDP prices (Ksh Million)'].str.replace(',', '').astype(float)\n",
    "\n",
    "# Convert the Year column to datetime format\n",
    "df['Year'] = pd.to_datetime(df['Year'], format='%Y')\n",
    "\n",
    "# Set the Year column as the index\n",
    "df.set_index('Year', inplace=True)\n",
    "\n",
    "# Plot the GDP over time\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(df.index, df['Real GDP prices (Ksh Million)'])\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Real GDP')\n",
    "plt.title('Kenya Real GDP Over Time')\n",
    "plt.show()\n",
    "\n",
    "# Find the optimal ARIMA parameters\n",
    "model = auto_arima(df['Real GDP prices (Ksh Million)'], seasonal=False)\n",
    "\n",
    "# Forecast the next n periods\n",
    "n = 5\n",
    "forecast, conf_int = model.predict(n_periods=n, return_conf_int=True)\n",
    "\n",
    "# Generate the forecast dates\n",
    "forecast_dates = pd.date_range(start=df.index[-1], periods=n+1, freq='Y')[1:]\n",
    "\n",
    "# Create a DataFrame for the forecasted values\n",
    "forecast_df = pd.DataFrame({'Forecast': forecast, 'Lower': conf_int[:, 0], 'Upper': conf_int[:, 1]}, index=forecast_dates)\n",
    "\n",
    "# Print the forecasted values\n",
    "print(forecast_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f213ff6a-4ed9-4752-8eee-166a8437e5ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set shape: (18, 1) (18,)\n",
      "Test set shape: (5, 1) (5,)\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# Load the dataset\n",
    "df = pd.read_csv('annual_gdp.csv')\n",
    "\n",
    "# Data Cleaning\n",
    "df = df[:-1]  # Remove the last row with all zeros\n",
    "df['Nominal GDP prices (Ksh Million)'] = df['Nominal GDP prices (Ksh Million)'].str.replace(',', '').astype(float)\n",
    "df['Real GDP prices (Ksh Million)'] = df['Real GDP prices (Ksh Million)'].str.replace(',', '').astype(float)\n",
    "\n",
    "# Feature Engineering\n",
    "# No specific feature engineering steps mentioned, so we'll skip this step\n",
    "\n",
    "# Outlier Detection and Handling\n",
    "# No specific outlier detection and handling steps mentioned, so we'll skip this step\n",
    "\n",
    "# Normalization or Standardization\n",
    "scaler = StandardScaler()\n",
    "df['Nominal GDP prices (Ksh Million)'] = scaler.fit_transform(df['Nominal GDP prices (Ksh Million)'].values.reshape(-1, 1))\n",
    "df['Real GDP prices (Ksh Million)'] = scaler.fit_transform(df['Real GDP prices (Ksh Million)'].values.reshape(-1, 1))\n",
    "\n",
    "# Train-Test Split\n",
    "X = df[['Nominal GDP prices (Ksh Million)']].values\n",
    "y = df['Real GDP prices (Ksh Million)'].values\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Print the shapes of the train and test sets\n",
    "print('Train set shape:', X_train.shape, y_train.shape)\n",
    "print('Test set shape:', X_test.shape, y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e742000-bc08-4306-b737-26583759cca9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3d2da8c2-54b2-47f8-973a-25be08fad0c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train RMSE: 1099664.7219566714\n",
      "Test RMSE: 1353534.452951561\n",
      "Train R^2 Score: 0.8844413232724991\n",
      "Test R^2 Score: 0.841517299461789\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "\n",
    "# Load the dataset\n",
    "df = pd.read_csv('annual_gdp.csv')\n",
    "\n",
    "# Data Cleaning\n",
    "df = df[:-1]  # Remove the last row with all zeros\n",
    "df['Nominal GDP prices (Ksh Million)'] = df['Nominal GDP prices (Ksh Million)'].str.replace(',', '').astype(float)\n",
    "df['Real GDP prices (Ksh Million)'] = df['Real GDP prices (Ksh Million)'].str.replace(',', '').astype(float)\n",
    "\n",
    "# Train-Test Split\n",
    "X = df[['Nominal GDP prices (Ksh Million)']].values\n",
    "y = df['Real GDP prices (Ksh Million)'].values\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Model Training\n",
    "model = LinearRegression()\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Model Evaluation\n",
    "y_pred_train = model.predict(X_train)\n",
    "y_pred_test = model.predict(X_test)\n",
    "\n",
    "train_rmse = mean_squared_error(y_train, y_pred_train, squared=False)\n",
    "test_rmse = mean_squared_error(y_test, y_pred_test, squared=False)\n",
    "\n",
    "train_r2 = r2_score(y_train, y_pred_train)\n",
    "test_r2 = r2_score(y_test, y_pred_test)\n",
    "\n",
    "print('Train RMSE:', train_rmse)\n",
    "print('Test RMSE:', test_rmse)\n",
    "print('Train R^2 Score:', train_r2)\n",
    "print('Test R^2 Score:', test_r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d151285-5514-4a84-8d2d-342160865748",
   "metadata": {},
   "source": [
    "The results from the regression model evaluation are as follows:\r\n",
    "\r\n",
    "Train RMSE: 1,099,664.72\r\n",
    "Test RMSE: 1,353,534.45\r\n",
    "Train R^2 Score: 0.884\r\n",
    "Test R^2 Score: 0.842\r\n",
    "\r\n",
    "The RMSE values represent the average difference between the predicted and actual values. Lower RMSE values indicate better model performance.\r\n",
    "\r\n",
    "The R^2 score measures the proportion of the variance in the target variable that can be explained by the model. Higher R^2 scores indicate better fit.\r\n",
    "\r\n",
    "In this case, the model performs reasonably well with an R^2 score of 0.884 on the train set and 0.842 on the test set. The RMSE values are quite high, indicating that there is still room for improvement in the model's predictivssist you with!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11a32ee8-7828-4870-80c7-561e3a36327c",
   "metadata": {},
   "source": [
    "## Hypeparameter Tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "df268371-60e7-492d-a343-1f673bd25a9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Hyperparameters: {'fit_intercept': True}\n",
      "Train RMSE: 1099664.7219566714\n",
      "Test RMSE: 1353534.452951561\n",
      "Train R^2 Score: 0.8844413232724991\n",
      "Test R^2 Score: 0.841517299461789\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "\n",
    "# Load the dataset\n",
    "df = pd.read_csv('annual_gdp.csv')\n",
    "\n",
    "# Data Cleaning\n",
    "df = df[:-1]  # Remove the last row with all zeros\n",
    "df['Nominal GDP prices (Ksh Million)'] = df['Nominal GDP prices (Ksh Million)'].str.replace(',', '').astype(float)\n",
    "df['Real GDP prices (Ksh Million)'] = df['Real GDP prices (Ksh Million)'].str.replace(',', '').astype(float)\n",
    "\n",
    "# Train-Test Split\n",
    "X = df[['Nominal GDP prices (Ksh Million)']].values\n",
    "y = df['Real GDP prices (Ksh Million)'].values\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Define the regression model\n",
    "model = LinearRegression()\n",
    "\n",
    "# Define the hyperparameters to tune\n",
    "param_grid = {'fit_intercept': [True, False]}\n",
    "\n",
    "# Perform GridSearchCV to find the best hyperparameters\n",
    "grid_search = GridSearchCV(model, param_grid, cv=5)\n",
    "grid_search.fit(X_train, y_train)\n",
    "\n",
    "# Get the best hyperparameters and model\n",
    "best_params = grid_search.best_params_\n",
    "best_model = grid_search.best_estimator_\n",
    "\n",
    "# Model Evaluation with best model\n",
    "y_pred_train = best_model.predict(X_train)\n",
    "y_pred_test = best_model.predict(X_test)\n",
    "\n",
    "train_rmse = mean_squared_error(y_train, y_pred_train, squared=False)\n",
    "test_rmse = mean_squared_error(y_test, y_pred_test, squared=False)\n",
    "\n",
    "train_r2 = r2_score(y_train, y_pred_train)\n",
    "test_r2 = r2_score(y_test, y_pred_test)\n",
    "\n",
    "print('Best Hyperparameters:', best_params)\n",
    "print('Train RMSE:', train_rmse)\n",
    "print('Test RMSE:', test_rmse)\n",
    "print('Train R^2 Score:', train_r2)\n",
    "print('Test R^2 Score:', test_r2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4e47db3-af0f-4e89-9dfe-6cbd49e0620d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3d6df435-e568-484f-9a40-2e59c15c0177",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE: 1154117.9247266552\n",
      "R^2 Score: 0.8756381751366029\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "\n",
    "# Load the dataset\n",
    "df = pd.read_csv('annual_gdp.csv')\n",
    "\n",
    "# Data Cleaning\n",
    "df = df[:-1]  # Remove the last row with all zeros\n",
    "df['Nominal GDP prices (Ksh Million)'] = df['Nominal GDP prices (Ksh Million)'].str.replace(',', '').astype(float)\n",
    "df['Real GDP prices (Ksh Million)'] = df['Real GDP prices (Ksh Million)'].str.replace(',', '').astype(float)\n",
    "\n",
    "# Prepare the data\n",
    "X = df[['Nominal GDP prices (Ksh Million)']].values\n",
    "y = df['Real GDP prices (Ksh Million)'].values\n",
    "\n",
    "# Train the model\n",
    "model = LinearRegression()\n",
    "model.fit(X, y)\n",
    "\n",
    "# Make predictions\n",
    "y_pred = model.predict(X)\n",
    "\n",
    "# Model evaluation\n",
    "rmse = mean_squared_error(y, y_pred, squared=False)\n",
    "r2 = r2_score(y, y_pred)\n",
    "\n",
    "print('RMSE:', rmse)\n",
    "print('R^2 Score:', r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59bb9880-19ea-42f5-a673-24bc71aca761",
   "metadata": {},
   "source": [
    "# Saving Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3460ff8e-e598-45d3-b71a-21ed0155c5c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['linear_regression_model.pkl']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import joblib\n",
    "\n",
    "# Save the trained model\n",
    "joblib.dump(model, 'linear_regression_model.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e21c3c7e-c6e9-4156-a9dc-c453bfefca70",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the saved model\n",
    "model = joblib.load('linear_regression_model.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad4b3b4c-1a36-4117-9fa8-67ab7ed0a3ef",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f166f150-b33f-44c0-9677-67b844f3a79c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "012b2221-b2ff-435d-839e-92c036505da0",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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": 5
}