JuMPcrashcourse.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Une prise en main rapide de Jupyter / Julia / JuMP\n",
    "\n",
    "## Qu'est-ce qu'un Jupyter notebook ?\n",
    "\n",
    "Un Jupyter notebook est un document qui contient \n",
    "+ du texte \n",
    "  - que l'on peut formatter à l'aide de Markdown\n",
    "  - qui peut contenir des maths à l'aide de $\\LaTeX$\n",
    "+ du code\n",
    "  - avec lequel on peut intéragir en ligne\n",
    "  \n",
    "Un notebook est une succession de cellules, chacune pouvant être soit du code, soit du texte.\n",
    "Quelques astuces :\n",
    "+ double-clicker pour rentrer dans une cellule\n",
    "+ Ctrl-enter pour éxecuter la cellule\n",
    "+ shift-enter pour éxecuter la cellule et passer à la suivante\n",
    "+ Alt-enter pour éxecuter la cellule et en ajouter une nouvelle\n",
    "\n",
    "Vous pourrez travailler et rendre votre projet sous forme de Jupyter notebook. Pour cela vous pouvez le télécharger sous forme de fichier .ipynb via l'onglet \"file\" en haut à gauche."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Qu'est-ce que JuliaBox ?\n",
    "\n",
    "JuliaBox est un site internet vous offrant une session sur un ordinateur où Julia et Jupyter sont installés. De cette manière vous pouvez faire tourner votre code sans avoir besoin d'installer Julia sur votre ordinateur. Ainsi vous pourrez travailler sur votre projet toujours depuis votre navigateur préféré.\n",
    "\n",
    "Attention, la session offert par JuliaBox dure 3h, au bout desquelles les calculs effectués sont perdus (mais pas le code). Donc, si d'un seul coup vous voyez des variables non-définies : pas d'affolement, il suffit de relancer le kernel (barre du haut) et recharger les cellules précédente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Qu'est-ce que Julia ?\n",
    "\n",
    "Julia est un langage de programmation, comparable à Python. C'est un langage récent, développé pour le calcul scientifique. \n",
    "\n",
    "Quelques éléments intéressant :\n",
    "+ langage open-source\n",
    "+ langage compilé \"Just-in-time\"\n",
    "+ langage disposant d'un terminal (comme python)\n",
    "+ ...\n",
    "\n",
    "Faisons nos premiers pas avec Julia. Exécuter les cellules suivantes, n'hésitez pas à modifier pour prendre en main :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [0 5 10 15]\n",
    "a[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "itération 1\n",
      "itération 2\n",
      "itération 3\n",
      "itération 4\n",
      "itération 5\n"
     ]
    }
   ],
   "source": [
    "for i = 1:5\n",
    "    println(\"itération \",i)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "factorielle (generic function with 1 method)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function factorielle(n)\n",
    "    res = 1\n",
    "    for i=1:n\n",
    "        res = res * i\n",
    "    end\n",
    "    return res\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorielle(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "## Qu'est-ce que JuMP ?\n",
    "\n",
    "JuMP est un package de Julia, qui est la raison pour laquelle ce projet sera réalisé en Julia.\n",
    "\n",
    "Il s'agit d'un package de modélisation, qui permet d'écrire un problème d'optimisation de manière simple puis de demander à un Solver de le résoudre.\n",
    "\n",
    "Nous allons maintenant faire no premiers pas avec JuMP.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mise en place\n",
    "\n",
    "Avant toute chose il faut appeler les bibliothèques utiles (préinstallées sur JuliaBox).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons maintenant dire que nous souhaitons utiliser ces deux packages (comparable à \"from packet import *\" en python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "using JuMP, GLPKMathProgInterface"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Construction d'un premier problème linéaire\n",
    "\n",
    "Nous souhaitons résoudre le problème linéaire suivant\n",
    "$$ \\begin{align*} \n",
    "\\min_{x,y} \\quad & 2x+3y \\\\\n",
    "s.c. \\quad & x+y \\geq 1 \\\\\n",
    "& x \\geq 0, y\\geq 0 \\\\\n",
    "\\end{align*}$$\n",
    "\n",
    "Commençons par construire le problème"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ x + y \\geq 1 $$"
      ],
      "text/plain": [
       "x + y ≥ 1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SOLVER = GLPKSolverLP()                    # On définit un solveur\n",
    "m = Model(solver=SOLVER)                # On construit un problème d'optimisation\n",
    "\n",
    "@variable(m,x>=0)                       # x est une variable réelle positive de m\n",
    "@variable(m,y>=0)                       # y est une variable réelle positive de m\n",
    "\n",
    "### Remarque les fonctions @variable / @objective / @constraint sont des fonctions spécifiques (des macros) \n",
    "# qui autorise de donner un argument comme 2*x+3*y sans qu'il soit évalué. \n",
    "# Ce n'est pas un comportement générique des fonctions julia.\n",
    "\n",
    "@objective(m,Min, 2*x+3*y)              # l'objectif de m est de Minimiser 2*x+3*y\n",
    "\n",
    "@constraint(m,x+y >= 1 )                # m a pour contrainte x+y <=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut vérifier que m est bien ce que l'on souhaite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min 2 x + 3 y\n",
      "Subject to\n",
      " x + y ≥ 1\n",
      " x ≥ 0\n",
      " y ≥ 0\n"
     ]
    }
   ],
   "source": [
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut également résoudre m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":Optimal"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et si on souhaite connaître la valeur optimale du problème ou des solutions optimales on peut les avoir de la manière suivante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "x = 1.0\n",
      "y = 0.0\n"
     ]
    }
   ],
   "source": [
    "println(getobjectivevalue(m))\n",
    "println(\"x = \",getvalue(x))\n",
    "println(\"y = \",getvalue(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un second problème linéaire\n",
    "\n",
    "Nous allons maintenant construire un problème linéaire plus complexe.\n",
    "$$\n",
    "\\begin{align*}\n",
    "\\min_{x\\in R^n} \\quad & \\sum_{i=1}^n c_i x_i \\\\\n",
    "s.c. \\quad & \\sum_{i=1}^n x_i \\geq n \\\\\n",
    "&  -1 \\leq x_i \\leq 2 & \\forall i\n",
    "\\end{align*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min 0.8972050649964163 x[1] + 0.562288544993758 x[2] + 0.3708486486088325 x[3] + 0.4667402147707074 x[4] + 0.48334043782197544 x[5] + 0.8999558652089157 x[6] + 0.9863389833234331 x[7] + 0.9540980378813038 x[8] + 0.514221331894821 x[9] + 0.14457520218789432 x[10]\n",
      "Subject to\n",
      " x[1] + x[2] + x[3] + x[4] + x[5] + x[6] + x[7] + x[8] + x[9] + x[10] ≥ 10\n",
      " -1 ≤ x[i] ≤ 2 ∀ i ∈ {1,2,…,9,10}\n"
     ]
    }
   ],
   "source": [
    "m2 = Model(solver=SOLVER)\n",
    "n = 10                                    # on choisit n = 10, mais vous pouvez le modifier\n",
    "c = rand(n)                               # c est choisi ici de manière aléatoire                                              \n",
    "\n",
    "@variable(m2, -1<= x[1:n] <= 2)           # x est une variable de m2 contenant n éléments x[1], x[2],...,x[n] tous compris entre -1 et 2\n",
    "\n",
    "@objective(m2,Min, sum(c[i]*x[i] for i=1:n) )\n",
    "\n",
    "@constraint(m2,sum(x[i] for i=1:n) >= n)\n",
    "                        \n",
    "print(m2)            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":Optimal"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(m2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Array{Float64,1}:\n",
       "  1.0\n",
       "  2.0\n",
       "  2.0\n",
       "  2.0\n",
       "  2.0\n",
       " -1.0\n",
       " -1.0\n",
       " -1.0\n",
       "  2.0\n",
       "  2.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getvalue(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ajoutons maintenant une série de contraintes de la forme\n",
    "$$ x_i + x_{i+1} \\leq 1, \\qquad \\forall i \\in 2, \\dots, n-1$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i = 1 : n-1\n",
    "    @constraint(m2, x[i]+x[i+1] <= 2)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Array{Float64,1}:\n",
       " 2.0\n",
       " 0.0\n",
       " 2.0\n",
       " 0.0\n",
       " 2.0\n",
       " 0.0\n",
       " 0.0\n",
       " 2.0\n",
       " 0.0\n",
       " 2.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[33mWARNING: \u001b[39m\u001b[22m\u001b[33mSolver does not appear to support providing initial feasible solutions.\u001b[39m\n"
     ]
    }
   ],
   "source": [
    "solve(m2)\n",
    "getvalue(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un problème non-linéaire\n",
    "\n",
    "Nous allons terminer avec un problème non-linéaire simple.\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "\\min_{x \\in R^{n.m}} \\quad & \\sum_{i,j} x_{i,j}^2 \\\\\n",
    "s.c. \\quad & \\sum_{i=1}^n x_{i,j} = 1 & \\forall j \\in [m] \n",
    "\\end{align*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Pkg.add(\"Ipopt\")                   # Installons un solveur non-linéaire\n",
    "using Ipopt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "SOLVER_NL = IpoptSolver()\n",
    "\n",
    "m3 = Model(solver = SOLVER_NL)\n",
    "\n",
    "N,M = 5,7 \n",
    "\n",
    "@variable(m3, x[i=1:N, j=1:M])\n",
    "\n",
    "@objective(m3, Max, sum(x[i,j]^2 for i=1:N, j=1:M))\n",
    "\n",
    "for j=1:M\n",
    "    @constraint(m3, sum(x[i,j] for i =1:N)==1)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max x[1,1]² + x[1,2]² + x[1,3]² + x[1,4]² + x[1,5]² + x[1,6]² + x[1,7]² + x[2,1]² + x[2,2]² + x[2,3]² + x[2,4]² + x[2,5]² + x[2,6]² + x[2,7]² + x[3,1]² + x[3,2]² + x[3,3]² + x[3,4]² + x[3,5]² + x[3,6]² + x[3,7]² + x[4,1]² + x[4,2]² + x[4,3]² + x[4,4]² + x[4,5]² + x[4,6]² + x[4,7]² + x[5,1]² + x[5,2]² + x[5,3]² + x[5,4]² + x[5,5]² + x[5,6]² + x[5,7]²\n",
      "Subject to\n",
      " x[1,1] + x[2,1] + x[3,1] + x[4,1] + x[5,1] = 1\n",
      " x[1,2] + x[2,2] + x[3,2] + x[4,2] + x[5,2] = 1\n",
      " x[1,3] + x[2,3] + x[3,3] + x[4,3] + x[5,3] = 1\n",
      " x[1,4] + x[2,4] + x[3,4] + x[4,4] + x[5,4] = 1\n",
      " x[1,5] + x[2,5] + x[3,5] + x[4,5] + x[5,5] = 1\n",
      " x[1,6] + x[2,6] + x[3,6] + x[4,6] + x[5,6] = 1\n",
      " x[1,7] + x[2,7] + x[3,7] + x[4,7] + x[5,7] = 1\n",
      " x[i,j] ∀ i ∈ {1,2,3,4,5}, j ∈ {1,2,…,6,7}\n"
     ]
    }
   ],
   "source": [
    "print(m3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "******************************************************************************\n",
      "This program contains Ipopt, a library for large-scale nonlinear optimization.\n",
      " Ipopt is released as open source code under the Eclipse Public License (EPL).\n",
      "         For more information visit http://projects.coin-or.org/Ipopt\n",
      "******************************************************************************\n",
      "\n",
      "This is Ipopt version 3.12.1, running with linear solver mumps.\n",
      "NOTE: Other linear solvers might be more efficient (see Ipopt documentation).\n",
      "\n",
      "Number of nonzeros in equality constraint Jacobian...:       35\n",
      "Number of nonzeros in inequality constraint Jacobian.:        0\n",
      "Number of nonzeros in Lagrangian Hessian.............:       35\n",
      "\n",
      "Total number of variables............................:       35\n",
      "                     variables with only lower bounds:        0\n",
      "                variables with lower and upper bounds:        0\n",
      "                     variables with only upper bounds:        0\n",
      "Total number of equality constraints.................:        7\n",
      "Total number of inequality constraints...............:        0\n",
      "        inequality constraints with only lower bounds:        0\n",
      "   inequality constraints with lower and upper bounds:        0\n",
      "        inequality constraints with only upper bounds:        0\n",
      "\n",
      "iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls\n",
      "   0 -0.0000000e+00 1.00e+00 0.00e+00  -1.0 0.00e+00    -  0.00e+00 0.00e+00   0\n",
      "   1 -1.4000000e+00 0.00e+00 2.00e+01  -1.7 2.00e-01   2.0 1.00e+00 1.00e+00h  1\n",
      "   2 -1.4000000e+00 0.00e+00 1.44e-15  -1.7 1.63e-17   1.5 1.00e+00 1.00e+00   0\n",
      "\n",
      "Number of Iterations....: 2\n",
      "\n",
      "                                   (scaled)                 (unscaled)\n",
      "Objective...............:  -1.4000000000000010e+00   -1.4000000000000010e+00\n",
      "Dual infeasibility......:   1.4432899320127035e-15    1.4432899320127035e-15\n",
      "Constraint violation....:   0.0000000000000000e+00    0.0000000000000000e+00\n",
      "Complementarity.........:   0.0000000000000000e+00    0.0000000000000000e+00\n",
      "Overall NLP error.......:   1.4432899320127035e-15    1.4432899320127035e-15\n",
      "\n",
      "\n",
      "Number of objective function evaluations             = 3\n",
      "Number of objective gradient evaluations             = 3\n",
      "Number of equality constraint evaluations            = 3\n",
      "Number of inequality constraint evaluations          = 0\n",
      "Number of equality constraint Jacobian evaluations   = 3\n",
      "Number of inequality constraint Jacobian evaluations = 0\n",
      "Number of Lagrangian Hessian evaluations             = 2\n",
      "Total CPU secs in IPOPT (w/o function evaluations)   =      0.156\n",
      "Total CPU secs in NLP function evaluations           =      0.152\n",
      "\n",
      "EXIT: Optimal Solution Found.\n",
      "1.400000000000001\n"
     ]
    }
   ],
   "source": [
    "solve(m3)\n",
    "println(getobjectivevalue(m3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5×7 Array{Float64,2}:\n",
       " 0.2  0.2  0.2  0.2  0.2  0.2  0.2\n",
       " 0.2  0.2  0.2  0.2  0.2  0.2  0.2\n",
       " 0.2  0.2  0.2  0.2  0.2  0.2  0.2\n",
       " 0.2  0.2  0.2  0.2  0.2  0.2  0.2\n",
       " 0.2  0.2  0.2  0.2  0.2  0.2  0.2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getvalue(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.6.2",
   "language": "julia",
   "name": "julia-0.6"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}