A method and a recommendation system for exploring service patterns in a service composition

Abstract

This invention provides a method and recommendation system for mining service patterns in exploratory service composition. The method includes: acquiring a dataset comprising multiple failed service composition processes, each of which is marked to distinguish between success points, debugging points, and failure points; based on the failed service composition processes and their markings in the dataset, focusing on mining service patterns related to debugging points and / or failure points to obtain failed service patterns. This invention utilizes the markings in the failed service composition processes to focus on mining the data related to failures and ignore the data unrelated to failures, which can significantly reduce the amount of data that needs to be processed and reduce the time required to mine failed service patterns.

Description

Technical Field

[0001] This invention relates to the field of data mining, specifically to a method for mining frequent patterns, and more specifically, to a method and recommendation system for mining service patterns in exploratory service combinations. Background Technology

[0002] Fine-grained atomic services in service systems struggle to meet increasingly complex user needs, leading to sustained research interest in service composition. In problem-solving across application areas such as collaborative research, telemedicine, and urban emergency response, service composition logic is often difficult to predefine fully and requires continuous adjustment during user participation. This has given rise to exploratory service composition, which supports construction as it is executed. During exploratory service composition, numerous service composition processes are generated. Fully utilizing this historical data can enhance the reusability of these processes and improve service composition efficiency.

[0003] Existing technologies abstract service pattern mining into frequent subgraph mining, and their solutions mainly employ two algorithmic approaches: the Apriori algorithm and the FP-growth algorithm.

[0004] Among the mining algorithms applying the Apriori algorithm, there are the AGM algorithm and its improved versions. The AGM algorithm is simple in concept, based on recursive statistics, and can mine all frequent subgraphs, but its execution efficiency is low for large databases. Improved algorithms for the AGM algorithm include the FSG algorithm and the AcGM algorithm, both of which have improved execution efficiency compared to the AGM algorithm.

[0005] The FP-growth algorithm compresses data into a frequent pattern tree, stores the relationships between items, and then generates frequent sets from the pattern tree. Because it doesn't need to generate candidate frequent sets, its execution efficiency is higher than the Apriori algorithm. Frequent subgraph mining algorithms based on this idea include gSpan and FFSM. gSpan's rightmost path expansion and frequent pruning strategies significantly reduce the algorithm's running time; FFSM improves computational speed and efficiency by only scanning all graphs isomorphic to the frequent subgraphs when calculating support, but it cannot support directed graph mining.

[0006] However, the existing technologies mentioned above only focus on mining successful service patterns and have not yet studied the mining of failed service patterns, thus failing to fully utilize the value of the corresponding historical data. Directly applying successful service pattern mining methods to failed service pattern mining would result in unnecessary waste of time and resources, because only a portion of the process trajectory leads to final execution failure, rather than the entire trajectory being a failure. Therefore, it is necessary to improve the existing technologies. Summary of the Invention

[0007] Therefore, the purpose of this invention is to overcome the shortcomings of the prior art and provide a method and recommendation system for mining service patterns in exploratory service composition. Alternatively, it can be described as a method for mining service patterns in exploratory service composition and a service recommendation system for exploratory service composition. Exploratory service composition refers to an application scenario where service composition processes are constructed in an exploratory manner while being executed. This allows for the discovery of service composition processes that meet specific needs.

[0008] The purpose of the present invention is achieved through the following technical solutions:

[0009] According to a first aspect of the present invention, a method for mining service patterns is provided, comprising: acquiring a dataset including multiple failed service composition processes, each of which is marked with a label for distinguishing success points, debug points, and failure points; and focusing on mining service patterns related to debug points and / or failure points based on the failed service composition processes and their labels in the dataset to obtain failed service patterns.

[0010] In some embodiments of the present invention, an incremental mining approach is used to focus on mining service patterns related to debug points and / or failure points.

[0011] In some embodiments of the present invention, the incremental mining approach focuses on mining service patterns related to debug points and / or failure points, including: converting the failed service combination process into graph data represented by nodes and edges, and marking the nodes corresponding to success points, debug points, and failure points in the graph data based on their corresponding labels; calculating the support of the edges connected to debug points and / or failure points and performing rightmost path expansion to obtain the intermediate result of the current mining, the intermediate result containing multiple DFS coding trees and the support of each node in the DFS coding trees; if there is no failed service pattern that has been mined, the intermediate result of the current mining is the intermediate result of the first mining, and nodes of the DFS coding trees with support greater than or equal to the minimum support are extracted from it as frequent subgraphs, and the failed service patterns are obtained after deduplication.

[0012] In some embodiments of the present invention, the incremental mining approach focuses on mining service patterns related to debug points and / or failure points, including: converting the failed service combination process into graph data represented by nodes and edges, and marking the nodes corresponding to success points, debug points, and failure points in the graph data based on their corresponding labels; calculating the support of the edges connected to debug points and / or failure points and performing rightmost path expansion to obtain the intermediate result of the current mining, the intermediate result containing multiple DFS coding trees and the support of each node in the DFS coding trees; if there are already mined failure service patterns, the intermediate result of the current mining is the newly mined intermediate result, the intersection of the nodes of the DFS coding trees in the newly mined intermediate result and the intermediate results of the historical mining are calculated, and the support of the same nodes in the DFS coding trees is superimposed to obtain the intermediate result obtained by incremental mining, from which the nodes of the DFS coding trees with support greater than or equal to the minimum support are extracted as frequent subgraphs, and after deduplication, they are used to update the original failure service patterns.

[0013] In some embodiments of the present invention, the dataset includes multiple successful service composition processes, and the method further includes: performing service pattern mining based on the multiple successful service composition processes to obtain successful service patterns.

[0014] According to a second aspect of the present invention, a service recommendation method is provided, comprising: creating a candidate service composition process based on a user's currently constructed service composition process and multiple candidate services; calculating the semantic matching degree between the user's currently constructed service composition process and each candidate service, determining the successful service patterns contained in the candidate service composition process and the failed service patterns obtained by the method of the first aspect; calculating the constraint strength of the candidate service composition process based on the semantic matching degree of the candidate services contained in the candidate service composition process, the support degree of the contained successful service patterns, and the support degree of the failed service patterns; and determining a recommended service from the multiple candidate services based on the constraint strength of all candidate service composition processes.

[0015] In some embodiments of the present invention, in the service recommendation method, the constraint strength is a weighted sum of the semantic matching degree of the candidate services contained in the candidate service composition process, the support degree of the successful service patterns contained therein, and the support degree of the failed service patterns.

[0016] According to a third aspect of the present invention, a service recommendation system for exploratory service composition is provided, comprising: a service library for managing services, service composition processes, and service patterns, wherein the service composition processes include successful service composition processes and failed service composition processes, and the service patterns include successful service patterns and failed service patterns; an execution engine module for executing user-created service composition processes and providing feedback on the execution results; a user interaction module for providing an interactive interface for users, wherein the interactive interface supports users marking and storing successful and failed service composition processes in the service library during the exploration of corresponding service composition processes, wherein the user adds markers indicating success points, failure points, and debugging points in failed service composition processes based on the corresponding execution results; a service pattern mining module for obtaining a dataset containing service composition processes from the service library and executing the service pattern mining method of the first aspect; and a service recommendation module for executing the service recommendation method of the second aspect and sending the recommended services to the user interaction module.

[0017] According to a fourth aspect of the present invention, an electronic device is provided, comprising: one or more processors; and a memory for storing executable instructions; wherein the one or more processors are configured to implement the steps of the methods of the first aspect and / or the second aspect by executing the executable instructions.

[0018] Compared with the prior art, the advantages of the present invention are:

[0019] This invention acquires a dataset comprising multiple failed service composition processes, each marked with a label to distinguish between success points, debug points, and failure points. Based on the failed service composition processes and their labels in the dataset, the invention focuses on mining service patterns related to debug points and / or failure points to obtain failed service patterns. By utilizing the labels in the failed service composition processes, the invention focuses on mining the data related to failures while ignoring the data unrelated to failures, which can significantly reduce the amount of data to be processed and the time required to mine failed service patterns. Attached Figure Description

[0020] The embodiments of the present invention will be further described below with reference to the accompanying drawings, wherein:

[0021] Figure 1 This is a system diagram of a service recommendation system for exploratory service composition according to an embodiment of the present invention;

[0022] Figure 2 This is a schematic diagram of the module connections for a service recommendation system for exploratory service composition according to an embodiment of the present invention;

[0023] Figure 3This is a schematic diagram of the exploration service composition process according to an embodiment of the present invention;

[0024] Figure 4 This is a flowchart illustrating a method for mining service modes according to an embodiment of the present invention;

[0025] Figure 5 A schematic diagram illustrating the principle of the method for mining service patterns according to an embodiment of the present invention for mining failed service patterns;

[0026] Figure 6 A schematic diagram illustrating the principle of incremental failure service pattern mining according to an embodiment of the present invention.

[0027] Figure 7 Recommended examples of service methods recommended by the present invention and the prior art;

[0028] Figure 8 This is a schematic diagram illustrating the effect of minSup on runtime according to an embodiment of the present invention.

[0029] Figure 9 This is a schematic diagram illustrating the effect of the number of trajectories on the running time when minSup=10 according to an embodiment of the present invention.

[0030] Figure 10 This is a schematic diagram illustrating the effect of the number of mining results on the running time when minSup=10 according to an embodiment of the present invention.

[0031] Figure 11 This is a schematic diagram illustrating the effect of the number of trajectories on the running time when minSup=6 according to an embodiment of the present invention.

[0032] Figure 12 This is a schematic diagram illustrating the effect of the number of mining results on the running time when minSup=6 according to an embodiment of the present invention.

[0033] Figure 13 This is a schematic diagram illustrating the effect of the number of trajectories on the running time when minSup=13 according to an embodiment of the present invention.

[0034] Figure 14 This is a schematic diagram illustrating the effect of the number of mining results on the running time when minSup=13 according to an embodiment of the present invention. Detailed Implementation

[0035] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and specific embodiments. It should be understood that the specific embodiments described herein are merely illustrative and are not intended to limit the invention.

[0036] As mentioned in the background section, existing technologies only focus on mining successful service patterns, neglecting research on mining failed service patterns, thus failing to fully utilize the value of corresponding historical data. The inventors, through analysis and summarization of service combination processes formed by exploratory service combinations, discovered that users' service selections share certain commonalities. Certain services often appear together in a single service combination process, and these fixed service combinations often appear as sub-fragments, exhibiting characteristics such as large granularity and high reusability. Related research refers to such frequently used service combinations as service patterns. Since the execution trajectory of exploratory service combination processes is divided into two types (successful execution and failed execution), existing technologies only focus on mining the service combination processes corresponding to successful execution trajectories (i.e., successful service combination processes) and then making subsequent recommendations to users based on the mined service patterns (i.e., successful service patterns). However, in reality, the service patterns obtained by mining the service combination processes corresponding to failed trajectories (failed service combination processes) are still meaningful for recommendations. Currently, recommendations based on exploratory service combination processes do not effectively utilize the corresponding information (i.e., failed service combination processes and failed service patterns; in existing technologies, failed service combination processes are neither stored nor utilized, let alone used to mine failed service patterns). However, directly applying successful service pattern mining methods to failed service pattern mining leads to unnecessary waste of time and resources. This is because only a portion of the process in a failed process trajectory results in the final execution failure, not the entire trajectory. Therefore, this invention acquires a dataset comprising multiple failed service combination processes, each labeled to distinguish between success points, debug points, and failure points. Based on the failed service combination processes and their labels in the dataset, the invention focuses on mining service patterns related to debug points and / or failure points to obtain failed service patterns. By utilizing the labels in the failed service combination processes, the invention focuses on mining the data related to failures while ignoring data unrelated to failures, significantly reducing the amount of data to be processed and the time required for failing service pattern mining.

[0037] According to one embodiment of the present invention, see Figure 1 This paper provides a service recommendation system for exploratory service composition, including: a service library 1, an execution engine module 2, a user interaction module 3, a service pattern mining module 4, and a service recommendation module 5.

[0038] According to one embodiment of the present invention, a service library 1 is used to manage services, service composition processes, and service patterns. To uncover failed service patterns, the present invention distinguishes between recorded service composition processes, including both successful and failed ones. A service refers to an application that performs a business task with a corresponding function. A service composition process is a business process (also called a service combination or service scheme) that combines multiple services in a certain execution order. For example, during exploratory service composition, a user marks the service composition process A→B→C (combining services A, B, and C) as a successful service composition process, and the service composition process A→C→B (combining services A, B, and C) as a failed service composition process. Successful and failed service composition processes are marked and stored in the service library for subsequent discovery of corresponding service patterns (i.e., frequently occurring patterns, also known as frequent patterns, which can be used to discover service patterns or improve recommended services). Service patterns include successful and failed service patterns. Users can adjust the services, service composition processes, or service patterns stored in the service library as needed.

[0039] According to one embodiment of the present invention, the execution engine module 2 is used to execute a service composition process created by the user and provide feedback on the execution results. For example, after a user creates a service composition process and confirms execution through the user interaction module 3, the execution engine module 2 executes the service composition process and provides feedback on the execution results (also known as service execution results). The user can view the execution results (e.g., whether there is output, whether the output result is ideal, whether there are errors, etc.) and mark the service composition process. The execution engine module 2 can also provide functions such as process parsing, service invocation, and exception handling. Among them, process parsing refers to parsing the process structure information according to the service composition process description to drive process execution; service invocation refers to calling the service corresponding to this node when the process reaches a service node and obtaining the service execution result; exception handling is used to handle and / or report abnormal situations that occur during process execution.

[0040] According to one embodiment of the present invention, the user interaction module 3 is used to provide an interactive interface for the user. This interface allows the user to mark and store successful and failed service combination processes in the service library during the exploration of corresponding service combination processes. Specifically, the user adds markers to failed service combination processes to indicate success points, failure points, and debug points based on the corresponding execution results. For example, the user can mark debug points, find downstream nodes according to the process structure to obtain failure points, and the rest are success points; that is, by default, points after the debug point in the current service combination process are failure points, and points before the debug point are success points. Alternatively, in another implementation, the user can mark debug points and failure points, and the rest are success points. For example, after the service combination process A→C→B is executed, if the user finds an error in the output, determines that service A is a success point, and the problem may lie in C→B, then marks point C, which is adjacent to the success point, as a debug point, and point B as a failure point.

[0041] According to one embodiment of the present invention, the service pattern mining module 4 is used to obtain a dataset containing service composition processes from the service library 1 and execute a method for mining service patterns, wherein the method for mining service patterns is used to mine successful service patterns based on successful service composition processes and to mine failed service patterns based on failed service composition processes.

[0042] According to one embodiment of the present invention, the service recommendation module 5 is used to execute a service recommendation method, obtain and send the recommended services to the user interaction module 3. This allows for better provision of corresponding services to users, enabling them to obtain the required service combinations more accurately and efficiently.

[0043] According to one embodiment of the present invention, see Figure 2 This paper illustrates a service recommendation system for exploratory service composition based on Web services, including a service library 1, an execution engine module 2, a user interaction module 3, a service pattern mining module 4, a service recommendation module 5, and a Web service module 6. The Web service module contains corresponding Web service programs or Web service interfaces. By calling the corresponding Web services, it generates service compositions recorded in the service composition process and returns the corresponding execution results after execution. The service library 1 includes a service management unit for managing corresponding services, a service composition process management unit for managing service composition processes, and a service pattern management unit for managing service patterns. The implementation methods of the service library 1, execution engine module 2, user interaction module 3, service pattern mining module 4, and service recommendation module 5 can refer to the aforementioned embodiments and will not be repeated here. This embodiment adds some illustrative connection relationships, but it should be understood that in actual applications, adjustments can be made according to the implementer's needs, and it is not necessary to follow the connection relationships of this embodiment.

[0044] Once the service recommendation system for exploratory service composition is set up, users can personalize their service composition exploration and discovery, thereby quickly obtaining the required service composition process. The user interaction module supports users in building service composition processes, and users can also execute and adjust the processes at runtime.

[0045] For example, after creating a service composition process in the interactive interface provided by user interaction module 3 (also known as the exploratory service composition user interaction interface), the user confirms execution and sends it to execution engine module 2. In execution engine module 2, user interaction module 3 sends the service composition process to execution engine module 2. Execution engine module 2 requests a service call from Web service module 6. Web service module 6 registers the service with service library 1 and executes the service composition process, then returns the execution result to user interaction module 3. Based on the result, the user can mark the corresponding service composition process (marking successful or failed service composition processes (success points, debug points, failure points)) and send it to service library 1 for storage. Furthermore, the status of the service composition process currently created by the user can be sent to service recommendation module 5 via service library 1 or user interaction module 3. If the user marks a service composition process as failed, service recommendation module 5 can adjust the service used at the debug point based on the marking and recommend other matching services. For example, see... Figure 3The combination of the letter N and the number represents the corresponding service name. Assume that the service combination process created by the user first corresponds to the first trajectory tr1. The service combination method is N1→N2→N3→N4. However, according to the running results, N2 is marked as a debug point, and N3 and N4 are marked as failure points. Correspondingly, the trajectory between N1→N2 is a successful trajectory, and the trajectory between N2→N3→N4 is a failure trajectory. User interaction module 3 (automatically when receiving user instructions or when the currently explored trajectory fails) creates a derived trajectory tr2 based on trajectory tr1. Trajectory tr2 copies the success points and connection relationships from trajectory tr1. Service recommendation module 5 starts from N1 and recommends multiple services (e.g., N5, N...). The user selects N5, and then service recommendation module 5 continues to recommend the next service (e.g., N..., N6, N...) based on N1→N5. The user selects N6, and so on, until the recommendation is completed, resulting in another expected service combination flow, i.e., N1→N5→N6→N7→N8→N9. After execution, it is found that the required result is still not obtained. Assume that after analysis, the user marks N7 as a debug point and N8 and N9 as failure points. Similarly, trajectory tr3 is derived from trajectory tr2, and the successful points marked in tr2 and their connections are copied. Then, services are recommended sequentially starting from N6, ultimately resulting in the service composition process: N1→N5→N6→N10→N11→N12. After execution, based on the results, if the user confirms it is a successful service composition process, the exploration stops. The failed and successful service composition processes obtained during the exploration process can be stored in service library 1 for the purpose of mining successful and failed service patterns.

[0046] To support the failure service pattern mining of this invention, the data structure of the service storage composition process in the service library needs to be adjusted. According to one embodiment of the invention, the data structure of the service storage composition process is configured to include a data structure recording trajectory-related information of the service composition process, values ​​distinguishing successful and failed service composition processes, and values ​​for distinguishing success points, debugging points, and failure points in failed service composition processes (i.e., markers for distinguishing success points, debugging points, and failure points). The values ​​for distinguishing success points, debugging points, and failure points in failed service composition processes can be implemented in different ways. For example, a binary parameter value (such as probePoint mentioned later) can be set, with 0 representing a non-debugging point and 1 representing a debugging point. The default configuration sets points before the debugging point as success points and points after the debugging point as failure points based on the direction in the service composition process. Alternatively, the parameter value can be distinguished using 0, 1, and 2, with 0 representing a success point, 1 representing a debugging point, and 2 representing a failure point. Preferably, to record the user's debugging process for easy viewing by the user or others to improve work efficiency, a data structure showing the trajectory and the derivation relationship of the trajectory's derived process can also be added to the data structure of the service storage composition process. As an example, a schematic data structure for a storage service composition process includes: service composition process instances, trajectories, activities, and data structures corresponding to derivation relationships. The specific definitions of each data structure are as follows: A stored service composition process instance (an instance refers to one exploration process, which may include a service composition process corresponding to a successful trajectory, a service composition process without failures (i.e., successful on the first exploration), or it may include a service composition process corresponding to a successful trajectory and at least one service composition process corresponding to a failed trajectory (successful exploration once or multiple times), or it may include a service composition process corresponding to one or more failed trajectories (never successful exploration)) can be represented as a triple Instance =<instanceID,name,trackSet> This is used to describe an exploratory process that achieves certain goals through a service composition process instance. Here, instanceID represents a unique identifier for the exploratory service composition process instance; name represents the name of the exploratory service composition process instance; and trackSet represents the set of tracks contained within the instance.The trajectory can be represented as Track =<trackProfile,instanceID,status,activities,transitions,directDeriv,dataPocket,exploredState> Here, `trackProfile` represents basic track information, including `trackID`, `name`, `createTime`, etc.; `instanceID` represents the instance to which the track belongs; `status` represents the execution status of the track, `status∈{init, running, suspend, complete, terminated}`; `activities` represents the activities contained in the track; `transitions` represents the connection relationships between the activities contained in the track; `directDeriv` locates the original track in the derivation relationship, defined as `directDeriv=`.<originalTrack,probePoint> Where `originalTrack` marks the parent track of the current derived track, `probePoint` marks the debug point in the original track during derivation, `dataPocket` contains the data information generated during track execution, and `exploredState` represents the track state after exploration is complete, where `exploredState` ∈ {success, failure}. An activity can be represented as Activity =<activityID,activityName,Input,Output,QoS,type,status> Where activityID represents the unique identifier of the activity; activityName represents the activity name; Input represents the set of input parameters; Output represents the set of output parameters; QoS represents the activity quality; type represents the activity type, type∈{service,start,end,orSplit,orJoin,andSplit,andJoin}; status represents the activity execution status, status∈{init,running,suspend,executed}. The connection relationship can be represented as Transition=<tranID,fromAct,toAct,dataMappingSet> Where tranID represents a unique identifier for the connection relationship; fromAct represents the source activity of the connection relationship; toAct represents the target activity of the connection relationship; and dataMappingSet represents a set of data mapping relationships between the source and target activities, where each data mapping can be represented as dataMapping =<SourcePara,TargetPara,mappingExpression> .Here, SourcePara represents the set of input and output parameters of the source node, TargetPara represents the set of input parameters of the target node, and mappingExpression represents the expression for the parameter mapping relationship between SourcePara and TargetPara. The addProbePoint operation can be denoted as addProbePoint(pt, a), where pt is the trajectory and a is the activity. Adding a debug point is only allowed if the state of pt is not terminated and the state of a is executed. This operation generates a new trajectory pt', which is cloned from the original trajectory through the dataMappingSet of the connection relationship and the predecessor activity of debug point a, remaining unchanged. Debug point a and its successor activity are reset and initialized after cloning. The derivation relationship can be represented as a binary unidirectional relationship dr(tr1, tr2), where tr1 represents the original trajectory and tr2 represents the derived trajectory. If two process fragments represent reachable process fragments from the starting node in process trajectories tr1 and tr2 respectively, they are considered identical if they satisfy the following conditions: i. The activity names, input / output parameters, parameter values, and types in the process fragments are exactly the same, and their states are both executed; ii. The source activity, target activity, and data mapping relationships between the activities in the process fragments are exactly the same. If two trajectories share the same reachable process fragment, they are in a derivative relationship, where the trajectory with the smaller createTime is the original trajectory, and the other is the derived trajectory. In this example, although only the setting of debug points is seen, by defining predefined rules, nodes before the debug point can be represented as success points by default, and nodes after the debug point can be represented as failure points by default, thus distinguishing between the three types of nodes. In addition, the data structure of the storage service mode also needs to be adjusted to distinguish between success service mode and failure service mode. As an example, a service pattern model can be represented as SP = {spID, activities, transitions, type}, where spID represents the unique identifier of the service pattern; activities are the activities contained in the service pattern; transitions are the connections between activities; and type is the type of service pattern, defined as type∈{success, failure}, where success represents a successful service pattern and failure represents a failed service pattern. It should be understood that an activity refers to a task, which is executed by a corresponding service; one activity corresponds to one service that executes that activity. Connections are edges, which are directed edges in this application. Connections are also called transitions or transition relationships in some scenarios.

[0047] According to one embodiment of the present invention, the data samples (service composition processes) of the present invention can come from various sources. For example, on one hand, the service pattern mining module 4 can obtain various service composition processes (datasets for a certain time period) generated by users when exploring service compositions from the service library 1, and perform service pattern mining based on the obtained service composition processes according to a method for mining service patterns according to the present invention, to obtain successful service patterns and failed service patterns. The service pattern management module updates the historically mined successful service patterns and failed service patterns, so that the service recommendation module 5 can make subsequent recommendations based on the updated successful service patterns and failed service patterns. As the amount of mined data samples increases, the accuracy of the recommendations is further improved. Moreover, the present invention utilizes the failed service patterns to exclude some service combinations that may lead to failure for users, thereby allowing users to obtain the required service composition processes more efficiently and accurately. On the other hand, see... Figure 2 In the upper right corner, in some cases, users can also obtain service composition processes from other sources to enrich the data sample. Users can import the service composition process and perform corresponding operations through the user interaction module 3, thereby sending the service composition process obtained from other sources to the service pattern mining module 4 for mining service patterns.

[0048] According to an embodiment of the present invention, a method for mining service patterns is provided, comprising: acquiring a dataset including multiple failed service combination processes, each of which is marked to distinguish between success points, debugging points, and failure points; and focusing on mining service patterns related to debugging points and / or failure points based on the failed service combination processes and their markings in the dataset to obtain failed service patterns. The method primarily focuses on mining the following three types of edges: 1. The source vertex of an edge is a success point, and the target vertex is a debugging point; 2. The source vertex of an edge is a debugging point, and the target vertex is a failure point; 3. Both the source vertex and the target vertex of an edge are failure points. In the failed service combination processes of the present invention, the markings distinguish between success points, debugging points, and failure points, allowing information unrelated to failure in the failed service combination processes to be ignored during the mining of failed service patterns. This focuses on mining the data related to failure while ignoring the data unrelated to failure, significantly reducing the amount of data to be processed and the time required for mining failed service patterns.

[0049] To further improve the efficiency of mining failed service patterns, according to an embodiment of the present invention, an incremental mining approach is used to focus on mining service patterns related to debug points and / or failure points. Preferably, the frequent pattern mining algorithm used in the incremental mining process focuses on mining service patterns related to debug points and / or failure points as follows: the failed service combination process is converted into graph data represented by nodes and edges, and the nodes corresponding to success points, debug points, and failure points are marked in the graph data based on their corresponding labels; the support of the edges connected to debug points and / or failure points is calculated and rightmost path expansion is performed to obtain the intermediate result of the current mining, which includes multiple DFS encoding trees and the support of each node in the DFS encoding trees; if no failed service pattern has been mined yet, the intermediate result of the current mining is used as the first... The intermediate results of the previous mining are used to extract nodes of the DFS coding tree with support greater than or equal to the minimum support as frequent subgraphs. After deduplication, the failed service patterns are obtained. Alternatively, if failed service patterns already mined exist, the current intermediate result is considered a newly mined intermediate result. The intersection of the nodes of the DFS coding tree in the newly mined intermediate result and the nodes of the historical intermediate results is calculated, and the support of the same nodes in the DFS coding trees is added together to obtain the intermediate result obtained by incremental mining. From this (i.e., from the intermediate result obtained by incremental mining), nodes of the DFS coding tree with support greater than or equal to the minimum support are extracted as frequent subgraphs. After deduplication, these are used to update the original failed service patterns. It should be noted that the gSpan algorithm can be used to construct the DFS coding tree. Each node in the coding tree is a graph (a graph consisting of nodes and edges corresponding to multiple services), and each node has a corresponding support. When performing rightmost path expansion, different DFS coding trees are formed by expanding from different edges. That is, expanding from one edge will result in a coding tree for that edge, representing a rightmost path expansion starting from that edge. As can be seen from the above technical solutions, incremental mining is based on merging the original intermediate results from the previous mining with the intermediate results generated by the incremental part, and then obtaining the incremental intermediate results. Failure service models are then mined based on these incremental intermediate results. For example, a simplified process can be found here. Figure 4 The process includes step S1: based on the failed service composition process, focusing on mining service patterns related to debugging points and / or failure points to obtain the initial intermediate and final results; and step S2: merging the intermediate results generated by the incremental part with the original intermediate results to obtain the incremental intermediate and final results. If new failed service composition processes are added subsequently, step S2 is repeated. The following is a detailed explanation... Figure 5 To illustrate the principle in a vivid way, Figure 5In this diagram, A, B, C, D, E, F, G, and H represent the corresponding services. After a period of time, assuming a failed service combination process 1-8 is obtained, edges connecting to debug points and / or failure points are extracted to focus on mining service patterns related to debug points and / or failure points, yielding intermediate results. This process is based on the GSpan algorithm, and the incremental mining process for failed service patterns is described below: The mining scope is limited to the vicinity of debug points, and the failed execution trajectories are mined. First, the input set of failed process trajectories T (a dataset consisting of service combination processes over a period) is abstracted into graph data D (graph set). Debug points and failure points are added to the graph data based on the corresponding labels. To focus on mining failure-related patterns, improve efficiency, and avoid interference from successful service patterns, only edges related to debug points and / or failure points are extracted. The extracted edges are sorted using DFS lexicographical order, and then rightmost path expansion mining is performed to obtain a DFS encoding tree and the support of each node. The resulting DFS encoding tree is saved as an intermediate mining result for subsequent incremental mining. Finally, if this is the first mining attempt and no failed service patterns exist in the service library, then nodes of the DFS coding tree with support greater than or equal to the minimum support are extracted as frequent subgraphs based on the intermediate results of the first mining attempt. After deduplication, the failed service patterns are obtained. Deduplication is achieved by, for example, if among all the nodes of the current DFS coding tree, if one DFS coding tree node is a subgraph of another DFS coding tree node, the former is removed, and only the latter (i.e., the other DFS coding tree node) is retained; in other words, if one subgraph is contained within another subgraph, only the latter is retained. If failed service patterns already exist in the current service library, then the input in the above steps is the incremental part, and the obtained intermediate result is the incremental intermediate result, which needs to be merged with the original intermediate result. See [link to illustrative incremental mining process] for an example. Figure 6 As shown: Time t = 0 indicates the first time the dataset T is used based on the data at time t. t The process of discovering failed service patterns is based on the DFS coding tree (DCT) obtained from the initial discovery. t Extract frequent subgraphs (e.g., set minimum support (the threshold for filtering) to 10), and remove duplicates to obtain the first discovered failed service patterns; at time t > 0, for example, time t+1, obtain the dataset for the next period, i.e., the incremental dataset △T collected at time (0, t+1]. t+1 Based on the incremental dataset △T t+1 Mining is performed to obtain the incremental DFS coding tree △DCT at time t+1. t+1 (Corresponding to the intermediate results of newly mined data), based on DCT t and △DCT t+1Find the intersection (i.e. merge) of the nodes of the DFS coding tree and add the support of the nodes of the same DFS coding tree to obtain the intermediate result obtained by incremental mining. Extract the nodes of the DFS coding tree with support greater than or equal to the minimum support as frequent subgraphs. After deduplication, obtain the new failure service pattern (which may be a set of multiple failure service patterns) to update the original failure service pattern.

[0050] According to one embodiment of the present invention, the method for mining service patterns further includes: mining service patterns based on the plurality of successful service combination processes to obtain successful service patterns. For all historically collected successful service combination processes, a frequent pattern mining algorithm can be used. For example, the gSpan (GraphBased Substructure Pattern Mining) algorithm can be used. Alternatively, other existing frequent pattern mining algorithms (such as the Apriori algorithm, AGM algorithm, AcGM algorithm, etc. mentioned in the background art) can also be used.

[0051] Traditional service recommendation methods in the prior art combine semantic matching of service operation interfaces with service patterns mined from service composition process instances (only frequent patterns, without distinguishing between success and failure as in this application) to obtain binary behavioral constraints (constraint strength) between services, and then make recommendations based on these binary behavioral constraints. Specifically, semantic matching degree (μ) can be calculated through semantic matching of input and output interfaces between service operations, and reuse degree (i.e., support of service patterns λ) can be generated through process instance analysis. μ and λ can ultimately yield the constraint strength (τ), and finally, the top N services with high constraint strength (τ) are recommended as recommended services through pattern matching. However, this recommendation method may initially recommend services with high constraint strength, even if the analyzed process instances contain a large number of erroneous process instances. Existing technologies do not record failed service combination processes during user exploration, nor do they differentiate and label node types or mine failed service patterns. To improve the accuracy of exploratory service combination recommendations, thereby improving user efficiency and user experience, according to an embodiment of the present invention, a service recommendation method is provided, comprising: creating candidate service combination processes based on the user's currently constructed service combination process and multiple candidate services; calculating the semantic matching degree between the user's currently constructed service combination process and each candidate service, determining the successful service patterns contained in the candidate service combination process and the failed service patterns obtained by the aforementioned service pattern mining method; calculating the constraint strength of the candidate service combination process based on the semantic matching degree of the candidate services contained in the candidate service combination process, the support degree of the contained successful service patterns, and the support degree of the failed service patterns; and determining the recommended service from multiple candidate services based on the constraint strength of all candidate service combination processes. To facilitate user adjustment of the recommendation effect, preferably, the constraint strength is a weighted sum of the semantic matching degree of the candidate services contained in the candidate service combination process, the support degree of the contained successful service patterns, and the support degree of the failed service patterns. The weights corresponding to the semantic matching degree of the candidate services, the support degree of the successful service patterns, and the support degree of the failed service patterns in the candidate service composition process can be customized. For example, the constraint strength τ is calculated as follows:

[0052] τ=w1×μ+w2×λ-w3×γ;

[0053] Where μ represents the semantic matching degree of the candidate services contained in the candidate service composition process, λ represents the support degree of the successful service pattern contained in the candidate service composition process, γ represents the support degree of the failed service pattern contained in the candidate service composition process, w1 represents the weight of μ, w2 represents the weight of λ, and w3 represents the weight of γ. Where w1>0, w2>0, w3>0, and w1+w2+w3=1. When the constraint strength satisfies τ>χ, where χ is the minimum constraint strength, it is considered that there may be a constraint relationship between services. Otherwise, there is no constraint relationship. Finally, after sorting according to the constraint strength from largest to smallest, recommendations can be made by selecting the top N services that satisfy the constraint relationship. This invention applies two service patterns to exploratory service composition, which on the one hand improves the efficiency of users constructing service composition processes, and on the other hand, fully utilizes domain prior knowledge to improve the reusability of service composition processes.

[0054] According to one embodiment of the present invention, the service recommendation method of the present invention can be used for Web service mining, where nodes are Web services and edges are hyperlinks between Web services, thereby exploratoryly discovering whether the corresponding Web service combination patterns (service combination processes) are successful. However, it should be understood that the service pattern mining method of the present invention is not limited to the service recommendation system described above for exploratory service combination. There are many specific application scenarios in the art that require the use of mined service patterns; for example, in the field of bioinformatics workflows, constructing corresponding service combination processes to process or manipulate gene-related data.

[0055] As an example, see Figure 7 An example of a bioinformatics process is used to illustrate how the use of a failed service pattern can improve the accuracy of service recommendations. Figure 7 The services shown (rectangles) are selected from a single bioflow downloaded from the myexperiment website, serving only as an example of service recommendation to illustrate how failure service patterns are applied in service recommendation. Specifically, the meanings of the various labels in the figures are as follows:

[0056] probeset_list represents a list of probe sets;

[0057] split_probesets represents the set of split probe points;

[0058] hsapiens_gene_ensembl represents the gene database of modern humans;

[0059] Create_report indicates the creation of a report;

[0060] Remove_uniprot_duplicates means removing database copies;

[0061] Remove_entrez_duplicates means removing copies of the retrieval system;

[0062] Remove_nulls means to remove null values;

[0063] Remove_nulls2 means to remove the null value 2;

[0064] Split_for_duplicates indicates splitting into duplicates;

[0065] Concat_kegg_genes means merging genes from the kegg database.

[0066] Traditional methods do not consider failed service patterns, and cannot guarantee the correctness of the analyzed process instances. For example, a successfully constructed and executed bioinformatics process is split_probesets->probeset_list->hsapiens_gene_ensembl. The system then recommends services to provide users with a reference for service selection. The service database currently shows the following services as successors to hsapiens_gene_ensembl: create_report, remove_uniprot_duplicates, remove_entrez_duplicates, remove_Nulls, remove_Nulls2, and split_for_duplicates. Using traditional service recommendation methods, only semantic matching (μ) and the support of successful service patterns (λ) are considered. After calculating the weighted sum of the corresponding weights to obtain the constraint strength (τ) between services, the three services with the highest constraint strength to the current service hsapiens_gene_ensembl are recommended: remove_entrez_duplicates, remove_Nulls2, and create_report. The fragment `hsapiens_gene_ensembl->remove_entrez_duplicates`, upon which this method is based, is a sub-fragment of the failed service pattern `hsapiens_gene_ensembl->remove_entrez_duplicates->concat_kegg_genes` mined in this invention. Although the constraint strength (τ) between these two services is high, using this service may cause the current process to fail. Considering the failed service pattern effectively solves this problem. By comprehensively considering the semantic matching degree (μ), the support of the successful service pattern (λ), and the support of the failed service pattern (γ), the recommendation results are adjusted to `remove_Nulls2`, `create_report`, and `split_for_duplicates`. It should be noted again that the above services, such as `split_probesets`, `probeset_list`, and `hsapiens_gene_ensembl`, all originate from a biological flow in the myexperiment research community and are only used to illustrate how the failed service pattern is applied in the service recommendation method.

[0067] To demonstrate the effectiveness of mining failed service patterns, the applicant crawled 1405 processes from the myexperiment (www.myexperiment.org) research community as an experimental dataset. The 16 most frequent active nodes in these processes were designated as debug points (this was solely for quickly obtaining the data samples needed for the experiment, not representing actual results; in reality, all nodes are successful). Specifically, since all service composition processes crawled from the website could be executed successfully, failed service composition processes were simulated using a program, resulting in 10490 failed service composition processes. The experiment compared the mining efficiency of methods without incremental mining of failed service patterns, methods using incremental mining of failed service patterns, and the gSpan algorithm's indiscriminate mining of service patterns across all edges, as shown in Table 1.

[0068] Table 1

[0069]

[0070] The main experimental parameters are minimum support and the number of trajectories. For example... Figure 8 As shown, with a fixed number of trajectories of 10,000, by adjusting the minimum support, the FSPMA algorithm and the gSpan algorithm have the same mining results, and the former has a significantly shorter running time than the latter. When minSup = 10, the FSPMA algorithm has the highest efficiency improvement compared to the gSpan algorithm.

[0071] In the experiment, a minimum support of 10 was selected to analyze the running time under different numbers of trajectories, such as... Figure 9 As shown, when the number of trajectories increases in units of 1000, with essentially the same mining accuracy, the IFSPMA algorithm used in exploratory service composition exhibits significantly shorter running time than the FSPMA algorithm and the gSpan method as the data volume gradually increases.

[0072] Furthermore, the number of mining results may also affect the runtime of the incremental failure service mode mining method. For minSup=10, the runtime analysis of different algorithms producing the same number of mining results is as follows: Figure 10 It can be seen that as the number of mining results increases, the IFSPMA algorithm significantly reduces the running time compared to the gSpan algorithm, and also reduces the running time compared to the FSPMA algorithm.

[0073] In addition, to examine the experimental results under different minimum support levels, the applicant conducted corresponding experiments for minimum support minSup=6 and minSup=13. The diagram illustrating the impact of the number of trajectories on runtime when minSup=6 is shown below. Figure 11The diagram illustrating the impact of the number of mining results on runtime when minSup=6 is shown in Figure 12; the diagram illustrating the impact of the number of trajectories on runtime when minSup=13 is shown in Figure 13. Figure 13 The diagram illustrating the impact of the number of mining results on the running time when minSup=13 is shown in Figure 14. Since the results are similar to those when minSup=10, the analysis of the results here will not be repeated.

[0074] In summary, the IFSPMA algorithm of this invention effectively focuses mining on the generation of failed service patterns, avoiding the gSpan algorithm's mining of the entire service composition process. Furthermore, the IFSPMA algorithm can adapt to an ever-increasing exploratory service composition environment. Under different minimum support and trajectory number settings, the mining efficiency is improved compared to the other two methods. Specifically, with a minimum support of 10 in the current dataset, the IFSPMA algorithm shows the highest efficiency improvement compared to the gSpan algorithm. As the number of trajectories increases, the efficiency of the IFSPMA algorithm steadily increases by approximately 40% compared to the FSPMA algorithm and by approximately 67% compared to gSpan.

[0075] It should be noted that although the steps are described in a specific order above, it does not mean that the steps must be executed in the above specific order. In fact, some of these steps can be executed concurrently, or even in a different order, as long as the required function can be achieved.

[0076] This invention can be a system, method, and / or computer program product. A computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for causing a processor to implement various aspects of the invention.

[0077] Computer-readable storage media can be tangible devices that hold and store instructions for use by an instruction execution device. Computer-readable storage media can be, for example, including but not limited to, electrical storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or any suitable combination thereof. More specific examples (a non-exhaustive list) of computer-readable storage media include: portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disc read-only memory (CD-ROM), digital multifunction disc (DVD), memory sticks, floppy disks, mechanical encoding devices, such as punch cards or recessed protrusions storing instructions thereon, and any suitable combination thereof.

[0078] The various embodiments of the present invention have been described above. These descriptions are exemplary and not exhaustive, nor are they limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein is chosen to best explain the principles, practical application, or technical improvements to the embodiments in the market, or to enable others skilled in the art to understand the embodiments disclosed herein.

Claims

1. A method for mining service models, characterized in that, include: Obtain a dataset containing multiple failed service composition processes, each with a marker to distinguish between success points, debug points, and failure points. In the service composition process, points after debug points are failure points, and points before debug points are success points. Based on the service composition process and its markers in the dataset that resulted in failures, this study focuses on mining service patterns related to debug points and / or failure points using an incremental mining approach. The study specifically targets the following three types of edges: a) the source vertex of an edge is a success point and the target vertex is a debug point; b) the source vertex of an edge is a debug point and the target vertex is a failure point; c) both the source and target vertices of an edge are failure points. The incremental mining approach specifically targets service patterns related to debug points and / or failure points, including: The failed service composition process is converted into graph data represented by nodes and edges, and the nodes corresponding to success points, debugging points and failure points are marked in the graph data based on their corresponding labels. Calculate the support for edges connected to debug points and / or failure points and perform rightmost path expansion to obtain the intermediate results of the current mining. The intermediate results contain multiple DFS coding trees and the support of each node in the DFS coding tree. If no failed service patterns have been discovered so far, the current intermediate result is the intermediate result of the first mining. Nodes of the DFS coding tree with support greater than or equal to the minimum support are extracted from it as frequent subgraphs. After deduplication, the failed service patterns are obtained. Alternatively, if failed service patterns have been discovered so far, the current intermediate result is the intermediate result of the newly mined mining. The nodes of the DFS coding tree in the newly mined intermediate result and the intermediate results of the historical mining are intersected, and the support of the same nodes in the DFS coding tree is superimposed to obtain the intermediate result obtained by incremental mining. Nodes of the DFS coding tree with support greater than or equal to the minimum support are extracted from it as frequent subgraphs. After deduplication, these are used to update the original failed service patterns.

2. The method according to claim 1, characterized in that, The dataset includes multiple successful service composition processes, and the method further includes: Based on the aforementioned successful service combination processes, service pattern mining is performed to obtain successful service patterns.

3. A method for service recommendation, characterized in that, include: Create a candidate service composition process based on the user's currently constructed service composition process and multiple candidate services; Calculate the semantic matching degree between the user's current service composition process and each candidate service. Determine the successful service patterns contained in the candidate service composition process and the failed service patterns obtained by the method of claim 1 or 2; The constraint strength of a candidate service composition process is calculated based on the semantic matching degree of the candidate services contained in the candidate service composition process, the support degree of the successful service mode, and the support degree of the failed service mode. Based on the constraint strength of all candidate service combination processes, the recommended service is determined from multiple candidate services.

4. The service recommendation method according to claim 3, characterized in that, The constraint strength is a weighted sum of the semantic matching degree of the candidate services contained in the candidate service composition process, the support degree of the successful service patterns contained therein, and the support degree of the failed service patterns.

5. A service recommendation system for exploratory service composition, characterized in that, include: A service library is used to manage services, service composition processes, and service modes. The service composition processes include successful service composition processes and failed service composition processes, and the service modes include successful service modes and failed service modes. The execution engine module is used to execute user-created service composition processes and return the results. The user interaction module provides an interactive interface for users. This interface allows users to mark and store successful and failed service combination processes in the service library during the exploration of the corresponding service combination process. Specifically, users can add markers indicating success points, failure points, and debugging points in failed service combination processes based on the corresponding running results. A service pattern mining module is used to obtain a dataset containing service composition processes from a service library and execute the method for mining service patterns as described in claim 1 or 2. The service recommendation module is used to execute the service recommendation method as described in claim 3 or 4, and send the recommended services to the user interaction module.

6. A computer-readable storage medium, characterized in that, It contains a computer program that can be executed by a processor to implement the steps of the method according to any one of claims 1 to 4.

7. An electronic device, characterized in that, include: One or more processors; as well as Memory, wherein the memory is used to store executable instructions; The one or more processors are configured to implement the steps of the method according to any one of claims 1 to 4 by executing the executable instructions.

Images