{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# TP 2-3 : Branch-and-bound applied to a knapsack problem" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Initialisation (à faire une seule fois)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Project.toml`\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Manifest.toml`\n", "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", "\u001b[32m ✓ \u001b[39mTestOptinum\n", " 1 dependency successfully precompiled in 2 seconds (262 already precompiled, 2 skipped during auto due to previous errors)\n", "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Project.toml`\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Manifest.toml`\n", "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", "\u001b[32m ✓ \u001b[39mTestOptinum\n", " 1 dependency successfully precompiled in 1 seconds (262 already precompiled, 2 skipped during auto due to previous errors)\n" ] } ], "source": [ "import Pkg;\n", "Pkg.add(\"GraphRecipes\");\n", "Pkg.add(\"Plots\");\n", "using GraphRecipes, Plots #only used to visualize the search tree at the end of the branch-and-bound" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Récupération des données" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "readKnapInstance" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\"\"\"Open and read a KnapFile.\n", "\n", "Args: \\\\\n", " - filename (String): the name of the file to read.\n", "\n", "Returns: \\\\\n", " - price (Vector{Integer}): prices of items to put in the KnapSack. \\\\\n", " - weight (Vector{Integer}): weights of items to put in the KnapSack. \\\\\n", " - capacity (Integer): the maximum capacity of the KnapSack.\n", "\"\"\"\n", "function readKnapInstance(filename)\n", " price = []\n", " weight = []\n", " capacity = -1\n", " open(filename) do f\n", " for i = 1:3\n", " tok = split(readline(f))\n", " if (tok[1] == \"ListPrices=\")\n", " for i = 2:(length(tok)-1)\n", " push!(price, parse(Int64, tok[i]))\n", " end\n", " elseif (tok[1] == \"ListWeights=\")\n", " for i = 2:(length(tok)-1)\n", " push!(weight, parse(Int64, tok[i]))\n", " end\n", " elseif (tok[1] == \"Capacity=\")\n", " capacity = parse(Int64, tok[2])\n", " else\n", " println(\"Unknown read :\", tok)\n", " end\n", " end\n", " end\n", " return price, weight, capacity\n", "end" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "# on convert tous les .opb et .lp\n", "for (root, dirs, files) in walkdir(\"data\")\n", " for file in files\n", " if endswith(file, \".opb\")\n", " price, weight, capacity = readKnapInstance(root * \"/\" * file)\n", " \n", " end\n", " end\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Procédure d'application des tests de sondabilités TA, TO et TR pour le cas de la relaxation linéaire" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "TestsSondabilite_relaxlin" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\"\"\"Test if a node should be pruned.\n", "\n", "Args: \\\\\n", " - x (Vector{Integer}): the node to be tested. \\\\\n", " - price (Vector{Integer}): prices of items to put in the KnapSack. \\\\\n", " - weight (Vector{Integer}): weights of items to put in the KnapSack. \\\\\n", " - capacity (Integer): the maximum capacity of the KnapSack. \\\\\n", " - BestProfit (Integer): the current BestProfit value. \\\\\n", " - Bestsol (Integer): the current BestSol values. \\\\\n", " - affich (Bool): determine if the function should print to stdout.\n", "\n", "Returns: \\\\\n", " - TA (Bool): true if the node is feasible. \\\\\n", " - TO (Bool): true if the node is optimal. \\\\\n", " - TR (Bool): true if the node is resolvable. \\\\\n", " - BestProfit (Integer): the updated value of BestProfit. \\\\\n", " - Bestsol (Vector{Integer}): the updated values of BestSol.\n", "\"\"\"\n", "function TestsSondabilite_relaxlin(x, price, weight, capacity, BestProfit, Bestsol, affich)\n", " TA, TO, TR = false, false, false\n", "\n", " if (!Constraints(x, weight, capacity)) # Test de faisabilite\n", " TA = true\n", " if affich\n", " println(\"TA\\n\")\n", " end\n", "\n", " elseif (Objective(x, price) <= BestProfit) # Test d'optimalite\n", " TO = true\n", " if affich\n", " println(\"TO\\n\")\n", " end\n", "\n", " elseif (AllDef(x)) # Test de resolution\n", " TR = true\n", " if affich\n", " println(\"TR : solution \", \" de profit \", Objective(x, price), \"\\n\")\n", " end\n", " if (Objective(x, price) >= BestProfit) # Le profit de la solution trouvée est meilleur que les autres\n", " if affich\n", " println(\"\\t-> Cette solution a un meilleur profit.\\n\")\n", " end\n", " # On remplace la solution et le profit par les nouvelles valeurs\n", " Bestsol = x\n", " BestProfit = Objective(x, price)\n", " else\n", " if affich\n", " println(\"\\t-> Cette solution est moins bonne.\\n\")\n", " end\n", " end\n", "\n", " elseif affich\n", " println(\"non sondable\\n\")\n", " end\n", "\n", " return TA, TO, TR, Bestsol, BestProfit\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Procédure de séparation et stratégie d'exploration permettant de se placer au prochain noeud à traiter" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SeparerNoeud" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\"\"\"Split a node in two.\n", "\n", "Args: \\\\\n", " - price (Vector{Integer}): prices of items to put in the KnapSack. \\\\\n", " - listvars (Vector{Vector{Integer}}): the current values of listvars. \\\\\n", " - listvals (Vector{Integer}): the current values of listvals.\n", "\n", "Returns: \\\\\n", " - listvars (Vector{Vector{Integer}}): the updated values of listvars. \\\\\n", " - listvals (Vector{Integer}): the updated values of listvals.\n", "\"\"\"\n", "function SeparerNoeud(price, listvars, listvals)\n", " # Le noeud est non-sondable. Appliquer le critère de séparation pour le séparer en sous-noeuds \n", "\n", " # Cas du noeud le plus à gauche\n", "\n", " # On sépare le noeud actuel en 2 sous-noeuds\n", " predX = pop!(listvars)\n", " nextX0 = copy(predX)\n", " nextX1 = copy(predX)\n", "\n", " # On initialise leurs valeurs à zéro\n", " val0 = 0\n", " val1 = 0\n", "\n", " # On fixe la nouvelle variable des deux sous-noeuds\n", " n = length(predX)\n", " for i = 1:n\n", " if predX[i] == -1\n", " # L'un a zéro\n", " nextX0[i] = 0\n", " # L'autre a un\n", " nextX1[i] = 1\n", "\n", " # On calcule leurs valeurs\n", " val0 = Objective(nextX0, price)\n", " val1 = Objective(nextX1, price)\n", " break\n", " end\n", " end\n", " \n", " # On ajoute les sous-noeuds a la pile des noeuds a explorer\n", " push!(listvars, nextX0)\n", " push!(listvars, nextX1)\n", "\n", " # On ajoute aussi leurs valeurs\n", " push!(listvals, val0)\n", " push!(listvals, val1)\n", "\n", " return listvars, listvals\n", "end" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "ExplorerAutreNoeud_relaxlin" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\"\"\"Pop node fom the list to explore another node.\n", "\n", "Args: \\\\\n", " - price (Vector{Integer}): prices of items to put in the KnapSack. \\\\\n", " - listvars (Vector{Vector{Integer}}): the current values of listvars. \\\\\n", " - listvals (Vector{Integer}): the current values of listvals.\n", "\n", "Returns: \\\\\n", " - listvars (Vector{Vector{Integer}}): the updated values of listvars. \\\\\n", " - listvals (Vector{Integer}): the updated values of listvals. \\\\\n", " - stop (Bool): true if the tree search is finished.\n", "\"\"\"\n", "function ExplorerAutreNoeud_relaxlin(listvars, listvals)\n", " # Le noeud est sondable, on l'enlève de la pile des noeuds à sonder\n", "\n", " stop = false\n", " if (length(listvars) > 1)\n", " # On passe au noeud suivant\n", " var = pop!(listvars)\n", " val = pop!(listvals)\n", " else\n", " # Il n'y a pas d'autre noeud\n", " stop = true\n", " end\n", "\n", " return listvars, listvals, stop\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Fonctions décrivant l'objectif et les contraintes" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "AllDef (generic function with 1 method)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Fonction objectif que l'on souhaite maximiser/minimiser (évalué dans le meilleur des cas)\n", "Objective(x, price) =\n", " sum(\n", " if x[i] < 0\n", " price[i]\n", " else\n", " price[i] * x[i]\n", " end\n", " for i = 1:length(x)\n", " )\n", "\n", "# Fonction permettant de vérfier toutes les contraintes du modèle (dans le meilleur des cas)\n", "Constraints(x, weight, capacity) =\n", " sum(\n", " if x[i] < 0\n", " 0\n", " else\n", " weight[i] * x[i]\n", " end\n", " for i = 1:length(x)\n", " ) <= capacity\n", "\n", "# Fonction qui nous dis si toutes les variables de x sont fixées\n", "function AllDef(x)\n", " for i = 1:length(x)\n", " if x[i] < 0\n", " return false\n", " end\n", " end\n", " return true\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Résolution du problème KnapSack" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SolveKnapInstance" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\"\"\"Solve the KnapSack problem for the data contained in `filename`.\n", "\n", "Args: \\\\\n", " - filename (String): the name of the file to read.\n", "\n", "Returns: \\\\\n", " - trParentnodes (Vector{Integer}): the parents nodes, to plot the tree.\n", " - trChildnodes (Vector{Integer}): the child nodes, to plot the tree.\n", " - trNamenodes (Vector{Integer}): the name of the nodes, to plot the tree.\n", "\"\"\"\n", "function SolveKnapInstance(filename)\n", "\n", " stop = false\n", " affich = false\n", " \n", " # Extraction des données\n", " price, weight, capacity = readKnapInstance(filename)\n", " \n", " tri = false\n", " if tri\n", " couples = zip(price, weight)\n", " couples = sort(collect(couples), by = x -> x[1] / x[2])\n", " unzip(a) = map(x->getfield.(a, x), fieldnames(eltype(a)))\n", " price, weight = unzip(couples)\n", " end\n", "\n", " if affich\n", " println(\"Capacity : \", capacity, \" | Number of objects : \", length(price), \"\\n\")\n", " end\n", "\n", " # Pour dessiner le graph\n", " trParentnodes = Int64[]\n", " trChildnodes = Int64[]\n", " trNamenodes = []\n", "\n", " # Liste des variable pour naviguer de noeuds en noeuds\n", " listvars = []\n", " listvals = []\n", " listnodes = []\n", "\n", " # La meilleur solution et sa valeur\n", " BestProfit = -1\n", " Bestsol = []\n", "\n", " # Compter le nombre de noeud explorés\n", " current_node_number = 0\n", "\n", " # On ajoute le premier noeud à explorer (la racine)\n", " push!(listvars, [-1 for p in price])\n", " push!(listvals, Objective(last(listvars), price))\n", " push!(listnodes, 1)\n", " push!(trNamenodes, 0)\n", " newnodeid = 2\n", "\n", " while (!stop)\n", "\n", " # Le noeud actuel\n", " x = last(listvars)\n", "\n", " if affich && current_node_number % 10000 == 0\n", " println(\"----------\\nNode n°\", current_node_number, \" :\\n\")\n", " println(\"Previous Solution memorized \", \" with bestprofit \", BestProfit, \"\\n\")\n", " end\n", "\n", " # Test de sondabilité du noeud actuel\n", " # -> On mets a jour la solution et sa valeur si besoin\n", " TA, TO, TR, Bestsol, BestProfit = TestsSondabilite_relaxlin(x, price, weight, capacity, BestProfit, Bestsol, affich)\n", "\n", " is_node_sondable = TA || TO || TR\n", " if (!is_node_sondable)\n", " # Le noeud n'est pas sondable, on le sépare en 2 sous-noeuds\n", " listvars, listvals = SeparerNoeud_relaxlin(price, listvars, listvals)\n", "\n", " curnode = pop!(listnodes)\n", "\n", " push!(trParentnodes, curnode)\n", " push!(trParentnodes, curnode)\n", "\n", " push!(listnodes, newnodeid + 1)\n", " push!(listnodes, newnodeid)\n", "\n", " push!(trChildnodes, newnodeid)\n", " push!(trChildnodes, newnodeid + 1)\n", "\n", " push!(trNamenodes, newnodeid - 1)\n", " push!(trNamenodes, newnodeid)\n", "\n", " newnodeid += 2\n", "\n", " else\n", " # Le noeud est sondable, on passe au noeud suivant\n", " listvars, listvals, stop = ExplorerAutreNoeud_relaxlin(listvars, listvals)\n", "\n", " pop!(listnodes)\n", " end\n", "\n", " current_node_number += 1\n", " end\n", "\n", " \n", " println(\"\\n******\\n\\nOptimal value = \", BestProfit, \"\\n\\nOptimal x = \", Bestsol)\n", " \n", " \n", " return trParentnodes, trChildnodes, trNamenodes\n", "end" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "******\n", "\n", "Optimal value = 2\n", "\n", "Optimal x = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n" ] }, { "data": { "text/plain": [ "([1, 1, 2, 2, 5, 5, 7, 7, 9, 9 … 93, 93, 100, 100, 103, 103, 101, 101, 106, 106], [2, 3, 4, 5, 6, 7, 8, 9, 10, 11 … 100, 101, 102, 103, 104, 105, 106, 107, 108, 109], Any[0, 1, 2, 3, 4, 5, 6, 7, 8, 9 … 99, 100, 101, 102, 103, 104, 105, 106, 107, 108])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "trParentnodes, trChildnodes, trNamenodes = SolveKnapInstance(\"data/test_perso/2max.opb\")\n", "# trParentnodes, trChildnodes, trNamenodes = SolveKnapInstance(\"data/subset_sum/knapPI_6_50_1000_1_-994.opb\")" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": "\n\n\n \n \n \n\n\n\n \n \n \n\n\n\n \n \n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "graphplot(trParentnodes, trChildnodes, names = trNamenodes, method = :tree)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "nombres de noeuds explorés : 109\n" ] } ], "source": [ "println(\"nombres de noeuds explorés : \", length(trNamenodes))" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# # on teste de résoudre tous les fichiers .opb\n", "# for (root, dirs, files) in walkdir(\"data\")\n", "# for file in files\n", "# if endswith(file, \".opb\")\n", "# SolveKnapInstance(root * \"/\" * file)\n", "# end\n", "# end\n", "# end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Rapport\n", "\n", "- Quelques détails sur les points clés et non triviaux de votre implémentation\n", "- Une courte argumentation de l’adéquation du résultat avec l’instance résolue\n", "- Quelques éléments d’analyse, par exemple :\n", "- Analyser l’impact des différents paramètres de la PSE sur la performance en terme de vitesse/délais (en temps cpu et nombre de noeuds explorés) pour l’obtention d’une solution réalisable, pour l’obtention de la meilleure solution, pour l’obtention de bornes supérieures de qualité et pour la complétion de l’algorithme\n", "\n", "## Notre implémentation\n", "\n", "Pour l'implémentation de notre `branch and bound`, nous avons gardé la même même architecture que celle du sujet. Nous avons simplement ré-écrit les fonctions qui calculent la valeur objectif et la valeur de la capacité. \\\n", "Notre vecteur de décision $x$ est tel que $x\\in\\{-1,0,1\\}^n$ avec $n$ le nombre d'objets disponibles. $1$ et $0$ représente, respectivement, un objet non-pris ou non-pris. La valeur $-1$ représente un objet ou la décision n'a pas encore été faite.\n", "Dans la fonction `Objetive`, si la valeur est a $-1$, on fait comme-ci elle était à $1$ pourcalculer une borne supérieur. Dans la fonction `Constraints` les $-1$ sont concidéré comme des $0$ pour avoir une borne inférieur de notre problème. \\\n", "
\n", "Pour l'exploration et la création de noeud, nous faisons une exploration des noeuds avec le plus de $1$ en premier. \\\n", "Lorsque nous arrivons sur un noeud, nous l'enlevons de la pile des noeuds. Nous calculons ensuite si il est \"trivial\" ou si il dépasse déjà l'une des bornes ou si il est divisible. Dans le cas ou il est \"trivial\", nous calculons sa valeur et remplaçons la meilleure valeur si nécessaire. Dans le cas ou il dépasse une borne, nous l'abandonnons. Et enfin, si il est séparable, nous le séparons en deux en ajoutant la pile des noeuds les deux sous noeuds. \\\n", "Exemple : $[(0,-1,-1)]$ -> $[(0,0,-1) ; (0,1,-1)]$\n", "\n", "## Justification de nos résultats\n", "\n", "Notre algorithme trouve bien les solutions idéales (comme indiqué dans le nom du fichier). Pour le test `uncorrelated_span/knapPI_11_20_1000_1_-1428` Nous avons trouvé la valeur optimale qui est de `1428` en `2131` exploration de noeuds la ou un algorithme classique de parcours de l'ensemble des noeuds aurait exploré `1048576` noeuds.\n", "\n", "## Analyse\n", "\n", "```\n", "lfainsin@bonite:~/2A/RO/tp2$ time julia test.jl data/weakly_correlated/knapPI_2_50_1000_1_-1396.opb\n", "---data/weakly_correlated/knapPI_2_50_1000_1_-1396.opb---\n", "Capacity = 995\n", "Number of objects = 50\n", "Expected optimal value = 1396\n", "Maximum number of nodes = 1125899906842624\n", "\n", "Node n°96: BestProfit = 825\n", "Node n°169: BestProfit = 844\n", "Node n°243: BestProfit = 919\n", "Node n°297: BestProfit = 943\n", "Node n°1126: BestProfit = 946\n", "Node n°1224: BestProfit = 1030\n", "Node n°1456: BestProfit = 1045\n", "Node n°2960: BestProfit = 1105\n", "Node n°3342: BestProfit = 1120\n", "Node n°4596: BestProfit = 1126\n", "Node n°6129: BestProfit = 1207\n", "Node n°10462: BestProfit = 1212\n", "Node n°24382: BestProfit = 1278\n", "Node n°418695: BestProfit = 1288\n", "Node n°422566: BestProfit = 1308\n", "Node n°436804: BestProfit = 1329\n", "Node n°443759: BestProfit = 1337\n", "Node n°446051: BestProfit = 1352\n", "Node n°916081: BestProfit = 1360\n", "Node n°1044425: BestProfit = 1396\n", "\n", "--------------------------------------------------\n", "Expected optimal value = 1396\n", "Optimal value = 1396\n", "Optimal x = [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]\n", "Maximum number of nodes = 1125899906842624\n", "Nodes explored = 3053865\n", "\n", "real 0m29,301s\n", "user 0m29,372s\n", "sys 0m0,809s\n", "```\n", "\n", "```\n", "lfainsin@bonite:~/2A/RO/tp2$ time julia test.jl data/weakly_correlated/knapPI_2_50_1000_1_-1396.opb\n", "---data/weakly_correlated/knapPI_2_50_1000_1_-1396.opb---\n", "Capacity = 995\n", "Number of objects = 50\n", "Expected optimal value = 1396\n", "Maximum number of nodes = 1125899906842624\n", "\n", "Node n°93: BestProfit = 487\n", "Node n°175: BestProfit = 626\n", "Node n°293: BestProfit = 705\n", "Node n°544: BestProfit = 810\n", "Node n°1671: BestProfit = 815\n", "Node n°1871: BestProfit = 836\n", "Node n°2019: BestProfit = 872\n", "Node n°2074: BestProfit = 886\n", "Node n°3204: BestProfit = 918\n", "Node n°4406: BestProfit = 950\n", "Node n°4708: BestProfit = 952\n", "Node n°4770: BestProfit = 978\n", "Node n°8898: BestProfit = 990\n", "Node n°9214: BestProfit = 1049\n", "Node n°18160: BestProfit = 1059\n", "Node n°18616: BestProfit = 1095\n", "Node n°25906: BestProfit = 1099\n", "Node n°27015: BestProfit = 1104\n", "Node n°27130: BestProfit = 1119\n", "Node n°27585: BestProfit = 1121\n", "Node n°28076: BestProfit = 1125\n", "Node n°43768: BestProfit = 1132\n", "Node n°44203: BestProfit = 1134\n", "Node n°59004: BestProfit = 1142\n", "Node n°59465: BestProfit = 1144\n", "Node n°59964: BestProfit = 1148\n", "Node n°65923: BestProfit = 1154\n", "Node n°66110: BestProfit = 1156\n", "Node n°71779: BestProfit = 1186\n", "Node n°71992: BestProfit = 1188\n", "Node n°73054: BestProfit = 1190\n", "Node n°73127: BestProfit = 1197\n", "Node n°73146: BestProfit = 1241\n", "Node n°152150: BestProfit = 1249\n", "Node n°154060: BestProfit = 1251\n", "Node n°179062: BestProfit = 1260\n", "Node n°181638: BestProfit = 1261\n", "Node n°181907: BestProfit = 1281\n", "Node n°192060: BestProfit = 1298\n", "Node n°202348: BestProfit = 1330\n", "Node n°203862: BestProfit = 1341\n", "Node n°206773: BestProfit = 1351\n", "Node n°399253: BestProfit = 1365\n", "Node n°619338: BestProfit = 1375\n", "Node n°619695: BestProfit = 1377\n", "Node n°842654: BestProfit = 1394\n", "Node n°844341: BestProfit = 1396\n", "\n", "--------------------------------------------------\n", "Expected optimal value = 1396\n", "Optimal value = 1396\n", "Optimal x = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1]\n", "Maximum number of nodes = 1125899906842624\n", "Nodes explored = 846447\n", "\n", "real 0m4,348s\n", "user 0m4,480s\n", "sys 0m0,747s\n", "```\n", "\n", "Nous avaons réalisé les calcules de deux manières différentes : \\\n", "La première fois, nous mettions a jour les coordonnées de $x$ dans l'ordre des indices. \\\n", "La deuxième fois, nous avons d'abbord trié les vecteurs `weight` et `price` par leur rapport $prix / poids$. Cela revient a mettre a jour les coordonnées de $x$ dans l'ordre du meilleur rapport $prix / poids$. (NB : le vecteur résultat n'est pas ré-ordonné comme l'était les `price` et `weight` initialement) \\\n", "
\n", "Pour le fichier `weakly_correlated/knapPI_2_50_1000_1_-1396`, nous avons comparé les résultats :\n", "| Valeurs | Sans tri | Avec tri |\n", "| :- | :- | :- |\n", "| Optimal value | 1396 | 1396 |\n", "| user | 29.372s | 4.480s |\n", "| Nodes explored | 3053865 | 846447 |\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [] } ], "metadata": { "kernelspec": { "display_name": "Julia 1.7.0", "language": "julia", "name": "julia-1.7" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.7.0" } }, "nbformat": 4, "nbformat_minor": 4 }