diff --git a/tutorials/classification_metrics.ipynb b/tutorials/classification_metrics.ipynb
new file mode 100644
index 0000000..ce1f9ea
--- /dev/null
+++ b/tutorials/classification_metrics.ipynb
@@ -0,0 +1,256 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f6dfd924",
+   "metadata": {},
+   "source": [
+    "# Classification Metrics in Machine Learning"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4a963095",
+   "metadata": {},
+   "source": [
+    "##  Introduction\n",
+    "\n",
+    "Classification metrics are used to evaluate the performance of classification models. \n",
+    "They help us understand how well our model is predicting different classes."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "78ce5f2e",
+   "metadata": {},
+   "source": [
+    "##  Confusion Matrix\n",
+    "\n",
+    "A confusion matrix is used to evaluate classification models.\n",
+    "\n",
+    "| Actual \\ Predicted | Positive | Negative |\n",
+    "|-------------------|----------|----------|\n",
+    "| Positive          | TP       | FN       |\n",
+    "| Negative          | FP       | TN       |\n",
+    "\n",
+    "- TP (True Positive): Correct positive prediction  \n",
+    "- TN (True Negative): Correct negative prediction  \n",
+    "- FP (False Positive): Incorrect positive prediction  \n",
+    "- FN (False Negative): Incorrect negative prediction  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bc4aa564",
+   "metadata": {},
+   "source": [
+    "##  Accuracy\n",
+    "\n",
+    "Accuracy measures the overall correctness of the model.\n",
+    "\n",
+    "Formula:\n",
+    "Accuracy = (TP + TN) / (TP + TN + FP + FN)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a0119f88",
+   "metadata": {},
+   "source": [
+    "##  Precision\n",
+    "\n",
+    "Precision measures how many predicted positives are actually correct.\n",
+    "\n",
+    "Formula:\n",
+    "Precision = TP / (TP + FP)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "280b32e9",
+   "metadata": {},
+   "source": [
+    "##  Recall\n",
+    "\n",
+    "Recall measures how many actual positives are correctly predicted.\n",
+    "\n",
+    "Formula:\n",
+    "Recall = TP / (TP + FN)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "55c333e8",
+   "metadata": {},
+   "source": [
+    "##  F1 Score\n",
+    "\n",
+    "F1 Score is the harmonic mean of precision and recall.\n",
+    "\n",
+    "Formula:\n",
+    "F1 Score = 2 × (Precision × Recall) / (Precision + Recall)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e1d85ce7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.datasets import load_breast_cancer\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.linear_model import LogisticRegression"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d3784336",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\PC\\AppData\\Roaming\\Python\\Python313\\site-packages\\sklearn\\linear_model\\_logistic.py:473: ConvergenceWarning: lbfgs failed to converge after 1000 iteration(s) (status=1):\n",
+      "STOP: TOTAL NO. OF ITERATIONS REACHED LIMIT\n",
+      "\n",
+      "Increase the number of iterations to improve the convergence (max_iter=1000).\n",
+      "You might also want to scale the data as shown in:\n",
+      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
+      "Please also refer to the documentation for alternative solver options:\n",
+      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
+      "  n_iter_i = _check_optimize_result(\n"
+     ]
+    }
+   ],
+   "source": [
+    "data = load_breast_cancer()\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(\n",
+    "    data.data, data.target, test_size=0.2, random_state=42\n",
+    ")\n",
+    "\n",
+    "model = LogisticRegression(max_iter=1000)\n",
+    "model.fit(X_train, y_train)\n",
+    "\n",
+    "y_pred = model.predict(X_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a470dc03",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy: 0.956140350877193\n",
+      "Precision: 0.9459459459459459\n",
+      "Recall: 0.9859154929577465\n",
+      "F1 Score: 0.9655172413793104\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
+    "\n",
+    "print(\"Accuracy:\", accuracy_score(y_test, y_pred))\n",
+    "print(\"Precision:\", precision_score(y_test, y_pred))\n",
+    "print(\"Recall:\", recall_score(y_test, y_pred))\n",
+    "print(\"F1 Score:\", f1_score(y_test, y_pred))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "4e58ac4f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhIAAAHHCAYAAADqJrG+AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAMqdJREFUeJzt3Qd8FVXa+PEnIYWQEEqAFLqvSJcqRVFEo1lUBAGx4IqCurL0om5cQGCVsCgGEQFlkaJiAQG7CLHEEpQidhAEBcWEmgCBFJj5f87Z/72bmwS4d7iTmwy/7/uZN7lnJjPnxpf3PnmeU4JM0zQFAADAgmArPwQAAKAQSAAAAMsIJAAAgGUEEgAAwDICCQAAYBmBBAAAsIxAAgAAWEYgAQAALCOQAAAAlhFIADbavn27XHvttVKtWjUJCgqS1atX+/X+v/76q77v4sWL/XrfiuzKK6/UB4CyQSABx/vll1/kb3/7m1xwwQVSuXJliY6Olssuu0yeeuopOXHihK3PHjRokHz33Xfy2GOPyQsvvCAdO3YUp7jrrrt0EKN+n6X9HlUQpc6r44knnvD5/nv37pXJkyfLli1b/NRjAHYIseWuQDnxzjvvyM033yzh4eFy5513SqtWraSgoEA+++wzeeCBB+SHH36Q5557zpZnqw/XjIwM+ec//ynDhw+35RkNGzbUzwkNDZVACAkJkePHj8tbb70lAwYM8Dj30ksv6cAtLy/P0r1VIDFlyhRp1KiRtG3b1uuf++CDDyw9D4A1BBJwrF27dsmtt96qP2w//PBDiY+Pd58bNmyY7NixQwcadtm/f7/+Wr16ddueof7aVx/WgaICNJXdefnll0sEEsuWLZPrr79eXn/99TLpiwpoqlSpImFhYWXyPAD/RWkDjjVjxgw5duyYLFy40COIcLnwwgtl1KhR7tcnT56Uf/3rX/J///d/+gNS/SX88MMPS35+vsfPqfYbbrhBZzU6deqkP8hV2WTp0qXua1RKXgUwisp8qA989XOukoDr+6LUz6jrilq7dq1069ZNByNRUVHStGlT3aezjZFQgdPll18ukZGR+md79+4tP/30U6nPUwGV6pO6To3luPvuu/WHsrduv/12ee+99yQ7O9vdtmHDBl3aUOeKO3TokIwfP15at26t35MqjfTs2VO++eYb9zUff/yxXHLJJfp71R9XicT1PtUYCJVd2rRpk1xxxRU6gHD9XoqPkVDlJfXfqPj7T0pKkho1aujMBwDrCCTgWCrdrj7gL730Uq+uv+eee2TSpEnSvn17SU1Nle7du0tKSorOahSnPnz79+8v11xzjcycOVN/IKkPY1UqUfr27avvodx22216fMSsWbN86r+6lwpYVCAzdepU/Zwbb7xRPv/88zP+3Lp16/SH5L59+3SwMHbsWPniiy905kAFHsWpTMLRo0f1e1Xfqw9rVVLwlnqv6kN+5cqVHtmIZs2a6d9lcTt37tSDTtV7e/LJJ3WgpcaRqN+360O9efPm+j0r9913n/79qUMFDS4HDx7UAYgqe6jfbY8ePUrtnxoLU7t2bR1QnDp1Src9++yzugTy9NNPS0JCgtfvFUApTMCBcnJyTPV/3r179/bq+i1btujr77nnHo/28ePH6/YPP/zQ3dawYUPdlp6e7m7bt2+fGR4ebo4bN87dtmvXLn3d448/7nHPQYMG6XsU98gjj+jrXVJTU/Xr/fv3n7bfrmcsWrTI3da2bVuzTp065sGDB91t33zzjRkcHGzeeeedJZ43ePBgj3vedNNNZkxMzGmfWfR9REZG6u/79+9vXn311fr7U6dOmXFxceaUKVNK/R3k5eXpa4q/D/X7mzp1qrttw4YNJd6bS/fu3fW5+fPnl3pOHUWtWbNGX//oo4+aO3fuNKOiosw+ffqc9T0CODsyEnCkI0eO6K9Vq1b16vp3331Xf1V/vRc1btw4/bX4WIoWLVro0oGL+otXlR3UX9v+4hpb8cYbb4hhGF79zJ9//qlnOajsSM2aNd3tF198sc6euN5nUffff7/Ha/W+1F/7rt+hN1QJQ5UjMjMzdVlFfS2trKGoslFw8H//X4/KEKhnuco2mzdv9vqZ6j6q7OENNQVXzdxRWQ6VQVGlDpWVAHDuCCTgSKrurqiUvTd+++03/eGmxk0UFRcXpz/Q1fmiGjRoUOIeqrxx+PBh8ZdbbrlFlyNUySU2NlaXWF577bUzBhWufqoP5eJUueDAgQOSm5t7xvei3ofiy3u57rrrdND26quv6tkaanxD8d+li+q/Kvs0adJEBwO1atXSgdi3334rOTk5Xj+zbt26Pg2sVFNQVXClAq3Zs2dLnTp1vP5ZAKdHIAHHBhKq9v3999/79HPFBzueTqVKlUptN03T8jNc9XuXiIgISU9P12Me/vrXv+oPWhVcqMxC8WvPxbm8FxcVEKi/9JcsWSKrVq06bTZCmTZtms78qPEOL774oqxZs0YPKm3ZsqXXmRfX78cXX3/9tR43oqgxGQD8g0ACjqUG86nFqNRaDmejZlioDzE106CorKwsPRvBNQPDH9Rf/EVnOLgUz3ooKkty9dVX60GJP/74o17YSpUOPvroo9O+D2Xbtm0lzm3dulX/9a9mcthBBQ/qw1plgUoboOqyYsUKPTBSzaZR16myQ2JiYonfibdBnTdUFkaVQVRJSg3eVDN61MwSAOeOQAKO9eCDD+oPTVUaUAFBcSrIUCP6Xal5pfjMCvUBrqj1EPxFTS9VKXyVYSg6tkH9JV98mmRxroWZik9JdVHTXNU1KjNQ9INZZWbULAXX+7SDCg7U9Nk5c+boktCZMiDFsx3Lly+XP/74w6PNFfCUFnT56qGHHpLdu3fr34v6b6qm36pZHKf7PQLwHgtSwbHUB7aahqjKAWp8QNGVLdV0SPXhpQYlKm3atNEfLGqVS/XBpaYifvXVV/qDp0+fPqedWmiF+itcfbDddNNNMnLkSL1mw7x58+Siiy7yGGyoBgaq0oYKYlSmQaXl586dK/Xq1dNrS5zO448/rqdFdu3aVYYMGaJXvlTTHNUaEWo6qF1U9mTChAleZYrUe1MZAjU1V5UZ1LgKNVW3+H8/NT5l/vz5evyFCiw6d+4sjRs39qlfKoOjfm+PPPKIezrqokWL9FoTEydO1NkJAOfAi5kdQIX2888/m/fee6/ZqFEjMywszKxatap52WWXmU8//bSeiuhSWFiopyw2btzYDA0NNevXr28mJyd7XKOoqZvXX3/9Wacdnm76p/LBBx+YrVq10v1p2rSp+eKLL5aY/pmWlqanryYkJOjr1NfbbrtNv5/izyg+RXLdunX6PUZERJjR0dFmr169zB9//NHjGtfzik8vVfdS7ere3k7/PJ3TTf9U02Tj4+N1/1Q/MzIySp22+cYbb5gtWrQwQ0JCPN6nuq5ly5alPrPofY4cOaL/e7Vv317/9y1qzJgxekqsejYA64LU/zqXQAQAAJy/GCMBAAAsI5AAAACWEUgAAADLCCQAAHCgRo0auXfOLXoMGzZMn8/Ly9Pfx8TE6GXq+/XrV+pU+bNhsCUAAA60f/9+j1Vw1XoyamVctaCdmv48dOhQvY+Q2vFXTQ8fPny4nsZ9th2GiyOQAADgPDB69Gh5++239Qq+alM+tceNWmunf//+7tVv1Zo7ajXgLl26eH1fShsAAFQQ+fn5OggoenizQqtaiE/tbTN48GBd3ti0aZMUFhbq5eldmjVrpjfx82ZbAcevbLmjRVKguwCUS532+G+bc8ApDh313GPHDoUH/PNvL2XOUpkyZYpHm1q19Wyr1q5evVqv2utazTczM1PvnqtWjy1K7TSszsn5HkgAAOBEycnJevfc4rvvno3aJE8tna92RfY3AgkAAOxm/G/Q47lQQYM3gUPxnYXXrVsnK1eudLepjfVUuUNlKYpmJdSsjTNtulcaxkgAAGA30/DPYYHapK5OnToeuxh36NBBQkNDJS0tzd22bds2vUuu2vDPF2QkAACwm2EE6LGGDiTU7sYhIf/7yFfTPdXuwKpMUrNmTYmOjpYRI0boIMKXGRsKgQQAAA61bt06nWVQszWKS01N1etGqIWo1MyPpKQkmTt3rs/PcOQ6EszaAErHrA0gMLM2Cvb+4Jf7hCW0lPKGjAQAAA4tbZQFBlsCAADLyEgAAGA307kZCQIJAAAqyDoS5RGlDQAAYBkZCQAA7GZS2gAAAFYZzg0kKG0AAADLyEgAAGAzk9IGAACwzCCQAAAAVpnODSQYIwEAACwjIwEAgN0M5y5IRSABAIDdTEobAAAAJZCRAADAboZzMxIEEgAA2M10biBBaQMAAFhGRgIAALsZzs1IEEgAAGAz03Tu9E9KGwAAwDIyEgAA2M2ktAEAAKwyCCQAAIBVpnMDCcZIAAAAy8hIAABgN8O5szYIJAAAsJtJaQMAAKAEMhIAANjNcG5GgkACAAC7mc4NJChtAAAAy8hIAABgN8O5GQkCCQAA7GY4N5CgtAEAACwjIwEAgM1MB28jTiABAIDdDOeWNggkAACwm+ncQIIxEgAAwDIyEgAA2M1wbkaCQAIAALuZzg0kKG0AAADLyEgAAGA3g4wEAAA4l9KG6YfDR3/88YfccccdEhMTIxEREdK6dWvZuHHj/7plmjJp0iSJj4/X5xMTE2X79u0+PYNAAgAABzp8+LBcdtllEhoaKu+99578+OOPMnPmTKlRo4b7mhkzZsjs2bNl/vz58uWXX0pkZKQkJSVJXl6e18+htAEAgANLG//+97+lfv36smjRIndb48aNPbIRs2bNkgkTJkjv3r1129KlSyU2NlZWr14tt956q1fPISMBAEBZBBKGHw4fvPnmm9KxY0e5+eabpU6dOtKuXTtZsGCB+/yuXbskMzNTlzNcqlWrJp07d5aMjAyvn0MgAQBABZGfny9HjhzxOFRbaXbu3Cnz5s2TJk2ayJo1a2To0KEycuRIWbJkiT6vgghFZSCKUq9d57xBIAEAQAUZbJmSkqKzBkUP1VYawzCkffv2Mm3aNJ2NuO++++Tee+/V4yH8iUACAIAKUtpITk6WnJwcj0O1lUbNxGjRooVHW/PmzWX37t36+7i4OP01KyvL4xr12nXOGwQSAABUkIxEeHi4REdHexyqrTRqxsa2bds82n7++Wdp2LChe+ClChjS0tLc51WpRM3e6Nq1q9dvjVkbAAA40JgxY+TSSy/VpY0BAwbIV199Jc8995w+lKCgIBk9erQ8+uijehyFCiwmTpwoCQkJ0qdPH6+fQyABAIADp39ecsklsmrVKl36mDp1qg4U1HTPgQMHuq958MEHJTc3V4+fyM7Olm7dusn7778vlStX9vo5QaaaSOowO1okBboLQLnUac/OQHcBKHcOHfVtJUcrTqyc5pf7RPR9WMobxkgAAADLKG0AAGA3w7mbdhFIAABgN8O5gQSlDQAAYBkZCQAA7GY6bl6DG4EEAAB2MyhtAAAAlEBGAgAAuxnOzUgQSAAAYDeTQAIAAFhlODeQYIwEAACwjIwEAAB2M5n+CQAArDIobQAAAJRARgIAALsZzs1IEEgAAGA307mBBKUNAABgGRkJAABsZhrM2gAAAFYZlDYAAABKICMBAIDdTOdmJAgkAACwm8EYCQAAYJXh3IwEYyQAAIBlZCQAALCb4dyMBIEEAAB2M507RoLSBgAAsIxAAucs+pYbpP6qeXLBVyv1UW9ZqlS5vKP7fEj9eImbPUkaf/aqPh/75D+lUkz1gPYZCLRRY++TQ0e3y7Tp/wx0V1BWpQ3DD0c5RCCBc3Yya78cTH1e9tw8XPbcPEKOf/mNxM+ZLGEXNpSgiHCpu2CaTuv9cfdD8vvAsRIUGiLxz0wVCQoKdNeBgGjXvrXcdfet8v13PwW6KyjL6Z+GH45yiEAC5+z4x1/K8fQNUvjbXin87Q859NRiMY7nSfjFzaRyu5YSUjdWsh6eKQXbf9XHvuTHJbxVE4no0jbQXQfKXGRkFXl24UwZPWKCZGcfCXR3gIo92PLAgQPy/PPPS0ZGhmRmZuq2uLg4ufTSS+Wuu+6S2rVrB7J7sCI4WKKSLpfgiHDJ++YnCa0fL2KKmAWF7kuM/EIdWUe0byknMr4OaHeBsjbjyUdk7fsfyycffyHjHvx7oLuDsmKWz7JEhQ4kNmzYIElJSVKlShVJTEyUiy66SLdnZWXJ7NmzZfr06bJmzRrp2PF/tXaUX2FNGkm9l2dJUFiYGMdPyJ8jp0rhL7vl1KEcMU7kSa1xQ+TgrEUiQSIxY4dIUEglqVS7ZqC7DZSpvv2ulzZtWsrV3fsGuisoa0b5LEtU6EBixIgRcvPNN8v8+fMlqFit3DRNuf/++/U1KltxJvn5+frwaDMMCQ+malOWCn79Xfb0/bsER1XRGYnYaePl90EP6GAic8yjUmfSCKl2R2/9j+noux9J3g/bHf0PCyiubt04mTZjgvS98S7Jzy8IdHcAvwky1ad2AERERMjXX38tzZo1K/X81q1bpV27dnLixIkz3mfy5MkyZcoUj7YRtS6QkbUv9Gt/4ZuEhdOlcM9e2T95trstuHq0yKlTYhzNlUbpL0v24tcl+/kVAe3n+abTnp2B7sJ567obEuXFl+fJyZMn3W0hISFiGIY+4mJa6q8oe2r2jN1yUwb55T6RyUukvAlYRkKNhfjqq69OG0ioc7GxsWe9T3JysowdO9ajbU+nfn7rJywKCpKg0FCPJuP/DyyL6NxGKtWsLrkfrg9Q54Cyl/5xhlzW6TqPtqfnTZftP++U2anPEUQ4neHcDGzAAonx48fLfffdJ5s2bZKrr77aHTSoMRJpaWmyYMECeeKJJ856n/DwcH14tFHWKFMxY+6W3PQNcvLP/RIcGSFVb+ghEZ0ulr33/nd+fNWbrpUCNV7icI5UbttcaicPleylq6Tw198D3XWgzBw7lis//eT5l+/x4yfk8KHsEu1wINO5gWLAAolhw4ZJrVq1JDU1VebOnSunTp3S7ZUqVZIOHTrI4sWLZcCAAYHqHnygsgux0x+QkNo15dTR41Lw8y4dRJzI2KzPhzWqp4ONStWqSuEfWXL42Zcle8nKQHcbAFCRx0gUVVhYqKeCKiq4CC2WEvfVjhZJfuoZ4CyMkQACNEZi6kC/3Cdy0ktS3pSLTbtU4BAfHx/obgAAYA/DuaUNBhMAAICKnZEAAMDRjICPIrANgQQAAHYzKW0AAACUQCABAIADtxGfPHmy3oKi6FF0Eci8vDy9FENMTIxERUVJv3799FpOvqK0AQCAzcwAzdpo2bKlrFu3zmNZdpcxY8bIO++8I8uXL5dq1arJ8OHDpW/fvvL555/79AwCCQAAHCokJERvSVFcTk6OLFy4UJYtWyZXXXWVblu0aJE0b95c1q9fL126dPH6GZQ2AACoIKUNtdv1kSNHPI7iO2AXtX37dklISJALLrhABg4cKLt379btansKtRhkYmKi+1pV9mjQoMFZd90ujkACAIAKEkikpKToMkTRQ7WVpnPnznq7iffff1/mzZsnu3btkssvv1yOHj0qmZmZEhYWJtWrV/f4GbXvlTrnC0obAABUkOmfyaXseF1840qXnj17ur+/+OKLdWDRsGFDee211yQiIkL8hYwEAAAVRHh4uERHR3scpwskilPZh4suukh27Nihx00UFBRIdna2xzVq1kZpYyrOhEACAAAHTv8s7tixY/LLL7/ova3ULttqn6u0tDT3+W3btukxFF27dhVfUNoAAMBmZgCWyB4/frz06tVLlzP27t0rjzzyiFSqVEluu+02PbZiyJAhukxSs2ZNndkYMWKEDiJ8mbGhEEgAAOBAv//+uw4aDh48KLVr15Zu3brpqZ3qeyU1NVWCg4P1QlRq5kdSUpLMnTvX5+cEmabpuJ1EdrRICnQXgHKp056dge4CUO4cOrrd9mccHXmDX+5TdfbbUt6QkQAAwG4Gm3YBAACUQEYCAAC7GY4bReBGIAEAgN0M5wYSlDYAAIBlZCQAALCZ6bwJkm4EEgAA2M0gkAAAAFYZzg0kGCMBAAAsIyMBAIAD99ooKwQSAADYzXBuIEFpAwAAWEZGAgAAuxniWAQSAADYzKS0AQAAUBIZCQAA7GY4NyNBIAEAgN0McSxKGwAAwDIyEgAA2MyktAEAACwzxLEIJAAAsJnp4IwEYyQAAIBlZCQAALCbIY5FIAEAgM1MBwcSlDYAAIBlZCQAALCbIY5FIAEAgM1MBwcSlDYAAIBlZCQAALCbIY5FIAEAgM1MAgkAAGCV6eBAgjESAADAMjISAADYzHRwRoJAAgAAu5lB4lSUNgAAgGVkJAAAsJlJaQMAAFhlGpQ2AAAASiAjAQCAzUxKGwAAwCqTWRsAAAAlkZEAAMBmJqUNAABglcmsDQAAYJVp+uc4F9OnT5egoCAZPXq0uy0vL0+GDRsmMTExEhUVJf369ZOsrCyf7ksgAQCAw23YsEGeffZZufjiiz3ax4wZI2+99ZYsX75cPvnkE9m7d6/07dvXp3sTSAAAUAalDdMPhxXHjh2TgQMHyoIFC6RGjRru9pycHFm4cKE8+eSTctVVV0mHDh1k0aJF8sUXX8j69eu9vj+BBAAAFSSQyM/PlyNHjngcqu1MVOni+uuvl8TERI/2TZs2SWFhoUd7s2bNpEGDBpKRkeH1eyOQAACggkhJSZFq1ap5HKrtdF555RXZvHlzqddkZmZKWFiYVK9e3aM9NjZWn/MWszYAALCZeY4DJV2Sk5Nl7NixHm3h4eGlXrtnzx4ZNWqUrF27VipXrix2IZAAAKCCTP8MDw8/beBQnCpd7Nu3T9q3b+9uO3XqlKSnp8ucOXNkzZo1UlBQINnZ2R5ZCTVrIy4uzus+EUgAAOBAV199tXz33XcebXfffbceB/HQQw9J/fr1JTQ0VNLS0vS0T2Xbtm2ye/du6dq1q9fPIZAAAMCBe21UrVpVWrVq5dEWGRmp14xwtQ8ZMkSXSmrWrCnR0dEyYsQIHUR06dLFv4HEm2++6fUNb7zxRq+vBQDgfGCW0yWyU1NTJTg4WGck1OyPpKQkmTt3rk/3CDLNsw8BUQ/x6mZBQbr+Emg7WiQFugtAudRpz85AdwEodw4d3V5hPpcu/HGNlDdeZSQMo5yGUgAAVACGg7cRZ4wEAAAOHCNRrgOJ3NxcvSa3Gtmppo4UNXLkSH/1DQAARzAdvPunz4HE119/Ldddd50cP35cBxRqpOeBAwekSpUqUqdOHQIJAADOIz4vka12CuvVq5ccPnxYIiIi9MYev/32m97s44knnrCnlwAAVGBmOdhGvNwEElu2bJFx48bpmRyVKlXS00XUohYzZsyQhx9+2J5eAgBQgZkB3P2z3AUSahUs13RQVcpQ4yQUtXGIWtcbAACcP3weI9GuXTvZsGGDNGnSRLp37y6TJk3SYyReeOGFEitoAQAAcfT0T58zEtOmTZP4+Hj9/WOPPSY1atSQoUOHyv79++W5556zo48AAFT46Z+mHw5HZCQ6duzo/l6VNt5//31/9wkAAFQQLEgFAIDNzHI64yIggUTjxo31nhqns3Mna/kDAHC+jJHwOZAYPXq0x+vCwkK9SJUqcTzwwAP+7BsAAHBaIDFq1KhS25955hnZuHGjP/oEAICjmA7OSPg8a+N0evbsKa+//rq/bgcAgGOYDl7Z0m+DLVesWKH33QAAAJ4YI1FsQaqigy1N05TMzEy9jsTcuXP93T8AAOCkQKJ3794egYRaLrt27dpy5ZVXSrNmzaQ8aLbj+0B3ASiXTuz9NNBdAM5LJhmJ/5k8ebI9PQEAwKEMBwcSPg+2VDt+7tu3r0T7wYMH9TkAAHD+8DkjocZElEZtJx4WFuaPPgEA4CimOJfXgcTs2bP1VzU+4j//+Y9ERUW5z506dUrS09PLzRgJAADKE8PBpQ2vA4nU1FR3RmL+/PkeZQyViWjUqJFuBwAA5w+vA4ldu3bprz169JCVK1fq7cMBAMDZMWujiI8++siengAA4FCGOJfPszb69esn//73v0u0z5gxQ26++WZ/9QsAADgxkFCDKq+77rpS99pQ5wAAgCdTgvxyOKK0cezYsVKneYaGhsqRI0f81S8AABzDcPD8T58zEq1bt5ZXX321RPsrr7wiLVq08Fe/AABwDEOC/HI4IiMxceJE6du3r/zyyy9y1VVX6ba0tDRZtmyZ3gEUAACcP3wOJHr16iWrV6+WadOm6cAhIiJC2rRpIx9++CHbiAMAUIryOr4hIIGEcv311+tDUeMiXn75ZRk/frxs2rRJr3IJAAD+h+mfpVAzNAYNGiQJCQkyc+ZMXeZYv369f3sHAACck5HIzMyUxYsXy8KFC3UmYsCAAXqzLlXqYKAlAADnX2kj2JexEU2bNpVvv/1WZs2aJXv37pWnn37a3t4BAOCQ0obhh6NCZyTee+89GTlypAwdOlSaNGlib68AAICzMhKfffaZHD16VDp06CCdO3eWOXPmyIEDB+ztHQAADmA4OCPhdSDRpUsXWbBggfz555/yt7/9TS9ApQZaGoYha9eu1UEGAAA4v5bI9nnWRmRkpAwePFhnKL777jsZN26cTJ8+XerUqSM33nijPb0EAADOmv6pqMGXatfP33//Xa8lAQAASjKC/HM4ZkGq4ipVqiR9+vTRBwAA8FRe98koN4EEAAA4PQdv/nlupQ0AAFA+zZs3Ty6++GKJjo7WR9euXfVSDi55eXkybNgwiYmJkaioKOnXr59kZWX5/BwCCQAAHDj9s169enoyhNoHa+PGjXori969e8sPP/ygz48ZM0beeustWb58uXzyySd6oUm1u7evgkzTdFzGJSSsbqC7AJRLJ/Z+GuguAOVOaK0LbH/GiviBfrlP/z9fOqefV7t0P/7449K/f3+pXbu2LFu2TH+vbN26VZo3by4ZGRl6yQdvkZEAAKCCyM/P13tdFT1U29monbnV+k+5ubm6xKGyFIWFhZKYmOi+plmzZtKgQQMdSPiCQAIAAJuZfjpSUlKkWrVqHodqOx213pMa/xAeHi7333+/rFq1Sm+yqTbhDAsLk+rVq3tcHxsbq8/5glkbAADYzPDTfZKTk2Xs2LEebSpIONN6T1u2bJGcnBxZsWKFDBo0SI+H8CcCCQAAKojw8PAzBg7FqazDhRdeqL9Xe2Vt2LBBnnrqKbnlllukoKBAsrOzPbISatZGXFycT32itAEAwHmysqVhGHpMhQoqQkNDJS0tzX1u27Ztsnv3bj2GwhdkJAAAcODKlsnJydKzZ089gFJtrKlmaHz88ceyZs0aPbZiyJAhukyiZnKodSZGjBihgwhfZmwoBBIAADjQvn375M4779S7dqvAQS1OpYKIa665Rp9PTU2V4OBgvRCVylIkJSXJ3LlzfX4O60gA5xHWkQACs47Eiwl3+OU+d+x9UcobMhIAANjMcO6eXQQSAABUlOmf5RGzNgAAgGVkJAAAsJkpzkUgAQCAzQwHj5GgtAEAACwjIwEAgM0McS4CCQAAbGaIc1HaAAAAlpGRAADAZqaDB1sSSAAAYDNDnIvSBgAAsIyMBAAANjPEuQgkAACwmSnORSABAIDNDAcPtmSMBAAAsIyMBAAANjPEuQgkAACwmSHORWkDAABYRkYCAACbmeJcBBIAANjMYNYGAABASWQkAACwmSHORSABAIDNTHEuShsAAMAyMhIAANjMcHBOgkACAACbGeJcBBIAANjMFOdijAQAALCMjAQAADYzxLkIJAAAsJnBypYAAAAlkZEAAMBmhoOHWxJIAABgM1Oci9IGAACwjIwEAAA2M8S5CCQAALCZ4eDiBqUNAABgGRkJAABsZopzEUgAAGAzQ5yLQAIAAJsZDs5JMEYCAABYRkYCAACbmeJcZCQAACiDMRKGHw5fpKSkyCWXXCJVq1aVOnXqSJ8+fWTbtm0e1+Tl5cmwYcMkJiZGoqKipF+/fpKVleXTcwgkAABwoE8++UQHCevXr5e1a9dKYWGhXHvttZKbm+u+ZsyYMfLWW2/J8uXL9fV79+6Vvn37+vScINM0HZdxCQmrG+guAOXSib2fBroLQLkTWusC258xstEtfrnP7F9ftfyz+/fv15kJFTBcccUVkpOTI7Vr15Zly5ZJ//799TVbt26V5s2bS0ZGhnTp0sWr+5KRAACggpQ28vPz5ciRIx6HavOGChyUmjVr6q+bNm3SWYrExET3Nc2aNZMGDRroQMJbBBIAAFQQKSkpUq1aNY9DtZ2NYRgyevRoueyyy6RVq1a6LTMzU8LCwqR69eoe18bGxupz3mLWBgAAFWQdieTkZBk7dqxHW3h4+Fl/To2V+P777+Wzzz4TfyOQAADAZqaf7qOCBm8Ch6KGDx8ub7/9tqSnp0u9evXc7XFxcVJQUCDZ2dkeWQk1a0Od8xalDQAAHMg0TR1ErFq1Sj788ENp3Lixx/kOHTpIaGiopKWludvU9NDdu3dL165dvX4OGQnY4vJunWXcuKHSvl1rSUiIk779B8ubb64JdLeAMnNtv0GyN3NfifZb+94gE8YNk/z8Anl8zgJ5b90nUlBYKJd16iATxg+TWjVrBKS/cN4S2cOGDdMzMt544w29loRr3IMaVxEREaG/DhkyRJdK1ADM6OhoGTFihA4ivJ2xoRBIwBaRkVXk229/lEWLX5HXly8MdHeAMvfKf57SA9xctu/8Te4d/bBc2+Ny/frfs5+V9IwN8uSjD0tUZKRMe3KujH74UXlx/swA9hpO2rRr3rx5+uuVV17p0b5o0SK566679PepqakSHBysF6JSsz+SkpJk7ty5Pj2HQAK2eH/NR/oAzlc1a3iOhP/PC69J/brxckm71nL0WK6sfPsDmTH5Qencoa0+/69/jpUbb79Pvvn+J2nTqnmAeg27mAHISHizTFTlypXlmWee0YdVjJEAAJupufpvf/CR3HT9tRIUFCQ/btsuJ0+elC4d27mvuaBhfYmPrSPffL81oH0FHBVI7NmzRwYPHnzGa0pbnMOBi3UCqMDS0jPk6LFj0ue6a/TrAwcPS2hoiERXjfK4LqZmdTlw6FCAegk7BWKvjbJSrgOJQ4cOyZIlS3xenMM0jpZZHwHgbFa+vUa6dekodWrHBLorCGBpw/TD/5RHAR0j8eabb57x/M6dOy0tzlEjptk59w0A/GFvZpas37hFZk2b4G6rFVNDCgtPypGjxzyyEgcPZUut/798MVBRBDSQUFuaqnrhmUoR6ryvi3Oc7WcAoKysemet1KxRTa7o2snd1qJpEwkJCZEvN26Ra3p00227fvtd/szaJ21a8YeQExniXAEtbcTHx8vKlSv1FKnSjs2bNweyezjH6Z9t2rTUh9K4UQP9ff36CYHuGlBm1P8fW/3OWundM1FCQiq526tGRUrfG66VGU8vkK82fSM/bN0uE6Y9qWdrMGPDmQzT9MtRHgU0I6FW1VK7j/Xu3bvU82fLVqD86tihjaStW+F+PfOJyfrrkqWvyZB7xgSwZ0DZydjwtc4yqNkaxT008m96/v7ofz6qZ3Vc2qmDTBw/LCD9BM5FkBnAT+pPP/1UcnNz5S9/+Uup59W5jRs3Svfu3X26b0hYXT/1EHCWE3s/DXQXgHIntNYFtj/jjoZ9/XKfF39bKeVNQDMSl1/+3xXeTicyMtLnIAIAgPLGKKczLhw//RMAAJRvLJENAIDNTAdnJAgkAACwmSHORSABAIDNDAdnJBgjAQAALCMjAQCAzUwHZyQIJAAAsJkhzkVpAwAAWEZGAgAAm5kO3u6BQAIAAJsZDh4jQWkDAABYRkYCAACbGeJcBBIAANjMpLQBAABQEhkJAABsZjg4I0EgAQCAzUymfwIAAKsMcS7GSAAAAMvISAAAYDOTMRIAAMAqw8GBBKUNAABgGRkJAABsZjJrAwAAWGVQ2gAAACiJjAQAADYzHZyRIJAAAMBmhoPHSFDaAAAAlpGRAADAZqY4F4EEAAA2MxwcShBIAABgM8PBgQRjJAAAgGVkJAAAsJnp4FkbBBIAANjMoLQBAAAqmvT0dOnVq5ckJCRIUFCQrF69ukSmZNKkSRIfHy8RERGSmJgo27dv9+kZBBIAAJTBypamH/7HV7m5udKmTRt55plnSj0/Y8YMmT17tsyfP1++/PJLiYyMlKSkJMnLy/P6GZQ2AABw6BiJnj176uN0fZo1a5ZMmDBBevfurduWLl0qsbGxOnNx6623evUMMhIAAJyHdu3aJZmZmbqc4VKtWjXp3LmzZGRkeH0fMhIAAFSQwZb5+fn6KCo8PFwfvlJBhKIyEEWp165z3iAjAQCAzUzT9MuRkpKiswZFD9UWSGQkAACoIJKTk2Xs2LEebVayEUpcXJz+mpWVpWdtuKjXbdu29fo+ZCQAACiD0obhh0MFDdHR0R6H1UCicePGOphIS0tztx05ckTP3ujatavX9yEjAQCAzcwALUh17Ngx2bFjh8cAyy1btkjNmjWlQYMGMnr0aHn00UelSZMmOrCYOHGiXnOiT58+Xj+DQAIAAJsZAZr+uXHjRunRo4f7tassMmjQIFm8eLE8+OCDeq2J++67T7Kzs6Vbt27y/vvvS+XKlb1+RpDpwAXAQ8LqBroLQLl0Yu+nge4CUO6E1rrA9me0iu3il/t8n7VeyhsyEgAAOLS0URYIJAAAcGhpoywwawMAAFhGRgIAAJuZlDYAAIBVBqUNAACAkshIAABgM5PSBgAAsMqgtAEAAFASGQkAAGxmUtoAAABWmaYhTkUgAQCAzQwHZyQYIwEAACwjIwEAgM1MB8/aIJAAAMBmBqUNAACAkshIAABgM5PSBgAAsMpwcCBBaQMAAFhGRgIAAJuZDh5sSSABAIDNTEobAAAAJZGRAADAZgalDQAAYJXp4NIGgQQAADYzHBxIMEYCAABYRkYCAACbmQ7OSBBIAABgM8PBgy0pbQAAAMvISAAAYDOT0gYAALDKcHAgQWkDAABYRkYCAACbmQ4ebEkgAQCAzQxKGwAAACWRkQAAwGamgzMSBBIAANjMZIwEAACwynRwRoIxEgAAwDIyEgAA2Mx0cEaCQAIAAJuZ4lyUNgAAgGVBppPzLQio/Px8SUlJkeTkZAkPDw90d4Byg38bcBICCdjmyJEjUq1aNcnJyZHo6OhAdwcoN/i3ASehtAEAACwjkAAAAJYRSAAAAMsIJGAbNYjskUceYTAZUAz/NuAkDLYEAACWkZEAAACWEUgAAADLCCQAAIBlBBIAAMAyAgnY5plnnpFGjRpJ5cqVpXPnzvLVV18FuktAQKWnp0uvXr0kISFBgoKCZPXq1YHuEnDOCCRgi1dffVXGjh2rp7ht3rxZ2rRpI0lJSbJv375Adw0ImNzcXP1vQQXZgFMw/RO2UBmISy65RObMmaNfG4Yh9evXlxEjRsg//vGPQHcPCDiVkVi1apX06dMn0F0BzgkZCfhdQUGBbNq0SRITE91twcHB+nVGRkZA+wYA8C8CCfjdgQMH5NSpUxIbG+vRrl5nZmYGrF8AAP8jkAAAAJYRSMDvatWqJZUqVZKsrCyPdvU6Li4uYP0CAPgfgQT8LiwsTDp06CBpaWnuNjXYUr3u2rVrQPsGAPCvED/fD9DU1M9BgwZJx44dpVOnTjJr1iw99e3uu+8OdNeAgDl27Jjs2LHD/XrXrl2yZcsWqVmzpjRo0CCgfQOsYvonbKOmfj7++ON6gGXbtm1l9uzZeloocL76+OOPpUePHiXaVdC9ePHigPQJOFcEEgAAwDLGSAAAAMsIJAAAgGUEEgAAwDICCQAAYBmBBAAAsIxAAgAAWEYgAQAALCOQABzorrvukj59+rhfX3nllTJ69OiALMAUFBQk2dnZZf5sAGWDQAIo4w949cGqDrUnyYUXXihTp06VkydP2vrclStXyr/+9S+vruXDH4Av2GsDKGN/+ctfZNGiRZKfny/vvvuuDBs2TEJDQyU5OdnjuoKCAh1s+IPaywEA7EBGAihj4eHhejv1hg0bytChQyUxMVHefPNNdznisccek4SEBGnatKm+fs+ePTJgwACpXr26Dgh69+4tv/76q/t+p06d0pukqfMxMTHy4IMPSvGV74uXNlQQ89BDD0n9+vV1f1RmZOHChfq+rr0gatSooTMTql+uHVxTUlKkcePGEhERIW3atJEVK1Z4PEcFRhdddJE+r+5TtJ8AnIlAAggw9aGrsg+K2mp927ZtsnbtWnn77belsLBQkpKSpGrVqvLpp5/K559/LlFRUTqr4fqZmTNn6g2fnn/+efnss8/k0KFDsmrVqjM+884775SXX35Zb6T2008/ybPPPqvvqwKL119/XV+j+vHnn3/KU089pV+rIGLp0qUyf/58+eGHH2TMmDFyxx13yCeffOIOePr27Su9evXSO1rec8898o9//MPm3x6AgFObdgEoG4MGDTJ79+6tvzcMw1y7dq0ZHh5ujh8/Xp+LjY018/Pz3de/8MILZtOmTfW1Lup8RESEuWbNGv06Pj7enDFjhvt8YWGhWa9ePfdzlO7du5ujRo3S32/btk2lK/SzS/PRRx/p84cPH3a35eXlmVWqVDG/+OILj2uHDBli3nbbbfr75ORks0WLFh7nH3rooRL3AuAsjJEAypjKNKi//lW2QZULbr/9dpk8ebIeK9G6dWuPcRHffPON7NixQ2ckisrLy5NffvlFcnJydNag6PbsISEh0rFjxxLlDReVLahUqZJ0797d6z6rPhw/flyuueYaj3aVFWnXrp3+XmU2im8T37VrV6+fAaBiIpAAypgaOzBv3jwdMKixEOqD3yUyMtLj2mPHjkmHDh3kpZdeKnGf2rVrWy6l+Er1Q3nnnXekbt26HufUGAsA5y8CCaCMqWBBDW70Rvv27eXVV1+VOnXqSHR0dKnXxMfHy5dffilXXHGFfq2mkm7atEn/bGlU1kNlQtTYBjXQszhXRkQN4nRp0aKFDhh279592kxG8+bN9aDRotavX+/V+wRQcTHYEijHBg4cKLVq1dIzNdRgy127dul1HkaOHCm///67vmbUqFEyffp0Wb16tWzdulX+/ve/n3ENiEaNGsmgQYNk8ODB+mdc93zttdf0eTWbRM3WUCWY/fv362yEKq2MHz9eD7BcsmSJLqts3rxZnn76af1auf/++2X79u3ywAMP6IGay5Yt04NAATgbgQRQjlWpUkXS09OlQYMGekaE+qt/yJAheoyEK0Mxbtw4+etf/6qDAzUmQX3o33TTTWe8ryqt9O/fXwcdzZo1k3vvvVdyc3P1OVW6mDJlip5xERsbK8OHD9ftakGriRMn6tkbqh9q5ogqdajpoIrqo5rxoYITNTVUze6YNm2a7b8jAIEVpEZcBrgPAACggiIjAQAALCOQAAAAlhFIAAAAywgkAACAZQQSAADAMgIJAABgGYEEAACwjEACAABYRiABAAAsI5AAAACWEUgAAADLCCQAAIBY9f8AQMEIsNcz8f0AAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from sklearn.metrics import confusion_matrix\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "cm = confusion_matrix(y_test, y_pred)\n",
+    "\n",
+    "sns.heatmap(cm, annot=True, fmt='d')\n",
+    "plt.title(\"Confusion Matrix\")\n",
+    "plt.xlabel(\"Predicted\")\n",
+    "plt.ylabel(\"Actual\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7fb2ad3",
+   "metadata": {},
+   "source": [
+    "##  When to Use Which Metric?\n",
+    "\n",
+    "- Accuracy → When dataset is balanced  \n",
+    "- Precision → When false positives are costly (e.g., spam detection)  \n",
+    "- Recall → When false negatives are critical (e.g., disease detection)  \n",
+    "- F1 Score → When you need balance between precision and recall  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21ce785b",
+   "metadata": {},
+   "source": [
+    "##  Conclusion\n",
+    "\n",
+    "Classification metrics help evaluate model performance from different perspectives.\n",
+    "\n",
+    "- Accuracy gives overall correctness  \n",
+    "- Precision focuses on prediction quality  \n",
+    "- Recall focuses on capturing all positives  \n",
+    "- F1 Score balances both precision and recall  \n",
+    "\n",
+    "Choosing the right metric depends on the problem."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9a08c28a",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "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.13.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}