Manufacturing systems: A knowledge- and optimization-based approach

Journal of Intelligent and Robotic Systems 3: 27-50, 1990. 27 © 1990 Kluwer Academic Publishers. Printed in the Netherlands.

Manufacturing Systems: A Knowledge- and Optimization-Based Approach* A N D R E W K U S I A K Department of Industrial and Management Engineering, University of lowa, Iowa City, IA 52242, U.S.A.

(Received: 12 May 1988; revised: 8 February 1989)

Abstract. Optimization approaches have traditionally been viewed as tools for solving manufacturing problems. The optimization approach is not suitable for many problems arising in modern manufacturing systems due to their complexity and involvement of qualitative factors. Expert systems appear to remedy the latter weakness of optimization approaches. The biggest disadvantage of expert systems in manufacturing environment is the slow response time. In this paper an integrand approach involving knowledge-based and optimization approaches is explored. The knowledge-and optimization-based approach is applied to solve two manufacturing problems: group technology (static problem) and scheduling (dynamic problem). The approach presented is illustrated with numerical example and computational results.

Key words. Manufacturing, expert systems, group technology, scheduling.

1. I n t r o d u c t i o n

An optimization approach has traditionally been used for solving manufacturing problems, however, it is not always easy to apply because:

• the data required by the optimization algorithms may not be easily available, • their scope of applicability may be limited, • human expertise might be required, and • the algorithms cannot generate optimal solutions for manufacturing problems

because of their complexity.

On the other hand, expert systems have typically been used to solve problems that are either too complex for mathematical formulation or too difficult to solve using optimization approaches. Some of the difficulties encountered when using optimization techniques may be offset by combining them with knowledge-based systems. Based on the operational mode, two classes of knowledge-based systems can be identified [10]:

• stand-alone knowledge-based systems, and • tandem knowledge-based systems.

* The original version of this paper was presented at the 2nd International Symposium on Robotics and Manufacturing (ISRAM), Albuquerque, New Mexico, 16-18 November 1988. The published proceedings of this meeting may be ordered from: CAD Laboratory for Systems/Robotics, EECE Dept, UNM, Albuquerque, NM 87131, U.S.A.

28 ANDREW KUSIAK

1.1. STAND-ALONE KNOWLEDGE-BASED SYSTEM

A knowledge-based system in the stand-alone mode uses data and constraints per- tinent to the problem and solves it using procedures similar to those used by human experts. It does not use the optimization approach which involves modeling the problem and solving the model using an optimal or a heuristic algorithm. Many existing knowledge-based systems fall into the stand-alone class. Dominic [6] is an example of stand-alone system used for design of mechanical parts.

1.2. TANDEM KNOWLEDGE-BASED SYSTEM

The tandem knowledge-based system combines the optimization approach with the knowledge-based system approach for problem solving. It can be thought of as a knowledge-based subsystem linked to a model and algorithm base (Figure 1).

The basic approach utilized in a tandem knowledge-based system is as follows: A suitable model is either selected or built for the given problem. To solve, the model, an optimal or heuristic algorithm is selected (if available in the algorithm base) or built. There are four classes of the tandem knowledge-based systems, namely:

• data-generating knowledge system • model-based knowledge system • model-building knowledge system • algorithm-building knowledge system.

The basic approach in all the four classes of the tandem knowledge-based system is the same, i.e. each one using optimization approach to solve the problem considered. However, the actual problem solving approach in each class is different. The main function in the data-generating knowledge system, is to modify, i.e. generate or reduce data (from among available data) as required by the model. In a model-based knowledge system, a suitable model and algorithm is selected for the given problem. The model-building knowledge system attempts to construct an appropriate model or

Fig. 1. Tandem knowledge-based system.

MANUFACTURING SYSTEMS 29

to modify the selected model, for example, add or delete constraints. In the algorithm- building knowledge system, the system constructs an algorithm for solving the problem.

1.2.1. Data-generating knowledge system

The data-generating knowledge system produces the reduced (possibly minimum) set of data required by a model considered. The data normally would be prepared by a user. The knowledge system generates data from the available sources (e.g. data bases) in the form suitable for the model. This may require the usage of other programs or systems in order to transform (e.g. aggregate) the data. Since the knowledge system is to generate the reduced set of data, the size of the problem to be solved is also reduced.

We are not aware of any papers published on the data-generating knowledge systems. Some publications that might partially relate to this topic fall into the category of knowledge acquisition. The emphasis of these papers, however, is on the knowledge and data acquisition aspect, rather than data processing. To date a large number of papers on knowledge representation have been published, including books, for example Addis et al. (1987).

1.2.2. Model-based knowledge system

The model-based knowledge system is suitable for problems which can be formulated using a number of models, each model being suitable for a particular situation. For a given problem, the knowledge system first identifies the problem and then selects an appropriate model and algorithm. The problem is solved by the algorithm and the solution produced is evaluated. If the solution is implementable, the knowledge-based subsystem accepts it. For example, in the case of machine layout problem, the solution (layout) is implementable if the space constraints are satisfied and adjacency require- ments are met in a layout produced by the knowledge-based system [13]. If the solution is not implementable, then the system may take one of the following actions:

(i) Modify certain parameters in the algorithm (if possible) and again apply the algorithm to the problem in order to generate a new solution, check whether it is implementable and repeat the above procedure until an implementable solution is obtained.

(ii) Modify the solution in order to make it implementable.

Of course, alternative (i) may not be applicable to all algorithms. Even if it would be applicable to a particular algorithm, the corresponding parameter could be modified only to a certain extent, beyond which any modification fails to produce acceptable solutions. In such a case, i.e. when the parameter(s) in the algorithm cannot be modified any further, and if the solutions produced thus far are not implementable, the knowledge-based system adopts alternative (ii) mentioned above. Note that the

30 ANDREW KUSIAK

system may also use alternative (i) to improve the current solution. The knowledge- based system for machine layout KBML [13] uses alternative (i) to improve the current solution and alternative (ii) to make a solution implementable (if necessary).

Duchessi and Belardo [4] developed a system that falls into the category of model- based knowledge systems.

1.2.3. Model-Building Knowledge System

Knowledge systems belonging to this class are, in general, more difficult to develop because they require a careful consideration of the knowledge base. The task of building or at least modifying a model to suit the problem considered is a difficult one even for human experts, since a number of factors such as data availability, ease of applying algorithms, constraints, etc., have to be examined. One should realize that it is difficult to develop a knowledge-based system, which like a human expert is capable of building or modifying a model to suit the problem considered.

The model-building approach involves two steps. In the first-step, the knowledge- based system either constructs an approach model for the given problem or modifies the model selected form the available set of models. In the second step, it determines whether there are any algorithms available to solve the model. If no approriate algorithm is found, then the system either:

(i) modifies the current model such that a suitable algorithm for solving it is available;

(ii) constructs another model for the problem.

If the knowledge-based system is unable to do either of the two above, then it considers modifying the algorithm or parameters within the algorithm, so that the problem can be solved. Of course, modification of the solution generated by the algorithm, in order to make it implementable or to incorporate qualitative factors is done, if necessary. A similar approach has been suggested by Kanet and Adelsberger [7].

In the data modifying and model-based systems, the models are selected from the model base without changing them. Hence their representation is not an important issue. Since, in a model-building system, models are constructed or modified, their representation should be given careful consideration. Evans et al. [5] presented an attempt to develop a model-modifying system that is capable of selecting or construct- ing models for the production planning problem. The knowledge-based system for equiPment selection (KBSES) falls into the class of model building systems [13].

The models generated in the latter paper are extracted (rather than built) from the master model Dolk and Konsynski [3] developed a system which is capable of modifying available models in the knowledge base. They examined the issues involved in knowledge representation for model management systems and proposed a 'model abstraction' approach to represent models in a data base. It involves representing a model in three sections, namely: data objects, procedures, and abstractions. The data


objects section lists the data items of the model. For example, the data items for a linear programming model are the objective function, constraints and decision variables. The procedures section lists: (1) the procedures available, i.e. addition of constraints, deletion of constraints, etc.; (2) the data objects it accesses; and (3) the data objects it returns. The assertions section lists information about data objects and procedures and also their relationships. For example, the assertions section of a linear programming model may Specify that all the expressions be linear in the decision variables.

Using the above mentioned approach, the authors showed how linear programming models may be represented in a system. More importantly, they showed how constraints, for example, integrality constraints may be added to a linear programming problem to convert it into an integer programming problem. The model management system developed by Dolk and Konsynski [3] constructs a model, based on the statement of the problem provided by the user and identifies a similar model stored in the data base using a pattern matching technique. It then solves the constructed model using an appropriate algorithm.

1.2.4. Algorithm-Building Knowledge System

The algorithm-building knowledge system should have the ability to build an algorithm for solving the problem. During the algorithm execution process, the algorithm and the knowledge-based subsystem closely interact. The knowledge-based subsystem may, for example generate search directions for the algorithm.

The knowledge-based system for group technology (EXGT-S) is an attempt in this direction [11]. Although the algorithm has been built by the designer of the knowledge- based system, it is closely interacts with the inference engine and knowledge base. The knowledge-based system modifies the search directions of the algorithm.

The experience as well as the prototype systems discussed in the literature, indicate that the above discussed four classes of knowledge-based systems do not appear too frequently in a pure form but rather as a mixture of different systems. For example an application may involve a data-generating function and model-building function.

To demonstrate the suitability of the knowledge- and optimization-based approach to manufacturing environment two problems have been selected:

(1) real time scheduling problem in an automated manufacturing system (dynamic problem)

(2) group technology (static problem).

The static and dynamic problems have been chosen to show the versatility of the concept presented.

2. Group Technology in Automated Manufacturing

In this section a formulation of the group technology problem that applies to an automated manufacturing environment is discussed. The group technology

32 ANDREW KUSIAK

problem in automated manufacturing systems can be loosely formulated as follows [10, 12].

Determine machine cells and part families with minimum number of parts that visit more than one machine cell, and select a suitable material handling carrier with the minimum corresponding cost subject to the following constraints:

Constraint CI: processing time available at each machine is not exceeded Constraint C2: upper limit on the frequency of trips of material handling carriers

for each machine cell is not exceeded. Constraint C3: number of machines in each machine cell does not exceed its upper

limit or alternatively the dimension (for example, the length) of each machine cell is not exceeded.

The above formulation of the GT problem is not only computationally complex, but also involves constraints that are difficult to handle by an algorithm alone. Therefore, to solve the above problem, a knowledge- and optimization-based system has been developed.

2.1. STRUCTURE OF THE KNOWLEDGE- AND OPTIMIZATION-BASED SYSTEM FOR

GROUP TECHNOLOGY (KBGT)

The knowledge- and optimization-based system (KBGT) considered has the structure shown in Figure 2.

The KBGT consists of five components:

• data base • knowledge base • inference engine • request processor • clustering algorithm.

The KBGT has been implemented in common LISP on a SPERRY-MICRO-IT (an IBM-PC compatible).

I t t t T

ALGONffHM PF:tC~ESSOR

I t Fig. 2. Structure of the knowledge- and optimization-based system (KBGT).


2.1.1. Input data

The input data required by KBGT fall into two categories:

• machine data • part data.

In addition to the above, depending on the characteristics of the manufacturing system, the following optional data can be provided:

• maximum number of machines in a machine cell • maximum frequency of trips which can be handled by a material handling carrier

(for example, robot or automated guided vehicle, AGV).

2.1.2. Grouping Process

Prior to beginning of the grouping process, KBGT constructs a machine-part incidence matrix based on the data provided by the user.

Next, the KB GT initializes in the data base, objects representing facts known about the manufacturing system considered. Then the system forms machine cells and the corresponding part families. Each machine cell is formed by including one machine at a time. A machine is first analyzed by the knowledge-based subsystem (KBS) for the possibility of inclusion in the machine cell. For example, a bottleneck machine, i.e. the machine that processes parts visiting more than one machine cell is not included.

Each time a machine cell has been formed, the KBS checks whether any of the constraints C1-C3 has been violated and removes all parts violating the constraints. For a machine cell, that has been formed and analyzed by the KBS, the corresponding machines and parts forming a part family are removed from the machine-part incidence matrix. The system does not backtrack in the grouping process, i.e. once a machine cell is formed, the machines incliuded in the cell are not considered for future machine cells.

2.1.3. Output Data

At the end of the grouping process, KBGT prints the following data:

• machine cells formed • part waiting list

This list includes parts that were placed on the waiting list due to either: - overlapping of parts in such a way that is prevented grouping, or - including them in a machine cell would violate one or more constraints.

• list of machines not used • list of bottleneck machines • maximum number of machines in a cell.

34 ANDREW KUSIAK

2.1.4. Data Base

The global data base contains information about the current problem represented in a form of objects and frames. It is a non-monotonic data base, since objects are modified by the clustering algorithm and the knowledge-based subsystem.

2.2. THE KNOWLEDGE-BASED SUBSYSTEM (KBS)

As illustrated in Figure 2, the knowledge-based components:

• knowledge base • inference engine • request processor.

subsystem consists of three

2.2.1. Knowledge Base

The knowledge base in KBGT contains production rules which have been acquired from three experts in group technology and the literature. In the current implementa- tion of KBGT, the knowledge base consists of three classes of production rules:

• preprocessing rules • current machine rules • machine cell rules.

The preprocessing rules deal with the initialization of objects in the data base that are not provided by the user. The current machine rules check the appropriateness of a current machine to the machine cell being formed, for example whether the current machine is a bottleneck machine. The machine cell rules deal with each machine cell which has been formed. Machine cell rules check for violation of constraints and remove parts violating them. Separating of rules into disjoint classes has two advantages. First, the search for applicable rules is more efficient since the inference engine attempts to fire only rules that are relevant to the current context. Second, the modularity of knowledge base makes it more understandable, and easy for modification.

Each production rule has the following format:

(rule number (IF conditions THEN actions))

The rule number is used for identification by the inference engine. The most significant digit rePresents a class, and the other two digits represent a rule number in a class. EaCh condition in a rule has one of the following forms:

(a) a straightforward checking of values in the data base, (b) procedure calls to calculate the values required, or (c) a combination of (a) and (b).


An example of (a) is comparing the size of the current MC-k with the maximum number of machines allowed per machine cell. An example of (b) is a call of the procedure calculating the similarity between a current machine and a machine cell.

Sample production rules that have been implemented in K BG T are listed below:

Rule 103 (preprocessing rule) IF the maximum number of machines in a machine cell is specified T H E N remove from the machine-part incidence matrix all parts that require more

machines that the maximum number of machines in the machine cell AND place them on the part waiting list.

Rule 201 (current machine rule) IF no machine has been included in MC-k AND the number of temporary candidate machines plus the current machine is

greater than the number of machines in a machine cell T H E N add the current machine number to the list of temporary bottleneck

machines AND go to step 1 of the clustering algorithm (see Section 2.3).

Rule 302 (machine cell rule) IF there are machines where constraint C 1 is violated T H E N remove parts from the machines violating constraint C1 AND place the removed parts on the part waiting list.

Rule 303 (machine cell rule) IF constraint C2 is violated for a robot or AGV T H E N select a robot or AGV such that C2 is not violated.

2.2.2. Inference Engine

One of the greatest advantages of the tandem system architecture is the simplicity of the inference engine. The inference engine in KBS employs a forward-chaining control strategy. In a given class of rules it attempts to fire all the rules which are related to the context considered. If a rule is triggered, i.e. the conditions are true, then the actions of the triggered rule are carried out. However, some rules, for example Rule 201, stop the search of the knowledge base and send a message to the algorithm.

2.2.3. Request Processor

The request processor facilitates the interaction between the algorithm and knowledge- based subsystem. Based on each request of the algorithm, the request processor calls the inference engine and selects a suitable class of rules to be searched by the inference engine.

36 ANDREW KUSIAK

2.3. CLUSTERING ALGORITHM

The clustering algorithm presented is an extension of the cluster identification algorithm discussed in Kusiak and Chow [14].

2.3.1. Algorithm

Step 0. Set iteration number k = 1. Construct machine-part incidence matrix. Send a request to KBS for preprocessing.

Step 1. Select a machine (row of machine-part incidence matrix) such that it processes the maximum number of parts and is not in the list of temporary bottleneck machines. Place the selected machine in the list of candidate machines.

Step 2. From the list of candidate machines, select a machine, which is the most similar to machine cell MC-k. If machine cell MC-k is empty, then choose the machine selected in step 1. Draw a horizontal line hi, where i is the selected machine number.

Step 3. For each entry crossed once by the horizontal line hi draw a vertical line vj. Parts indicated by the vertical lines are potential candidates for part family PF-k. For each entry tij > 0 crossed by a vertical line vj, add the corresponding machines, which are not in the list of candidate machines to the list of temporary candidate machines. Remove the current machines from the list of candidate machines.

Step 4. KBS analyzes the current machine selected, and takes one of the following two actions:

• go to step 5 (include the current machine in MC-k) • go to step 1 (do not include it).

Step 5. Add the machine considered to machine cell MC-k. Add the corresponding part numbers to part family PF-k. If the list of candidate machines is empty, then go to step, otherwise, go to step 2.

Step 6. KBS analyses machine cell MC-k for violations of constraints C1-C3 and attempts to satisfy the constraints. Remove machine cell MC-k and part family PF-k from the machine-part incidence matrix.

Step 7. If the machine-part incidence matrix is not empty, then increment k by 1 and go to step 1; otherwise; STOP.

2.4. ILLUSTRATIVE EXAMPLE

Given the machine-part incidence matrix (1), vector fa (frequency of AGV trips required for handling each part), vectorfr (frequency of robot trips required to handle each part), max fa = 40 (maximum frequency of trips that can be handled by an AGV), m a x f r = 100 (maximum frequency of trips that can be handled by a robot),


and vector T (the column outside o f matrix (1)), solve the g roup technology problem.

The max imum number o f machines in a machine cell is 3.

fa [11 30 2.5 - 6 I0 - 6 7 15 18 141 max-fa(40) fr [11 30 5 3 6 15 10 12 7 - 36 28] max-fr(100)

PARTNUMBER [ 0 0 0 0 0 0 0 0 0 1 ! 1 7 k J 1 2 3 4 5 6 7 8 9 0 1 2

lr 4 1V401 2 26 5 10 40 3 l 0 10 ,1401 MACHINE NUMBER 4 35 2 6 50 5 5 6 25 50 6 16 10 3 18 60 7 1 7 7 20

(l)

The solution generated by the K B G T is shown in matrix (2).

1 6 9 5 10 12 2 4 7 8 11

26

5

10

6 25

10 22 8

1 7 7

4 21 8

35 2 6

16 10 3 18

3

20 (2)

As shown in matrix (2) and Figure 3, three machine cells MC-1 = {2, 5}, MC-

2 = {3, 7}, M e - 3 = {1, 4, 6} and the three corresponding par t families PF-1 --

{1, 6, 9}, PF-2 = {5, 10, 12}, PF-3 = {2, 4, 7, 8, 11} have been generated. Par t

number 3 has been assigned to a functional manufac tur ing facility. Two AGVs and

a handling robot tend the three machine cells.

To date a large number o f clustering algorithms have been developed, mostly for

solving the 0-1 g roup technology problem and only a few of them have been tested.

In order to evaluate the performance of K B G T consider four matrix formulat ions o f the G T problem in Table I.

The solutions obtained are of better quality than ones generated by the four algorithms considered. The computa t ional time complexity o f the heuristic clustering

algori thms available in the literature is high, for example O(m2n + n2m), where m

is the number o f rows and n is the number o f columns in a machine-par t inci-

dence matrix. The algori thm presented in this paper has the computa t iona l time

38 A N D R E W K U S I A K

r~

~ z

u'3 '~-

" 0 " 0 ~o

< < < ~ < m z z z z~ ~ = ~ ' ~

~ o e o

oo ~ o o o o

~ o o N ~ o o o o

, ~ 0

t'N

E

o

MANUFACTURING SYSTEMS

MANUFACTURING SYSTEM

MACHINE CELL MC-1 5~ l MACHINE CELL MC-2

[ MACHINE 2 I [ MACHINE [ MACHINE 3] [ MACHINE 7 1

FUNCTIONAL MACHINING FACILITY

MACHJNE CELL MC-3

39

Fig. 3. Layout corresponding to the solution of the group technology problem represented in matrix (2).

Fig, 4. Structure of the knowledge- and optimization-based scheduling system (KBSS).

complexity slightly higher than O (mn). The CPU time reported in Table I is for a SPERRY-MICRO-IT.

3. The Knowledge- and Optimization-Based Scheduling System (KBSS)

The KBSS performs the following two basic functions:

• selects an algorithm for the problem considered • controls the schedule generation procedure of the algorithm selected.

40 ANDREW KUSIAK

The knowledge-based system is built using the tandem architecture proposed in Kusiak [10]. The basic components of the KBSS are shown in Figure 4, and involve

• knowledge base • algorithm base • data base • inference engine.

3.1. KNOWLEDGE BASE

Knowledge in KBSS has been acquired from experts as well as the scheduling literature. Frames are used to represent the declarative knowledge related to the de'scription of scheduling problems, parts and operations, and the schedules generated. Two sample frames for a part and the schedule generated are presented below.

Frame 1 (Part_number (Due_date (value)) (Number_of_operations (value)) (Number_of_process_plans (value)) (Process_plan_0 (operation_number,

processing_time, machine_number, tool_number, pallet_fixture_number, material_handling_carrier_number))

Frame 2

(Process_plan_p (operation_number, processing_time, machine_number, tool_number, pallet fixture_number, matterial_handling_carrier_number)))

(Schedule_of_problem (Problem_number) (Generated_by (algorithm_number)) (Idle_time (machine_l, machine_2, . . . ,

machine_m)) (Completion_time (part_I, part_2 . . . . . part_n)) (Average_utilization_rate (machine,

tool, pallet_fixture, material_handling_

carrier))


Frame 1 represents knowledge used to generate schedules and select alternative process plans. Frame 2 represents the schedules generated and is used for rescheduling.

The procedural knowledge of the knowledge- and optimization-based system is represented in the form of production rules. To handle different problems the production rules are divided into following three classes:

Class 1 selects an approriate algorithm to solve the problem considered; Class 2 controls the procedure of selecting alternative process plans and modifies

the sequence of the priority rules in the heuristic algorithm; Class 3 evaluates the schedules obtained and performs rescheduling.

Several sample production rules in each class are presented below:

Class 1 Rule 13: IF

AND AND

the scheduling problem involves more than 5 resources number of operations is greater or equal 60 alternative process plans are available

THEN use the heuristic algorithm (presented in Section 3.4)

Class 2 Rule 24: IF

AND AND

THEN

AND

an alternative process plan is specified for an operation that is non-scheduleable due to unavailability of resources listed in the basic process plan the required alternative resources for the operation are available the sum of the waiting and processing time for the operation in the basic process plan is longer than one in the alternative process plan replace the basis process plan with the corresponding alternative process plan add the corresponding operation to the set of scheduleable operations.

Class 3 Rule 36: IF

THEN AND

Rule 38: IF THEN

a part in a partial (or final) schedule generated by the heuristic algorithm does not meet the required due date schedule the part ensuring that the due date is satisfied reschedule other parts using the heuristic algorithm (presented in Section 3.4) all due dates have been met in the final schedule accept the schedule.

3.2. ALGORITHM BASE

In the algorithm base a number of scheduling algorithms. The heuristic algorithm presented in the Section 3.4 is most likely to be used for solving scheduling problems in large-scale automated manufacturing systems.

42 ANDREW KUSIAK

3.3. INFERENCE ENGINE

The inference engine in the knowledge- and optimization-based scheduling system (KBSS) controls the procedure of triggering rules in the knowledge base and the procedure of schedule generation by an algorithm selected. One of the greatest advantages of the tandem system architecture is the simplicity of the inference engine. The inference engine in KBSS employs a forward-chaining control strategy. In a given class of production rules it attempt s to fire all the rules which are related to the context considered. If a rule is triggered, i.e. the conditions are true, then the actions of the rule triggered are carried out. Some rules stop the search of the inference engine and switch the control process to the algorithm.

The inference engine maintains a list of the rules which have been fired. The list is called 'explain'. The rules in 'explain' are placed in the order that they were fired. The list forms a basis for building an explanation facility.

3.4. THE HEURISTIC ALGORITHM

In many manufacturing systems, one associates with each part a basic process plan and one or more alternative process plans. A process plan specifies the operations belonging to the part, processing times of these operations, and the resources required such as machines, tools, pallets/fixtures, etc.

Before the heuristic algorithm is presented, the following notation and definitions are introduced:

I K IP, L QI d~ f El i

nSik

nbik

np~

t

rig

set of all operations set of all parts set of operations belonging to part Pk, k ~ K Set of all resource types set of resources of type l, l ~ L due date of part Pk, k ~ K completion time of operation i, i ~ I remaining processing time of operation i, i ~ I number of successive operations of operation i in part Pk, i ~ / , k ~ K number of immediate (directly linked by precedence constraints) successive operations following operation i in part Pk, i ~ / , k ~ K number of unprocessed operations in part Pk corresponding to operation i, i 6 L k ~ K current scheduling time resource q of type l, q ~ Q~, l ~ L.

In particular, the following four types of resources are used:

• machine (l = 1), • tool (l = 2),


• pallet/fixture (l = 3), and • material handling carrier (l = 4).

Resource rlu is available if it can be used without any delay, q e QI, l e L. The status

sr~q of such resource equals 1, otherwise sr~q = O.

A process plan pp(v) of a part P~ is a vector of triplets, each containing: operation number, processing time, and set of resources to ~rocess the operation. It is denoted as follows:

pp(v) = [(a, t(~ v), R~ v)) . . . . , (i, tl v), RlV/), . . , (b, t(b v), R(bV))],

where RlV/ = (rlq), r~), . . . , "~q~(V)~,, q ~ Q,, l ~ L; a, . . . , i . . . , b denote the operations numbers; v = 0 denotes the basic process plan; v = 1, 2 . . . . denotes an alternative process plan; and t} v~ denotes processing time of operation i using process plan v.

Without loss of generality, it is assumed that tl °) ~< t} ~) , i E/ , which holds in practice. A process plan PP(k ~) for part Pk and the corresponding operations is available

if each element in PP(k ~) has been specified. Operation i is scheduleable at time t if:

(1) no other operation that belongs to the same part is being processed at time t; (2) all operations preceding operation i have been completed before time t; (3) all resources required by the basic process plan to process operation i are

available at time t.

Based on the above definitions, further notation is introduced:

{i atio / sn°nsch dulabl 2 operation i is scheduleable,

operation i is being processed, operation status, s~ = operation i has been completed,

operation i satisfies the first two conditions in the definition of scheduleability

1 resource r~q is available r e s o u r c e s t a t u s Srlq

0 otherwise

set of operations withs~ = j , j = O, 1 , 2 , 3 , 4 , i e i ,

s t ~ s l a c k t i m e o f p a r t P k , stk = ( d k - - t - - ~ t } ° ~ ) f o r i e l P k , k e K , i~So~;S 1

nook number of operations in $1 w IPk, i ~ I, k E K,

In the process of schedule generation, an operation might not be processed according to the basic process plan due to unavailability of the resources specified in the basic process plan. The scheduling heuristic presented in this section exists from step 3 and step 6, and enter the inference engine of the knowledge-based system.

44 ANDREW KUSIAK

Seven priority scheduling rules have been incorporated into the heuristic algorithm:

Rule P1 selects an operation with the largest number of successive operations; Rule P2 selects an operation belonging to a part with the minimum number of

scheduleable operations; Rule P3 selects an operation with the largest number of immediate successive

operations; Rule P4 selects an operation belonging to a part with the largest number of

unprocessed operations; Rule P5 selects an operation with the shortest processing time; Rule P6 selects an operation belonging to a part with the shortest slack time; Rule P7 selects an operation arbitrarily.

The priority rules are used in step 2 of the algorithm in the sequence of P1 to P7. If more than one operation is selected by a priority rule, the next rules perform further selection. Different sequences of the priority rules have been tested for various problems and the results are reported later in this paper.

3.4.1. Algorithm

Step 0. Set current time t -- 0 and resource status srtq = 1, q ~ Q~, 1 ~ L.

Step 1. Construct the following two sets:

• set So of nonscheduleable operations (s~ = 0) • set S~ of scheduleable operations (s~ = 1).

Step 2. In the set S~, select an operation i* based on the following priority rules:

PI:

P2:

P3:

P4:

P5:

P6:

P7:

Step 3. Set:

nsi,~ = maxi~st {nsik}, k E K,

noi,k = min,~sl {noik}, k ~ K,

nbi,k = maxi~s~ {nbi~}, k ~ K,

npi,k = maxi~s~ {npi~}, k ~ K,

ti, = mini~s~ {t}°~},

Stk* t t

icSouS I

brake a tie arbitrarily.

• operation status si, = 2 for operation i* selected in step 2, • operation status si = 0 for all the unprocessed operations of the part

corresponding to equation i*

MANUFACTURING SYSTEMS

Delete operation i* from S,. If S~ u So = ~ , stop; otherwise, set:

• remaining process time rt~. = t} °~,

• resource status Srlq = 0, for rtq ~ R} °~, q ~ Q~, 1 E L .

45

Update S, and So. If S, ¢ 75, go to step 2. If S, = 75 and no resource is available, go to step 4; otherwise update set $4, enter the inference engine, and return.

Step 4. Construct set $2, and: • calculate completion time f = rt i + t, i ~ $2

• set current time t = f = minims2 { f }, • set operation status sz = 3, • delete operation 7 from $2 • set resource status Srjq = 1, rtq ~ R} °), q e QI, l ~ L

• set remaining time rti = f - t, i ~ $2

U p d a t e S 1 and So.

Step 5. Step 6.

If S1 • So = 75, stop; otherwise, go to step 6. If $1 ¢ 75, go to step 2. If $1 = ~ and no resource is available, go to step 4; otherwise update set $4, enter the inference engine, and return.

The algorithm presented solves scheduling problems with due dates. If the due date is not imposed for a part Pk, the corresponding value of d~ is set an arbitrary large number.

The above algorithm is embedded into the knowledge-based system discussed in the previous section. In the next section, the heuristic algorithm and sample production rules are illustrated with the following numerical example.

3.5. NUMERICAL EXAMPLE

Schedule twelve operations shown in Figure 5 on three machines. It is assumed that:

• three different tools are available to process the operations, • all other resources are unlimited, and • due dates are not imposed.

The following notation is used for the resources:

rlq denotes machine (resource type 1), q = 1, 2, 3, r2q denotes tool (resource type 2), q = 1, 2, 3.

The machine and tool status are represented as follows:

Srlq denotes machine status, q = 1, 2, 3,

46 ANDREW KUSIAK

PART P 4

i b a i

v

PART P 3

©

[ , ,~ !

V

PART P PART P 2 1

I ba I

Fig. 5. Parts with operations and precedence constraints.

Sr2q denotes tool status, q = 1, 2, 3, and ti denotes the processing time t} °) of operation i in the basic process plan.

The basic process plans of the four parts are shown below:

pp}O): [(1, 4, 2, 2), (2, 5, 1, 3), (3, 2, 3, 2)], PP2(°): [(4, 6, 1, 3), (5, 3, 2, 2), (6, 3, 3, 1)1, pp~O): [(7, 3, 3, 1), (8, 3, 1, 2), (9, 6, 3, 1), (10, 2, 1, 3)], PP~4°): [(11, 4, 3, 2), (12, 3, 2, 3)].

Note that for any triplet in the above process plans, the first element denotes operation number, the second denotes processing time and the third pair denotes the required machine number (resource type 1) and tool number (resource type 2).

The alternative process plans for the four parts are:

pp}l): [(1, 6, 3, 1), (2, 6, 2, 2), (3, 4, 1, 1)]; PPI2): [(1, 7, 1, 3), (2, 7, 1, 2), (3, 5, 1, 3)]

PP(2'): [(4, 6, 2, 2), (5, 4, 3, 1), (6, 5, 1, 2)]; Pp2(2): [(4, 8, 3, 1), (5, 8, 1, 3), (6, 5, 2, 3)]

PP~'): [(7, 4, 3, 2), (8, 5, 3, 3), (9, 7, 2, 1), (10, 2, 3, 2)]; pp~2): [(7, 4, 2, 2), (8, 5, 2, 1), (9, 9, 1, 3), (10, 4, l, 2)]

PP~41): [(11, 4, 1, 3), (12, 5, 1, 2)1; Pp4(2): [(11, 4, 3, 1), (12, 6, 3, 3)].

M A N U F A C T U R I N G SYSTEMS 47

M I

(3) (3) (3) (2)

" " "" Y / X / / , " " / I A 4 I 1° V,~);Y/X//,2.~A

(2) (2) (1) (2) / / / .,"//~

(1) (1) (2) (3) TIME

6 10 12 18

(k)

(1)

OPERATION i USES TOOL k AND IS PROCESSED ACCORDING TO THE BASIC PROCESS PLAN

OPERATION j USES TOOL 1 AND IS PROCESSED ACCORDING TO THE ALTERNATIVE PROCESS PLAN

Fig. 6. The final schedule.

The Gantt chart of the final schedule obtained after seven iterations is shown in Figure 6.

3.6. C O M P U T A T I O N A L RESULTS

In this section, computational experience with the knowledge- and optimization- based scheduling system KBSS is presented. The heuristic algorithm discussed is the most likely algorithm to be used while solving industrial scheduling problems in automated manufacturing systems. The results generated by the knowledge- and optimization-based scheduling system can be improved by using other production rules. The degree of improvement depends upon the quality of the knowledge collected.

In order to evaluate the quality of solutions generated by the KBSS, sample problems have been solved. Three measures of performance were used:

• maximum flow time (Fmax)

Fmax = max{Fj}, j = 1 . . . . ,N, • j

• average flow time (F)

N

P = X F j / N j = l

where Fj is flow time for machine j , and N is the number of machines • machine utilization (Urn)

N

Um = E V~/N,

48

Table II. Scheduling results.

A N D R E W K U S I A K

Sequence of Priority CPU CPU CPU Problem Rules Fma x P U m time Fma x F U m time Fma x P U m time

1:14 machines 20 parts 160 operations Minimum-maximum flow time: 24.0

P1 P2-P3-P4-P5-P6 26,5 24.0 P2-P1-P3-P4-P5-P6 26.5 24.0 P3-P2-PI-P4-P5-P6 26.5 24.0 P4 P2-P3-PI-P5-P6 26.5 24.2 P1-P3-P2-P4~P5-P6 26.5 24.0 P3-P1-P4-P2 P5-P6 26.5 24.2 P2 P3-Pt-P4-P5-P6 26.5 24.0

0.99 9.32 26,5 24.1 0.99 8.70 26.5 24,8 0.96 7.22 0.99 9.23 26.5 24.1 0.99 8,46 29.0 25.3 0.95 7.81 0.99 9.25 26,5 24,2 0.99 8.69 29.0 25.3 0.95 8.19 0.99 9.81 26.5 24,2 0.99 8.45 26.5 24,4 0,99 8,43 0,99 9.36 26.5 24.0 0.99 8.77 26.5 24.8 0.97 8.37 0.99 10.l 27.5 24.0 0.99 8,82 26.0 24.5 0.98 8.17 0.99 9.20 26.5 24.1 0.99 8.52 29.0 25.3 0.95 8.21

Number of precedence constraints 0 48 140

2: 12machines 18 parts 132 operations

Minimum-maximum flow time: 27.0

P1-P2-P3-P4-P5-P6 30.0 27,2 P2-P1-P3-P4-P5 P6 30.0 27,2 P3-P2-P1-P4-P5-P6 30.0 27.1 P4 P2-P3-P1-P5-P6 30.0 27.2 P1-P3-P2-P4-P5-P6 30.0 27.2 P3-P1-P4-P2-P5-P6 30.0 27.0 P2-P3-PI-P4-P5-P6 30.0 27.2

0.99 6.71 30.0 27.1 0.99 6.06 31.0 27.8 0.98 5.50 0,99 6.62 30.0 27.3 0.99 6,16 32,5 28.2 0.99 5.21 0,99 6,63 30.0 27.0 0.99 6.03 3 2 , 5 28.2 0.96 5.46 0.99 6.66 29.5 27.0 0,99 6,07 30,0 27.5 0.98 5.83 0.99 6.72 30.0 27.1 0,99 6,06 31.0 27.8 0.97 5.44 0.99 7.06 30.0 27.3 0.99 6.58 30.5 27.8 0.97 5.53 0,99 6,64 30.0 27.3 0.99 6.13 32.5 28.2 0.96 5.45


3:10 machines 16 parts 116 operations


P1-P2-P3-P4-P5-P6 26.5 24.1 P2-PI-P3-P4-P5-P6 26.5 24.1 P3-P2-PI-P4-P5-P6 26.5 24.1 P4-P2-P3-PI-P5-P6 26.5 24.1 PI-P3-P2-P4-P5-P6 26.5 24.1 P3-P1-P4-P2-P5-P6 26.5 24.1 P2-P3-P1-P4-P5-P6 26.5 24.1

0.99 5,49 24,5 24.1 0.99 4.92 27.5 24.5 0.98 4.27 0.99 5,33 26.5 24.1 0.99 4.96 26.5 24.2 0.99 4.60 0.99 5.36 24.5 24,1 0.99 4.93 26.5 24.2 0.99 4.75 0.99 5.29 26.5 24.0 1.00 4.87 25.5 24.3 0.99 4.56 0.99 5.40 24.5 24,1 0.99 4.94 27.5 24.5 0.98 4,29 0.99 5.44 26.5 24.0 1.00 4.97 26.5 24.5 0,98 4,51 0.99 5.36 26.5 24,1 0.99 5.02 26.5 24.2 0.99 4,75


4: 12machines 18 parts 94 operations


PI-P2-P3-P4-P5-P6 23.0 19.0 P2-P1-P3-P4-P5-P6 23.0 19.0 P3-P2-P1-P4-P5-P6 23.0 19.0 P4-P2-P3-PI-P5-P6 22.0 19.0 PI-P3-P2-P4-P5-P6 23.0 19.0 P3-PI-P4-P2-P5-P6 22.0 19.0 P2-P3-P1-P4-P5-P6 23.0 19.0

1.00 3.57 21,0 19.2 0,99 3.09 21.0 19.6 0.96 2.80 1.00 3,47 23,0 19.2 0.99 3.18 21.5 19.6 0.97 3.04 1.00 3.48 21,5 19.2 0.99 3.10 21.5 19.6 0.97 3.16 0.99 3.57 22,0 19,3 0.99 3.20 22.0 19.4 0.98 3.13 1.00 3,57 21.0 19.2 0.99 3.18 21.0 19,6 0.97 2.89 0.99 3.64 22.0 19.1 0.99 3.43 22.0 19.4 0,98 2.93 1.00 3.52 23,0 19,2 0.99 3.24 21,5 19,6 0,97 3.20


5:6 Machines 9 parts 66 operations


P1-P2-P3-P4-P5 P6 30.5 27.8 P2-Pl P3-P4-P5-P6 30.5 27.8 P3 P2-PI P4-PS-P6 30.5 27.8 P4 P2-P3-P1-P5-P6 30.0 27.2 PI-P3-P2-P4-P5-P6 30.5 27.8 P3-P1-P4-P2 P5-P6 30.0 27.2 P2 P3 P1 P4-P5-P6 30.5 27.8

0,98 1.75 28.0 27.2 1.00 1.74 30.0 28,0 0,97 1,51 0,98 1.69 30.0 27.4 0.99 1.64 32,0 28.3 0,96 1.36 0,98 1.79 28.0 27,2 1.00 1,74 32,0 28,3 0,96 1.44 1,00 1.85 31.0 27.2 1.00 1,64 30,5 27.9 0.97 1.70 0.98 1.83 28.0 27.2 1.00 1,75 30.0 28.0 0.97 1.51 1,00 1.93 29.0 27.4 0.99 t.77 30.0 27,7 0.98 1.51 0,98 1.67 30,0 27.4 0.99 1.66 32.0 28.3 0.96 1.41



where

: Z tlv /rJ, i~M(j)

in which tl ~) is the processing time of operation i using process plan v and M(j) is the set of operations processed on machine j .

In order to evaluate the effect of the sequence of priority rules P1 to P6 on the solution quality, a number of scheduling problems have been solved for five different sequences of priority rules. Computational results for three sample problems are presented in Table II. Problems in Table II include basic and alternative process plans where for a given operation, the processing time of basic and alternative process plans were assumed identical. It was assumed that all machines were operational in the scheduling horizon. In all the problems in Table II the number of resources, except machines, was assumed unlimited.

The computational results presented in the table allow us to draw the following conclusions:

(1) Schedules generated by the knowledge- and optimization-based system are of good quality.

(2) The increase of the number of precedence constraints increases the maximum flow time and average flow while the machine utilization decreases.

(3) There is no sequence of priority rules that is dominant in terms of the solution quality.

(4) The CPU time increases with the increase of problem size and decreases with the increase of the number of precedence constraints. CPU time is also slightly affected by the sequence of priority rules.

4. Conclusions

In this paper a knowledge- and optimization-based approach for solving manufacturing problem was discussed. The methodology developed allows us to solve effectively manufacturing problems which tend to be well structured. Combining the knowledge- and optimization-based approaches has the following advantages:

(1) reduces the size of the knowledge base (2) simplifies inference engine (3) allows quantitative and qualitative factors to be considered.

Computational experience with the static (group technology) and dynamic (scheduling) problems includes that the knowledge- and optimization-based methodology applies to a large class of manufacturing problems.

References

1. Addis, T., Boose, J.H. and Gaines, B.R. (eds), Proc. First European Workshop on Knowledge Acqui- sition for Knowledge-Based Systems, Reading (1987).

50 ANDREW KUSIAK

2. Chandrasekharan, M.P. and Rajagopalan, R., ZODIAC - an algorithm for concurrent formation of part-families and machine-cells, Int. J. Production Research 25, No. 6, 835-850 (1987).

3. Dolk, D.R. and Konsynski, B.R., Knowledge representation for model management systems, IEEE Trans. Software Engineering SE-10, No. 6, 619-628 (1984).

4. Duchessi, P. and Belardo, S., Lending analysis support system (LASS): An application of a knowledge- based system to support commercial loan analysis, IEEE Trans. Systems, Man and Cybernetics SMC-17, No. 4, 608-616 (1987).

5. Evans, J.R., Dennis, D.R. and Shafer, S.M., An intelligent system for production planning modelling and optimization, Proc. 7th Int. Conf. on Production Research, 17-20 August, Cincinnati, OH, pp. 1689-1693 (1987).

6. Howe, A., Cohen, P., Dixon, J. and Simmons, M., Dominic: A domain-independent program for mechanical engineering design, in D.T. Pham (ed.), Expert Systems in Engineering, Springer-Verlag, New York, pp. 361-371 (1988).

7. Kanet, J.J. and Adelsberger, H.H., Expert systems in production scheduling, European J. Operational Research 29, No. 1, 51-59 (1987).

8. King, J.R. and Nakornchai, V., Machine-component group formation in group technology: review and extension, Int. J. Production Research 20, 117-133 (1982).

9. Kumar, K.R. and Vannelli, A., Strategic subcontracting for efficient disaggregated manufacturing, Int. J. Production Research 25, No. 12, 1715-1728 (1987).

10. Kusiak, A., Artificial intelligence and operations research in flexible manufacturing systems, Informa- tion Processing and Operations Research (INFOR) 25, No. 1, 2-12 (1987).

11. Kusiak, A., EXGT-S: A knowledge-based system for group technology, Int. J. Production Research 26, No. 5, 887-904 (1988).

12. Kusiak, A., Expert systems and optimization in manufacturing, in M. Jamshidi, 4. Y. S, Luh, H. Seraji and G. P. Starr (eds), Robotics and Manufacturing, ASME Press, New York, pp. 891-900 (1988).

13. Kusiak, A. and Heragu, S.S., Knowledge-based systems guides machine layout in flexible manufacturing system, Industrial Engineering 20, No. 11, 48-53 (1988).

14. Kusiak, A. and Chow, W.S., Decomposition of manufacturing systems, IEEEJ. Robotics andAutoma- tion 4, No. 5, 457-471 (1988).

15. Seifoddini, H., Improper machine assignment in machine-component grouping in group technology, Proc. Fall Industrial Engineering Conf., Boston, MA, 7-10 December, pp. 406-409 (1986).

Manufacturing systems: A knowledge- and optimization-based approach

Documents

Transcript of Manufacturing systems: A knowledge- and optimization-based approach