noshot 11.0.0__py3-none-any.whl → 12.0.0__py3-none-any.whl

noshot/data/ML TS XAI/ML/ML Lab AllinOne.ipynb

@@ -1,961 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "007cdc19-d98f-4533-a27b-2ea68643fd09",
-   "metadata": {},
-   "source": [
-    "#### __Most plots Related to dataset with categorical variable as output are used in KNN exp__\n",
-    "#### __But it should also be used for relevant other experiments also like Naive Bayes, Logistic Regression__"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c73ca8b2-5a11-488d-97ca-160ad0ff4f18",
-   "metadata": {},
-   "source": [
-    "### __***PCA***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e4a62599-bb3d-4b3d-8bcd-ec26893e3921",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import seaborn as sns\n",
-    "import matplotlib.pyplot as plt\n",
-    "from sklearn.preprocessing import StandardScaler\n",
-    "from sklearn.decomposition import PCA\n",
-    "\n",
-    "df = pd.read_table('data/balance-scale.csv', delimiter=',')\n",
-    "print(\"Shape:\", df.shape)\n",
-    "display(df.head())\n",
-    "\n",
-    "X = df.drop(columns='class name')\n",
-    "y = df['class name']\n",
-    "\n",
-    "scaled = StandardScaler().fit_transform(X)\n",
-    "pca = PCA(n_components=2).fit_transform(scaled)\n",
-    "\n",
-    "final = pd.DataFrame(pca, columns=['PC1', 'PC2'])\n",
-    "final['target'] = df['class name']\n",
-    "final.head()\n",
-    "\n",
-    "sns.countplot(df, x='class name', hue='class name')\n",
-    "plt.show()\n",
-    "sns.heatmap(X.corr(), cmap='Blues')\n",
-    "plt.show()\n",
-    "sns.pairplot(X)\n",
-    "plt.show()\n",
-    "sns.scatterplot(final, x='PC1', y='PC2', hue='target')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9c779383-f645-4ee2-8bd0-4d9ce2f900fb",
-   "metadata": {},
-   "source": [
-    "### __***KNN***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4b52d350-cc91-4505-96b5-8fad7f4eb6f7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import seaborn as sns\n",
-    "import matplotlib.pyplot as plt\n",
-    "from sklearn.preprocessing import StandardScaler\n",
-    "from sklearn.model_selection import train_test_split, cross_val_score\n",
-    "from sklearn.decomposition import PCA\n",
-    "from sklearn.neighbors import KNeighborsClassifier\n",
-    "from sklearn.metrics import confusion_matrix, classification_report\n",
-    "from sklearn.metrics import accuracy_score, ConfusionMatrixDisplay\n",
-    "from mlxtend.plotting import plot_decision_regions\n",
-    "from scipy.cluster.hierarchy import dendrogram, linkage\n",
-    "from scipy.spatial import Voronoi, voronoi_plot_2d\n",
-    "\n",
-    "df = pd.read_csv(\"data/sobar-72.csv\")\n",
-    "print(\"Shape:\", df.shape)\n",
-    "display(df.head())\n",
-    "\n",
-    "X = df.drop(columns='ca_cervix')\n",
-    "y = df['ca_cervix']\n",
-    "\n",
-    "X_scaled = StandardScaler().fit_transform(X)\n",
-    "X_pca = PCA(n_components=2).fit_transform(X_scaled)\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X_pca, y, \n",
-    "                                                    test_size=0.4,\n",
-    "                                                    random_state=4)\n",
-    "\n",
-    "knn = KNeighborsClassifier(n_neighbors=15, metric='euclidean') \n",
-    "#can be ['euclidean', 'manhattan', 'minkowski']\n",
-    "knn.fit(X_train, y_train)\n",
-    "y_pred = knn.predict(X_test)\n",
-    "\n",
-    "sns.countplot(df, x='ca_cervix', hue='ca_cervix')\n",
-    "plt.show()\n",
-    "\n",
-    "sns.pairplot(df.iloc[:,:4])\n",
-    "plt.show()\n",
-    "\n",
-    "# dont use this mlxtend module may not be installed in lab\n",
-    "# ========================================================\n",
-    "plot_decision_regions(X_train, y_train.values, clf=knn, legend=2)\n",
-    "plt.xlabel('X')\n",
-    "plt.ylabel('Y')\n",
-    "plt.title(f'KNN with K=5 using Euclidean Distance')\n",
-    "plt.show()\n",
-    "# ========================================================\n",
-    "print(classification_report(y_test, y_pred))\n",
-    "print(\"Accuracy\", accuracy_score(y_test, y_pred))\n",
-    "ConfusionMatrixDisplay(confusion_matrix(y_test, y_pred)).plot()\n",
-    "plt.show()\n",
-    "\n",
-    "errors = [1 - cross_val_score(KNeighborsClassifier(n_neighbors=k), \n",
-    "                              X_train, y_train).mean() for k in range(1, 21)]\n",
-    "plt.plot(range(1, 21), errors, marker='o')\n",
-    "plt.title(\"Elbow Method for Optimal k\")\n",
-    "plt.xlabel(\"k\")\n",
-    "plt.ylabel(\"Error\")\n",
-    "plt.show()\n",
-    "\n",
-    "vor = Voronoi(X_pca)\n",
-    "voronoi_plot_2d(vor, show_vertices=False)\n",
-    "plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y)\n",
-    "plt.show()\n",
-    "\n",
-    "# use this instead for decision boundary graph\n",
-    "x_min, x_max = X_pca[:,0].min() - 1, X_pca[:,0].max() + 1\n",
-    "y_min, y_max = X_pca[:,1].min() - 1, X_pca[:,1].max() + 1\n",
-    "xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02), \n",
-    "                     np.arange(y_min, y_max, 0.02))\n",
-    "\n",
-    "Z = knn.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n",
-    "\n",
-    "plt.figure()\n",
-    "plt.contourf(xx, yy, Z, cmap=plt.cm.coolwarm, alpha=0.8)\n",
-    "plt.scatter(X_pca[:,0], X_pca[:,1], c=y, cmap=plt.cm.coolwarm, s=20, \n",
-    "            edgecolors='k')\n",
-    "plt.title('Decision surface')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b9a6637d-95a0-45c0-8527-0febe5ce29b4",
-   "metadata": {},
-   "source": [
-    "### __***LDA***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6fcb1964-95eb-4d1a-9961-8cf3fe9961e4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "from sklearn.preprocessing import StandardScaler\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n",
-    "from sklearn.metrics import accuracy_score\n",
-    "\n",
-    "df = pd.read_csv(r\"data\\doctor-visits.csv\")\n",
-    "print(\"Shape:\", df.shape)\n",
-    "display(df.head())\n",
-    "\n",
-    "X = df.drop(columns=['Number of Doctors Visited'])\n",
-    "y = df['Number of Doctors Visited']\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, \n",
-    "                                                    random_state=4)\n",
-    "\n",
-    "lda = LDA(n_components=2)\n",
-    "X_train = lda.fit_transform(X_train, y_train)\n",
-    "X_test = lda.fit_transform(X_test, y_test)\n",
-    "\n",
-    "lda.fit(X_train,y_train)\n",
-    "y_pred = lda.predict(X_test)\n",
-    "print (\"Accuracy:\", accuracy_score(y_test, y_pred))\n",
-    "\n",
-    "plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap='viridis')\n",
-    "plt.title('LDA Dimensionality Reduction')\n",
-    "plt.xlabel('LDA Component 1')\n",
-    "plt.ylabel('LDA Component 2')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "468327ab-beff-425b-ba7a-3e2b373ba9ae",
-   "metadata": {},
-   "source": [
-    "### __***Linear Regression***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2511f5c4-b720-4889-b1f3-ca92266bf09b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "from sklearn.linear_model import LinearRegression\n",
-    "from sklearn.metrics import r2_score, mean_squared_error\n",
-    "\n",
-    "df = pd.read_excel(\"data/real-estate.xlsx\")\n",
-    "print(\"Shape:\", df.shape)\n",
-    "display(df.head())\n",
-    "\n",
-    "X = df[['X5 latitude']].values\n",
-    "y = df['Y house price of unit area'].values\n",
-    "\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
-    "\n",
-    "model = LinearRegression().fit(X_train, y_train)\n",
-    "y_train_pred = model.predict(X_train)\n",
-    "y_test_pred = model.predict(X_test)\n",
-    "\n",
-    "sns.heatmap(df.corr(), annot=True)\n",
-    "plt.show()\n",
-    "\n",
-    "plt.figure(figsize=(10,5))\n",
-    "plt.scatter(X_train, y_train, label='Train Data Points', edgecolor='k')\n",
-    "plt.scatter(X_test, y_test, label='Test Data Points', edgecolor='k')\n",
-    "plt.plot(X_train, model.predict(X_train), color='red', \n",
-    "         label='Linear Regression Line')\n",
-    "plt.legend()\n",
-    "plt.grid()\n",
-    "plt.show()\n",
-    "\n",
-    "plt.figure(figsize=(10,5))\n",
-    "plt.scatter(X_test, y_test, label='Test Data Points', edgecolor='k')\n",
-    "plt.plot(X_test, model.predict(X_test), color='red', \n",
-    "         label='Linear Regression Line')\n",
-    "for i in range(len(X_test)):\n",
-    "    plt.plot((X_test[i], X_test[i]), (y_test[i], y_test_pred[i]), \n",
-    "             color='blue', linestyle='--')\n",
-    "plt.legend()\n",
-    "plt.grid()\n",
-    "plt.show()\n",
-    "\n",
-    "print(\"Train MSE:\", mean_squared_error(y_train, y_train_pred))\n",
-    "print(\"Train R2 Score:\", r2_score(y_train, y_train_pred))\n",
-    "print(\"Test MSE:\", mean_squared_error(y_test, y_test_pred))\n",
-    "print(\"Test R2 Score:\", r2_score(y_test, y_test_pred))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c4a1c9ec-ca2e-483c-961b-2214c6f966d2",
-   "metadata": {},
-   "source": [
-    "### __***Logistic Regression***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "39fd591b-1bf3-48ad-83df-7a0832fe5742",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import seaborn as sns\n",
-    "import matplotlib.pyplot as plt\n",
-    "from sklearn.preprocessing import MinMaxScaler, LabelEncoder\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "from sklearn.decomposition import PCA\n",
-    "from sklearn.linear_model import LogisticRegression\n",
-    "from sklearn.metrics import accuracy_score, classification_report, auc\n",
-    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, roc_curve\n",
-    "\n",
-    "df = pd.read_csv('data/magic04.data', header=None)\n",
-    "display(df.head())\n",
-    "\n",
-    "X = MinMaxScaler().fit_transform(df.drop(columns=[10]))\n",
-    "X = PCA(n_components=1).fit_transform(X)\n",
-    "y = LabelEncoder().fit_transform(df[10])  # Convert 'g'/'h' to 0/1\n",
-    "\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, \n",
-    "                                                    stratify=y)\n",
-    "lr = LogisticRegression(max_iter=5000, random_state=0)\n",
-    "lr.fit(X_train, y_train)\n",
-    "y_pred = lr.predict(X_test)\n",
-    "\n",
-    "print(f\"Accuracy: {accuracy_score(y_test, y_pred)}\")\n",
-    "print(classification_report(y_test, y_pred))\n",
-    "cm = confusion_matrix(y_test, y_pred)\n",
-    "ConfusionMatrixDisplay(cm, display_labels=['g', 'h']).plot()\n",
-    "plt.show()\n",
-    "\n",
-    "y_pred_proba = lr.predict_proba(X_test)[:, 1]\n",
-    "fpr, tpr, _ = roc_curve(y_test, y_pred_proba, pos_label=1)\n",
-    "roc_auc = auc(fpr, tpr)\n",
-    "plt.plot(fpr, tpr, label=f'ROC curve (area = {roc_auc:.2f})')\n",
-    "plt.plot([0, 1], [0, 1], 'k--', label='No Skill')\n",
-    "plt.xlabel('False Positive Rate')\n",
-    "plt.ylabel('True Positive Rate')\n",
-    "plt.title('ROC Curve')\n",
-    "plt.legend()\n",
-    "plt.show()\n",
-    "\n",
-    "# may not proper s curve because of low model accuracy\n",
-    "# ====================================================\n",
-    "plt.figure(figsize=(10, 6))\n",
-    "plt.scatter(X, y, color='red', label='Data points (g = 1, h = 0)')\n",
-    "x_values = np.linspace(X.min(), X.max(), 100).reshape(-1, 1)\n",
-    "y_values = lr.predict_proba(x_values)[:, 1] \n",
-    "plt.plot(x_values, y_values, color='blue', label='Logistic Regression S-Curve')\n",
-    "plt.axhline(0.5, color='green', linestyle='--', label='Threshold (0.5)')\n",
-    "plt.title('Logistic Regression: X(PCA Transformed) vs Probability of g')\n",
-    "plt.legend()\n",
-    "plt.grid()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9a251e04-2e7b-4a94-921e-9fd3f18984e7",
-   "metadata": {},
-   "source": [
-    "### __***Naive Bayes***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "985bcacf-bcee-49ef-9c59-ede381fef350",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "from sklearn.preprocessing import LabelEncoder\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "from sklearn.naive_bayes import GaussianNB\n",
-    "from sklearn.metrics import accuracy_score, classification_report, roc_curve\n",
-    "from sklearn.metrics import ConfusionMatrixDisplay, auc, confusion_matrix\n",
-    "\n",
-    "df = pd.read_csv(\"data/agaricus-lepiota.data\", header=None)\n",
-    "display(df.head())\n",
-    "\n",
-    "df = df.apply(LabelEncoder().fit_transform)\n",
-    "X = df.drop(columns=[0])\n",
-    "y = df[0]\n",
-    "\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, \n",
-    "                                                    stratify=y)\n",
-    "\n",
-    "nb = GaussianNB()\n",
-    "nb.fit(X_train, y_train)\n",
-    "y_pred = nb.predict(X_test)\n",
-    "\n",
-    "print(f\"Accuracy: {accuracy_score(y_test, y_pred)}\")\n",
-    "print(classification_report(y_test, y_pred))\n",
-    "ConfusionMatrixDisplay(confusion_matrix(y_test, y_pred)).plot()\n",
-    "plt.show()\n",
-    "\n",
-    "y_pred_proba = nb.predict_proba(X_test)[:, 1]\n",
-    "fpr, tpr, _ = roc_curve(y_test, y_pred_proba)\n",
-    "roc_auc = auc(fpr, tpr)\n",
-    "plt.plot(fpr, tpr, label=f'ROC curve (area = {roc_auc:.2f})')\n",
-    "plt.plot([0, 1], [0, 1], 'k--', label='No Skill')\n",
-    "plt.xlabel('False Positive Rate')\n",
-    "plt.ylabel('True Positive Rate')\n",
-    "plt.title('ROC Curve for Agaricus-Lepiota Classification')\n",
-    "plt.legend()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "77d7fd14-037a-4e11-b248-c3a7f136a9fc",
-   "metadata": {},
-   "source": [
-    "### __***SVM (Linear & Non-Linear)***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "17f1e639-d8ae-41f9-9ba7-1c489e122ff0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "from sklearn.metrics import accuracy_score, classification_report\n",
-    "from sklearn.metrics import ConfusionMatrixDisplay, roc_curve, auc\n",
-    "from sklearn.preprocessing import StandardScaler\n",
-    "from sklearn.decomposition import PCA\n",
-    "from sklearn.svm import SVC\n",
-    "from mlxtend.plotting import plot_decision_regions\n",
-    "from scipy.io import arff\n",
-    "\n",
-    "data = pd.DataFrame(arff.loadarff(\"data/rice.arff\")[0])\n",
-    "data['Class'] = data['Class'].map({b'Cammeo': 0, b'Osmancik': 1})\n",
-    "\n",
-    "X = PCA(n_components=2).fit_transform(data.drop('Class', axis=1))\n",
-    "y = data['Class']\n",
-    "\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, \n",
-    "                                                    random_state=42)\n",
-    "\n",
-    "scaler = StandardScaler()\n",
-    "X_train, X_test = scaler.fit_transform(X_train), scaler.transform(X_test)\n",
-    "\n",
-    "# kernel options: 'linear', 'rbf', 'poly', 'sigmoid'\n",
-    "kernel = 'linear'\n",
-    "\n",
-    "# gamma should be:\n",
-    "# - 'auto' for linear kernel\n",
-    "# - 'scale' or 'auto' for rbf, poly, sigmoid kernels\n",
-    "model = SVC(kernel=kernel, C=1, degree=5, \n",
-    "            gamma='auto' if kernel == 'linear' else 'scale', probability=True)\n",
-    "model.fit(X_train, y_train)\n",
-    "y_pred = model.predict(X_test)\n",
-    "\n",
-    "print(f\"\\nSVM ({kernel}) Accuracy: {accuracy_score(y_test, y_pred):.2f}\")\n",
-    "print(classification_report(y_test, y_pred))\n",
-    "\n",
-    "plot_decision_regions(X_train, y_train.values, clf=model, legend=2)\n",
-    "plt.title(f'Decision Boundary ({kernel})')\n",
-    "plt.show()\n",
-    "\n",
-    "ConfusionMatrixDisplay.from_predictions(y_test, y_pred, display_labels=[0, 1])\n",
-    "plt.title(f'Confusion Matrix ({kernel})')\n",
-    "plt.show()\n",
-    "\n",
-    "proba = model.predict_proba(X_test)[:, 1]\n",
-    "fpr, tpr, _ = roc_curve(y_test, proba)\n",
-    "plt.plot(fpr, tpr, label=f'{kernel} (AUC = {auc(fpr, tpr):.2f})')\n",
-    "plt.plot([0, 1], [0, 1], 'k--')\n",
-    "plt.xlabel('False Positive Rate')\n",
-    "plt.ylabel('True Positive Rate')\n",
-    "plt.title(f'ROC Curve ({kernel})')\n",
-    "plt.legend()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3047d014-1588-4ba3-b122-8a1e009db945",
-   "metadata": {},
-   "source": [
-    "### __***Feed Forward - Classification (Output Categorical)***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "02cd39c1-edaa-4f18-9298-68e111cf45ce",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import warnings\n",
-    "warnings.filterwarnings('ignore')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8d6b8e4d-e851-4874-af1f-2da2346a9aa3",
-   "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 sklearn.model_selection import train_test_split\n",
-    "from sklearn.metrics import classification_report, accuracy_score \n",
-    "from sklearn.metrics import ConfusionMatrixDisplay, roc_curve, auc\n",
-    "from tensorflow.keras.models import Sequential\n",
-    "from tensorflow.keras.layers import Dense, Dropout\n",
-    "from tensorflow.keras.optimizers import Adam\n",
-    "from tensorflow.keras import regularizers\n",
-    "\n",
-    "df = pd.read_csv(\"data/sobar-72.csv\")\n",
-    "print(\"Shape:\",df.shape)\n",
-    "display(df.head())\n",
-    "\n",
-    "X = df.drop(columns=['ca_cervix'])\n",
-    "y = tf.keras.utils.to_categorical(df['ca_cervix'], num_classes=2)\n",
-    "\n",
-    "x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2, \n",
-    "                                                    random_state=42)\n",
-    "\n",
-    "# change l2 (Ridge) to l1 for Lasso regularization\n",
-    "model = Sequential([\n",
-    "    Dense(128, activation='relu', input_shape=(19,), \n",
-    "          kernel_regularizer=regularizers.l2(0.001)), # if no regularizer remove this\n",
-    "    Dropout(0.3),\n",
-    "    Dense(64, activation='relu', \n",
-    "          kernel_regularizer=regularizers.l2(0.001)), # if no regularizer remove this\n",
-    "    Dropout(0.3),\n",
-    "    Dense(2, activation='softmax') # makes it classification\n",
-    "])\n",
-    "\n",
-    "model.compile(optimizer=Adam(), loss='categorical_crossentropy', \n",
-    "              metrics=['accuracy'])\n",
-    "\n",
-    "history = model.fit(x_train, y_train, epochs=50, batch_size=32, \n",
-    "                    validation_split=0.2, verbose=1)\n",
-    "\n",
-    "def plot_history(history):\n",
-    "    plt.figure(figsize=(12, 5))\n",
-    "    plt.subplot(1, 2, 1)\n",
-    "    plt.plot(history.history['loss'], label='Training Loss')\n",
-    "    plt.plot(history.history['val_loss'], label='Validation Loss')\n",
-    "    plt.title('Loss')\n",
-    "    plt.subplot(1, 2, 2)\n",
-    "    plt.plot(history.history['accuracy'], label='Training Accuracy')\n",
-    "    plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n",
-    "    plt.title('Accuracy')\n",
-    "    plt.tight_layout()\n",
-    "    plt.show()\n",
-    "\n",
-    "plot_history(history)\n",
-    "\n",
-    "loss, accuracy = model.evaluate(x_test, y_test)\n",
-    "print(f'Test accuracy: {accuracy:.4f}, Test loss: {loss:.4f}')\n",
-    "\n",
-    "y_pred = np.argmax(model.predict(x_test), axis=1)\n",
-    "y_test = np.argmax(y_test, axis=1)\n",
-    "\n",
-    "print(\"Classification Report:\")\n",
-    "print(classification_report(y_test, y_pred))\n",
-    "print(f\"Accuracy: {accuracy_score(y_test, y_pred):.2f}\")\n",
-    "ConfusionMatrixDisplay.from_predictions(y_test, y_pred, cmap='Blues')\n",
-    "plt.show()\n",
-    "\n",
-    "y_pred_proba = model.predict(x_test)[:, 1]\n",
-    "fpr, tpr, _ = roc_curve(y_test, y_pred_proba)\n",
-    "plt.plot(fpr, tpr, label=f'ROC curve (area = {auc(fpr, tpr):.2f})')\n",
-    "plt.plot([0, 1], [0, 1], color='navy', linestyle='--')\n",
-    "plt.xlabel('False Positive Rate')\n",
-    "plt.ylabel('True Positive Rate')\n",
-    "plt.title('Receiver Operating Characteristic')\n",
-    "plt.legend(loc=\"lower right\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "86c71922-b7d4-4ae8-ae4e-0f19b4b74af7",
-   "metadata": {},
-   "source": [
-    "### __***Feed Forward - Regression (Output Numerical)***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ac35d507-57d3-4ea6-a535-3df21c0b4dcd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import warnings\n",
-    "warnings.filterwarnings('ignore')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "02e338ba-2fa5-4187-8337-a4db19af2faf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "from sklearn.preprocessing import StandardScaler\n",
-    "from sklearn.metrics import accuracy_score, mean_squared_error\n",
-    "import tensorflow as tf\n",
-    "from tensorflow.keras.models import Sequential\n",
-    "from tensorflow.keras.layers import Dense\n",
-    "\n",
-    "df = pd.read_csv('data/california.csv')\n",
-    "display(df.head())\n",
-    "\n",
-    "X = df.drop(columns='target')\n",
-    "y = df['target']\n",
-    "\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, \n",
-    "                                                    random_state=42)\n",
-    "\n",
-    "scaler = StandardScaler()\n",
-    "X_train = scaler.fit_transform(X_train)\n",
-    "X_test = scaler.transform(X_test)\n",
-    "\n",
-    "# Simple FNN/MLP model\n",
-    "model = Sequential([\n",
-    "    Dense(32, activation='relu', input_shape=(X_train.shape[1],)),\n",
-    "    Dense(16, activation='relu'),\n",
-    "    Dense(1) # makes its regression\n",
-    "])\n",
-    "\n",
-    "model.compile(optimizer='adam', loss='mse')\n",
-    "\n",
-    "history = model.fit(X_train, y_train, epochs=25, validation_split=0.2, verbose=1)\n",
-    "\n",
-    "y_pred = model.predict(X_test).flatten()\n",
-    "mse = mean_squared_error(y_test, y_pred)\n",
-    "print(f\"Regression MSE on California Housing dataset: {mse:.4f}\")\n",
-    "\n",
-    "plt.plot(history.history['loss'], label='Train Loss')\n",
-    "plt.plot(history.history['val_loss'], label='Val Loss')\n",
-    "plt.title('Regression Loss')\n",
-    "plt.xlabel('Epochs')\n",
-    "plt.ylabel('MSE Loss')\n",
-    "plt.legend()\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5253df17-9602-4e1e-adec-df37b95a87f0",
-   "metadata": {},
-   "source": [
-    "### __***MLP (FNN from scratch above code or learn this)***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "886ac28f-4952-4a26-bd2f-912cac7e8107",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\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\n",
-    "from sklearn.neural_network import MLPClassifier\n",
-    "\n",
-    "df = pd.read_csv('data/HeartDiseaseTrain-Test.csv')\n",
-    "display(df.head())\n",
-    "\n",
-    "X = df.drop('target', axis=1)\n",
-    "X = X.apply(LabelEncoder().fit_transform)\n",
-    "\n",
-    "X = X / X.max() #normalize features\n",
-    "y = df['target']\n",
-    "\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, \n",
-    "                                                    random_state=1)\n",
-    "\n",
-    "# Using 'relu' activation; others to try: 'identity', 'tanh', 'logistic'\n",
-    "activation = 'relu'\n",
-    "hidden_layers = (8, 8, 8)\n",
-    "\n",
-    "print(f\"\\nActivation: {activation}, Hidden Layers: {hidden_layers}\")\n",
-    "model = MLPClassifier(hidden_layer_sizes=hidden_layers, activation=activation,\n",
-    "                      solver='adam', max_iter=500, random_state=42)\n",
-    "model.fit(X_train, y_train)\n",
-    "\n",
-    "preds_train = model.predict(X_train)\n",
-    "print(\"\\nTrain Results:\")\n",
-    "print(classification_report(y_train, preds_train, zero_division=0))\n",
-    "ConfusionMatrixDisplay.from_predictions(y_train, preds_train)\n",
-    "plt.show()\n",
-    "\n",
-    "preds_test = model.predict(X_test)\n",
-    "print(\"\\nTest Results:\")\n",
-    "print(classification_report(y_test, preds_test, zero_division=0))\n",
-    "ConfusionMatrixDisplay.from_predictions(y_test, preds_test)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "625ac47b-8d21-4e64-9729-791067f4edca",
-   "metadata": {},
-   "source": [
-    "### __***CNN***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6e34cf42-1b2b-49a9-81c0-c66e380122b0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import warnings\n",
-    "warnings.filterwarnings('ignore')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9d1d0dc8-af7c-4052-8834-936143fb490c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import tensorflow as tf\n",
-    "from tensorflow.keras import layers, models\n",
-    "from keras.datasets import cifar10\n",
-    "from keras.utils import to_categorical\n",
-    "import matplotlib.pyplot as plt\n",
-    "from sklearn.metrics import roc_curve, auc, confusion_matrix\n",
-    "from sklearn.metrics import ConfusionMatrixDisplay\n",
-    "from sklearn.preprocessing import label_binarize\n",
-    "\n",
-    "(X_train, y_train), (X_test, y_test) = cifar10.load_data()\n",
-    "\n",
-    "X_train = X_train.astype('float32') / 255.0\n",
-    "X_test = X_test.astype('float32') / 255.0\n",
-    "\n",
-    "y_train = to_categorical(y_train, 10)\n",
-    "y_test = to_categorical(y_test, 10)\n",
-    "\n",
-    "model = models.Sequential([\n",
-    "    layers.Conv2D(32, kernel_size=(3, 3), activation=\"relu\", input_shape=(32, 32, 3)),\n",
-    "    layers.MaxPooling2D(),\n",
-    "    layers.Conv2D(64, kernel_size=(3, 3), activation=\"relu\"),\n",
-    "    layers.MaxPooling2D(),\n",
-    "    layers.Flatten(),\n",
-    "    layers.Dense(10, activation=\"softmax\")\n",
-    "])\n",
-    "\n",
-    "model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])\n",
-    "\n",
-    "history = model.fit(X_train, y_train, epochs=5, batch_size=32, validation_split=0.2)\n",
-    "\n",
-    "y_pred = model.predict(X_test)\n",
-    "y_pred_classes = tf.argmax(y_pred, axis=1)\n",
-    "y_test_classes = tf.argmax(y_test, axis=1)\n",
-    "\n",
-    "conf_matrix = confusion_matrix(y_test_classes, y_pred_classes)\n",
-    "ConfusionMatrixDisplay(conf_matrix).plot(cmap='Blues')\n",
-    "plt.title('Confusion Matrix')\n",
-    "plt.show()\n",
-    "\n",
-    "plt.figure(figsize=(12, 5))\n",
-    "\n",
-    "plt.subplot(1, 2, 1)\n",
-    "plt.plot(history.history['accuracy'], label='Training Accuracy')\n",
-    "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n",
-    "plt.title('Accuracy Curve')\n",
-    "plt.xlabel('Epochs')\n",
-    "plt.ylabel('Accuracy')\n",
-    "plt.legend()\n",
-    "\n",
-    "plt.subplot(1, 2, 2)\n",
-    "plt.plot(history.history['loss'], label='Training Loss')\n",
-    "plt.plot(history.history['val_loss'], label='Validation Loss')\n",
-    "plt.title('Loss Curve')\n",
-    "plt.xlabel('Epochs')\n",
-    "plt.ylabel('Loss')\n",
-    "plt.legend()\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "af7093fd-ea5c-4058-b4a3-3692a5e61eff",
-   "metadata": {},
-   "source": [
-    "### __***CNN Another Example***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "381a98d6-7828-43c8-b0a4-d1c24b229e66",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import tensorflow as tf\n",
-    "from tensorflow.keras import layers, models\n",
-    "from tensorflow.keras.preprocessing import image\n",
-    "import os\n",
-    "\n",
-    "dataset_path = 'Pistachio_Image_Dataset'\n",
-    "\n",
-    "img_height, img_width = 180, 180\n",
-    "batch_size = 32\n",
-    "\n",
-    "train_ds = tf.keras.utils.image_dataset_from_directory(\n",
-    "    dataset_path,\n",
-    "    validation_split=0.2,\n",
-    "    subset=\"training\",\n",
-    "    seed=123,\n",
-    "    image_size=(img_height, img_width),\n",
-    "    batch_size=batch_size)\n",
-    "\n",
-    "val_ds = tf.keras.utils.image_dataset_from_directory(\n",
-    "    dataset_path,\n",
-    "    validation_split=0.2,\n",
-    "    subset=\"validation\",\n",
-    "    seed=123,\n",
-    "    image_size=(img_height, img_width),\n",
-    "    batch_size=batch_size)\n",
-    "\n",
-    "model = models.Sequential([\n",
-    "    layers.Rescaling(1./255, input_shape=(img_height, img_width, 3)),\n",
-    "    layers.Conv2D(32, 3, activation='relu'),\n",
-    "    layers.MaxPooling2D(),\n",
-    "    layers.Conv2D(64, 3, activation='relu'),\n",
-    "    layers.MaxPooling2D(),\n",
-    "    layers.Conv2D(128, 3, activation='relu'),\n",
-    "    layers.MaxPooling2D(),\n",
-    "    layers.Flatten(),\n",
-    "    layers.Dense(128, activation='relu'),\n",
-    "    layers.Dense(2)\n",
-    "])\n",
-    "\n",
-    "model.compile(optimizer='adam',\n",
-    "              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
-    "              metrics=['accuracy'])\n",
-    "\n",
-    "epochs = 5\n",
-    "history = model.fit(\n",
-    "    train_ds,\n",
-    "    validation_data=val_ds,\n",
-    "    epochs=epochs\n",
-    ")\n",
-    "\n",
-    "class_names = ['Kirmizi_Pistachio', 'Siirt_Pistachio']\n",
-    "img_path = 'Pistachio_Image_Dataset/Siirt_Pistachio/siirt (11).jpg'\n",
-    "img = image.load_img(img_path, target_size=(180, 180))\n",
-    "\n",
-    "plt.imshow(img)\n",
-    "plt.title(\"Input Image\")\n",
-    "plt.axis(\"off\")\n",
-    "plt.show()\n",
-    "\n",
-    "img_array = image.img_to_array(img)\n",
-    "img_array = tf.expand_dims(img_array, 0)\n",
-    "\n",
-    "predictions = model.predict(img_array)\n",
-    "score = tf.nn.softmax(predictions[0])\n",
-    "\n",
-    "predicted_class = class_names[np.argmax(score)]\n",
-    "confidence = 100 * np.max(score)\n",
-    "\n",
-    "print(f\"Image most likely belongs to '{predicted_class}' with {confidence:.2f}% confidence.\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "770b6523-d178-45f6-b6a7-a04d780f5a9a",
-   "metadata": {},
-   "source": [
-    "### __***HMM - Viterbi***__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "eebdc5a0-8aef-41ff-ad89-d9424aa8a43f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import networkx as nx\n",
-    "import matplotlib.pyplot as plt\n",
-    "from hmmlearn.hmm import CategoricalHMM\n",
-    "\n",
-    "visibleStates = ['early', 'mid', 'late']\n",
-    "hiddenStates = ['Genuine User', 'Intruder']\n",
-    "hiddenInitial = [0.9, 0.1]\n",
-    "\n",
-    "hiddenTransition = np.array([\n",
-    "    [0.7, 0.3],\n",
-    "    [0.4, 0.6]\n",
-    "])\n",
-    "\n",
-    "emissionMatrix = np.array([\n",
-    "    [0.8, 0.1, 0.1],\n",
-    "    [0.1, 0.3, 0.6]\n",
-    "])\n",
-    "\n",
-    "graph = nx.DiGraph()\n",
-    "graph.add_nodes_from(visibleStates + hiddenStates)\n",
-    "\n",
-    "for i, x in enumerate(hiddenStates):\n",
-    "    for j, y in enumerate(hiddenStates):\n",
-    "        graph.add_edge(x, y, weight=hiddenTransition[i, j])\n",
-    "\n",
-    "for i, x in enumerate(hiddenStates):\n",
-    "    for j, y in enumerate(visibleStates):\n",
-    "        graph.add_edge(x, y, weight=emissionMatrix[i, j])\n",
-    "\n",
-    "pos = nx.circular_layout(graph)\n",
-    "nx.draw(graph, pos, with_labels=True, node_size=1500)\n",
-    "nx.draw_networkx_edge_labels(graph, pos, edge_labels=nx.get_edge_attributes(graph, 'weight'))\n",
-    "plt.show()\n",
-    "\n",
-    "observations = ['early', 'early', 'late', 'mid', 'early', 'late']\n",
-    "observationMap = {'early': 0, 'mid': 1, 'late': 2}\n",
-    "mappedSequence = np.array([observationMap[o] for o in observations]).reshape(-1, 1)\n",
-    "\n",
-    "model = CategoricalHMM(n_components=2)\n",
-    "model.startprob_ = hiddenInitial\n",
-    "model.transmat_ = hiddenTransition\n",
-    "model.emissionprob_ = emissionMatrix\n",
-    "\n",
-    "logValue, bestPath = model.decode(mappedSequence, algorithm=\"viterbi\")\n",
-    "\n",
-    "decodedPath = [hiddenStates[state] for state in bestPath]\n",
-    "\n",
-    "result = pd.DataFrame({\n",
-    "    'Observation': observations,\n",
-    "    'Predicted State': decodedPath\n",
-    "})\n",
-    "\n",
-    "print(\"\\nDecoded Path with Observations:\")\n",
-    "display(result)\n",
-    "\n",
-    "print(\"\\nLog Probability of Best Path:\", logValue)"
-   ]
-  }
- ],
- "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
-}