noshot 8.0.0__py3-none-any.whl → 10.0.0__py3-none-any.whl

noshot/data/ML TS XAI/ML/ML Lab H Sec/1. Iris Dataset (Softmax vs Sigmoid).ipynb

@@ -0,0 +1,231 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d9e9837e-70fc-47f0-9198-9c0bd862aa26",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "import tensorflow as tf\n",
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.layers import Dense, Input\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import LabelEncoder, StandardScaler, label_binarize\n",
+    "from sklearn.metrics import classification_report, confusion_matrix \n",
+    "from sklearn.metrics import ConfusionMatrixDisplay, roc_curve, auc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5d5852fb-929b-4e10-b71a-2806723e538c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "names = ['Sepal Length', 'Sepal Width', 'Petal Length', 'Petal Width', 'target']\n",
+    "df = pd.read_csv('iris.data', names=names)\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6944dd0f-23ad-4966-b9bd-93ea91f9ce02",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sns.countplot(df, x='target', hue='target', palette='viridis')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "790b368d-c13f-4f2d-971d-71cb0649e64e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = df.drop(columns='target')\n",
+    "y = df['target']\n",
+    "\n",
+    "X = StandardScaler().fit_transform(X)\n",
+    "y = LabelEncoder().fit_transform(y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c1bce7c1-f370-4f04-9663-64e3386baccb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def build_model(output_activation):\n",
+    "    model = Sequential([\n",
+    "        Input(shape=(4,)),\n",
+    "        Dense(64, activation='relu'),\n",
+    "        Dense(32, activation='relu'),\n",
+    "        Dense(3, activation=output_activation)\n",
+    "    ])\n",
+    "    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])\n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "998082ab-6ab5-4df2-99f6-53b5c304a818",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=2)\n",
+    "model_softmax = build_model('softmax')\n",
+    "history_softmax = model_softmax.fit(X_train, y_train, \n",
+    "                                    validation_data=(X_test, y_test), \n",
+    "                                    epochs=25, verbose=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f0dd395f-0831-4d78-9f06-0bb20d9bfdb7",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=2)\n",
+    "model_sigmoid = build_model('sigmoid')\n",
+    "history_sigmoid = model_sigmoid.fit(X_train, y_train, \n",
+    "                                    validation_data=(X_test, y_test), \n",
+    "                                    epochs=25, verbose=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8c1c01d7-d783-438b-834b-2820c6ed1afc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(10,6))\n",
+    "\n",
+    "plt.plot(history_softmax.history['accuracy'], label='Softmax - Train Accuracy', color='blue', linewidth=2)\n",
+    "plt.plot(history_softmax.history['val_accuracy'], label='Softmax - Val Accuracy', color='blue', linestyle='--')\n",
+    "\n",
+    "plt.plot(history_sigmoid.history['accuracy'], label='Sigmoid - Train Accuracy', color='green', linewidth=2)\n",
+    "plt.plot(history_sigmoid.history['val_accuracy'], label='Sigmoid - Val Accuracy', color='green', linestyle='--')\n",
+    "\n",
+    "plt.title('Training and Validation Accuracy Comparison')\n",
+    "plt.xlabel('Epoch')\n",
+    "plt.ylabel('Accuracy')\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "51329ded-8ea8-4404-94c7-65f968170e0c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "softmax_score = model_softmax.evaluate(X_test, y_test, verbose=0)\n",
+    "sigmoid_score = model_sigmoid.evaluate(X_test, y_test, verbose=0)\n",
+    "\n",
+    "print(f\"Test Accuracy with Softmax: {softmax_score[1]:.4f}\")\n",
+    "print(f\"Test Accuracy with Sigmoid: {sigmoid_score[1]:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9eb9a3f8-4d1b-46fd-b7f0-c860c884ce5e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.bar(['Softmax', 'Sigmoid'], [softmax_score[1], sigmoid_score[1]], color=['blue','green'])\n",
+    "plt.ylabel('Test Accuracy')\n",
+    "plt.title('Final Test Accuracy Comparison')\n",
+    "plt.ylim(0, 1)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6af8884-54fa-4fbe-905c-e9bb2ce85d8f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred_softmax = np.argmax(model_softmax.predict(X_test), axis=1)\n",
+    "y_pred_sigmoid = np.argmax(model_sigmoid.predict(X_test), axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c6dbf0c-b52d-4560-844d-f78562585cca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "labels = df['target'].unique()\n",
+    "print(\"Classification Report for Softmax:\")\n",
+    "print(classification_report(y_test, y_pred_softmax, target_names=labels))\n",
+    "\n",
+    "print(\"\\nClassification Report for Sigmoid:\")\n",
+    "print(classification_report(y_test, y_pred_sigmoid, target_names=labels))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "246d7e32-f654-43f9-8535-caa20e613016",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cm_softmax = confusion_matrix(y_test, y_pred_softmax)\n",
+    "cm_sigmoid = confusion_matrix(y_test, y_pred_sigmoid)\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 2, figsize=(14, 6))\n",
+    "\n",
+    "ConfusionMatrixDisplay(cm_softmax, display_labels=labels).plot(ax=ax[0])\n",
+    "ax[0].set_title(\"Softmax Confusion Matrix\", size=25)\n",
+    "\n",
+    "ConfusionMatrixDisplay(cm_sigmoid, display_labels=labels).plot(ax=ax[1])\n",
+    "ax[1].set_title(\"Sigmoid Confusion Matrix\", size=25)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "NEW-VENV-1",
+   "language": "python",
+   "name": "new-venv-1"
+  },
+  "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

noshot/data/ML TS XAI/ML/ML Lab H Sec/2. Student Dataset (Overfit vs Regularized).ipynb

@@ -0,0 +1,269 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f8f281db-b729-4df9-8735-639cd5cf64d8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import tensorflow as tf\n",
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.layers import Dense, Dropout, BatchNormalization\n",
+    "from tensorflow.keras.optimizers import Adam\n",
+    "from tensorflow.keras import regularizers\n",
+    "from sklearn.preprocessing import LabelEncoder\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import classification_report, confusion_matrix \n",
+    "from sklearn.metrics import ConfusionMatrixDisplay, accuracy_score, roc_curve, auc\n",
+    "\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cb163478-4de9-4d16-ae12-d650a7c7bffd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv('student-mat.csv', sep=';')\n",
+    "#df = pd.read_csv('student-por.csv', sep=';')\n",
+    "print(\"Shape:\",df.shape)\n",
+    "df = df.drop(columns=['G1','G2'])\n",
+    "df = df.rename(columns={'G3': 'target'})\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "91764ed3-4699-45e0-b795-0c79b77a78ca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cat_cols = df.select_dtypes(include='object').columns.tolist()\n",
+    "df[cat_cols] = df[cat_cols].apply(LabelEncoder().fit_transform)\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "284440eb-4a57-496c-a7c3-847027372c4e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = df.drop(columns=['target'])\n",
+    "y = tf.keras.utils.to_categorical(df['target'], num_classes=21)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e7a7a68d-1aeb-4099-ae62-3f7a06167fa6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "overfit = Sequential([\n",
+    "    Dense(128, activation='relu', input_shape=(30,)),\n",
+    "    Dense(64, activation='relu'),\n",
+    "    Dense(32, activation='relu'),\n",
+    "    Dense(21, activation='softmax')\n",
+    "])\n",
+    "\n",
+    "overfit.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8f92d2c8-2117-46d0-82e6-51ccf67957f8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)\n",
+    "history1 = overfit.fit(x_train, y_train, epochs=25,\n",
+    "                    batch_size=8, validation_split=0.2,\n",
+    "                    verbose=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12d28840-d3d7-42f6-b33c-63c833123ddd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "regularized = Sequential([\n",
+    "    Dense(128, activation='relu', input_shape=(30,), kernel_regularizer=regularizers.l2(0.002)),\n",
+    "    Dropout(0.25),\n",
+    "    Dense(64, activation='relu', kernel_regularizer=regularizers.l2(0.002)),\n",
+    "    Dropout(0.25),\n",
+    "    Dense(21, activation='softmax')\n",
+    "])\n",
+    "\n",
+    "regularized.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f30536d9-df1f-41be-8821-75cab3a74d9b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "early_stopping = tf.keras.callbacks.EarlyStopping(monitor='val_loss', \n",
+    "                                                  patience=10, \n",
+    "                                                  restore_best_weights=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b8dd5fbb-71a5-4e00-925d-ff522b9ab314",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=1)\n",
+    "history2 = regularized.fit(x_train, y_train, epochs=25, \n",
+    "                    batch_size=16, validation_split=0.3,\n",
+    "                    callbacks=[early_stopping], verbose=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cb392228-7a26-4dc5-a2a3-5cd44875c4ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_history(history1, history2):\n",
+    "    plt.figure(figsize=(12, 5))\n",
+    "    plt.subplot(1, 2, 1)\n",
+    "    plt.plot(history1.history['accuracy'], label='Overfit Model Validation Accuracy')\n",
+    "    plt.plot(history2.history['accuracy'], label='Regularized Model Validation Accuracy')\n",
+    "    plt.title('Training Accuracy')\n",
+    "    plt.xlabel('Epoch')\n",
+    "    plt.ylabel('Accuracy')\n",
+    "    plt.legend()\n",
+    "\n",
+    "    plt.subplot(1, 2, 2)\n",
+    "    plt.plot(history1.history['val_accuracy'], label='Overfit Model Validation Accuracy')\n",
+    "    plt.plot(history2.history['val_accuracy'], label='Regularized Model Validation Accuracy')\n",
+    "    plt.title('Validation Accuracy')\n",
+    "    plt.xlabel('Epoch')\n",
+    "    plt.ylabel('Accuracy')\n",
+    "    plt.legend()\n",
+    "\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "plot_history(history1, history2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8703400f-47a9-4c4e-b9b4-e302c69a209b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loss1, accuracy1 = overfit.evaluate(x_train, y_train)\n",
+    "loss2, accuracy2 = overfit.evaluate(x_test, y_test)\n",
+    "print(f'Train accuracy Overfit Model: {accuracy1:.4f}')\n",
+    "print(f'Test accuracy Overfit Model: {accuracy2:.4f}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8548d072-206c-4ab6-8c98-c5fb63b644c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loss1, accuracy1 = regularized.evaluate(x_train, y_train)\n",
+    "loss2, accuracy2 = regularized.evaluate(x_test, y_test)\n",
+    "print(f'Train accuracy Regularized Model: {accuracy1:.4f}')\n",
+    "print(f'Test accuracy Regularized Model: {accuracy2:.4f}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ad978e23-15b8-402f-bb31-d00aa4771c93",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred1 = np.argmax(overfit.predict(x_test), axis=1)\n",
+    "y_test1 = np.argmax(y_test, axis=1)\n",
+    "y_pred2 = np.argmax(regularized.predict(x_test), axis=1)\n",
+    "y_test2 = np.argmax(y_test, axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ca0a093-04ac-48f3-8454-010413d268cf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"Classification Report for Overfit:\")\n",
+    "print(classification_report(y_test1, y_pred1))\n",
+    "\n",
+    "print(\"\\nClassification Report for Regularized:\")\n",
+    "print(classification_report(y_test2, y_pred2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c31bd086-7fd9-4ea9-b0bf-9ac14bcca5bc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "labels1 = np.unique(np.concatenate((y_test1, y_pred1)))\n",
+    "labels2 = np.unique(np.concatenate((y_test2, y_pred2)))\n",
+    "\n",
+    "cm1 = confusion_matrix(y_test1, y_pred1, labels=labels1)\n",
+    "cm2 = confusion_matrix(y_test2, y_pred2, labels=labels2)\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 2, figsize=(14, 6))\n",
+    "\n",
+    "ConfusionMatrixDisplay(cm1, display_labels=labels1).plot(ax=ax[0], colorbar=False)\n",
+    "ax[0].set_title(\"Overfit Confusion Matrix\", size=25)\n",
+    "\n",
+    "ConfusionMatrixDisplay(cm2, display_labels=labels2).plot(ax=ax[1], colorbar=False)\n",
+    "ax[1].set_title(\"Regularized Confusion Matrix\", size=25)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "NEW-VENV-1",
+   "language": "python",
+   "name": "new-venv-1"
+  },
+  "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}