1) There's 2 course grained moves out of the box in 6.1.0.CR1:
pillarChangeMove and pillarSwapMove.
And in 6.1.0.CR1 they also include subpillars (which is important).
Start with trying those.
2) Then look into cartesianProduct selection and mimic selection (see docs).
The <cartesianProductMoveSelector> allows you to combine to existing
moves into a new one.
The mimic selection allows you to make sure that those 2 moves change
the same entity (if needed), but a different variable of course.
I am working on nearBySelection for 6.2 to allow it to select 2 entities
that are somehow "nearBy" to each other (for example in the same service
etc).
3) If the above don't help enough, there's always custom moves (see
docs): total freedom, but the devil is in the details :)
On 24-06-14 01:58, DwProd . wrote:
Hello there,
I'm pretty new to OptaPlanner, and I must say I'm really impressed
with the maturity of it all. Great software with a great documentation !
I've been working on a variation of the Cloud Balancing example, with
a few differences, which make it look like the Machine Reassignment
problem as well :
- Some processes are already placed and are immovable (using a
Selection Filter checking a boolean property of the planning entity)
- The Computer (the planning variable) is nullable (basically this is
Multiple Muti-Dimensional Knapsack problem) which means I added a soft
constraint penalty for processes with a null host.
- Processes can only be of a few classes (which I called services, a
Problem Fact). Processes of a given service type have a certain amount
of required cpu and ram.
Taking these elements into account, I do get very good results with
OptaPlanner. However, the following constraints always put me into a
score trap :
- For some services, processes work in groups. For instance, if groups
are of size 3, having 7 processes is not any better than having 6
processes. If there were already 2 processes (immovable and placed), I
should only add 4 processes and not 5, even if there are enough
resources. For this constraint, I have tried using a rule (medium
constraint) accumulating processes of that service and using the
modulo operator with the group size.
- Some services are dependant on one another. For instance, I know
that if I have n1 groups of processes of the service 1, I require
Math.ceil(2.5*n1) groups of processes of the service 2. I have
implemented this similarly with a medium constraint...
With any (or both) of these constraints, little to no processes of the
concerned services are added and I fail to reach a good solution. I
have tried benchmarking with several local search methods and various
parameters, but all give the same results...
I feel like the next logical step would be to used the often mentioned
in the documentation "Coarse Grained Moves" but I fail to locate any
simple example. The Nurse Rostering example seems to use that
technique to some extent but it seems like an overly complicated
example, is it not.
Thank you very much for reading this far, if you have any question,
guideline, or just a trick, I'd be absolutely delighted to hear from you !
Cheers,
Woody
_______________________________________________
rules-users mailing list
rules-users(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users