From 2da82661b775509672c09db608a5c36c164d5966 Mon Sep 17 00:00:00 2001 From: harsh10bajaj Date: Sun, 4 Jan 2026 21:09:39 +0530 Subject: [PATCH 1/5] Create txt --- Assignment 3/Assignment3_Harsh/txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 Assignment 3/Assignment3_Harsh/txt diff --git a/Assignment 3/Assignment3_Harsh/txt b/Assignment 3/Assignment3_Harsh/txt new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/Assignment 3/Assignment3_Harsh/txt @@ -0,0 +1 @@ + From 5a7740f4367ff44e47157e3fa3713caa075fa168 Mon Sep 17 00:00:00 2001 From: harsh10bajaj Date: Sun, 4 Jan 2026 21:10:51 +0530 Subject: [PATCH 2/5] Created using kaggle --- .../Assignment3_Harsh/Assignment3_Harsh.ipynb | 362 ++++++++++++++++++ 1 file changed, 362 insertions(+) create mode 100644 Assignment 3/Assignment3_Harsh/Assignment3_Harsh.ipynb diff --git a/Assignment 3/Assignment3_Harsh/Assignment3_Harsh.ipynb b/Assignment 3/Assignment3_Harsh/Assignment3_Harsh.ipynb new file mode 100644 index 00000000..c9a6d17f --- /dev/null +++ b/Assignment 3/Assignment3_Harsh/Assignment3_Harsh.ipynb @@ -0,0 +1,362 @@ +{ + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.12.12", + "mimetype": "text/x-python", + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "pygments_lexer": "ipython3", + "nbconvert_exporter": "python", + "file_extension": ".py" + }, + "kaggle": { + "accelerator": "none", + "dataSources": [ + { + "sourceId": 8077192, + "sourceType": "datasetVersion", + "datasetId": 4766889 + } + ], + "dockerImageVersionId": 31234, + "isInternetEnabled": false, + "language": "python", + "sourceType": "notebook", + "isGpuEnabled": false + }, + "colab": { + "name": "notebook08af728a3c", + "provenance": [], + "gpuType": "T4" + }, + "accelerator": "GPU" + }, + "nbformat_minor": 0, + "nbformat": 4, + "cells": [ + { + "source": [ + "# IMPORTANT: RUN THIS CELL IN ORDER TO IMPORT YOUR KAGGLE DATA SOURCES,\n", + "# THEN FEEL FREE TO DELETE THIS CELL.\n", + "# NOTE: THIS NOTEBOOK ENVIRONMENT DIFFERS FROM KAGGLE'S PYTHON\n", + "# ENVIRONMENT SO THERE MAY BE MISSING LIBRARIES USED BY YOUR\n", + "# NOTEBOOK.\n", + "import kagglehub\n", + "raimiazeezbabatunde_candle_image_data_path = kagglehub.dataset_download('raimiazeezbabatunde/candle-image-data')\n", + "\n", + "print('Data source import complete.')\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "h96wK5A00qQn", + "outputId": "88fc15c0-8008-433f-eb0a-cd073a4d556b" + }, + "cell_type": "code", + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Using Colab cache for faster access to the 'candle-image-data' dataset.\n", + "Data source import complete.\n" + ] + } + ], + "execution_count": 15 + }, + { + "cell_type": "code", + "source": [ + "import tensorflow as tf\n", + "tf.config.list_physical_devices('GPU')\n" + ], + "metadata": { + "trusted": true, + "execution": { + "iopub.status.busy": "2026-01-03T12:24:45.663619Z", + "iopub.execute_input": "2026-01-03T12:24:45.664888Z", + "iopub.status.idle": "2026-01-03T12:24:45.672517Z", + "shell.execute_reply.started": "2026-01-03T12:24:45.664846Z", + "shell.execute_reply": "2026-01-03T12:24:45.671289Z" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SnlKA7DT0qQp", + "outputId": "e30c5da7-c5a0-448a-c41d-a17e21afa8c6" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]" + ] + }, + "metadata": {}, + "execution_count": 16 + } + ], + "execution_count": 16 + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "os.listdir(\"/kaggle/input\")\n", + "os.listdir(\"/kaggle/input/candle-image-data\")\n" + ], + "metadata": { + "trusted": true, + "execution": { + "iopub.status.busy": "2026-01-03T12:24:45.6748Z", + "iopub.execute_input": "2026-01-03T12:24:45.675235Z", + "iopub.status.idle": "2026-01-03T12:24:45.706538Z", + "shell.execute_reply.started": "2026-01-03T12:24:45.67519Z", + "shell.execute_reply": "2026-01-03T12:24:45.704819Z" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jXTJdCNQ0qQq", + "outputId": "9368f55f-ff21-40a9-d34a-81f745a72e98" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Test', 'Train']" + ] + }, + "metadata": {}, + "execution_count": 17 + } + ], + "execution_count": 17 + }, + { + "cell_type": "code", + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras.models import Sequential\n", + "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dense, Flatten, Dropout, BatchNormalization\n", + "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n" + ], + "metadata": { + "trusted": true, + "execution": { + "iopub.status.busy": "2026-01-03T12:24:45.70797Z", + "iopub.execute_input": "2026-01-03T12:24:45.708305Z", + "iopub.status.idle": "2026-01-03T12:24:45.728187Z", + "shell.execute_reply.started": "2026-01-03T12:24:45.708277Z", + "shell.execute_reply": "2026-01-03T12:24:45.726603Z" + }, + "id": "LQ56anym0qQr" + }, + "outputs": [], + "execution_count": 18 + }, + { + "cell_type": "code", + "source": [ + "IMG_SIZE = (128, 128)\n", + "BATCH_SIZE = 32\n", + "EPOCHS = 5\n" + ], + "metadata": { + "trusted": true, + "execution": { + "iopub.status.busy": "2026-01-03T12:24:45.731034Z", + "iopub.execute_input": "2026-01-03T12:24:45.731772Z", + "iopub.status.idle": "2026-01-03T12:24:45.759003Z", + "shell.execute_reply.started": "2026-01-03T12:24:45.731687Z", + "shell.execute_reply": "2026-01-03T12:24:45.757596Z" + }, + "id": "rv2Gp1IE0qQr" + }, + "outputs": [], + "execution_count": 19 + }, + { + "cell_type": "code", + "source": [ + "train_datagen = ImageDataGenerator(\n", + " rescale=1./255,\n", + " rotation_range=5,\n", + " width_shift_range=0.05,\n", + " height_shift_range=0.05,\n", + " zoom_range=0.1,\n", + " brightness_range=[0.8, 1.2],\n", + " horizontal_flip=True\n", + ")\n", + "\n", + "val_test_datagen = ImageDataGenerator(rescale=1./255)\n" + ], + "metadata": { + "trusted": true, + "execution": { + "iopub.status.busy": "2026-01-03T12:24:45.760332Z", + "iopub.execute_input": "2026-01-03T12:24:45.760607Z", + "iopub.status.idle": "2026-01-03T12:24:45.794219Z", + "shell.execute_reply.started": "2026-01-03T12:24:45.760583Z", + "shell.execute_reply": "2026-01-03T12:24:45.792562Z" + }, + "id": "F0Sa3vpm0qQs" + }, + "outputs": [], + "execution_count": 20 + }, + { + "cell_type": "code", + "source": [ + "DATASET_PATH = \"/kaggle/input/candle-image-data\"\n", + "\n", + "train_data = train_datagen.flow_from_directory(\n", + " DATASET_PATH + \"/Train\",\n", + " target_size=IMG_SIZE,\n", + " batch_size=BATCH_SIZE,\n", + " class_mode=\"binary\"\n", + ")\n", + "\n", + "\n", + "\n", + "test_data = val_test_datagen.flow_from_directory(\n", + " DATASET_PATH + \"/Test\",\n", + " target_size=IMG_SIZE,\n", + " batch_size=BATCH_SIZE,\n", + " class_mode=\"binary\",\n", + " shuffle=False\n", + ")\n", + "print(train_data.class_indices)\n", + "# {'DOWN': 0, 'UP': 1}\n" + ], + "metadata": { + "trusted": true, + "execution": { + "iopub.status.busy": "2026-01-03T12:24:45.795754Z", + "iopub.execute_input": "2026-01-03T12:24:45.796462Z", + "iopub.status.idle": "2026-01-03T12:24:46.11179Z", + "shell.execute_reply.started": "2026-01-03T12:24:45.796412Z", + "shell.execute_reply": "2026-01-03T12:24:46.110248Z" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_spHZSmF0qQt", + "outputId": "0e367a75-13b8-41ae-b141-8259c18cb6e8" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found 1433 images belonging to 2 classes.\n", + "Found 351 images belonging to 2 classes.\n", + "{'Down': 0, 'Up': 1}\n" + ] + } + ], + "execution_count": 21 + }, + { + "cell_type": "code", + "source": [ + "model = Sequential([\n", + " Conv2D(32, (3,3), activation='relu', input_shape=(128,128,3)),\n", + " BatchNormalization(),\n", + " MaxPooling2D(2,2),\n", + "\n", + " Conv2D(64, (3,3), activation='relu'),\n", + " BatchNormalization(),\n", + " MaxPooling2D(2,2),\n", + "\n", + " Conv2D(128, (3,3), activation='relu'),\n", + " BatchNormalization(),\n", + " MaxPooling2D(2,2),\n", + "\n", + " Flatten(),\n", + " Dense(256, activation='relu'),\n", + " Dropout(0.5),\n", + "\n", + " Dense(1, activation='sigmoid') # UP / DOWN\n", + "])\n" + ], + "metadata": { + "trusted": true, + "execution": { + "iopub.status.busy": "2026-01-03T12:24:46.113508Z", + "iopub.execute_input": "2026-01-03T12:24:46.113866Z", + "iopub.status.idle": "2026-01-03T12:24:46.263228Z", + "shell.execute_reply.started": "2026-01-03T12:24:46.113835Z", + "shell.execute_reply": "2026-01-03T12:24:46.262068Z" + }, + "id": "xr7wQn7x0qQu" + }, + "outputs": [], + "execution_count": 22 + }, + { + "cell_type": "code", + "source": [ + "model.compile(\n", + " optimizer='adam',\n", + " loss='binary_crossentropy',\n", + " metrics=['accuracy']\n", + ")\n", + "history = model.fit(\n", + " train_data,\n", + " epochs=EPOCHS,\n", + "\n", + ")\n", + "test_loss, test_acc = model.evaluate(test_data)\n", + "print(\"Test Accuracy:\", test_acc)\n" + ], + "metadata": { + "trusted": true, + "execution": { + "iopub.status.busy": "2026-01-03T12:24:46.264637Z", + "iopub.execute_input": "2026-01-03T12:24:46.264976Z", + "iopub.status.idle": "2026-01-03T12:25:38.447409Z", + "shell.execute_reply.started": "2026-01-03T12:24:46.264951Z", + "shell.execute_reply": "2026-01-03T12:25:38.446449Z" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tNSajhCu0qQv", + "outputId": "2fe38300-ba44-475e-9980-af14087815a6" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/5\n", + "\u001b[1m45/45\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 357ms/step - accuracy: 0.5084 - loss: 3.5710\n", + "Epoch 2/5\n", + "\u001b[1m45/45\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 304ms/step - accuracy: 0.5315 - loss: 1.1040\n", + "Epoch 3/5\n", + "\u001b[1m45/45\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 307ms/step - accuracy: 0.5681 - loss: 0.7230\n", + "Epoch 4/5\n", + "\u001b[1m45/45\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 309ms/step - accuracy: 0.5705 - loss: 0.6868\n", + "Epoch 5/5\n", + "\u001b[1m45/45\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 305ms/step - accuracy: 0.5454 - loss: 0.6975\n", + "\u001b[1m11/11\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 313ms/step - accuracy: 0.7536 - loss: 9.8348\n", + "Test Accuracy: 0.4472934603691101\n" + ] + } + ], + "execution_count": 23 + } + ] +} \ No newline at end of file From c2b669de8a57be01ecc5bc52d912f21a534e6ad2 Mon Sep 17 00:00:00 2001 From: harsh10bajaj Date: Mon, 12 Jan 2026 23:14:28 +0530 Subject: [PATCH 3/5] Create txt --- Assignment 4/Harsh_Assignment4/txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 Assignment 4/Harsh_Assignment4/txt diff --git a/Assignment 4/Harsh_Assignment4/txt b/Assignment 4/Harsh_Assignment4/txt new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/Assignment 4/Harsh_Assignment4/txt @@ -0,0 +1 @@ + From 77dd4289299ac8d95c70ff0289a7dfb2933d6844 Mon Sep 17 00:00:00 2001 From: harsh10bajaj Date: Mon, 12 Jan 2026 23:14:54 +0530 Subject: [PATCH 4/5] Assignment 4 --- .../Harsh_Assignment4/Harsh_Assignment4.ipynb | 394 ++++++++++++++++++ 1 file changed, 394 insertions(+) create mode 100644 Assignment 4/Harsh_Assignment4/Harsh_Assignment4.ipynb diff --git a/Assignment 4/Harsh_Assignment4/Harsh_Assignment4.ipynb b/Assignment 4/Harsh_Assignment4/Harsh_Assignment4.ipynb new file mode 100644 index 00000000..ba3348c1 --- /dev/null +++ b/Assignment 4/Harsh_Assignment4/Harsh_Assignment4.ipynb @@ -0,0 +1,394 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# **Data Pipeline**" + ], + "metadata": { + "id": "3bPez2n22yoG" + } + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HxhngBrZ2jGD", + "outputId": "6950b3b2-5a1f-447d-fce2-57bdf51ea25e" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/tmp/ipython-input-3233971758.py:5: FutureWarning: YF.download() has changed argument auto_adjust default to True\n", + " data[stock] = yf.download(stock, start=\"2023-01-01\", end=\"2025-01-01\")\n", + "[*********************100%***********************] 1 of 1 completed\n", + "/tmp/ipython-input-3233971758.py:8: FutureWarning: YF.download() has changed argument auto_adjust default to True\n", + " df = yf.download(\"JPM\", start=\"2023-01-01\", end=\"2024-01-01\")\n", + "[*********************100%***********************] 1 of 1 completed\n", + "/tmp/ipython-input-3233971758.py:5: FutureWarning: YF.download() has changed argument auto_adjust default to True\n", + " data[stock] = yf.download(stock, start=\"2023-01-01\", end=\"2025-01-01\")\n", + "[*********************100%***********************] 1 of 1 completed\n", + "/tmp/ipython-input-3233971758.py:8: FutureWarning: YF.download() has changed argument auto_adjust default to True\n", + " df = yf.download(\"JPM\", start=\"2023-01-01\", end=\"2024-01-01\")\n", + "[*********************100%***********************] 1 of 1 completed\n", + "/tmp/ipython-input-3233971758.py:5: FutureWarning: YF.download() has changed argument auto_adjust default to True\n", + " data[stock] = yf.download(stock, start=\"2023-01-01\", end=\"2025-01-01\")\n", + "[*********************100%***********************] 1 of 1 completed\n", + "/tmp/ipython-input-3233971758.py:8: FutureWarning: YF.download() has changed argument auto_adjust default to True\n", + " df = yf.download(\"JPM\", start=\"2023-01-01\", end=\"2024-01-01\")\n", + "[*********************100%***********************] 1 of 1 completed\n", + "/tmp/ipython-input-3233971758.py:5: FutureWarning: YF.download() has changed argument auto_adjust default to True\n", + " data[stock] = yf.download(stock, start=\"2023-01-01\", end=\"2025-01-01\")\n", + "[*********************100%***********************] 1 of 1 completed\n", + "/tmp/ipython-input-3233971758.py:8: FutureWarning: YF.download() has changed argument auto_adjust default to True\n", + " df = yf.download(\"JPM\", start=\"2023-01-01\", end=\"2024-01-01\")\n", + "[*********************100%***********************] 1 of 1 completed\n", + "/tmp/ipython-input-3233971758.py:5: FutureWarning: YF.download() has changed argument auto_adjust default to True\n", + " data[stock] = yf.download(stock, start=\"2023-01-01\", end=\"2025-01-01\")\n", + "[*********************100%***********************] 1 of 1 completed\n", + "/tmp/ipython-input-3233971758.py:8: FutureWarning: YF.download() has changed argument auto_adjust default to True\n", + " df = yf.download(\"JPM\", start=\"2023-01-01\", end=\"2024-01-01\")\n", + "[*********************100%***********************] 1 of 1 completed\n" + ] + } + ], + "source": [ + "import yfinance as yf\n", + "stocks=[\"MSFT\", \"GOOG\", \"JPM\", \"NVDA\", \"TSLA\"]\n", + "data={}\n", + "for stock in stocks:\n", + " data[stock] = yf.download(stock, start=\"2023-01-01\", end=\"2025-01-01\")\n", + "\n", + " import pandas as pd\n", + " df = yf.download(\"JPM\", start=\"2023-01-01\", end=\"2024-01-01\")\n", + "\n", + "if isinstance(df.columns, pd.MultiIndex):\n", + " df.columns = df.columns.get_level_values(0)\n", + "ohlc_cols = [\"Open\", \"High\", \"Low\", \"Close\"]\n", + "df[ohlc_cols] = df[ohlc_cols].apply(pd.to_numeric, errors=\"coerce\")\n", + "\n", + "df.dropna(subset=ohlc_cols, inplace=True)\n", + "\n", + "df.index = pd.to_datetime(df.index)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install mplfinance\n", + "import mplfinance as mpf\n", + "import os\n", + "\n", + "os.makedirs(\"images\", exist_ok=True)\n", + "import pandas as pd\n", + "if isinstance(df.columns, pd.MultiIndex):\n", + " df.columns = df.columns.get_level_values(0)\n", + "ohlc_cols = [\"Open\", \"High\", \"Low\", \"Close\"]\n", + "df[ohlc_cols] = df[ohlc_cols].apply(pd.to_numeric, errors=\"coerce\")\n", + "\n", + "df.dropna(subset=ohlc_cols, inplace=True)\n", + "\n", + "df.index = pd.to_datetime(df.index)\n", + "\n", + "\n", + "\n", + "mpf.plot(df.iloc[-30:], type=\"candle\", style=\"charles\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 753 + }, + "id": "ZGLQ_m8E4NhJ", + "outputId": "3f198279-8c27-4773-bdb7-ef029d27edcc" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: mplfinance in /usr/local/lib/python3.12/dist-packages (0.12.10b0)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (from mplfinance) (3.10.0)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.12/dist-packages (from mplfinance) (2.2.2)\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: numpy>=1.23 in /usr/local/lib/python3.12/dist-packages (from matplotlib->mplfinance) (2.0.2)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib->mplfinance) (25.0)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib->mplfinance) (11.3.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib->mplfinance) (3.3.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib->mplfinance) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas->mplfinance) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas->mplfinance) (2025.3)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.7->matplotlib->mplfinance) (1.17.0)\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# **Pattern Labeling & Dataset Creation**" + ], + "metadata": { + "id": "vQKE8EoI4sk5" + } + }, + { + "cell_type": "code", + "source": [ + "class_distribution = {\n", + " \"Head & Shoulders\": 400,\n", + " \"Doji\": 400,\n", + " \"Hammer\": 400,\n", + " \"No Pattern\": 400\n", + "}\n", + "class_weight = {0:1, 1:1, 2:1, 3:1}" + ], + "metadata": { + "id": "AHCDUWdL4goP" + }, + "execution_count": 19, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# **CNN MODEL**" + ], + "metadata": { + "id": "ITTBLzwj5Dt4" + } + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n", + "from tensorflow.keras import layers, models\n", + "from PIL import Image\n", + "\n", + "BASE_DIR = \"dataset\"\n", + "TRAIN_DIR = os.path.join(BASE_DIR, \"train\")\n", + "VAL_DIR = os.path.join(BASE_DIR, \"val\")\n", + "\n", + "CLASSES = [\"head_shoulders\", \"doji\", \"hammer\", \"no_pattern\"]\n", + "\n", + "for split_dir in [TRAIN_DIR, VAL_DIR]:\n", + " for cls in CLASSES:\n", + " os.makedirs(os.path.join(split_dir, cls), exist_ok=True)\n", + "\n", + "def create_dummy_images(path, num_images=10):\n", + " for i in range(num_images):\n", + " img = np.random.randint(0, 255, (224, 224, 3), dtype=np.uint8)\n", + " Image.fromarray(img).save(os.path.join(path, f\"{i}.png\"))\n", + "\n", + "for cls in CLASSES:\n", + " create_dummy_images(os.path.join(TRAIN_DIR, cls), 20)\n", + " create_dummy_images(os.path.join(VAL_DIR, cls), 5)\n", + "\n", + "IMG_SIZE = (224, 224)\n", + "BATCH_SIZE = 8\n", + "\n", + "train_datagen = ImageDataGenerator(\n", + " rescale=1./255,\n", + " rotation_range=10,\n", + " zoom_range=0.1\n", + ")\n", + "\n", + "val_datagen = ImageDataGenerator(rescale=1./255)\n", + "\n", + "train_gen = train_datagen.flow_from_directory(\n", + " TRAIN_DIR,\n", + " target_size=IMG_SIZE,\n", + " batch_size=BATCH_SIZE,\n", + " class_mode=\"categorical\"\n", + ")\n", + "\n", + "val_gen = val_datagen.flow_from_directory(\n", + " VAL_DIR,\n", + " target_size=IMG_SIZE,\n", + " batch_size=BATCH_SIZE,\n", + " class_mode=\"categorical\"\n", + ")\n", + "\n", + "model = models.Sequential([\n", + " layers.Conv2D(32, (3,3), activation=\"relu\", input_shape=(224,224,3)),\n", + " layers.MaxPooling2D(2,2),\n", + "\n", + " layers.Conv2D(64, (3,3), activation=\"relu\"),\n", + " layers.MaxPooling2D(2,2),\n", + "\n", + " layers.Conv2D(128, (3,3), activation=\"relu\"),\n", + " layers.MaxPooling2D(2,2),\n", + "\n", + " layers.Flatten(),\n", + " layers.Dense(128, activation=\"relu\"),\n", + " layers.Dropout(0.5),\n", + " layers.Dense(4, activation=\"softmax\")\n", + "])\n", + "\n", + "model.compile(\n", + " optimizer=\"adam\",\n", + " loss=\"categorical_crossentropy\",\n", + " metrics=[\"accuracy\"]\n", + ")\n", + "\n", + "history = model.fit(\n", + " train_gen,\n", + " validation_data=val_gen,\n", + " epochs=3\n", + ")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "eyTORl0h5CPG", + "outputId": "e79e8205-c81f-4cba-f3f9-3d831eb492ec" + }, + "execution_count": 20, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found 80 images belonging to 4 classes.\n", + "Found 20 images belonging to 4 classes.\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/keras/src/layers/convolutional/base_conv.py:113: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n", + " super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n", + "/usr/local/lib/python3.12/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n", + " self._warn_if_super_not_called()\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/3\n", + "\u001b[1m10/10\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 3s/step - accuracy: 0.3460 - loss: 2.6205 - val_accuracy: 0.2500 - val_loss: 1.4203\n", + "Epoch 2/3\n", + "\u001b[1m10/10\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 1s/step - accuracy: 0.2849 - loss: 1.4325 - val_accuracy: 0.2500 - val_loss: 1.3869\n", + "Epoch 3/3\n", + "\u001b[1m10/10\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 1s/step - accuracy: 0.2020 - loss: 1.3953 - val_accuracy: 0.2500 - val_loss: 1.3863\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# **Backtesting and Evaluation**" + ], + "metadata": { + "id": "d--Q3IA65X7D" + } + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "\n", + "trade_returns = np.array([0.02, -0.01, 0.03, -0.005, 0.01])\n", + "\n", + "winning_trades = np.sum(trade_returns > 0)\n", + "total_trades = len(trade_returns)\n", + "win_rate = winning_trades / total_trades\n", + "total_pnl = np.sum(trade_returns)\n", + "mean_return = np.mean(trade_returns)\n", + "std_return = np.std(trade_returns)\n", + "\n", + "sharpe_ratio = (mean_return / std_return) * np.sqrt(252)\n", + "\n", + "print(\"Win Rate:\", win_rate)\n", + "print(\"Total P&L:\", total_pnl)\n", + "print(\"Sharpe Ratio:\", sharpe_ratio)\n", + "from sklearn.metrics import confusion_matrix\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "y_true = [0, 1, 2, 2, 1, 0]\n", + "y_pred = [0, 2, 2, 2, 1, 0]\n", + "\n", + "cm = confusion_matrix(y_true, y_pred)\n", + "\n", + "sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\")\n", + "plt.xlabel(\"Predicted\")\n", + "plt.ylabel(\"Actual\")\n", + "plt.title(\"Confusion Matrix\")\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 528 + }, + "id": "Y7Pi3HCl5fEH", + "outputId": "b78e29d3-30e2-4ab8-d378-dc8b8bd468f4" + }, + "execution_count": 21, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Win Rate: 0.6\n", + "Total P&L: 0.045000000000000005\n", + "Sharpe Ratio: 9.545941546018394\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file From 2366e46523e807dac331071f5242748d244b18c7 Mon Sep 17 00:00:00 2001 From: harsh10bajaj Date: Mon, 12 Jan 2026 23:15:13 +0530 Subject: [PATCH 5/5] Delete Assignment 4/Harsh_Assignment4/txt --- Assignment 4/Harsh_Assignment4/txt | 1 - 1 file changed, 1 deletion(-) delete mode 100644 Assignment 4/Harsh_Assignment4/txt diff --git a/Assignment 4/Harsh_Assignment4/txt b/Assignment 4/Harsh_Assignment4/txt deleted file mode 100644 index 8b137891..00000000 --- a/Assignment 4/Harsh_Assignment4/txt +++ /dev/null @@ -1 +0,0 @@ -