Generative Adversarial Framework with Composite Discriminator for Organization and Process Modelling—Smart City Cases

Highlights

• What are the main findings?
  • We successfully apply generative AI techniques (in particular, generative adversarial modeling) to speed up and streamline the development of organizational structures and processes, which is demanded in volatile smart city environments.
  • We demonstrate the developed idea of the original composite discriminator, taking advantage of separate evaluation of tacit and explicit domain knowledge on smart city related scenarios, namely logistics system model generation and smart tourist trip booking process model generation
  • We show that the developed mechanism of generating and using meaningful augmentations enables learning on limited datasets.
• What is the implication of the main finding?
  • The developed approach offers an effective solution for the fast generation of organizational structures and process models, accounting for both tacit and explicit requirements and constraints.
  • By automating the creation of organization structures and processes, the approach can contribute to the adaptability of smart city structures and processes and their fast adaptation to changing requirements.
  • The approach can be applied to other domains and could be a starting point for research efforts in related scientific fields.

Abstract

Smart city operation assumes dynamic infrastructure in various aspects. However, organization and process modelling require domain expertise and significant efforts from modelers. As a result, such processes are still not well supported by IT systems and still mostly remain manual tasks. Today, machine learning technologies are capable of performing various tasks including those that have normally been associated with people; for example, tasks that require creativeness and expertise. Generative adversarial networks (GANs) are a good example of this phenomenon. This paper proposes an approach to generating organizational and process models using a GAN. The proposed GAN architecture takes into account both tacit expert knowledge encoded in the training set sample models and the symbolic knowledge (rules and algebraic constraints) that is an essential part of such models. It also pays separate attention to differentiable functional constraints, since learning those just from samples is not efficient. The approach is illustrated via examples of logistic system modelling and smart tourist trip booking process modelling. The developed framework is implemented in a publicly available open-source library that can potentially be used by developers of modelling software.

1. Introduction

The paradigm of smart cities assumes an increasing level of citizens’ comfort, often achieved via the usage of modern information and communication technologies [1,2]. This is done in various aspects of human life: from sustainability and urban planning to mobility and services [3,4,5,6]. Solutions supporting smart city operation do not only improve the citizens’ experience but also require faster and more efficient decision making in modeling, planning, and management [7,8].

The task of organization and process modelling is complicated due to the variety of interconnections influencing each other, the presence of numerous functional dependencies, and by the presence of the human factor, which causes the emergence of hardly specifiable social connections, which need to be taken into account during modelling [9,10,11]. It also requires domain expertise and significant efforts from modelers. As a result, such processes are still not well supported by IT systems and still mostly remain manual tasks.

It is not always reasonable or even possible to solve this task by using exclusively analytical approaches due to the high variety of connections. The same applies to the application of exclusively machine learning (ML) models trained using the previous experience of experts due to the low efficiency of identifying functional dependencies from examples. Thus, for their effective modelling, it is necessary to ensure (a) model representation, taking into account the variety of relations and the complexity of their topology, and (b) accounting for factors of different mathematical nature, including the experience of experts as well as strict constraints imposed on various parameters, described in the form of equations or table functions. The aim of this paper is to solve these tasks.

To solve task (a), this paper contributes by considering the modelled systems from the point of view of “System of Systems (SoS) Engineering” as multi-level and requiring configuration both at the level of the entire system and at the level of its components. Moreover, it applies the representation of the modelled system in the form of multilevel graphs with typified nodes and edges, both at the level of the entire system and at the level of the components.

One of the powerful techniques for approximating artifacts using (typically) deep learning is generative adversarial modeling. According to this technique, a pair of models is created, such that one model (the generator) tries to learn patterns in the training set samples and apply those to the input noise and the other one learns to distinguish generated samples from those in the training set.

To solve problem (b), this paper contributes by proposing an approach based on the development of a composite discriminator (additionally taking into account symbolic rules) for training a generative neural network [12,13,14,15,16,17].

The scientific novelty of the presented approach is threefold. First, we propose to apply generative AI techniques (in particular, generative adversarial modeling), taking into account both tacit and explicit knowledge to speed up and streamline the development of organizational structures and processes, which is demanded in volatile smart city environments. Second, we introduce the idea of the original composite discriminator taking advantage of a separate evaluation of the similarity of the generated sample to the training ones, meeting structural and algebraic constraints and meeting differentiable constraints, which improves the learning speed of the generator. Third, the proposed mechanism is capable of generating and using meaningful augmentations that enable learning on limited datasets.

The reminder of this paper is structured as follows. Section 2 presents the state of the art in the areas of decision support for modelling and generative adversarial networks. The approach is outlined in Section 3, followed by the presentation of the algorithms used (Section 4), experimentation results (Section 5), and details of the programming library implementation (Section 6). The limitations of the proposed approach are discussed in the Discussion section (Section 7). The main results are summarized in the Conclusions (Section 8).

2. Related Works

2.1. Decision Support in Organization and Process Modelling

Today, decision support in the area of organization and process modelling is in demand, since in addition to the creative component, such process includes tasks related to the analysis of existing solutions for possible reuse, which can be very time-consuming. Existing research aimed at assisting the modeler is at the intersection of recommendation systems (DC) and conceptual design.

There are a limited number of methods and prototypes designed to support the modeler’s work. For example, there are approaches focused on the automatic completion of an unfinished model. These approaches were mainly developed in the context of business process modeling and focus on various helper functions, such as facilitating the completion of a partially built model by, for example, presenting relevant fragments of already existing models [18], using pattern-based knowledge for completion [19], or other autofill mechanisms [20] that function by adding the necessary information to implement the model [21] or provide assistance in applying modeling syntax [22].

Another form of recommendation-based support is suggestions for specific modeling actions, also called auto-completion [23]. Work in this area, based on the artificial intelligence paradigm, is currently regarded as very promising [24].

Finally, there are approaches designed to improve the quality of the model [25] or providing information support in a specific subject area in the case of modelling, when certain constraints must be met [26] or when support is required for model changes.

Recently, the introduction of machine learning, for example for parameter determination within a recommendation system, has also been discussed as a future area of research [26].

The idea of using machine learning (which is basically looking for implicit patterns) to support modeling tasks came from using manual or semi-automated template libraries. For example, in [27], the usage of templates is considered an important feature of enterprise modeling tools in today’s era of digitalization. Awadid et al. [28] propose a complex system of organizing patterns with an assessment of their consistency, and Khider et al. [29]—a system of recommendations for specific patterns or known patterns. The effectiveness and prospects of using templates in enterprise modeling are also emphasized in [30]. The need to balance between flexibility/variety of patterns and the number of patterns to be analyzed manually is highlighted in [31], which proposes to expand the patterns to the concept of a set (“bag”) of fragments (bag of fragments), which are compared with the current model. It can be said that this work serves as a kind of link between the use of templates and machine learning methods. To solve this problem, machine learning methods can be useful, allowing one to both identify patterns by analyzing and summarizing existing big data and to select and offer them to the user depending on the situation (generate suggestions to extend the model or generate an entire model).

All of the above approaches are mainly based on the use of predefined templates, which, on the one hand, makes the modeling process more reliable and predictable but, on the other hand, less flexible and creative. The use of generative design based on machine learning methods is intended to eliminate this limitation.

Today, there already exist machine learning models, including those based on deep neural networks, which are focused on working with network structures and, in particular, with graphs. Jangda et al. [32] propose a method for representing the graph in a form suitable for use in machine learning models and supporting parallelization of the training process for the efficient use of GPUs in order to increase the speed and performance of the training process. Valera et al. [33] use the random forest machine learning paradigm to analyze the main flows in the transport network, representing the latter in the form of a graph. Such models are often successfully used in chemistry today. Chen et al. [34] use the graph to represent chemical compounds to use machine learning techniques to generalize and predict their properties. A similar task has been solved in [35], but using machine learning methods. Nielsen et al. [36] apply machine learning to simulate processes with physical particles.

2.2. Application of Neural Networks to Organization and Process Modelling

One of the typical ways of representing organization or process models is using various network (graph) structures (most modeling techniques are based on using a number of connectivity diagrams—e.g., BPMN and IDEF3). Nodes in these network structures correspond to elements of the model (depending on the type of the model), while connections reflect connections between the elements (dependencies, material and information flows, etc.) There are a number of papers in which Generative Adversarial Networks (GANs) are adapted to work with graph data (and, therefore, can potentially be applied to organization and process models).

A large category of network (graph) GANs are designed for processing one (typically large) graph—e.g., a knowledge graph or user–item relations graph. These approaches, also classified as graph representation, learn and model the local structure of the graph and can be used for link prediction [37,38,39].

Another category of network (graph) GANs are aimed at the generation of whole graphs. These GANs are trained on a set of graphs from a certain domain and learn to generate new graphs from the same domain [40,41,42,43]. Inherently, this setting is closer to the problem considered in this paper. Typically, the generator and discriminator of these GANs are based on graph neural networks (GCN [44], GAT [45], etc.). The idea of conditional GANs (generative models that can accept additional condition/context parameters) has also been adapted to graph GANs [41].

There are also several especially relevant papers where the “classical” GAN structure has been augmented by an additional block aimed at accounting for additional domain-specific requirements. In [46], MolGAN has been proposed—a graph GAN for generating small molecules, so that the generated molecules are evaluated according to several properties. This evaluation is done using special software; however, MolGAN contains an additional approximator neural network (along with the generator and the discriminator) which is also trained in order to create a differentiable representation of the evaluation procedure and streamline the training of the generator while accounting for the domain-specific constraints. The problem of molecule structure generation is also addressed in [47].

There are no existing GANs for organization or process models; however, the existing approaches for labeled graph generation and taking into account domain-specific constraints [46] can be adapted to this scenario.

3. Proposed Approach

We propose to consider a modelled process or system as multi-level and requiring configuration both at the level of the entire system and at the level of its components. Thus, within the framework, first the problem of modelling the whole system is solved, followed by modelling its components.

Since modelled systems or process often must meet a few strict requirements (explicit or parametric, that is, formalized and described in the form of equations or table functions), the use of classical generative algorithms is ineffective, since such dependencies are difficult to learn only from examples. The use of evolutionary or swarm algorithms is also ineffective, since the “hit” of values in the required ones is very unlikely.

On the other hand, the use of only methods based, for example, on the technology of constraint programming will also not be effective since they cannot take into account the non-formalizable knowledge of expert modelers.

Thus, within the framework of this concept, the use of a composite discriminator is proposed, the principle of operation of which is presented in Figure 1 on an example of smart logistics system modelling. A composite discriminator combines methods for checking both parametric patterns (analytically) and tacit knowledge of experts using the classic generative–adversarial pair. Below, some examples of these are presented.

Examples of parametric constraints (that can be fuzzy):

• functional constraint on the number of vehicles for a given volume of deliveries ($V$): $N_v=f\left(V\right)$;
• functional fuzzy constraint on the number of employees for a given supply volume ($V$): $N_d\left(\delta \right)=g\left(V\right)$;
• functional fuzzy constraint of the influence of the leader’s leadership qualities ($Q_i$) on the employee productivity: $N_d\left(\delta \right)=g(V,Q_i)$.

Examples of revealed tacit rules:

• if there is a possibility of a stable social connection, it is reasonable to provide additional control;
• the logistics department usually includes roles of the head of logistics department and driver, as well as the resource vehicle;
• products as a rule require assembly.

The main problem in this scheme is the formulation of the error function that combines the estimates of the neural network and analytical components of the discriminator, since it must convey the degree of compliance of the evaluated generated solution with all constraints. Thus, the formulation of an algorithm for creating and training a composite discriminator that combines the properties of neural network and analytical approaches is a novel scientific result.

An illustration of a generated model is shown in Figure 2. Below, the considered initial data for it are presented:

• possible product configurations;
• the volume of product deliveries per month ($V=500)$;
• functional dependencies for calculating the number of vehicles ($N_v$) and drivers ($N_d$);
• matrices of candidates’ characteristics.

The black arrows in Figure 2 denote formal relationships (information and material flows, hierarchy, etc.). The red arrow and equation reflect the fact that the presence of high leadership qualities of a candidate for the position of head of the logistics department may reduce the number of required drivers, but at the same time the probability of meeting the initial requirements (volume of deliveries) will slightly decrease. The system can also identify a potential social connection between the head of the procurement department and a potential supplier (the green arrow), and to level it, an additional control element “Audit” (shown in green) is added.

4. Algorithms Used

The developed approach is based on the following three algorithms developed by the authors:

• An algorithm of training a generative neural network model with elements of autonomous self-learning through the formation of augmented training data that considers both the experience of experts and parametric patterns (ATGM);
• An algorithm or creation and training a composite discriminator that combines the properties of neural and analytical approaches (ATCD);
• An algorithm of multi-level model generation with a complex topology of connections at the level of the system as a whole and at the level of its components (AMGS).

4.1. The ATGM Algorithm

The ATGM algorithm is based on the following mathematical relations. The inputs to the algorithm are a set of training examples of models ($X^T$), a validator of constraints on the structure and configuration parameters of the models ($\mathsf{\Phi })$, and a method for estimating valid input parameters based on known configuration parameters ($\overline{\mathsf{\Phi }}$) $X^T={\left\{x_i^T\right\}}_{i=1}^t$, where $t$ is the size of the training set and any element $x_i^T$ is a tuple $(N,C,P,Q)$. The elements of the tuple are as follows:

$N\in {\{0,1,..m\}}^n$ is the vector of the elements of the model, where each element corresponds to an element type ($m$ is the number of element types) and their number ($n$ is the maximum allowable number of elements);

$C={\left(C_i\right)}_1^c,\forall i:C_i\in {\left\{\mathrm{0,1}\right\}}^{n\times n}$ are matrices of relationships ($c$ is the number of types of relationships) between the elements of the model;

$P={\mathbb{R}}^{n\times p}$ is a matrix of parameter values of the model’s elements ($p$ is the maximum number of parameters for one element);

$Q\in {\mathbb{R}}^q$ is the vector of “input” parameters ($q$ is the number parameters);

$X^T$ is a set of predefined models (the training set), each element $x_i^T$ of which has a label indicating its validity $b_i^T\in B^T, b_i^T\in \left\{\mathrm{0,1}\right\}$ (0—invalid model and 1—valid model).

Initial data augmentation is performed as follows:

$$C_{ijk}^{\prime }=\left\{\begin{array}{c}\left(C_{ijk}+{\epsilon }_C\right)mod2,N_{ij}\ne 0,N_{ik}\ne 0, \\ 0,\mathrm{o}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{r}\mathrm{w}\mathrm{i}\mathrm{s}\mathrm{e}\end{array}\right., \mathrm{where} {\epsilon }_C=Bernoulli\left(p_i\right)$$

(1)

$$P_{ij}^{\prime }=P_{ij}+{\epsilon }_P, \mathrm{where} {\epsilon }_P=N(0,{\sigma }_j)$$

(2)

To ensure the validity of the augmented models created using the above relations, the feasible input parameters are first selected, $Q_i^{\prime }=\overline{\mathsf{\Phi }}(N,C_i^{\prime },P_i^{\prime })$, and then the resulting model $b_i$= $\mathsf{\Phi }\left(x_i\right), x_i=(N_i,C_i^{\prime },P_i^{\prime },Q_i^{\prime })$ is validated. If $b_i=\mathrm{T}\mathrm{R}\mathrm{U}\mathrm{E}$, the model created through the augmentation is used during the training. For complex tasks, augmentation based on Formulas (1) and (2) can affect only key parameters, which then are used to define the remaining parameters of the model and possible input parameters (as indicated in Figure 3). Definition of key parameters and their dependencies with other parameters are specific for each model.

To ensure that training models received from experts prevail over those created through augmentation, models should be augmented anew at each training epoch.

The training of the generative–adversarial model is carried out in the classical way [48,49,50,51], except for the method of evaluating the generated model and training the discriminator, which are performed according to the ATCD algorithm.

Figure 3 shows a block diagram of the ATGM algorithm. It starts by reading the training dataset. Then, a training cycle is performed, the criterion for the end of which is the achievement of the required accuracy by the generator (exit from the cycle according to the condition “Has the required accuracy been achieved?”). One such cycle of learning corresponds to one epoch.

The next nested loop is the generation of augmented data, which ends with the condition “Enough augmented data?”. As part of this cycle, the following operations are performed:

A random model is selected from the training dataset and augmented according to the ratios mentioned above: a set is formed. Then, its uniqueness is checked. If the resulting model is unique, the input parameters are selected and then validated. Selection of the input parameters is necessary, since the probability of creating a valid model randomly can be very low. If the resulting model is valid, it is saved.

Once a sufficient number of augmented models have been accumulated, a learning cycle (epoch) is performed using the AOCD algorithm.

The second AOCD algorithm is aimed at creating a mechanism that combines the classical (neural network) component to take into account the tacit knowledge of experts embedded in training models with the parametric component to take into account the patterns specified analytically.

This algorithm itself does not implement the functions of strong AI, but it is necessary to ensure the operation of the AOGM algorithm, although it can be used outside of it. This need is caused by the fact that structured objects (such as considered organization and process models) must satisfy both the non-formalizable/poorly formalized knowledge of expert designers and a number of strict requirements (explicit or parametric, that is, formalized and described in the form of equations or table functions), for which the use of classical generative algorithms is ineffective. The composite discriminator combines methods for testing both the tacit knowledge of experts using the classical (neural network) component, and parametric patterns (analytically). The proposed formulation of the error function combines the estimates of the neural network and analytical components of the discriminator, conveying the degree of compliance of the evaluated generated solution with all constraints.

4.2. The ATCD Algorithm

The ATCD algorithm is based on the on the approach described in [46], which has been adopted and extended. It uses the following mathematical relations:

The model $x=(N,C,P,Q)$, and the training set $X^T$ have been described above;

$G_{\theta }$—generator;

$D_{\varphi }$—discriminator;

$R_{\psi }$—neural network-based approximator of constraints on the model’s structure and parameters;

$\mathsf{\Phi }$—constraint validator (defined above);

${\mathsf{\Phi }}^{\prime }$—validator of differentiable constraints.

The training process is based on the following relations:

$\tilde{x}=G_{\theta }(\mathcal{z},Q)$ is a probabilistic estimation of the model ($\mathcal{z}\in {\mathbb{R}}^d$ is a vector of random values with a normal distribution from 0 to 1 of the length $d$, a “noise”).

$x^G=f\left(\tilde{x}\right)=(N^G, C^G, P^G, Q^G)$ is the model obtained on the basis of a probabilistic estimation of the model $\tilde{x}$. Differentiable discretization (replacement of probabilistic parameters with binary or integer parameters) is performed in one of three ways (addition of Humbel noise, usage of Gumbel–Softmax, or no discretization usage) described and implemented in [46].

With the help of the validator, each generated model $x^G$ is assigned a label $b^G=\mathsf{\Phi }\left(x^G\right),{ b}^G\in \left\{\mathrm{0,1}\right\}, { B}^G=\{b^G\}$, indicating its validity (0—invalid model and 1—valid model).

To train the neural network-based approximator of constraints on structure and parameters, both the generated models $({\tilde{X}}^G, B^G), {\tilde{X}}^G=\{{\tilde{x}}^G\}$and training models $(X^T, B^T)$ are used. The error $l^R$ is calculated using the following formulas: $l^R={\lambda }_R^R·l^{RG}+{\lambda }_R^{\mathsf{\Phi }}·l^{{\mathsf{\Phi }}^{\prime }G}$ for generated data and $l^R={\lambda }_R^R·l^{RT}+{\lambda }_R^{\mathsf{\Phi }}·l^{{\mathsf{\Phi }}^{\prime }T}$ for training data, where $l^{RG}=ME\left(R_{\psi }\left(X^G\right),B^G\right)$, $l^{RT}=ME\left(R_{\psi }\left(X^T\right),B^T\right)$, $ME$—mean error, ${\lambda }_R^R+{\lambda }_R^{{\mathsf{\Phi }}^{\prime }}=1$—trade-off coefficients determining the significance of partial errors within the composite one, and $l^{{\mathsf{\Phi }}^{\prime }G}={\mathsf{\Phi }}^{\prime }(P^G)$—the error value of the validator of differentiable constraints.

Discriminator training is performed in a classic way. The error $l^D$ is calculated using the following formulas: $l^{DG}=ME\left(D_{\varphi }\left(X^G\right),0\right),l^{DT}=ME\left(D_{\varphi }\left(X^T\right),1\right)$.

The composite error is used to train the generator $l^G={\lambda }_G^R·l^{RG}+{\lambda }_G^D·l^{DG}+{\lambda }_G^{\mathsf{\Phi }}·l^{{\mathsf{\Phi }}^{\prime }G}$, where ${\lambda }_G^R+{\lambda }_G^D+{\lambda }_G^{{\mathsf{\Phi }}^{\prime }}=1$—trade-off coefficients.

Thus, when training a generator, the error $l^{RG}$ provides learning constraints on structure and non-differentiable constraints on parameters, the error $l^{\mathsf{\Phi }G}$—learning differentiable constraints on parameters, and the error $l^{DG}$—learning the variety of generated models.

Figure 4 shows a block diagram of the ATCD algorithm. The algorithm begins with reading the initial data (the training set $X^T$), as well as generating a given (determined by the number of training elements within one epoch) number of models by the generator and their subsequent discretization. The resulting models are evaluated by the discriminator and the error $l^{DG}$ is computed (the generated models are considered as fake ones).

At the same time, the validator validates the generated models, which results in the TRUE/FALSE label and the error $l^{{\mathsf{\Phi }}^{\prime }}$ (the result of the work of the validator of differentiable constraints).

The training dataset is evaluated by the discriminator (the models are considered real) to calculate the error value $l^{DT}$.

In parallel, both the training and validated generated models are evaluated by the neural network approximator, producing the error values $l^{RG}$ and $l^{RT}$.

The calculated error values are used to update the weights of the generator ($l^{RG}, l^{DG}, l^{{\mathsf{\Phi }}^{\prime }G}$), neural network approximator ($l^{RG}, l^{RT}, l^{{\mathsf{\Phi }}^{\prime }G}, l^{{\mathsf{\Phi }}^{\prime }T}$), and discriminator ($l^{DG}, l^{DT}$).

4.3. The ATGM Algorithm for Complementing Existing Models

The ATGM algorithm can also be used to complement partially specified models (in addition to generating models from scratch). This functionality is useful if the designer already has a partially defined model (for example, if some key elements have been defined and the full model needs to be completed, or a model has been defined but some its elements need to be changed to meet the changed requirements).

For this purpose, the vector of input parameters of the elements of the training set $Q\in {\mathbb{R}}^q{x}_i^T=(N,C,P,Q)X^T={\left\{x_i^T\right\}}_{i=1}^t$ is extended to a data structure similar to that describing the models, namely $\tilde{Q}=(N_Q,{ M}_N,C_Q,{ M}_C,P_Q,{ M}_P,Q_Q,{ M}_Q)$, where

$N_Q\in {\{0,1,..m\}}^n$—vector of predefined elements of the model,

$M_N={\left(m_{Ni}\right)}_1^n,\forall i:m_{Ni}\in \left\{\mathrm{0,1}\right\}$—a vector mask that defines the significant values of the vector $N_Q$ (the values of the vector $N_Q$ for which the matrix value is $1$ are considered prespecified and the values for which the matrix value is equal $0$ are to be ignored);

$C_Q={\left(C_i\right)}_1^c,\forall i:C_i\in {\left\{\mathrm{0,1}\right\}}^{n\times n}$—matrices of relationships between the elements of the model;

$M_C={\left(m_{Ci}\right)}_1^c,\forall i:m_{Ci}\in {\left\{\mathrm{0,1}\right\}}^{n\times n}—$a set of matrices masks that determine the significant values of the matrices $C_Q$;

$P_Q={\mathbb{R}}^{n\times p}$—matrix of parameter values of the model elements;

$M_P={\left\{{\mathrm{m}}_{\mathrm{P}}\right\}}^{n\times p}={\left\{\mathrm{0,1}\right\}}^{n\times p}—$a matrix mask that determines the significant values of the matrix $P_Q$;

$Q_Q\in {\mathbb{R}}^q$—vector of “input” parameters;

$M_Q={\left\{m_q\right\}=\left\{\mathrm{0,1}\right\}}^q$is a vector mask that defines the significant values of the vector $Q_Q$.

The augmentation in turn is complemented by a mask generation step, which is then combined with models from the training set to create “incomplete model–complete model” training pairs. Mask elements are generated using the Bernoulli distribution: $m_{Ni}=Bernoulli\left(p_N\right)$, $m_{Ci}=Bernoulli\left(p_C\right)$, $m_P=Bernoulli\left(p_P\right)$, and $m_Q=Bernoulli\left(p_Q\right)$, where the probabilities $p_{N }, p_C,p_P,p_Q$ are defined empirically.

The block diagram of the ATGM algorithm for model complementing is identical to that in Figure 3; however, after the augmentation generation an additional step of mask generation is introduced.

4.4. The AMGS Algorithm

The AMGS algorithm is aimed for multi-level model generation based on information transfer between levels (AMDS). It is based on the following mathematical relations.

The inputs to the algorithm are a set of generative neural networks ${\left\{G_{i,{\theta }_i}\right\}}_{i=1}^{\mathsf{\Lambda }}$ trained using the ATCD and ATGM algorithms for the top level model generation and for generation of its components (aspects), a set of input parameter values for each aspect ${{\{\tilde{Q}}_i\}}_{i=1}^{\mathsf{\Lambda }}$, a set of relationships between the parameters of aspects ${\left\{{\mathsf{\Gamma }}_{i,j}\right\}}_{i,j=1}^{\mathsf{\Lambda },\mathsf{\Lambda }}: {\tilde{Q}}_j^{\prime }={\mathsf{\Gamma }}_{i,j}(x_i, {\tilde{Q}}_j)$, and the modelling sequence, which is a sequence of aspect indexes ${\left\{{\tau }_i\right\}}_{i=1}^{\mathsf{\Lambda }}$. The result of the successful operation of the algorithm is a set of agreed aspect models ${\left\{x_i\right\}}_{i=1}^{\mathsf{\Lambda }}$, where $x_i=G_{i,{\theta }_i}(\mathcal{z},{\tilde{Q}}_i^{\prime })$.

The essence of the algorithm is the sequential generation of models of the system as a whole and its components using trained generative neural networks, with the transfer of parameters (requirements) from more general models to more specific ones. If it is not possible to generate a model that satisfies the input parameters, it is possible to revert to the previous level according to the modelling sequence $\left\{{\tau }_i\right\}$ (“higher-level models”).

Figure 5 shows a block diagram of the AMGS algorithm. It begins with the generation of a batch of upper-level models (${\tau }_1$) based on the specified input parameters ${\tilde{Q}}_{{\tau }_1}$. Then, the lower level models (according to the sequence ${\left\{{\tau }_i\right\}}_{i=1}^{\mathsf{\Lambda }}$) are generated using input parameters defined by the set of relationships between the aspect model parameters ${\left\{{\mathsf{\Gamma }}_{i,j}\right\}}_{i,j=1}^{\mathsf{\Lambda },\mathsf{\Lambda }}$. If at any stage none of the generated models meet the requirements, another model from the previous stage is selected according to the modelling sequence. If there are no such models left, the process returns to the stage that was even earlier according to the modelling sequence. This process is repeated until all models of the first aspect are exhausted. Thus, the result of the algorithm is either a set of agreed aspect models ${\left\{x_i\right\}}_{i=1}^{\mathsf{\Lambda }}$ or the absence of the ability to generate those according to the specified conditions.

5. Experiments

The experimental evaluation of the proposed approach is based on two applications. The first one is from the area of smart logistics and the second one is from the area of smart tourism. The proposed approach is explored in three ways. First, the experiments aim to answer the question of if this approach can actually be used to infuse business constraints (typically, non-differentiable) into a generative model so that the structures generated by a neural network actually conform to these constraints. Second, they aim to analyze the effect of the most important parameters of the approach. Finally, third, they aim to evaluate the usability of the approach.

5.1. Smart Logistics System Modelling Use Case

5.1.1. Smart Logistics System Modelling Dataset

To evaluate the approach, we developed a semi-synthetic dataset of logistics models. The model of a logistic system consists of several possible units, links between them (two types—hierarchical and information flow), and numeric parameters of the units (workload and personnel quantity). In addition to explicit links between units, there are also implicit functional relationships. These relationships are generally “soft” (for example, it is impossible to unambiguously determine the required number of personnel); however, there are constraints that allow assessing the feasibility of a specific set of parameters and the presence/absence of certain units.

The dataset consists of

• 20 logistics system models (note the small number of these models: the size of the datasets models the typical situation when there are only a few samples available for training a generative model);
• a set of business rules and constraints, reflecting the relationships between parameters of units (e.g., possible relationship between a unit’s workload and its personnel).

These two components (samples and rule specification) encode two types of knowledge related to logistics system model—implicit and explicit (symbolic), respectively.

This dataset was used to train a generative–adversarial model for recommending valid logistics system models according to the given criteria for a given set of input parameters (load of certain departments).

5.1.2. Quality Metrics

The main purpose of the generative model is to form valid models (including structural and parametric parts). Validness in this context is defined by the set of problem-specific rules and constraints. Therefore, we measure success of the generative model as the ratio of generated components, conforming the requirements to the total number of generated components: $Ac{c}_R\left(X\right)={\displaystyle \frac{\left|\left\{x|R\left(x\right), x\in X\right\}\right|}{\left|X\right|}}$, where $X$—is the set of generated models and $R\left(·\right)$ is a predicate describing problem-specific constraints. We call this metric constraint satisfaction accuracy, or simply “accuracy” for brevity.

We performed a series of experiments to select optimal training parameter values (see below), then trained 10 generative models with these values. Finally, using each model, we generated 100 structures, yielding a constraint satisfaction accuracy mean of 0.87 and standard deviation of 0.04.

5.1.3. Model Parameters

The convergence rate and accuracy of the resulting model are determined by the complexity of the neural networks (generator, discriminator, and approximator). For the generator, it is the dimensionality of the fully-connected layers, and for the discriminator and the approximator (sharing the same structure) it the dimensionality of the graph convolution layers and fully-connected classification head. Increasing these dimensionalities can result in increased accuracy; however, it also increases the generation time (both iteration time and the number of iterations).

Another parameter influencing the convergence rate (and slightly influencing the accuracy) is batch size. Figure 6 shows learning curves with different batch sizes. It can be seen that with smaller batches (16 samples) the training is slower, but the quality of the generated structures is more stable; with larger batches (500 samples) the generator reaches high accuracy relatively quickly, but the quality is less stable and it frequently drops to near-zero values.

5.2. Smart Tourist Trip Booking Process Use Case

5.2.1. Smart Tourist Trip Booking Process Dataset

Smart tourist trip booking process can involve various operations depending on the client’s preferences. To create a training dataset, process models from the SAP-SAM dataset (https://github.com/signavio/sap-sam, accessed on 26 February 2025) were utilized. The SAP-SAM dataset (SAP Signavio Academic Models) contains several hundred thousand models in JSON format. Primarily, these are process models in BPMN notation, created over approximately ten years by researchers, educators, and students using a free software platform.

To form the training set, the following operations were performed:

• An analysis of model types within the dataset was conducted.
• From the entire dataset, only BPMN models were selected. However, since the type is not defined for most models and models described in BPMN 2.0 notation have different types (e.g., “BPMN 2.0”, “Business Process Diagram (BPMN 2.0)”), the presence of the keyword “bpmn2.0#” in the model text was chosen as the selection criterion. This resulted in the selection of 618,861 models.
• In the final step, models written in English containing the phrase “Travel Booking” were filtered. The resulting set of 29 models was used as the training dataset.

5.2.2. Definition of Explicit Constraints on Process Models

According to the proposed algorithms, explicit (symbolic) constraints were defined to accelerate the process of training the composite discriminator of the generative adversarial model. They include:

• Each model must have start and end nodes.
• Any node, except the start node, must have an incoming edge.
• Any node, except the end node, must have an outgoing edge.
• The start node must not have incoming edges.
• The end node must not have outgoing edges.
• If a “Transaction Start” node is present, the model must include both “Transaction Success” and “Transaction Failure” nodes.
• If a “Transaction Start” node is absent, the model should not include “Transaction Success” or “Transaction Failure” nodes.

These constraints are processed by a constraint validator, which allows for more precise determination of the gradient during the training of the neural network generator. This enhances the convergence of the training process and, therefore, reduces its duration.

5.2.3. Training Process

The listing of intermediate training results is presented in Listing 1. It includes the following results:

Listing 1. The listing of intermediate training results of the generative adversarial model.

The number of model parameters: 57,329 Start training... Elapsed [0:00:02], Iteration [100/5000], D/loss_real: 0.0198, D/loss_fake: 0.0145, V/loss: 0.1778, G/loss_fake: 4.2388, G/loss_value: 0.2441, G/loss_compliance: 0.1807, Accuracy: 1.0000 Elapsed [0:00:05], Iteration [200/5000], D/loss_real: 0.0063, D/loss_fake: 0.0075, V/loss: 0.0549, G/loss_fake: 5.0640, G/loss_value: 0.1221, G/loss_compliance: 0.2261, Accuracy: 1.0000 Elapsed [0:00:07], Iteration [300/5000], D/loss_real: 0.0019, D/loss_fake: 0.0033, V/loss: 0.0211, G/loss_fake: 5.7244, G/loss_value: 0.0946, G/loss_compliance: 0.1965, Accuracy: 1.0000 Elapsed [0:00:10], Iteration [400/5000], D/loss_real: 0.0007, D/loss_fake: 0.0014, V/loss: 0.0096, G/loss_fake: 6.6027, G/loss_value: 0.0664, G/loss_compliance: 0.2728, Accuracy: 1.0000 Elapsed [0:00:12], Iteration [500/5000], D/loss_real: 0.0003, D/loss_fake: 0.0007, V/loss: 0.7485, G/loss_fake: 7.2087, G/loss_value: 0.0911, G/loss_compliance: 0.2408, Accuracy: 0.1111 Saved model checkpoints into output/data_sap_process_models...

• Iteration: The iteration number and the total number of specified training iterations.
• D/loss_real: The value of the discriminator’s loss function when evaluating “real” samples (samples from the training set).
• D/loss_fake: The value of the discriminator’s loss function when evaluating “fake” samples (samples generated by the generator).
• V/loss: The value of the loss function of the constraint approximator.
• G/loss_fake: The value of the generator’s loss function as determined by the discriminator (indicating how much the generated samples differ from the real ones).
• G/loss_value: The value of the generator’s loss function as determined by the constraint approximator (indicating how well the generated samples conform to the specified constraints).
• G/loss_compliance: The value of the generator’s loss function obtained by comparing how well the generated samples adhere to the specified initial parameters.
• Accuracy: The “accuracy” of the generated samples in terms of structural constraints (the admissibility of combinations of nodes and edges within the model).

From the listing, it can be observed that after just 400 iterations, the training results appear satisfactory—the generator produces process models with permissible structures and relatively low values for the loss functions assessing the conformity of the generated samples to the specified parameters. Subsequently, the accuracy value begins to decline, leading to the decision to terminate the training.

5.2.4. Process Model Generation Procedure

After the generative model is trained, the tourist trip booking process generation procedure consists of the following steps:

• Specification of input parameters. At this step, the input data vector for the process model generator is formed. For example, one might specify the generation of booking process to include the task “Book flight” and not include the task “Book attraction”.
• Generation of a set of process models. At this step, the trained generator generates a set of process models according to the input parameters.
• Evaluation of generated process models. Since neural networks cannot guarantee precise results, after generating a certain number of models, the sampling procedure is applied: only those models that meet the specified parameters and input criteria are selected. If after the sampling procedure the number of generated process models is not sufficient, the generation process (Step 2) may be repeated.
• Selection of the most appropriate process model. From the obtained set of models, the user selects the most suitable ones. For example, based on the initial condition specified in Step 1, the following model variants were generated (Listings 2–6).

Upon analyzing the generated process models, the user can choose the most appropriate option for the specific task. For instance, in a case where transactions and hotel booking operations are likely needed, the most suitable option would be variant 4, which includes these tasks as illustrated in Figure 7.

Listing 2. Generated process model for smart tourist trip booking (variant 1).

Task 1: Check request Task 6: Notify customer Task 7: Success Task 8: Booking error Task 9: Book flight Task 11: Book bus Connection (1, 9) from Check request to Book flight Connection (1, 11) from Check request to Book bus Connection (7, 6) from Success to Notify customer Connection (8, 6) from Booking error to Notify customer Connection (9, 7) from Book flight to Success Connection (9, 8) from Book flight to Booking error Connection (11, 7) from Book bus to Success Connection (11, 8) from Book bus to Booking error

Listing 3. Generated process model for smart tourist trip booking (variant 2).

Task 1: Check request Task 2: Manual handling Task 6: Notify customer Task 8: Booking error Task 9: Book flight Task 11: Book bus Connection (1, 2) from Check request to Manual handling Connection (1, 9) from Check request to Book flight Connection (1, 11) from Check request to Book bus Connection (2, 6) from Manual handling to Notify customer Connection (8, 6) from Booking error to Notify customer Connection (9, 8) from Book flight to Booking error Connection (11, 8) from Book bus to Booking error

Listing 4. Generated process model for smart tourist trip booking (variant 3).

Task 1: Check request Task 3: Transaction start Task 4: Transaction success Task 5: Transaction failure Task 6: Notify customer Task 7: Success Task 8: Booking error Task 9: Book flight Task 11: Book bus Connection (1, 3) from Check request to Transaction start Connection (1, 9) from Check request to Book flight Connection (1, 11) from Check request to Book bus Connection (3, 9) from Transaction start to Book flight Connection (3, 11) from Transaction start to Book bus Connection (4, 6) from Transaction success to Notify customer Connection (5, 6) from Transaction failure to Notify customer Connection (7, 4) from Success to Transaction success Connection (7, 6) from Success to Notify customer Connection (8, 5) from Booking error to Transaction failure Connection (8, 6) from Booking error to Notify customer Connection (9, 7) from Book flight to Success Connection (9, 8) from Book flight to Booking error Connection (11, 7) from Book bus to Success Connection (11, 8) from Book bus to Booking error

Listing 5. Generated process model for smart tourist trip booking (variant 4).

Task 1: Check request Task 3: Transaction start Task 4: Transaction success Task 5: Transaction failure Task 6: Notify customer Task 8: Booking error Task 9: Book flight Task 10: Book hotel Connection (1, 3) from Check request to Transaction start Connection (3, 9) from Transaction start to Book flight Connection (3, 10) from Transaction start to Book hotel Connection (4, 6) from Transaction success to Notify customer Connection (5, 6) from Transaction failure to Notify customer Connection (8, 5) from Booking error to Transaction failure Connection (9, 6) from Book flight to Transaction success Connection (10, 6) from Book flight to Transaction success Connection (9, 8) from Book flight to Booking error Connection (10, 8) from Book hotel to Booking error

Listing 6. Generated process model for smart tourist trip booking (variant 5).

Task 1: Check request Task 2: Manual handling Task 3: Transaction start Task 4: Transaction success Task 5: Transaction failure Task 6: Notify customer Task 8: Booking error Task 9: Book flight Task 10: Book hotel Connection (1, 2) from Check request to Manual handling Connection (1, 3) from Check request to Transaction start Connection (2, 6) from Manual handling to Notify customer Connection (3, 9) from Transaction start to Book flight Connection (3, 10) from Transaction start to Book hotel Connection (4, 6) from Transaction success to Notify customer Connection (5, 6) from Transaction failure to Notify customer Connection (8, 5) from Booking error to Transaction failure Connection (8, 6) from Booking error to Notify customer Connection (9, 8) from Book flight to Booking error Connection (10, 8) from Book hotel to Booking error

6. Programming Library

We have developed and published an open-source programming library, OrGAN (https://github.com/cais-lab/organ accessed on 6 December 2024), implementing the proposed techniques. To train a generative–adversarial neural network model, the OrGAN library provides two interfaces: a command line interface and an application programming interface. The command line interface may be useful to a user who is satisfied with the basic architectures of neural networks (generator and discriminator) and the application programming interface provides richer options for configuring a generative–adversarial model. The library is based on the PyTorch framework (v. 1.8.1) and allows users to define their own architectures for the generator, discriminator, and validator, as well as implement specific non-differentiable verification logic for the considered class of organizational structures.

7. Discussion

The paper proposes a GAN training approach based on the idea of the original composite discriminator, taking advantage of separate evaluation of tacit and explicit domain knowledge on smart city-related scenarios, namely logistics system model generation and smart tourist trip booking process model generation. It provides a higher automation level of the modelers’ work in the context of organization and process modelling.

The experiments prove the validity of this approach as an effective solution for the fast generation of organizational structures and process models, accounting for both tacit and explicit requirements and constraints. They demonstrate the approach on two scenarios related to smart cities; however, it can be potentially extended to other domains and serve as a starting point for research efforts in related scientific fields.

Unfortunately, there are no direct competitive models to compare the developed approach with. One of the closest models is MolGAN [46], but it does not address the generation of numerical parameters of graph nodes or the partial definition of generated graphs. A comparison of the GAN training process using the developed composite discriminator with a conventional GAN is presented in Figure 8. It is based on the training of a simplified Smart Logistics System Modelling Use Case with the application of only structural constraints. One can see that the application of the composite discriminator enabled a reduction of the incorrect generated models of 36.4%: the achieved accuracies after 22,000 batches for the composite discriminator and the conventional discriminator are 88.3% and 81.6%, respectively.

The approach is still subject to several limitations discussed below.

• Generating large-scale complex organizational systems can be a challenging task for GANs. The proposed approach mitigates this limitation in the following ways. First, the usage of the composite discriminator enables reducing the complexity of GAN training due to separate handling of explicit constraints and, especially, differentiable constraints, which makes it possible to simplify and speed up the training of GANs for such models. Second, the introduced the AMGS algorithm for the step-by-step detailing of the generated model makes it possible to generate several simpler models instead of one complex model. These means do not remove the limitation completely, but in many cases they do.
• The definition of constraints for a particular model, as well as the augmentation generation procedure, is a complex and often iterative process. It might require numerous tests to achieve convergence of the GAN training. Further, depending on the model complexity, the structures and sizes of the neural networks used can require adjustment. We have not studied the dependency of the sizes of the GAN models on the complexity of the dataset models. In fact, the selection of the GAN models’ sizes can be challenging due to the necessity to find the balance between the modelling graph complexity and the training set available. This issue is currently considered as one of the topics of future research.
• One more limitation is related to the absence of a standard for describing datasets in the developed library. However, the library is still under development and since it is open-source we invite other developers to contribute.

Normally, an important metric for GANs is the diversity of the generated models. However, in this study we do not present such an analysis, since in the presented scenarios this is not the case. Good specification of the enterprise or process model being designed does not allow for a wide range of diverse models. In fact, what is demanded from the GAN is several similar (but different in few aspects) models that meet the given requirements, and the modeler can select one as the basis and introduce needed adjustments. The diversity can also be affected by the small training dataset (Section 5.2.1); however, as was mentioned in the paper, today there are no high-quality datasets for the considered domain (enterprise and process modelling), which was the main reason for developing the augmentation procedure presented in this paper. Nevertheless, one can observe the diversity of generated models in the process model scenario: for this reason, we presented five various generated models (Section 5.2.4, Listings 2–6).

Another important point in enterprise and process modelling is the adaptability of the models to changes in dynamic environments. The suggested framework does not support adjustment of the models; instead, the modeler can modify the input parameters for the model to generate a new one that would meet the changed requirements. The input parameters in this case can be not only numeric ones, but also a partially defined model—so the modeler can “freeze” the fragments of the model that have to be preserved, update the input parameters, and use the normal generation process to create new models.

8. Conclusions

This paper proposes an approach to generating and complementing graph-based organization and process models using a GAN with examples related to the smart city area, namely for decision support in logistics system and smart tourist trip booking process modelling. The developed model considers a composite discriminator consisting of three components: a “classical” discriminator for learning tacit patterns in the training dataset, an analytical constraint validator for learning differentiable constraints on parameters, and a constraint approximator for learning constraints on structure and non-differentiable constraints on parameters. A procedure for generating augmentations is also considered that makes it possible to extend the training set with meaningful models satisfying required constraints. The multi-aspect modelling algorithm enables the multi-level generation of complex models. The carried out experiments prove the feasibility of the proposed approach. A publicly-available open-source library, OrGAN, has been developed which may be useful for both developers and researchers.

Future work is considered in the following directions. First, as was already mentioned, we are going to study the dependencies between GAN neural network sizes, modelling graph complexity, and the training set size. This issue also covers the problem of the scalability of this approach. The other direction aims at developing a universal framework for the definition of the problem domain constraints to simplify the symbolic knowledge representation. We also plan to extend the approach to other domain and cross-domain applications.

We believe that the proposed approach can be useful for developing GAN models, not only for generating models in the identified domains but also for other ones, and can be a starting point for research efforts in related scientific fields.