run_asprin_dreyers_experiments.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ASPrin experiments with the Dreyers dataset\n",
    "\n",
    "To be used the `asprin` optimiser tool must be installed, and the easiest way to do it is via its [Anaconda package](https://anaconda.org/potassco/asprin)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *Dreyers* dataset is available from the [tslaats/EventLogs](https://github.com/tslaats/EventLogs/tree/10db2d389b8190651bda5be578a7dad8123df384) repository. The [data/dreyers/fetch_dreyers_dataset.py](data/dreyers/fetch_dreyers_dataset.py) script downloads a local copy of the dataset and splits it in positive/negative log files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run data/dreyers/fetch_dreyers_dataset.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "import negdis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `cerv` dataset as an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_DIR = Path('data', 'dreyers')\n",
    "\n",
    "POS_LOG_PATH = DATA_DIR.joinpath('Dreyers Foundation.pos.xes')\n",
    "NEG_LOG_PATH = DATA_DIR.joinpath('Dreyers Foundation.neg.xes')\n",
    "\n",
    "DECLARE_RULES_PATH = DATA_DIR.joinpath('declare_rules.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Input files can also be created on the fly, in this case the set of Declare patterns are defined directly in this notebook as a string. See below on how to use it (note the use of `r''` Python construct to avoid string interpolation). Strings can be passed as file arguments by using the `negdis.as_file` context function (see below for its usage)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DECLARE_PATTERNS_STR = r'''\n",
    "Absence(a):[^a]*\n",
    "Absence2(a):[^a]*(a)?[^a]*\n",
    "Absence3(a):[^a]*((a)?[^a]*){2}\n",
    "AlternatePrecedence(a,b):[^b]*(a[^b]*b[^b]*)*[^b]*\n",
    "AlternateResponse(a,b):[^a]*(a[^a]*b[^a]*)*[^a]*\n",
    "AlternateSuccession(a,b):[^ab]*(a[^ab]*b[^ab]*)*[^ab]*\n",
    "ChainPrecedence(a,b):[^b]*(ab[^b]*)*[^b]*\n",
    "ChainResponse(a,b):[^a]*(ab[^a]*)*[^a]*\n",
    "ChainSuccession(a,b):[^ab]*(ab[^ab]*)*[^ab]*\n",
    "Choice(a,b):.*[ab].*\n",
    "CoExistence(a,b):[^ab]*((a.*b.*)|(b.*a.*))*[^ab]*\n",
    "End(a):.*a\n",
    "Exactly1(a):[^a]*a[^a]*\n",
    "Exactly2(a):[^a]*(a[^a]*){2}\n",
    "ExclusiveChoice(a,b):([^b]*a[^b]*)|([^a]*b[^a]*)\n",
    "Existence(a):.*a.*\n",
    "Existence2(a):.*(a.*){2}\n",
    "Existence3(a):.*(a.*){3}\n",
    "Init(a):a.*\n",
    "NotChainSuccession(a,b):[^a]*(aa*[^ab][^a]*)*([^a]*|aa*)\n",
    "NotCoExistence(a,b):[^ab]*((a[^b]*)|(b[^a]*))?\n",
    "NotSuccession(a,b):[^a]*(a[^b]*)*[^ab]*\n",
    "Precedence(a,b):[^b]*(a.*b)*[^b]*\n",
    "RespondedExistence(a,b):[^a]*((a.*b.*)|(b.*a.*))*[^a]*\n",
    "Response(a,b):[^a]*(a.*b)*[^a]*\n",
    "Succession(a,b):[^ab]*(a.*b)*[^ab]*\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choices generation stage\n",
    "\n",
    "Run `negdis` to generate the candidates, output is stored in a temporary file. *Negdis* executable is wrapped in the `negdis.Negdis` class; its `default` method returns an object using the file in the `dist` directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "negdis_exe = negdis.Negdis.default()\n",
    "print(negdis_exe.version())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import atexit\n",
    "import tempfile\n",
    "\n",
    "out_dir = Path(tempfile.mkdtemp())\n",
    "\n",
    "@atexit.register\n",
    "def cleanup():\n",
    "    import shutil\n",
    "    # remove the temporary directory on termination\n",
    "    shutil.rmtree(out_dir)\n",
    "\n",
    "\n",
    "# output on a temporary file\n",
    "CHOICES_PATH = Path(out_dir).joinpath('choices.json')\n",
    "\n",
    "with negdis.as_file(DECLARE_PATTERNS_STR) as patterns:\n",
    "    negdis_exe.discover(POS_LOG_PATH, NEG_LOG_PATH, patterns, CHOICES_PATH)\n",
    "\n",
    "print(f'Choices written to: {CHOICES_PATH}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shows top constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "negdis.count_choices(CHOICES_PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Optimisation stage\n",
    "\n",
    "The configuration of the solver can be customised using the class `negdis.SolverConf`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "The configuration of the solver is customised using the class `negdis.SolverConf`:\n",
    "\n",
    "```python\n",
    "negdis.SolverConf.from_dict({\n",
    "    'id': 'asprinminclos',\n",
    "    'inputs': ['guess.lp'],\n",
    "    'args': ['--quiet=1'],\n",
    "    'docstring': 'Minimal cardinality wrt the closure constraints, and selected constraints for ties',\n",
    "    'solver': 'asprin',\n",
    "    'template': asprin_opt_code\n",
    "})\n",
    "```\n",
    "\n",
    "Actual ASP program is generated by concatenating the content of files in `inputs` with the string `template`, and then replacing the values of `${...}` macros. Default macros are:\n",
    "\n",
    "- `${predicate_action}(action)`: predicate with all the actions\n",
    "- `${predicate_choice}(trace, constraint)`: the candidates for each trace\n",
    "- `${predicate_constraint_action}(constraint, action)`: actions which are argument of the constraint\n",
    "- `${predicate_constraint_name}(constraint, name, arity)`: name of the pattern of the constraint\n",
    "- `${predicate_constraint}(constraint)`: all constraints that can be generated by the rules, and the candidates\n",
    "- `${predicate_holds}(constraint)`: constraints deduced by the rules starting from the selected\n",
    "- `${predicate_selected}(constraint)`: constraints selected for a specific model\n",
    "\n",
    "each `constraint` is encoded as the function term `${functor_declare}(pattern, actions+)`. All these predicates except `${predicate_selected}` and `${predicate_holds}` are completely evaluated during grounding, so they can be used as *domain predicates*. \n",
    "\n",
    "New macros can be defined (or the default value replaced) by means of a dictionary that can be passed as an argument.\n",
    "\n",
    "If the file names in `inputs` are not absolute paths, they'll be searched in the current directory followed by the directory of the Python package `negdis.templates`; e.g. the `guess.lp` is fetched from `negdis/templates/guess.lp` within one of the directories in `sys.path`. The location of the `negdis.templates` module directory can be verified using the following code:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ASP program generated by a configuration (without the parts due to the specific problem) can be inspected using the `SolverConf.program` method, which accepts an *optional* argument with the mapping for the macros."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To show the original ASP program without the variable substitution the `SolverConf.program` method takes an optional `eval` argument which can be set to `False`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All default solver configurations are available via the `negdis.configurations` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `negdis.optimise_choices` function runs the optimisation code (see below for examples). The function takes an optional `mapping` argument which is used to expand the program.\n",
    "\n",
    "Note that *asprin* solver doesn't support JSON output, so for the time being only the raw solver output is printed and no statistics are reported."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The configuration below uses the solver to optimise by preferring models that include a specific action. The name can be selected by setting the value for the `good_action` macro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt_code = r'''\n",
    "%%%%%%%%%%%%%%\n",
    "%%%%%%% asprin optimisation statements\n",
    "\n",
    "in_model(A) :- ${predicate_selected}(C), ${predicate_constraint_action}(C, A).\n",
    "\n",
    "nice_model :- in_model(${good_action}).\n",
    "not_nice_model :- not nice_model. \n",
    "\n",
    "#preference(p1,aso){ nice_model >> not_nice_model }.\n",
    "#preference(p2,subset){ ${predicate_holds}(C) : ${predicate_constraint}(C) }.\n",
    "\n",
    "#preference(p10,lexico){ 1::**p2; 2::**p1 }.\n",
    "#optimize(p10).\n",
    "\n",
    "#show in_model/1.\n",
    "#show nice_model/0.\n",
    "#show not_nice_model/0.\n",
    "'''\n",
    "\n",
    "opt_mode_nice = negdis.SolverConf.from_dict({\n",
    "    'id': 'nice_models',\n",
    "    'inputs': ['guess.lp'],\n",
    "    'args': ['--quiet=1'],\n",
    "    'docstring': 'Models without a specific constraint, and (subset) closure for ties',\n",
    "    'solver': 'asprin',\n",
    "    'template': opt_code\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following two cells below preferred models are those with *Architect Review* and *Indledende afvisning* (i.e. *Initial rejection*) respectively. In both cases the solver is able to find models with the preferred action."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "negdis.optimise_choices(CHOICES_PATH, opt_mode_nice, DECLARE_RULES_PATH, models=5, timeout=60, mapping={'good_action': '\"Architect Review\"'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "negdis.optimise_choices(CHOICES_PATH, opt_mode_nice, DECLARE_RULES_PATH, models=5, timeout=60, mapping={'good_action': '\"Indledende afvisning\"'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Cleanup temporary files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shutil\n",
    "\n",
    "shutil.rmtree(str(out_dir))"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "c5f02f6ff8ceb2d172dcd8fd4cf9ff10030db4e319c4ae443d3135ea5dc38f6e"
  },
  "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}