# From Reinforcement Learning to Reality: Generating Structured Text Logic Controller

Dimitri Renard, Ramla Saddem, David Annebicque, Mathieu Roisin, Bernard Riera

► To cite this version:

Dimitri Renard, Ramla Saddem, David Annebicque, Mathieu Roisin, Bernard Riera. From Reinforcement Learning to Reality: Generating Structured Text Logic Controller. 2024 10th International Conference on Control, Decision and Information Technologies (CoDIT), Jul 2024, Vallette, France. pp.1269-1274, 10.1109/CoDIT62066.2024.10708353. hal-04745723

HAL Id: hal-04745723

https://hal.science/hal-04745723v1

Submitted on 30 Apr 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
# From Reinforcement Learning to Reality: Generating Structured Text Logic Controller

Dimitri Renard, Ramla Saddem, David Annebicque, Mathieu Roisin, Bernard Riera

**Abstract**— This paper proposes a novel approach that combines Reinforcement Learning (RL) and IEC 61131-3 Programming Logic Controller (PLC) standards for generating logic controllers. We present a proof of concept to demonstrate the feasibility of this hybrid methodology, which could be implemented in a PLC environment.

**Keywords**—Reinforcement Learning, PLC, IEC 61131-3, DES

## I. INTRODUCTION

The manufacturing industry is facing a significant challenge: decarbonizing production while maintaining or even increasing efficiency and quality. Industry 4.0 technologies, such as data collection and advanced analytics, offer new opportunities to address this challenge. However, simply adding these technologies is not enough; existing methods and practices must also evolve. In particular, the design of control systems must be reconsidered to accommodate the complex and dynamic nature of Industry 4.0 production processes. Creating flexible logic controllers for these systems can be a time-consuming and costly endeavor. Fortunately, Artificial Intelligence (AI) provides a promising solution to simplify and automate this process. This paper presents an innovative methodology for automatically generating ST logic controllers using RL algorithms, from design to deployment in a PLC using Structured Text (ST) IEC 61131-3 language. Our methodology encompasses all stages of the controller design and implementation process, from initial design to actual implementation. By leveraging AI and RL, we can automate the complex and time-consuming task of creating flexible logic controllers, leading to increased efficiency and improved quality in manufacturing processes.

## II. STATE OF ART

In this section, we provide a concise overview of RL and logic controller design, which are fundamental concepts leveraged in the methodology presented later. By introducing these fundamental notions, we aim to give the reader a solid understanding of the underlying principles and the methodology goal.

D. R. Author is with Prosyst and the University of Reims Champagne-Ardenne, Reims, 51100 FR (corresponding author to provide e-mail: dimitri.renard@univ-reims.fr).

R. S., D. A., M. R., and B. R. Authors are with the University of Reims Champagne-Ardenne, Reims, 51100 FR.

### A. Reinforcement Learning

RL is a subfield of AI that allows agents to learn autonomously, optimal decision-making in complex environments through interaction and exploration. The agent receives a reward for each action that brings it closer to its goal. So the agent gradually learns to adopt the best strategy to achieve it [1]. Two main categories of RL methods exist: value-based and policy-based.

Value-based methods, such as Q-learning [2], Double Q-learning [3], and SARSA, estimate a value for each state-action pair and subsequently derive a policy from these values. In contrast, policy-based methods, such as Evolutionary Strategies, directly learn the policy, which represents the probability of selecting each action in each state, without the intermediate step of value estimation.

### B. Logic Controller Design

Designing logic controllers is a complex task that requires great rigor. Indeed, malfunctions of controlled systems can be dangerous for operators and the environment. This is why it is essential to apply rigorous and proven design methodologies [4] to ensure the safety and reliability of control systems. The Evaluation Assurance Level (EAL) ISO 15408 [5] standard, provides a recognized framework for evaluating the security of critical applications. The use of verification methodologies, whether semiformal or formal, is even more crucial in the context of Industry 4.0, where flexibility, adaptability, and monitoring of control systems are major requirements [6]. The advent of Digital Twins and the integration of AI models into control systems further reinforce the need for a methodical and rigorous approach to design them.

### C. Reinforcement Learning and Logic Controller

Research on leveraging AI algorithms for logic controller generation is still in its early stages [7]. Studies have explored the use of AI for energy optimization [8]. Jaensch's work utilizes virtual commissioning as a shop floor (PO) simulation to achieve flow optimization [9], [10]. Additionally, there is an emphasis on decomposing systems to reduce each subsystem learning complexity. Zinn's work focuses on generating the controller with an abstraction of actions to simplify the learning phase [11]. A review of existing AI approaches for Discrete Event Systems (DES) planning and control reveals a promising research area [12]. However, none of these studies propose a general definition of the state, and none demonstrate a concrete implementation up to the PLC code level. By continuing to explore the potential of AI-based logic controller generation, we can unlock new possibilities for complex systems optimization and control.
### III. CONCEPT

Designing logic controllers is a challenging and expensive task when done by humans. However, it is also challenging for AI if the problem is tackled head-on. This section aims to present the tricks used in our reinforcement learning-based control design methodology to achieve an implementable logic controller and counter the combinatorial explosion.

#### A. Reinforcement Learning for logic controller

To perform reinforcement learning of a logic controller, we need to define an environment, states, actions, and rewards.

The learning environment is a simulation of the operating part of the real system to be controlled. Simulation enables us to obtain an environment that can be reset and accelerated without security problems. By connecting directly to the simulation, this architecture eliminates the need for an intermediary database and facilitates the retrieval of training data in a streamlined manner.

The state of the system is defined in the literature as the inputs and outputs of the system. However, this way of defining the state of the system leads to a combinatorial explosion. We therefore propose to break down the system into operative tasks as defined [13]. An operative task cannot be stopped by another task. The state we propose is composed of the condition and the initial step of each task [IC₁, IS₁, IC₂, IS₂, ..., ICₙ, ISₙ]. This definition of the state reduces the complexity of learning and makes it more efficient. Moreover, this state definition is inherently generic, applicable to any system structured into operational tasks.

Thus, reinforcement learning aims to activate the optimal task according to the system state. Task permissions are our agent-controllable actions. The addition of the waiting task compensates the task temporal dimension and therefore the potential voluntary waiting required for the system to function. This task is therefore an action that can be chosen by the agent. Its initial condition is set such that another task is allowable in the state. Thus, the waiting task is voluntary and not coerced. It is terminated either by a change of state, by a timeout or when no other task is activated. This task is only implemented for the learning phase.

The reward is harder to define to obtain optimal learning. The task of conducting the final operation must be highly rewarded. Tasks that, by definition, perform a value-based task can have an intermediate reward to facilitate learning. Other tasks are considered expensive and are therefore associated with a negative reward. This way of defining reward is empirical, but simple for human understanding. As a result, the classification of tasks is easy to automation engineer.

Fig. 1 shows how we have designed the learning phase for the logic controller problem. We have a part which chooses a task for each automaton cycle and another which waits for the end of a task to carry out the learning with its start state and its end state.

<figure><img src="image_2.png" /><figcaption>Fig. 1. Reinforcement learning for logic controller</figcaption></figure>

#### B. Limitation of combinatorial explosion

One of the problems of reinforcement learning is its combinatorial explosion. This happens very quickly with the number of actions possible simultaneously. To limit this combinatorial explosion, we use a single task authorization per state. However, simultaneous tasks are not excluded. However, the tasks will have been authorized individually on two different (potentially consecutive) PLC cycles.

To further limit the combinatorial explosion, a logic filter is used upstream of the agent's choice of action. It allows you to filter out tasks that do not have the initial condition or state active. It also allows you to define parallel execution incompatibilities between tasks. This is simplified by authorizing only one task per PLC cycle. This is because it eliminates concurrent execution constraints. Thus, the agent chosen from an action list can be allowed in the state and not the entire action space. It is quite easy to create this filter because it consists for each task of an equation composed of logic ANDs between the condition and the initial state of the task, as well as the initial states of incompatible tasks. It corresponds to only simple constraints, as defined in [14]. It is currently defined manually but could be automated using simulations.

#### C. Deployment in PLC

To be able to deterministically deploy the policy learned by the agent in the PLC, we go through two pre-processing steps. The first treatment is the transition of the policy to a table where, for each state seen in the learning phase, an action is associated (not allowing anything is an action). Unseen states default to the action of not executing anything. Thus, they do not need to be defined. States seen in the learning phase with a learned action of not allowing anything could be eliminated from the implemented table. However, from a diagnostic perspective, it seems interesting to keep them to differentiate between known and unknown states.

The second processing performed in offline mode is table sorting in ascending order of state. Thus, a binary search is possible. The binary search algorithm has been implemented as a function in ST. The status/action table is divided into two tables: one state and one action. To simplify code reuse, the binary search function that
dynamically manages various table sizes. This flexible approach makes it easier to reuse the function block across multiple applications or system operating modes, reducing code duplication, and improving maintainability.

Fig. 2 illustrates the algorithm implemented within the PLC. The system's state is directly derived from the tasks' information. The state is then used to search the state-action table and retrieve the corresponding action. This action translates to a task authorization, which undergoes a safety check by the filter before being activated. This algorithm is executed during each PLC cycle.

<figure><img src="image_3.png" /><figcaption>Fig. 2. Flowchart command by state</figcaption></figure>

The code for each task is implemented in the PLC in the same way as that used in the training phase (Out of transcription of semantics, e.g., “=” to “:=”). It is therefore possible to automate this transcription task to prevent any human errors.

The logic filter is also implemented in the PLC program. In this phase, it becomes a security. The table learned and implemented respects the filter conditions for any state. However, a cyberattack can occur on the table. The filter is used to ensure that a task authorized by the table is in its initial state, in its initial condition, and non-parallel compatible tasks are not running.

## IV. PROOF OF CONCEPT

This section is a proof of concept to show in more detail how the proposed methodology works, as well as to demonstrate its effectiveness and current limitations.

### A. Study system

To carry out this proof of concept, we use the Factory IO operative part simulator. It allows you to intuitively create manufacturing systems from a library of predefined components. It is a simulator dedicated to research and pedagogical activities [15].

The study system consists of two feed conveyors, an evacuation conveyor, and a robot (Fig. 3). The order purpose is to evacuate parts. The system is broken down into 13 operational tasks TABLE 1. The supply (via a generation) of parts is random. The 4 possible robot

positions are numbered on Fig. 3. The parts must be conveyed in position 1 and 3, be picked up by the robot and placed in position 2 to be evacuated.

<figure><img src="image_4.png" /><figcaption>Fig. 3. Study system</figcaption></figure>

<figure><img src="image_5.png" /><figcaption>TABLE 1: DESCRIPTION TASKS</figcaption></figure>

<table><thead><tr><td>Task</td><td>Component</td><td>Description</td><td>Non-parallel compatible tasks</td></tr></thead><tbody><tr><td>T1</td><td>Feeding Conveyor 1</td><td>Feed part to position 1</td><td>T12</td></tr><tr><td>T2</td><td>Feeding Conveyor 2</td><td>Feed part to position 3</td><td>T13</td></tr><tr><td>T3</td><td>Robot</td><td>Rotation without part 0 to 1</td><td>T6</td></tr><tr><td>T4</td><td>Robot</td><td>Rotation with part 1 to 2</td><td>T12</td></tr><tr><td>T5</td><td>Robot</td><td>Deposit part</td><td>T8, T9, T10, T11</td></tr><tr><td>T6</td><td>Robot</td><td>Rotation without part 0 to 3</td><td>T3</td></tr><tr><td>T7</td><td>Robot</td><td>Rotation with part 3 to 2</td><td>T8, T13</td></tr><tr><td>T8</td><td>Robot</td><td>Rotation without part 2 to 0</td><td>T5, T7, T10, T11</td></tr><tr><td>T9</td><td>Output Conveyor</td><td>Evacuate part</td><td>T5</td></tr><tr><td>T10</td><td>Robot</td><td>Rotation without part 2 to 1</td><td>T5, T8, T11</td></tr><tr><td>T11</td><td>Robot</td><td>Rotation without part 2 to 3</td><td>T5, T8, T10</td></tr><tr><td>T12</td><td>Robot</td><td>Take a part in position 1</td><td>T1, T4, T8</td></tr><tr><td>T13</td><td>Robot</td><td>Take a part in position 3</td><td>T2, T7, T8</td></tr></tbody></table>
## B. Learning

To conduct the learning phase, we chose Python, a programming language that offers a wide range of libraries in AI field.

The learning algorithm we used to train the logic controller is Double Q-Learning. Its particularity compared to Q-Learning is the parallel learning of two tables to approximate the next state value via an independent experience. Each table represents an independent experiment. To fully understand and adapt it to our needs, we reimplemented the algorithm in Python. Action (task) choice as well as learning way have not been modified.

A key difference in our learning approach is that we defer Q-table updates until task completion, while allowing concurrent task execution. For each authorized task, the initial state is recorded. Upon task completion, learning occurs between the initial and final states of that specific task. However, other tasks have potentially been authorized or have been completed and thus have modified the system state. The learning flow are shown in the Fig. 4.

<figure><img src="image_6.png" /><figcaption>Fig. 4. Learning Flow</figcaption></figure>

For training on our system, hyperparameters have been defined empirically. The generated order was for 25 episodes of 10 parts to be evacuated. The simulation is set up to generate 5 parts per feed conveyor. Thus, the system will necessarily end up if a conveyor is no longer powered. So, learning will see more states. The time required for this learning was 26 minutes.

Factors $\alpha_t$ and $\epsilon$ change with the number of passes in the state $n(state)$ or choosing an action in a state $n_t(state, action)$ as proposed in [3]. More the state is known, less exploration there is. More an action has been performed in one state, less the training is considered for the next state. The hyperparameters used for this training are listed in TABLE 2.

<table><caption>TABLE 2: DOUBLE Q-LEARNING HYPERPARAMETER USED</caption><thead><tr><td>Parameter</td><td>Value</td></tr></thead><tbody><tr><td>$Q_0$<br>(Initial value of the Q-tables)</td><td>0</td></tr><tr><td>$\alpha_t(state, action)$<br>(Learning rate)</td><td>$\frac{1}{n_t(state, action)^{0.8}}$</td></tr><tr><td>$\gamma$<br>(Discount-Rate Parameter)</td><td>0.97</td></tr><tr><td>$\epsilon$<br>(probability of taking a random action)</td><td>$\frac{1}{\sqrt{n(state)}}$</td></tr></tbody></table>

In order to keep up with learning evolution, as shown in Fig. 5, and carry out many tests to design this approach and move towards a better definition of hyperparameters, we used Optuna library with its dashboard functions [16]. The first episode of the apprenticeship successfully evacuated the 10 parts, with an average of 10.8 tasks per part (t/p). The most effective episode is the 20th, with 7.4 t/p. The last episode returns an average of 7.8 t/p.

<figure><img src="image_7.png" /><figcaption>Fig. 5. Tracking the evolution of the number of tasks performed per part during training</figcaption></figure>

## C. Deployment

This section presents the actual implementation of the model learned in the previous section within the PLC.

The algorithm used for learning is Double Q-Learning with two Q-tables. To transform the obtained tables into a single state-action table, we perform the matrix addition of the two Q-tables. For each state, the action with the maximum value is selected, as shown in Fig. 6, because it is the action that is predicted to have the highest expected reward.

The generated table in this proof of concept contains 236 states. These 236 states represent the states encountered during learning. These are states where at least one task was executable or is a task completion state. The table is automatically sorted in ascending order of states at the learning end. The result to be implemented in the PLC for this use case is a table of 236 states and their associated action.
<figure><img src="image_8.png" /></figure>

One line per state seen in the learning phase

<caption>Fig. 6. Q-table transformation</caption>

To facilitate the reconfigurability of the system by deploying a new table in the PLC, we have developed an automatic generation application for the transcription of the table into a Data Blocks. This allows the Data Block to be imported into the automation project with two clicks, without any human transcription errors. This makes it easy to add or modify a control table in the PLC project after the learning phase.

The program implemented in the PLC is available on GitHub. The program is structured as follows:

* Initial step actualization:

For each PLC cycle, the Initial step value of each task is updated. This value is stored in the task object for easier readability of the PLC code.

* Initial condition actualization:

For each PLC cycle, there is also an update of each initial task condition value.

* State vector creation:

The state vector must be constructed, like in the learning phase. By applying this algorithm to the state, we clearly refund the initial conditions and states of each task.

* State lookup in the table:

The binary search algorithm is encapsulated in a Function Block.

* Authorize the task corresponding to the state:

All the authorizations are forced to be false, and the action corresponding to the state is pre-authorized.

* Logic filter:

The logic filter used to facilitate the learning is also implemented to guarantee safety. It is easily understandable by a human. It issues the task authorization. In the implemented case, AUTf no longer represents the product of the task's IS and IC. Instead, it signifies the pre-authorization state.

* Task programs:

All the separate task programs have been implemented. The first transition is composed of the task initial state, the task initial condition and the task authorization. IS and IC are implemented in the PLC to assure the security, as does the filter. Task 1 has 4 variables. Variables X10 and X11 are the states, and variables FTX10 and FTX11 are the transitions for the Task 1.

## D. Generated command

The generated command allows parts evacuation from the two feeding conveyors (show Fig. 7). This state-based approach offers a significant advantage: it eliminates the need for a complex initialization process. Instead, the controller dynamically selects the optimal action based on the system's real-time state stored in its control table. This method allows for a non-critical system stoppage by simply preventing the controller from initiating new tasks. Upon system restart, the initial conditions determine the system's state (i.e., no tasks are running) and, consequently, authorize the task corresponding to that state, permitting the system to resume operation.

<figure><img src="image_9.png" /><figcaption>Fig. 7. System control by the learned command</figcaption></figure>

## V. DISCUSSION

The state defined in this methodology could be useful in the context of a Digital Twin service. To achieve this, the creation of a buffer in the PLC seems necessary to be able to transmit all state transitions to the Digital Twin. In this way, an unknown state can be detected, which can make it easier to understand the fault. Exploiting the state defined by these tasks is a promising research avenue.

Hyperparameters and rewards definitions for reinforcement learning are difficult to optimize. The values used therefore remain empirical. The solution obtained by learning after an infinite number of passes through each state-action pair is theoretically the optimal policy. However, this depends on the objective and, therefore, the rewards. The search for a rigorous methodology to define hyperparameters and rewards seems necessary to be implemented in the methodology proposed in this article.

Factory IO is suitable for proof-of-concepts and educational applications in a simple and easy-to-use environment. It has limitations on time acceleration and can only be instantiated once per machine. More expensive and complex field-level simulators will be more appropriate for industrializing the proposed methodology for logic controller synthesis.

The logic controller, presented in this article, is not entirely generated by AI. In our case, an automation engineer creates the tasks. The tasks are developed independently of each other, which facilitates the automation engineer's work. However, AI could also perform the constraints definition or the operative tasks' creation. Operative tasks limit the perimeter and thus limit the number of actuators and sensors. A definition of the state based on its elements may be conceivable.
# VI. CONCLUSION

In conclusion, this paper presents an innovative methodology for logic controllers design using reinforcement learning. Our approach, based on the decomposition into operative tasks and the logic filter use, significantly reduces learning process complexity. The proof-of-concept demonstrates the viability of the methodology and its concrete applicability in a PLC. This work opens the way for new research and applications in the field of logic controller synthesis. The application of the methodology to more complex systems and its possibilities for advanced monitoring are promising prospects for the future.

# DATA AVAILABILITY STATEMENT

PLC code and Factory IO simulation scene are available on: https://github.com/DimitriRenard/RL-ST-Logic-Controller

# ACKNOWLEDGMENT

This research and development undertaking is conducted in a context of an industrial and academic collaboration (CIFRE convention) between Prosyst and the CReSTIC laboratory of University of Reims Champagne Ardennes, financed by Prosyst and the National Association of Research and Technology.

# REFERENCES

[1] R. Sutton and A. Barto, *Reinforcement Learning: An Introduction*, 2nd ed. Cambridge, Massachusetts, USA: MIT press, 2018.

[2] C. J. C. H. Watkins and P. Dayan, ‘Q-learning’, *Machine Learning*, vol. 8, no. 3–4, pp. 279–292, 1992, doi: 10.1007/BF00992698.

[3] H. Van Hasselt, ‘Double Q-learning’, in *Advances in Neural Information Processing Systems*, Vancouver, Canada, 2010, pp. 2613–2621.

[4] J. Zaytoon and B. Riera, ‘Synthesis and implementation of logic controllers – A review’, *Annual Reviews in Control*, vol. 43, pp. 152–168, 2017, doi: 10.1016/j.arcontrol.2017.03.004.

[5] ISO, ‘ISO/IEC 15408-1:2022 Information security, cybersecurity and privacy protection’. Geneva, Switzerland, 2022. Accessed: Feb. 15, 2024. [Online]. Available: https://www.iso.org/standard/72891.html

[6] R. Pichard, ‘Contribution à la Commande des Systèmes à Événements Discrets par Filtre Logique’ [Contribution to the Control of discrete event systems by logical filter], PHD thesis, Université de Reims Champagne-Ardenne, Reims, 2018.

[7] A. Boudribila, M.-A. Chadi, A. Tajer, and Z. Boulghasoul, ‘Large Language Models and Adversarial Reinforcement Learning to Automate PLCs Programming: A Preliminary Investigation’, in *2023 9th International Conference on Control, Decision and Information Technologies (CoDIT)*, Rome, Italy: IEEE, 2023, pp. 650–655. doi: 10.1109/CoDIT58514.2023.10284185.

[8] Hang Li, ‘An approach to improve flexible manufacturing systems with machine learning algorithms’, in *IECON 2016 - 42nd Annual Conference of the IEEE Industrial Electronics Society*, Florence, Italy: IEEE, 2016, pp. 54–59. doi: 10.1109/IECON.2016.7793838.

[9] F. Jaensch, A. Csiszar, C. Scheifele, and A. Verl, ‘Digital Twins of Manufacturing Systems as a Base for Machine Learning’, in *2018 25th International Conference on Mechatronics and Machine Vision in Practice (M2VIP)*, Stuttgart: IEEE, 2018, pp. 1–6. doi: 10.1109/M2VIP.2018.8600844.

[10] F. Jaensch, A. Steidle, and A. Verl, ‘Curriculum Multi-Stage Reinforcement Learning for Automated Interlinked Production Systems on Virtual Commissioning Simulations’, in *2021 Third International Conference on Transdisciplinary AI (TransAI)*, Laguna Hills, CA, USA: IEEE, 2021, pp. 129–136. doi: 10.1109/TransAI51903.2021.00031.

[11] J. Zinn, B. Vogel-Heuser, and P. Ockier, ‘Deep Q-learning for the Control of PLC-based Automated Production Systems’, in *2020 IEEE 16th International Conference on Automation Science and Engineering (CASE)*, Hong Kong: IEEE, 2020, pp. 1434–1440. doi: 10.1109/CASE48305.2020.9216863.

[12] M. Kranz, V. Nitsch, and S. Mütze-Niewöhner, ‘Linking Discrete-Event Simulation with Artificial Intelligence: A Literature-Based Analysis of Existing Approaches in the Context of Manufacturing Planning and Control’, in *2023 IEEE International Conference on Industrial Engineering and Engineering Management (IEEM)*, Singapore: IEEE, 2023, pp. 1194–1198. doi: 10.1109/IEEM58616.2023.10406374.

[13] P. Taillard, ‘L’analyse stucturée par tâches’ [Task-based structural analysis], *technologie*, vol. 170, 2010.

[14] R. Coupat, ‘Méthodologie pour les études d’automatisation et la génération automatique de programmes Automates Programmables Industriels sûrs de fonctionnement’ [Methodology for automation studies and for automatic generation of safety Programmable Logic Controller code], PHD thesis, Université de Reims Champagne-Ardenne, Reims, 2014. [Online]. Available: https://www.theses.fr/2014REIMS019

[15] B. Riera and B. Vigário, ‘HOME I/O and FACTORY I/O: a virtual house and a virtual plant for control education’, presented at the IFAC World Congress, Toulouse, France, 2017, pp. 9144–9149. doi: 10.1016/j.ifacol.2017.08.1719.

[16] T. Akiba, S. Sano, T. Yanase, T. Ohta, and M. Koyama, ‘Optuna: A Next-generation Hyperparameter Optimization Framework’, in *Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining*, in KDD ’19. New York, NY, USA: Association for Computing Machinery, 2019, pp. 2623–2631. doi: 10.1145/3292500.3330701.