VNS is an improvement over VND that focuses on diversification. Where deterministic VND would be finished, VNS adds a probabilistic shaking phase. That means that a set of neighbor-hood structures, which are different from the ones employed by the VND and typically larger, are used to change the currently best known solution to escape its basin of attraction. We refer to Section 2.2.7 for further details.
Our proposed VNS algorithm uses a single type of shaking neighborhood structure in multiple configurations. Let this neighborhood structure be calledNs(v), withv ∈ [0,1]as parameter controlling the shaking vigor.Nsis based on the idea of clearing substrate nodes. WhenNs(v)
Algorithm 8.1:VNS for the VNMP Input : VNMP instance I
Output: Solution S for I
1 Solution best=initialize(I);
2 nni=1;
3 while!terminate()do
4 Solution candidate=shake(Ns(vbnni),best);
5 applyVND(candidate);
6 ifcandidate.value<best.valuethen// New best solution found
7 best=candidate;
8 nni=1;
9 end
10 else
11 ++nni;
12 ifnni>nmaxthennni=1
13 end
14 end
15 return best;
is applied to a VNMP solution,Nsrandomly selects dv· |V|esubstrate nodes. All virtual arc implementations that traverse the selected nodes are removed from the solution. All virtual nodes mapped to the selected substrate nodes are mapped to a substrate node that is allowed byM but not selected. If no such node exists, the mapping remains unchanged. The resulting solution is completed and improved by VND to create the final solution of one VNS iteration.
During the execution of VNS we apply Ns with different values for v. The used values are determined by two parameters, the base neighborhood sizevb and the count of iterations that have not resulted in an improvement of the best found solutionnni. At the beginning of a new iteration, Ns(vbnni) is applied to the currently best found solution and the result is improved by VND. If the solution created in this manner is better than the currently best known solution, nni is reset to one, otherwisenni is increased by one. The upper limit fornni isnmax. If this value is exceeded,nniis reset to one. The largest shaking neighborhood searched during VNS is Ns(vbnmax). Values forvbandnmaxhave to be chosen such thatvbnmax≤1. The shaking and improvement steps are applied until the time-limit is reached. The initial solution for VNS is built by the same method as for GRASP, but without randomization, i.e., CH-O. Algorithm 8.1 shows the general outline of the proposed VNS.
8.4 Results
To test the proposed GRASP and VNS algorithms, we used the same selection of VNMP in-stances as in the previous two chapters, that means 210 full-load inin-stances and 630 derived instances with loads 0.1, 0.5, and 0.8. In total, there are 120 instances for every size class and
Table 8.1: Average relative rankRreland its relation to the best result, average number of itera-tions (Its.), fraction of solved instances (Solv.) in percent and averageCafor different values of αper instance size.
Size GR-0.00 GR-0.10 GR-0.20 GR-0.30 GR-0.40 GR-0.50 GR-0.60 GR-0.70 GR-0.80 GR-0.90 GR-0.99 Rrel 20 0.278= 0.216= 0.219= 0.235= 0.215= 0.331> 0.384> 0.445> 0.516> 0.618> 0.842>
Its. 20 1998 2323 2641 2916 3142 3291 3453 3677 3751 3836 3897
30 780 896 1034 1153 1248 1399 1534 1588 1676 1667 1664
50 282 329 390 442 481 497 531 553 565 567 566
100 39 47 56 62 66 71 77 82 83 87 87
200 45 54 66 78 90 98 103 112 116 127 129
500 15 18 22 26 30 33 36 39 41 41 42
1000 4 5 7 7 9 10 11 12 12 12 12
Solv. 20 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 99.2
[%] 30 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0
50 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0
100 100.0 100.0 100.0 99.2 98.3 97.5 97.5 99.2 99.2 97.5 95.8
200 95.8 99.2 99.2 99.2 98.3 97.5 97.5 96.7 95.8 95.0 91.7
500 71.7 80.8 81.7 81.7 76.7 80.8 78.3 75.8 77.5 75.0 70.0
1000 34.2 58.3 57.5 55.8 60.0 55.0 54.2 55.8 55.0 55.0 55.8
Ca 20 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 8.6
30 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
50 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
100 0.0 0.0 0.0 1.3 2.5 3.7 2.8 1.5 1.5 2.5 4.2
200 0.4 0.0 0.0 0.1 0.4 1.6 0.9 1.8 2.0 4.9 20.4
500 120.5 92.8 50.0 26.9 47.1 32.8 55.7 54.1 76.8 89.4 83.9
1000 708.7 227.1 251.1 206.1 245.5 273.5 251.2 311.4 263.5 336.7 277.5
210 for every load. See Chapter 5 for more detail on those instances. A time-limit of 200 seconds was applied for sizes up to 100 nodes, 500 seconds for larger instances.
Our design goal for the proposed algorithms was solving VNMP-O. Therefore, the relative rank as defined in Section 3.7 will once again be our main performance metric. Section 8.4.1 com-pares the performance of the GRASP approach for different values ofα, Section 8.4.2 analyzes the performance of the VNS approach for different shaking neighborhood structure configu-rations and Section 8.4.3 shows a comparison of the best GRASP and VNS approaches, also considering previously presented algorithms.
8.4.1 GRASP
To evaluate the influence ofα on the GRASP approach, we tested values forα from0 (com-pletely random initial solution) to0.9in0.1increments and0.99(very similar initial solutions).
The average performance depending on the instance size can be seen in Table 8.1. Once again, we mark the relation of the results to the best observed result with=if no significant difference
could be observed, or > if the difference is indeed significant. See Section 2.4.2 for further details on the employed statistical tests.
Immediately visible in the presented data is the tendency of the best α value to rise with the instance size. For size 20, α ∈ [0,0.4]yields the best results w.r.t.Rrel, while for size 1000 α ∈ [0.5,0.8]. The reason for this behaviour is that for small instances, the randomized con-struction heuristic does not have to make as many random choices as for the larger instance sizes. Therefore, to get the same search space coverage w.r.t. initial solutions,αhas to be small for small instances. The results for the larger instances show that ifαis too small, then the per-formance degrades, because the initial solution is far too random. Another contributing factor is that VND takes longer to optimize a very random initial solution, as can be seen by the iteration counts, which increase with rising values ofα. Therefore, fewer iterations can be performed in the same amount of time.
Note that for finding valid solutions, lowαvalues seem to be beneficial, even for large instances.
The GRASP approaches presented here are already an improvement when compared to MA-O as outlined in the previous chapter. GRASP with anα ∈[0.1,0.2]is nearly able to find a valid solution to every instance of size 200, just a single instance remains unsolved. The solution derived for the one remaining instance has so little additional resource costCa, that the reported average is zero. This is by no means certain, as the results for α = 0.3 indicate. With this configuration, also one instance remains unsolved, but with a noticeable impact on the average Ca. Also for the two largest instance sizes, the average Ca is lower than for the best MA configurations.
Table 8.2 shows the influence ofαfor different load cases. Again we can observe that higher values ofα allow more iterations, but they do not lead to improved performance for high load.
Instead, a value forα ∈[0.4,0.5]seems to be best suited when performance at a specific load level across different sizes is most important. Lowαvalues are again beneficial for finding valid solutions and especially for the highest load, GRASP performs better than MA previously.
Based on these results, we select the GRASP approach with α = 0.4 (GR-0.40) for further comparisons. We will denote this configuration by GRASP-O.
8.4.2 VNS
To analyze the influence of different shaking neighborhood configurations, we performed exper-iments with nmax ∈ {2,5,10}andvb ∈ {0.01,0.05,0.1}to cover the range from very small changes with few shaking neighborhoods (i.e., few different configurations for Ns) to large changes with a lot of neighborhoods. Table 8.3 shows the performance of different neighbor-hood configurations based on instance size. The different configurations are labeled as “VNS-nmax.vb”, e.g., VNS-2.05 uses nmax = 2 and vb = 0.05. We can see a similar behaviour to GRASP. For smaller sizes, large shaking neighborhoods are beneficial, while large instance sizes require small neighborhoods for the best levels of performance. Smaller shaking neigh-borhoods lead to an increased number of iterations in the same amount of time. Also note the similarity in number of iterations between VNS-5.05 and VNS-2.10, caused by the very similar maximum shaking neighborhood sizes. Indeed, between sizes 50 and 500, there is no significant difference between the two configurations. Larger shaking neighborhoods seem to increase the chance of finding valid solutions. Indeed, VNS-10.10 is able to solve all instances of size 200.
Table 8.2: Average relative rankRreland its relation to the best result, average number of itera-tions (Its.), fraction of solved instances (Solv.) in percent and averageCafor different values of αper load.
Load GR-0.00 GR-0.10 GR-0.20 GR-0.30 GR-0.40 GR-0.50 GR-0.60 GR-0.70 GR-0.80 GR-0.90 GR-0.99 Rrel 0.10 0.520> 0.413> 0.330> 0.288= 0.299= 0.335= 0.419> 0.495> 0.573> 0.683> 0.766>
0.50 0.744> 0.586> 0.445> 0.384> 0.307= 0.313= 0.324= 0.354= 0.473> 0.574> 0.773>
0.80 0.782> 0.634> 0.521> 0.430> 0.305= 0.318= 0.312= 0.350> 0.397> 0.482> 0.695>
1.00 0.682> 0.568> 0.470> 0.377= 0.356= 0.360= 0.380= 0.407> 0.423> 0.482> 0.654>
Its. 0.10 1529 1737 1990 2193 2348 2490 2638 2781 2871 2917 2947
0.50 108 142 173 208 239 267 298 322 330 333 336
0.80 80 105 120 137 155 169 180 190 192 195 201
1.00 90 114 126 139 151 160 167 173 175 176 173
Solv. 0.10 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0
[%] 0.50 90.0 97.1 97.6 97.1 97.1 96.7 96.7 96.7 96.2 95.7 95.7
0.80 81.0 90.5 89.0 89.5 90.0 87.6 87.6 89.0 88.6 86.7 85.2
1.00 72.9 77.1 78.1 76.7 74.8 76.2 74.3 72.9 73.8 73.3 69.0
Ca 0.10 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
0.50 46.5 7.7 0.4 0.5 0.5 0.5 0.5 0.5 0.6 0.7 7.1
0.80 106.0 17.2 21.7 22.1 18.3 14.7 25.4 24.2 25.8 38.1 25.9
1.00 321.5 158.0 149.9 111.3 150.0 162.8 151.6 185.9 170.0 209.0 192.5
The averageCahowever is higher for the largest instance sizes than for GRASP-O. The results also indicate that increasing the shaking neighborhood size in multiple small steps works better than few large steps. This can be seen with configurations that have the same maximum shaking neighborhood size. VNS-10.01 and VNS-2.05 show no significant difference inRrel, except for sizes 200 and 1000 where using smaller steps is significantly better. The difference is more pronounced for VNS-10.05 and VNS-5.10. Until size 50 there is no difference in performance, for larger instances using smaller steps is significantly better.
The influence of the shaking neighborhood configuration across different load cases can be seen in Table 8.4. Small shaking neighborhoods lead to the best performance. Load0.1is an excep-tion, as larger shaking neighborhoods achieve the best results. As for the configurations with the same maximum shaking neighborhood size, smaller steps are a significant advantage for half of the load cases.
Based on these results, we chose VNS-10.01 for further comparison. We will denote this con-figuration by VNS-O.
8.4.3 Comparison
In this section, we compare our proposed algorithms GRASP-O (GR-0.4) and VNS-O (VNS-10.01) with previously presented algorithms. These are MA-O, the Memetic Algorithm for the VNMP introduced in Chapter 7, VND-O as introduced in Chapter 6, and the local improvement method VND on its own, to see improvement caused by GRASP and VNS when using it. Recall that the available run-time for MA-O was the same as for the GRASP and VNS algorithms and that MA-O also made use of VND for local improvement. The reported results of VND and VND-O are based on a time-limit of 1000 seconds. Note that we only show the average run-time for these two algorithms, since the others were run until the time-limit was reached.
Table 8.3: Average relative rankRreland its relation to the best result, average number of itera-tions (Its.), fraction of solved instances (Solv.) in percent and averageCafor different shaking neighborhood configurations per instance size.
Size VNS-2.01 VNS-5.01 VNS-10.01 VNS-2.05 VNS-5.05 VNS-10.05 VNS-2.10 VNS-5.10 VNS-10.10 Rrel 20 0.389> 0.436> 0.396> 0.416> 0.240> 0.244> 0.340> 0.198= 0.163=
Its. 20 7327 7327 7345 7325 6796 5812 6822 5701 4742
30 3721 3699 3670 3590 3132 2577 3156 2511 2010
50 1766 1758 1664 1583 1321 1042 1327 1001 786
100 415 389 346 311 237 181 233 169 127
200 504 450 399 349 270 208 260 192 147
500 157 143 124 110 85 67 83 62 48
1000 51 44 39 33 25 20 25 18 14
Solv. 20 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0
[%] 30 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0
50 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0
100 98.3 99.2 100.0 100.0 99.2 100.0 100.0 100.0 99.2
200 93.3 95.8 97.5 95.8 95.0 99.2 99.2 98.3 100.0
500 74.2 74.2 76.7 79.2 76.7 77.5 80.0 76.7 76.7
1000 55.8 55.0 59.2 53.3 55.0 54.2 55.0 55.0 53.3
Ca 20 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
30 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
50 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
100 1.2 1.3 0.0 0.0 1.3 0.0 0.0 0.0 0.6
200 13.6 2.5 6.1 3.9 4.1 1.4 0.5 0.4 0.0
500 97.3 100.0 68.5 76.5 86.1 91.7 87.9 86.3 107.2
1000 333.1 281.4 311.2 317.8 357.6 315.8 314.6 339.8 360.7
For the others, we show the number of performed iterations instead. One iteration is basically one execution of VND, which takes the majority of the required run-time, and some algorithm dependent actions. For GRASP, the execution of the randomized construction heuristic, for VNS the shaking and for MA the creation of a new individual. For reference, the average run-time of these three algorithms when considering different load cases is 328.5 seconds.
Table 8.5 shows the performance of the compared algorithms in relation to each other. It can be seen that the results achieved by GRASP-O are disappointing. It is significantly outperformed by the VNS and MA algorithms. However, using GRASP around VND is significantly better than using VND alone, except for size 1000, where both perform equally well. VND-O can only be beaten or matched by GRASP-O up to size 100, then VND-O achieves significantly better results. VNS-O works far better, achieving the best solutions for sizes 30 to 200. For size 20, MA-O works marginally better. Keep in mind however, that we selected a shaking configuration for the VNS that was significantly worse for the smallest instance sizes than the alternatives, so it should be possible to at least match the MA with a different configuration. For the two largest sizes, VNS-O is beaten by VND-O, partly because the VND-O had more run-time available (and
Table 8.4: Average relative rankRreland its relation to the best result, average number of itera-tions (Its.), fraction of solved instances (Solv.) in percent and averageCa for different shaking neighborhood configurations per load.
Load VNS-2.01 VNS-5.01 VNS-10.01 VNS-2.05 VNS-5.05 VNS-10.05 VNS-2.10 VNS-5.10 VNS-10.10 Rrel 0.10 0.393> 0.289= 0.253= 0.242= 0.239= 0.250= 0.250= 0.304> 0.390>
0.50 0.464> 0.408= 0.360= 0.407> 0.415> 0.458> 0.436> 0.486> 0.516>
0.80 0.446= 0.451= 0.408= 0.467> 0.471> 0.479> 0.486> 0.559> 0.535>
1.00 0.454= 0.407= 0.432= 0.449= 0.482> 0.528> 0.506> 0.546> 0.572>
Its. 0.10 6220 6176 6100 5992 5451 4640 5472 4542 3744
0.50 924 905 877 853 712 550 708 526 410
0.80 483 477 458 444 360 274 367 262 204
1.00 339 335 329 312 257 196 256 186 141
Solv. 0.10 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0 100.0
[%] 0.50 95.2 96.7 98.1 96.7 97.1 97.1 97.6 97.1 96.2
0.80 87.1 87.1 88.6 85.7 86.7 87.1 88.6 87.1 88.6
1.00 72.9 72.9 75.2 76.7 73.8 76.2 76.2 75.7 74.8
Ca 0.10 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
0.50 7.2 7.0 6.9 0.6 6.9 0.4 0.4 7.5 1.3
0.80 45.5 30.0 29.6 36.7 21.5 21.0 25.8 40.8 31.7
1.00 201.6 183.2 183.9 190.2 228.2 212.3 204.1 195.4 234.7
also made use of it) as evidenced by the average run-times. Also, it is not a coincidence that there is no significant difference between the GRASP, VNS, MA, and VND approaches for size 1000.
They all use VND as local improvement strategy, and as can be seen by the iteration count, not enough iterations could be performed to reap the benefits of the more involved heuristics within the available run-time. Based on the presented results, it seems that it is best to create one good solution and improve upon it (VNS-O), instead of creating a population of good solutions and profiting from their combination (MA-O) or trying to get lucky with randomly generated (and then improved) solutions (GRASP-O).
For solving instances at a specific load level, Table 8.6 shows that the VNS approach is the best choice across all load levels, achieving significantly better results than all of the other compared algorithms. There is no reason to use GRASP-O, it is matched or outmatched by VND-O within the same or lower run-time.