I'm trying to improve the throughput of a production system. The exact type of the system isn't relevant (I think).
Description
- The system consists of a LINE of stations (numbered 1, 2, 3...) and an ARM.
- The system receives an ITEM at random times.
- Each ITEM has a PLAN associated with it (for example, ITEM1 may have a PLAN which says it needs to go through station 3, then 1, then 5). The PLAN includes timing information on how long the ITEM would be at each station (a range of hard max/min values).
- Every STATION can hold one ITEM at a time.
- The ARM is used to move each ITEM from one STATION to the next. Each PLAN includes timing information for the ARM as well, which is a fixed value.
Current Practice
I have two current (working) planning solutions.
The first maintains a master list of usage for each STATION, consider this a 'booking' approach. As each new ITEM-N enters, the system searches ahead to find the earliest possible slot where PLAN-N would fit. So for example, it would try to fit it at t=0, then progressively try higher delays till it found a fit (well actually I have some heuristics here to cut down processing time, but the approach holds)
The second maintains a list for each ITEM specifying when it is to start. When a new ITEM-N enters, the system compares its' PLAN-N with all existing lists to find a suitable time to start. Again, it starts at t=0 then progressively tries higher delays.
Neither of the two solutions take advantage of the range of times an ITEM is allowed at each station. A fixed time is assumed (midpoint or minimum).
Ideal Solution
It's quite self-evident that there exists situations where an incoming ITEM would be able to start earlier than otherwise possible if some of the current ITEMs change the duration they spend in certain STATION, whether by shortening that duration (so the new ITEM could enter the STATION instead) or lengthening that duration (so the ARM has time to move the ITEM).
I'm trying to implement a Genetic Algorithm solution to the problem. My current gene contains N numbers (between 0 and 1) where N is the total number of stations among all item currently in the system as well as a new item which is to be added in. It's trivial to convert this gene to an actual duration (0 would be the min duration, 1 would be the max, scale linearly in between).
However, this gene representation consistently produces un-usable plans which overlap with each other. The reason for this is that when multiple items are already arranged ideally (consecutive in time, planning wise), no variation on durations is possible. This is unavoidable because once items are already being processed, they cannot be delayed or brought forward.
An example of the above situation, say ITEMA is in STATION3 for durations t1 to t2 and t3 to t4. ITEMB then comes along and occupies STATION3 for duration t2 to t3 (so STATION3 is fully utilized between t1 and t4). With my current gene representation, I'm virtually guaranteed never to find a valid solution, since that would require certain elements of the gene to have exactly the correct value so as not to generate an overlap.
Questions
- Is there a better gene representation than I describe above?
- Would I be better served doing some simple hill-climbing to find modifiable timings? Or, is GA actually suited to this problem?
