From 82833d0d453e5fd3b29b8017161e17f9af6124b1 Mon Sep 17 00:00:00 2001 From: Viu Long Kong Date: Mon, 23 Mar 2020 13:56:22 +0100 Subject: [PATCH] update --- examples/mp/jupyter/efficient.ipynb | 238 ++++++++++++++--------- examples/mp/modeling/nurses_multiobj.py | 2 +- examples/mp/modeling/sport_scheduling.py | 2 +- 3 files changed, 148 insertions(+), 94 deletions(-) diff --git a/examples/mp/jupyter/efficient.ipynb b/examples/mp/jupyter/efficient.ipynb index 59e7d58..7a99935 100644 --- a/examples/mp/jupyter/efficient.ipynb +++ b/examples/mp/jupyter/efficient.ipynb @@ -36,7 +36,7 @@ "text": [ "--> begin fibonacci 30\n", "fibonacci(30) = 832040\n", - "<-- end fibonacci 30, time: 154 ms\n" + "<-- end fibonacci 30, time: 231 ms\n" ] } ], @@ -151,7 +151,7 @@ "output_type": "stream", "text": [ "--> begin bench1_size_1000\n", - "<-- end bench1_size_1000, time: 3333 ms\n", + "<-- end bench1_size_1000, time: 2724 ms\n", "Model: bench1\n", " - number of variables: 1000\n", " - binary=1000, integer=0, continuous=0\n", @@ -186,7 +186,7 @@ "output_type": "stream", "text": [ "--> begin bench1 size=3000\n", - "<-- end bench1 size=3000, time: 24649 ms\n" + "<-- end bench1 size=3000, time: 23384 ms\n" ] } ], @@ -207,7 +207,8 @@ "Python's um function calls the `+` operator repeatedly, that is, sum([x,y,z, t]) is evaluated as ((x+y)+z)+t. Calling `sum` with `N` arguments then creates `N` intermediate expressions, but there's more. Each intermediate expression has to be copied for the next sum, and as the size of the intermediate expressions grow, each copy takes an O(n) time, and th efinal sum has time in O(N^2).\n", "On the opposite, `Model.sum()` creates only _one_ expression and incrementally adds each argument to it.\n", "\n", - "**Summary**: never use Python's builtin sum, instead use `Model.sum()` to compute expresssions in Docplex.\n", + "**Rule #1**: never use Python's builtin `sum` function to compute expressions,\n", + " use `Model.sum()` instead.\n", "\n", "Let's experiment with our benchmark model. First we define a variant function to build the same model as above with Python `sum`, and measure the two build times." ] @@ -222,9 +223,9 @@ "output_type": "stream", "text": [ "--> begin python_sum_too_slow_n=1000\n", - "<-- end python_sum_too_slow_n=1000, time: 5435 ms\n", + "<-- end python_sum_too_slow_n=1000, time: 4872 ms\n", "--> begin same_model_with_model_sum_n=1000\n", - "<-- end same_model_with_model_sum_n=1000, time: 2546 ms\n" + "<-- end same_model_with_model_sum_n=1000, time: 2569 ms\n" ] } ], @@ -287,7 +288,7 @@ "output_type": "stream", "text": [ "--> begin bench2 size=3000\n", - "<-- end bench2 size=3000, time: 15698 ms\n" + "<-- end bench2 size=3000, time: 15968 ms\n" ] } ], @@ -340,7 +341,7 @@ "output_type": "stream", "text": [ "--> begin bench3 size=3000\n", - "<-- end bench3 size=3000, time: 9409 ms\n" + "<-- end bench3 size=3000, time: 9406 ms\n" ] } ], @@ -388,7 +389,7 @@ "output_type": "stream", "text": [ "--> begin bench4 size=3000\n", - "<-- end bench4 size=3000, time: 9946 ms\n" + "<-- end bench4 size=3000, time: 10174 ms\n" ] } ], @@ -431,7 +432,7 @@ "output_type": "stream", "text": [ "--> begin bench5 size=3000\n", - "<-- end bench5 size=3000, time: 11013 ms\n" + "<-- end bench5 size=3000, time: 10753 ms\n" ] } ], @@ -464,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -472,7 +473,7 @@ "output_type": "stream", "text": [ "--> begin bench6 size=3000\n", - "<-- end bench6 size=3000, time: 9232 ms\n" + "<-- end bench6 size=3000, time: 7172 ms\n" ] } ], @@ -493,6 +494,46 @@ " build_bench_model6(N)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tip #6: experiment with Model.sum_vars\n", + "\n", + "`Model.sum_vars()` expects only variables as arguments. Although it speeds up expression building, it may cause errors when checker is disabled." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--> begin bench7 size=3000\n", + "<-- end bench7 size=3000, time: 6860 ms\n" + ] + } + ], + "source": [ + "def build_bench_model7(size=10):\n", + " m = Model(name=\"bench7\", ignore_names=True, checker='off')\n", + " rsize = range(size)\n", + " # create variables as a dictionary indexed by the range\n", + " ys = m.binary_var_dict(rsize, name=\"y\")\n", + " # create constraints\n", + " m.add((m.dotf(ys, lambda j_: i + (i+j_) % 3) >= i for i in rsize),\n", + " (\"ct_%d\" % i for i in rsize))\n", + " m.add(m.sum_vars_all_different(ys) >= 2, \"sum_vars_ys_ge_2\")\n", + " m.minimize(m.dotf(ys, lambda j_: j_ +1))\n", + " return m\n", + "\n", + "with ContextTimer(\"bench7 size={0}\".format(N)):\n", + " build_bench_model7(N)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -526,7 +567,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -535,78 +576,90 @@ "text": [ "* start computing performance data\n", "* start computing results...\n", - "--> begin [1/36] use build_bench_model1 with size=100\n", - "<-- end [1/36] use build_bench_model1 with size=100, time: 42 ms\n", - "--> begin [2/36] use build_bench_model2 with size=100\n", - "<-- end [2/36] use build_bench_model2 with size=100, time: 28 ms\n", - "--> begin [3/36] use build_bench_model3 with size=100\n", - "<-- end [3/36] use build_bench_model3 with size=100, time: 23 ms\n", - "--> begin [4/36] use build_bench_model4 with size=100\n", - "<-- end [4/36] use build_bench_model4 with size=100, time: 21 ms\n", - "--> begin [5/36] use build_bench_model5 with size=100\n", - "<-- end [5/36] use build_bench_model5 with size=100, time: 19 ms\n", - "--> begin [6/36] use build_bench_model6 with size=100\n", - "<-- end [6/36] use build_bench_model6 with size=100, time: 17 ms\n", - "--> begin [7/36] use build_bench_model1 with size=300\n", - "<-- end [7/36] use build_bench_model1 with size=300, time: 254 ms\n", - "--> begin [8/36] use build_bench_model2 with size=300\n", - "<-- end [8/36] use build_bench_model2 with size=300, time: 151 ms\n", - "--> begin [9/36] use build_bench_model3 with size=300\n", - "<-- end [9/36] use build_bench_model3 with size=300, time: 117 ms\n", - "--> begin [10/36] use build_bench_model4 with size=300\n", - "<-- end [10/36] use build_bench_model4 with size=300, time: 101 ms\n", - "--> begin [11/36] use build_bench_model5 with size=300\n", - "<-- end [11/36] use build_bench_model5 with size=300, time: 97 ms\n", - "--> begin [12/36] use build_bench_model6 with size=300\n", - "<-- end [12/36] use build_bench_model6 with size=300, time: 67 ms\n", - "--> begin [13/36] use build_bench_model1 with size=600\n", - "<-- end [13/36] use build_bench_model1 with size=600, time: 1021 ms\n", - "--> begin [14/36] use build_bench_model2 with size=600\n", - "<-- end [14/36] use build_bench_model2 with size=600, time: 892 ms\n", - "--> begin [15/36] use build_bench_model3 with size=600\n", - "<-- end [15/36] use build_bench_model3 with size=600, time: 417 ms\n", - "--> begin [16/36] use build_bench_model4 with size=600\n", - "<-- end [16/36] use build_bench_model4 with size=600, time: 410 ms\n", - "--> begin [17/36] use build_bench_model5 with size=600\n", - "<-- end [17/36] use build_bench_model5 with size=600, time: 418 ms\n", - "--> begin [18/36] use build_bench_model6 with size=600\n", - "<-- end [18/36] use build_bench_model6 with size=600, time: 251 ms\n", - "--> begin [19/36] use build_bench_model1 with size=1000\n", - "<-- end [19/36] use build_bench_model1 with size=1000, time: 3026 ms\n", - "--> begin [20/36] use build_bench_model2 with size=1000\n", - "<-- end [20/36] use build_bench_model2 with size=1000, time: 1701 ms\n", - "--> begin [21/36] use build_bench_model3 with size=1000\n", - "<-- end [21/36] use build_bench_model3 with size=1000, time: 1092 ms\n", - "--> begin [22/36] use build_bench_model4 with size=1000\n", - "<-- end [22/36] use build_bench_model4 with size=1000, time: 1207 ms\n", - "--> begin [23/36] use build_bench_model5 with size=1000\n", - "<-- end [23/36] use build_bench_model5 with size=1000, time: 1125 ms\n", - "--> begin [24/36] use build_bench_model6 with size=1000\n", - "<-- end [24/36] use build_bench_model6 with size=1000, time: 704 ms\n", - "--> begin [25/36] use build_bench_model1 with size=3000\n", - "<-- end [25/36] use build_bench_model1 with size=3000, time: 23946 ms\n", - "--> begin [26/36] use build_bench_model2 with size=3000\n", - "<-- end [26/36] use build_bench_model2 with size=3000, time: 15195 ms\n", - "--> begin [27/36] use build_bench_model3 with size=3000\n", - "<-- end [27/36] use build_bench_model3 with size=3000, time: 9592 ms\n", - "--> begin [28/36] use build_bench_model4 with size=3000\n", - "<-- end [28/36] use build_bench_model4 with size=3000, time: 9393 ms\n", - "--> begin [29/36] use build_bench_model5 with size=3000\n", - "<-- end [29/36] use build_bench_model5 with size=3000, time: 10426 ms\n", - "--> begin [30/36] use build_bench_model6 with size=3000\n", - "<-- end [30/36] use build_bench_model6 with size=3000, time: 7888 ms\n", - "--> begin [31/36] use build_bench_model1 with size=5000\n", - "<-- end [31/36] use build_bench_model1 with size=5000, time: 69977 ms\n", - "--> begin [32/36] use build_bench_model2 with size=5000\n", - "<-- end [32/36] use build_bench_model2 with size=5000, time: 45892 ms\n", - "--> begin [33/36] use build_bench_model3 with size=5000\n", - "<-- end [33/36] use build_bench_model3 with size=5000, time: 28273 ms\n", - "--> begin [34/36] use build_bench_model4 with size=5000\n", - "<-- end [34/36] use build_bench_model4 with size=5000, time: 27294 ms\n", - "--> begin [35/36] use build_bench_model5 with size=5000\n", - "<-- end [35/36] use build_bench_model5 with size=5000, time: 29352 ms\n", - "--> begin [36/36] use build_bench_model6 with size=5000\n", - "<-- end [36/36] use build_bench_model6 with size=5000, time: 18474 ms\n", + "--> begin [1/42] use build_bench_model1 with size=100\n", + "<-- end [1/42] use build_bench_model1 with size=100, time: 1116 ms\n", + "--> begin [2/42] use build_bench_model2 with size=100\n", + "<-- end [2/42] use build_bench_model2 with size=100, time: 39 ms\n", + "--> begin [3/42] use build_bench_model3 with size=100\n", + "<-- end [3/42] use build_bench_model3 with size=100, time: 27 ms\n", + "--> begin [4/42] use build_bench_model4 with size=100\n", + "<-- end [4/42] use build_bench_model4 with size=100, time: 23 ms\n", + "--> begin [5/42] use build_bench_model5 with size=100\n", + "<-- end [5/42] use build_bench_model5 with size=100, time: 23 ms\n", + "--> begin [6/42] use build_bench_model6 with size=100\n", + "<-- end [6/42] use build_bench_model6 with size=100, time: 21 ms\n", + "--> begin [7/42] use build_bench_model7 with size=100\n", + "<-- end [7/42] use build_bench_model7 with size=100, time: 19 ms\n", + "--> begin [8/42] use build_bench_model1 with size=300\n", + "<-- end [8/42] use build_bench_model1 with size=300, time: 245 ms\n", + "--> begin [9/42] use build_bench_model2 with size=300\n", + "<-- end [9/42] use build_bench_model2 with size=300, time: 163 ms\n", + "--> begin [10/42] use build_bench_model3 with size=300\n", + "<-- end [10/42] use build_bench_model3 with size=300, time: 114 ms\n", + "--> begin [11/42] use build_bench_model4 with size=300\n", + "<-- end [11/42] use build_bench_model4 with size=300, time: 113 ms\n", + "--> begin [12/42] use build_bench_model5 with size=300\n", + "<-- end [12/42] use build_bench_model5 with size=300, time: 92 ms\n", + "--> begin [13/42] use build_bench_model6 with size=300\n", + "<-- end [13/42] use build_bench_model6 with size=300, time: 72 ms\n", + "--> begin [14/42] use build_bench_model7 with size=300\n", + "<-- end [14/42] use build_bench_model7 with size=300, time: 73 ms\n", + "--> begin [15/42] use build_bench_model1 with size=600\n", + "<-- end [15/42] use build_bench_model1 with size=600, time: 1057 ms\n", + "--> begin [16/42] use build_bench_model2 with size=600\n", + "<-- end [16/42] use build_bench_model2 with size=600, time: 681 ms\n", + "--> begin [17/42] use build_bench_model3 with size=600\n", + "<-- end [17/42] use build_bench_model3 with size=600, time: 425 ms\n", + "--> begin [18/42] use build_bench_model4 with size=600\n", + "<-- end [18/42] use build_bench_model4 with size=600, time: 389 ms\n", + "--> begin [19/42] use build_bench_model5 with size=600\n", + "<-- end [19/42] use build_bench_model5 with size=600, time: 393 ms\n", + "--> begin [20/42] use build_bench_model6 with size=600\n", + "<-- end [20/42] use build_bench_model6 with size=600, time: 247 ms\n", + "--> begin [21/42] use build_bench_model7 with size=600\n", + "<-- end [21/42] use build_bench_model7 with size=600, time: 253 ms\n", + "--> begin [22/42] use build_bench_model1 with size=1000\n", + "<-- end [22/42] use build_bench_model1 with size=1000, time: 2768 ms\n", + "--> begin [23/42] use build_bench_model2 with size=1000\n", + "<-- end [23/42] use build_bench_model2 with size=1000, time: 1825 ms\n", + "--> begin [24/42] use build_bench_model3 with size=1000\n", + "<-- end [24/42] use build_bench_model3 with size=1000, time: 1128 ms\n", + "--> begin [25/42] use build_bench_model4 with size=1000\n", + "<-- end [25/42] use build_bench_model4 with size=1000, time: 1048 ms\n", + "--> begin [26/42] use build_bench_model5 with size=1000\n", + "<-- end [26/42] use build_bench_model5 with size=1000, time: 1046 ms\n", + "--> begin [27/42] use build_bench_model6 with size=1000\n", + "<-- end [27/42] use build_bench_model6 with size=1000, time: 693 ms\n", + "--> begin [28/42] use build_bench_model7 with size=1000\n", + "<-- end [28/42] use build_bench_model7 with size=1000, time: 714 ms\n", + "--> begin [29/42] use build_bench_model1 with size=3000\n", + "<-- end [29/42] use build_bench_model1 with size=3000, time: 24263 ms\n", + "--> begin [30/42] use build_bench_model2 with size=3000\n", + "<-- end [30/42] use build_bench_model2 with size=3000, time: 16222 ms\n", + "--> begin [31/42] use build_bench_model3 with size=3000\n", + "<-- end [31/42] use build_bench_model3 with size=3000, time: 9826 ms\n", + "--> begin [32/42] use build_bench_model4 with size=3000\n", + "<-- end [32/42] use build_bench_model4 with size=3000, time: 9843 ms\n", + "--> begin [33/42] use build_bench_model5 with size=3000\n", + "<-- end [33/42] use build_bench_model5 with size=3000, time: 10558 ms\n", + "--> begin [34/42] use build_bench_model6 with size=3000\n", + "<-- end [34/42] use build_bench_model6 with size=3000, time: 9044 ms\n", + "--> begin [35/42] use build_bench_model7 with size=3000\n", + "<-- end [35/42] use build_bench_model7 with size=3000, time: 6884 ms\n", + "--> begin [36/42] use build_bench_model1 with size=5000\n", + "<-- end [36/42] use build_bench_model1 with size=5000, time: 70562 ms\n", + "--> begin [37/42] use build_bench_model2 with size=5000\n", + "<-- end [37/42] use build_bench_model2 with size=5000, time: 50955 ms\n", + "--> begin [38/42] use build_bench_model3 with size=5000\n", + "<-- end [38/42] use build_bench_model3 with size=5000, time: 28237 ms\n", + "--> begin [39/42] use build_bench_model4 with size=5000\n", + "<-- end [39/42] use build_bench_model4 with size=5000, time: 27734 ms\n", + "--> begin [40/42] use build_bench_model5 with size=5000\n", + "<-- end [40/42] use build_bench_model5 with size=5000, time: 28905 ms\n", + "--> begin [41/42] use build_bench_model6 with size=5000\n", + "<-- end [41/42] use build_bench_model6 with size=5000, time: 18852 ms\n", + "--> begin [42/42] use build_bench_model7 with size=5000\n", + "<-- end [42/42] use build_bench_model7 with size=5000, time: 19793 ms\n", "* end computing results\n" ] } @@ -621,7 +674,8 @@ " (build_bench_model3, \"dotf\"),\n", " (build_bench_model4, \"batch_cts\"),\n", " (build_bench_model5, \"ignore_names\"),\n", - " (build_bench_model6, \"names_checker_off\")\n", + " (build_bench_model6, \"names_checker_off\"),\n", + " (build_bench_model7, \"sum_vars\")\n", " ]\n", "print(\"* start computing performance data\")\n", "res = {}\n", @@ -643,12 +697,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -696,7 +750,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "* geometric mean of time improvement is 3.5\n" + "* geometric mean of time improvement is 3.9\n" ] } ], @@ -734,9 +788,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "docplex37", "language": "python", - "name": "python3" + "name": "docplex37" }, "language_info": { "codemirror_mode": { @@ -748,7 +802,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.5" } }, "nbformat": 4, diff --git a/examples/mp/modeling/nurses_multiobj.py b/examples/mp/modeling/nurses_multiobj.py index bc9d96f..ed16ed1 100644 --- a/examples/mp/modeling/nurses_multiobj.py +++ b/examples/mp/modeling/nurses_multiobj.py @@ -522,7 +522,7 @@ def build(context=None, **kwargs): # Solve the model and print solution solve(model) - print(model.get_solve_details()) + print(model.solve_details) # Save the CPLEX solution as "solution.json" program output with get_environment().get_output_stream("solution.json") as fp: diff --git a/examples/mp/modeling/sport_scheduling.py b/examples/mp/modeling/sport_scheduling.py index 792d998..76ff2df 100644 --- a/examples/mp/modeling/sport_scheduling.py +++ b/examples/mp/modeling/sport_scheduling.py @@ -136,4 +136,4 @@ def print_sports_solution(mdl): with get_environment().get_output_stream("solution.json") as fp: model.solution.export(fp, "json") else: - print("Problem could not be solved: " + model.get_solve_details().get_status()) + print("Problem could not be solved: " + model.solve_details.get_status())