Aryeh Rappaport Avinoam Meir. Schedule automation

Transcription

1 Aryeh Rappaport Avinoam Meir Schedule automation

2 Introduction In this project we tried to automate scheduling. Which is to help a student to pick the time he takes the courses so they want collide with given courses. This program can also be used for administration so they can pick at what time to put every course so it want collide with other courses. The program lets you pick a schedule from the list : And then you pick what algorithm you want to run: And then the program gives you a possible schedule and the nodes and time it took:

3 Approach and Method This problem is NP for checking all the options of the different hours of the course. Lets assume they have 6 different options to pick a course in the schedule. And we have n courses so in order to check all the options we will we need to check which is NP. different options This is constraint satisfaction problem (very similar to graph coloring )- because for each course each option we choose it is restrict us from choosing options in other courses Explain algorithms: General: We get the different courses from a text file that we generated randomly from a c++ program (that we added to the zip file) that has at least one possible schedule. We then saved it into a 3 dimension list. Which the first one is the courses and the second one is the options and the third dimension is the hours in every option We created one schedule called "schedule_example" that has only a few courses to test if our algorithms work. The rest of the schedules have 22 classes which fills up all the schedule. The difference between the algorithms is the maximum options every course has for example "full_schcedulex25" has maximum 25 options. Because they have an option that all the schedule is full so in order for the schedule to be correct it needs to fill up all the hours. Testing the algorithm we did by two different measures by the amount of nodes and by the time it took for the algorithm to finish Trivial algorithm: In this algorithm we implemented as a simple dfs search which continues until the schedule is full. initial state :no courses in schedule goal: all the courses in the schedule state : a schedule with courses in it action: adding courses to the to the schedule results: the reason we even bothered to build this algorithm is to show the big improvement we get with even a little smarter algorithm. This algorithm takes a only for the "schedule_example" for all the rest it takes a few hours. basic algorithm: In this algorithm we implemented sort of a CSP "Incremental Formulation - by DFS" But with no heuristic so that it picks the first state. The difference from the from the Trivial algorithm that here it checks every time if the state is possible and if it is not it doesn t continue to check the deeper states. empty substitution :no courses in schedule a complete and legal substitution: all the courses in the schedule

4 partial substitution : a schedule with courses in it variable: an option of one the courses results: This is algorithm is the straightforward algorithm that we thought of and we build this algorithm so we can compare it with the other algorithm.this algorithm runs significantly better than the Trivial algorithm. Arc Consistency Propagation algorithm with (MRV + LCV heuristics): In this algorithm we implemented sort of a CSP "Incremental Formulation - by DFS" with Minimum Remaining Values as heuristic to choose the next step (course with minimum amount of options), and Least Constrain Value as heuristic to pick value (Inside every course we rearranged the options so the option we put first is the one with least amount of constraints. ). After we pick course and value we run Arc Consistency Propagation -that mean that we remove every potential collusion in the schedule and check if the schedule could be complete. empty substitution :no courses in schedule a complete and legal substitution: all the courses in the schedule partial substitution : a schedule with courses in it variable: an option of one the courses results: This algorithm runs significantly better than the basic algorithm, in both parameters nodes and time. Genetic Algorithms : In this algorithm we implemented Genetic Algorithms as described in AIMA book, with the following settings: any individual is schedule with all courses any course with one of its time options. Population is set of individuals Fitness function is the total number of hours in week minus the hours where there are collusion Mutation is change the selected time option in one course We run it in the following configuration: Max-iteration:10000 Population-size:20 in each iteration we generate new population with the following steps: we create distribution for the chance of each state to be parent by the fitness function, and then we generate each individual from 2 parents that chosen randomly from the distribution. after that with small probability we mutate the individual. results: This algorithm doesn t achieve good results, especially when the schedule full. we conclude from the result that for problems with hard dependencies this algorithm is not efficient, the reason for that seems to be that the idea of generating successor state from two parents state cause many collisions where the internal dependencies in each state are very important

5 MRV combine with + Max Constraints LCV: In this algorithm we implemented sort of a CSP "Incremental Formulation - by DFS" with Minimum Remaining Values (course with minimum amount of options) combine with Max Constraints (which means course with max hours) - (we use it as tie breaker) as heuristic to choose the next step.and Least Constrain Value as heuristic to pick value (Inside every course we rearranged the options so the option we put first is the one with least amount of constraints. ). we do not use here Arc Consistency empty substitution :no courses in schedule a complete and legal substitution: all the courses in the schedule partial substitution : a schedule with courses in it variable: an option of one the courses result: Even though this algorithm doesn't always give us the least amount of nodes it gives us an improvement in the time,

6 Results we test the algorithm in variety number of courses and options per course: here the results first we will want to show an example of how much our algorithms are an improved from the trivial case we will show it for the case of 9 courses with 40 options then we will test when the schedule is completely full we create for that 20 courses and change the number of option for each course we ensure that at least one option is without collision: here the results: nodes Time MRV + LCV MRV + LCV + arc consistency basic trivial GA none none partialschedule9x40 our csp basic trivial partialschedule9x40 our csp basic trivial nodes time(sec)

7 Number of options per course MRV + LCV MRV + LCV + arc consiste ncy basic trivial reasona b reasona b reasona b reasona b l e time l e time l e time GA none none none none none none none Run time MRV + LCV MRV + LCV + arc consistency basic

8 Expanded nodes: Number of options per course MRV + LCV MRV + LCV + arc consisten cy basic trivial GA none none none none none none none expanded nodes MRV + LCV MRV + LCV + arc consistency basic

9 expanded node - just the best algorithms MRV + LCV MRV + LCV + arc consistency Some observations: 1) MRV + LCV significantly reduce the run time and the number of expanded nodes 2) The genetic algorithm failed to find full schedule 3) The results depends on the order of the courses hence 35 options take less time and expanded nodes than 30 options 4) We see that in aspect of run time arc consistency slows the program, and in most of the time expanded its take more expanded nodes The next test is partial full schedule we test it especially for find the limit of Genetic Algorithm partial schedule with 7 courses and 20 options partial schedule with 8 courses and 20 options

10 per course per course GA our arc consistency basic Time chart - partial schedule basic arc consistency our GA partial schedule with 8 courses and 20 options per course partial schedule with 7 courses and 20 options per course partial schedule with 13 courses and 4 options per course partial schedule with 14 courses and 4 options per course GA none our arc consistency

11 basic Conclusions 1) MRV + LCV significantly reduce the run time and the number of expanded nodes 2) The genetic algorithm doesn t achieve good results, especially when the schedule full. we conclude from that for problems with hard dependencies this algorithm is not efficient, the reason for that seems to be that the idea of generating successor state from two parents state cause many collisions where the internal dependencies in each state are very important 3) We see that in aspect of run time arc consistency slows the program because it take O (sum of total options) for each course. 4) The Max Constraints (which means course with max hours) heuristic is very helpful in this problem especially when there are many dependencies (even more then arc consistency)