noshot 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

noshot/data/ML TS XAI/AIDS/3. Genetic Algorithm/Genetic.ipynb

@@ -1,95 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b5d46296-1714-4d28-b99b-02403662e645",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from random import randint as rint\n",
-    "n = 8\n",
-    "def show(b):\n",
-    "    board = [['_'] * n for _ in range(n)]\n",
-    "    for i in range(n):\n",
-    "        board[int(b[i])-1][i] = 'Q'\n",
-    "    print(f\" {' '.join(['_']*n)}\")\n",
-    "    for i in board:\n",
-    "        print(f\"|{'|'.join(i)}|\")\n",
-    "def mutate(b1, b2):\n",
-    "    b1, b2 = list(b1), list(b2)\n",
-    "    x, y = rint(0,n-1), rint(0,n-1)\n",
-    "    b1[x], b2[x] = b2[x], b1[x]\n",
-    "    b1[y] = str(int(y) + 1)\n",
-    "    return (''.join(b1),''.join(b2))\n",
-    "def crossover(b1, b2):\n",
-    "    b1, b2 = list(b1), list(b2)\n",
-    "    x = rint(1,n-1)\n",
-    "    b1[0:x], b2[0:x] = b2[0:x], b1[0:x]\n",
-    "    return (''.join(b1), ''.join(b2))\n",
-    "def fitness(b):\n",
-    "    b = list(b)\n",
-    "    attacks = 0\n",
-    "    for i in range(n):\n",
-    "        for j in range(i+1, n):\n",
-    "            if b[i] == b[j] or abs(int(b[i]) - int(b[j])) == j - i:\n",
-    "                attacks += 1\n",
-    "    return attacks\n",
-    "def genetic(gen, pop):\n",
-    "    global n \n",
-    "    n = len(pop[0])\n",
-    "    pq = pop\n",
-    "    for i in range(1,gen+1):\n",
-    "        pq.sort(key = lambda x : fitness(x))\n",
-    "        b1 = pq.pop(0)\n",
-    "        b2 = pq.pop(0)\n",
-    "        pq.clear()\n",
-    "        if fitness(b1) == 0:\n",
-    "            print(\"Goal State:\",b1,\"Generation:\",i)\n",
-    "            show(b1)\n",
-    "            return\n",
-    "        x1, x2 = crossover(b1, b2)\n",
-    "        x3, x4 = crossover(b2, b1)\n",
-    "        pq = [x1, x2, x3, x4, *mutate(x1, x2), *mutate(x2, x1), b1, b2]\n",
-    "    print(\"Most Evolved State:\",pq[0],\"Generation:\",i,\"Attacks:\",fitness(pq[0]))\n",
-    "    show(pq[0])\n",
-    "\n",
-    "def main():\n",
-    "    #no of queens is inferred in genetic()\n",
-    "    print(\"Genetic Algorithm Example 1(5 Queen): \")\n",
-    "    genetic(1000, [\"32152\",\"24345\"])\n",
-    "    print()\n",
-    "    print(\"Genetic Algorithm Example 2(8 Queen): \")\n",
-    "    genetic(1000, [\"57142860\",\"56782463\"])\n",
-    "\n",
-    "    #Sample output\n",
-    "    #Genetic Algorithm Example 1(5 Queen): \n",
-    "    #Most Evolved State: 14352 Generation: 1000 Attacks: 2\n",
-    "    #Genetic Algorithm Example 2(8 Queen): \n",
-    "    #Goal State: 57142863 Generation: 1\n",
-    "main()"
-   ]
-  }
- ],
- "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/AIDS/4. Simulated Annealing/Simulated Annealing.ipynb

@@ -1,74 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1fbe1abb-5a71-4dce-99dc-efbab49656dd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import math\n",
-    "import random\n",
-    "def simulated_annealing(initsol, inittemp, alpha, iters):\n",
-    "    currsol = initsol\n",
-    "    cost = fcost(currsol)\n",
-    "    sol = currsol\n",
-    "    mincost = cost\n",
-    "    temp = inittemp\n",
-    "    for iteration in range(iters):\n",
-    "        neighbor = successors(currsol)\n",
-    "        ncost = fcost(neighbor)\n",
-    "        costdiff = ncost - cost\n",
-    "        if costdiff < 0 or random.random() < math.exp(-costdiff/temp):\n",
-    "            currsol = neighbor\n",
-    "            cost = ncost\n",
-    "            if cost < mincost:\n",
-    "                sol = currsol\n",
-    "                mincost = cost\n",
-    "        temp *= alpha\n",
-    "    return sol, mincost\n",
-    "def fcost(sol):\n",
-    "    return sum([i**2 for i in sol])\n",
-    "def successors(sol, step = 1.0):\n",
-    "    succ = [x + random.uniform(-step,step) for x in sol]\n",
-    "    return succ\n",
-    "\n",
-    "def main():\n",
-    "    initsol = [300.0, 400.0]\n",
-    "    inittemp = 1000.0\n",
-    "    alpha = 0.95\n",
-    "    iters = 500\n",
-    "    \n",
-    "    bestsol, cost = simulated_annealing(initsol, inittemp, alpha, iters)\n",
-    "    print(\"Best Solution:\",bestsol)\n",
-    "    print(\"Best Cost:\",cost)\n",
-    "\n",
-    "    #Sample input/output (can change due to the use of random)\n",
-    "    #Best Solution: [225.56303970871514, 294.69364950481685]\n",
-    "    #Best Cost: 137723.03194110325\n",
-    "main()"
-   ]
-  }
- ],
- "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/AIDS/4. Simulated Annealing/Sudoku Simulated Annealing.ipynb

@@ -1,103 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3686dceb-7ecd-40c8-8f9c-eab71bd40f11",
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "import math \n",
-    "import random\n",
-    "def display(board):\n",
-    "    for row in board:\n",
-    "        print(' '.join(str(num) if num != 0 else '.' for num in row))\n",
-    "    print()\n",
-    "def fill(board):\n",
-    "    for i in range(9):\n",
-    "        choices = list(set(range(1,10)) - set(board[i]) - {0})\n",
-    "        random.shuffle(choices)\n",
-    "        for j in range(9):\n",
-    "            if board[i][j] == 0:\n",
-    "                board[i][j] = choices.pop()\n",
-    "def cost(board):\n",
-    "    conflicts = 0\n",
-    "    for n in range(9):\n",
-    "        row = board[n]\n",
-    "        col = [x[n] for x in board]\n",
-    "        conflicts += len(row) - len(set(row))\n",
-    "        conflicts += len(col) - len(set(col))\n",
-    "    for l in [0,3,6]:\n",
-    "        for k in [0,3,6]:\n",
-    "            block = []\n",
-    "            for i in range(0+l,3+l):\n",
-    "                for j in range(0+k,3+k):\n",
-    "                    block.append(board[i][j])\n",
-    "            conflicts += 9 - len(set(block))\n",
-    "    return conflicts\n",
-    "def next(board, fixed):\n",
-    "    neighbor = [[x for x in row] for row in board]\n",
-    "    i = random.randint(0,8)\n",
-    "    cols = [j for j in range(9) if (i,j) not in fixed]\n",
-    "    if len(cols) >= 2:\n",
-    "        j1, j2 = random.sample(cols, 2)\n",
-    "        neighbor[i][j1], neighbor[i][j2] = neighbor[i][j2], neighbor[i][j1]\n",
-    "    return neighbor\n",
-    "def simulated_annealing(board, initial_temp = 1.0, cooling_rate = 0.99, min_temp = 0.001):\n",
-    "    fixed = [(x,y) for x in range(9) for y in range(9) if board[x][y] != 0]\n",
-    "    fill(board)\n",
-    "    current = best = board\n",
-    "    temp = initial_temp\n",
-    "    while temp > min_temp:\n",
-    "        neighbor = next(current,fixed)\n",
-    "        delta = cost(neighbor) - cost(current)\n",
-    "        if delta < 0:\n",
-    "            current = neighbor\n",
-    "            if cost(neighbor) < cost(best):\n",
-    "                best = neighbor\n",
-    "        else:\n",
-    "            if random.random() < math.exp(-delta/temp):\n",
-    "                current = neighbor\n",
-    "        temp *= cooling_rate\n",
-    "    print(f\"Sudoku ({'Best Possible State | Attacks = '+str(cost(best)) if cost(best) else 'Solved'})\") \n",
-    "    display(best)\n",
-    "\n",
-    "def main():\n",
-    "    board =[[5, 3, 0, 0, 7, 0, 0, 0, 0],\n",
-    "            [6, 0, 0, 1, 9, 5, 0, 0, 0],\n",
-    "            [0, 9, 8, 0, 0, 0, 0, 6, 0],\n",
-    "            [8, 0, 0, 0, 6, 0, 0, 0, 3],\n",
-    "            [4, 0, 0, 8, 0, 3, 0, 0, 1],\n",
-    "            [7, 0, 0, 0, 2, 0, 0, 0, 6],\n",
-    "            [0, 6, 0, 0, 0, 0, 2, 8, 0],\n",
-    "            [0, 0, 0, 4, 1, 9, 0, 0, 5],\n",
-    "            [0, 0, 0, 0, 8, 0, 0, 7, 9]]\n",
-    "    simulated_annealing(board)                                       \n",
-    "main()"
-   ]
-  }
- ],
- "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/AIDS/5. Alpha Beta Pruning/AlphaBetaPruning.ipynb

@@ -1,182 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1ff278f1-8592-427e-b72a-032f21aa02e5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import networkx as nx\n",
-    "import matplotlib.pyplot as plt\n",
-    "def show_tree(graph):\n",
-    "    graph = {node : [adj for adj in graph[node]] for node in graph}\n",
-    "    terminal_nodes = set()\n",
-    "    for node in graph:\n",
-    "        for i in range(len(graph[node])):\n",
-    "            x = str(graph[node][i])\n",
-    "            if x.isdigit():\n",
-    "                while x in terminal_nodes:\n",
-    "                    x+=\" \"\n",
-    "                graph[node][i] = x\n",
-    "                terminal_nodes.add(x)\n",
-    "    g = nx.DiGraph(graph)\n",
-    "    levels = nx.single_source_shortest_path_length(g, next(iter(g.nodes)))\n",
-    "    layers = {}\n",
-    "    for node, level in levels.items():\n",
-    "        layers[level] = layers.get(level, []) + [node]\n",
-    "    pos = {}\n",
-    "    for level, nodes in layers.items():\n",
-    "        x_offset = (len(nodes) - 1)/2\n",
-    "        for i, node in enumerate(nodes):\n",
-    "            x = i - x_offset\n",
-    "            y = -level\n",
-    "            pos[node] = (x,y)\n",
-    "    plt.figure(figsize = (8,4))\n",
-    "    nx.draw(g, pos, with_labels = True, \n",
-    "            node_size = 600, node_color = 'lightgreen',\n",
-    "            font_size = 12, font_family = 'cursive',\n",
-    "            arrows = False, width = 1.5, edge_color = 'red',\n",
-    "            edgecolors = 'black', linewidths = 1.5,\n",
-    "            margins = 0.1, clip_on = False)\n",
-    "    plt.suptitle(\"Alpha Beta Pruning\")\n",
-    "    plt.show()\n",
-    "    plt.clf()\n",
-    "MIN = -float('inf')\n",
-    "MAX = float('inf')\n",
-    "def alphabeta(node, graph, ismax, pruned = [], alpha = MIN, beta = MAX, path = {}):\n",
-    "    if str(node).isdigit():\n",
-    "        return int(node), pruned, path\n",
-    "    option = MIN if ismax else MAX\n",
-    "    for child in graph[node]:\n",
-    "        val, _, _ = alphabeta(child, graph, not ismax, pruned, alpha, beta, path)\n",
-    "        if ismax:\n",
-    "            option = max(option, val)\n",
-    "            alpha = max(option, alpha)\n",
-    "            path[node] = alpha\n",
-    "        else:\n",
-    "            option = min(option, val)\n",
-    "            beta = min(option, beta)\n",
-    "            path[node] = beta\n",
-    "        if alpha >= beta:\n",
-    "            i = graph[node].index(child)+1\n",
-    "            pruned += [f\"{node}-{adj}\" for adj in graph[node][i:]]\n",
-    "            break\n",
-    "    return option, pruned, path\n",
-    "def show_path(node, graph, path, value):\n",
-    "    for adj in graph[node]:\n",
-    "        if str(adj).isdigit():\n",
-    "            return [node,str(value)]\n",
-    "        if path[adj] == value:\n",
-    "            return [node] + show_path(adj, graph, path, value)\n",
-    "def get_graph():\n",
-    "    graph = {}\n",
-    "    print(\"Enter edge (u, v)\")\n",
-    "    print(\"[PRESS ENTER TO STOP]\")\n",
-    "    x = input()\n",
-    "    while x:\n",
-    "        x = x.split(maxsplit = 1)\n",
-    "        u, adj = x[0], [v.strip() for v in x[1].strip(' []').split(',') if v]\n",
-    "        graph[u] = graph.get(u,[]) + adj\n",
-    "        x = input()\n",
-    "    return graph\n",
-    "def example():\n",
-    "    graph = {\n",
-    "        'A' : ['B', 'C'],\n",
-    "        'B' : ['D', 'E'],\n",
-    "        'C' : ['F', 'G'],\n",
-    "        'D' : ['H', 'I'],\n",
-    "        'E' : [10, 5],\n",
-    "        'F' : ['J', 'K'],\n",
-    "        'G' : ['L', 'M'],\n",
-    "        'H' : [11, 12],\n",
-    "        'I' : [8, 9],\n",
-    "        'J' : [8, 5],\n",
-    "        'K' : [12, 11],\n",
-    "        'L' : [12, 9],\n",
-    "        'M' : [8, 7]}\n",
-    "\n",
-    "    show_tree(graph)\n",
-    "    print(graph)\n",
-    "    start = 'A'\n",
-    "    \n",
-    "    val, pruned, path = alphabeta(start, graph, True)#True means first node is max\n",
-    "    path = show_path(start, graph, path, val)\n",
-    "    print(\"Alpha Beta Pruning(Maximize):\", val, \" Pruned Branches:\", (', '.join(pruned) if pruned else None), \" Path:\",'->'.join(path))\n",
-    "    \n",
-    "    val, pruned, path = alphabeta(start, graph, False)#False means first node is min\n",
-    "    path = show_path(start, graph, path, val)\n",
-    "    print(\"Alpha Beta Pruning(Minimize):\", val, \" Pruned Branches:\", (', '.join(pruned) if pruned else None), \" Path:\",'->'.join(path))\n",
-    "\n",
-    "def main():\n",
-    "    #example();return #change the example according to question\n",
-    "    graph = get_graph()\n",
-    "    start = input(\"Enter start node: \")\n",
-    "    show_tree(graph)\n",
-    "    print(graph)\n",
-    "    val, pruned, path = alphabeta(start, graph, True)#True means first node is max\n",
-    "    path = show_path(start, graph, path, val)\n",
-    "    print(\"Alpha Beta Pruning(Maximize):\", val, \" Pruned Branches:\", (', '.join(pruned) if pruned else None), \" Path:\",'->'.join(path))\n",
-    "    \n",
-    "    val, pruned, path = alphabeta(start, graph, False)#False means first node is min\n",
-    "    path = show_path(start, graph, path, val)\n",
-    "    print(\"Alpha Beta Pruning(Minimize):\", val, \" Pruned Branches:\", (', '.join(pruned) if pruned else None), \" Path:\",'->'.join(path))\n",
-    "    #Sample output\n",
-    "    #Enter edge (u, v)\n",
-    "    #[PRESS ENTER TO STOP]\n",
-    "    #A B\n",
-    "    #A C\n",
-    "    #B D\n",
-    "    #B E\n",
-    "    #C F\n",
-    "    #C G\n",
-    "    #D H\n",
-    "    #D I\n",
-    "    #E 10\n",
-    "    #E 5\n",
-    "    #F J\n",
-    "    #F K\n",
-    "    #G L\n",
-    "    #G M\n",
-    "    #H 11\n",
-    "    #H 12\n",
-    "    #I 8\n",
-    "    #I 9\n",
-    "    #J 8\n",
-    "    #J 5\n",
-    "    #K 12\n",
-    "    #K 11\n",
-    "    #L 12\n",
-    "    #L 9\n",
-    "    #M 8\n",
-    "    #M 7\n",
-    "\n",
-    "    #Alpha Beta Pruning(Maximize): 10  Pruned Branches: I-9, J-5, M-7  Path: A->B->E->10\n",
-    "    #Alpha Beta Pruning(Minimize): 8  Pruned Branches: I-9, J-5, M-7, K-11, L-9  Path: A->C->F->J->8\n",
-    "\n",
-    "main()"
-   ]
-  }
- ],
- "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/AIDS/6. Consraint Satisfaction Problems (CSP)/(A) CSP House Allocation.ipynb

@@ -1,120 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5136c471-9d1d-4b2b-8f6b-e584ea42a133",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import networkx as nx\n",
-    "import matplotlib.pyplot as plt\n",
-    "def check(assign, loc):\n",
-    "    #constraints given in the question\n",
-    "    #change it accordinly\n",
-    "\n",
-    "    a = assign['A']\n",
-    "    b = assign['B']\n",
-    "    c = assign['C']\n",
-    "    d = assign['D']\n",
-    "    \n",
-    "    #1. C lives in a house higher than D\n",
-    "    if c != -1 and d != -1 and c < d:return False\n",
-    "\n",
-    "    #2. D lives next to A in Lower number House\n",
-    "    if d != -1 and a != -1 and (a - d) != 1:return False\n",
-    "\n",
-    "    #3. There is at least one house between D and B    \n",
-    "    if d != -1 and b != -1 and abs(d - b) == 1:return False\n",
-    "\n",
-    "    #4. C doesn't live in house number 3\n",
-    "    if c != -1 and c == 3:return False\n",
-    "\n",
-    "    #5. B doesn't live in house number 1\n",
-    "    if b != -1 and b == 1:return False\n",
-    "        \n",
-    "    if loc in assign.values():\n",
-    "        return False\n",
-    "    return True\n",
-    "def backtrack(houses, locs):\n",
-    "    assign = {house : -1 for house in houses}    \n",
-    "    return rec_backtrack(assign, locs)\n",
-    "def rec_backtrack(assign, locs):\n",
-    "    if check(assign, -1):\n",
-    "        return assign\n",
-    "    choices = [x for x in assign if assign[x] == -1]\n",
-    "    house = choices[0] if choices else None\n",
-    "    for loc in locs:\n",
-    "        if check(assign, loc):\n",
-    "            assign[house] = loc\n",
-    "            res = rec_backtrack(assign, locs)\n",
-    "            if res:\n",
-    "                return res\n",
-    "            assign[house] = -1\n",
-    "    return None\n",
-    "def display_house(result):\n",
-    "    g = nx.Graph()\n",
-    "    nodes = list(result.keys())\n",
-    "    nodes.sort(key = lambda x : result[x])\n",
-    "    nodes = [f\"{node}({result[node]})\" for node in nodes]\n",
-    "    for u, v in zip(nodes, nodes[1:]):\n",
-    "        g.add_edge(u, v)\n",
-    "    pos = {node : (0, i) for i, node in enumerate(nodes)}\n",
-    "    nx.draw(g, pos, with_labels = True,\n",
-    "            width = 1.5, edge_color = 'red',\n",
-    "            node_size = 800, node_color = 'lightgreen',\n",
-    "            font_size = 12, font_family = 'cursive',\n",
-    "            edgecolors = 'black', linewidths = 1.5,\n",
-    "            margins = 0.2, clip_on = False)\n",
-    "    plt.suptitle(\"House Allocation(Constraint Satisfaction Problem)\")\n",
-    "    plt.show()\n",
-    "    plt.clf()\n",
-    "\n",
-    "def main():\n",
-    "    #Info: \"There are 4 family namely A, B, C, D there are 4 houses namely 1,2,3,4\"\n",
-    "    #1. C lives in a house higher than D\n",
-    "    #2. D lives next to A in Lower number House\n",
-    "    #3. There is at least one house between D and B\n",
-    "    #4. C doesn't live in house number 3\n",
-    "    #5. B doesn't live in house number 1\n",
-    "    locs = [1,2,3,4]\n",
-    "    houses = ['A','B','C','D']\n",
-    "    sol = backtrack(houses, locs)\n",
-    "    if sol:\n",
-    "        display_house(sol)\n",
-    "        for node in sol:\n",
-    "            print(\"House:\",node,\" Location:\",sol[node])\n",
-    "    else:\n",
-    "        print(\"No Solution Exists\")\n",
-    "\n",
-    "    #Sample Input/Output\n",
-    "    #House: A  Location: 2\n",
-    "    #House: B  Location: 3\n",
-    "    #House: C  Location: 4\n",
-    "    #House: D  Location: 1\n",
-    "main()"
-   ]
-  }
- ],
- "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
-}