noshot 2.0.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

noshot/data/ML TS XAI/ML/Main/10. HMM Veterbi.ipynb

@@ -0,0 +1,228 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "GrBOlID9_Jiz",
+    "outputId": "f547fe18-4b89-4b41-928d-4fcc75fe5916"
+   },
+   "outputs": [],
+   "source": [
+    "transition = {\"AtoA\":0.7,\"AtoB\":0.3,\"BtoA\":0.5,\"BtoB\":0.5}\n",
+    "emission = {\"A\":{\"S1\":0.6,\"S2\":0.1,\"S3\":0.3},\"B\":{\"S1\":0.1,\"S2\":0.7,\"S3\":0.2}}\n",
+    "pi=(1,0)\n",
+    "\n",
+    "a,b=pi\n",
+    "alpha1=[a]\n",
+    "alpha2=[b]\n",
+    "for i in [\"S3\",\"S2\",\"S1\"]:\n",
+    "    temp1=[]\n",
+    "    temp2=[]\n",
+    "    for j in [\"AtoA\",\"AtoB\",\"BtoA\",\"BtoB\"]:\n",
+    "        if j.endswith(\"A\"):\n",
+    "            if j.startswith(\"A\"): temp1.append(a*transition[j]*emission[\"A\"][i])\n",
+    "            else: temp1.append(b*transition[j]*emission[\"B\"][i])\n",
+    "        else:\n",
+    "            if j.startswith(\"A\"): temp2.append(a*transition[j]*emission[\"A\"][i])\n",
+    "            else: temp2.append(b*transition[j]*emission[\"B\"][i])\n",
+    "    a=sum(temp1)\n",
+    "    b=sum(temp2)\n",
+    "    alpha1.append(a)\n",
+    "    alpha2.append(b)\n",
+    "    temp1.clear()\n",
+    "    temp2.clear()\n",
+    "    if i==\"S1\": print(\"Using Forward Chaining:\",round(a+b,4))\n",
+    "print(alpha1,\"\\n\",alpha2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "Ywqsib8v_zM7",
+    "outputId": "0b4359a0-276d-4d41-beb7-a0e5c9d8fe41"
+   },
+   "outputs": [],
+   "source": [
+    "transition={\"AtoA\":0.7,\"AtoB\":0.3,\"BtoA\":0.5,\"BtoB\":0.5}\n",
+    "emission={\"A\":{\"S1\":0.6,\"S2\":0.1,\"S3\":0.3},\"B\":{\"S1\":0.1,\"S2\":0.7,\"S3\":0.2}}\n",
+    "pi=(1,1)\n",
+    "\n",
+    "beta1=[]\n",
+    "beta2=[]\n",
+    "a,b=pi\n",
+    "for i in reversed([\"S3\",\"S2\",\"S1\"]):\n",
+    "    temp1=[]\n",
+    "    temp2=[]\n",
+    "    for j in [\"AtoA\",\"AtoB\",\"BtoA\",\"BtoB\"]:\n",
+    "        if j.startswith(\"A\"):\n",
+    "            if j.endswith(\"A\"): temp1.append(a*transition[j]*emission[\"A\"][i])\n",
+    "            else: temp1.append(b*transition[j]*emission[\"A\"][i])\n",
+    "        else:\n",
+    "            if j.endswith(\"A\"): temp2.append(a*transition[j]*emission[\"B\"][i])\n",
+    "            else: temp2.append(b*transition[j]*emission[\"B\"][i])\n",
+    "    a=sum(temp1)\n",
+    "    b=sum(temp2)\n",
+    "    beta1.append(a)\n",
+    "    beta2.append(b)\n",
+    "    temp1.clear()\n",
+    "    temp2.clear()\n",
+    "    if i==\"S3\": print(\"Using Backward Chaining:\",round(a,4))\n",
+    "print(beta1,\"\\n\",beta2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "waKP0k73_1yn",
+    "outputId": "1427045a-2118-4a11-938c-f5e54e63fe80"
+   },
+   "outputs": [],
+   "source": [
+    "transition={\"AtoA\":0.7,\"AtoB\":0.3,\"BtoA\":0.5,\"BtoB\":0.5}\n",
+    "emission={\"A\":{\"S1\":0.6,\"S2\":0.1,\"S3\":0.3},\"B\":{\"S1\":0.1,\"S2\":0.7,\"S3\":0.2}}\n",
+    "pi=(1,0)\n",
+    "\n",
+    "a,b=pi\n",
+    "delta1=[a]\n",
+    "delta2=[b]\n",
+    "chi=[]\n",
+    "for i in [\"S3\",\"S2\",\"S1\"]:\n",
+    "    temp1=[]\n",
+    "    temp2=[]\n",
+    "    temp3={}\n",
+    "    for j in [\"AtoA\",\"AtoB\",\"BtoA\",\"BtoB\"]:\n",
+    "        if j.endswith(\"A\"):\n",
+    "            if j.startswith(\"A\"): temp1.append(a*transition[j]*emission[\"A\"][i])\n",
+    "            else: temp1.append(b*transition[j]*emission[\"B\"][i])\n",
+    "        else:\n",
+    "            if j.startswith(\"A\"): temp2.append(a*transition[j]*emission[\"A\"][i])\n",
+    "            else: temp2.append(b*transition[j]*emission[\"B\"][i])\n",
+    "    a=max(temp1)\n",
+    "    b=max(temp2)\n",
+    "    temp3[a]=\"A\"\n",
+    "    temp3[b]=\"B\"\n",
+    "    delta1.append(a)\n",
+    "    delta2.append(b)\n",
+    "    chi.append(temp3[max(temp3.keys())])\n",
+    "    temp1.clear()\n",
+    "    temp2.clear()\n",
+    "    if i==\"S1\":\n",
+    "        print(\"Using Veterbi Algorithm:\",round(max(a,b),4))\n",
+    "        print(\"Best Sequence:\")\n",
+    "        for i in chi: print(i,end=\"->\")\n",
+    "        print(temp3[max(temp3.keys())])\n",
+    "print(delta1)\n",
+    "print(delta2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 36
+    },
+    "id": "pU0-CxGx_4Gz",
+    "outputId": "97bbaadc-83d8-4b86-89e7-f67e347adfb0"
+   },
+   "outputs": [],
+   "source": [
+    "from graphviz import Digraph\n",
+    "\n",
+    "states = ['A', 'B']\n",
+    "observations = ['S1', 'S2', 'S3']\n",
+    "\n",
+    "dot = Digraph(comment='HMM')\n",
+    "\n",
+    "for state in states:\n",
+    "    dot.node(state, state)\n",
+    "\n",
+    "for from_state in states:\n",
+    "    for to_state in states:\n",
+    "        transition_prob = transition[from_state + 'to' + to_state]\n",
+    "        dot.edge(from_state, to_state, label=str(transition_prob))\n",
+    "\n",
+    "for state in states:\n",
+    "    for observation in observations:\n",
+    "        emission_prob = emission[state][observation]\n",
+    "        dot.edge(state, observation, label=str(emission_prob), style='dashed')\n",
+    "\n",
+    "dot.render('hmm', view=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 513
+    },
+    "id": "qBU_NokB_679",
+    "outputId": "d3b086cb-92d6-4941-de26-137888b1a2d1"
+   },
+   "outputs": [],
+   "source": [
+    "import networkx as nx\n",
+    "import matplotlib.pyplot as plt\n",
+    "graph = nx.DiGraph()\n",
+    "\n",
+    "graph.add_nodes_from(states)\n",
+    "for from_state in states:\n",
+    "    for to_state in states:\n",
+    "        transition_prob = transition[from_state + 'to' + to_state]\n",
+    "        graph.add_edge(from_state, to_state, weight=transition_prob, label=str(transition_prob))\n",
+    "\n",
+    "for state in states:\n",
+    "    for observation in observations:\n",
+    "        emission_prob = emission[state][observation]\n",
+    "        graph.add_edge(state, observation, weight=emission_prob, label=str(emission_prob), style='dashed')\n",
+    "pos = nx.spring_layout(graph)\n",
+    "edge_labels = nx.get_edge_attributes(graph, 'label')\n",
+    "\n",
+    "nx.draw(graph, pos, with_labels=True, node_size=1500, node_color=\"skyblue\", font_size=12, font_weight='bold')\n",
+    "nx.draw_networkx_edge_labels(graph, pos, edge_labels=edge_labels, font_size=10)\n",
+    "\n",
+    "plt.title(\"Hidden Markov Model\")\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "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/Main/2. KNN (Balance Scale Dataset).ipynb

@@ -0,0 +1,117 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b4a8b5dc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import sklearn\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn import metrics\n",
+    "from sklearn.preprocessing import StandardScaler"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1c308767",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cols = ['class name','left-weight','left-distance','right-weight','right-distance']\n",
+    "df = pd.read_csv('data/balance-scale.txt', delimiter=',', names=cols)\n",
+    "print(\"Shape:\", df.shape)\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c5dc6788-f131-4b3e-8b39-0f83c117e2cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "features = ['left-weight', 'left-distance', 'right-weight', 'right-distance']\n",
+    "x = df.loc[:, features]\n",
+    "y = df.loc[:, 'class name']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "59450a6f-db40-4b8c-b294-d427f0792c26",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = StandardScaler().fit_transform(x)\n",
+    "X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.4, \n",
+    "                                                    random_state=4)\n",
+    "print (X_train.shape)\n",
+    "print (X_test.shape)\n",
+    "knn = KNeighborsClassifier(n_neighbors=15)\n",
+    "knn.fit(X_train, y_train)                  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22e96c2a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred = knn.predict(np.array([1,1,1,1]).reshape(1, -1))[0]\n",
+    "print(\"Class Predicted [1,1,1,1]:\", y_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "366c003d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred = knn.predict(X_test)\n",
+    "print(\"Accuracy:\", metrics.accuracy_score(y_test, y_pred))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "517c6e56-afc6-481c-a48c-b1a0435537bd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cm = metrics.confusion_matrix(y_test, knn.predict(X_test))\n",
+    "metrics.ConfusionMatrixDisplay(cm, display_labels=['B','L','R']).plot()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "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": 5
+}

noshot/data/ML TS XAI/ML/Main/2. KNN (Iris Dataset).ipynb

@@ -0,0 +1,165 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f8872206-2c4c-4b9c-a146-4874bed47d58",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import sklearn\n",
+    "from sklearn import svm\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn import metrics\n",
+    "from sklearn.preprocessing import StandardScaler"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6784e6b1-ab93-4529-85a0-8be414f00283",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv('data/iris.csv')\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7d9be320-b960-49d2-bf0b-d6193332b1f8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class_mapper = {0: \"setosa\", 1: \"versicolor\", 2: \"virginica\"}\n",
+    "df['target']  = df['class'].map(class_mapper)\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d523f9bd-14d5-42f6-80cc-fe8a8210fa1f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "feature = ['sepal length (cm)','sepal width (cm)','petal length (cm)','petal width (cm)']\n",
+    "x = df.loc[:, feature]\n",
+    "y = df.loc[:, 'target']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f852a9d8-bb7a-49d3-a199-e47738c05a04",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = StandardScaler().fit_transform(x)\n",
+    "X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.4,\n",
+    "                                                    random_state=4)\n",
+    "print (X_train.shape)\n",
+    "print (X_test.shape)\n",
+    "knn = KNeighborsClassifier(n_neighbors=15)\n",
+    "knn.fit(X_train, y_train)                  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e57d7cdd-29b8-4235-aea7-9f904a70e9fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred = knn.predict(np.array([5.2, 3.5, 1.1, 0.2]).reshape(1, -1))[0]\n",
+    "print(\"Class Predicted [5.2, 3.5, 1.1, 0.2]:\", y_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b48aeb20-c569-4d0f-900c-82cd9ad92098",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred = knn.predict(X_test)\n",
+    "print(\"Accuracy:\", metrics.accuracy_score(y_test, y_pred))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f72df1f8-5075-4d23-b93f-18a91e8fd1e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cm = metrics.confusion_matrix(y_test, knn.predict(X_test))\n",
+    "metrics.ConfusionMatrixDisplay(cm, display_labels=['setosa','versicolor','virginica']).plot()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4c1df2d9-4e4b-43a1-aaec-d7eee15b716b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = df.iloc[:, :2].values\n",
+    "y = df['class'].values\n",
+    "\n",
+    "def make_meshgrid(x, y, h=.02):\n",
+    "    x_min, x_max = x.min() - 1, x.max() + 1\n",
+    "    y_min, y_max = y.min() - 1, y.max() + 1\n",
+    "    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n",
+    "    return xx, yy\n",
+    "\n",
+    "def plot_contours(ax, clf, xx, yy, **params):\n",
+    "    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n",
+    "    Z = Z.reshape(xx.shape)\n",
+    "    out = ax.contourf(xx, yy, Z, **params)\n",
+    "    return out\n",
+    "\n",
+    "model = svm.SVC(kernel='linear')\n",
+    "clf = model.fit(X, y)\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "title = ('Decision surface of linear SVC ')\n",
+    "\n",
+    "X0, X1 = X[:, 0], X[:, 1]\n",
+    "xx, yy = make_meshgrid(X0, X1)\n",
+    "\n",
+    "plot_contours(ax, clf, xx, yy, cmap=plt.cm.coolwarm, alpha=0.8)\n",
+    "ax.scatter(X0, X1, c=y, cmap=plt.cm.coolwarm, s=20, edgecolors='k')\n",
+    "ax.set_title(title)\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "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": 5
+}