the airline industry known as pairings) to monthly schedules ... the Air Line Pilot Association (ALPA),â .... memory and speed considerations force us to limit the ...
A Two-Phase Genetic Algorithm for LargeScale Bidline-Generation Problems at Delta Air Lines Ioannis T. Christou
Delta Technology 1001 International Boulevard Department 709 Atlanta, Georgia 30354
Armand Zakarian
Delta Technology
Jun-Min Liu
Delta Technology
Helen Carter
Delta Air Lines Department 028 PO Box 20706 Atlanta, Georgia 30320
We developed a two-phase algorithm for solving Delta Air Lines’ bidline-generation problem: assigning trips (tasks) to monthly schedules for crew members (called bidlines.) The system must produce bidlines that conform to all rules, and it should maximize average total value and the quality of the bidlines as measured by their purity. The first phase of the algorithm (the purity phase) constructs as many high-quality lines as possible, and the second (the GA phase) completes the assignments by constructing high-total-value valid lines from the remaining open trips. Delta obtains significant savings in staffing by using this algorithm. The bidlines produced are of comparable quality to those built with the semiautomatic process that Delta Air Lines used before.
T
he bidline-generation problem (BLP) is the problem of assigning trips (in the airline industry known as pairings) to monthly schedules (known as lines of time, bidlines, or simply lines) for the crew members of an airline. Crew members submit bids for the generated lines based on their seniority. The objectives of the assignment
are to maximize the quality of the schedules produced and to maximize the average value (pay) of the lines. The latter objective aims at improving both pay opportunities for crew and the efficiency of the airline by reducing staffing needs. All schedules produced must obey all the rules regarding the construction of
Copyright 䉷 1999 INFORMS 0092-2102/99/2905/0051/$05.00 1526–551X electronic ISSN This paper was refereed.
COMPUTERS/COMPUTER SCIENCE—ARTIFICIAL INTELLIGENCE, SOFTWARE INDUSTRIES—TRANSPORTATION
INTERFACES 29: 5 September–October 1999 (pp. 51–65)
CHRISTOU ET AL. lines of time set forth by the Federal Aviation Administration (FAA), the “Working Agreement Between Delta Air Lines and the Air Line Pilot Association (ALPA),” and company guidelines. These rules govern the construction of lines and accurately define the legality of a proposed line. The nature of these rules makes the problem at least NP-hard: Every trip has a property called pay or value (that roughly corresponds to the total flying time of the trip); the total pay rule states that each line must have a total pay within a predetermined window. Therefore, to solve the bidline-generation problem, one must solve at least the k-way numberpartitioning problem, a generalization of the number-partitioning problem [Garey and Johnson 1979], which is NP-complete. Trips may operate every day of the month, only Monday to Friday, or only a few times during the month. The trip instances must be assigned to lines (see Figure 1). The number of lines, n, is computed as n ⳱ [total flying hours/Wl] where the variable total flying hours is the total pay of all the trips operating during the given month, and Wl represents the minimum legal pay that each line can have according to the total-pay rule. This implies that n represents the maximum number of lines that may be built. In a legal assignment, each of these lines will either get a total pay within a specified window [Wl, Wu] (dictated by the total-pay rule) or it will be empty (no trips will be assigned to it). We may also leave a few trips (with a total value less than the minimum legal line value) unassigned (or in open time). The problem, therefore, is a complex assignment problem that can be formulated
as an integer nonlinear multicommodity network flow problem. Each trip represents a commodity to be transferred to the sink node through exactly one intermediate node (line or open-time). The costs along each arc (from a trip instance to a line or from a line to the sink node) are complex, nonlinear functions that become infinitely large when the flow of trips into a line makes the line illegal. Since the problem is NP-hard, we use heuristic algorithms to solve the BLP; in particular, we use a two-phase genetic algorithm (GA) that in its first phase constructs many high-quality lines, taking into account the concept of purity, a term used to define and measure the quality of the schedules produced. In the second phase, we use the GA to arrange the remaining open trips into valid lines of time. The GA solves a feasibility problem that is already highly constrained. This is therefore different from the traditional use of GAs as first-order optimizers to locate the neighborhood of optimal or almost optimal solutions. Basic Notions and Related Work A trip (pairing) consists of a sequence of flights with the first flight departing from the crew member’s base and the last returning to that base. A day’s worth of work is called a duty period; all duty periods in a trip except the last are followed by layovers at layover ports. A trip inherits various characteristics of the flights that make up the trip. The most important in terms of line quality and validity are the departure and arrival times of each leg of each flight and the total flight time of each leg. We are also concerned with value (pay) of the trip, which
INTERFACES 29:5
52
DELTA
Figure 1: Trip instances, for example, trip 3000 operating on the 30th of the month (on the left side), are assigned to bidlines (on the right side).
roughly corresponds to the total flight time. All of the rules regarding the validity of a proposed line of time can be expressed in terms of flight time or the distribution of working days or days off in the schedule. The total-pay rule specifies that the value of all lines should be within a userspecified window (typically six hours wide). The window may differ for different positions (that is, for captains or first officers) even for the same fleet. The FAA rules specify maximum allowed flying in a sliding window (for example, a maximum of 30 hours in any seven consecutive days). Another rule puts a five-day limit on the number of consecutive working days with specific provisions for returning to base on the sixth day. Finally, all lines should have some number of days off (for
example, 15), and days off may never appear by themselves. Another heuristic global optimization approach used to generate bidlines is simulated annealing [Campbell, Durfee, and Hines 1997]. However, Campbell, Durfee, and Hines let the simulated-annealing procedure search for high-quality solutions instead of using as much as possible apriori knowledge of the form of optimal or near-optimal lines to construct them directly. FedEx used their system as a tool to evaluate the effect of changing the rules on the quality and total cost of the solution, not for production. Jarrah and Diamond [1997] describe a successful set-partitioning approach with column generation. The system is not fully automatic. It allows the planner to define a set of constraints (scenarios) that are used to generate a set of lines (columns).
September–October 1999
53
CHRISTOU ET AL. The system then solves a set-partitioning problem to select a subset of the lines. The planner may at this point choose to break up some of the generated lines, select a new scenario, and restart the process. In the remainder of this paper, we first describe in detail the purity phase of the algorithm that is responsible for the high quality of the results; then we discuss the novelties of the genetic algorithm we designed and implemented [Christou 1996; Christou and Meyer 1996] to efficiently complete the assignment without any serious sacrifice of the quality of the lines. In particular, we describe the design of the GA so that it can solve the feasibility problem at hand and the representation issues (which are tightly connected with the evaluation function we use), together with some local improvement heuristics we implemented to converge faster to a desirable point. We also discuss techniques for avoiding premature convergence to undesirable local optima. We conclude with computational results that show that we can both achieve high-quality lines and reduce staffing requirements (compared with the lines Delta Air Lines previously produced semi automatically). The Purity Phase: Building High-Quality Bidlines We developed the line-of-time optimizer (LOTO) to solve a dual-objective optimization problem: It must assign all the trips for a given month to as few bidlines as possible (leaving open, or unassigned, trips with total value up to the minimum of the total pay window), and it must produce as many pure (regular) lines as possible. Determining whether a partially filled
line can be completed is of paramount importance, and the system must do this before placing any trip in the line to ensure creating a valid line of time. It uses a pathconstruction mechanism [Rehwinkel 1996] to determine the best path (the best combination of trips to make up a valid line). Here, best may imply the most pure or the highest-total-pay combination, depending on when the mechanism is used (for example, in the first or purity phase, best means most pure, whereas in the second phase, best means highest total pay). This path-construction mechanism creates a tree whose nodes are trips to be assigned. The root of the tree is a partially filled line. By traversing the tree from any of its nodes toward its root along the edges of the tree, the mechanism forms valid combinations of trips that can be placed on the line. From all the paths that correspond to valid, complete lines, the algorithm selects the best. If no path in the tree forms a valid, complete line, the partially filled line at the root of the tree is not completable and must be discarded. Since this tree can grow very large, memory and speed considerations force us to limit the number of nodes to be created in the tree. We set this limit to 50,000 nodes. The algorithm forms the tree through a combination of depth-first search and breadth-first search. The root node contains the current, partially filled line. Then, the algorithm examines, one at a time, each of the trips that can be placed in the line without violating any rules for assignment right after each of the trips that have been added to the tree so far. Whenever the system can fit a trip in the line after assigning to the line all the trips
INTERFACES 29:5
54
DELTA in the path beginning from the node that is being checked, it creates a new node representing this trip that points to the node being examined (Figure 2). This technique has allowed us to exploit most of the benefits of breadth-first search and depth-first search without using too much memory. Purity is a broad term in the airline industry, used to describe the quality of a line. There are two types of purity, trip purity and day purity. A line is trip-pure when all the trips in it are essentially repeats of one trip; for example, a line that consists of the trip 3415 (ATL (departs:0800) → EWR (departs:1300) → YYZ (layover) (departs:0930) → CVG (departs:1400) → EWR (layover) (departs:0800) → ATL) departing on the first, the eighth, the 15th, and the 24th is trip-pure. A line that consists of trips that depart on the same day of the week (for example, every Tuesday) is called day-pure; for example, a line that consists of the trip 3415 departing on the first, the eighth, the 15th, and the 22nd of the month is day-pure (and trip-pure as well, making it a perfectly pure line). However, a line can be trip-pure even if it consists of two different trips if they have the same duty periods (every duty period begins and ends within a few minutes of the corresponding duty period of the other trip, and they have the same layover cities). The trips are essentially the same, and so a line consisting of such trips is still trip-pure. A family of trips is a set of trips that are essentially the same for purity purposes (Figure 3). We implemented the following algo-
rithm (based on the agreement between ALPA and Delta Air Lines) to produce as many high quality lines as possible: (1) Select a family of pairings that are essentially the same pairings. (2) Estimate the number of lines, N, to be built from the family, and break them into groups of seven lines (so that the resulting lines are highly day-pure). (3) Place the ith trip of the family (in chronological order) into the (i mod N)th line, subject to the constraint that no rule is violated and that the line remains completable after this assignment. (4) Complete lines that were left incomplete in the previous step using a single filler trip that if possible maintains the day purity of the line, as well as the trip purity of the line. If there is more than one such
September–October 1999
55
Figure 2: Nodes on levels near the bottom are built after nodes at higher levels have been built, and nodes at the same level are built in a left-to-right order. Here we first build a path by adding trip 1 to the root node. Then we expand this path by adding trip 2 and we create yet another path by adding trip 2 to the root node. Then, we expand the most recently created path (trip 2 r root) by adding trip 4. Then, we add trip 4 to the path containing trip 2, trip 1 and the root and so on.
CHRISTOU ET AL. trip, choose the one with the highest total pay. (5) Complete any lines that were left incomplete in the previous step, using more than one filler, by choosing a combination that minimizes the number of different trips in the line. If more than a certain threshold (usually three) of different trips are needed to complete the line, reset the line and then free the assigned trips. (6) Do a stack test to ensure that no period of time requires more crew members to cover the open trips that operate during this interval than the estimated total number of lines. If the stack test fails, undo lines built from the family one by one until the stack test succeeds again. (7) If one or more lines are completed, go
to step 1. Steps 1 through 5 of the above algorithm create lines as in Figure 3. Step 6 solves a semiassignment problem, and it implements an algorithm due to Kennington and Wang [1992]. Semiassignment is a generalization of the assignment problem, where a task requires that more than one person be assigned to it (as a consequence, in semiassignment problems, the number of persons is larger than the number of tasks). Step 6 detects infeasibility of the BLP after the assignment of a combination of trips to a line. It cannot guarantee the feasibility of the assignment but serves very well to indicate that a period of time is left with too many open trips during the purity phase.
Figure 3: In this example of a set of lines built from a certain family of trips we select a fourday trip A operating Monday through Friday to form the family. We estimate that we can build five lines from this family. We cannot assign the trip on the 22nd of the month to the first line because the number of days off in this line would drop below the legal minimum of 15. Instead, we assign trip A on the 29th so that we use only two on-duty days in the month while maintaining perfect purity for the first line. We cannot use the same trick for the second line, however, since the first day of trip A doesn’t have enough value (roughly, flight time) to bring the total value of the line within the window. Instead, we select a high-value filler available on the 23rd, B, so as to maintain day-purity of the line. Similarly, we build lines three- to five-daypure using the same filler trip B.
INTERFACES 29:5
56
DELTA The purity phase ends either when all trips have been assigned into complete lines or when a family yields no lines. In the latter case, we use the second phase (the GA phase) to complete the assignment, that is, to assign the remaining open trips to valid lines. The Genetic Algorithm Phase: Completing the Assignments The second phase of the algorithm aims to assign trips to the incomplete lines to complete them and to achieve high total pay. Because there is no easy deterministic way to systematically search for a feasible assignment of the open trips to valid bidlines, we used GAs as randomized adaptive search procedures that can locate promising regions fairly quickly [Holland 1992]. The success of genetic algorithms in the field of scheduling [Michalewicz 1994; Syswerda 1991] prompted us to use them as a tool in this problem. In general, genetic algorithms work with populations of points (called individuals) in a search space, borrowing ideas from genetics and biology. Each iteration of the algorithm manipulates the individuals of the population so as to come up with new offspring that will make up the population in the next iteration. The initial population that bootstraps the computations is created randomly. Every individual is represented as a string composed of letters of a chosen alphabet (often, but not always, consisting of two digits {0, 1}); the representation must be able to map all the possible strings of the alphabet into points in the search space. An evaluation function measures the objective value of the point that the individ-
ual represents. This objective value is then scaled proportionately among the values of the other members of the population to produce a fitness value that reflects how “good” the point is compared with the other members of the population. And finally, a set of genetic operators manipulates members of the population to produce the new population. The genetic operators manipulate a selected subset of the current population whose members have fitness values that are above average. The set of genetic operators that can manipulate the individuals of a given population can vary widely from application to application, but the most often used operators (and the ones we use) are the one-point cross-over, mutation, and inversion. The one-point crossover is a procedure that operates on two individuals (strings) to produce two new individuals. One chooses a position in the strings at random, and the two strings are cut in this point. The first part of the first string is concatenated with the second part of the second string to form an offspring, and the second part of the first string is concatenated with the first part of the second string to form yet another offspring. In mutation, one chooses certain positions in a string at random and changes the letter of the alphabet at that point with another random letter. In inversion, one chooses two positions in the string randomly and inverts the substring within these two positions. We chose one-point crossover, mutation, and inversion as the three operators for the BLP because they have been shown to maintain diversity of the genetic material
September–October 1999
57
CHRISTOU ET AL. and to drive the search toward promising regions [Holland 1992; Michalewicz 1994]; they also fit naturally in the framework of our representation. We then evaluate the offspring produced via this “mating,” and if they are more fit than other members of the population, they survive the iteration, otherwise we replace them with their parents. The higher the fitness value of an individual, the more chances it has to mate repeatedly. This selection of the most fit parents to mate produces “selective pressure,” which pushes the search toward promising regions. In this way, the GA searches interesting neighborhoods for an optimal point. Because many points exist at each iteration in the population, we maintain enough diversity (we hope). One of the most crucial elements in applying a GA in a heavily constrained feasibility problem is selecting an appropriate representation. Because of the nature of the problem, one cannot use penalty methods that penalize infeasible individuals heavily, since most individuals will produce infeasible solutions. Similarly, one cannot incorporate problem-specific knowledge of the constraints into the evaluation function or the genetic operators to produce feasible solutions without performing an exhaustive search. Instead, we resorted to a semirepair method. The representation we chose is the following: every position in the individual’s string represents an open trip, so that the length of the genetic string is the number of open trips. The letter in the allele is a number in the range ⳮ1. . .L ⳮ 1 where L is the total number of lines to be built. The number ⳮ1 indicates that the
trip must not be assigned to any line at this time. Any other number in the range 0. . .L ⳮ 1 represents a guideline for placing the trip in a line. Figure 4 shows an individual’s representation as well as a possible crossover and mutation that two such strings might undergo. In particular, if the trip can be assigned in the indicated line without violating any rules and without rendering the line incompletable, the assignment is made; otherwise, the trip is assigned to the closest line (in numerical order) to the one indicated by the chromosome that will remain completable after the assignment (which should violate no constraint). It is possible that a trip won’t fit into any line, because by the time it is examined, the previous assignments of trips into lines prevent it from being assigned anywhere. After we check all the open trips represented in the individual for assignment, we execute local improvement methods in an attempt to further improve upon the proposed solution, thus acting as semirepair methods. This representation has a good potential for satisfying the building-block hypothesis: By using crossover, we can combine an individual’s string that represents good assignments of the first trips into lines with the last part of another individual’s string that places the last trips into other lines, and by doing so form a better total assignment. After tentative assignments have been cleared from all lines left incomplete, the evaluation function calculates the total open time of the unassigned trips. This means that the value of the objective function is an exact metric of the objective of the problem, which is to place the open
INTERFACES 29:5
58
DELTA
Figure 4: Here we show the process of mating to produce a new individual. The representation used is clearly shown. We show one-point crossover, which is a procedure that operates on two individuals (strings) to produce two new individuals. We choose a position in the strings at random, and the two strings are cut in this point. The first part of the first string is concatenated with the second part of the second string to form an offspring, and the second part of the first string is concatenated with the first part of the second string to form yet another offspring. In mutation, we choose certain positions in a string at random, and we change the letter of the alphabet at that point with another random letter.
trips into valid, complete lines leaving open trips that amount to no more than the lower end of the total pay window. Once an individual gets an objective value below this threshold (the total open time below the lower limit of the total pay window), the GA stops; a feasible solution has been found, and the resulting assignments are written in the database as the proposed solution. To speed up the search, after the individual’s string has been interpreted and various trips placed into lines, a local im-
provement heuristic based on swaps begins to further improve upon the current solution. In particular, the evaluation function executes a procedure (called DOSWAPS) that checks every line that is not yet complete for completion: If such a line can be completed from the open trips, after the line is cleared from its tentative assignments, the procedure assigns the combination of trips yielding the highest total pay; otherwise, we check the line against any other line that was built in the GA phase for swaps that will allow us to com-
September–October 1999
59
CHRISTOU ET AL. plete both lines by rearranging their assignments and by using open trips. Finally, if only one line is left incomplete (after attempts at swaps with other lines built in the GA phase), yet another swapping heuristic is used; the evaluation function executes a procedure (called COMPLETE-USING-PURE-LINES) to check whether it can complete the line by swapping trips with lines built in the purity phase (normally we would not undo these high-quality lines). If this fails to complete the last line and bring the total open time below the lower limit of the pay window, yet another procedure (called INCREASE-LINES-CREDIT) tries to finish the assignment by checking every line built in the GA phase first, then every line built in the purity phase, for any possible increase in the total pay of the lines by undoing some previously made assignments and substituting trips from those left open that have higher total pay. This procedure stops as soon as the value of the trips left open is less than than the lower limit of the total pay window. This simple heuristic has often enabled us to find a feasible solution early (within less than five generations) and thus cut computational costs, without significant sacrifices in the overall quality of the assignments. The reason the INCREASE-LINES-CREDIT heuristic often helps to complete the BLP is that in the purity phase, we build many very pure lines but can significantly improve their total pay, reducing the open time. When the open time is already close to the feasible region, we can easily find a valid solution in this way. If, after a certain number of generations, we have not found a feasible solution, we
undo a fixed number of lines (with the least total pay) that were built in the purity phase; the genetic algorithm starts again, using this expanded set of open trips and lines, trying to rearrange them into a feasible solution. The more pure lines undone, the easier it is for the GA to find a feasible solution because the problem becomes less constrained. However, it takes longer to perform a fitness function evaluation because more trips have to be assigned to lines. One of the problems most often encountered in GA research and applications is “premature convergence” [Michalewicz 1994]. Early in the GA iterations, the population becomes homogenized, losing diversity, usually because an individual with fairly high fitness value (but suboptimal) is selected for mating repeatedly so that subsequent generations are all descendants of this original super individual. Once the population has converged, finding another better point is practically impossible. This problem can become acute when elitist models are used to speed up the search; in such settings, offspring that are not strictly better than their parents do not survive the iteration, yielding their places to their better parents. As a consequence, the search quickly focuses in a few areas, and points that do not seem as good are discarded. To avoid premature convergence but still take advantage of the benefits of an elitist model, researchers have proposed various techniques [Christou 1996; Goldberg 1989; Michalewicz 1994]. Our GA phase employs DGA, a distributed genetic algorithm library. The selection mechanism DGA uses is
INTERFACES 29:5
60
DELTA the roulette wheel mechanism, where each individual occupies a portion of a wheel according to its fitness value. The wheel is then spun to select individuals for mating. Instead of spinning the wheel twice as many times as there are individuals in the population (a generational replacement technique), we opted for the steady-state approach [Levine 1995; Michalewicz 1994], in which 70 percent of the members of the population produce new offspring (not necessarily surviving though). This technique reduces the push of the selective pressure somewhat, allowing more diversity in the population for a longer period of time. Yet another, not so widespread mechanism, that of aging, is used to alleviate premature convergence. At birth, every individual is given a number of generations to “live” in the population, after which it will be removed from the population even if it is the most fit individual at the time. This limit on the individual’s lifetime is chosen from a normal distribution N (fitness(individual)*5,0.09). Consequently the more fit an individual is, the more generations it will survive (and have chances to mate), but eventually every member of the population will be removed, and this will greatly reduce the risk of premature convergence. DGA uses the island model of computation in which many GA processes run concurrently as islands, maintaining their own populations. These processes run asynchronously, thus minimizing the penalties of interprocess communication, and broadcast to each other some population statistics at the end of every generation iteration (Figure 5).
Each DGA process maintains its own population, which varies in size as the generations go on. Each island has a maximum capacity set. When an island becomes almost deserted (which implies that the population at some point consisted of low-fitness-value individuals that got a short life-span, and that their offspring did not survive or did not improve on the fitness values of their parents enough to avoid near extinction), the best-fit individuals of another island migrate to the almost empty island to give a new push to its evolutionary process and enhance its genetic diversity. The new population expands the search horizons. Age and migration together work as a powerful mechanism to alleviate premature convergence [Christou and Meyer 1996]. Computational Results The DGA library [Christou 1996] was written in ANSI C [Kernighan and Ritchie 1988], using the PVM 3.3.10 [Geist et al. 1994] message-passing library for interprocess communication. We wrote the LOTO algorithms in CⳭⳭ [Stroustrup 1997]; LOTO interfaces with a Sybase 10 DBMS for input/output purposes using SQL. We compiled the whole program using the xlC compiler under an IBM 591 RS 6000 workstation equipped with 256 MB of main memory, running AIX version 3.5.2. We used the ⳮO3 compiler optimization flag to compile the code. We set the crossover rate to 0.70 and the mutation rate to 0.01. We set the maximum population of each island to 16. An island sends individuals to another island if and only if the smaller population is at most half the size of the bigger population, but in our runs, only one island was
September–October 1999
61
CHRISTOU ET AL.
Figure 5: An asynchronous distributed genetic algorithm (DGA) is a set of running genetic algorithms, each enhanced with appropriate communication mechanisms to exchange necessary information with the other GA processes. At any iteration of a GA process, the process selects a number of individuals via the roulette wheel mechanism, and these individuals mate to produce new offspring via crossover, mutation, and inversion. After producing a new population, each GA process broadcasts population statistics information to the other processes and receives similar information from them. Then, it may decide to send some of the individuals in its population to other processes, basing this decision on the most recently received population statistics information. The GA process also probes for any incoming individuals from the other processes, and if it finds any, it inserts them in the population.
INTERFACES 29:5
62
DELTA created because we were running the system on a uni-processor environment: The memory requirements of each DGA process are too high for creating more than one such process per processor. Finally, if after 30 generations the algorithm has not found a feasible solution, it undoes around 20 percent of the lines built during the purity phase to make the problem less constrained. Table 1 shows the most important statistics of the LOTO run for November 1997 at Delta Air Lines’ largest base, Atlanta. (We implemented the system in production for the December 1997 bidlines.) LOTO builds lines with higher average value than the original semiautomatic process in almost all cases. Frequently the improvement is significant as in the case of the 767 fleet for both captains and first officers. The run time varies with the size of the problem from one minute to four hours 20 minutes. With these running times, the planners at Delta can build all the domestic pilot lines within two days. The process used to take four to six days. This reduction in time allows the airline to react much more quickly to last-minute changes in requirements. More important, the airline has time to optimize the lines by status, thus using crew more efficiently. Before implementing LOTO, Delta would frequently build only one set of lines for all statuses for a given fleet and base (using the fact that pairings for captains and first officers are the same and only the pay windows differ). For example, in the case of the MD-88 in Atlanta in November, the airline built a single set of lines for both captains and first officers by using a pay
window of 74 to 79 hours (the intersection of the captains’ 73:00–79:00 window and the first officers’ 74:00–80:00 window). Using a narrow window may adversely affect line quality by constraining the problem more. It also leads to an average line value that is more than an hour lower than the one possible (and computed by LOTO) based on a full six-hour window for first officers. We do not have the actual lines Delta built in November. However, we have the production lines for several categories from July 1997 that Delta provided to us when we started development of LOTO in June. In all cases we have compared, LOTO has built significantly more daypure lines than the semiautomatic process Delta was using for July (Table 2). Conclusions and Future Directions We have described LOTO, a system based on evolutionary programming ideas for efficiently solving the bidlinegeneration problem. In the first phase of the algorithm, many high-quality lines are produced; then, in the second phase, a genetic algorithm with appropriate representations for the problem at hand, equipped with various strategies for avoiding convergence to undesirable points and with local improvement heuristics based on swaps that resemble hill-climbing techniques, completes the assignment with a solution that satisfies both objectives to a high degree. For future work, we would like to experiment with different representations that would allow us to take more advantage of previously computed solutions to subproblems; in particular, we could produce many different lines using the path-
September–October 1999
63
CHRISTOU ET AL. construction mechanisms and then let the genetic algorithm solve a set-partitioning problem, that of choosing among these previously computed lines, so that each trip appears only once among the chosen set of lines. In this case, the GA would act as a coordinator, finding a solution to a global problem by fitting together as best as possible, solutions to a subproblem (namely the problem of creating one, fairly high-quality line). The success of GAs in solving problems formulated in a similar way in such fields as graph partitioning [Christou, Martin, and Meyer 1996] and pharmaceutical design [Hart 1994] suggests that the chances of applying this approach successfully to this field should be
very good. We would also like to try to solve the bidline-generation problem using exact methods (such as mixed integer programming [Nemhauser and Wolsey 1985]), even though formulating the objective of the problem is a challenge by itself [Campbell et al. 1997]. If the computational times to solve the problem exactly are not too great, this approach would give us the optimal solution. Finally, Delta is currently using the system to produce lines of time for the pilots of its domestic fleets. We intend to develop the rules that are in effect for the international fleets so that Delta can use the system for them as well.
Fleet
Base
Status
Cap
Line average (LOTO)
No. lines (LOTO)
Time (LOTO)
Line average (original)
727 727 727 737 737 767 767 L10 M88 M88
ATL ATL ATL ATL ATL ATL ATL ATL ATL ATL
CPT FO SO CPT FO CPT FO CPT CPT FO
79:30 79:00 78:30 82:00 79:00 77:30 80:30 80:00 79:00 80:00
76:41 76:10 75:30 79:39 76:53 75:08 78:03 76:46 76:31 77:36
143 144 145 35 36 319 307 102 233 230
0:21h 0:22h 0:10h 0:01h 0:01h 3:48 4:25h 0:17h 0:35h 0:58h
76:05
78:38 77:02 73:41 77:14 76:13 76:26
Table 1. We compare the average line values achieved by LOTO to the corresponding values for the original process used by Delta. The “Cap” is the upper bound of the total pay window, which is six hours wide.
Fleet
Base
Status
No. lines (LOTO)
Day-pure (LOTO)
2 D-P (LOTO)
No. lines (original)
Day-pure (original)
2 D-P (original)
767 767 M88 M88
ATL SLC ATL DFW
CPT CPT CPT CPT
314 68 241 144
41% 41% 27% 36%
11% 9% 10% 23%
322 70 243 145
7% 4% 19% 18%
21% 21% 38% 44%
Table 2. We compare day purity of the lines generated by LOTO to the lines generated in production. The columns labeled “2 D-P” show the percentage of lines containing trips starting on exactly two different days of the week.
INTERFACES 29:5
64
DELTA References Campbell, Kevin W.; Durfee, R. Bret; and Hines, Gail S. 1997, “FedEx generates bid lines using simulated annealing,” Interfaces, Vol. 27, No. 2, pp. 1–16. Christou, I. T. 1996, “Distributed genetic algorithms for partitioning grid domains,” PhD dissertation, University of Wisconsin– Madison. Christou, I. T. and Meyer, R. R. 1996, “Fast distributed genetic algorithms for partitioning uniform grids,” in Lecture Notes in Computer Science 1117, eds. A. Ferreira, J. Rolim, Y. Saad, and T. Yang, Springer-Verlag, Berlin, pp. 89–104. Christou, Ioannis T.; Martin, Wayne; and Meyer, Robert R. 1996, “Genetic algorithms as multi-coordinators in large scale optimization,” Technical report MP-TR-96-14, University of Wisconsin–Madison. Garey, M. R. and Johnson, D. S. 1979, Computers and Intractability: A Guide to the Theory of NPCompleteness, W. H. Freeman and Company, San Francisco. Geist, A.; Beguelin, A.; Dongarra, J.; Jiang, W.; Mancheck, R.; and Sunderam, V. 1994, PVM 3 User’s Guide and Reference Manual, Oak Ridge National Laboratory, Oak Ridge, Tennessee. Goldberg, David E. 1989, Genetic Algorithms in Search, Optimization and Machine Learning, Addison-Wesley, Reading, Massachusetts. Hart, W. E. 1994, “Adaptive global optimization with local search,” PhD dissertation, University of California, San Diego. Holland, John 1992, Adaptation in Natural and Artificial Systems, MIT Press, Cambridge, Massachusetts. Jarrah, Ahmad I. Z. and Diamond, James T. 1997, “The problem of generating crew bidlines,” Interfaces, Vol. 27, No. 4, pp. 49–64. Kennington, J. and Wang, Z. 1992, “A shortest augmenting path algorithm for the semiassignment problem,” Operations Research, Vol. 44, No. 1, pp. 178–187. Kernighan, Brian W. and Ritchie, Dennis M. 1988, The C Programming Language, second edition, Prentice Hall, Englewood Cliffs, New Jersey. Levine, D. 1995, User’s Guide to the PGAPack Parallel Genetic Algorithm Library Version 0.2, Argonne National Laboratory, Argonne,
September–October 1999
Illinois. Michalewicz, Zbigniew 1994, Genetic Algorithms Ⳮ Data Structures ⳱ Evolution Programs, Springer-Verlag, Berlin. Nemhauser, G. and Wolsey, L. 1985, Integer and Combinatorial Optimization, John Wiley & Sons, New York. Rehwinkel, F. 1996, private communication. Stroustrup, Bjarne 1997, The CⳭⳭ Programming Language, third edition, Addison-Wesley, Reading, Massachusetts. Syswerda, G. 1991, “Schedule optimization using genetic algorithms,” in Handbook of Genetic Algorithms, ed. L. Davis, Van Nostrand Reinhold, New York, pp. 332–349.
Tim Dowdall, Manager–Crew Planning, Delta Air Lines, Atlanta, Georgia 30320, writes: “Delta Airlines has successfully implemented a line of time optimizer ‘LOTO.’ This function is being used in production on a monthly basis, and proves to be fast and reliable. LOTO has given the crew planning function a new element of operational flexibility. Delta Air Lines is now able to optimize the pilot monthly line of time by position, thereby adding a second and third dimension to a function that was previously a single dimension, manual process.”
65
