diff --git a/Assignment 4/Assignment4_ADITI.ipynb b/Assignment 4/Assignment4_ADITI.ipynb
new file mode 100644
index 0000000..f2f6ebd
--- /dev/null
+++ b/Assignment 4/Assignment4_ADITI.ipynb	
@@ -0,0 +1,737 @@
+{
+  "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": 2,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "sZ3E5mybgsU2",
+        "outputId": "5cc96ed7-7dd8-40fa-b4b4-19681ba859e0"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: yfinance in /usr/local/lib/python3.12/dist-packages (0.2.66)\n",
+            "Requirement already satisfied: mplfinance in /usr/local/lib/python3.12/dist-packages (0.12.10b0)\n",
+            "Requirement already satisfied: opencv-python in /usr/local/lib/python3.12/dist-packages (4.12.0.88)\n",
+            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.12/dist-packages (1.6.1)\n",
+            "Requirement already satisfied: torch in /usr/local/lib/python3.12/dist-packages (2.9.0+cpu)\n",
+            "Requirement already satisfied: torchvision in /usr/local/lib/python3.12/dist-packages (0.24.0+cpu)\n",
+            "Requirement already satisfied: pandas>=1.3.0 in /usr/local/lib/python3.12/dist-packages (from yfinance) (2.2.2)\n",
+            "Requirement already satisfied: numpy>=1.16.5 in /usr/local/lib/python3.12/dist-packages (from yfinance) (2.0.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.5.1)\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.7)\n",
+            "Requirement already satisfied: peewee>=3.16.2 in /usr/local/lib/python3.12/dist-packages (from yfinance) (3.18.3)\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: matplotlib in /usr/local/lib/python3.12/dist-packages (from mplfinance) (3.10.0)\n",
+            "Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.16.3)\n",
+            "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.5.3)\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: filelock in /usr/local/lib/python3.12/dist-packages (from torch) (3.20.0)\n",
+            "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.12/dist-packages (from torch) (4.15.0)\n",
+            "Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from torch) (75.2.0)\n",
+            "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.12/dist-packages (from torch) (1.14.0)\n",
+            "Requirement already satisfied: networkx>=2.5.1 in /usr/local/lib/python3.12/dist-packages (from torch) (3.6.1)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.12/dist-packages (from torch) (3.1.6)\n",
+            "Requirement already satisfied: fsspec>=0.8.5 in /usr/local/lib/python3.12/dist-packages (from torch) (2025.3.0)\n",
+            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.12/dist-packages (from torchvision) (11.3.0)\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: 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.11.12)\n",
+            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.12/dist-packages (from pandas>=1.3.0->yfinance) (2.9.0.post0)\n",
+            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas>=1.3.0->yfinance) (2025.3)\n",
+            "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests>=2.31->yfinance) (3.4.4)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests>=2.31->yfinance) (3.11)\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: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from sympy>=1.13.3->torch) (1.3.0)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.12/dist-packages (from jinja2->torch) (3.0.3)\n",
+            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib->mplfinance) (1.3.3)\n",
+            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib->mplfinance) (0.12.1)\n",
+            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib->mplfinance) (4.61.1)\n",
+            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib->mplfinance) (1.4.9)\n",
+            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib->mplfinance) (25.0)\n",
+            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib->mplfinance) (3.2.5)\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>=2.8.2->pandas>=1.3.0->yfinance) (1.17.0)\n"
+          ]
+        }
+      ],
+      "source": [
+        "!pip install yfinance mplfinance opencv-python scikit-learn torch torchvision\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import cv2\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import yfinance as yf\n",
+        "import mplfinance as mpf\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "from sklearn.metrics import confusion_matrix, classification_report\n",
+        "\n",
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "import torch.optim as optim\n",
+        "from torchvision import datasets, transforms\n",
+        "from torch.utils.data import DataLoader\n"
+      ],
+      "metadata": {
+        "id": "scpPR8k3igDw"
+      },
+      "execution_count": 3,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "stocks = ['AAPL', 'MSFT', 'GOOG', 'AMZN', 'TSLA']\n",
+        "start_date = '2023-01-01'\n",
+        "end_date = '2025-01-01'\n",
+        "\n",
+        "data = {}\n",
+        "\n",
+        "for stock in stocks:\n",
+        "    df = yf.download(stock, start=start_date, end=end_date)\n",
+        "    df = df[['Open', 'High', 'Low', 'Close', 'Volume']]\n",
+        "    data[stock] = df\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ZlyYkE98ikiR",
+        "outputId": "490af3ae-dad2-414c-e8a4-3230f3e11a41"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/tmp/ipython-input-4240685054.py:8: FutureWarning: YF.download() has changed argument auto_adjust default to True\n",
+            "  df = yf.download(stock, start=start_date, end=end_date)\n",
+            "[*********************100%***********************]  1 of 1 completed\n",
+            "/tmp/ipython-input-4240685054.py:8: FutureWarning: YF.download() has changed argument auto_adjust default to True\n",
+            "  df = yf.download(stock, start=start_date, end=end_date)\n",
+            "[*********************100%***********************]  1 of 1 completed\n",
+            "/tmp/ipython-input-4240685054.py:8: FutureWarning: YF.download() has changed argument auto_adjust default to True\n",
+            "  df = yf.download(stock, start=start_date, end=end_date)\n",
+            "[*********************100%***********************]  1 of 1 completed\n",
+            "/tmp/ipython-input-4240685054.py:8: FutureWarning: YF.download() has changed argument auto_adjust default to True\n",
+            "  df = yf.download(stock, start=start_date, end=end_date)\n",
+            "[*********************100%***********************]  1 of 1 completed\n",
+            "/tmp/ipython-input-4240685054.py:8: FutureWarning: YF.download() has changed argument auto_adjust default to True\n",
+            "  df = yf.download(stock, start=start_date, end=end_date)\n",
+            "[*********************100%***********************]  1 of 1 completed\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "os.makedirs(\"images\", exist_ok=True)\n"
+      ],
+      "metadata": {
+        "id": "_SMJymTyipjF"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df = yf.download(stock, start=start_date, end=end_date)\n",
+        "\n",
+        "df.columns = df.columns.get_level_values(0)\n",
+        "\n",
+        "df = df[['Open', 'High', 'Low', 'Close', 'Volume']]\n",
+        "\n",
+        "df = df.apply(pd.to_numeric, errors='coerce')\n",
+        "df.dropna(inplace=True)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "W5FcmerEjaj4",
+        "outputId": "c26c2e65-7264-489b-f8a7-f3e461a850bd"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/tmp/ipython-input-2670428902.py:1: FutureWarning: YF.download() has changed argument auto_adjust default to True\n",
+            "  df = yf.download(stock, start=start_date, end=end_date)\n",
+            "[*********************100%***********************]  1 of 1 completed\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "window = 20\n",
+        "img_count = 0\n",
+        "\n",
+        "os.makedirs(\"images\", exist_ok=True)\n",
+        "\n",
+        "for stock, df in data.items():\n",
+        "\n",
+        "\n",
+        "    df.columns = df.columns.get_level_values(0)\n",
+        "\n",
+        "    df = df[['Open', 'High', 'Low', 'Close', 'Volume']]\n",
+        "\n",
+        "    df = df.apply(pd.to_numeric, errors='coerce')\n",
+        "    df.dropna(inplace=True)\n",
+        "\n",
+        "    for i in range(len(df) - window):\n",
+        "        window_df = df.iloc[i:i+window]\n",
+        "\n",
+        "        save_path = f\"images/{stock}_{img_count}.png\"\n",
+        "\n",
+        "        mpf.plot(\n",
+        "            window_df,\n",
+        "            type='candle',\n",
+        "            style='charles',\n",
+        "            savefig=save_path\n",
+        "        )\n",
+        "        plt.close()\n",
+        "        img_count += 1\n",
+        "\n",
+        "print(\"Total images created:\", img_count)\n",
+        "\n",
+        "\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "yyHZG7ZhisQp",
+        "outputId": "8648d2e9-412c-42fb-d5d4-80e4ab5bf8aa"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Total images created: 2410\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print(df.dtypes)\n",
+        "\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "TEMS8UY3jIAW",
+        "outputId": "cc9c80bf-f54d-4ff8-857e-84e9719a3cfb"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "metadata": {
+            "tags": null
+          },
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Price\n",
+            "Open      float64\n",
+            "High      float64\n",
+            "Low       float64\n",
+            "Close     float64\n",
+            "Volume      int64\n",
+            "dtype: object\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def detect_doji(row):\n",
+        "    return abs(row['Open'] - row['Close']) <= (row['High'] - row['Low']) * 0.1\n",
+        "\n",
+        "def detect_hammer(row):\n",
+        "    body = abs(row['Open'] - row['Close'])\n",
+        "    lower_wick = min(row['Open'], row['Close']) - row['Low']\n",
+        "    return lower_wick > body * 2\n"
+      ],
+      "metadata": {
+        "id": "wz3OvTaYlJuX"
+      },
+      "execution_count": 9,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "labels = []\n",
+        "image_names = []\n",
+        "\n",
+        "window = 20\n",
+        "img_count = 0\n",
+        "\n",
+        "os.makedirs(\"images\", exist_ok=True)\n",
+        "\n",
+        "for stock, df in data.items():\n",
+        "\n",
+        "\n",
+        "    df.columns = df.columns.get_level_values(0)\n",
+        "    df = df[['Open', 'High', 'Low', 'Close', 'Volume']]\n",
+        "    df = df.apply(pd.to_numeric, errors='coerce')\n",
+        "    df.dropna(inplace=True)\n",
+        "\n",
+        "    for i in range(len(df) - window):\n",
+        "        window_df = df.iloc[i:i+window]\n",
+        "        last_candle = window_df.iloc[-1]\n",
+        "\n",
+        "        label = None\n",
+        "        if detect_doji(last_candle):\n",
+        "            label = 0\n",
+        "        elif detect_hammer(last_candle):\n",
+        "            label = 1\n",
+        "        else:\n",
+        "            continue\n",
+        "\n",
+        "        save_path = f\"images/{stock}_{img_count}.png\"\n",
+        "\n",
+        "        mpf.plot(\n",
+        "            window_df,\n",
+        "            type='candle',\n",
+        "            style='charles',\n",
+        "            savefig=save_path\n",
+        "        )\n",
+        "        plt.close()\n",
+        "\n",
+        "        labels.append(label)\n",
+        "        image_names.append(f\"{stock}_{img_count}.png\")\n",
+        "        img_count += 1\n",
+        "\n",
+        "print(\"Total labeled images:\", len(labels))\n",
+        "\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "rUtnEqCLlLrl",
+        "outputId": "119ecc80-2b97-449e-b3b7-a9dca7659f32"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Total labeled images: 523\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.model_selection import train_test_split\n",
+        "\n",
+        "X_train, X_temp, y_train, y_temp = train_test_split(\n",
+        "    image_names, labels, test_size=0.3, shuffle=True, stratify=labels\n",
+        ")\n",
+        "\n",
+        "X_val, X_test, y_val, y_test = train_test_split(\n",
+        "    X_temp, y_temp, test_size=0.5, shuffle=True, stratify=y_temp\n",
+        ")\n",
+        "\n",
+        "print(len(X_train), len(X_val), len(X_test))\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "jjRhIam-nFdo"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from PIL import Image\n",
+        "from torchvision import transforms\n",
+        "from torch.utils.data import Dataset, DataLoader\n"
+      ],
+      "metadata": {
+        "id": "EhkkuHbqnKfE"
+      },
+      "execution_count": 14,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "transform = transforms.Compose([\n",
+        "    transforms.Resize((128, 128)),\n",
+        "    transforms.RandomHorizontalFlip(),\n",
+        "    transforms.ColorJitter(brightness=0.2, contrast=0.2),\n",
+        "    transforms.ToTensor()\n",
+        "])\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "DuKRJ1senNCx"
+      },
+      "execution_count": 13,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class CandleDataset(Dataset):\n",
+        "    def __init__(self, image_files, labels, transform=None):\n",
+        "        self.image_files = image_files\n",
+        "        self.labels = labels\n",
+        "        self.transform = transform\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        return len(self.image_files)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        img_path = os.path.join(\"images\", self.image_files[idx])\n",
+        "        image = Image.open(img_path).convert(\"RGB\")\n",
+        "\n",
+        "        if self.transform:\n",
+        "            image = self.transform(image)\n",
+        "\n",
+        "        return image, self.labels[idx]\n"
+      ],
+      "metadata": {
+        "id": "ktxMKijMnPgh"
+      },
+      "execution_count": 15,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "train_loader = DataLoader(\n",
+        "    CandleDataset(X_train, y_train, transform),\n",
+        "    batch_size=32, shuffle=True\n",
+        ")\n",
+        "\n",
+        "val_loader = DataLoader(\n",
+        "    CandleDataset(X_val, y_val, transform),\n",
+        "    batch_size=32, shuffle=False\n",
+        ")\n",
+        "\n",
+        "test_loader = DataLoader(\n",
+        "    CandleDataset(X_test, y_test, transform),\n",
+        "    batch_size=32, shuffle=False\n",
+        ")\n"
+      ],
+      "metadata": {
+        "id": "G8sCvowknScG"
+      },
+      "execution_count": 16,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### CNN MODEL"
+      ],
+      "metadata": {
+        "id": "pVdy1_vznaHD"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "import torch.nn as nn\n"
+      ],
+      "metadata": {
+        "id": "OjQPHK4inVK6"
+      },
+      "execution_count": 17,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class CNN(nn.Module):\n",
+        "    def __init__(self, num_classes=3):\n",
+        "        super().__init__()\n",
+        "\n",
+        "        self.features = nn.Sequential(\n",
+        "            nn.Conv2d(3, 32, kernel_size=3, padding=1),\n",
+        "            nn.ReLU(),\n",
+        "            nn.MaxPool2d(2),\n",
+        "\n",
+        "            nn.Conv2d(32, 64, kernel_size=3, padding=1),\n",
+        "            nn.ReLU(),\n",
+        "            nn.MaxPool2d(2),\n",
+        "\n",
+        "            nn.Conv2d(64, 128, kernel_size=3, padding=1),\n",
+        "            nn.ReLU(),\n",
+        "            nn.AdaptiveAvgPool2d((1, 1))\n",
+        "        )\n",
+        "\n",
+        "        self.classifier = nn.Sequential(\n",
+        "            nn.Flatten(),\n",
+        "            nn.Linear(128, num_classes)\n",
+        "        )\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        x = self.features(x)\n",
+        "        x = self.classifier(x)\n",
+        "        return x\n"
+      ],
+      "metadata": {
+        "id": "fFH20vKEngc5"
+      },
+      "execution_count": 18,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "model = CNN(num_classes=2).to(device)\n",
+        "\n",
+        "criterion = nn.CrossEntropyLoss()\n",
+        "optimizer = torch.optim.Adam(model.parameters(), lr=0.003)\n"
+      ],
+      "metadata": {
+        "id": "6XnzMEuQnjLk"
+      },
+      "execution_count": 19,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "epochs = 25\n",
+        "\n",
+        "for epoch in range(epochs):\n",
+        "    model.train()\n",
+        "    correct = 0\n",
+        "    total = 0\n",
+        "    running_loss = 0.0\n",
+        "\n",
+        "    for images, labels in train_loader:\n",
+        "        images, labels = images.to(device), labels.to(device)\n",
+        "\n",
+        "        optimizer.zero_grad()\n",
+        "        outputs = model(images)\n",
+        "        loss = criterion(outputs, labels)\n",
+        "        loss.backward()\n",
+        "        optimizer.step()\n",
+        "\n",
+        "        running_loss += loss.item()\n",
+        "\n",
+        "        _, preds = torch.max(outputs, 1)\n",
+        "        correct += (preds == labels).sum().item()\n",
+        "        total += labels.size(0)\n",
+        "\n",
+        "    train_acc = 100 * correct / total\n",
+        "    avg_loss = running_loss / len(train_loader)\n",
+        "\n",
+        "    print(f\"Epoch [{epoch+1}/{epochs}] | Loss: {avg_loss:.4f} | Train Acc: {train_acc:.2f}%\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "RpV8xJDtnllC",
+        "outputId": "5234ee31-6e0c-4bcc-9250-7d0dbeb74470"
+      },
+      "execution_count": 20,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch [1/25] | Loss: 0.7093 | Train Acc: 51.91%\n",
+            "Epoch [2/25] | Loss: 0.6945 | Train Acc: 47.81%\n",
+            "Epoch [3/25] | Loss: 0.6940 | Train Acc: 46.72%\n",
+            "Epoch [4/25] | Loss: 0.6928 | Train Acc: 52.19%\n",
+            "Epoch [5/25] | Loss: 0.6921 | Train Acc: 52.19%\n",
+            "Epoch [6/25] | Loss: 0.6919 | Train Acc: 52.19%\n",
+            "Epoch [7/25] | Loss: 0.6947 | Train Acc: 52.19%\n",
+            "Epoch [8/25] | Loss: 0.6917 | Train Acc: 52.19%\n",
+            "Epoch [9/25] | Loss: 0.6930 | Train Acc: 52.19%\n",
+            "Epoch [10/25] | Loss: 0.6928 | Train Acc: 52.19%\n",
+            "Epoch [11/25] | Loss: 0.6925 | Train Acc: 52.19%\n",
+            "Epoch [12/25] | Loss: 0.6913 | Train Acc: 52.19%\n",
+            "Epoch [13/25] | Loss: 0.6931 | Train Acc: 52.19%\n",
+            "Epoch [14/25] | Loss: 0.6920 | Train Acc: 52.19%\n",
+            "Epoch [15/25] | Loss: 0.6914 | Train Acc: 52.19%\n",
+            "Epoch [16/25] | Loss: 0.6928 | Train Acc: 52.19%\n",
+            "Epoch [17/25] | Loss: 0.6920 | Train Acc: 52.19%\n",
+            "Epoch [18/25] | Loss: 0.6930 | Train Acc: 52.19%\n",
+            "Epoch [19/25] | Loss: 0.6924 | Train Acc: 52.19%\n",
+            "Epoch [20/25] | Loss: 0.6919 | Train Acc: 52.19%\n",
+            "Epoch [21/25] | Loss: 0.6930 | Train Acc: 52.19%\n",
+            "Epoch [22/25] | Loss: 0.6919 | Train Acc: 52.19%\n",
+            "Epoch [23/25] | Loss: 0.6921 | Train Acc: 52.19%\n",
+            "Epoch [24/25] | Loss: 0.6923 | Train Acc: 52.19%\n",
+            "Epoch [25/25] | Loss: 0.6928 | Train Acc: 52.19%\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# MODEL EVALUATION"
+      ],
+      "metadata": {
+        "id": "91Nn5_wwoPAd"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.metrics import classification_report, confusion_matrix\n",
+        "import numpy as np\n"
+      ],
+      "metadata": {
+        "id": "uTHEEb7GoKwn"
+      },
+      "execution_count": 21,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "model.eval()\n",
+        "y_true, y_pred = [], []\n",
+        "\n",
+        "with torch.no_grad():\n",
+        "    for images, labels in test_loader:\n",
+        "        images = images.to(device)\n",
+        "        outputs = model(images)\n",
+        "        _, preds = torch.max(outputs, 1)\n",
+        "\n",
+        "        y_true.extend(labels.numpy())\n",
+        "        y_pred.extend(preds.cpu().numpy())\n",
+        "\n",
+        "print(confusion_matrix(y_true, y_pred))\n",
+        "print(classification_report(y_true, y_pred))\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "0lPRkabAoUOR",
+        "outputId": "2c57daa3-4654-4db8-e99e-561e46ac4345"
+      },
+      "execution_count": 22,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[[ 0 38]\n",
+            " [ 0 41]]\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "           0       0.00      0.00      0.00        38\n",
+            "           1       0.52      1.00      0.68        41\n",
+            "\n",
+            "    accuracy                           0.52        79\n",
+            "   macro avg       0.26      0.50      0.34        79\n",
+            "weighted avg       0.27      0.52      0.35        79\n",
+            "\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
+            "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
+            "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
+            "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
+            "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
+            "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "capital = 10000\n",
+        "profit = 0\n",
+        "\n",
+        "for pred in y_pred:\n",
+        "    if pred == 1:        # Hammer → Buy\n",
+        "        profit += 10\n",
+        "    elif pred == 0:      # Doji → Small profit\n",
+        "        profit += 5\n",
+        "\n",
+        "print(\"Initial Capital:\", capital)\n",
+        "print(\"Final Capital:\", capital + profit)\n",
+        ""
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "IM5nhJOCoXPK",
+        "outputId": "b0e5c799-886c-4b4a-cc67-fe4e78524c82"
+      },
+      "execution_count": 23,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Initial Capital: 10000\n",
+            "Final Capital: 10790\n"
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Assignment3/Aditi_assignment3.ipynb b/Assignment3/Aditi_assignment3.ipynb
new file mode 100644
index 0000000..2cecc7e
--- /dev/null
+++ b/Assignment3/Aditi_assignment3.ipynb
@@ -0,0 +1,381 @@
+{
+  "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": "mV-xt9p18i6e",
+        "outputId": "32e786c3-ccce-4048-e126-7a67e3cb5f43"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Dataset URL: https://www.kaggle.com/datasets/raimiazeezbabatunde/candle-image-data\n",
+            "License(s): apache-2.0\n",
+            "Downloading candle-image-data.zip to /content\n",
+            "  0% 0.00/13.4M [00:00<?, ?B/s]\n",
+            "100% 13.4M/13.4M [00:00<00:00, 832MB/s]\n",
+            "DONE\n"
+          ]
+        }
+      ],
+      "source": [
+        "#Downloading dataset\n",
+        "import os\n",
+        "!mkdir -p ~/.kaggle\n",
+        "!cp kaggle.json ~/.kaggle/\n",
+        "!chmod 600 ~/.kaggle/kaggle.json\n",
+        "!kaggle datasets download -d raimiazeezbabatunde/candle-image-data\n",
+        "!unzip -q candle-image-data.zip -d ./candlestick_data\n",
+        "print(\"DONE\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Importing Libraries\n",
+        "import torch\n",
+        "from torch import nn\n",
+        "from torch.utils.data import DataLoader, random_split\n",
+        "import torchvision.transforms as transforms\n",
+        "from torchvision.datasets import ImageFolder\n"
+      ],
+      "metadata": {
+        "id": "UBJpvHYg81dk"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Resizing data and Data Augmentation\n",
+        "train_transform = transforms.Compose([\n",
+        "    transforms.Resize((64,64)),\n",
+        "    transforms.ColorJitter(brightness=0.2),\n",
+        "    transforms.RandomCrop(64, padding=4),\n",
+        "    transforms.ToTensor()\n",
+        "])\n",
+        "\n",
+        "test_transform = transforms.Compose([\n",
+        "    transforms.Resize((64,64)),\n",
+        "    transforms.ToTensor()\n",
+        "])\n",
+        "\n",
+        "# Loading dataset\n",
+        "train_dataset = ImageFolder(\n",
+        "    root = '/content/candlestick_data',\n",
+        "    transform=train_transform\n",
+        ")\n",
+        "test_dataset = ImageFolder(\n",
+        "    root = '/content/candlestick_data',\n",
+        "    transform=test_transform\n",
+        ")\n",
+        "\n",
+        "# Train-Test split\n",
+        "train_size = int(0.8*len(train_dataset))\n",
+        "test_size = len(train_dataset) - train_size\n",
+        "\n",
+        "generator = torch.Generator().manual_seed(11)\n",
+        "\n",
+        "train_data, _ = random_split(train_dataset, [train_size, test_size], generator=generator)\n",
+        "_, test_data   = random_split(train_dataset,  [train_size, test_size], generator=generator)\n",
+        "\n",
+        "\n",
+        "print(f\"Training Data: {len(train_data)} images\")\n",
+        "print(f\"Testing Data: {len(test_data)} images\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "e7fJhKvX87Bk",
+        "outputId": "4b4443c0-3724-4976-8dac-d4706ed0dd77"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Training Data: 1427 images\n",
+            "Testing Data: 357 images\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "batch_size = 32\n",
+        "\n",
+        "train_dataloader = DataLoader(train_data, batch_size=batch_size, shuffle=True)\n",
+        "test_dataloader = DataLoader(test_data, batch_size=batch_size, shuffle=True)\n",
+        "\n",
+        "for X,y in train_dataloader:\n",
+        "  print(f\"Shape of X: {X.shape}\")  #[batchsize, channels(rbg), height, width]\n",
+        "  print(f\"Shape of y: {y.shape}\")\n",
+        "  break"
+      ],
+      "metadata": {
+        "id": "DCPsPxgh9Cml",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "66fe3e05-4fed-4316-bf33-b5e932cfe9d5"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Shape of X: torch.Size([32, 3, 64, 64])\n",
+            "Shape of y: torch.Size([32])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "import torch.nn as nn"
+      ],
+      "metadata": {
+        "id": "gFBwZcnn9HTO"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Defining CNN model\n",
+        "class CNN(nn.Module):\n",
+        "  def __init__(self):\n",
+        "    super().__init__()\n",
+        "    # Feature Extractor\n",
+        "    self.feature_extractor = nn.Sequential(\n",
+        "        # Layer 1\n",
+        "        nn.Conv2d(3, 32, kernel_size=3, padding=1),\n",
+        "        nn.ReLU(),\n",
+        "        nn.MaxPool2d(kernel_size=2),\n",
+        "        # Layer 2\n",
+        "        nn.Conv2d(32, 64, kernel_size=3, padding=1),\n",
+        "        nn.ReLU(),\n",
+        "        nn.MaxPool2d(kernel_size=2),\n",
+        "        # Layer 3\n",
+        "        nn.Conv2d(64, 32, kernel_size=3, padding=1),\n",
+        "        nn.ReLU(),\n",
+        "        nn.MaxPool2d(kernel_size=2),\n",
+        "        # Flattening\n",
+        "        nn.Flatten()\n",
+        "    )\n",
+        "    # Classifier\n",
+        "    self.classifier = nn.Sequential(\n",
+        "        nn.Dropout(p=0.2),\n",
+        "        nn.Linear(32*8*8, 2)\n",
+        "    )\n",
+        "  def forward(self, x):\n",
+        "        x = self.feature_extractor(x)\n",
+        "        x = self.classifier(x)\n",
+        "        return x"
+      ],
+      "metadata": {
+        "id": "5y0HZbB69P-W"
+      },
+      "execution_count": 6,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch.optim as optim"
+      ],
+      "metadata": {
+        "id": "HQMGygCR9Q3j"
+      },
+      "execution_count": 7,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Deciding values of Hyperparamters\n",
+        "lr = 0.001\n",
+        "num_epochs = 10"
+      ],
+      "metadata": {
+        "id": "lv2Dxb-X9cLX"
+      },
+      "execution_count": 22,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Device configuration\n",
+        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
+      ],
+      "metadata": {
+        "id": "Hi5pCMNQ9jJi"
+      },
+      "execution_count": 23,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Training and Evaluation of model\n",
+        "train_losses = []\n",
+        "val_accuracies = []\n",
+        "\n",
+        "model = CNN().to(device)\n",
+        "class_weights = torch.tensor([0.83, 0.17]).to(device)\n",
+        "# Choosing loss function and optimizer\n",
+        "criterion = nn.CrossEntropyLoss(weight = class_weights)\n",
+        "optimizer = optim.Adam(model.parameters(), lr)\n",
+        "\n",
+        "for epoch in range(num_epochs):\n",
+        "  model.train()\n",
+        "  running_loss = 0.0\n",
+        "  for X,y in train_dataloader:\n",
+        "    X = X.to(device)\n",
+        "    y = y.to(device)\n",
+        "    # Forward pass\n",
+        "    pred = model(X)\n",
+        "    # Evaluate loss\n",
+        "    loss = criterion(pred, y)\n",
+        "    # Backpropagation\n",
+        "    loss.backward()\n",
+        "    optimizer.step()\n",
+        "    optimizer.zero_grad()\n",
+        "\n",
+        "    running_loss += loss.item()\n",
+        "\n",
+        "  avg_loss = running_loss / len(train_dataloader)\n",
+        "  train_losses.append(avg_loss)\n",
+        "\n",
+        "  model.eval()\n",
+        "  correct = 0\n",
+        "  total = 0\n",
+        "\n",
+        "  with torch.no_grad():\n",
+        "    for X,y in test_dataloader:\n",
+        "      X = X.to(device)\n",
+        "      y = y.to(device)\n",
+        "      output = model(X)\n",
+        "      _, pred = torch.max(output.data, 1)\n",
+        "      total += y.size(0)\n",
+        "      correct += (pred == y).sum().item()\n",
+        "\n",
+        "  accuracy = 100*correct/total\n",
+        "  val_accuracies.append(accuracy)\n",
+        "  print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {avg_loss:.4f}, Val Accuracy: {accuracy:.2f}%')"
+      ],
+      "metadata": {
+        "id": "SbIchiq8_s3f",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "6aa64866-150c-49bc-dbc0-ed4c8066ab34"
+      },
+      "execution_count": 24,
+      "outputs": [
+        {
+          "metadata": {
+            "tags": null
+          },
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Epoch [1/10], Loss: 0.6911, Val Accuracy: 16.53%\n",
+            "Epoch [2/10], Loss: 0.6932, Val Accuracy: 40.06%\n",
+            "Epoch [3/10], Loss: 0.6893, Val Accuracy: 16.53%\n",
+            "Epoch [4/10], Loss: 0.6842, Val Accuracy: 53.78%\n",
+            "Epoch [5/10], Loss: 0.6898, Val Accuracy: 37.54%\n",
+            "Epoch [6/10], Loss: 0.6836, Val Accuracy: 48.46%\n",
+            "Epoch [7/10], Loss: 0.6778, Val Accuracy: 47.06%\n",
+            "Epoch [8/10], Loss: 0.6803, Val Accuracy: 62.46%\n",
+            "Epoch [9/10], Loss: 0.6777, Val Accuracy: 57.70%\n",
+            "Epoch [10/10], Loss: 0.6718, Val Accuracy: 58.54%\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Plotting results\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "def plot_results(train_losses, val_accuracies):\n",
+        "    plt.figure(figsize=(12, 5))\n",
+        "\n",
+        "    # Plotting Training loss curve\n",
+        "    plt.subplot(1, 2, 1)\n",
+        "    plt.plot(train_losses, label='Training Loss', color='tab:red')\n",
+        "    plt.title('Training Loss per Epoch')\n",
+        "    plt.xlabel('Epoch')\n",
+        "    plt.ylabel('Loss')\n",
+        "    plt.grid()\n",
+        "    plt.legend()\n",
+        "\n",
+        "    # Plotting accuracy curve\n",
+        "    plt.subplot(1, 2, 2)\n",
+        "    plt.plot(val_accuracies, label='Validation Accuracy', color='tab:blue')\n",
+        "    plt.title('Validation Accuracy per Epoch')\n",
+        "    plt.xlabel('Epoch')\n",
+        "    plt.ylabel('Accuracy (%)')\n",
+        "    plt.grid()\n",
+        "    plt.legend()\n",
+        "\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "plot_results(train_losses, val_accuracies)\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "KqHpB1Fc_tx_",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 507
+        },
+        "outputId": "e2a3ac38-d491-49ac-87e2-f5904259cffe"
+      },
+      "execution_count": 17,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x500 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file