financial_bert_monthly_prediction_training_from_embedding_v1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "gpuType": "V100",
      "authorship_tag": "ABX9TyN3sh1zswnSDRWK8KyZAzVS",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/gitHubAndyLee2020/FinanceBERT/blob/main/financial_bert_monthly_prediction_training_from_embedding_v1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### FinancialBERT Monthly Prediction Training from Embedding v1"
      ],
      "metadata": {
        "id": "uNVKG-IgoerS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Data Preparation"
      ],
      "metadata": {
        "id": "OFpIQ5Yc53kW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Upload training_data.jsonl file into a variable called \"training_data\"\n",
        "# Upload zipped stock_data folder\n",
        "from google.colab import files\n",
        "\n",
        "uploaded = files.upload()"
      ],
      "metadata": {
        "id": "oIK_r5N2Nktk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!unzip stock_data.zip\n",
        "!rm stock_data.zip"
      ],
      "metadata": {
        "id": "xizAqnWDNx-6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Prepare stock price history data\n",
        "import json\n",
        "import os\n",
        "\n",
        "# Path to your folder containing .jsonl files\n",
        "folder_path = 'stock_data/'\n",
        "\n",
        "# Initialize an empty list to store the dictionaries from all files\n",
        "stock_price_history_data_list = []\n",
        "\n",
        "# Iterate over each file in the folder\n",
        "for filename in os.listdir(folder_path):\n",
        "    if filename.endswith('.jsonl'):\n",
        "        file_path = os.path.join(folder_path, filename)\n",
        "\n",
        "        # Open and read each file\n",
        "        with open(file_path, 'r') as file:\n",
        "            for line in file:\n",
        "                # Convert each line into a dictionary and append to the list\n",
        "                stock_price_history_data_list.append(json.loads(line))\n",
        "\n",
        "stock_price_history_data = {}\n",
        "\n",
        "for entry in stock_price_history_data_list:\n",
        "    if entry['stock'] not in stock_price_history_data:\n",
        "        stock_price_history_data[entry['stock']] = {}\n",
        "    stock_price_history_data[entry['stock']][entry['month_year']] = {\n",
        "        'this_month_vw': entry['this_month_vw'],\n",
        "        'next_month_vw': entry['next_month_vw'],\n",
        "        'percentage_change': entry['percentage_change'],\n",
        "    }"
      ],
      "metadata": {
        "id": "54rA2y4gN4eo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Prepare training data\n",
        "import json\n",
        "\n",
        "# Path to your .jsonl file\n",
        "file_path = 'cleaned_training_data.jsonl'\n",
        "\n",
        "# Initialize an empty list to store the dictionaries\n",
        "training_data_list = []\n",
        "\n",
        "# Open the file and read line by line\n",
        "with open(file_path, 'r') as file:\n",
        "    for line in file:\n",
        "        # Convert each line into a dictionary and append to the list\n",
        "        training_data_list.append(json.loads(line))\n",
        "\n",
        "training_data = {}\n",
        "\n",
        "for entry in training_data_list:\n",
        "    if entry['stock'] not in training_data:\n",
        "        training_data[entry['stock']] = {}\n",
        "    training_data[entry['stock']][entry['month_year']] = entry['data']"
      ],
      "metadata": {
        "id": "iFTGDUokN29m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock_price_history_data['A']['2019-02'], training_data['A']['2019-02']"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YhF-RtVcRH8h",
        "outputId": "7c77dae0-907b-4f37-e23f-e3674500b601"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "({'this_month_vw': 77.448,\n",
              "  'next_month_vw': 80.0518,\n",
              "  'percentage_change': 0.03361997727507498},\n",
              " [{'title': 'Barclays Maintains Overweight on Agilent Technologies, Raises Price Target to $83',\n",
              "   'date': '2019-02-21 08:00:00-05:00'},\n",
              "  {'title': 'UPDATE: Agilent Raises FY19 Adj. EPS Guidance From $3-$3.05 To $3.03-$3.07 vs $3.05 Estimate, Sales From $5.13B-$5.17B To $5.15B-$5.19B vs $5.17B Est.',\n",
              "   'date': '2019-02-20 16:07:00-05:00'},\n",
              "  {'title': 'Agilent Sees Q2 Adj. EPS $0.70-$0.72 vs $0.72 Estimate, Sales $1.255B-$1.27B vs $1.27B Est.; Raises FY19 Guidance',\n",
              "   'date': '2019-02-20 16:06:00-05:00'},\n",
              "  {'title': 'Agilent Technologies Q1 EPS $0.76 Beats $0.73 Estimate, Sales $1.284B Beat $1.27B Estimate',\n",
              "   'date': '2019-02-20 16:05:00-05:00'},\n",
              "  {'title': '10 Stocks To Watch For February 20, 2019',\n",
              "   'date': '2019-02-20 04:33:00-05:00'},\n",
              "  {'title': 'Earnings Scheduled For February 20, 2019',\n",
              "   'date': '2019-02-20 04:04:00-05:00'},\n",
              "  {'title': 'JANA 13F Shows Liquidated Stakes In Alibaba, Agilent, US Steel, SVMK, Electronic Arts, Dollar Tree',\n",
              "   'date': '2019-02-14 09:36:00-05:00'},\n",
              "  {'title': '8 Biggest Price Target Changes For Tuesday',\n",
              "   'date': '2019-02-12 09:57:00-05:00'},\n",
              "  {'title': 'Deutsche Bank Maintains Buy on Agilent Technologies, Raises Price Target to $85',\n",
              "   'date': '2019-02-12 08:34:00-05:00'}])"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Group Entries by Published Dates"
      ],
      "metadata": {
        "id": "d7vlcx1SFRb2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Format train/test dataset\n",
        "presplit_texts = []\n",
        "presplit_targets = []\n",
        "\n",
        "for ticker in stock_price_history_data.keys():\n",
        "    for month_year in stock_price_history_data[ticker].keys():\n",
        "        if month_year in training_data[ticker]:\n",
        "            headlines = [item['title'] for item in training_data[ticker][month_year]]\n",
        "            # Group headlines by 5 items, skip leftovers\n",
        "            # Each item in a group joined by periods\n",
        "            length = len(headlines) - len(headlines) % 5\n",
        "            for i in range(0, length, 5):\n",
        "                presplit_texts.append('. '.join(headlines[i:i+5]) + '.')\n",
        "                presplit_targets.append(stock_price_history_data[ticker][month_year]['percentage_change'])"
      ],
      "metadata": {
        "id": "zFFAkrNWSneT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "# Randomly split the dataset into train and test sets\n",
        "texts, test_texts, targets, test_targets = train_test_split(\n",
        "    presplit_texts, presplit_targets, test_size=0.1, random_state=42\n",
        ")"
      ],
      "metadata": {
        "id": "Ig0xxfy6VQa7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Model Definition"
      ],
      "metadata": {
        "id": "LPiwgMI356yu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "from torch import nn\n",
        "from transformers import BertModel, BertTokenizer"
      ],
      "metadata": {
        "id": "XZc4CfRtogI7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(\"Using device:\", device)"
      ],
      "metadata": {
        "id": "kXzLGjlpaM36"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class FinBERTRegressor(nn.Module):\n",
        "    def __init__(self, finbert_model_name=\"ProsusAI/finbert\", hidden_size=768, output_size=1):\n",
        "        super(FinBERTRegressor, self).__init__()\n",
        "        # Load the FinBERT model\n",
        "        self.finbert = BertModel.from_pretrained(finbert_model_name)\n",
        "\n",
        "        # Regression layer\n",
        "        self.regressor = nn.Linear(hidden_size, output_size)\n",
        "\n",
        "    def forward(self, input_ids, attention_mask, token_type_ids=None):\n",
        "        # Get embeddings from FinBERT\n",
        "        with torch.no_grad():  # No need to calculate gradients for FinBERT\n",
        "            outputs = self.finbert(input_ids=input_ids, attention_mask=attention_mask)\n",
        "\n",
        "        # We use the [CLS] token's embedding for regression\n",
        "        cls_embedding = outputs.last_hidden_state[:, 0, :]\n",
        "\n",
        "        # Pass through the regression layer\n",
        "        return self.regressor(cls_embedding)"
      ],
      "metadata": {
        "id": "x0n4y77BojDa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = FinBERTRegressor()\n",
        "model.to(device)  # Move the model to the GPU"
      ],
      "metadata": {
        "id": "XX_FBg4Pom2b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tokenizer = BertTokenizer.from_pretrained(\"ProsusAI/finbert\")"
      ],
      "metadata": {
        "id": "b3ALocJnopcN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Dataset Processing"
      ],
      "metadata": {
        "id": "5_rmNJkb599x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from torch.utils.data import DataLoader, TensorDataset\n",
        "import torch.optim as optim\n",
        "from tqdm import tqdm  # Import tqdm\n",
        "\n",
        "# Assuming 'texts' is your list of texts to be tokenized\n",
        "input_ids = []\n",
        "attention_masks = []\n",
        "\n",
        "# Wrap the iteration over texts with tqdm\n",
        "for text in tqdm(texts, desc=\"Tokenizing\"):\n",
        "    encoded_dict = tokenizer.encode_plus(\n",
        "                        text,\n",
        "                        add_special_tokens=True,\n",
        "                        max_length=64,\n",
        "                        pad_to_max_length=True,\n",
        "                        return_attention_mask=True,\n",
        "                        return_tensors='pt',\n",
        "                   )\n",
        "\n",
        "    input_ids.append(encoded_dict['input_ids'])\n",
        "    attention_masks.append(encoded_dict['attention_mask'])\n",
        "\n",
        "input_ids = torch.cat(input_ids, dim=0)\n",
        "attention_masks = torch.cat(attention_masks, dim=0)\n",
        "targets = torch.tensor(targets)\n",
        "\n",
        "# Create TensorDataset\n",
        "dataset = TensorDataset(input_ids, attention_masks, targets)\n",
        "\n",
        "# DataLoader\n",
        "batch_size = 16\n",
        "dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)\n",
        "\n",
        "# Loss function\n",
        "loss_fn = nn.MSELoss()\n",
        "\n",
        "# Optimizer\n",
        "optimizer = optim.Adam(model.parameters(), lr=1e-5)"
      ],
      "metadata": {
        "id": "4iOzcjVWqQIu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Tokenize the test data\n",
        "test_input_ids = []\n",
        "test_attention_masks = []\n",
        "\n",
        "for text in tqdm(test_texts, desc=\"Tokenizing Test Data\"):\n",
        "    encoded_dict = tokenizer.encode_plus(\n",
        "                        text,\n",
        "                        add_special_tokens=True,\n",
        "                        max_length=64,\n",
        "                        pad_to_max_length=True,\n",
        "                        return_attention_mask=True,\n",
        "                        return_tensors='pt',\n",
        "                   )\n",
        "\n",
        "    test_input_ids.append(encoded_dict['input_ids'])\n",
        "    test_attention_masks.append(encoded_dict['attention_mask'])\n",
        "\n",
        "test_input_ids = torch.cat(test_input_ids, dim=0)\n",
        "test_attention_masks = torch.cat(test_attention_masks, dim=0)\n",
        "test_targets = torch.tensor(test_targets)\n",
        "\n",
        "# Create TensorDataset for test data\n",
        "test_dataset = TensorDataset(test_input_ids, test_attention_masks, test_targets)\n",
        "\n",
        "# Create DataLoader for test data\n",
        "test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)"
      ],
      "metadata": {
        "id": "3mfTHBk-cDN8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Training Loop"
      ],
      "metadata": {
        "id": "lN_Xsmxj6E03"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "avg_train_loss_history = []\n",
        "avg_test_loss_history = []\n",
        "# Initialize variables to track the best test loss and corresponding epoch\n",
        "best_test_loss = float('inf')\n",
        "best_epoch = 0"
      ],
      "metadata": {
        "id": "Gq55_4eTdKYE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "start_epoch = 1 # inclusive\n",
        "end_epoch = 51 # exclusive"
      ],
      "metadata": {
        "id": "rl4ANH_jdPTS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Check if the model directory exists, if not, create it\n",
        "model_dir = 'model'\n",
        "if not os.path.exists(model_dir):\n",
        "    os.makedirs(model_dir)\n",
        "\n",
        "# Training Loop\n",
        "for epoch in range(start_epoch, end_epoch):\n",
        "    # Training Phase\n",
        "    model.train()\n",
        "    total_train_loss = 0\n",
        "\n",
        "    progress_bar = tqdm(dataloader, desc=f'Epoch {epoch}/{end_epoch - 1}')\n",
        "    for batch in progress_bar:\n",
        "        b_input_ids, b_input_mask, b_labels = [b.to(device) for b in batch]\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(b_input_ids, b_input_mask)\n",
        "        loss = loss_fn(outputs.squeeze(), b_labels.float())\n",
        "        total_train_loss += loss.item()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        progress_bar.set_description(f\"Epoch {epoch}/{end_epoch - 1} - Train Loss: {loss.item():.2f}\")\n",
        "\n",
        "    avg_train_loss = total_train_loss / len(dataloader)\n",
        "    avg_train_loss_history.append(avg_train_loss)\n",
        "    print(f'Epoch {epoch}/{end_epoch - 1} - Avg Train Loss: {avg_train_loss:.2f}')\n",
        "\n",
        "    # Evaluation Phase\n",
        "    model.eval()\n",
        "    total_test_loss = 0\n",
        "    with torch.no_grad():\n",
        "        for batch in test_dataloader:\n",
        "            b_input_ids, b_input_mask, b_labels = [b.to(device) for b in batch]\n",
        "            outputs = model(b_input_ids, b_input_mask)\n",
        "            loss = loss_fn(outputs.squeeze(), b_labels.float())\n",
        "            total_test_loss += loss.item()\n",
        "\n",
        "    avg_test_loss = total_test_loss / len(test_dataloader)\n",
        "    avg_test_loss_history.append(avg_test_loss)\n",
        "    print(f'Epoch {epoch}/{end_epoch - 1} - Avg Test Loss: {avg_test_loss:.2f}')\n",
        "\n",
        "    # Keep track of the best epoch\n",
        "    if avg_test_loss < best_test_loss:\n",
        "        best_test_loss = avg_test_loss\n",
        "        best_epoch = epoch\n",
        "\n",
        "    # Save the model weights\n",
        "    model_save_path = os.path.join(model_dir, f'model_epoch_{epoch}.pth')\n",
        "    torch.save(model.regressor.state_dict(), model_save_path)\n",
        "    print(f'Model saved for epoch {epoch} at {model_save_path}')"
      ],
      "metadata": {
        "id": "LxStoBohXDBz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Examples Inputs & Outputs"
      ],
      "metadata": {
        "id": "bJaX4zSm6G4n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assuming 'model' is your PyTorch model and 'tokenizer' is your tokenizer\n",
        "text = \"Google stock rises 200% during this year's 3rd quarter.\"\n",
        "\n",
        "# Tokenize the text\n",
        "inputs = tokenizer(text, return_tensors=\"pt\", truncation=True, padding=True, max_length=512)\n",
        "\n",
        "# Move the inputs to the same device as the model\n",
        "inputs = {k: v.to(device) for k, v in inputs.items()}\n",
        "\n",
        "# Generate output\n",
        "output = model(**inputs)\n",
        "\n",
        "print(f\"Prediction is {abs(output.item()) * 100:.2f}% {'rise' if output.item() > 0 else 'fall'} in the stock price during next month.\")"
      ],
      "metadata": {
        "id": "Ka7cRbMXou1J",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "984cbd09-ec84-4c32-e4b1-41926aac7c62"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Prediction is 2.43% rise in the stock price during next month.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Assuming 'model' is your PyTorch model and 'tokenizer' is your tokenizer\n",
        "text = \"Google stock crashs and the company files for backruptcy\"\n",
        "\n",
        "# Tokenize the text\n",
        "inputs = tokenizer(text, return_tensors=\"pt\", truncation=True, padding=True, max_length=512)\n",
        "\n",
        "# Move the inputs to the same device as the model\n",
        "inputs = {k: v.to(device) for k, v in inputs.items()}\n",
        "\n",
        "# Generate output\n",
        "output = model(**inputs)\n",
        "\n",
        "print(f\"Prediction is {abs(output.item()) * 100:.2f}% {'rise' if output.item() > 0 else 'fall'} in the stock price during next month.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IyZWQ0ys2Uh4",
        "outputId": "27e92643-5dff-454e-e1d1-fef29e21d0c6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Prediction is 1.67% fall in the stock price during next month.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Training Statistics"
      ],
      "metadata": {
        "id": "wS1wnCOA6J2s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the best epoch and its test loss after all epochs are completed\n",
        "print(f'Best epoch: {best_epoch} with Test Loss: {best_test_loss:.2f}')"
      ],
      "metadata": {
        "id": "hBlrq_c9kalh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Creating the plot\n",
        "plt.figure(figsize=(10, 6))  # Optional: You can adjust the figure size\n",
        "plt.plot(avg_train_loss_history, linestyle='-', color='b')  # Line plot without markers\n",
        "\n",
        "# Adding title and labels\n",
        "plt.title('Loss Over Time (Train Avg Loss)')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "\n",
        "# Optionally, add a grid for easier reading\n",
        "plt.grid(True)\n",
        "\n",
        "# Show the plot\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        },
        "id": "CaosdSgvdkCH",
        "outputId": "19b6e194-7b1e-47c3-fb54-587f3a9fa010"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Creating the plot\n",
        "plt.figure(figsize=(10, 6))  # Optional: You can adjust the figure size\n",
        "plt.plot(avg_test_loss_history, linestyle='-', color='b')  # Line plot without markers\n",
        "\n",
        "# Adding title and labels\n",
        "plt.title('Loss Over Time (Test Avg Loss)')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "\n",
        "# Optionally, add a grid for easier reading\n",
        "plt.grid(True)\n",
        "\n",
        "# Show the plot\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        },
        "id": "ObmckHnsdnJl",
        "outputId": "151b106f-bcd0-4c96-b204-9f2a41d62e88"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Model Information"
      ],
      "metadata": {
        "id": "-uaRpW2w6Sxt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate the number of parameters\n",
        "total_params = sum(p.numel() for p in model.regressor.parameters())\n",
        "\n",
        "print(f\"Total number of parameters: {total_params}\")"
      ],
      "metadata": {
        "id": "wFHHPVSvu8UM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!ls -lh model/model_epoch_1.pth"
      ],
      "metadata": {
        "id": "W8fbZuHsvPYa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Downloading Model Data"
      ],
      "metadata": {
        "id": "6U2aOEQV6NFz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "from google.colab import files\n",
        "\n",
        "# Example dictionary\n",
        "data = {\n",
        "    'batch_size': batch_size,\n",
        "    'learning_rate': 1e-5,\n",
        "    'num_epochs': 50,\n",
        "    'best_epoch': best_epoch,\n",
        "    'best_test_loss': best_test_loss,\n",
        "    'avg_train_loss_history': avg_train_loss_history,\n",
        "    'avg_test_loss_history': avg_test_loss_history,\n",
        "}\n",
        "\n",
        "# Convert dictionary to JSON formatted string\n",
        "json_data = json.dumps(data, indent=4)\n",
        "\n",
        "# Write JSON data to a file\n",
        "filename = 'model_training_data_v1.json'\n",
        "with open(filename, 'w') as file:\n",
        "    file.write(json_data)\n",
        "\n",
        "# Download the file to your local system\n",
        "files.download(filename)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "VHiEdY8Qss-8",
        "outputId": "9f8eac6d-69cf-4c36-c1c1-788dacb62ebc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_b682a488-a73b-44f5-b14c-dc86245b2c5e\", \"model_training_data_v1.json\", 3092)"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Download the best model weight to your local system\n",
        "files.download(f'model/model_epoch_{best_epoch}.pth')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "9PjM4TW1zJKb",
        "outputId": "d153f499-6f2f-4e2d-e57a-497dffcaa0d6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_810aef48-e9c6-4f2a-9b1d-61db633b8a6f\", \"model_epoch_47.pth\", 438016315)"
            ]
          },
          "metadata": {}
        }
      ]
    }
  ]
}