colab/DLPlan_system_demo.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T_xAC-ACW0D7"
      },
      "source": [
        "# DLPlan: Description Logics State Features for Planning\n",
        "\n",
        "This notebook aims to give an overview of the main functionality of each of the components of the DLPlan library."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ISoY5PqKXfkr"
      },
      "source": [
        "## 0. Installation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-0uUuQxGR-ra"
      },
      "outputs": [],
      "source": [
        "!pip install dlplan==0.2.19 xdot"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load example data used in the notebook\n",
        "import requests\n",
        "domain_data = requests.get(\"https://raw.githubusercontent.com/rleap-project/dlplan/main/colab/delivery/domain.pddl\")\n",
        "instance_data = requests.get(\"https://raw.githubusercontent.com/rleap-project/dlplan/main/colab/delivery/instance_1_2.pddl\")\n",
        "with open(\"/content/domain.pddl\", \"w\") as file:\n",
        "  file.write(domain_data.text)\n",
        "with open(\"/content/instance.pddl\", \"w\") as file:\n",
        "  file.write(instance_data.text)"
      ],
      "metadata": {
        "id": "Kmao9lO9xIUS"
      },
      "execution_count": 48,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NAWoakDjXUny"
      },
      "source": [
        "## 1. Expand and Visualize First-order State Spaces (state_space component)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "id": "WXUXyfGvaY4P"
      },
      "outputs": [],
      "source": [
        "from dlplan.state_space import generate_state_space\n",
        "\n",
        "# 1. Generate state space of Delivery instance with 1 package p and 2 locations a,b\n",
        "state_space = generate_state_space(\n",
        "    \"/content/domain.pddl\",\n",
        "    \"/content/instance.pddl\",\n",
        "    index=0).state_space"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4jXVjm2fWyi7"
      },
      "outputs": [],
      "source": [
        "# 2. Visualize state space\n",
        "from IPython.display import Image\n",
        "state_space_dot = state_space.to_dot(1)\n",
        "with open(\"graph.dot\", \"w\") as file:\n",
        "    file.write(state_space_dot)\n",
        "!dot -Tpng graph.dot > graph.png\n",
        "display(Image('graph.png'))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d7vqg0OJoOOL"
      },
      "source": [
        "## 2. Evaluate Description Logics State Features (core component)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "id": "CDpQALB7kWuz"
      },
      "outputs": [],
      "source": [
        "from dlplan.core import SyntacticElementFactory\n",
        "\n",
        "# 1. Parse two features\n",
        "instance_info = state_space.get_instance_info()\n",
        "vocabulary_info = instance_info.get_vocabulary_info()\n",
        "factory = SyntacticElementFactory(vocabulary_info)\n",
        "undelivered_packages = factory.parse_concept(\n",
        "    \"c_and(c_not(c_equal(r_primitive(at,0,1),r_primitive(at_g,0,1))),c_primitive(package,0))\")\n",
        "num_undelivered_packages = factory.parse_numerical(\n",
        "    \"n_count(c_and(c_not(c_equal(r_primitive(at,0,1),r_primitive(at_g,0,1))),c_primitive(package,0)))\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H-WEt5S3WrNT"
      },
      "outputs": [],
      "source": [
        "# 2. Evaluate the features\n",
        "initial_state = state_space.get_states()[state_space.get_initial_state_index()]\n",
        "print(\"Undelivered packages in initial state:\",\n",
        "      undelivered_packages.evaluate(initial_state))\n",
        "print(\"Number of undelivered packages in initial states:\",\n",
        "      num_undelivered_packages.evaluate(initial_state))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "38IZnr4vtX0Q"
      },
      "source": [
        "# 3. Generate Description Logics State Features (generator component)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "41uWVTinlPf2"
      },
      "outputs": [],
      "source": [
        "from dlplan.generator import generate_features\n",
        "\n",
        "# 1. Generate and print feature representations\n",
        "states = state_space.get_states().values()\n",
        "feature_reprs = generate_features(factory, list(states), feature_limit=400)\n",
        "print(\"\\n\".join(feature_reprs))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "id": "m72sg6foUTC-"
      },
      "outputs": [],
      "source": [
        "# 2. Analyze the generated features\n",
        "# Concept feature was not pruned\n",
        "assert repr(undelivered_packages) in feature_reprs\n",
        "# Numerical feature was pruned\n",
        "assert repr(num_undelivered_packages) not in feature_reprs\n",
        "# Reason for pruning\n",
        "feature = factory.parse_numerical(\"n_concept_distance(c_primitive(package,0),r_primitive(at_g,0,1),c_equal(r_primitive(at,0,1),r_primitive(at_g,0,1)))\")\n",
        "assert [num_undelivered_packages.evaluate(state) for state in states] == [feature.evaluate(state) for state in states] and \\\n",
        "        num_undelivered_packages.compute_complexity() >= feature.compute_complexity()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 4. Example Application: General Policies (policy component)\n"
      ],
      "metadata": {
        "id": "-1seKDcK8-I7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from dlplan.policy import PolicyReader, PolicyBuilder\n",
        "\n",
        "# Visualize state space\n",
        "display(Image('graph.png'))\n",
        "\n",
        "# Parse policy from text\n",
        "builder = PolicyBuilder()\n",
        "policy = PolicyReader().read(\n",
        "    \"\"\"\n",
        "    (:policy\\n\n",
        "    (:booleans\n",
        "        (0 \"b_empty(r_primitive(carrying,0,1))\")\n",
        "    )\n",
        "    (:numericals\n",
        "        (0 \"n_count(r_and(r_primitive(at,0,1),r_primitive(at_g,0,1)))\")\n",
        "        (1 \"n_concept_distance(c_some(r_inverse(r_primitive(at,0,1)),c_primitive(truck,0)),r_primitive(adjacent,0,1),c_some(r_inverse(r_primitive(at_g,0,1)),c_top))\")\n",
        "        (2 \"n_concept_distance(c_some(r_inverse(r_primitive(at,0,1)),c_primitive(truck,0)),r_primitive(adjacent,0,1),c_and(c_all(r_inverse(r_primitive(at_g,0,1)),c_bot),c_some(r_inverse(r_primitive(at,0,1)),c_primitive(package,0))))\")\n",
        "    )\n",
        "    (:rule (:conditions (:c_b_pos 0) (:c_n_gt 2)) (:effects (:e_b_bot 0) (:e_n_bot 0) (:e_n_dec 2)))\n",
        "    (:rule (:conditions (:c_b_pos 0) (:c_n_eq 2)) (:effects (:e_b_neg 0) (:e_n_bot 0) (:e_n_bot 1)))\n",
        "    (:rule (:conditions (:c_b_neg 0) (:c_n_gt 1)) (:effects (:e_b_bot 0) (:e_n_bot 0) (:e_n_dec 1)))\n",
        "    (:rule (:conditions (:c_b_neg 0) (:c_n_eq 1)) (:effects (:e_b_pos 0) (:e_n_dec 0) (:e_n_bot 1)))\n",
        "    )\n",
        "    \"\"\",\n",
        "    builder, factory)\n",
        "\n",
        "# Classify transitions (s,s') into ``Good'' or ``Bad''\n",
        "# (state 0, state 1): move t to cell containing undelivered package p when not holding a package is ``Good''\n",
        "assert policy.evaluate(state_space.get_states()[0], state_space.get_states()[1])\n",
        "# (state 1, state 0): move t *** away *** from cell containing undelivered package p when not holding a package is ``Bad''\n",
        "assert not policy.evaluate(state_space.get_states()[1], state_space.get_states()[0])"
      ],
      "metadata": {
        "id": "Ek5Nlzsq9VWi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 5. Integration into Planning Systems"
      ],
      "metadata": {
        "id": "2vs_Q1GQ6wjO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from dlplan.core import VocabularyInfo, InstanceInfo, State\n",
        "\n",
        "# Initialize state language\n",
        "vocabulary = VocabularyInfo()\n",
        "predicate_0 = vocabulary.add_predicate(\"predicate\", 2)\n",
        "predicate_1 = vocabulary.add_predicate(\"predicate_g\", 2)\n",
        "\n",
        "# Initialize specific instance\n",
        "instance = InstanceInfo(vocabulary, index=0)\n",
        "atom_0 = instance.add_atom(\"predicate\", [\"object_1\", \"object_2\"])\n",
        "atom_1 = instance.add_static_atom(\"predicate_g\", [\"object_2\", \"object_1\"])\n",
        "\n",
        "# Map planner state to DLPlan state\n",
        "state = State(instance, [atom_0], index=0)\n",
        "\n",
        "print(repr(vocabulary))\n",
        "print(repr(instance))\n",
        "print(repr(state))"
      ],
      "metadata": {
        "id": "Qw6WLG2i64qn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "2Ob4ttA0vWY7"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}