Pareto Solution Generation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import cPickle as pickle\n",
    "from multiprocessing import Pool\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import dynamic_benchmark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"\"\" Calculate the Pareto set solution\n",
    "    \n",
    "    INPUT:\n",
    "        offset: 0 implies this is the global Pareto set.\n",
    "        x1: float value to indicate the value of the first parameter\n",
    "        t: time variable\n",
    "        \n",
    "    OUTPUT:\n",
    "        output: Pareto optimal point (x1, ...)\n",
    "\"\"\"\n",
    "def pareto_set_2obj(offset, x1, t):\n",
    "    output = [x1]\n",
    "    output.extend([offset + np.sin(0.5*np.pi*(t-x1)) for e in range(20)])\n",
    "    return output\n",
    "\n",
    "def pareto_set_3obj(offset, x1, x2, t):\n",
    "    output = [x1, x2]\n",
    "    output.extend([offset + np.sin(0.5*np.pi*(t-x1)) for e in range(20)])\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"\"\" Efficient Pareto Filtering method. The code is obtained from: \n",
    "    http://code.activestate.com/recipes/578287-multidimensional-pareto-front\n",
    "\"\"\"\n",
    "def dominates(row, candidate_row):\n",
    "    return sum([row[x] <= candidate_row[x] for x in range(len(row))]) == len(row)    \n",
    "\n",
    "\n",
    "def pareto_filter(input_points, dominates=dominates):\n",
    "    candidate_rowNr  = 0\n",
    "    pareto_points    = set()\n",
    "    dominated_points = set()\n",
    "    while True:\n",
    "        candidate_row = input_points[candidate_rowNr]\n",
    "        input_points.remove(candidate_row)\n",
    "        rowNr = 0\n",
    "        non_dominated = True\n",
    "        while len(input_points) != 0 and rowNr < len(input_points):\n",
    "            row = input_points[rowNr]\n",
    "            if dominates(candidate_row, row):\n",
    "                # If it is worse on all features remove the row from the array\n",
    "                input_points.remove(row)\n",
    "                dominated_points.add(tuple(row))\n",
    "            elif dominates(row, candidate_row):\n",
    "                non_dominated = False\n",
    "                dominated_points.add(tuple(candidate_row))\n",
    "                rowNr += 1\n",
    "            else:\n",
    "                rowNr += 1\n",
    "\n",
    "        if non_dominated:\n",
    "            # add the non-dominated point to the Pareto frontier\n",
    "            pareto_points.add(tuple(candidate_row))\n",
    "\n",
    "        if len(input_points) == 0:\n",
    "            break\n",
    "    return pareto_points, dominated_points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# create Pareto set for 2-objective problem\n",
    "ps_dict_2obj = dict()\n",
    "\n",
    "for t in range(41):\n",
    "    time_value = 0.1*t\n",
    "    x1 = np.linspace(0, 1, 1000)\n",
    "    x_array = list([pareto_set_2obj(0, _x1, time_value) for _x1 in x1])\n",
    "    ps_dict_2obj[str(time_value)] = x_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# create Pareto set for 3-objective problem\n",
    "ps_dict_3obj = dict()\n",
    "\n",
    "for t in range(41):\n",
    "    time_value = 0.1*t\n",
    "    x1 = np.linspace(0, 1, 100)\n",
    "    x2 = np.linspace(0, 1, 100)\n",
    "    x1, x2 = np.meshgrid(x1, x2)\n",
    "    x1 = x1.reshape(-1)\n",
    "    x2 = x2.reshape(-1)\n",
    "    x_array = list([pareto_set_3obj(0, _x1, _x2, time_value) for _x1, _x2 in zip(x1, x2)])\n",
    "    ps_dict_3obj[str(time_value)] = x_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function to create Pareto front/set for each problem (GTA1-GTA8):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# create Pareto front for two-objective problem\n",
    "def pareto_points(args):\n",
    "    ps_dict, problem = args\n",
    "    func = getattr(dynamic_benchmark, problem)\n",
    "    pf_dict = dict()\n",
    "\n",
    "    for time_value in ps_dict:\n",
    "        obj_array = list([func(x, float(time_value)) for x in ps_dict[time_value]])\n",
    "        pf, _ = pareto_filter(obj_array)\n",
    "        pf = set(pf)\n",
    "        ps = [x for x in ps_dict[time_value] if tuple(func(x, float(time_value))) in pf]\n",
    "        pf_dict[time_value] = (pf, ps)\n",
    "    \n",
    "    with open(\"pareto/{}.p\".format(problem), \"wb\") as fhandle:\n",
    "        pickle.dump(pf_dict, fhandle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionary to store the optimal solutions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "input_list = [(ps_dict_2obj, \"DB{}a\".format(i+1)) for i in range(8)]\n",
    "input_list += [(ps_dict_3obj, \"DB{}a\".format(i+9)) for i in range(4)]\n",
    "\n",
    "p = Pool(8)\n",
    "p.map(pareto_points, input_list);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}