Intelligent optimization method and device for business process of cloud edge collaboration, and storage medium

Abstract

The invention discloses a cloud edge collaborative business process intelligent optimization method and device and a storage medium, and belongs to the field of business process optimization. The method comprises the following steps of: 1, preprocessing a local business process event log by a client, and calculating the support degree, the cost and the average cost lower bound of a plot with the length of m; 2, the client side encrypts the plot and uploads the plot and a calculation result to the server; 3, the server calculates the global confidence degree, the global average cost and the global average cost lower bound of the plots, the plots meeting the high correlation and low cost are added into a result set and a candidate set, and the plots meeting the high correlation and potential low cost are added into the candidate set; 4, the server generates m + 1 length candidate plots based on the candidate set, encrypts and distributes the m + 1 length candidate plots to the client; 5, the client side calculates the lower bound of the support degree, the cost and the average cost of the new candidate plot; and 6, circularly executing the steps 2-5 until no new candidate plot exists, and outputting a final result set.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of business process optimization, in particular to a cloud-edge collaborative business process intelligent optimization method and device and storage medium. BACKGROUND

[0002] Nowadays, with the rapid development of Internet of Things and industrial Internet technology, computer platforms can generate and store massive business process data in real time with the help of sensors. These large-scale data sets may contain hidden knowledge of great value for process optimization, revealing implicit dependencies or correlations with practical utility, such as business paths with low resource consumption and high execution efficiency, or key links with potential dependencies. How to extract novel, useful and actionable knowledge from large-scale databases has become one of the core goals of data mining. Sequential pattern mining (SPM) is a data mining technique that analyzes the relationships between items in sequence databases and has been widely applied to business process optimization to identify common task execution sequences, optimize resource scheduling and path planning. With the continuous deepening of SPM research on various data types, it has been extended to multiple fields, such as comparative SPM, co-located SPM, negative SPM, three-way SPM, maximum SPM, high utility SPM and low average cost SPM.

[0003] In addition, when sequence data is converted into timestamped event sequences, frequent episode mining (FEM) is introduced to retrieve hidden important knowledge from event sequence data, which is widely used in production process analysis, service invocation chain optimization, etc. To avoid mining a large number of meaningless episodes, FEM with time gap constraints is proposed. An episode with time gap constraints can be represented as α e 1[ a , b ] e 2…[ a , b ] e m , where a and b (0≤ a ≤ b ) represent the minimum and maximum time gap constraints, respectively. One-off FEM is a kind of FEM with time gap constraints, meaning that each event in the event sequence can be used at most once, which is more consistent with the characteristics of events in actual business processes that cannot be reused.

[0004] Existing research on one-time FEMs ignores key factors such as event utility and cost, and mainly focuses on episode identification based on frequency. Therefore, high-utility episode mining (HUEM) is proposed to provide accurate and informative results, making it a valuable tool in various applications. In practice, traditional HUEM algorithms evaluate the utility or benefit of each episode, but ignore the resources, effort, time, or cost required to apply these episodes. For example, in product order production process path data, applying HUEM can find high-utility episodes (utility can be represented as whether the product is passed after processing). Suppose the HUEM algorithm identifies the episode <Machine A, Machine B, Machine C, Pass>, indicating that many parts processed by these machines are qualified. Although such episodes seem useful, their key drawback is that HUEM ignores the cost of applying these episodes, such as the funds, time, or resources consumed to produce each product using these machines. Therefore, traditional HUEM algorithms can mine a large number of episodes with high utility but high cost, which is not optimal in real-world scenarios. For different tasks, many low-average-cost episode mining methods have been proposed. Given an event sequence and a predefined maximum cost threshold maxeac , if the average cost of an episode does not exceed maxeac , it is called a low-average-cost episode and can be used as a candidate optimization path in business process optimization. The following illustrates its application scenario through a typical example: Example 1: Suppose there is a business event log as shown in Table 1 L 1. Event sequences s1 and s2 represent product order production processes over time, where each event in the sequence consists of an activity, a timestamp, and a cost, corresponding to a processing machine, processing time, and resources consumed by the activity, respectively.

[0005] Table 1: Business process event log L 1

[0006] For episode α = t[0,2]g, it is observed that it has three occurrences in s1: <1,3>, <2,3>, and <5,6>. Among them, <1,3> and <2,3> violate the one-time condition because the event with timestamp 3 is reused. However, <1,3> and <5,6> meet the one-time constraint because there are no events reused between them. Therefore, episode α has two valid one-time occurrences in s1: <1,3> and <5,6>. Similarly, episode α has one valid one-time occurrence in s2: <1,2>. According to the cost value calculation, the global average cost of episode α is [(1+2)×2+(2+3)] / (2+1)=3.67. If maxeac is set to 5, episode α meets the conditions of a low-average-cost episode because its average cost does not exceedmaxeac Thus, it can be concluded that the processing machines t and g can be part of the optimal processing path, as their production processes do not consume excessive resources.

[0007] However, there are two main limitations in the existing research. Firstly, the internal correlation between episodes is not considered, and the mining accuracy is insufficient. For example, in a product order processing workflow, a low-cost path can be composed of several low-cost processing machines and some high-cost machines. Even if these operations are not strongly related or occur accidentally, they are still considered valuable episodes. Secondly, existing methods mainly mine centralized data, which often has the risk of data privacy leakage. For example, in production process research, operation data containing sensitive information cannot be directly shared. Data owners prefer to keep data locally while participating in collaborative mining to avoid privacy leakage. Therefore, it is still a key challenge to realize secure and compliant collaborative mining, so that the potential value of data can flow freely.

[0008] In view of the technical problems in the prior art that the low average cost episode mining method applied to business process optimization does not consider the internal correlation between episodes, resulting in insufficient mining accuracy, and the privacy protection mechanism is missing in the distributed scene, no effective solution has been proposed so far. SUMMARY

[0009] Embodiments of the present disclosure provide a cloud-edge collaborative business process intelligent optimization method and device and a storage medium to at least solve the technical problems in the prior art that the low average cost episode mining method applied to business process optimization does not consider the internal correlation between episodes, resulting in insufficient mining accuracy, and the privacy protection mechanism is missing in the distributed scene.

[0010] According to an aspect of the embodiments of the present disclosure, a cloud-edge collaborative business process intelligent optimization method is provided, including: step 1: each client pre-processes a local business process event log to obtain a plurality of partial event sequences, and calculates a support degree, a cost and a lower bound of average cost of a scenario with a length of m; wherein the cost is the sum of the costs of all one-time occurrences of the scenario in all partial event sequences; the lower bound of average cost represents the minimum value of the cost of the first occurrence of the scenario in each partial event sequence; the initial value of m is 1; step 2: each client encrypts the support degree, the cost and the lower bound of average cost of each scenario with the scenario and uploads them to a server; step 3: the server calculates a global confidence, a global average cost and a global lower bound of average cost of each scenario, adds scenarios meeting a first condition to a first set and a second set, and adds scenarios meeting a second condition to the second set only; wherein the first condition is that the global average cost of the scenario is less than or equal to a maximum cost threshold and the global confidence is greater than or equal to a minimum correlation threshold; the second condition is that the global lower bound of average cost of the scenario is less than or equal to the maximum cost threshold and the global confidence is greater than or equal to the minimum correlation threshold; step 4: the server generates a candidate scenario set with a scenario length of m+1 based on the second set, generates a corresponding merged scenario set for each client based on the second set and the candidate scenario set, and distributes the encrypted merged scenario set to each client; step 5: each client calculates the support degree, the cost and the lower bound of average cost of each scenario in the merged scenario set distributed by the server using the plurality of partial event sequences; step 6: steps 2 to 5 are repeated until the candidate scenario set is empty, and the first set obtained finally is output as a business process optimization basis.

[0011] According to another aspect of the embodiments of the present disclosure, a storage medium is also provided, which includes a stored program, wherein the program is executed by a processor when running.

[0012] The application adopts a federal collaborative mining framework. Firstly, a plurality of clients respectively preprocess business process event logs locally to generate partial event sequences and calculate the support, cost and average cost lower bound of local episodes (initial length m=1), laying a foundation for subsequent efficient screening. Then, the clients upload the episodes and their calculation results to the server after encryption, ensuring that the original sensitive process data remains local and only sharing encrypted statistical information, thereby avoiding the privacy leakage risk of centralized storage from the architecture and providing a built-in privacy protection mechanism for federal collaborative mining. The server side calculates the global confidence, global average cost and global average cost lower bound of each episode based on the encrypted data, and performs a double screening strategy: adding episodes that meet the conditions of "global average cost ≤ maximum cost threshold and global confidence ≥ minimum correlation threshold" (i.e. low-cost and high-relevance episodes) to a first set (final result set) and a second set (candidate expansion set); at the same time, adding episodes that meet the conditions of "global average cost lower bound ≤ maximum cost threshold and global confidence ≥ minimum correlation threshold" to the second set, ensuring that potential low-cost episodes are not lost and retaining the possibility of generating longer candidate episodes. The server then generates m+1 length candidate episodes based on the second set, generates a corresponding merged episode set for each client and distributes it to the clients after encryption. The clients locally calculate the support, cost and average cost lower bound of these new candidate episodes and return them after encryption, and the iteration continues until no new candidate episodes are generated. Finally, the first set, i.e. the set of globally low average cost and high relevance episodes, is output.

[0013] By introducing global confidence as a core screening indicator, the application requires that the output low-cost episodes (first set) must meet the minimum correlation threshold, which directly quantifies and embeds the consideration of the inherent relevance between events within an episode. For example, in production line path mining, a high-relevance path means that the processing order between machine combinations has strong dependency and practical significance, rather than an accidental low-cost combination, thereby significantly improving the accuracy and business value of the mining results. At the same time, the entire process is built on the federal learning paradigm, with local calculation by the client and only encrypted intermediate results shared, so that the original business process event logs (including sensitive operations, timestamps, costs, etc.) remain with the data owner (client) at all times, and the server only processes encrypted aggregated information, fundamentally solving the privacy protection mechanism deficiency problem of collaborative mining in a federal scenario and achieving secure and compliant knowledge discovery. Thus, in a cloud-edge collaborative architecture, high-quality process episodes with strong event relevance and low average cost are accurately and safely mined from distributed event logs, providing reliable data support and decision-making basis for intelligent optimization of business processes. Thus, the technical problems of the prior art, such as the lack of consideration of the inherent relevance between events in low average cost episode mining methods applied to business process optimization, resulting in insufficient mining accuracy, and the lack of privacy protection mechanisms in distributed scenarios, are solved. Attached Figure Description

[0014] The accompanying drawings, which are included to provide a further understanding of this disclosure and form part of this application, illustrate exemplary embodiments of this disclosure and are used to explain this disclosure, but do not constitute an undue limitation of this disclosure. In the drawings: Figure 1 This is a hardware structure block diagram of a computing device for implementing the methods described according to embodiments of the present disclosure; Figure 2 This is a schematic diagram of the hardware architecture of the cloud-edge collaborative business process intelligent optimization device according to the embodiments of this disclosure; Figure 3 This is a schematic diagram of the search process of the DBEI algorithm according to the embodiments of this application; Figure 4 This is a schematic diagram illustrating the comparison of runtime according to the embodiments of this application; Figure 5 This is a schematic diagram illustrating the comparison of the number of candidate scenarios according to the embodiments of this application; Figure 6 This is a schematic diagram comparing memory usage according to embodiments of this application; Figure 7 This is a schematic diagram illustrating the runtime for different dataset sizes according to the embodiments of this application; Figure 8 This is a schematic diagram illustrating memory usage for different dataset sizes according to embodiments of this application; Figure 9 This is a schematic diagram comparing the number of transmission candidate scenarios according to an embodiment of this application; Figure 10 This is a schematic diagram comparing the number of transmission candidate plot events according to the embodiments of this application; Figure 11 This is a schematic diagram of the Petri net of the "Gauge" product of client 1 according to an embodiment of this application; Figure 12 This is a schematic diagram of the Petri net of the "Gauge" product of client 2 according to an embodiment of this application; Figure 13 This is a schematic diagram of the Petri net of the "Gauge" product of client 3 according to an embodiment of this application; Figure 14 This is a schematic diagram of the FLEs of the "Gauge" product according to the embodiments of this application. Detailed Implementation

[0015] In order to make the technical solution of the present disclosure better understood by the person skilled in the art, the technical solutions in the embodiments of the present disclosure will be clearly and completely described below in combination with the drawings in the embodiments of the present disclosure. Obviously, the described embodiments are only a part of the embodiments of the present disclosure, not all the embodiments. Based on the embodiments in the present disclosure, all other embodiments obtained by the person skilled in the art without creative labor should fall within the scope of protection of the present disclosure.

[0016] It should be noted that the terms "first", "second" and the like in the description and claims of the present disclosure and the above-described drawings are used to distinguish similar objects, and do not necessarily indicate a specific order or a chronological sequence. It should be understood that the data thus used can be interchanged under appropriate circumstances, so that the embodiments of the present disclosure described herein can be implemented in an order other than those illustrated or described herein. In addition, the terms "include" and "have" and any variations thereof are intended to cover non-exclusive inclusion, for example, a process, method, system, product or device including a series of steps or units does not have to be limited to those steps or units clearly listed, but can include other steps or units not clearly listed or inherent to these processes, methods, products or devices.

[0017] Embodiments According to the present embodiment, a method embodiment of a cloud-edge collaborative business process intelligent optimization method is provided. It should be noted that the steps shown in the flowchart of the accompanying drawings can be executed in a computer system such as a set of computer executable instructions, and although a logical order is shown in the flowchart, in some cases, the steps shown or described herein can be executed in an order different from that shown herein.

[0018] The method embodiment provided by the present embodiment can be executed in a server or similar computing device. Figure 1 A hardware structure block diagram of a computing device for implementing a cloud-edge collaborative business process intelligent optimization method is shown. As shown in the figure, Figure 1 The computing device can include one or more processors (the processor can include but is not limited to a microprocessor MCU or a programmable logic device FPGA processing device), a memory for storing data, a transmission device for communication function, and an input / output interface. The memory, the transmission device and the input / output interface are connected with the processor through a bus. In addition, it can also include a display, a keyboard and a cursor control device connected with the input / output interface. Those skilled in the art can understand that Figure 1 The structure shown in the figure is only schematic, which does not limit the structure of the above-mentioned electronic device. For example, the computing device can include more or less components than those shown in the figure, or have a structure different from that shown in the figure. Figure 1 For example, the computing device can include more or less components than those shown in the figure, or have a structure different from that shown in the figure. Figure 1different configurations are shown.

[0019] It should be noted that the one or more processors and / or other data processing circuitry described above can be referred to herein generally as "data processing circuitry." The data processing circuitry can be embodied in whole or in part as software, hardware, firmware, or any combination thereof. Furthermore, the data processing circuitry can be a single standalone processing module, or it can be incorporated in whole or in part within any one of other elements of a computing device. As referred to in the embodiments of the present disclosure, the data processing circuitry functions as a processor to control, for example, selection of a variable resistance terminal path connected to an interface.

[0020] The memory can be used to store software programs and modules of application software, such as program instructions / data storage means corresponding to the cloud-edge collaborative business process intelligent optimization method in the embodiments of the present disclosure. The processor performs various functional applications and data processing by running the software programs and modules stored in the memory, that is, implements the cloud-edge collaborative business process intelligent optimization method of the application program described above. The memory can include a high-speed random access memory, and can also include a non-volatile memory, such as one or more magnetic storage devices, flash memories, or other non-volatile solid-state memories. In some examples, the memory can further include a memory disposed remotely with respect to the processor, and these remote memories can be connected to the computing device through a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0021] The transmission device is used to receive or send data via a network. Specific examples of the above-mentioned network can include a wireless network provided by a communication provider of the computing device. In one example, the transmission device includes a network adapter (Network Interface Controller, NIC), which can be connected to other network devices through a base station so as to be able to communicate with the Internet. In one example, the transmission device can be a radio frequency (Radio Frequency, RF) module, which is used to communicate with the Internet in a wireless manner.

[0022] The display can be, for example, a touch screen type liquid crystal display (LCD), which can enable a user to interact with the user interface of the computing device.

[0023] It should be noted that in some optional embodiments, the above-mentioned Figure 1 The computing device shown can include hardware elements (including circuitry), software elements (including computer code stored on a computer readable medium), or a combination of both hardware and software elements. It should be noted that in some embodiments, the functions described herein can be implemented as part of an operating system or a specific application, component, method, or process Figure 1 is merely one example of a particular implementation and is intended to provide an example of the types of components that can be present in the computing device described above.

[0024] The present application finds that frequent episode mining (FEM) is different from the deeply researched sequence pattern mining (SPM) and time series pattern mining method, which aims to find episodes that meet window or time constraints and have a frequency exceeding a minimum support threshold. Analyzing these potential episodes has important value for decision-making in multiple fields, such as alarm sequence analysis, user behavior analysis, financial event and stock trend analysis, Internet anomaly intrusion detection, and biomedical data analysis. Many episode mining methods have been proposed, for example: some scholars have proposed a framework for mining frequent episodes from heterogeneous sensor data to infer the daily activity patterns of residents; some scholars have proposed a precise episode rule mining algorithm optimized by four strategies, which has shown great potential in weather monitoring, network intrusion detection, and e-commerce prediction tasks; some scholars have proposed a fixed gap episode rule mining algorithm based on Trie tree, which optimizes performance and memory usage through pruning strategies and is successfully applied to intelligent traffic management systems.

[0025] Although support-based episode mining research has been relatively extensive, FEM research combined with utility factors is still limited. Therefore, utility-oriented mining as a novel data mining framework is proposed, which aims to identify high-utility patterns rather than frequent patterns. However, traditional utility mining ignores the cost or effort required to obtain patterns. For example, effective treatment patterns are given priority in medical treatment, but high costs may make intervention unfeasible. This has driven the development of low-cost pattern mining methods, which extend the traditional utility mining problem by evaluating the average cost of patterns to minimize expenses. Some scholars define a new task of finding cost-effective event sequences in event logs and design three efficient pattern extraction algorithms; to discover strongly related patterns, some scholars design a new cost lower bound to effectively constrain the search space of patterns; for quantized sequence databases, some scholars propose a new algorithm called FLCHUSP, which uses a novel cost-utility list data structure to store and efficiently update the utility and cost information of patterns, and successfully identifies interesting patterns on real datasets.

[0026] Although the above algorithms have achieved remarkable success in various fields, their application framework is limited to a single data source. However, modern applications require the integration of multi-source knowledge to generate comprehensive knowledge while protecting data privacy in collaborative learning paradigms. This growing demand has significantly increased the importance of privacy protection algorithms for multi-source scenarios. Federated learning, as a framework that allows participants to share model parameters or intermediate results without exposing local private data to build a global model, has received increasing attention. Some scholars apply the concept of pre-item to federated mining to discover high-utility item sets, significantly reducing the number of scans of distributed data sets, but their performance significantly decreases when the feature distribution of client data is skewed; to mine complete results from databases with different feature distributions, some scholars propose a boundary aggregation strategy that re-scans client databases to obtain missing information to ensure the completeness of the mining results; some scholars propose a federated learning framework for mining association rules from electronic health records, which can generate globally accurate results while reducing computational costs.

[0027] In summary, the existing low average cost cloud edge collaborative business process intelligent optimization method not only does not consider the internal correlation between episodes and lacks privacy protection mechanisms in distributed scenarios, but also faces the problem of exponential growth of candidate episode space and low efficiency of communication resource utilization between heterogeneous clients. To achieve more efficient and accurate low average cost episode mining, the present application proposes a cloud edge collaborative business process intelligent optimization method, and applies a uniquely designed federated one-time related low average cost episode mining algorithm (hereinafter referred to as FLE-Miner algorithm, where FLE stands for federated one-time related low average cost episode) in the method. Figure 2 The overall framework of the device corresponding to the cloud edge collaborative business process intelligent optimization method proposed by the present application is shown.

[0028] Before elaborating on the cloud edge collaborative business process intelligent optimization method proposed by the present application, the following definitions are proposed by the embodiments of the present application: Define business process event log L composed of r event sequences, denoted as L ={s1, s2, …, s r}. Each event sequence s q is a list containing n events v, denoted as , where: , ∑ is the activity set; (for all 1≤ i < j ≤ n , there is < ) is a timestamp indicating the occurrence time; is the cost of an activity in terms of resource consumption (e.g., time or money). Table 1 above shows an example of a business process event log L 1.

[0029] In embodiments of the present invention, a scenario is defined as follows: Scenario a is a set of ordered activities, denoted as a = a1, a2,..., an e 1[ a , b ] e 2…[ a , b ] e m , which can be simply denoted as a = a1, a2,..., an tgap = [ a , b ] = a1, a2,..., an e 1 e 2… e m where min and max (0≤ min≤ max) represent the minimum and maximum time gap constraints, respectively. a b a b

[0030] In embodiments of the present invention, a one-time occurrence and support degree are defined as follows: For a scenario a = a1, a2,..., an [ a , b ] …[ a , b ] , an occurrence a1, a2,..., an is said to exist if there exists a1, a2,..., an such that a1, a2,..., an j [1, m ] and a1, a2,..., an occurs at time t1, t2,..., tn and satisfies a1, a2,..., an t 1, t 2,…, t m . It is assumed that a1, a2,..., an and a1, a2,..., an are two occurrences of a if and only if for all 1≤ i≤ n, a1, a2,..., an and a1, a2,..., an satisfy a1, a2,..., an , ,…, i , j ≤ m t 1, t 2,…, t m ,​​​​​​​​​​​ ,…, > are two one-off occurrences. All one-off occurrences of α in s1 are stored in a set S (α, s1), whose support is the number of one-off occurrences, i.e. sup (α, s1) = | S (α, s1) |. The support of α in the log L is:

[0031] In the embodiments of the present application, the following Example 2 illustrates one-off occurrences and support: For the business process event log L 1 in Table 1 and the episode α = t[0, 2]g[0, 2]t, its one-off occurrences in s1 are <1, 3, 5> and in s2 are <1, 4, 6>, i.e. S (α, s1) = {<1, 3, 5>}, sup (α, s1) = 1, S (α, s2) = {<1, 4, 6>}, sup (α, s2) = 1. Therefore, the support of α in L 1 is sup (α, L 1) = 2.

[0032] In the embodiments of the present application, the cost of an episode and the definition of global average cost are as follows: The cost of an episode on a single client is the sum of the costs of all one-off occurrences of the episode, denoted as: , where occ is a one-off occurrence of episode α in the business process event log L. The global average cost is the ratio of the sum of all client costs to the sum of supports, denoted as: . Where W represents the number of clients.

[0033] In the embodiments of the present application, the definition of global confidence of an episode is as follows: The global confidence is an important measure for evaluating the relevance of events within an episode, defined as: all-conf (α) = i.e. the global confidence of episode α is the ratio of the sum of supports of episode α in all clients to the maximum value of the sum of supports of each activity in episode α in all clients.

[0034] In the embodiments of the present application, the definition of federated relevant low average cost episode is as follows: Given a maximum cost threshold maxeac and a minimum relevance threshold mincor , if an episode α satisfiesAC (α) ≤ maxeac and all-conf (α) ≥ mincor is called a federal related low average cost episode (FLE for short).

[0035] In the embodiments of the present application, the following Example 3 illustrates the federal related low average cost episode FLE: Consider the business process event logs of two clients (Table 1 and Table 2), set tgap = [0, 2], maxeac = 5, mincor = 0.35. All FLEs include {t, g, a, tg, gt, gg}. Take episode gt as an example: in L 1, the set of one-off occurrences is {<3, 5>, <4, 6>}, the support is 2, and the cost EC (gt, L 1) = (2+1) + (3+2) = 8; in L 2, the one-off occurrence is <1, 2>, the support is 1, and the cost EC (gt, L 2) = 4; the global average cost AC (gt) = (8+4) / (2+1) = 4; the global confidence all-conf (gt) = 3 / max {8, 7} = 0.375. According to Definition 6, gt is an FLE because its AC (gt) = 4<5 and all-conf (gt) = 0.375>0.35.

[0036] Table 2: Business process event log L 2

[0037] Next, the embodiments of the present application expand the cloud-edge collaborative business process intelligent optimization method proposed in the present application in combination with Figure 2 and the above definitions and examples. The method mainly includes two key stages: 1) client mining stage; 2) server aggregation stage. The detailed steps are as follows: Step 1: Each client pre-processes the local business process event log to obtain a plurality of partial event sequences, and calculates the support, cost and average cost lower bound of an episode with a length of m; wherein the cost is the sum of the costs of all one-off occurrences of the episode in all partial event sequences; the average cost lower bound represents the minimum value of the cost of the first occurrence of the episode in each partial event sequence; the initial value of m is 1; Step 2: Each client encrypts and uploads the support, cost and average cost lower bound of each scenario to the server; Step 3: The server calculates the global confidence, global average cost and global average cost lower bound of each scenario, adds scenarios meeting the first condition to the first set and the second set, and adds scenarios meeting the second condition only to the second set according to the calculation results; wherein the first condition is that the global average cost of the scenario is less than or equal to the maximum cost threshold and the global confidence is greater than or equal to the minimum correlation threshold; the second condition is that the global average cost lower bound of the scenario is less than or equal to the maximum cost threshold and the global confidence is greater than or equal to the minimum correlation threshold; Step 4: The server generates a candidate scenario set with a length of m+1 based on the second set, and generates a corresponding merged scenario set for each client based on the second set and the candidate scenario set and distributes it to each client after encryption; Step 5: Each client calculates the support, cost and average cost lower bound of each scenario in the merged scenario set distributed by the server using the plurality of partial event sequences; Step 6: Repeat steps 2 to 5 until the candidate scenario set is empty, and output the final first set as the basis for business process optimization.

[0038] Specifically, the application adopts a federated collaborative mining framework. Firstly, multiple clients preprocess the business process event logs locally to generate partial event sequences and calculate the support, cost and average cost lower bound of local episodes (initial length m=1), laying the foundation for subsequent efficient screening. Then, the clients upload the episodes and their calculation results to the server after encryption, ensuring that the original sensitive process data remains local and only sharing encrypted statistical information, which architecturally avoids the privacy leakage risk of centralized storage and provides a built-in privacy protection mechanism for federated collaborative mining. The server side calculates the global confidence, global average cost and global average cost lower bound of each episode based on the encrypted data, and performs a double screening strategy: episodes that meet "global average cost ≤ maximum cost threshold and global confidence ≥ minimum correlation threshold" (i.e. low-cost and high-relevance episodes) are added to the first set (final result set) and the second set (candidate expansion set); at the same time, episodes that meet "global average cost lower bound ≤ maximum cost threshold and global confidence ≥ minimum correlation threshold" are added to the second set, ensuring that potential low-cost episodes are not lost and retaining the possibility of generating longer candidate episodes. Then the server generates m+1 length candidate episodes based on the second set, generates the corresponding merged episode set for each client and distributes it to the clients after encryption. The clients locally calculate the support, cost and average cost lower bound of these new candidate episodes and return them after encryption, and the iteration continues until no new candidate episodes are generated. Finally, the first set, i.e. the set of episodes with low average cost and high relevance globally, is output as the basis for business process optimization.

[0039] The application introduces global confidence as a core screening index, and forcibly requires the output low-cost scenario (first set) to meet a minimum correlation threshold, which directly quantifies and embeds the consideration of the inherent correlation between events in the scenario, for example, in production line path mining, a high correlation path means that the processing order between machine combinations has strong dependence and practical significance, rather than accidental low-cost combinations, thereby significantly improving the accuracy and business value of the mining results. At the same time, the whole process is based on the federated learning paradigm, the client calculates locally, and only shares encrypted intermediate results, the original business process event log (including sensitive operations, timestamps, costs, etc.) always needs to leave the data owner (client), and the server only processes encrypted aggregated information, which fundamentally solves the problem of missing privacy protection mechanism in collaborative mining in the federated scenario, and realizes safe and compliant knowledge discovery. Thus, under the cloud-edge collaborative architecture, high-quality process scenarios with strong event correlation and low average cost are accurately and safely mined from distributed event logs, providing reliable data support and decision basis for intelligent optimization of business processes. Thus, the technical problems of the prior art that the low average cost scenario mining method applied to business process optimization does not consider the inherent correlation between events in the scenario, resulting in insufficient mining accuracy, and the lack of privacy protection mechanism in the distributed scenario are solved.

[0040] Next, the technical implementation details of steps 1-6 will be described: In step 1, the preprocessing of the local business process event log by each client includes: using an event splitting strategy to split the event sequence in the business process event log into multiple initial partial event sequences according to the time gap constraint condition; wherein the event splitting strategy is: if the time gap between any two consecutive events in the event sequence does not meet the time gap constraint condition, the event sequence can be split into multiple initial partial event sequences; the average cost lower bound of each event in each initial partial event sequence is calculated by the following formula: ; wherein, is the expression of each event in the partial event sequence, represents the i-th activity of the event, represents the timestamp of the occurrence time of the i-th activity, represents the cost of the resource consumed by the i-th activity, represents the remaining events of the event in the partial event sequence, represents the average cost lower bound of the event , which is the minimum cost of all events in the event and on a single client. for event cost on a single client, d denote any event in for event cost on a single client; convert each event in all initial partial event sequences into a quadruple form based on the average cost lower bound , obtaining final multiple partial event sequences.

[0041] Specifically, in order to search all occurrences of each candidate scenario on a client, it is necessary to traverse the business process event log of the client multiple times. Obviously, it is inefficient to directly browse the original log. To solve this problem, the application preprocesses the business process event log of the client: first, an event splitting strategy is adopted to split the event sequence in the business process event log into multiple partial event sequences according to time gaps; then an average cost lower bound of an event is proposed, and each event in the partial event sequence is converted into a quadruple form. Among them, the event splitting strategy is: if the time gap between any two consecutive events in the event sequence does not satisfy the time gap constraint tgap , the event sequence can be converted into multiple partial event sequences.

[0042] In an embodiment of the application, the following Example 4 illustrates the event splitting strategy: The business process event log in Table 1 above L 1 is taken as an example, and tgap = [0, 2] is set. For the event sequence s1, according to the event splitting strategy, {(t, 1, 1)(t, 2, 1)(g, 3, 2)(p, 4, 11)(t, 5, 1)(g, 6, 2)} is a partial event sequence, because ( 1 ≤ j ≤ 5). However, {(g, 6, 2)(g, 10, 2)} is not a partial event sequence, because 10 - 6 - 1 = 3>2, which does not satisfy the time gap constraint. Therefore, the partial event sequences generated by s1 are {(t, 1, 1)(t, 2, 1)(g, 3, 2)(p, 4, 11)(t, 5, 1)(g, 6, 2)} and {(g, 10, 2)(g, 11, 2)(a, 12, 3)(a, 13, 3)(p, 14, 11)}.

[0043] In an embodiment of the application, the average cost lower bound of an event is defined as follows: the event after the event in the event sequence is denoted as . The average cost lower bound of the event is denoted as is with the minimum cost of all events in where d denotes any event in

[0044] In the embodiments of the present application, the average cost lower bound of events is illustrated as follows in Example 5: In the above Example 4, the partial event sequence of s1 is converted, and the remaining events of the first event (t, 1, 1) are rem ((t, 1, 1)) ={(t, 2, 1)(g, 3, 2)(p, 4, 11)(t, 5, 1)(g, 6, 2)} with the minimum cost of 1, thus CLE ((t, 1, 1)) = 1, and the converted event is (t, 1, 1, 1). Similarly, the partial event sequence of s1 is converted into {(t, 1, 1, 1)(t, 2, 1, 1)(g, 3, 2, 1)(p, 4, 11, 1)(t, 5, 1, 1)(g, 6, 2, 2)} and {(g, 10, 2, 2)(g, 11, 2, 2)(a, 12, 3, 3)(a, 13, 3, 3)(p, 14, 11, 11)}. The preprocessed new business process event log L 1' is shown in Table 3.

[0045] Table 3: New business process event log

[0046]

[0047] For the convenience of understanding, the pseudo code of log preprocessing is given as follows: Input: process event log L and time gap threshold tgap Output: new process event log

[0048] 1: initialization ; 2: traverse each event sequence s in log L 3: loop from to : 4: if and do not satisfy the time gap threshold: 5: get the partial event sequence according to the event splitting strategy , and add it to ; 6: Termination condition judgment 7: End the inner loop 8: End the outer loop 9: Traversal Each part of the event sequence s: 10: Iterate through each event in s : 11: Calculation ; 12: Forming new tuples ; 13: Generate extended event sequences ; 14: End the inner loop 15: will Add to middle; 16: End the outer loop; 17: Return .

[0049] In step 1 above, each client calculates the support of a plot of length m using the following steps: Based on the definition of plot α and the definition of support, iterate through all events of length m in all partial event sequences of each client, and calculate the support of plots of length m. m The total number of times each plot point appears at one time is used as the support level of the corresponding plot point on a single client.

[0050] In step 1 above, the lower bound of the global average cost of the plot is calculated using the following formula: ; in, For plot The lower bound of the global average cost represents the plot of all partial event sequences. The minimum value of the first occurrence of the lower bound of average cost; ooc first For plot α in a partial event sequence The first appearance of it in the text; Represents a partial event sequence Mid-plot The first appearance of the lower bound of average cost; This represents the local business process event log of the j-th client. This indicates the total number of clients.

[0051] In step 1 above, the most important issue in calculating the cost of an episode is finding all occurrences of that episode on the client side. This application uses the DBEI algorithm, which employs a depth-first and backtracking strategy on the event index to search for one-time occurrences of an episode. The specific steps are as follows: Step 1.1: Based on the multiple partial event sequences, create an event index set; based on the event index set, construct a Nettree with m layers of nodes for a plot of length m; wherein, each event index is the timestamp of each event in that plot; Step 1.2: For each partial event sequence, select the first unused node in the first layer of the network tree. ; Step 1.3: If the node is successfully located Then, under the time interval constraint, in the first... Layer search for the first unused child node Otherwise, go back to the first... j -1 floor and in the j The layer finds the next node; Step 1.4: Iterate through step 1.3 until a node is found. This indicates that a one-time occurrence of the plot has been found; Step 1.5: Iterate through steps 1.2 to 1.4 until no new one-time occurrences can be detected in any of the partial event sequences, thus obtaining all one-time occurrences of an episode of length m; Step 1.6: Determine the sum of the costs of all one-time occurrences of a plot of length m as the cost of that plot on a single client.

[0052] In this embodiment of the invention, Example 6 is provided to illustrate the calculation process of plot cost: Example 6: The business process event logs in Table 3 above L Taking 1' and plot α = t[0, 2]g[0, 2]t as an example, the search process of the DBEI algorithm is as follows: Figure 3 As shown. Combined with Figure 3 As shown, when performing the calculation of episode cost, the timestamp of each event is first stored using the event index. L The event index set obtained is {s1': { 't': [1,2,5], 'g': [3,6], 'p':[4], 'a': [ ]}, s2': { 't': [ ], 'g': [10,11], 'p':

[14] , 'a': [12,13]}, s3':{ 't': [1,6,7], 'g': [2,4], 'p': [3], 'a': [5]}}. Next, the DBEI algorithm from arrive The search for the occurrence of α follows the specific steps below: 1) The event indices of activities 't' and 'g' are {s1': { 't': [1,2,5]}, s2': { 't': []}, s3': { 't': [1,6,7]}} and {s1': {'g': [3,6]}, s2': { 'g': [10,11]}, s3': {'g': [2,4]}} respectively. Thus, the Nettree structure as shown in Figure 3 is constructed for scenario a.

[0053] 2) In , the node is the first unused node in the first level.

[0054] 3) Then the first unused child node of node is found, which satisfies the time gap constraint with timestamp 1, i.e. node .

[0055] 4) Similarly, node is found as the child of . Thus, the DBEI algorithm obtains the first occurrence <1,3,5> in .

[0056] 5) Iterating steps 1.2 to 1.4, no other occurrence is found. Meanwhile, in , since activity does not exist, it is directly skipped. Finally, in , according to step 1.2, node is the first unused node in the first level. According to step 1.3, the first unused child node of node is found in the second level, which satisfies the time gap constraint, i.e. node . However, node has no child satisfying the time gap constraint. Thus, backtracking to the second level, the next child node of is found according to step 1.3. Moreover, according to step 1.4, <1,4,6> is found as an occurrence in . no other occurrence is found. The search is completed.

[0057] After that, according to the definition of the cost of a scenario and the global average cost, the cost of scenario a on a single client, i.e. the sum of the costs of all one-time occurrences of scenario a on client , is calculated. .

[0058] In step 3, the operation of the server calculating the global confidence, the global average cost and the global average cost lower bound of each episode includes: calculating the ratio of the sum of the support of each episode at all clients to the sum of the support of each activity in the episode at all clients as the global confidence of the episode; calculating the ratio of the sum of the cost of each episode at all clients to the sum of the support as the global average cost of the episode; and calculating the sum of the average cost lower bounds of all events e i , t i , c i ) in each episode as the average cost lower bound of a one-time occurrence of the episode; and taking the minimum value of the average cost lower bound of the first occurrence of the episode in all partial event sequences as the global average cost lower bound of the episode.

[0059] In step 4, the operation of the server generating a candidate episode set with an episode length of m+1 based on the second set includes: generating a candidate episode set with an episode length of m+1 based on the second set according to a preset episode connection strategy; wherein the episode connection strategy is: if the prefix sub-episode of episode α is the same as the suffix sub-episode of episode β, a candidate episode δ with an episode length of m+1 is generated, δ=γ⊕α; and based on the candidate episodes of all episodes in the second set, a candidate episode set with an episode length of m+1 is constructed. m m +1 is generated, δ=γ⊕α; and based on the candidate episodes of all episodes in the second set, a candidate episode set with an episode length of m+1 is constructed.

[0060] Specifically, the following will introduce candidate episode generation and candidate episode distribution, which are used to generate and distribute the next round of candidate episodes to each client.

[0061] 1) Candidate episode generation Since the candidate episode space of low average cost episode mining will grow exponentially due to the fact that the global average cost does not satisfy the anti-monotonicity, the present application designs multiple strategies to reduce the number of candidate episodes.

[0062] First, the embodiments of the present application provide the following example 7 to verify that the global average cost of the episode does not satisfy the anti-monotonicity: Example 7: considering the business process event logs in Table 1 and Table 2 above L 1 and L 2, episode α=t[0,2]p and β=p. According to the definition of the cost and the global average cost of the episode, AC (α)=(12+3) / 2=7.5, and AC (β)=31 / 4=7.75>7.5. At the same time, α is a super episode of β. Therefore, the global average cost of the episode does not satisfy the anti-monotonicity. ​

[0063] To prune the candidate episodes, the present application first proves that the global confidence satisfies the anti-monotonicity: In an embodiment of the present application, Lemma 1 is provided: the support satisfies the anti-monotonicity, that is, if an episode β is a sub-episode of α, then sup (β, L) ≥ sup (α, L ).

[0064] In an embodiment of the present application, Theorem 1 is provided as follows: the global confidence satisfies the anti-monotonicity, that is, if β is a sub-episode of α, then all-conf (β) ≥ all-conf (α).

[0065] In an embodiment of the present application, the following proof is provided: According to Lemma 1, sup (β, L) ≥ sup (α, L ), and since the active set of β is a subset of α, therefore ≥ . That is, all-conf (β) ≥ all-conf (α).

[0066] In an embodiment of the present application, the pruning strategy is: if the global confidence of an episode α is lower than the minimum relevance threshold mincor , then all super-episodes thereof can be directly pruned.

[0067] To further reduce the number of candidate episodes, it is crucial to design an effective global average cost lower bound. However, the current global average cost lower bound depends on the support threshold, and since the FLE mining task does not specify this threshold, it cannot be directly applied to the present method. As a solution, the present application defines an episode global average cost lower bound that does not depend on the support threshold.

[0068] In an embodiment of the present application, the definition of the average cost lower bound of a one-time occurrence of an episode is: the average cost lower bound of a one-time occurrence t 1, t 2,…, t m of an episode α is CLE (α,< t 1, t 2,…, t m ) = .

[0069] In an embodiment of the present application, the definition of the global average cost lower bound of an episode is: the global average cost lower bound of an episode α is denoted as LBC(α), which represents the minimum lower bound of the average cost of the first occurrence of this plot in all partial event sequences. LBC The formula for calculating (α) is: ,in, ooc first For plot α in event sequence s q This is the first appearance of [the character / symbol].

[0070] In this embodiment of the invention, Example 8 is provided to illustrate the lower bound of the global average cost of the scenario: In this example, this application calculates the lower bound of the average cost of plot α = t[0,2]g. <1,3> and <1,2> ​​are respectively... L 1. Event Sequence and event sequence The first appearance of. Therefore, in the event sequence. middle, CLE (α,<1,3>)=1+1=2; in the event sequence middle, CLE (α,<1,2>)=1+1=2. Similarly, <2,5> is... L 2 event sequences The first appearance, CLE (α,<2,5>)=1+3=4. Therefore, LBC (α) = min { min {2, 2},4} = 2.

[0071] In this embodiment of the invention, the lower bound of the average cost scenario is defined as: if the lower bound of the average cost of scenario α is... LBC (α) is not greater than maxeac If α is the lower bound of average cost (LBE), then α is called the lower bound of average cost scenario.

[0072] In this embodiment of the invention, Theorem 2 is provided: If scenario α is not LBE, then it is not FLE.

[0073] In this embodiment of the invention, the following proof is provided: It is known that: .

[0074] Therefore, if plot α is not LBE, i.e. LBC (α)> maxeac ,but AC (α)> maxeac Therefore, α is not FLE. In this embodiment of the invention, Theorem 3 is provided: the lower bound of the global average cost of a plot satisfies monotonicity. In this embodiment of the invention, the following proof is provided: Assume there exist three plots α, β, and γ, where β and γ are the prefix and suffix subplots of α, respectively. According to Definition 10, it is known that: .

[0075] Similarly, it can be proven LBC (α)> LBC (γ). Therefore, if β is not LBE (i.e., LBC(β)> maxeac If ), then LBC(α)> maxeac Therefore, α is not an LBE either; if γ is not an LBE, then α is also not an LBE. Thus, the lower bound of the global average cost of the plot satisfies monotonicity.

[0076] Based on Theorems 2 and 3 above, this application adopts a plot connection strategy to generate candidate plots.

[0077] In this embodiment of the invention, the definitions of the maximum prefix, the maximum suffix, and the plot connection are as follows: Suppose there is a plot and activities d and h If α = β[ a , b ] d Then β is called the largest prefix subplot of α, denoted as prefix (α) = β. Similarly, if γ = h [ a , b If β is a maximal suffix subplot of γ, then β is called the maximal suffix subplot of γ, denoted as β. suffix (γ)=β. Because... prefix (α)= suffix Since (γ) = β, new superplots δ can be generated through plot connections, i.e., δ = γ ⊕ α = h [ a , b ]β[ a , b ] d .

[0078] In this embodiment of the invention, Example 9 is provided to illustrate the principle of the plot connection strategy: Example 9: Let plot γ = t[0,2]g[0,2]t, with its maximum prefix subplot and maximum suffix subplot being t[0,2]g and g[0,2]t respectively. If α = g[0,2]t[0,2]g, then the superplot δ = γ⊕α = t[0,2]g[0,2]t[0,2]g.

[0079] In this embodiment of the invention, Theorem 4 is provided: All lengths of m +1 LBE set H m+1 All are included in the candidate plot set C m+1 Among them Cm+1 a set of LBEs of length m H m generated by the episode connection strategy. This means that the episode connection strategy is complete.

[0080] In the embodiments of the present application, the following is provided as a proof: By contradiction, assume that there exists an LBE episode of length m +1 But does not belong to the candidate episode set . The largest prefix sub-episode and the largest suffix sub-episode of this episode are denoted by and , respectively, and both of them are LBEs. According to the episode connection strategy definition, and can be generated by the episode connection strategy , thus belongs to , which is a contradiction to the assumption.

[0081] In the embodiments of the present application, the following Example 10 shows that the episode connection strategy is superior to the enumeration tree strategy: Example 10: Consider the business process event logs in Table 1 and Table 2 above L 1 and L 2, when the time gap tgap = [0, 2], maxeac = 5 and mincor = 0.35: There are five LBEs of length 2, i.e., {tg, gt, gg, gp, ga}. Based on the enumeration tree strategy: Since each LBE of length 2 will generate four candidate episodes, there will be 5 x 4 = 20 candidate episodes of length 3. For example, gt combined with {t, g, p, a} will generate gtt, gtg, gtp, gta. Moreover, since tt is not an LBE, according to Theorem 3, the super episode gtt is not an LBE and can be pruned. While through the episode connection strategy, only nine candidate episodes of length 3 are generated, i.e., {tgt, tgg, tgp, tga, gtg, ggg, ggt, ggp, gga}. Therefore, the episode connection strategy is superior to the enumeration tree strategy.

[0082] ​In step 4, according to the second set and the candidate episode set, the operation of generating a corresponding merged episode set for each client includes: calculating the support degree of each episode in the second set in the local business process event log of the current client, and screening out target episodes with a support degree of zero; pruning candidate episodes with the target episode as a prefix or a suffix from the candidate episode set to obtain an optimized candidate episode set of the current client; and merging candidate episodes with the same prefix in the optimized candidate episode set into one episode to obtain a merged episode set of the current client.

[0083] Specifically, in traditional federated mining, the server broadcasts all original candidate episodes to each client to collect client information. However, there can be significant differences in the distribution of data features across clients, resulting in some candidate episodes not appearing in the local data of the client. Therefore, sending all episodes to each client will result in waste of communication resources. To reduce communication costs, the application designs a screening strategy and an episode merging strategy, and the principles of the two strategies are as follows: Screening strategy: if the support degree of a prefix or suffix sub-episode of a candidate episode is zero on a client, the candidate episode can be removed from the candidate episode set of the client.

[0084] In an embodiment of the application, Theorem 5 is provided: the screening strategy is correct and complete.

[0085] In an embodiment of the application, the following proof is provided: According to Lemma 1, the support degree of a sub-episode is greater than or equal to that of its parent episode. If the support degree of a sub-episode β on a client is sup (β)=0, it can be concluded that the support degree of its parent episode α (β is a sub-episode of α) on the client is sup (α)=0, so α can be pruned. In summary, the screening strategy is correct and complete.

[0086] In an embodiment of the application, Example 11 is provided to illustrate the screening strategy: In Example 10, there are five LBEs with a length of 2, i.e., {tg, gt, gg, gp, ga}, L The candidate episodes with a length of 3 are {tgt, tgg, tgp, tga, gtg, ggp, gga}. At the same time, it is known that the support degree of episode gg in L 2 is zero under the time gap constraint [0, 2]. Therefore, according to the screening strategy, candidate episodes with gg as a prefix or a suffix can be pruned from the candidate episode set L 2, LThe set of candidate plots of length 3 becomes {tgt, tgp, tga,gtg}.

[0087] Use a plot connection strategy to generate L The candidate plot set for 1 is also {tgt, tgg, tgp, tga, gtg,ggp,gga}. Under the time gap constraint [0,2], the support of these five LBEs of length 2 is not zero. Therefore, L The set of candidate plots of length 3 is {tgt, tgg, tgp, tga, gtg,ggp,gga}; In this embodiment of the invention, a merged plot is defined as follows: a merged plot contains multiple plots with the same maximum prefix, which differ only in their last activity.

[0088] In this embodiment of the invention, the plot merging strategy is: assuming that there exists k If there are plots with the same longest prefix, then this... k Individual plots can be merged into a single merged plot.

[0089] In this embodiment of the invention, Example 12 is provided to illustrate the plot merging strategy: In Example 11 above, this application obtained L The set of candidate episodes is 2. Based on the episode merging strategy, this set can be transformed into a merged episode set {tgtpa, gtg}. For example, episodes tgt, tgp, and tga share the same prefix tg, and therefore can be merged into a single merged episode tgtpa.

[0090] Similarly, based on the plot merging strategy, L The candidate plot set {tgt, tgg, tgp, tga, gtg,ggp,gga} can be transformed into the merged plot set {tgtgpa, gtg,ggpa}.

[0091] In step 5 above, the operation of each client using the multiple partial event sequences to calculate the support, cost, and lower bound of the average cost of each plot in the merged plot set distributed by the server includes: each client splitting each merged plot in the merged plot set distributed by the server into plots of length m+1 to obtain a plot set of length m+1; and each client using the multiple partial event sequences to calculate the support, cost, and lower bound of the average cost of each plot in the plot set of length m+1.

[0092] In this embodiment of the invention, Example 13 is provided to illustrate the principle of the cloud-edge collaborative intelligent optimization method for business processes proposed in this application: Example 13: Given the business process event logs of two clients (as in Table 1 and Table 2 above), set the time gap constraint tgap = [0, 2], the maximum cost threshold maxeac = 5, the minimum correlation threshold mincor = 0.35.

[0093] Step 1: In the ClientMining phase, Client 1 pre-processes the new business process event log L 1' as shown in Table 3. As described in Example 6, L 1', the support of episodes t, g, p, a in L 1 are 6, 6, 3, 3 respectively, the cost are 9, 14, 23, 8 respectively, and the lower bound of average cost are 1, 1, 1, 2 respectively. Similarly, Client 2's pre-processed log L 2' is consistent with that in Table 2, and its episode index set is {s1': { 't': [2], 'g': [1, 5], 'p': [6], 'a': [3, 4]}}. The support of episodes t, g, p, a in L 2 are 1, 2, 1, 2 respectively, the cost are 1, 6, 8, 8 respectively, and the lower bound of average cost are 1, 1, 8, 3 respectively. L

[0094] Step 2: Client 1 and Client 2 encrypt the support, cost, and lower bound of average cost of episodes t, g, p, a, and upload them to the server.

[0095] Step 3: The server decrypts the data, calculates the global confidence, global average cost, and global lower bound of average cost of each episode. The set of FLEs M = {t, g, a} and the set of LBEs H 1 = {t, g, p, a}.

[0096] Step 4: The server uses episode connection strategies to generate the set of candidate episodes H 2 from C 1. For example, episode t generates candidate episodes tt, tg, tp, ta. This step generates a total of 16 candidate episodes (4 × 4), all of which are retained in​C 2. After applying the filtering and episode merging strategies, the merged episode set for Client 1 and Client 2 is {ttgpa, gtgpa, ptgpa, atgpa}, which is distributed to each client after encryption.

[0097] Step five: Client 1 and Client 2 compute the support, cost, and lower bound of average cost for each episode in the merged episode set using the local business process event logs. For example, the support, cost, and lower bound of cost for episode tt in L 1 are 2, 6, and 2, respectively, while in L 2 they are all 0.

[0098] Step six: By iterating steps two to five, the final FLEs set M = {t, g, a, tg, gt,gg} is obtained.

[0099] For ease of understanding, the pseudo code of the FLE-Miner algorithm is given below: Input: client process event logs L , parameter W, time gap tgap , and maximum cost threshold maxeac ; Output: FLEs set M ; 1: initialize m as 1; 2: call ClientMining( L [ j ], NULL, tgap ) to generate the initial queue Q; 3: loop while queue Q is not empty: 4: iterate through each episode a in Q: 5: compute the global confidence all-conf (a) ; 6: if all-conf (a) ≥ minimum correlation threshold mincor ; 7: compute the AC (a) ; 8: if AC (a) ≤ maximum cost threshold maxeac ; 9: add episode a to set M and set H m ; 10: else: 11: compute the ; 12: If LBC (α) ≤ maximum cost threshold maxeac ; 13: Add episode α to set H m ; 14: End of judgment; 15: End of cost judgment; 16: End of confidence judgment; 17: End of traversal; 18: Generate next layer of candidate episode set C from H m using episode connection strategy m+1 ; 19: Update m to m +1; 20: If set C m is empty: 21: Break out of loop; 22: End of judgment; 23: Generate merged episode set for each client according to filtering strategy and episode merging strategy ; 24: Call to update queue Q; 25: End of loop; 26: Return set M。

[0100] For ease of understanding, the pseudo code for calling ClientMining is given below: Input: business process event log , merged episode set , and time gap tgap ; Output: episode set ; 1: Initialize set empty; 2: If set is empty: 3: Initialize m 1; 4: Preprocess business process event log to generate partial event sequences, create event index set based on the partial event sequences, and calculate support, cost, and average cost lower bound of episodes with length 1, and add them to the result set ; ; ​​5: Termination condition judgment; 6: When Loop when not empty: 7: Traversal Each plot α in: 8: Calculate the plot α in the business process event log In DBEI( , α, tgap ); 9: Calculate the plot α in the business process event log. In ; 10: Calculate the plot α in the business process event log. In ; 11: Support , and Add to collection ; 12: End traversal; 13: End the loop; 14: Return to collection .

[0101] In this embodiment of the invention, the following Theorem 6 is provided: The space complexity of FLE-Miner is: O ( W ×( N + m ×( K + N / z ))),in W , N , m , K and z These represent the number of clients, the maximum length of the client's business process event log, the maximum length of the candidate event, the maximum number of candidate events, and the size of the activity set Σ, respectively.

[0102] In this embodiment of the invention, the following proof is provided: First, each client needs to scan the business process event logs to create an event index. This index is used to store the index of each event, therefore the space complexity of creating the event index is O(n log n). O ( N In addition, each client needs to store candidate episodes, resulting in a space complexity of O(n). O ( m × K). Finally, the spatial complexity of DBEI algorithm is O ( m × N / z ). Therefore, the spatial complexity of each client is O ( N + m ×( K + N / z ))}. Since there are W clients, the spatial complexity of FLE-Miner is O ( W ×( N + m ×( K + N / z )))}.

[0103] In an embodiment of the application, it is provided that Theorem 7: The time complexity of FLE-Miner is O ( W × K + N + m × N / z × K ).

[0104] In an embodiment of the application, it is provided that the proof is as follows: The time complexity of FLE-Miner consists of two processes. In the first process, the server aggregates the information uploaded by the clients to generate the next round of candidate scenarios, and the time complexity of this process is O ( W × K ). In the second process, the event index is created by browsing the business process event log, and the time complexity of this process is O ( N ). Meanwhile, the time complexity of DBEI algorithm for a single candidate scenario is O ( m × N / z )\), and therefore the time complexity of DBEI for all candidate scenarios is O ( m × N / z × K ). In summary, the time complexity of FLE-Miner is O ( W × K + N + m × N / z × K )。

[0105] In the embodiments of the present application, the data sets and the comparative algorithms will be described below, the mining performance of FLE-Miner and the comparative algorithms will be evaluated, the scalability of FLE-Miner will be discussed, the mining ability of FLE-Miner will be compared and analyzed, and the case study in real industrial logs will be shown.

[0106] Among them, the introduction of the data sets and the comparative algorithms is as follows: All experiments were performed on a desktop computer equipped with Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz, 16.0GB RAM and running Windows 10 64-bit operating system. All algorithms are implemented in Python using PyCharm development tools. To verify the performance of FLE-Miner, the client and server are simulated, and seven real logs and two simulated logs are used as experimental data, the cost is randomly set for each event, and it is divided into three smaller data sets as heterogeneous client data. The detailed information of these data sets is shown in Table 4.

[0107] Table 4: Details of data sets

[0108] To evaluate the mining performance of FLE-Miner, six comparative algorithms are designed: FLE-Df, FLE-Bf, FLE-NoPre, Sow-H, MatchDB-O and FMIAR. A brief introduction of these algorithms is as follows: 1. FLE-Df and FLE-Bf: To evaluate the superiority of the episode connection strategy for generating candidate episodes in FLE-Miner, FLE-Df and FLE-Bf algorithms are proposed, which apply depth-first and breadth-first enumeration strategies to generate candidate episodes, respectively.

[0109] 2. FLE-NoPre: To determine the efficiency of the event splitting strategy, FLE-NoPre algorithm is proposed, which does not use the event splitting strategy.

[0110] 3. Sow-H and MatchDB-O: To analyze the efficiency of DBEI algorithm, Sow-H and MatchDB-O algorithms are proposed. Sow-H uses the one-way scanning strategy proposed in the reference to search for occurrences, and MatchDB-O uses the matchDB algorithm proposed in the reference to search for occurrences.

[0111] 4. FMIAR: To verify the efficiency of the filtering strategy and the plot merging strategy, this application considers the FMIAR algorithm, which distributes all original candidate plots generated by the server to each client.

[0112] The performance of FLE-Miner is described below: To verify the mining performance of FLE-Miner, this application selected five comparison algorithms: FLE-Df, FLE-Bf, FLE-NoPre, Sow-H, and MatchDB-O. The experimental datasets ELog1-ELog8 were used for evaluation, with parameters tgap set to 0-5 weeks (ELog1-ELog6) and 0-3 hours (ELog7-ELog8), mincor set to 0.42, 0.90, 0.90, 0.90, 0.90, 0.85, 0.42, and 0.42, and maxeac set to 7, 5, 5, 5, 5, 6, 11.9, and 12. Since all six algorithms are complete, they mined the same number of FLEs in each dataset, specifically 62, 295, 310, 519, 258, 362, 66, and 64, respectively. The comparison results of runtime, number of candidate plots, and memory usage on ELog1-ELog8 are as follows: Figures 4-6 As shown.

[0113] This application leads to the following conclusions: 1. FLE-Miner outperforms FLE-Df and FLE-Bf, verifying the superiority of the plot connection strategy over the enumeration tree strategy using depth-first search and breadth-first search. For example... Figure 5 As shown, FLE-Miner generates fewer candidate plots than FLE-Df and FLE-Bf, while Figure 4 This demonstrates that FLE-Miner runs significantly faster than these two algorithms. For example, on ELog1, FLE-Df takes 40.90 seconds to generate 8,712 candidate plots, FLE-Bf takes 22.13 seconds to generate 4,917 candidate plots, while FLE-Miner generates only 1,219 candidate plots in just 4.30 seconds. This is because the depth-first search and breadth-first search enumeration tree strategies used by FLE-Df and FLE-Bf generate more candidate plots than the plot connection strategy used by FLE-Miner. Therefore, FLE-Miner computes fewer candidate plots than FLE-Df and FLE-Bf, resulting in superior performance.

[0114] 2. FLE-Miner outperforms FLE-NoPre, indicating that the event splitting strategy can effectively reduce the number of candidate episodes. For example... Figure 5 As shown, FLE-Miner generates fewer candidate plots than FLE-NoPre.Figure 4 FLE-Miner shows faster running speed than FLE-NoPre. For example, on ELogl, FLE-NoPre takes 5.81 seconds to generate 1,287 candidate episodes, while FLE-Miner only takes 4.30 seconds to generate 1,219 candidate episodes. This improvement is due to the event splitting strategy that improves the cost lower bound and minimizes the generation of redundant episodes. The present application knows that the fewer candidate episodes, the faster the algorithm runs. Therefore, FLE-Miner outperforms FLE-NoPre in running efficiency.

[0115] 3. On all datasets, FLE-Miner runs faster than Sow-H and MatchDB-O, indicating that the DBEI algorithm effectively improves the mining performance. As shown in Figure 4 for example, on ELog2, FLE-Miner completes execution in 11.86 seconds, while Sow-H and MatchDB-O take 204.61 seconds and 66.62 seconds, respectively. This difference is due to the different matching algorithms used by these methods. Sow-H and MatchDB-O use linear search to locate the position of the subsequent event and perform multiple verifications, which is an inefficient method with significantly higher computational cost compared to FLE-Miner. However, FLE-Miner Figure 6 shows that the memory consumption of FLE-Miner is slightly higher than that of Sow-H and MatchDB-O. For example, on ELog3, FLE-Miner uses 224.41 Mb of memory, while Sow-H and MatchDB-O consume 223.45 Mb and 223.26 Mb of memory, respectively. This increased memory usage is due to the additional event index created by FLE-Miner for optimization of episode detection. Overall, FLE-Miner achieves a significant speed improvement with only a slight increase in memory usage, outperforming Sow-H and MatchDB-O in performance.

[0116] The scalability is introduced as follows: To evaluate the scalability of FLE-Miner, the present application compares it with FLE-Df, FLE-Bf, FLE-NoPre, Sow-H, and MatchDB-O using the ELog8 dataset. The present application creates six scaled datasets of ELog8, named ELog8_1, ELog8_2, ELog8_3, ELog8_4, ELog8_5, and ELog86, corresponding to one, two, three, four, five, and six times the size of the original dataset, respectively. tgap set to 0-3 hours, mincor set to 0.42, maxeac set to 12. The comparison results of running time and memory usage are shown in Figure 7and Figure 8 as shown.

[0117] The growth rate of FLE-Miner's running time and memory usage is lower than the growth rate of the dataset size. For example, ELog8_6 is six times the size of ELog8_1. On ELog8_6, FLE-Miner's running time is 7.69 seconds and memory usage is 120.79 Mb. Compared with the performance on ELog8_1, the running time growth factor is 7.69 / 1.32≈5.826 and the memory usage growth factor is 120.79 / 110.30≈1.095. The results of all other datasets are consistent with ELog8. More importantly, FLE-Miner's scalability is superior to other algorithms. As shown in Figure 7 the running time growth factors of FLE-Df, FLE-Bf, FLE-NoPre, Sow-H and MatchDB-O are calculated as 45.80 / 6.51≈7.035, 22.82 / 3.11≈7.338, 25.48 / 1.58≈16.127, 33.12 / 4.69≈7.062 and 17.50 / 2.16≈8.102, respectively, all of which exceed FLE-Miner's running time growth factor 5.826. However, Figure 8 shows that FLE-Miner's memory usage growth factor (1.095) exceeds that of the comparative algorithms. The reason is explained in the previous section. In summary, FLE-Miner generally exhibits better scalability.

[0118] FLE-Miner's mining ability is as follows: To verify the effectiveness of the filtering strategy and episode merging strategy, the present application uses FMIAR as a comparative algorithm and uses ELog1-ELog8 as experimental datasets. The parameter tgap is set to 0-5 weeks (ELog1-ELog6) and 0-3 hours (ELog7-ELog8), mincor is set to 0.42, 0.90, 0.90, 0.90, 0.90, 0.85, 0.42 and 0.42, and maxeac is set to 7, 5, 5, 5, 5, 6, 11.9 and 12. The comparison results of the number of candidate episodes transmitted and the number of candidate episode events transmitted on ELog1-ELog8 are shown in Figure 9 and Figure 10 .

[0119] FLE-Miner effectively reduces the number of candidate episodes transmitted to the client through the filtering strategy and compresses the number of candidate episode events through the episode merging strategy. As shown in Figure 9 and Figure 10As shown, FLE-Miner transmits fewer candidate episodes and episode events to clients compared to FMIAR. For example, on ELog3, FMIAR transmits 117,018 candidate episodes containing 353,643 events to clients, while FLE-Miner transmits only 93,523 candidate episodes containing 178,074 events, with a compression rate of 49.65%. The reason is that the filtering strategy pre-judges certain clients' redundant episodes through the prefix and suffix episode information of candidate episodes, thereby reducing unnecessary transmission. At the same time, the episode merging strategy compresses candidate episodes with the same prefix to reduce the number of candidate episode events transmitted. The present application knows that the fewer candidate episodes transmitted, the lower the communication cost; the fewer candidate episode events transmitted, the lower the communication cost. Therefore, the filtering strategy and the episode merging strategy can reduce the communication cost.

[0120] In an embodiment of the present application, the following case study is given: As a case study, the present application investigates the federated application of FLE-Miner in the product order production process log to identify the low-cost processing activity sequence that helps to achieve low cost. The cost of product processing activities can depend not only on the current activity itself, but also on the previous processing activities. Therefore, different activity choices can lead to an increase or decrease in the cost of subsequent activities. The present application conducts experiments on a real complex industrial log ELog9 to mine low-cost paths in the product order production process. To reduce the complexity of mining episodes, the present application only extracts the process related to the "Gauge" product when mining FLEs, which contains 13 activities and 91 events. The present application divides the log data into three parts, representing three client datasets: Client 1, Client 2, and Client 3. Using the PM4PY Python package, the present application visualizes the production process of the "Gauge" product of Client 1, Client 2, and Client 3 as three Petri nets, as shown in Figures 11-13 (Notice: each activity is coded as an integer).

[0121] From Figure 14 it can be observed that FLEs include activity 3 and activity 13, which involve two selection structures in Figures 11-13 . Figure 11 The first selection structure (labeled as ①) in Figure 13 involves the selection between activity 2 and a transition. Figure 12 The second selection structure (labeled as ②) in Figure 13The second selection structure (labeled as 2) exists between the transitions. The first selection structure indicates that the selection of activity 3 is better than the other selections because it can reduce the cost of the subsequent activities. In addition, the second selection structure indicates that it is the best choice to perform activity 13 before the subsequent activities because this also reduces the cost of the subsequent activities. As can be seen from the above results, the reason for reducing the cost of the subsequent activities is that activities 3 and 13 are performed in the production path of the product order, rather than other selections. This also indicates that it is not as good to select to perform other options as activities 3 and 13 because other selections can increase the cost of the subsequent activities. In addition, it should be noted that the other selections because they can cause undesirable phenomena in the process. Therefore, FLE-Miner can achieve knowledge sharing without transmitting local data, breaking the data silos. It effectively identifies federated low-cost paths from heterogeneous business process event logs while highlighting the inefficient links in the workflow. By sharing this information between clients, it provides reliable decision support for client process optimization.

[0122] Thus, the present application introduces a new problem of mining FLEs across multiple data sources. This new problem has special significance in modern applications because it supports collaborative learning while ensuring client data privacy and security, thereby facilitating knowledge sharing between clients. The algorithm of FLE-Miner proposed in the present application combines five strategies of event splitting, pruning, global lower bound of average cost, filtering, and episode merging to efficiently mine FLEs.

[0123] Moreover, the experimental results show that FLE-Miner outperforms the comparative methods in performance while ensuring privacy protection. More importantly, the case study of real industrial logs shows that FLE-Miner can successfully discover low average cost paths from multiple client local business process event logs without uploading the original data.

[0124] In summary, to integrate multi-source data to discover federated one-time related low average cost episodes (FLE) while maintaining data privacy, the application proposes a cloud-edge collaborative business process intelligent optimization method implemented by FLE-Miner algorithm, which mainly includes two modules: client mining and server aggregation. In the client mining link, the event splitting strategy is adopted in the data preprocessing stage to reconstruct the client business process event log, so as to improve the search efficiency; in the cost calculation stage, through the DBEI algorithm based on the depth first search and backtracking strategy of event index, all occurrences of episodes on the client are identified. For the server aggregation link, in the candidate episode generation stage, in view of the fact that FLE mining does not meet the anti-monotonicity, the pruning strategy and global average cost lower bound are introduced to eliminate the candidate episodes with insufficient potential in advance, and the episode connection strategy is used to generate candidate episodes for subsequent iteration; in the candidate episode distribution stage, the screening strategy and episode merging strategy are designed to generate the merged episode set for each client, effectively reducing the communication cost between heterogeneous clients. The experimental results verify that the FLE-Miner algorithm has superior mining performance while ensuring privacy protection. More importantly, the case study of real industrial logs shows that the application can successfully discover low average cost paths from the local business process event logs of multiple clients without uploading the original data, thereby achieving data privacy protection.

[0125] In addition, referring to Figure 1 According to a second aspect of the embodiment, a storage medium is provided. The storage medium includes a stored program, wherein the program is executed by a processor to perform any of the above methods when the program is running.

[0126] It should be noted that, for the foregoing method embodiments, in order to simply describe, they are all expressed as a series of action combinations, but those skilled in the art should know that the present application is not limited to the action sequence described, because according to the present application, certain steps can be performed in other sequences or simultaneously. Secondly, those skilled in the art should know that the embodiments described in the specification all belong to preferred embodiments, and the actions and modules involved are not necessarily necessary for the present application.

[0127] Those skilled in the art can clearly understand the method according to the above-mentioned embodiments can be realized by means of software and necessary general hardware platform, of course, also can be through hardware, but many cases the former is the better implementation. Based on such understanding, the technical solutions of the present application essentially or say the part of the contribution to the prior art can be embodied in the form of software products, the computer software product is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disc), including a number of instructions to make a terminal device (may be a mobile phone, computer, server, or network equipment, etc.) executes the method described in the embodiments of the present application.

[0128] The above only is the preferred embodiment of the present application, it should be pointed out that, for those skilled in the art, without departing from the principles of the present application, can make a number of improvements and refinements, these improvements and refinements also should be considered as the protection scope of the present application.

Claims

1. A cloud-edge collaborative business process intelligent optimization method, characterized in that, include: Step 1: Each client preprocesses its local business process event log to obtain multiple partial event sequences, and calculates the support, cost, and lower bound of the average cost for each event of length m; wherein, the cost is the sum of the costs of all one-time occurrences of the event in all partial event sequences; the lower bound of the average cost represents the minimum cost of the first occurrence of the event in each partial event sequence; the initial value of m is 1; Step 2: Each client uploads the support level, cost, and lower bound of average cost for each plot to the server after encrypting the plot. Step 3: The server calculates the global confidence, global average cost, and lower bound of the global average cost for each episode. Based on the calculation results, episodes that meet the first condition are added to the first set and the second set, and episodes that meet the second condition are added only to the second set. The first condition is that the global average cost of the episode is less than or equal to the maximum cost threshold and the global confidence is greater than or equal to the minimum relevance threshold; the second condition is that the lower bound of the global average cost of the episode is less than or equal to the maximum cost threshold and the global confidence is greater than or equal to the minimum relevance threshold. Step 4: The server generates a candidate plot set with a plot length of m+1 based on the second set. According to the second set and the candidate plot set, the server generates a corresponding merged plot set for each client, encrypts it, and distributes it to each client. Step 5: Each client uses the multiple partial event sequences to calculate the support, cost, and lower bound of the average cost for each event in the merged event set distributed by the server; Step 6: Repeat steps 2 to 5 until the candidate plot set is empty, and output the final first set as the basis for business process optimization.

2. The method according to claim 1, characterized in that, Each client performs preprocessing operations on its local business process event logs, including: An event splitting strategy is adopted to split the event sequence in the business process event log into multiple initial partial event sequences based on the time interval constraint. The event splitting strategy is as follows: if the time interval between any two consecutive events in the event sequence does not meet the time interval constraint, the event sequence can be split into multiple initial partial event sequences. The lower bound of the average cost for each event in each initial partial event sequence is calculated using the following formula: ； in, This is the expression for each event in a partial event sequence. This represents the i-th activity of the event. This represents the timestamp of the i-th activity. This represents the cost of resources consumed by the i-th activity. Represents events in a partial event sequence The remaining events afterward, Indicates an event The lower bound of the average cost, which is the event... and The minimum cost of all events on a single client; For the event Cost per client d express Any event in, For the event Cost per client; Based on the lower bound of the average cost, each event in all initial partial event sequences is converted into a quadruple form. This yields the final sequence of multiple partial events.

3. The method according to claim 2, characterized in that, Each client calculates the support level for a plot of length m using the following steps: Define plot α as an ordered set of activities, denoted as ,in a and b These are two non-negative integers, representing the minimum and maximum time gap constraints, respectively. This refers to the m-th activity in plot α; Regarding the plot If it exists ,Activity In time It occurs and satisfies ,but t = < t 1, t 2,…, t m > is one occurrence of plot α; another occurrence of plot α is defined as... t' = < t 1', t 2 ' ,…, t m ' >, if and only if 1 ≤ i , j ≤ m , hour, t and t' These are two instances of plot α appearing at once; Define the total number of times plot α appears once in all partial event sequences as the support of plot α in the local business process event log of a single client; Iterate through all partial event sequences of length m in each client, and calculate the length of each sequence. m The total number of times each plot point appears at one time is used as the support level of the corresponding plot point on a single client.

4. The method according to claim 2, characterized in that, The lower bound of the global average cost of the plot is calculated using the following formula: ； in, For plot The lower bound of the global average cost represents the plot of all partial event sequences. The first occurrence of the minimum lower bound of average cost; OOC first For plot α in a partial event sequence The first appearance of it in the text; Represents a partial event sequence Mid-plot The first appearance of the lower bound of average cost; This represents the local business process event log of the j-th client. This indicates the total number of clients.

5. The method according to claim 2, characterized in that, Each client calculates the cost of a plot of length m using the following steps: Step 1.1: Based on the multiple partial event sequences, create an event index set; based on the event index set, construct a network tree with m layers of nodes for a plot of length m; wherein, each event index is the timestamp of each event in that plot; Step 1.2: For each partial event sequence, select the first unused node in the first layer of the network tree. ; Step 1.3: If the node is successfully located Then, under the time interval constraint, in the first... j Search for the first unused child node at level +1. Otherwise, go back to the first... j -1 layer and in the j The layer finds the next node; Step 1.4: Iterate through step 1.3 until a node is found. This indicates that a one-time occurrence of the plot has been found; Step 1.5: Iterate through steps 1.2 to 1.4 until no new one-time occurrences can be detected in any of the partial event sequences, thus obtaining all one-time occurrences of an episode of length m; Step 1.6: Determine the sum of the costs of all one-time occurrences of a plot of length m as the cost of that plot on a single client.

6. The method according to claim 5, characterized in that, The server's operations for calculating the global confidence, global average cost, and lower bound of the global average cost for each episode include: The ratio of the sum of the support for each event across all clients to the sum of the support for each activity within that event across all clients is used as the global confidence score for that event. Calculate the ratio of the sum of the average costs of each episode across all clients to the sum of the support, and use this as the global average cost of that episode; Calculate all events in each episode The sum of the lower bounds of the average cost is used as the lower bound of the average cost of a single occurrence of the plot; the minimum of the lower bounds of the average cost of the first occurrence of the plot in all partial event sequences is used as the lower bound of the global average cost of the plot.

7. The method according to claim 1, characterized in that, The server's operation of generating a candidate plot set with plot length m+1 based on the second set includes: Based on the second set, a plot with a length of [length missing] is generated according to a preset plot connection strategy. m A candidate plot set of +1; wherein, the plot connection strategy is: if the prefix subplot of plot α is the same as the suffix subplot of plot β, then the generated plot has a length of +1. m +1 candidate plot δ, δ=γ⊕α; Based on the candidate plots of all plots in the second set, construct a candidate plot set with a plot length of m+1.

8. The method according to claim 1, characterized in that, The operation of generating a corresponding merged episode set for each client based on the second set and the candidate episode set includes: Calculate the support of each plot in the second set in the local business process event log of the current client, and filter out the target plots with zero support; Prune candidate plots that have the target plot as a prefix or suffix from the candidate plot set to obtain the optimized candidate plot set for the current client; Candidate scenarios with the same prefix in the optimized candidate scenario set are merged into one scenario to obtain the merged scenario set for the current client.

9. The method according to claim 8, characterized in that, Each client utilizes the multiple partial event sequences to calculate the support, cost, and lower bound of the average cost for each event in the merged event set distributed by the server, including: Each client splits each merged plot in the merged plot set distributed by the server into plots of length m+1, resulting in a plot set of length m+1. Each client uses the multiple partial event sequences to calculate the support, cost, and lower bound of the average cost for each plot in the plot set of length m+1.

10. A storage medium, characterized in that, The storage medium includes a stored program, wherein, when the program is executed, the method described in any one of claims 1 to 9 is performed by a processor.

Images