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

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

@@ -0,0 +1,961 @@
+{
+ "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
+}

{noshot-9.0.0.dist-info → noshot-11.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noshot
-Version: 9.0.0
+Version: 11.0.0
 Summary: Support library for Artificial Intelligence, Machine Learning and Data Science tools
 Author: Tim Stan S
 License: MIT

{noshot-9.0.0.dist-info → noshot-11.0.0.dist-info}/RECORD

@@ -2,6 +2,7 @@ noshot/__init__.py,sha256=000R40tii8lDFU8C1fBaD3SOnxD0PWRNWZU-km49YrU,21
 noshot/main.py,sha256=zXegIqjJPARlPnQMS-B2dAENcvyaZkNwmue63Gm8lHU,663
 noshot/data/ML TS XAI/ML/CNN(Image_for_Folders_5).ipynb,sha256=VAk1gwoDTBMSdXJxiOLJRvWnzJs84kdNr8Tn_1LaGZw,8802
 noshot/data/ML TS XAI/ML/CNN(Image_form_Folder_2).ipynb,sha256=o3Ho3f1CcYhzNW5yB8PEt5WuxFvgc04_bT73wMmpx14,8772
+noshot/data/ML TS XAI/ML/ML Lab AllinOne.ipynb,sha256=4E6ddpzBISsp-3aEm_mzMPKW1gSHBrMdhatEUiL59wQ,34015
 noshot/data/ML TS XAI/ML/Rolls Royce AllinOne.ipynb,sha256=dQ3HgLix6HLqPltFiPrElmEdYAsvR6flDpHEIjcngp4,24774
 noshot/data/ML TS XAI/ML/Json Codes/ML LAB CIA 2.ipynb,sha256=mJFkK3jsrr1I967c3Ovm8jpMnO1wjAfb--pNeYnWZ7I,14767
 noshot/data/ML TS XAI/ML/ML 1/1. EDA-PCA (Balance Scale Dataset).ipynb,sha256=1QYmUb1QZ4FtmdwoWhTbF9divKNMOxS8AMOy56At0xg,3625
@@ -64,8 +65,8 @@ noshot/data/ML TS XAI/ML/ML Lab H Sec/student-mat.csv,sha256=dnzX-s54dAWJJsKLcXC
 noshot/data/ML TS XAI/ML/ML Lab H Sec/student-por.csv,sha256=6nnPKJRApzZilddcT1eTL_i0dSqvIvgmhM4pi3R83bs,117234
 noshot/utils/__init__.py,sha256=QVrN1ZpzPXxZqDOqot5-t_ulFjZXVx7Cvr-Is9AK0po,110
 noshot/utils/shell_utils.py,sha256=-XfgYlNQlULa_rRJ3vsfTns4m_jiueGEj396J_y0Gus,2611
-noshot-9.0.0.dist-info/licenses/LICENSE.txt,sha256=fgCruaVm5cUjFGOeEoGIimT6nnUunBqcNZHpGzK8TSw,1086
-noshot-9.0.0.dist-info/METADATA,sha256=q0WpAfRb9MV9hadVVEMIjXigVzYVZh_D3DJv3J_bYls,2573
-noshot-9.0.0.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-noshot-9.0.0.dist-info/top_level.txt,sha256=UL-c0HffdRwohz-y9icY_rnY48pQDdxGcBsgyCKh2Q8,7
-noshot-9.0.0.dist-info/RECORD,,
+noshot-11.0.0.dist-info/licenses/LICENSE.txt,sha256=fgCruaVm5cUjFGOeEoGIimT6nnUunBqcNZHpGzK8TSw,1086
+noshot-11.0.0.dist-info/METADATA,sha256=XK3d0s_DAtwG-YPjhwU2UiaSnoLvmVbhovIR1ilNZU0,2574
+noshot-11.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+noshot-11.0.0.dist-info/top_level.txt,sha256=UL-c0HffdRwohz-y9icY_rnY48pQDdxGcBsgyCKh2Q8,7
+noshot-11.0.0.dist-info/RECORD,,

{noshot-9.0.0.dist-info → noshot-11.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any