Manufacturing systems: A knowledge- and optimization ... - Springer Link

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

27

Manufacturing Systems: A Knowledge- and Optimization-Based Approach* ANDREW KUSIAK 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-ALONEKNOWLEDGE-BASEDSYSTEM A knowledge-based system in the stand-alone mode uses data and constraints pertinent 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. TANDEMKNOWLEDGE-BASEDSYSTEM 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-basedsystem.

MANUFACTURING SYSTEMS

29

to modify the selected model, for example, add or delete constraints. In the algorithmbuilding 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 requirements 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 knowledgebased system for machine layout K B M L [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 modelbased 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 knowledgebased 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 constructing 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

MANUFACTURINGSYSTEMS

31

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 knowledgebased 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

ALGONffHM

I Fig. 2.

t

T

PF:tC~ESSOR

t

Structure of the knowledge- and optimization-based system (KBGT).


33

2.1.1. Input data The input data required by K B G T 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, K B G T constructs a machine-part incidence matrix based on the data provided by the user. Next, the K B G T 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, K B G T 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 subsystem consists of three components: • knowledge base • inference engine • request processor.

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 implementation 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).


35

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 B G 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 A N D place them on the part waiting list.

Rule 201 (current machine rule) IF AND

no machine has been included in MC-k 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 A N D 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 A N D 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 knowledgebased 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. ILLUSTRATIVEEXAMPLE 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),

37


and vector T (the column outside o f matrix (1)), solve the g r o u p technology problem. The m a x i m u m n u m b e r o f machines in a machine cell is 3.

fa [11 30 fr [11 30 PARTNUMBER [ 0

k1

lr

2 26

3l

MACHINE NUMBER 4 5 6 7

2.5 5

3

6 6

I0 6 15 10 12

7 7

15 18 141 max-fa(40) - 36 28] max-fr(100)

0

0

0

0

0

0

0

0

1

!

17

2

3

4

5

6

7

8

9

0

1

2

4

5

10

10

35

0

5

1V401 40

2

10

,1401

6

6 16

J

25 3

18

1

7

7

50 50 60 20

(l)

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

1

6

26

10

5

6

9

5

10

12

10

22

8

1

7

7

2

4

7

8

11

3

25 20 (2) 4

21

35 16

8 2

10

3

6 18

As shown in matrix (2) and Figure 3, three machine cells MC-1 = {2, 5}, M C 2 = {3, 7}, M e - 3 = {1, 4, 6} and the three corresponding part families PF-1 -{1, 6, 9}, PF-2 = {5, 10, 12}, PF-3 = {2, 4, 7, 8, 11} have been generated. Part n u m b e r 3 has been assigned to a functional manufacturing facility. T w o A G V s and a handling r o b o t tend the three machine cells. To date a large n u m b e r o f clustering algorithms have been developed, mostly for solving the 0-1 g r o u p technology problem and only a few o f them have been tested. In order to evaluate the performance o f K B G T consider four matrix formulations 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 c o m p u t a t i o n a l time complexity o f the heuristic clustering algorithms available in the literature is high, for example O(m2n + n2m), where m is the n u m b e r o f rows and n is the n u m b e r o f columns in a machine-part incidence matrix. The algorithm presented in this paper has the c o m p u t a t i o n a l time

38

ANDREW KUSIAK

u'3 '~-