19_NimbusIdeal.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nimbus ideal vs. payoff ideal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is some issues that cause the results attained by Nimbus method to be higher than the ideal values attained by calculating the payoff table for the clusters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from interactiveBoreal import *\n",
    "import gradutil\n",
    "from BorealWeights import BorealWeightedProblem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "kehys = ReferenceFrame()\n",
    "nclust = 600\n",
    "kehys.cluster(nclust=nclust, seedn=6, outdata=kehys.x_stack)\n",
    "data = kehys.centers\n",
    "nvar = len(kehys.x_norm)\n",
    "weights_norm = kehys.weights/nvar\n",
    "ideal = kehys.ideal\n",
    "nadir = kehys.nadir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "solver_name = 'cplex'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we try to calculate ideal and possible nadir values for all the objectives using nimbus scalarization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "nimbus_ref = np.array([[kehys.ideal[0], kehys.nadir[1], kehys.nadir[2], kehys.nadir[3]],\n",
    "                       [kehys.nadir[0], kehys.ideal[1], kehys.nadir[2], kehys.nadir[3]],\n",
    "                       [kehys.nadir[0], kehys.nadir[1], kehys.ideal[2], kehys.nadir[3]],\n",
    "                       [kehys.nadir[0], kehys.nadir[1], kehys.nadir[2], kehys.ideal[3]]])\n",
    "stay = np.array([], dtype=int)\n",
    "detoriate = np.array([], dtype=int)\n",
    "nimbus_res_cluster = []\n",
    "nimbus_res_orig = []\n",
    "nimbus_problems = []\n",
    "ide = kehys.normalize_ref(kehys.ideal)\n",
    "nad = kehys.normalize_ref(kehys.nadir)\n",
    "for i in range(len(nimbus_ref)):\n",
    "    minmax = np.array([i], dtype=int)\n",
    "    ref = kehys.normalize_ref(nimbus_ref[i])\n",
    "    nimbus_problems.append(NIMBUS(ide, nad, ref, kehys.centers, \n",
    "                                  minmax, stay, detoriate, np.array([0,0,0,0]), \n",
    "                                  weights=kehys.weights, nvar=nvar))\n",
    "    nimbus_solver = Solver(nimbus_problems[i].model, solver=solver_name)\n",
    "    res = nimbus_solver.solve() \n",
    "    nimbus_res_cluster.append([gradutil.model_to_real_values(kehys.x_stack[:,:,j], \n",
    "                                                             nimbus_problems[i].model, \n",
    "                                                             kehys.xtoc) \n",
    "                               for j in range(len(nimbus_ref))])\n",
    "    nimbus_res_orig.append([gradutil.cluster_to_value(kehys.x_stack[:,:,j], \n",
    "                                                      gradutil.res_to_list(nimbus_problems[i].model), \n",
    "                                                      kehys.weights)\n",
    "                            for j in range(len(nimbus_ref))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in nimbus_res_cluster:\n",
    "     print(['{:12.2f}'.format(value) for value in k])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, the greatest values column wise are at the diagonal. As NIMBUS uses exactly these in its operations this seems very good!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "for k in nimbus_res_orig:\n",
    "    print(['{:12.2f}'.format(value) for value in k])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now when we print the original variable values, we see that the biggest values are not anymore at the diagonal. This was expected so no need to worry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ideal of the attained results:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "nimbus_ideal = np.max(nimbus_res_cluster, axis=0)\n",
    "print(['{:12.2f}'.format(value) for value in nimbus_ideal])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the nadir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "nimbus_nadir = np.min(nimbus_res_cluster, axis=0)\n",
    "print(['{:12.2f}'.format(value) for value in nimbus_nadir])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(['{:12.2f}'.format(value) for value in kehys.ideal])\n",
    "print(['{:12.2f}'.format(value) for value in kehys.nadir])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The differences are then not so big and so NIMBUS seems to work!"
   ]
  }
 ],
 "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
}