\n",
- "Note\n",
- " \n",
- "In this tutorial, we use SCIP because it is more widely available than commercial MIP solvers. However, all the steps below should work for Gurobi, CPLEX or XPRESS, as long as you have a license for these solvers. The performance impact of MIPLearn may also change for different solvers.\n",
- "
\n",
+ "4. Use the ML models together with Gurobi to solve new instances\n",
"\n",
"\n",
"Warning\n",
@@ -32,7 +26,7 @@
},
{
"cell_type": "markdown",
- "id": "193ba5db",
+ "id": "f0d159b8",
"metadata": {},
"source": [
"## Installation\n",
@@ -48,56 +42,50 @@
{
"cell_type": "code",
"execution_count": 1,
- "id": "03519dc6",
+ "id": "b16685be",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
- "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m git-repo `https://github.com/ANL-CEEESA/MIPLearn.jl.git`\n",
- "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n",
- "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaRegistries/General.git`\n",
+ "Path `/home/axavier/Packages/MIPLearn.jl/dev` exists and looks like the correct package. Using existing path.\n",
"\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n",
- "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/Packages/MIPLearn/dev/docs/jump-tutorials/Project.toml`\n",
- " \u001b[90m [2b1277c3] \u001b[39m\u001b[93m~ MIPLearn v0.2.0 `https://github.com/ANL-CEEESA/MIPLearn.jl.git#dev` ⇒ v0.2.0 `https://github.com/ANL-CEEESA/MIPLearn.jl.git#dev`\u001b[39m\n",
- "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/Packages/MIPLearn/dev/docs/jump-tutorials/Manifest.toml`\n",
- " \u001b[90m [2b1277c3] \u001b[39m\u001b[93m~ MIPLearn v0.2.0 `https://github.com/ANL-CEEESA/MIPLearn.jl.git#dev` ⇒ v0.2.0 `https://github.com/ANL-CEEESA/MIPLearn.jl.git#dev`\u001b[39m\n",
- "\u001b[32m\u001b[1m Building\u001b[22m\u001b[39m MIPLearn → `~/.julia/scratchspaces/44cfe95a-1eb2-52ea-b672-e2afdf69b78f/8e595dec310860a52e01c8875f51165fcccb1875/build.log`\n",
- "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n",
- "\u001b[32m ✓ \u001b[39mMIPLearn\n",
- "1 dependency successfully precompiled in 10 seconds (96 already precompiled)\n"
+ "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/Packages/MIPLearn/dev/docs/jump-tutorials/Project.toml`\n",
+ "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/Packages/MIPLearn/dev/docs/jump-tutorials/Manifest.toml`\n"
]
}
],
"source": [
"using Pkg\n",
- "Pkg.add(PackageSpec(url=\"https://github.com/ANL-CEEESA/MIPLearn.jl.git\"))"
+ "#Pkg.add(PackageSpec(url=\"https://github.com/ANL-CEEESA/MIPLearn.jl.git\"))\n",
+ "Pkg.develop(PackageSpec(path=\"/home/axavier/Packages/MIPLearn.jl/dev\"))"
]
},
{
"cell_type": "markdown",
- "id": "85c136a1",
+ "id": "e5ed7716",
"metadata": {},
"source": [
"In addition to MIPLearn itself, we will also install a few other packages that are required for this tutorial:\n",
"\n",
- "- [**SCIP**](https://www.scipopt.org/), one of the fastest non-commercial MIP solvers currently available\n",
+ "- [**Gurobi**](https://www.gurobi.com/), a state-of-the-art MIP solver\n",
"- [**JuMP**](https://jump.dev/), an open source modeling language for Julia\n",
- "- [**Distributions.jl**](https://github.com/JuliaStats/Distributions.jl), a statistics package that we will use to generate random inputs\n",
- "- [**Glob.jl**](https://github.com/vtjnash/Glob.jl), a package that retrieves all files in a directory matching a certain pattern"
+ "- [**Distributions.jl**](https://github.com/JuliaStats/Distributions.jl), a statistics package that we will use to generate random inputs"
]
},
{
"cell_type": "code",
"execution_count": 2,
- "id": "36ae5ca6",
+ "id": "f88155c5",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
+ "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n",
+ "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaRegistries/General.git`\n",
"\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n",
"\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/Packages/MIPLearn/dev/docs/jump-tutorials/Project.toml`\n",
"\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/Packages/MIPLearn/dev/docs/jump-tutorials/Manifest.toml`\n"
@@ -107,7 +95,7 @@
"source": [
"using Pkg\n",
"Pkg.add([\n",
- " PackageSpec(url=\"https://github.com/scipopt/SCIP.jl.git\", rev=\"7aa79aaa\"),\n",
+ " PackageSpec(name=\"Gurobi\", version=\"0.9.14\"),\n",
" PackageSpec(name=\"JuMP\", version=\"0.21\"),\n",
" PackageSpec(name=\"Distributions\", version=\"0.25\"),\n",
" PackageSpec(name=\"Glob\", version=\"1\"),\n",
@@ -116,7 +104,7 @@
},
{
"cell_type": "markdown",
- "id": "735da4c6",
+ "id": "a0e1dda5",
"metadata": {},
"source": [
"
\n",
@@ -130,7 +118,7 @@
},
{
"cell_type": "markdown",
- "id": "b61a4780",
+ "id": "378b6a97",
"metadata": {},
"source": [
"## Modeling a simple optimization problem\n",
@@ -166,7 +154,7 @@
{
"cell_type": "code",
"execution_count": 3,
- "id": "b8a47a58",
+ "id": "798b2f6c",
"metadata": {},
"outputs": [],
"source": [
@@ -181,7 +169,7 @@
},
{
"cell_type": "markdown",
- "id": "7acf8818",
+ "id": "104b709a",
"metadata": {},
"source": [
"Next, we create a function that converts this data structure into a concrete JuMP model. For more details on the JuMP syntax, see [the official JuMP documentation](https://jump.dev/JuMP.jl/stable/)."
@@ -190,7 +178,7 @@
{
"cell_type": "code",
"execution_count": 4,
- "id": "1b8245e2",
+ "id": "a7c048e4",
"metadata": {},
"outputs": [],
"source": [
@@ -219,7 +207,7 @@
},
{
"cell_type": "markdown",
- "id": "d4b9bfa3",
+ "id": "5f10142e",
"metadata": {},
"source": [
"At this point, we can already use JuMP and any mixed-integer linear programming solver to find optimal solutions to any instance of this problem. To illustrate this, let us solve a small instance with three generators, using SCIP:"
@@ -228,7 +216,7 @@
{
"cell_type": "code",
"execution_count": 5,
- "id": "a74e5709",
+ "id": "bc2022a4",
"metadata": {},
"outputs": [
{
@@ -242,7 +230,7 @@
}
],
"source": [
- "using SCIP\n",
+ "using Gurobi\n",
"\n",
"model = build_uc_model(\n",
" UnitCommitmentData(\n",
@@ -254,8 +242,8 @@
" )\n",
")\n",
"\n",
- "scip = optimizer_with_attributes(SCIP.Optimizer, \"limits/gap\" => 1e-4)\n",
- "set_optimizer(model, scip)\n",
+ "gurobi = optimizer_with_attributes(Gurobi.Optimizer, \"Threads\" => 1, \"Seed\" => 42)\n",
+ "set_optimizer(model, gurobi)\n",
"set_silent(model)\n",
"optimize!(model)\n",
"\n",
@@ -266,7 +254,7 @@
},
{
"cell_type": "markdown",
- "id": "033821cd",
+ "id": "9ee6958b",
"metadata": {},
"source": [
"Running the code above, we found that the optimal solution for our small problem instance costs \\$1320. It is achieve by keeping generators 2 and 3 online and producing, respectively, 60 MW and 40 MW of power."
@@ -274,7 +262,7 @@
},
{
"cell_type": "markdown",
- "id": "fdc17cc8",
+ "id": "f34e3d44",
"metadata": {},
"source": [
"## Generating training data\n",
@@ -289,7 +277,7 @@
{
"cell_type": "code",
"execution_count": 6,
- "id": "adec6906",
+ "id": "a498e1e1",
"metadata": {},
"outputs": [],
"source": [
@@ -317,433 +305,377 @@
},
{
"cell_type": "markdown",
- "id": "b1f4bdbd",
+ "id": "e33bb12c",
"metadata": {},
"source": [
- "In this example, for simplicity, only the demands change from one instance to the next. We could also have made the prices and the production limits random. The more randomization we have in the training data, however, the more challenging it is for the machine learning models to learn solution patterns.\n",
+ "In this example, for simplicity, only the demands change from one instance to the next. We could also have randomized the costs, production limits or even the number of units. The more randomization we have in the training data, however, the more challenging it is for the machine learning models to learn solution patterns.\n",
"\n",
- "Now we generate 100 instances of this problem, each one with 1,000 generators. We will use the first 90 instances for training, and the remaining 10 instances to evaluate SCIP's performance."
+ "Now we generate 500 instances of this problem, each one with 50 generators, and we use 450 of these instances for training. After generating the instances, we write them to individual files. MIPLearn uses files during the training process because, for large-scale optimization problems, it is often impractical to hold in memory the entire training data, as well as the concrete JuMP models. Files also make it much easier to solve multiple instances simultaneously, potentially even on multiple machines. We will cover parallel and distributed computing in a future tutorial. The code below generates the files `uc/train/00001.jld2`, `uc/train/00002.jld2`, etc., which contain the input data in [JLD2 format](https://github.com/JuliaIO/JLD2.jl)."
]
},
{
"cell_type": "code",
"execution_count": 7,
- "id": "ffe2f033",
+ "id": "5358a046",
"metadata": {},
"outputs": [],
"source": [
- "data = random_uc_data(samples=100, n=1000);\n",
- "train_data = data[1:90]\n",
- "test_data = data[91:100];"
+ "using MIPLearn\n",
+ "data = random_uc_data(samples=500, n=50);\n",
+ "train_files = MIPLearn.save(data[1:450], \"uc/train/\")\n",
+ "test_files = MIPLearn.save(data[451:500], \"uc/test/\");"
]
},
{
"cell_type": "markdown",
- "id": "0785952f",
+ "id": "38a27d1c",
"metadata": {},
"source": [
- "Next, we write these data structures to individual files. MIPLearn uses files during the training process because, for large-scale optimization problems, it is often impractical to hold the entire training data, as well as the concrete JuMP models, in memory. Files also make it much easier to solve multiple instances simultaneously, potentially even on multiple machines. We will cover parallel and distributed computing in a future tutorial.\n",
- "\n",
- "The code below generates the files `uc/train/000001.jld2`, `uc/train/000002.jld2`, etc., which contain the input data in [JLD2 format](https://github.com/JuliaIO/JLD2.jl)."
+ "Finally, we use `LearningSolver` to solve all the training instances. `LearningSolver` is the main component provided by MIPLearn, which integrates MIP solvers and ML. The optimal solutions, along with other useful training data, are stored in HDF5 files `uc/train/00001.h5`, `uc/train/00002.h5`, etc."
]
},
{
"cell_type": "code",
"execution_count": 8,
- "id": "e5ad203b",
+ "id": "c341b12d",
"metadata": {},
"outputs": [],
"source": [
- "using MIPLearn\n",
- "MIPLearn.save(data[1:90], \"uc/train/\")\n",
- "MIPLearn.save(data[91:100], \"uc/test/\")\n",
- "\n",
- "using Glob\n",
- "train_files = glob(\"uc/train/*.jld2\")\n",
- "test_files = glob(\"uc/test/*.jld2\");"
+ "solver = LearningSolver(gurobi)\n",
+ "solve!(solver, train_files, build_uc_model);"
]
},
{
"cell_type": "markdown",
- "id": "a758917d",
- "metadata": {},
- "source": [
- "Finally, we use `MIPLearn.LearningSolver` and `MIPLearn.solve!` to solve all the training instances. `LearningSolver` is the main component provided by MIPLearn, which integrates MIP solvers and ML. The `solve!` function can be used to solve either one or multiple instances, and requires: (i) the list of files containing the training data; and (ii) the function that converts the data structure into a concrete JuMP model:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "id": "930b59cd",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "105.491488 seconds (94.05 M allocations: 3.632 GiB, 1.17% gc time, 0.56% compilation time)\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING: Dual bound 1.98665e+07 is larger than the objective of the primal solution 1.98665e+07. The solution might not be optimal.\n"
- ]
- }
- ],
- "source": [
- "using Glob\n",
- "solver = LearningSolver(scip)\n",
- "@time solve!(solver, train_files, build_uc_model);"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "2e0c3908",
- "metadata": {},
- "source": [
- "The macro `@time` shows us how long did the code take to run. We can see that SCIP was able to solve all training instances in about 2 minutes. The solutions, and other useful training data, are stored by MIPLearn in `.h5` files, stored side-by-side with the original `.jld2` files."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "67b5cc7c",
+ "id": "189b4f60",
"metadata": {},
"source": [
"## Solving new instances\n",
"\n",
- "With training data in hand, we can now fit the ML models using `MIPLearn.fit!`, then solve the test instances with `MIPLearn.solve!`, as shown below:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "id": "ae19716a",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- " 5.876161 seconds (9.35 M allocations: 335.718 MiB, 1.57% gc time)\n"
- ]
- }
- ],
- "source": [
- "solver_ml = LearningSolver(scip)\n",
- "fit!(solver_ml, train_files, build_uc_model)\n",
- "@time solve!(solver_ml, test_files, build_uc_model);"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "59c709bf",
- "metadata": {},
- "source": [
- "The trained MIP solver was able to solve all test instances in about 6 seconds. To see that ML is being helpful here, let us repeat the code above, but remove the `fit!` line:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "id": "cab08714",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- " 10.308870 seconds (8.19 M allocations: 279.036 MiB, 0.45% gc time)\n"
- ]
- }
- ],
- "source": [
- "solver_baseline = LearningSolver(scip)\n",
- "@time solve!(solver_baseline, test_files, build_uc_model);"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "fb9fbfa7",
- "metadata": {},
- "source": [
- "Without the help of the ML models, SCIP took around 10 seconds to solve the same test instances.\n",
- "\n",
- "
\n",
- "Note\n",
- " \n",
- "Note that is is not necessary to specify what ML models to use. MIPLearn, by default, will try a number of classical ML models and will choose the one that performs the best, based on k-fold cross validation. MIPLearn is also able to automatically collect features based on the MIP formulation of the problem and the solution to the LP relaxation, among other things, so it does not require handcrafted features. If you do want to customize the models and features, however, that is also possible, as we will see in a later tutorial.\n",
- "
"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "dc1bc410",
- "metadata": {},
- "source": [
- "## Understanding the acceleration\n",
- "\n",
- "Let us go a bit deeper and try to understand how exactly did MIPLearn accelerate SCIP's performance. First, we are going to solve one of the test instances again, using the trained solver, but this time using the `tee=true` parameter, so that we can see SCIP's log:"
+ "With training data in hand, we can now fit the ML models using `MIPLearn.fit!`, then solve the test instances with `MIPLearn.solve!`, as shown below. The `tee=true` parameter asks MIPLearn to print the solver log to the screen."
]
},
{
"cell_type": "code",
- "execution_count": 12,
- "id": "cd429f82",
+ "execution_count": 9,
+ "id": "1cf11450",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "presolving:\n",
- "(round 1, fast) 861 del vars, 861 del conss, 0 add conss, 2000 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 0 clqs\n",
- "(round 2, fast) 861 del vars, 1722 del conss, 0 add conss, 2000 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 0 clqs\n",
- "(round 3, fast) 862 del vars, 1722 del conss, 0 add conss, 2000 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 0 clqs\n",
- "presolving (4 rounds: 4 fast, 1 medium, 1 exhaustive):\n",
- " 862 deleted vars, 1722 deleted constraints, 0 added constraints, 2000 tightened bounds, 0 added holes, 0 changed sides, 0 changed coefficients\n",
- " 0 implications, 0 cliques\n",
- "presolved problem has 1138 variables (0 bin, 0 int, 0 impl, 1138 cont) and 279 constraints\n",
- " 279 constraints of type
\n",
- "Presolving Time: 0.03\n",
+ "Gurobi Optimizer version 9.1.1 build v9.1.1rc0 (linux64)\n",
+ "Thread count: 16 physical cores, 32 logical processors, using up to 1 threads\n",
+ "Optimize a model with 101 rows, 100 columns and 250 nonzeros\n",
+ "Model fingerprint: 0xfb382c05\n",
+ "Coefficient statistics:\n",
+ " Matrix range [1e+00, 1e+03]\n",
+ " Objective range [1e+00, 6e+04]\n",
+ " Bounds range [1e+00, 1e+00]\n",
+ " RHS range [2e+04, 2e+04]\n",
+ "Presolve removed 100 rows and 50 columns\n",
+ "Presolve time: 0.00s\n",
+ "Presolved: 1 rows, 50 columns, 50 nonzeros\n",
+ "\n",
+ "Iteration Objective Primal Inf. Dual Inf. Time\n",
+ " 0 7.0629410e+05 6.782322e+02 0.000000e+00 0s\n",
+ " 1 8.0678161e+05 0.000000e+00 0.000000e+00 0s\n",
+ "\n",
+ "Solved in 1 iterations and 0.00 seconds\n",
+ "Optimal objective 8.067816095e+05\n",
+ "\n",
+ "User-callback calls 33, time in user-callback 0.00 sec\n",
+ "\n",
+ "Gurobi Optimizer version 9.1.1 build v9.1.1rc0 (linux64)\n",
+ "Thread count: 16 physical cores, 32 logical processors, using up to 1 threads\n",
+ "Optimize a model with 101 rows, 100 columns and 250 nonzeros\n",
+ "Model fingerprint: 0x7bb6bbd6\n",
+ "Variable types: 50 continuous, 50 integer (50 binary)\n",
+ "Coefficient statistics:\n",
+ " Matrix range [1e+00, 1e+03]\n",
+ " Objective range [1e+00, 6e+04]\n",
+ " Bounds range [1e+00, 1e+00]\n",
+ " RHS range [2e+04, 2e+04]\n",
"\n",
- " time | node | left |LP iter|LP it/n|mem/heur|mdpt |vars |cons |rows |cuts |sepa|confs|strbr| dualbound | primalbound | gap | compl. \n",
- "* 0.0s| 1 | 0 | 203 | - | LP | 0 |1138 | 279 | 279 | 0 | 0 | 0 | 0 | 1.705035e+07 | 1.705035e+07 | 0.00%| unknown\n",
- " 0.0s| 1 | 0 | 203 | - | 8950k | 0 |1138 | 279 | 279 | 0 | 0 | 0 | 0 | 1.705035e+07 | 1.705035e+07 | 0.00%| unknown\n",
+ "User MIP start produced solution with objective 822175 (0.00s)\n",
+ "User MIP start produced solution with objective 812767 (0.00s)\n",
+ "User MIP start produced solution with objective 811628 (0.00s)\n",
+ "User MIP start produced solution with objective 809648 (0.01s)\n",
+ "User MIP start produced solution with objective 808536 (0.01s)\n",
+ "Loaded user MIP start with objective 808536\n",
"\n",
- "SCIP Status : problem is solved [optimal solution found]\n",
- "Solving Time (sec) : 0.04\n",
- "Solving Nodes : 1\n",
- "Primal Bound : +1.70503465600131e+07 (1 solutions)\n",
- "Dual Bound : +1.70503465600131e+07\n",
- "Gap : 0.00 %\n",
+ "Presolve time: 0.00s\n",
+ "Presolved: 101 rows, 100 columns, 250 nonzeros\n",
+ "Variable types: 50 continuous, 50 integer (50 binary)\n",
"\n",
- "violation: integrality condition of variable <> = 0.338047247943162\n",
- "all 1 solutions given by solution candidate storage are infeasible\n",
+ "Root relaxation: objective 8.067816e+05, 55 iterations, 0.00 seconds\n",
"\n",
- "feasible solution found by completesol heuristic after 0.1 seconds, objective value 1.705169e+07\n",
- "presolving:\n",
- "(round 1, fast) 0 del vars, 0 del conss, 0 add conss, 3000 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 0 clqs\n",
- "(round 2, exhaustive) 0 del vars, 0 del conss, 0 add conss, 3000 chg bounds, 0 chg sides, 0 chg coeffs, 1000 upgd conss, 0 impls, 0 clqs\n",
- "(round 3, exhaustive) 0 del vars, 0 del conss, 0 add conss, 3000 chg bounds, 0 chg sides, 0 chg coeffs, 2000 upgd conss, 1000 impls, 0 clqs\n",
- " (0.1s) probing: 51/1000 (5.1%) - 0 fixings, 0 aggregations, 0 implications, 0 bound changes\n",
- " (0.1s) probing aborted: 50/50 successive totally useless probings\n",
- " (0.1s) symmetry computation started: requiring (bin +, int -, cont +), (fixed: bin -, int +, cont -)\n",
- " (0.1s) no symmetry present\n",
- "presolving (4 rounds: 4 fast, 3 medium, 3 exhaustive):\n",
- " 0 deleted vars, 0 deleted constraints, 0 added constraints, 3000 tightened bounds, 0 added holes, 0 changed sides, 0 changed coefficients\n",
- " 2000 implications, 0 cliques\n",
- "presolved problem has 2000 variables (1000 bin, 0 int, 0 impl, 1000 cont) and 2001 constraints\n",
- " 2000 constraints of type \n",
- " 1 constraints of type \n",
- "Presolving Time: 0.11\n",
- "transformed 1/1 original solutions to the transformed problem space\n",
+ " Nodes | Current Node | Objective Bounds | Work\n",
+ " Expl Unexpl | Obj Depth IntInf | Incumbent BestBd Gap | It/Node Time\n",
"\n",
- " time | node | left |LP iter|LP it/n|mem/heur|mdpt |vars |cons |rows |cuts |sepa|confs|strbr| dualbound | primalbound | gap | compl. \n",
- " 0.2s| 1 | 0 | 1201 | - | 20M | 0 |2000 |2001 |2001 | 0 | 0 | 0 | 0 | 1.705035e+07 | 1.705169e+07 | 0.01%| unknown\n",
+ " 0 0 806781.610 0 1 808536.496 806781.610 0.22% - 0s\n",
+ "H 0 0 808091.02482 806781.610 0.16% - 0s\n",
+ " 0 0 807198.955 0 2 808091.025 807198.955 0.11% - 0s\n",
+ " 0 0 807198.955 0 1 808091.025 807198.955 0.11% - 0s\n",
+ " 0 0 807198.955 0 2 808091.025 807198.955 0.11% - 0s\n",
+ " 0 0 807226.059 0 3 808091.025 807226.059 0.11% - 0s\n",
+ " 0 0 807240.578 0 5 808091.025 807240.578 0.11% - 0s\n",
+ " 0 0 807240.663 0 5 808091.025 807240.663 0.11% - 0s\n",
+ " 0 0 807259.825 0 4 808091.025 807259.825 0.10% - 0s\n",
+ " 0 0 807275.314 0 5 808091.025 807275.314 0.10% - 0s\n",
+ " 0 0 807279.037 0 6 808091.025 807279.037 0.10% - 0s\n",
+ " 0 0 807291.881 0 8 808091.025 807291.881 0.10% - 0s\n",
+ " 0 0 807325.323 0 6 808091.025 807325.323 0.09% - 0s\n",
+ " 0 0 807326.015 0 7 808091.025 807326.015 0.09% - 0s\n",
+ " 0 0 807326.798 0 7 808091.025 807326.798 0.09% - 0s\n",
+ " 0 0 807328.550 0 8 808091.025 807328.550 0.09% - 0s\n",
+ " 0 0 807331.193 0 9 808091.025 807331.193 0.09% - 0s\n",
+ " 0 0 807332.143 0 7 808091.025 807332.143 0.09% - 0s\n",
+ " 0 0 807335.410 0 8 808091.025 807335.410 0.09% - 0s\n",
+ " 0 0 807335.452 0 8 808091.025 807335.452 0.09% - 0s\n",
+ " 0 0 807337.253 0 9 808091.025 807337.253 0.09% - 0s\n",
+ " 0 0 807337.409 0 9 808091.025 807337.409 0.09% - 0s\n",
+ " 0 0 807347.720 0 8 808091.025 807347.720 0.09% - 0s\n",
+ " 0 0 807352.765 0 7 808091.025 807352.765 0.09% - 0s\n",
+ " 0 0 807366.618 0 9 808091.025 807366.618 0.09% - 0s\n",
+ " 0 0 807368.345 0 10 808091.025 807368.345 0.09% - 0s\n",
+ " 0 0 807369.195 0 10 808091.025 807369.195 0.09% - 0s\n",
+ " 0 0 807392.319 0 8 808091.025 807392.319 0.09% - 0s\n",
+ " 0 0 807401.436 0 9 808091.025 807401.436 0.09% - 0s\n",
+ " 0 0 807405.685 0 8 808091.025 807405.685 0.08% - 0s\n",
+ " 0 0 807411.994 0 8 808091.025 807411.994 0.08% - 0s\n",
+ " 0 0 807424.710 0 9 808091.025 807424.710 0.08% - 0s\n",
+ " 0 0 807424.867 0 11 808091.025 807424.867 0.08% - 0s\n",
+ " 0 0 807427.428 0 12 808091.025 807427.428 0.08% - 0s\n",
+ " 0 0 807433.211 0 10 808091.025 807433.211 0.08% - 0s\n",
+ " 0 0 807439.215 0 10 808091.025 807439.215 0.08% - 0s\n",
+ " 0 0 807439.303 0 11 808091.025 807439.303 0.08% - 0s\n",
+ " 0 0 807443.312 0 11 808091.025 807443.312 0.08% - 0s\n",
+ " 0 0 807444.488 0 12 808091.025 807444.488 0.08% - 0s\n",
+ " 0 0 807444.499 0 13 808091.025 807444.499 0.08% - 0s\n",
+ " 0 0 807444.499 0 13 808091.025 807444.499 0.08% - 0s\n",
+ " 0 2 807445.982 0 13 808091.025 807445.982 0.08% - 0s\n",
"\n",
- "SCIP Status : solving was interrupted [gap limit reached]\n",
- "Solving Time (sec) : 0.21\n",
- "Solving Nodes : 1\n",
- "Primal Bound : +1.70516871251443e+07 (1 solutions)\n",
- "Dual Bound : +1.70503465600130e+07\n",
- "Gap : 0.01 %\n",
+ "Cutting planes:\n",
+ " Cover: 3\n",
+ " MIR: 18\n",
+ " StrongCG: 1\n",
+ " Flow cover: 3\n",
+ "\n",
+ "Explored 39 nodes (333 simplex iterations) in 0.03 seconds\n",
+ "Thread count was 1 (of 32 available processors)\n",
+ "\n",
+ "Solution count 6: 808091 808536 809648 ... 822175\n",
+ "\n",
+ "Optimal solution found (tolerance 1.00e-04)\n",
+ "Best objective 8.080910248225e+05, best bound 8.080640878016e+05, gap 0.0033%\n",
+ "\n",
+ "User-callback calls 341, time in user-callback 0.00 sec\n",
"\n"
]
}
],
"source": [
+ "solver_ml = LearningSolver(gurobi)\n",
+ "fit!(solver_ml, train_files, build_uc_model)\n",
"solve!(solver_ml, test_files[1], build_uc_model, tee=true);"
]
},
{
"cell_type": "markdown",
- "id": "8b14440d",
+ "id": "872211e7",
"metadata": {},
"source": [
- "The log above is quite complicated if you have never seen it before, but the important line is the one starting with `feasible solution found [...] objective value 1.705169e+07`. This line indicates that MIPLearn was able to construct a warm start with value `1.705169e+07`. Using this warm start, SCIP then used the branch-and-cut method to either prove its optimality or to find an even better solution. Very quickly, however, SCIP proved that the solution produced by MIPLearn was indeed optimal. It was able to do this without generating a single cutting plane or running any other heuristics; it could tell the optimality by the root LP relaxation alone, which was very fast. \n",
- "\n",
- "Let us now repeat the process, but using the untrained solver this time:"
+ "By examining the solve log above, specifically the line `Loaded user MIP start with objective...`, we can see that MIPLearn was able to construct an initial solution which turned out to be near optimal for the problem. Now let us repeat the code above, but using an untrained solver. Note that the `fit` line is omitted."
]
},
{
"cell_type": "code",
- "execution_count": 13,
- "id": "3a96934a",
+ "execution_count": 10,
+ "id": "fc1e3629",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "presolving:\n",
- "(round 1, fast) 861 del vars, 861 del conss, 0 add conss, 2000 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 0 clqs\n",
- "(round 2, fast) 861 del vars, 1722 del conss, 0 add conss, 2000 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 0 clqs\n",
- "(round 3, fast) 862 del vars, 1722 del conss, 0 add conss, 2000 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 0 clqs\n",
- "presolving (4 rounds: 4 fast, 1 medium, 1 exhaustive):\n",
- " 862 deleted vars, 1722 deleted constraints, 0 added constraints, 2000 tightened bounds, 0 added holes, 0 changed sides, 0 changed coefficients\n",
- " 0 implications, 0 cliques\n",
- "presolved problem has 1138 variables (0 bin, 0 int, 0 impl, 1138 cont) and 279 constraints\n",
- " 279 constraints of type \n",
- "Presolving Time: 0.03\n",
+ "Gurobi Optimizer version 9.1.1 build v9.1.1rc0 (linux64)\n",
+ "Thread count: 16 physical cores, 32 logical processors, using up to 1 threads\n",
+ "Optimize a model with 101 rows, 100 columns and 250 nonzeros\n",
+ "Model fingerprint: 0xfb382c05\n",
+ "Coefficient statistics:\n",
+ " Matrix range [1e+00, 1e+03]\n",
+ " Objective range [1e+00, 6e+04]\n",
+ " Bounds range [1e+00, 1e+00]\n",
+ " RHS range [2e+04, 2e+04]\n",
+ "Presolve removed 100 rows and 50 columns\n",
+ "Presolve time: 0.00s\n",
+ "Presolved: 1 rows, 50 columns, 50 nonzeros\n",
+ "\n",
+ "Iteration Objective Primal Inf. Dual Inf. Time\n",
+ " 0 7.0629410e+05 6.782322e+02 0.000000e+00 0s\n",
+ " 1 8.0678161e+05 0.000000e+00 0.000000e+00 0s\n",
+ "\n",
+ "Solved in 1 iterations and 0.00 seconds\n",
+ "Optimal objective 8.067816095e+05\n",
"\n",
- " time | node | left |LP iter|LP it/n|mem/heur|mdpt |vars |cons |rows |cuts |sepa|confs|strbr| dualbound | primalbound | gap | compl. \n",
- "* 0.0s| 1 | 0 | 203 | - | LP | 0 |1138 | 279 | 279 | 0 | 0 | 0 | 0 | 1.705035e+07 | 1.705035e+07 | 0.00%| unknown\n",
- " 0.0s| 1 | 0 | 203 | - | 8950k | 0 |1138 | 279 | 279 | 0 | 0 | 0 | 0 | 1.705035e+07 | 1.705035e+07 | 0.00%| unknown\n",
+ "User-callback calls 33, time in user-callback 0.00 sec\n",
"\n",
- "SCIP Status : problem is solved [optimal solution found]\n",
- "Solving Time (sec) : 0.04\n",
- "Solving Nodes : 1\n",
- "Primal Bound : +1.70503465600131e+07 (1 solutions)\n",
- "Dual Bound : +1.70503465600131e+07\n",
- "Gap : 0.00 %\n",
+ "Gurobi Optimizer version 9.1.1 build v9.1.1rc0 (linux64)\n",
+ "Thread count: 16 physical cores, 32 logical processors, using up to 1 threads\n",
+ "Optimize a model with 101 rows, 100 columns and 250 nonzeros\n",
+ "Model fingerprint: 0x899aac3d\n",
+ "Variable types: 50 continuous, 50 integer (50 binary)\n",
+ "Coefficient statistics:\n",
+ " Matrix range [1e+00, 1e+03]\n",
+ " Objective range [1e+00, 6e+04]\n",
+ " Bounds range [1e+00, 1e+00]\n",
+ " RHS range [2e+04, 2e+04]\n",
+ "Found heuristic solution: objective 893073.33620\n",
+ "Presolve time: 0.00s\n",
+ "Presolved: 101 rows, 100 columns, 250 nonzeros\n",
+ "Variable types: 50 continuous, 50 integer (50 binary)\n",
"\n",
- "violation: integrality condition of variable <> = 0.338047247943162\n",
- "all 1 solutions given by solution candidate storage are infeasible\n",
+ "Root relaxation: objective 8.067816e+05, 55 iterations, 0.00 seconds\n",
"\n",
- "presolving:\n",
- "(round 1, fast) 0 del vars, 0 del conss, 0 add conss, 2000 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 0 clqs\n",
- "(round 2, exhaustive) 0 del vars, 0 del conss, 0 add conss, 2000 chg bounds, 0 chg sides, 0 chg coeffs, 1000 upgd conss, 0 impls, 0 clqs\n",
- "(round 3, exhaustive) 0 del vars, 0 del conss, 0 add conss, 2000 chg bounds, 0 chg sides, 0 chg coeffs, 2000 upgd conss, 1000 impls, 0 clqs\n",
- " (0.0s) probing: 51/1000 (5.1%) - 0 fixings, 0 aggregations, 0 implications, 0 bound changes\n",
- " (0.0s) probing aborted: 50/50 successive totally useless probings\n",
- " (0.0s) symmetry computation started: requiring (bin +, int -, cont +), (fixed: bin -, int +, cont -)\n",
- " (0.0s) no symmetry present\n",
- "presolving (4 rounds: 4 fast, 3 medium, 3 exhaustive):\n",
- " 0 deleted vars, 0 deleted constraints, 0 added constraints, 2000 tightened bounds, 0 added holes, 0 changed sides, 0 changed coefficients\n",
- " 2000 implications, 0 cliques\n",
- "presolved problem has 2000 variables (1000 bin, 0 int, 0 impl, 1000 cont) and 2001 constraints\n",
- " 2000 constraints of type \n",
- " 1 constraints of type \n",
- "Presolving Time: 0.03\n",
+ " Nodes | Current Node | Objective Bounds | Work\n",
+ " Expl Unexpl | Obj Depth IntInf | Incumbent BestBd Gap | It/Node Time\n",
"\n",
- " time | node | left |LP iter|LP it/n|mem/heur|mdpt |vars |cons |rows |cuts |sepa|confs|strbr| dualbound | primalbound | gap | compl. \n",
- "p 0.0s| 1 | 0 | 1 | - | locks| 0 |2000 |2001 |2001 | 0 | 0 | 0 | 0 | 0.000000e+00 | 2.335200e+07 | Inf | unknown\n",
- "p 0.0s| 1 | 0 | 2 | - | vbounds| 0 |2000 |2001 |2001 | 0 | 0 | 0 | 0 | 0.000000e+00 | 1.839873e+07 | Inf | unknown\n",
- " 0.1s| 1 | 0 | 1204 | - | 20M | 0 |2000 |2001 |2001 | 0 | 0 | 0 | 0 | 1.705035e+07 | 1.839873e+07 | 7.91%| unknown\n",
- " 0.1s| 1 | 0 | 1207 | - | 22M | 0 |2000 |2001 |2002 | 1 | 1 | 0 | 0 | 1.705036e+07 | 1.839873e+07 | 7.91%| unknown\n",
- "r 0.1s| 1 | 0 | 1207 | - |shifting| 0 |2000 |2001 |2002 | 1 | 1 | 0 | 0 | 1.705036e+07 | 1.711399e+07 | 0.37%| unknown\n",
- " 0.1s| 1 | 0 | 1209 | - | 22M | 0 |2000 |2001 |2003 | 2 | 2 | 0 | 0 | 1.705037e+07 | 1.711399e+07 | 0.37%| unknown\n",
- "r 0.1s| 1 | 0 | 1209 | - |shifting| 0 |2000 |2001 |2003 | 2 | 2 | 0 | 0 | 1.705037e+07 | 1.706492e+07 | 0.09%| unknown\n",
- " 0.1s| 1 | 0 | 1210 | - | 22M | 0 |2000 |2001 |2004 | 3 | 3 | 0 | 0 | 1.705037e+07 | 1.706492e+07 | 0.09%| unknown\n",
- " 0.1s| 1 | 0 | 1211 | - | 23M | 0 |2000 |2001 |2005 | 4 | 4 | 0 | 0 | 1.705037e+07 | 1.706492e+07 | 0.09%| unknown\n",
- " 0.1s| 1 | 0 | 1212 | - | 23M | 0 |2000 |2001 |2006 | 5 | 5 | 0 | 0 | 1.705037e+07 | 1.706492e+07 | 0.09%| unknown\n",
- "r 0.1s| 1 | 0 | 1212 | - |shifting| 0 |2000 |2001 |2006 | 5 | 5 | 0 | 0 | 1.705037e+07 | 1.706228e+07 | 0.07%| unknown\n",
- " 0.1s| 1 | 0 | 1214 | - | 24M | 0 |2000 |2001 |2007 | 6 | 7 | 0 | 0 | 1.705037e+07 | 1.706228e+07 | 0.07%| unknown\n",
- " 0.2s| 1 | 0 | 1216 | - | 24M | 0 |2000 |2001 |2009 | 8 | 8 | 0 | 0 | 1.705037e+07 | 1.706228e+07 | 0.07%| unknown\n",
- " 0.2s| 1 | 0 | 1220 | - | 25M | 0 |2000 |2001 |2011 | 10 | 9 | 0 | 0 | 1.705037e+07 | 1.706228e+07 | 0.07%| unknown\n",
- " 0.2s| 1 | 0 | 1223 | - | 25M | 0 |2000 |2001 |2014 | 13 | 10 | 0 | 0 | 1.705037e+07 | 1.706228e+07 | 0.07%| unknown\n",
- " time | node | left |LP iter|LP it/n|mem/heur|mdpt |vars |cons |rows |cuts |sepa|confs|strbr| dualbound | primalbound | gap | compl. \n",
- " 0.2s| 1 | 0 | 1229 | - | 26M | 0 |2000 |2001 |2015 | 14 | 11 | 0 | 0 | 1.705038e+07 | 1.706228e+07 | 0.07%| unknown\n",
- "r 0.2s| 1 | 0 | 1403 | - |intshift| 0 |2000 |2001 |2015 | 14 | 11 | 0 | 0 | 1.705038e+07 | 1.705687e+07 | 0.04%| unknown\n",
- "L 0.7s| 1 | 0 | 1707 | - | rens| 0 |2000 |2001 |2015 | 14 | 11 | 0 | 0 | 1.705038e+07 | 1.705332e+07 | 0.02%| unknown\n",
- "L 0.7s| 1 | 0 | 1707 | - | alns| 0 |2000 |2001 |2015 | 14 | 11 | 0 | 0 | 1.705038e+07 | 1.705178e+07 | 0.01%| unknown\n",
+ " 0 0 806781.610 0 1 893073.336 806781.610 9.66% - 0s\n",
+ "H 0 0 842766.25007 806781.610 4.27% - 0s\n",
+ "H 0 0 818273.05208 806781.610 1.40% - 0s\n",
+ " 0 0 807198.955 0 2 818273.052 807198.955 1.35% - 0s\n",
+ "H 0 0 813499.43980 807198.955 0.77% - 0s\n",
+ " 0 0 807246.085 0 3 813499.440 807246.085 0.77% - 0s\n",
+ " 0 0 807272.377 0 4 813499.440 807272.377 0.77% - 0s\n",
+ " 0 0 807284.557 0 1 813499.440 807284.557 0.76% - 0s\n",
+ " 0 0 807298.666 0 2 813499.440 807298.666 0.76% - 0s\n",
+ " 0 0 807305.559 0 6 813499.440 807305.559 0.76% - 0s\n",
+ "H 0 0 812223.58825 807305.559 0.61% - 0s\n",
+ " 0 0 807309.503 0 4 812223.588 807309.503 0.61% - 0s\n",
+ " 0 0 807339.469 0 4 812223.588 807339.469 0.60% - 0s\n",
+ " 0 0 807344.135 0 6 812223.588 807344.135 0.60% - 0s\n",
+ " 0 0 807359.565 0 7 812223.588 807359.565 0.60% - 0s\n",
+ " 0 0 807371.997 0 8 812223.588 807371.997 0.60% - 0s\n",
+ " 0 0 807372.245 0 8 812223.588 807372.245 0.60% - 0s\n",
+ " 0 0 807378.545 0 9 812223.588 807378.545 0.60% - 0s\n",
+ " 0 0 807378.545 0 9 812223.588 807378.545 0.60% - 0s\n",
+ "H 0 0 811628.30751 807378.545 0.52% - 0s\n",
+ "H 0 0 810280.45754 807378.545 0.36% - 0s\n",
+ " 0 0 807378.545 0 1 810280.458 807378.545 0.36% - 0s\n",
+ "H 0 0 810123.10116 807378.545 0.34% - 0s\n",
+ " 0 0 807378.545 0 1 810123.101 807378.545 0.34% - 0s\n",
+ " 0 0 807378.545 0 3 810123.101 807378.545 0.34% - 0s\n",
+ " 0 0 807378.545 0 7 810123.101 807378.545 0.34% - 0s\n",
+ " 0 0 807379.672 0 8 810123.101 807379.672 0.34% - 0s\n",
+ " 0 0 807379.905 0 9 810123.101 807379.905 0.34% - 0s\n",
+ " 0 0 807380.615 0 10 810123.101 807380.615 0.34% - 0s\n",
+ " 0 0 807402.384 0 10 810123.101 807402.384 0.34% - 0s\n",
+ " 0 0 807407.299 0 12 810123.101 807407.299 0.34% - 0s\n",
+ " 0 0 807407.299 0 12 810123.101 807407.299 0.34% - 0s\n",
+ " 0 2 807408.320 0 12 810123.101 807408.320 0.34% - 0s\n",
+ "H 3 3 809647.65837 807476.463 0.27% 3.0 0s\n",
+ "H 84 35 808870.26352 807568.065 0.16% 2.7 0s\n",
+ "H 99 29 808536.49552 807588.561 0.12% 2.7 0s\n",
+ "* 310 1 5 808091.02482 808069.217 0.00% 3.3 0s\n",
"\n",
- "SCIP Status : solving was interrupted [gap limit reached]\n",
- "Solving Time (sec) : 0.69\n",
- "Solving Nodes : 1\n",
- "Primal Bound : +1.70517823853380e+07 (13 solutions)\n",
- "Dual Bound : +1.70503798271962e+07\n",
- "Gap : 0.01 %\n",
+ "Cutting planes:\n",
+ " Gomory: 3\n",
+ " Cover: 7\n",
+ " MIR: 9\n",
+ " Flow cover: 3\n",
+ "\n",
+ "Explored 311 nodes (1175 simplex iterations) in 0.06 seconds\n",
+ "Thread count was 1 (of 32 available processors)\n",
+ "\n",
+ "Solution count 10: 808091 808536 808870 ... 818273\n",
+ "\n",
+ "Optimal solution found (tolerance 1.00e-04)\n",
+ "Best objective 8.080910248225e+05, best bound 8.080692169045e+05, gap 0.0027%\n",
+ "\n",
+ "User-callback calls 832, time in user-callback 0.00 sec\n",
"\n"
]
}
],
"source": [
+ "solver_baseline = LearningSolver(gurobi)\n",
"solve!(solver_baseline, test_files[1], build_uc_model, tee=true);"
]
},
{
"cell_type": "markdown",
- "id": "92d23037",
+ "id": "7b5ce528",
"metadata": {},
"source": [
- "In this log file, notice how the previous line about warm starts is missing. Since no warm starts were provided, SCIP had to find an initial solution using its own internal heuristics, which are not specifically tailored for this problem. The initial solution found by SCIP's heuristics has value `2.335200e+07`, which is significantly worse than the one constructed by MIPLearn. SCIP then proceeded to improve this solution, by generating cutting planes and repeatedly running additional primal heuristics. In the end, it was able to find the optimal solution, as expected, but it took longer.\n",
+ "In the log above, the `MIP start` line is missing, and Gurobi had to start with a significantly inferior initial solution. The solver was still able to find the optimal solution at the end, but it required using its own internal heuristic procedures. In this example, because we solve very small optimization problems, there was almost no difference in terms of running time. For larger problems, however, the difference can be significant. See benchmarks for more details.\n",
+ "\n",
+ "\n",
+ "Note\n",
+ " \n",
+ "In addition to partial initial solutions, MIPLearn is also able to predict lazy constraints, cutting planes and branching priorities. See the next tutorials for more details.\n",
+ "
\n",
"\n",
- "In summary, MIPLearn accelerated the solution process by constructing a high-quality initial solution. In the following tutorials, we will see other strategies that MIPLearn can use to accelerate MIP performance, besides warm starts."
+ "\n",
+ "Note\n",
+ " \n",
+ "It is not necessary to specify what ML models to use. MIPLearn, by default, will try a number of classical ML models and will choose the one that performs the best, based on k-fold cross validation. MIPLearn is also able to automatically collect features based on the MIP formulation of the problem and the solution to the LP relaxation, among other things, so it does not require handcrafted features. If you do want to customize the models and features, however, that is also possible, as we will see in a later tutorial.\n",
+ "
"
]
},
{
"cell_type": "markdown",
- "id": "94f869d7",
+ "id": "46da094b",
"metadata": {},
"source": [
"## Accessing the solution\n",
"\n",
- "In the example above, we used `MIPLearn.solve!` together with data files to solve both the training and the test instances. The solutions were saved to a `.h5` files in the train/test folders, and could be retrieved by reading theses files, but that is not very convenient. In this section we will use an easier method.\n",
- "\n",
- "We can use the function `MIPLearn.load!` to obtain a regular JuMP model:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "id": "948d3056",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "A JuMP Model\n",
- "Minimization problem with:\n",
- "Variables: 2000\n",
- "Objective function type: AffExpr\n",
- "`AffExpr`-in-`MathOptInterface.EqualTo{Float64}`: 1 constraint\n",
- "`AffExpr`-in-`MathOptInterface.GreaterThan{Float64}`: 1000 constraints\n",
- "`AffExpr`-in-`MathOptInterface.LessThan{Float64}`: 1000 constraints\n",
- "`VariableRef`-in-`MathOptInterface.GreaterThan{Float64}`: 1000 constraints\n",
- "`VariableRef`-in-`MathOptInterface.ZeroOne`: 1000 constraints\n",
- "Model mode: AUTOMATIC\n",
- "CachingOptimizer state: NO_OPTIMIZER\n",
- "Solver name: No optimizer attached.\n",
- "Names registered in the model: eq_demand, eq_max_power, eq_min_power, x, y"
- ]
- },
- "execution_count": 14,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "model = MIPLearn.load(\"uc/test/000001.jld2\", build_uc_model)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "0b689ac5",
- "metadata": {},
- "source": [
- "We can then solve this model as before, with `MIPLearn.solve!`:"
+ "In the example above, we used `MIPLearn.solve` together with data files to solve both the training and the test instances. The optimal solutions were saved to HDF5 files in the train/test folders, and could be retrieved by reading theses files, but that is not very convenient. In the following example, we show how to build and solve a JuMP model entirely in-memory, using our trained solver."
]
},
{
"cell_type": "code",
- "execution_count": 15,
- "id": "696a33ae",
+ "execution_count": 11,
+ "id": "986f0c18",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "obj = 1.7051217395548128e7\n",
- " x = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]\n",
- " y = [767.11, 646.61, 230.28, 365.46, 1150.99, 1103.36, 0.0, 0.0, 0.0, 0.0]\n"
+ "obj = 809710.340270503\n",
+ " x = [1.0, -0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0]\n",
+ " y = [696.38, 0.0, 249.05, 0.0, 1183.75, 0.0, 504.91, 387.32, 1178.0, 765.25]\n"
]
}
],
"source": [
+ "# Construct model using previously defined functions\n",
+ "data = random_uc_data(samples=1, n=50)[1]\n",
+ "model = build_uc_model(data)\n",
+ "\n",
+ "# Solve model\n",
"solve!(solver_ml, model)\n",
+ "\n",
+ "# Print part of the optimal solution\n",
"println(\"obj = \", objective_value(model))\n",
"println(\" x = \", round.(value.(model[:x][1:10])))\n",
"println(\" y = \", round.(value.(model[:y][1:10]), digits=2))"
]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f43ed281",
+ "metadata": {},
+ "outputs": [],
+ "source": []
}
],
"metadata": {
"kernelspec": {
- "display_name": "Julia 1.6.0",
+ "display_name": "Julia 1.6.2",
"language": "julia",
"name": "julia-1.6"
},
@@ -751,7 +683,7 @@
"file_extension": ".jl",
"mimetype": "application/julia",
"name": "julia",
- "version": "1.6.0"
+ "version": "1.6.2"
}
},
"nbformat": 4,
diff --git a/docs/pyomo-tutorials/getting-started.ipynb b/docs/pyomo-tutorials/getting-started.ipynb
index 189b148..46d7c2c 100644
--- a/docs/pyomo-tutorials/getting-started.ipynb
+++ b/docs/pyomo-tutorials/getting-started.ipynb
@@ -3,9 +3,11 @@
{
"cell_type": "markdown",
"id": "6b8983b1",
- "metadata": {},
+ "metadata": {
+ "tags": []
+ },
"source": [
- "# Getting started with MIPLearn\n",
+ "# Getting started\n",
"\n",
"## Introduction\n",
"\n",
@@ -50,64 +52,9 @@
"execution_count": 1,
"id": "cd8a69c1",
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Defaulting to user installation because normal site-packages is not writeable\n",
- "Requirement already satisfied: MIPLearn==0.2.0.dev13 in /home/axavier/.local/lib/python3.7/site-packages (0.2.0.dev13)\n",
- "Requirement already satisfied: p-tqdm<2,>=1 in /home/axavier/.local/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (1.3.3)\n",
- "Requirement already satisfied: overrides<4,>=3 in /home/axavier/.local/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (3.1.0)\n",
- "Requirement already satisfied: scikit-learn<0.25,>=0.24 in /opt/anaconda3/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (0.24.1)\n",
- "Requirement already satisfied: h5py<4,>=3 in /home/axavier/.local/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (3.5.0)\n",
- "Requirement already satisfied: matplotlib<4,>=3 in /home/axavier/.local/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (3.4.1)\n",
- "Requirement already satisfied: seaborn<0.12,>=0.11 in /opt/anaconda3/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (0.11.1)\n",
- "Requirement already satisfied: python-markdown-math<0.9,>=0.8 in /home/axavier/.local/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (0.8)\n",
- "Requirement already satisfied: decorator<5,>=4 in /home/axavier/.local/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (4.4.2)\n",
- "Requirement already satisfied: mypy==0.790 in /home/axavier/.local/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (0.790)\n",
- "Requirement already satisfied: pandas<2,>=1 in /opt/anaconda3/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (1.2.3)\n",
- "Requirement already satisfied: pytest<7,>=6 in /opt/anaconda3/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (6.2.3)\n",
- "Requirement already satisfied: numpy<1.21,>=1 in /home/axavier/.local/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (1.19.5)\n",
- "Requirement already satisfied: tqdm<5,>=4 in /home/axavier/.local/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (4.60.0)\n",
- "Requirement already satisfied: pyomo<6,>=5 in /home/axavier/.local/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (5.7.3)\n",
- "Requirement already satisfied: networkx<3,>=2 in /home/axavier/.local/lib/python3.7/site-packages (from MIPLearn==0.2.0.dev13) (2.5.1)\n",
- "Requirement already satisfied: typed-ast<1.5.0,>=1.4.0 in /opt/anaconda3/lib/python3.7/site-packages (from mypy==0.790->MIPLearn==0.2.0.dev13) (1.4.2)\n",
- "Requirement already satisfied: typing-extensions>=3.7.4 in /opt/anaconda3/lib/python3.7/site-packages (from mypy==0.790->MIPLearn==0.2.0.dev13) (3.7.4.3)\n",
- "Requirement already satisfied: mypy-extensions<0.5.0,>=0.4.3 in /home/axavier/.local/lib/python3.7/site-packages (from mypy==0.790->MIPLearn==0.2.0.dev13) (0.4.3)\n",
- "Requirement already satisfied: cached-property in /home/axavier/.local/lib/python3.7/site-packages (from h5py<4,>=3->MIPLearn==0.2.0.dev13) (1.5.2)\n",
- "Requirement already satisfied: pyparsing>=2.2.1 in /opt/anaconda3/lib/python3.7/site-packages (from matplotlib<4,>=3->MIPLearn==0.2.0.dev13) (2.4.7)\n",
- "Requirement already satisfied: pillow>=6.2.0 in /opt/anaconda3/lib/python3.7/site-packages (from matplotlib<4,>=3->MIPLearn==0.2.0.dev13) (8.2.0)\n",
- "Requirement already satisfied: python-dateutil>=2.7 in /opt/anaconda3/lib/python3.7/site-packages (from matplotlib<4,>=3->MIPLearn==0.2.0.dev13) (2.8.1)\n",
- "Requirement already satisfied: cycler>=0.10 in /opt/anaconda3/lib/python3.7/site-packages (from matplotlib<4,>=3->MIPLearn==0.2.0.dev13) (0.10.0)\n",
- "Requirement already satisfied: kiwisolver>=1.0.1 in /opt/anaconda3/lib/python3.7/site-packages (from matplotlib<4,>=3->MIPLearn==0.2.0.dev13) (1.3.1)\n",
- "Requirement already satisfied: six in /opt/anaconda3/lib/python3.7/site-packages (from cycler>=0.10->matplotlib<4,>=3->MIPLearn==0.2.0.dev13) (1.15.0)\n",
- "Requirement already satisfied: pathos in /home/axavier/.local/lib/python3.7/site-packages (from p-tqdm<2,>=1->MIPLearn==0.2.0.dev13) (0.2.7)\n",
- "Requirement already satisfied: pytz>=2017.3 in /opt/anaconda3/lib/python3.7/site-packages (from pandas<2,>=1->MIPLearn==0.2.0.dev13) (2021.1)\n",
- "Requirement already satisfied: PyUtilib>=6.0.0 in /home/axavier/.local/lib/python3.7/site-packages (from pyomo<6,>=5->MIPLearn==0.2.0.dev13) (6.0.0)\n",
- "Requirement already satisfied: ply in /opt/anaconda3/lib/python3.7/site-packages (from pyomo<6,>=5->MIPLearn==0.2.0.dev13) (3.11)\n",
- "Requirement already satisfied: attrs>=19.2.0 in /opt/anaconda3/lib/python3.7/site-packages (from pytest<7,>=6->MIPLearn==0.2.0.dev13) (20.3.0)\n",
- "Requirement already satisfied: iniconfig in /opt/anaconda3/lib/python3.7/site-packages (from pytest<7,>=6->MIPLearn==0.2.0.dev13) (1.1.1)\n",
- "Requirement already satisfied: packaging in /opt/anaconda3/lib/python3.7/site-packages (from pytest<7,>=6->MIPLearn==0.2.0.dev13) (20.9)\n",
- "Requirement already satisfied: pluggy<1.0.0a1,>=0.12 in /opt/anaconda3/lib/python3.7/site-packages (from pytest<7,>=6->MIPLearn==0.2.0.dev13) (0.13.1)\n",
- "Requirement already satisfied: py>=1.8.2 in /opt/anaconda3/lib/python3.7/site-packages (from pytest<7,>=6->MIPLearn==0.2.0.dev13) (1.10.0)\n",
- "Requirement already satisfied: toml in /opt/anaconda3/lib/python3.7/site-packages (from pytest<7,>=6->MIPLearn==0.2.0.dev13) (0.10.2)\n",
- "Requirement already satisfied: importlib-metadata>=0.12 in /opt/anaconda3/lib/python3.7/site-packages (from pytest<7,>=6->MIPLearn==0.2.0.dev13) (3.10.0)\n",
- "Requirement already satisfied: zipp>=0.5 in /opt/anaconda3/lib/python3.7/site-packages (from importlib-metadata>=0.12->pytest<7,>=6->MIPLearn==0.2.0.dev13) (3.4.1)\n",
- "Requirement already satisfied: Markdown>=3.0 in /opt/anaconda3/lib/python3.7/site-packages (from python-markdown-math<0.9,>=0.8->MIPLearn==0.2.0.dev13) (3.3.4)\n",
- "Requirement already satisfied: nose in /opt/anaconda3/lib/python3.7/site-packages (from PyUtilib>=6.0.0->pyomo<6,>=5->MIPLearn==0.2.0.dev13) (1.3.7)\n",
- "Requirement already satisfied: scipy>=0.19.1 in /opt/anaconda3/lib/python3.7/site-packages (from scikit-learn<0.25,>=0.24->MIPLearn==0.2.0.dev13) (1.6.2)\n",
- "Requirement already satisfied: threadpoolctl>=2.0.0 in /opt/anaconda3/lib/python3.7/site-packages (from scikit-learn<0.25,>=0.24->MIPLearn==0.2.0.dev13) (2.1.0)\n",
- "Requirement already satisfied: joblib>=0.11 in /opt/anaconda3/lib/python3.7/site-packages (from scikit-learn<0.25,>=0.24->MIPLearn==0.2.0.dev13) (1.0.1)\n",
- "Requirement already satisfied: multiprocess>=0.70.11 in /home/axavier/.local/lib/python3.7/site-packages (from pathos->p-tqdm<2,>=1->MIPLearn==0.2.0.dev13) (0.70.11.1)\n",
- "Requirement already satisfied: ppft>=1.6.6.3 in /home/axavier/.local/lib/python3.7/site-packages (from pathos->p-tqdm<2,>=1->MIPLearn==0.2.0.dev13) (1.6.6.3)\n",
- "Requirement already satisfied: dill>=0.3.3 in /home/axavier/.local/lib/python3.7/site-packages (from pathos->p-tqdm<2,>=1->MIPLearn==0.2.0.dev13) (0.3.3)\n",
- "Requirement already satisfied: pox>=0.2.9 in /home/axavier/.local/lib/python3.7/site-packages (from pathos->p-tqdm<2,>=1->MIPLearn==0.2.0.dev13) (0.2.9)\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
- "!pip install MIPLearn==0.2.0.dev13"
+ "# !pip install MIPLearn==0.2.0.dev13"
]
},
{
@@ -115,7 +62,7 @@
"id": "e8274543",
"metadata": {},
"source": [
- "In addition to MIPLearn itself, we will also install Gurobi 9.1, a state-of-the-art commercial MILP solver. To succesfully complete this step, you will need a valid Gurobi license."
+ "In addition to MIPLearn itself, we will also install Gurobi 9.5, a state-of-the-art commercial MILP solver. This step also install a demo license for Gurobi, which should able to solve the small optimization problems in this tutorial. A paid license is required for solving large-scale problems."
]
},
{
@@ -128,14 +75,13 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Defaulting to user installation because normal site-packages is not writeable\n",
"Looking in indexes: https://pypi.gurobi.com\n",
- "Requirement already satisfied: gurobipy==9.1.2 in /home/axavier/.local/lib/python3.7/site-packages (9.1.2)\n"
+ "Requirement already satisfied: gurobipy<9.6,>=9.5 in /opt/anaconda3/envs/miplearn/lib/python3.8/site-packages (9.5.1)\n"
]
}
],
"source": [
- "!pip install --upgrade -i https://pypi.gurobi.com gurobipy==9.1.2"
+ "!pip install --upgrade -i https://pypi.gurobi.com 'gurobipy>=9.5,<9.6'"
]
},
{
@@ -184,57 +130,68 @@
" \n",
"\n",
"\n",
- "Next, let us convert this abstract mathematical formulation into a concrete optimization model, using Python and Pyomo. We start by defining a class `UnitCommitmentInstance`, which holds all the input data. The class also contains a method `to_model` which constructs a concrete Pyomo model object:"
+ "Next, let us convert this abstract mathematical formulation into a concrete optimization model, using Python and Pyomo. We start by defining a data class `UnitCommitmentData`, which holds all the input data."
]
},
{
"cell_type": "code",
- "execution_count": 12,
- "id": "b5bd2c58",
+ "execution_count": 3,
+ "id": "22a67170-10b4-43d3-8708-014d91141e73",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "from dataclasses import dataclass\n",
+ "import numpy as np\n",
+ "\n",
+ "@dataclass\n",
+ "class UnitCommitmentData:\n",
+ " demand: float\n",
+ " pmin: np.ndarray\n",
+ " pmax: np.ndarray\n",
+ " cfix: np.ndarray\n",
+ " cvar: np.ndarray"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "29f55efa-0751-465a-9b0a-a821d46a3d40",
+ "metadata": {},
+ "source": [
+ "Next, we write a `build_uc_model` function, which converts the input data into a concrete Pyomo model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "2f67032f-0d74-4317-b45c-19da0ec859e9",
"metadata": {},
"outputs": [],
"source": [
"import pyomo.environ as pe\n",
- "import pyomo.opt as pyo\n",
- "from miplearn import Instance\n",
"\n",
- "class UnitCommitmentInstance(Instance):\n",
- " def __init__(\n",
- " self,\n",
- " demand,\n",
- " pmin,\n",
- " pmax,\n",
- " cfix,\n",
- " cvar,\n",
- " ):\n",
- " super().__init__()\n",
- " self.demand = demand\n",
- " self.pmin = pmin\n",
- " self.pmax = pmax\n",
- " self.cfix = cfix\n",
- " self.cvar = cvar\n",
- " \n",
- " def to_model(self):\n",
- " n = len(self.pmin)\n",
- " model = pe.ConcreteModel()\n",
- " model.x = pe.Var(range(n), domain=pe.Binary)\n",
- " model.y = pe.Var(range(n), bounds=(0, float(\"inf\")))\n",
- " model.obj = pe.Objective(\n",
- " expr=sum(\n",
- " self.cfix[i] * model.x[i] +\n",
- " self.cvar[i] * model.y[i]\n",
- " for i in range(n)\n",
- " )\n",
+ "def build_uc_model(data: UnitCommitmentData) -> pe.ConcreteModel:\n",
+ " model = pe.ConcreteModel()\n",
+ " n = len(data.pmin)\n",
+ " model.x = pe.Var(range(n), domain=pe.Binary)\n",
+ " model.y = pe.Var(range(n), domain=pe.NonNegativeReals)\n",
+ " model.obj = pe.Objective(\n",
+ " expr=sum(\n",
+ " data.cfix[i] * model.x[i] +\n",
+ " data.cvar[i] * model.y[i]\n",
+ " for i in range(n)\n",
" )\n",
- " model.eq_max_power = pe.ConstraintList()\n",
- " model.eq_min_power = pe.ConstraintList()\n",
- " for i in range(n):\n",
- " model.eq_max_power.add(model.y[i] <= self.pmax[i] * model.x[i])\n",
- " model.eq_min_power.add(model.y[i] >= self.pmin[i] * model.x[i])\n",
- " model.eq_demand = pe.Constraint(\n",
- " expr=sum(model.y[i] for i in range(n)) == self.demand,\n",
- " )\n",
- " return model"
+ " )\n",
+ " model.eq_max_power = pe.ConstraintList()\n",
+ " model.eq_min_power = pe.ConstraintList()\n",
+ " for i in range(n):\n",
+ " model.eq_max_power.add(model.y[i] <= data.pmax[i] * model.x[i])\n",
+ " model.eq_min_power.add(model.y[i] >= data.pmin[i] * model.x[i])\n",
+ " model.eq_demand = pe.Constraint(\n",
+ " expr=sum(model.y[i] for i in range(n)) == data.demand,\n",
+ " )\n",
+ " return model"
]
},
{
@@ -247,7 +204,7 @@
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": 5,
"id": "2a896f47",
"metadata": {},
"outputs": [
@@ -255,27 +212,32 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "obj = 1320.0\n",
- " x = [0.0, 1.0, 1.0]\n",
- " y = [0.0, 60.0, 40.0]\n"
+ "Set parameter Threads to value 1\n",
+ "Set parameter Seed to value 42\n",
+ "Restricted license - for non-production use only - expires 2023-10-25\n",
+ "obj = 1320.0\n",
+ "x = [-0.0, 1.0, 1.0]\n",
+ "y = [0.0, 60.0, 40.0]\n"
]
}
],
"source": [
- "instance = UnitCommitmentInstance(\n",
- " demand = 100.0,\n",
- " pmin = [10, 20, 30],\n",
- " pmax = [50, 60, 70],\n",
- " cfix = [700, 600, 500],\n",
- " cvar = [1.5, 2.0, 2.5],\n",
+ "model = build_uc_model(\n",
+ " UnitCommitmentData(\n",
+ " demand = 100.0,\n",
+ " pmin = [10, 20, 30],\n",
+ " pmax = [50, 60, 70],\n",
+ " cfix = [700, 600, 500],\n",
+ " cvar = [1.5, 2.0, 2.5],\n",
+ " )\n",
")\n",
- "model = instance.to_model()\n",
- "opt = pyo.SolverFactory(\"gurobi\")\n",
- "opt.solve(model)\n",
"\n",
- "print(\"obj = \", pe.value(model.obj))\n",
- "print(\" x = \", [pe.value(model.x[i]) for i in range(3)])\n",
- "print(\" y = \", [pe.value(model.y[i]) for i in range(3)])\n"
+ "solver = pe.SolverFactory(\"gurobi_persistent\")\n",
+ "solver.set_instance(model)\n",
+ "solver.solve()\n",
+ "print(\"obj =\", model.obj())\n",
+ "print(\"x =\", [model.x[i].value for i in range(3)])\n",
+ "print(\"y =\", [model.y[i].value for i in range(3)])"
]
},
{
@@ -295,29 +257,29 @@
"\n",
"Although Gurobi could solve the small example above in a fraction of a second, it gets slower for larger and more complex versions of the problem. If this is a problem that needs to be solved frequently, as it is often the case in practice, it could make sense to spend some time upfront generating a **trained** version of Gurobi, which can solve new instances (similar to the ones it was trained on) faster.\n",
"\n",
- "In the following, we will use MIPLearn to train machine learning models that can be used to accelerate Gurobi's performance on a particular set of instances. More specifically, MIPLearn will train a model that is able to predict the optimal solution for instances that follow a given probability distribution, then it will provide this predicted solution to Gurobi as a warm start.\n",
- "\n",
- "Before we can train the model, we need to collect training data by solving a large number of instances. In real-world situations, we may construct these training instances based on historical data. In this tutorial, we will construct them using a random instance generator:"
+ "In the following, we will use MIPLearn to train machine learning models that is able to predict the optimal solution for instances that follow a given probability distribution, then it will provide this predicted solution to Gurobi as a warm start. Before we can train the model, we need to collect training data by solving a large number of instances. In real-world situations, we may construct these training instances based on historical data. In this tutorial, we will construct them using a random instance generator:"
]
},
{
"cell_type": "code",
- "execution_count": 42,
+ "execution_count": 6,
"id": "5eb09fab",
"metadata": {},
"outputs": [],
"source": [
"from scipy.stats import uniform\n",
+ "from typing import List\n",
"import random\n",
"\n",
- "def random_uc_instances(samples, n, seed=42):\n",
+ "def random_uc_data(samples: int, n: int, seed: int = 42) -> List[UnitCommitmentData]:\n",
" random.seed(seed)\n",
+ " np.random.seed(seed)\n",
" pmin = uniform(loc=100_000.0, scale=400_000.0).rvs(n)\n",
" pmax = pmin * uniform(loc=2.0, scale=2.5).rvs(n)\n",
" cfix = pmin * uniform(loc=100.0, scale=25.0).rvs(n)\n",
" cvar = uniform(loc=1.25, scale=0.25).rvs(n)\n",
" return [\n",
- " UnitCommitmentInstance(\n",
+ " UnitCommitmentData(\n",
" demand = pmax.sum() * uniform(loc=0.5, scale=0.25).rvs(),\n",
" pmin = pmin,\n",
" pmax = pmax,\n",
@@ -333,116 +295,22 @@
"id": "3a03a7ac",
"metadata": {},
"source": [
- "In this example, for simplicity, only the demands change from one instance to the next. We could also have made the prices and the production limits random. The more randomization we have in the training data, however, the more challenging it is for the machine learning models to learn solution patterns.\n",
+ "In this example, for simplicity, only the demands change from one instance to the next. We could also have randomized the costs, production limits or even the number of units. The more randomization we have in the training data, however, the more challenging it is for the machine learning models to learn solution patterns.\n",
"\n",
- "Now we generate 100 instances of this problem, each one with 1,000 generators. We will use the first 90 instances for training, and the remaining 10 instances to evaluate performance."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 43,
- "id": "6156752c",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Using license file /home/axavier/gurobi.lic\n",
- "Using gurobi.env file\n",
- "Set parameter Threads to value 1\n",
- "Read LP format model from file /tmp/tmpl37dgdq_.pyomo.lp\n",
- "Reading time = 0.01 seconds\n",
- "x2001: 2002 rows, 2001 columns, 5001 nonzeros\n",
- "Gurobi Optimizer version 9.1.1 build v9.1.1rc0 (linux64)\n",
- "Thread count: 16 physical cores, 32 logical processors, using up to 1 threads\n",
- "Optimize a model with 2002 rows, 2001 columns and 5001 nonzeros\n",
- "Model fingerprint: 0x637c283e\n",
- "Variable types: 1001 continuous, 1000 integer (1000 binary)\n",
- "Coefficient statistics:\n",
- " Matrix range [1e+00, 2e+06]\n",
- " Objective range [1e+00, 6e+07]\n",
- " Bounds range [1e+00, 1e+00]\n",
- " RHS range [1e+00, 7e+08]\n",
- "Presolve removed 1 rows and 1 columns\n",
- "Presolve time: 0.00s\n",
- "Presolved: 2001 rows, 2000 columns, 5000 nonzeros\n",
- "Variable types: 1000 continuous, 1000 integer (1000 binary)\n",
- "\n",
- "Root relaxation: objective 2.143251e+10, 1010 iterations, 0.00 seconds\n",
- "\n",
- " Nodes | Current Node | Objective Bounds | Work\n",
- " Expl Unexpl | Obj Depth IntInf | Incumbent BestBd Gap | It/Node Time\n",
- "\n",
- " 0 0 2.1433e+10 0 1 - 2.1433e+10 - - 0s\n",
- "H 0 0 2.143648e+10 2.1433e+10 0.02% - 0s\n",
- " 0 0 2.1433e+10 0 3 2.1436e+10 2.1433e+10 0.02% - 0s\n",
- " 0 0 2.1433e+10 0 1 2.1436e+10 2.1433e+10 0.02% - 0s\n",
- " 0 0 2.1433e+10 0 3 2.1436e+10 2.1433e+10 0.02% - 0s\n",
- "H 0 0 2.143631e+10 2.1433e+10 0.02% - 0s\n",
- " 0 0 2.1433e+10 0 2 2.1436e+10 2.1433e+10 0.02% - 0s\n",
- " 0 0 2.1433e+10 0 2 2.1436e+10 2.1433e+10 0.02% - 0s\n",
- " 0 2 2.1433e+10 0 2 2.1436e+10 2.1433e+10 0.02% - 0s\n",
- "H 224 189 2.143590e+10 2.1433e+10 0.02% 1.0 0s\n",
- "H 259 218 2.143566e+10 2.1433e+10 0.01% 1.0 0s\n",
- "H 516 430 2.143497e+10 2.1433e+10 0.01% 1.1 0s\n",
- "H 631 467 2.143400e+10 2.1433e+10 0.01% 1.7 0s\n",
- "\n",
- "Cutting planes:\n",
- " Gomory: 1\n",
- "\n",
- "Explored 632 nodes (2451 simplex iterations) in 0.34 seconds\n",
- "Thread count was 1 (of 32 available processors)\n",
- "\n",
- "Solution count 6: 2.1434e+10 2.1435e+10 2.14357e+10 ... 2.14365e+10\n",
- "\n",
- "Optimal solution found (tolerance 1.00e-04)\n",
- "Best objective 2.143399941747e+10, best bound 2.143258805394e+10, gap 0.0066%\n"
- ]
- }
- ],
- "source": [
- "instances = random_uc_instances(samples=100, n=1000);\n",
- "train_instances = instances[1:90]\n",
- "test_instances = instances[91:100];\n",
- "\n",
- "model = instances[0].to_model()\n",
- "opt = pyo.SolverFactory(\"gurobi\")\n",
- "opt.solve(model, tee=True);"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "b795a0b1",
- "metadata": {},
- "source": [
- "Next, we write these objects to individual files. MIPLearn uses files during the training process because, for large-scale optimization problems, it is often impractical to hold the entire training data, as well as the concrete Pyomo models, in memory. Files also make it much easier to solve multiple instances simultaneously, potentially even on multiple machines. We will cover parallel and distributed computing in a future tutorial.\n",
- "\n",
- "The code below generates the files `uc/train/00001.h5`, `uc/train/00002.h5`, etc., which contain the input data in HDF5 format."
+ "Now we generate 500 instances of this problem, each one with 50 generators, and we use 450 of these instances for training. After generating the instances, we write them to individual files. MIPLearn uses files during the training process because, for large-scale optimization problems, it is often impractical to hold in memory the entire training data, as well as the concrete Pyomo models. Files also make it much easier to solve multiple instances simultaneously, potentially even on multiple machines. We will cover parallel and distributed computing in a future tutorial. The code below generates the files `uc/train/00000.pkl.gz`, `uc/train/00001.pkl.gz`, etc., which contain the input data in compressed (gzipped) pickle format."
]
},
{
"cell_type": "code",
"execution_count": 7,
- "id": "e21d9aa0",
+ "id": "6156752c",
"metadata": {},
"outputs": [],
"source": [
- "from miplearn.instance.file import FileInstance\n",
- "from glob import glob\n",
- "import os\n",
- "\n",
- "os.makedirs(\"uc/train\", exist_ok=True)\n",
- "os.makedirs(\"uc/test\", exist_ok=True)\n",
- "\n",
- "for (i, instance) in enumerate(train_instances):\n",
- " FileInstance.save(instance, f\"uc/train/{i:05d}.h5\")\n",
- " \n",
- "for (i, instance) in enumerate(test_instances):\n",
- " FileInstance.save(instance, f\"uc/test/{i:05d}.h5\")\n",
- "\n",
- "train_instances = [FileInstance(f) for f in glob(\"uc/train/*.h5\")]\n",
- "test_instances = [FileInstance(f) for f in glob(\"uc/test/*.h5\")]"
+ "from miplearn import save\n",
+ "data = random_uc_data(samples=500, n=50)\n",
+ "train_files = save(data[0:450], \"uc/train/\")\n",
+ "test_files = save(data[450:500], \"uc/test/\")"
]
},
{
@@ -450,50 +318,19 @@
"id": "b17af877",
"metadata": {},
"source": [
- "Finally, we use `LearningSolver` to solve all the training instances. `LearningSolver` is the main component provided by MIPLearn, which integrates MIP solvers and ML. The solutions, and other useful training data, are stored in the same HDF5 files."
+ "Finally, we use `LearningSolver` to solve all the training instances. `LearningSolver` is the main component provided by MIPLearn, which integrates MIP solvers and ML. The optimal solutions, along with other useful training data, are stored in HDF5 files `uc/train/00000.h5`, `uc/train/00001.h5`, etc."
]
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": 12,
"id": "7623f002",
"metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- " 12%|█▏ | 11/89 [00:50<05:56, 4.57s/it]\n"
- ]
- },
- {
- "ename": "KeyboardInterrupt",
- "evalue": "",
- "output_type": "error",
- "traceback": [
- "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)",
- "\u001b[0;32m
\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0msolver\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLearningSolver\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0minstance\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_instances\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0msolver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minstance\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
- "\u001b[0;32m~/Packages/MIPLearn/dev/miplearn/solvers/learning.py\u001b[0m in \u001b[0;36msolve\u001b[0;34m(self, instance, model, discard_output, tee)\u001b[0m\n\u001b[1;32m 354\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0minstance\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 355\u001b[0m \u001b[0minstance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minstance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 356\u001b[0;31m return self._solve(\n\u001b[0m\u001b[1;32m 357\u001b[0m \u001b[0minstance\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minstance\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 358\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
- "\u001b[0;32m~/Packages/MIPLearn/dev/miplearn/solvers/learning.py\u001b[0m in \u001b[0;36m_solve\u001b[0;34m(self, instance, model, discard_output, tee)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minfo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Extracting features (after-load)...\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0minitial_time\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 171\u001b[0;31m self.extractor.extract_after_load_features(\n\u001b[0m\u001b[1;32m 172\u001b[0m \u001b[0minstance\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minternal_solver\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 173\u001b[0m )\n",
- "\u001b[0;32m~/Packages/MIPLearn/dev/miplearn/features/extractor.py\u001b[0m in \u001b[0;36mextract_after_load_features\u001b[0;34m(self, instance, solver, sample)\u001b[0m\n\u001b[1;32m 35\u001b[0m ) -> None:\n\u001b[1;32m 36\u001b[0m \u001b[0mvariables\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msolver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_variables\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwith_static\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 37\u001b[0;31m \u001b[0mconstraints\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msolver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_constraints\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwith_static\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwith_lhs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_lhs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 38\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mconstraints\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnames\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mput_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"static_var_lower_bounds\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvariables\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower_bounds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
- "\u001b[0;32m~/Packages/MIPLearn/dev/miplearn/solvers/pyomo/base.py\u001b[0m in \u001b[0;36mget_constraints\u001b[0;34m(self, with_static, with_sa, with_lhs)\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mconstr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 238\u001b[0m \u001b[0mnames\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconstr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 239\u001b[0;31m \u001b[0m_parse_constraint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconstr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcurr_row\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 240\u001b[0m \u001b[0mcurr_row\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 241\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
- "\u001b[0;32m~/Packages/MIPLearn/dev/miplearn/solvers/pyomo/base.py\u001b[0m in \u001b[0;36m_parse_constraint\u001b[0;34m(c, row)\u001b[0m\n\u001b[1;32m 204\u001b[0m \u001b[0mlhs_row\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 205\u001b[0m lhs_col.append(\n\u001b[0;32m--> 206\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_varname_to_idx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mterm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_args_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 207\u001b[0m )\n\u001b[1;32m 208\u001b[0m \u001b[0mlhs_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mterm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_args_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
- "\u001b[0;32m~/.conda/envs/miplearn/lib/python3.8/site-packages/Pyomo-5.7.3-py3.8-linux-x86_64.egg/pyomo/core/base/component.py\u001b[0m in \u001b[0;36mname\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 285\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 286\u001b[0m \u001b[0;34m\"\"\"Get the fully qualifed component name.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 287\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetname\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfully_qualified\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 288\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[0;31m# Adding a setter here to help users adapt to the new\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
- "\u001b[0;32m~/.conda/envs/miplearn/lib/python3.8/site-packages/Pyomo-5.7.3-py3.8-linux-x86_64.egg/pyomo/core/base/component.py\u001b[0m in \u001b[0;36mgetname\u001b[0;34m(self, fully_qualified, name_buffer, relative_to)\u001b[0m\n\u001b[1;32m 910\u001b[0m \u001b[0;31m# more expensive than if a buffer is provided.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 911\u001b[0m \u001b[0;31m#\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 912\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 913\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 914\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mbase\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0m_name_index_generator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
- "\u001b[0;32m~/.conda/envs/miplearn/lib/python3.8/site-packages/Pyomo-5.7.3-py3.8-linux-x86_64.egg/pyomo/core/base/indexed_component.py\u001b[0m in \u001b[0;36miteritems\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 370\u001b[0m \u001b[0;34m\"\"\"Return an iterator of (index,data) tuples from the dictionary\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 371\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 372\u001b[0;31m \u001b[0;32myield\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 373\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 374\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindex\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
- "\u001b[0;32m~/.conda/envs/miplearn/lib/python3.8/site-packages/Pyomo-5.7.3-py3.8-linux-x86_64.egg/pyomo/core/base/indexed_component.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, index)\u001b[0m\n\u001b[1;32m 380\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 381\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 382\u001b[0;31m \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_NotFound\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 383\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 384\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
- "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
- ]
- }
- ],
+ "outputs": [],
"source": [
"from miplearn import LearningSolver\n",
- "from tqdm import tqdm\n",
- "\n",
"solver = LearningSolver()\n",
- "for instance in tqdm(train_instances):\n",
- " solver.solve(instance)"
+ "solver.solve(train_files, build_uc_model);"
]
},
{
@@ -501,157 +338,274 @@
"id": "2f24ee83",
"metadata": {},
"source": [
- "## Solving new instances\n",
+ "## Solving test instances\n",
"\n",
- "With training data in hand, we can now fit the ML models, using the `LearningSolver.fit` method, then solve the test instances with `MIPLearn.solve!`, as shown below:"
+ "With training data in hand, we can now fit the ML models, using the `LearningSolver.fit` method, then solve the test instances with `LearningSolver.solve`, as shown below. The `tee=True` parameter asks MIPLearn to print the solver log to the screen."
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 9,
"id": "c8385030",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Set parameter LogFile to value \"/tmp/tmpvbaqbyty.log\"\n",
+ "Set parameter QCPDual to value 1\n",
+ "Gurobi Optimizer version 9.5.1 build v9.5.1rc2 (linux64)\n",
+ "Thread count: 16 physical cores, 32 logical processors, using up to 1 threads\n",
+ "Optimize a model with 101 rows, 100 columns and 250 nonzeros\n",
+ "Model fingerprint: 0x8de73876\n",
+ "Coefficient statistics:\n",
+ " Matrix range [1e+00, 2e+06]\n",
+ " Objective range [1e+00, 6e+07]\n",
+ " Bounds range [1e+00, 1e+00]\n",
+ " RHS range [2e+07, 2e+07]\n",
+ "Presolve removed 100 rows and 50 columns\n",
+ "Presolve time: 0.00s\n",
+ "Presolved: 1 rows, 50 columns, 50 nonzeros\n",
+ "\n",
+ "Iteration Objective Primal Inf. Dual Inf. Time\n",
+ " 0 5.7349081e+08 1.044003e+04 0.000000e+00 0s\n",
+ " 1 6.8268465e+08 0.000000e+00 0.000000e+00 0s\n",
+ "\n",
+ "Solved in 1 iterations and 0.00 seconds (0.00 work units)\n",
+ "Optimal objective 6.826846503e+08\n",
+ "Set parameter LogFile to value \"\"\n",
+ "Set parameter LogFile to value \"/tmp/tmp48j6n35b.log\"\n",
+ "Gurobi Optimizer version 9.5.1 build v9.5.1rc2 (linux64)\n",
+ "Thread count: 16 physical cores, 32 logical processors, using up to 1 threads\n",
+ "Optimize a model with 101 rows, 100 columns and 250 nonzeros\n",
+ "Model fingerprint: 0x200d64ba\n",
+ "Variable types: 50 continuous, 50 integer (50 binary)\n",
+ "Coefficient statistics:\n",
+ " Matrix range [1e+00, 2e+06]\n",
+ " Objective range [1e+00, 6e+07]\n",
+ " Bounds range [1e+00, 1e+00]\n",
+ " RHS range [2e+07, 2e+07]\n",
+ "\n",
+ "User MIP start produced solution with objective 6.84841e+08 (0.00s)\n",
+ "Loaded user MIP start with objective 6.84841e+08\n",
+ "\n",
+ "Presolve time: 0.00s\n",
+ "Presolved: 101 rows, 100 columns, 250 nonzeros\n",
+ "Variable types: 50 continuous, 50 integer (50 binary)\n",
+ "\n",
+ "Root relaxation: objective 6.826847e+08, 56 iterations, 0.00 seconds (0.00 work units)\n",
+ "\n",
+ " Nodes | Current Node | Objective Bounds | Work\n",
+ " Expl Unexpl | Obj Depth IntInf | Incumbent BestBd Gap | It/Node Time\n",
+ "\n",
+ " 0 0 6.8268e+08 0 1 6.8484e+08 6.8268e+08 0.31% - 0s\n",
+ " 0 0 6.8315e+08 0 3 6.8484e+08 6.8315e+08 0.25% - 0s\n",
+ " 0 0 6.8315e+08 0 1 6.8484e+08 6.8315e+08 0.25% - 0s\n",
+ " 0 0 6.8315e+08 0 3 6.8484e+08 6.8315e+08 0.25% - 0s\n",
+ " 0 0 6.8315e+08 0 4 6.8484e+08 6.8315e+08 0.25% - 0s\n",
+ " 0 0 6.8315e+08 0 4 6.8484e+08 6.8315e+08 0.25% - 0s\n",
+ " 0 2 6.8327e+08 0 4 6.8484e+08 6.8327e+08 0.23% - 0s\n",
+ "\n",
+ "Cutting planes:\n",
+ " Flow cover: 3\n",
+ "\n",
+ "Explored 32 nodes (155 simplex iterations) in 0.02 seconds (0.00 work units)\n",
+ "Thread count was 1 (of 32 available processors)\n",
+ "\n",
+ "Solution count 1: 6.84841e+08 \n",
+ "\n",
+ "Optimal solution found (tolerance 1.00e-04)\n",
+ "Best objective 6.848411655488e+08, best bound 6.848411655488e+08, gap 0.0000%\n",
+ "Set parameter LogFile to value \"\"\n",
+ "WARNING: Cannot get reduced costs for MIP.\n",
+ "WARNING: Cannot get duals for MIP.\n"
+ ]
+ }
+ ],
"source": [
"solver_ml = LearningSolver()\n",
- "solver_ml.fit(train_instances)\n",
- "for instance in tqdm(test_instances):\n",
- " solver_ml.solve(instance)"
+ "solver_ml.fit(train_files, build_uc_model)\n",
+ "solver_ml.solve(test_files[0:1], build_uc_model, tee=True);"
]
},
{
"cell_type": "markdown",
- "id": "8ae11854",
+ "id": "61da6dad-7f56-4edb-aa26-c00eb5f946c0",
"metadata": {},
"source": [
- "The trained MIP solver was able to solve all test instances in about 6 seconds. To see that ML is being helpful here, let us repeat the code above, but remove the `fit!` line:"
+ "By examining the solve log above, specifically the line `Loaded user MIP start with objective...`, we can see that MIPLearn was able to construct an initial solution which turned out to be the optimal solution to the problem. Now let us repeat the code above, but using an untrained solver. Note that the `fit` line is omitted."
]
},
{
"cell_type": "code",
- "execution_count": null,
- "id": "71c58e4a",
+ "execution_count": 10,
+ "id": "33d15d6c-6db4-477f-bd4b-fe8e84e5f023",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Set parameter LogFile to value \"/tmp/tmp3uhhdurw.log\"\n",
+ "Set parameter QCPDual to value 1\n",
+ "Gurobi Optimizer version 9.5.1 build v9.5.1rc2 (linux64)\n",
+ "Thread count: 16 physical cores, 32 logical processors, using up to 1 threads\n",
+ "Optimize a model with 101 rows, 100 columns and 250 nonzeros\n",
+ "Model fingerprint: 0x8de73876\n",
+ "Coefficient statistics:\n",
+ " Matrix range [1e+00, 2e+06]\n",
+ " Objective range [1e+00, 6e+07]\n",
+ " Bounds range [1e+00, 1e+00]\n",
+ " RHS range [2e+07, 2e+07]\n",
+ "Presolve removed 100 rows and 50 columns\n",
+ "Presolve time: 0.00s\n",
+ "Presolved: 1 rows, 50 columns, 50 nonzeros\n",
+ "\n",
+ "Iteration Objective Primal Inf. Dual Inf. Time\n",
+ " 0 5.7349081e+08 1.044003e+04 0.000000e+00 0s\n",
+ " 1 6.8268465e+08 0.000000e+00 0.000000e+00 0s\n",
+ "\n",
+ "Solved in 1 iterations and 0.01 seconds (0.00 work units)\n",
+ "Optimal objective 6.826846503e+08\n",
+ "Set parameter LogFile to value \"\"\n",
+ "Set parameter LogFile to value \"/tmp/tmp18aqg2ic.log\"\n",
+ "Gurobi Optimizer version 9.5.1 build v9.5.1rc2 (linux64)\n",
+ "Thread count: 16 physical cores, 32 logical processors, using up to 1 threads\n",
+ "Optimize a model with 101 rows, 100 columns and 250 nonzeros\n",
+ "Model fingerprint: 0xb90d1075\n",
+ "Variable types: 50 continuous, 50 integer (50 binary)\n",
+ "Coefficient statistics:\n",
+ " Matrix range [1e+00, 2e+06]\n",
+ " Objective range [1e+00, 6e+07]\n",
+ " Bounds range [1e+00, 1e+00]\n",
+ " RHS range [2e+07, 2e+07]\n",
+ "Found heuristic solution: objective 8.056576e+08\n",
+ "Presolve time: 0.00s\n",
+ "Presolved: 101 rows, 100 columns, 250 nonzeros\n",
+ "Variable types: 50 continuous, 50 integer (50 binary)\n",
+ "\n",
+ "Root relaxation: objective 6.826847e+08, 56 iterations, 0.00 seconds (0.00 work units)\n",
+ "\n",
+ " Nodes | Current Node | Objective Bounds | Work\n",
+ " Expl Unexpl | Obj Depth IntInf | Incumbent BestBd Gap | It/Node Time\n",
+ "\n",
+ " 0 0 6.8268e+08 0 1 8.0566e+08 6.8268e+08 15.3% - 0s\n",
+ "H 0 0 7.099498e+08 6.8268e+08 3.84% - 0s\n",
+ " 0 0 6.8315e+08 0 3 7.0995e+08 6.8315e+08 3.78% - 0s\n",
+ "H 0 0 6.883227e+08 6.8315e+08 0.75% - 0s\n",
+ " 0 0 6.8352e+08 0 4 6.8832e+08 6.8352e+08 0.70% - 0s\n",
+ " 0 0 6.8352e+08 0 4 6.8832e+08 6.8352e+08 0.70% - 0s\n",
+ " 0 0 6.8352e+08 0 1 6.8832e+08 6.8352e+08 0.70% - 0s\n",
+ "H 0 0 6.862582e+08 6.8352e+08 0.40% - 0s\n",
+ " 0 0 6.8352e+08 0 4 6.8626e+08 6.8352e+08 0.40% - 0s\n",
+ " 0 0 6.8352e+08 0 4 6.8626e+08 6.8352e+08 0.40% - 0s\n",
+ " 0 0 6.8352e+08 0 1 6.8626e+08 6.8352e+08 0.40% - 0s\n",
+ " 0 0 6.8352e+08 0 3 6.8626e+08 6.8352e+08 0.40% - 0s\n",
+ " 0 0 6.8352e+08 0 4 6.8626e+08 6.8352e+08 0.40% - 0s\n",
+ " 0 0 6.8352e+08 0 4 6.8626e+08 6.8352e+08 0.40% - 0s\n",
+ " 0 2 6.8354e+08 0 4 6.8626e+08 6.8354e+08 0.40% - 0s\n",
+ "* 18 5 6 6.849018e+08 6.8413e+08 0.11% 3.1 0s\n",
+ "H 24 1 6.848412e+08 6.8426e+08 0.09% 3.2 0s\n",
+ "\n",
+ "Cutting planes:\n",
+ " Gomory: 1\n",
+ " Flow cover: 2\n",
+ "\n",
+ "Explored 30 nodes (217 simplex iterations) in 0.02 seconds (0.00 work units)\n",
+ "Thread count was 1 (of 32 available processors)\n",
+ "\n",
+ "Solution count 6: 6.84841e+08 6.84902e+08 6.86258e+08 ... 8.05658e+08\n",
+ "\n",
+ "Optimal solution found (tolerance 1.00e-04)\n",
+ "Best objective 6.848411655488e+08, best bound 6.848411655488e+08, gap 0.0000%\n",
+ "Set parameter LogFile to value \"\"\n",
+ "WARNING: Cannot get reduced costs for MIP.\n",
+ "WARNING: Cannot get duals for MIP.\n"
+ ]
+ }
+ ],
"source": [
"solver_baseline = LearningSolver()\n",
- "for instance in tqdm(test_instances):\n",
- " solver_baseline.solve(instance)"
+ "solver_baseline.solve(test_files[0:1], build_uc_model, tee=True);"
]
},
{
"cell_type": "markdown",
- "id": "117adfb7",
+ "id": "b6d37b88-9fcc-43ee-ac1e-2a7b1e51a266",
"metadata": {},
"source": [
- "Without the help of the ML models, SCIP took around 10 seconds to solve the same test instances.\n",
+ "In the log above, the `MIP start` line is missing, and Gurobi had to start with a significantly inferior initial solution. The solver was still able to find the optimal solution at the end, but it required using its own internal heuristic procedures. In this example, because we solve very small optimization problems, there was almost no difference in terms of running time. For larger problems, however, the difference can be significant. See benchmarks for more details.\n",
"\n",
"\n",
"Note\n",
" \n",
- "Note that is is not necessary to specify what ML models to use. MIPLearn, by default, will try a number of classical ML models and will choose the one that performs the best, based on k-fold cross validation. MIPLearn is also able to automatically collect features based on the MIP formulation of the problem and the solution to the LP relaxation, among other things, so it does not require handcrafted features. If you do want to customize the models and features, however, that is also possible, as we will see in a later tutorial.\n",
- "
"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "dec6acd7",
- "metadata": {},
- "source": [
- "## Understanding the acceleration\n",
- "\n",
- "Let us go a bit deeper and try to understand how exactly did MIPLearn accelerate Gurobi's performance. First, we are going to solve one of the test instances again, using the trained solver, but this time using the `tee=True` parameter, so that we can see Gurobi's log:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "0d4df336",
- "metadata": {},
- "outputs": [],
- "source": [
- "solver_ml.solve(test_instances[0], tee=True);"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "df5108b9",
- "metadata": {},
- "source": [
- "The log above is quite complicated if you have never seen it before, but the important line is the one starting with `feasible solution found [...] objective value 1.705169e+07`. This line indicates that MIPLearn was able to construct a warm start with value `1.705169e+07`. Using this warm start, SCIP then used the branch-and-cut method to either prove its optimality or to find an even better solution. Very quickly, however, SCIP proved that the solution produced by MIPLearn was indeed optimal. It was able to do this without generating a single cutting plane or running any other heuristics; it could tell the optimality by the root LP relaxation alone, which was very fast. \n",
- "\n",
- "Let us now repeat the process, but using the untrained solver this time:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "51864ed9",
- "metadata": {},
- "outputs": [],
- "source": [
- "solver_baseline.solve(test_instances[0], tee=True);"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "5a78550e",
- "metadata": {},
- "source": [
- "In this log file, notice how the previous line about warm starts is missing. Since no warm starts were provided, SCIP had to find an initial solution using its own internal heuristics, which are not specifically tailored for this problem. The initial solution found by SCIP's heuristics has value `2.335200e+07`, which is significantly worse than the one constructed by MIPLearn. SCIP then proceeded to improve this solution, by generating cutting planes and repeatedly running additional primal heuristics. In the end, it was able to find the optimal solution, as expected, but it took longer.\n",
+ "In addition to partial initial solutions, MIPLearn is also able to predict lazy constraints, cutting planes and branching priorities. See the next tutorials for more details.\n",
+ "\n",
+ "Note\n",
+ " \n",
+ "It is not necessary to specify what ML models to use. MIPLearn, by default, will try a number of classical ML models and will choose the one that performs the best, based on k-fold cross validation. MIPLearn is also able to automatically collect features based on the MIP formulation of the problem and the solution to the LP relaxation, among other things, so it does not require handcrafted features. If you do want to customize the models and features, however, that is also possible, as we will see in a later tutorial.\n",
+ "
"
]
},
{
"cell_type": "markdown",
"id": "eec97f06",
- "metadata": {},
+ "metadata": {
+ "tags": []
+ },
"source": [
"## Accessing the solution\n",
"\n",
- "In the example above, we used `MIPLearn.solve!` together with data files to solve both the training and the test instances. The solutions were saved to a `.h5` files in the train/test folders, and could be retrieved by reading theses files, but that is not very convenient. In this section we will use an easier method.\n",
- "\n",
- "We can use the function `MIPLearn.load!` to obtain a regular JuMP model:"
+ "In the example above, we used `LearningSolver.solve` together with data files to solve both the training and the test instances. The optimal solutions were saved to HDF5 files in the train/test folders, and could be retrieved by reading theses files, but that is not very convenient. In the following example, we show how to build and solve a Pyomo model entirely in-memory, using our trained solver."
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 11,
"id": "67a6cd18",
"metadata": {},
- "outputs": [],
- "source": [
- "model = MIPLearn.load(\"uc/test/000001.jld2\", build_uc_model)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "b7a5629c",
- "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "obj = 903865807.3536932\n",
+ " x = [1.0, 1.0, 1.0, 1.0, 1.0]\n",
+ " y = [1105176.593734543, 1891284.5155055337, 1708177.4224033852, 1438329.610189608, 535496.3347187206]\n"
+ ]
+ }
+ ],
"source": [
- "We can then solve this model as before, with `MIPLearn.solve!`:"
+ "# Construct model using previously defined functions\n",
+ "data = random_uc_data(samples=1, n=50)[0]\n",
+ "model = build_uc_model(data)\n",
+ "\n",
+ "# Solve model using ML + Gurobi\n",
+ "solver_ml.solve(model)\n",
+ "\n",
+ "# Print part of the optimal solution\n",
+ "print(\"obj =\", model.obj())\n",
+ "print(\" x =\", [model.x[i].value for i in range(5)])\n",
+ "print(\" y =\", [model.y[i].value for i in range(5)])"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "6d5fa7e9",
+ "id": "5593d23a-83bd-4e16-8253-6300f5e3f63b",
"metadata": {},
"outputs": [],
- "source": [
- "solve!(solver_ml, model)\n",
- "println(\"obj = \", objective_value(model))\n",
- "println(\" x = \", round.(value.(model[:x][1:10])))\n",
- "println(\" y = \", round.(value.(model[:y][1:10]), digits=2))"
- ]
+ "source": []
}
],
"metadata": {
"kernelspec": {
- "display_name": "miplearn",
+ "display_name": "Python 3",
"language": "python",
- "name": "miplearn"
+ "name": "python3"
},
"language_info": {
"codemirror_mode": {
diff --git a/docs/pyomo-tutorials/gurobi.env b/docs/pyomo-tutorials/gurobi.env
index 70e8481..705c8fe 100644
--- a/docs/pyomo-tutorials/gurobi.env
+++ b/docs/pyomo-tutorials/gurobi.env
@@ -1,2 +1,3 @@
OutputFlag 1
-Threads 1
\ No newline at end of file
+Threads 1
+Seed 42
\ No newline at end of file
diff --git a/miplearn/solvers/pyomo/cplex.py b/miplearn/solvers/pyomo/cplex.py
index 2cf8ddd..021a430 100644
--- a/miplearn/solvers/pyomo/cplex.py
+++ b/miplearn/solvers/pyomo/cplex.py
@@ -28,7 +28,6 @@ class CplexPyomoSolver(BasePyomoSolver):
) -> None:
if params is None:
params = {}
- params["randomseed"] = randint(low=0, high=1000).rvs()
if "mip_display" not in params.keys():
params["mip_display"] = 4
super().__init__(
diff --git a/miplearn/solvers/pyomo/gurobi.py b/miplearn/solvers/pyomo/gurobi.py
index 162c668..f350405 100644
--- a/miplearn/solvers/pyomo/gurobi.py
+++ b/miplearn/solvers/pyomo/gurobi.py
@@ -32,7 +32,6 @@ class GurobiPyomoSolver(BasePyomoSolver):
) -> None:
if params is None:
params = {}
- params["seed"] = randint(low=0, high=1000).rvs()
super().__init__(
solver_factory=pe.SolverFactory("gurobi_persistent"),
params=params,
diff --git a/miplearn/solvers/pyomo/xpress.py b/miplearn/solvers/pyomo/xpress.py
index d49db8c..b0cf763 100644
--- a/miplearn/solvers/pyomo/xpress.py
+++ b/miplearn/solvers/pyomo/xpress.py
@@ -32,7 +32,6 @@ class XpressPyomoSolver(BasePyomoSolver):
) -> None:
if params is None:
params = {}
- params["randomseed"] = randint(low=0, high=1000).rvs()
super().__init__(
solver_factory=pe.SolverFactory("xpress_persistent"),
params=params,