KR102777453B1 - System and method for auto-completing roboting processing automation based on history - Google Patents

Abstract

A system and method for robotic processing automation scenario auto-completion based on history are disclosed. According to one embodiment, the system for robotic processing automation scenario auto-completion based on history includes: a search module which generates a search target scenario pattern from a new scenario being written, and searches for one or more candidate scenario patterns corresponding to the search target scenario pattern from a scenario pattern repository; a selection module which selects one final candidate scenario pattern from among the candidate scenario patterns by considering an occurrence frequency of each of the candidate scenario patterns searched; and a scenario auto-completion module which extracts one or more candidate scenarios including the selected candidate scenario pattern from the scenario repository, and selects one of the candidate scenarios as an auto-completion reference scenario by considering an execution history of each of the candidate scenarios.

Description

System and method for AUTO-COMPLETING ROBOTING PROCESSING AUTOMATION BASED ON HISTORY

The disclosed embodiments relate to robotic process automation technologies.

Robotic Process Automation (RPA) is a technology that allows software robots to imitate and perform simple, repetitive tasks performed by users on a PC according to a pre-determined scenario. RPA mainly includes software that designs scenarios to perform actions such as sending and receiving emails, writing documents, and recording/re-entering data, and provides the function to execute them.

In order to automate repetitive tasks through RPA, an automation scenario is required. In the past, scenarios were written by simulating a series of actions on the user interface of the user's computer in software, setting property values so that the results would work well, and repeating multiple debugging or simulations to correct the property values. However, in this case, since the scenarios that had already been written could not be used, the same scenarios had to be developed repeatedly, and there was no way to verify whether the settings of the newly written scenario were optimal, so there was a problem that the development time was long and the success of the performance could not be guaranteed even after development.

Republic of Korea Patent Publication No. 10-2160344 (2020.09.21)

The disclosed embodiments are intended to provide technical means for efficiently creating robotic process automation scenarios.

According to an exemplary embodiment, a robotic processing automation scenario auto-completion system is provided, including a search module which generates a search target scenario pattern from a new scenario being written and searches for one or more candidate scenario patterns corresponding to the search target scenario pattern from a scenario pattern repository; a selection module which selects one final candidate scenario pattern from among the candidate scenario patterns by considering an occurrence frequency of each of the candidate scenario patterns searched; and a scenario auto-completion module which extracts one or more candidate scenarios including the selected candidate scenario pattern from the scenario repository and selects one of the candidate scenarios as an auto-completion reference scenario by considering an execution history of each of the candidate scenarios.

The above system may further include a scenario pattern extraction module that generates one or more scenario patterns from one or more pre-written scenarios stored in the scenario repository and stores the generated scenario patterns in the scenario pattern repository.

The above scenario pattern extraction module can store an identifier (ID) for each of the above scenario patterns, a previous scenario pattern, an identifier (ID) of a corresponding scenario, and a storage location in the above scenario pattern storage.

The above scenario pattern extraction module can, if a scenario pattern identical to the storage target scenario pattern is already stored in the scenario pattern storage, add the identifier and storage location of a scenario corresponding to the storage target scenario pattern to the entry of the identical scenario pattern.

The above search module can generate one or more search target scenario patterns that include the last added step among the new scenarios and have a length greater than a set value.

The above search module can sequentially search the scenario pattern storage considering the length of the one or more search target scenario patterns, and extract the one or more candidate scenario patterns that include the same scenario pattern as the search target scenario pattern and additionally include one more behavior pattern.

The above selection module can select N candidate scenario patterns by considering the occurrence frequency of one or more candidate scenario patterns, and select the final candidate scenario pattern by filtering the selected N candidate scenario patterns using preset lower threshold values and upper threshold values.

The above selection module may select, if there is a candidate scenario pattern exceeding the upper threshold value among the N candidate scenario patterns, the candidate scenario pattern with the highest occurrence frequency among the candidate scenario patterns exceeding the upper threshold value as the final sign scenario pattern.

The above selection module can set a candidate scenario pattern selected by the user from among the remaining candidate scenario patterns as the final sign scenario pattern when the number of candidate scenario patterns remaining as a result of the filtering is two or more.

The above auto-completion module can select the auto-completion reference scenario by considering the number of executions and success rate of each of the one or more candidate scenarios during a preset period.

The above auto-completion module can generate object information and attribute information of a new additional step of the new scenario by using one or more step object information and attribute information included in the above auto-completion reference scenario.

According to another exemplary embodiment, a method for robotic processing automation scenario auto-completion is provided, including the steps of: generating a search target scenario pattern from a new scenario being written, and searching for one or more candidate scenario patterns corresponding to the search target scenario pattern from a scenario pattern repository; selecting one final candidate scenario pattern among the candidate scenario patterns by considering an occurrence frequency of each of the searched candidate scenario patterns; and extracting one or more candidate scenarios including the selected candidate scenario pattern from the scenario repository, and selecting one of the candidate scenarios as an auto-completion reference scenario by considering an execution history of each of the candidate scenarios.

The above method may further include a scenario pattern extraction step of generating one or more scenario patterns from one or more pre-written scenarios stored in the scenario repository and storing the generated scenario patterns in the scenario pattern repository.

The above scenario pattern extraction step can store an identifier (ID) for each of the above scenario patterns, a previous scenario pattern, an identifier (ID) of a corresponding scenario, and a storage location in the above scenario pattern storage.

The above scenario pattern extraction step can add an identifier and storage location of a scenario corresponding to the storage target scenario pattern to the entry of the same scenario pattern if a scenario pattern identical to the storage target scenario pattern is already stored in the scenario pattern storage.

The above searching step can generate one or more search target scenario patterns that include the last added step among the new scenarios and have a length greater than or equal to a set value.

The above-described searching step can sequentially search the scenario pattern storage by considering the length of the one or more search target scenario patterns, and extract the one or more candidate scenario patterns that include the same scenario pattern as the search target scenario pattern and additionally include one more behavior pattern.

The above-described selecting step may select N candidate scenario patterns by considering the occurrence frequency of one or more candidate scenario patterns, and filter the selected N candidate scenario patterns by using preset lower threshold values and upper threshold values to select the final candidate scenario pattern.

The above-described selecting step may select, if there is a candidate scenario pattern exceeding the upper threshold value among the N candidate scenario patterns, the candidate scenario pattern with the highest occurrence frequency among the candidate scenario patterns exceeding the upper threshold value as the final sign scenario pattern.

The above-mentioned selecting step may set a candidate scenario pattern selected by the user from among the remaining candidate scenario patterns as the final sign scenario pattern if the number of candidate scenario patterns remaining as a result of the above-mentioned filtering is two or more.

The above auto-completion step may select the auto-completion reference scenario by considering the number of executions and success rate of each of the one or more candidate scenarios during a preset period.

The above auto-completion step can generate object information and attribute information of a new additional step of the new scenario by using one or more step object information and attribute information included in the auto-completion reference scenario.

According to the disclosed embodiments, a scenario can be completed by finding an identical scenario applicable to a stage currently under development among previously written automation scenarios and automatically setting the attribute values of the current stage. Accordingly, the development productivity of a robotic processing automation scenario can be increased, and since a new scenario is created based on an existing verified scenario, the possibility of errors occurring during operation can be reduced.

Figure 1 is a block diagram for explaining a robotic processing automation scenario automatic completion system (100) according to one embodiment.
Figure 2 is a flow chart for explaining in detail the operation of the scenario pattern extraction module (102) of the robotic processing automation scenario automatic completion system (100) according to one embodiment.
Figure 3 is a flow chart for explaining in detail the operation of the search module (104) of the robotic processing automation scenario automatic completion system (100) according to one embodiment.
Figure 4 is a flow chart for explaining in detail the operation of the selection module (106) of the robotic processing automation scenario automatic completion system (100) according to one embodiment.
FIG. 5 is a flow chart for explaining in detail the operation of the scenario auto-completion module (108) of the robotic processing automation scenario auto-completion system (100) according to one embodiment.
Figure 6 is a flow chart for explaining a method (600) for automatically completing a robotic processing automation scenario according to one embodiment.
FIG. 7 is a block diagram illustrating a computing environment including a computing device suitable for use in exemplary embodiments.

Hereinafter, specific embodiments of the present invention will be described with reference to the drawings. The following detailed description is provided to help a comprehensive understanding of the methods, devices, and/or systems described herein. However, this is only an example and the present invention is not limited thereto.

In describing embodiments of the present invention, if it is judged that a detailed description of a known technology related to the present invention may unnecessarily obscure the gist of the present invention, the detailed description will be omitted. In addition, the terms described below are terms defined in consideration of their functions in the present invention, and may vary depending on the intention or custom of the user or operator. Therefore, the definitions should be made based on the contents throughout this specification. The terms used in the detailed description are only for describing embodiments of the present invention, and should never be limited. Unless clearly used otherwise, the singular form includes the plural form. In this description, expressions such as "comprises" or "comprising" are intended to indicate certain features, numbers, steps, operations, elements, parts or combinations thereof, and should not be construed to exclude the presence or possibility of one or more other features, numbers, steps, operations, elements, parts or combinations thereof other than those described.

Before describing the disclosed embodiments, the terms used in this specification are defined as follows.

Scenario: refers to a configuration in which a software robot can automatically perform tasks to be automated. A scenario is composed of one or more scenario steps, each corresponding to a task step that constitutes a task to be automated.

Action Pattern: A pair of actions (tasks) that are actually performed in a specific step (Activity) that constitutes a scenario and the target of the action. For example, the action pattern of clicking on the search engine of a search engine consists of the following actions and targets.

Example) Clicking the search button = Action (click) + Target (search page button)

Scenario phase: This refers to a behavior pattern that is specified to be executable by combining it with actual property values. The relationship between a behavior pattern and a scenario phase is similar to the relationship between a class and an object (Instance) of a class in a programming language.

Behavior Pattern Identifier: This refers to a unique value generated by combining the essential attribute values of the action and the target. In the disclosed embodiments, the behavior pattern identifier may be a value obtained by hashing the essential attribute values of the action and the target through a hash function. In the following description, it is expressed in a simplified form such as "A01" for convenience.

Scenario pattern: refers to a pattern of sequential actions that have a sequence.

Scenario Pattern Length: The number of behavior patterns that a scenario pattern has.

Scenario Pattern Identifier: This refers to a unique ID value generated by combining behavior pattern identifiers in order and using a hash function.

In the disclosed embodiments, an action means a specific task performed in a single scenario step, such as execution of a program, mouse click, input of text, or a specific task defined by a user, and is generally expressed in the form of a single function in an automation scenario. In addition, the target of the action can be expressed as an object calling the action and a property of the object.

The properties of an object that is the target of an action can be divided into essential properties and optional properties. The essential properties of an object are properties that are invariable and appear in each object, while optional properties are properties that are expressed differently for each object. There is no absolute standard for distinguishing between essential and optional properties for each object, and they can be appropriately defined as needed.

From this perspective, a behavior pattern can be understood as a combination of only the essential properties of a behavior and an object, and a scenario step can be understood as a combination of optional properties to specify behavior options and objects in a behavior pattern so that the behavior pattern can actually be executed within the scenario. This can be summarized as follows.

Behavior Pattern = Behavior + Object Required Properties

Scenario Step = Action + Action Options + Object Required Properties + Object Optional Properties

For example, the behavior pattern of clicking the Google search button in the Chrome browser can be determined as follows:

Chrome Google Search Button Click Behavior Pattern =

Click +

Button required attributes (Chrome, "www.google.com", tag="input" type="submit")

Additionally, the scenario steps of the Google search button click action can be determined as follows.

Chrome Google Search Button Click Scenario Steps =

Click +

Execution options (Mouse Lbutton Click, position=(54, 24), Delay 100ms, Timeout 10 seconds) +

Button required attributes (Chrome, www.google.com, tag="input" type="submit") +

Button selection attributes (name="btnK", class="gNO89b", aria-label="Google Search" value="Google Search", size="973, 555, 111, 36")

FIG. 1 is a block diagram for explaining a robotic processing automation scenario automatic completion system (100) according to one embodiment. As illustrated, the robotic processing automation scenario automatic completion system (100) according to one embodiment includes a scenario pattern extraction module (102), a search module (104), a selection module (106), and a scenario automatic completion module (108).

The scenario pattern extraction module (102) generates one or more scenario patterns from one or more pre-written scenarios stored in the scenario repository (110) and stores them in the scenario pattern repository (112). The scenario repository (110) is a database that stores and manages one or more pre-written scenarios. In addition, the scenario pattern repository (112) is a database that stores and manages one or more scenario patterns extracted from the scenarios.

In one embodiment, the scenario pattern extraction module (102) may store the identifier (ID) of each scenario pattern, a previous scenario pattern, an identifier (ID) of a corresponding scenario, and a storage location together with the scenario pattern in the scenario pattern storage (112). If a scenario pattern identical to the storage target scenario pattern is already stored in the scenario pattern storage (112), the scenario pattern extraction module (102) may add the identifier and storage location of the scenario corresponding to the storage target scenario pattern to the entry of the identical scenario pattern.

The search module (104) generates a search target scenario pattern from a new scenario being written, and searches for one or more candidate scenario patterns corresponding to the search target scenario pattern from the scenario pattern storage (112).

In one embodiment, the search module (104) may generate one or more search target scenario patterns that include the last added step of the new scenario being written and have a length greater than or equal to a set value. Thereafter, the search module (104) may sequentially search the scenario pattern storage (112) considering the length of each search target scenario pattern, and extract one or more candidate scenario patterns therefrom that include the same scenario pattern as the search target scenario pattern and additionally include one more behavior pattern.

The selection module (106) selects one final candidate scenario pattern among the candidate scenario patterns by considering the occurrence frequency of each candidate scenario pattern searched by the search module (104).

In one embodiment, the selection module (106) may select N candidate scenario patterns by considering the occurrence frequency of one or more candidate scenario patterns, and may select a final candidate scenario pattern by filtering the selected N candidate scenario patterns using preset lower threshold values and upper threshold values. At this time, the N value may be appropriately set by considering the average occurrence frequency of the scenario patterns, etc.

If there is a candidate scenario pattern exceeding the upper threshold value among the N candidate scenario patterns, the selection module (106) may select the candidate scenario pattern with the highest occurrence frequency among the candidate scenario patterns exceeding the upper threshold value as the final sign scenario pattern. Conversely, if the number of candidate scenario patterns remaining as a result of the filtering is 2 or more, the selection module (106) may set the candidate scenario pattern selected by the user among the remaining candidate scenario patterns as the final sign scenario pattern.

The scenario auto-completion module (108) extracts one or more candidate scenarios including the selected candidate scenario pattern from the scenario repository (110), and selects one of the candidate scenarios as an auto-completion reference scenario by considering the execution history of each candidate scenario. The number of executions and the number of successful executions (or success rates) for each scenario stored in the scenario repository (110) are stored and managed in the execution history repository (114). The scenario auto-completion module (108) can select an auto-completion reference scenario by considering the number of executions and the success rate for a preset period of time of each candidate scenario stored in the execution history repository (114). Thereafter, the scenario auto-completion module (108) can generate object information and property information of a new additional step of a new scenario being written by using object information and property information for one or more steps included in the auto-completion reference scenario.

FIG. 2 is a flow chart for explaining in detail the operation of the scenario pattern extraction module (102) of the robotic processing automation scenario automatic completion system (100) according to one embodiment. In the illustrated flow chart, the method or process is described by dividing it into a plurality of steps, but at least some of the steps may be performed in a changed order, combined with other steps and performed together, omitted, divided into detailed steps and performed, or one or more steps not illustrated may be added and performed.

In step 202, when a pre-written automation scenario is registered, the scenario pattern extraction module (102) stores the registered scenario in the scenario storage (110).

In step 204, the scenario pattern extraction module (102) converts each step of the scenario into a behavior pattern.

For example, let's assume the following scenario is registered:

Example) Run browser > Go to email site > Enter ID > Enter password > Click login button > Click inbox

If we convert this into a behavior pattern, it can be structured as follows:

Behavior pattern: A01 > B02 > C03 > C04 > D05 > C06

In step 206, the scenario pattern extraction module (102) generates all scenario patterns that constitute a scenario from the input scenario, and assigns an identifier (ID) to each scenario pattern. At this time, a limit may be appropriately placed on the minimum scenario pattern length. For example, if the minimum scenario pattern length (M) is defined as 3, the following 10 scenario patterns can be generated from the aforementioned scenario.

Scenario Pattern Length 3: A01B02C03, B02C03C04, C03C04D05, C04D05C06

Scenario Pattern Length 4: A01B02C03C04, B02C03C04D05, C03C04D05C06

Scenario Pattern Length 5: A01B02C03C04D05, B02C03C04D05C06

Scenario Pattern Length 6: A01B02C03C04D05C06

In step 208, the scenario pattern extraction module (102) registers and stores all identified scenario patterns in the scenario pattern storage (112). At this time, the scenario pattern information stored in the scenario pattern storage (112) may include an identifier (ID) of the scenario pattern, a previous scenario pattern (excluding the last behavior pattern in the stored scenario pattern), an identifier (ID) of a scenario corresponding to the pattern, and a storage location of the scenario in the scenario storage (110). For example, a scenario pattern composed of A01B02C03C04 may be stored in the scenario pattern storage (112) as follows.

Example) Scenario Pattern ID, Scenario Pattern (A01B02C03C04), Previous Pattern (A01B02C03), Scenario ID (1), Location (1)

If a scenario pattern identical to the scenario pattern to be saved is already saved in the scenario pattern storage (112), the scenario pattern extraction module (102) can add the identifier (scenario ID (2)) and storage location (location (2)) of the scenario corresponding to the scenario pattern to be saved to the entry of the identical scenario pattern as follows.

Example) Scenario Pattern ID, Scenario Pattern (A01B02C03C04), Previous Pattern (A01B02C03), Scenario ID (1), Location (1), Scenario ID (2), Location (2)

FIG. 3 is a flowchart for explaining in detail the operation of the search module (104) of the robotic processing automation scenario auto-completion system (100) according to one embodiment. As described above, the search module (104) generates a search target scenario pattern from a new scenario being written, and searches for one or more candidate scenario patterns corresponding to the search target scenario pattern from the scenario pattern storage (112).

In step 302, the search module (104) generates all scenario patterns that include the most recently added step (activity) in the new scenario being written and have a length greater than or equal to M. In this case, M may be set equal to the minimum scenario pattern length described above.

For example, let's say you're writing a new scenario like this:

Launch browser > Go to email site > Enter ID > Enter password

Also, let us assume that the behavior patterns corresponding to each step are as follows.

Launch browser: A01

Go to Email Site: B02

Enter ID: C03

Enter password: C04

The last step added in the above scenario is “Enter Password”. Therefore, the search module (104) generates all scenario patterns that include “Enter Password” and whose pattern length is longer than or equal to the minimum value (assuming M = 3).

Generated scenario patterns: A01B02C03C04, B02C03C04

In step 304, the search module (104) searches for one or more candidate scenario patterns corresponding to the search target scenario pattern from the scenario pattern repository (112).

For example, assume that the following scenario pattern is registered in the scenario pattern repository (112).

Scenario Pattern 1 (A01B02C03C04D05)

- Run browser > Go to email site > Enter ID > Enter password > Click login button

Scenario Pattern 2 (A01B02C03C04C04)

- Run browser > Go to email site > Enter ID > Enter password > Enter key

The search module (104) sequentially searches the scenario pattern storage (112) in order of the length of the search target scenario pattern, considering the length of the search target scenario pattern. If there is no scenario pattern corresponding to the longest scenario pattern, the search module (104) repeats the search using a search target scenario pattern having a shorter length.

In the above example, the search module (104) can confirm through search that a scenario pattern corresponding to A01B02C03C04 exists in the scenario pattern storage (112).

In step 306, the search module (104) extracts one or more candidate scenario patterns from the scenario pattern repository (112) that include the same scenario pattern as the search target scenario pattern and additionally include one more behavior pattern. This can be performed by utilizing previous patterns stored in each scenario pattern repository (112).

In the above example, the search module (104) can search for a behavior pattern that includes the A01B02C03C04 pattern and is one size larger to obtain the following candidate scenario patterns.

Candidate Scenario Patterns: A01B02C03C04D05, A01B02C03C04C04

The search results above show that D05 and C04 are added to the search target scenario pattern A01B02C03C04.

FIG. 4 is a flowchart for explaining in detail the operation of the selection module (106) of the robotic processing automation scenario automatic completion system (100) according to one embodiment. As described above, the selection module (106) can select one final candidate scenario pattern among the candidate scenario patterns by considering the occurrence frequency of each candidate scenario pattern searched by the search module (104).

In step 402, the selection module (106) selects N candidates in order of high occurrence frequency from among the candidate scenario patterns received from the search module (104). At this time, the occurrence frequency can be calculated from the number of corresponding scenario IDs of each entry stored in the scenario pattern storage (112). At this time, the N value can be appropriately set in consideration of the average occurrence frequency of the scenario pattern, etc.

In step 404, the selection module (106) filters the selected N candidate scenario patterns using a preset lower bound and upper bound. At this time, the lower bound and upper bound can be appropriately set in consideration of the average occurrence frequency of the scenario, etc.

First, the selection module (106) discards candidates among the N candidate scenarios whose occurrence frequency is lower than a lower threshold value.

If there is a candidate scenario pattern exceeding the upper threshold value among the N candidate scenario patterns, the selection module (106) can select the candidate scenario pattern with the highest occurrence frequency among the candidate scenario patterns exceeding the upper threshold value as the final sign scenario pattern. For example, assume that the occurrence frequency of each candidate scenario is as follows.

A01B02C03C04D05: Occurred 90 times

A01B02C03C04C04: Occurred 10 times

If the above upper threshold value is assumed to be 90%, the selection module (106) can single-select the A01B02C03C04D05 pattern.

In step 406, the selection module (106) determines the number of remaining candidate scenario patterns as a result of performing steps 402 and 404. If there are no remaining candidate scenario patterns, the process ends. On the other hand, if there is only one remaining candidate scenario pattern, the selection module (106) selects the remaining candidate scenario pattern as the final candidate scenario pattern. If there are two or more remaining candidate scenario patterns, the selection module (106) can set a candidate scenario pattern selected by the user from among the remaining candidate scenario patterns as the final sign scenario pattern.

For example, if A01B02C03C04D05, A01B02C03C04C04 remain as the final candidates, the selection module (106) may present D05 ("click the login button"), C04 ("press the Enter key") as the next possible action pattern candidates to the user and receive selection information from the user.

FIG. 5 is a flowchart for explaining in detail the operation of the scenario auto-completion module (108) of the robotic processing automation scenario auto-completion system (100) according to one embodiment.

In step 502, the scenario auto-completion module (108) retrieves one or more candidate scenarios containing the selected final candidate scenario pattern from the scenario repository (110).

In step 504, the scenario auto-completion module (108) selects one of the candidate scenarios as an auto-completion reference scenario by considering the execution history of the searched candidate scenarios. As described above, the number of executions and the number of successful executions (or success rates) for each scenario stored in the scenario storage (110) are stored and managed in the execution history storage (114). Therefore, the scenario auto-completion module (108) can select an auto-completion reference scenario by considering the number of executions and the success rate for a preset period of time of each candidate scenario stored in the execution history storage (114).

Specifically, the scenario auto-completion module (108) checks the execution history of the scenario and selects the candidate scenario with the highest success rate as the auto-completion reference scenario. In one embodiment, the scenario auto-completion module (108) may consider the success rate for the entire period or a preset period (e.g., the last 30 days). In addition, the scenario auto-completion module (108) may exclude scenarios whose execution counts do not reach a threshold from the candidates.

In step 506, the scenario auto-completion module (108) generates object information and attribute information of a new additional step of the new scenario being written using object information and attribute information for one or more steps included in the selected auto-completion reference scenario.

For example, when the A01B02C03C04D05 scenario pattern is selected as an auto-complete reference scenario, the scenario auto-complete module (108) can automatically complete the "click confirmation button" step of the newly created scenario by copying the detailed attribute information of the behavior pattern D05 to be added.

FIG. 6 is a flowchart for explaining a method (600) for automatically completing a robotic processing automation scenario according to one embodiment. The illustrated method may be performed in a computing device having one or more processors and a memory storing one or more programs executed by the one or more processors, for example, the robotic processing automation scenario automatically completing system (100) described above. In the illustrated flowchart, the method or process is described by dividing it into a plurality of steps, but at least some of the steps may be performed in a changed order, combined with other steps and performed together, omitted, divided into detailed steps and performed, or one or more steps not illustrated may be added and performed.

In step 602, the scenario pattern extraction module (102) of the robotic processing automation scenario auto-completion system (100) generates one or more scenario patterns from one or more pre-written scenarios stored in the scenario repository (110) and stores them in the scenario pattern repository (112). In one embodiment, the scenario pattern extraction module (102) of the robotic processing automation scenario auto-completion system (100) may store, together with the scenario pattern, an identifier (ID) of each scenario pattern, a previous scenario pattern, an identifier (ID) of a corresponding scenario, and a storage location in the scenario pattern repository (112). If a scenario pattern identical to a storage target scenario pattern is already stored in the scenario pattern repository (112), the scenario pattern extraction module (102) may add the identifier and storage location of the scenario corresponding to the storage target scenario pattern to the entry of the same scenario pattern.

In step 604, the search module (104) of the robotic processing automation scenario auto-completion system (100) generates a search target scenario pattern from a new scenario being written, and searches for one or more candidate scenario patterns corresponding to the search target scenario pattern from the scenario pattern storage (112).

In step 606, the selection module (106) of the robotic processing automation scenario auto-completion system (100) selects one final candidate scenario pattern among the candidate scenario patterns by considering the occurrence frequency of each candidate scenario pattern searched by the search module (104).

In step 608, the scenario auto-completion module (108) of the robotic processing automation scenario auto-completion system (100) extracts one or more candidate scenarios including the selected candidate scenario pattern from the scenario repository (110), and selects one of the candidate scenarios as an auto-completion reference scenario by considering the execution history of each candidate scenario. Thereafter, the scenario auto-completion module (108) can generate object information and attribute information of a new additional step of a new scenario being written by using object information and attribute information for one or more steps included in the auto-completion reference scenario.

FIG. 7 is a block diagram illustrating a computing environment including a computing device suitable for use in exemplary embodiments. In the illustrated embodiment, each of the components may have different functions and capabilities other than those described below, and may include additional components other than those described below.

The illustrated computing environment (10) includes a computing device (12). In one embodiment, the computing device (12) may be the aforementioned RPA scenario automatic completion system (100).

A computing device (12) includes at least one processor (14), a computer-readable storage medium (16), and a communication bus (18). The processor (14) may cause the computing device (12) to operate in accordance with the exemplary embodiments described above. For example, the processor (14) may execute one or more programs stored in the computer-readable storage medium (16). The one or more programs may include one or more computer-executable instructions, which, when executed by the processor (14), may cause the computing device (12) to perform operations in accordance with the exemplary embodiments.

A computer-readable storage medium (16) is configured to store computer-executable instructions or program code, program data, and/or other suitable forms of information. A program (20) stored in the computer-readable storage medium (16) includes a set of instructions executable by the processor (14). In one embodiment, the computer-readable storage medium (16) may be a memory (volatile memory such as random access memory, non-volatile memory, or a suitable combination thereof), one or more magnetic disk storage devices, optical disk storage devices, flash memory devices, any other form of storage medium that can be accessed by the computing device (12) and capable of storing desired information, or a suitable combination thereof.

A communication bus (18) interconnects various other components of the computing device (12), including the processor (14) and computer-readable storage media (16).

The computing device (12) may also include one or more input/output interfaces (22) that provide interfaces for one or more input/output devices (24) and one or more network communication interfaces (26). The input/output interfaces (22) and the network communication interfaces (26) are coupled to the communication bus (18). The input/output devices (24) may be coupled to other components of the computing device (12) via the input/output interfaces (22). Exemplary input/output devices (24) may include input devices such as a pointing device (such as a mouse or trackpad), a keyboard, a touch input device (such as a touchpad or a touchscreen), a voice or sound input device, various types of sensor devices and/or photographing devices, and/or output devices such as a display device, a printer, speakers, and/or a network card. The exemplary input/output devices (24) may be included within the computing device (12) as a component that constitutes the computing device (12), or may be coupled to the computing device (12) as a separate device distinct from the computing device (12).

Although the present invention has been described in detail above through representative examples, those skilled in the art will understand that various modifications can be made to the above-described examples without departing from the scope of the present invention. Therefore, the scope of the rights of the present invention should not be limited to the described examples, but should be determined not only by the claims described below but also by equivalents of the claims.

100: RPA Scenario Auto-Completion System
102: Scenario Pattern Extraction Module
104: Search Module
106: Selection Module
108: Scenario Auto-Completion Module
110: Scenario Repository
112: Scenario Pattern Repository
114: Execution history storage
10: Computing Environment
12: Computing Devices
14: Processor
16: Computer readable storage medium
18: Communication bus
20: Program
22: Input/output interface
24: Input/output devices
26: Network Communication Interface

Claims (22)

A search module that generates a search target scenario pattern from a new scenario being written and searches for one or more candidate scenario patterns corresponding to the search target scenario pattern from a scenario pattern repository;
A selection module for selecting one final candidate scenario pattern among the candidate scenario patterns by considering the occurrence frequency of each of the candidate scenario patterns searched; and
A robotic processing automation scenario auto-completion system comprising a scenario auto-completion module for extracting one or more candidate scenarios containing the above-described selected candidate scenario patterns from a scenario repository and selecting one of the candidate scenarios as an auto-completion reference scenario by considering the execution history of each of the candidate scenarios. In claim 1,
A robotic processing automation scenario auto-completion system further comprising a scenario pattern extraction module that generates one or more scenario patterns from one or more pre-written scenarios stored in the scenario repository and stores the generated scenario patterns in the scenario pattern repository. In claim 2,
The above scenario pattern extraction module,
A robotic processing automation scenario auto-completion system that stores an identifier (ID) for each of the above scenario patterns, a previous scenario pattern, an identifier (ID) of a corresponding scenario, and a storage location in the above scenario pattern storage. In claim 3,
The above scenario pattern extraction module,
If a scenario pattern identical to the scenario pattern to be saved is already saved in the scenario pattern repository,
A robotic processing automation scenario auto-completion system that adds an identifier and a storage location of a scenario corresponding to the above storage target scenario pattern to an entry of the same scenario pattern. In claim 1,
The above search module,
A robotic processing automation scenario auto-completion system that includes the last added step among the above new scenarios and generates one or more search target scenario patterns whose length is greater than a set value. In claim 5,
The above search module,
By sequentially searching the scenario pattern repository considering the length of one or more search target scenario patterns,
A robotic processing automation scenario auto-completion system that extracts one or more candidate scenario patterns that include the same scenario pattern as the above search target scenario pattern and additionally includes one more behavior pattern. In claim 1,
The above selection module,
Select N candidate scenario patterns by considering the occurrence frequency of one or more of the above candidate scenario patterns,
A robotic processing automation scenario auto-completion system that selects the final candidate scenario pattern by filtering the N selected candidate scenario patterns using preset lower and upper threshold values. In claim 7,
The above selection module,
A robotic processing automation scenario automatic completion system, wherein, if there is a candidate scenario pattern exceeding the upper threshold value among the above N candidate scenario patterns, the candidate scenario pattern with the highest occurrence frequency among the candidate scenario patterns exceeding the upper threshold value is selected as the final sign scenario pattern. In claim 7,
The above selection module,
A robotic processing automation scenario automatic completion system, which sets a candidate scenario pattern selected by a user from among the remaining candidate scenario patterns as the final sign scenario pattern when the number of remaining candidate scenario patterns is two or more as a result of the filtering above. In claim 1,
The above auto-completion module,
A robotic processing automation scenario auto-completion system that selects the auto-completion reference scenario by considering the number of executions and success rates of each of the one or more candidate scenarios during a preset period of time. In claim 1,
The above auto-completion module,
A robotic processing automation scenario auto-completion system that generates object information and attribute information of a new additional step of the new scenario by using one or more step object information and attribute information included in the above auto-completion reference scenario. A step of generating a search target scenario pattern from a new scenario being written, and searching for one or more candidate scenario patterns corresponding to the search target scenario pattern from a scenario pattern repository;
A step of selecting one final candidate scenario pattern among the candidate scenario patterns by considering the occurrence frequency of each of the candidate scenario patterns searched; and
A method for robotic processing automation scenario auto-completion, comprising a scenario auto-completion step of extracting one or more candidate scenarios including the selected candidate scenario pattern from a scenario repository, and selecting one of the candidate scenarios as an auto-completion reference scenario by considering the execution history of each candidate scenario. In claim 12,
A method for automatically completing a robotic processing automation scenario, further comprising a scenario pattern extraction step of generating one or more scenario patterns from one or more pre-written scenarios stored in the scenario repository and storing the generated scenario patterns in the scenario pattern repository. In claim 13,
The above scenario pattern extraction step is:
A method for automatically completing a robotic processing automation scenario, which stores an identifier (ID) for each of the above scenario patterns, a previous scenario pattern, an identifier (ID) of a corresponding scenario, and a storage location in the above scenario pattern storage. In claim 13,
The above scenario pattern extraction step is,
If a scenario pattern identical to the scenario pattern to be saved is already saved in the scenario pattern repository,
A method for automatically completing a robotic processing automation scenario, which adds an identifier and a storage location of a scenario corresponding to the above storage target scenario pattern to an entry of the same scenario pattern. In claim 12,
The above search steps are:
A method for automatically completing a robotic processing automation scenario, which includes the last added step among the above new scenarios and generates one or more search target scenario patterns having a length greater than a set value. In claim 16,
The above search steps are:
By sequentially searching the scenario pattern repository considering the length of one or more search target scenario patterns,
A method for automatically completing a robotic processing automation scenario, wherein the method extracts one or more candidate scenario patterns that include the same scenario pattern as the above search target scenario pattern and additionally include one more behavior pattern. In claim 12,
The above selection steps are:
Select N candidate scenario patterns by considering the occurrence frequency of one or more of the above candidate scenario patterns,
A method for automatically completing a robotic processing automation scenario, wherein the final candidate scenario pattern is selected by filtering the N selected candidate scenario patterns using preset lower and upper threshold values. In claim 18,
The above selection steps are:
A method for automatically completing a robotic processing automation scenario, wherein, if there is a candidate scenario pattern exceeding the upper threshold value among the above N candidate scenario patterns, the candidate scenario pattern with the highest occurrence frequency among the candidate scenario patterns exceeding the upper threshold value is selected as the final sign scenario pattern. In claim 18,
The above selection steps are:
A method for automatically completing a robotic processing automation scenario, wherein, when the number of remaining candidate scenario patterns as a result of the filtering is two or more, a candidate scenario pattern selected by a user from among the remaining candidate scenario patterns is set as the final sign scenario pattern. In claim 12,
The above auto-completion step is,
A method for automatically completing a robotic processing automation scenario, wherein the auto-completion reference scenario is selected by considering the number of executions and success rates of each of the one or more candidate scenarios during a preset period of time. In claim 12,
The above auto-completion step is,
A method for automatically completing a robotic processing automation scenario, which creates object information and attribute information of a new additional step of the new scenario by using one or more step object information and attribute information included in the above automatic completion reference scenario.