A cloud-edge collaborative business process intelligent optimization method and device and storage medium

Abstract

The application 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: step 1, a client preprocesses a local business process event log, and calculates the support, cost and average cost lower bound of a scenario with a length of m; step 2, the client encrypts the scenario and the calculation result and uploads them to a server; step 3, the server calculates the global confidence, global average cost and global average cost lower bound of the scenario, adds scenarios meeting high correlation and low cost to a result set and a candidate set, and adds scenarios meeting high correlation and potential low cost to the candidate set; step 4, the server generates a candidate scenario with a length of m+1 based on the candidate set, and encrypts and distributes the candidate scenario to the client; step 5, the client calculates the support, cost and average cost lower bound of the new candidate scenario; and step 6, steps 2-5 are circularly executed until there is no new candidate scenario, and a final result set is output.

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:

[0005] 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.

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

[0007]

[0008] For episode a = 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 a has two valid one-time occurrences in s1: <1,3> and <5,6>. Similarly, episode a has one valid one-time occurrence in s2: <1,2>. According to the cost value calculation, the global average cost of episode a is [(1+2)×2+(2+3)] / (2+1)=3.67. If maxeacSet to 5, the scenario α meets the condition of low average cost scenario because its average cost does not exceed maxeac Therefore, it can be concluded that the processing machines t and g can be part of the optimal processing path because their production processes do not consume excessive resources.

[0009] However, there are two main limitations in existing research. First, the internal correlation between scenarios and events is not considered, and the mining accuracy is insufficient. For example, in a product order processing workflow, a low-cost path may consist of several low-cost processing machines and some high-cost machines. Even if these operations are weakly or accidentally related, they will still be considered valuable scenarios. Second, existing methods mainly mine centralized data, which often poses a 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 achieve secure and compliant collaborative mining, allowing the potential value of data to flow freely.

[0010] In view of the technical problems in the prior art that the low average cost scenario mining method applied to business process optimization does not consider the internal correlation between scenarios and events, resulting in insufficient mining accuracy, and the lack of privacy protection mechanism in a distributed scenario, no effective solutions have been proposed so far. SUMMARY

[0011] 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 scenario mining method applied to business process optimization does not consider the internal correlation between scenarios and events, resulting in insufficient mining accuracy, and the lack of privacy protection mechanism in a distributed scenario.

[0012] 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.

[0013] 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.

[0014] 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.

[0015] 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

[0016] 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:

[0017] 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;

[0018] 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;

[0019] Figure 3 This is a schematic diagram of the search process of the DBEI algorithm according to the embodiments of this application;

[0020] Figure 4 This is a schematic diagram illustrating the comparison of runtime according to the embodiments of this application;

[0021] Figure 5 This is a schematic diagram illustrating the comparison of the number of candidate scenarios according to the embodiments of this application;

[0022] Figure 6 This is a schematic diagram comparing memory usage according to embodiments of this application;

[0023] Figure 7 This is a schematic diagram illustrating the runtime for different dataset sizes according to the embodiments of this application;

[0024] Figure 8 This is a schematic diagram illustrating memory usage for different dataset sizes according to embodiments of this application;

[0025] Figure 9 This is a schematic diagram comparing the number of transmission candidate scenarios according to an embodiment of this application;

[0026] Figure 10 This is a schematic diagram comparing the number of transmission candidate plot events according to the embodiments of this application;

[0027] 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;

[0028] 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;

[0029] Figure 13is a schematic diagram of a Petri net of the "Gauge" product of the client 3 according to the embodiment of the present application;

[0030] Figure 14 is a schematic diagram of FLEs of the "Gauge" product according to the embodiment of the present application. DETAILED DESCRIPTION

[0031] In order to enable persons skilled in the art to better understand the technical solutions of the present disclosure, the technical solutions in the embodiments of the present disclosure will be clearly and completely described below in conjunction 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 persons skilled in the art without creative labor should be within the protection scope of the present disclosure.

[0032] It should be noted that the terms "first", "second", and the like in the specification and claims of the present disclosure and the above-described drawings are used to distinguish similar objects, and do not necessarily have to describe a specific order or sequence. It should be understood that the data used in this way 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 that includes 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 that are not clearly listed or inherent to these processes, methods, products or devices.

[0033] EMBODIMENT

[0034] 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 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.

[0035] 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 Figure 1As shown, the computing device can include one or more processors (the processor can include, but not limited to, a processing device such as a microprocessor MCU or a programmable logic device FPGA), 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 is only a 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 different configuration from that shown in the figure. Figure 1 The structure shown is only a 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 different configuration from that shown in the figure. Figure 1 The structure shown is only a 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 different configuration from that shown in the figure.

[0036] It should be noted that the one or more processors and / or other data processing circuits described above can be referred to as "data processing circuits" herein. The data processing circuit can be embodied in whole or in part as software, hardware, firmware, or any combination thereof. In addition, the data processing circuit can be a single independent processing module, or all or part of any one of the other elements combined into the computing device. As referred to in the embodiments of the present disclosure, the data processing circuit serves as a processor to control, for example, the selection of the variable resistance terminal path connected with the interface.

[0037] The memory can be used to store software programs and modules of application software, such as program instructions / data storage devices corresponding to the cloud-edge collaborative business process intelligent optimization method in the embodiments of the present disclosure. The processor executes 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. 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 remotely arranged with respect to the processor, which 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 a combination thereof.

[0038] The transmission device is used to receive or send data via a network. Particular examples of the network can include a wireless network provided by a communication provider of the computing device. In one example, the transmission device includes a network interface controller (NIC) that can connect to other network devices through a base station so as to communicate with the Internet. In one example, the transmission device can be a radio frequency (RF) module that is used to communicate with the Internet in a wireless manner.

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

[0040] It is noted herein that, in some alternative embodiments, the above-described 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 Figure 1 is merely one example of a particular implementation and is intended to illustrate the types of components that can be present in the computing device described above.

[0041] The present application finds that frequent episode mining (FEM) is different from the deeply researched sequential 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 methods for mining episodes 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 a Trie tree, which optimizes performance and memory usage through a pruning strategy and is successfully applied to intelligent traffic management systems.

[0042] Although the research on episode mining based on support has been relatively extensive, the research on FEM combining utility factors is still limited. Therefore, utility-oriented mining is proposed as a novel data mining framework, which aims to identify high-utility patterns rather than frequent patterns. However, traditional utility mining ignores the cost or effort required to obtain the patterns. For example, in medical treatment, effective treatment patterns are given priority, but high cost may make the intervention unfeasible. This has prompted the development of low-cost pattern mining methods, which extend the traditional utility mining problem by evaluating the average cost of patterns to minimize the cost. Some scholars define a new task of finding cost-effective event sequences in event logs and design three efficient pattern extraction algorithms; in order to find strongly related patterns, some scholars design a new lower bound of cost to effectively constrain the search space of patterns; for quantitative sequence databases, some scholars propose a new algorithm named 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.

[0043] 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 through collaborative learning paradigms. This growing demand has significantly increased the importance of privacy-preserving 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 datasets, but their performance will significantly decrease when the feature distribution of client data is skewed; in order to mine complete results from databases with different feature distributions, some scholars propose a boundary aggregation strategy to obtain missing information by rescanning client databases 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 cost.

[0044] In summary, the existing low-average-cost cloud-edge collaborative business process intelligent optimization method not only fails to 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 utilization efficiency of communication resources between heterogeneous clients. To achieve more efficient and accurate low-average-cost episode mining, this 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 2The overall framework of the device corresponding to the cloud edge collaboration business process intelligent optimization method proposed in the application is shown.

[0045] Before elaborating on the cloud edge collaboration business process intelligent optimization method proposed in the application, the following definitions are proposed by the embodiments of the application:

[0046] 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 representing the occurrence time; is the cost representing the resource (such as time or money) consumed by the activity. Table 1 shows a business process event log L 1.

[0047] In the embodiments of the application, the definition of scenario is as follows:

[0048] Scenario α is an ordered activity set, denoted as α = e 1[ a , b ] e 2…[ a , b ] e m , which can also be simply denoted as the time gap tgap = [ a , b ] of α= e 1 e 2… e m , where a and b (0≤ a ≤ b ) represent the minimum and maximum time gap constraints, respectively.

[0049] In the embodiments of the application, the definition of one-time occurrence and support degree is as follows:

[0050] For scenario α= [ a , b ] …[a , b ] , if there exists j [1, m ] activity occurs at time and satisfies , then t 1, t 2,…, t m is an occurrence of α. Suppose , ,…, is another occurrence of α if and only if for all 1 ≤ i , j ≤ m , we have , t 1, t 2,…, t m and , ,…, are two one-time occurrences. All one-time occurrences of α in s1 are stored in the set S (α, s1), whose support is the number of one-time occurrences, i.e. sup (α, s1) = | S (α, s1) |. The support of α in the log L is:

[0051] In the embodiments of the present application, the following example 2 illustrates one-time occurrence and support:

[0052] For the business process event log L 1 in table 1 and the scenario α = t[0, 2]g[0, 2]t, its one-time 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.

[0053] In the embodiments of the present application, the cost of a scenario and the global average cost are defined as follows:

[0054] The cost of a scenario on a single client is the sum of the costs of all one-time occurrences of the scenario, denoted as: , where occ is a one-time occurrence of scenario a 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 the supports, denoted as: , where W represents the number of clients.

[0055] In embodiments of the present application, the global confidence of a scenario is defined as follows:

[0056] The global confidence is an important measure for assessing the relevance of events within a scenario, defined as: all-conf (α) = , i.e., the global confidence of scenario a is the ratio of the sum of the supports of scenario a in all clients to the maximum of the sum of the supports of each activity in scenario a in all clients.

[0057] In embodiments of the present application, a federated relevant low average cost scenario (FLE for short) is defined as follows:

[0058] Given a maximum cost threshold maxeac and a minimum relevance threshold mincor , if a scenario a satisfies AC (α) ≤ maxeac and all-conf (α) ≥ mincor , then it is called a federated relevant low average cost scenario (FLE for short).

[0059] In embodiments of the present application, the following Example 3 is provided to illustrate the federated relevant low average cost scenario FLE:

[0060] Consider two clients' business process event logs (Table 1 and Table 2), set tgap = [0, 2], maxeac = 5, mincor = 0.35. All FLEs include {t, g, a, tg, gt, gg}. Take scenario gt as an example: in L 1, the one-time occurrence set 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-time 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 FLE because... AC (gt) = 4 < 5 and all-conf (gt) = 0.375>0.35.

[0061] Table 2: Business Process Event Log L 2

[0062]

[0063] Next, in conjunction with the embodiments of the present invention Figure 2 Based on the above definitions and examples, this application elaborates on the cloud-edge collaborative business process intelligent optimization method. This method mainly comprises two key stages: 1) client-side data mining stage; 2) server aggregation stage. The detailed steps are as follows:

[0064] 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;

[0065] 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.

[0066] 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.

[0067] 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.

[0068] 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;

[0069] Step 6: Repeat steps 2 to 5 until the candidate episode set is empty, and output the final first set as the basis for business process optimization.

[0070] Specifically, the present application adopts a federal collaborative mining framework. First, a plurality of clients each preprocess the business process event log 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 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: 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) are added to the first set (final result set) and the second set (candidate expansion set); at the same time, episodes that meet the conditions of "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 each client after encryption. The clients locally calculate the support, cost, and average cost lower bound of these new candidate episodes and return them encrypted, 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 as the basis for business process optimization.

[0071] The present application introduces global confidence as a core screening index, and forcibly requires the output low-cost scenario (first set) to meet the 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.

[0072] Next, the present application embodiment will expand the technical implementation details of steps 1-6 described above:

[0073] In step 1 described above, the operation of pre-processing the local business process event log by each client includes: adopting an event splitting strategy, and splitting the event sequence in the business process event log into multiple initial partial event sequences according to a 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:

[0074] ;

[0075] wherein, is the expression of each event in the partial event sequence, denotes the i-th activity of the event, denotes the timestamp of the occurrence time of the i-th activity, denotes the cost of the resource consumed by the i-th activity, denotes the remaining events of the event in the partial event sequence, denotes the average cost lower bound of the event , which is the average cost lower bound of the event with the minimum cost of all events on a single client; for an event the cost of an event on a single client, d denotes any event in for an event the cost of an event on a single client; based on the average cost lower bound, convert each event in all initial partial event sequences into a quadruple form , obtaining a final plurality of partial event sequences.

[0076] Specifically, in order to search for 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, directly browsing the original log is inefficient. 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 a plurality of 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. 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 a plurality of partial event sequences.

[0077] In an embodiment of the application, the following Example 4 illustrates the event splitting strategy:

[0078] 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)}.

[0079] In an embodiment of the application, the average cost lower bound of an event is defined as follows:

[0080] event in the event sequence the remaining events after The average cost lower bound of this event is denoted as is the minimum cost of all events in The average cost lower bound of this event is denoted as where d denotes any event in .

[0081] In the embodiments of the present application, the average cost lower bound of the event is illustrated as follows in Example 5:

[0082] In the above Example 4, the remaining events of the first event (t, 1, 1) in the partial event sequence of s1 after conversion are rem ((t, 1, 1)) ={(t, 2, 1)(g, 3, 2)(p, 4, 11)(t, 5, 1)(g, 6, 2)} and the minimum cost thereof is 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)}. L 1' as shown in Table 3.

[0083] Table 3: New business process event log

[0084]

[0085] For the convenience of understanding, the pseudo code of log preprocessing is given as follows:

[0086] Input: Process event log L and time gap threshold tgap

[0087] Output: New process event log

[0088] 1: Initialization ;

[0089] 2: Traverse each event sequence s in the log L

[0090] 3: From to Loop:

[0091] 4: If and do not satisfy the time gap threshold:

[0092] 5: Get partial event sequences according to the event splitting strategy and add them to ;

[0093] 6: End condition judgment

[0094] 7: End inner loop

[0095] 8: End outer loop

[0096] 9: Traverse each partial event sequence s in :

[0097] 10: Traverse each event in s: :

[0098] 11: Calculate ;

[0099] 12: Form a new tuple ;

[0100] 13: Generate an extended event sequence ;

[0101] 14: End inner loop

[0102] 15: Add to ;

[0103] 16: End outer loop;

[0104] 17: Return .

[0105] In the above step 1, each client calculates the support of a scenario of length m by the following steps: according to the definition of scenario a and the definition of support, traverse all events of length m in all partial event sequences of each client, calculate the total number of one-time occurrence of each scenario of length m as the support of the corresponding scenario on a single client.

[0106] In the above step 1, the global average cost lower bound of the scenario is calculated by the following formula:

[0107] ;

[0108] Wherein, is the scenario the global average cost lower bound of the first occurrence of the episode the minimum value of the average cost lower bound of the first occurrence of the episode ooc first the global average cost lower bound of the first occurrence of the episode in the partial event sequence the global average cost lower bound of the first occurrence of the episode in the partial event sequence the global average cost lower bound of the first occurrence of the episode the local business process event log of the jth client the total number of clients

[0109] In the above step 1, in order to calculate the cost of the episode, the most important problem is to find all occurrences of the episode in the client, and the present application adopts the DBEI algorithm which uses the depth-first and backtracking strategy on the event index to search for a one-time occurrence of the episode. The specific steps are as follows:

[0110] Step 1.1: based on the plurality of partial event sequences, create an event index set; based on the event index set, construct a net tree Nettree with m layers of nodes for the episode with a length of m; wherein each event index is the timestamp of each event in the episode;

[0111] Step 1.2: for each partial event sequence, select the first unused node in the first layer of the net tree

[0112] Step 1.3: if the node is successfully located, search for the first unused child node in the mth layer of the net tree under the time gap constraint; otherwise, backtrack to the (m-1)th layer and find the next node in the mth layer; j j

[0113] Step 1.4: iterate step 1.3 until the node is found, indicating that a one-time occurrence of the episode is found;

[0114] Step 1.5: iterate steps 1.2 to 1.4 until no new one-time occurrence can be detected in each partial event sequence, and obtain all one-time occurrences of the episode with a length of m;

[0115] Step 1.6: determine the sum of the costs of all one-time occurrences of the episode with a length of m as the cost of the episode on a single client.

[0116] In the embodiments of the present application, the following example 6 illustrates the calculation process of the episode cost: ​​​

[0117] Example 6: The business process event log in Table 3 above L 1' and scenario a = t[0, 2]g[0, 2]t, the search process of the DBEI algorithm is shown in Figure 3 Fig. 1. In the calculation of the scenario cost, the timestamps of each event are first stored using the event index, as shown in Figure 3 Fig. 2. L The event index set obtained by the DBEI algorithm 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 searches for the occurrence of a from to The specific search steps are as follows:

[0118] 1) The event indexes 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. Therefore, the DBEI algorithm constructs the Nettree structure for scenario a as shown in Figure 3 Fig. 3.

[0119] 2) In , the node is the first unused node in the first layer.

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

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

[0122] 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 In the example, according to step 1.2, the node is the first unused node of the first layer. According to step 1.3, the first unused sub-node of the node that satisfies the time gap constraint is found in the second layer, i.e., the node . However, the node has no sub-node that satisfies the time gap constraint. Therefore, backtracking to the second layer, the next sub-node of the node is found according to step 1.3. In addition, according to step 1.4, it is found that <1, 4, 6> is one occurrence in the node . There is no other occurrence in the node . The search is completed.

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

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

[0125] In step 4 above, the operation of the server to generate a candidate scenario set with a scenario length of m+1 based on the second set includes: generating a candidate scenario set with a scenario length of m+1 based on the second set according to a preset scenario connection strategy; wherein the scenario connection strategy is: if the prefix sub-scenario of the scenario a is the same as the suffix sub-scenario of the scenario b, then generating a candidate scenario d with a scenario length of m+1, d = g m ⊕a; based on the candidate scenarios of all scenarios in the second set, constructing a candidate scenario set with a scenario length of m+1. m

[0126] ​Specifically, candidate episode generation and candidate episode distribution will be introduced below, which are used to generate and distribute the next round of candidate episodes to each client.

[0127] 1) Candidate episode generation

[0128] Since the candidate episode space of low average cost episode mining will grow exponentially due to the global average cost not satisfying the anti-monotonicity, the present application designs various strategies to reduce the number of candidate episodes.

[0129] Firstly, the embodiment of the present application provides the following example 7 to verify that the global average cost of the episode does not satisfy the anti-monotonicity:

[0130] Example 7: Consider the business process event log 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 of the episode and the global average cost, 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.

[0131] In order to prune the candidate episode, the present application first proves that the global confidence satisfies the anti-monotonicity:

[0132] In the embodiment of the present application, Lemma 1 is provided: the support satisfies the anti-monotonicity, that is, if episode β is a sub-episode of α, then sup (β, L) ≥ sup (α, L ).

[0133] In the 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 (α).

[0134] In the embodiment of the present application, the following proof is provided:

[0135] According to Lemma 1, sup (β, L) ≥ sup (α, L ), and since the activity set of β is a subset of α, therefore ≥ . That is all-conf (β) ≥ all-conf (α).

[0136] In the embodiment of the present application, the pruning strategy is: if the global confidence of episode α is lower than the minimum correlation thresholdmincor Then all its superplots can be directly pruned.

[0137] To further reduce the number of candidate plots, designing an effective lower bound for the global average cost is crucial. However, current lower bounds for global average cost rely on a support threshold, which cannot be directly applied to this method since this threshold is not specified in the FLE mining task. As a solution, this application defines a lower bound for the global average cost of plots that does not depend on a support threshold.

[0138] In this embodiment of the invention, the lower bound of the average cost of a plot occurring once is defined as: the cost of a plot α occurring once < t 1, t 2,…, t m The lower bound of the average cost is CLE (α,< t 1, t 2,…, t m >) = .

[0139] In this embodiment of the invention, the lower bound of the global average cost of a plot is defined as follows: the lower bound of the global average cost of plot α 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].

[0140] In this embodiment of the invention, Example 8 is provided to illustrate the lower bound of the global average cost of the scenario:

[0141] 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.

[0142] 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.

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

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

[0145] 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:

[0146] .

[0147] 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.

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

[0149] In this embodiment of the invention, the definitions of the maximum prefix, the maximum suffix, and the plot connection are as follows:

[0150] 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 , bIf β is the largest suffix sub-scenario of γ, denoted as suffix (γ)=β. Since prefix (α)= suffix (γ)=β, a new hyper-scenario δ can be generated by scenario connection, i.e., δ=γ⊕α= h [ a , b ]β[ a , b ] d .

[0151] In the embodiment of the present application, the following example 9 is provided to illustrate the principle of the scenario connection strategy:

[0152] Example 9: Let a scenario γ=t[0,2]g[0,2]t, whose largest prefix sub-scenario and largest suffix sub-scenario are t[0,2]g and g[0,2]t, respectively. If α=g[0,2]t[0,2]g, then the hyper-scenario δ=γ⊕α=t[0,2]g[0,2]t[0,2]g.

[0153] In the embodiment of the present application, the following theorem 4 is provided: all LBE sets of length m +1 H m+1 are contained in the candidate scenario set C m+1 , where C m+1 is generated by the scenario connection strategy from the LBE set m H m This means that the scenario connection strategy is complete.

[0154] In the embodiment of the present application, the following proof is provided:

[0155] By contradiction, assume that there exists an LBE scenario of length m +1 but does not belong to the candidate scenario set . Let the largest prefix sub-scenario and largest suffix sub-scenario of this scenario be and , respectively, and both of them are LBE. According to the definition of the scenario connection strategy, and can be generated by the scenario connection strategy , thus belongs to , which contradicts the assumption.

[0156] In the embodiment of the present application, the following example 10 is provided to show that the scenario connection strategy is superior to the enumeration tree strategy:

[0157] ​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, namely {tg, gt, gg, gp, ga}. Based on the enumeration tree strategy: since each LBE of length 2 generates 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 by the episode-joining strategy, only nine candidate episodes of length 3 are generated, namely {tgt, tgg, tgp, tga, gtg, ggg, ggt, ggp, gga}. Therefore, the episode-joining strategy is superior to the enumeration tree strategy.

[0158] In step 4 above, the operation of generating a corresponding merged episode set for each client from the second set and the candidate episode set 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 a target episode with a support degree of zero; pruning the 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 the 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.

[0159] Specifically, in traditional federated mining, the server will broadcast all original candidate episodes to each client to collect client information. However, there can be significant differences in the distribution of data characteristics 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 a waste of communication resources. To reduce communication costs, the present application designs a screening strategy and an episode merging strategy, and the principles of the two strategies are as follows:

[0160] Screening strategy: if the prefix or suffix sub-episode of a candidate episode has a support degree of zero at a client, the candidate episode can be excluded from the candidate episode set of the client.

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

[0162] In an embodiment of the present application, the following proof is provided:

[0163] According to Lemma 1, the support of a child scenario is greater than or equal to the support of its parent scenario. If the support of a child scenario β on a client is sup (β)=0, then it can be concluded that the support of its parent scenario α (β is a child of α) on the client is sup (α)=0, and thus α can be pruned. In summary, the screening strategy is correct and complete.

[0164] In an embodiment of the present application, the screening strategy is illustrated by the following Example 11:

[0165] In the above Example 10, there are five LBEs of length 2, i.e., {tg, gt, gg, gp, ga}, L The candidate scenarios of length 3 under the time gap constraint [0, 2] are {tgt, tgg, tgp, tga, gtg, ggp, gga}. Meanwhile, it is known that the support of scenario gg in L 2 is zero. Therefore, according to the screening strategy, the candidate scenarios with gg as prefix or suffix can be pruned from the candidate scenario set of L 2, L The candidate scenario set of length 3 under the time gap constraint [0, 2] becomes {tgt, tgp, tga, gtg}.

[0166] The candidate scenario set of L 1 is also {tgt, tgg, tgp, tga, gtg, ggp, gga}. Under the time gap constraint [0, 2], the support of the five LBEs of length 2 is not zero, and thus, L The candidate scenario set of length 3 under the time gap constraint [0, 2] is {tgt, tgg, tgp, tga, gtg, ggp, gga};

[0167] In an embodiment of the present application, the definition of a merged scenario is that a merged scenario contains multiple scenarios with the same maximum prefix, and these scenarios only differ in the last activity.

[0168] In an embodiment of the present application, the scenario merging strategy is that if there are k scenarios with the same maximum prefix, then these k scenarios can be merged into one merged scenario.

[0169] In an embodiment of the present application, the scenario merging strategy is illustrated by the following Example 12:

[0170] In the above Example 11, the candidate scenario set of LThe candidate episode set of step 2 can be converted into a merged episode set {tgtpa, gtg} according to the episode merging strategy. For example, the episodes tgt, tgp and tga have the same prefix tg, and thus can be merged into one merged episode tgtpa.

[0171] Similarly, according to the episode merging strategy, L The candidate episode set {tgt, tgg, tgp, tga, gtg, ggp, gga} of step 1 can be converted into a merged episode set {tgtgpa, gtg, ggpa}.

[0172] In step 5, each client calculates the support, cost and average cost lower bound of each episode in the merged episode set distributed by the server using the plurality of partial event sequences, including: each client splits each merged episode in the merged episode set distributed by the server into episodes with length m+1 to obtain an episode set with length m+1; and each client calculates the support, cost and average cost lower bound of each episode in the episode set with length m+1 using the plurality of partial event sequences.

[0173] In the embodiment of the application, the principle of the cloud-edge collaborative business process intelligent optimization method proposed in the application is illustrated as follows in Example 13:

[0174] Example 13: Given the business process event logs of two clients (such as Table 1 and Table 2), set the time gap constraint tgap =[0, 2], the maximum cost threshold maxeac =5, the minimum correlation threshold mincor =0.35.

[0175] Step 1: In the ClientMining phase, the preprocessed new business process event log of client 1 L 1' is shown in Table 3. As described in Example 6, L The event index set of 1' 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]}} The support of episodes t, g, p and a in 1' is 6, 6, 3 and 3 respectively, the cost is 9, 14, 23 and 8 respectively, and the average cost lower bound is 1, 1, 1 and 2 respectively. Similarly, the preprocessed log of client 2 L 1' is shown in Table 3. As described in Example 6, L2' and in Table 2 L 2. Consistent, its event index set is: {s1': { 't': [2], 'g': [1,5], 'p': [6], 'a': [3,4]}}. The events t, g, p, a are in... L The support levels in 2 are 1, 2, 1, 2, the costs are 1, 6, 8, 8, and the lower bounds of the average cost are 1, 1, 8, 3.

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

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

[0178] Step 4: The server uses a plot connection strategy to... H 1. Generate a set of candidate plots C 2. For example, plot t generates candidate plots tt, tg, tp, ta. This step generates a total of 16 candidate plots (4 × 4), all of which are retained in... C In step 2, after applying the filtering and story merging strategy, the merged story set for client 1 and client 2 is {ttgpa, gtgpa, ptgpa, atgpa}, which is then encrypted and distributed to each client.

[0179] Step 5: Client 1 and Client 2 use their local business process event logs to calculate the support, cost, and lower bound of the average cost for each event in the merged event set. For example, event tt in L In 1, the support, cost, and lower bound of cost are 2, 6, and 2, respectively, while... L Both values ​​in option 2 are 0.

[0180] Step 6: By iterating through steps 2 to 5, the final set of FLEs is obtained. M = {t, g, a, tg, gt,gg}.

[0181] For ease of understanding, the pseudocode for the FLE-Miner algorithm is given below:

[0182] Input: Client process event log L Parameter W, time interval tgap and maximum cost threshold maxeac ;

[0183] Output: Set of FLEs M ;

[0184] 1: Initialize m to 1;

[0185] 2: Call ClientMining( L [ j ], NULL, tgap ) to generate an initial queue Q;

[0186] 3: Loop while queue Q is not empty:

[0187] 4: For each episode a in Q:

[0188] 5: Compute global confidence all-conf (α) for episode a;

[0189] 6: If all-conf (α) ≥ minimum relevance threshold mincor ;

[0190] 7: Compute AC (α) for episode a;

[0191] 8: If AC (α) ≤ maximum cost threshold maxeac ;

[0192] 9: Add episode a to set M and set H m ;

[0193] 10: Else:

[0194] 11: Compute for episode a;

[0195] 12: If LBC (α) ≤ maximum cost threshold maxeac ;

[0196] 13: Add episode a to set H m ;

[0197] 14: End relevance judgment;

[0198] 15: End cost judgment;

[0199] 16: End confidence judgment;

[0200] 17: End iteration;

[0201] 18: Use episode connection strategy to connect episodes from Hm The next layer of candidate episode set C is generated m+1 ;

[0202] 19: Update m for m +1;

[0203] 20: If set C m is empty:

[0204] 21: Break the loop;

[0205] 22: End the judgment;

[0206] 23: According to the filtering strategy and episode merging strategy, generate the merged episode set for each client ;

[0207] 24: Call UpdateQueueQ;

[0208] 25: End the loop;

[0209] 26: Return set M。

[0210] For ease of understanding, the pseudo code for calling ClientMining is given as follows:

[0211] Input: business process event log , merged episode set , and time gap tgap ;

[0212] Output: episode set ;

[0213] 1: Initialize set empty;

[0214] 2: If set is empty:

[0215] 3: Initialize m 1;

[0216] 4: Preprocess the business process event log to generate partial event sequences , create an event index set based on the partial event sequences , calculate the support, cost and average cost lower bound of episodes with length 1, and add them to the result set ;

[0217] 5: End condition judgment;

[0218] 6: When Loop if not empty:

[0219] 7: iterate through each episode a in

[0220] 8: compute the support of episode a in the business process event log DBEI( , a, tgap );

[0221] 9: compute the frequency of episode a in the business process event log

[0222] 10: compute the duration of episode a in the business process event log

[0223] 11: add the support , and of episode a to the set

[0224] 12: end iteration;

[0225] 13: end loop;

[0226] 14: return the set .

[0227] In embodiments of the application, the following theorem 6 is provided:

[0228] The space complexity of FLE-Miner is O ( W ×( N + m ×( K + N / z ))) where W , N , m , K and z denote the number of clients, the maximum length of the business process event log of a client, the maximum length of a candidate episode, the maximum number of candidate episodes, and the size of the active set Σ, respectively.

[0229] In embodiments of the application, the following proof is provided:

[0230] First, each client needs to scan the business process event log to create an event index, which is used to store the index of each event, so the space complexity of creating an event index is O ( N ​​​​​​​). Moreover, each client needs to store the candidate scenarios, resulting in a space complexity of O ( m × K ) for each client. Finally, the space complexity of the DBEI algorithm is known to be O ( m × N / z ). Thus, the space complexity of FLE-Miner is O ( N + m ×( K + N / z )) for each client. Since there are W clients, the space complexity of FLE-Miner is O ( W ×( N + m ×( K + N / z ))).

[0231] 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 ).

[0232] In an embodiment of the application, it is provided that the proof is as follows:

[0233] 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 the DBEI algorithm is O ( m × N / z ) for a single candidate scenario, and thus the time complexity of DBEI is O ( m × N / z × K ) for all candidate scenarios. In summary, the time complexity of FLE-Miner isO W K N m N z K

[0234] 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.

[0235] Among them, the introduction of the data sets and the comparative algorithms is as follows:

[0236] 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.

[0237] Table 4: Details of data sets

[0238]

[0239] 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:

[0240] 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.

[0241] 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.

[0242] ​​​​​​​​3. Sow-H and MatchDB-O: To analyze the efficiency of DBEI algorithm, this paper proposes Sow-H and MatchDB-O algorithm. 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.

[0243] 4. FMIAR: To verify the efficiency of the filtering strategy and the episode merging strategy, this paper considers the FMIAR algorithm, which distributes all the original candidate episodes generated by the server to each client.

[0244] The performance of FLE-Miner is introduced as follows:

[0245] To verify the mining performance of FLE-Miner, this paper selects five comparison algorithms: FLE-Df, FLE-Bf, FLE-NoPre, Sow-H and MatchDB-O. The experimental data sets ELog1-ELog8 are used for evaluation, and 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. Since all six algorithms are complete, the number of FLEs they mine in each data set is the same, and the specific number is 62, 295, 310, 519, 258, 362, 66 and 64. The comparison results of running time, candidate episode number and memory usage on ELog1-ELog8 are shown in Figures 4-6

[0246] This paper can draw the following conclusions:

[0247] 1. FLE-Miner is superior to FLE-Df and FLE-Bf, which verifies the superiority of the episode connection strategy over the enumeration tree strategy using depth-first search and breadth-first search. As shown in Figure 5 , the number of candidate episodes generated by FLE-Miner is less than that of FLE-Df and FLE-Bf, and Figure 4 ​FLE-Miner is significantly faster than both algorithms. For example, on ELogl, FLE-Df takes 40.90 seconds to generate 8,712 candidate episodes, FLE-Bf takes 22.13 seconds to generate 4,917 candidate episodes, and FLE-Miner takes only 4.30 seconds to generate 1,219 candidate episodes. This is because FLE-Df and FLE-Bf use the depth-first search and breadth-first search tree enumeration strategies that generate more candidate episodes than the episode connection strategy used by FLE-Miner. As a result, FLE-Miner computes fewer candidate episodes than FLE-Df and FLE-Bf, and performs better.

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

[0249] 3. FLE-Miner is faster than Sow-H and MatchDB-O on all datasets, 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 stems from the different matching algorithms used by these methods. Sow-H and MatchDB-O use linear search to locate the position of subsequent events and perform multiple verifications, which is an inefficient method with significantly higher computational cost compared to FLE-Miner. However, FLE-Miner is able to find the best match for each episode in a single pass, which is a more efficient approach. Figure 6FLE-Miner's memory consumption is slightly higher than Sow-H and MatchDB-O. For example, on ELog3, FLE-Miner uses 224.41 Mb memory, while Sow-H and MatchDB-O consume 223.45 Mb and 223.26 Mb memory, respectively. This increased memory usage is due to the additional event index that FLE-Miner creates for optimizing pattern detection. Overall, FLE-Miner achieves a significant speedup with only a slight increase in memory usage, outperforming Sow-H and MatchDB-O.

[0250] Scalability is introduced as follows:

[0251] To evaluate FLE-Miner's scalability, we compare it with FLE-Df, FLE-Bf, FLE-NoPre, Sow-H, and MatchDB-O using the ELog8 dataset. We create six scaled datasets of ELog8, named ELog8_1, ELog8_2, ELog8_3, ELog8_4, ELog8_5, and ELog8_6, 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 7 and Figure 8

[0252] FLE-Miner's running time and memory usage grow at a lower rate than the size of the dataset. 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 its memory usage is 120.79 Mb, which is a running time growth factor of 7.69 / 1.32 ≈ 5.826 and a memory usage growth factor of 120.79 / 110.30 ≈ 1.095 compared to the performance on ELog8_1. The results for 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, all of which exceed FLE-Miner's running time growth factor of 5.826. However,​Figure 8 The memory usage growth factor (1.095) of FLE-Miner is higher than that of the comparative algorithm. The reason is explained in the previous section. In summary, FLE-Miner shows better scalability in general.

[0253] The mining capability of FLE-Miner is as follows:

[0254] To verify the effectiveness of the filtering strategy and the episode merging strategy, the present application takes FMIAR as the comparative algorithm and uses ELog1-ELog8 as the experimental data sets. 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

[0255] 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 10 Compared with FMIAR, FLE-Miner transmits fewer candidate episodes and episode events to the client. For example, on ELog3, FMIAR transmits 117,018 candidate episodes containing 353,643 events to the client, while FLE-Miner only transmits 93,523 candidate episodes containing 178,074 events, with a compression rate of 49.65%. The reason is that the filtering strategy pre-judges the redundant episodes of certain clients through the prefix and suffix episode information of the 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.

[0256] In the embodiments of the present application, the following case studies are given:

[0257] ​As a case study, the present application investigates the federated application of FLE-Miner in product order production process logs to identify sequences of processing activities that contribute to low cost. The cost of a product processing activity can depend not only on the current activity itself, but also on previous processing activities. Thus, different activity choices can result in 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 product order production processes. To reduce the complexity of the mining scenario, the present application extracts only the processes 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 processes of the "Gauge" product for Client 1, Client 2, and Client 3 as three Petri nets, as shown in FIG. 1. Figures 11-13

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

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

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

[0261] In summary, to integrate multiple data sources to discover federated one-time related low average cost episodes (FLEs) while maintaining data privacy, the present application proposes a cloud-edge collaborative intelligent optimization method for business processes realized 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 logs, thereby improving the search efficiency; in the cost calculation stage, the DBEI algorithm is used to identify all occurrences of episodes on the client based on the depth-first search and backtracking strategy of event index. For the server aggregation link, in the candidate episode generation stage, given that FLE mining does not satisfy anti-monotonicity, the pruning strategy and global average cost lower bound are introduced to eliminate potential candidate episodes in advance, and the episode connection strategy is used to generate candidate episodes for subsequent iteration; in the candidate episode distribution stage, the filtering strategy and episode merging strategy are designed to generate a 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 on real industrial logs shows that the present application can successfully discover low average cost paths from multiple clients' local business process event logs without uploading raw data, thus realizing data privacy protection.

[0262] Further, referring to Figure 1 According to a second aspect of the present embodiment, a storage medium is provided. The storage medium includes a stored program, wherein the program is executed by a processor when the program is run.

[0263] It should be noted that, for the foregoing method embodiments, for the sake of simple description, 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 by 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 are all preferred embodiments, and the actions and modules involved are not necessarily essential to the present application.

[0264] Those skilled in the art can clearly understand the method according to the above-mentioned embodiments can be realized by means of software and the necessary general hardware platform, of course, it can also be realized by hardware, but in many cases the former is a better implementation. Based on such understanding, the technical solutions of the present application can be embodied in the form of a software product, which is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk) and includes a plurality of instructions for causing a terminal device (which can be a mobile phone, computer, server, or network device, etc.) to execute the method described in the embodiments of the present application.

[0265] The above is only the preferred embodiment of the present application, it should be noted 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 should also 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 +1 level 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.

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