DRL | Repository for codes of 'Deep Reinforcement Learning | Reinforcement Learning library

There is a task assigning example in the optaplanner-examples module, which shows how to model such a problem. The main idea is that every task points to the next task and to the previous task or the worker. The worker is the first element of such a chain. In this example, one of the goals is to minimize the makespan; your soft constraint about location sounds very similar - instead of penalizing for the amount of time required to complete all the tasks by a single worker, it would focus on the distance between locations associated with each task.

TensorFlow has 2 execution modes: eager execution, and graph mode. TensorFlow default behavior, since version 2, is to default to eager execution. Eager execution is great as it enables you to write code close to how you would write standard python. It's easier to write, and it's easier to debug. Unfortunately, it's really not as fast as graph mode.

So the idea is, once the function is prototyped in eager mode, to make TensorFlow execute it in graph mode. For that you can use tf.function. tf.function compiles a callable into a TensorFlow graph. Once the function is compiled into a graph, the performance gain is usually quite important. The recommended approach when developing in TensorFlow is the following:

• Debug in eager mode, then decorate with @tf.function.
• Don't rely on Python side effects like object mutation or list appends.
• tf.function works best with TensorFlow ops; NumPy and Python calls are converted to constants.

I would add: think about the critical parts of your program, and which ones should be converted first into graph mode. It's usually the parts where you call a model to get a result. It's where you will see the best improvements.

You can find more information in the following guides:

• Better performance with tf.function
• Introduction to graphs and tf.function

So, there are at least two things you can change in your code to make it run quite faster:

1. The first one is to not use model.predict on a small amount of data. The function is made to work on a huge dataset or on a generator. (See this comment on Github). Instead, you should call the model directly, and for performance enhancement, you can wrap the call to the model in a tf.function.

Model.predict is a top-level API designed for batch-predicting outside of any loops, with the fully-features of the Keras APIs.

1. The second one is to make your training step a separate function, and to decorate that function with @tf.function.

So, I would declare the following things before your training loop:

It goes in the RuleSet area of the decision table definition.

From the docs:

16.7.2.1. RuleSet definitions

Entries in the RuleSet area of a decision table define DRL constructs and rule attributes that you want to apply to all rules in a package (not only in the spreadsheet). Entries must be in a vertically stacked sequence of cell pairs, where the first cell contains a label and the cell to the right contains the value. A decision table spreadsheet can have only one RuleSet area.

The following table lists the supported labels and values for RuleSet definitions:

Label Value Usage EscapeQuotes true or false. If true, then quotation marks are escaped so that they appear literally in the DRL. Optional, at most once. If omitted, quotation marks are escaped.

For future reference, you should be referencing the official documentation and not random sites on the internet. The Drools folks have amazingly good documentation compared to some other libraries, and the library is actively enough developed that by the time a book or blog is published, it's likely out of date or incomplete.

It looks like the contents of any loaded class files also need to be written to the KieFileSystem before compiling.

So to give Drools full access to a class, the following is required:

No, it's not a bug. It's how the feature works.

Calling update is functionally equivalent to calling 'fireRules'. It's as if we exited the current 'fire rules' flow, and then reran all the rules with new data. Since it's a new run, there's no previous executions, so no-loop doesn't apply.

This is in comparison to insert (for example). When you call insert in the RHS of a rule, the engine merely re-evaluates subsequent rules in the current run. In this case, 'no-loop' does apply, because we're still in the same run, and the previous executions remain.

no-loop is intended to keep the same rule from firing more than once in a single execution of the rules. It's not intended to keep the rule from firing across multiple executions.

To make your rule not fire on update, you need to modify your left hand side to exclude the condition that is set on the right hand side. Since you've omitted your definition of the setIsolateCSIFlag function, I'll make up a simple example instead:

Pessimistic locking is implemented only in JBPM see here

There's no such functionality in Drools persistence, SessionInfo will always use OptimisticLocking based on JPA's @Version annotation.

If you need such feature, please file a feature request on Drools' Jira

Change your rules rely on exclusive conditions.

Simple example. Let's say we have an application dealing with calendar events. We have a rule flow for public holidays. We have a rule flow for religious holidays. There are some religious holidays which are also public holidays; for these we only want to fire the public holiday rules.

The answer is yes. In 7.10, deploy a container with your DRL rule(s) and then access the KIE Server Execution Docs (i.e. http://localhost:8080/kie-server/docs/).

Then, navigate to the "KIE Session Assets" and POST to /server/containers/instances/{containerId}.

Enter your container ID (i.e. rules_1.0.0-SNAPSHOT)

And here's an example body:

Just java.lang.IllegalStateException: There is an error in a scoreDrl or scoreDrlFile. really isn't usefull indeed. Normally that should have a chained exception to that exception with the actual line number.

Is there no actual stacktrace? Here's what I get if I run spring-boot-school-timetabling with an invalid constraints.drl: