## A list,

Particle swarm optimization (PSO) is a numerical optimization algorithm based on swarm intelligence, which was proposed by social psychologist James Kennedy and electrical engineer Russell Eberhart in 1995. Since the birth of PSO, it has been improved in many aspects. This part will introduce the basic principle and process of particle swarm optimization algorithm.

1.1 Particle swarm optimization

Particle swarm optimization (PSO) is a population intelligence algorithm inspired by bird swarm or fish swarm learning. It is used to solve nonlinear, non-convex or combinatorial optimization problems in many fields of science and engineering.

1.1.1 Algorithm idea

Many birds are gregarious and form different groups for various reasons. Flocks may vary in size, appear in different seasons, and may even consist of different species that work well together in the colony. More eyes and ears mean more opportunities to spot food and predators in time. A flock is always beneficial to the survival of its members in many ways:

Foraging: Sociobiologist E.O.Wilson said that, at least in theory, individual members of a group can benefit from the discoveries and prior experiences of other members in their search for food [1]. If a group of birds has the same food source, then certain species of birds will flock together in a non-competitive way. That way, more birds can take advantage of other birds’ discoveries about food locations.

Defense against Predators: Flocks of birds have many advantages when it comes to protecting themselves from predators.

More ears and eyes mean more chances of spotting predators or any other potential danger;

A flock of birds may confuse or neutralize predators by besieging or agile flight;

In a colony, warning each other can reduce the danger to any one bird.

Aerodynamics: When birds fly in groups, they often arrange themselves into specific shapes or formations. Depending on the number of birds in a flock, each bird produces different air currents as it flaps its wings, which results in varying wind patterns. These formations take advantage of different patterns, allowing birds in flight to use the air around them in the most energy-efficient way.

The development of particle swarm optimization requires some advantages of simulating birds. However, in order to understand an important property of swarm intelligence and particle swarm optimization, it is worth mentioning some disadvantages of birds. There are also some risks for birds when they travel in groups. More ears and eyes mean more wings and mouths, which leads to more noise and movement. In this case, more predators can locate the flock, posing a constant threat to the birds. A larger group will also require more food, which leads to more competition for food, potentially weeding out some of the weaker birds in the group. It should be noted here that PSO does not mimic the disadvantage of bird group behavior, so no individuals are allowed to be killed during the search, while in genetic algorithms some of the weaker individuals will die out. In a PSO, all individuals will survive and strive to become stronger throughout the search. In particle swarm optimization, the improvement of potential solutions is the result of cooperation, while in evolutionary algorithms, it is due to competition. This concept makes swarm intelligence different from evolutionary algorithms. In short, in evolutionary algorithms, a new population evolves with each iteration, whereas in swarm intelligence algorithms, each generation has individuals who make themselves better. An individual’s identity does not change with iteration. Mataric[2] gave the following flock rule:

Safe roaming: when birds fly, there is no collision with each other or with obstacles; Scatter: Each bird keeps a minimum distance from the others; Aggregation: Each bird also maintains a maximum distance from other birds; Homing: All birds have the potential to find food sources or nests. In the design of particle swarm optimization algorithm, these four rules are not used to simulate the group behavior of birds. In the fundamental particle swarm optimization model developed by Kennedy and Eberhart, the movement of agents does not follow the rules of safe roaming and dispersion. In other words, the agents in the pSO are allowed to be as close to each other as possible during the movement of the PSO. Aggregation and homing are effective in particle swarm optimization. In particle swarm optimization, agents must fly within a specific area in order to maintain maximum distance from any other agents. This means that the search stays within or at the boundary of the search space throughout the whole process. The fourth rule, homing means that any agent in the group can be globally optimal.

During the development of the PSO model, Kennedy and Eberhart proposed five basic principles for judging whether a group of agents is a group:

Proximity principle: agent groups should be able to perform simple spatial and temporal calculations; Quality principle: agent group can respond to quality factors in the environment; Multiple response principle: agent groups should not engage in activities in too narrow channels; Stability principle: the agent group cannot change its behavior pattern every time the environment changes; Adaptability principle: agent groups can change their behavior patterns when the calculated costs are small.

Considering these five principles, Kennedy and Eberhart developed a PSO model for function optimization. In particle swarm optimization (PSO), the random search method is adopted and swarm intelligence is used to solve the problem. In other words, particle swarm optimization is a swarm intelligent search algorithm. This search is done by a randomly generated set of possible solutions. This set of possible solutions is called a group, and each possible solution is called a particle. In particle swarm optimization, particle search is influenced by two learning methods. Each particle is learning from the others, as well as its own experiences along the way. Learning from others can be called social learning, while learning from one’s own experience can be called cognitive learning. As a result of social learning, the particle stores in its memory the best solution accessed by all particles in the group, which we call GBest. Through cognitive learning, the particle stores in its memory the best solution so far that it itself has accessed, called PBest.

The change in direction and size of any particle is determined by a factor called velocity, which is the rate of change in position relative to time. For PSO, the iteration is time. Thus, for particle swarm optimization, velocity can be defined as the rate of change of position relative to iteration. Since the iteration counter increases in units, the dimension of velocity V is the same as that of position X.

For D dimensional search space, The ith particle in the population under the time step t is represented by the d-dimensional vector x I t=(x I 1t,…,x I Dt) t x_i^t = {(x_{i1}^t, \cdots,x_{iD}t) t}xit=(xi1t,…,xiDt) t, Its velocity is expressed by another D-dimensional vector v I t=(v I 1t,… v I Dt) t v_i^t = {(v_{i1}^t, \cdots,v_{iD}t) t}vit=(vi1t,…,viDt) t. P I t = (p I 1 t,… p I D t) t p_i^t = {\left({p_{i1}^t, \cdots,p_{iD}^t} \right)^ t} pit=(pi1t,… The velocity and position of the ith particle are updated by the following formula respectively: V I d t + 1 = v I d t + c 1 r 1 (p I d t − x I d t) + c 2 r 2 (p g d t − x I d t) (1) v_{id}^{t + 1} = v_{id}^t + {c_1}{r_1}\left( {p_{id}^t – x_{id}^t} \right) + {c_2}{r_2}\left( {p_{gd}^t – x_{id}^t} \right)\tag 1 + 1 = vidt vidt + c1r1 (pidt – xidt) + c2r2 (PGDT – xidt) (1)

x i d t + 1 = x i d t + v i d t + 1 (2) x_{id}^{t + 1} = x_{id}^t + v_{id}^{t + 1}\tag 2xidt+1=xidt+vidt+1(2)

Where d = 1, 2,… ,D is dimension, I =1,2… ,S is the particle index,S is the population size. C1 and c2 are constants called cognitive and social scaling parameters, respectively, or simply acceleration coefficients. R1 and r2 are random numbers satisfying uniform distribution [0,1]. The above two formulas are separately updated for each dimension of each particle, and the only connection between different dimensions in the problem space is introduced through the objective function, namely gBest and pBest, the best positions currently found [3]. The algorithm flow of PSO is as follows:

1.1.3 Interpretation of the update equation

The right side of the speed update equation (1) consists of three parts 3:

The velocity of the previous time, v, can be thought of as a momentum term that stores the direction of the previous motion in order to prevent the particle from drastically changing direction.

The second is the cognitive or ego part, by which the particle’s current position moves towards its own best position, so that throughout the search the particle remembers its best position and avoids wandering around. It should be noted that PIDt-xidt is a vector in the direction from XIDt to PIDT, so as to attract the current position to the optimal position of the particle. The order of the two cannot be changed, otherwise the current position will be far away from the optimal position.

The third is the social component, which is responsible for sharing information through groups. By this term, the particle moves to the optimal individual in the group, that is, each individual learns from the other individuals in the group. Again, they should be PGBT – xIDT.

It can be seen that the cognitive scale parameter C1 adjusts the maximum stride length in the direction of its optimal position, while the social scale parameter C2 adjusts the maximum stride length in the direction of the globally optimal particle. Figure 2 shows the typical geometry of particles moving in two dimensions.

FIG. 2 Geometric illustration of particle movement during particle swarm optimization

It can be seen from the update equation that Kennedy and Eberhart’s PSO design follows five basic principles of PSO. In the process of particle swarm optimization, a series of time steps are calculated in d – dimensional space. At any time step, the population follows the guiding direction of GBest and PBest, that is, the population responds to the quality factor and thus follows the quality principle. As uniformly distributed random numbers R1 and R2 are included in the velocity update equation, the current position between pBest and GBest is randomly assigned, which proves the diversity of response principles. In the process of particle swarm optimization, only when the particle swarm receives good information from GBEST, random motion will occur, thus proving the stability principle of particle swarm optimization process. Populations change when GBest changes and therefore follow the principle of adaptation. 1.2 Parameters in Particle Swarm Optimization The convergence speed and optimization ability of any population-based algorithm are affected by its parameter selection. In general, it is not possible to make general recommendations on parameter Settings for these algorithms because the parameters of these algorithms are highly dependent on the problem parameters. However, available theoretical and/or experimental studies give a general range of parameter values. Similar to other population-based search algorithms, parameter adjustment of general PSO is always a challenging task due to the existence of random factors R1 and R2 in the search process. The basic version of PSO requires very few parameters. This chapter discusses only the parameters of the basic version of THE PSO introduced in [4].

One basic parameter is population size, which is usually set empirically based on the number of decision variables in the problem and the complexity of the problem. The general recommendation is 20-50 particles.

The other parameters are the scaling factors C1 and c2. As mentioned earlier, these parameters determine the step size of the particle in the next iteration. In other words, c1 and C2 determine the velocity of the particle. In the base version of PSO, select C1 = C2 =2. In this case, the increase in the particle S velocity is uncontrolled, which is conducive to faster convergence but not to better use of the search space. If we set c1=c2>0, then the particle will attract the average of pBest and gBest. The C1 > C2 setting favors multimodal problems, while c2> C1 favors single-modal problems. In the search process, the smaller the values of C1 and C2 are, the smoother the particle track will be, while the larger the values of C1 and C2 are, the more intense the particle motion will be and the greater the acceleration will be. Researchers have also proposed adaptive acceleration coefficients [5]. The stop criterion is not only a parameter of pSO, but also a parameter of any population-based metaheuristic algorithm. The commonly used stop criterion is usually based on the maximum number of function evaluations or iterations, which is proportional to the time taken by the algorithm. A more efficient stop criterion is based on the search ability of the algorithm, if an algorithm does not significantly improve the solution within a certain number of iterations, then the search should be stopped.

## Ii. Source code

```
clear;
clc;
%jsp_pso
PAR_NUM=50;
GEN_NUM=1000;
JOB_NUM=6;
MAC_NUM=6; N =JOB_NUM*MAC_NUM; particle=rand(PAR_NUM,n+1);
vel=rand(PAR_NUM,n);
%evaluate
for i=1:PAR_NUM
[A B]=sort(particle(i,1:n));
array=ceil(B/MAC_NUM);
makespan=jp_makespan(array);
particle(i,n+1)=makespan;
end
pbest_p=zeros(PAR_NUM,n);
gbest_p=zeros(1,n); % pBEST_P and gbest_P represent single particle optimal sequence and population optimal sequence respectively. pbest_v=zeros(PAR_NUM,1);
gbest_v=zeros(1.1); %pbest_v and gbest_V represent the minimum makespan of single particle and population respectively.for i=1:PAR_NUM
pbest_p(i,1:n)=particle(i,1:n);
pbest_v(i)=particle(i,n+1);
end
[I J]=sort(particle(:,n+1));
gbest_p=particle(J(1),1:n);
gbest_v=particle(J(1),n+1);
e=0.729;
k1=2;
k2=2.1;
iter=0;
while iter<GEN_NUM
for i=1:PAR_NUM
%update
A=rand(1);
B=rand(1);
vel(i,:)=e*vel(i,:)+k1*A*(pbest_p(i,:)-particle(i,1:n))+k2*B*(gbest_p-particle(i,1:n));
particle(i,1:n)=particle(i,1:n)+vel(i,:);
%evaluate
[G H]=sort(particle(i,1:n));
array=ceil(H/MAC_NUM);
makespan=jp_makespan(array);
particle(i,n+1)=makespan;
if particle(i,n+1)<pbest_v(i)
pbest_p(i,:)=particle(i,1:n);
pbest_v(i)=particle(i,1+n);
end
function makespan=jp_makespan(array% calculate the makespan for each particle; %arrayRepresents coding sequence; T=[1 3 6 7 3 6
8 5 10 10 10 4
5 4 8 9 1 7
5 5 5 3 8 9
9 3 5 4 3 1
3 3 9 10 4 1];
js=[3 1 2 4 6 5
2 3 5 6 1 4
3 4 6 1 2 5
2 1 3 4 5 6
3 2 5 6 1 4
2 4 6 1 5 3]; The % JS matrix records the machining machine of different processes of each workpiece; wpn=length(array);
[m n]=size(T);
jp=zeros(1,n); %jp Recording process mp=zeros(1,m); T1_start =zeros(m,n); t1_end=zeros(m,n); Record the start and end time of each process of the machine; t2_start=zeros(m,n); t2_end=zeros(m,n); % Record the start time and end time of each process;for i=1:wpn
k=array(i); %k=1.2.3.4.5.6; Represents the workpiece number; jp(k)=jp(k)+1; %jp Record the process of the workpiece; mp(js(k,jp(k)))=mp(js(k,jp(k)))+1; %mp record the process of machine tool; q=mp(js(k,jp(k)));if jp(k)= =1
if mp(js(k,1)) = =1
t1_start(js(k,1),1) =0;
t1_end(js(k,1),1)=T(k,1);
t2_end(k,1)=t1_end(js(k,1),1);
else
t1_start(js(k,1),mp(js(k,1)))=t1_end(js(k,1),mp(js(k,1))- 1);
t1_end(js(k,1),mp(js(k,1)))= t1_start(js(k,1),mp(js(k,1)))+T(k,1);
t2_end(k,1)=t1_end(js(k,1),mp(js(k,1)));
end
unction gant6c6(jobname,t_start,t_end,gbest_v)
[m n]=size(t_start);
axis_size=[0 gbest_v+2 0 m+0.5];
axis(axis_size);
yla=[1:m];
set(gca,'ytick',yla);
ylabel('Processing Machine'.'FontSize'.12.'color'.'b');
xlabel('Processing Time'.'FontSize'.12.'color'.'b');
title('the scheduling result'.'FontSize'.16.'color'.'r');
set(gcf,'Color'.'g')
hold on
ZO=m+1;
for i=1:m
for j=1:n
x=[t_start(i,j) t_start(i,j) t_end(i,j) t_end(i,j)];
y=[ZO-i0.3 ZO-i+0.3 ZO-i+0.3 ZO-i0.3];
% [1 1 0 ] y yellow
% [1 0 1] m magenta
% [0 1 1] c cyan
% [1 0 0] r red
%[0 1 0] g green
%[0 0 1] b blue
switch(jobname(i,j))
case 1
fill(x,y,'y');
case 2
fill(x,y,'m');
case 3
fill(x,y,'c');
case 4
fill(x,y,'r');
case 5
fill(x,y,'g');
case 6
fill(x,y,'b');
end
Copy the code
```

## 3. Operation results

## Fourth, note

Version: 2014 a