diff --git a/README.md b/README.md
index 9a7cb80..3301f7a 100644
--- a/README.md
+++ b/README.md
@@ -6,10 +6,12 @@
 ![PyPI](https://img.shields.io/pypi/v/deeptensor)
 ![Downloads](https://img.shields.io/pypi/dm/deeptensor)
 ![License](https://img.shields.io/github/license/deependujha/DeepTensor)
-<a href="https://colab.research.google.com/gist/deependujha/bf44ba02d975e691f4746a85ff8122fd/play-with-deeptensor.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="play with DeepTensor In Colab"/></a>
+<a target="_blank" href="https://colab.research.google.com/github/deependujha/DeepTensor/blob/main/demo/roboflow-demo.ipynb">
+  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
+</a>
 </div>
 
-![mexican cat dance](./assets/mexican-cat-dance.gif)
+![mexican cat dance](https://www.deependujha.xyz/deeptensor-assets/mexican-cat-dance.gif)
 
 - DeepTensor: A minimal deep learning library focused on custom autograd and efficient tensor operations.
 
@@ -27,7 +29,7 @@ pip install deeptensor
 
 - [play with demo](./demo/main.ipynb)
 
-![demo](./assets/trained-model.png)
+![demo](https://www.deependujha.xyz/deeptensor-assets/deeptensor-confusion-matrix.png)
 
 ---
 
@@ -69,6 +71,7 @@ from deeptensor import (
     # losses
     mean_squared_error,
     cross_entropy,
+    binary_cross_entropy,
 )
 
 model = Model(
diff --git a/demo/roboflow-demo.ipynb b/demo/roboflow-demo.ipynb
new file mode 100644
index 0000000..9e4161a
--- /dev/null
+++ b/demo/roboflow-demo.ipynb
@@ -0,0 +1,819 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "source": [
+    "## **DeepTensor 🔥**\n",
+    "\n",
+    "A minimal PyTorch-like **deep learning library** focused on custom autograd and efficient tensor operations.\n",
+    "\n",
+    "\n",
+    "### **Features at a Glance** 🚀\n",
+    "\n",
+    "- **Automatic gradient computation** with a custom autograd engine.\n",
+    "- **Weight initialization schemes**:\n",
+    "  - `Xavier/Glorot` and `He` initialization in both `uniform` and `normal` variants.\n",
+    "- **Activation functions**:\n",
+    "  - `ReLU`, `GeLU`, `Sigmoid`, `Tanh`, `SoftMax`, `LeakyReLU`, and more.\n",
+    "- **Built-in loss functions**:\n",
+    "  - `Mean Squared Error (MSE)`, `Cross Entropy`, and `Binary Cross Entropy`.\n",
+    "- **Optimizers**:\n",
+    "  - `SGD`, `Momentum`, `AdaGrad`, `RMSprop`, and `Adam`.\n",
+    "\n",
+    "\n",
+    "### **Why DeepTensor?**\n",
+    "\n",
+    "DeepTensor offers a hands-on implementation of deep learning fundamentals with a focus on **customizability** and **learning the internals** of deep learning frameworks like PyTorch.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "### Installation\n",
+    "\n",
+    "```bash\n",
+    "pip install deeptensor\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from __future__ import annotations\n",
+    "\n",
+    "! pip install -q deeptensor numpy scikit-learn seaborn"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "### Import modules"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'0.4.0'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import deeptensor as dt\n",
+    "\n",
+    "dt.version  # should to be version `0.4.0` or above"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "### **The `Value` Class** ☸️\n",
+    "\n",
+    "The `Value` class is the **core building block** of DeepTensor. It represents a unique value with the following attributes:\n",
+    "\n",
+    "- `data`: The actual value (e.g., a number or tensor element).  \n",
+    "- `grad`: The gradient of the value, used for backpropagation.  \n",
+    "- **Parents**: A list of values that contributed to its computation.  \n",
+    "- **Backward Method**: Builds and traverses a Directed Acyclic Graph (DAG) in reverse order to compute gradients.  \n",
+    "\n",
+    "This enables **automatic differentiation**, making `Value` the foundation for neural network computations.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "#### **Key Features**\n",
+    "\n",
+    "- Tracks operations to build a computational graph.  \n",
+    "- Performs **reverse-mode autodiff** by traversing the graph when `backward()` is called.  \n",
+    "- Supports common operations like addition, multiplication, and exponentiation out of the box.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "a=Value(data=5.200000, grad=0.000000); b=Value(data=4.300000, grad=0.000000); c=Value(data=9.500000, grad=0.000000)\n",
+      "a.data=5.2; b.data=4.3; c.data=9.5\n",
+      "a.grad=0.0; b.grad=0.0; c.grad=0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "a = dt.Value(5.2)\n",
+    "b = dt.Value(4.3)\n",
+    "c = a + b\n",
+    "\n",
+    "print(f\"{a=}; {b=}; {c=}\")  # noqa: T201 `to remove ruff warnings`\n",
+    "print(f\"{a.data=}; {b.data=}; {c.data=}\")  # noqa: T201\n",
+    "print(f\"{a.grad=}; {b.grad=}; {c.grad=}\")  # noqa: T201"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "a=Value(data=5.000000, grad=0.000000); b=Value(data=4.000000, grad=0.000000); c=Value(data=44.000000, grad=0.000000)\n",
+      "a.data=5.0; b.data=4.0; c.data=44.0\n",
+      "a.grad=0.0; b.grad=0.0; c.grad=0.0\n",
+      "\n",
+      " -------------------- after backward -------------------- \n",
+      "\n",
+      "a=Value(data=5.000000, grad=10.000000); b=Value(data=4.000000, grad=5.000000); c=Value(data=44.000000, grad=1.000000)\n",
+      "a.data=5.0; b.data=4.0; c.data=44.0\n",
+      "a.grad=10.0; b.grad=5.0; c.grad=1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "a = dt.Value(5.0)\n",
+    "b = dt.Value(4.0)\n",
+    "\n",
+    "c = a**2 + b * 5 - 1\n",
+    "\n",
+    "print(f\"{a=}; {b=}; {c=}\")  # noqa: T201\n",
+    "print(f\"{a.data=}; {b.data=}; {c.data=}\")  # noqa: T201\n",
+    "print(f\"{a.grad=}; {b.grad=}; {c.grad=}\")  # noqa: T201\n",
+    "\n",
+    "print(\"\\n\", \"-\" * 20, \"after backward\", \"-\" * 20, \"\\n\")  # noqa: T201\n",
+    "c.backward()\n",
+    "\n",
+    "print(f\"{a=}; {b=}; {c=}\")  # noqa: T201\n",
+    "print(f\"{a.data=}; {b.data=}; {c.data=}\")  # noqa: T201\n",
+    "print(f\"{a.grad=}; {b.grad=}; {c.grad=}\")  # noqa: T201"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "### **The `Tensor` Class** 🧊\n",
+    "\n",
+    "The `Tensor` class is an abstraction that builds on the **`Value`** class, enabling multi-dimensional arrays (like vectors, matrices, etc.) for your computations. With `Tensor`, you can store and manipulate large datasets seamlessly, supporting a variety of operations such as addition, matrix multiplication, division, and more.\n",
+    "\n",
+    "#### **Key Features**\n",
+    "\n",
+    "- Supports multi-dimensional arrays (1D, 2D, etc.)  \n",
+    "- Operations like addition, element-wise division, and matrix multiplication can be performed directly on `Tensors`.  \n",
+    "- Each element of a tensor is a **`Value`** object, allowing for the efficient computation of gradients during backpropagation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## helper functions to print tensor\n",
+    "\n",
+    "\n",
+    "def print_one_d_tensor(t):\n",
+    "    print(\"[\")  # noqa: T201\n",
+    "    for i in range(t.shape[0]):\n",
+    "        print(f\"\\t{t.get(i)},\")  # noqa: T201\n",
+    "    print(\"]\")  # noqa: T201\n",
+    "\n",
+    "\n",
+    "def print_two_d_tensor(t):\n",
+    "    assert len(t.shape) == 2\n",
+    "    print(\"[\")  # noqa: T201\n",
+    "    for i in range(t.shape[0]):\n",
+    "        print(\"\\t[\")  # noqa: T201\n",
+    "        for j in range(t.shape[1]):\n",
+    "            print(f\"\\t\\t{t.get([i, j])},\")  # noqa: T201\n",
+    "        print(\"\\t]\")  # noqa: T201\n",
+    "    print(\"]\")  # noqa: T201"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Tensor `set` and `get`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t1=tensor of shape: (4, )\n",
+      "[\n",
+      "\tValue(data=1.000000, grad=0.000000),\n",
+      "\tValue(data=2.000000, grad=0.000000),\n",
+      "\tValue(data=3.000000, grad=0.000000),\n",
+      "\tValue(data=4.000000, grad=0.000000),\n",
+      "]\n",
+      "\n",
+      " -------------------- 2D tensor -------------------- \n",
+      "\n",
+      "t2=tensor of shape: (2, 3, )\n",
+      "[\n",
+      "\t[\n",
+      "\t\tValue(data=1.000000, grad=0.000000),\n",
+      "\t\tValue(data=2.000000, grad=0.000000),\n",
+      "\t\tValue(data=3.000000, grad=0.000000),\n",
+      "\t]\n",
+      "\t[\n",
+      "\t\tValue(data=4.000000, grad=0.000000),\n",
+      "\t\tValue(data=5.000000, grad=0.000000),\n",
+      "\t\tValue(data=6.000000, grad=0.000000),\n",
+      "\t]\n",
+      "]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# ------------ 1D tensor ------------\n",
+    "t1 = dt.Tensor([4])\n",
+    "\n",
+    "t1.set(0, dt.Value(1.0))\n",
+    "t1.set(1, dt.Value(2.0))\n",
+    "t1.set(2, dt.Value(3.0))\n",
+    "t1.set(3, dt.Value(4.0))\n",
+    "\n",
+    "print(f\"{t1=}\")  # noqa: T201\n",
+    "\n",
+    "\n",
+    "print_one_d_tensor(t1)\n",
+    "\n",
+    "print(\"\\n\", \"-\" * 20, \"2D tensor\", \"-\" * 20, \"\\n\")  # noqa: T201\n",
+    "\n",
+    "# ------------ 2D tensor ------------\n",
+    "t2 = dt.Tensor([2, 3])\n",
+    "\n",
+    "counter = 1.0\n",
+    "for i in range(2):\n",
+    "    for j in range(3):\n",
+    "        t2.set([i, j], dt.Value(counter))\n",
+    "        counter += 1.0\n",
+    "\n",
+    "print(f\"{t2=}\")  # noqa: T201\n",
+    "\n",
+    "print_two_d_tensor(t2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "#### Performing Tensor Operations ⚽️"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[\n",
+      "\tValue(data=11.000000, grad=0.000000),\n",
+      "\tValue(data=22.000000, grad=0.000000),\n",
+      "\tValue(data=33.000000, grad=0.000000),\n",
+      "]\n",
+      "------------------------------\n",
+      "[\n",
+      "\tValue(data=2.000000, grad=0.000000),\n",
+      "\tValue(data=4.000000, grad=0.000000),\n",
+      "\tValue(data=6.000000, grad=0.000000),\n",
+      "]\n"
+     ]
+    }
+   ],
+   "source": [
+    "t1 = dt.Tensor([3])\n",
+    "t2 = dt.Tensor([3])\n",
+    "\n",
+    "t1.set(0, dt.Value(1.0))\n",
+    "t1.set(1, dt.Value(2.0))\n",
+    "t1.set(2, dt.Value(3.0))\n",
+    "\n",
+    "t2.set(0, dt.Value(10.0))\n",
+    "t2.set(1, dt.Value(20.0))\n",
+    "t2.set(2, dt.Value(30.0))\n",
+    "\n",
+    "t3 = t1 + t2\n",
+    "\n",
+    "t4 = t2 / dt.Value(5)\n",
+    "\n",
+    "print_one_d_tensor(t3)\n",
+    "\n",
+    "print(\"-\" * 30)  # noqa: T201\n",
+    "\n",
+    "print_one_d_tensor(t4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "#### Tensor Matrix-Multiplication 🚀"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[\n",
+      "\t[\n",
+      "\t\tValue(data=19.000000, grad=0.000000),\n",
+      "\t\tValue(data=22.000000, grad=0.000000),\n",
+      "\t]\n",
+      "\t[\n",
+      "\t\tValue(data=43.000000, grad=0.000000),\n",
+      "\t\tValue(data=50.000000, grad=0.000000),\n",
+      "\t]\n",
+      "]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create two matrices as Tensors\n",
+    "t1 = dt.Tensor([2, 2])\n",
+    "t2 = dt.Tensor([2, 2])\n",
+    "\n",
+    "val1 = [[1.0, 2.0], [3.0, 4.0]]\n",
+    "val2 = [[5.0, 6.0], [7.0, 8.0]]\n",
+    "\n",
+    "# Expected result of t1 @ t2\n",
+    "# [1*5 + 2*7, 1*6 + 2*8] = [19, 22]\n",
+    "# [3*5 + 4*7, 3*6 + 4*8] = [43, 50]\n",
+    "expected_val = [[19.0, 22.0], [43.0, 50.0]]\n",
+    "\n",
+    "for i in range(2):\n",
+    "    for j in range(2):\n",
+    "        t1.set([i, j], dt.Value(val1[i][j]))\n",
+    "        t2.set([i, j], dt.Value(val2[i][j]))\n",
+    "\n",
+    "# Perform matrix multiplication\n",
+    "t3 = t1.matmul(t2)  # or t3 = t1 * t2 if overloaded\n",
+    "\n",
+    "print_two_d_tensor(t3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "### Training an MLP model on `Breast-Cancer dataset`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.datasets import load_breast_cancer\n",
+    "\n",
+    "data = load_breast_cancer()\n",
+    "\n",
+    "x_data = data[\"data\"]\n",
+    "y_data = data[\"target\"]\n",
+    "labels = data[\"target_names\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((569, 30), (569,), array(['malignant', 'benign'], dtype='<U9'))"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x_data.shape, y_data.shape, labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([1.799e+01, 1.038e+01, 1.228e+02, 1.001e+03, 1.184e-01, 2.776e-01,\n",
+       "        3.001e-01, 1.471e-01, 2.419e-01, 7.871e-02, 1.095e+00, 9.053e-01,\n",
+       "        8.589e+00, 1.534e+02, 6.399e-03, 4.904e-02, 5.373e-02, 1.587e-02,\n",
+       "        3.003e-02, 6.193e-03, 2.538e+01, 1.733e+01, 1.846e+02, 2.019e+03,\n",
+       "        1.622e-01, 6.656e-01, 7.119e-01, 2.654e-01, 4.601e-01, 1.189e-01]),\n",
+       " 0)"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x_data[0], y_data[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(569, 30)"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(\n",
+    "    len(x_data),\n",
+    "    len(x_data[0]),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "### Initializing a model ❤️\n",
+    "\n",
+    "- Since we'll be using `sigmoid` activation function, so we're going with `Xavier/Glorat` initialization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Model(\n",
+       "\tFeedForwardLayer(30,16),\n",
+       "\tSigmoid(),\n",
+       "\tFeedForwardLayer(16,4),\n",
+       "\tSigmoid(),\n",
+       "\tFeedForwardLayer(4,1),\n",
+       "\tSigmoid(),\n",
+       ")"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "seed = 42\n",
+    "\n",
+    "model = dt.Model(\n",
+    "    [\n",
+    "        dt.FeedForwardLayer(30, 16, seed, \"XAVIER\", \"NORMAL\"),\n",
+    "        dt.Sigmoid(),\n",
+    "        dt.FeedForwardLayer(16, 4, seed, \"XAVIER\", \"NORMAL\"),\n",
+    "        dt.Sigmoid(),\n",
+    "        dt.FeedForwardLayer(4, 1, seed, \"XAVIER\", \"NORMAL\"),\n",
+    "        dt.Sigmoid(),\n",
+    "    ],\n",
+    "    False,  # using_cuda\n",
+    ")\n",
+    "\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Value(data=0.107475, grad=0.000000),\n",
+       " Value(data=-0.114732, grad=0.000000),\n",
+       " Value(data=0.285342, grad=0.000000),\n",
+       " Value(data=0.098807, grad=0.000000),\n",
+       " Value(data=-0.025886, grad=0.000000)]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.parameters()[:5]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "### Optimizers 🤞🏻"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "opt = dt.Adam(model, 0.001)  # learning rate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0 ;\tAvg Loss: 0.661677 ;\t Accuray:  62.741652\n",
+      "Epoch 1 ;\tAvg Loss: 0.663178 ;\t Accuray:  62.741652\n",
+      "Epoch 2 ;\tAvg Loss: 0.663739 ;\t Accuray:  62.741652\n",
+      "Epoch 3 ;\tAvg Loss: 0.663831 ;\t Accuray:  62.741652\n",
+      "Epoch 4 ;\tAvg Loss: 0.663806 ;\t Accuray:  62.741652\n",
+      "Epoch 5 ;\tAvg Loss: 0.66377 ;\t Accuray:  62.741652\n",
+      "Epoch 6 ;\tAvg Loss: 0.661123 ;\t Accuray:  62.741652\n",
+      "Epoch 7 ;\tAvg Loss: 0.665338 ;\t Accuray:  62.741652\n",
+      "Epoch 8 ;\tAvg Loss: 0.663803 ;\t Accuray:  62.741652\n",
+      "Epoch 9 ;\tAvg Loss: 0.663518 ;\t Accuray:  62.741652\n",
+      "Epoch 10 ;\tAvg Loss: 0.663446 ;\t Accuray:  62.741652\n",
+      "Epoch 11 ;\tAvg Loss: 0.663411 ;\t Accuray:  62.741652\n",
+      "Epoch 12 ;\tAvg Loss: 0.663305 ;\t Accuray:  62.741652\n",
+      "Epoch 13 ;\tAvg Loss: 0.640415 ;\t Accuray:  62.741652\n",
+      "Epoch 14 ;\tAvg Loss: 0.59976 ;\t Accuray:  62.741652\n",
+      "Epoch 15 ;\tAvg Loss: 0.558387 ;\t Accuray:  63.44464\n",
+      "Epoch 16 ;\tAvg Loss: 0.532258 ;\t Accuray:  75.571178\n",
+      "Epoch 17 ;\tAvg Loss: 0.487437 ;\t Accuray:  85.413005\n",
+      "Epoch 18 ;\tAvg Loss: 0.459689 ;\t Accuray:  88.927944\n",
+      "Epoch 19 ;\tAvg Loss: 0.431474 ;\t Accuray:  88.400703\n",
+      "Epoch 20 ;\tAvg Loss: 0.404914 ;\t Accuray:  89.279438\n",
+      "Epoch 21 ;\tAvg Loss: 0.392604 ;\t Accuray:  89.103691\n",
+      "Epoch 22 ;\tAvg Loss: 0.382511 ;\t Accuray:  88.927944\n",
+      "Epoch 23 ;\tAvg Loss: 0.372032 ;\t Accuray:  88.049209\n",
+      "Epoch 24 ;\tAvg Loss: 0.377367 ;\t Accuray:  87.873462\n",
+      "Epoch 25 ;\tAvg Loss: 0.345432 ;\t Accuray:  88.927944\n",
+      "Epoch 26 ;\tAvg Loss: 0.333812 ;\t Accuray:  90.333919\n",
+      "Epoch 27 ;\tAvg Loss: 0.33919 ;\t Accuray:  89.630931\n",
+      "Epoch 28 ;\tAvg Loss: 0.36282 ;\t Accuray:  88.400703\n",
+      "Epoch 29 ;\tAvg Loss: 0.324273 ;\t Accuray:  89.982425\n",
+      "Epoch 30 ;\tAvg Loss: 0.364052 ;\t Accuray:  88.049209\n",
+      "Epoch 31 ;\tAvg Loss: 0.353663 ;\t Accuray:  88.57645\n",
+      "Epoch 32 ;\tAvg Loss: 0.385323 ;\t Accuray:  86.643234\n",
+      "Epoch 33 ;\tAvg Loss: 0.422378 ;\t Accuray:  84.358524\n",
+      "Epoch 34 ;\tAvg Loss: 0.321946 ;\t Accuray:  89.455185\n",
+      "Epoch 35 ;\tAvg Loss: 0.387853 ;\t Accuray:  86.29174\n",
+      "Epoch 36 ;\tAvg Loss: 0.314003 ;\t Accuray:  90.333919\n",
+      "Epoch 37 ;\tAvg Loss: 0.357576 ;\t Accuray:  88.224956\n",
+      "Epoch 38 ;\tAvg Loss: 0.326638 ;\t Accuray:  89.455185\n",
+      "Epoch 39 ;\tAvg Loss: 0.318482 ;\t Accuray:  90.333919\n",
+      "Epoch 40 ;\tAvg Loss: 0.405873 ;\t Accuray:  85.588752\n",
+      "Epoch 41 ;\tAvg Loss: 0.327107 ;\t Accuray:  89.455185\n",
+      "Epoch 42 ;\tAvg Loss: 0.353209 ;\t Accuray:  87.873462\n",
+      "Epoch 43 ;\tAvg Loss: 0.281205 ;\t Accuray:  91.739895\n",
+      "Epoch 44 ;\tAvg Loss: 0.317295 ;\t Accuray:  90.158172\n",
+      "Epoch 45 ;\tAvg Loss: 0.312197 ;\t Accuray:  90.509666\n",
+      "Epoch 46 ;\tAvg Loss: 0.343417 ;\t Accuray:  88.57645\n",
+      "Epoch 47 ;\tAvg Loss: 0.296917 ;\t Accuray:  91.212654\n",
+      "Epoch 48 ;\tAvg Loss: 0.358467 ;\t Accuray:  88.049209\n",
+      "Epoch 49 ;\tAvg Loss: 0.397968 ;\t Accuray:  86.29174\n"
+     ]
+    }
+   ],
+   "source": [
+    "avg_loss_progression = []\n",
+    "for epochs in range(50):\n",
+    "    total_loss = 0\n",
+    "    accuracy = 0\n",
+    "    for i in range(len(x_data)):\n",
+    "        curr_input = dt.Tensor([30])\n",
+    "        for j in range(len(x_data[0])):\n",
+    "            curr_input.set(j, dt.Value(x_data[i][j]))\n",
+    "\n",
+    "        y_pred = model(curr_input)\n",
+    "\n",
+    "        predicted = int(y_pred.get(0).data > 0.5)\n",
+    "        if predicted == y_data[i]:\n",
+    "            accuracy += 1\n",
+    "        loss = dt.binary_cross_entropy(y_pred, y_data[i])\n",
+    "        total_loss += loss.data\n",
+    "\n",
+    "        # backprop\n",
+    "        opt.zero_grad()\n",
+    "        loss.backward()\n",
+    "        opt.step()\n",
+    "\n",
+    "        del curr_input\n",
+    "\n",
+    "    avg_loss = round(total_loss / len(x_data), 6)\n",
+    "    avg_loss_progression.append(avg_loss)\n",
+    "    acc_percent = round(((accuracy / len(x_data)) * 100), 6)\n",
+    "    print(\"Epoch\", epochs, \";\\tAvg Loss:\", avg_loss, \";\\t Accuray: \", acc_percent)  # noqa: T201\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Plotting the loss array\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.plot(avg_loss_progression, label=\"Avg Loss\", color=\"blue\")\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Average Loss\")\n",
+    "plt.title(\"Loss Progression over Epochs\")\n",
+    "plt.grid(True)\n",
+    "plt.legend()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pred_data = []\n",
+    "\n",
+    "for i in range(len(x_data)):\n",
+    "    curr_input = dt.Tensor([30])\n",
+    "    for j in range(len(x_data[0])):\n",
+    "        curr_input.set(j, dt.Value(x_data[i][j]))\n",
+    "\n",
+    "    y_pred = model(curr_input)\n",
+    "\n",
+    "    pred_output = int(y_pred.get(0).data > 0.5)\n",
+    "    pred_data.append(pred_output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(569, 569)"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(pred_data), len(y_data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import seaborn as sns\n",
+    "from sklearn.metrics import classification_report, confusion_matrix\n",
+    "\n",
+    "c = confusion_matrix(y_data, pred_data)\n",
+    "sns.heatmap(c, annot=True, xticklabels=labels, yticklabels=labels);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.99      0.74      0.84       212\n",
+      "           1       0.86      0.99      0.92       357\n",
+      "\n",
+      "    accuracy                           0.90       569\n",
+      "   macro avg       0.93      0.87      0.88       569\n",
+      "weighted avg       0.91      0.90      0.89       569\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(classification_report(y_data, pred_data))  # noqa: T201"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/pyproject.toml b/pyproject.toml
index f0b1660..6ebfaca 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,8 +4,9 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "deeptensor"
-version = "0.3.0" # new api
+version = "0.4.0" # new api
 url = "https://github.com/deependujha/deeptensor"
+description = "A minimal deep learning library focused on custom autograd and efficient tensor operations."
 readme = "README.md"
 authors = [
   { name = "Deependu Jha", email = "deependujha21@gmail.com" },
diff --git a/src/deeptensor/__version__.py b/src/deeptensor/__version__.py
index 5117fb3..3620f7e 100644
--- a/src/deeptensor/__version__.py
+++ b/src/deeptensor/__version__.py
@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-version = "0.3.0"
+version = "0.4.0"