Evolutionary Learning of Weighted Linear Composite Dispatching Rules for Scheduling

A prevalent approach to solving job shop scheduling problems is to combine several relatively simple dispatching rules such that they may benefit each other for a given problem space. Generally, this is done in an ad-hoc fashion, requiring expert knowledge from heuristics designers, or extensive exploration of suitable combinations of heuristics. The approach here is to automate that selection by translating dispatching rules into measurable features and optimising what their contribution should be via evolutionary search. The framework is straight forward and easy to implement and shows promising results. Various data distributions are investigated for both job shop and flow shop problems, as is scalability for higher dimensions. Moreover, the study shows that the choice of objective function for evolutionary search is worth investigating. Since the optimisation is based on minimising the expected mean of the fitness function over a large set of problem instances which can vary within the set, then normalising the objective function can stabilise the optimisation process away from local minima. 1 JOB SHOP SCHEDULING The job-shop scheduling problem (JSP) deals with the allocation of tasks of competing resources where the goal is to optimise a single or multiple objectives – in particular minimising a schedule’s maximum completion time, i.e., the makespan, denotedCmax. Due to difficulty in solving this problem, heuristics are generally applied. Perhaps the simplest approach to generating good feasible solutions for JSP is by applying dispatching rules (DR), e.g., choosing a task corresponding to longest or shortest processing time, most or least successors, or ranked positional weight, i.e., sum of processing times of its predecessors. Ties are broken in an arbitrary fashion or by another heuristic rule. Combining dispatching rules for JSP is promising, however, there is a large number of rules to choose from, thus its combinations rely on expert knowledge or extensive trial-and-error process to choose a suitable DR (Tay and Ho, 2008). Hence given the diversity within the JSP paradigm, there is no “one-rule-fits-all” for all problem instances (or shop constraints), however single priority dispatching rules (SDR) based on job processing attributes have proven to be effective (Haupt, 1989). The classical dispatching rules are continually used in research; a summary of over 100 classical DRs for JSP can be found in (Panwalkar and Iskander, 1977). However, careful combinations of such simple rules, i.e., composite dispatching rules (CDRs) can perform significantly better (Jayamohan and Rajendran, 2004). As a consequence, a linear composite of dispatching rules for JSP was presented in (Ingimundardottir and Runarsson, 2011b). There the goal was to learn a set of weights, w via ordinal regression such that h(x j) = ⟨ w ·φ(x j) ⟩ , (1) yields the preference estimate for dispatching job j that corresponds to post-decision state x j, where φ(x j) denotes the feature mapping (cf. Section 4). In short, Eq. (1) is a simple linear combination of features found using a classifier which is trained by giving more weight to instances that are preferred w.r.t. optimality in a supervised learning fashion. As a result, the job dispatched is the following, j∗ = argmax j { h(x j) } . (2) A more popular approach in recent JSP literature is applying genetic algorithms (GAs) (Pinedo, 2008). However, in that case an extensive number of schedules need to be evaluated, and even for low dimensional JSP, it can quickly become computationally infeasible. GAs can be used directly on schedules (Cheng et al., 1996; Cheng et al., 1999; Tsai et al., 2007; Qing-dao-er ji and Wang, 2012; Ak and Koc, 2012), however, then there are many concerns that need to be dealt with. To begin with there are nine encoding schemes for representing the schedules (Cheng et al., 1996), in addition, special care must be taken when applying cross-over and mutation operators in order for schedules to still remain feasible. Moreover, in case of JSP, GAs are not adapt for fine-tuning around optima. Luckily a subsequent local search can mediate the optimisation (Cheng et al., 1999). The most predominant approach in hyperheuristics, a framework of creating new heuristics from a set of predefined heuristics, is genetic programming (Burke et al., 2013). Dispatching rules based genetic algorithms (DRGA) (VázquezRodrı́guez and Petrovic, 2009; Dhingra and Chandna, 2010; Nguyen et al., 2013) are a special case of genetic programming (Koza and Poli, 2005), where GAs are applied indirectly to JSP via dispatching rules, i.e., where a solution is no longer a proper schedule but a representation of a schedule via applying certain DRs consecutively. There are two main viewpoints on how to approach scheduling problems, a) local level by building schedules for one problem instance at a time; and b) global level by building schedules for all problem instances at once. For local level construction a simple construction heuristic is applied. The schedule’s features are collected at each dispatch iteration from which a learning model will inspect the feature set to discriminate which operations are preferred to others via ordinal regression. The focus is essentially on creating a meaningful preference set composed of features and their ranks as the learning algorithm is only run once to find suitable operators for the value function. This is the approach taken in (Ingimundardottir and Runarsson, 2011b). Expanding on that work, this study will explore a global level construction viewpoint where there is no feature set collected beforehand since the learning model is optimised directly via evolutionary search. This involves numerous costly value function evaluations. In fact it involves an indirect method of evaluation whether one learning model is preferable to another, w.r.t. which one yields a better expected mean. 2 OUTLINE In order to formulate the relationship between problem structure and heuristic efficiency, one can utilise Rice’s framework for algorithm selection (Rice, 1976). The framework consists of four fundamental components, namely, Problem space or instance space P , set of problem instances; Feature space F , measurable properties of the instances in P ; Algorithm space A , set of all algorithms under inspection; Performance space Y , the outcome for P using an algorithm from A . For a given problem instance x ∈ P with k features φ(x) = {φ1(x), ...,φk(x)} ∈ F and using algorithm a ∈ A the performance is y = Y (a,φ(x)) ∈ Y , where Y : A × F 7→ Y is the mapping for algorithm and feature space onto the performance space. (SmithMiles et al., 2009; Smith-Miles and Lopes, 2011; Ingimundardottir and Runarsson, 2012) formulate JSP in the following manner: a) problem space P is defined as the union of N problem instances consisting of processing time and ordering matrices given in Section 3; b) feature space F , which is outlined in Section 4. Note, these are not the only possible set of features, however, they are built on the work by (Ingimundardottir and Runarsson, 2011b; Smith-Miles et al., 2009) and deemed successful in capturing the essence of a JSP data structure; c) algorithm space A is simply the scheduling policies under consideration and discussed in Section 5; d) performance space is based on the resulting Cmax. Different fitness measures are investigated in Section 5.1; and e) mapping Y is the step-by-step scheduling process. In the context of Rice’s framework, and returning to the aforementioned approaches to scheduling problems, then the objective is to maximise its expected heuristic performance, i.e.,