Miniproyecto.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9aRRMmpW9ifH"
      },
      "outputs": [],
      "source": [
        "class Nodo():\n",
        "    def __init__(self, estado, padre, accion):\n",
        "        self.estado = estado\n",
        "        self.padre = padre\n",
        "        self.accion = accion\n",
        "\n",
        "class Frontera():\n",
        "    def __init__(self):\n",
        "        self.frontera =[]\n",
        "    \n",
        "    def empty(self):\n",
        "        return (len(self.frontera) == 0)\n",
        "\n",
        "    def add(self, nodo):\n",
        "        self.frontera.append(nodo)\n",
        "    \n",
        "    def eliminar(self):\n",
        "        # LIFO o FIFO\n",
        "        pass\n",
        "\n",
        "    def contiene_estado(self, estado):\n",
        "        return any(nodo.estado == estado for nodo in self.frontera)\n",
        "\n",
        "class Pila(Frontera):\n",
        "    def eliminar(self):\n",
        "        # Termina la busqueda si la frontera esta vacia\n",
        "        if self.empty():        \n",
        "            raise Exception(\"Frontera vacia\")\n",
        "        else:\n",
        "            # Guardamos el ultimo item en la lista \n",
        "            # (el cual es el nodo recientemente añadido)\n",
        "            nodo = self.frontera[-1]\n",
        "            # Guardamos todos los items excepto el \n",
        "            # ultimo (eliminamos)\n",
        "            self.frontera = self.frontera[:-1]\n",
        "            return nodo\n",
        "    \n",
        "class Cola(Frontera):\n",
        "    def eliminar(self):\n",
        "        # Termina la busqueda si la frontera esta vacia\n",
        "        if self.empty():        \n",
        "            raise Exception(\"Frontera vacia\")\n",
        "        else:\n",
        "            # Guardamos el primer item en la lista \n",
        "            # (el cual es el nodo añadido de primero)\n",
        "            nodo = self.frontera[0]\n",
        "            # Guardamos todos los items excepto el \n",
        "            # primero (eliminamos)\n",
        "            self.frontera = self.frontera[1:]\n",
        "            return nodo"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# from search import *\n",
        "\n",
        "class SimpleProblemSolvingAgentProgram:\n",
        "    \"\"\"\n",
        "    [Figure 3.1]\n",
        "    Abstract framework for a problem-solving agent.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, initial_state=None):\n",
        "        \"\"\"State is an abstract representation of the state\n",
        "        of the world, and seq is the list of actions required\n",
        "        to get to a particular state from the initial state(root).\"\"\"\n",
        "        self.state = initial_state\n",
        "        self.seq = []\n",
        "\n",
        "    def __call__(self, percept):\n",
        "        \"\"\"[Figure 3.1] Formulate a goal and problem, then\n",
        "        search for a sequence of actions to solve it.\"\"\"\n",
        "        self.state = self.update_state(self.state, percept)\n",
        "        if not self.seq:\n",
        "            goal = self.formulate_goal(self.state)\n",
        "            problem = self.formulate_problem(self.state, goal)\n",
        "            self.seq = self.search(problem)\n",
        "            if not self.seq:\n",
        "                return None\n",
        "        return self.seq\n",
        "        # return self.seq.pop(0)\n",
        "\n",
        "    def update_state(self, state, percept):\n",
        "        raise NotImplementedError\n",
        "\n",
        "    def formulate_goal(self, state):\n",
        "        raise NotImplementedError\n",
        "\n",
        "    def formulate_problem(self, state, goal):\n",
        "        raise NotImplementedError\n",
        "\n",
        "    def search(self, problem):\n",
        "        raise NotImplementedError"
      ],
      "metadata": {
        "id": "3pi0qV8U29of"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "habitaciones = [[\"Dirty\", \"Dirty\", \"Dirty\"], \n",
        "                [\"Dirty\", \"Dirty\", \"Dirty\"], \n",
        "                [\"Dirty\", \"Dirty\", \"Dirty\"] ]\n",
        "\n",
        "objetivo = [[\"Clean\", \"Clean\", \"Clean\"], \n",
        "            [\"Clean\", \"Clean\", \"Clean\"],\n",
        "            [\"Clean\", \"Clean\", \"Clean\"]]\n",
        "\n",
        "state1 = [(0, 0),habitaciones]\n",
        "\n",
        "class vacuumAgent(SimpleProblemSolvingAgentProgram):\n",
        "        def update_state(self, state, percept):\n",
        "            return percept\n",
        "\n",
        "        def formulate_goal(self, state):\n",
        "            goal = len(habitaciones)*len(habitaciones[0])\n",
        "            return goal  \n",
        "\n",
        "        def formulate_problem(self, state, goal):\n",
        "            problem = state, goal\n",
        "            return problem   \n",
        "    \n",
        "        def search(self, problem):\n",
        "\n",
        "            self.num_explorados = 0\n",
        "            state, goal = problem\n",
        "            # Inicializamos la frontera para empezar en la posicion inicial\n",
        "            start = Nodo(estado=state, padre=None, accion=None)\n",
        "            frontera = Pila()\n",
        "            frontera.add(start)\n",
        "        \n",
        "            # Inicializamos en conjunto explorado vacio\n",
        "            self.explorado = set()\n",
        "            self.cont = 0\n",
        "            # Manetenmos el bucle hasta que encontremos la solución\n",
        "            while True:\n",
        "\n",
        "                # Si nada queda en la frontera, entonces no hya mas camino\n",
        "                if frontera.empty():\n",
        "                    print(self.cont)\n",
        "                    raise Exception(\"No hay Solución\")\n",
        "            \n",
        "                # Escogemos un nodo de la frontera\n",
        "                nodo = frontera.eliminar()\n",
        "                self.num_explorados +=1\n",
        "                if nodo.accion == \"suck\":\n",
        "                  n,k = nodo.estado[0]\n",
        "                  self.cont += 1\n",
        "                  nodo.estado[1][n][k] = \"Clean\" \n",
        "\n",
        "                # Si el nodo es el objetivo, entonces tenemos una solución\n",
        "                if nodo.estado[1] == objetivo:\n",
        "                    acciones = []\n",
        "                    cel = []\n",
        "                    # Rastreamos los nodos padre hasta la solución (objetivo hasta estado inicial)\n",
        "                    while nodo.padre is not None:\n",
        "                        acciones.append(nodo.accion)\n",
        "                        cel.append(nodo.estado)\n",
        "                        nodo = nodo.padre\n",
        "                    acciones.reverse()\n",
        "                    cel.reverse()\n",
        "                    self.solucion = (acciones, cel)\n",
        "                    return acciones\n",
        "            \n",
        "                # Marcamos el nodo como exploado\n",
        "                n,k = nodo.estado[0]\n",
        "                if not nodo.estado[1][n][k] == \"Dirty\":\n",
        "                  self.explorado.add(nodo.estado[0])\n",
        "                # Agregamos vecinos a la frontera\n",
        "                for accion, estado in self.acciones_valida(nodo.estado):\n",
        "                    if not frontera.contiene_estado(estado[0]) and estado[0] not in self.explorado:\n",
        "                        hijo = Nodo(estado = estado, padre = nodo, accion=accion)\n",
        "                        frontera.add(hijo)\n",
        "\n",
        "\n",
        "        def acciones_valida(self, state):\n",
        "          fila, col = state[0]\n",
        "          self.altura = len(habitaciones)\n",
        "          self.ancho = len(habitaciones[0])\n",
        "          candidatos = [\n",
        "              (\"up\", (fila -1, col)),\n",
        "              (\"down\", (fila +1, col)),\n",
        "              (\"left\", (fila, col -1)),\n",
        "              (\"right\", (fila, col +1)),\n",
        "              (\"suck\", (fila, col))\n",
        "              \n",
        "          ]\n",
        "\n",
        "          resultados = []\n",
        "          for accion, (f,c) in candidatos:\n",
        "              if 0<=f < self.altura and 0<=c < self.ancho:\n",
        "                if state[1][f][c] == \"Dirty\":\n",
        "                  resultados.append((accion,[(f,c), state[1]]))\n",
        "                if not state[1][f][c] == \"Dirty\" and not accion == \"suck\":\n",
        "                  resultados.append((accion,[(f,c), state[1]]))\n",
        "        \n",
        "    \n",
        "          return resultados\n",
        "\n",
        "a = vacuumAgent(state1)\n",
        "\n",
        "print(a(state1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Umn9v6Ml3A18",
        "outputId": "d75c6732-5d16-479f-ee20-e894aa35bd52"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['suck', 'right', 'suck', 'right', 'suck', 'down', 'suck', 'left', 'suck', 'left', 'suck', 'down', 'suck', 'right', 'suck', 'right', 'suck']\n"
          ]
        }
      ]
    }
  ]
}