I am trying to simulate scheduling in a grid environment. I don't know what algorithms to use. I am considering Job Shop Scheduling algorithm http://en.wikipedia.org/wiki/Job_shop_scheduling but dunno if it is used in grids. What algorithms are typically used in grid environments for scheduling incoming jobs to resources?. Any help would be much appreciated. Thanks.
There are many job-shop scheduling algorithms that can be parallelized. You should start with a literature review or a good reference, like Brucker's "Scheduling Algorithms." The particulars of your domain are likely to allow or disallow various pseudo-polynomial time approaches.
Job Shop Scheduling isn't an algorithm, it's a problem as far as I know.
If you have 3 or more machines, it's NP complete. There are bunch of a algorithms that can deal with NP complete problems, such as Tabu Search, Genetic Algorithms, Simulated Annealing, ... Some of which can be multi-threaded easily (others hard). But the gain of multi-threading is relatively small compared to the gain of improving the algorithm. See this slide for the effect of improving CPU/multi-threading VS improving the algorithm with one of the examples of Drools Planner.
Floyd-Warshall for bipartite graphs and Edmond's Blossom algorithm for non-bipartite graph.
Related
The Knapsack problem is a combinatorial optimization problem where one has to maximize the bene t of objects in a knapsack without exceeding its capacity. We know that there are many ways to solve this problem, genetic algorithm, dynamic programmming, and greedy method. I want to know what is the advantage and disadvantage to use the genetic algorithm comparing with dynamic programming? Space complexity, time complexity, and optimality?
So in order to answer this, it is important to consider what you think is the most important: Speed or Accuracy
Genetic algorithms do not guarantee finding the most optimal solution, however, they typically run very quickly.
Some quick descriptions of a Genetic Algorithm might yield:
It is an estimation function and does not guarantee finding the globally optimal solution
It typically runs very fast (both in memory usage and complexity)
Actual calculations are hard, since genetic algorithms are typically problem specific and chaotic in nature. A good base for what its complexity might look like:
O( O(Fitness) * (O(mutation) + O(crossover)))
However, Dynamic Programming does guarantee to find the most optimal solution, granted with a much longer run time. Some quick descriptions of Dynamic Programming might yield:
It is an exact function -- guarantees convergence on the most globally optimal solution
High memory usage and a very long run time
Complexity for knapsack 01 problem is something like: O(numItems * knapsackCapacity), and memory complexity like O(knapsackCapacity) (credits to this post for that)
If you are asking what is preferred, that is subject specific. If you want a good enough guess quickly, GA is probably the way to go. But if you need a guaranteed and verifiable solution, DP is the way to go.
This should satisfy a basic comparison.
I'm learning about Genetic algorithms and procedural content generation and in some papers people talk about Search-based algorithms to create content such as levels.
Anyway, I'm reading some papers about the topic and in some of them talk about Search-based algorithms and basically they explain what it is, and for me looks basically like a genetic algorithm, but I'm not really sure if they're the same, or a particular case of genetic algorithms.
Is the other way around. Genetic Algorithms are a kind of search-based algorithm. In GA you are searching inside the universe of possible solutions, getting better at doing the job by combining parts of the successful solutions (and a bit of chance: mutation).
https://en.wikipedia.org/wiki/Search-based_software_engineering
I have solved a single objective convex optimization problem (actually related to reducing interference reduction) using cvx package with MATLAB. Now I want to extend the problem to multi objective one. What are the pros-cons of solving it using genetic algorithm in comparison to cvx package? I haven't read anything about genetic algorithms and it came about by searching net for multiobjective optimization.
The optimization algorithms based on derivatives (or gradients) including convex optimization algorithm essentially try to find a local minimum. The pros and cons are as follows.
Pros:
1. It can be extremely fast since it only tries to follow the path given by derivative.
2. Sometimes, it achieves the global minimum (e.g., the problem is convex).
Cons:
1. When the problem is highly nonlinear and non-convex, the solution depends on initial point, hence there is high probability that the solution achieved is far from the global optimum.
2. It's not quite for multi-objective optimization problem.
Because of the disadvantages described above, for multi-objective optimization, we generally use evolutionary algorithm. Genetic algorithms belong to evolutionary algorithm.
Evolutionary algorithms developed for multi-objective optimization problems are fundamentally different from the gradient-based algorithms. They are population-based, i.e., maintain multiple solutions (hundreds or thousands of them) where as the latter ones maintain only one solution.
NSGA-II is an example: https://ieeexplore.ieee.org/document/996017, https://mae.ufl.edu/haftka/stropt/Lectures/multi_objective_GA.pdf, https://web.njit.edu/~horacio/Math451H/download/Seshadri_NSGA-II.pdf
The purpose of the multi-objective optimization is find the Pareto surface (or optimal trade-off surface). Since the surface consists of multiple points, population-based evolutionary algorithms suit well.
(You can solve a series of single objective optimization problems using gradient-based algorithms, but unless the feasible set is convex, it cannot find them accurately.)
My teacher wants us to make two projects, but we haven´t seen many topics and I don´t have very clear what evolutionary computing is used for. Can you give me some ideas, please?
A good place to start is to identify something that can be improved with successive alterations. A great example is the design of a simple windmill propeller or turbine. Start of with a random design and arrangement of the blands. Input this geometry into the genetic algorithm and define the fitness as how fast the propeller spins based on a fixed air flow (a fan for example). Even if you do not build the fan, this is an interesting one to write about and should get you some marks!
Some great problems for Evolutionary programming are the Traveling Salesman Problem and Knapsack Problem.
You may also want to consider another NP Complete problem like Sudoku. Sudoku is a good example of a problem that is possible to solve with stochastic optimization, but more efficient techniques exist. There are a number of Sudoku Solutions Here.
You could compare the difficulty of using evolutionary programming with the Sudoku problem to either the Traveling Salesman or the Knapsack problem and explain why the algorithm works well for the first 2 problems but not the Sudoku.
Yes, there are many such questions like this on SO. I saw genetic algorithms were the most common answers.
Making a timetable schedule and
Algorithm for creating a school timetable
However, I am worried about these characteristics of a GA
termination condition of the program are hard to define
cant escape local maxima easily
I expect the program to be pushed to conflicting criteria and impossible solutions too readily by it's users.
Hence I want a method that
is decisive- guaranteed to reach a near-optimal situation or report that the algorithm won't reach a solution
can take both hard (inviolable) limits and soft limits
elegantly takes in user-input constraints; if user-input doesnt work, it can be added to the code without breaking it
There are 100000 exhaustively possible timetables.
I searched around and saw that metaheuristic algorithms like simulated annealing are a good candidate. What about dynamic programming algorithms?
Is a brute-force approach okay for such a data set?
What is a good algorithm that can fit the criteria?
For small input, with only 100,000 possibilities - I'd go with a plain brute force solution: Just check all possibilities, and chose the best out of them. For modern machines, running your scoring function on an input of size 100,000 is not computationally hard, and will most likely take just a few seconds.
GA and other AI algorithms, are usually used for much larger input [billions and more possibilities], so they might not be the best solution in your case.
Unlike any other solution, the brute force solution will ensure you the optimal solution, and will be terminated when it exhausts all possible solutions.
(*)Note: you can modify GA and steepest ascent hill climbing to overcome the 2nd problem you mention [escaping local maxima] by enforcing random restarts when the solution is not improving for k steps, but again - you will have no idea how close you are to the optimal solution at each point.