Enhancing Makespan Minimization in Unrelated Parallel Batch Processing with an Improved Artificial Bee Colony Algorithm ^†

Abstract

To solve the unrelated parallel batch processing machine scheduling problem (UPBPMSP) with dynamic job arrivals, heterogeneous processing times, and machine heterogeneity, this paper presents an improved artificial bee colony (IABC) algorithm aimed at minimizing the makespan. Three improvements include the following: (1) a hybrid encoding scheme that combines machine allocation coefficients and priority weights, allowing for flexible consideration of machine capabilities and dynamic job priorities; (2) a dual-mode variable neighborhood search strategy to optimize machine allocation and job sequencing simultaneously; (3) a dynamic weight tournament selection mechanism to enhance population diversity and avoid premature convergence. Experimental results show that IABC reduces the makespan by 5% to 25% compared to traditional ABC and genetic algorithms (GAs), with the most significant advantages observed in concentrated job arrival scenarios. Statistical tests confirm that the improvements are statistically significant, validating the effectiveness of the proposed algorithm.

1. Introduction

The traditional static scheduling method is difficult to directly apply to the unrelated parallel batch processing machine scheduling problem (UPBPMSP), which involves heterogeneous job sizes, processing times, and dynamic job arrival times. Most existing studies assume static job arrivals, and no efficient algorithm has been developed for static scheduling problems with known dynamic arrival times. Compared to traditional scheduling problems, batch processing machine scheduling not only requires job sequencing but also involves optimizing batch sizes and load balancing among machines, which increases its complexity. Solving the UPBPMSP becomes even more challenging when addressing issues such as multi-objective optimization, energy efficiency optimization, and dynamic constraints. The artificial bee colony (ABC) algorithm was introduced by Karaboga and Basturk in 2007, drawing inspiration from the foraging behavior of honey bees [1]. It efficiently achieves global optimization and has since become a widely used method for solving scheduling problems. As a result, many researchers have proposed improved versions of the ABC algorithm, incorporating multi-objective optimization, energy-efficient scheduling, and adaptive mechanisms to enhance its performance.

Zhu et al. proposed an enhanced ABC algorithm for the unrelated parallel machine scheduling problem, optimizing both makespan and total energy consumption simultaneously [2]. Wang et al. introduced a Q-learning-driven ABC algorithm, providing more adaptive scheduling strategies to address dynamic changes and multi-constraints in manufacturing environments [3]. Additionally, Wang et al. combined ABC with fuzzy theory, presenting an energy-efficient optimization approach for solving uncertainty and parallel machine scheduling problems [4]. Jin et al. addressed the machine degradation effects in remanufacturing system scheduling, optimizing resource allocation using ABC [5]. Liao et al. combined multi-objective ABC with adaptive large neighborhood search, proposing an optimized method for flexible job-shop scheduling that significantly improves scheduling efficiency and quality [6]. Zhu et al. tackled the unequal sub-batch scheduling problem, solving multiple production constraints such as job delays and machine capacity limitations, demonstrating its advantages in complex scheduling scenarios [7]. Touafek et al. proposed a hybrid optimization method combining reinforcement learning and ABC to solve job degradation and flexible maintenance scheduling problems, dynamically adjusting scheduling strategies to enhance ABC’s adaptability [8].

These studies demonstrate that improvements to the ABC algorithm allow it to more effectively address complex production scheduling problems, particularly in energy optimization and multi-objective scheduling, highlighting its potential. However, existing research has yet to fully explore the adaptability of the ABC algorithm in other scheduling problems, especially in the UPBPMSP with dynamic job arrivals, which still presents significant research opportunities. Therefore, this study introduces an enhanced version of the Artificial Bee Colony algorithm aimed at reducing makespan. It achieves this by integrating a hybrid encoding scheme, a dual-mode variable neighborhood search strategy, and a dynamic weight tournament selection mechanism.

2. Description of the Problem

The unrelated parallel batch processing machine scheduling problem addressed in this paper can be described as follows: Given n jobs with dynamic arrival times and varying sizes, these jobs need to be allocated to m unrelated parallel batch processing machines for processing. Each machine k can process multiple jobs simultaneously, provided that the total job size does not exceed the machine’s capacity, and the processing time is machine-dependent.

The objective is to minimize the makespan (${\mathrm{C}}_{\mathrm{m}\mathrm{a}\mathrm{x}}$). The following decisions need to be made: (1) Assign each job to one machine; (2) Determine the processing sequence of jobs on each machine; (3) Group jobs assigned to the same machine into batches, ensuring the total size of each batch does not exceed the machine’s capacity.

3. IABC Algorithm

The IABC algorithm flow proposed in this paper is as follows.

Step 1: Parameter initialization, set the population size, maximum iterations, stagnation threshold, and scheduling data (including job size, processing time, arrival time, machine capacity, etc.). Initialize the population and generate the initial solution using a two-phase heuristic method.

Step 2: The IABC algorithm is composed of three main phases. During the employed bee phase, a dual-mode variable neighborhood search technique is used to explore the solution space, utilizing two distinct perturbation modes to prevent the algorithm from becoming trapped in local optima. A greedy selection mechanism is then applied to retain only the improved solutions. The onlooker bee phase utilizes a dynamic tournament selection mechanism, ensuring high-quality solutions are selected, followed by two-point crossover and non-uniform mutation operations to enhance diversity and exploration. In the scout bee phase, if no improvements are found after several iterations, and the number of unimproved solutions exceeds a predefined threshold, a random re-initialization is performed.

Step 3: The loop is terminated and results are output once the termination condition is met.

A flowchart of the IABC algorithm is shown in Figure 1.

3.1. Encoding

A two-dimensional continuous hybrid encoding method is used. The chromosome has a dimension of 2 × J (where J is the number of jobs). The first J dimensions represent the machine allocation strategy, which is determined by the machine allocation coefficient (MAC). The subsequent J dimensions represent the job processing sequence strategy, which is determined by the dynamic priority weight (PW).

The machine allocation coefficient is represented by a continuous value within the range of [0,M), where M is the number of machines. The mapping rule is as follows: ${\mathrm{k}}_{\mathrm{j}}=\mathrm{f}\mathrm{l}\mathrm{o}\mathrm{o}\mathrm{r}\left({\mathrm{M}\mathrm{A}\mathrm{C}}_{\mathrm{j}}\right)+1$, where ${\mathrm{k}}_{\mathrm{j}}$ is the assigned machine number for job j, and the floor function ensures that the machine number falls within the valid range [1,M]. The PW is also represented by a continuous value, where a higher weight indicates a higher priority for the job in the batch sorting process.

3.2. Initial Solution Generation

The initial solutions are generated using a two-phase heuristic method. In the first phase, the machine with the shortest processing time is preferentially selected, along with the rule of applying continuous perturbations. The MAC for job j is calculated by reducing the selected machine number by 1 and then adding a random value between 0 and 0.99. If multiple machines have the same shortest processing time, one machine is randomly selected. In the second phase, the arrival time of the job is normalized using the formula ${\mathrm{r}}_{\mathrm{j}}$/max(${\mathrm{r}}_{\mathrm{j}}$), where ${\mathrm{r}}_{\mathrm{j}}$ represents the arrival time. Gaussian noise N(0,0.3) is then added, yielding the PW for job j as follows: ${\mathrm{P}\mathrm{W}}_{\mathrm{j}}={\mathrm{r}}_{\mathrm{j}}/\mathrm{m}\mathrm{a}\mathrm{x}\left({\mathrm{r}}_{\mathrm{j}}\right)+\mathrm{N}\left(\mathrm{0,0.3}\right)$. This value represents the initial priority of the job.

3.3. Employed Bee Phase

In this phase, the solution is updated using the dual-mode variable neighborhood search strategy. The process is as follows:

(1) With a probability of 70%, the machine assignment search field is selected. The jobs are arranged in descending order according to their PW. The top three jobs with the highest PW values are selected, and Gaussian perturbation N(0,0.3) is applied to the MAC of these three jobs. The update rule is: ${\mathrm{M}\mathrm{A}\mathrm{C}}_{\mathrm{n}\mathrm{e}\mathrm{w}}={\mathrm{M}\mathrm{A}\mathrm{C}}_{\mathrm{o}\mathrm{l}\mathrm{d}}+\mathrm{N}\left(\mathrm{0,0.3}\right)$. (2) With a probability of 30%, the priority weight search field is selected. Jobs whose arrival time is later than the median arrival time are chosen. Gaussian perturbation N(0,0.5) is then applied to the PW of these jobs. The update rule is: ${\mathrm{P}\mathrm{W}}_{\mathrm{n}\mathrm{e}\mathrm{w}}={\mathrm{P}\mathrm{W}}_{\mathrm{o}\mathrm{l}\mathrm{d}}+\mathrm{N}\left(\mathrm{0,0.5}\right)$. (3) The new solution is evaluated by calculating the makespan (${\mathrm{C}}_{\mathrm{m}\mathrm{a}\mathrm{x}}$) and the fitness value (${\mathrm{f}\mathrm{i}\mathrm{t}\mathrm{n}\mathrm{e}\mathrm{s}\mathrm{s}}_{\mathrm{i}}=1/(1+{\mathrm{C}}_{\mathrm{m}\mathrm{a}\mathrm{x}})$). A greedy selection is then performed. If the new solution outperforms the previous one, it is accepted, and the trial counter is set to zero (trial = 0). If not, the original solution remains, and the trial counter is increased by one (trial = trial + 1).

3.4. Onlooker Bee Phase

During the onlooker bee phase, a dynamic weight tournament selection mechanism is employed to refine the solution by combining adaptive crossover and mutation operations. The process is as follows:

Step 1: The selection probability of candidate solutions is dynamically adjusted. Frequently selected solutions have their selection probability reduced. First, the selection count for each solution is recorded (initially set to zero), and the tournament size is defined as 3. Then, the weight ${\mathrm{w}}_{\mathrm{i}}$ for each solution is calculated as: ${\mathrm{w}}_{\mathrm{i}}={\displaystyle \frac{1}{1+{\mathrm{s}\mathrm{e}\mathrm{l}\mathrm{e}\mathrm{c}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}\mathrm{C}\mathrm{o}\mathrm{u}\mathrm{n}\mathrm{t}}_{\mathrm{i}}}}$, where ${\mathrm{s}\mathrm{e}\mathrm{l}\mathrm{e}\mathrm{c}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}\mathrm{C}\mathrm{o}\mathrm{u}\mathrm{n}\mathrm{t}}_{\mathrm{i}}$ represents the selection count of solution i. In each iteration, three candidate solutions are randomly selected based on their weight, and the individual with the highest fitness is chosen as a parent. After each selection, the selection count of the chosen solution is updated. This procedure continues until the specified number of parents is chosen to create the new population.

Step 2: In the two-point crossover operation, the selected parents undergo crossover with an 80% probability. Two different solutions are randomly selected, and two crossover points are randomly chosen to exchange gene segments between the points.

Step 3: In the mutation operation, a job’s machine allocation or priority weight is mutated with a 10% probability. In the machine allocation mutation, a job’s machine allocation dimension is randomly selected and switched to another machine. In the priority weight mutation, Gaussian noise N(0,0.2) is added to a randomly selected priority gene (PW part).

4. Experiment and Findings

4.1. Experimental Setup

To assess the effectiveness of the IABC algorithm in solving the UPBPMSP, all experiments and algorithms were developed using Matlab R2021b. The experiments were performed on a system running Windows 10, equipped with an AMD Ryzen 5 4600H processor, integrated Radeon Graphics, and 16 GB of RAM. All algorithms were executed on the same hardware platform to ensure the comparability and fairness of the results.

In the experiments, each algorithm was run on 30 independent trials to ensure statistical significance. The performance data recorded includes makespan, standard deviation, and average computation time. The results were compared between the IABC algorithm, the traditional ABC algorithm, and the Genetic Algorithm (GA) under various conditions, including different job numbers (n = {20, 50, 100}) and machine configurations (m = {3,4,5}).

For the experimental parameter configuration, the job number was set to three different values: 20, 50, and 100. The machine number was set to three configurations: 3, 4, and 5. The job size distribution followed two uniform distributions: U[1,5] and U[1,10]. The distribution of job processing time and arrival time followed two distinct distributions, respectively. A total of 72 test instances were generated through combinations of these parameters, with 30 independent trials conducted for each instance to ensure the reliability of the results.

In terms of experimental conditions, the machine capacity was set to 10 for each machine, the population size for each algorithm was set to 100, and the number of iterations was set to 100.

Regarding parameter tuning, a preliminary experiment was conducted. The IABC algorithm and other comparison algorithms were carefully tuned. Parameters such as population size and iteration number were determined through preliminary testing to ensure that each algorithm ran with feasible configurations. Additionally, all experiments controlled the random seed to ensure the reproducibility of the results. Each algorithm was run under the same random seed conditions to prevent variations due to randomness. Finally, the main experimental results for some representative instances are shown in

Table 1. Main experimental results.

Job	Machine	$\mathbf{Average} {\mathbf{C}}_{\mathbf{m}\mathbf{a}\mathbf{x}}$			Average Computation Time			Standard Deviation
		IABC	GA	ABC	IABC	GA	ABC	IABC	GA	ABC
n = 20	m = 3	27.73	29.63	33.03	2.01	1.41	4.23	2.89	3.70	2.82
	m = 5	20.30	23.70	25.83	4.04	3.12	9.10	1.47	1.84	1.80
n = 50	m = 3	113.43	139.73	147.60	3.62	2.94	8.83	5.91	7.83	7.69
	m = 5	70.23	94.00	100.17	3.83	3.11	9.48	4.99	5.97	6.05
n = 100	m = 3	363.07	464.87	478.57	10.15	9.18	27.97	18.02	21.92	19.65
	m = 5	204.17	295.90	307.77	10.31	9.29	28.51	10.14	14.19	12.40

.

According to the experimental results in Table 1, the GA has the shortest computation time among all the algorithms, but in terms of the quality of the makespan, the IABC algorithm outperforms GA, while the ABC algorithm performs the worst. Although GA achieves a lower computation time in solving the scheduling problem, its makespan results are less ideal compared to IABC. However, the performance of the ABC algorithm is relatively poor, particularly in terms of makespan, where it generally performs worse than GA, while its computation time is longer than both IABC and GA.

Overall, while GA excels in computation time, while the IABC algorithm offers a better balance in terms of makespan and production scheduling quality. In contrast, the ABC algorithm performs the worst in both computation efficiency and scheduling quality, particularly in large-scale scheduling problems, where IABC shows a clear advantage.

In comparing the performance of the IABC algorithm and the comparison algorithms in terms of makespan, we conducted an independent sample t-test. The t-test results (see

Table 2. Comparison of statistical results of algorithms about ${\mathrm{C}}_{\mathrm{m}\mathrm{a}\mathrm{x}}.$

			${\mathbf{C}}_{\mathbf{m}\mathbf{a}\mathbf{x}}$
Algorithms			IABC vs. GA	IBAC vs. ABC
Small (n = 20)	m = 3	p-value	0.031	0
		t-test	+	+
	m = 5	p-value	0	0
		t-test	+	+
Medium (n = 50)	m = 3	p-value	0	0
		t-test	+	+
	m = 5	p-value	0	0
		t-test	+	+
Large (n = 100)	m = 3	p-value	0	0
		t-test	+	+
	m = 5	p-value	0	0
		t-test	+	+

) indicate that the IABC algorithm performs significantly better than GA in terms of makespan for different problem sizes. Although GA offers shorter computation times, it sacrifices the quality of the scheduling results. Based on these findings, despite GA’s advantage in computation time, the IABC algorithm better balances computation time and scheduling quality, making it a more suitable choice for solving UPBPMSP.

As shown in Table 2, the p-values for various problem sizes are all below 0.05, suggesting that there are statistically significant differences between the IABC algorithm and both the GA and ABC algorithms with respect to the makespan.

4.2. Performance Test of IABC Algorithm in Different Dynamic Arrival Time Scenarios

The scheduling problem also involves dynamic scenarios with varying arrival times. To evaluate the robustness of the IABC algorithm in such dynamic arrival time scenarios, this section designs three typical dynamic distribution patterns (as shown in

Table 3. Different dynamic arrival time scenario definitions.

Scenario Classification	Description
$\mathrm{Uniform} \mathrm{Distribution} \mathrm{U}\left(\mathrm{0,10}\right)$	${\mathrm{r}}_{\mathrm{j}}~\mathrm{U}\left[\mathrm{0,10}\right]$
$\mathrm{Concentrated} \mathrm{Arrival} (0/10)$	50% jobs arrive at t = 0, 50% at t = 10.
$\mathrm{Normal} \mathrm{Distribution} \mathrm{N}\left(\mathrm{5,4}\right)$	${\mathrm{r}}_{\mathrm{j}}~\mathrm{N}\left(\mathrm{5,4}\right)$

) and compares them with the comparison algorithms and the traditional first-come, first-served (FCFS) rule. The makespan (${\mathrm{C}}_{\mathrm{m}\mathrm{a}\mathrm{x}}$) index is used for evaluation, and the applicability and advantages of the IABC algorithm are analyzed.

Based on the scenarios described above, the experiment is conducted with 3 machines and 20 and 50 jobs, respectively. The machine capacity is set to 10, the job processing time follows a uniform distribution U[5,15], and the job size follows a uniform distribution U[1,5]. Each algorithm is run independently 30 times. The results of the experiment are shown in

Table 4. The average makespan of each algorithm under different dynamic arrival time scenarios.

Scenario	J = 20				J = 50
	IABC	ABC	GA	FCFS	IABC	ABC	GA	FCFS
Uniform Distribution U[0,10]	28.00	33.20	30.10	88.00	61.33	76.47	73.33	231.00
Concentrated Arrival (0/10)	26.00	30.60	28.50	67.00	55.83	71.70	67.80	201.00
Normal Distribution N(5,4)	27.87	33.73	31.00	104.00	51.50	66.17	63.23	186.00

.

The experimental results indicate that the IABC algorithm consistently performs better than the other algorithms in all tested scenarios, particularly in those with concentrated job arrivals and normal distribution arrivals. However, while the IABC algorithm generally outperforms other algorithms in most experimental conditions, it should be noted that in certain problem configurations, particularly in small-scale scenarios, the performance gains are less significant. Its performance should be further evaluated in other dynamic environments to fully understand its capabilities.

5. Conclusions

The IABC algorithm proposed in this paper demonstrates notable improvements over the traditional ABC algorithm and GA in terms of makespan. In the experimental tests, the makespan of the IABC algorithm was reduced by an average of 5% to 25%, with the most significant advantages observed in scenarios involving concentrated job arrivals, where the algorithm exhibited superior robustness and optimization capabilities. However, it is important to note that while the IABC algorithm generally outperforms the other algorithms under most experimental conditions, its advantages may not be as pronounced in certain small-scale or specific problem configurations. Additionally, the performance improvement is limited by the scale and complexity of the scheduling problem, and its performance may vary across different hardware platforms. Overall, the IABC algorithm effectively balances computation time and makespan when solving the UPBPMSP, but further optimization is needed to address larger-scale or more complex scheduling problems.