[rules-users] Coarse Grained Moves
Geoffrey De Smet
ge0ffrey.spam at gmail.com
Fri Jun 27 08:14:13 EDT 2014
Look at MoveIteratorFactory, that allows you to select those moves JIT
(so without creating all of them like in MoveListFactory).
Also see JUST_IN_TIME vs caching explanation in docs.
Let's continue further questions/discussions on the new mailing list
http://www.optaplanner.org/community/forum.html
hth
On 27-06-14 14:05, DwProd . wrote:
> Thanks a lot, yeah nearBySelection is probably what I would need, too
> bad it's not out yet :(
>
> As for the custom MoveListFactory, I found out what I'm trying to do
> has an off the charts complexity. It basically has to find all subsets
> of planning variables of a given size (combinations with repetition)
> which is the number of entities I want to move at once... Worst case
> has a complexity of something like O(4^n/sqrt(pi n))... It gets
> unmanagable pretty soon unfortunately.
>
> I'm not sure what I'll be doing but it seems like I'll have to do
> without those constraints at first... Thanks again for your help however !
>
> Best regards,
>
> Woody
>
>
> 2014-06-25 13:18 GMT+02:00 Geoffrey De Smet <ge0ffrey.spam at gmail.com
> <mailto:ge0ffrey.spam at gmail.com>>:
>
>
> On 25-06-14 12:58, DwProd . wrote:
>> Thanks a lot for your answer !
>>
>> 1) I don't think pillar based moves are what I'm looking for,
>> except if I can select a pillar based on a Problem Fact (its
>> service in my case) and then spread the different entities of the
>> pillar on the available hosts (basically setting possibly
>> different planning variables for the entities of the pillar).
>>
>> 2) cartesianProductMoveSelector seem more like it, but the number
>> of moves to combine is somewhat static is it not ? I can't for
>> instance specify in a Planning Entity (using a property) that its
>> move should be combined with n other moves of processes of the
>> same type ?
> That would be nearBySelection... (note: the name might change
> before I implement).
> You need to be able to tell optaplanner that processes of the same
> type are "near" (~related) to each other and should be moved together.
> As stated before, I am working on this for 6.2.
>
>>
>> 3) I feel like my usecase is complicated enough to have to resort
>> to that if there is no built in way to handle it... Does this
>> work by implementing a MoveListFactory, or a CompositeMove ? I
>> don't think I quite get the difference to be honest...
> If you write a custom MoveListFactory (or MoveIteratorFactory),
> you could still opt to go with the build-in moves (such as
> ChangeMove) or combinations of those with CompositeMove. However,
> because those build-in moves require reflection stuff
> (VariableDescriptor etc), it's probably easier to just to write a
> domain-specific Move.
> See the examples that have custom moves.
>
>>
>> Thanks again for your time,
>>
>> Cheers,
>>
>> Woody
>>
>>
>> 2014-06-25 9:37 GMT+02:00 Geoffrey De Smet
>> <ge0ffrey.spam at gmail.com <mailto:ge0ffrey.spam at gmail.com>>:
>>
>> 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).
>> http://docs.jboss.org/drools/release/latest/optaplanner-docs/html_single/index.html#pillarChangeMoveSelector
>> 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 at lists.jboss.org <mailto:rules-users at lists.jboss.org>
>>> https://lists.jboss.org/mailman/listinfo/rules-users
>>
>>
>> _______________________________________________
>> rules-users mailing list
>> rules-users at lists.jboss.org <mailto:rules-users at lists.jboss.org>
>> https://lists.jboss.org/mailman/listinfo/rules-users
>>
>>
>>
>>
>> _______________________________________________
>> rules-users mailing list
>> rules-users at lists.jboss.org <mailto:rules-users at lists.jboss.org>
>> https://lists.jboss.org/mailman/listinfo/rules-users
>
>
> _______________________________________________
> rules-users mailing list
> rules-users at lists.jboss.org <mailto:rules-users at lists.jboss.org>
> https://lists.jboss.org/mailman/listinfo/rules-users
>
>
>
>
> _______________________________________________
> rules-users mailing list
> rules-users at lists.jboss.org
> https://lists.jboss.org/mailman/listinfo/rules-users
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.jboss.org/pipermail/rules-users/attachments/20140627/539f7d0d/attachment-0001.html
More information about the rules-users
mailing list