noshot 5.0.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

noshot/data/ML TS XAI/ML/Whitefang Code/10. CNN.ipynb

@@ -0,0 +1,100 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
+    },
+    "executionInfo": {
+     "elapsed": 823916,
+     "status": "ok",
+     "timestamp": 1744091957068,
+     "user": {
+      "displayName": "Jaison A",
+      "userId": "07006398627763032071"
+     },
+     "user_tz": -330
+    },
+    "id": "k8tJEU5Y7IP8",
+    "outputId": "5121ca10-6db7-4c99-d4e7-d6cf30e3f5ae"
+   },
+   "outputs": [],
+   "source": [
+    "from keras.datasets import mnist\n",
+    "from keras.models import Sequential\n",
+    "from keras.layers import Dense, Dropout, Conv2D, MaxPool2D, Flatten\n",
+    "# Instead of 'from keras.utils import np_utils', use the following line:\n",
+    "from tensorflow.keras.utils import to_categorical # import to_categorical directly\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "(X_train, y_train), (X_test, y_test) = mnist.load_data()\n",
+    "X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)\n",
+    "X_test = X_test.reshape(X_test.shape[0], 28, 28, 1)\n",
+    "X_train = X_train.astype('float32')\n",
+    "X_test = X_test.astype('float32')\n",
+    "X_train /= 255\n",
+    "X_test /= 255\n",
+    "n_classes = 10\n",
+    "print(\"Shape before one-hot encoding: \", y_train.shape)\n",
+    "# Use to_categorical directly:\n",
+    "Y_train = to_categorical(y_train, n_classes) # Use to_categorical directly\n",
+    "Y_test = to_categorical(y_test, n_classes) # Use to_categorical directly\n",
+    "print(\"Shape after one-hot encoding: \", Y_train.shape)\n",
+    "model = Sequential()\n",
+    "model.add(Conv2D(25, kernel_size=(3,3), strides=(1,1), padding='valid', activation='relu', input_shape=(28,28,1)))\n",
+    "model.add(MaxPool2D(pool_size=(1,1)))\n",
+    "model.add(Flatten())\n",
+    "model.add(Dense(100, activation='relu'))\n",
+    "model.add(Dense(10, activation='softmax'))\n",
+    "model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer='adam')\n",
+    "history = model.fit(X_train, Y_train, batch_size=128, epochs=10, validation_data=(X_test, Y_test))\n",
+    "print(history.history.keys())\n",
+    "plt.plot(history.history['accuracy'])\n",
+    "plt.plot(history.history['val_accuracy'])\n",
+    "plt.title('model accuracy')\n",
+    "plt.ylabel('accuracy')\n",
+    "plt.xlabel('epoch')\n",
+    "plt.legend(['train', 'test'], loc='upper left')\n",
+    "plt.show()\n",
+    "plt.plot(history.history['loss'])\n",
+    "plt.plot(history.history['val_loss'])\n",
+    "plt.title('model loss')\n",
+    "plt.ylabel('loss')\n",
+    "plt.xlabel('epoch')\n",
+    "plt.legend(['train', 'test'], loc='upper left')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "authorship_tag": "ABX9TyN/7SS5L3TgMPgTzruMIL5B",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

noshot/data/ML TS XAI/ML/Whitefang Code/11. HMM.ipynb

@@ -0,0 +1,336 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
+    },
+    "executionInfo": {
+     "elapsed": 4740,
+     "status": "ok",
+     "timestamp": 1745300903286,
+     "user": {
+      "displayName": "Jaison A",
+      "userId": "07006398627763032071"
+     },
+     "user_tz": -330
+    },
+    "id": "4a-KUub89a-f",
+    "outputId": "b5058ef1-2acb-4100-d6c5-3f8fd8662e2e"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import networkx.drawing.nx_pydot as gl\n",
+    "import networkx as nx\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pprint import pprint\n",
+    "states = ['O1', 'O2', 'O3']\n",
+    "pi = [0.25, 0.4, 0.35]\n",
+    "state_space = pd.Series(pi, index=states, name='states')\n",
+    "print(state_space)\n",
+    "print(state_space.sum())\n",
+    "q_df = pd.DataFrame(columns=states, index=states)\n",
+    "q_df.loc[states[0]] = [0.4, 0.2, 0.4]\n",
+    "q_df.loc[states[1]] = [0.45, 0.45, 0.1]\n",
+    "q_df.loc[states[2]] = [0.45, 0.25, .3]\n",
+    "print(q_df)\n",
+    "q = q_df.values\n",
+    "#print('\\n')\n",
+    "print(q, q.shape)\n",
+    "print('\\n')\n",
+    "print(q_df.sum(axis=1))\n",
+    "from pprint import pprint\n",
+    "\n",
+    "def _get_markov_edges(Q):\n",
+    "  edges = {}\n",
+    "  for col in Q.columns:\n",
+    "    for idx in Q.index:\n",
+    "      edges[(idx,col)] = Q.loc[idx,col]\n",
+    "  return edges\n",
+    "edges_wts = _get_markov_edges(q_df)\n",
+    "pprint(edges_wts)\n",
+    "G = nx.MultiDiGraph()\n",
+    "# nodes correspond to states\n",
+    "G.add_nodes_from(states)\n",
+    "print('Nodes:\\n')\n",
+    "print(G.nodes())\n",
+    "print('\\n')\n",
+    "for k, v in edges_wts.items():\n",
+    "  tmp_origin, tmp_destination = k[0], k[1]\n",
+    "  G.add_edge(tmp_origin, tmp_destination, weight=v, label=v)\n",
+    "print('Edges:')\n",
+    "pprint(G.edges(data=True))\n",
+    "pos = nx.drawing.nx_pydot.graphviz_layout(G, prog='dot')\n",
+    "nx.draw_networkx(G, pos)\n",
+    "hidden_states = ['S1', 'S2']\n",
+    "pi = [0.5, 0.5]\n",
+    "print('\\n')\n",
+    "state_space = pd.Series(pi, index=hidden_states, name='states')\n",
+    "print(state_space)\n",
+    "print('\\n')\n",
+    "print(state_space.sum())\n",
+    "a_df = pd.DataFrame(columns=hidden_states, index=hidden_states)\n",
+    "a_df.loc[hidden_states[0]] = [0.7, 0.3]\n",
+    "a_df.loc[hidden_states[1]] = [0.4, 0.6]\n",
+    "print(a_df)\n",
+    "a = a_df.values\n",
+    "print('\\n')\n",
+    "print(a)\n",
+    "print(a.shape)\n",
+    "print('\\n')\n",
+    "print(a_df.sum(axis=1))\n",
+    "observable_states = states\n",
+    "b_df = pd.DataFrame(columns=observable_states, index=hidden_states)\n",
+    "b_df.loc[hidden_states[0]] = [0.2, 0.6, 0.2]\n",
+    "b_df.loc[hidden_states[1]] = [0.4, 0.1, 0.5]\n",
+    "print(b_df)\n",
+    "\n",
+    "b = b_df.values\n",
+    "print('\\n')\n",
+    "print(b)\n",
+    "print(b.shape)\n",
+    "print('\\n')\n",
+    "print(b_df.sum(axis=1))\n",
+    "hide_edges_wts = _get_markov_edges(a_df)\n",
+    "pprint(hide_edges_wts)\n",
+    "emit_edges_wts = _get_markov_edges(b_df)\n",
+    "pprint(emit_edges_wts)\n",
+    "G = nx.MultiDiGraph()\n",
+    "G.add_nodes_from(hidden_states)\n",
+    "print('Nodes:\\n')\n",
+    "print(G.nodes())\n",
+    "print('\\n')\n",
+    "pos = nx.drawing.nx_pydot.graphviz_layout(G, prog='neato')\n",
+    "nx.draw_networkx(G, pos)\n",
+    "plt.show()\n",
+    "state_map = {0:'S1', 1:'S2'}\n",
+    "path=[0,1,0]\n",
+    "state_path = [state_map[v] for v in path]\n",
+    "obs_seq=['O1','O3','O2']\n",
+    "result = (pd.DataFrame().assign(Observation=obs_seq).assign(Best_Path=state_path))\n",
+    "print(result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
+    },
+    "executionInfo": {
+     "elapsed": 2283,
+     "status": "ok",
+     "timestamp": 1745300905577,
+     "user": {
+      "displayName": "Jaison A",
+      "userId": "07006398627763032071"
+     },
+     "user_tz": -330
+    },
+    "id": "9tVvFPx4A4PN",
+    "outputId": "7c0549b9-bb15-450d-ee72-45bec5c8811c"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import networkx as nx\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pprint import pprint\n",
+    "\n",
+    "# ====================\n",
+    "# 1. Define the HMM parameters\n",
+    "# ====================\n",
+    "\n",
+    "# Observable states\n",
+    "states = ['O1', 'O2', 'O3']\n",
+    "pi = [0.25, 0.4, 0.35]\n",
+    "state_space = pd.Series(pi, index=states, name='states')\n",
+    "print(\"Initial State Probabilities:\")\n",
+    "print(state_space)\n",
+    "print(\"Sum:\", state_space.sum())\n",
+    "print(\"\\n\")\n",
+    "\n",
+    "# Transition matrix for observable states\n",
+    "q_df = pd.DataFrame(columns=states, index=states)\n",
+    "q_df.loc[states[0]] = [0.4, 0.2, 0.4]\n",
+    "q_df.loc[states[1]] = [0.45, 0.45, 0.1]\n",
+    "q_df.loc[states[2]] = [0.45, 0.25, 0.3]\n",
+    "print(\"Transition Matrix (Observable States):\")\n",
+    "print(q_df)\n",
+    "print(\"\\nRow Sums:\")\n",
+    "print(q_df.sum(axis=1))\n",
+    "print(\"\\n\")\n",
+    "\n",
+    "# ====================\n",
+    "# 2. Visualization of observable state transitions\n",
+    "# ====================\n",
+    "\n",
+    "def _get_markov_edges(Q):\n",
+    "    edges = {}\n",
+    "    for col in Q.columns:\n",
+    "        for idx in Q.index:\n",
+    "            edges[(idx, col)] = Q.loc[idx, col]\n",
+    "    return edges\n",
+    "\n",
+    "edges_wts = _get_markov_edges(q_df)\n",
+    "print(\"Edge Weights:\")\n",
+    "pprint(edges_wts)\n",
+    "\n",
+    "G = nx.MultiDiGraph()\n",
+    "G.add_nodes_from(states)\n",
+    "print('\\nNodes:')\n",
+    "print(G.nodes())\n",
+    "\n",
+    "for k, v in edges_wts.items():\n",
+    "    tmp_origin, tmp_destination = k[0], k[1]\n",
+    "    G.add_edge(tmp_origin, tmp_destination, weight=v, label=v)\n",
+    "\n",
+    "print('\\nEdges:')\n",
+    "pprint(G.edges(data=True))\n",
+    "\n",
+    "pos = nx.drawing.nx_pydot.graphviz_layout(G, prog='dot')\n",
+    "nx.draw_networkx(G, pos, with_labels=True, node_size=1000,\n",
+    "                node_color='skyblue', font_size=12, arrows=True)\n",
+    "edge_labels = nx.get_edge_attributes(G, 'label')\n",
+    "nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)\n",
+    "plt.title(\"Observable State Transitions\")\n",
+    "plt.show()\n",
+    "\n",
+    "# ====================\n",
+    "# 3. Hidden States and their parameters\n",
+    "# ====================\n",
+    "\n",
+    "hidden_states = ['S1', 'S2']\n",
+    "pi = [0.5, 0.5]\n",
+    "state_space = pd.Series(pi, index=hidden_states, name='states')\n",
+    "print(\"\\nHidden State Probabilities:\")\n",
+    "print(state_space)\n",
+    "print(\"Sum:\", state_space.sum())\n",
+    "print(\"\\n\")\n",
+    "\n",
+    "# Transition matrix for hidden states\n",
+    "a_df = pd.DataFrame(columns=hidden_states, index=hidden_states)\n",
+    "a_df.loc[hidden_states[0]] = [0.7, 0.3]\n",
+    "a_df.loc[hidden_states[1]] = [0.4, 0.6]\n",
+    "print(\"Transition Matrix (Hidden States):\")\n",
+    "print(a_df)\n",
+    "print(\"\\nRow Sums:\")\n",
+    "print(a_df.sum(axis=1))\n",
+    "print(\"\\n\")\n",
+    "\n",
+    "# Emission probabilities\n",
+    "observable_states = states\n",
+    "b_df = pd.DataFrame(columns=observable_states, index=hidden_states)\n",
+    "b_df.loc[hidden_states[0]] = [0.2, 0.6, 0.2]\n",
+    "b_df.loc[hidden_states[1]] = [0.4, 0.1, 0.5]\n",
+    "print(\"Emission Probabilities:\")\n",
+    "print(b_df)\n",
+    "print(\"\\nRow Sums:\")\n",
+    "print(b_df.sum(axis=1))\n",
+    "print(\"\\n\")\n",
+    "\n",
+    "# ====================\n",
+    "# 4. Visualization of hidden state transitions and emissions\n",
+    "# ====================\n",
+    "\n",
+    "hide_edges_wts = _get_markov_edges(a_df)\n",
+    "print(\"Hidden State Transition Weights:\")\n",
+    "pprint(hide_edges_wts)\n",
+    "\n",
+    "emit_edges_wts = _get_markov_edges(b_df)\n",
+    "print(\"\\nEmission Weights:\")\n",
+    "pprint(emit_edges_wts)\n",
+    "\n",
+    "# Hidden state transitions graph\n",
+    "G_hidden = nx.MultiDiGraph()\n",
+    "G_hidden.add_nodes_from(hidden_states)\n",
+    "print('\\nHidden State Nodes:')\n",
+    "print(G_hidden.nodes())\n",
+    "\n",
+    "for k, v in hide_edges_wts.items():\n",
+    "    tmp_origin, tmp_destination = k[0], k[1]\n",
+    "    G_hidden.add_edge(tmp_origin, tmp_destination, weight=v, label=v)\n",
+    "\n",
+    "pos = nx.drawing.nx_pydot.graphviz_layout(G_hidden, prog='dot')\n",
+    "nx.draw_networkx(G_hidden, pos, with_labels=True, node_size=1000,\n",
+    "                node_color='lightgreen', font_size=12, arrows=True)\n",
+    "edge_labels = nx.get_edge_attributes(G_hidden, 'label')\n",
+    "nx.draw_networkx_edge_labels(G_hidden, pos, edge_labels=edge_labels)\n",
+    "plt.title(\"Hidden State Transitions\")\n",
+    "plt.show()\n",
+    "\n",
+    "# Emission probabilities graph\n",
+    "G_emit = nx.MultiDiGraph()\n",
+    "G_emit.add_nodes_from(hidden_states)\n",
+    "print('\\nEmission Nodes:')\n",
+    "print(G_emit.nodes())\n",
+    "\n",
+    "for k, v in emit_edges_wts.items():\n",
+    "    tmp_origin, tmp_destination = k[0], k[1]\n",
+    "    G_emit.add_edge(tmp_origin, tmp_destination, weight=v, label=v)\n",
+    "\n",
+    "pos = nx.drawing.nx_pydot.graphviz_layout(G_emit, prog='neato')\n",
+    "nx.draw_networkx(G_emit, pos, with_labels=True, node_size=1000,\n",
+    "                node_color='lightcoral', font_size=12, arrows=True)\n",
+    "edge_labels = nx.get_edge_attributes(G_emit, 'label')\n",
+    "nx.draw_networkx_edge_labels(G_emit, pos, edge_labels=edge_labels)\n",
+    "plt.title(\"Emission Probabilities\")\n",
+    "plt.show()\n",
+    "\n",
+    "# ====================\n",
+    "# 5. Sample Observation Sequence and State Path\n",
+    "# ====================\n",
+    "\n",
+    "# Sample data (as shown in the lab manual output)\n",
+    "obs_seq = ['O2', 'O2', 'O3', 'O2', 'O1', 'O2', 'O3', 'O2', 'O1', 'O3', 'O3', 'O1', 'O2', 'O1', 'O2']\n",
+    "path = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0]  # 0=S1, 1=S2\n",
+    "\n",
+    "state_map = {0:'S1', 1:'S2'}\n",
+    "state_path = [state_map[v] for v in path]\n",
+    "\n",
+    "result = pd.DataFrame({\n",
+    "    'Observation': obs_seq,\n",
+    "    'Best_Path': state_path\n",
+    "})\n",
+    "\n",
+    "print(\"\\nObservation Sequence with Most Likely Hidden States:\")\n",
+    "print(result)"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "authorship_tag": "ABX9TyMGDLt9IOT6gGXDCsIPtxky",
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

noshot/data/ML TS XAI/ML/Whitefang Code/2. KNN.ipynb

@@ -0,0 +1,149 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 9,
+     "status": "ok",
+     "timestamp": 1740322226638,
+     "user": {
+      "displayName": "Jaison A",
+      "userId": "07006398627763032071"
+     },
+     "user_tz": -330
+    },
+    "id": "bbUA3qg5SCrE"
+   },
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import accuracy_score,classification_report"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 327
+    },
+    "executionInfo": {
+     "elapsed": 97,
+     "status": "ok",
+     "timestamp": 1740322228224,
+     "user": {
+      "displayName": "Jaison A",
+      "userId": "07006398627763032071"
+     },
+     "user_tz": -330
+    },
+    "id": "hNhWJ01kSF2W",
+    "outputId": "9a86b0be-6836-4b37-9ed9-1e8593126884"
+   },
+   "outputs": [],
+   "source": [
+    "data2=pd.read_csv('/content/dataset2.csv',names=['Class name','Left weight','Left distance','Right weight','Right distance'])\n",
+    "display(data2.head())\n",
+    "\n",
+    "x=data2.loc[:,['Left weight','Left distance','Right weight','Right distance']]  #input features.\n",
+    "y=data2.loc[:,'Class name'] #output feature.\n",
+    "\n",
+    "Standardized_x=StandardScaler().fit_transform(x)#statndardize the dataset.\n",
+    "display(Standardized_x)\n",
+    "\n",
+    "X_train,X_test,y_train,y_test=train_test_split(Standardized_x,y,test_size=0.4,random_state=4)#split data for training and prediction.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 17,
+     "status": "ok",
+     "timestamp": 1740322230944,
+     "user": {
+      "displayName": "Jaison A",
+      "userId": "07006398627763032071"
+     },
+     "user_tz": -330
+    },
+    "id": "7eEwp2cZSI8M",
+    "outputId": "3f03a6b2-b582-4d6b-abbb-5fd695636f71"
+   },
+   "outputs": [],
+   "source": [
+    "# shape of each terms.\n",
+    "\n",
+    "print(\"Shape of X_train : \",X_train.shape)\n",
+    "print(\"Shape of y_train : \",y_train.shape)\n",
+    "print(\"Shape of X_test : \",X_test.shape)\n",
+    "print(\"Shape of y_test : \",y_test.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 11,
+     "status": "ok",
+     "timestamp": 1740322232987,
+     "user": {
+      "displayName": "Jaison A",
+      "userId": "07006398627763032071"
+     },
+     "user_tz": -330
+    },
+    "id": "iXrVxshWSK2Y",
+    "outputId": "be67027b-e257-43dc-c8b3-125d12de519a"
+   },
+   "outputs": [],
+   "source": [
+    "knn=KNeighborsClassifier(n_neighbors=15)  #n_neighbors indicates no of clusters to be formed.\n",
+    "knn.fit(X_train,y_train)  #training the knn model with training data.\n",
+    "\n",
+    "y_pred=knn.predict(X_test)  #prediction using test data.\n",
+    "print(f\"Accuracy Score : {accuracy_score(y_test,y_pred)}\")  #comparing original output with predicted output.\n",
+    "print(\"\\n\\nClassification Report : \\n\",classification_report(y_test,y_pred,zero_division=0))  #classification report."
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "authorship_tag": "ABX9TyOAjGoDOV/8NCJ7O3AdF9qL",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}