This paper presents Robidium: a tool that discovers automatable routine tasks from User Interactions (UI) logs and generates Robotic Process Automation (RPA) scripts to automate such routines. Unlike record-and-replay features provided by commercial RPA tools, Robidium may take as input an UI log that is not speci cally recorded to capture a pre-identi ed task. Instead, the log may contain mixtures of automatable and non-automatable routines, interspersed with events that are not part of any routine as well as redundant or irrelevant events.
Robidium is a Software as a Service (SaaS) tool that implements the Robotic
Process Mining pipeline proposed in [
UI log
Preprocessor
Simplified Segmenter tasks traces Simplifier
Routines Extractor Candidate routines Evaluator
Automatable
routines Automatable Routines Discoverer
Compiler
Automatable Routine Specification
Synthesizer
RPA script
Robidium's architecture consists of six components (Fig. 1) as detailed below.
Segmenter. Robidium takes as input a UI log in which each row includes a
timestamp, one or more attributes that (combined) denote an action (e.g. \Edit"
+ Cell ID in Excel), and other attributes capturing the action's payload (e.g.
value of the Excel cell after the action). UI logs that ful ll these requirements
can be produced using the Action Logger tool [
Simpli er. A UI log may contain redundant behavior that does not a ect the outcome of the recorded task. For example, the user could ll in the eld with the wrong value by mistake and then correct it. This can lead to incorrect identication of routines. The Simpli er component eliminates such redundant subsequences of actions. It consists of three sub-modules responsible for di erent types of redundancies related to read, write, and navigation actions. Each sub-module is implemented via a set of regular expression nd-and-replace rules. Routines extractor. Simpli er returns a list of task traces without redundant actions. These task traces are then provided as input to Routines extractor, which identi es routine candidates for automation. Each user interaction in the log is converted into its symbolic representation by combining type and context attributes that capture where the action was performed (e.g., application, URL, eld name, and button label). The user selects the context attributes. In order to nd repeats, user interactions across the traces must have identical symbolic representations. Therefore, we do not use the attributes that contain the data used during the execution of an action (e.g., the value of a eld, copied content, etc.). The tool applies sequential pattern mining to identify frequently repetitive execution patterns, given sequences comprised of symbolic representations of user interactions. Such patterns are then considered to be candidates for automation. The routine candidates can be selected accordingly to di erent criteria such as length, frequency, coverage, or cohesion.
Evaluator. Each candidate rutine then must be assessed for its amenability to
automation by Evaluator. For each candidate, Evaluator extracts its instances
from the log and veri es whether all the actions are automatable. In particular,
an action can be automated if its value can be computed from the outcomes of
the previous actions using a constant or deterministic function. In this regard,
Evaluator discovers data transformations between the actions in the instances of
the routine candidate. It discovers the syntactic transformations as described in
[
Compiler. This automatable routine speci cation is then given as an input to Compiler that generates an RPA bot, by mapping each action of the routine into the corresponding executable command of the selected RPA tool. At the moment, Robidium creates RPA bots for the UIPath Enterprise RPA Platform.8 These scripts can then be executed via the command line or the interface of UIPath. Compiler also identi es the variables in the script (e.g., row in the spreadsheet) that can be then used as the input parameters during its execution. 8 www.uipath.com
A typical routine that can be automated using Robidium is transferring data from one system to another, for example from a spreadsheet to a form of a web-based information system. Fig. 2a shows an extract of a spreadsheet with students' contact details. Each entry in the spreadsheet is then used to create the corresponding student record using the web form shown in Fig. 2b. Such routine tasks may involve data transformations for converting the input data into the desired format (e.g., split full name into rst and last name). Robidium identi es such transformations and generates corresponding RPA scripts that implement the tasks. Fig. 3 shows the generated script in the UIPath RPA platform.
(a) (b) Fig. 2: An extract of a spreadsheet (a), and a new record web form.
The RPA bot shown in Fig. 3 automatically transfer all the entries in the
spreadsheet in Fig. 2a into the system with the web form interface from Fig. 2b.
We have validated the tool in cooperation with a team responsible for
admission and scholarship allocation processes within a university. The team used the
Action Logger tool [
This paper presented Robidium, a tool to automatically discover and implement routine tasks recorded in UI logs. The tool aims to reduce the amount of time spent on the identi cation and analysis of the candidates for automation and allows focusing on their implementation. The tool generates executable bots that can be used as a starting point for further re nement by RPA developers.
In future work, we plan to address some of the limitations Robidium. First, the current version of Robidum can only generate scripts of fully automatable routines. It does not support steps that require intermediate user input. Second, the tool automates only one variant of routine at a time. If a routine has multiple variants, multiple bots are generated. We plan to add functionality to combine multiple variants of a routine into a single executable speci cation that can be compiled into a single bot. Finally, we plan to improve the e ciency of the various algorithms implemented in the tool to be able to support larger UI logs. Acknowledgments. This research is supported by the Australian Research Council (DP180102839) and the European Research Council (project PIX).