Static Tree Pricing Algorithm for SCF

The static tree pricing algorithm was presented in section 6.4.3 and listed as pseudo code in section 6.6. Limits and parameters k and ˜δ have been set as described in section 9.3.1. For the tests a huge amount of pricing possibilities arise, the main test subject was the impact on performance when using node-label constraints:

• We test how the static tree pricing algorithm performs when the SCF model uses only arc-label constraints and the pricing bases on the dual variablesu_ij. In contrast to it we test the

9.3. Branch-and-Price Results for Fraunhofer Data Chapter 9. Experimental Results

performance, when the model additionally includes node-label constraints combined with the according pricing strategy described in section 5.5 based on the dual variablesuij andµj.

• How do run times differ, when either a starting solution (star shaped spanning tree) or a Farkas pricing algorithm for determining a starting solution is used instead.

• How are run times affected, when pricing is restricted only to non-dominated template arcs or dominated arcs are allowed as well.

• How does the algorithm perform when only one arc with negative reduced cost per pricing step is determined, confronted to pricing all arcs with reduced cost<0 in one pricing step.

• How does disabling or enabling variable duplicates perform. For the former, in each pricing step we check if we already have found the actual template arc. If the actual arc was already priced, we add another variable, if existing, with equal or inferior reduced cost instead.

When doing this the problem turns out to be efficiently solved. The counterpart is to allow equal template arcs to be multiply priced.

• For the branch-and-bound decision tree we determine how depth first search (DFS) and best first search (BFS) perform.

• How does using continuous values for arcs variablesxij affect performance.

All the presented options may be combined. As listing each such test combination would take too much space, we present the fastest variants. All tested variants determined the correct minimal codebook. Test runs using DFS for the branch-and-bound tree have been showed not to be com-petitive for our purposes. So for all presented test runs BFS has been used. Also tests with a pricing algorithm that allows variable duplicates could not reach not in the least the run times of the pricing algorithm that does not permit variable duplicates and marks the found variable after each pricing iteration and hence is not listed here.

Tables 9.11, 9.12, 9.13, 9.14 and 9.15 show test data for the static tree pricing algorithm based on a SCF model. As already described, in these tables columns ‘alg[s]’ lists average algorithm run time in seconds as well as average total run time (columns ‘tot[s]’) in seconds. Columns ‘pit’ shows the average amount of pricing iterations, columns ‘pvar’ the average number of priced variables.

Columns ‘bbn’ shows the average amount of nodes created in the branch-and-bound decision tree.

Rows ‘BP/static’ shows data for a static tree pricing algorithm in standard configuration that em-ploys only arc-label constraints, uses a starting solution, determines in each pricing iteration only one arc with maximal negative reduced cost and allows no variable duplicates. The branch-and-bound decision tree uses BFS and we restricted the search to non-dominated template arcs. For rows ‘BP/static/nlc’ additionally node-label constraints have been used. For rows ‘BP/static/fark’

and ‘BP/static/nlc/fark’ a starting solution determined with Farkas pricing algorithm has been used instead of a star shaped spanning tree. Rows ‘BP/static/dom’ and ‘BP/static/nlc/dom’ show data for static tree pricing algorithms that allow dominated template arcs to be priced. The sys-tematic should be clear for ‘BP/static/nlc/fark/dom’. Rows ‘BP/static/allarcs’ lists run times for a static tree pricing algorithm that prices all arcs with reduced costs<0 in one pricing iteration.

Rows ‘BP/static/nlc/cont’ show average run times of the static tree pricing algorithm using an SCF, where arcs variablesxijhave been implemented as continuous values. This approach was con-sidered because of the following. As described in [CaClPa09] it is possible to solve the MLST formu-lated as a flow network formulations with real valued arcs variablesx. The result values forxmay be fractional, but the results for the labels are correct. We assumed that this may be the case also for our extended variant (selected nodes, directed). Computational tests support this assumption, and codebooks were determined correctly. Averages for the runs (rows ‘BP/static/nlc/cont’) are presented in tables 9.11–9.15. Tables 6 and 7 in the appendix show in row ‘BP/static/[AVG]’ the standard deviation as an average over ‘BP/static/[fark,dom,nlc,nlc/fark,nlc/dom,nlc/fark/dom]’

since values for these static tree pricing algorithm variants are very similar.

In test runs employing only arc-label constraints and 2-dimensional ˜δ one value (ft-19, ˜δ = (20,20)^>,k= 20)) exceeds the pricing iterations limit². The same test runs employing additionally

2When more elaborate tests are done, time and pricing iterations limit should be increased.

9.3. Branch-and-Price Results for Fraunhofer Data Chapter 9. Experimental Results

node-label constraints were all computed. For 3-dimensional ˜δ = (80,80,80)^> again the static segmentation tree could not be build because of memory usage. This must be regarded when comparing values. Mainly data for branch-and-cut, the SCF solved completely and static tree pricing algorithm are easily compared.

Branch-and-Price Initialization Times The static tree pricing algorithm has to perform an initialization step. It has to load the SCF model, generate variables and constraints, build the entire static tree, and determine the starting solution, a star shaped spanning tree (naturally, if Farkas pricing was not enabled). The building of such a starting solution is described in 5.6.

Average times for this step are listed in table 9.10 and correlate with the build time of a static tree. As we can see, this step increases the run times for big ˜δ= (80,80)^>with an average of 20.0 seconds, which often is much more than the effective branch-and-price run time. For small ˜δ, the effect is almost negligible.

Table 9.10: Average initialization times in seconds for static tree pricing algorithms, 2-dimensional ˜δ.

fhg/2d

k (10,10)^> (20,20)^> (30,30)^> (40,40)^> (80,80)^>

10 0.11 0.41 1.12 2.19 15.92

20 0.17 0.63 1.67 2.92 17.44

30 0.25 0.87 2.36 3.81 20.05

AVG 0.18 0.64 1.72 2.97 17.80

stdev 0.07 0.23 0.62 0.81 2.09

fhg/3d

All variants determined a correct minimal codebook. As we can see in tables 9.11, 9.12, 9.13, 9.14 and 9.15, branch and price performs very good for big 2-dimensional ˜δ= (40,40)^>,(80,80)^>

values. The number of priced variables with these parameters is very small when compared to the setT^c(discussed in section 9.4). So is the number of branch-and-bound nodes. For smaller ˜δ, and askincreases, more pricing iterations, as well as branch-and-bound nodes are needed to solve the problem. Accordingly, the run times are higher. For 3-dimensional ˜δthe run times can not reach the excellent branch-and-cut run times, the best values were achieved with small ˜δ= (10,10,10)^>. As we can see in the tables concerning 2-dimensional data, the run time decreases whenkincreases and ˜δis small. In case ˜δis big, the opposite effect occurs, and run times increase with the size of k. For the amount of pricing iterations, the same effect is noted, the amount of pricing iterations directly influence the run times. Best values for big ˜δ= (80,80)^>are result when using node-label constraints, for big ˜δ= (40,40)^> Farkas pricing is more effective. The effects of having a better starting set take effect the more ˜δ increases from (10,10)^> to (40,40)^>. When ˜δ is very big, the best template arcs can be found very quickly and a starting set built by Farkas pricing or a star shaped spanning tree makes very few difference.

In the according tables we see, that the static tree pricing algorithm test runs which include node-label constraints as well as the according pricing strategy perform best. The algorithms using node-label constraints are faster than the variants using only arc-label constraints. Branch-and-bound nodes as well as pricing iterations and priced variables are significantly smaller, especially the more k increases. If node-label constraints are used in combination with Farkas pricing, a very good starting solution (which may be different from the one described in 5.6) is found and results mostly in smaller run times and less priced variables. Interestingly, when allowing the pricing of dominated template arcs the branch-and-price algorithm performs well too. Pricing all arcs with a reduced cost <0 in one pricing iteration (using no node-label constraints) performs relatively good, but this approach is outperformed by the other tested variants. The smallest average amount of branch-and-bound nodes with an average of 289 (2-dimensional ˜δ) 292 (3-dimensional ˜δ) is achieved with the variant using node-label constraints. We can say that using node-label constraints reduce significantly the amount of branch-and-bound nodes. The overall

9.3. Branch-and-Price Results for Fraunhofer Data Chapter 9. Experimental Results

average of branch-and-bound nodes for the variants using node-label constraints is half of the ones needed for solving instances using no node-label constraints, but the average is influenced somewhat by relatively big branch-and-bound node values fork= 20, ˜δ= (20,20)^>. The variant using Farkas pricing in combination with node-label constraints has the smallest average amount of priced variables, which were averagely 299 with 2-dimensional ˜δand 638 for 3-dimensional ˜δ. Here, the amount of priced variables is small, since Farkas pricing determines better starting solutions with more template arcs that may be part of the solution. As fastest static tree pricing algorithm was determined ‘BP/static/nlc/fark’, the approaches ‘BP/static/nlc’ and ‘BP/static/nlc/dom’ are also relatively fast.

Figures 9.4 shows a comparison of run times for selected options. In figures 9.4a,9.4b the average was taken overk, thus depicting the performance for each ˜δparameter. In images 9.4c, 9.4d the average was taken over ˜δvalues, thus depicting the performance for different k. In these images we see that approaches that use node-label constraints perform better, the morekincreases. For small ˜δ, the node-label constraints are not very meaningful and the brought in information be-comes effective, when ˜δincreases.

Sheet1

Figure 9.4: Performance of selected options for the static tree pricing algorithm, figures 9.4a, 9.4b in the first row show the average overk, figures 9.4c, 9.4d in the second row the average over ˜δ.

Branch-and-price works correctly when arcs variables may hold continuous values (rows ‘BP/

static/nlc/cont’). The approach could not reach the average run times of the other approaches that use integer arcs variables, but for some parameter values good results for the amount of pricing iterations, priced variables and branch-and-bound nodes could be achieved. Higher run times are consequence of theSCIPframework that strongly utilizes heuristics, which are beneficial when having integer and binary variables.

The variant allowing variable duplicates was found to be the weakest and is not listed. For some instances a very big amount of variables (>100000) are multiply priced and increase needlessly the size of the LP.SCIPis able to cope with such multiple variables. All tested instances with this option enabled have run times exceeding greatly the run times presented here.

105

9.3. Branch-and-Price Results for Fraunhofer Data Chapter 9. Experimental Results