AI.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "dcca10d1-cd97-4ff9-b282-2de8b696d9c9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter 9 numbers , seperated:\n",
      "depth= 0\n",
      "depth= 0\n",
      "depth= 0\n",
      "[[0, 1], [1, 1], [2, 1]]\n",
      "[[0, 0], [1, 0], [2, 0]]\n",
      "[[0, 0], [1, 0], [2, 0]]\n",
      "depth= 2\n",
      "depth= 2\n",
      "depth= 2\n",
      "[[0, 7], [1, 3], [2, 3]]\n",
      "[[0, 8], [1, 3], [2, 3]]\n",
      "[[0, 9.179115295410156e-05], [1, 3.790855407714844e-05], [2, 3.2901763916015625e-05]]\n",
      "depth= 4\n",
      "depth= 4\n",
      "depth= 4\n",
      "[[0, 33], [1, 5], [2, 5]]\n",
      "[[0, 28], [1, 6], [2, 6]]\n",
      "[[0, 0.0003719329833984375], [1, 4.601478576660156e-05], [2, 7.009506225585938e-05]]\n",
      "depth= 8\n",
      "depth= 8\n",
      "depth= 8\n",
      "[[0, 321], [1, 20], [2, 13]]\n",
      "[[0, 210], [1, 16], [2, 12]]\n",
      "[[0, 0.0030400753021240234], [1, 0.00015282630920410156], [2, 0.00010800361633300781]]\n",
      "depth= 12\n",
      "depth= 12\n",
      "depth= 12\n",
      "[[0, 2569], [1, 135], [2, 37]]\n",
      "[[0, 1520], [1, 88], [2, 28]]\n",
      "[[0, 0.02435612678527832], [1, 0.0009648799896240234], [2, 0.0002701282501220703]]\n",
      "depth= 16\n",
      "depth= 16\n",
      "depth= 16\n",
      "[[0, 16840], [1, 740], [2, 97]]\n",
      "[[0, 9180], [1, 445], [2, 64]]\n",
      "[[0, 0.09913492202758789], [1, 0.0036220550537109375], [2, 0.00043702125549316406]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import copy\n",
    "import time\n",
    "class Node:\n",
    "    def __init__(self):\n",
    "        '''dimension can be passed to create the node'''\n",
    "        self.node = np.zeros([3,3], dtype = int)\n",
    "        ''' node for children based on operators'''\n",
    "        self.up = None\n",
    "        self.down = None\n",
    "        self.left = None\n",
    "        self.right = None\n",
    "        ''' save the parent to compute the depth'''\n",
    "        self.parent = None\n",
    "        '''h_t = misplaced tile distance, h_m = manhattan distance, g = distance from the root, f for a*'''\n",
    "        self.g = 0\n",
    "        self.h_t = 0\n",
    "        self.h_m = 0\n",
    "        self.f = 0\n",
    "        \n",
    "    def misplacedTile(self,goal):\n",
    "        self.goal = goal\n",
    "        '''Compute the Mispalced tile heuristics with the help of the goal.\n",
    "        Numpy uses all() to compare if each nd array is the same.\n",
    "        We find the sum of the nd-array which is different from the goal state and return the result'''\n",
    "        if not (self.node == self.goal).all():\n",
    "            self.h_t = np.sum(self.node!=self.goal)\n",
    "        return self.h_t\n",
    "    \n",
    "    def manhattan(self, goal):\n",
    "        self.goal = goal \n",
    "        '''Instead of 3 we can use dimension value. \n",
    "        Compute the Manhattan distance heuristics with the goal and the node.\n",
    "        Each position is checked and computed for the positional change required in the nd array.\n",
    "        '''\n",
    "        for i in range(0,3):\n",
    "            for j in range(0,3):\n",
    "                m,n = np.where(self.node==goal[i][j])\n",
    "                if(goal[i][j]!=0):\n",
    "                    self.h_m += abs(i-m[0])+abs(j-n[0])\n",
    "        return self.h_m\n",
    "\n",
    "def genChild(i, j, node, goal):\n",
    "    '''Generate children based on the i,j (position of the blank).\n",
    "    We can move up only if there is space above. Similary we compute child possiblity based on the i,j value.\n",
    "    If the child is possible based on the operation create a node and swap with the blank. Then compute manhattan \n",
    "    and misplaced tile heuristics. Add the parent to the node and increase of the cost g(n) by 1 \n",
    "    as we've generated the child\n",
    "    '''\n",
    "    #up=>i-1\n",
    "    if i>0:\n",
    "        child = copy.deepcopy(node.node)\n",
    "        x = i-1\n",
    "        child[i,j], child[x,j] = child[x,j], child[i,j]\n",
    "        node.up = Node()\n",
    "        node.up.node = child\n",
    "        node.up.misplacedTile(goal)\n",
    "        node.up.manhattan(goal)\n",
    "        node.up.parent = node\n",
    "        node.up.g = node.g+1\n",
    "    #down=>i+1\n",
    "    if i<2:\n",
    "        child = copy.deepcopy(node.node)\n",
    "        x = i+1\n",
    "        child[i,j], child[x,j] = child[x,j], child[i,j]\n",
    "        node.down = Node()\n",
    "        node.down.node = child\n",
    "        node.down.misplacedTile(goal)\n",
    "        node.down.manhattan(goal)\n",
    "        node.down.parent = node\n",
    "        node.down.g = node.g+1\n",
    "    #left=>j-1\n",
    "    if j>0:       \n",
    "        child = copy.deepcopy(node.node)\n",
    "        x = j-1\n",
    "        child[i,j],child[i,x] = child[i,x], child[i,j]\n",
    "        node.left = Node()\n",
    "        node.left.node = child\n",
    "        node.left.misplacedTile(goal)\n",
    "        node.left.manhattan(goal)\n",
    "        node.left.parent = node\n",
    "        node.left.g = node.g+1\n",
    "    #right=>j+1\n",
    "    if j<2:\n",
    "        child = copy.deepcopy(node.node)\n",
    "        x = j+1\n",
    "        child[i,j],child[i,x] = child[i,x], child[i,j]\n",
    "        node.right = Node()\n",
    "        node.right.node = child\n",
    "        node.right.misplacedTile(goal)\n",
    "        node.right.manhattan(goal)\n",
    "        node.right.parent = node\n",
    "        node.right.g = node.g+1\n",
    "\n",
    "def calculateFTile(node):\n",
    "    '''Since at times we might encounter nodes with less children(corner and edge cases), we check for the \n",
    "    node generation and calculate the f(n) for the misplaced tile, so we use h_t\n",
    "    '''\n",
    "    a = b = c = d = float(\"inf\")\n",
    "    if node.up is not None:\n",
    "            a = node.up.h_t + node.up.g\n",
    "            node.up.f = a\n",
    "    if node.down is not None:\n",
    "            b = node.down.h_t + node.down.g\n",
    "            node.down.f = b\n",
    "    if node.left is not None:\n",
    "            c = node.left.h_t + node.left.g\n",
    "            node.left.f = c\n",
    "    if node.right is not None:\n",
    "            d = node.right.h_t + node.right.g\n",
    "            node.right.f = d\n",
    "    return min(a,b,c,d)\n",
    "\n",
    "def calculateFmanhattan(node):\n",
    "    '''Since at times we might encounter nodes with less children(corner and edge cases), we check for the \n",
    "    node generation and calculate the f(n) for the manhattan distacne, so we use h_m.\n",
    "    '''\n",
    "    a = b = c = d = float(\"inf\")\n",
    "    if node.up is not None:\n",
    "        a = node.up.h_m + node.up.g\n",
    "        node.up.f = a\n",
    "    if node.down is not None:            \n",
    "        b = node.down.h_m + node.down.g\n",
    "        node.down.f = b\n",
    "    if node.left is not None:            \n",
    "        c = node.left.h_m + node.left.g\n",
    "        node.left.f = c\n",
    "    if node.right is not None:            \n",
    "        d = node.right.h_m + node.right.g\n",
    "        node.right.f = d\n",
    "    return min(a,b,c,d)\n",
    "\n",
    "def calculateFUCS(node):\n",
    "    '''Since at times we might encounter nodes with less children(corner and edge cases), we check for the \n",
    "    node generation and calculate the f(n) for the Uniform Cost Search, so we do not use h.\n",
    "    '''\n",
    "    a = b = c = d = float(\"inf\")\n",
    "    if node.up is not None:\n",
    "        a = node.up.g\n",
    "        node.up.f = a\n",
    "    if node.down is not None:            \n",
    "        b = node.down.g\n",
    "        node.down.f = b\n",
    "    if node.left is not None:            \n",
    "        c = node.left.g\n",
    "        node.left.f = c\n",
    "    if node.right is not None:            \n",
    "        d = node.right.g\n",
    "        node.right.f = d\n",
    "    return min(a,b,c,d)\n",
    "\n",
    "def nodesToExpand(node, states):\n",
    "    '''If the generate nodes are not present in the states(which are the nodes that are already explored, \n",
    "    if the generated node is in the states, it is a repeated state and can be ignored) we add it to the queue.\n",
    "    '''\n",
    "    includednodes = []\n",
    "    if node.up is not None:\n",
    "        if not any([np.array_equal(node.up.node, state) for state in states]):\n",
    "            includednodes.append(node.up)\n",
    "    if node.down is not None:\n",
    "        if not any([np.array_equal(node.down.node, state) for state in states]):\n",
    "            includednodes.append(node.down)\n",
    "    if node.left is not None:\n",
    "        if not any([np.array_equal(node.left.node, state) for state in states]):\n",
    "            includednodes.append(node.left)\n",
    "    if node.right is not None:\n",
    "        if not any([np.array_equal(node.right.node, state) for state in states]):\n",
    "            includednodes.append(node.right)\n",
    "    return includednodes\n",
    "\n",
    "def depth(node):\n",
    "    '''Compute the node depth based on the parent and increase the d value.'''\n",
    "    d = 0\n",
    "    n = node\n",
    "    while n.parent is not None:\n",
    "        d+=1\n",
    "        n = n.parent\n",
    "    print(\"depth=\",d)\n",
    "    return d\n",
    "\n",
    "def solve(startNode, goal):\n",
    "    ''' This is where we solve the puzzle'''\n",
    "    '''Algorithm options: \n",
    "    0 = Uniform Cost Search, \n",
    "    1 = A* with Misplaced Tile\n",
    "    2 = A* with Manhattan Distance'''\n",
    "    algorithm_options = [0,1,2]\n",
    "    ''' Node expanded, max queue and the time executed size for each algorithm for every input'''\n",
    "    nodes_expanded = []\n",
    "    max_queue = []\n",
    "    time_list = []\n",
    "    '''Each algorithm has to run for each input'''\n",
    "    for choice in algorithm_options:\n",
    "        states = [startNode.node]\n",
    "        '''create a queue q.'''\n",
    "        q = []\n",
    "        #end time\n",
    "        e = 0\n",
    "        #node inserted\n",
    "        q.append(startNode)\n",
    "        #queue count\n",
    "        max_q = 0\n",
    "        node = startNode\n",
    "        #start from the dequeued node\n",
    "        q.pop(0)\n",
    "        while(1):\n",
    "            '''If the goal state and the node are equal, we have reached a solution.'''\n",
    "            if (node.node==goal).all():\n",
    "                d = (depth(node))\n",
    "                break\n",
    "            '''find the 0 as it is where the blank is present and we can perform operations based on the blank.'''\n",
    "            i,j = np.where(node.node==0)\n",
    "            #Generate child for each node\n",
    "            genChild(i, j, node, goal)\n",
    "            #start the time\n",
    "            s = time.time()\n",
    "            '''Based on the choice compute the f(n)'''\n",
    "            if choice == 0:\n",
    "                f = calculateFUCS(node)\n",
    "            elif choice==1:\n",
    "                f = calculateFTile(node)\n",
    "            else:\n",
    "                f = calculateFmanhattan(node)\n",
    "            '''Nodes to added based on the f(n) and to check if it is not a repeated state. \n",
    "            The returned nodes are added to the queue for further exploration'''    \n",
    "            qnodes = nodesToExpand(node,states)\n",
    "            for n in qnodes:\n",
    "                q.append(n)\n",
    "            '''We sort the elements in the queue based on the f. \n",
    "            As we always get to a solution based on the minimum f(n)'''\n",
    "            q.sort(key = lambda x: x.f)\n",
    "            '''max queue length calculation'''\n",
    "            max_q = max(len(q),max_q)\n",
    "            '''If the Queue is empty we can not find the solution so break.'''\n",
    "            if len(q)==0: \n",
    "                print(\"Can not find a solution!\")\n",
    "                break\n",
    "            '''Dequeue the next element in the queue.'''\n",
    "            node = q.pop(0)\n",
    "            '''Since we are processing the node, add it to the states explored'''\n",
    "            states.append(node.node)\n",
    "            '''if the node is the goal state, calculate the depth and stop the time and break the loop.'''\n",
    "            if (node.node==goal).all():\n",
    "                d = depth(node)\n",
    "                e = time.time() - s\n",
    "                break\n",
    "        '''Add the values with the algorithm so it will be easy to plot'''\n",
    "        nodes_expanded.append([choice, len(states)])\n",
    "        max_queue.append([choice, max_q])\n",
    "        time_list.append([choice,e])\n",
    "    print(nodes_expanded)\n",
    "    print(max_queue)\n",
    "    print(time_list)\n",
    "    return nodes_expanded, max_queue, d, time_list\n",
    "   \n",
    "''' Lists of Inputs at different Depth ''' \n",
    "#We can also get the input from the user. use input(). 0 presents Blank\n",
    "inputs = [\"1,2,3,4,5,6,7,8,0\",\n",
    "          \"1,2,3,4,5,6,0,7,8\",\n",
    "          \"1,2,3,5,0,6,4,7,8\",\n",
    "          \"1,3,6,5,0,2,4,7,8\", \n",
    "          \"1,3,6,5,0,7,4,8,2\",\n",
    "          \"1,6,7,5,0,3,4,8,2\",\n",
    "          #\"7,1,2,4,8,5,6,3,0\",\n",
    "          #\"0,7,2,4,6,1,3,5,8\"\n",
    "         ]\n",
    "''' 8 puzzle problem so dimension is equal to 3 '''\n",
    "dim = 3\n",
    "''' Node expanded, max queue and the time executed size for each algorithm for every input'''\n",
    "nodes_expanded = []\n",
    "max_queue = []\n",
    "time_list = []\n",
    "\n",
    "'''depth of each input'''\n",
    "input_depth = []\n",
    "\n",
    "'''Solve for each input'''\n",
    "for i in inputs:\n",
    "    intial = i\n",
    "    #Convert String to a list\n",
    "    intial = list(map(int,intial.split(\",\")))\n",
    "    #Create the initial state as the start node with Type Node (User Defined Class) object\n",
    "    startNode = Node()\n",
    "    #Convert the list to a nd-array using numpy\n",
    "    startNode.node = np.asarray(intial).reshape(dim, dim)\n",
    "\n",
    "    '''Create Goal state based on the dimension or get the goal from the user'''\n",
    "    goal = np.arange(1,(dim*dim)+1,1).reshape(dim, dim)\n",
    "    goal[dim-1][dim-1] = 0\n",
    "\n",
    "    '''n = Nodes expanded, m = max queue size, d =depth, t = time returned after solving \n",
    "    for the input using different algorithms. Save the result'''\n",
    "    n, m, d, t = solve(startNode, goal)\n",
    "    nodes_expanded.append(n)\n",
    "    max_queue.append(m)\n",
    "    input_depth.append(d)\n",
    "    time_list.append(t)\n",
    "    \n",
    "    '''Save the state to a file'''\n",
    "    file = open(\"8puzzle.txt\",\"a\")\n",
    "    file.writelines(\"\\n\"+i+\"\\nNode expanded:\"+str(n)+\"\\nMax Queue:\"+str(m)+\"\\nDepth:\"+str(d)+\"\\n\")\n",
    "    file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "317b796c-d465-4380-b6ce-58d3a8e3251f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as p\n",
    "'''Graph plotting.\n",
    "3 list for 3 algorithms'''\n",
    "node_ucs = []\n",
    "node_tile = []\n",
    "node_man = []\n",
    "\n",
    "for node in nodes_expanded:\n",
    "    node_ucs.append(node[0][1])\n",
    "    node_tile.append(node[1][1])\n",
    "    node_man.append(node[2][1])\n",
    "depth = [0,2,4,8,12,16]\n",
    "p.plot(depth, node_ucs, label = \"Uniform Search\")\n",
    "p.plot(depth, node_tile, label = \"MisplacedTile\")\n",
    "p.plot(depth, node_man, label = \"Manhattan\")\n",
    "#for a detailed view of the A* algorithm\n",
    "p.ylim(0,500)\n",
    "#To get a clear overview of the algorithm. Uncomment if necessary\n",
    "#p.yscale(\"log\")\n",
    "p.xlabel(\"Depth\")\n",
    "p.ylabel(\"Nodes\")\n",
    "p.legend()\n",
    "p.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "0f292516-2bdb-47a8-b158-46e91a4ba310",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as p\n",
    "time = []\n",
    "time1 = []\n",
    "time2 = []\n",
    "time3 = []\n",
    "for t in time_list:\n",
    "    time1.append(t[0][1])\n",
    "    time2.append(t[1][1])\n",
    "    time3.append(t[2][1])\n",
    "depth = [0,2,4,8,12,16]\n",
    "p.plot(depth, node_ucs, label = \"Uniform Search\")\n",
    "p.plot(depth, node_tile, label = \"MisplacedTile\")\n",
    "p.plot(depth, node_man, label = \"Manhattan\")\n",
    "#p.ylim(0,500)\n",
    "p.yscale(\"log\")\n",
    "p.xlabel(\"Depth\")\n",
    "p.ylabel(\"Time\")\n",
    "p.legend()\n",
    "p.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a552df4-9e6c-48fd-9b7c-1205f8f804d3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}