# Makespan estimation in a flexible job-shop scheduling environment using machine learning

David Tremblet, Simon Thevenin, Alexandre Dolgui

► To cite this version:

David Tremblet, Simon Thevenin, Alexandre Dolgui. Makespan estimation in a flexible job-shop scheduling environment using machine learning. International Journal of Production Research, 2024, 62 (10), pp.3654-3670. 10.1080/00207543.2023.2245918. hal-04420067v2

HAL Id: hal-04420067

https://hal.science/hal-04420067v2

Submitted on 16 Feb 2026

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons CC BY 4.0 - Attribution - International License
# ARTICLE TEMPLATE

## Makespan estimation in a flexible job-shop scheduling environment using machine learning

David Trembletª, Simon Theveninª and Alexandre Dolguiª

ªIMT Atlantique, LS2N-CNRS, La Chantrerie, 4 Rue Alfred Kastler, B.P. 20722, 44307 Nantes, France

### ARTICLE HISTORY

Compiled February 16, 2026

### ABSTRACT

A production plan gives the quantity of products to release on the shop floor in each period, where a period may represent a week or a month. The plan is the basis for negotiating order acceptance and delivery dates with customers and suppliers. The production plan must respect the available capacity on the shop floor, as underloading the shop floor leads to a loss of opportunity, and thus, a loss of competitiveness for the company. To properly manage the production capacity while negotiating with suppliers and customers, the production planners need a tool to accurately estimate the capacity consumption in each period. The computation of capacity consumption requires creating a detailed production schedule which is a complex task. Algorithms that find close to optimal schedules in a complex manufacturing environment are often time-consuming, which is impractical in a negotiation context. We investigate machine learning models to predict capacity consumption. We consider a flexible job-shop as commonly encountered in practice, and proposed several machine learning models. Namely, several variants of linear regression, decision trees, and artificial neural networks. Numerical experiments showed that our models outperform those found by both an exact approach and dispatching rules when computation time is short.

### KEYWORDS

Scheduling, Production planning, Machine Learning, Make to order production, Flexible job shop

## 1. Introduction

Production planning is an essential function of manufacturing operations management that decides the production quantities per period and item. This process results in a production plan, which supports decision-makers during negotiations with suppliers and customers. In particular, in a make-to-order or assemble-to-order manufacturing strategy, the production planners rely on the production plan to negotiate the acceptance of customers' orders, to negotiate the delivery date with customers, or to order the raw materials and components from suppliers. While negotiating with customers, the production planner modifies the plans, but they must ensure that the plan for each period respects the production capacity. Underestimating the capacity leads to an unfeasible plan, and thus the company delivers late to customers, and the planner does
a lot of firefighting to update the plan at the last moment. On the contrary, overestimating the capacity leads to a loss of opportunity, and this affects the competitiveness of the company. Consequently, during negotiations, production planners need a tool to predict quickly and accurately the capacity consumption of a production plan. An accurate prediction of capacity consumption prediction is decisive in order acceptance and scheduling, where production planners make real-time decisions to react to incoming orders or due-date quotations (Calosso et al. 2003). In these situations, make-to-order production systems are limited by the production capacity, and the producer negotiates with the client to reach an agreement on the delivery date or due date (Wang, Geng, and Cheng 2018). In this context, real-time prediction of capacity consumption enables better awareness of the lead times required to supply products or services, and it offers crucial information during negotiations.

In this work, we investigate the use of machine learning to predict this capacity consumption. Once trained, machine learning models can provide a prediction instantly. The proposed models benefit decision support software where planners manually adjust the production quantities, and the software informs on the impact of their decision on the production plan. For instance, before accepting a new order, the planner modifies the production plan, and the software provides him with an accurate estimate of the feasibility of the plan. In our study, we limit production planning to lot-sizing problems. In addition, we assume the factory operates in a flexible job-shop environment with sequence-dependent setup times. The consideration of this scheduling environment is motivated by the wide popularity of job-shop applications in industrial cases (Błażewicz, Domschke, and Pesch 1996) and by the rise of flexible resources in manufacturing systems.

This paper is a strong extension of the conference paper (Tremblet, Thevenin, and Dolgui 2022), where we first proposed a machine learning algorithm to predict the makespan of a flexible job-shop scheduling problem. The main contributions of the current paper are threefold. First, we strongly enhance the machine learning model with additional features, such as the results of dispatching rules. Our tests show that these features significantly improve the accuracy of the model. Second, we consider three additional machine learning models. Namely, an artificial neural network, linear regression, and a customized linear regression approach. The proposed linear regression trains the model in such a way that the capacity consumption is never underestimated in the training sample. The resulting model prevents the creation of plans that cannot be implemented on the shop floor. Third, we perform computationally intensive experiments to evaluate the performance of the models. The results show that the proposed machine-learning models return accurate predictions that outperform dispatching rules and IBM's Constraint Programming Optimizer.

The structure of this paper is as follows. Section 2 presents a literature review on the flexible job-shop scheduling and machine-learning approaches for scheduling problems. Section 3 presents the formulation and the notation used for this problem as well as a constraint programming model. A description of our machine learning models is given in Section 4. The performance of our approach is then compared in numerical experiments carried out in Section 5, before concluding in Section 6.

## 2. Literature review

This section reviews the literature about approaches to predict the available capacity during order acceptance negotiation, before providing the state-of-the-art in the appli-
cation of machine learning methods to scheduling problems.

## 2.1. Capacity prediction in make-to-order production

The prediction of the completion time in make-to-order systems plays a crucial role in order acceptance and scheduling problems (Slotnick 2011). In these problems, customers place orders to be accepted or rejected by the firm while maximizing profit. Before accepting an order, the manufacturer must ensure he can produce it on time. If the capacity is insufficient to produce on time, the manufacturer may reject the order or quote a different delivery date to the customer.

Several mathematical models and heuristics have been proposed in the literature to solve scheduling problems in a make-to-order context problem (see Gharehgozli et al. (2007); Thevenin, Zufferey, and Widmer (2016); Xu, Wang, and Huang (2015)). Often, the proposed approaches are not adapted to negotiation, as they require several minutes of run time. Recently, some studies investigated approaches to provide answers for this problem in a real-time context, with more and more complex scheduling environments being considered. Rahman, Sarker, and Essam (2015) proposed heuristics to provide quick solutions for a real-time order acceptance problem with permutation flow shop scheduling. The authors evaluated their methods on a real case study and validated the performance of their approach for this problem. Chen et al. (2021) also investigated the real-time order acceptance and scheduling problem with data-enabled permutation flow shops. They proposed a discrete event-based formulation coupled which allows capturing the production status of the shop floor, which is then transmitted to a bilevel interactive optimization.

To the best of our knowledge, the use of supervised learning approaches in order acceptance and scheduling problems has only been considered once in the literature (Nguyen 2016), although a few studies investigated the use of reinforcement learning algorithms for this problem (Arredondo and Martinez 2010; Li, Wang, and Sawhney 2012).

## 2.2. Machine learning approaches in scheduling

The use of machine learning algorithms for industrial applications is not new, and a lot of approaches based on machine learning have been proposed to solve scheduling problems (Bertolini et al. 2021).

This section reviews the applications of machine learning approaches to approximate the completion times required to perform jobs in scheduling environments. We reduced the scope to job-shop and, more specifically, flexible job-shop scheduling problems.

Brandimarte (1993) introduced the flexible job-shop scheduling problems (FJSP) at the beginning of the 1990s. Nowadays, many solvers based on mathematical programs or constraint programming can solve small-size instances of this problem efficiently. However, the FJSP is NP-hard (Garey, Johnson, and Sethi 1976), and such approaches cannot find optimal solutions for large-scale instances in a reasonable amount of time. Therefore, several authors (Shen, Dauzère-Pérès, and Neufeld 2018, e.g.,) propose heuristics to solve large-scale instances of the FJSP.

In the present work, we are interested in approaches to solve large-scale instances instantly, whereas metaheuristics typically require several minutes up to hours of computations (e.g., Thevenin, Zufferey, and Glardon 2017). In such a context, greedy heuristics and dispatching rules are more appropriate. The scheduling literature also provides
methods based on machine learning prediction. Indeed, while the training of machine
learning models may be time-consuming, once trained, such models can provide pre-
dictions in less than a second. For example, Jong et al. (2019) proposed a visual com-
puting approach that approximates the makespan by using a visual representation of
the shop floor. Other machine learning applications (usually with decision trees) select
the best dispatching rules to apply with respect to features of the problem (Nakasuka
and Yoshida 1992; Li and Olafsson 2005; Lee, Piramuthu, and Tsai 1997). Such dis-
patching rules are easy to interpret and apply. This approach is commonly combined
with heuristics such as genetic algorithms, since the machine learning based dispatching
rules can generate a large number of interesting initial solutions, and this helps genetic
algorithms converge to a promising solution (Lee, Piramuthu, and Tsai 1997; Ho, Tay,
and Lai 2007). Recently, Jun, Lee, and Chun (2019) proposed a framework based on
random forest and genetic algorithm to solve the FJSP with release dates and due dates,
where the objective is to minimize the total weighted tardiness. The authors compare
their approach to other machine learning models, to exact methods, and to a heuristic.
Although the heuristic provides the best schedule, it is slower and lacks of scalability
when dealing with large-scale instances. In contrast, the method that combines random
forest and genetic algorithm provides good quality solutions in less than a second, which
is suitable in a context of urgent order acceptance, or for user interaction in the context
of a scheduling software.

In the area of machine learning methods, reinforcement learning has also sparked a
growing interest. Recently, some studies started to investigate the use of methods based
on reinforcement learning for flexible job-shop scheduling problems (Chen et al. 2020;
Luo 2020; Liu, Piplani, and Toro 2022). These approaches have proven to be efficient
in dispatching operations on the shop floor, especially when arrival dates and due dates
are considered.

Makespan approximation with machine learning is relevant to compute instantly the
minimum time required to process all jobs on the shop floor. User interactions with
scheduling software ask for such fast computation, and this occurs for instance in joint
human/computer scheduling, or when an operator needs to accept clients' orders while
discussing with the customer. However, very few studies consider makespan prediction
for job-shop scheduling, since such prediction gives no information on the schedules or
on the dispatching rule to apply. Nevertheless, the use of machine learning to predict the
makespan was considered in the context of batch processing, which often requires esti-
mating the total flow time of the job to release on a shop floor. Raaymakers and Weijters
(2003) came up with a comparison between regression analysis and neural networks for
a makespan approximation in a job-shop scheduling problem. Schneckenreither, Haeus-
sler, and Gerhold (2020) proposed neural networks models to predict the lead times for
order release planning. The goal of their prediction is to decide when to release orders in
both the flow shop and job-shop based on the estimated completion time found by the
machine learning approach. Predicting lead times is important in their problem since
it has a direct impact on the backorder costs which may occur when the quantities to
produce are too tight to be processed on the shop floor. Their approach is therefore able
to predict values for the lead time which are closer to the real one when compared to
other forecast methods. In another related context, Patil (2008) investigated the use of
neural networks and meta-heuristics in a due-date quotation context. The proposed ap-
proach is able to predict attractive due dates, which are useful for negotiation processes
occurring after the arrival of an order.

More recently, Kim and Maravelias (2022) proposed supervised learning methods in
a chemical production scheduling context. The authors consider logistic regression to
predict the feasibility of production schedules and a random forest model to predict the computational time required by a MILP solver.

Machine learning for scheduling problems is also used in other contexts. Müller et al. (2022) propose a machine learning model to choose the best constraint programming solver given an instance of the FJSP. Li et al. (2020) use of machine learning to decide if rescheduling is necessary when the production on the shop floor deviates from the plan.

In this paper, we aim to investigate the use of machine learning approaches to predict the makespan in a more complex production environment (the FJSP), and we want to compare the prediction of several machine learning models. Besides their applications when an estimate of the makespan is required in less than a second, these machine learning models have also a prospective usage for the integration of the scheduling decisions into production planning models, especially lotsizing and MRP environment. Casazza and Ceselli (2019) and Dias and Ierapetritou (2019) propose approaches based on machine learning models to approximate the scheduling activities, and they integrate these predictions into a production planning model. In their approaches, each period of the production planning problem corresponds to a scheduling problem to be solved by the mean of mathematical models which embedded the machine learning translated to constraints and variables. Dias and Ierapetritou (2019) shows the efficiency of such an approach when dealing with complex instances with large planning horizons. Thus, the objective of this paper is to build more efficient models which can also be integrated into lot-sizing models for the case of material requirement planning software.

# 3. Problem Definition

## 3.1. *Description of the scheduling environment*

This paper considers a hierarchical production planning and scheduling environment, where the decisions made at the planning level are transferred to the scheduling level to ensure adherence to the plan. In an order acceptance context, the planner may assign the production of orders to a planning horizon of $T$ time periods (e.g., weeks or months), trying to respect due dates and minimize production costs, among other criteria. At the scheduling level, the production quantities for each item become a set of jobs that must be scheduled before the end of the period. Thus, a capacity is imposed for each period of the production plan, and the schedules associated with each of these periods must not exceed the available capacity for the period. In other words, in each period $t \in T$ of the production plan, the planner must solve a scheduling problem, for which the total completion time has to be lower than the available capacity in period $t$. In this work, we consider that the shop corresponds to a Flexible Job-Shop Scheduling Problem with sequence-dependent setup times (FJSP-SDST).

The FJSP-SDST is a variant of the Job-Shop Scheduling Problem, where a set of $n$ jobs $J$ have to be performed on a set of $m$ machines $M$ with respect to the routing. Each job $i$ is subdivided into $n_i$ successive operations. Since operations follow the same order for each job, we denote $O_{ij}$ the $j^{th}$ operation to be performed by job $i$ and $p_{ijk}^u$ the required processing time to process one unit of operation $O_{ij}$ on machine $k \in M$. In a flexible job-shop, some operations $O_{ij}$ are said to be flexible, which means they can be performed by one machine among the subset of machines $M_{ij} \subseteq M$ and with a processing time $p_{ijk}^u$ which depends on the machine $k \in M_{ij}$ on which the operation is assigned. Between each operation, the machines required extra time to shift from one job
to another, and a sequence-dependent setup time $s_{ii'}^k$ occurs when job $i'$ is processed after job $i$ on machine $k$. To simplify the notation, we also denote by $D^k = (s_{ii'}^k)_{1 \le i \le n, 1 \le i' \le n}$ the setup time matrix of our problem. The objective is to minimize the maximum completion time of the last operation performed, also denoted as makespan $C_{max}$. Thus, before accepting an order, an instance of the flexible shop scheduling problem described above has to be considered for each period to ensure that the production is feasible with respect to the capacity available at each period.

When dealing with the considered problem in practice, some characteristics of the FJSP-SDST remain the same in all the periods of the planning horizon. This is the case for the machine routings, all operations for all jobs, the setup times, and the operations flexibility. Only the processing times $p_{ijk}^u$ associated with each operation can change between the periods, depending on the production quantities decided at the planning level. Therefore, to better illustrate this situation, we consider, as an input parameter, the lot sizes $l \in \mathbb{R}_+$ which represents the quantity of jobs $i \in J$ to be processed on the shop floor. Thus, we can compute the final processing time $p_{ijk}$ of each operation $O_{ij}$ to be performed on machine $k \in M$ by multiplying its time with the lot-sizes, i.e. $p_{ijk} = l_i \cdot p_{ijk}^u$. By considering these adjustable processing times, we can generate a large pool of flexible scheduling instances with the same structure by only modifying the lot sizes of jobs, which is more appropriate in an order acceptance context with fixed scheduling routings and fluctuating demands.

<figure><img src="image_2.png" /><figcaption>**Figure 1.** Caption: Example of lot-sizes applied to a scheduling instance

**Figure 1.** Alt Text: Two schedules for the same scheduling problems but with different lot sizes, one respecting the capacity and the other one not</figcaption></figure>

Figure 1 illustrates the impact of the lot-sizing decisions at the scheduling level. Figure 1 shows the optimal schedules for two instances with the same machines and routings but with different lot sizes. In this example, two jobs are considered, with three operations to be performed following routings over a set of four machines. Setup times are illustrated as black segments between each pair of operations performed on the same machine, whose length depends on the machine and the jobs to shift. On the left-hand side scheduling instance, the lot sizes are equal to one for both jobs 1 and 2 and the quantities respect the capacity, which is represented here by the end of the period. If we now suppose that another customer wants to order one quantity of product 1, the lot size $l_1$ of job 1 should increase by one and the scheduling problem should be reconsidered. The optimal solution of this new scheduling problem is given on the right, where the processing times of operations associated with job 1 are higher compared to the previous demand. Therefore, the makespan found for this schedule would exceed the capacity, and the planner has to choose to either reject the order or shift some workload on the other periods in order to identify a new feasible plan including this order. Note
that in this study, we focus on a batch processing environment, which means that, for each operation, the whole lot is processed and cannot be interrupted.

Finding a good approximation of the time required to process the orders on the shop floor is crucial for the competitiveness of companies operating with a make-to-order strategy. If the capacity consumption is underestimated, the company will not be able to deliver on time to its customers, and this will have a bad impact on its image. On the contrary, if the capacity is overestimated, the company will not produce as much as it could, and this lead to a loss of opportunity. Solving the scheduling problems to optimality would provide the exact capacity consumption for the production quantities in a period. However, solving scheduling problems is complex, and state-of-the-art metaheuristics usually require a relatively long time of computation to find good-quality solutions.

Besides, in the case of infeasible schedules, the planner may try to reallocate some quantities to the following periods, which requires solving several scheduling problems to place a single order. Therefore, the planning software must react quickly and precisely to answer rapidly to the demand of customers. This paper investigates if machine learning can provide a fast and precise estimation of the capacity consumption associated with the production quantities of a period decided at the planning level. In the following section, we propose a complete formulation of the FJSP-SDST, as well as a constraint programming model which will be used to compare our approach and also to generate a dataset for our experiments.

## 3.2. Problem formulation

In this section, we provide a constraint programming (CP) model to solve the FJSP-SDST. Some constraint programming solvers perform well on scheduling problems since they implement efficient heuristics. CP relies on the definition of variables defined over a discrete domain and problem-specific constraints to model the requirements of the problem. The solving paradigm behind CP solvers finds solutions by progressively assigning values to the variables while propagating constraints to reduce the search space. This process helps to reduce the domain of some variables due to inconsistency of the current solution, which leads to feasible solutions when all values are assigned or infeasible solutions when an empty domain is reached for at least one variable. This method has been extensively studied and is able to outperform Mixed Integer Linear Programs and metaheuristics for some scheduling problems (Yunusoglu and Yildiz 2021; Ham and Cakici 2016).

We use the notations and the global constraints provided by CP Optimizer (IBM 2021). The model is presented as follows:

$I_{\{ij\}}^{ops}$ : Interval variables representing all possible operation choices, for each $j^{th}$ operation of job $i \in J$,

$I_{\{ijkp\}}^{mops}$ : Interval variables for each operation, i.e., the $j^{th}$ operation of job $i \in J$, to be performed on machine $k$ with finite duration $p$,

$S_{\{k\}}$ : Sequence variables for each machine $k \in M$ for all operation interval variable $I_{ijkp}^{mops}$,

$C_{max}$ : Makespan to be minimized, i.e. the latest ending time among all operations $j \in n_i$ for all job $i \in J$.
$$ \min C_{max} \qquad (1) $$

s.t.

$$ \max_{\substack{i \in J \\ j \in 1..n_i}} (\text{endOf}(I_{\{ij\}}^{ops})) \leq C_{max} \qquad (2) $$

$$ \text{endBeforeStart}(I_{\{ij\}}^{ops}, I_{\{i(j+1)\}}^{ops}) \quad \forall i \in J, \forall j \in 1..n_i - 1 \qquad (3) $$

$$ \text{alternative} \left( I_{\{ij\}}^{ops}, \left\{ I_{\{ijkp\}}^{mops} \mid \forall k \in M_{ij} \right\} \right) \quad \forall i \in J, \forall j \in 1..n_i \qquad (4) $$

$$ \text{noOverlap}(S_{\{k\}}, D^k) \qquad \forall k \in M \qquad (5) $$

In the above constraint programming approach, the objective is to minimize the makespan (1), which is defined by inequalities (3) as the maximum over the completion time of each job. The precedence relations over the consecutive operations of each job *i* are defined by constraints (4). Constraints (5) are used to ensure that each operation *j* of job *i* is performed by a machine *k* among the set $M_{ij}$. Finally, constraints (2) guarantee that no overlapping occurs in the schedule, and that each machine processes at most one operation at a time. These constraints also ensure that a setup defined in the matrix $D^k$ occurs between each pair of jobs. Note that in the variable definitions, the fixed index *p* corresponds to the size of interval variable $I_{\{ijkp\}}^{mops}$, which corresponds to the processing time of operation $O_{ij}$ ($p = p_{ijk}$). Therefore, *p* is an input for our problem and is rounded up to ensure integer decision variables.

We solve FJSP-SDST instances with a constraint programming solver to build a large initial dataset which will be the starting point for the training of our machine learning models.

## 4. Description of the machine learning based approach

This section describes the machine learning models that predict capacity consumption given the production quantity of a period. We aim at training machine learning models using FJSP-SDST instances with different lot sizes in order to forecast an appropriate value for the makespan. Since the values to be predicted by our model are known in the training data set, we use supervised learning. For the considered application, we may either seek to predict the feasibility of a schedule, or we can estimate an appropriate value for the makespan. The former approach is related to a classification problem since the output returned by such models would be binary: yes or no. Although this approach is conceivable in our problem, it may not work when the capacity is not constant over all the periods, which can occur in the case of holidays or incidents leading to a temporary shutdown of the factory. On the other hand, the latter approach is related to regression analysis in the context of supervised learning, and it provides richer information in the context of production planning software. The prediction of the makespan can also be useful when overtime work can be planned, and thus the available capacity can be extended. Therefore, we present in the following subsections some relevant features to
be used as input for our models as well as four regression machine learning approaches trained to forecast the makespan of FJSP-SDST.

## 4.1. Machine learning models

In this study, we consider four regression models to estimate the makespan. These models take as input the features defined in section 4.2. A training step sets the parameters of the models to minimize the prediction error on a training dataset, and this error is usually the mean squared error between the predicted outcome and the targeted value of the sample. The initial data set contains a set of samples, where each sample gives the lot size of each job and the makespan of the associated scheduling problem. The additional features defined in subsection 4.2 are computed for each sample and added to the dataset.

The first three models considered in this paper are random forests, artificial neural networks, and linear regression. These three models were selected based on their performance in similar problems, and the rest of this section describes them successively. We also propose a more robust machine learning model based on linear regression.

### 4.1.1. Random Forest

Random forest model (Breiman 2001) is an ensemble method since it makes a prediction based on the estimation of multiple regression trees. More precisely, a random forest estimates the makespan with multiple regression trees, and it returns the average prediction of all the trees. This process reduces the overfitting and the high variance encountered when only one estimator is considered. An example of a regression tree structure is provided in Figure 2. In a regression tree, each split node corresponds to a linear condition based on one feature that indicates the path followed by the samples. To predict the value of a sample, the forecast approach starts at the root node, and it browses the tree by following a path based on the splitting conditions until reaching a leaf node. The value of this leaf node is the final prediction for the sample. The advantage of random forest is that it remains easily explainable when compared to the other machine-learning methods proposed in this paper. After reading the decision tree, the planner understands why the production plan exceeds the capacity, and he can adjust the plan accordingly.

<figure><img src="image_3.png" /><figcaption>**Figure 2.** Caption: Example of a single regression tree trained to predict the makespan</figcaption></figure>

<caption>**Figure 2.** Alt Text: An example of regression tree that predicts the makespan based on three attributes $l_1$, $F_2$ and $F_4$</caption>
### 4.1.2. Artificial neural networks

An artificial neural network is a set of interconnected nodes which interact with each other to provide a final prediction. Figure 3 provides an example of a feedforward neural networks framework with one input layer, two hidden layers, and an output layer returning the forecast. In this structure, the network is composed of several hidden layers, each of which contains a set of nodes holding the main component of the prediction computation. Each node is computed as a linear combination of the previous nodes weighted by some parameters, as linear regression does. Besides, to capture non-linear activities in the sample data, an activation function is applied at each node of the neural network. These models are powerful in finding abstract correlations between data and the targeted value and have proven their efficiency in a completion time estimation purpose (Raaymakers and Weijters 2003; Schneckenreither, Haeussler, and Gerhold 2020).

<figure><img src="image_4.png" /><figcaption>**Figure 3.** Caption: Example of an artificial neural network structure with two hidden layers of different lengths</figcaption></figure>

<caption>**Figure 3.** Alt Text: An artificial neural network with two hidden layers, one input layer with all the features and one output layer returning the forecasted makespan</caption>

### 4.1.3. Linear regression

The linear regression predicts the makespan with a linear combination of input variables weighted by parameters $α$. The fitting of parameters $α$ is an optimization problem that minimizes an error, usually the mean squared error, between the weighted linear combination of features and the targeted value for each sample of our training dataset.

Although the prediction of these regression models may be accurate, the methods are trained to minimize the prediction errors over a training dataset. Consequently, a regression model may overestimate or underestimate the value of the makespan for some samples of the dataset when no perfect fitting exists. An underestimation of the makespan can be alarming since it can lead the planner to exceed the production capacity in one period of the production plan. To avoid this issue, we propose a fourth machine learning model, which we call Constrained Linear Regression (CLR). This approach consists of a linear regression similar to the one described above, but this model forbids the underestimation of the makespan for all the samples of the training dataset. Such a constraint is imposed in the optimization process that fits the values of the
parameters in the training phase.

Standard mathematical models that fit linear regression while minimizing the mean absolute error rely on a linear program that looks for the best weights $\alpha_f$ to apply to each feature $f$ in the set of input features $F$. For each sample $s$ of a given dataset $D$, the prediction of the linear regression $Y^s$ is computed by summing up the values of the features $X_f^s$ weighted by their coefficient $\alpha_f$ and adding an intercept $\alpha_0$. Then, an absolute error $e^s$ between the prediction and the real makespan $C_{max}^s$ is computed for each sample $s \in D$. The same methodology is used in this study but we add constraints to this mathematical model which specify, for each sample of the training dataset, that the predicted value must always be greater or equal to the makespan of the sample.

The mathematical model used to train this model is formulated as follows:

$$ \min \quad \frac{1}{|D|} \sum_{s \in D} e^s \qquad (6) $$

$$ \text{subject to:} \qquad (7) $$

$$ \alpha_0 + \sum_{f \in F} X_f^s \alpha_f = Y^s, \qquad \forall s \in D \qquad (8) $$

$$ Y^s - C_{max}^s \le e^s, \qquad \forall s \in D \qquad (9) $$

$$ Y^s \ge C_{max}^s, e^s \ge 0, \qquad \forall s \in D $$

$$ \alpha_f \in \mathbb{R}, \qquad \forall f \in F $$

The objective function (6) minimizes the mean absolute error between the makespan of each data sample and the prediction of the linear regression. Equations (8) ensure that the prediction corresponds to the weighted sum of features plus the intercept for each sample $s \in D$. Constraints (9) compute the error between the makespan $C_{max}^s$ and the value $Y^s$ predicted by the linear regression. As the model ensures that the prediction never underestimates the makespan on the training dataset, it only minimizes the positive error. To ensure that the linear regression model always overestimates the makespan on the training dataset, we set the lower bound of variable $Y^s$ to the makespan $C_{max}^s$ for each sample $s \in D$.

## 4.2. Selection of input variables

This section introduces potential features which have a correlation with the makespan prediction. Many related works seek features that help approximate the makespan in scheduling problems (Mirshekarian and Šormaz 2016; Raaymakers and Weijters 2003). In our context, with a fixed scheduling environment and adjustable quantities for all the operations, many of these features are redundant or need to be adapted to our problem.

### 4.2.1. Job lot-sizes

The first set of features is the quantities associated with each job. In our problem, the lot-sizes $l$ have a direct impact on makespan, since they change the final processing times $p_{ijk}$ associated with the operations $O_{ij}$. Therefore, we consider the lot-sizes $l_i$, one for each job $i \in J$, as input of our machine learning models.
### 4.2.2. Sum of processing times

Along with the lot sizes, the different combinations of sums of processing times are also relevant in the prediction of the makespan. One example is the sum of processing times of all the operations to be performed on one specific machine $k \in M$. The maximum among all these sums gives a lower bound for the FJSP-SDST and its value may be correlated with the makespan. However, the computation of this lower bound requires knowing the affectation of tasks on machines, which is a decision of the problem. As the lower bound cannot be computed directly, we consider various features that help to approximate the sum of the completion time on each machine.

The parameters we use to compute the different features are:

* $o_{ijk}$ : The "operating ratio" for each operation $O_{ij}$ performed on machine $k$.

* $o_k$ : Estimated on the total number of operations to be performed on machine $k \in M$.

* $s_k^{mean}$ : Average setup times between each pair of jobs that can be performed on machine $k$.

* $s_k^{min}$ : Minimum setup times between each pair of jobs that can be performed on machine $k$.

Operating ratio $o_{ijk}$ provides the attractiveness of machine $k$ to perform operation $O_{ij}$. This parameter depends on the flexibility of the operation and on the processing speed of the machines since an operation is likely to be performed on the most efficient machine in the optimal solution. Thus, this ratio $o_{ijk}$ must increase when the processing time $p_{ijk}$ decreases and vice versa. In addition, the sum of all operating ratios for each operation $O_{ij}$ for each machine $k \in M_{ij}$ must be equal to 1.

To compute these ratios, we use the following expression:

$$o_{ijk} = \begin{cases} 0 & \text{if } k \notin M_{ij} \\ 1 & \text{if } M_{ij} = \{k\} \\ \frac{1}{p_{ijk} \cdot \sum_{k' \in M_{ij}} \frac{1}{p_{ijk'}}} & \text{otherwise} \end{cases}$$

The estimated number $o_k$ of operations to be performed on machine $k \in M$ is computed based on the operating ratio as follows:

$$o_k = \sum_{i \in J} \sum_{j \in n_i} \sum_{k \in M} o_{ijk}.$$

After computing these parameters, we propose four features as input for our machine learning models:

$$\bullet F_1 = \max_{k \in M} \left\{ \left( \sum_{i \in J} \sum_{j=1}^{n_i} \sum_{M_{ij}=\{k\}} p_{ijk} + s_k^{min} \right) - s_k^{min} \right\}$$

$$\bullet F_2 = \max_{i \in J} \left\{ \sum_{j=1}^{n_i} \min_{k \in M_{ij}} \{p_{ijk}\} \right\}$$

$$\bullet F_3 = \max_{k \in M} \left\{ \left( \sum_{i \in J} \sum_{j=1}^{n_i} o_{ijk} \cdot p_{ijk} \right) + (o_k - 1) \cdot s_k^{mean} \right\}$$

$$\bullet F_4 = \frac{1}{m} \sum_{k \in M} \left( \left( \sum_{i \in J} \sum_{j=1}^{n_i} o_{ijk} \cdot p_{ijk} \right) + (o_k - 1) \cdot s_k^{mean} \right)$$
Feature $F_1$ estimates the maximum among all the sums of processing times associated with each machine $k \in M$. This feature accounts only for the minimum setup times and non flexible operations to guarantee that these sums represent a lower bound of the makespan. Feature $F_2$ applies the same process but takes the maximum over all the sums of all processing times of each job instead. In the case of a flexible operation, only the operation with the smallest processing time is considered. Features $F_3$ and $F_4$ are computed by considering the estimated sums of processing times operating in each machine $k \in M$. $F_3$ represents the maximum value among all these sums, and $F_4$ the average value.

Both attributes $F_1$ and $F_2$ constitute lower bounds of the problem, while features $F_3$ and $F_4$ provide better approximations by taking flexible operations into account. Note that considering one feature for each sum of processing times for each job $i \in J$ is redundant in our case since these sums are linearly proportional to the lot sizes $l$. In addition, preliminary experiments showed that taking the estimated processing time per machine as a feature (rather than taking the average over all machines as $F_4$) does not yield better predictions.

### 4.2.3. Dispatching rules

Finally, we consider a set of features computed by constructing schedules following some well-known dispatching rules from the literature and returning the makespan found. In this paper, three rules are considered: The shortest processing times (SPT), Longest processing times (LPT), and First-in-first-out (FIFO) rules. In the case of flexible operation, the machine with the lowest workload is selected. The solutions found by these dispatching rules remain fast to compute and constitute some upper bounds for our problem.

### 4.2.4. Feature selection and extraction

Data preprocessing is an important machine learning step to enhance performance and reduce the computational complexity of predictive models. Data preprocessing generates new attributes and selects the most relevant and informative features. In this study, we focused on two preprocessing steps based on a polynomial feature transformation and a Least Absolute Shrinkage and Selection Operator (LASSO) feature selection. For this first step, a set of new attributes is created by generating polynomial combinations up to a maximum degree for each of the features defined in section 4.2. These new features provide additional information that helps to describe the training datasets and enhances the performance of estimators. For instance, when multiple jobs on the shop floor share the same machines, conflicts can arise between their respective operations. This can result in idle time on some machines, and it significantly increases the makespan. Therefore, polynomial combinations of lot sizes (e.g., $l_{(i,i')} = l_i \cdot l_{i'}$) for each unique pair of job $(i, i')$, provide additional information that is beneficial for machine learning models.

However, adding these new features increase the dimensionality of the dataset, thus the learning approaches become more complex to train and more prone to overfitting as the number of attributes increases. To overcome this issue, we apply a feature selection based on the wrapper method. This latter method consists in building machine learning models to obtain the prediction power of each attribute and retaining the most relevant ones with respect to their importance. In our study, we choose to fit LASSO models to measure the feature importance. LASSO builds a linear regression model minimizing
the mean squared error and adding a penalty term based on the L1-norm of the features (Tibshirani 1996). The fitted model assigns some weight to each feature, each of which tends to be shrunk to 0 when the importance of the corresponding feature is low. Therefore, the attributes with the lowest weight are removed from the training dataset and only a subset of features is retained for building the machine learning models.

In our experiments, we observed no significant improvement above a degree of 3 for the polynomial features and we choose to keep a subset of at most 300 attributes.

# 5. Computational experiments

## 5.1. Instances generation

We consider a company that operates with a make-to-order production strategy, where the shop floor is a job-shop environment. To train and test our models, we built several datasets based on FJSP-SDST instances from the literature. We consider three of the classical benchmark instances from (Hurink, Jurisch, and Thole 1994) for the Flexible Job-Shop Scheduling problem. In this set of instances, we choose the three job-shop scheduling problems *mt06*, *mt10* and *mt20*, derived from Fisher and Thompson (1963), which are standard instances of the literature for the job-shop scheduling problem (Jain and Meeran 1999). Each instance size represents a problem having respectively 6 jobs and 6 machines, 10 jobs and 10 machines, and 20 jobs and 5 machines. The number of operations is equal to the number of machines for each instance size. For the flexibility, we consider the *edata* set, where each operation has a probability of 15% of being flexible, i.e. to be performed on more than one machine from a given set. The setup times between each pair of jobs are randomly chosen from [1, 100] for *mt06* and [1, 1000] for *mt10* and *mt20*, respecting valid triangular inequalities for all instances sizes. To simplify the notation, we denote these instances by their size, which respectively are 6 × 6, 10 × 10, and 20 × 5.

These three job-shop environments give the machines and the precedences between the jobs. For each job-shop environment, we generate three data-set with 10,000 samples, where each of these datasets corresponds to a different lot-size range.

More precisely, given a job-shop instance, the operations of each job keep the same precedence graphs, but the processing times are proportional to the lot sizes as defined in Section 3. Each sample of the dataset represents a randomly generated vector of lot sizes *l* for each job to be performed, which reflects the corresponding order or demand for each of the products. We generated the lot sizes for each job by following a uniform distribution with support [1, 5], [5, 20], and [10, 40], one for each dataset. Therefore, the total number of datasets considered is equal to nine in our experiments, and each dataset contains 10,000 samples. Each sample is solved with the constraint programming model described in Section 3.2 with **IBM Ilog CP Optimizer** with a time limit of 5 hour. The experiments were conducted on a computer with an Intel Xeon Broadwell EP E5-2630v4 @ 2,20GHz with 124 Go of RAM. The makespan obtained for each sample is used as a target to be predicted by our machine-learning model.

Table 1 provides statistics on the nine datasets used for the experiments.

In this Table, the first four rows represent the average makespan obtained after respectively 10 seconds, 180 seconds, 1 hour, and 5 hours. The next four columns compare the average relative GAP obtained for the same times respectively. The ninth row provides the average CPU Time required to solve each sample. The next six rows provide information about the makespan, including the standard deviation, the minimum makespan,
<table><caption>**Table 1.** Dataset's descriptive statistics around the makespan</caption><thead><tr><th rowspan="2">Scheduling size</th><th colspan="3">6 × 6</th><th colspan="3">10 × 10</th><th colspan="3">20 × 5</th></tr><tr><th>[1,5]</th><th>[5,20]</th><th>[10,40]</th><th>[1,5]</th><th>[5,20]</th><th>[10,40]</th><th>[1,5]</th><th>[5,20]</th><th>[10,40]</th></tr></thead><tbody><tr><td>MEAN10</td><td>-</td><td>-</td><td>-</td><td>7975.9</td><td>16723.5</td><td>28156.6</td><td>12357.3</td><td>23833.5</td><td>38514.4</td></tr><tr><td>MEAN180</td><td>-</td><td>-</td><td>-</td><td>7722.9</td><td>16230.2</td><td>27855.4</td><td>11745.7</td><td>22963.8</td><td>37249.4</td></tr><tr><td>MEAN3600</td><td>-</td><td>-</td><td>-</td><td>7514.8</td><td>-</td><td>-</td><td>11625.6</td><td>22708.1</td><td>36847.0</td></tr><tr><td>MEAN</td><td>425.9</td><td>940.7</td><td>1649.1</td><td>7504.8</td><td>16220.9</td><td>27855.3</td><td>11581.5</td><td>22637.8</td><td>36728.9</td></tr><tr><td>GAP10(%)</td><td>-</td><td>-</td><td>-</td><td>39.6</td><td>24.0</td><td>12.3</td><td>33.5</td><td>24.8</td><td>18.6</td></tr><tr><td>GAP180(%)</td><td>-</td><td>-</td><td>-</td><td>37.6</td><td>4.5</td><td>0.0</td><td>30.0</td><td>22.0</td><td>15.9</td></tr><tr><td>GAP3600(%)</td><td>-</td><td>-</td><td>-</td><td>8.9</td><td>-</td><td>-</td><td>29.3</td><td>21.1</td><td>15.0</td></tr><tr><td>GAP(%)</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.1</td><td>0.0</td><td>0.0</td><td>29.0</td><td>20.9</td><td>14.7</td></tr><tr><td>Time (s.)</td><td>1.26</td><td>0.56</td><td>0.43</td><td>2973.0</td><td>118.7</td><td>24.0</td><td>18000.0</td><td>18000.0</td><td>18000.0</td></tr><tr><td>STD</td><td>27.3</td><td>100.5</td><td>208.0</td><td>345.3</td><td>1216.7</td><td>2385.7</td><td>382.2</td><td>1184.3</td><td>2293.3</td></tr><tr><td>MIN</td><td>339</td><td>623</td><td>968</td><td>6291.0</td><td>11652.0</td><td>16858.0</td><td>10247.0</td><td>17775.0</td><td>28342.0</td></tr><tr><td>25%</td><td>407</td><td>870</td><td>1504</td><td>7265.0</td><td>15405.0</td><td>26273.0</td><td>11322.0</td><td>21838.0</td><td>35166.0</td></tr><tr><td>MED</td><td>426</td><td>943</td><td>1653</td><td>7506.0</td><td>16259.0</td><td>27936.0</td><td>11576.0</td><td>22627.0</td><td>36719.0</td></tr><tr><td>75%</td><td>444</td><td>1012</td><td>1801</td><td>7739.0</td><td>17080.0</td><td>29513.0</td><td>11837.0</td><td>23448.0</td><td>38272.0</td></tr><tr><td>MAX</td><td>517</td><td>1230</td><td>2251</td><td>8682.0</td><td>20234.0</td><td>35518.0</td><td>13007.0</td><td>26888.0</td><td>44948.0</td></tr><tr><td>OPT</td><td>10000</td><td>10000</td><td>10000</td><td>9955</td><td>10000</td><td>10000</td><td>0</td><td>0</td><td>0</td></tr></tbody></table>

the 25th percentile, the median, and 75th percentile, and the minimum makespan. Finally, the last row shows the number of instances that were solved to optimality within the 5 hours time limit.

If the solver is able to find nearly all the optimal solutions within the time limit of one hour for all the samples of size 6 × 6 and 10 × 10, no optimal solution was found for the instances size of 20 × 5. We can also notice an average GAP between 14% and 29% for the larger instances. However, this GAP is not representative since CP Optimizer finds lower bounds that are very low compared to the optimal solution when reached. In the case of instance size 10 × 10, most of the solutions found between 1 and 5 hours have a GAP3600(%) above 30%, while the GAP between the solution obtained at 1 hour and the optimal solution never exceeds 10%.

Thus, although the solver finds near-optimal solutions for all the instances on average, the time required to solve the problem grows exponentially with the instance size. In addition, note that both the average GAP and Time tend to decrease when the lot-size distribution increases. This is mainly due to the setup times which become less important when the processing times associated with each job increase, leading to less complex instances.

In a make-to-order system, the makespan plays a crucial role when deciding if some orders should be accepted or not, depending on the number of jobs already processed. The order should be accepted if the factory can produce it with its available capacity. In our test data, we generate a value for the capacity of the shop floor, and this capacity value is a sensitive parameter for our experiment. If the capacity is too tight, then a model that always predicts the instance as infeasible would perform well. On the contrary, if the capacity is loose, a model that tends to predict the data as feasible would perform well. To avoid any bias, we generate the capacity in such a way that half of the data points are feasible, and the other half is infeasible. In practice, the proportion of samples that belong to each label may vary, but there exist techniques to artificially balance the categories. In other words, we considered an available capacity equal to the median makespan for each dataset, and half of the instances with a makespan lower than this capacity are considered as "Feasible" on the shop floor within the capacity, whereas the remaining half was labeled as "Infeasible". Each data sample will be predicted as Feasible if the makespan predicted by the model is lower than the available capacity
and Infeasible otherwise.

Therefore, besides the Mean Absolute Error between the real makespan and our prediction, we measured the accuracy, recall, and precision, which are common metrics used in classification. The accuracy corresponds to the proportion of samples that were correctly predicted by the method. The recall is the percentage of feasible plans that the method correctly predicts, while the precision is the percentage of infeasible plans that were correctly predicted by the model.

Models with high precision are crucial to limit the number of instances wrongly predicted as feasible by our model. These schedules are troublesome since they lead to infeasible production plans, which require a lot of effort on the shop floor to update the plan at the last moment. At the planning level, various actions can help to repair such infeasible plans, but they lead to larger costs. This includes the rejection or the late deliveries of some orders, express distribution modes, and deliveries of raw material, ... (Thevenin, Zufferey, and Glardon 2017). On the other hand, a model with lower recall but higher precision would reject some feasible solutions, but it would keep a larger set of feasible schedules.

For the experiments, we randomly sampled 80% of our dataset for training and the remaining 20% for the testing phase. We also performed a K-fold cross-validation with 5 folds to evaluate the performance of our machine-learning models and measure the influence of training datasets on the prediction. More precisely, each training dataset is divided into 5 subsets and 4 of these subsets are used for training while the remaining one is used for testing. We then average the score obtained for each fold in the experiments.

Each machine learning model was trained using the Scikit-Learn package (Pedregosa et al. 2011) for linear regression.

The default parameters are used for both linear regression and random forest, the latter embeds 100 regression trees. For neural networks, we trained different architectures and selected the one resulting in the best score in the cross-validation. We compared the number of layers as well as the number of neurons in each layer. We didn't notice significant differences between each of the architectures, although increasing the number of hidden layers implies a faster convergence for the model. The final model architecture includes 3 hidden layers with 100 neurons each.

The constrained linear regression (CLR) proposed in Section 4 was trained by solving the mathematical model presented in Section 4 using ILOG CPLEX 20.1.0.

## 5.2. *Numerical results*

Table 2, 3 and 4 report the performances of the machine learning models and several approximations of makespan for the dataset with respective lot-sizes between [1,5], [5,20], and [10,40]. In total, the four machine learning models presented in Section 4 are used to predict each dataset. As a comparison, we used the three dispatching rules used as features for our model (LPT, SPT, and FIFO). We also compared our results with those found by CP Optimizer with a time limit of 10 seconds and 180 seconds. The first case is appropriate in the context of an emergency, or during a negotiation with flexible planning software which requires checking multiple plans in a limited amount of time. The second case is less appropriate for fast computation of plans but remains interesting in the case where the planner would like to take the risk of waiting longer in the hope of reaching a feasible plan. We evaluated the results on both the cross-validation (CV) and the test (Test) datasets. The comparison between cross-validation and test also allows to compare the influence of the training dataset on the prediction and to validate the
<table><caption>**Table 2.** Prediction performance machine learning and other approximations of capacity consumption for lot-sizes with support [1,5]</caption><thead><tr><th rowspan="2">Size</th><th rowspan="2">Method</th><th colspan="2">Accuracy(%)</th><th colspan="2">Precision(%)</th><th colspan="2">Recall(%)</th><th colspan="2">MAE</th></tr><tr><th>CV</th><th>Test</th><th>CV</th><th>Test</th><th>CV</th><th>Test</th><th>CV</th><th>Test</th></tr></thead><tbody><tr><td rowspan="7">6 × 6</td><td>CLR</td><td>89.2</td><td>88.6</td><td>99.9</td><td>100.0</td><td>79.0</td><td>77.6</td><td>7.0</td><td>7.3</td></tr><tr><td>Linear Regression</td><td>96.2</td><td>96.3</td><td>96.7</td><td>97.2</td><td>95.9</td><td>95.5</td><td>2.5</td><td>2.5</td></tr><tr><td>Random Forest</td><td>96.6</td><td>96.4</td><td>97.0</td><td>97.7</td><td>96.3</td><td>95.2</td><td>2.5</td><td>2.4</td></tr><tr><td>Neural Networks</td><td>97.0</td><td>97.0</td><td>98.1</td><td>98.0</td><td>96.1</td><td>96.0</td><td>2.0</td><td>2.1</td></tr><tr><td>LPT</td><td>49.4</td><td>49.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>385.8</td><td>388.0</td></tr><tr><td>SPT</td><td>49.4</td><td>49.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>326.5</td><td>322.9</td></tr><tr><td>FIFO</td><td>49.4</td><td>49.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>158.9</td><td>158.7</td></tr><tr><td>CPO(10s)</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td></tr><tr><td>CPO(180s)</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td rowspan="7">10 × 10</td><td>CLR</td><td>91.3</td><td>90.4</td><td>99.9</td><td>99.9</td><td>82.2</td><td>80.9</td><td>81.3</td><td>86.1</td></tr><tr><td>Linear Regression</td><td>97.1</td><td>96.6</td><td>97.2</td><td>96.6</td><td>96.8</td><td>96.5</td><td>26.1</td><td>25.5</td></tr><tr><td>Random Forest</td><td>96.5</td><td>96.6</td><td>96.3</td><td>96.8</td><td>96.5</td><td>96.3</td><td>32.5</td><td>31.8</td></tr><tr><td>Neural Networks</td><td>96.9</td><td>96.6</td><td>97.2</td><td>97.4</td><td>96.5</td><td>95.7</td><td>28.8</td><td>27.4</td></tr><tr><td>LPT</td><td>51.9</td><td>49.9</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>11551.4</td><td>11576.8</td></tr><tr><td>SPT</td><td>51.9</td><td>49.9</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>9001.4</td><td>8971.7</td></tr><tr><td>FIFO</td><td>51.9</td><td>49.9</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>6055.4</td><td>6056.4</td></tr><tr><td>CPO(10s)</td><td>61.9</td><td>60.5</td><td>100.0</td><td>100.0</td><td>22.0</td><td>21.2</td><td>469.6</td><td>477.5</td></tr><tr><td>CPO(180s)</td><td>77.6</td><td>76.4</td><td>100.0</td><td>100.0</td><td>54.2</td><td>52.9</td><td>217.7</td><td>219.8</td></tr><tr><td rowspan="7">20 × 5</td><td>CLR</td><td>59.6</td><td>58.7</td><td>95.8</td><td>97.3</td><td>21.4</td><td>18.1</td><td>455.6</td><td>469.4</td></tr><tr><td>Linear Regression</td><td>81.5</td><td>83.0</td><td>82.6</td><td>83.0</td><td>80.7</td><td>83.1</td><td>166.1</td><td>163.0</td></tr><tr><td>Random Forest</td><td>81.4</td><td>83.2</td><td>82.3</td><td>83.3</td><td>80.9</td><td>83.1</td><td>165.5</td><td>165.4</td></tr><tr><td>Neural Networks</td><td>81.3</td><td>82.5</td><td>81.0</td><td>82.7</td><td>82.7</td><td>82.1</td><td>163.8</td><td>165.8</td></tr><tr><td>LPT</td><td>49.2</td><td>49.9</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>11730.8</td><td>11777.9</td></tr><tr><td>SPT</td><td>49.2</td><td>49.9</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>9892.2</td><td>9902.7</td></tr><tr><td>FIFO</td><td>49.2</td><td>49.9</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>7916.3</td><td>7916.2</td></tr><tr><td>CPO(10s)</td><td>53.5</td><td>53.8</td><td>100.0</td><td>100.0</td><td>8.5</td><td>7.8</td><td>775.0</td><td>779.0</td></tr><tr><td>CPO(180s)</td><td>83.8</td><td>84.0</td><td>100.0</td><td>100.0</td><td>68.1</td><td>68.1</td><td>165.0</td><td>161.6</td></tr></tbody></table>

performance of each approach if no significant difference can be observed (Liu and Özsu 2009).

Tables 2, 3 and 4 show that our predictive models are more accurate on average than the other approximation methods. Note that we do not report results for CPO(180) on 6 × 6 instances since CPO finds the optimal solution in less than 10 seconds. For the instance size of 6 × 6, the best performance is found by CP Optimizer, since all the optimal solutions were obtained before the time limit of 10 seconds. However, when dealing with larger instance sizes, the average MAE found by the latter approach is larger than most of the proposed machine learning models. When focusing on datasets with sizes 10 × 10 and 20 × 5, the best machine learning models in each category outperform the constraint programming solver in 10 seconds, with a difference in accuracy that goes from 1% to 35% higher in the best cases. The recall of CPO(10s) is really low compared to the supervised learning models, especially for small lot sizes. Nevertheless, the optimizer has the advantage of never wrongly classifying a plan as feasible since it provides feasible schedules as a guarantee to the user. CPO(180s) significantly outperforms CPO(10s), and it provides better accuracy than machine learning models on the largest instances. However, the machine learning methods have more accurate predictions on 10 × 10 instances, and they provide these predictions in less than a second.

Regarding SPT, LPT, and FIFO for the makespan approximation, the results show that the recall is too low when compared to the other approaches. This reflects the few numbers of samples that each of these methods can predict as "Feasible". The makespan
<table><caption>**Table 3.** Prediction performance machine learning and other approximations of capacity consumption for lot-sizes with support [5,20]</caption><thead><tr><th rowspan="2">Size</th><th rowspan="2">Method</th><th colspan="2">Accuracy(%)</th><th colspan="2">Precision(%)</th><th colspan="2">Recall(%)</th><th colspan="2">MAE</th></tr><tr><th>CV</th><th>Test</th><th>CV</th><th>Test</th><th>CV</th><th>Test</th><th>CV</th><th>Test</th></tr></thead><tbody><tr><td rowspan="8">6 × 6</td><td>CLR</td><td>91.0</td><td>90.4</td><td>100.0</td><td>100.0</td><td>81.6</td><td>80.9</td><td>24.0</td><td>25.2</td></tr><tr><td>Linear Regression</td><td>95.7</td><td>95.7</td><td>95.7</td><td>95.7</td><td>95.4</td><td>95.7</td><td>11.9</td><td>9.8</td></tr><tr><td>Random Forest</td><td>96.0</td><td>95.7</td><td>96.4</td><td>96.0</td><td>95.4</td><td>95.4</td><td>9.4</td><td>9.4</td></tr><tr><td>Neural Networks</td><td>96.3</td><td>96.2</td><td>96.7</td><td>95.4</td><td>95.6</td><td>97.0</td><td>8.0</td><td>8.0</td></tr><tr><td>LPT</td><td>52.1</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>1100.1</td><td>1084.9</td></tr><tr><td>SPT</td><td>52.1</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>824.0</td><td>811.4</td></tr><tr><td>FIFO</td><td>55.2</td><td>54.4</td><td>100.0</td><td>1.0</td><td>7.8</td><td>8.9</td><td>185.1</td><td>185.2</td></tr><tr><td>CPO(10s)</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td></tr><tr><td>CPO(180s)</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td rowspan="8">10 × 10</td><td>CLR</td><td>94.3</td><td>93.7</td><td>99.9</td><td>100.0</td><td>88.8</td><td>87.3</td><td>177.0</td><td>183.0</td></tr><tr><td>Linear Regression</td><td>97.5</td><td>96.6</td><td>97.5</td><td>96.8</td><td>97.5</td><td>96.3</td><td>76.9</td><td>75.9</td></tr><tr><td>Random Forest</td><td>96.1</td><td>95.5</td><td>95.9</td><td>95.4</td><td>96.4</td><td>95.5</td><td>122.4</td><td>119.0</td></tr><tr><td>Neural Networks</td><td>97.3</td><td>96.3</td><td>97.2</td><td>97.1</td><td>97.4</td><td>95.3</td><td>82.4</td><td>78.9</td></tr><tr><td>LPT</td><td>49.4</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>33593.1</td><td>33543.3</td></tr><tr><td>SPT</td><td>49.4</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>27181.1</td><td>27178.7</td></tr><tr><td>FIFO</td><td>49.4</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>8226.2</td><td>8213.1</td></tr><tr><td>CPO(10s)</td><td>85.4</td><td>84.1</td><td>100.0</td><td>100.0</td><td>70.9</td><td>68.1</td><td>503.0</td><td>500.9</td></tr><tr><td>CPO(180s)</td><td>99.7</td><td>99.8</td><td>100.0</td><td>100.0</td><td>99.4</td><td>99.5</td><td>9.5</td><td>9.1</td></tr><tr><td rowspan="8">20 × 5</td><td>CLR</td><td>75.0</td><td>74.5</td><td>98.8</td><td>99.2</td><td>51.6</td><td>49.5</td><td>785.8</td><td>822.1</td></tr><tr><td>Linear Regression</td><td>90.5</td><td>91.1</td><td>90.9</td><td>91.9</td><td>90.4</td><td>90.2</td><td>288.0</td><td>284.2</td></tr><tr><td>Random Forest</td><td>90.5</td><td>90.5</td><td>90.7</td><td>90.7</td><td>90.7</td><td>90.2</td><td>295.3</td><td>295.4</td></tr><tr><td>Neural Networks</td><td>89.9</td><td>90.8</td><td>89.6</td><td>91.5</td><td>90.8</td><td>89.8</td><td>303.0</td><td>295.9</td></tr><tr><td>LPT</td><td>48.2</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>25716.2</td><td>25709.2</td></tr><tr><td>SPT</td><td>48.2</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>25830.0</td><td>25944.8</td></tr><tr><td>FIFO</td><td>48.2</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>11859.4</td><td>11854.7</td></tr><tr><td>CPO(10s)</td><td>68.0</td><td>69.3</td><td>100.0</td><td>100.0</td><td>37.2</td><td>38.6</td><td>1195.5</td><td>1196.1</td></tr><tr><td>CPO(180s)</td><td>90.0</td><td>90.0</td><td>100.0</td><td>100.0</td><td>80.3</td><td>80.0</td><td>325.8</td><td>327.0</td></tr></tbody></table>

estimated using these methods is large when compared to a machine learning approach. As a result, these methods are too conservative, and they would reject the large majority of orders when applied to a real case scenario. In fact, such dispatching rules are more relevant when applied to dedicated approaches (Jun, Lee, and Chun 2019) or simulation (Lu, Huang, and Yang 2011).

For the comparison between each of our machine learning models, the best performance differ from one model to another, but the results stay consistent for each method. The similarity between the cross-validation and the out-of-sample results also confirms the consistency of the results regardless of the dataset used for the training.

The Linear Regression approach obtained the best results for most of the dataset, but it is not relevant when compared to the neural networks and Random Forest model. Constraint Linear Regression has a lower accuracy than the other machine learning models, but this method is more precise and can maintain a precision greater than 95% with a relatively high percentage of recall compared to CPO(10s). Although this approach cannot guarantee the feasibility of the plan, it remains more robust than any other machine learning proposed in this study and can be favored to maintain a higher percentage of feasibility.

Unlike the dispatching rules and CP Optimizer, the machine learning models do not return the schedule associated with the prediction. Although such schedules provide valuable information for the planner when scheduling the lots, in this work, we focus on the fast evaluation of the feasibility of production schedules in a real-time negotia-
<table><caption>**Table 4.** Prediction performance machine learning and other approximations of capacity consumption for lot-sizes with support [10,40]</caption><thead><tr><th rowspan="2">Size</th><th rowspan="2">Method</th><th colspan="2">Accuracy(%)</th><th colspan="2">Precision(%)</th><th colspan="2">Recall(%)</th><th colspan="2">MAE</th></tr><tr><th>CV</th><th>Test</th><th>CV</th><th>Test</th><th>CV</th><th>Test</th><th>CV</th><th>Test</th></tr></thead><tbody><tr><td rowspan="7">6 × 6</td><td>CLR</td><td>92.2</td><td>92.0</td><td>99.9</td><td>99.9</td><td>84.4</td><td>84.0</td><td>45.2</td><td>45.9</td></tr><tr><td>Linear Regression</td><td>96.4</td><td>97.0</td><td>96.2</td><td>97.5</td><td>96.7</td><td>96.5</td><td>18.0</td><td>18.5</td></tr><tr><td>Random Forest</td><td>96.4</td><td>97.3</td><td>96.1</td><td>97.3</td><td>96.7</td><td>97.3</td><td>18.8</td><td>18.2</td></tr><tr><td>Neural Networks</td><td>97.0</td><td>97.3</td><td>96.9</td><td>96.8</td><td>97.2</td><td>97.8</td><td>15.1</td><td>14.4</td></tr><tr><td>LPT</td><td>49.1</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>2033.1</td><td>2048.3</td></tr><tr><td>SPT</td><td>49.1</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>1492.2</td><td>1499.9</td></tr><tr><td>FIFO</td><td>66.1</td><td>66.4</td><td>100.0</td><td>1.0</td><td>32.8</td><td>32.7</td><td>215.3</td><td>218.4</td></tr><tr><td>CPO(10s)</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td></tr><tr><td>CPO(180s)</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td rowspan="7">10 × 10</td><td>CLR</td><td>93.8</td><td>93.9</td><td>99.9</td><td>100.0</td><td>87.6</td><td>87.7</td><td>385.8</td><td>400.9</td></tr><tr><td>Linear Regression</td><td>97.0</td><td>97.6</td><td>97.0</td><td>97.9</td><td>96.9</td><td>97.2</td><td>163.8</td><td>157.0</td></tr><tr><td>Random Forest</td><td>95.2</td><td>95.9</td><td>95.1</td><td>96.0</td><td>95.3</td><td>95.7</td><td>281.9</td><td>264.0</td></tr><tr><td>Neural Networks</td><td>96.9</td><td>97.7</td><td>97.1</td><td>98.1</td><td>96.7</td><td>97.3</td><td>172.4</td><td>159.4</td></tr><tr><td>LPT</td><td>50.6</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>62953.5</td><td>62973.4</td></tr><tr><td>SPT</td><td>50.6</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>53830.1</td><td>53949.8</td></tr><tr><td>FIFO</td><td>50.6</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.1</td><td>0.0</td><td>11547.2</td><td>11491.0</td></tr><tr><td>CPO(10s)</td><td>95.4</td><td>95.5</td><td>100.0</td><td>100.0</td><td>90.6</td><td>91.0</td><td>301.8</td><td>299.1</td></tr><tr><td>CPO(180s)</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.2</td></tr><tr><td rowspan="7">20 × 5</td><td>CLR</td><td>80.6</td><td>80.4</td><td>99.2</td><td>99.5</td><td>60.6</td><td>61.0</td><td>1199.1</td><td>1262.4</td></tr><tr><td>Linear Regression</td><td>93.0</td><td>93.0</td><td>92.8</td><td>93.4</td><td>92.7</td><td>92.4</td><td>431.8</td><td>419.5</td></tr><tr><td>Random Forest</td><td>92.3</td><td>92.7</td><td>92.1</td><td>92.8</td><td>92.1</td><td>92.6</td><td>447.9</td><td>442.3</td></tr><tr><td>Neural Networks</td><td>92.4</td><td>93.3</td><td>91.3</td><td>93.0</td><td>93.3</td><td>93.7</td><td>464.2</td><td>440.2</td></tr><tr><td>LPT</td><td>52.8</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>45319.9</td><td>45283.7</td></tr><tr><td>SPT</td><td>52.8</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>47816.9</td><td>47903.2</td></tr><tr><td>FIFO</td><td>52.8</td><td>50.0</td><td>100.0</td><td>100.0</td><td>0.0</td><td>0.0</td><td>17733.7</td><td>17707.9</td></tr><tr><td>CPO(10s)</td><td>74.7</td><td>74.6</td><td>100.0</td><td>100.0</td><td>47.9</td><td>49.2</td><td>1789.3</td><td>1770.1</td></tr><tr><td>CPO(180s)</td><td>91.4</td><td>91.1</td><td>100.0</td><td>100.0</td><td>82.3</td><td>82.2</td><td>521.4</td><td>516.8</td></tr></tbody></table>

tion context. We assume that when all negotiations are done, the planner will solve the scheduling problem with a large computation time to build the schedule. Figure 4 shows the Gantt chart of the optimal solution obtained with CP Optimizer for one instance from the testing dataset with scheduling size 10 × 10 and batch size in [5, 20]. The operations of each job are represented by color and name, and the setup times are depicted as black boxes between the operations. This Figure also shows the makespan predicted by CPO(10s), CPO(180s), CLR, and neural networks. The optimal schedule is labeled as Feasible in our study since it achieves a makespan of 15,929 for an available capacity of 16,259. In this example, CPO(10s) returned a makespan larger than the capacity limit, and we classify this instance as infeasible. By only relying on this outcome, a manual planner would choose to modify the quantities by delaying existing orders or declining the incoming one. Despite underestimating the makespan, the neural networks model proposed a prediction that closely approximates the optimal makespan, offering a more precise estimation compared to CPO(10s). Furthermore, CLR proposes a more robust prediction that both overestimate the makespan and classify this instance as Feasible. In this case, the planner can expect to obtain a makespan lying between the predictions proposed by neural networks and CLR.
<figure><img src="image_5.png" /><figcaption>**Figure 4.** Caption: Gant chart and prediction results for the optimal schedule of one instance of size 10 × 10 with lot-sizes with support [5, 20]</figcaption></figure>

<caption>**Figure 4.** Alt Text: Gant chart of the optimal schedule for one instance of size 10 × 10 with lot-sizes with support [5, 20] and the prediction results of different methods proposed in the study</caption>

### 5.3. Heuristic performance comparison

In this subsection, we provide a brief comparison of the performance between machine learning, constraint programming, and heuristical approaches. To compare our approach with results from the literature, we limited our comparison to the results for flexible job shop scheduling problems without setup times and with lot sizes equal to one for each product, as the default scheduling problems. Hence, to increase the number of scheduling problems to be tested, we add the benchmark instances mk1-mk10 from Brandimarte (1993). We then compared the makespan prediction proposed by our machine learning approach with the results of CP Optimizer for 10 seconds and 5 hours, and also the makespan found by the Tabu search (TS) proposed by Hurink, Jurisch, and Thole (1994) and the parallel variable neighborhood search (PVNS) of Yazdani, Amiri, and Zandieh (2010). For each scheduling size, we trained the machine learning models on 10000 instances with lot sizes within [1, 5], since these lot sizes are close to the instance
<table><caption>**Table 5.** Prediction performance between machine learning models and heuristic results from Hurink, Jurisch, and Thole (1994) and Yazdani, Amiri, and Zandieh (2010)</caption><thead><tr><th>Method</th><th>CLR</th><th>Linear Regression</th><th>Random Forest</th><th>Neural Networks</th><th>TS</th><th>PVNS</th><th>CPO(10s)</th><th>CPO(5h)</th></tr></thead><tbody><tr><td>mt06</td><td>58</td><td>56</td><td>57</td><td>57</td><td>57</td><td>-</td><td>55*</td><td>55*</td></tr><tr><td>mt10</td><td>892</td><td>874</td><td>883</td><td>905</td><td>899</td><td>-</td><td>871*</td><td>871*</td></tr><tr><td>mt20</td><td>1118</td><td>1094</td><td>1098</td><td>1093</td><td>1109</td><td>-</td><td>1088*</td><td>1088*</td></tr><tr><td>mk01</td><td>44</td><td>42</td><td>41</td><td>41</td><td>-</td><td>40</td><td>40*</td><td>40*</td></tr><tr><td>mk02</td><td>29</td><td>28</td><td>28</td><td>28</td><td>-</td><td>26</td><td>26</td><td>26*</td></tr><tr><td>mk03</td><td>208</td><td>207</td><td>207</td><td>206</td><td>-</td><td>204</td><td>204*</td><td>204*</td></tr><tr><td>mk04</td><td>66</td><td>63</td><td>63</td><td>63</td><td>-</td><td>60</td><td>60*</td><td>60*</td></tr><tr><td>mk05</td><td>179</td><td>177</td><td>178</td><td>177</td><td>-</td><td>173</td><td>173</td><td>172</td></tr><tr><td>mk06</td><td>64</td><td>62</td><td>59</td><td>62</td><td>-</td><td>60</td><td>59</td><td>57*</td></tr><tr><td>mk07</td><td>151</td><td>144</td><td>143</td><td>143</td><td>-</td><td>141</td><td>141</td><td>139</td></tr><tr><td>mk08</td><td>541</td><td>532</td><td>529</td><td>531</td><td>-</td><td>523</td><td>523*</td><td>523*</td></tr><tr><td>mk09</td><td>316</td><td>311</td><td>312</td><td>311</td><td>-</td><td>307</td><td>307*</td><td>307*</td></tr><tr><td>mk10</td><td>210</td><td>204</td><td>206</td><td>203</td><td>-</td><td>208</td><td>207</td><td>195</td></tr></tbody></table>

with a single lot for each product. The results of these experiments are shown in Table 5. An asterisk indicates the optimal solution reported by CP Optimizer. In this Table, the results of CP Optimizer outperform those found by the two heuristics and are able to find optimal solutions for half of the instances within ten seconds. Although the presence of setup times increases the complexity of the instances for CP Optimizer, we can notice that the latter proposed competitive results and can be easily adapted to take lot sizes and setup times into account, which is not the case for metaheuristics. For the machine learning models, although the prediction is close to the real makespan, we can notice a slight deviation between the predicted makespan and the real one in some instances. This deviation is mainly due to the range of lot sizes in the training dataset, which affects the process duration of the task and thus limits the prediction of the models. Also, since most of the solutions obtained by CP Optimizer after 10 seconds are near-optimal, the latter performs very well compared to the machine learning models. However, if we focus on the hardest instance mk10, the machine learning models outperform both CPO(10s) and the metaheuristic. In this case, the gap between the solutions of CP Optimizer after 10 seconds and 5 hours is high, allowing the machine learning model to be trained on relevant data and thus improve their performance compared to the constraint programming approach.

## 6. Conclusion

This paper investigates machine learning models to estimate the makespan of a flexible job-shop scheduling instance. The objective of the resulting models is to accurately predict the capacity consumption in each period of the production plan. We introduce four machine learning models with relevant features for the training of each of our models. Namely, two versions of the linear regression, a random forest, and an artificial neural networks model. In particular, we propose a specific machine learning model for capacity consumption estimation in production planning, where underestimation of the consumption has a much more negative impact than overestimation. Therefore, we propose a Constrained Linear Regression model, which ensures a certain level of precision and avoids misclassification. We compare the machine learning output with the result of classical dispatching rules from the literature and with the result of a constraint programming solver. Although the constraint programming approach proposed good results for the small-size instances, the numerical experiments show that the machine learning models outperform both of these approaches, and they have better accuracy than
any other approach for the largest instance sizes. Our results show that the proposed
models are accurate, and they are useful in a negotiation context since they provide an
estimation in less than a second.

We identify several perspectives for future work. First, the constrained machine learn-
ing approach can be extended to other methods such as Neural Networks or Random
Forests. Second, the machine learning model proposed in this paper may be integrated
into algorithms that automatically build production plans. This second perspective re-
quires selecting some linear features from the set defined in this study before translating
the learned model into mathematical model constraints. The resulting model would pro-
vide a production plan that precisely accounts for the capacity on the shop floor, whereas
state-of-the-art approaches use a rough approximation of the capacity consumption.

Acknowledgements

The present work was conducted within the project ASSISTANT (https://assistant-
project.eu/) funded by the European Commission, under grant agreement number
101000165, H2020 - ICT-38-2020, Artificial intelligence for manufacturing. The authors
would also like to thank the region Pays de la Loire for their financial support.

Data Availability Statement

The data that support the findings of this study are openly available at http://doi.
org/10.5281/zenodo.8081180.

References

Arredondo, Facundo, and Ernesto Martinez. 2010. “Learning and adaptation of a policy for dynamic order acceptance in make-to-order manufacturing.” *Computers and Industrial Engineering* 58 (1): 70–83.

Bertolini, Massimo, Davide Mezzogori, Mattia Neroni, and Francesco Zammori. 2021. “Machine Learning for industrial applications: A comprehensive literature review.” *Expert Systems with Applications* 175: 114820.

Błażewicz, Jacek, Wolfgang Domschke, and Erwin Pesch. 1996. “The job shop scheduling problem: Conventional and new solution techniques.” *European Journal of Operational Research* 93 (1): 1–33.

Brandimarte, P. 1993. "Routing and scheduling in a flexible job shop by tabu search." *Ann Oper Res* 41: 157-183.

Breiman, Leo. 2001. “Random Forests.” *Machine Learning* 45 (1): 5–32.

Calosso, T., M. Cantamessa, Dang Vu, and A. Villa. 2003. “Production planning and order acceptance in business to business electronic commerce.” *International Journal of Production Economics* 85 (2): 233–249.

Casazza, Marco, and Alberto Ceselli. 2019. *Heuristic Data-Driven Feasibility on Integrated Planning and Scheduling*, 115–125. Cham: Springer International Publishing.

Castañé, G, A Dolgui, N Kousi, B Meyers, Simon Thevenin, E Vyhmeister, and Per-Olov Östberg. 2022. “The ASSISTANT project: AI for high level decisions in manufacturing.” *International Journal of Production Research* 1–19.

Chen, Ronghua, Bo Yang, Shi Li, and Shilong Wang. 2020. “A self-learning genetic algorithm based on reinforcement learning for flexible job-shop scheduling problem.” *Computers and Industrial Engineering* 149: 106778.
Chen, Wenchong, Xuejian Gong, Humyun Fuad Rahman, Hongwei Liu, and Ershi Qi. 2021. "Real-time order acceptance and scheduling for data-enabled permutation flow shops: Bilevel interactive optimization with nonlinear integer programming." *Omega* 105: 102499.

Dias, Lisia S., and Marianthi G. Ierapetritou. 2019. "Data-driven feasibility analysis for the integration of planning and scheduling problems." *Optimization and Engineering* 20 (4): 1029–1066.

Fisher, H., and G.L. Thompson. 1963. "Probabilistic Learning Combinations of Local Job-Shop Scheduling Rules." *Industrial Scheduling, Muth and G. L. Thompson (Eds.)* 45: 225–251.

Garey, M. R., D. S. Johnson, and Ravi Sethi. 1976. "The Complexity of Flowshop and Jobshop Scheduling." *Mathematics of Operations Research* 1 (2): 117–129.

Gharehgozli, A. H., M. Rabbani, N. Zaerpour, and J. Razmi. 2007. "A comprehensive decision-making structure for acceptance/rejection of incoming orders in make-to-order environments." *The International Journal of Advanced Manufacturing Technology* 39 (9-10): 1016–1032.

Ham, Andy M., and Eray Cakici. 2016. "Flexible job shop scheduling problem with parallel batch processing machines: MIP and CP approaches." *Computers and Industrial Engineering* 102: 160–165.

Ho, Nhu Binh, Joc Cing Tay, and Edmund M.-K. Lai. 2007. "An effective architecture for learning and evolving flexible job-shop schedules." *European Journal of Operational Research* 179 (2): 316–333.

Hurink, J, B Jurisch, and M Thole. 1994. "Tabu search for the job-shop scheduling problem with multi-purpose machines." *OR Spektrum* 15: 205–215.

IBM. 2021. "IBM ILOG CPLEX Optimization Studio 20.1.0: Online documentation." https://www.ibm.com/docs/en/icos/20.1.0.

Jain, A.S., and S. Meeran. 1999. "Deterministic job-shop scheduling: Past, present and future." *European Journal of Operational Research* 113 (2): 390–434.

Jong, Arent W. De, Jose I. U. Rubrico, Masaru Adachi, Takayuki Nakamura, and Jun Ota. 2019. "A generalised makespan estimation for shop scheduling problems, using visual data and a convolutional neural network." *International Journal of Computer Integrated Manufacturing* 32 (6): 559–568.

Jun, Sungbum, Seokcheon Lee, and Hyonho Chun. 2019. "Learning dispatching rules using random forest in flexible job shop scheduling problems." *International Journal of Production Research* 57 (10): 3290–3310.

Kim, Boeun, and Christos T. Maravelias. 2022. "Data-based Approach to Predict Feasibility and Computational Requirement for Chemical Production Scheduling." *IFAC-PapersOnLine* 55 (7): 827–832.

Lee, C.-Y., S. Piramuthu, and Y.-K. Tsai. 1997. "Job shop scheduling with a genetic algorithm and machine learning." *International Journal of Production Research* 35 (4): 1171–1191.

Li, Xiaonan, and Sigurdur Olafsson. 2005. "Discovering Dispatching Rules Using Data Mining." *Journal of Scheduling* 8 (6): 515–527.

Li, Xueping, Jiao Wang, and Rapinder Sawhney. 2012. "Reinforcement learning for joint pricing, lead-time and scheduling decisions in make-to-order systems." *European Journal of Operational Research* 221 (1): 99–109.

Li, Yuanyuan, Stefano Carabelli, Edoardo Fadda, Daniele Manerba, Roberto Tadei, and Olivier Terzo. 2020. "Machine learning and optimization for production rescheduling in Industry 4.0." *The International Journal of Advanced Manufacturing Technology* 110 (9-10): 2445–2463.

Liu, Ling, and M Tamer Özsu. 2009. *Encyclopedia of database systems*. Vol. 6. Springer.

Liu, Renke, Rajesh Piplani, and Carlos Toro. 2022. "Deep reinforcement learning for dynamic scheduling of a flexible job shop." *International Journal of Production Research* 60 (13): 4049–4069.

Lu, H.L., George Q. Huang, and H.D. Yang. 2011. "Integrating order review/release and dispatching rules for assembly job shop scheduling using a simulation approach." *International Journal of Production Research* 49 (3): 647–669.
Luo, Shu. 2020. "Dynamic scheduling for flexible job shop with new job insertions by deep reinforcement learning." *Applied Soft Computing* 91: 106208.

Mirshekarian, Sadegh, and Dušan N. Šormaz. 2016. "Correlation of job-shop scheduling problem features with scheduling efficiency." *Expert Systems with Applications* 62: 131–147.

Müller, David, Marcus G. Müller, Dominik Kress, and Erwin Pesch. 2022. "An algorithm selection approach for the flexible job shop scheduling problem: Choosing constraint programming solvers through machine learning." *European Journal of Operational Research* 302 (3): 874–891.

Nakasuka, Shinichi, and Taketoshi Yoshida. 1992. "Dynamic scheduling system utilizing machine learning as a knowledge acquisition tool." *International Journal of Production Research* 30 (2): 411–431.

Nguyen, Su. 2016. "A learning and optimizing system for order acceptance and scheduling." *The International Journal of Advanced Manufacturing Technology* 86 (5-8): 2021–2036.

Patil, Rahul J. 2008. "Using ensemble and metaheuristics learning principles with artificial neural networks to improve due date prediction performance." *International Journal of Production Research* 46 (21): 6009–6027.

Pedregosa, F., G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, et al. 2011. "Scikit-learn: Machine Learning in Python." *Journal of Machine Learning Research* 12: 2825–2830.

Raaymakers, W.H.M, and A.J.M.M Weijters. 2003. "Makespan estimation in batch process industries: A comparison between regression analysis and neural networks." *European Journal of Operational Research* 145 (1): 14–30.

Rahman, Humyun Fuad, Ruhul Sarker, and Daryl Essam. 2015. "A real-time order acceptance and scheduling approach for permutation flow shop problems." *European Journal of Operational Research* 247 (2): 488–503.

Schneckenreither, Manuel, Stefan Haeussler, and Christoph Gerhold. 2020. "Order release planning with predictive lead times: a machine learning approach." *International Journal of Production Research* 59 (11): 3285–3303.

Shen, Liji, Stéphane Dauzère-Pérès, and Janis S. Neufeld. 2018. "Solving the flexible job shop scheduling problem with sequence-dependent setup times." *European Journal of Operational Research* 265 (2): 503–516.

Slotnick, Susan A. 2011. "Order acceptance and scheduling: A taxonomy and review." *European Journal of Operational Research* 212 (1): 1–11.

Thevenin, Simon, Nicolas Zufferey, and Rémy Glardon. 2017. "Model and metaheuristics for a scheduling problem integrating procurement, sale and distribution decisions." *Annals of Operations Research* 259 (1): 437–460.

Thevenin, Simon, Nicolas Zufferey, and Marino Widmer. 2016. "Order acceptance and scheduling with earliness and tardiness penalties." *Journal of Heuristics* 22 (6): 849–890.

Tibshirani, Robert. 1996. "Regression Shrinkage and Selection Via the Lasso." *Journal of the Royal Statistical Society: Series B (Methodological)* 58 (1): 267–288.

Tremblet, David, Simon Thevenin, and Alexandre Dolgui. 2022. "Predicting makespan in Flexible Job Shop Scheduling Problem using Machine Learning." *IFAC-PapersOnLine* 55 (10): 1–6.

Wang, Xiuli, Sujie Geng, and T.C.E. Cheng. 2018. "Negotiation mechanisms for an order subcontracting and scheduling problem." *Omega* 77: 154–167.

Xu, Lei, Qian Wang, and Simin Huang. 2015. "Dynamic order acceptance and scheduling problem with sequence-dependent setup time." *International Journal of Production Research* 53 (19): 5797–5808.

Yazdani, M., M. Amiri, and M. Zandieh. 2010. "Flexible job-shop scheduling with parallel variable neighborhood search algorithm." *Expert Systems with Applications* 37 (1): 678–687.

Yunusoglu, Pinar, and Seyda Topaloglu Yildiz. 2021. "Constraint programming approach for multi-resource-constrained unrelated parallel machine scheduling problem with sequence-dependent setup times." *International Journal of Production Research* 60 (7): 2212–2229.