13_ScalarizationTesting.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scalarization testing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ASF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now there is standard Achievement Scalarizing Function implemented, so let's use it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ASF import ASF\n",
    "from gradutil import *\n",
    "from pyomo.opt import SolverFactory\n",
    "import logging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "logger = logging.getLogger('pyomo.opt')\n",
    "logger.setLevel(logging.ERROR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "revenue, carbon, deadwood, ha = init_boreal()\n",
    "ide = ideal(False)\n",
    "nad = nadir(False)\n",
    "opt = SolverFactory('cplex')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ind = 100\n",
    "x = np.dstack((new_normalize(nan_to_bau(revenue[:ind]).values),\n",
    "               new_normalize(nan_to_bau(carbon[:ind]).values),\n",
    "               new_normalize(nan_to_bau(deadwood[:ind]).values),\n",
    "               new_normalize(nan_to_bau(ha[:ind]).values)))\n",
    "X = np.dstack((nan_to_bau(revenue[:ind]).values,\n",
    "               nan_to_bau(carbon[:ind]).values,\n",
    "               nan_to_bau(deadwood[:ind]).values,\n",
    "               nan_to_bau(ha[:ind]).values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "ref = np.array((ide[0], 0, 0, 0))\n",
    "asf = ASF(ide, nad, ref, X)\n",
    "opt.solve(asf.model)\n",
    "print(np.sum(values_to_list(asf.model, X), axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "ref = np.array((0, ide[1], 0, 0))\n",
    "asf = ASF(ide, nad, ref, X)\n",
    "opt.solve(asf.model)\n",
    "print(np.sum(values_to_list(asf.model,X), axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "ref = np.array((0, 0, ide[2], 0))\n",
    "asf = ASF(ide, nad, ref, X)\n",
    "opt.solve(asf.model)\n",
    "print(np.sum(values_to_list(asf.model, X), axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Timing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ASF function seems to work properly so no problem. Let's see how much time does it take when running in full speed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "n_revenue = nan_to_bau(revenue)\n",
    "n_carbon = nan_to_bau(carbon)\n",
    "n_deadwood = nan_to_bau(deadwood)\n",
    "n_ha= nan_to_bau(ha)\n",
    "x_full = np.dstack((new_normalize(n_revenue.values),\n",
    "                    new_normalize(n_carbon.values),\n",
    "                    new_normalize(n_deadwood.values),\n",
    "                    new_normalize(n_ha.values)))\n",
    "X_full = np.dstack((n_revenue.values,\n",
    "                    n_carbon.values,\n",
    "                    n_deadwood.values,\n",
    "                    n_ha.values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from interactiveBoreal import ReferenceFrame as rf\n",
    "kehys = rf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "extreme1 = np.array([2.49578348e+08, 2.82311284e+06, 8.17647344e+04, 1.20426387e+04])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "extreme2 = np.array([8.73864412e+07, 4.42779337e+06, 2.02829180e+05, 1.81784694e+04])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "extreme3 = np.array([1.13414218e+08, 4.19114380e+06, 2.12316813e+05, 1.90109867e+04])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "extreme4 = np.array([1.44157068e+08, 3.91362164e+06, 2.05681872e+05, 1.99452821e+04])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "asf_fullx1 = ASF(ide, nad, extreme1, X_full)\n",
    "opt.solve(asf_fullx1.model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution1 = np.sum(values_to_list(asf_fullx1.model,X_full), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "asf_fullx2 = ASF(ide, nad, extreme2, X_full)\n",
    "opt.solve(asf_fullx2.model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution2 = np.sum(values_to_list(asf_fullx2.model,X_full), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "asf_fullx3 = ASF(ide, nad, extreme3, X_full)\n",
    "opt.solve(asf_fullx3.model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution3 = np.sum(values_to_list(asf_fullx3.model,X_full), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "asf_fullx4 = ASF(ide, nad, extreme4, X_full)\n",
    "opt.solve(asf_fullx4.model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution4 = np.sum(values_to_list(asf_fullx4.model,X_full), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "kyle_ref = np.array([2381.33344539, 59.3622342119, 2.87427595511, 0.275386287914])*68700"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "asf_fullx5 = ASF(ide, nad, kyle_ref, X_full)\n",
    "opt.solve(asf_fullx5.model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "kyle_solutions = np.sum(values_to_list(asf_fullx5.model,X_full), axis=0)/68700"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "kyle_solutions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for e,s in zip([extreme1,extreme2,extreme3,extreme4], [solution1,solution2,solution3,solution4]):\n",
    "    '''if (e<s).all():\n",
    "        print('Dominated')\n",
    "    elif (s<e).all():\n",
    "        print('Dominating')\n",
    "    else:\n",
    "        print('Non-dominating')'''\n",
    "    print('{} & {} \\\\\\\\'.format('Surrogate Front', ' & '.join(['{:,.0f}'.format(value).replace(',', ' ') for value in e])))\n",
    "    print('{} & {} \\\\\\\\'.format('Real Front', ' & '.join(['{:,.0f}'.format(value).replace(',', ' ') for value in s])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparing scalarizations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have ASF, STOM ja GUESS scalarizations available. Lets compare them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ref_test = np.array((2,3,4,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "asf = ASF(ide, nad, ref_test, x, scalarization='ASF')\n",
    "opt.solve(asf.model)\n",
    "print(np.sum(values_to_list(asf.model, X), axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stom = ASF(ide, nad, ref_test, x, scalarization='STOM')\n",
    "opt.solve(stom.model)\n",
    "print(np.sum(values_to_list(stom.model, X), axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "guess = ASF(ide, nad, ref_test, x, scalarization='GUESS')\n",
    "opt.solve(guess.model)\n",
    "print(np.sum(values_to_list(guess.model, X), axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There truly is differences between results, so it seems that scalarization functions are working properly (?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    from time import time\n",
    "    from datetime import timedelta\n",
    "    import logging\n",
    "    import interactiveBoreal as ib\n",
    "\n",
    "    logging.basicConfig(level=logging.INFO)\n",
    "    logger = logging.getLogger(__name__)\n",
    "    start = time()\n",
    "    logger.info('Started')\n",
    "    logger.info('Initializing...')\n",
    "    kehys = ib.ReferenceFrame()\n",
    "    logger.info('Initialized. Time since start {}'.\n",
    "                format(timedelta(seconds=int(time()-start))))\n",
    "    nclust = 600\n",
    "    seedn = 6\n",
    "    '''\n",
    "    logger.info('Clustering...')\n",
    "    import simplejson as json\n",
    "    with open('clusterings/new_300.json', 'r') as file:\n",
    "        clustering = json.load(file)\n",
    "    kehys.xtoc = np.array(clustering['5']['xtoc'])\n",
    "    kehys.weights = np.array([sum(kehys.xtoc == i)\n",
    "                              for i in range(nclust)\n",
    "                              if sum(kehys.xtoc == i) > 0])\n",
    "    \n",
    "    kehys.cluster(nclust=nclust, seedn=seedn)\n",
    "    logger.info('Clustered. Time since start {}'.\n",
    "                format(timedelta(seconds=int(time()-start))))\n",
    "    '''\n",
    "    kyle1 = np.array((1858.0, 58.69, 2.651, 0.27))\n",
    "    init_ref = kyle1 * 68700\n",
    "    # init_ref = np.array((0, 0, kehys.ideal[2], 0))\n",
    "    ref = kehys.normalize_ref(init_ref)\n",
    "\n",
    "    logger.info('Using ideal: {} and nadir: {}'.\n",
    "                format(kehys.ideal, kehys.nadir))\n",
    "    logger.info('Reference point: {}.'.format(init_ref))\n",
    "    logger.info('Solving...')\n",
    "\n",
    "    '''\n",
    "    data = kehys.centers\n",
    "    nvar = len(kehys.x_norm)\n",
    "    weights = kehys.weights/nvar\n",
    "    '''\n",
    "    data = kehys.x_norm_stack\n",
    "    nvar = len(kehys.x_norm)\n",
    "    weights = np.ones(nvar)/nvar\n",
    "\n",
    "    ''' Because everything is scaled, scale these too'''\n",
    "    ideal = kehys.normalize_ref(kehys.ideal)\n",
    "    nadir = kehys.normalize_ref(kehys.nadir)\n",
    "\n",
    "    solver_name = 'cplex'\n",
    "\n",
    "    asf = ASF(ideal, nadir, ref, data, weights=weights, nvar=nvar,\n",
    "              scalarization='asf')\n",
    "\n",
    "    asf_solver = ib.Solver(asf.model, solver=solver_name)\n",
    "    asf_solver.solve()\n",
    "    logger.info('Solved')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "asf_values = kehys.values(kehys.x_stack, weights, model=asf.model)\n",
    "asf_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "asf_values/68700"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "init_ref"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kehys.ideal, init_ref, kehys.nadir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ideal, ref, nadir\n"
   ]
  }
 ],
 "metadata": {
  "git": {
   "suppress_outputs": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}