Project-Class-module-github-MOO.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyomo.environ import *\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import random \n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "req= [(7, 1),(8, 1),(7, 2),(7, 3),(7, 4),(15, 6),(13, 8),(15, 8)\n",
    ",(18, 9),(19, 9),(20, 9),(16, 10),(17, 10),(19, 12),(19, 14),(21, 16),(22, 16),(24, 16),(21, 17)\n",
    ",(25, 17),(26, 17),(28, 17),(23, 18),(26, 18),(27, 19),(28, 19),(25, 20),(27, 20),(32, 21),(29, 22)\n",
    ",(30, 22),(32, 22),(29, 23),(32, 23),(29, 24),(30, 24)\n",
    ",(31, 24),(29, 25),(32, 25),(31, 26),(29, 27),(30, 27),(31, 27),(30, 28),(32, 28)\n",
    ",(33, 29),(34, 29),(35, 29),(33, 31),(36, 31),(37, 31),(36, 32),(41, 33),(44, 33),(45, 33),(39, 34),(40, 35),(39, 36),(42, 37),(44, 37),(45, 37)\n",
    ",(40, 38),(41, 38),(43, 38),(44, 38),(47, 39),(46, 41),(47, 41),(47, 42),(49, 47)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_courses = 50\n",
    "n_periods = 10\n",
    "load_per_period_lb = 2\n",
    "load_per_period_ub = 100\n",
    "courses_per_period_lb = 2\n",
    "courses_per_period_ub = 10\n",
    "course_load = [3, 7, 6, 1, 3, 2, 5, 1, 7, 10, 4, 9, 9, 10, 6, 8, 4, 1, 10, 9, 8, 5, 10, 5, 9, 4, 1, 3, 3, 3, 2, 8, 9, 9, 8, 4, 10, 2, 4, 8, 1, 7, 7, 1, 8, 2, 10, 4, 4, 9, ]\n",
    "len(course_load)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = AbstractModel()\n",
    "model.i = RangeSet(n_courses)\n",
    "model.t = RangeSet(n_periods)\n",
    "model.dependency = Set(initialize=req)\n",
    "model.assign = Var(model.i, model.t, initialize = 0, within=Binary)\n",
    "model.maxload = Var(bounds=(0,100), initialize = 0, within=Reals)\n",
    "model.w1 = Param(mutable=True, initialize =1)\n",
    "model.w2 = Param(mutable=True, initialize =0)\n",
    "model.limit = Param(mutable=True, initialize =10000)\n",
    "\n",
    "\n",
    "def rule_load(model,i):\n",
    "    return course_load[i-1]\n",
    "model.L = Param(model.i, initialize = rule_load)\n",
    "\n",
    "def Rule_C0(model,i1,i2 ):\n",
    "    return sum(tt*model.assign[i1,tt] for tt in model.t) <= sum(tt*model.assign[i2,tt] for tt in model.t)\n",
    "model.C0=Constraint(model.dependency, rule=Rule_C0)\n",
    "\n",
    "def Rule_C1(model,i):\n",
    "    return sum(model.assign[i,t] for t in model.t) == 1\n",
    "model.C1=Constraint(model.i, rule=Rule_C1)\n",
    "\n",
    "def Rule_C2A(model,t):\n",
    "    return sum(model.assign[i,t] for i in model.i) <= courses_per_period_ub\n",
    "model.C2A=Constraint(model.t, rule=Rule_C2A)\n",
    "\n",
    "def Rule_C2AL(model,t):\n",
    "    return sum(model.L[i]* model.assign[i,t] for i in model.i) <= load_per_period_ub\n",
    "model.C2AL=Constraint(model.t, rule=Rule_C2AL)\n",
    "\n",
    "def Rule_C2B(model,t):\n",
    "    return sum(model.assign[i,t] for i in model.i) >= courses_per_period_lb\n",
    "model.C2B=Constraint(model.t, rule=Rule_C2B)\n",
    "\n",
    "def Rule_C2BL(model,t):\n",
    "    return sum(model.L[i]* model.assign[i,t] for i in model.i) >= load_per_period_lb\n",
    "model.C2BL=Constraint(model.t, rule=Rule_C2BL)\n",
    "\n",
    "def Rule_C3(model,t):\n",
    "    return sum(model.L[i]* model.assign[i,t] for i in model.i) <= model.maxload\n",
    "model.C3=Constraint(model.t, rule=Rule_C3)\n",
    "\n",
    "\n",
    "def Rule_C4(model):\n",
    "    return sum(t*model.L[i]* model.assign[i,t] for i in model.i for t in model.t) <= model.limit\n",
    "model.C4=Constraint( rule=Rule_C4)\n",
    "\n",
    "\n",
    "def rule_OF(model):\n",
    "    return model.w1*model.maxload + model.w2*sum(t*model.L[i]* model.assign[i,t] for i in model.i for t in model.t) #OF2 \n",
    "\n",
    "model.obj1 = Objective(rule=rule_OF, sense=minimize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt = SolverFactory('cbc')\n",
    "instance = model.create_instance()  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "min OF1 =  29.0\n",
      "max OF2 =  1543.0\n"
     ]
    }
   ],
   "source": [
    "instance.w1 =1 \n",
    "instance.w2 =0 \n",
    "results = opt.solve(instance) # solves and updates instance\n",
    "minOF1 = value(instance.maxload)\n",
    "maxOF2 = value(sum(t*instance.L[i]* instance.assign[i,t] for i in instance.i for t in instance.t) )\n",
    "      \n",
    "print('min OF1 = ', minOF1 )\n",
    "print('max OF2 = ', maxOF2 )\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max OF1 =  76.0\n",
      "min OF2 =  838.0\n"
     ]
    }
   ],
   "source": [
    "instance.w1 =0 \n",
    "instance.w2 =1 \n",
    "results = opt.solve(instance) # solves and updates instance\n",
    "maxOF1 = value(instance.maxload)\n",
    "minOF2 = value(sum(t*instance.L[i]* instance.assign[i,t] for i in instance.i for t in instance.t) )\n",
    "      \n",
    "print('max OF1 = ', maxOF1 )\n",
    "print('min OF2 = ', minOF2 )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OF1 = 76.0 , OF2 = 838.0  , limit = 838.0\n",
      "OF1 = 62.0 , OF2 = 873.0  , limit = 873.25\n",
      "OF1 = 58.0 , OF2 = 908.0  , limit = 908.5\n",
      "OF1 = 55.0 , OF2 = 942.0  , limit = 943.75\n",
      "OF1 = 51.0 , OF2 = 979.0  , limit = 979.0\n",
      "OF1 = 49.0 , OF2 = 1012.0  , limit = 1014.25\n",
      "OF1 = 47.0 , OF2 = 1043.0  , limit = 1049.5\n",
      "OF1 = 44.0 , OF2 = 1084.0  , limit = 1084.75\n",
      "OF1 = 43.0 , OF2 = 1120.0  , limit = 1120.0\n",
      "OF1 = 41.0 , OF2 = 1154.0  , limit = 1155.25\n",
      "OF1 = 39.0 , OF2 = 1190.0  , limit = 1190.5\n",
      "OF1 = 38.0 , OF2 = 1225.0  , limit = 1225.75\n",
      "OF1 = 37.0 , OF2 = 1251.0  , limit = 1261.0\n",
      "OF1 = 35.0 , OF2 = 1296.0  , limit = 1296.25\n",
      "OF1 = 34.0 , OF2 = 1331.0  , limit = 1331.5\n",
      "OF1 = 33.0 , OF2 = 1366.0  , limit = 1366.75\n",
      "OF1 = 32.0 , OF2 = 1399.0  , limit = 1402.0\n",
      "OF1 = 31.0 , OF2 = 1436.0  , limit = 1437.25\n",
      "OF1 = 31.0 , OF2 = 1453.0  , limit = 1472.5\n",
      "OF1 = 30.0 , OF2 = 1492.0  , limit = 1507.75\n",
      "OF1 = 29.0 , OF2 = 1539.0  , limit = 1543.0\n"
     ]
    }
   ],
   "source": [
    "N = 20\n",
    "OF1_vec = [] \n",
    "OF2_vec = [] \n",
    "\n",
    "instance.w1 =1 \n",
    "instance.w2 =0 \n",
    "for counter in range(N+1):\n",
    "    limit = (maxOF2-minOF2)*counter/N + minOF2\n",
    "    instance.limit = limit \n",
    "    results = opt.solve(instance) # solves and updates instance\n",
    "    OF1 = value(instance.maxload)\n",
    "    OF2 = value(sum(t*instance.L[i]* instance.assign[i,t] for i in instance.i for t in instance.t) )\n",
    "    OF1_vec.append(OF1)  \n",
    "    OF2_vec.append(OF2)\n",
    "    print(f\"OF1 = {OF1} , OF2 = {OF2}  , limit = {limit}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "KOLOR = ['r', 'k', 'b', 'g', 'gold', 'pink','dodgerblue','orange','brown','olive']\n",
    "\n",
    "plt.figure(figsize=(10,5))\n",
    "plt.xlabel('OF1', fontsize=14, fontweight = 'bold')\n",
    "plt.ylabel('OF2', fontsize=14, fontweight = 'bold')\n",
    "plt.xticks(fontsize=14, fontweight = 'bold')\n",
    "plt.yticks(fontsize=14, fontweight = 'bold')\n",
    "\n",
    "plt.scatter(OF1_vec,OF2_vec, s=100)\n",
    "Yi = [i for i in instance.i]\n",
    "plt.grid()\n",
    "plt.savefig('Pareto'+  ' .png', format='png', dpi=200)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}