diff --git "a/DataSynthis_ML_JobTask.ipynb" "b/DataSynthis_ML_JobTask.ipynb" new file mode 100644--- /dev/null +++ "b/DataSynthis_ML_JobTask.ipynb" @@ -0,0 +1,1090 @@ +{ + "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": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Fv8lT_HYMiW-", + "outputId": "69a72432-a2ad-4198-c286-09a89afca0eb" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: pandas in /usr/local/lib/python3.12/dist-packages (2.2.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (2.0.2)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (3.10.0)\n", + "Requirement already satisfied: seaborn in /usr/local/lib/python3.12/dist-packages (0.13.2)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.12/dist-packages (from pandas) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas) (2025.2)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (4.60.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.4.9)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (25.0)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (11.3.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (3.2.4)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)\n", + "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.12/dist-packages (1.6.1)\n", + "Requirement already satisfied: statsmodels in /usr/local/lib/python3.12/dist-packages (0.14.5)\n", + "Requirement already satisfied: tensorflow in /usr/local/lib/python3.12/dist-packages (2.19.0)\n", + "Requirement already satisfied: numpy>=1.19.5 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.16.2)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.5.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (3.6.0)\n", + "Requirement already satisfied: pandas!=2.1.0,>=1.4 in /usr/local/lib/python3.12/dist-packages (from statsmodels) (2.2.2)\n", + "Requirement already satisfied: patsy>=0.5.6 in /usr/local/lib/python3.12/dist-packages (from statsmodels) (1.0.1)\n", + "Requirement already satisfied: packaging>=21.3 in /usr/local/lib/python3.12/dist-packages (from statsmodels) (25.0)\n", + "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (1.4.0)\n", + "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (1.6.3)\n", + "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (25.2.10)\n", + "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (0.6.0)\n", + "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (0.2.0)\n", + "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (18.1.1)\n", + "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (3.4.0)\n", + "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (5.29.5)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (2.32.4)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from tensorflow) (75.2.0)\n", + "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (1.17.0)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (3.1.0)\n", + "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (4.15.0)\n", + "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (1.17.3)\n", + "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (1.75.0)\n", + "Requirement already satisfied: tensorboard~=2.19.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (2.19.0)\n", + "Requirement already satisfied: keras>=3.5.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (3.10.0)\n", + "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (3.14.0)\n", + "Requirement already satisfied: ml-dtypes<1.0.0,>=0.5.1 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (0.5.3)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.12/dist-packages (from astunparse>=1.6.0->tensorflow) (0.45.1)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.12/dist-packages (from keras>=3.5.0->tensorflow) (13.9.4)\n", + "Requirement already satisfied: namex in /usr/local/lib/python3.12/dist-packages (from keras>=3.5.0->tensorflow) (0.1.0)\n", + "Requirement already satisfied: optree in /usr/local/lib/python3.12/dist-packages (from keras>=3.5.0->tensorflow) (0.17.0)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.12/dist-packages (from pandas!=2.1.0,>=1.4->statsmodels) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas!=2.1.0,>=1.4->statsmodels) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas!=2.1.0,>=1.4->statsmodels) (2025.2)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.4.3)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests<3,>=2.21.0->tensorflow) (2.5.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests<3,>=2.21.0->tensorflow) (2025.8.3)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.12/dist-packages (from tensorboard~=2.19.0->tensorflow) (3.9)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.12/dist-packages (from tensorboard~=2.19.0->tensorflow) (0.7.2)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from tensorboard~=2.19.0->tensorflow) (3.1.3)\n", + "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.12/dist-packages (from werkzeug>=1.0.1->tensorboard~=2.19.0->tensorflow) (3.0.2)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.12/dist-packages (from rich->keras>=3.5.0->tensorflow) (4.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.12/dist-packages (from rich->keras>=3.5.0->tensorflow) (2.19.2)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.12/dist-packages (from markdown-it-py>=2.2.0->rich->keras>=3.5.0->tensorflow) (0.1.2)\n", + "Requirement already satisfied: prophet in /usr/local/lib/python3.12/dist-packages (1.1.7)\n", + "Requirement already satisfied: yfinance in /usr/local/lib/python3.12/dist-packages (0.2.66)\n", + "Requirement already satisfied: cmdstanpy>=1.0.4 in /usr/local/lib/python3.12/dist-packages (from prophet) (1.2.5)\n", + "Requirement already satisfied: numpy>=1.15.4 in /usr/local/lib/python3.12/dist-packages (from prophet) (2.0.2)\n", + "Requirement already satisfied: matplotlib>=2.0.0 in /usr/local/lib/python3.12/dist-packages (from prophet) (3.10.0)\n", + "Requirement already satisfied: pandas>=1.0.4 in /usr/local/lib/python3.12/dist-packages (from prophet) (2.2.2)\n", + "Requirement already satisfied: holidays<1,>=0.25 in /usr/local/lib/python3.12/dist-packages (from prophet) (0.81)\n", + "Requirement already satisfied: tqdm>=4.36.1 in /usr/local/lib/python3.12/dist-packages (from prophet) (4.67.1)\n", + "Requirement already satisfied: importlib_resources in /usr/local/lib/python3.12/dist-packages (from prophet) (6.5.2)\n", + "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.12/dist-packages (from yfinance) (2.32.4)\n", + "Requirement already satisfied: multitasking>=0.0.7 in /usr/local/lib/python3.12/dist-packages (from yfinance) (0.0.12)\n", + "Requirement already satisfied: platformdirs>=2.0.0 in /usr/local/lib/python3.12/dist-packages (from yfinance) (4.4.0)\n", + "Requirement already satisfied: pytz>=2022.5 in /usr/local/lib/python3.12/dist-packages (from yfinance) (2025.2)\n", + "Requirement already satisfied: frozendict>=2.3.4 in /usr/local/lib/python3.12/dist-packages (from yfinance) (2.4.6)\n", + "Requirement already satisfied: peewee>=3.16.2 in /usr/local/lib/python3.12/dist-packages (from yfinance) (3.18.2)\n", + "Requirement already satisfied: beautifulsoup4>=4.11.1 in /usr/local/lib/python3.12/dist-packages (from yfinance) (4.13.5)\n", + "Requirement already satisfied: curl_cffi>=0.7 in /usr/local/lib/python3.12/dist-packages (from yfinance) (0.13.0)\n", + "Requirement already satisfied: protobuf>=3.19.0 in /usr/local/lib/python3.12/dist-packages (from yfinance) (5.29.5)\n", + "Requirement already satisfied: websockets>=13.0 in /usr/local/lib/python3.12/dist-packages (from yfinance) (15.0.1)\n", + "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.12/dist-packages (from beautifulsoup4>=4.11.1->yfinance) (2.8)\n", + "Requirement already satisfied: typing-extensions>=4.0.0 in /usr/local/lib/python3.12/dist-packages (from beautifulsoup4>=4.11.1->yfinance) (4.15.0)\n", + "Requirement already satisfied: stanio<2.0.0,>=0.4.0 in /usr/local/lib/python3.12/dist-packages (from cmdstanpy>=1.0.4->prophet) (0.5.1)\n", + "Requirement already satisfied: cffi>=1.12.0 in /usr/local/lib/python3.12/dist-packages (from curl_cffi>=0.7->yfinance) (2.0.0)\n", + "Requirement already satisfied: certifi>=2024.2.2 in /usr/local/lib/python3.12/dist-packages (from curl_cffi>=0.7->yfinance) (2025.8.3)\n", + "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.12/dist-packages (from holidays<1,>=0.25->prophet) (2.9.0.post0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=2.0.0->prophet) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=2.0.0->prophet) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=2.0.0->prophet) (4.60.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=2.0.0->prophet) (1.4.9)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=2.0.0->prophet) (25.0)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=2.0.0->prophet) (11.3.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=2.0.0->prophet) (3.2.4)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas>=1.0.4->prophet) (2025.2)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests>=2.31->yfinance) (3.4.3)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests>=2.31->yfinance) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests>=2.31->yfinance) (2.5.0)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.12/dist-packages (from cffi>=1.12.0->curl_cffi>=0.7->yfinance) (2.23)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil->holidays<1,>=0.25->prophet) (1.17.0)\n", + "Requirement already satisfied: huggingface_hub in /usr/local/lib/python3.12/dist-packages (0.35.0)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from huggingface_hub) (3.19.1)\n", + "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.12/dist-packages (from huggingface_hub) (2025.3.0)\n", + "Requirement already satisfied: packaging>=20.9 in /usr/local/lib/python3.12/dist-packages (from huggingface_hub) (25.0)\n", + "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.12/dist-packages (from huggingface_hub) (6.0.2)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.12/dist-packages (from huggingface_hub) (2.32.4)\n", + "Requirement already satisfied: tqdm>=4.42.1 in /usr/local/lib/python3.12/dist-packages (from huggingface_hub) (4.67.1)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.12/dist-packages (from huggingface_hub) (4.15.0)\n", + "Requirement already satisfied: hf-xet<2.0.0,>=1.1.3 in /usr/local/lib/python3.12/dist-packages (from huggingface_hub) (1.1.10)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests->huggingface_hub) (3.4.3)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests->huggingface_hub) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests->huggingface_hub) (2.5.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests->huggingface_hub) (2025.8.3)\n" + ] + } + ], + "source": [ + "# Install required packages\n", + "!pip install pandas numpy matplotlib seaborn\n", + "!pip install scikit-learn statsmodels tensorflow\n", + "!pip install prophet yfinance\n", + "!pip install huggingface_hub" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from datetime import datetime, timedelta\n", + "import yfinance as yf\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Statistical models\n", + "from statsmodels.tsa.arima.model import ARIMA\n", + "from statsmodels.tsa.stattools import adfuller\n", + "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n", + "\n", + "# ML models\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "from sklearn.metrics import mean_squared_error, mean_absolute_error\n", + "from tensorflow.keras.models import Sequential\n", + "from tensorflow.keras.layers import LSTM, Dense, Dropout\n", + "\n", + "# Prophet\n", + "from prophet import Prophet\n", + "\n", + "# Evaluation metrics\n", + "def mean_absolute_percentage_error(y_true, y_pred):\n", + " return np.mean(np.abs((y_true - y_pred) / y_true)) * 100" + ], + "metadata": { + "id": "m7fRKobSM9kS" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def get_stock_data(symbol='AAPL', start_date='2015-01-01', end_date='2024-01-01'):\n", + " \"\"\"\n", + " Get stock data with multiple fallback options\n", + " \"\"\"\n", + " try:\n", + " # Try the original symbol first\n", + " data = yf.download(symbol, start=start_date, end=end_date, progress=False)\n", + " if data.empty:\n", + " raise ValueError(f\"No data found for symbol: {symbol}\")\n", + " return data\n", + " except Exception as e:\n", + " print(f\"Error with {symbol}: {e}\")\n", + " print(\"Trying alternative symbols...\")\n", + "\n", + " # Try alternative symbols for Thai stocks or SET index\n", + " alternatives = ['BBL.BK', 'PTT.BK', 'ADVANC.BK', '^SET', 'AAPL', 'GOOGL']\n", + "\n", + " for alt_symbol in alternatives:\n", + " try:\n", + " print(f\"Trying {alt_symbol}...\")\n", + " data = yf.download(alt_symbol, start=start_date, end=end_date, progress=False)\n", + " if not data.empty:\n", + " print(f\"Successfully downloaded data for {alt_symbol}\")\n", + " return data\n", + " except:\n", + " continue\n", + "\n", + " # If all else fails, create synthetic data for demonstration\n", + " print(\"Creating synthetic stock data for demonstration...\")\n", + " return create_synthetic_data(start_date, end_date)\n", + "\n", + "def create_synthetic_data(start_date, end_date):\n", + " \"\"\"\n", + " Create synthetic stock price data for demonstration\n", + " \"\"\"\n", + " dates = pd.date_range(start=start_date, end=end_date, freq='D')\n", + " n_days = len(dates)\n", + "\n", + " # Generate realistic synthetic data with trend and seasonality\n", + " np.random.seed(42)\n", + " trend = np.linspace(100, 200, n_days)\n", + " seasonal = 10 * np.sin(2 * np.pi * np.arange(n_days) / 365)\n", + " noise = np.random.normal(0, 5, n_days)\n", + "\n", + " prices = trend + seasonal + noise\n", + " prices = np.maximum(prices, 10) # Ensure positive prices\n", + "\n", + " data = pd.DataFrame({\n", + " 'Open': prices * 0.99,\n", + " 'High': prices * 1.02,\n", + " 'Low': prices * 0.98,\n", + " 'Close': prices,\n", + " 'Volume': np.random.randint(1000000, 10000000, n_days)\n", + " }, index=dates)\n", + "\n", + " return data\n", + "\n", + "# Get stock data\n", + "stock_data = get_stock_data('BBL.BK') # Using Bangkok Bank as example\n", + "print(f\"Data shape: {stock_data.shape}\")\n", + "print(f\"Date range: {stock_data.index.min()} to {stock_data.index.max()}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dgASkji6NJnS", + "outputId": "cc8039ca-5b0a-4a13-cb68-711fc4e9b14a" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Data shape: (2187, 5)\n", + "Date range: 2015-01-05 00:00:00 to 2023-12-28 00:00:00\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def preprocess_data(data):\n", + " \"\"\"\n", + " Preprocess stock price data\n", + " \"\"\"\n", + " # Use closing prices\n", + " if isinstance(data, pd.DataFrame):\n", + " # Correctly extract the 'Close' price values as a 1D array\n", + " prices = data[('Close', data['Close'].columns[0])].copy()\n", + " else:\n", + " prices = data.copy()\n", + "\n", + " # Handle missing values\n", + " prices = prices.ffill().bfill()\n", + "\n", + " # Remove any remaining NaN values\n", + " prices = prices.dropna()\n", + "\n", + " # Create DataFrame for Prophet\n", + " df = pd.DataFrame({\n", + " 'ds': prices.index,\n", + " 'y': prices.values\n", + " })\n", + "\n", + " return df, prices\n", + "\n", + "# Preprocess data\n", + "df, prices = preprocess_data(stock_data)\n", + "\n", + "print(f\"Data shape: {df.shape}\")\n", + "print(f\"Date range: {df['ds'].min()} to {df['ds'].max()}\")\n", + "print(f\"Sample prices:\\n{prices.head()}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Fmd7b1rSNj6x", + "outputId": "feff325b-3e26-4d93-f06d-73503af9a27a" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Data shape: (2187, 2)\n", + "Date range: 2015-01-05 00:00:00 to 2023-12-28 00:00:00\n", + "Sample prices:\n", + "Date\n", + "2015-01-05 124.926834\n", + "2015-01-06 124.598061\n", + "2015-01-07 125.913063\n", + "2015-01-08 126.241852\n", + "2015-01-09 124.926834\n", + "Name: (Close, BBL.BK), dtype: float64\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def plot_stock_analysis(prices, title=\"Stock Price Analysis\"):\n", + " \"\"\"\n", + " Comprehensive stock price analysis visualization\n", + " \"\"\"\n", + " fig, axes = plt.subplots(2, 2, figsize=(15, 10))\n", + "\n", + " # Price time series\n", + " axes[0, 0].plot(prices.index, prices.values, linewidth=1)\n", + " axes[0, 0].set_title(f'{title} - Price')\n", + " axes[0, 0].set_xlabel('Date')\n", + " axes[0, 0].set_ylabel('Price')\n", + " axes[0, 0].tick_params(axis='x', rotation=45)\n", + "\n", + " # Daily returns\n", + " returns = prices.pct_change().dropna()\n", + " axes[0, 1].plot(returns.index, returns.values, linewidth=1, alpha=0.7)\n", + " axes[0, 1].set_title('Daily Returns')\n", + " axes[0, 1].set_xlabel('Date')\n", + " axes[0, 1].set_ylabel('Returns')\n", + " axes[0, 1].tick_params(axis='x', rotation=45)\n", + "\n", + " # Histogram of returns\n", + " axes[1, 0].hist(returns.dropna(), bins=50, alpha=0.7, edgecolor='black')\n", + " axes[1, 0].set_title('Distribution of Returns')\n", + " axes[1, 0].set_xlabel('Returns')\n", + " axes[1, 0].set_ylabel('Frequency')\n", + "\n", + " # Autocorrelation\n", + " plot_acf(prices.dropna(), lags=50, ax=axes[1, 1], alpha=0.05)\n", + " axes[1, 1].set_title('Autocorrelation Function')\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + " # Print basic statistics\n", + " print(\"Basic Statistics:\")\n", + " print(f\"Mean price: {prices.mean():.2f}\")\n", + " print(f\"Std price: {prices.std():.2f}\")\n", + " print(f\"Min price: {prices.min():.2f}\")\n", + " print(f\"Max price: {prices.max():.2f}\")\n", + " print(f\"Total return: {((prices.iloc[-1] / prices.iloc[0]) - 1) * 100:.2f}%\")\n", + "\n", + "plot_stock_analysis(prices)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "VzHbfHs3N5eR", + "outputId": "4bc96b9d-ea90-4489-d15f-6948c66d2a66" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Basic Statistics:\n", + "Mean price: 123.55\n", + "Std price: 21.65\n", + "Min price: 69.06\n", + "Max price: 163.91\n", + "Total return: 12.20%\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def check_stationarity(timeseries):\n", + " \"\"\"\n", + " Check stationarity using Augmented Dickey-Fuller test\n", + " \"\"\"\n", + " result = adfuller(timeseries.dropna())\n", + " print('ADF Statistic:', result[0])\n", + " print('p-value:', result[1])\n", + " print('Critical Values:')\n", + " for key, value in result[4].items():\n", + " print(f'\\t{key}: {value}')\n", + "\n", + " if result[1] <= 0.05:\n", + " print(\"✅ Series is stationary\")\n", + " return True\n", + " else:\n", + " print(\"❌ Series is non-stationary - differencing required\")\n", + " return False\n", + "\n", + "# Check stationarity\n", + "print(\"Original series:\")\n", + "is_stationary = check_stationarity(prices)\n", + "\n", + "# Check stationarity of returns if original is non-stationary\n", + "if not is_stationary:\n", + " print(\"\\nReturns series:\")\n", + " returns = prices.pct_change().dropna()\n", + " check_stationarity(returns)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fPCEtQOyN_35", + "outputId": "32499e49-2dec-4e83-a9e0-e860be76d83a" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Original series:\n", + "ADF Statistic: -1.6748618922637941\n", + "p-value: 0.44410869556430993\n", + "Critical Values:\n", + "\t1%: -3.4333532186762805\n", + "\t5%: -2.862866720471125\n", + "\t10%: -2.5674762791431696\n", + "❌ Series is non-stationary - differencing required\n", + "\n", + "Returns series:\n", + "ADF Statistic: -18.301692892117448\n", + "p-value: 2.285871213216054e-30\n", + "Critical Values:\n", + "\t1%: -3.4333532186762805\n", + "\t5%: -2.862866720471125\n", + "\t10%: -2.5674762791431696\n", + "✅ Series is stationary\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def arima_forecast(train_data, test_data, order=(1,1,1)):\n", + " \"\"\"\n", + " Implement ARIMA model for forecasting\n", + " \"\"\"\n", + " try:\n", + " # Fit ARIMA model\n", + " model = ARIMA(train_data, order=order)\n", + " fitted_model = model.fit()\n", + "\n", + " # Forecast\n", + " forecast = fitted_model.forecast(steps=len(test_data))\n", + "\n", + " return forecast, fitted_model\n", + " except Exception as e:\n", + " print(f\"ARIMA error: {e}\")\n", + " # Return naive forecast as fallback\n", + " last_value = train_data.iloc[-1]\n", + " forecast = np.full(len(test_data), last_value)\n", + " return forecast, None\n", + "\n", + "def find_best_arima_order(data, max_p=3, max_d=2, max_q=3):\n", + " \"\"\"\n", + " Find optimal ARIMA parameters using AIC\n", + " \"\"\"\n", + " best_aic = np.inf\n", + " best_order = None\n", + "\n", + " for p in range(max_p + 1):\n", + " for d in range(max_d + 1):\n", + " for q in range(max_q + 1):\n", + " try:\n", + " model = ARIMA(data, order=(p, d, q))\n", + " fitted_model = model.fit()\n", + " if fitted_model.aic < best_aic:\n", + " best_aic = fitted_model.aic\n", + " best_order = (p, d, q)\n", + " print(f\"ARIMA({p},{d},{q}) - AIC: {fitted_model.aic:.2f}\")\n", + " except Exception as e:\n", + " continue\n", + "\n", + " print(f\"✅ Best ARIMA order: {best_order} with AIC: {best_aic:.2f}\")\n", + " return best_order, best_aic\n", + "\n", + "# Find best ARIMA parameters (use smaller range for stability)\n", + "best_order, best_aic = find_best_arima_order(prices, max_p=2, max_d=1, max_q=2)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yOsn00k1OEL5", + "outputId": "06693a47-f9c2-45bc-b819-8035c9de90bf" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "ARIMA(0,0,0) - AIC: 19659.45\n", + "ARIMA(0,0,1) - AIC: 16832.71\n", + "ARIMA(0,0,2) - AIC: 14740.97\n", + "ARIMA(0,1,0) - AIC: 8369.02\n", + "ARIMA(0,1,1) - AIC: 8370.40\n", + "ARIMA(0,1,2) - AIC: 8364.98\n", + "ARIMA(1,0,0) - AIC: 8378.20\n", + "ARIMA(1,0,1) - AIC: 8379.39\n", + "ARIMA(1,0,2) - AIC: 8374.41\n", + "ARIMA(1,1,0) - AIC: 8370.48\n", + "ARIMA(1,1,1) - AIC: 8366.32\n", + "ARIMA(1,1,2) - AIC: 8366.89\n", + "ARIMA(2,0,0) - AIC: 8379.56\n", + "ARIMA(2,0,1) - AIC: 8375.28\n", + "ARIMA(2,0,2) - AIC: 8376.36\n", + "ARIMA(2,1,0) - AIC: 8364.77\n", + "ARIMA(2,1,1) - AIC: 8366.76\n", + "ARIMA(2,1,2) - AIC: 8366.10\n", + "✅ Best ARIMA order: (2, 1, 0) with AIC: 8364.77\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def create_lstm_model(input_shape, units=50):\n", + " \"\"\"\n", + " Create LSTM model architecture\n", + " \"\"\"\n", + " model = Sequential([\n", + " LSTM(units, return_sequences=True, input_shape=input_shape),\n", + " Dropout(0.2),\n", + " LSTM(units, return_sequences=False),\n", + " Dropout(0.2),\n", + " Dense(25),\n", + " Dense(1)\n", + " ])\n", + "\n", + " model.compile(optimizer='adam', loss='mse', metrics=['mae'])\n", + " return model\n", + "\n", + "def prepare_lstm_data(data, lookback=30):\n", + " \"\"\"\n", + " Prepare data for LSTM model\n", + " \"\"\"\n", + " scaler = MinMaxScaler(feature_range=(0, 1))\n", + " scaled_data = scaler.fit_transform(data.values.reshape(-1, 1))\n", + "\n", + " X, y = [], []\n", + " for i in range(lookback, len(scaled_data)):\n", + " X.append(scaled_data[i-lookback:i, 0])\n", + " y.append(scaled_data[i, 0])\n", + "\n", + " X, y = np.array(X), np.array(y)\n", + " X = X.reshape(X.shape[0], X.shape[1], 1)\n", + "\n", + " return X, y, scaler\n", + "\n", + "def lstm_forecast(train_data, test_data, lookback=30, epochs=20, batch_size=16):\n", + " \"\"\"\n", + " Implement LSTM model for forecasting\n", + " \"\"\"\n", + " try:\n", + " # Prepare data\n", + " X_train, y_train, scaler = prepare_lstm_data(train_data, lookback)\n", + "\n", + " # Create and train model\n", + " model = create_lstm_model((X_train.shape[1], 1), units=50)\n", + "\n", + " # Use smaller epochs for faster training\n", + " history = model.fit(\n", + " X_train, y_train,\n", + " epochs=epochs,\n", + " batch_size=batch_size,\n", + " verbose=0,\n", + " validation_split=0.1\n", + " )\n", + "\n", + " # Prepare for forecasting\n", + " forecasts = []\n", + " current_batch = X_train[-1:].copy()\n", + "\n", + " for i in range(len(test_data)):\n", + " current_pred = model.predict(current_batch, verbose=0)[0]\n", + " forecasts.append(current_pred[0])\n", + "\n", + " # Update batch\n", + " current_batch = np.roll(current_batch, -1)\n", + " current_batch[0, -1, 0] = current_pred[0]\n", + "\n", + " # Inverse transform\n", + " forecasts = np.array(forecasts).reshape(-1, 1)\n", + " forecasts = scaler.inverse_transform(forecasts)\n", + "\n", + " return forecasts.flatten(), model\n", + "\n", + " except Exception as e:\n", + " print(f\"LSTM error: {e}\")\n", + " # Return naive forecast\n", + " last_value = train_data.iloc[-1]\n", + " forecast = np.full(len(test_data), last_value)\n", + " return forecast, None" + ], + "metadata": { + "id": "VGf680WNOqDB" + }, + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def prophet_forecast(train_df, test_periods):\n", + " \"\"\"\n", + " Implement Facebook Prophet model for forecasting\n", + " \"\"\"\n", + " try:\n", + " # Create and fit Prophet model\n", + " model = Prophet(\n", + " yearly_seasonality=True,\n", + " weekly_seasonality=True,\n", + " daily_seasonality=False,\n", + " changepoint_prior_scale=0.05\n", + " )\n", + "\n", + " model.fit(train_df)\n", + "\n", + " # Create future dataframe\n", + " future = model.make_future_dataframe(periods=test_periods, freq='D', include_history=False)\n", + "\n", + " # Forecast\n", + " forecast = model.predict(future)\n", + "\n", + " return forecast, model\n", + " except Exception as e:\n", + " print(f\"Prophet error: {e}\")\n", + " # Return naive forecast\n", + " last_value = train_df['y'].iloc[-1]\n", + " forecast_df = pd.DataFrame({\n", + " 'ds': pd.date_range(start=train_df['ds'].iloc[-1], periods=test_periods+1, freq='D')[1:],\n", + " 'yhat': np.full(test_periods, last_value)\n", + " })\n", + " return forecast_df, None" + ], + "metadata": { + "id": "dDOnIJRTOtKK" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def rolling_window_evaluation(data, model_type='arima', window_size=180, test_size=30, **kwargs):\n", + " \"\"\"\n", + " Perform rolling window evaluation\n", + " \"\"\"\n", + " forecasts = []\n", + " actuals = []\n", + "\n", + " # Use smaller window for faster computation\n", + " n_windows = min(5, (len(data) - window_size - test_size) // test_size)\n", + "\n", + " print(f\"Evaluating {model_type} with {n_windows} windows...\")\n", + "\n", + " for i in range(0, n_windows * test_size, test_size):\n", + " start_idx = i\n", + " end_idx = i + window_size + test_size\n", + "\n", + " if end_idx > len(data):\n", + " break\n", + "\n", + " train_data = data.iloc[start_idx:start_idx + window_size]\n", + " test_data = data.iloc[start_idx + window_size:end_idx]\n", + "\n", + " if model_type == 'arima':\n", + " forecast, _ = arima_forecast(train_data, test_data, **kwargs)\n", + " elif model_type == 'lstm':\n", + " forecast, _ = lstm_forecast(train_data, test_data, **kwargs)\n", + " elif model_type == 'prophet':\n", + " train_df = pd.DataFrame({'ds': train_data.index, 'y': train_data.values})\n", + " forecast_df, _ = prophet_forecast(train_df, len(test_data))\n", + " forecast = forecast_df['yhat'].values\n", + "\n", + " forecasts.extend(forecast)\n", + " actuals.extend(test_data.values)\n", + "\n", + " return np.array(forecasts), np.array(actuals)\n", + "\n", + "def calculate_metrics(actual, predicted):\n", + " \"\"\"\n", + " Calculate evaluation metrics\n", + " \"\"\"\n", + " # Handle division by zero in MAPE\n", + " mask = actual != 0\n", + " actual = actual[mask]\n", + " predicted = predicted[mask]\n", + "\n", + " if len(actual) == 0:\n", + " return {'RMSE': np.inf, 'MAE': np.inf, 'MAPE': np.inf, 'MSE': np.inf}\n", + "\n", + " mse = mean_squared_error(actual, predicted)\n", + " rmse = np.sqrt(mse)\n", + " mae = mean_absolute_error(actual, predicted)\n", + "\n", + " try:\n", + " mape = mean_absolute_percentage_error(actual, predicted)\n", + " except:\n", + " mape = np.inf\n", + "\n", + " return {\n", + " 'RMSE': rmse,\n", + " 'MAE': mae,\n", + " 'MAPE': mape,\n", + " 'MSE': mse\n", + " }" + ], + "metadata": { + "id": "0vKIcsQIOuLH" + }, + "execution_count": 13, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def compare_models(data):\n", + " \"\"\"\n", + " Compare performance of all models\n", + " \"\"\"\n", + " results = {}\n", + "\n", + " # ARIMA evaluation\n", + " print(\"🔍 Evaluating ARIMA model...\")\n", + " arima_forecasts, arima_actuals = rolling_window_evaluation(\n", + " data, model_type='arima', order=(1,1,1) # Using simple order for stability\n", + " )\n", + " results['ARIMA'] = calculate_metrics(arima_actuals, arima_forecasts)\n", + "\n", + " # LSTM evaluation\n", + " print(\"🔍 Evaluating LSTM model...\")\n", + " lstm_forecasts, lstm_actuals = rolling_window_evaluation(\n", + " data, model_type='lstm', lookback=30, epochs=10\n", + " )\n", + " results['LSTM'] = calculate_metrics(lstm_actuals, lstm_forecasts)\n", + "\n", + " # Prophet evaluation\n", + " print(\"🔍 Evaluating Prophet model...\")\n", + " prophet_forecasts, prophet_actuals = rolling_window_evaluation(\n", + " data, model_type='prophet'\n", + " )\n", + " results['Prophet'] = calculate_metrics(prophet_actuals, prophet_forecasts)\n", + "\n", + " # Naive model (persistence) as baseline\n", + " print(\"🔍 Evaluating Naive model (baseline)...\")\n", + " naive_forecasts = np.roll(arima_actuals, 1)\n", + " naive_forecasts[0] = arima_actuals[0]\n", + " results['Naive'] = calculate_metrics(arima_actuals, naive_forecasts)\n", + "\n", + " return results, (arima_forecasts, lstm_forecasts, prophet_forecasts, naive_forecasts, arima_actuals)\n", + "\n", + "# Compare all models\n", + "performance_results, all_forecasts = compare_models(prices)\n", + "arima_forecasts, lstm_forecasts, prophet_forecasts, naive_forecasts, actuals = all_forecasts" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "n_8lMTf6OyFg", + "outputId": "05c7dc82-d97d-4685-d375-69a927e77f12" + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🔍 Evaluating ARIMA model...\n", + "Evaluating arima with 5 windows...\n", + "🔍 Evaluating LSTM model...\n", + "Evaluating lstm with 5 windows...\n", + "🔍 Evaluating Prophet model...\n", + "Evaluating prophet with 5 windows...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "DEBUG:cmdstanpy:input tempfile: /tmp/tmphba_fawk/uv_0920f.json\n", + "DEBUG:cmdstanpy:input tempfile: /tmp/tmphba_fawk/rbt6c0da.json\n", + "DEBUG:cmdstanpy:idx 0\n", + "DEBUG:cmdstanpy:running CmdStan, num_threads: None\n", + "DEBUG:cmdstanpy:CmdStan args: ['/usr/local/lib/python3.12/dist-packages/prophet/stan_model/prophet_model.bin', 'random', 'seed=70208', 'data', 'file=/tmp/tmphba_fawk/uv_0920f.json', 'init=/tmp/tmphba_fawk/rbt6c0da.json', 'output', 'file=/tmp/tmphba_fawk/prophet_modelooie8wwl/prophet_model-20251002184250.csv', 'method=optimize', 'algorithm=lbfgs', 'iter=10000']\n", + "18:42:50 - cmdstanpy - INFO - Chain [1] start processing\n", + "INFO:cmdstanpy:Chain [1] start processing\n", + "18:42:50 - cmdstanpy - INFO - Chain [1] done processing\n", + "INFO:cmdstanpy:Chain [1] done processing\n", + "DEBUG:cmdstanpy:input tempfile: /tmp/tmphba_fawk/4mhc61_0.json\n", + "DEBUG:cmdstanpy:input tempfile: /tmp/tmphba_fawk/_l9ygdq4.json\n", + "DEBUG:cmdstanpy:idx 0\n", + "DEBUG:cmdstanpy:running CmdStan, num_threads: None\n", + "DEBUG:cmdstanpy:CmdStan args: ['/usr/local/lib/python3.12/dist-packages/prophet/stan_model/prophet_model.bin', 'random', 'seed=683', 'data', 'file=/tmp/tmphba_fawk/4mhc61_0.json', 'init=/tmp/tmphba_fawk/_l9ygdq4.json', 'output', 'file=/tmp/tmphba_fawk/prophet_model55ryy6md/prophet_model-20251002184250.csv', 'method=optimize', 'algorithm=lbfgs', 'iter=10000']\n", + "18:42:50 - cmdstanpy - INFO - Chain [1] start processing\n", + "INFO:cmdstanpy:Chain [1] start processing\n", + "18:42:50 - cmdstanpy - INFO - Chain [1] done processing\n", + "INFO:cmdstanpy:Chain [1] done processing\n", + "DEBUG:cmdstanpy:input tempfile: /tmp/tmphba_fawk/z9h9i_im.json\n", + "DEBUG:cmdstanpy:input tempfile: /tmp/tmphba_fawk/7no9wygh.json\n", + "DEBUG:cmdstanpy:idx 0\n", + "DEBUG:cmdstanpy:running CmdStan, num_threads: None\n", + "DEBUG:cmdstanpy:CmdStan args: ['/usr/local/lib/python3.12/dist-packages/prophet/stan_model/prophet_model.bin', 'random', 'seed=75181', 'data', 'file=/tmp/tmphba_fawk/z9h9i_im.json', 'init=/tmp/tmphba_fawk/7no9wygh.json', 'output', 'file=/tmp/tmphba_fawk/prophet_model69co53fa/prophet_model-20251002184250.csv', 'method=optimize', 'algorithm=lbfgs', 'iter=10000']\n", + "18:42:50 - cmdstanpy - INFO - Chain [1] start processing\n", + "INFO:cmdstanpy:Chain [1] start processing\n", + "18:42:50 - cmdstanpy - INFO - Chain [1] done processing\n", + "INFO:cmdstanpy:Chain [1] done processing\n", + "DEBUG:cmdstanpy:input tempfile: /tmp/tmphba_fawk/be6_08ok.json\n", + "DEBUG:cmdstanpy:input tempfile: /tmp/tmphba_fawk/nm242wsb.json\n", + "DEBUG:cmdstanpy:idx 0\n", + "DEBUG:cmdstanpy:running CmdStan, num_threads: None\n", + "DEBUG:cmdstanpy:CmdStan args: ['/usr/local/lib/python3.12/dist-packages/prophet/stan_model/prophet_model.bin', 'random', 'seed=55719', 'data', 'file=/tmp/tmphba_fawk/be6_08ok.json', 'init=/tmp/tmphba_fawk/nm242wsb.json', 'output', 'file=/tmp/tmphba_fawk/prophet_modelqmtc909h/prophet_model-20251002184250.csv', 'method=optimize', 'algorithm=lbfgs', 'iter=10000']\n", + "18:42:50 - cmdstanpy - INFO - Chain [1] start processing\n", + "INFO:cmdstanpy:Chain [1] start processing\n", + "18:42:50 - cmdstanpy - INFO - Chain [1] done processing\n", + "INFO:cmdstanpy:Chain [1] done processing\n", + "DEBUG:cmdstanpy:input tempfile: /tmp/tmphba_fawk/0anx4d9q.json\n", + "DEBUG:cmdstanpy:input tempfile: /tmp/tmphba_fawk/8b8w34q2.json\n", + "DEBUG:cmdstanpy:idx 0\n", + "DEBUG:cmdstanpy:running CmdStan, num_threads: None\n", + "DEBUG:cmdstanpy:CmdStan args: ['/usr/local/lib/python3.12/dist-packages/prophet/stan_model/prophet_model.bin', 'random', 'seed=51703', 'data', 'file=/tmp/tmphba_fawk/0anx4d9q.json', 'init=/tmp/tmphba_fawk/8b8w34q2.json', 'output', 'file=/tmp/tmphba_fawk/prophet_modelgjk3_rs6/prophet_model-20251002184250.csv', 'method=optimize', 'algorithm=lbfgs', 'iter=10000']\n", + "18:42:50 - cmdstanpy - INFO - Chain [1] start processing\n", + "INFO:cmdstanpy:Chain [1] start processing\n", + "18:42:50 - cmdstanpy - INFO - Chain [1] done processing\n", + "INFO:cmdstanpy:Chain [1] done processing\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🔍 Evaluating Naive model (baseline)...\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def create_performance_table(results):\n", + " \"\"\"\n", + " Create performance comparison table\n", + " \"\"\"\n", + " comparison_df = pd.DataFrame(results).T\n", + " comparison_df = comparison_df.round(4)\n", + "\n", + " # Highlight best model for each metric\n", + " styled_df = comparison_df.style.highlight_min(subset=['RMSE', 'MAE', 'MAPE', 'MSE'], color='lightgreen')\n", + "\n", + " return comparison_df, styled_df\n", + "\n", + "# Create performance table\n", + "performance_table, styled_table = create_performance_table(performance_results)\n", + "print(\"📊 Performance Comparison:\")\n", + "print(performance_table)\n", + "\n", + "# Display styled table if in notebook environment\n", + "try:\n", + " display(styled_table)\n", + "except:\n", + " pass" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 279 + }, + "id": "CTwj_YaUPYq5", + "outputId": "ff517806-5b4f-4615-c784-c73374be2c8a" + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📊 Performance Comparison:\n", + " RMSE MAE MAPE MSE\n", + "ARIMA 6.6468 4.9774 4.4575 44.1802\n", + "LSTM 6.4420 5.2999 4.8176 41.4990\n", + "Prophet 58.5214 34.8851 32.8064 3424.7571\n", + "Naive 1.7710 1.3556 1.2362 3.1365\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 RMSEMAEMAPEMSE
ARIMA6.6468004.9774004.45750044.180200
LSTM6.4420005.2999004.81760041.499000
Prophet58.52140034.88510032.8064003424.757100
Naive1.7710001.3556001.2362003.136500
\n" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "def plot_forecast_comparison(actual, forecasts_dict, title=\"Forecast Comparison\"):\n", + " \"\"\"\n", + " Plot comparison of different model forecasts\n", + " \"\"\"\n", + " plt.figure(figsize=(15, 10))\n", + "\n", + " # Plot actual values\n", + " plt.plot(actual, label='Actual', linewidth=3, color='black', alpha=0.8)\n", + "\n", + " # Plot forecasts\n", + " colors = ['red', 'blue', 'green', 'orange']\n", + " for i, (model_name, forecast) in enumerate(forecasts_dict.items()):\n", + " plt.plot(forecast, label=model_name, color=colors[i], alpha=0.7, linewidth=2)\n", + "\n", + " plt.title(title, fontsize=16, fontweight='bold')\n", + " plt.xlabel('Time Steps', fontsize=12)\n", + " plt.ylabel('Price', fontsize=12)\n", + " plt.legend(fontsize=12)\n", + " plt.grid(True, alpha=0.3)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "# Plot results\n", + "forecasts_dict = {\n", + " 'ARIMA': arima_forecasts,\n", + " 'LSTM': lstm_forecasts,\n", + " 'Prophet': prophet_forecasts,\n", + " 'Naive': naive_forecasts\n", + "}\n", + "plot_forecast_comparison(actuals, forecasts_dict)\n", + "\n", + "# Plot individual model performance\n", + "def plot_individual_forecasts(actual, forecasts_dict):\n", + " \"\"\"\n", + " Plot individual model forecasts in subplots\n", + " \"\"\"\n", + " fig, axes = plt.subplots(2, 2, figsize=(15, 10))\n", + " axes = axes.flatten()\n", + "\n", + " for i, (model_name, forecast) in enumerate(forecasts_dict.items()):\n", + " if i < len(axes):\n", + " axes[i].plot(actual, label='Actual', color='black', linewidth=2)\n", + " axes[i].plot(forecast, label=model_name, color=['red', 'blue', 'green', 'orange'][i], linewidth=2)\n", + " axes[i].set_title(f'{model_name} Forecast', fontsize=14, fontweight='bold')\n", + " axes[i].set_xlabel('Time Steps')\n", + " axes[i].set_ylabel('Price')\n", + " axes[i].legend()\n", + " axes[i].grid(True, alpha=0.3)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "plot_individual_forecasts(actuals, forecasts_dict)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "hissbIRQPfnJ", + "outputId": "0600e003-6ff0-4169-a14f-e3ba45c2870e" + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file