aaronkurz / hitl-ab-bpm Goto Github PK

Create the first api endpoints for the frontend to fetch data/ BPMN files from the backend. For example:

• the BPMN files of the variants (GET)
• the list of configurable parameters (GET/PUT)
• fetch the proposed execution strategy (GET)
• retrieve the updated execution strategy (PUT)
• display the results (GET)

The question arose in the meeting on 23/11/2021. While running multiple instances at the same time, do instances influence each other in terms of runtime or access to a shared resource. This is more of a research question if such a implementation if possible. If not, we just have to document the limits of our work and make the assumption that instances do not influence each others runtime.

More sophisticated reward function is needed - perhaps implementing the function from the phd paper?

Add the pip install for the Contextual Bandits package + requirements to the docker file.

Three days each week according to the 12 ECTS calculation.

In order to properly setup the prototype locally, the "normal" Camunda engine image must be changed to our own Java application where the simulator plugin is enabled. After finishing this task, let other group members as well as the stakeholders test the implementation.

Get everything development-ready

After successfully starting and terminating a batch of instances via API calls, the history service has to be called to retrieve valuable data from each instance run. If an instance has not been terminated and the history service is called, an error will be thrown. In order to avoid an error and ensure the proper execution, it has be ensured that every instance has terminated before the data is retrieved.

Converting seconds to milliseconds in order to ensure faster execution of the processes / RL environment. This can be done in the BPMN files.

Find out how to assign cost to a task or a function (cost/min) to a task. Offers an additional dimension to compare the variants. This also helps in terms of finding useful parameters for the human expert. Does Camunda allow such definitions and how would you implement/model that.

• Engine
• History Service
• Simulator
• ...

Take a look at https://github.com/david-cortes/contextualbandits. Omar is already taking care of installing the package and requirements in the docker file. Take a look at the example and implement a basic version of the RL env/agent. Most importantly understand how the RL env and agent is set up, which methods are important and how it works. Start with the examples and work your way up from there. The specific method does not matter right now. Define a VERY simple and basic reward function. The focus is on starting the execution of batches of instances from within the RL env and the orchestration of the different components of the prototype.

Linked to #32

Create a conceptual mock up of the frontend which then can be used as a baseline for discussions with the stakeholders. Elements that should be included:

• display of the variants of the business process
• the configurable parameters for the human expert (including batch size)
• Buttons to clear or start the execution with the configured parameters
• the proposed execution strategy
• the result
  Additionally a header or a menu where a link to the documentation could be displayed, convention for creating new business process variants etc, and a link to the GitHub.

Implement the initial policy proposal which is used by default before the human expert configures it. As discussed in the meeting on 23/11/2021 we start if 50/50 and the batch size is determined by the human expert (e. g. n=10). Then 5 instances of variant A and 5 instances of variant B will be started. This require the utility implementation TODO.

Linked to #49

Dependency: #25
In order to properly implement the RL agent, especially the reward function, we need some client of evaluation and monitoring. In the https://github.com/david-cortes/contextualbandits/blob/master/example/policy_evaluation.ipynb, a evaluation example can be found. On top of that, it can be helpful to track the accumulated mean reward. Find out if there is a pre-implemented methods for that or how we would track the reward live (tensor board offers such functionality). This also could be implemented by us. Simply add a list in which the calculated reward is stored and plot it in the end (just an idea).

Get everything development-ready

In order to properly test our implementation we need decently complex business process variants. Start with the examples given in the phd thesis linked in the slack (pilot license). Model these variants and add extensions to each task according to the plugin GitHub: https://github.com/camunda-consulting/camunda-bpm-simulator. Feel free to decide what good time frames, ranges etc. are.

Is your feature request related to a problem? Please describe.
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

Describe the solution you'd like
A clear and concise description of what you want to happen.

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

Additional context
Add any other context or screenshots about the feature request here.

Creates requests for new process definiton instances (not the decision which version).

Probably just a python script.

Due to the nature of a prototype, the BPMN files are not uploaded by the user via the frontend due to the simulator plugin conventions to simulate a business process. Therefore, the BPMN files of the variants are stored in the backend. In order to start an instance, the BPMN files have to be pushed to the Camunda engine first via API calls. Therefore, a method has to be implemented to retrieve a BPMN file (names) from the backend (database).

Pour the API calls from the Jupiter notebook into methods that can be used in the instance router management in order to push a BPMN file to the engine, start instances, and retrieve the data.
#25 #31 #32

Linked to #39

alternatively => parsing bpmn files?

I mean... everyone will have to do it sometime.

It is still open how we store data that we retrieve from the simulations of a variant of the business process. We could simply use log files or tables as a database. It depends on the data we retrieve, how much data we retrieve, how we use the data in the RL environment, and what data we would like to store for later, e. g. historical data, additional key performance indicators (KPIs) to evaluate the decisions of the RL agent makes.

Gradle script etc

See the official announcement on the course page.

"Gelber Zettel" Enrollment form:
https://www.static.tu.berlin/fileadmin/www/10002461/Pruefungsamt/Formulare_Bescheide/Pruefungsanmeldung.pdf

The instance router houses the RL env, utility classes to interact with the Camunda engine via API calls, and utility to store and retrieve data from the backend database. When the action of the RL agent is initiated (an action is chosen), multiple utility methods have to be called in order to properly interact with the Camunda engine that simulates each instance. After the simulation of each instance has terminated, the data has to be retrieved, stored, and processed (batch: calculate the mean) before it is fed back to the RL env which then calculates the reward. For every action the RL agent, this loop has to be cleanly implemented and executed. Therefore some form of management is required to execute the methods accordingly and guarantee the correctness.
The goal is one simple method call within the RL env that handles the above mentioned requirements. Maybe multithreading is required to synchronize the environments.